SourceCode/PROMS/Volian.Controls.Library/EditItem.cs.org

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; using JR.Utils.GUI.Forms;

namespace Volian.Controls.Library { #region Enums public enum ChildRelation : int { None = 0, After = 1, Before = 2, RNO = 3, SupInfo = 4 } 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(); this.Enter += EditItem_Enter; }

// This event was added to better control enabling or disabling of the Insert and Copy Step buttons on the ribbon void EditItem_Enter(object sender, EventArgs e) { bool allow = (MyStepPanel.VwMode == E_ViewMode.Edit); StepTabRibbon str = MyStepPanel.MyStepTabPanel.MyStepTabRibbon; str.SiblingsButtonsEnabled = allow; str.InsertButtonsEnabled = allow && !(MyItemInfo.IsProcedure || MyItemInfo.IsSection || MyItemInfo.IsRNOPart || MyItemInfo.IsSupInfoPart); // do special case for cpystep button: cannot copy an enhanced step: if (MyItemInfo.IsEnhancedStep) str.SetCopyStepButton(false); }

public EditItem(IContainer container) { container.Add(this); InitializeComponent(); this.Enter += EditItem_Enter; } #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 // MyBeforeEditItems are Cautions & Notes { 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; } } internal List<EditItem> _MySupInfoEditItems; public List<EditItem> MySupInfoEditItems { get { return _MySupInfoEditItems; } set { _MySupInfoEditItems = 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 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 _UserCheckOff = false; private bool _ChangeBar = false; private StepPanel _MyStepPanel; public StepPanel MyStepPanel { get { return _MyStepPanel; } set { _MyStepPanel = value; } }

private DisplayTags _MyStepPropertiesPanel; public DisplayTags MyStepPropertiesPanel // gives us access to the Step Properties panel - used with shortcut keystrokes { get { return _MyStepPropertiesPanel; } set { _MyStepPropertiesPanel = 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 = MyParent.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; CheckOff co = _MyItemInfo.GetCheckOffStep(); if (co != null && co.UIMark != null) { UserCheckOff = true; UserCheckOffChar = (char)co.UIMark; } // Deal with changes in content data value.MyContent.Changed += new ContentInfoEvent(MyContent_Changed); value.MyProcedure.MyContent.Changed += new ContentInfoEvent(MyContent_Changed); // Deal with change in item data value.Changed += new ItemInfoEvent(value_Changed); value.OrdinalChanged += new ItemInfoEvent(value_OrdinalChanged); // do something like this to draw circle around step numbers - note got NULL reference error on NSP data //if (value.FormatStepData != null && value.FormatStepData.TabData.IdentPrint.Contains("C0")) Circle = true; } } private bool _ChangeBarForConfigItemChange = true;

public bool ChangeBarForConfigItemChange { get { return _ChangeBarForConfigItemChange; } set { _ChangeBarForConfigItemChange = value; } }

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; CheckOff co = _MyItemInfo.GetCheckOffStep(); if (co != null && co.UIMark != null) { UserCheckOff = true; UserCheckOffChar = (char)co.UIMark; } else UserCheckOff = false; RefreshContent();

/ see if change in subsections to be displayed, i.e. if the user made a change to editable data / on the section properties form, we may have to display steps or remove steps. By design, / steps are the first children from a section. Also, this will only occur if the format has / metasections AND there are subsections. if (MyItemInfo.IsSection && MyItemInfo.ActiveFormat.PlantFormat.FormatData.SectData.UseMetaSections && MyItemInfo.Sections != null && MyItemInfo.Sections.Count > 0) { // find out what the editable flag is to determine if change. bool showSteps = MyItemInfo.MyConfig is SectionConfig && (MyItemInfo.MyConfig as SectionConfig).SubSection_Edit = "Y"; if (showSteps && _MyAfterEditItems ! null && _MyAfterEditItems.Count > 0 && _MyAfterEditItems[0].MyItemInfo.IsSection) { // need to add steps in, i.e. they do not exist in step editor yet. _MyAfterEditItems[0].AddSiblingBeforeNoDataSave(MyItemInfo.Steps, false); } else if (!showSteps && _MyAfterEditItems != null && _MyAfterEditItems.Count > 0 && _MyAfterEditItems[0].MyItemInfo.IsStep) { // Remove steps - only want sections. Put in a list for removal. List<EditItem> remEIs = new List<EditItem>(); foreach (EditItem ei in _MyAfterEditItems) { if (!ei.MyItemInfo.IsSection) remEIs.Add(ei); } foreach (EditItem ei1 in remEIs) { ei1.RemoveItemWithoutDelete(); } remEIs.Clear(); } } } 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; } } / This should find the item that precedes the current item vertically in the supplemental information column / and then return the Bottom of that item. // It is used so that an edit item does not overlap in 'y-direction' any preceding items. internal int? FindTopSupInfo(bool useSuppInfoColBottom) { if (MyParentEditItem == null) return null; / on supplemental info item: parent is item in left column. / return null if parent does not have previous siblings or parents that have supp info. FindPreviousOrParentSupInfo looks above to // items that have supinfo. EditItem prevOrParSupInfo = MyParentEditItem.FindPreviousOrParentSupInfo(); if (prevOrParSupInfo == null || !prevOrParSupInfo.Visible) { / Account for Expanded or collapsed. note that BottomMostEditItem already accounts for / whether it is expanded or collapsed. if (MyParentEditItem.MyPreviousEditItem != null) return MyParentEditItem.MyPreviousEditItem.BottomMostEditItem.Bottom; if (MyParentEditItem.MyBeforeEditItems != null) return MyParentEditItem.MyBeforeEditItems[MyParentEditItem.MyBeforeEditItems.Count - 1].BottomMostEditItem.Bottom; return (MySectionRTBItem==null)?0:MySectionRTBItem.Bottom; } int b1 = prevOrParSupInfo.BottomMostEditItem.Bottom; int b2 = b1; if (prevOrParSupInfo.MyParentEditItem.MyItemInfo.StepLevel > MyParentEditItem.MyItemInfo.StepLevel) b2 = prevOrParSupInfo.MyParentEditItem.LastSiblingEditItem.BottomMostEditItem.Bottom;

/ if the current supinfo's parent (proc step) is same as the lastsibling bottom most, don't use its value - it puts the next step / down too far: if (this.MyParentEditItem.MyID == prevOrParSupInfo.MyParentEditItem.LastSiblingEditItem.BottomMostEditItem.MyID) b2 = b1; // if not in the same HLS, don't use the lastsibling either: if (this.MyParentEditItem.MyItemInfo.MyHLS.ItemID != prevOrParSupInfo.MyParentEditItem.LastSiblingEditItem.MyItemInfo.MyHLS.ItemID) b2 = b1; if (useSuppInfoColBottom) return b1; else return Math.Max(b1, b2); // look at both supinfo & parent column to determine bottom } / This goes up edititems, looking for the closest in 'y-direction' of any supplemental info items. EditItem FindPreviousOrParentSupInfo() / current edit item is parent of supplmental info item { EditItem prev = this; // First see if there are any Cautions or Notes before me that have supinfo: EditItem lastBefore = prev.FindLastBeforeWithSupInfo(); if (lastBefore != null) return lastBefore.MySupInfoEditItems[0];

// There were no Cautions/Notes before me with supinfo, now see if there are previous items with supinfo: while (prev.MyPreviousEditItem != null) { prev = prev.MyPreviousEditItem; EditItem eiTmp = prev.FindLastSubstepWithSupInfo(); / check for MySupInfoEditItems as null because the FindLastSubstepWithSupInfo checks for data, but the supinfo step may / not be displayed yet, i.e. the eiTmp.MySupInfoEditItems has an edititem defined only it if is displayed. if (eiTmp != null && eiTmp.MySupInfoEditItems != null) return eiTmp.MySupInfoEditItems[0]; } // No previous items had supinfo, look up to the parent. But if on first before, i.e. first caution or note, there is nothing before (just the section) if (prev.MyParentEditItem.MyBeforeEditItems != null && prev.MyParentEditItem.MyBeforeEditItems.Count > 0 && prev.MyParentEditItem.MyBeforeEditItems[0] == prev) { EditItem eitmp = null; // if on a Note/Caution, need to be sure there isn't a step before me with supinfo (don't just assume going to Section) if (prev.MyParentEditItem.MyPreviousEditItem!=null)eitmp = prev.MyParentEditItem.MyPreviousEditItem.BottomMostEditItem.FindPreviousOrParentSupInfo(); return eitmp; } if (prev.MyParentEditItem.MySupInfoEditItems != null) return prev.MyParentEditItem.MySupInfoEditItems[0]; if (prev.MyItemInfo.IsSection) return null; return prev.MyParentEditItem.FindPreviousOrParentSupInfo(); } private EditItem FindLastBeforeWithSupInfo() { if (MyBeforeEditItems = null || MyBeforeEditItems.Count = 0) return null;

for (int i = MyBeforeEditItems.Count - 1; i > -1; i–) { // Need to look at caution/note (mybeforeedititems) if they have substeps that have supinfo if (MyBeforeEditItems[i].MySupInfoEditItems != null && MyBeforeEditItems[i].MySupInfoEditItems.Count > 0) return MyBeforeEditItems[i]; } return null; } / The next 2 methods, FindLastSubstepWithSupInfo, FindLastItemWithSupInfo: / for the current item, get to its bottommost supplemental info, if any steps/substeps have it. // private EditItem FindLastSubstepWithSupInfo() { ItemInfo ii = FindLastItemWithSupInfo(MyItemInfo); if (ii == null) return null; return GetEditItemFromItemID(ii.ItemID); } private ItemInfo FindLastItemWithSupInfo(ItemInfo stp) { // first check substeps (& their substeps) of item passed in. if (stp.Steps != null && stp.Steps.Count > 0) { for (int i = stp.Steps.Count - 1; i > -1; i–) { ItemInfo tmp = FindLastItemWithSupInfo(stp.Steps[i]); if (tmp != null) return tmp; } } //now check the step that was passed in. if (stp.SupInfos != null && stp.SupInfos.Count > 0) return stp; if (stp.Notes != null && stp.Notes.Count > 0) { for (int j = stp.Notes.Count - 1; j > -1; j–) { if (stp.Notes[j].SupInfos != null && stp.Notes[j].SupInfos.Count > 0) return stp.Notes[j]; } } if (stp.Cautions != null && stp.Cautions.Count > 0) { for (int j = stp.Cautions.Count - 1; j > -1; j–) { if (stp.Cautions[j].SupInfos != null && stp.Cautions[j].SupInfos.Count > 0) return stp.Cautions[j]; } } return null; } / <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, bool test1) { // if on a supplemental info, use special code to find what steps are above the supplemental info if (MyItemInfo.MyDocStyle != null && MyItemInfo.MyDocStyle.SupplementalInformation) { if (MyItemInfo.IsSupInfoPart) { int? tmptop = FindTopSupInfo(test1); return tmptop == null ? bottom : Math.Max(bottom, (int)tmptop); } } 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); } internal int FindTop(int bottom) { return FindTop(bottom, true); } / <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; } } public bool UserCheckOff { get { return _UserCheckOff; } set { _UserCheckOff = value; } } private char _UserCheckOffChar; public char UserCheckOffChar { get { return _UserCheckOffChar; } set { _UserCheckOffChar = 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, bool addFirstChld) { if (siblingEditItems == null) // Create a list of siblings { siblingEditItems = new List<EditItem>(); siblingEditItems.Add(this); MyParentEditItem = parentEditItem; } else // Add to the existing list { / add first child, when there are other children already there. This is used / for metasection editable data changed from off to on so that the first step is located // in the editor correctly, i.e. right below the section & above the subsections. if (addFirstChld) { EditItem parent = siblingEditItems[0].MyParentEditItem; siblingEditItems.Insert(0, this); MyStepPanel.ItemMoving++; _MyNextEditItem = siblingEditItems[1]; _MyNextEditItem._MyPreviousEditItem = this; MyPreviousEditItem = null; _MyNextEditItem.MyParentEditItem = null; MyParentEditItem = parent; MyStepPanel.ItemMoving–; } else if (nextEditItem == null) // Add to the end of the list { EditItem lastChild = LastChild(siblingEditItems); siblingEditItems.Add(this); MyPreviousEditItem = lastChild; / RHM - The following line was remove for Facing Pages (Supplemental Information) / * / When MyPreviousEditItem is set, the location and size is set as a side-effect. / When MyParentEditItem is set, the location and size is set as a side effect. / Only Previous or Parent should be set, no both. / * /MyParentEditItem = MyPreviousEditItem.MyParentEditItem; / Farley - part of bug fix B2015-123 alignment of tabs on the edit screen } else // Add to the middle of the list before a particular item { EditItem prevChild = nextEditItem.MyPreviousEditItem; EditItem parent = nextEditItem.MyParentEditItem; if(siblingEditItems.Contains(nextEditItem)) siblingEditItems.Insert(siblingEditItems.IndexOf(nextEditItem), this); else siblingEditItems.Insert(0, this); MyStepPanel.ItemMoving++; _MyNextEditItem = nextEditItem; if(!MyItemInfo.IsNote || !MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format || MyPreviousEditItem == null) nextEditItem._MyPreviousEditItem = this; MyPreviousEditItem = prevChild;// If a previous exists - this will adjust the location and width of the EditItem if (MyItemInfo.IsNote && MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && MyPreviousEditItem != null) nextEditItem.MyPreviousEditItem = this;//Position First Note in Dev Doc Format if (!MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format || !(nextEditItem.MyItemInfo.IsNote && MyItemInfo.IsCaution)) { // RHM 20170216 For Deviation Document don't set MyParentEditItem to null when Type Changes from Caution to Note nextEditItem.MyParentEditItem = null; MyParentEditItem = parent; // If a parent exists - this will adjust the location and width of the EditItem AdjustForDevDocStepHeight(); } //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(); if (_MySupInfoEditItems != null) foreach (EditItem chld in _MySupInfoEditItems) 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 RemoveItemWithoutDelete() { BeingRemoved = true; int TopMostYBefore = TopMostEditItem.Top; MyStepPanel._LookupEditItems.Remove(MyID); EditItem newFocus = null; int? TopMostParentY = (MyParentEditItem = null ? null : (int?)(MyParentEditItem.TopMostEditItem.Top)); int? ParentY = (MyParentEditItem = null ? null : (int?)(MyParentEditItem.Top)); RemoveFromParentsChildList(); 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; } else { newFocus = MyParentEditItem; MyParentEditItem = null; } Dispose(); if (newFocus != null) { newFocus.SetFocus(); newFocus.SetAllTabs(); newFocus.AdjustLocation(); } } private static int xOffset = 0; public void RemoveItem() { // if this item has enhanced edititems, remove them: StepConfig sc = MyItemInfo.MyConfig as StepConfig; List<EnhancedDocument> thisEnhs = null; if (sc != null) thisEnhs = sc.MyEnhancedDocuments; else { if (MyItemInfo.IsSection) { SectionConfig secc = MyItemInfo.MyConfig as SectionConfig; if (secc.Section_LnkEnh == "Y") thisEnhs = secc.MyEnhancedDocuments; } }

List<int> enhIds = new List<int>(); if (thisEnhs != null) { foreach (EnhancedDocument ed in thisEnhs) { if (ed.Type != 0) enhIds.Add(ed.ItemID); } } BeingRemoved = true; MyStepPanel.SelectedEditItem = null; // Unselect the item to be deleted //ShowTops("\r\n"); int TopMostYBefore = TopMostEditItem.Top; /_MyTimer.ActiveProcess = "DeleteItem"; / Add a Panel temporarily so that AutoScroll will not happen during the delete. Panel pnl = new Panel(); pnl.Size = new Size(10, 10); MyStepPanel.Controls.Add(pnl); pnl.BackColor = Color.Red; pnl.Location = new Point(xOffset += 15, MyStepPanel.ClientSize.Height + 10); EditItem newFocus = DeleteItem(); if (newFocus == null) { MyStepPanel.Controls.Remove(pnl); return; } //_MyTimer.ActiveProcess = "SetFocus";

int b4topadjust = newFocus.Top; newFocus.SetFocus(); /shifts edititem to center it / need to adjust the TopMostYBefore so that it accounts for any shifting that occurred when the // SetFocus was called. This fixes B2016-040. b4topadjust -= newFocus.Top; TopMostYBefore -= b4topadjust;

//_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"); ForceEditItemRefresh(newFocus); MyStepPanel.Controls.Remove(pnl); foreach (int enhId in enhIds) { ItemInfo ii = ItemInfo.Get(enhId); bool success = this._MyStepPanel.MyStepTabPanel.MyDisplayTabControl.DeleteRTBItem(ii); if (!success) Item.DeleteItemAndChildren(ii); } if (MyItemInfo.MyDocStyle != null && MyItemInfo.MyDocStyle.SupplementalInformation) { if (newFocus.MyItemInfo.IsInSupInfo) newFocus.AdjustAllForSupInfoHeight(); else { EditItem prvOrParSupInfo = newFocus.FindPreviousOrParentSupInfo(); if (prvOrParSupInfo != null) prvOrParSupInfo.AdjustAllForSupInfoHeight(); } } }

private static void ForceEditItemRefresh(EditItem newFocus) { / bug fix / need to force a refresh from the level above the step that was removed. / this fixes a problem where the following step/substep wasn't shown on the screen (but was there) / and fixes a problem where the sequence numbers were off by one // and fixes a problem where an edit window would end up on top of the ones above it EditItem ei = newFocus; while (ei.MyPreviousEditItem != null) ei = ei.MyPreviousEditItem; if (ei.MyParentEditItem != null && ei.MyParentEditItem.MyItemInfo.IsStep) ei.MyParentEditItem.Expand(true); } 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 if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && MyNextEditItem.MyPreviousEditItem == null && (MyNextEditItem.MyItemInfo.IsNote || MyNextEditItem.MyItemInfo.IsCaution)) { MyNextEditItem.MyParentEditItem.Top = (MyNextEditItem.MyParentEditItem.MyPreviousEditItem != null ? MyNextEditItem.MyParentEditItem.MyPreviousEditItem.FindBottomDevDoc: MyNextEditItem.MyParentEditItem.MyParentEditItem.Bottom); MyNextEditItem.Top = MyNextEditItem.MyParentEditItem.Top; MyNextEditItem.AdjustLocation(); } else { MyNextEditItem.TopMostEditItem.AdjustLocation(); } MyNextEditItem = null; } else if (MyPreviousEditItem != null) { MyPreviousEditItem.MyNextEditItem = null; /newFocus = MyPreviousEditItem.BottomMostEditItem; / bug fix - when deleting an edit window in the AER, position to the bottom most in the AER - was jumping to RNO newFocus = MyPreviousEditItem.BottomMostEditItemNoRNOs; if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && MyPreviousEditItem.MyNextEditItem == null && (MyPreviousEditItem.MyItemInfo.IsNote || MyPreviousEditItem.MyItemInfo.IsCaution)) { MyPreviousEditItem.MyParent.Top = MyPreviousEditItem.MyParent.MyPreviousEditItem.FindBottomDevDoc; MyPreviousEditItem.Top = MyPreviousEditItem.MyParent.Top; MyPreviousEditItem.MyParent.AdjustLocation(); } 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) private void HandleSqlExceptionOnDelete(Exception ex) { this.MyStepRTB.InsertSymbol(@"\u160?"); // since text was deleted, insert a hard space to prevent a looping effect B2016-082 using (Item itm = MyStepRTB.MyItemInfo.Get()) { Annotation x = Annotation.MakeAnnotation(itm, AnnotationType.GetByName("Verification Required"), null, "A Hard Space was put in to keep the Transitions referencing here valid. \nPlease remove or re-assign these transitions before deleting this step.", null); } if (ex.Message.Contains("has External Transitions and has no next step")) { using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitions(MyID)) { DialogResult ans = FlexibleMessageBox.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 Procedure")) { using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitionsToChildren(MyID)) { DialogResult ans = FlexibleMessageBox.Show("Transitions exist to this procedure." + "\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 Procedure", 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 = FlexibleMessageBox.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; } else if (parentEditItem.MySupInfoEditItems != null && parentEditItem.MySupInfoEditItems.Contains(this)) { parentEditItem.MySupInfoEditItems.Remove(this); if (parentEditItem.MySupInfoEditItems.Count == 0) parentEditItem.MySupInfoEditItems = 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); } public EditItem AddChildBefore(ItemInfoList myItemInfoList, EditItem nextEditItem) { EditItem child = null; if (myItemInfoList != null) foreach (ItemInfo item in myItemInfoList) child = AddChildBefore(item, nextEditItem); return child; } / <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); } public void AddChildSupInfo(ItemInfo myItemInfo, bool expand) { EditItem child = new RTBItem(myItemInfo, MyStepPanel, this, ChildRelation.SupInfo, 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); } public void AddChildSupInfo(ItemInfoList myItemInfoList, bool expand) { if (myItemInfoList != null) foreach (ItemInfo item in myItemInfoList) AddChildSupInfo(item, expand); } / <summary> / Add a child after / </summary> / <param name="MyItemInfo"></param> / <param name="expand"></param> public EditItem AddChildAfter(ItemInfo MyItemInfo, bool expand, bool addFirstChld) { EditItem child = null; if (MyItemInfo.IsFigure) child = new ImageItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, expand); else if (MyItemInfo.IsRtfRaw) child = new RtfRawItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, expand); else if (MyItemInfo.MyContent.MyGrid != null) child = new GridItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, expand); else child = new RTBItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, expand, addFirstChld); return child; } public EditItem AddChildAfter(ItemInfo MyItemInfo, EditItem nextEditItem) { EditItem child = null; if (MyItemInfo.IsFigure) child = new ImageItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, true, nextEditItem, FigInsType); else if (MyItemInfo.IsRtfRaw) child = new RtfRawItem(MyItemInfo, MyStepPanel, this, ChildRelation.After, true, nextEditItem); else 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.IsFigure) child = new ImageItem(MyItemInfo, MyStepPanel, this, ChildRelation.Before, true, nextEditItem, FigInsType); else if (MyItemInfo.IsRtfRaw) child = new RtfRawItem(MyItemInfo, MyStepPanel, this, ChildRelation.Before, true, nextEditItem); 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; } public EditItem AddChildSupInfo(ItemInfo MyItemInfo, EditItem nextEditItem) { EditItem child = null; if (MyItemInfo.MyContent.MyGrid != null) child = new GridItem(MyItemInfo, MyStepPanel, this, ChildRelation.SupInfo, true, nextEditItem); else child = new RTBItem(MyItemInfo, MyStepPanel, this, ChildRelation.SupInfo, 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); AddGridIfNeeded(newItemInfo); AddImageIfNeeded(newItemInfo); DoAddSiblingAfter(newItemInfo, updateStatus); if (MyStepPanel.SelectedEditItem is RTBItem) { RTBItem rtbi = MyStepPanel.SelectedEditItem as RTBItem; / see if this step has associated enhanced step(s). If it does, flag it so / that the enhanced steps get inserted also. StepConfig sc = new StepConfig(MyItemInfo.MyContent.Config); if (sc.MyEnhancedDocuments.Count > 0) { rtbi.EnhAddFromItemInfo = MyItemInfo; rtbi.EnhAddType = EnhancedAddTypes.After; } } } / This logic allows us to do an Insert Before and Insert After while on a Table / if allowed by the format private void AddGridIfNeeded(ItemInfo newItemInfo) { if (this is GridItem) { GridItem gi = this as GridItem; VlnFlexGrid fg = new VlnFlexGrid(gi.MyFlexGrid.Rows.Count, gi.MyFlexGrid.Cols.Count); / bug fix B2015136 / need to copy the font used in the table we are doing the Insert Previous/Next from. VE_Font vefont = MyItemInfo.ActiveFormat.PlantFormat.FormatData.StepDataList.Table.Font; Font GridFont = new Font(vefont.Family, (float)vefont.Size); fg.Font = GridFont; using (Item itm = newItemInfo.Get()) { itm.MyContent.MyGrid.Data = fg.GetXMLData(); itm.Save(); } } } / This logic allows us to do an Insert Before and Insert After while on a Figure / if allowed by the format. Note that Before/After for figures is only Clipboard (if / image data exists in clipboard), or file. Doing RO images will be added later if needed - / this decision was made because of scope. private void AddImageIfNeeded(ItemInfo newItemInfo) { if (this is ImageItem) ImageItem.AddImageIfNeeded(newItemInfo); }

public void AddSiblingAfter(int? type, bool updateStatus) { SaveContents(); ItemInfo newItemInfo = MyItemInfo.InsertSiblingAfter("", "", type); AddGridIfNeeded(newItemInfo); AddImageIfNeeded(newItemInfo); DoAddSiblingAfter(newItemInfo, updateStatus); if (MyStepPanel.SelectedEditItem is RTBItem) { RTBItem rtbi = MyStepPanel.SelectedEditItem as RTBItem; / see if this step has associated enhanced step(s). If it does, flag it so / that the enhanced steps get inserted also. StepConfig sc = new StepConfig(MyItemInfo.MyContent.Config); if (sc.MyEnhancedDocuments.Count > 0) { rtbi.EnhAddFromItemInfo = MyItemInfo; rtbi.EnhAddType = EnhancedAddTypes.After; } } } 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; case ChildRelation.SupInfo: newEditItem = ActiveParent.AddChildSupInfo(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(int? type, bool updateStatus) { SaveContents(); ItemInfo newItemInfo = MyItemInfo.InsertSiblingBefore("", "",type); AddGridIfNeeded(newItemInfo); AddImageIfNeeded(newItemInfo); DoAddSiblingBefore(newItemInfo, updateStatus); } 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); AddGridIfNeeded(newItemInfo); AddImageIfNeeded(newItemInfo); DoAddSiblingBefore(newItemInfo, updateSelection); if (MyStepPanel.SelectedEditItem is RTBItem) { RTBItem rtbi = MyStepPanel.SelectedEditItem as RTBItem; / see if this step has associated enhanced step(s). If it does, flag it so / that the enhanced steps get inserted also. StepConfig sc = new StepConfig(MyItemInfo.MyContent.Config); if (sc.MyEnhancedDocuments.Count > 0) { rtbi.EnhAddFromItemInfo = MyItemInfo; rtbi.EnhAddType = EnhancedAddTypes.Before; } } } public void DoAddSiblingBefore(ItemInfo newItemInfo, bool updateSelection) { 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; case ChildRelation.SupInfo: newEditItem = ActiveParent.AddChildSupInfo(newItemInfo, this); break; default: // Need debug break; } if (updateSelection) MyStepPanel.SelectedEditItem = newEditItem;//Update Screen } public void AddSiblingBeforeNoDataSave(ItemInfo newItemInfo, bool updateSelection, EditItem tt) { EditItem newEditItem = null; newEditItem = ActiveParent.AddChildBefore(newItemInfo, this); //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 } private bool specialAdd = false; public void AddSiblingBeforeNoDataSave(ItemInfoList newItemInfos, bool updateSelection) { specialAdd = true; EditItem newEditItem = null; newEditItem = ActiveParent.AddChildAfter(newItemInfos, false, true); if (updateSelection) MyStepPanel.SelectedEditItem = newEditItem;//Update Screen specialAdd = false; } private ImageItem.E_ImageSource FigInsType = ImageItem.E_ImageSource.None; public void AddChild(E_FromType fromType, int type, ImageItem.E_ImageSource newSource) { FigInsType = newSource; AddChild("", fromType, type, null); FigInsType = ImageItem.E_ImageSource.None; } 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.ActiveFormat.MyStepSectionLayoutData.Dev_Format) || _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; case E_FromType.SupInfo: newEditItem = this.AddChildSupInfo(newItemInfo, nextItem); break; default: newEditItem = this.AddChildAfter(newItemInfo, nextItem); break; } MyStepPanel.SelectedEditItem = newEditItem;//Update Screen if (MyStepPanel.SelectedEditItem is RTBItem) { RTBItem rtbi = MyStepPanel.SelectedEditItem as RTBItem; / see if this step has associated enhanced step(s). If it does, flag it so / that the enhanced steps get inserted also. EnhancedDocuments cfgeds = null; if (MyItemInfo.IsStepSection) { SectionConfig scfg = MyItemInfo.MyConfig as SectionConfig; if (scfg.Section_LnkEnh != "Y") return; cfgeds = scfg.MyEnhancedDocuments; } else { StepConfig sc = new StepConfig(MyItemInfo.MyContent.Config); cfgeds = sc.MyEnhancedDocuments; } if (cfgeds != null && cfgeds.Count > 0) { rtbi.EnhAddFromItemInfo = MyItemInfo; rtbi.EnhAddType = EnhancedAddTypes.Child; } } } 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, bool addFirstChld) { EditItem child = null; int indx = 0; if (myItemInfoList != null) foreach (ItemInfo item in myItemInfoList) { if (addFirstChld) { // the first time add it as first child, the rest should be done in between. child = AddChildAfter(item, expand, addFirstChld); addFirstChld = false; } else child = AddChildAfter(item, this._MyAfterEditItems[indx]); indx++; } return child; } public EditItem AddChildAfter(ItemInfoList myItemInfoList, bool expand) { EditItem child = null; if (myItemInfoList != null) foreach (ItemInfo item in myItemInfoList) child = AddChildAfter(item, expand, false); return child; } public EditItem AddChildAfter(ItemInfoList myItemInfoList, EditItem nextEditItem) { EditItem child = null; if (myItemInfoList != null) foreach (ItemInfo item in myItemInfoList) child = AddChildAfter(item, nextEditItem); return child; } #endregion #region CopyPaste public void PasteSiblingBefore(int copyStartID) { ItemInfo newItemInfo = MyItemInfo.PasteSiblingBefore(copyStartID, GetChangeId(MyItemInfo));

if (newItemInfo.ItemID == MyItemInfo.ItemID) return;

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; case ChildRelation.SupInfo: newEditItem = ActiveParent.AddChildSupInfo(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));

// MyItemInfo is the 'paste from' item, if it has enhanced need to copy and paste the steps in enhanced. ItemInfo newEnh = newItemInfo.EnhancedPasteItem(copyStartID, MyItemInfo, ItemInfo.EAddpingPart.Before, GetChangeId(MyItemInfo)); // if enhanced items were created, then see if they need displayed: if (newEnh != null) AddAllEnhancedItemsToDisplay(newItemInfo); } private void AddAllEnhancedItemsToDisplay(ItemInfo newItemInfo) { EnhancedDocuments eds = newItemInfo.GetMyEnhancedDocuments(); if (eds != null && eds.Count > 0) { foreach (EnhancedDocument ed in eds) AddEnhancedItemToDisplayTabItem(ItemInfo.Get(ed.ItemID)); } } public void AddEnhancedItemToDisplayTabItem(ItemInfo newEnh) { / if tabcontrol was open for enhanced, display the steps: ItemInfo proc = newEnh.MyProcedure; / Find procedure Item string key = "Item - " + proc.ItemID.ToString(); if (MyStepPanel.MyStepTabPanel.MyDisplayTabControl._MyDisplayTabItems.ContainsKey(key)) { DisplayTabItem pg = MyStepPanel.MyStepTabPanel.MyDisplayTabControl._MyDisplayTabItems[key]; / _MyDisplayTabItems (in line above) had tabs that were closed, so use the next line / to validate that the tab is still open. foreach (DisplayTabItem ti in MyStepPanel.MyStepTabPanel.MyDisplayTabControl.MyBar.Items) { if (ti == pg) pg.MyStepTabPanel.MyStepPanel.GetEditItem(newEnh); } } } public void CreateLinksEnhancedSingleItem(ItemInfo srcII, ItemInfo enhII, int enhtype) { srcII.DoCreateLinksEnhancedSingleItem(enhII, enhtype); SetFocus(); } public void CreateLinksEnhancedAllInProcedure(ItemInfo srcII, ItemInfo enhII, int enhtype) { using (ContentInfoList cil = ContentInfoList.Convert16To32EnhancedContents(srcII.ItemID, enhII.ItemID, enhtype)) { foreach (ContentInfo ci in cil) { using (Content c = ci.Get()) { / first refresh configs because the ContentInfo.Refresh causes events to occur that refresh screen / and if configs aren't done first, the screen refresh, if based on config data, will not be correct. foreach (ItemInfo ii in ci.ContentItems) ii.RefreshConfig(); ContentInfo.Refresh(c); } } } } public void UnlinkEnhanced(ItemInfo enhII) { enhII.DoUnlinkEnhanced(enhII); SetFocus(); } public ItemInfo AddMissingEnhancedStep(ItemInfo ii, int EnhType) { / if the missing enhanced step is a caution or note, check that parent HLS has the needed / enhanced step to insert the caution/note from. If not, do a message. if (ii.IsCaution || ii.IsNote) { bool canMakeMissingStep = false; StepConfig sc = ii.MyHLS.MyConfig as StepConfig; foreach (EnhancedDocument ed in sc.MyEnhancedDocuments) { if (EnhType == ed.Type) // the hls has an enhanced linked step of this type, the caution/note can be made: { canMakeMissingStep = true; break; } } if (!canMakeMissingStep) { MessageBox.Show("Cannot create the missing enhanced step, the Enhanced Step for the High Level step must be created first."); return null; } } ItemInfo newEnh = ii.DoAddMissingEnhancedItems(EnhType); // if enhanced items were created, then see if they need displayed: if (newEnh != null) AddAllEnhancedItemsToDisplay(MyItemInfo); SetFocus(); return newEnh; } private string GetChangeId(ItemInfo iiDest) { // get the change id for the destination's procedure's change id. string chgid = null; if (iiDest.ActiveFormat.PlantFormat.FormatData.ProcData.ChangeBarData.ChangeIds) chgid = MyStepPanel.MyStepTabPanel.MyDisplayTabControl.ItemsChangeIds[iiDest.MyProcedure.ItemID]; return chgid; } public void PasteSiblingAfter(int copyStartID) { ItemInfo newItemInfo = MyItemInfo.PasteSiblingAfter(copyStartID, GetChangeId(MyItemInfo)); if (newItemInfo.ItemID == MyItemInfo.ItemID) return; 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; case ChildRelation.SupInfo: newEditItem = ActiveParent.AddChildSupInfo(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));

// MyItemInfo is the 'paste from' item, if it has enhanced need to copy and paste the steps in enhanced. ItemInfo newEnh = newItemInfo.EnhancedPasteItem(copyStartID, MyItemInfo, ItemInfo.EAddpingPart.After, GetChangeId(MyItemInfo)); if (newEnh != null) AddAllEnhancedItemsToDisplay(newItemInfo); } public void PasteChild(int copyStartID) { ItemInfo newItemInfo = MyItemInfo.PasteChild(copyStartID, GetChangeId(MyItemInfo));

E_FromType fromType = E_FromType.Step; if (MyItemInfo.MyContent.Type < 10000) fromType = E_FromType.Procedure; else if (MyItemInfo.MyContent.Type < 20000) fromType = E_FromType.Section; else if (MyItemInfo.MyContent.Type > 19999) { int tmptype = (int)MyItemInfo.MyContent.Type - 20000; if (MyItemInfo.IsCaution) fromType = E_FromType.Caution; else if (MyItemInfo.IsNote) fromType = E_FromType.Note; else if (MyItemInfo.IsTable) fromType = E_FromType.Table; else if (MyItemInfo.IsRNOPart) fromType = E_FromType.RNO; else if (MyItemInfo.IsSupInfoPart) fromType = E_FromType.SupInfo; } EditItem nextItem = GetNextItem(fromType, newItemInfo); 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; case E_FromType.SupInfo: newEditItem = this.AddChildSupInfo(newItemInfo, nextItem); break; default: newEditItem = this.AddChildAfter(newItemInfo, nextItem); break; } MyStepPanel.SelectedEditItem = newEditItem;//Update Screen

// MyItemInfo is the 'paste from' item, if it has enhanced need to copy and paste the steps in enhanced. ItemInfo newEnh = newItemInfo.EnhancedPasteItem(copyStartID, MyItemInfo, ItemInfo.EAddpingPart.Child, GetChangeId(MyItemInfo)); if (newEnh != null) AddAllEnhancedItemsToDisplay(newItemInfo); } 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;

StepConfig savOrigPasteConfig = MyItemInfo.MyConfig as StepConfig; 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, GetChangeId(MyItemInfo)); } //catch (System.Data.SqlClient.SqlException ex) catch (Exception ex) { if (HandleSqlExceptionOnCopy(ex)) return this; 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; case ChildRelation.SupInfo: newEditItem = parentEditItem.AddChildSupInfo(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)); // MyItemInfo is the 'paste from' item, if it has enhanced need to copy and paste the steps in enhanced. ItemInfo newEnh = newItemInfo.PasteEnhancedItems(copyStartID, MyItemInfo, ItemInfo.EAddpingPart.Replace, GetChangeId(MyItemInfo)); if (newEnh != null) AddAllEnhancedItemsToDisplay(newItemInfo); // KBR - I think this won't work for replace!! return newEditItem; } private bool HandleSqlExceptionOnCopy(Exception ex) { if (ex.Message.Contains("This step has been deleted")) { MessageBox.Show("The step being pasted has been deleted", "Cannot Paste Step", MessageBoxButtons.OK, MessageBoxIcon.Hand); return true; } if(ex.Message.Contains("This current step has been deleted in another session")) { MessageBox.Show("The highlighted step has been deleted by another user.", "Cannot Paste Step", MessageBoxButtons.OK, MessageBoxIcon.Hand); return true; } return false; } 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); } } if (MySupInfoEditItems != null) { foreach (EditItem sis in MySupInfoEditItems) { sis.IdentifyMe(highlight); sis.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; if (rnoTop.Top != Top) 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)); if (rnoTop.Top != BottomMostEditItemNoRNOs.Bottom) rnoTop.Top = BottomMostEditItemNoRNOs.Bottom; rnoTop.LastMethodsPop(); MyStepPanel.ItemMoving–; } } } } protected void MoveSupInfo() // If the current item has supplemental information, be sure its top location is that of the current item. { if (_MySupInfoEditItems != null && _MySupInfoEditItems.Count > 0) { EditItem supInfoTop = _MySupInfoEditItems[0].TopMostEditItem; if (supInfoTop.Top != Top + supInfoTop.SupInfoTopOffset) { MyStepPanel.ItemMoving++; supInfoTop.LastMethodsPush(string.Format("EditItem_Move SupInfo Right {0}", supInfoTop.MyID)); supInfoTop.Top = Top + supInfoTop.SupInfoTopOffset; supInfoTop.LastMethodsPop(); MyStepPanel.ItemMoving–; } } } private bool _TryAgainLater = false; public bool TryAgainLater { get { return _TryAgainLater; } set { _TryAgainLater = value; } } //static bool _ShowChanges=false; int _LastTop = 0;

// Bug Fix: B2017-059 only turn on the spellchecking if the RTB is visible. This controls the number of windows handles created durning spellchecking private void TurnOnSpellCheckIfVisible() { if (MyStepRTB != null) { if (this.Top + this.Height > 0 && this.Top < MyStepPanel.Height) MyStepRTB.SpellCheckStatus = true; else MyStepRTB.SpellCheckStatus = false; } } / <summary> / Handles movement of the EditItems / </summary> / <param name="sender"></param> / <param name="e"></param> / use the following to debug if two steps are to be displayed one right after the other vertically, but they are getting separated, overwritten, / gaps. See code below at the beginning of EditItem_Move that uses these. //static EditItem ei_below; //static EditItem ei_above; private void EditItem_Move(object sender, EventArgs e) { //if (MyID = 205300) ei_above = this; //if (MyID = 205306) ei_below = this; //if (ei_below != null && ei_above != null && MyID = ei_below.MyID && ei_below.Top ! ei_above.Bottom) Console.WriteLine("here"); TurnOnSpellCheckIfVisible(); int newTop = Top - MyStepPanel.TopMostEditItem.Top; //if(_ShowChanges && _LastTop != newTop && MyItemInfo.InList(134786)) //Volian.Base.Library.vlnStackTrace.ShowStackLocal(2,10,"\"EditItem_Move\"\t\"\"\t\"{0}\"\t{1}\t{2}\t{3}",MyItemInfo.ShortPath, MyID, Top, _LastTop); if (_LastTop == newTop) return; _LastTop = newTop; int watchThis = _WatchThis; if (MyStepPanel.ItemMoving == 0 && !TryAgainLater) { /vlnStackTrace.ScrollInStack(); return; / If 0 - Indicates scrolling which requires no action. } TryAgainLater = false; //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; EditItem supinfo = null; if (MySupInfoEditItems != null && MySupInfoEditItems.Count > 0) supinfo = MySupInfoEditItems[0].BottomMostEditItem; if (supinfo != null && supinfo.Bottom > btm.Bottom) btm = supinfo; 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(); AdjustAllForSupInfoHeight(); } #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(StepSectionLayoutData myStepSectionLayoutData, int width) { // bug fix: B2016-111 - myParentEditItem was getting a null reference error when inserting a figure before/after a figure EditItem myParentEditItem = _MyParentEditItem; if (myParentEditItem == null) { EditItem parentEI = _MyPreviousEditItem; while (parentEI._MyPreviousEditItem != null) parentEI = parentEI._MyPreviousEditItem; myParentEditItem = parentEI._MyParentEditItem; } / Should center on parent unless it is a centered table type in the AER column or parent is another table type, then / walk up until finding a non-table type step'. (B2016-264: insert of centered eq off centered eq was not locating child equation correctly) EditItem aboveForLocation = myParentEditItem; if (aboveForLocation.MyItemInfo.IsTable || aboveForLocation.MyItemInfo.IsRtfRaw || aboveForLocation.MyItemInfo.IsFigure) { while (aboveForLocation.MyItemInfo.IsFigure || aboveForLocation.MyItemInfo.IsRtfRaw || aboveForLocation.MyItemInfo.IsTable) aboveForLocation = aboveForLocation.MyParentEditItem; }

int center = aboveForLocation.ContentLeft + aboveForLocation.ContentWidth / 2; int rightLimit = aboveForLocation.Right; // Then should center on the wid Limit if ((MyItemInfo.FormatStepData.Type.Contains("AER") = false && MyItemInfo.RNOLevel = 0 ) && !MyItemInfo.IsInSupInfo) { // B2017-043 COLR is used as a Width int colR = MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColRTable, MyItemInfo.ColumnMode); rightLimit += colR * MyItemInfo.ColumnMode; center += (colR * MyItemInfo.ColumnMode) / 2; center -= (aboveForLocation.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; // B2017-043 account for Horizontal Scroll int colT =MyStepPanel.DisplayRectangle.X + 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()); MyStepPropertiesPanel.UpdatePageBreakCheckBox(); // update the checkbox on the Step Properties panel if (!MyStepRTB.ContainsFocus) MyStepRTB.Focus(); } protected void ToggleChangeBar() { MyStepPropertiesPanel.ToggleChangeBar(); // update the checkbox on the Step Properties panel if (!MyStepRTB.ContainsFocus) MyStepRTB.Focus(); } protected void ToggleContinuousActionSummary() { if (MyStepPropertiesPanel != null) / bug fix B2016-256 check for a null reference incase we are not on a step element MyStepPropertiesPanel.ToggleContActSummary(); / update the checkbox on the Step Properties panel if (!MyStepRTB.ContainsFocus) MyStepRTB.Focus(); } protected void TogglePlaceKeeper() { MyStepPropertiesPanel.TogglePlaceKeeper(); // update the checkbox on the Step Properties panel if (!MyStepRTB.ContainsFocus) MyStepRTB.Focus(); } protected void TogglePlaceKeeperContAct() { MyStepPropertiesPanel.TogglePlaceKeeperContAct(); // update the checkbox on the Step Properties panel if (!MyStepRTB.ContainsFocus) MyStepRTB.Focus(); } protected void ToggleSuperScript() { MyStepPanel.MyStepTabPanel.MyStepTabRibbon.btnSuperscript_Click(this, new EventArgs()); // click the Superscrpt button on the ribbon if (!MyStepRTB.ContainsFocus) MyStepRTB.Focus(); } protected void ToggleSubScript() { MyStepPanel.MyStepTabPanel.MyStepTabRibbon.btnSubscript_Click(this, new EventArgs()); // click the Subscrpt button on the ribbon if (!MyStepRTB.ContainsFocus) MyStepRTB.Focus(); } 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 / Limit scroll location within allowable values scrollValue = Math.Max(MyStepPanel.VerticalScroll.Minimum,Math.Min(MyStepPanel.VerticalScroll.Maximum,scrollValue)); /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(_MySupInfoEditItems); 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(_MySupInfoEditItems, 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(_MySupInfoEditItems); 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(_MySupInfoEditItems); 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() { if (RNORight) MoveRNO(); / This is needed when an AER is Deleted that has an RNO. MoveSupInfo(); / If the current item has supplemental information, be sure its top location is that of the current item. if (RNOLevel > 0 && AEREditItem != null) AEREditItem.AdjustLocation(); EditItem nextEditItem = NextDownEditItem; /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 (nextEditItem != null) { if (MyStepPanel.ExpandingHLS != null && nextEditItem.MyItemInfo.IsSection) return; // without this, if next item is section, it crashes on null reference if (MyStepPanel.ExpandingHLS != null && nextEditItem.MyItemInfo.MyHLS.ItemID != MyStepPanel.ExpandingHLS.ItemID) return; int bottom = nextEditItem.FindTop(Bottom); if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format) { if (MyItemInfo.IsCaution || MyItemInfo.IsNote) { if (nextEditItem.MyItemInfo.IsHigh || (nextEditItem.MyItemInfo.IsNote && MyItemInfo.IsCaution)) { bottom = FirstSiblingEditItem.Top; } / RHM 20170216 / MyParent will walk back MyPrevious to find Parent // NextDevDocStep will find the first part of a Dev Doc HLS AdjustForDevDocStepHeight(); } } // SameRowAsParent - Comanche Peak Step Designator //FormatData fmtdata = MyItemInfo.ActiveFormat.PlantFormat.FormatData; //int formatSteptype = MyItemInfo.FormatStepType; //if (fmtdata.StepDataList[formatSteptype].SameRowAsParent) /if (MyItemInfo.SameRowAsParent && MyItemInfo.IsCaution2) / bottom = Top;

/ If this is a "TitleWithTextRight", don't move down on the screen but only if it has a / child, i.e. want the child to be positioned on line, but if no child, move down on screen: int newTop = bottom; if (MyItemInfo.IsSupInfoPart) newTop = Math.Max(bottom, nextEditItem.BottomOfStepImmediatelyAbove()); if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format) / Deviation Document Format if (MyItemInfo.IsStep && nextEditItem.MyItemInfo.IsStep && nextEditItem.MyItemInfo.MyHLS.ItemID != MyItemInfo.MyHLS.ItemID)/ Move from one step to another newTop = FindBottomDevDoc;// Use the bottom most caution or note

if (MyItemInfo.FormatStepData != null && MyItemInfo.FormatStepData.Type == "TitleWithTextRight" && MyItemInfo.HasChildren) newTop = Top; //This was useful to find the code that was positioning the Deviationn Document steps /if (MyItemInfo.InList(134782, 134783) || nextEditItem.MyItemInfo.InList(134782, 134783)) / Console.WriteLine("\"AdjustLocation\"\t\"{0}\"\t\"{1}\"\t{2}\t{3}\t{4}\t{5}", MyItemInfo.ShortPath, nextEditItem.MyItemInfo.ShortPath, nextEditItem.MyID, newTop, FindBottom, FindBottom - Top); if (nextEditItem.Top != newTop) { MyStepPanel.ItemMoving++; nextEditItem.LastMethodsPush(string.Format("AdjustLocation {0}", MyID)); nextEditItem._NextDownEditItemPath = _NextDownEditItemPath; float oldTop = nextEditItem.Top; nextEditItem.ExpandPrefix = 0;// If I move then I have to move my children when I expand / it appears that setting the top doesn't always work. The logic below checks to see if it does / not work and trys some other things so that the EditItem will be moved to the correct place. // As a last attempt, the EditItem is added to a list to be refreshed from a timer on MyStepPanel. if (nextEditItem.MySupInfoEditItems != null && nextEditItem.MySupInfoEditItems.Count > 0) newTop = nextEditItem.MySupInfoEditItems[0].FindTop(newTop); nextEditItem.Top = newTop; if (nextEditItem.Top != newTop) { /_MyLog.InfoFormat("'TryAgainLater',{0},{1},{2},{3},{4},'{5}'", / oldTop, nextEditItem.Top, newTop, MyStepPanel.Height, nextEditItem.MyID, nextEditItem.MyItemInfo.ShortPath); nextEditItem.TryAgainLater = true; } nextEditItem.LastMethodsPop(); MyStepPanel.ItemMoving–; } } } private int _DevDocHeight = 0; // Deviation Document Step Height B2016-123, B2017-020, B2017-021 public int DevDocHeight { get { return _DevDocHeight; } set { _DevDocHeight = value; } } public void TryAgainNow(int bottom) { TryToSetTop(bottom-10); //TryToSetTop(bottom+10); TryToSetTop(bottom); } private void TryToSetTop(int offset) { Top = offset; if (Top != offset) _MyLog.InfoFormat("Didn't work - Top {0} != offset {1} {2}", Top, offset,MyStepPanel.VerticalScroll.Value); } / <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 { if(MyStepPanel.AutoExpand) Expand((_ContentType >= 20000) || MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format); else Expand(false); //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++; if (TopMostEditItem.Top != Top) TopMostEditItem.Top = Top; MyStepPanel.ItemMoving–; } else TopMostEditItem.AdjustLocation(); //_ShowChanges = true; AdjustChildren(); //_ShowChanges = false; /if(_Before != null ) / Top = _Before[_Before.Count - 1].BottomMost.Bottom; } else { if (MyItemInfo.IsHigh) MyStepPanel.ExpandingHLS = MyItemInfo; MyExpandingStatus = ExpandingStatus.Expanding; _ChildrenLoaded = true; //_Panel.SuspendLayout(); AddChildBefore(MyItemInfo.Cautions, expand); AddChildBefore(MyItemInfo.Notes, expand); AddChildAfter(MyItemInfo.Procedures, expand); if (MyItemInfo.RNOs != null && MyItemInfo.RNOLevel < MyItemInfo.ColumnMode) AddChildRNO(MyItemInfo.RNOs, expand); if (MyItemInfo.RNOs != null && ((MyItemInfo.ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedBackgrounds) == E_PurchaseOptions.EnhancedBackgrounds)) AddChildAfter(MyItemInfo.RNOs, expand); AddChildSupInfo(MyItemInfo.SupInfos, expand); AddChildAfter(MyItemInfo.Tables, expand); / get the config item for the steps section. there is an 'editable' / flag used in metasections to define whether the steps should print. / this flag can be toggle on the section's properties dialog. / Only check the flag if the section has subsections because the / default for the flag is not editable, and this would make non-metasections / not editable. bool hasMetaSubs = MyItemInfo.IsSection && MyItemInfo.Sections != null && MyItemInfo.Sections.Count>0; bool EditSteps = !hasMetaSubs || (MyItemInfo.MyConfig is SectionConfig && (MyItemInfo.MyConfig as SectionConfig).SubSection_Edit == "Y"); if (EditSteps) AddChildAfter(MyItemInfo.Steps, expand);

if (MyItemInfo.RNOs != null && MyItemInfo.RNOLevel >= MyItemInfo.ColumnMode && !((MyItemInfo.ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedBackgrounds) == E_PurchaseOptions.EnhancedBackgrounds)) AddChildRNO(MyItemInfo.RNOs, expand); AddChildAfter(MyItemInfo.Sections, expand); MatchExpanded(); if (MyItemInfo.IsHigh) MyStepPanel.ExpandingHLS = null; } 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; if (_MyChildRelation == ChildRelation.SupInfo) 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; } public int? BottomOfParentSupInfo() { int? bottom = null; if (Colapsing) return null; EditItem parent = this; while (parent != null && parent.MyItemInfo.IsSection = false && parent._MyChildRelation ! ChildRelation.Before) { if (parent._MySupInfoEditItems != null) return parent._MySupInfoEditItems[0].BottomMostEditItem.Bottom; parent = parent.UpOneEditItem; } return bottom; } private string _NextDownEditItemPath = "None"; public string NextDownEditItemPath { get { return _NextDownEditItemPath; } } / <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.MySupInfoEditItems != null && btmNext.MySupInfoEditItems.Count > 0) { int btmSupInfo = btmNext.MySupInfoEditItems[0].FindTop(btm.Bottom); if (btmSupInfo > bottom) bottom = btmSupInfo; } 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))); if (btmNext.Top != 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}',{2},{3}", MyID, MyPath, Top, Bottom); // + "-" + 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 private int SupInfoTopOffset { get { return _MyParentEditItem.MyStepRTB.Location.Y - MyStepRTB.Location.Y; } } protected string _TabFormat; private static int _WidthAdjust = 5; protected bool _IgnoreResize = false; private int FindBottomDevDoc // Find Bottom of a Deviation Document Step { get { int y = BottomMostEditItem.Bottom;// RHM 20170216 Get the bottom most step of a High Level step (RNOs and Substeps) if (MyParentEditItem == null || MyParentEditItem.MyItemInfo.IsSection) { EditItem eitm2 = this; if (eitm2 != null && eitm2.MyBeforeEditItems != null) foreach (EditItem eitm2Tmp in eitm2.MyBeforeEditItems) y = Math.Max(y, eitm2Tmp.Bottom); return y; } y = Math.Max(y, MyParentEditItem.Bottom); EditItem eitm = MyParentEditItem; while (eitm != null && !eitm.MyItemInfo.IsHigh) eitm = eitm.MyParent; if (eitm != null && eitm.MyBeforeEditItems != null) foreach (EditItem eitmTmp in eitm.MyBeforeEditItems) y = Math.Max(y, eitmTmp.Bottom); return y; } } / <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); int widt = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidT); int wids = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidSTableEdit, 0); int width = Math.Max(widt, wids); ItemWidth = MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColT) + width; break; case 1: // Section if (this == TopMostEditItem) { if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format) { if (MyPreviousEditItem != null) { EditItem ei = MyPreviousEditItem.BottomMostEditItem; if (ei.MyItemInfo.IsHigh && (ei.MyItemInfo.Cautions !=null || ei.MyItemInfo.Notes!=null)) { if (ei.MyItemInfo.Cautions!= null)// Look at cautions { EditItem eic = MyStepPanel._LookupEditItems[ei.MyItemInfo.Cautions[0].ItemID].BottomMostEditItem; if (eic.Bottom > ei.Bottom) ei = eic; } if (ei.MyItemInfo.Notes!= null)//Look at notes { EditItem ein = MyStepPanel._LookupEditItems[ei.MyItemInfo.Notes[0].ItemID].BottomMostEditItem; if (ein.Bottom > ei.Bottom) ei = ein; } } // B2017-043 Account for the Horizonal Scroll position when locating the step ItemLocation = new Point(MyStepPanel.DisplayRectangle.X + MyStepPanel.ToDisplay(MyItemInfo.ActiveFormat.MyStepSectionLayoutData.ColS) + 50, ei.Bottom); } else // B2017-043 Account for the Horizonal Scroll position when locating the step ItemLocation = new Point(MyStepPanel.DisplayRectangle.X + MyStepPanel.ToDisplay(MyItemInfo.ActiveFormat.MyStepSectionLayoutData.ColS) + 50, _MyParentEditItem.Bottom); } else 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); //ContentWidth = _WidthAdjust + BorderWidth; /if (MyItemInfo.FormatStepData.WidthOverrideEdit != null && MyItemInfo.FormatStepData.WidthOverrideEdit > 0) / ContentWidth += MyStepPanel.ToDisplay(MyItemInfo.FormatStepData.WidthOverrideEdit); /else / ContentWidth += 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 if (MyStepData.Type.Contains("Figure")) { AdjustTableWidthAndLocation(); } else if (MyItemInfo.IsRtfRaw) { AdjustTableWidthAndLocation(); } else { if (MyItemInfo.FormatStepData.StepLayoutData.AlignWithParentTab) / Paul Linn made the request on 6/4/12 to align the Component Description & / Required Position under the Component Number. ItemLocation = new Point(_MyParentEditItem.ItemLocation.X, _MyParentEditItem.Bottom); / part of F2017-011, for enhanced backgrounds, always align the TitleWithTextRight and TitleWithTextBelow with the parent tab (on the screen) else if ((MyItemInfo.FormatStepData.Type = "TitleWithTextRight" || MyItemInfo.FormatStepData.Type = "TitleWithTextBelow") && ((MyItemInfo.ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedBackgrounds) == E_PurchaseOptions.EnhancedBackgrounds)) / align with parent tab if in background document ItemLocation = new Point(_MyParentEditItem.ItemLocation.X, _MyParentEditItem.Bottom); else if (MyItemInfo.FormatStepData.Type = "TitleWithTextRight" && (MyItemInfo.Steps = null || MyItemInfo.Steps.Count == 0)) // this code is run for siblings within a HLS (but not last sibling). ItemLocation = new Point(_MyParentEditItem.ItemLocation.X, _MyParentEditItem.Bottom); else if (MyItemInfo.MyParent.FormatStepData.Type == "TitleWithTextRight") ItemLocation = new Point(_MyParentEditItem.ItemLocation.X + _MyParentEditItem.ItemWidth + 10, _MyParentEditItem.ItemLocation.Y); // F2017-011 added 10 to fix positoning of Purpose text on sceen (enhanced backgrounds) else if (MyItemInfo.MyTab.Offset != 0) ContentLocation = new Point(_MyParentEditItem.ContentLocation.X + 10, _MyParentEditItem.Bottom); //ItemLocation = new Point(_MyParentEditItem.ItemLocation.X+10, _MyParentEditItem.Bottom); else { // B2016-134 Fix - If a previous step exists, use it to locate the current step if (_MyPreviousEditItem != null) ItemLocation = new Point(_MyParentEditItem.ContentLeft, _MyPreviousEditItem.BottomMostEditItem.Bottom); else { ItemLocation = new Point(_MyParentEditItem.ContentLeft, _MyParentEditItem.Bottom); // if inserting a substep within supplemental information, then may have to adjust steps too: if (MyItemInfo.IsInSupInfo) { AdjustLocation(); // find parent of supinfo & adjust its location: ItemInfo supInfoPart = MyItemInfo; while (!supInfoPart.IsSupInfoPart) supInfoPart = supInfoPart.MyParent; EditItem eitmp = MyStepPanel._LookupEditItems[supInfoPart.ItemID]; eitmp.MyParentEditItem.AdjustLocation(); } } } bool specialTplSupport = ((MyItemInfo.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_PageListSpBckgrnd) == E_DocStructStyle.DSS_PageListSpBckgrnd) || (MyItemInfo.MyDocStyle.LandscapePageList && MyItemInfo.MyDocStyle.ComponentList); bool wecTplSupport = ((MyItemInfo.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_ChklstEditSize) == E_DocStructStyle.DSS_ChklstEditSize); if (MyItemInfo.FormatStepData.ReadOnly) { Graphics g = CreateGraphics(); SizeF sz = g.MeasureString(MyItemInfo.MyContent.Text, MyItemInfo.FormatStepData.Font.WindowsFont); ItemWidth = (int)sz.Width; } else if (MyItemInfo.FormatStepData.Type == "TitleWithTextRight" && specialTplSupport) { Graphics g = CreateGraphics(); SizeF sz = g.MeasureString(MyItemInfo.MyContent.Text, MyItemInfo.FormatStepData.Font.WindowsFont); ItemWidth = (int)sz.Width + 5; } else if (MyItemInfo.FormatStepData.Type == "TitleWithTextBelow" && specialTplSupport) { ItemWidth = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidSTableEdit, 0); } else if (wecTplSupport || (MyItemInfo.MyParent.FormatStepData.Type == "TitleWithTextBelow" && specialTplSupport)) { ItemWidth = MyParentEditItem.ItemWidth - RTBItem.RTBMargin; } else if (MyItemInfo.MyParent.FormatStepData.Type = "TitleWithTextRight" && ((MyItemInfo.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_PageListSpBckgrnd) = E_DocStructStyle.DSS_PageListSpBckgrnd)) { ItemWidth = MyParentEditItem.MyParentEditItem.ContentWidth - MyParentEditItem.ItemWidth; } else if (MyItemInfo.MyParent.FormatStepData.Type == "TitleWithTextRight") { ItemWidth = MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColT) + MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidSTableEdit, 0); ItemWidth = ItemWidth - ItemLocation.X; } else if (MyParentEditItem != null && MyParentEditItem.MyItemInfo.FormatStepData.ReadOnly) ItemWidth = MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColT) + MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidSTableEdit, 0); else if (MyItemInfo.MyTab != null && MyItemInfo.MyTab.Offset != 0) { // Farley - part of bug fix B2015-123 alignment of tabs on the edit screen (Farly is only one using tab offset) ContentWidth = _MyParentEditItem.ContentWidth; int xOffTabNew = (MyItemInfo.MyParent.MyTab != null ? MyItemInfo.MyParent.MyTab.Offset : MyItemInfo.MyParent.OffsetTab) + MyItemInfo.MyTab.Offset; xOffTabNew += MyItemInfo.MyParent.MyTab == null ? 0 : MyItemInfo.MyParent.MyTab.Offset; int xIncrement = xOffTabNew - MyItemInfo.MyTab.Offset; MyStepRTB.Location = new Point(MyStepRTB.Location.X + xIncrement, MyStepRTB.Location.Y); } else ItemWidth = _MyParentEditItem.ContentWidth; } break; } break; case ChildRelation.SupInfo: // on a supplemental info item EditItem high = MyStepPanel._LookupEditItems[MyItemInfo.MyHLS.ItemID]; if (_MyParentEditItem.MyItemInfo.IsNote || _MyParentEditItem.MyItemInfo.IsCaution) { ContentWidth = high.ContentWidth - high.ContentLocation.X; } else ContentWidth = _MyParentEditItem.ContentWidth; / Currently on the supinfo, so MyParentEditItem is the step the supinfo is related to. / From this MyParentEditItem, need to find what is the bottom of the 'previous step' on the screen where 'previous step' can be: / 1) The bottom most EditItem from a caution/note, i.e. MyBeforeEditItems. This must be checked first. / 2) If there is a MyParentEditItem, use it (only MyParentEditItem or MyPreviousEditItem can be set), if going to parent don't use / BottomMostEditItem because that will take it onto this step or subsequent substeps. So just use its bottom. Note that there / are special cases if on a Note/Caution (see below for comments) / 3) If there is no MyBeforeEditItems & no MyParentEditItems, there must be a MyPreviousEditItems. Use its MyBottomMostEditItem's bottom / since this previous may have substeps. int btm = MyParentEditItem.BottomOfStepImmediatelyAbove(); int topp = FindTop(btm, false); if (topp != 0) { MyStepPanel.ItemMoving++; _MyParentEditItem.Top = (int)topp; if (_MyParentEditItem.MyItemInfo.Steps != null && _MyParentEditItem.MyItemInfo.Steps.Count > 0) { EditItem chtmp = GetEditItemFromItemID(_MyParentEditItem.MyItemInfo.Steps[0].ItemID); if (chtmp != null && chtmp._MyParentEditItem != null) { chtmp.Top = chtmp._MyParentEditItem.Bottom; chtmp.AdjustLocation(); } } _MyParentEditItem.AdjustLocation(); MyStepPanel.ItemMoving–; } ContentLocation = new Point(high.ContentLeft + high.Width + 36, (int)_MyParentEditItem.Top + SupInfoTopOffset); // account for Caution/Note tab above caution/note 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; / Use the RNOWidthAlt value if it exists instead of the default RNO width / Note that I needed to add 1 to the ToDisplay() value to be closer to the needed / width for the screen (this does not affect the printout) / If in single column, don't make this adjustment: string[] splitRNOWidthAlt = MyStepSectionLayoutData.RNOWidthAlt.Split(','); int ovrRNOWidth = (RNOLevel < splitRNOWidthAlt.Length)?MyStepPanel.ToDisplay(float.Parse(splitRNOWidthAlt[RNOLevel])+1) : 0; if (MyStepSectionLayoutData.RNOWidthAlt != null && ovrRNOWidth > 1 && MyItemInfo.ColumnMode != 0) ContentWidth = ovrRNOWidth; else 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)); if (_MyParentEditItem.Top != top) _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; int spaceToRTB = 23; _IgnoreResize = false; MyStepPanel.ItemMoving++; //Location = new Point(_MyParentRTBItem.Left + 20, FindTop(_MyParentRTBItem.Top)); int myTop = 0; if (MyNextEditItem == null) myTop = _MyParentEditItem.Top; else myTop = MyNextEditItem.Top;

//if (MyItemInfo.SameRowAsParent && MyItemInfo.IsCaution2) /{ / if (MyItemInfo.WidthOverride > 0) / Width = MyStepPanel.ToDisplay(MyItemInfo.WidthOverride) + spaceToRTB; /} if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && (MyItemInfo.IsCaution || MyItemInfo.IsNote)) { // B2017-043 account for Horizontal Scroll int x = MyStepPanel.DisplayRectangle.X + MyStepPanel.ToDisplay(MyItemInfo.ActiveFormat.MyStepSectionLayoutData.ColT); int y = Top; if (MyPreviousEditItem == null || !MyPreviousEditItem.MyItemInfo.IsCaution || !MyItemInfo.IsNote) y = FindTop(myTop); / Get the "bottom" number of the longest Caution/Note on the step/substep above so that / we can position properly on the screen. // EX. Catawba Deviations E-1 step deviation for step 10 EditItem eitm = (MyParentEditItem.MyPreviousEditItem != null) ? MyParentEditItem.MyPreviousEditItem : MyParentEditItem.MyParentEditItem; if (eitm != null && eitm.MyBeforeEditItems != null) foreach (EditItem eitmTmp in eitm.MyBeforeEditItems) y = Math.Max(y, eitmTmp.Bottom); if (MyItemInfo.IsNote) / Move to the right based upon the Width of the Caution which is the same as the width of the note. { / AdjustChildren width BeforeItem setting Left offset int width = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidT) + spaceToRTB; x += width + 6;//Account for the width of the Caution in the Deviation Document } Location = new Point(x, y); } else Location = new Point(_MyParentEditItem.Left + 20, FindTop(myTop)); // ip2bck's needed the width to be set slightly differently to get the correct width. int widthtpl = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidT) + spaceToRTB; if (MyItemInfo.FormatStepData != null && MyItemInfo.FormatStepData.UseOldTemplate && ((MyItemInfo.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_PageListSpBckgrnd) == E_DocStructStyle.DSS_PageListSpBckgrnd)) widthtpl = MyParentEditItem.Width + MyParentEditItem.Left - Left; Width = widthtpl; // MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidT) + spaceToRTB; MyStepPanel.ItemMoving–; /_MyParentRTBItem.Top = Bottom; / Could be a Caution or Note - Need to get WidT break; } } LastMethodsPop(); } } private int BottomOfStepImmediatelyAbove() { int btm = 0; if (MyBeforeEditItems != null && MyBeforeEditItems.Count > 0) // Notes & Cautions before btm = MyBeforeEditItems[MyBeforeEditItems.Count - 1].BottomMostEditItem.Bottom; else { / if on a caution or note, (the first one), need to go up to either previous step or the section to find its bottom / _MyParentEditItem is a way to find that the structure supports this, i.e. there can be a caution or note: if (_MyParentEditItem != null && _MyParentEditItem.MyBeforeEditItems != null && _MyParentEditItem.MyBeforeEditItems.Count > 0 / this part checks that there are cautions/notes && _MyParentEditItem.MyBeforeEditItems[0].MyID == MyID) / first caution or note, i.e. index of MyBeforeItems == 0 { if (_MyParentEditItem._MyPreviousEditItem == null) / this part checks for first HLS btm = _MyParentEditItem._MyParentEditItem.Bottom; / bottom of the section else btm = _MyParentEditItem._MyPreviousEditItem.BottomMostEditItem.Bottom; // bottom of previous step } else { btm = MyParentEditItem != null ? MyParentEditItem.Bottom : MyPreviousEditItem.BottomMostEditItem.Bottom; } } return btm; } / <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; // the table code goes through the following, rather than 'istablepart' if (MyStepData != null && ((MyStepData.Type.ToLower().Contains("table") || MyStepData.ParentType.ToLower().Contains("table")) || (MyStepData.Type.ToLower().Contains("figure") || MyStepData.ParentType.ToLower().Contains("figure")) || (MyStepData.Type.ToLower().Contains("equation") || MyStepData.ParentType.ToLower().Contains("equation")))) { ItemWidth = TableWidth; Location = new Point(_MyPreviousEditItem.Left, FindTop(_MyPreviousEditItem.BottomMostEditItem.Bottom)); } else if (value.MyItemInfo.IsTablePart) { ItemLocation = new Point(value.MyParentEditItem.ContentLeft, value.Bottom); ItemWidth = value.MyParentEditItem.ContentWidth; } else { if (MyItemInfo.FormatStepData != null && MyItemInfo.FormatStepData.ReadOnly) { Graphics g = CreateGraphics(); SizeF sz = g.MeasureString(MyItemInfo.MyContent.Text, MyItemInfo.FormatStepData.Font.WindowsFont); ItemWidth = (int)sz.Width; } else if (MyPreviousEditItem != null && MyPreviousEditItem.MyItemInfo.FormatStepData != null && MyPreviousEditItem.MyItemInfo.FormatStepData.ReadOnly) ItemWidth = MyStepPanel.ToDisplay(MyStepSectionLayoutData.ColT) + MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidSTableEdit, 0); / RHM The following lines were commented-out for Facing Pages (Supplemental Information) to test follow the instructions //else if (MyItemInfo.MyTab.Offset != 0) / Farley - part of bug fix B2015-123 alignment of tabs on the edit screen (Farly is only one using tab offset) // ContentWidth = (MyPreviousEditItem.MyItemInfo.MyTab.Offset != 0) ? MyPreviousEditItem.ContentWidth : MyPreviousEditItem.ContentWidth + 10; else Width = MyPreviousEditItem.Width;

if (TopMostEditItem == this) { if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && (MyItemInfo.IsNote || MyItemInfo.IsCaution) && (MyPreviousEditItem == null || (MyPreviousEditItem.MyItemInfo.IsCaution && MyItemInfo.IsNote))) //if ((MyItemInfo.SameRowAsParent && MyItemInfo.IsCaution2) || (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && (MyItemInfo.IsNote || MyItemInfo.IsCaution))) { // B2017-043 account for Horizontal Scroll int x = MyStepPanel.DisplayRectangle.X + MyStepPanel.ToDisplay(MyItemInfo.ActiveFormat.MyStepSectionLayoutData.ColT); if (MyItemInfo.IsNote) x += Width + 6; //Find first sibling EditItem prev = _MyPreviousEditItem; while (prev._MyPreviousEditItem != null) prev = prev._MyPreviousEditItem; Location = new Point(x, prev.Top);// Use the top of the first sibling } else { int top = FindTop(_MyPreviousEditItem.BottomMostEditItem.Bottom); if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && _MyPreviousEditItem.MyItemInfo.IsHigh) //if (MyItemInfo.SameRowAsParent || (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && _MyPreviousEditItem.MyItemInfo.IsHigh)) { if (_MyPreviousEditItem.MyBeforeEditItems != null) foreach (EditItem ei in _MyPreviousEditItem.MyBeforeEditItems) top = Math.Max(top, ei.Bottom); } Location = new Point(_MyPreviousEditItem.Left, top); // B2017-029 only do this if this is a the deviation document AdjustForDevDocStepHeight(); AdjustAllForSupInfoHeight(); } } 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.SupInfo: break; case ChildRelation.Before: //MyStepPanel.ItemMoving++; //UpOneRTBItem.Top = BottomMostRTBItem.Bottom; //MyStepPanel.ItemMoving–; break; } if (_MyPreviousEditItem.MyNextEditItem != this) _MyPreviousEditItem.MyNextEditItem = this; } LastMethodsPop(); } } / AdjustAllForSupInfoHeight & AdjustFOrSupInfoHeight go from current edit item down, adjusting any of the edit items' top / location to account for any supplemental informations that items may have so that either the step or its supplemental information // does not overwrite other steps on screen. private void AdjustAllForSupInfoHeight() { EditItem ei = this; while (ei != null) { ei = ei.AdjustForSupInfoHeight(); } } private EditItem AdjustForSupInfoHeight() { if (MyStepPanel._LookupEditItems.ContainsKey(MyID) && MyItemInfo.IsInSupInfo) // only do this if it is displayed (in LookupEditItems and in sup info column { ItemInfo supInfoPart = MyItemInfo; while (!supInfoPart.IsSupInfoPart) supInfoPart = supInfoPart.MyParent; EditItem EIsupInfoPartAbove = MyStepPanel._LookupEditItems[supInfoPart.ItemID];

/ find first edititem below this (EIWsupInfoBelow) or a sibling or child child that have sup info / if found, adjust top of this item to the bottommost edititem above this EditItem EIWsupInfoBelow = null; EIWsupInfoBelow = EIsupInfoPartAbove.MyParentEditItem.FindFirstChildWithSupInfo(EIsupInfoPartAbove.MyParentEditItem.MyItemInfo); if (EIWsupInfoBelow == null) EIWsupInfoBelow = EIsupInfoPartAbove.MyParentEditItem.FindSiblingOrParentSiblingWithSupInfo(EIsupInfoPartAbove.MyParentEditItem.MyItemInfo);

if (EIWsupInfoBelow != null) // for editiem below, find bottom of step & subinfo column and take the max of these: { int bottomOfAboveSupInfoColumn = EIsupInfoPartAbove.BottomMostEditItem.Bottom; int bottomOfImmediatelyAbove = EIWsupInfoBelow.BottomOfStepImmediatelyAbove(); MyStepPanel.ItemMoving++; EIWsupInfoBelow.Top = Math.Max(bottomOfAboveSupInfoColumn, bottomOfImmediatelyAbove); EIWsupInfoBelow.AdjustLocation(); MyStepPanel.ItemMoving–; return EIWsupInfoBelow.MySupInfoEditItems==null?null:EIWsupInfoBelow.MySupInfoEditItems[0]; } } return null; } private EditItem CheckForExpanded(EditItem ei) { ItemInfo hls = ei.MyItemInfo.MyHLS; EditItem hlsEI = GetEditItemFromItemID(hls.ItemID); if (hlsEI==null) return null; return ei; } // FindSiblingOrParentSiblingWithSupInfo will find the next edititem below me on the screen that has a supinfo private EditItem FindSiblingOrParentSiblingWithSupInfo(ItemInfo itm) { if (itm = null || itm.IsProcedure) return null; if (itm.NextItem = null) { return FindSiblingOrParentSiblingWithSupInfo(itm.ActiveParent as ItemInfo); } EditItem chldOfNext = null; // if section, handle notes/cautions on section and if none, look for hls (children of section) if (itm.NextItem.IsSection) { if (itm.NextItem.Steps = null || itm.NextItem.Steps.Count = 0) return null; chldOfNext = FindFirstCautionOrNoteWithSupInfo(itm.NextItem); if (chldOfNext != null) return CheckForExpanded(chldOfNext); chldOfNext = FindFirstChildWithSupInfo(itm.NextItem); if (chldOfNext != null) return CheckForExpanded(chldOfNext); return null; } // Handle caution/note off of itm.nextitem. See if any of those have supinfos. chldOfNext = FindFirstCautionOrNoteWithSupInfo(itm.NextItem); if (chldOfNext != null) return CheckForExpanded(chldOfNext);

/ this is step side (parent) of supinfo part. This step does not have any children with supinfo. / See if any of my next siblings have supinfo if (itm.NextItem.SupInfos != null && itm.NextItem.SupInfos.Count > 0) { return GetEditItemFromItemID(itm.NextItem.ItemID); } // no longer looking at next, go to children. chldOfNext = FindFirstChildWithSupInfo(itm.NextItem); if (chldOfNext != null) return CheckForExpanded(chldOfNext); return FindSiblingOrParentSiblingWithSupInfo(itm.NextItem); } / FindFirstChildWithSupinfo finds the first child going down the screen that has a supinfo. It checks for cautions and / notes first. private EditItem FindFirstChildWithSupInfo(ItemInfo itm) { // If on a caution, see if there are any notes below me on the screen that have supinfo. if (itm.IsCaution && (itm.ActiveParent as ItemInfo).Notes != null && (itm.ActiveParent as ItemInfo).Notes.Count > 0) { foreach (ItemInfo inote in (itm.ActiveParent as ItemInfo).Notes) { if (inote.SupInfos != null && inote.SupInfos.Count > 0) return GetEditItemFromItemID(inote.ItemID); EditItem chld = FindFirstChildWithSupInfo(inote); if (chld != null) return CheckForExpanded(chld); } } // if on a caution or note check the step below me, which is really my activeparent (cautions/notes are above their respective parent) if ((itm.IsCaution || itm.IsNote) && (itm.NextItem = null || itm.NextItemCount = 0) && (itm.ActiveParent as ItemInfo).SupInfos != null && (itm.ActiveParent as ItemInfo).SupInfos.Count > 0) return GetEditItemFromItemID((itm.ActiveParent as ItemInfo).ItemID);

// Finally check substeps: if (itm.Steps = null || itm.Steps.Count = 0) return null; foreach (ItemInfo ii in itm.Steps) { if (ii.SupInfos != null && ii.SupInfos.Count > 0) return GetEditItemFromItemID(ii.ItemID); EditItem chld = FindFirstChildWithSupInfo(ii); if (chld != null) return CheckForExpanded(chld); } return null; } // FindFirstCautionOrNoteWithSupInfo looks for first caution or note going down the screen that has supInfo private EditItem FindFirstCautionOrNoteWithSupInfo(ItemInfo itm) { if (itm.Cautions != null && itm.Cautions.Count > 0) { foreach (ItemInfo ii in itm.Cautions) { if (ii.SupInfos != null && ii.SupInfos.Count > 0) return GetEditItemFromItemID(ii.ItemID); EditItem chld = FindFirstChildWithSupInfo(ii); if (chld != null) return CheckForExpanded(chld); } } if (itm.Notes != null && itm.Notes.Count > 0) { foreach (ItemInfo ii in itm.Notes) { if (ii.SupInfos != null && ii.SupInfos.Count > 0) return GetEditItemFromItemID(ii.ItemID); EditItem chld = FindFirstChildWithSupInfo(ii); if (chld != null) return CheckForExpanded(chld); } } return null; } private EditItem GetEditItemFromItemID(int itemid) { if (!MyStepPanel._LookupEditItems.ContainsKey(itemid)) return null; return MyStepPanel._LookupEditItems[itemid]; } / <summary> / Adjust the height of a Deviation Document Step Including the Cautions and Notes B2016-123, B2017-020, B2017-021 / </summary> private void AdjustForDevDocStepHeight() { if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && MyParent.MyItemInfo.IsHigh) { int bot = MyParent.FindBottomDevDoc; int DDHeight = bot - FirstSiblingEditItem.Top;//Determine the height of the step including cautions and notes if (MyParent.DevDocHeight != DDHeight) { MyParent.DevDocHeight = DDHeight;// If the height has changed adjust the top of the next item down EditItem ei = NextDevDocStep;// RHM 20170216 Locate Next Dev Doc Step if (ei != null) { ei.Top = bot; ei.AdjustLocation(); } } } } / RHM 20170216 - Find Next Dev Doc High Level Step / If caution Exists return caution // If note exists return note private EditItem NextDevDocStep { get { EditItem ei = this; while (ei != null && !ei.MyItemInfo.IsHigh) ei = ei.MyParent;// Get High Level Step if(ei != null) ei=ei.MyNextEditItem;// Get Next High Level Step if (ei != null) { if (ei.MyItemInfo.IsHigh && (ei.MyItemInfo.Cautions != null || ei.MyItemInfo.Notes != null)) { if (ei.MyItemInfo.Cautions != null)// Look at cautions { EditItem eic = MyStepPanel._LookupEditItems[ei.MyItemInfo.Cautions[0].ItemID].BottomMostEditItem; ei = eic; } else if (ei.MyItemInfo.Notes != null)//Look at notes { EditItem ein = MyStepPanel._LookupEditItems[ei.MyItemInfo.Notes[0].ItemID].BottomMostEditItem; ei = ein; } } } return ei; } } // RHM 20170216 Find Parent by walking up MyPrevious private EditItem MyParent { get { if (MyParentEditItem != null) return MyParentEditItem; return MyPreviousEditItem.MyParent; } } protected void SetupEditItem(ItemInfo itemInfo, StepPanel myStepPanel, EditItem myParentEditItem, ChildRelation myChildRelation, bool expand, EditItem nextEditItem, bool addFirstChld) { if (myStepPanel.TopMostEditItem = null) myStepPanel.TopMostEditItem = this; //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 / Fix for B2016-037: there were '<NewID>'s in saved content text. This was caused by a bug in code that / did not resolve these correctly if there was more than 1 in the text. So if, when loading the text, this / is found, resolve them: if (itemInfo.MyContent.Text.Contains("<NewID>")) { DisplayText vlntxt = new DisplayText(itemInfo, E_EditPrintMode.Edit, E_ViewMode.Edit, false, E_FieldToEdit.StepText, true, null, null, false); vlntxt.SetDTS = false; vlntxt.CleanUpNewIDs(); vlntxt = null; } ContentFont = myStepPanel.StepFont;//lblTab.Font = myStepPanel.StepFont; if (itemInfo.MyTab != null ) 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, addFirstChld); break; case ChildRelation.Before: AddItem(myParentEditItem, ref myParentEditItem._MyBeforeEditItems, nextEditItem, addFirstChld); break; case ChildRelation.RNO: RNOLevel = myParentEditItem.RNOLevel + 1; AddItem(myParentEditItem, ref myParentEditItem._MyRNOEditItems, nextEditItem, addFirstChld); break; case ChildRelation.SupInfo: AddItem(myParentEditItem, ref myParentEditItem._MySupInfoEditItems, nextEditItem, addFirstChld); break; case ChildRelation.None: break; } if (itemInfo != null) { // ip2bck's needed the ContentWidth set to get the edit windows to size correctly. if (itemInfo.IsStep && itemInfo.FormatStepData.Type = "TitleWithTextBelow" && ((itemInfo.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_PageListSpBckgrnd) = E_DocStructStyle.DSS_PageListSpBckgrnd)) ContentWidth = myParentEditItem.ContentWidth; if (itemInfo.IsStep && itemInfo.MyParent.IsFigure) { ContentWidth = myParentEditItem.MyParentEditItem.ContentWidth; Left = MyParentEditItem.MyParentEditItem.Left + MyParentEditItem.MyParentEditItem.TabLeft; }

if (myChildRelation == ChildRelation.None) { if (ContentType = 0 && MyStepSectionLayoutData ! null) { LastMethodsPush(string.Format("SetupRTBItem {0}", MyID)); int widt = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidT); int wids = MyStepPanel.ToDisplay(MyStepSectionLayoutData.WidSTableEdit, 0); ItemWidth = Math.Max(widt, wids); } } } // TIMING: DisplayItem.TimeIt("CSLARTB Parent"); SetText(); if (itemInfo.IsSupInfoPart) { EditItem high = MyStepPanel._LookupEditItems[itemInfo.MyHLS.ItemID]; ContentLocation = new Point(high.ContentLeft + high.Width + 36, (int)_MyParentEditItem.Top + SupInfoTopOffset); } // 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); / If on the first Caution/Note and the parent has a previous, for example a caution off of 5th HLS, go to the // bottom on the previous parent. In the example, the bottom of the 4th HLS. int btm = myStepPanel.DisplayRectangle.Y; int top = FindTop(btm); if (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format) if (MyItemInfo.IsCaution || MyItemInfo.IsNote) top = myParentEditItem.TopMostEditItem.Top; /if ((MyItemInfo.SameRowAsParent && MyItemInfo.IsCaution2) || (MyItemInfo.ActiveFormat.MyStepSectionLayoutData.Dev_Format && (MyItemInfo.IsCaution || MyItemInfo.IsNote))) / top = myParentEditItem.TopMostEditItem.Top; if (Top < top) { LastMethodsPush("SetupRTBItem"); MyStepPanel.ItemMoving++; Top = top; MyStepPanel.ItemMoving–; LastMethodsPop(); } this.Enabled = this.MyItemInfo.IsApplicable(MyStepPanel.ApplDisplayMode); _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(); if (ChangeBarForConfigItemChange) itm.MyContent.DTS = DateTime.Now; itm.MyContent.UserID = Volian.Base.Library.VlnSettings.UserID; 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); / Show a small E to indicate Enhanced Steps DVEnhancedDocuments dveds = MyItemInfo.MyDocVersion.DocVersionConfig.MyEnhancedDocuments; float x = 0; float y = 0; foreach (EnhancedDocument ed in MyItemInfo.GetMyEnhancedDocuments()) { DVEnhancedDocument dved = dveds.GetByType(ed.Type); Font fnt = new System.Drawing.Font("Arial", 5); //g.DrawLine(Pens.DarkGreen, 18, 1, 18, 6); //g.DrawLine(Pens.DarkGreen, 18, 1, 21, 1); //g.DrawLine(Pens.DarkGreen, 18, 3, 21, 3); //g.DrawLine(Pens.DarkGreen, 18, 6, 21, 6); //g.DrawString("B", fnt, Brushes.Green, new RectangleF(new PointF(0,0), this.Size), StringFormat.GenericDefault); g.DrawString(dved.PdfToken, fnt, Brushes.Green, new RectangleF(new PointF(x,y), this.Size), StringFormat.GenericDefault); if (y > 0) { x += 18; y = 0; } else y = 14; } //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); Font myWFont = (MyItemInfo.MyTab != null) ? MyItemInfo.MyTab.MyFont.WindowsFont : MyItemInfo.FormatStepData.Font.WindowsFont; g.DrawString(TabText, myWFont, Brushes.Black, new RectangleF(new PointF(Convert.ToSingle(TabLocation.X), Convert.ToSingle(TabLocation.Y)), this.Size), 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 { float X; float H; if (this is GridItem) { GridItem gi = this as GridItem; X = gi.MyFlexGrid.Right+2; H = gi.MyFlexGrid.Height; } else if (this is RtfRawItem) { RtfRawItem ri = this as RtfRawItem; X = ri.MyStepRTB.Right + 4; H = ri.MyStepRTB.Height; } else if (this is ImageItem) { ImageItem ii = this as ImageItem; X = ii.MyPictureBox.Right + 4; H = ii.MyPictureBox.Height; } else { RTBItem ri = this as RTBItem; X = ri.MyStepRTB.Right + 2; H = ri.MyStepRTB.Height; } g.DrawLine(penCB, X, ContentTop, X, ContentTop+H); //Height); } } if (UserCheckOff) { PointF location; if (this is GridItem) { GridItem gi = this as GridItem; location = new PointF(gi.MyFlexGrid.Left + gi.MyFlexGrid.Width + 2, gi.MyFlexGrid.Top); } else if (this is RtfRawItem) { RtfRawItem rr = this as RtfRawItem; / SkipSpaces puts the checkoff macro (if specified in the format) next to the step tab / this is used for Bryon and Braidwood if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.SkipSpaces) location = new PointF(rr.MyStepRTB.Left - 50, rr.MyStepRTB.Top); else location = new PointF(rr.MyStepRTB.Left + rr.MyStepRTB.Width + 2, rr.MyStepRTB.Top); } else if (this is ImageItem) { ImageItem ii = this as ImageItem; if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.SkipSpaces) location = new PointF(ii.MyPictureBox.Left - 50, ii.MyPictureBox.Top); else location = new PointF(ii.MyPictureBox.Left + ii.MyPictureBox.Width + 2, ii.MyPictureBox.Top); } else { RTBItem ri = this as RTBItem; / SkipSpaces puts the checkoff macro (if specified in the format) next to the step tab / this is used for Bryon and Braidwood if (MyItemInfo.ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.SkipSpaces) location = new PointF(ri.MyStepRTB.Left - 50, ri.MyStepRTB.Top); else location = new PointF(ri.MyStepRTB.Left + ri.MyStepRTB.Width + 2, ri.MyStepRTB.Top); } CheckOff co = MyItemInfo.GetCheckOffStep(); / There may have been a data change in the setting of which checkoff to use (property / change in the config data), or whether a checkoff is used at all. Need to set the // 'UserCheckOff' or 'UserCheckOffChar' properties to reflect that. if (co != null && co.UIMark != null) { UserCheckOffChar = (char)co.UIMark; Font myFont = new Font("VolianDraw", MyItemInfo.MyTab.MyFont.WindowsFont.Size); g.DrawString(UserCheckOffChar.ToString(), myFont, Brushes.DarkGreen, new RectangleF(location, MyStepPanel.MyStepPanelSettings.NumberSize), StringFormat.GenericDefault); } else if (co == null) UserCheckOff = false; } } } }