Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity
SourceCode/PROMS/Volian.Controls.Library/StepItem.cs
Rich 1731dbe43b Preparation to switch to ITextSharp library 
Corrected logic to process window size/movement adjustments
2009-02-06 15:52:27 +00:00

1306 lines
40 KiB
C#
Raw Blame History

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;
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
}
#endregion
public partial class StepItem : UserControl
{
#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;
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;
private bool _Loading = true;
private StepData _MyStepData;
private ItemInfo _MyItemInfo;
private static int _WidthAdjust = 3;
private string _TabFormat;
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;
int typ = (int)value.MyContent.Type;
if (typ >= 20000)
{
int stepType = typ % 10000;
_MyStepData = value.ActiveFormat.PlantFormat.FormatData.StepDataList[stepType];
}
#if(DEBUG)
// TODO: This formatting should come from the format file
if (value.MyContent.Type == 20002)
Circle = true;
if (_TabFormat == "o ")
CheckOff = true;
if ((value.ItemID % 25) == 0)
ChangeBar = true;
#endif
value.MyContent.Changed += new ContentInfoEvent(MyContent_Changed);
}
}
void MyContent_Changed(object sender)
{
// Update the text to reflect the content change
MyStepRTB.MyItemInfo=MyStepRTB.MyItemInfo; // Reset Text
// TODO: Need code to update tabs.
}
/// <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
{
_MyParentStepItem = value;
if (_MyParentStepItem != null)
{
switch (_MyChildRelation)
{
case ChildRelation.None: // Same as after
case ChildRelation.After:
// 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
ItemLocation = new Point(_MyParentStepItem.ItemLocation.X + 20, _MyParentStepItem.Bottom);
int borderWidth = _MyStepRTB.Width - _MyStepRTB.ClientRectangle.Width;
TextWidth = _WidthAdjust + borderWidth + _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.WidSTableEdit, Convert.ToInt32(_MyStepSectionLayoutData.PMode) - 1);
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);
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:
if (RNOLevel <= _MyStepPanel.MaxRNO)
{
int colR = _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.ColRTable, Convert.ToInt32(_MyStepSectionLayoutData.PMode) - 1);
if (colR - _MyParentStepItem.Width < 0) colR = _MyParentStepItem.Width + 0;
ItemLocation = new Point(_MyParentStepItem.ItemLeft + RNOLevel * colR, _MyParentStepItem.Top);
}
else
{
TextLocation = new Point(_MyParentStepItem.TextLeft, _MyParentStepItem.BottomMostStepItem.Bottom);
}
// Same size as the Parent
TabFormat = "";
TextWidth = _MyParentStepItem.TextWidth;
break;
case ChildRelation.Before:
Location = new Point(_MyParentStepItem.Left + 20, _MyParentStepItem.Top);
_MyStepPanel.ItemMoving++;
_MyParentStepItem.Top = Bottom;
_MyStepPanel.ItemMoving--;
// Could be a Caution or Note - Need to get WidT
Width = _MyStepPanel.ToDisplay(_MyStepSectionLayoutData.WidT);
break;
}
}
}
}
/// <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); }
}
/// <summary>
/// Width of the Tab and RTB
/// </summary>
public int ItemWidth
{
get { return Width - lblTab.Left; }
set
{
Width = 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>
public string TabFormat
{
get { return _TabFormat; }
set
{
_TabFormat = value;
if (_MyItemInfo != null)
{
string tabString = _TabFormat;
switch (_Type / 10000)
{
case 0: // Procedure
//// TIMING: DisplayItem.TimeIt("TabFormat Start");
tabString = _MyItemInfo.MyContent.Number.PadRight(20);
//// TIMING: DisplayItem.TimeIt("TabFormat End");
break;
case 1: // Section
//// TIMING: DisplayItem.TimeIt("TabFormat Start");
tabString = _MyItemInfo.MyContent.Number.PadRight(20);
//// TIMING: DisplayItem.TimeIt("TabFormat End");
break;
case 2: // Step
//// TIMING: DisplayItem.TimeIt("TabFormat Start");
//int ordinal = _MyItem.Ordinal;
int ordinal = Ordinal;
//// TIMING: DisplayItem.TimeIt("TabFormat End");
string alpha = AlphabeticalNumbering.Convert(ordinal);
tabString = tabString.Replace("<alpha>", alpha.ToLower());
tabString = tabString.Replace("<ALPHA>", alpha);
string roman = RomanNumeral.Convert(ordinal);
tabString = tabString.Replace("<roman>", roman.ToLower());
tabString = tabString.Replace("<ROMAN>", roman);
tabString = tabString.Replace("<number>", ordinal.ToString().PadLeft(2));
tabString = tabString.Replace("<ID>", MyID.ToString());
break;
}
lblTab.Text = tabString;
lblTab.Width = tabString.Length * 8;
_MyStepRTB.Left = lblTab.Left + lblTab.Width;// +2;
_MyStepRTB.Width = Width - _MyStepRTB.Left;
// TODO: Performance - SetToolTip();
}
}
}
/// <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;
}
}
/// <summary>
/// Sets the previous item and adjusts locations
/// </summary>
public StepItem MyPreviousStepItem
{
get { return _MyPreviousStepItem; }
set
{
_MyPreviousStepItem = value;
if (_MyPreviousStepItem != null)
{
Location = new Point(_MyPreviousStepItem.Left, _MyPreviousStepItem.BottomMostStepItem.Bottom);
Width = MyPreviousStepItem.Width;
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;
}
}
}
/// <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 + (Visible ? Height : 0);
}
}
/// <summary>
/// Bottom most child
/// </summary>
public StepItem BottomMostStepItem
{
get
{
StepItem tmpr = null; // BottomMost RNO
if ((MyExpandingStatus != ExpandingStatus.No || Expanded) && _MyRNOStepItems != null) 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 (tmpa.Bottom >= tmpr.Bottom)
return tmpa;
return tmpr;
}
}
/// <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; }
}
#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%
_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.Top = 3;
_MyStepRTB.Top = 3;
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 = lblTab.Font = myStepPanel.ProcFont;
break;
case 1: // Section
_MyStepRTB.Font = lblTab.Font = myStepPanel.SectFont;
break;
case 2: // Steps
_MyStepRTB.Font = lblTab.Font = myStepPanel.StepFont;
_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.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData;
//// TIMING: DisplayItem.TimeIt("CSLARTB _Layout");
if (myParentStepItem != null)
SeqLevel = myParentStepItem.SeqLevel + ((myChildRelation == ChildRelation.After || myChildRelation == ChildRelation.Before) && TemporaryFormat.IsSequential(itemInfo) ? 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);
break;
case ChildRelation.Before:
AddItem(myParentStepItem, ref myParentStepItem._MyBeforeStepItems);
break;
case ChildRelation.RNO:
RNOLevel = myParentStepItem.RNOLevel + 1;
AddItem(myParentStepItem, ref myParentStepItem._MyRNOStepItems);
break;
case ChildRelation.None:
break;
}
if (itemInfo != null)
{
if (myChildRelation == ChildRelation.None)
{
if (_Type == 0 && _MyStepSectionLayoutData != null)
{
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);
// 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.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;
}
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);
_Loading = false;
//// TIMING: DisplayItem.TimeIt("CSLARTB Controls Add");
}
#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)
{
if (siblingStepItems == null)
{
siblingStepItems = new List<StepItem>();
siblingStepItems.Add(this);
MyParentStepItem = parentStepItem;
}
else
{
StepItem lastChild = LastChild(siblingStepItems);
siblingStepItems.Add(this);
MyPreviousStepItem = lastChild;
}
TabFormat = TemporaryFormat.TabFormat(this);
}
/// <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 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 void AddChildAfter(ItemInfo MyItemInfo, bool expand)
{
StepItem child = new StepItem(MyItemInfo, _MyStepPanel, this, ChildRelation.After, expand);
child.RNOLevel = this.RNOLevel;
}
/// <summary>
/// Add a list of children after
/// </summary>
/// <param name="myItemInfoList"></param>
/// <param name="expand"></param>
public void AddChildAfter(ItemInfoList myItemInfoList, bool expand)
{
if (myItemInfoList != null)
foreach (ItemInfo item in myItemInfoList)
AddChildAfter(item, expand);
}
#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;
}
/// <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)
{
this.Height = _MyStepRTB.Height + 10;
}
/// <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)
{
_MyStepPanel.ItemMoving++;
Top = top;
_MyStepPanel.ItemMoving--;
}
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;
}
/// <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;
AdjustLocation();
}
/// <summary>
/// Handles movement of the StepItems
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void StepItem_Move(object sender, EventArgs e)
{
if (_MyStepPanel.ItemMoving == 0) return; // If 0 - Indicates scrolling which requires no action.
if (_MyItemInfo == null) return;
if (MyExpandingStatus == ExpandingStatus.Expanding) return;
_Moving = true;
StepItem tmp = (StepItem)sender;
if (tmp._MyPreviousStepItem == null && tmp._MyParentStepItem == null)
{
return;
}
AdjustLocation();
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);
if (RNOLevel >= _MyStepPanel.MaxRNO)
{
StepItem tmpBottom = this;
if (_MyAfterStepItems != null) tmpBottom = _MyAfterStepItems[_MyAfterStepItems.Count - 1].BottomMostStepItem;
_MyStepPanel.ItemMoving++;
_MyRNOStepItems[0].TopMostStepItem.Top = tmpBottom.Bottom;
_MyStepPanel.ItemMoving--;
}
else
{
_MyStepPanel.ItemMoving++;
_MyRNOStepItems[0].TopMostStepItem.Top = Top;
_MyStepPanel.ItemMoving--;
}
}
}
_Moving = false;
BottomMostStepItem.AdjustLocation();
}
/// <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));
}
#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 the width of the table
/// </summary>
/// <param name="myFont"></param>
/// <param name="txt"></param>
/// <returns></returns>
private float TableWidth(Font myFont, string txt)
{
string[] lines = txt.Split("\n".ToCharArray());
float max = 0;
Graphics g = this.CreateGraphics();
PointF pnt = new PointF(0, 0);
foreach (string line in lines)
{
string line2 = Regex.Replace(line, @"\\.*? ", ""); // Remove RTF Commands
SizeF siz = g.MeasureString(line2, myFont, pnt, StringFormat.GenericTypographic);
if (siz.Width + _MyStepPanel.MyStepPanelSettings.TableWidthAdjust > max) max = siz.Width + _MyStepPanel.MyStepPanelSettings.TableWidthAdjust;
}
return max;
}
/// <summary>
/// Calculates the table location
/// </summary>
/// <param name="myParentStepItem"></param>
/// <param name="myStepSectionLayoutData"></param>
/// <param name="width"></param>
/// <returns></returns>
private Point TableLocation(StepItem myParentStepItem, StepSectionLayoutData myStepSectionLayoutData, int width)
{
int x = myParentStepItem.TextLeft;
int y = myParentStepItem.Bottom;
if (x + width > myParentStepItem.Right) x = myParentStepItem.Right - width;
int colT = _MyStepPanel.ToDisplay(myStepSectionLayoutData.ColT);
if (x < colT) x = colT;
return new Point(x, y);
}
/// <summary>
/// Sets the Item and as a result the text for the RichTextBox
/// </summary>
private void SetText()
{
if (_MyItemInfo != null)
this._MyStepRTB.MyItemInfo = _MyItemInfo;
}
/// <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, _MyStepRTB.Font, Brushes.Black, new RectangleF(new PointF(_MyStepPanel.MyStepPanelSettings.NumberLocationX, _MyStepPanel.MyStepPanelSettings.NumberLocationY), _MyStepPanel.MyStepPanelSettings.NumberSize), StringFormat.GenericDefault);
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);
g.DrawLine(penCB, 0, 0, 0, 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.Visible = false;
}
}
}
/// <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.Visible = true;
}
}
}
/// <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.Visible = true;
}
}
}
/// <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 "";
}
}
/// <summary>
/// Adjust the Location of all items below the current item.
/// </summary>
private void AdjustLocation()
{
StepItem tmp = NextDownStepItem;
if (tmp == null) return;
if (tmp != null && !tmp.Moving && tmp.Top != Bottom)
{
_MyStepPanel.ItemMoving++;
tmp.Top = Bottom;
_MyStepPanel.ItemMoving--;
}
}
/// <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()
{
_MyStepRTB.Focus();
_MyStepRTB.Select(0, 0);
// 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);
AddChildAfter(MyItemInfo.Steps, expand);
AddChildAfter(MyItemInfo.Tables, expand);
AddChildRNO(MyItemInfo.RNOs, expand);
if (!_MyvlnExpander.Expanded)
_MyvlnExpander.ShowExpanded();
}
MyExpandingStatus = ExpandingStatus.Done;
BottomMostStepItem.AdjustLocation();
MyExpandingStatus = ExpandingStatus.No;
//// TIMING: DisplayItem.TimeIt("Expand End");
}
/// <summary>
/// This finds the next StepItem down.
/// </summary>
public StepItem NextDownStepItem
{
get
{
StepItem tmp = this;
if (tmp.MyNextStepItem == null && FirstSiblingStepItem._MyChildRelation == ChildRelation.Before && tmp._MyAfterStepItems == null)
return UpOneStepItem;
if (Expanded && tmp._MyAfterStepItems != null)// check to see if there is a _After
return tmp._MyAfterStepItems[0].TopMostStepItem;// if there is go that way
while (tmp != null && tmp.MyNextStepItem == null) // if no Next walk up the parent path
{
tmp = tmp.UpOneStepItem;
if (tmp == null) // No Parent
return null;
if (tmp.MyExpandingStatus == ExpandingStatus.Expanding || tmp.Moving) // Parent Expanding or Moving - Wait
return null;
if (tmp.MyNextStepItem == null && tmp.FirstSiblingStepItem._MyChildRelation == ChildRelation.Before)
return tmp.UpOneStepItem;
StepItem btm = tmp.BottomMostStepItem;
if (this != btm)
{
if (tmp.MyNextStepItem != null && tmp.MyNextStepItem.TopMostStepItem.Top != btm.Bottom)
{
_MyStepPanel.ItemMoving++;
tmp.MyNextStepItem.TopMostStepItem.Top = btm.Bottom;
_MyStepPanel.ItemMoving--;
}
return null; // Not the bottom - don't adjust anything else
}
}
if (tmp != null)
return tmp.MyNextStepItem.TopMostStepItem;// if no _After - check to see if there is a Next
return null;
}
}
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink