2428 lines
80 KiB
C#
2428 lines
80 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using VEPROMS.CSLA.Library;
|
|
using System.Text.RegularExpressions;
|
|
using Volian.Base.Library;
|
|
|
|
namespace Volian.Controls.Library
|
|
{
|
|
#region Enums
|
|
public enum ChildRelation : int
|
|
{
|
|
None = 0,
|
|
After = 1,
|
|
Before = 2,
|
|
RNO = 3
|
|
}
|
|
public enum ExpandingStatus : int
|
|
{
|
|
No = 0,
|
|
Expanding = 1,
|
|
Colapsing = 2,
|
|
Hiding = 4,
|
|
Showing = 8,
|
|
Done = 16
|
|
}
|
|
public enum E_ChangeBarPosition : int
|
|
{
|
|
Left = 0,
|
|
Right = 1
|
|
}
|
|
#endregion
|
|
public partial class StepItem : UserControl
|
|
{
|
|
//private static int _StepItemUnique = 0;
|
|
//private static int StepItemUnique
|
|
//{
|
|
// get
|
|
// {
|
|
// if (_StepItemUnique == 3)
|
|
// Console.WriteLine("here");
|
|
// return ++_StepItemUnique;
|
|
// }
|
|
//}
|
|
//private int _MyStepItemUnique = StepItemUnique;
|
|
|
|
//public int MyStepItemUnique
|
|
//{
|
|
// get {return _MyStepItemUnique; }
|
|
//}
|
|
|
|
#region Private Fields
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
private StepPanel _MyStepPanel;
|
|
|
|
public StepPanel MyStepPanel
|
|
{
|
|
get { return _MyStepPanel; }
|
|
set { _MyStepPanel = value; }
|
|
}
|
|
private ChildRelation _MyChildRelation;
|
|
private StepItem _MyParentStepItem = null;
|
|
private StepItem _MySectionStepItem;
|
|
private StepItem _MyPreviousStepItem = null;
|
|
private StepItem _MyNextStepItem = null;
|
|
private bool _ChildrenLoaded = false;
|
|
public bool HasChildren
|
|
{
|
|
get {return _MyBeforeStepItems != null || _MyRNOStepItems != null || _MyAfterStepItems != null;}
|
|
}
|
|
private List<StepItem> _MyBeforeStepItems;
|
|
|
|
public List<StepItem> MyBeforeStepItems
|
|
{
|
|
get { return _MyBeforeStepItems; }
|
|
set { _MyBeforeStepItems = value; }
|
|
}
|
|
private List<StepItem> _MyAfterStepItems;
|
|
|
|
public List<StepItem> MyAfterStepItems
|
|
{
|
|
get { return _MyAfterStepItems; }
|
|
set { _MyAfterStepItems = value; }
|
|
}
|
|
private List<StepItem> _MyRNOStepItems;
|
|
|
|
public List<StepItem> MyRNOStepItems
|
|
{
|
|
get { return _MyRNOStepItems; }
|
|
set { _MyRNOStepItems = value; }
|
|
}
|
|
public Label MyLabel
|
|
{ get { return lblTab; } }
|
|
private StepSectionLayoutData _MyStepSectionLayoutData;
|
|
public StepSectionLayoutData MyStepSectionLayoutData
|
|
{
|
|
get { return _MyStepSectionLayoutData; }
|
|
set { _MyStepSectionLayoutData = value; }
|
|
}
|
|
private bool _Loading = true;
|
|
private StepData _MyStepData;
|
|
public StepData MyStepData
|
|
{
|
|
get { return _MyStepData; }
|
|
set { _MyStepData = value; }
|
|
}
|
|
private ItemInfo _MyItemInfo;
|
|
private static int _WidthAdjust = 3;
|
|
|
|
private int _ExpandPrefix = 0;
|
|
private int _ExpandSuffix = 0;
|
|
private ExpandingStatus _MyExpandingStatus = ExpandingStatus.No;
|
|
private bool _Colapsing = false;
|
|
private bool _Moving = false;
|
|
private int _RNOLevel = 0;
|
|
private int _SeqLevel = 0;
|
|
private int _Type;
|
|
private bool _Circle = false;
|
|
private bool _CheckOff = false;
|
|
private bool _ChangeBar = false;
|
|
|
|
#endregion
|
|
#region Properties
|
|
/// <summary>
|
|
/// This returns the section or procedure for the current item.
|
|
/// If the item is a step or section, it returns the section
|
|
/// If it is a procedure, it returns the procedure
|
|
/// </summary>
|
|
public StepItem MySectionStepItem
|
|
{
|
|
get
|
|
{
|
|
if (_MySectionStepItem == null)
|
|
{
|
|
if (MyItemInfo.IsSection || MyItemInfo.IsProcedure) _MySectionStepItem = this;
|
|
else _MySectionStepItem = _MyParentStepItem.MySectionStepItem;
|
|
}
|
|
return _MySectionStepItem;
|
|
}
|
|
set { _MySectionStepItem = value; }
|
|
}
|
|
/// <summary>
|
|
/// Gets or Sets ItemInfo
|
|
/// </summary>
|
|
public ItemInfo MyItemInfo
|
|
{
|
|
get { return _MyItemInfo; }
|
|
set
|
|
{
|
|
_MyItemInfo = value;
|
|
if (VlnSettings.StepTypeToolType)SetToolTip(_MyItemInfo.ToolTip);
|
|
ChangeBar = _MyItemInfo.HasChangeBar;
|
|
value.MyContent.Changed += new ContentInfoEvent(MyContent_Changed);
|
|
value.OrdinalChanged += new ItemInfoEvent(value_OrdinalChanged);
|
|
}
|
|
}
|
|
void value_OrdinalChanged(object sender)
|
|
{
|
|
TabFormat = null; // Reset Tab
|
|
}
|
|
private 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 StepItem ActiveParent
|
|
{
|
|
get { return _MyParentStepItem!=null ? _MyParentStepItem : _MyPreviousStepItem.ActiveParent; }
|
|
}
|
|
void MyContent_Changed(object sender)
|
|
{
|
|
// Update the text to reflect the content change
|
|
MyStepRTB.MyItemInfo.RefreshItemAnnotations();
|
|
MyStepRTB.MyItemInfo=MyStepRTB.MyItemInfo; // Reset Text
|
|
SetExpandAndExpander(MyItemInfo);
|
|
// TODO: Need code to update tabs ? not sure what this is - maybe for
|
|
// transitions?
|
|
}
|
|
/// <summary>
|
|
/// Used to connect the RichTextBox with the menus and toolbars
|
|
/// </summary>
|
|
public StepRTB MyStepRTB
|
|
{
|
|
get { return _MyStepRTB; }
|
|
}
|
|
/// <summary>
|
|
/// Return the Parent StepItem
|
|
/// </summary>
|
|
private StepItem UpOneStepItem
|
|
{
|
|
get
|
|
{
|
|
StepItem tmp = this;
|
|
while (tmp != null && tmp.MyParentStepItem == null) tmp = tmp.MyPreviousStepItem;
|
|
if (tmp != null) return tmp.MyParentStepItem;
|
|
return null;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Sets the parent and postions the item with respect to the parent
|
|
/// </summary>
|
|
public StepItem MyParentStepItem
|
|
{
|
|
get { return _MyParentStepItem; }
|
|
set
|
|
{
|
|
LastMethodsPush("set_MyParentStepItem");
|
|
_MyParentStepItem = value;
|
|
if (_MyParentStepItem != null)
|
|
{
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.None: // Same as after
|
|
case ChildRelation.After: // Procedures, sections, substeps, and tables/figures
|
|
// The size depends upon the parent type
|
|
int iType = (int)_MyParentStepItem._Type;
|
|
|
|
switch (iType / 10000)
|
|
{
|
|
case 0: // Procedure
|
|
ItemLocation = new Point(_MyParentStepItem.ItemLocation.X + 20, _MyParentStepItem.Bottom);
|
|
ItemWidth = _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.ColT) + _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.WidT);
|
|
break;
|
|
case 1: // Section
|
|
if(this == TopMostStepItem)
|
|
ItemLocation = new Point(_MyParentStepItem.ItemLocation.X + 20, _MyParentStepItem.Bottom);
|
|
else
|
|
TopMostStepItem.ItemLocation = new Point(TopMostStepItem.ItemLocation.X, _MyParentStepItem.Bottom);
|
|
int borderWidth = _MyStepRTB.Width - _MyStepRTB.ClientRectangle.Width;
|
|
//TextWidth = _WidthAdjust + borderWidth + _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.WidSTableEdit, Convert.ToInt32(_MyStepSectionLayoutData.PMode) - 1);
|
|
TextWidth = _WidthAdjust + borderWidth + _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.WidSTableEdit, MyItemInfo.ColumnMode);
|
|
break;
|
|
case 2: // Step
|
|
// if Table then determine width and location based upon it's parent's location
|
|
if (_MyStepData.Type == "Table" || _MyStepData.ParentType == "Table")
|
|
{
|
|
_MyStepRTB.Font = _MyStepData.Font.WindowsFont;
|
|
ItemWidth = (int)TableWidth(_MyStepRTB.Font, _MyItemInfo.MyContent.Text, true);
|
|
ItemLocation = new Point(50, _MyParentStepItem.Bottom);
|
|
ItemLocation = TableLocation(_MyParentStepItem, _MyStepSectionLayoutData, ItemWidth);
|
|
}
|
|
else
|
|
{
|
|
ItemLocation = new Point(_MyParentStepItem.TextLeft, _MyParentStepItem.Bottom);
|
|
ItemWidth = _MyParentStepItem.TextWidth;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case ChildRelation.RNO:
|
|
// this is set so that TextWidth command below will be correct. TextWidth uses
|
|
// the tab start & tab width to calculate the overall width.
|
|
TabFormat = ""; // this is set so that TextWidth command below will be correct
|
|
_IgnoreResize = true;
|
|
TextWidth = _MyParentStepItem.TextWidth;
|
|
_IgnoreResize = false;
|
|
if (RNOLevel <= _MyItemInfo.ColumnMode)
|
|
{
|
|
//int colR = _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.ColRTable, Convert.ToInt32(_MyStepSectionLayoutData.PMode) - 1);
|
|
int colR = _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.ColRTable, MyItemInfo.ColumnMode);
|
|
if (colR - _MyParentStepItem.Width < 0) colR = _MyParentStepItem.Width + 0;
|
|
_MyStepPanel.ItemMoving++;
|
|
//Left = _MyParentStepItem.ItemLeft + RNOLevel * colR;
|
|
//ItemLocation = new Point(_MyParentStepItem.ItemLeft + RNOLevel * colR, _MyParentStepItem.Top);
|
|
LastMethodsPush(string.Format("set_MyParentStepItem RNO Right {0}", MyID));
|
|
ItemLocation = new Point(_MyParentStepItem.ItemLeft + RNOLevel * colR, _MyParentStepItem.Top);
|
|
int top = _MyParentStepItem.FindTop(_MyParentStepItem.Top);
|
|
if (top != _MyParentStepItem.Top)
|
|
{
|
|
_MyParentStepItem.LastMethodsPush(string.Format("set_MyParentStepItem RNO Right {0}", MyID));
|
|
_MyParentStepItem.Top = top;
|
|
_MyParentStepItem.LastMethodsPop();
|
|
Top = top;
|
|
}
|
|
LastMethodsPop();
|
|
_MyStepPanel.ItemMoving--;
|
|
}
|
|
else
|
|
{
|
|
_MyStepPanel.ItemMoving++;
|
|
LastMethodsPush(string.Format("set_MyParentStepItem RNO Below {0} {1} {2}", MyID, _MyParentStepItem.BottomMostStepItem.MyID, _MyParentStepItem.BottomMostStepItem.Bottom));
|
|
TextLocation = new Point(_MyParentStepItem.TextLeft, _MyParentStepItem.BottomMostStepItem.Bottom);
|
|
LastMethodsPop();
|
|
//TextLocation = new Point(_MyParentStepItem.TextLeft, FindTop(_MyParentStepItem.Top));
|
|
_MyStepPanel.ItemMoving--;
|
|
}
|
|
// Same size as the Parent
|
|
break;
|
|
case ChildRelation.Before: // Cautions and Notes
|
|
//if(_WatchThis > 0 && MyID > 2111)
|
|
// Console.WriteLine("Setting MyParent: \r\n\tParent {0},{1} \r\n\tTopMostItem {2},{3} \r\n\tNext {4}, {5}", _MyParentStepItem.MyID, _MyParentStepItem
|
|
// ,_MyParentStepItem.TopMostStepItem.MyID,_MyParentStepItem.TopMostStepItem
|
|
// , _MyNextStepItem == null ? 0 : _MyNextStepItem.MyID, _MyNextStepItem == null ? "None" : _MyNextStepItem.ToString());
|
|
|
|
//Location = new Point(_MyParentStepItem.Left + 20, max(_MyParentStepItem.Top, (_MyNextStepItem == null ? 0 : _MyNextStepItem.Top )) ?? 0);
|
|
_IgnoreResize = true;
|
|
Width = _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.WidT);
|
|
_IgnoreResize = false;
|
|
_MyStepPanel.ItemMoving++;
|
|
//Location = new Point(_MyParentStepItem.Left + 20, FindTop(_MyParentStepItem.Top));
|
|
int myTop = MyNextStepItem == null ? _MyParentStepItem.Top : MyNextStepItem.Top;
|
|
Location = new Point(_MyParentStepItem.Left + 20, FindTop(myTop));
|
|
_MyStepPanel.ItemMoving--;
|
|
//_MyParentStepItem.Top = Bottom;
|
|
// Could be a Caution or Note - Need to get WidT
|
|
break;
|
|
}
|
|
}
|
|
LastMethodsPop();
|
|
}
|
|
}
|
|
private Stack<string> _LastMethods= new Stack<string>();
|
|
//private string _LastMethod = "";
|
|
private void LastMethodsPush(string str)
|
|
{
|
|
_MyStepPanel._LastAdjust = str;
|
|
_LastMethods.Push(str);
|
|
}
|
|
private string LastMethodsPop()
|
|
{
|
|
//_MyStepPanel._LastAdjust = "";
|
|
return _LastMethods.Pop();
|
|
}
|
|
private bool LastMethodsEmpty
|
|
{
|
|
get { return _LastMethods.Count == 0; }
|
|
}
|
|
/// <summary>
|
|
/// This should find the item that precedes the current item vertically
|
|
/// and then return the Bottom of that item.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private int FindTop(int bottom)
|
|
{
|
|
int lastBottomPrev = bottom; // This is necessary if the value of bottom can be negative.
|
|
if (_MyPreviousStepItem != null)
|
|
lastBottomPrev = _MyPreviousStepItem.BottomMostStepItem.Bottom;
|
|
int? bottomRNO = BottomOfParentRNO();
|
|
if (lastBottomPrev > bottom) bottom = (int)(lastBottomPrev); // RHM 20090615 ES02 Step8
|
|
// Moving from Step 8 to the Note preceeding step 8 caused the step 9 to be positioned in the wrong place.
|
|
//if (lastBottomParent > bottom) bottom = lastBottomParent;
|
|
//if (bottomRNO == null) return bottom;
|
|
return (int) max(bottomRNO, bottom);
|
|
}
|
|
/// <summary>
|
|
/// The left edge of the Tab
|
|
/// </summary>
|
|
public int ItemLeft
|
|
{
|
|
get { return Left + lblTab.Left; }
|
|
set { Left = value - lblTab.Left; }
|
|
}
|
|
/// <summary>
|
|
/// The Top of the StepItem
|
|
/// </summary>
|
|
public int ItemTop
|
|
{
|
|
get { return Top; }
|
|
set
|
|
{
|
|
_MyStepPanel.ItemMoving++;
|
|
Top = value;
|
|
_MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// The Location of the Tab
|
|
/// </summary>
|
|
public Point ItemLocation
|
|
{
|
|
get { return new Point(Location.X + lblTab.Left, Location.Y); }
|
|
set { Location = new Point(value.X - lblTab.Left, value.Y); }
|
|
}
|
|
private int _RTBMargin = 3;
|
|
/// <summary>
|
|
/// Margin between the StepItem and the StepRTB. Appears on the Right.
|
|
/// Will allow space to draw a Change Bar on the right side of the StepItem.
|
|
/// </summary>
|
|
public int RTBMargin
|
|
{
|
|
get { return _RTBMargin; }
|
|
set { _RTBMargin = value; }
|
|
}
|
|
/// <summary>
|
|
/// Width of the Tab and RTB
|
|
/// </summary>
|
|
public int ItemWidth
|
|
{
|
|
get { return Width - lblTab.Left; }
|
|
set
|
|
{
|
|
Width = RTBMargin + value + lblTab.Left;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Width of the RichTextBox
|
|
/// </summary>
|
|
public int TextWidth
|
|
{
|
|
get { return _MyStepRTB.Width; }
|
|
set
|
|
{
|
|
Width = value + lblTab.Left + lblTab.Width;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Location of the RichTextBox
|
|
/// </summary>
|
|
public Point TextLocation
|
|
{
|
|
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 int TextLeft
|
|
{
|
|
get { return Left + _MyStepRTB.Left; }
|
|
}
|
|
/// <summary>
|
|
/// Tab Format used for outputing the Tab
|
|
/// </summary>
|
|
private string _TabFormat;
|
|
public string TabFormat
|
|
{
|
|
get
|
|
{
|
|
if (_TabFormat == null) TabFormat = null; // execute 'set' code.
|
|
return _TabFormat;
|
|
}
|
|
set
|
|
{
|
|
if (_MyItemInfo != null)
|
|
{
|
|
ItemInfo.ResetTabString(MyID);
|
|
string tabString = _MyItemInfo.MyTab.CleanText;
|
|
lblTab.Text = tabString;
|
|
lblTab.Width = tabString.Length * 8 * MyStepPanel.DPI / 96;// Adjust width for DPI
|
|
Invalidate();
|
|
_MyStepRTB.Left = lblTab.Left + lblTab.Width;// +2;
|
|
_MyStepRTB.Width = Width - _MyStepRTB.Left - RTBMargin;
|
|
_TabFormat = value; // tabString;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// This is the "number" of the item (1, 2, 3 etc.) for Substeps
|
|
/// </summary>
|
|
public int Ordinal
|
|
{
|
|
get
|
|
{
|
|
int count = 1;
|
|
for (StepItem tmp = this; tmp.MyPreviousStepItem != null; tmp = tmp.MyPreviousStepItem) count++;
|
|
return count;
|
|
}
|
|
}
|
|
// hardcode to right for HLP. The change bar location from the format will need to be used to set this.
|
|
private E_ChangeBarPosition _ChangeBarPosition = E_ChangeBarPosition.Right;
|
|
public E_ChangeBarPosition ChangeBarPosition
|
|
{
|
|
get { return _ChangeBarPosition; }
|
|
set { _ChangeBarPosition = value; }
|
|
}
|
|
/// <summary>
|
|
/// Sets the previous item and adjusts locations
|
|
/// </summary>
|
|
public StepItem MyPreviousStepItem
|
|
{
|
|
get { return _MyPreviousStepItem; }
|
|
set
|
|
{
|
|
LastMethodsPush("set_MyPreviousStepItem");
|
|
_MyPreviousStepItem = value;
|
|
if (_MyPreviousStepItem != null)
|
|
{
|
|
_IgnoreResize=true;
|
|
if (_MyStepData != null && (_MyStepData.Type.ToLower().Contains("table") || _MyStepData.ParentType.ToLower().Contains("table")))
|
|
{
|
|
ItemWidth = (int)TableWidth(_MyStepRTB.Font, _MyItemInfo.MyContent.Text, true);
|
|
Location = new Point(_MyPreviousStepItem.Left, FindTop(_MyPreviousStepItem.BottomMostStepItem.Bottom));
|
|
}
|
|
else if (value.MyItemInfo.IsTablePart)
|
|
{
|
|
ItemLocation = new Point(value.MyParentStepItem.TextLeft, value.MyParentStepItem.Bottom);
|
|
ItemWidth = value.MyParentStepItem.TextWidth;
|
|
}
|
|
else
|
|
{
|
|
Width = MyPreviousStepItem.Width;
|
|
if (TopMostStepItem == this)
|
|
Location = new Point(_MyPreviousStepItem.Left, FindTop(_MyPreviousStepItem.BottomMostStepItem.Bottom));
|
|
else
|
|
TopMostStepItem.Location = new Point(TopMostStepItem.Left, FindTop(_MyPreviousStepItem.BottomMostStepItem.Bottom));
|
|
}
|
|
_IgnoreResize=false;
|
|
//ShowMe("");
|
|
//if (MyID > _StartingID)
|
|
// Console.WriteLine("{0}-->Setting MyPreviousStepItem {1},{2},{3},{4},{5},{6},{7}", WatchThisIndent, MyID, this
|
|
// , _MyPreviousStepItem
|
|
// ,Top
|
|
// , _MyPreviousStepItem.BottomMostStepItem.Bottom
|
|
// , FindTop(_MyPreviousStepItem.BottomMostStepItem.Bottom)
|
|
// , _MyPreviousStepItem.Bottom);
|
|
//Location = new Point(_MyPreviousStepItem.Left, _MyPreviousStepItem.BottomMostStepItem.Bottom);
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.None:
|
|
break;
|
|
case ChildRelation.After:
|
|
break;
|
|
case ChildRelation.RNO:
|
|
break;
|
|
case ChildRelation.Before:
|
|
//_MyStepPanel.ItemMoving++;
|
|
//UpOneStepItem.Top = BottomMostStepItem.Bottom;
|
|
//_MyStepPanel.ItemMoving--;
|
|
break;
|
|
}
|
|
if (_MyPreviousStepItem.MyNextStepItem != this) _MyPreviousStepItem.MyNextStepItem = this;
|
|
}
|
|
LastMethodsPop();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Sets the next item and adjusts the location,
|
|
/// This also sets the previous for the "next" item
|
|
/// which adjusts other locations.
|
|
/// </summary>
|
|
public StepItem MyNextStepItem
|
|
{
|
|
get { return _MyNextStepItem; }
|
|
set
|
|
{
|
|
_MyNextStepItem = value;
|
|
if (_MyNextStepItem != null)
|
|
{
|
|
if (_MyNextStepItem.MyPreviousStepItem != this)
|
|
{
|
|
_MyNextStepItem.MyPreviousStepItem = this;
|
|
MyNextStepItem.Location = new Point(Left, Bottom);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// returns the TopMostChild
|
|
/// </summary>
|
|
public StepItem TopMostStepItem
|
|
{
|
|
get
|
|
{
|
|
if (Expanded && _MyBeforeStepItems != null) return _MyBeforeStepItems[0].TopMostStepItem;
|
|
return this;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Returns the bottom location (Top + Height)
|
|
/// </summary>
|
|
public new int Bottom
|
|
{
|
|
get
|
|
{
|
|
return Top + (Hidden ? 0 : Height);
|
|
}
|
|
}
|
|
private bool _Hidden = false;
|
|
public bool Hidden
|
|
{
|
|
get { return _Hidden; }
|
|
set { _Hidden = value; Visible = !value; }
|
|
}
|
|
/// <summary>
|
|
/// Bottom most child
|
|
/// </summary>
|
|
public StepItem BottomMostStepItem
|
|
{
|
|
get
|
|
{
|
|
StepItem tmpr = null; // BottomMost RNO
|
|
//int rnoOffset = 0;
|
|
if ((MyExpandingStatus != ExpandingStatus.No || Expanded) && _MyRNOStepItems != null)
|
|
{
|
|
//rnoOffset = this.Top - _MyRNOStepItems[0].Top;
|
|
tmpr = _MyRNOStepItems[_MyRNOStepItems.Count - 1].BottomMostStepItem;
|
|
}
|
|
StepItem tmpa = this; // BottomMost After
|
|
if ((MyExpandingStatus != ExpandingStatus.No || Expanded) & _MyAfterStepItems != null)
|
|
tmpa = _MyAfterStepItems[_MyAfterStepItems.Count - 1].BottomMostStepItem;
|
|
// return the bottom most of the two results
|
|
if (tmpr == null)
|
|
return tmpa;
|
|
//if (rnoOffset > 0)
|
|
//Console.WriteLine("RNO Bottom Offset {0}", rnoOffset);
|
|
//if (tmpa.Bottom >= (tmpr.Bottom + rnoOffset))
|
|
if (tmpa.Bottom >= (tmpr.Bottom))
|
|
return tmpa;
|
|
return tmpr;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Bottom most child excluding RNOs
|
|
/// </summary>
|
|
public StepItem BottomMostStepItemNoRNOs
|
|
{
|
|
get
|
|
{
|
|
StepItem tmpa = this; // BottomMost After
|
|
if ((MyExpandingStatus != ExpandingStatus.No || Expanded) & _MyAfterStepItems != null)
|
|
tmpa = _MyAfterStepItems[_MyAfterStepItems.Count - 1].BottomMostStepItem;
|
|
// return the bottom most
|
|
return tmpa;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// First sibling
|
|
/// </summary>
|
|
private StepItem FirstSiblingStepItem
|
|
{
|
|
get
|
|
{
|
|
StepItem tmp = this;
|
|
while (tmp.MyPreviousStepItem != null)
|
|
tmp = tmp.MyPreviousStepItem;
|
|
return tmp;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Last sibling
|
|
/// </summary>
|
|
private StepItem LastSiblingStepItem
|
|
{
|
|
get
|
|
{
|
|
StepItem tmp = this;
|
|
while (tmp.MyNextStepItem != null)
|
|
tmp = tmp.MyNextStepItem;
|
|
return tmp;
|
|
}
|
|
}
|
|
/// <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 bool Expanded
|
|
{
|
|
get
|
|
{
|
|
return !_Colapsing && (MyExpandingStatus != ExpandingStatus.No || _MyvlnExpander.Expanded);
|
|
}
|
|
set
|
|
{
|
|
_MyvlnExpander.Expanded = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Sets or Gets expanding status
|
|
/// </summary>
|
|
public ExpandingStatus MyExpandingStatus
|
|
{
|
|
get { return _MyExpandingStatus; }
|
|
set { _MyExpandingStatus = value; }
|
|
}
|
|
/// <summary>
|
|
/// Gets or sets colapsing
|
|
/// </summary>
|
|
public bool Colapsing
|
|
{
|
|
get { return _Colapsing; }
|
|
set { _Colapsing = value; }
|
|
}
|
|
/// <summary>
|
|
/// Gets or Sets the ability to expand
|
|
/// </summary>
|
|
public bool CanExpand
|
|
{
|
|
get { return _MyvlnExpander.Visible; }
|
|
set { _MyvlnExpander.Visible = value; }
|
|
}
|
|
/// <summary>
|
|
/// Gets the text from the content
|
|
/// </summary>
|
|
public string MyText
|
|
{
|
|
get { return _MyItemInfo == null ? null : _MyItemInfo.MyContent.Text; }
|
|
}
|
|
/// <summary>
|
|
/// Gets the ItemID from the ItemInfo
|
|
/// </summary>
|
|
public int MyID
|
|
{
|
|
get { return _MyItemInfo == null ? 0 : _MyItemInfo.ItemID; }
|
|
}
|
|
/// <summary>
|
|
/// Tracks when a StepItem is moving
|
|
/// </summary>
|
|
public bool Moving
|
|
{
|
|
get { return _Moving; }
|
|
set { _Moving = value; }
|
|
}
|
|
/// <summary>
|
|
/// The RNO (Contingency) Level
|
|
/// </summary>
|
|
public int RNOLevel
|
|
{
|
|
get { return _RNOLevel; }
|
|
set { _RNOLevel = value; }
|
|
}
|
|
/// <summary>
|
|
/// Sequential Level - Only counts levels of Sequential substeps
|
|
/// </summary>
|
|
public int SeqLevel
|
|
{
|
|
get { return _SeqLevel; }
|
|
set { _SeqLevel = value; }
|
|
}
|
|
// TODO: This should be changed to get the Circle format from the data
|
|
/// <summary>
|
|
/// Show a circle or not
|
|
/// </summary>
|
|
public bool Circle
|
|
{
|
|
get { return _Circle; }
|
|
set { _Circle = value; }
|
|
}
|
|
// TODO: This should be changed to get the Checkoff status from the data
|
|
/// <summary>
|
|
/// Has a check-off or not
|
|
/// </summary>
|
|
public bool CheckOff
|
|
{
|
|
get { return _CheckOff; }
|
|
set { _CheckOff = value; }
|
|
}
|
|
// TODO: This should be changed to get the ChangeBar status from the data
|
|
/// <summary>
|
|
/// Has a changebar or not
|
|
/// </summary>
|
|
public bool ChangeBar
|
|
{
|
|
get { return _ChangeBar; }
|
|
set
|
|
{
|
|
_ChangeBar = value;
|
|
this.Invalidate();
|
|
}
|
|
}
|
|
#endregion // Properties
|
|
#region Constructors
|
|
public StepItem(ItemInfo itemInfo, StepPanel myStepPanel, StepItem myParentStepItem, ChildRelation myChildRelation, bool expand)
|
|
{
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB Top");
|
|
InitializeComponent();// TODO: Performance 25%
|
|
SetupStepItem(itemInfo, myStepPanel, myParentStepItem, myChildRelation, expand, null);
|
|
}
|
|
public StepItem(ItemInfo itemInfo, StepPanel myStepPanel, StepItem myParentStepItem, ChildRelation myChildRelation, bool expand, StepItem nextStepItem)
|
|
{
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB Top");
|
|
InitializeComponent();// TODO: Performance 25%
|
|
SetupStepItem(itemInfo, myStepPanel, myParentStepItem, myChildRelation, expand, nextStepItem);
|
|
}
|
|
private void SetupStepItem(ItemInfo itemInfo, StepPanel myStepPanel, StepItem myParentStepItem, ChildRelation myChildRelation, bool expand, StepItem nextStepItem)
|
|
{
|
|
//if (itemInfo.ItemID == 225) _MyStepRTB.Resize += new EventHandler(_MyStepRTB_Resize);
|
|
_MyStepRTB.MyStepItem = 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(StepItem_Paint);
|
|
this.BackColorChanged += new EventHandler(StepItem_BackColorChanged);
|
|
if (itemInfo != null)
|
|
{
|
|
_Type = (int)itemInfo.MyContent.Type;
|
|
switch (_Type / 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[_Type % 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._LookupStepItems.Add(itemInfo.ItemID, this);
|
|
_MyChildRelation = myChildRelation;
|
|
if (myParentStepItem != null) RNOLevel = myParentStepItem.RNOLevel;
|
|
if (itemInfo != null)
|
|
{
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB before _Layout");
|
|
_MyStepSectionLayoutData = itemInfo.ActiveFormat.MyStepSectionLayoutData;
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB _Layout");
|
|
if (myParentStepItem != null)
|
|
SeqLevel = myParentStepItem.SeqLevel + ((myChildRelation == ChildRelation.After || myChildRelation == ChildRelation.Before) && itemInfo.IsSequential ? 1 : 0);
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB seqLevel");
|
|
MyItemInfo = itemInfo;
|
|
}
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB MyItem");
|
|
myStepPanel.Controls.Add(this);
|
|
|
|
switch (myChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
AddItem(myParentStepItem, ref myParentStepItem._MyAfterStepItems,nextStepItem);
|
|
break;
|
|
case ChildRelation.Before:
|
|
AddItem(myParentStepItem, ref myParentStepItem._MyBeforeStepItems, nextStepItem);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
RNOLevel = myParentStepItem.RNOLevel + 1;
|
|
AddItem(myParentStepItem, ref myParentStepItem._MyRNOStepItems, nextStepItem);
|
|
break;
|
|
case ChildRelation.None:
|
|
break;
|
|
}
|
|
if (itemInfo != null)
|
|
{
|
|
if (myChildRelation == ChildRelation.None)
|
|
{
|
|
if (_Type == 0 && _MyStepSectionLayoutData != null)
|
|
{
|
|
LastMethodsPush(string.Format("SetupStepItem {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 (myParentStepItem == null)// If it is the top node
|
|
if (_Type >= 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("SetupStepItem");
|
|
_MyStepPanel.ItemMoving++;
|
|
Top = top;
|
|
_MyStepPanel.ItemMoving--;
|
|
LastMethodsPop();
|
|
}
|
|
_Loading = false;
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB Controls Add");
|
|
}
|
|
private void SetExpandAndExpander(ItemInfo itemInfo)
|
|
{
|
|
// Don't allow substeps to expand
|
|
switch (_Type / 10000)
|
|
{
|
|
case 1: // Section can expand
|
|
CanExpand = true;
|
|
// If a word document set the expander to attachment
|
|
_MyvlnExpander.Attachment = !(itemInfo.IsStepSection);
|
|
//OLD: _MyvlnExpander.Attachment = (itemInfo.MyContent.ContentPartCount == 0);
|
|
break;
|
|
case 2: // High level steps with children can expand
|
|
CanExpand = itemInfo.IsHigh && itemInfo.HasChildren; // TemporaryFormat.IsHigh(item); ;
|
|
break;
|
|
default://Procedures cannot expand, because they automatically expand
|
|
CanExpand = false;
|
|
break;
|
|
}
|
|
}
|
|
private 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;
|
|
}
|
|
}
|
|
private void SetupHeader()
|
|
{
|
|
SetupHeader(MyItemInfo);
|
|
LastMethodsPush("SetupHeader");
|
|
Height = _MyStepRTB.Height + _MyStepRTB.Top + 7;
|
|
LastMethodsPop();
|
|
}
|
|
void _MyStepRTB_Resize(object sender, EventArgs e)
|
|
{
|
|
// Console.WriteLine("Left {0} Width {1}", Left, Width);
|
|
}
|
|
|
|
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 AddItem
|
|
/// <summary>
|
|
/// Adds an item to a list
|
|
/// </summary>
|
|
/// <param name="parentStepItem">Parent Container</param>
|
|
/// <param name="siblingStepItems">StepItem List</param>
|
|
public void AddItem(StepItem parentStepItem, ref List<StepItem> siblingStepItems, StepItem nextStepItem)
|
|
{
|
|
if (siblingStepItems == null) // Create a list of siblings
|
|
{
|
|
siblingStepItems = new List<StepItem>();
|
|
siblingStepItems.Add(this);
|
|
MyParentStepItem = parentStepItem;
|
|
}
|
|
else // Add to the existing list
|
|
{
|
|
if (nextStepItem == null) // Add to the end of the list
|
|
{
|
|
StepItem lastChild = LastChild(siblingStepItems);
|
|
siblingStepItems.Add(this);
|
|
MyPreviousStepItem = lastChild;
|
|
}
|
|
else // Add to the middle of the list before a particular item
|
|
{
|
|
StepItem prevChild = nextStepItem.MyPreviousStepItem;
|
|
StepItem parent = nextStepItem.MyParentStepItem;
|
|
siblingStepItems.Insert(siblingStepItems.IndexOf(nextStepItem), this);
|
|
MyStepPanel.ItemMoving++;
|
|
_MyNextStepItem = nextStepItem;
|
|
nextStepItem._MyPreviousStepItem = this;
|
|
MyPreviousStepItem = prevChild;// If a previous exists - this will adjust the location and width of the StepItem
|
|
nextStepItem.MyParentStepItem = null;
|
|
MyParentStepItem = parent; // If a parent exists - this will adjust the location and width of the StepItem
|
|
//nextStepItem.MyPreviousStepItem = this;
|
|
MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
if (MyItemInfo.IsCaution || MyItemInfo.IsNote)
|
|
{
|
|
StepItem prev = this;
|
|
while (prev.MyPreviousStepItem != null) prev = prev.MyPreviousStepItem;
|
|
prev.SetAllTabs();
|
|
}
|
|
else
|
|
SetAllTabs();
|
|
}
|
|
// clear tabs, clears then all so that next 'get' will calculate new.
|
|
public void SetAllTabs()
|
|
{
|
|
TabFormat = null; // reset TabFormat
|
|
SetupHeader();
|
|
if (_MyAfterStepItems != null) foreach (StepItem chld in _MyAfterStepItems) chld.SetAllTabs();
|
|
if (_MyNextStepItem != null) _MyNextStepItem.SetAllTabs();
|
|
// Update the RNO tab if it exists - RHM 20100106
|
|
if (_MyRNOStepItems != null) foreach (StepItem chld in _MyRNOStepItems) chld.SetAllTabs();
|
|
}
|
|
/// <summary>
|
|
/// Add the next item to a list
|
|
/// </summary>
|
|
/// <param name="myItemInfo"></param>
|
|
/// <param name="expand"></param>
|
|
/// <returns></returns>
|
|
//public StepItem AddNext(ItemInfo myItemInfo, bool expand)
|
|
//{
|
|
// StepItem tmp = new StepItem(myItemInfo, _MyStepPanel, MyParentStepItem, ChildRelation.None, expand);
|
|
// MyNextStepItem = tmp;
|
|
// return tmp;
|
|
//}
|
|
#endregion
|
|
#region RemoveItem
|
|
protected void ShowTops(string title)
|
|
{
|
|
int TopMostY = TopMostStepItem.Top;
|
|
int? TopMostParentY = (MyParentStepItem == null ? null : (int?)(MyParentStepItem.TopMostStepItem.Top));
|
|
int? ParentY = (MyParentStepItem == null ? null : (int?)(MyParentStepItem.Top));
|
|
//Console.Write("{0}: TopMostY={1}, TopMostParentY={2}, ParentY = {3}",title, TopMostY, TopMostParentY, ParentY);
|
|
Console.Write("{0}{1},{2},{3}", title, TopMostY, TopMostParentY.ToString() ?? "null", ParentY.ToString() ?? "null");
|
|
}
|
|
private bool _BeingRemoved = false;
|
|
public bool BeingRemoved
|
|
{
|
|
get { return _BeingRemoved; }
|
|
set { _BeingRemoved = value; }
|
|
}
|
|
public void RemoveItem()
|
|
{
|
|
BeingRemoved = true;
|
|
MyStepPanel.SelectedStepRTB = null; // Unselect the item to be deleted
|
|
//ShowTops("\r\n");
|
|
int TopMostYBefore = TopMostStepItem.Top;
|
|
StepItem newFocus = DeleteItem();
|
|
if (newFocus == null) return;
|
|
newFocus.MyStepRTB.Focus();
|
|
Dispose();
|
|
newFocus.SetAllTabs();
|
|
int TopMostYAfter = newFocus.TopMostStepItem.Top;
|
|
if (TopMostYAfter > TopMostYBefore)
|
|
newFocus.TopMostStepItem.Top = TopMostYBefore;
|
|
newFocus.AdjustLocation();
|
|
//newFocus.ShowTops("");
|
|
}
|
|
public StepItem DeleteItem()
|
|
{
|
|
StepItem newFocus = null;
|
|
int? TopMostParentY = (MyParentStepItem == null ? null : (int?)(MyParentStepItem.TopMostStepItem.Top));
|
|
int? ParentY = (MyParentStepItem == null ? null : (int?)(MyParentStepItem.Top));
|
|
try
|
|
{
|
|
Item.DeleteItemAndChildren(MyItemInfo);
|
|
}
|
|
catch (System.Data.SqlClient.SqlException ex)
|
|
{
|
|
HandleSqlExceptionOnDelete(ex);
|
|
return null;
|
|
}
|
|
// Remove StepItems
|
|
RemoveFromParentsChildList();
|
|
if (MyNextStepItem != null)
|
|
{
|
|
if (MyPreviousStepItem != null)
|
|
{
|
|
MyNextStepItem.MyPreviousStepItem = MyPreviousStepItem;
|
|
MyPreviousStepItem = null;
|
|
newFocus = MyNextStepItem;
|
|
}
|
|
else
|
|
{
|
|
MyNextStepItem.MyParentStepItem = MyParentStepItem;
|
|
MyParentStepItem = null;
|
|
MyNextStepItem.MyPreviousStepItem = null;
|
|
newFocus = MyNextStepItem;
|
|
}
|
|
// Adjust the vertical locations of all of the items below the item deleted
|
|
MyNextStepItem.TopMostStepItem.AdjustLocation();
|
|
MyNextStepItem = null;
|
|
}
|
|
else if (MyPreviousStepItem != null)
|
|
{
|
|
MyPreviousStepItem.MyNextStepItem = null;
|
|
newFocus = MyPreviousStepItem;
|
|
MyPreviousStepItem = null;
|
|
//Console.Write(",\"Previous\",");
|
|
}
|
|
else
|
|
{
|
|
newFocus = MyParentStepItem;
|
|
MyParentStepItem = null;
|
|
//Console.Write(",\"Parent\",");
|
|
}
|
|
return newFocus;
|
|
}
|
|
|
|
private void HandleSqlExceptionOnDelete(System.Data.SqlClient.SqlException ex)
|
|
{
|
|
if (ex.Message.Contains("has External Transitions and has no next step"))
|
|
{
|
|
using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitions(MyID))
|
|
{
|
|
DialogResult ans = MessageBox.Show("Transitions exist to this step and cannot be adjusted automatically." +
|
|
"\r\n\r\nDo you want to be placed on the " + (exTrans.Count > 1 ? "first " : "") + "substep with the problem Transition?" +
|
|
"\r\n\r\nSubsteps with Problem Transitions" +
|
|
exTrans.Summarize(),
|
|
"Cannot Delete This Step", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
|
|
if (ans == DialogResult.Yes)
|
|
{
|
|
MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(exTrans[0].MyContent.ContentItems[0]);
|
|
|
|
}
|
|
else
|
|
this.MyStepRTB.Focus();
|
|
}
|
|
}
|
|
else if (ex.Message.Contains("has External Transitions to it's children"))
|
|
{
|
|
using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitionsToChildren(MyID))
|
|
{
|
|
DialogResult ans = MessageBox.Show("Transitions exist to substeps of this step and cannot be adjusted automatically." +
|
|
"\r\n\r\nDo you want to be placed on the " + (exTrans.Count > 1 ? "first " : "") + "substep with the problem Transition?" +
|
|
"\r\n\r\nSubsteps with Problem Transitions:" +
|
|
exTrans.Summarize(),
|
|
"Cannot Delete This Step", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
|
|
if (ans == DialogResult.Yes)
|
|
{
|
|
MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OpenItem(exTrans[0].MyContent.ContentItems[0]);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
MessageBox.Show(ex.Message, "SQL Exception", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
|
|
}
|
|
private void RemoveFromParentsChildList()
|
|
{
|
|
StepItem top = this;
|
|
while (top.MyPreviousStepItem != null) top = top.MyPreviousStepItem;
|
|
StepItem parentStepItem = top.MyParentStepItem;
|
|
if (parentStepItem == null) return; // No parent, nothing to remove.
|
|
if (parentStepItem.MyAfterStepItems != null && parentStepItem.MyAfterStepItems.Contains(this))
|
|
{
|
|
parentStepItem.MyAfterStepItems.Remove(this);
|
|
if (parentStepItem.MyAfterStepItems.Count == 0)
|
|
parentStepItem.MyAfterStepItems = null;
|
|
}
|
|
else if (parentStepItem.MyBeforeStepItems != null && parentStepItem.MyBeforeStepItems.Contains(this))
|
|
{
|
|
parentStepItem.MyBeforeStepItems.Remove(this);
|
|
if(parentStepItem.MyBeforeStepItems.Count == 0)
|
|
parentStepItem.MyBeforeStepItems = null;
|
|
}
|
|
else if (parentStepItem.MyRNOStepItems != null && parentStepItem.MyRNOStepItems.Contains(this))
|
|
{
|
|
parentStepItem.MyRNOStepItems.Remove(this);
|
|
if(parentStepItem.MyRNOStepItems.Count == 0)
|
|
parentStepItem.MyRNOStepItems = null;
|
|
}
|
|
if (parentStepItem.MyAfterStepItems == null && parentStepItem.MyBeforeStepItems == null && parentStepItem.MyRNOStepItems == null)
|
|
parentStepItem.CanExpand = false;
|
|
}
|
|
//private void ShowSiblings(string title)
|
|
//{
|
|
// Console.WriteLine("---{0} {1}---",title,MyID);
|
|
// StepItem top = this;
|
|
// while (top.MyPreviousStepItem != null) top = top.MyPreviousStepItem;
|
|
// do
|
|
// {
|
|
// Console.WriteLine("{0} StepItem - {1} {2}", top.MyID == MyID ? "*" : " ", top.MyID, top.MyItemInfo.MyContent.Text);
|
|
// top = top.MyNextStepItem;
|
|
// } while (top != null);
|
|
//}
|
|
#endregion
|
|
#region Add Children
|
|
/// <summary>
|
|
/// Add a child before (Notes, Cautions, etc.)
|
|
/// </summary>
|
|
/// <param name="myItemInfo"></param>
|
|
/// <param name="expand"></param>
|
|
public void AddChildBefore(ItemInfo myItemInfo, bool expand)
|
|
{
|
|
StepItem child = new StepItem(myItemInfo, _MyStepPanel, this, ChildRelation.Before, expand);
|
|
}
|
|
/// <summary>
|
|
/// Add a list of children before
|
|
/// </summary>
|
|
/// <param name="myItemInfoList"></param>
|
|
/// <param name="expand"></param>
|
|
public void AddChildBefore(ItemInfoList myItemInfoList, bool expand)
|
|
{
|
|
if (myItemInfoList != null)
|
|
foreach (ItemInfo item in myItemInfoList)
|
|
AddChildBefore(item, expand);
|
|
}
|
|
/// <summary>
|
|
/// Add an RNO (Contingency) child
|
|
/// </summary>
|
|
/// <param name="myItemInfo"></param>
|
|
/// <param name="expand"></param>
|
|
public void AddChildRNO(ItemInfo myItemInfo, bool expand)
|
|
{
|
|
StepItem child = new StepItem(myItemInfo, _MyStepPanel, this, ChildRelation.RNO, expand);
|
|
}
|
|
/// <summary>
|
|
/// Add a list of RNO (Contingency) children
|
|
/// </summary>
|
|
/// <param name="myItemInfoList"></param>
|
|
/// <param name="expand"></param>
|
|
public void AddChildRNO(ItemInfoList myItemInfoList, bool expand)
|
|
{
|
|
if (myItemInfoList != null)
|
|
foreach (ItemInfo item in myItemInfoList)
|
|
AddChildRNO(item, expand);
|
|
}
|
|
/// <summary>
|
|
/// Add a child after
|
|
/// </summary>
|
|
/// <param name="MyItemInfo"></param>
|
|
/// <param name="expand"></param>
|
|
public StepItem AddChildAfter(ItemInfo MyItemInfo, bool expand)
|
|
{
|
|
StepItem child = new StepItem(MyItemInfo, _MyStepPanel, this, ChildRelation.After, expand);
|
|
return child;
|
|
}
|
|
public StepItem AddChildAfter(ItemInfo MyItemInfo, StepItem nextStepItem)
|
|
{
|
|
StepItem child = new StepItem(MyItemInfo, _MyStepPanel, this, ChildRelation.After, true, nextStepItem);
|
|
return child;
|
|
}
|
|
public StepItem AddChildBefore(ItemInfo MyItemInfo, StepItem nextStepItem)
|
|
{
|
|
StepItem child = new StepItem(MyItemInfo, _MyStepPanel, this, ChildRelation.Before, true, nextStepItem);
|
|
return child;
|
|
}
|
|
public StepItem AddChildRNO(ItemInfo MyItemInfo, StepItem nextStepItem)
|
|
{
|
|
StepItem child = new StepItem(MyItemInfo, _MyStepPanel, this, ChildRelation.RNO, true, nextStepItem);
|
|
return child;
|
|
}
|
|
/// <summary>
|
|
/// Adds a sibling after the current StepItem
|
|
/// </summary>
|
|
public void AddSiblingAfter()
|
|
{
|
|
AddSiblingAfter("",true);
|
|
}
|
|
public void AddSiblingAfter(string text,bool updateStatus)
|
|
{
|
|
MyStepRTB.SaveText();
|
|
ItemInfo newItemInfo = MyItemInfo.InsertSiblingAfter(text);
|
|
DoAddSiblingAfter(newItemInfo, updateStatus);
|
|
}
|
|
public void AddSiblingAfter(int? type, bool updateStatus)
|
|
{
|
|
MyStepRTB.SaveText();
|
|
ItemInfo newItemInfo = MyItemInfo.InsertSiblingAfter("","",type);
|
|
DoAddSiblingAfter(newItemInfo,updateStatus);
|
|
}
|
|
private void DoAddSiblingAfter(ItemInfo newItemInfo, bool updateStatus)
|
|
{
|
|
StepItem newStepItem = null;
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newStepItem = ActiveParent.AddChildAfter(newItemInfo, MyNextStepItem);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newStepItem = ActiveParent.AddChildBefore(newItemInfo, MyNextStepItem);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newStepItem = ActiveParent.AddChildRNO(newItemInfo, MyNextStepItem);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
//StepItem newStepItem = ActiveParent.AddChildAfter(newItemInfo, );
|
|
if(updateStatus)
|
|
_MyStepPanel.SelectedStepRTB = newStepItem.MyStepRTB;//Update Screen
|
|
}
|
|
private static int _WatchThis = 1;
|
|
public void AddSiblingBefore()
|
|
{
|
|
AddSiblingBefore("",true);
|
|
}
|
|
public void AddSiblingBefore(string text, bool updateSelection)
|
|
{
|
|
// Save RTB text before creating a new item because the process of creating
|
|
// a new item will save a change to iteminfo excluding text changes. This
|
|
// shouldn't be necessary for adding sibling after because the current step
|
|
// doesn't get saved during the insert after because of the MyPrevious field
|
|
// is only set on an insert before, which is what saves the item without
|
|
// any updates from the richtextbox text.
|
|
_MyStepRTB.SaveText();
|
|
ItemInfo newItemInfo = MyItemInfo.InsertSiblingBefore(text);
|
|
StepItem newStepItem=null;
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newStepItem = ActiveParent.AddChildAfter(newItemInfo, this);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newStepItem = ActiveParent.AddChildBefore(newItemInfo, this);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newStepItem = ActiveParent.AddChildRNO(newItemInfo, this);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
if(updateSelection)
|
|
_MyStepPanel.SelectedStepRTB = newStepItem.MyStepRTB;//Update Screen
|
|
}
|
|
public void AddChild(E_FromType fromType, int type)
|
|
{
|
|
AddChild("",fromType, type);
|
|
}
|
|
public void AddChild(string text, E_FromType fromType, int type)
|
|
{
|
|
if (_MyItemInfo.IsHigh || _MyItemInfo.IsSection)
|
|
this.CanExpand = true;
|
|
this.Expanded = true;
|
|
_WatchThis = 1;
|
|
ItemInfo newItemInfo = MyItemInfo.InsertChild(fromType, type, text);
|
|
// TODO: We need to determine where this will go in the stack of children
|
|
StepItem nextItem = null;
|
|
if (newItemInfo.NextItem != null)
|
|
nextItem = MyStepPanel.FindItem(newItemInfo.NextItem);
|
|
else if (fromType == E_FromType.Table && MyAfterStepItems != null)
|
|
nextItem = MyAfterStepItems[0];
|
|
// Cautions come before notes, so if this is a Caution and there are Notes, put this first
|
|
else if (fromType == E_FromType.Caution && ((ItemInfo)newItemInfo.ActiveParent).Notes != null
|
|
&& ((ItemInfo)newItemInfo.ActiveParent).Notes.Count > 0)
|
|
nextItem = MyStepPanel.FindItem(((ItemInfo)newItemInfo.ActiveParent).Notes[0]);
|
|
// TODO: May need similar logic if a Table is being added to a step that has substeps
|
|
// else if (fromType == E_FromType.Table && ((ItemInfo)newItemInfo.ActiveParent).Steps != null
|
|
//&& ((ItemInfo)newItemInfo.ActiveParent).Steps.Count > 0)
|
|
// nextItem = MyStepPanel.FindItem(((ItemInfo)newItemInfo.ActiveParent).Steps[0]);
|
|
StepItem newStepItem;
|
|
switch (fromType)
|
|
{
|
|
case E_FromType.Caution:
|
|
newStepItem = this.AddChildBefore(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Note:
|
|
newStepItem = this.AddChildBefore(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Procedure:
|
|
newStepItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.RNO:
|
|
newStepItem = this.AddChildRNO(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Section:
|
|
newStepItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Step:
|
|
newStepItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Table:
|
|
newStepItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
default:
|
|
newStepItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
}
|
|
_MyStepPanel.SelectedStepRTB = newStepItem.MyStepRTB;//Update Screen
|
|
}
|
|
/// <summary>
|
|
/// Add a list of children after
|
|
/// </summary>
|
|
/// <param name="myItemInfoList"></param>
|
|
/// <param name="expand"></param>
|
|
public StepItem AddChildAfter(ItemInfoList myItemInfoList, bool expand)
|
|
{
|
|
StepItem child = null;
|
|
if (myItemInfoList != null)
|
|
foreach (ItemInfo item in myItemInfoList)
|
|
child = AddChildAfter(item, expand);
|
|
return child;
|
|
}
|
|
#endregion
|
|
#region CopyPaste
|
|
public void PasteSiblingBefore(int copyStartID)
|
|
{
|
|
ItemInfo newItemInfo = MyItemInfo.PasteSiblingBefore(copyStartID);
|
|
StepItem newStepItem = null;
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newStepItem = ActiveParent.AddChildAfter(newItemInfo, this);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newStepItem = ActiveParent.AddChildBefore(newItemInfo, this);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newStepItem = ActiveParent.AddChildRNO(newItemInfo, this);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
if (newStepItem != null) _MyStepPanel.SelectedStepRTB = newStepItem.MyStepRTB;//Update Screen
|
|
_MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnItemPaste(this, new vlnTreeItemInfoPasteEventArgs(newItemInfo, copyStartID, ItemInfo.EAddpingPart.Before, newItemInfo.MyContent.Type));
|
|
|
|
}
|
|
public void PasteSiblingAfter(int copyStartID)
|
|
{
|
|
ItemInfo newItemInfo = MyItemInfo.PasteSiblingAfter(copyStartID);
|
|
StepItem newStepItem = null;
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newStepItem = ActiveParent.AddChildAfter(newItemInfo, MyNextStepItem);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newStepItem = ActiveParent.AddChildBefore(newItemInfo, MyNextStepItem);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newStepItem = ActiveParent.AddChildRNO(newItemInfo, MyNextStepItem);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
_MyStepPanel.SelectedStepRTB = newStepItem.MyStepRTB;//Update Screen
|
|
_MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnItemPaste(this, new vlnTreeItemInfoPasteEventArgs(newItemInfo, copyStartID, ItemInfo.EAddpingPart.After, newItemInfo.MyContent.Type));
|
|
|
|
}
|
|
public StepItem PasteReplace(int copyStartID)
|
|
{
|
|
// To allow a Paste Step into an empty (new) step/substep, we need to add a character to the the Text field
|
|
// to simulate replacing an existing step - otherwise we will get null references.
|
|
if (MyStepPanel.SelectedStepRTB.Text == "")
|
|
MyStepPanel.SelectedStepRTB.Text = " ";
|
|
MyStepPanel.SelectedStepRTB = null; // Unselect the item to be deleted
|
|
ChildRelation childRelation = _MyChildRelation;
|
|
StepItem newFocus = null;
|
|
StepItem nextStepItem = MyNextStepItem;
|
|
StepItem prevStepItem = MyPreviousStepItem;
|
|
StepItem parentStepItem = ActiveParent;
|
|
|
|
int TopMostYBefore = TopMostStepItem.Top;
|
|
int? TopMostParentY = (MyParentStepItem == null ? null : (int?)(MyParentStepItem.TopMostStepItem.Top));
|
|
int? ParentY = (MyParentStepItem == null ? null : (int?)(MyParentStepItem.Top));
|
|
ItemInfo newItemInfo = null;
|
|
try
|
|
{
|
|
newItemInfo = Item.PasteReplace(MyItemInfo, copyStartID);
|
|
}
|
|
catch (System.Data.SqlClient.SqlException ex)
|
|
{
|
|
HandleSqlExceptionOnDelete(ex);
|
|
return this;
|
|
}
|
|
// Remove the StepItem that was the replaced item.
|
|
RemoveFromParentsChildList();
|
|
|
|
if (MyNextStepItem != null)
|
|
{
|
|
if (MyPreviousStepItem != null)
|
|
{
|
|
MyNextStepItem.MyPreviousStepItem = MyPreviousStepItem;
|
|
MyPreviousStepItem = null;
|
|
}
|
|
else
|
|
{
|
|
MyNextStepItem.MyParentStepItem = MyParentStepItem;
|
|
MyParentStepItem = null;
|
|
MyNextStepItem.MyPreviousStepItem = null;
|
|
}
|
|
MyNextStepItem = null;
|
|
}
|
|
else if (MyPreviousStepItem != null)
|
|
{
|
|
MyPreviousStepItem.MyNextStepItem = null;
|
|
newFocus = MyPreviousStepItem;
|
|
MyPreviousStepItem = null;
|
|
}
|
|
else
|
|
{
|
|
newFocus = MyParentStepItem;
|
|
MyParentStepItem = null;
|
|
}
|
|
|
|
// add copied item to ui where the replaced item was.
|
|
StepItem newStepItem = null;
|
|
switch (childRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newStepItem = parentStepItem.AddChildAfter(newItemInfo, nextStepItem);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newStepItem = parentStepItem.AddChildBefore(newItemInfo, nextStepItem);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newStepItem = parentStepItem.AddChildRNO(newItemInfo, nextStepItem);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
_MyStepPanel.SelectedStepRTB = newStepItem.MyStepRTB;//Update Screen
|
|
_MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnItemPaste(this, new vlnTreeItemInfoPasteEventArgs(newItemInfo, copyStartID, ItemInfo.EAddpingPart.Replace, newItemInfo.MyContent.Type));
|
|
return newStepItem;
|
|
}
|
|
public void HighlightBackColor()
|
|
{
|
|
// Highlight all of the rtb's within this stepitem:
|
|
if (MyAfterStepItems != null)
|
|
{
|
|
foreach (StepItem sia in MyAfterStepItems)
|
|
{
|
|
sia.MyStepRTB.HighlightBackColor();
|
|
sia.HighlightBackColor();
|
|
}
|
|
}
|
|
if (MyBeforeStepItems != null)
|
|
{
|
|
foreach (StepItem sib in MyBeforeStepItems)
|
|
{
|
|
sib.MyStepRTB.HighlightBackColor();
|
|
sib.HighlightBackColor();
|
|
}
|
|
}
|
|
if (MyRNOStepItems != null)
|
|
{
|
|
foreach (StepItem sir in MyRNOStepItems)
|
|
{
|
|
sir.MyStepRTB.HighlightBackColor();
|
|
sir.HighlightBackColor();
|
|
}
|
|
}
|
|
}
|
|
public void SetBackColor()
|
|
{
|
|
// Set (removing highlighting) all of the rtb's within this stepitem:
|
|
if (MyAfterStepItems != null)
|
|
{
|
|
foreach (StepItem sia in MyAfterStepItems)
|
|
{
|
|
sia.MyStepRTB.SetBackColor();
|
|
sia.SetBackColor();
|
|
}
|
|
}
|
|
if (MyBeforeStepItems != null)
|
|
{
|
|
foreach (StepItem sib in MyBeforeStepItems)
|
|
{
|
|
sib.MyStepRTB.SetBackColor();
|
|
sib.SetBackColor();
|
|
}
|
|
}
|
|
if (MyRNOStepItems != null)
|
|
{
|
|
foreach (StepItem sir in MyRNOStepItems)
|
|
{
|
|
sir.MyStepRTB.SetBackColor();
|
|
sir.SetBackColor();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Event Handlers
|
|
/// <summary>
|
|
/// If the background changes, change the background of the RichTextBox
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void StepItem_BackColorChanged(object sender, EventArgs e)
|
|
{
|
|
//_MyStepRTB.BackColor = BackColor;
|
|
_MyStepRTB.SetBackColor();
|
|
}
|
|
/// <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 _StepRTB_HeightChanged(object sender, EventArgs args)
|
|
{
|
|
if (this.Height != _MyStepRTB.Height+_MyStepRTB.Top+7) // add in 7 to make it look good // + 10)
|
|
{
|
|
//if (MyID == 2131 || MyID == 2132)
|
|
// Console.WriteLine("oops!");
|
|
LastMethodsPush(string.Format("_StepRTB_HeightChanged {0}", _MyStepRTB.Height));
|
|
this.Height = _MyStepRTB.Height + _MyStepRTB.Top + 7;
|
|
LastMethodsPop();
|
|
}
|
|
}
|
|
/// <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 = TopMostStepItem.Top;// This does'nt work - this is since the last time it was expanded.
|
|
_Colapsing = true;
|
|
// Hide Children
|
|
HideChildren();
|
|
// Adjust Positions
|
|
_ExpandPrefix = Top - top;
|
|
_ExpandSuffix = BottomMostStepItem.Bottom - Bottom;
|
|
if (Top != top)
|
|
{
|
|
LastMethodsPush(string.Format("Colapse {0}", MyID));
|
|
_MyStepPanel.ItemMoving++;
|
|
Top = top;
|
|
_MyStepPanel.ItemMoving--;
|
|
LastMethodsPop();
|
|
}
|
|
else
|
|
AdjustLocation();
|
|
BottomMostStepItem.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)
|
|
Expand(_Type >= 20000);
|
|
Cursor.Current = tmp;
|
|
}
|
|
bool _IgnoreResize = false;
|
|
/// <summary>
|
|
/// Adjust the locations when the StepItem is resized
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void StepItem_Resize(object sender, EventArgs e)
|
|
{
|
|
if (_MyItemInfo == null) return;
|
|
if (_IgnoreResize) return;
|
|
AdjustLocation();
|
|
if (lblHeader != null) lblHeader.Width = this.Width;
|
|
}
|
|
private string WatchThisIndent
|
|
{
|
|
get { return "".PadLeft(_WatchThis, '\t'); }
|
|
}
|
|
/// <summary>
|
|
/// Handles movement of the StepItems
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void StepItem_Move(object sender, EventArgs e)
|
|
{
|
|
int watchThis = _WatchThis;
|
|
//if (MyID == _lookForID || MyID == 2111)
|
|
//{
|
|
// //vlnStackTrace.ShowStack("{0} Move TO {1} - {2}, BottomMost {3}", MyID, Top, MyPath, BottomMostStepItem.MyPath);
|
|
// Console.WriteLine("{0} Move TO {1} - {2}, BottomMost {3}", MyID, Top, MyPath, BottomMostStepItem.MyPath);
|
|
//}
|
|
//if (MyID > _StartingID)
|
|
// Console.WriteLine("{0}--------------- {1} Top = {2} Bottom {3}", WatchThisIndent, MyID, Top, Bottom);
|
|
if (_MyStepPanel.ItemMoving == 0)
|
|
{
|
|
//vlnStackTrace.ScrollInStack();
|
|
return; // If 0 - Indicates scrolling which requires no action.
|
|
}
|
|
//ShowMe("Move");
|
|
if (_MyItemInfo == null)
|
|
return;
|
|
//if (_WatchThis > 0 && MyID > _StartingID)
|
|
//{
|
|
|
|
// Console.WriteLine("{0}Start Move {1},{2}", WatchThisIndent, MyID, this);
|
|
// if (MyID == _LookForID)
|
|
// Console.WriteLine("{0}---------------", WatchThisIndent,MyID, this);
|
|
// _WatchThis++;
|
|
//}
|
|
if (MyExpandingStatus == ExpandingStatus.Expanding)
|
|
{
|
|
_WatchThis=watchThis;
|
|
return;
|
|
}
|
|
Moving = true;
|
|
StepItem tmp = (StepItem)sender;
|
|
if (tmp._MyPreviousStepItem == null && tmp._MyParentStepItem == null)
|
|
{
|
|
_WatchThis=watchThis;
|
|
return;
|
|
}
|
|
if (Visible) // Only Adjust Location if StepItem is visible
|
|
{
|
|
if (RNOBelow) // Adjust substeps first
|
|
{
|
|
//Console.WriteLine("RNOBelow");
|
|
AdjustLocation();
|
|
MoveRNO();
|
|
}
|
|
else // Adjust RNO First
|
|
{
|
|
if (RNORight)
|
|
{
|
|
//Console.WriteLine("RNORight");
|
|
MoveRNO();
|
|
}
|
|
AdjustLocation();
|
|
}
|
|
}
|
|
Moving = false;
|
|
StepItem btm = BottomMostStepItem;
|
|
if(this != btm)
|
|
btm.AdjustLocation();
|
|
//if (_WatchThis > 0 && MyID > _StartingID)
|
|
//{
|
|
// Console.WriteLine("{0}Finish Move {1},{2}",WatchThisIndent, MyID, this);
|
|
//}
|
|
_WatchThis=watchThis;
|
|
}
|
|
private bool RNOBelow
|
|
{
|
|
get
|
|
{
|
|
if (_MyRNOStepItems != null)
|
|
{
|
|
return _MyRNOStepItems[0].RNOLevel > _MyItemInfo.ColumnMode;
|
|
//return _MyRNOStepItems[0].Left == Left;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
private bool RNORight
|
|
{
|
|
get
|
|
{
|
|
if (_MyRNOStepItems != null)
|
|
{
|
|
return _MyRNOStepItems[0].RNOLevel <= _MyItemInfo.ColumnMode;
|
|
//return _MyRNOStepItems[0].Left != Left;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
private void MoveRNO()
|
|
{
|
|
if (_MyRNOStepItems != null)
|
|
{
|
|
if (_MyRNOStepItems[0].TopMostStepItem.Top != Top)
|
|
{
|
|
//if(_MyLog.IsDebugEnabled)_MyLog.DebugFormat("\r\n'Adjust RNO',{0},'Move',{1}", MyID, _RNO[0].MyID);
|
|
StepItem rnoTop = _MyRNOStepItems[0].TopMostStepItem;
|
|
if (rnoTop.RNOLevel <= _MyItemInfo.ColumnMode)
|
|
{
|
|
//StepItem tmpBottom = this;
|
|
//if (_MyAfterStepItems != null) tmpBottom = _MyAfterStepItems[_MyAfterStepItems.Count - 1].BottomMostStepItem;
|
|
_MyStepPanel.ItemMoving++;
|
|
rnoTop.LastMethodsPush(string.Format("StepItem_Move RNO Right {0}", rnoTop.MyID));
|
|
//rnoTop.Top = tmpBottom.Bottom;
|
|
rnoTop.Top = Top;
|
|
rnoTop.LastMethodsPop();
|
|
_MyStepPanel.ItemMoving--;
|
|
}
|
|
else
|
|
{
|
|
_MyStepPanel.ItemMoving++;
|
|
rnoTop.LastMethodsPush(string.Format("StepItem_Move RNO Below {0} {1} {2}", rnoTop.MyID, BottomMostStepItemNoRNOs.MyID, BottomMostStepItemNoRNOs.Bottom));
|
|
rnoTop.Top = BottomMostStepItemNoRNOs.Bottom;
|
|
rnoTop.LastMethodsPop();
|
|
_MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Handle the LinkGoTO event
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
private void _StepRTB_LinkGoTo(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
_MyLog.DebugFormat("_DisplayRTB_LinkGoTo " + args.LinkInfoText);
|
|
_MyStepPanel.OnLinkClicked(sender, args);
|
|
}
|
|
/// <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>
|
|
/// When a RichTextBox is entered, the selected StepRTB is set
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void _StepRTB_Enter(object sender, EventArgs e)
|
|
{
|
|
if (_MyStepPanel.DisplayItemChanging) return;
|
|
//vlnStackTrace.ShowStack("_StepRTB_Enter {0}",this.MyID);
|
|
_MyStepPanel.SelectedStepRTB = _MyStepRTB;
|
|
}
|
|
/// <summary>
|
|
/// Raise a OnLinkModifyTran event, when the user chooses to Modify a transition
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
private void _StepRTB_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 _StepRTB_LinkModifyRO(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
_MyStepPanel.OnLinkModifyRO(sender, args);
|
|
}
|
|
/// <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)
|
|
{
|
|
_MyStepPanel.OnAttachmentClicked(sender, new StepPanelAttachmentEventArgs(this));
|
|
}
|
|
private void _MyStepRTB_CursorKeyPress(object sender, KeyEventArgs args)
|
|
{
|
|
_MyStepPanel.StepCursorKeys(sender as StepRTB, args);
|
|
}
|
|
private void _MyStepRTB_CursorMovement(object sender, StepRTBCursorMovementEventArgs args)
|
|
{
|
|
_MyStepPanel.CursorMovement(sender as StepRTB, args.CursorLocation, args.Key);
|
|
}
|
|
private void _MyStepRTB_ModeChange(object sender, StepRTBModeChangeEventArgs args)
|
|
{
|
|
_MyStepPanel.OnModeChange(sender as StepRTB, args);
|
|
}
|
|
#endregion // Event Handlers
|
|
#region Private Methods
|
|
/// <summary>
|
|
/// Finds the last child in a list
|
|
/// </summary>
|
|
/// <param name="childStepItems"></param>
|
|
/// <returns></returns>
|
|
private static StepItem LastChild(List<StepItem> childStepItems)
|
|
{
|
|
return childStepItems[childStepItems.Count - 1];
|
|
}
|
|
/// <summary>
|
|
/// Calculate TableWidth based upon the the contents
|
|
/// </summary>
|
|
/// <param name="myFont"></param>
|
|
/// <param name="txt"></param>
|
|
/// <param name="addBorder"></param>
|
|
/// <returns></returns>
|
|
public float TableWidth(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);
|
|
}
|
|
/// <summary>
|
|
/// Calculates the table location
|
|
/// </summary>
|
|
/// <param name="myParentStepItem"></param>
|
|
/// <param name="myStepSectionLayoutData"></param>
|
|
/// <param name="width"></param>
|
|
/// <returns></returns>
|
|
public Point TableLocation(StepItem myParentStepItem, StepSectionLayoutData myStepSectionLayoutData, int width)
|
|
{
|
|
// Should center on parent unless it is a centered table in the AER column
|
|
int center = myParentStepItem.TextLeft + myParentStepItem.TextWidth / 2;
|
|
int rightLimit = myParentStepItem.Right;
|
|
// Then should center on the wid Limit
|
|
if (MyItemInfo.FormatStepData.Type.Contains("AER") == false && MyItemInfo.RNOLevel == 0)
|
|
{
|
|
int colR = _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.ColRTable, MyItemInfo.ColumnMode);
|
|
rightLimit += colR * MyItemInfo.ColumnMode;
|
|
center += (colR * MyItemInfo.ColumnMode) / 2;
|
|
center -= (myParentStepItem.TextLeft - (int)MyItemInfo.MyDocStyle.Layout.LeftMargin) / 2;
|
|
}
|
|
|
|
// Calulate the x location
|
|
//int x = myParentStepItem.TextLeft;
|
|
int x = center - width / 2;
|
|
if (x + width > rightLimit) x = rightLimit - width;
|
|
int colT = _MyStepPanel.ToDisplay(myStepSectionLayoutData.ColT);
|
|
if (x < colT) x = colT;
|
|
int y = FindTop(myParentStepItem.Bottom);
|
|
return new Point(x, y);
|
|
}
|
|
/// <summary>
|
|
/// Sets the Item and as a result the text for the RichTextBox
|
|
/// </summary>
|
|
private void SetText()
|
|
{
|
|
LastMethodsPush("SetText");
|
|
if (_MyItemInfo != null)
|
|
this._MyStepRTB.MyItemInfo = _MyItemInfo;
|
|
LastMethodsPop();
|
|
}
|
|
/// <summary>
|
|
/// If the selected StepItem is within the window leave it as it is.
|
|
/// If not, scroll so that the selected window is centered.
|
|
/// </summary>
|
|
private void ScrollToCenter()
|
|
{
|
|
//vlnStackTrace.ShowStack("CenterScroll {0} Current {1} Top {2} Bottom {3} Limit {4}", _MyItem.ItemID, _Panel.VerticalScroll.Value, Top, Bottom, _Panel.Height);// Show StackTrace
|
|
//Console.WriteLine("CenterScroll {0} Current {1} Top {2} Bottom {3} Limit {4}", _MyItem.ItemID, _Panel.VerticalScroll.Value, Top, Bottom, _Panel.Height);
|
|
if (Top >= 0 && Bottom <= _MyStepPanel.Height) return;// Don't move if within screen.
|
|
int scrollValue = _MyStepPanel.VerticalScroll.Value + (Top - (_MyStepPanel.Height / 2)); // calculate scroll center for the item
|
|
//Console.WriteLine("CenterScroll {0} Current {1} New {2} Min {3} Max {4}", _MyItem.ItemID, _Panel.VerticalScroll.Value, scrollValue, _Panel.VerticalScroll.Minimum, _Panel.VerticalScroll.Maximum);
|
|
if (scrollValue >= _MyStepPanel.VerticalScroll.Minimum && scrollValue <= _MyStepPanel.VerticalScroll.Maximum) // If it is within range
|
|
_MyStepPanel.VerticalScroll.Value = scrollValue; // Center the item
|
|
}
|
|
// TODO: the format of the circles, Checkoffs and Changebars should come from the format file
|
|
/// <summary>
|
|
/// This adds drawing items to the StepItem as needed including
|
|
/// Circle around the Tab Number
|
|
/// Check-Offs
|
|
/// Change Bars
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void StepItem_Paint(object sender, PaintEventArgs e)
|
|
{
|
|
Graphics g = e.Graphics;
|
|
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
|
|
//g.DrawString(lblTab.Text, MyItemInfo.MyTab.MyFont.WindowsFont, Brushes.Red, new RectangleF(new PointF(_MyStepPanel.MyStepPanelSettings.NumberLocationX, _MyStepPanel.MyStepPanelSettings.NumberLocationY), _MyStepPanel.MyStepPanelSettings.NumberSize), StringFormat.GenericDefault);
|
|
// adjust x location of label by 7, to position correctly.
|
|
//g.DrawString(lblTab.Text, MyItemInfo.MyTab.MyFont.WindowsFont, Brushes.Blue, new RectangleF(new PointF(Convert.ToSingle(lblTab.Location.X-7), Convert.ToSingle(lblTab.Location.Y)), _MyStepPanel.MyStepPanelSettings.NumberSize), StringFormat.GenericDefault);
|
|
//g.DrawLine(Pens.DarkGreen, lblTab.Location.X-7, 0, lblTab.Location.X-7, this.Height);
|
|
//g.DrawLine(Pens.DarkGreen, MyStepRTB.Location.X - 7, 0, MyStepRTB.Location.X - 7, this.Height);
|
|
g.DrawString(lblTab.Text, MyItemInfo.MyTab.MyFont.WindowsFont, Brushes.Black, new RectangleF(new PointF(Convert.ToSingle(lblTab.Location.X), Convert.ToSingle(lblTab.Location.Y)), _MyStepPanel.MyStepPanelSettings.NumberSize), StringFormat.GenericDefault);
|
|
//g.DrawLine(Pens.DarkGreen, lblTab.Location.X, 0, lblTab.Location.X, this.Height);
|
|
//g.DrawLine(Pens.DarkGreen, MyStepRTB.Location.X, 0, MyStepRTB.Location.X, this.Height);
|
|
if (Circle)
|
|
{
|
|
Pen penC = new Pen(_MyStepPanel.MyStepPanelSettings.CircleColor, _MyStepPanel.MyStepPanelSettings.CircleWeight);
|
|
g.DrawArc(penC, lblTab.Left + 1, 0, _MyStepPanel.MyStepPanelSettings.CircleDiameter, _MyStepPanel.MyStepPanelSettings.CircleDiameter, 0F, 360F);
|
|
}
|
|
if (CheckOff)
|
|
{
|
|
Pen penCO = new Pen(_MyStepPanel.MyStepPanelSettings.CheckOffColor, _MyStepPanel.MyStepPanelSettings.CheckOffWeight);
|
|
g.DrawRectangle(penCO, _MyStepPanel.MyStepPanelSettings.CheckOffX, _MyStepPanel.MyStepPanelSettings.CheckOffY, _MyStepPanel.MyStepPanelSettings.CheckOffSize, _MyStepPanel.MyStepPanelSettings.CheckOffSize);
|
|
}
|
|
if (ChangeBar)
|
|
{
|
|
Pen penCB = new Pen(_MyStepPanel.MyStepPanelSettings.ChangeBarColor, _MyStepPanel.MyStepPanelSettings.ChangeBarWeight);
|
|
if (ChangeBarPosition == E_ChangeBarPosition.Left)
|
|
g.DrawLine(penCB, 0, _MyStepRTB.Top, 0, Height); // left, top, right, bottom.
|
|
else
|
|
{
|
|
g.DrawLine(penCB, Width-2, _MyStepRTB.Top, Width-2, Height);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Hide a Items Children - Part of colapsing
|
|
/// </summary>
|
|
protected void HideChildren()
|
|
{
|
|
HideChildren(_MyBeforeStepItems);
|
|
HideChildren(_MyRNOStepItems);
|
|
HideChildren(_MyAfterStepItems);
|
|
}
|
|
/// <summary>
|
|
/// Hide a list of children - Part of colapsing
|
|
/// </summary>
|
|
/// <param name="childStepItems"></param>
|
|
private void HideChildren(List<StepItem> childStepItems)
|
|
{
|
|
if (childStepItems != null)
|
|
{
|
|
foreach (StepItem child in childStepItems)
|
|
{
|
|
if (child.Expanded) child.HideChildren();
|
|
child.Hidden = true;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Unhide an items Children - Part of expanding
|
|
/// </summary>
|
|
/// <param name="expand"></param>
|
|
protected void UnhideChildren(bool expand)
|
|
{
|
|
UnhideChildren(_MyBeforeStepItems, expand);
|
|
UnhideChildren(_MyRNOStepItems, expand);
|
|
UnhideChildren(_MyAfterStepItems, expand);
|
|
if (!_MyvlnExpander.Expanded)
|
|
_MyvlnExpander.ShowExpanded();
|
|
}
|
|
/// <summary>
|
|
/// Unhide a list of children - part of expanding
|
|
/// </summary>
|
|
/// <param name="childStepItems"></param>
|
|
/// <param name="expand"></param>
|
|
private void UnhideChildren(List<StepItem> childStepItems, bool expand)
|
|
{
|
|
if (childStepItems != null)
|
|
{
|
|
foreach (StepItem child in childStepItems)
|
|
{
|
|
if (child.Expanded)
|
|
child.UnhideChildren(expand);
|
|
else if (expand)
|
|
child.Expand(expand);
|
|
child.Hidden = false;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Move children as necessary
|
|
/// </summary>
|
|
protected void AdjustChildren()
|
|
{
|
|
AdjustChildren(_MyBeforeStepItems);
|
|
AdjustChildren(_MyRNOStepItems);
|
|
AdjustChildren(_MyAfterStepItems);
|
|
}
|
|
/// <summary>
|
|
/// Move a list of children
|
|
/// </summary>
|
|
/// <param name="childStepItems"></param>
|
|
private void AdjustChildren(List<StepItem> childStepItems)
|
|
{
|
|
if (childStepItems != null)
|
|
{
|
|
foreach (StepItem child in childStepItems)
|
|
{
|
|
child.AdjustLocation();
|
|
if (child.Expanded) child.AdjustChildren();
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Expand a list of children
|
|
/// </summary>
|
|
/// <param name="childStepItems"></param>
|
|
private void ExpandChildren(List<StepItem> childStepItems)
|
|
{
|
|
if (childStepItems != null)
|
|
{
|
|
foreach (StepItem child in childStepItems)
|
|
{
|
|
if (child.CanExpand)
|
|
{
|
|
child.Expand(true);
|
|
}
|
|
child.Hidden = false;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Expand children
|
|
/// </summary>
|
|
private void ExpandChildren()
|
|
{
|
|
// Walk though Children performing Expand
|
|
ExpandChildren(_MyBeforeStepItems);
|
|
ExpandChildren(_MyRNOStepItems);
|
|
ExpandChildren(_MyAfterStepItems);
|
|
}
|
|
private string MyPath
|
|
{
|
|
get
|
|
{
|
|
if (MyItemInfo.MyContent.Type >= 20000)
|
|
return MyItemInfo.Path.Substring(MyItemInfo.ActiveSection.Path.Length);
|
|
return MyItemInfo.MyContent.ToString();
|
|
}
|
|
}
|
|
private StepItem AERStepItem
|
|
{
|
|
get
|
|
{
|
|
if(RNOLevel == 0)return null;
|
|
if (MyParentStepItem != null)
|
|
{
|
|
if (MyParentStepItem.RNOLevel < RNOLevel)
|
|
return MyParentStepItem;
|
|
else
|
|
return MyParentStepItem.AERStepItem;
|
|
}
|
|
else if (MyPreviousStepItem != null)
|
|
{
|
|
return MyPreviousStepItem.AERStepItem;
|
|
}
|
|
//Volian.Base.Library.vlnStackTrace.ShowStackLocal("'AERStepItem',{0},{1}", MyID, MyItemInfo.DBSequence);
|
|
return null;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Adjust the Location of all items below the current item.
|
|
/// </summary>
|
|
internal void AdjustLocation()
|
|
{
|
|
//Console.WriteLine("'AdjustLocation',{0},{1},'{2}'", MyID, MyItemInfo.DBSequence, Volian.Base.Library.vlnStackTrace.CalledFrom4);
|
|
if (RNORight) MoveRNO(); // This is needed when an AER is Deleted that has an RNO.
|
|
if (RNOLevel > 0 && AERStepItem != null)
|
|
AERStepItem.AdjustLocation();
|
|
StepItem nextStepItem = NextDownStepItem;
|
|
//if (MyID == 2138)
|
|
// Console.WriteLine("2138");
|
|
//if (_WatchThis > 0 && MyID > _StartingID)
|
|
//if((nextStepItem == null ? 0 : nextStepItem.MyID) == MyID)
|
|
//if(_LookForID.Contains(MyID))
|
|
// Console.WriteLine("{0}AdjustLocation {1},{2},{3} -> {4},{5} ({6}) {7}", WatchThisIndent, MyID, MyItemInfo.Ordinal, MyPath,
|
|
// nextStepItem == null ? 0 : nextStepItem.MyID, nextStepItem == null ? 0 : nextStepItem.MyItemInfo.Ordinal, nextStepItem == null ? "Null" : nextStepItem.MyPath,
|
|
// _NextDownStepItemPath);
|
|
//if (_WatchThis && MyID == 2119)
|
|
// Console.WriteLine("I'm here");
|
|
//if (MyID > 2120)
|
|
// Console.WriteLine("{0}\t{1}", MyID, nextStepItem == null ? 0 : nextStepItem.MyID);
|
|
if (nextStepItem != null)
|
|
{
|
|
//int bottom = BottomMostStepItem.Bottom;
|
|
if (nextStepItem != null)
|
|
{
|
|
//if (MyID == 2123)
|
|
// _LookForID = 2123;
|
|
int bottom = nextStepItem.FindTop(Bottom);
|
|
if (nextStepItem.Top != bottom)
|
|
// if (nextStepItem != null && !nextStepItem.Moving && nextStepItem.Top != bottom)
|
|
{
|
|
_MyStepPanel.ItemMoving++;
|
|
nextStepItem.LastMethodsPush(string.Format("AdjustLocation {0}",MyID));
|
|
nextStepItem._NextDownStepItemPath = _NextDownStepItemPath;
|
|
nextStepItem.Top = bottom;
|
|
nextStepItem.LastMethodsPop();
|
|
_MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("{0}** No Adjustment next = {1}, moving = {2}", WatchThisIndent, nextStepItem, nextStepItem == null ? false : nextStepItem.Moving);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Automatically expands Steps if not currently expanded
|
|
/// </summary>
|
|
internal void AutoExpand()
|
|
{
|
|
if (CanExpand && Expanded == false)// TODO: May need to do some additional checking for subsections
|
|
{
|
|
//vlnStackTrace.ShowStack(">AutoExpand ID {0} - Can {1} Expanded {2}", _MyItem.ItemID, CanExpand, Expanded);
|
|
Expand(_Type >= 20000);
|
|
//Console.WriteLine("<AutoExpand ID {0} - Can {1} Expanded {2}",_MyItem.ItemID, CanExpand, Expanded);
|
|
}
|
|
}
|
|
#endregion // Private Methods
|
|
#region Public Methods
|
|
/// <summary>
|
|
/// Sets the focus to this StepItem and positions the cursor to the begining of the string
|
|
/// </summary>
|
|
public void ItemSelect()
|
|
{
|
|
// Was getting an Error that _MyStepRTB was Disposed RHM 20101217
|
|
if (!_MyStepRTB.Disposing)
|
|
{
|
|
_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 StepItem
|
|
/// </summary>
|
|
public void ItemShow()
|
|
{
|
|
_MyStepRTB.Focus();
|
|
ScrollToCenter();
|
|
}
|
|
/// <summary>
|
|
/// Expand an item and it's children
|
|
/// <para/>If the children have been loaded then just expand them
|
|
/// <para/>If not, load the children and expand their children etc.
|
|
/// </summary>
|
|
/// <param name="expand">normally equal to _Type > = 20000 (Step)</param>
|
|
public void Expand(bool expand)
|
|
{
|
|
//// TIMING: DisplayItem.TimeIt("Expand Start");
|
|
if (_ChildrenLoaded)
|
|
{
|
|
// Unhide Children
|
|
MyExpandingStatus = ExpandingStatus.Showing;
|
|
UnhideChildren(expand);
|
|
if (_ExpandPrefix != 0)
|
|
{
|
|
_MyStepPanel.ItemMoving++;
|
|
TopMostStepItem.Top = Top;
|
|
_MyStepPanel.ItemMoving--;
|
|
}
|
|
else
|
|
TopMostStepItem.AdjustLocation();
|
|
AdjustChildren();
|
|
//if(_Before != null )
|
|
// Top = _Before[_Before.Count - 1].BottomMost.Bottom;
|
|
}
|
|
else
|
|
{
|
|
MyExpandingStatus = ExpandingStatus.Expanding;
|
|
_ChildrenLoaded = true;
|
|
//_Panel.SuspendLayout();
|
|
AddChildBefore(MyItemInfo.Cautions, expand);
|
|
AddChildBefore(MyItemInfo.Notes, expand);
|
|
AddChildAfter(MyItemInfo.Procedures, expand);
|
|
AddChildAfter(MyItemInfo.Sections, expand);
|
|
if (MyItemInfo.RNOs != null && MyItemInfo.RNOLevel < MyItemInfo.ColumnMode)
|
|
AddChildRNO(MyItemInfo.RNOs, expand);
|
|
AddChildAfter(MyItemInfo.Tables, expand);
|
|
AddChildAfter(MyItemInfo.Steps, expand);
|
|
if (MyItemInfo.RNOs != null && MyItemInfo.RNOLevel >= MyItemInfo.ColumnMode)
|
|
AddChildRNO(MyItemInfo.RNOs, expand);
|
|
if (!_MyvlnExpander.Expanded)
|
|
_MyvlnExpander.ShowExpanded();
|
|
}
|
|
MyExpandingStatus = ExpandingStatus.Done;
|
|
BottomMostStepItem.AdjustLocation();
|
|
MyExpandingStatus = ExpandingStatus.No;
|
|
//// TIMING: DisplayItem.TimeIt("Expand End");
|
|
}
|
|
public StepItem BeforeItem
|
|
{
|
|
get
|
|
{
|
|
if (_MyAfterStepItems != null)
|
|
{
|
|
foreach (StepItem stepItem in _MyAfterStepItems)
|
|
{
|
|
if (stepItem._MyBeforeStepItems != null)
|
|
return stepItem.TopMostStepItem;
|
|
StepItem beforeItem = stepItem.BeforeItem;
|
|
if (beforeItem != null) return beforeItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
public StepItem ItemAbove
|
|
{
|
|
get
|
|
{
|
|
if (_MyChildRelation == ChildRelation.Before) return _MyParentStepItem.ItemAbove;
|
|
if (_MyPreviousStepItem != null) return _MyPreviousStepItem.BottomMostStepItem;
|
|
if (_MyChildRelation == ChildRelation.After) return _MyParentStepItem;
|
|
if (_MyChildRelation == ChildRelation.RNO) return _MyParentStepItem;
|
|
return null;
|
|
}
|
|
}
|
|
private static int? max(int? value1, int value2)
|
|
{
|
|
if (value1 == null || value2 > value1) return value2;
|
|
return value1;
|
|
}
|
|
private static int min(int value1, int value2)
|
|
{
|
|
if (value2 < value1) return value2;
|
|
return value1;
|
|
}
|
|
public int FindRight()
|
|
{
|
|
if (!RNORight) return Right;
|
|
return _MyRNOStepItems[0].FindRight();
|
|
}
|
|
public int? BottomOfParentRNO()
|
|
{
|
|
int? bottom = null;
|
|
StepItem stepItem = this;
|
|
if (!MyItemInfo.IsTablePart)
|
|
{
|
|
if (stepItem._MyChildRelation == ChildRelation.None)
|
|
return null;
|
|
if (stepItem._MyChildRelation == ChildRelation.After && !RNORight)
|
|
return null;
|
|
}
|
|
while (stepItem != null && stepItem._MyChildRelation != ChildRelation.None && stepItem._MyChildRelation != ChildRelation.After)
|
|
stepItem = stepItem.UpOneStepItem;
|
|
if (stepItem == null || stepItem._MyChildRelation == ChildRelation.None)
|
|
return null;
|
|
StepItem parent = stepItem.UpOneStepItem;
|
|
int right = FindRight();
|
|
bool centeredTable = (MyItemInfo.IsTablePart && MyItemInfo.FormatStepData.Type.Contains("AER") == false && MyItemInfo.RNOLevel == 0);
|
|
while (parent != null && parent.MyItemInfo.IsSection == false)
|
|
{
|
|
if (parent._MyRNOStepItems != null)
|
|
{
|
|
if (centeredTable || right > parent._MyRNOStepItems[0].Left)
|
|
{
|
|
if(parent._MyRNOStepItems[0].BottomMostStepItem.RNOLevel > RNOLevel && RNOLevel < _MyItemInfo.ColumnMode)
|
|
bottom = max(bottom, parent._MyRNOStepItems[0].BottomMostStepItem.Bottom);
|
|
}
|
|
}
|
|
parent = parent.UpOneStepItem;
|
|
}
|
|
return bottom;
|
|
}
|
|
private string _NextDownStepItemPath = "None";
|
|
/// <summary>
|
|
/// This finds the next StepItem down.
|
|
/// </summary>
|
|
public StepItem NextDownStepItem
|
|
{
|
|
get
|
|
{
|
|
StepItem stepItem = this;
|
|
_NextDownStepItemPath = "Path 1";
|
|
// If this item appears before it's parent, and it doesn't have anything below it, return the parent
|
|
if (MyNextStepItem == null && MyAfterStepItems == null && FirstSiblingStepItem._MyChildRelation == ChildRelation.Before)
|
|
return UpOneStepItem;
|
|
_NextDownStepItemPath = "Path 2";
|
|
if (Expanded && _MyAfterStepItems != null)// check to see if there is a _After
|
|
return MyAfterStepItems[0].TopMostStepItem;// if there is, go that way
|
|
_NextDownStepItemPath = "Path 3";
|
|
if (Expanded && MyRNOStepItems != null && MyItemInfo.RNOLevel >= MyItemInfo.ColumnMode)// check to see if there is a _After
|
|
return MyRNOStepItems[0].TopMostStepItem;// if there is, go that way
|
|
while (stepItem != null && stepItem.MyNextStepItem == null) // if no Next walk up the parent path
|
|
{
|
|
bool lastWasRNO = (stepItem._MyChildRelation == ChildRelation.RNO);
|
|
stepItem = stepItem.UpOneStepItem;
|
|
_NextDownStepItemPath = "Path 4";
|
|
if (stepItem == null) // No Parent
|
|
return null;
|
|
_NextDownStepItemPath = string.Format("Path 5 {0}, {1}",stepItem.MyExpandingStatus,stepItem.Moving);
|
|
if (stepItem.MyExpandingStatus == ExpandingStatus.Expanding || stepItem.Moving) // Parent Expanding or Moving - Wait
|
|
return null;
|
|
_NextDownStepItemPath = "Path 5 RNO";
|
|
if (stepItem.RNOBelow && !Ancestor(stepItem.MyRNOStepItems[0]))
|
|
return stepItem.MyRNOStepItems[0];
|
|
_NextDownStepItemPath = "Path 6";
|
|
if (stepItem.MyNextStepItem == null && stepItem.FirstSiblingStepItem._MyChildRelation == ChildRelation.Before)
|
|
return stepItem.UpOneStepItem;
|
|
StepItem btm = stepItem.BottomMostStepItem; // Find the Bottom StepItem of this ancestor
|
|
StepItem beforeItem = stepItem.BeforeItem;
|
|
if (lastWasRNO && beforeItem != null)
|
|
{
|
|
_NextDownStepItemPath = "Path 7";
|
|
if (beforeItem.ItemAbove.Bottom > this.Bottom) return null;
|
|
_NextDownStepItemPath = "Path 8";
|
|
return beforeItem;
|
|
}
|
|
if (this != btm) // If this is not the bottom, then just adjust things with respect to the bottom
|
|
{
|
|
StepItem btmNext = btm.NextDownStepItem;
|
|
//if (stepItem.MyNextStepItem != null && stepItem.MyNextStepItem.TopMostStepItem.Top != btm.Bottom)
|
|
if (btmNext != null)
|
|
{
|
|
int bottom = btmNext.FindTop(btm.Bottom);
|
|
if(btmNext.Top != bottom)
|
|
{
|
|
_MyStepPanel.ItemMoving++;
|
|
//stepItem.MyNextStepItem.TopMostStepItem.Top = btm.Bottom;
|
|
//Console.WriteLine("{0}***Move in NextDownStepItem {1},{2} From {3} To {4}",WatchThisIndent, btmNext.MyID, btmNext, btmNext.Top, btm.Bottom);
|
|
btmNext.LastMethodsPush(string.Format("NextDownStepItem {0} {1}", MyID, stepItem.MyID));
|
|
//ShowMe(string.Format("FindTop = {0}", btmNext.FindTop(btm.Bottom)));
|
|
btmNext.Top = bottom;
|
|
btmNext.LastMethodsPop();
|
|
_MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
_NextDownStepItemPath = string.Format("Path 9 {0}",btm);
|
|
return null; // Not the bottom - don't adjust anything else
|
|
}
|
|
//else
|
|
//{
|
|
//}
|
|
}
|
|
if (stepItem != null)
|
|
{
|
|
// Need to verify that the bottom of the parents RNO does not excede the bottom of this item.
|
|
StepItem next = stepItem.MyNextStepItem.TopMostStepItem;
|
|
_NextDownStepItemPath = "Path A";
|
|
//if (Bottom >= (BottomOfParentRNO(next) ?? Bottom))
|
|
return next;// if no _After - check to see if there is a Next
|
|
//_NextDownStepItemPath = "Path B";
|
|
//return null;
|
|
}
|
|
_NextDownStepItemPath = "Path C";
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private bool Ancestor(StepItem stepItem)
|
|
{
|
|
if (MyID == stepItem.MyID) return true;
|
|
if (MyItemInfo.IsHigh) return false;
|
|
return UpOneStepItem.Ancestor(stepItem);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return _MyItemInfo == null ? base.ToString() : string.Format("{0},'{1}'", MyID, MyPath); // + "-" + MyItemInfo.MyContent.Text;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|