2aeee7fdbc
Fixed format of ToString for AnnotationAuditInfo Fixed format of ToString for ContentAuditInfo Fixed Restore if no next item Fixed ActiveParent logic after restore Added Timing logic and then Commented it Fixed Logic when there is not a NextNode Timing Debug code Update UserID when saving annotation Commented Timing Debug Created and used FixPath - StepPath Use MyItemInfo.SearchPath if Content doesn't have path Refresh Change List from Timer.Tick Added Timer for Refresh Added code to refresh ChangeBar Added and Commented timing debug Changed logic for saving ROUsages Added Closed Property that is set when the handle is destroyed Don't refresh StepRTB if it is closed
2142 lines
73 KiB
C#
2142 lines
73 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
using System.Drawing;
|
|
using System.Windows.Forms;
|
|
using System.Text.RegularExpressions;
|
|
using VEPROMS.CSLA.Library;
|
|
using Volian.Base.Library;
|
|
|
|
namespace Volian.Controls.Library
|
|
{
|
|
#region Enums
|
|
public enum ChildRelation : int
|
|
{
|
|
None = 0,
|
|
After = 1,
|
|
Before = 2,
|
|
RNO = 3
|
|
}
|
|
public enum E_ChangeBarPosition : int
|
|
{
|
|
Left = 0,
|
|
Right = 1
|
|
}
|
|
#endregion
|
|
public abstract partial class EditItem : UserControl
|
|
{
|
|
#region EditItemUnique
|
|
//private static int _EditItemUnique = 0;
|
|
//private static int EditItemUnique
|
|
//{
|
|
// get
|
|
// {
|
|
// if (_EditItemUnique == 3)
|
|
// Console.WriteLine("here");
|
|
// return ++_EditItemUnique;
|
|
// }
|
|
//}
|
|
//private int _MyEditItemUnique = EditItemUnique;
|
|
|
|
//public int MyEditItemUnique
|
|
//{
|
|
// get {return _MyEditItemUnique; }
|
|
//}
|
|
#endregion
|
|
#region Constructor
|
|
public EditItem()
|
|
{
|
|
InitializeComponent();
|
|
}
|
|
|
|
public EditItem(IContainer container)
|
|
{
|
|
container.Add(this);
|
|
InitializeComponent();
|
|
}
|
|
#endregion
|
|
#region Properties
|
|
private bool _RTBLastFocus = true;
|
|
public bool RTBLastFocus
|
|
{
|
|
get { return _RTBLastFocus; }
|
|
set { _RTBLastFocus = value; }
|
|
}
|
|
protected static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
protected ChildRelation _MyChildRelation;
|
|
public ChildRelation MyChildRelation
|
|
{
|
|
get { return _MyChildRelation; }
|
|
set { _MyChildRelation = value; }
|
|
}
|
|
protected bool _Loading = true;
|
|
protected EditItem _MyParentEditItem = null;
|
|
protected EditItem _MySectionRTBItem;
|
|
protected EditItem _MyPreviousEditItem = null;
|
|
protected EditItem _MyNextEditItem = null;
|
|
private bool _ChildrenLoaded = false;
|
|
public bool HasChildren
|
|
{
|
|
get { return _MyBeforeEditItems != null || _MyRNOEditItems != null || _MyAfterEditItems != null; }
|
|
}
|
|
internal List<EditItem> _MyBeforeEditItems;
|
|
public List<EditItem> MyBeforeEditItems
|
|
{
|
|
get { return _MyBeforeEditItems; }
|
|
set { _MyBeforeEditItems = value; }
|
|
}
|
|
internal List<EditItem> _MyAfterEditItems;
|
|
public List<EditItem> MyAfterEditItems
|
|
{
|
|
get { return _MyAfterEditItems; }
|
|
set { _MyAfterEditItems = value; }
|
|
}
|
|
internal List<EditItem> _MyRNOEditItems;
|
|
public List<EditItem> MyRNOEditItems
|
|
{
|
|
get { return _MyRNOEditItems; }
|
|
set { _MyRNOEditItems = value; }
|
|
}
|
|
private StepSectionLayoutData _MyStepSectionLayoutData;
|
|
public StepSectionLayoutData MyStepSectionLayoutData
|
|
{
|
|
get { return _MyStepSectionLayoutData; }
|
|
set { _MyStepSectionLayoutData = value; }
|
|
}
|
|
private StepData _MyStepData;
|
|
public StepData MyStepData
|
|
{
|
|
get { return _MyStepData; }
|
|
set { _MyStepData = value; }
|
|
}
|
|
private ItemInfo _MyItemInfo;
|
|
private int _ExpandPrefix = 0;
|
|
public int ExpandPrefix
|
|
{
|
|
get { return _ExpandPrefix; }
|
|
set { _ExpandPrefix = value; }
|
|
}
|
|
private int _ExpandSuffix = 0;
|
|
public int ExpandSuffix
|
|
{
|
|
get { return _ExpandSuffix; }
|
|
set { _ExpandSuffix = value; }
|
|
}
|
|
private bool _Colapsing = false;
|
|
/// <summary>
|
|
/// Gets or sets colapsing
|
|
/// </summary>
|
|
public bool Colapsing
|
|
{
|
|
get { return _Colapsing; }
|
|
set { _Colapsing = value; }
|
|
}
|
|
private bool _Moving = false;
|
|
private int _RNOLevel = 0;
|
|
private int _SeqLevel = 0;
|
|
private int _ContentType;
|
|
public int ContentType
|
|
{
|
|
get { return _ContentType; }
|
|
set { _ContentType = value; }
|
|
}
|
|
private bool _Circle = false;
|
|
private bool _CheckOff = false;
|
|
private bool _ChangeBar = false;
|
|
private StepPanel _MyStepPanel;
|
|
public StepPanel MyStepPanel
|
|
{
|
|
get { return _MyStepPanel; }
|
|
set { _MyStepPanel = value; }
|
|
}
|
|
/// <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 EditItem MySectionRTBItem
|
|
{
|
|
get
|
|
{
|
|
if (_MySectionRTBItem == null)
|
|
{
|
|
if (MyItemInfo.IsSection || MyItemInfo.IsProcedure) _MySectionRTBItem = (RTBItem)this;
|
|
else _MySectionRTBItem = _MyParentEditItem.MySectionRTBItem;
|
|
}
|
|
return _MySectionRTBItem;
|
|
}
|
|
set { _MySectionRTBItem = 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;
|
|
// Deal with changes in content data
|
|
value.MyContent.Changed += new ContentInfoEvent(MyContent_Changed);
|
|
// Deal with change in item data
|
|
value.Changed += new ItemInfoEvent(value_Changed);
|
|
value.OrdinalChanged += new ItemInfoEvent(value_OrdinalChanged);
|
|
}
|
|
}
|
|
void value_Changed(object sender)
|
|
{
|
|
ChangeBar = _MyItemInfo.HasChangeBar;
|
|
}
|
|
protected void MyContent_Changed(object sender)
|
|
{
|
|
// Update the text to reflect the content change
|
|
MyItemInfo.RefreshItemAnnotations();
|
|
ChangeBar = MyItemInfo.HasChangeBar;
|
|
RefreshContent();
|
|
}
|
|
void value_OrdinalChanged(object sender)
|
|
{
|
|
RefreshOrdinal();
|
|
}
|
|
public EditItem ActiveParent
|
|
{
|
|
get { return _MyParentEditItem != null ? _MyParentEditItem : _MyPreviousEditItem.ActiveParent; }
|
|
}
|
|
/// <summary>
|
|
/// Return the Parent EditItem
|
|
/// </summary>
|
|
private EditItem UpOneEditItem
|
|
{
|
|
get
|
|
{
|
|
EditItem tmp = this;
|
|
while (tmp != null && tmp.MyParentEditItem == null) tmp = tmp.MyPreviousEditItem;
|
|
if (tmp != null) return tmp.MyParentEditItem;
|
|
return null;
|
|
}
|
|
}
|
|
private Stack<string> _LastMethods = new Stack<string>();
|
|
//private string _LastMethod = "";
|
|
internal void LastMethodsPush(string str)
|
|
{
|
|
if(MyStepPanel != null)MyStepPanel._LastAdjust = str;
|
|
_LastMethods.Push(str);
|
|
}
|
|
internal string LastMethodsPop()
|
|
{
|
|
//MyStepPanel._LastAdjust = "";
|
|
return _LastMethods.Pop();
|
|
}
|
|
internal 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>
|
|
internal int FindTop(int bottom)
|
|
{
|
|
int lastBottomPrev = bottom; // This is necessary if the value of bottom can be negative.
|
|
if (_MyPreviousEditItem != null)
|
|
lastBottomPrev = _MyPreviousEditItem.BottomMostEditItem.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 Top of the EditItem
|
|
/// </summary>
|
|
public int ItemTop
|
|
{
|
|
get { return Top; }
|
|
set
|
|
{
|
|
MyStepPanel.ItemMoving++;
|
|
Top = value;
|
|
MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
private E_ChangeBarPosition _ChangeBarPosition = E_ChangeBarPosition.Right;
|
|
public E_ChangeBarPosition ChangeBarPosition
|
|
{
|
|
get { return _ChangeBarPosition; }
|
|
set { _ChangeBarPosition = value; }
|
|
}
|
|
/// <summary>
|
|
/// Sets the next item and adjusts the location,
|
|
/// This also sets the previous for the "next" item
|
|
/// which adjusts other locations.
|
|
/// </summary>
|
|
public EditItem MyNextEditItem
|
|
{
|
|
get { return _MyNextEditItem; }
|
|
set
|
|
{
|
|
_MyNextEditItem = value;
|
|
if (_MyNextEditItem != null)
|
|
{
|
|
if (_MyNextEditItem.MyPreviousEditItem != this)
|
|
{
|
|
_MyNextEditItem.MyPreviousEditItem = this;
|
|
MyNextEditItem.Location = new Point(Left, Bottom);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// returns the TopMostChild
|
|
/// </summary>
|
|
public EditItem TopMostEditItem
|
|
{
|
|
get
|
|
{
|
|
if (Expanded && _MyBeforeEditItems != null) return _MyBeforeEditItems[0].TopMostEditItem;
|
|
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 EditItem BottomMostEditItem
|
|
{
|
|
get
|
|
{
|
|
EditItem tmpr = null; // BottomMost RNO
|
|
//int rnoOffset = 0;
|
|
if ((MyExpandingStatus != ExpandingStatus.No || Expanded) && _MyRNOEditItems != null)
|
|
{
|
|
//rnoOffset = this.Top - _MyRNOEditItems[0].Top;
|
|
tmpr = _MyRNOEditItems[_MyRNOEditItems.Count - 1].BottomMostEditItem;
|
|
}
|
|
EditItem tmpa = this; // BottomMost After
|
|
if ((MyExpandingStatus != ExpandingStatus.No || Expanded) & _MyAfterEditItems != null)
|
|
tmpa = _MyAfterEditItems[_MyAfterEditItems.Count - 1].BottomMostEditItem;
|
|
// 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 EditItem BottomMostEditItemNoRNOs
|
|
{
|
|
get
|
|
{
|
|
EditItem tmpa = this; // BottomMost After
|
|
if ((MyExpandingStatus != ExpandingStatus.No || Expanded) & _MyAfterEditItems != null)
|
|
tmpa = _MyAfterEditItems[_MyAfterEditItems.Count - 1].BottomMostEditItem;
|
|
// return the bottom most
|
|
return tmpa;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// First sibling
|
|
/// </summary>
|
|
private EditItem FirstSiblingEditItem
|
|
{
|
|
get
|
|
{
|
|
EditItem tmp = this;
|
|
while (tmp.MyPreviousEditItem != null)
|
|
tmp = tmp.MyPreviousEditItem;
|
|
return tmp;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Last sibling
|
|
/// </summary>
|
|
private EditItem LastSiblingEditItem
|
|
{
|
|
get
|
|
{
|
|
EditItem tmp = this;
|
|
while (tmp.MyNextEditItem != null)
|
|
tmp = tmp.MyNextEditItem;
|
|
return tmp;
|
|
}
|
|
}
|
|
private ExpandingStatus _MyExpandingStatus = ExpandingStatus.No;
|
|
/// <summary>
|
|
/// Sets or Gets expanding status
|
|
/// </summary>
|
|
public ExpandingStatus MyExpandingStatus
|
|
{
|
|
get { return _MyExpandingStatus; }
|
|
set { _MyExpandingStatus = value; }
|
|
}
|
|
/// <summary>
|
|
/// Gets the ItemID from the ItemInfo
|
|
/// </summary>
|
|
public int MyID
|
|
{
|
|
get { return _MyItemInfo == null ? 0 : _MyItemInfo.ItemID; }
|
|
}
|
|
/// <summary>
|
|
/// Tracks when a EditItem 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 AddItem
|
|
/// <summary>
|
|
/// Adds an item to a list
|
|
/// </summary>
|
|
/// <param name="parentEditItem">Parent Container</param>
|
|
/// <param name="siblingEditItems">EditItem List</param>
|
|
public void AddItem(EditItem parentEditItem, ref List<EditItem> siblingEditItems, EditItem nextEditItem)
|
|
{
|
|
if (siblingEditItems == null) // Create a list of siblings
|
|
{
|
|
siblingEditItems = new List<EditItem>();
|
|
siblingEditItems.Add(this);
|
|
MyParentEditItem = parentEditItem;
|
|
}
|
|
else // Add to the existing list
|
|
{
|
|
if (nextEditItem == null) // Add to the end of the list
|
|
{
|
|
EditItem lastChild = LastChild(siblingEditItems);
|
|
siblingEditItems.Add(this);
|
|
MyPreviousEditItem = lastChild;
|
|
}
|
|
else // Add to the middle of the list before a particular item
|
|
{
|
|
EditItem prevChild = nextEditItem.MyPreviousEditItem;
|
|
EditItem parent = nextEditItem.MyParentEditItem;
|
|
siblingEditItems.Insert(siblingEditItems.IndexOf(nextEditItem), this);
|
|
MyStepPanel.ItemMoving++;
|
|
_MyNextEditItem = nextEditItem;
|
|
nextEditItem._MyPreviousEditItem = this;
|
|
MyPreviousEditItem = prevChild;// If a previous exists - this will adjust the location and width of the EditItem
|
|
nextEditItem.MyParentEditItem = null;
|
|
MyParentEditItem = parent; // If a parent exists - this will adjust the location and width of the EditItem
|
|
//nextEditItem.MyPreviousEditItem = this;
|
|
MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
if (MyItemInfo.IsCaution || MyItemInfo.IsNote)
|
|
{
|
|
EditItem prev = this;
|
|
while (prev.MyPreviousEditItem != null) prev = prev.MyPreviousEditItem;
|
|
prev.SetAllTabs();
|
|
}
|
|
else
|
|
SetAllTabs();
|
|
}
|
|
// clear tabs, clears then all so that next 'get' will calculate new.
|
|
public void SetAllTabs()
|
|
{
|
|
RefreshTab();
|
|
|
|
if (_MyAfterEditItems != null) foreach (EditItem chld in _MyAfterEditItems) chld.SetAllTabs();
|
|
if (_MyNextEditItem != null) _MyNextEditItem.SetAllTabs();
|
|
// Update the RNO tab if it exists - RHM 20100106
|
|
if (_MyRNOEditItems != null) foreach (EditItem chld in _MyRNOEditItems) chld.SetAllTabs();
|
|
}
|
|
/// <summary>
|
|
/// Add the next item to a list
|
|
/// </summary>
|
|
/// <param name="myItemInfo"></param>
|
|
/// <param name="expand"></param>
|
|
/// <returns></returns>
|
|
//public EditItem AddNext(ItemInfo myItemInfo, bool expand)
|
|
//{
|
|
// EditItem tmp = new EditItem(myItemInfo, MyStepPanel, MyParentEditItem, ChildRelation.None, expand);
|
|
// MyNextEditItem = tmp;
|
|
// return tmp;
|
|
//}
|
|
#endregion
|
|
#region RemoveItem
|
|
protected void ShowTops(string title)
|
|
{
|
|
int TopMostY = TopMostEditItem.Top;
|
|
int? TopMostParentY = (MyParentEditItem == null ? null : (int?)(MyParentEditItem.TopMostEditItem.Top));
|
|
int? ParentY = (MyParentEditItem == null ? null : (int?)(MyParentEditItem.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()
|
|
{
|
|
//Volian.Base.Library.VlnTimer _MyTimer = new VlnTimer();
|
|
BeingRemoved = true;
|
|
MyStepPanel.SelectedEditItem = null; // Unselect the item to be deleted
|
|
//ShowTops("\r\n");
|
|
int TopMostYBefore = TopMostEditItem.Top;
|
|
//_MyTimer.ActiveProcess = "DeleteItem";
|
|
EditItem newFocus = DeleteItem();
|
|
if (newFocus == null) return;
|
|
//_MyTimer.ActiveProcess = "SetFocus";
|
|
newFocus.SetFocus();
|
|
//_MyTimer.ActiveProcess = "Dispose";
|
|
Dispose();
|
|
//_MyTimer.ActiveProcess = "SetAllTabs";
|
|
newFocus.SetAllTabs();
|
|
//_MyTimer.ActiveProcess = "TopMostYAfter";
|
|
int TopMostYAfter = newFocus.TopMostEditItem.Top;
|
|
if (TopMostYAfter > TopMostYBefore)
|
|
newFocus.TopMostEditItem.Top = TopMostYBefore;
|
|
//_MyTimer.ActiveProcess = "AdjustLocation";
|
|
newFocus.AdjustLocation();
|
|
//newFocus.ShowTops("");
|
|
//_MyTimer.ShowElapsedTimes("RemoveItem");
|
|
}
|
|
public EditItem DeleteItem()
|
|
{
|
|
//Volian.Base.Library.VlnTimer _MyTimer = new VlnTimer();
|
|
//_MyTimer.ActiveProcess = "_LookupEditItems.Remove";
|
|
MyStepPanel._LookupEditItems.Remove(MyID);
|
|
EditItem newFocus = null;
|
|
int? TopMostParentY = (MyParentEditItem == null ? null : (int?)(MyParentEditItem.TopMostEditItem.Top));
|
|
int? ParentY = (MyParentEditItem == null ? null : (int?)(MyParentEditItem.Top));
|
|
try
|
|
{
|
|
//_MyTimer.ActiveProcess = "DeleteItemAndChildren";
|
|
Item.DeleteItemAndChildren(MyItemInfo);
|
|
}
|
|
catch (System.Data.SqlClient.SqlException ex)
|
|
{
|
|
HandleSqlExceptionOnDelete(ex);
|
|
return null;
|
|
}
|
|
// Remove EditItems
|
|
//_MyTimer.ActiveProcess = "RemoveFromParentsChildList";
|
|
RemoveFromParentsChildList();
|
|
//_MyTimer.ActiveProcess = "MyNextEditItem";
|
|
if (MyNextEditItem != null)
|
|
{
|
|
if (MyPreviousEditItem != null)
|
|
{
|
|
MyNextEditItem.MyPreviousEditItem = MyPreviousEditItem;
|
|
MyPreviousEditItem = null;
|
|
newFocus = MyNextEditItem;
|
|
}
|
|
else
|
|
{
|
|
MyNextEditItem.MyParentEditItem = MyParentEditItem;
|
|
MyParentEditItem = null;
|
|
MyNextEditItem.MyPreviousEditItem = null;
|
|
newFocus = MyNextEditItem;
|
|
}
|
|
// Adjust the vertical locations of all of the items below the item deleted
|
|
MyNextEditItem.TopMostEditItem.AdjustLocation();
|
|
MyNextEditItem = null;
|
|
}
|
|
else if (MyPreviousEditItem != null)
|
|
{
|
|
MyPreviousEditItem.MyNextEditItem = null;
|
|
newFocus = MyPreviousEditItem.BottomMostEditItem;
|
|
MyPreviousEditItem = null;
|
|
//Console.Write(",\"Previous\",");
|
|
}
|
|
else
|
|
{
|
|
newFocus = MyParentEditItem;
|
|
MyParentEditItem = null;
|
|
//Console.Write(",\"Parent\",");
|
|
}
|
|
//_MyTimer.ShowElapsedTimes("DeleteItem");
|
|
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
|
|
SetFocus();
|
|
}
|
|
}
|
|
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()
|
|
{
|
|
EditItem top = this;
|
|
while (top.MyPreviousEditItem != null) top = top.MyPreviousEditItem;
|
|
EditItem parentEditItem = top.MyParentEditItem;
|
|
if (parentEditItem == null) return; // No parent, nothing to remove.
|
|
if (parentEditItem.MyAfterEditItems != null && parentEditItem.MyAfterEditItems.Contains(this))
|
|
{
|
|
parentEditItem.MyAfterEditItems.Remove(this);
|
|
if (parentEditItem.MyAfterEditItems.Count == 0)
|
|
parentEditItem.MyAfterEditItems = null;
|
|
}
|
|
else if (parentEditItem.MyBeforeEditItems != null && parentEditItem.MyBeforeEditItems.Contains(this))
|
|
{
|
|
parentEditItem.MyBeforeEditItems.Remove(this);
|
|
if (parentEditItem.MyBeforeEditItems.Count == 0)
|
|
parentEditItem.MyBeforeEditItems = null;
|
|
}
|
|
else if (parentEditItem.MyRNOEditItems != null && parentEditItem.MyRNOEditItems.Contains(this))
|
|
{
|
|
parentEditItem.MyRNOEditItems.Remove(this);
|
|
if (parentEditItem.MyRNOEditItems.Count == 0)
|
|
parentEditItem.MyRNOEditItems = null;
|
|
}
|
|
if (parentEditItem.MyAfterEditItems == null && parentEditItem.MyBeforeEditItems == null && parentEditItem.MyRNOEditItems == null)
|
|
parentEditItem.CanExpand = false;
|
|
}
|
|
//private void ShowSiblings(string title)
|
|
//{
|
|
// Console.WriteLine("---{0} {1}---",title,MyID);
|
|
// EditItem top = this;
|
|
// while (top.MyPreviousEditItem != null) top = top.MyPreviousEditItem;
|
|
// do
|
|
// {
|
|
// Console.WriteLine("{0} EditItem - {1} {2}", top.MyID == MyID ? "*" : " ", top.MyID, top.MyItemInfo.MyContent.Text);
|
|
// top = top.MyNextEditItem;
|
|
// } 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)
|
|
{
|
|
EditItem child = new RTBItem(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)
|
|
{
|
|
EditItem child = new RTBItem(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 EditItem AddChildAfter(ItemInfo MyItemInfo, bool expand)
|
|
{
|
|
EditItem child = null;
|
|
//if (MyItemInfo.MyContent.ContentGridCount != 0)
|
|
if (MyItemInfo.MyContent.MyGrid != null)
|
|
child = new GridItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, expand);
|
|
else
|
|
child = new RTBItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, expand);
|
|
return child;
|
|
}
|
|
public EditItem AddChildAfter(ItemInfo MyItemInfo, EditItem nextEditItem)
|
|
{
|
|
EditItem child = null;
|
|
//if (MyItemInfo.MyContent.ContentGridCount != 0)
|
|
if (MyItemInfo.MyContent.MyGrid != null)
|
|
child = new GridItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, true, nextEditItem);
|
|
else
|
|
child = new RTBItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, true, nextEditItem);
|
|
return child;
|
|
}
|
|
public EditItem AddChildBefore(ItemInfo MyItemInfo, EditItem nextEditItem)
|
|
{
|
|
EditItem child = null;
|
|
//if (MyItemInfo.MyContent.ContentGridCount != 0)
|
|
if(MyItemInfo.MyContent.MyGrid != null)
|
|
child = new GridItem(MyItemInfo, MyStepPanel, this, ChildRelation.Before, true, nextEditItem);
|
|
else
|
|
child = new RTBItem(MyItemInfo, MyStepPanel, this, ChildRelation.Before, true, nextEditItem);
|
|
return child;
|
|
}
|
|
public EditItem AddChildRNO(ItemInfo MyItemInfo, EditItem nextEditItem)
|
|
{
|
|
// not sure about this, i.e. whether a grid can be added here.
|
|
EditItem child = null;
|
|
//if (MyItemInfo.MyContent.ContentGridCount != 0)
|
|
if (MyItemInfo.MyContent.MyGrid != null)
|
|
child = new GridItem(MyItemInfo, MyStepPanel, this, ChildRelation.RNO, true, nextEditItem);
|
|
else
|
|
child = new RTBItem(MyItemInfo, MyStepPanel, this, ChildRelation.RNO, true, nextEditItem);
|
|
return child;
|
|
}
|
|
/// <summary>
|
|
/// Adds a sibling after the current EditItem
|
|
/// </summary>
|
|
public void AddSiblingAfter()
|
|
{
|
|
AddSiblingAfter("", true);
|
|
}
|
|
public void AddSiblingAfter(string text, bool updateStatus)
|
|
{
|
|
SaveContents();
|
|
ItemInfo newItemInfo = MyItemInfo.InsertSiblingAfter(text);
|
|
DoAddSiblingAfter(newItemInfo, updateStatus);
|
|
}
|
|
public void AddSiblingAfter(int? type, bool updateStatus)
|
|
{
|
|
SaveContents();
|
|
ItemInfo newItemInfo = MyItemInfo.InsertSiblingAfter("", "", type);
|
|
DoAddSiblingAfter(newItemInfo, updateStatus);
|
|
}
|
|
private void DoAddSiblingAfter(ItemInfo newItemInfo, bool updateStatus)
|
|
{
|
|
EditItem newEditItem = null;
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newEditItem = ActiveParent.AddChildAfter(newItemInfo, MyNextEditItem);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newEditItem = ActiveParent.AddChildBefore(newItemInfo, MyNextEditItem);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newEditItem = ActiveParent.AddChildRNO(newItemInfo, MyNextEditItem);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
//EditItem newEditItem = ActiveParent.AddChildAfter(newItemInfo, );
|
|
if (updateStatus)
|
|
MyStepPanel.SelectedEditItem = newEditItem;//Update Screen
|
|
}
|
|
protected 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.
|
|
SaveContents();
|
|
ItemInfo newItemInfo = MyItemInfo.InsertSiblingBefore(text);
|
|
EditItem newEditItem = null;
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newEditItem = ActiveParent.AddChildAfter(newItemInfo, this);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newEditItem = ActiveParent.AddChildBefore(newItemInfo, this);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newEditItem = ActiveParent.AddChildRNO(newItemInfo, this);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
if (updateSelection)
|
|
MyStepPanel.SelectedEditItem = newEditItem;//Update Screen
|
|
}
|
|
public void AddChild(E_FromType fromType, int type)
|
|
{
|
|
AddChild("", fromType, type, null);
|
|
}
|
|
public void AddChild(E_FromType fromType, int type, VlnFlexGrid vfGrid)
|
|
{
|
|
AddChild("", fromType, type, vfGrid);
|
|
}
|
|
public void AddChild(string text, E_FromType fromType, int type, VlnFlexGrid vfGrid)
|
|
{
|
|
if (_MyItemInfo.IsHigh || _MyItemInfo.IsSection)
|
|
CanExpand = true;
|
|
this.Expanded = true;
|
|
_WatchThis = 1;
|
|
ItemInfo newItemInfo = MyItemInfo.InsertChild(fromType, type, text);
|
|
if (vfGrid != null)
|
|
{
|
|
string xml = vfGrid.GetXMLData();
|
|
using (Item itm = newItemInfo.Get())
|
|
{
|
|
itm.MyContent.MyGrid.Data = xml;
|
|
itm.Save();
|
|
// newItemInfo.MyContent.MyGrid.ResetContent(itm.MyContent.MyGrid); // Do I need this?
|
|
}
|
|
}
|
|
// TODO: We need to determine where this will go in the stack of children
|
|
EditItem nextItem = GetNextItem(fromType, newItemInfo);
|
|
// 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]);
|
|
EditItem newEditItem;
|
|
switch (fromType)
|
|
{
|
|
case E_FromType.Caution:
|
|
newEditItem = this.AddChildBefore(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Note:
|
|
newEditItem = this.AddChildBefore(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Procedure:
|
|
newEditItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.RNO:
|
|
newEditItem = this.AddChildRNO(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Section:
|
|
newEditItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Step:
|
|
newEditItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
case E_FromType.Table:
|
|
newEditItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
default:
|
|
newEditItem = this.AddChildAfter(newItemInfo, nextItem);
|
|
break;
|
|
}
|
|
MyStepPanel.SelectedEditItem = newEditItem;//Update Screen
|
|
}
|
|
public EditItem GetNextItem(E_FromType fromType, ItemInfo newItemInfo)
|
|
{
|
|
EditItem nextItem = null;
|
|
if (newItemInfo.NextItem != null)
|
|
nextItem = MyStepPanel.FindItem(newItemInfo.NextItem);
|
|
else if (fromType == E_FromType.Table && MyAfterEditItems != null)
|
|
nextItem = MyAfterEditItems[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]);
|
|
return nextItem;
|
|
}
|
|
/// <summary>
|
|
/// Add a list of children after
|
|
/// </summary>
|
|
/// <param name="myItemInfoList"></param>
|
|
/// <param name="expand"></param>
|
|
public EditItem AddChildAfter(ItemInfoList myItemInfoList, bool expand)
|
|
{
|
|
EditItem 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);
|
|
EditItem newEditItem = null;
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newEditItem = ActiveParent.AddChildAfter(newItemInfo, this);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newEditItem = ActiveParent.AddChildBefore(newItemInfo, this);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newEditItem = ActiveParent.AddChildRNO(newItemInfo, this);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
if (newEditItem != null) MyStepPanel.SelectedEditItem = newEditItem;//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);
|
|
EditItem newEditItem = null;
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newEditItem = ActiveParent.AddChildAfter(newItemInfo, MyNextEditItem);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newEditItem = ActiveParent.AddChildBefore(newItemInfo, MyNextEditItem);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newEditItem = ActiveParent.AddChildRNO(newItemInfo, MyNextEditItem);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
MyStepPanel.SelectedEditItem = newEditItem;//Update Screen
|
|
MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnItemPaste(this, new vlnTreeItemInfoPasteEventArgs(newItemInfo, copyStartID, ItemInfo.EAddpingPart.After, newItemInfo.MyContent.Type));
|
|
|
|
}
|
|
public EditItem 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.SelectedEditItem.Empty)
|
|
MyStepPanel.SelectedEditItem.Empty=false;
|
|
MyStepPanel.SelectedEditItem = null; // Unselect the item to be deleted
|
|
ChildRelation childRelation = _MyChildRelation;
|
|
EditItem newFocus = null;
|
|
EditItem nextEditItem = MyNextEditItem;
|
|
EditItem prevEditItem = MyPreviousEditItem;
|
|
EditItem parentEditItem = ActiveParent;
|
|
|
|
int TopMostYBefore = TopMostEditItem.Top;
|
|
int? TopMostParentY = (MyParentEditItem == null ? null : (int?)(MyParentEditItem.TopMostEditItem.Top));
|
|
int? ParentY = (MyParentEditItem == null ? null : (int?)(MyParentEditItem.Top));
|
|
ItemInfo newItemInfo = null;
|
|
try
|
|
{
|
|
newItemInfo = Item.PasteReplace(MyItemInfo, copyStartID);
|
|
}
|
|
catch (System.Data.SqlClient.SqlException ex)
|
|
{
|
|
HandleSqlExceptionOnDelete(ex);
|
|
return this;
|
|
}
|
|
// Remove the EditItem that was the replaced item.
|
|
RemoveFromParentsChildList();
|
|
|
|
if (MyNextEditItem != null)
|
|
{
|
|
if (MyPreviousEditItem != null)
|
|
{
|
|
MyNextEditItem.MyPreviousEditItem = MyPreviousEditItem;
|
|
MyPreviousEditItem = null;
|
|
}
|
|
else
|
|
{
|
|
MyNextEditItem.MyParentEditItem = MyParentEditItem;
|
|
MyParentEditItem = null;
|
|
MyNextEditItem.MyPreviousEditItem = null;
|
|
}
|
|
MyNextEditItem = null;
|
|
}
|
|
else if (MyPreviousEditItem != null)
|
|
{
|
|
MyPreviousEditItem.MyNextEditItem = null;
|
|
newFocus = MyPreviousEditItem;
|
|
MyPreviousEditItem = null;
|
|
}
|
|
else
|
|
{
|
|
newFocus = MyParentEditItem;
|
|
MyParentEditItem = null;
|
|
}
|
|
|
|
// add copied item to ui where the replaced item was.
|
|
EditItem newEditItem = null;
|
|
switch (childRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
newEditItem = parentEditItem.AddChildAfter(newItemInfo, nextEditItem);
|
|
break;
|
|
case ChildRelation.Before:
|
|
newEditItem = parentEditItem.AddChildBefore(newItemInfo, nextEditItem);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
newEditItem = parentEditItem.AddChildRNO(newItemInfo, nextEditItem);
|
|
break;
|
|
default: // Need debug
|
|
break;
|
|
}
|
|
MyStepPanel.SelectedEditItem = newEditItem; //Update Screen
|
|
MyStepPanel.MyStepTabPanel.MyDisplayTabControl.OnItemPaste(this, new vlnTreeItemInfoPasteEventArgs(newItemInfo, copyStartID, ItemInfo.EAddpingPart.Replace, newItemInfo.MyContent.Type));
|
|
return newEditItem;
|
|
}
|
|
public void IdentifyChildren(bool highlight)
|
|
{
|
|
// Highlight children of EditItem:
|
|
if (MyAfterEditItems != null)
|
|
{
|
|
foreach (EditItem sia in MyAfterEditItems)
|
|
{
|
|
sia.IdentifyMe(highlight);
|
|
sia.IdentifyChildren(highlight);
|
|
}
|
|
}
|
|
if (MyBeforeEditItems != null)
|
|
{
|
|
foreach (EditItem sib in MyBeforeEditItems)
|
|
{
|
|
sib.IdentifyMe(highlight);
|
|
sib.IdentifyChildren(highlight);
|
|
}
|
|
}
|
|
if (MyRNOEditItems != null)
|
|
{
|
|
foreach (EditItem sir in MyRNOEditItems)
|
|
{
|
|
sir.IdentifyMe(highlight);
|
|
sir.IdentifyChildren(highlight);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region Event Handlers
|
|
private string WatchThisIndent
|
|
{
|
|
get { return "".PadLeft(_WatchThis, '\t'); }
|
|
}
|
|
protected bool RNOBelow
|
|
{
|
|
get
|
|
{
|
|
if (_MyRNOEditItems != null)
|
|
{
|
|
return _MyRNOEditItems[0].RNOLevel > _MyItemInfo.ColumnMode;
|
|
//return _MyRNOEditItems[0].Left == Left;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
protected bool RNORight
|
|
{
|
|
get
|
|
{
|
|
if (_MyRNOEditItems != null)
|
|
{
|
|
return _MyRNOEditItems[0].RNOLevel <= _MyItemInfo.ColumnMode;
|
|
//return _MyRNOEditItems[0].Left != Left;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
protected void MoveRNO()
|
|
{
|
|
if (_MyRNOEditItems != null)
|
|
{
|
|
if (_MyRNOEditItems[0].TopMostEditItem.Top != Top)
|
|
{
|
|
//if(_MyLog.IsDebugEnabled)_MyLog.DebugFormat("\r\n'Adjust RNO',{0},'Move',{1}", MyID, _RNO[0].MyID);
|
|
EditItem rnoTop = _MyRNOEditItems[0].TopMostEditItem;
|
|
if (rnoTop.RNOLevel <= _MyItemInfo.ColumnMode)
|
|
{
|
|
//EditItem tmpBottom = this;
|
|
//if (_MyAfterEditItems != null) tmpBottom = _MyAfterEditItems[_MyAfterEditItems.Count - 1].BottomMostEditItem;
|
|
MyStepPanel.ItemMoving++;
|
|
rnoTop.LastMethodsPush(string.Format("EditItem_Move RNO Right {0}", rnoTop.MyID));
|
|
//rnoTop.Top = tmpBottom.Bottom;
|
|
rnoTop.Top = Top;
|
|
rnoTop.LastMethodsPop();
|
|
MyStepPanel.ItemMoving--;
|
|
}
|
|
else
|
|
{
|
|
MyStepPanel.ItemMoving++;
|
|
rnoTop.LastMethodsPush(string.Format("EditItem_Move RNO Below {0} {1} {2}", rnoTop.MyID, BottomMostEditItemNoRNOs.MyID, BottomMostEditItemNoRNOs.Bottom));
|
|
rnoTop.Top = BottomMostEditItemNoRNOs.Bottom;
|
|
rnoTop.LastMethodsPop();
|
|
MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Handles movement of the EditItems
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void EditItem_Move(object sender, EventArgs e)
|
|
{
|
|
int watchThis = _WatchThis;
|
|
//if (MyID == 136)
|
|
//{
|
|
// vlnStackTrace.ShowStack("{0} Move TO {1}", MyID, Top);
|
|
// //vlnStackTrace.ShowStack("{0} Move TO {1} - {2}, BottomMost {3}", MyID, Top, MyPath, BottomMostRTBItem.MyPath);
|
|
// //Console.WriteLine("{0} Move TO {1} - {2}, BottomMost {3}", MyID, Top, MyPath, BottomMostRTBItem.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;
|
|
EditItem tmp = (EditItem)sender;
|
|
if (tmp.MyPreviousEditItem == null && tmp.MyParentEditItem == null)
|
|
{
|
|
_WatchThis = watchThis;
|
|
return;
|
|
}
|
|
if (RNOBelow) // Adjust substeps first
|
|
{
|
|
//Console.WriteLine("RNOBelow");
|
|
AdjustLocation();
|
|
MoveRNO();
|
|
}
|
|
else // Adjust RNO First
|
|
{
|
|
if (RNORight)
|
|
{
|
|
//Console.WriteLine("RNORight");
|
|
MoveRNO();
|
|
}
|
|
AdjustLocation();
|
|
}
|
|
Moving = false;
|
|
EditItem btm = BottomMostEditItem;
|
|
if (this != btm)
|
|
btm.AdjustLocation();
|
|
//if (_WatchThis > 0 && MyID > _StartingID)
|
|
//{
|
|
// Console.WriteLine("{0}Finish Move {1},{2}",WatchThisIndent, MyID, this);
|
|
//}
|
|
_WatchThis = watchThis;
|
|
}
|
|
/// <summary>
|
|
/// Adjust the locations when the EditItem is resized
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void EditItem_Resize(object sender, EventArgs e)
|
|
{
|
|
if (MyItemInfo == null) return;
|
|
if (_IgnoreResize) return;
|
|
AdjustLocation();
|
|
HandleResize();
|
|
|
|
}
|
|
#endregion // Event Handlers
|
|
#region Private and Protected Methods
|
|
/// <summary>
|
|
/// Calculates the table location
|
|
/// </summary>
|
|
/// <param name="myParentEditItem"></param>
|
|
/// <param name="myStepSectionLayoutData"></param>
|
|
/// <param name="width"></param>
|
|
/// <returns></returns>
|
|
protected Point TableLocation(EditItem myParentEditItem, StepSectionLayoutData myStepSectionLayoutData, int width)
|
|
{
|
|
// Should center on parent unless it is a centered table in the AER column
|
|
int center = myParentEditItem.ContentLeft + myParentEditItem.ContentWidth / 2;
|
|
int rightLimit = myParentEditItem.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 -= (myParentEditItem.ContentLeft - (int)MyItemInfo.MyDocStyle.Layout.LeftMargin) / 2;
|
|
}
|
|
|
|
// Calulate the x location
|
|
//int x = myParentEditItem.TextLeft;
|
|
int x = center - width / 2;
|
|
if (x + width > rightLimit) x = rightLimit - width;
|
|
int colT = MyStepPanel.ToDisplay((int)myStepSectionLayoutData.ColT);
|
|
if (x < colT) x = colT;
|
|
int y = FindTop(myParentEditItem.Bottom);
|
|
return new Point(x, y);
|
|
}
|
|
protected void DoMouseWheel(MouseEventArgs e)
|
|
{
|
|
MyStepPanel.MouseWheel(e);
|
|
}
|
|
protected void InsertPgBrk()
|
|
{
|
|
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.btnInsPgBrk_Click(this, new EventArgs());
|
|
}
|
|
protected void OpenAnnotations()
|
|
{
|
|
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.btnAnnots_Click(this, new EventArgs());
|
|
}
|
|
protected bool CheckClipboard()
|
|
{
|
|
return (MyStepPanel.MyStepTabPanel.MyDisplayTabControl.MyCopyStep != null);
|
|
}
|
|
protected void CopyStep()
|
|
{
|
|
MyStepPanel.MyStepTabPanel.MyStepTabRibbon.DoCopyStep();
|
|
}
|
|
/// <summary>
|
|
/// Finds the last child in a list
|
|
/// </summary>
|
|
/// <param name="childEditItems"></param>
|
|
/// <returns></returns>
|
|
private static EditItem LastChild(List<EditItem> childEditItems)
|
|
{
|
|
return childEditItems[childEditItems.Count - 1];
|
|
}
|
|
/// <summary>
|
|
/// If the selected EditItem is within the window leave it as it is.
|
|
/// If not, scroll so that the selected window is centered.
|
|
/// </summary>
|
|
protected 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
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hide a Items Children - Part of colapsing
|
|
/// </summary>
|
|
protected void HideChildren()
|
|
{
|
|
HideChildren(_MyBeforeEditItems);
|
|
HideChildren(_MyRNOEditItems);
|
|
HideChildren(_MyAfterEditItems);
|
|
}
|
|
/// <summary>
|
|
/// Hide a list of children - Part of colapsing
|
|
/// </summary>
|
|
/// <param name="childEditItems"></param>
|
|
private void HideChildren(List<EditItem> childEditItems)
|
|
{
|
|
if (childEditItems != null)
|
|
{
|
|
foreach (EditItem child in childEditItems)
|
|
{
|
|
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(_MyBeforeEditItems, expand);
|
|
UnhideChildren(_MyRNOEditItems, expand);
|
|
UnhideChildren(_MyAfterEditItems, expand);
|
|
MatchExpanded();
|
|
|
|
}
|
|
/// <summary>
|
|
/// Unhide a list of children - part of expanding
|
|
/// </summary>
|
|
/// <param name="childEditItems"></param>
|
|
/// <param name="expand"></param>
|
|
private void UnhideChildren(List<EditItem> childEditItems, bool expand)
|
|
{
|
|
if (childEditItems != null)
|
|
{
|
|
foreach (EditItem child in childEditItems)
|
|
{
|
|
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(_MyBeforeEditItems);
|
|
AdjustChildren(_MyRNOEditItems);
|
|
AdjustChildren(_MyAfterEditItems);
|
|
}
|
|
/// <summary>
|
|
/// Move a list of children
|
|
/// </summary>
|
|
/// <param name="childEditItems"></param>
|
|
private void AdjustChildren(List<EditItem> childEditItems)
|
|
{
|
|
if (childEditItems != null)
|
|
{
|
|
foreach (EditItem child in childEditItems)
|
|
{
|
|
child.AdjustLocation();
|
|
if (child.Expanded) child.AdjustChildren();
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Expand a list of children
|
|
/// </summary>
|
|
/// <param name="childEditItems"></param>
|
|
private void ExpandChildren(List<EditItem> childEditItems)
|
|
{
|
|
if (childEditItems != null)
|
|
{
|
|
foreach (EditItem child in childEditItems)
|
|
{
|
|
if (child.CanExpand)
|
|
{
|
|
child.Expand(true);
|
|
}
|
|
child.Hidden = false;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Expand children
|
|
/// </summary>
|
|
private void ExpandChildren()
|
|
{
|
|
// Walk though Children performing Expand
|
|
ExpandChildren(_MyBeforeEditItems);
|
|
ExpandChildren(_MyRNOEditItems);
|
|
ExpandChildren(_MyAfterEditItems);
|
|
}
|
|
private string MyPath
|
|
{
|
|
get
|
|
{
|
|
if (MyItemInfo.MyContent.Type >= 20000)
|
|
return MyItemInfo.Path.Substring(MyItemInfo.ActiveSection.Path.Length);
|
|
return MyItemInfo.MyContent.ToString();
|
|
}
|
|
}
|
|
private EditItem AEREditItem
|
|
{
|
|
get
|
|
{
|
|
if (RNOLevel == 0) return null;
|
|
if (MyParentEditItem != null)
|
|
{
|
|
if (MyParentEditItem.RNOLevel < RNOLevel)
|
|
return MyParentEditItem;
|
|
else
|
|
return MyParentEditItem.AEREditItem;
|
|
}
|
|
else if (MyPreviousEditItem != null)
|
|
{
|
|
return MyPreviousEditItem.AEREditItem;
|
|
}
|
|
//Volian.Base.Library.vlnStackTrace.ShowStackLocal("'AEREditItem',{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 && AEREditItem != null)
|
|
AEREditItem.AdjustLocation();
|
|
EditItem nextEditItem = NextDownEditItem;
|
|
//if (MyID == 2138)
|
|
// Console.WriteLine("2138");
|
|
//if (_WatchThis > 0 && MyID > _StartingID)
|
|
//if((nextEditItem == null ? 0 : nextEditItem.MyID) == MyID)
|
|
//if(_LookForID.Contains(MyID))
|
|
// Console.WriteLine("{0}AdjustLocation {1},{2},{3} -> {4},{5} ({6}) {7}", WatchThisIndent, MyID, MyItemInfo.Ordinal, MyPath,
|
|
// nextEditItem == null ? 0 : nextEditItem.MyID, nextEditItem == null ? 0 : nextEditItem.MyItemInfo.Ordinal, nextEditItem == null ? "Null" : nextEditItem.MyPath,
|
|
// _NextDownEditItemPath);
|
|
//if (_WatchThis && MyID == 2119)
|
|
// Console.WriteLine("I'm here");
|
|
//if (MyID > 2120)
|
|
// Console.WriteLine("{0}\t{1}", MyID, nextEditItem == null ? 0 : nextEditItem.MyID);
|
|
if (nextEditItem != null)
|
|
{
|
|
//int bottom = BottomMostEditItem.Bottom;
|
|
if (nextEditItem != null)
|
|
{
|
|
//if (MyID == 2123)
|
|
// _LookForID = 2123;
|
|
int bottom = nextEditItem.FindTop(Bottom);
|
|
if (nextEditItem.Top != bottom)
|
|
// if (nextEditItem != null && !nextEditItem.Moving && nextEditItem.Top != bottom)
|
|
{
|
|
MyStepPanel.ItemMoving++;
|
|
nextEditItem.LastMethodsPush(string.Format("AdjustLocation {0}", MyID));
|
|
nextEditItem._NextDownEditItemPath = _NextDownEditItemPath;
|
|
nextEditItem.Top = bottom;
|
|
nextEditItem.LastMethodsPop();
|
|
MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("{0}** No Adjustment next = {1}, moving = {2}", WatchThisIndent, nextEditItem, nextEditItem == null ? false : nextEditItem.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(_ContentType >= 20000);
|
|
//Console.WriteLine("<AutoExpand ID {0} - Can {1} Expanded {2}",_MyItem.ItemID, CanExpand, Expanded);
|
|
}
|
|
}
|
|
#endregion // Private Methods
|
|
#region Public Methods
|
|
/// <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++;
|
|
TopMostEditItem.Top = Top;
|
|
MyStepPanel.ItemMoving--;
|
|
}
|
|
else
|
|
TopMostEditItem.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);
|
|
MatchExpanded();
|
|
}
|
|
MyExpandingStatus = ExpandingStatus.Done;
|
|
BottomMostEditItem.AdjustLocation();
|
|
MyExpandingStatus = ExpandingStatus.No;
|
|
//// TIMING: DisplayItem.TimeIt("Expand End");
|
|
}
|
|
public EditItem BeforeItem
|
|
{
|
|
get
|
|
{
|
|
if (_MyAfterEditItems != null)
|
|
{
|
|
foreach (EditItem EditItem in _MyAfterEditItems)
|
|
{
|
|
if (EditItem._MyBeforeEditItems != null)
|
|
return EditItem.TopMostEditItem;
|
|
EditItem beforeItem = EditItem.BeforeItem;
|
|
if (beforeItem != null) return beforeItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
public EditItem ItemAbove
|
|
{
|
|
get
|
|
{
|
|
if (_MyChildRelation == ChildRelation.Before) return _MyParentEditItem.ItemAbove;
|
|
if (_MyPreviousEditItem != null) return _MyPreviousEditItem.BottomMostEditItem;
|
|
if (_MyChildRelation == ChildRelation.After) return _MyParentEditItem;
|
|
if (_MyChildRelation == ChildRelation.RNO) return _MyParentEditItem;
|
|
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 _MyRNOEditItems[0].FindRight();
|
|
}
|
|
public int? BottomOfParentRNO()
|
|
{
|
|
int? bottom = null;
|
|
EditItem EditItem = this;
|
|
if (!MyItemInfo.IsTablePart)
|
|
{
|
|
if (EditItem._MyChildRelation == ChildRelation.None)
|
|
return null;
|
|
if (EditItem._MyChildRelation == ChildRelation.After && !RNORight)
|
|
return null;
|
|
}
|
|
while (EditItem != null && EditItem._MyChildRelation != ChildRelation.None && EditItem._MyChildRelation != ChildRelation.After)
|
|
EditItem = EditItem.UpOneEditItem;
|
|
if (EditItem == null || EditItem._MyChildRelation == ChildRelation.None)
|
|
return null;
|
|
EditItem parent = EditItem.UpOneEditItem;
|
|
int right = FindRight();
|
|
bool centeredTable = (MyItemInfo.IsTablePart && MyItemInfo.FormatStepData.Type.Contains("AER") == false && MyItemInfo.RNOLevel == 0);
|
|
while (parent != null && parent.MyItemInfo.IsSection == false && parent._MyChildRelation != ChildRelation.Before)
|
|
{
|
|
if (parent._MyRNOEditItems != null)
|
|
{
|
|
if (centeredTable || right > parent._MyRNOEditItems[0].Left)
|
|
{
|
|
if (parent._MyRNOEditItems[0].BottomMostEditItem.RNOLevel > RNOLevel && RNOLevel < _MyItemInfo.ColumnMode)
|
|
bottom = max(bottom, parent._MyRNOEditItems[0].BottomMostEditItem.Bottom);
|
|
}
|
|
}
|
|
parent = parent.UpOneEditItem;
|
|
}
|
|
return bottom;
|
|
}
|
|
private string _NextDownEditItemPath = "None";
|
|
/// <summary>
|
|
/// This finds the next EditItem down.
|
|
/// </summary>
|
|
public EditItem NextDownEditItem
|
|
{
|
|
get
|
|
{
|
|
EditItem EditItem = this;
|
|
_NextDownEditItemPath = "Path 1";
|
|
// If this item appears before it's parent, and it doesn't have anything below it, return the parent
|
|
if (MyNextEditItem == null && MyAfterEditItems == null && FirstSiblingEditItem._MyChildRelation == ChildRelation.Before)
|
|
return UpOneEditItem;
|
|
_NextDownEditItemPath = "Path 2";
|
|
if (Expanded && _MyAfterEditItems != null)// check to see if there is a _After
|
|
return MyAfterEditItems[0].TopMostEditItem;// if there is, go that way
|
|
_NextDownEditItemPath = "Path 3";
|
|
if (Expanded && MyRNOEditItems != null && MyItemInfo.RNOLevel >= MyItemInfo.ColumnMode)// check to see if there is a _After
|
|
return MyRNOEditItems[0].TopMostEditItem;// if there is, go that way
|
|
while (EditItem != null && EditItem.MyNextEditItem == null) // if no Next walk up the parent path
|
|
{
|
|
bool lastWasRNO = (EditItem._MyChildRelation == ChildRelation.RNO);
|
|
EditItem = EditItem.UpOneEditItem;
|
|
_NextDownEditItemPath = "Path 4";
|
|
if (EditItem == null) // No Parent
|
|
return null;
|
|
_NextDownEditItemPath = string.Format("Path 5 {0}, {1}", EditItem.MyExpandingStatus, EditItem.Moving);
|
|
if (EditItem.MyExpandingStatus == ExpandingStatus.Expanding || EditItem.Moving) // Parent Expanding or Moving - Wait
|
|
return null;
|
|
_NextDownEditItemPath = "Path 5 RNO";
|
|
if (EditItem.RNOBelow && !Ancestor(EditItem.MyRNOEditItems[0]))
|
|
return EditItem.MyRNOEditItems[0];
|
|
_NextDownEditItemPath = "Path 6";
|
|
if (EditItem.MyNextEditItem == null && EditItem.FirstSiblingEditItem._MyChildRelation == ChildRelation.Before)
|
|
return EditItem.UpOneEditItem;
|
|
EditItem btm = EditItem.BottomMostEditItem; // Find the Bottom EditItem of this ancestor
|
|
EditItem beforeItem = EditItem.BeforeItem;
|
|
if (lastWasRNO && beforeItem != null)
|
|
{
|
|
_NextDownEditItemPath = "Path 7";
|
|
if (beforeItem.ItemAbove.Bottom > this.Bottom) return null;
|
|
_NextDownEditItemPath = "Path 8";
|
|
return beforeItem;
|
|
}
|
|
if (this != btm) // If this is not the bottom, then just adjust things with respect to the bottom
|
|
{
|
|
EditItem btmNext = btm.NextDownEditItem;
|
|
//if (EditItem.MyNextEditItem != null && EditItem.MyNextEditItem.TopMostEditItem.Top != btm.Bottom)
|
|
if (btmNext != null)
|
|
{
|
|
int bottom = btmNext.FindTop(btm.Bottom);
|
|
if (btmNext.Top != bottom)
|
|
{
|
|
MyStepPanel.ItemMoving++;
|
|
//EditItem.MyNextEditItem.TopMostEditItem.Top = btm.Bottom;
|
|
//Console.WriteLine("{0}***Move in NextDownEditItem {1},{2} From {3} To {4}",WatchThisIndent, btmNext.MyID, btmNext, btmNext.Top, btm.Bottom);
|
|
btmNext.LastMethodsPush(string.Format("NextDownEditItem {0} {1}", MyID, EditItem.MyID));
|
|
//ShowMe(string.Format("FindTop = {0}", btmNext.FindTop(btm.Bottom)));
|
|
btmNext.Top = bottom;
|
|
btmNext.LastMethodsPop();
|
|
MyStepPanel.ItemMoving--;
|
|
}
|
|
}
|
|
_NextDownEditItemPath = string.Format("Path 9 {0}", btm);
|
|
return null; // Not the bottom - don't adjust anything else
|
|
}
|
|
//else
|
|
//{
|
|
//}
|
|
}
|
|
if (EditItem != null)
|
|
{
|
|
// Need to verify that the bottom of the parents RNO does not excede the bottom of this item.
|
|
EditItem next = EditItem.MyNextEditItem.TopMostEditItem;
|
|
_NextDownEditItemPath = "Path A";
|
|
//if (Bottom >= (BottomOfParentRNO(next) ?? Bottom))
|
|
return next;// if no _After - check to see if there is a Next
|
|
//_NextDownEditItemPath = "Path B";
|
|
//return null;
|
|
}
|
|
_NextDownEditItemPath = "Path C";
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private bool Ancestor(EditItem EditItem)
|
|
{
|
|
if (MyID == EditItem.MyID) return true;
|
|
if (MyItemInfo.IsHigh) return false;
|
|
return UpOneEditItem.Ancestor(EditItem);
|
|
}
|
|
public override string ToString()
|
|
{
|
|
return _MyItemInfo == null ? base.ToString() : string.Format("{0},'{1}'", MyID, MyPath); // + "-" + MyItemInfo.MyContent.Text;
|
|
}
|
|
#endregion
|
|
#region Abstract Methods and Properties
|
|
public abstract int TableWidth { get; }
|
|
public abstract int BorderWidth { get; }
|
|
public abstract Point ContentLocation { get; set; }
|
|
public abstract string TabFormat { get; set; }
|
|
public abstract void AdjustTableWidthAndLocation();
|
|
public abstract void SetToolTip(string tip);
|
|
public abstract void RefreshContent();
|
|
//public abstract EditItem MyPreviousEditItem { get; set; }
|
|
public abstract int ItemLeft { get; set; }
|
|
public abstract int ContentLeft { get; }
|
|
public abstract int ContentWidth { get; set; }
|
|
public abstract Point ItemLocation { get; set; }
|
|
public abstract int ItemWidth { get; set; }
|
|
public abstract void RefreshOrdinal();
|
|
public abstract bool Expanded { get; set; }
|
|
public abstract void RefreshTab();
|
|
public abstract void SetFocus();
|
|
public abstract void SaveContents();
|
|
public abstract bool CanExpand { get; set; }
|
|
public abstract void HandleResize();
|
|
public abstract void MatchExpanded();
|
|
public abstract void ItemSelect();
|
|
public abstract void ItemShow();
|
|
public abstract StepRTB MyStepRTB { get; }
|
|
public abstract DialogResult ReplaceText(string rpltxt, string fndstr, bool caseSensitive, bool matchWholeWord, bool reverse, bool prompt, IWin32Window fndrpldlg);
|
|
public abstract bool FindText(string str, bool caseSensitive, bool matchWholeWord, bool reverse);
|
|
public abstract void PositionToEnd();
|
|
public abstract void PositionToStart();
|
|
public abstract string SelectedTextForFind { get;}
|
|
public abstract bool SpellCheckNext();
|
|
public abstract void IdentifyMe(bool highlight);
|
|
public abstract void SetActive();
|
|
public abstract bool Empty { get; set; }
|
|
//public abstract bool IsEmpty();
|
|
//public abstract void MakeNotEmpty();
|
|
public abstract void RefreshDisplay(bool activeMode);
|
|
public abstract void ToggleEditView(E_ViewMode vwMode);
|
|
public abstract int TabLeft { get; set; }
|
|
public abstract Font TabFont { get; set; }
|
|
public abstract string TabText { get; }
|
|
public abstract Point TabLocation { get; }
|
|
public abstract Font ContentFont { get; set; }
|
|
public abstract float ContentTop { get; }
|
|
public abstract void SetupHeader(ItemInfo itemInfo);
|
|
public abstract void ShowExpanded();
|
|
public abstract void SetText();
|
|
public abstract void SetExpandAndExpander(ItemInfo itemInfo);
|
|
public abstract void SaveCurrentAndContents();
|
|
#endregion
|
|
protected string _TabFormat;
|
|
private static int _WidthAdjust = 3;
|
|
protected bool _IgnoreResize = false;
|
|
/// <summary>
|
|
/// Sets the parent and postions the item with respect to the parent
|
|
/// </summary>
|
|
public EditItem MyParentEditItem
|
|
{
|
|
get { return _MyParentEditItem; }
|
|
set
|
|
{
|
|
LastMethodsPush("set_MyParentRTBItem");
|
|
_MyParentEditItem = value;
|
|
if (_MyParentEditItem != 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)_MyParentEditItem.ContentType;
|
|
|
|
switch (iType / 10000)
|
|
{
|
|
case 0: // Procedure
|
|
ItemLocation = new Point(_MyParentEditItem.ItemLocation.X + 20, _MyParentEditItem.Bottom);
|
|
ItemWidth = MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColT) + MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidT);
|
|
break;
|
|
case 1: // Section
|
|
if (this == TopMostEditItem)
|
|
ItemLocation = new Point(_MyParentEditItem.ItemLocation.X + 20, _MyParentEditItem.Bottom);
|
|
else
|
|
TopMostEditItem.ItemLocation = new Point(TopMostEditItem.ItemLocation.X, _MyParentEditItem.Bottom);
|
|
//TextWidth = _WidthAdjust + borderWidth + MyStepPanel.ToDisplay(_MyStepSectionLayoutData.WidSTableEdit, Convert.ToInt32(_MyStepSectionLayoutData.PMode) - 1);
|
|
ContentWidth = _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")
|
|
{
|
|
AdjustTableWidthAndLocation();
|
|
}
|
|
else
|
|
{
|
|
ItemLocation = new Point(_MyParentEditItem.ContentLeft, _MyParentEditItem.Bottom);
|
|
ItemWidth = _MyParentEditItem.ContentWidth;
|
|
}
|
|
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;
|
|
ContentWidth = _MyParentEditItem.ContentWidth;
|
|
_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 - _MyParentEditItem.Width < 0) colR = _MyParentEditItem.Width + 0;
|
|
MyStepPanel.ItemMoving++;
|
|
//Left = _MyParentRTBItem.ItemLeft + RNOLevel * colR;
|
|
//ItemLocation = new Point(_MyParentRTBItem.ItemLeft + RNOLevel * colR, _MyParentRTBItem.Top);
|
|
LastMethodsPush(string.Format("set_MyParentRTBItem RNO Right {0}", MyID));
|
|
ItemLocation = new Point(_MyParentEditItem.ItemLeft + RNOLevel * colR, _MyParentEditItem.Top);
|
|
int top = _MyParentEditItem.FindTop(_MyParentEditItem.Top);
|
|
if (top != _MyParentEditItem.Top)
|
|
{
|
|
_MyParentEditItem.LastMethodsPush(string.Format("set_MyParentRTBItem RNO Right {0}", MyID));
|
|
_MyParentEditItem.Top = top;
|
|
_MyParentEditItem.LastMethodsPop();
|
|
Top = top;
|
|
}
|
|
LastMethodsPop();
|
|
MyStepPanel.ItemMoving--;
|
|
}
|
|
else
|
|
{
|
|
MyStepPanel.ItemMoving++;
|
|
LastMethodsPush(string.Format("set_MyParentRTBItem RNO Below {0} {1} {2}", MyID, _MyParentEditItem.BottomMostEditItem.MyID, _MyParentEditItem.BottomMostEditItem.Bottom));
|
|
ContentLocation = new Point(_MyParentEditItem.ContentLeft, _MyParentEditItem.BottomMostEditItem.Bottom);
|
|
LastMethodsPop();
|
|
//TextLocation = new Point(_MyParentRTBItem.TextLeft, FindTop(_MyParentRTBItem.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}", _MyParentRTBItem.MyID, _MyParentRTBItem
|
|
// ,_MyParentRTBItem.TopMostRTBItem.MyID,_MyParentRTBItem.TopMostRTBItem
|
|
// , _MyNextRTBItem == null ? 0 : _MyNextRTBItem.MyID, _MyNextRTBItem == null ? "None" : _MyNextRTBItem.ToString());
|
|
|
|
//Location = new Point(_MyParentRTBItem.Left + 20, max(_MyParentRTBItem.Top, (_MyNextRTBItem == null ? 0 : _MyNextRTBItem.Top )) ?? 0);
|
|
_IgnoreResize = true;
|
|
Width = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidT);
|
|
_IgnoreResize = false;
|
|
MyStepPanel.ItemMoving++;
|
|
//Location = new Point(_MyParentRTBItem.Left + 20, FindTop(_MyParentRTBItem.Top));
|
|
int myTop = MyNextEditItem == null ? _MyParentEditItem.Top : MyNextEditItem.Top;
|
|
Location = new Point(_MyParentEditItem.Left + 20, FindTop(myTop));
|
|
MyStepPanel.ItemMoving--;
|
|
//_MyParentRTBItem.Top = Bottom;
|
|
// Could be a Caution or Note - Need to get WidT
|
|
break;
|
|
}
|
|
}
|
|
LastMethodsPop();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Sets the previous item and adjusts locations
|
|
/// </summary>
|
|
public /*override*/ EditItem MyPreviousEditItem
|
|
{
|
|
get { return _MyPreviousEditItem; }
|
|
set
|
|
{
|
|
LastMethodsPush("set_MyPreviousRTBItem");
|
|
_MyPreviousEditItem = value;
|
|
if (_MyPreviousEditItem != null)
|
|
{
|
|
_IgnoreResize = true;
|
|
if (MyStepData != null && (MyStepData.Type.ToLower().Contains("table") || MyStepData.ParentType.ToLower().Contains("table")))
|
|
{
|
|
ItemWidth = TableWidth;
|
|
Location = new Point(_MyPreviousEditItem.Left, FindTop(_MyPreviousEditItem.BottomMostEditItem.Bottom));
|
|
}
|
|
else if (value.MyItemInfo.IsTablePart)
|
|
{
|
|
ItemLocation = new Point(value.MyParentEditItem.ContentLeft, value.MyParentEditItem.Bottom);
|
|
ItemWidth = value.MyParentEditItem.ContentWidth;
|
|
}
|
|
else
|
|
{
|
|
Width = MyPreviousEditItem.Width;
|
|
if (TopMostEditItem == this)
|
|
Location = new Point(_MyPreviousEditItem.Left, FindTop(_MyPreviousEditItem.BottomMostEditItem.Bottom));
|
|
else
|
|
TopMostEditItem.Location = new Point(TopMostEditItem.Left, FindTop(_MyPreviousEditItem.BottomMostEditItem.Bottom));
|
|
}
|
|
_IgnoreResize = false;
|
|
//ShowMe("");
|
|
//if (MyID > _StartingID)
|
|
// Console.WriteLine("{0}-->Setting MyPreviousRTBItem {1},{2},{3},{4},{5},{6},{7}", WatchThisIndent, MyID, this
|
|
// , _MyPreviousRTBItem
|
|
// ,Top
|
|
// , _MyPreviousRTBItem.BottomMostRTBItem.Bottom
|
|
// , FindTop(_MyPreviousRTBItem.BottomMostRTBItem.Bottom)
|
|
// , _MyPreviousRTBItem.Bottom);
|
|
//Location = new Point(_MyPreviousRTBItem.Left, _MyPreviousRTBItem.BottomMostRTBItem.Bottom);
|
|
switch (_MyChildRelation)
|
|
{
|
|
case ChildRelation.None:
|
|
break;
|
|
case ChildRelation.After:
|
|
break;
|
|
case ChildRelation.RNO:
|
|
break;
|
|
case ChildRelation.Before:
|
|
//MyStepPanel.ItemMoving++;
|
|
//UpOneRTBItem.Top = BottomMostRTBItem.Bottom;
|
|
//MyStepPanel.ItemMoving--;
|
|
break;
|
|
}
|
|
if (_MyPreviousEditItem.MyNextEditItem != this) _MyPreviousEditItem.MyNextEditItem = this;
|
|
}
|
|
LastMethodsPop();
|
|
}
|
|
}
|
|
protected void SetupEditItem(ItemInfo itemInfo, StepPanel myStepPanel, EditItem myParentEditItem, ChildRelation myChildRelation, bool expand, EditItem nextEditItem)
|
|
{
|
|
//if (itemInfo.ItemID == 10366) Console.WriteLine("Here");
|
|
//if (itemInfo.ItemID == 225) _MyStepRTB.Resize += new EventHandler(_MyStepRTB_Resize);
|
|
//_MyStepRTB.MyRTBItem = this;
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB InitComp");
|
|
BackColor = myStepPanel.PanelColor;
|
|
//_MyStepRTB.BackColor = myStepPanel.InactiveColor;
|
|
// TODO: Adjust top based upon format
|
|
// TODO: Remove Label and just output ident on the paint event
|
|
TabLeft = 20;
|
|
SetupHeader(itemInfo);
|
|
this.Paint += new PaintEventHandler(EditItem_Paint);
|
|
this.BackColorChanged += new EventHandler(EditItem_BackColorChanged);
|
|
this.Move += new EventHandler(EditItem_Move);
|
|
this.Resize += new EventHandler(EditItem_Resize);
|
|
if (itemInfo != null)
|
|
{
|
|
ContentType = (int)itemInfo.MyContent.Type;
|
|
switch (ContentType / 10000)
|
|
{
|
|
case 0: // Procedure
|
|
ContentFont = myStepPanel.ProcFont;// lblTab.Font = myStepPanel.ProcFont;
|
|
TabFont = itemInfo.MyTab.MyFont.WindowsFont;
|
|
break;
|
|
case 1: // Section
|
|
ContentFont = myStepPanel.SectFont;// lblTab.Font = myStepPanel.SectFont;
|
|
TabFont = itemInfo.MyTab.MyFont.WindowsFont;
|
|
break;
|
|
case 2: // Steps
|
|
ContentFont = myStepPanel.StepFont;//lblTab.Font = myStepPanel.StepFont;
|
|
TabFont = itemInfo.MyTab.MyFont.WindowsFont;
|
|
MyStepData = itemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList[ContentType % 10000];
|
|
break;
|
|
}
|
|
//this.Move += new EventHandler(DisplayItem_Move);
|
|
}
|
|
else
|
|
{
|
|
if (myStepPanel.MyFont != null) ContentFont = TabFont = myStepPanel.MyFont;
|
|
}
|
|
if (expand) ShowExpanded();
|
|
MyStepPanel = myStepPanel;
|
|
if (itemInfo != null && !myStepPanel._LookupEditItems.ContainsKey(itemInfo.ItemID)) myStepPanel._LookupEditItems.Add(itemInfo.ItemID, this);
|
|
_MyChildRelation = myChildRelation;
|
|
if (myParentEditItem != null) RNOLevel = myParentEditItem.RNOLevel;
|
|
if (itemInfo != null)
|
|
{
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB before _Layout");
|
|
MyStepSectionLayoutData = itemInfo.ActiveFormat.MyStepSectionLayoutData;
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB _Layout");
|
|
if (myParentEditItem != null)
|
|
SeqLevel = myParentEditItem.SeqLevel + ((myChildRelation == ChildRelation.After || myChildRelation == ChildRelation.Before) && itemInfo.IsSequential ? 1 : 0);
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB seqLevel");
|
|
MyItemInfo = itemInfo;
|
|
MyItemInfo.MyConfig.PropertyChanged += new PropertyChangedEventHandler(MyConfig_PropertyChanged);
|
|
}
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB MyItem");
|
|
myStepPanel.Controls.Add(this);
|
|
|
|
switch (myChildRelation)
|
|
{
|
|
case ChildRelation.After:
|
|
AddItem(myParentEditItem, ref myParentEditItem._MyAfterEditItems, nextEditItem);
|
|
break;
|
|
case ChildRelation.Before:
|
|
AddItem(myParentEditItem, ref myParentEditItem._MyBeforeEditItems, nextEditItem);
|
|
break;
|
|
case ChildRelation.RNO:
|
|
RNOLevel = myParentEditItem.RNOLevel + 1;
|
|
AddItem(myParentEditItem, ref myParentEditItem._MyRNOEditItems, nextEditItem);
|
|
break;
|
|
case ChildRelation.None:
|
|
break;
|
|
}
|
|
if (itemInfo != null)
|
|
{
|
|
if (myChildRelation == ChildRelation.None)
|
|
{
|
|
if (ContentType == 0 && MyStepSectionLayoutData != null)
|
|
{
|
|
LastMethodsPush(string.Format("SetupRTBItem {0}", MyID));
|
|
Width = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidT);
|
|
}
|
|
}
|
|
}
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB Parent");
|
|
SetText();
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB SetText");
|
|
if (itemInfo != null)
|
|
{
|
|
Name = string.Format("Item-{0}", itemInfo.ItemID);
|
|
SetExpandAndExpander(itemInfo);
|
|
if (expand && (itemInfo.MyContent.ContentPartCount != 0)) // If it should expand and it can expand
|
|
Expand(true);
|
|
else
|
|
if (myParentEditItem == null)// If it is the top node
|
|
if (ContentType >= 20000) // and it is a step - fully expand
|
|
Expand(true);
|
|
else // otherwise only expand one level
|
|
Expand(false);
|
|
}
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB before Controls Add");
|
|
//myStepPanel.Controls.Add(this);
|
|
int top = FindTop(0);
|
|
if (Top < top)
|
|
{
|
|
LastMethodsPush("SetupRTBItem");
|
|
MyStepPanel.ItemMoving++;
|
|
Top = top;
|
|
MyStepPanel.ItemMoving--;
|
|
LastMethodsPop();
|
|
}
|
|
_Loading = false;
|
|
//// TIMING: DisplayItem.TimeIt("CSLARTB Controls Add");
|
|
}
|
|
void MyConfig_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
SaveConfig();
|
|
}
|
|
public void SaveConfig()
|
|
{
|
|
if (!MyItemInfo.MyConfig.IsDirty) return;
|
|
using (Item itm = MyItemInfo.Get())
|
|
{
|
|
itm.MyContent.Config = MyItemInfo.MyConfig.ToString();
|
|
itm.Save();
|
|
}
|
|
MyItemInfo.MyConfig.IsDirty = false;
|
|
}
|
|
/// <summary>
|
|
/// If the background changes, change the background of the RichTextBox
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void EditItem_BackColorChanged(object sender, EventArgs e)
|
|
{
|
|
//IdentifyMe(false);
|
|
}
|
|
// TODO: the format of the circles, Checkoffs and Changebars should come from the format file
|
|
/// <summary>
|
|
/// This adds drawing items to the RTBItem as needed including
|
|
/// Circle around the Tab Number
|
|
/// Check-Offs
|
|
/// Change Bars
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void EditItem_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(TabText, MyItemInfo.MyTab.MyFont.WindowsFont, Brushes.Black, new RectangleF(new PointF(Convert.ToSingle(TabLocation.X), Convert.ToSingle(TabLocation.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, TabLeft + 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, ContentTop, 0, Height); // left, top, right, bottom.
|
|
else
|
|
{
|
|
g.DrawLine(penCB, Width - 2, ContentTop, Width - 2, Height);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|