Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
be6576925163c8589500a0ebff3f2fb067340183
SourceCode/PROMS/VEPROMS.CSLA.Library/Extension/ItemExt.cs
John 22978ffff5 B2019-165 Added a check box on the automation tab to allow user to turn off the printing of a foldout page on the last page of a Word document that does not include foldouts (Byron/Braidwood) 
Code cleanup, found a missed instance of a check for “FOLDOUT” as section number – corrected so that it using the Section_IsFoldout method instead
2019-11-13 17:11:51 +00:00

7880 lines
264 KiB
C#
Raw Blame History

#define ItemWithContent
using System;
using System.Collections.Generic;
using System.Text;
using Csla;
using Csla.Data;
using System.Data;
using System.Data.SqlClient;
using System.Xml;
using System.Drawing;
using System.Text.RegularExpressions;
using Volian.Base.Library;
namespace VEPROMS.CSLA.Library
{
#region Item
public partial class Item : IVEDrillDown
{
// put in for debug
//public static int CacheCountPrimaryKey
//{ get { return _CacheByPrimaryKey.Count; } }
//public static int CacheCountList
//{ get { return _CacheList.Count; } }
public string DisplayNumber
{
get { return ItemInfo.ConvertToDisplayText(MyContent.Number); }
}
public ItemInfo MyItemInfo /* Return Info version of the current Item */
{ get { return ItemInfo.Get(ItemID); } }
public static void ShowAllocated(string title)
{
Console.WriteLine("{0} - {1} Items in the dictionary", title, _CacheByPrimaryKey.Count);
foreach (List<Item> itmlst in _CacheByPrimaryKey.Values)
foreach (Item itm in itmlst)
Console.WriteLine("Item {0} UniqueID {1}", itm.ItemID, itm.MyItemUnique);
Console.WriteLine("- - - - - -");
}
public override string ToString()
{
return string.Format("{0} {1}", MyContent.Number, MyContent.Text).Trim();
}
// TODO: Move to ItemInfo Extension
#region IVEDrillDown
//public System.Collections.IList GetChildren()
//{
// return this.MyContent.ContentParts;
//}
//public bool HasChildren
//{
// get { return this.MyContent.ContentPartCount > 0; }
//}
//public Item MyProcedure
//{
// get
// {
// // Walk up active parents until the parent is not an item
// Item tmp = this;
// while (tmp.ActiveParent.GetType() != typeof(DocVersion)) tmp = (Item)tmp.ActiveParent;
// return tmp;
// }
//}
//private IVEDrillDown _ActiveParent = null;
//public IVEDrillDown ActiveParent
//{
// get
// {
// if (_ActiveParent == null)
// {
// if (MyPrevious != null)
// _ActiveParent = _MyPrevious.ActiveParent;
// else
// {
// if (ItemDocVersionCount > 0)
// _ActiveParent = this.ItemDocVersions[0].MyDocVersion;
// else
// {
// if (this.ItemParts == null || this.ItemPartCount == 0)
// _ActiveParent = this;
// else
// _ActiveParent = this.ItemParts[0].MyContent.ContentItems[0].MyItem;
// }
// }
// }
// return _ActiveParent == this ? null : _ActiveParent;
// }
//}
//private Format _ActiveFormat = null;// Added to cache ActiveFormat
//public Format ActiveFormat
//{
// get
// {
// if (_ActiveFormat == null)
// _ActiveFormat = (LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat);
// return _ActiveFormat;
// }
// set
// {
// _ActiveFormat = null; // Reset
// }
//}
//public Format LocalFormat
//{
// get { return MyContent.MyFormat; }
//}
public ConfigDynamicTypeDescriptor MyConfig
{
get { return null; }
}
#endregion
public void MoveItem(IVEDrillDownReadOnly pInfo, int index)
{
bool wasfirstchild = false;
ItemInfo parentInfo = pInfo as ItemInfo;
DocVersionInfo parentInfoDV = pInfo as DocVersionInfo;
IList<ItemInfo> children = null;
E_FromType partType = 0; // this is needed later to determine sub-group type.
if (parentInfo != null)
{
// this may have subgroups, need to use part type to get children list...
ItemInfo thisinfo = ItemInfo.Get(ItemID);
partType = thisinfo.FirstSibling.ItemParts[0].PartType;
children = (IList<ItemInfo>)parentInfo.Lookup((int)partType);
}
else
children = (IList<ItemInfo>)parentInfoDV.GetChildren();
int numChild = children.Count;
if (this.PreviousID == null) wasfirstchild = true;//Use PreviousID rather than MyPrevious so the item is not cached
Item origNextItem = null;
// First, remove from this item from its list. To do this, get the current item's next point and redirect it's myprevious
// to this item's previous...
if (NextItems != null && NextItems.Count > 0)
{
origNextItem = NextItems.Items[0];
origNextItem.MyPrevious = this.MyPrevious;
this.Save();
}
// check to see if the item is being moved into the middle of some items. newPreviousItem is the item defined
// by index-1, i.e. inserting below newPreviousItem.
ItemInfo newPreviousInfo = (index == 0) ? null : children[index - 1];
ItemInfo newNextInfo = (index == children.Count) ? null : children[index];
// Adjust the new next proc to be me.
if (newNextInfo != null)
{
using (Item newNextItem = newNextInfo.Get())
{
newNextItem.MyPrevious = this;
newNextItem.Save();
}
}
// adjust the previous node, i.e. may either be at same level or, if first in list, adjust the parent...
// if 'newPreviousItem' isn't null, then adding to the middle of the list.
if (newPreviousInfo != null)
{
using (Item newPreviousItem = newPreviousInfo.Get())
{
MyPrevious = newPreviousItem;
Save();
}
}
else// RHM 2/20/2013 Moving Change
{
MyPrevious = null;
// Console.WriteLine(">Setting MyPrevious Null {0}", ItemID);
Save();
// Console.WriteLine("'Moved','e{0}','u{1}','{2}',{3}", ItemID, _MyItemUnique, StringIt(_LastChanged), index);
ItemInfo.RefreshParent(this, parentInfo);
//Console.WriteLine("<Setting MyPrevious Null {0}", ItemID);
}
// newPreviousInfo == null if moving into first child, and wasfirstchild == true if moving out of first child.
// This will require adjusting the DocVersion to point to the correct first child if a procedure is moved.
if (newPreviousInfo == null || wasfirstchild)
{
if (parentInfo != null) // Moving Item within procedure, i.e. moving a section or step
{
using (Item parentItem = parentInfo.Get())
{
// moving first child out... reset parent to point to the original next item
if (wasfirstchild)
{
parentItem.MyContent.ContentParts[(int)partType].MyItem = origNextItem;
newPreviousInfo.RefreshItemParts();
}
else
parentItem.MyContent.ContentParts[(int)partType].MyItem = this;
parentItem.Save();
}
}
else if (parentInfoDV != null) // Moving Item (Procedure) within DocVersion
{
using (DocVersion parentItemDV = parentInfoDV.Get())
{
ItemInfo firstinfo = parentInfoDV.FirstChild();
parentItemDV.MyItem = wasfirstchild ? parentInfoDV.Procedures[1].Get() : this;
parentItemDV.Save();
if (!wasfirstchild && firstinfo != null)
{
using (Item firstchild = firstinfo.Get())
{
firstchild.MyPrevious = this;
firstchild.Save();
}
}
}
}
if (!wasfirstchild)
{
this.MyPrevious = null;
this.Save();
}
if (origNextItem != null) origNextItem.Dispose();
if (parentInfo != null)
parentInfo.MyContent.RefreshContentParts();
}
//ShowItemAndSections("After MoveItem", pInfo as ItemInfo);
if (parentInfoDV != null)
DocVersionInfo.ResetProcedures(parentInfoDV.VersionID);
if (parentInfo != null)
ItemInfo.ResetParts(parentInfo.ItemID);
//ShowItemAndSections("After Refresh", pInfo as ItemInfo);
}
//private static string StringIt(byte[] _LastChanged)
//{
// StringBuilder sb = new StringBuilder();
// for (int i = 0; i < _LastChanged.Length; i++)
// sb.Append(string.Format("{0:X2}",_LastChanged[i]));
// return sb.ToString();
//}
//private void ShowItemAndSections(string title, ItemInfo pinfo)
//{
//
// pinfo.ShowThis(title + "-Parent");
// int i=0;
// foreach (ItemInfo child in pinfo.Sections)
// child.ShowThis(title + string.Format("-Child {0}", ++i));
//}
protected static int MakeNewItem(IVEDrillDownReadOnly parentInfoDD, ItemInfo previousInfo, string number, string title, int type, E_FromType partType)
{
int newitemid = 0;
if (parentInfoDD == null)
parentInfoDD = previousInfo.ActiveParent;
ItemInfo parentInfo = parentInfoDD as ItemInfo;
DocVersionInfo parentInfoDV = parentInfoDD as DocVersionInfo;
using (Content cont = Content.New(number, title, type, null, null))
{
using (Item fromitem = previousInfo == null ? null : previousInfo.Get())
{
ItemInfo nextInfo = null; // Check to see if the item is being inserted in the middle of some items.
if (previousInfo != null)
nextInfo = previousInfo.GetNext();
using (Item itm = Item.MakeItem(fromitem, cont))
{
newitemid = itm.ItemID;
if (nextInfo != null)
{
using (Item nextItem = nextInfo.Get())
{
nextItem.MyPrevious = itm;// Aim the next item back at the new item.
nextItem.Save();
}
}
if (fromitem == null)
{
if (parentInfo != null) // Adding Item to Procedure, Section or Step
{
using (Item parentItem = parentInfo.Get())
{
ItemInfo firstinfo = parentInfo.FirstChild(partType);
if (firstinfo != null)
{
using (Item firstchild = firstinfo.Get())
{
parentItem.MyContent.ContentParts[(int)partType].MyItem = itm;// First update the parent to point to the new first child
parentItem.Save();
firstchild.MyPrevious = itm;// Aim the old first child to point to the new first child.
firstchild.Save();
}
}
else
{
parentItem.MyContent.ContentParts.Add((int)partType, itm);// update the parent to point to the new first child
parentItem.Save();
}
}
}
if (parentInfoDV != null) // Adding Item (Procedure) to DocVersion
{
using (DocVersion parentItemDV = parentInfoDV.Get())
{
int? oldItemID = parentItemDV.ItemID;
parentItemDV.MyItem = itm;// First update the parent to point to the new first child
parentItemDV.Save();
if (oldItemID != null)
{
using (Item firstchild = Item.Get((int)oldItemID))
{
firstchild.MyPrevious = itm;// Aim the old first child to point to the new first child.
firstchild.Save();
}
}
}
}
}
}
}
}
if (parentInfo != null)
parentInfo.MyContent.RefreshContentParts();
if (parentInfoDV != null)
parentInfoDV.ResetProcedures();
return newitemid;
}
}
#endregion
#region ItemInfo
public partial class ItemInfo : IVEDrillDownReadOnly
{
private bool _PrintAllAtOnce = false;
public bool PrintAllAtOnce
{
get { return _PrintAllAtOnce; }
set { _PrintAllAtOnce = value; }
}
public SectionInfo GetSectionInfo()
{
if (this is SectionInfo) return this as SectionInfo;
return SectionInfo.Get(ItemID);
}
public StepInfo GetStepInfo()
{
if (this is StepInfo) return this as StepInfo;
return StepInfo.Get(ItemID);
}
public ProcedureInfo GetProcedureInfo()
{
if (this is ProcedureInfo) return this as ProcedureInfo;
return ProcedureInfo.Get(ItemID);
}
private string _EnhType = null;
public string EnhType
{
get
{
if (_EnhType != null) return _EnhType;
if (!IsSection)
_EnhType = "";
else
{
// get the section's enhtype from the config
SectionConfig sc = MyConfig as SectionConfig;
_EnhType = sc.Section_LnkEnh;
}
return _EnhType;
}
}
public bool InList(params int[] IDs)
{
foreach (int id in IDs)
if (id == ItemID) return true;
return false;
}
public static bool IsInCache(int itemID)
{
return _CacheByPrimaryKey.ContainsKey(itemID.ToString());
}
public static string ReplaceLinkWithNewID(string tmpForLink)
{
tmpForLink = Regex.Replace(tmpForLink, @"#Link:ReferencedObject:[0-9]+ ", @"#Link:ReferencedObject:<NewID> ");
tmpForLink = Regex.Replace(tmpForLink, @"#Link:Transition:([0-9]+) [0-9]+ ", @"#Link:Transition:$1 <NewID> ");
tmpForLink = Regex.Replace(tmpForLink, @"#Link:TransitionRange:([0-9]+) [0-9]+ ", @"#Link:TransitionRange:$1 <NewID> ");
tmpForLink = tmpForLink.Replace(@"\u8212 \'96", @"-"); // Replace EM Dash with hyphen
tmpForLink = tmpForLink.Replace(@"\u8211 \'96", @"-"); // Replace EN Dash with hyphen
tmpForLink = tmpForLink.Replace(@"\u8212 ", @"-"); // Replace EM Dash with hyphen
tmpForLink = tmpForLink.Replace(@"\u8211 ", @"-"); // Replace EN Dash with hyphen
return tmpForLink;
}
public void SetHeader(VE_Font myFont, string myText)
{
_MyHeader = new MetaTag(myFont);
_TagsSetup = true;
_MyHeader.CleanText = myText;
_MyHeader.Text = myText;
_MyHeader.Justify = ContentAlignment.MiddleCenter;
}
public void MoveItem(IVEDrillDownReadOnly pInfo, int index)
{
using (ItemInfoList movedItems = ItemInfoList.GetMoveItem(ItemID, index))
{
foreach (ItemInfo itm in movedItems)
ItemInfo.Refresh(itm);
}
DocVersionInfo parentInfoDV = pInfo as DocVersionInfo;
if (parentInfoDV != null)
DocVersionInfo.ResetProcedures(parentInfoDV.VersionID);
ItemInfo parentInfo = pInfo as ItemInfo;
if (parentInfo != null)
ItemInfo.ResetParts(parentInfo.ItemID);
}
public static void Refresh(ItemInfo tmp)
{
string key = tmp.ItemID.ToString();
ConvertListToDictionary();
if (_CacheByPrimaryKey.ContainsKey(key))
foreach (ItemInfo tmpInfo in _CacheByPrimaryKey[key])
tmpInfo.RefreshFields(tmp);
}
protected virtual void RefreshFields(ItemInfo tmp)
{
if (_PreviousID != tmp.PreviousID)
{
if (MyPrevious != null) MyPrevious.RefreshNextItems(); // Update List for old value
_PreviousID = tmp.PreviousID; // Update the value
}
_MyPrevious = null; // Reset list so that the next line gets a new list
if (MyPrevious != null) MyPrevious.RefreshNextItems(); // Update List for new value
//if (_ContentID != tmp.ContentID)
//{
if (MyContent != null) MyContent.RefreshContentItems(); // Update List for old value
_ContentID = tmp.ContentID; // Update the value
//}
_MyContent = null; // Reset list so that the next line gets a new list
if (MyContent != null) MyContent.RefreshContentItems(); // Update List for new value
_DTS = tmp.DTS;
_UserID = tmp.UserID;
_ItemInfoExtension.Refresh(this);
OnChange();// raise an event
}
private bool _Moving = false;
public bool Moving
{
get { return _Moving; }
set { _Moving = value; }
}
public static void RefreshParent(Item tmp, ItemInfo pInfo)
{
string key = tmp.ItemID.ToString();
ConvertListToDictionary();
if (_CacheByPrimaryKey.ContainsKey(key))
foreach (ItemInfo tmpInfo in _CacheByPrimaryKey[key])
{
tmpInfo._ActiveParent = pInfo;
tmpInfo.RefreshItemParts();
}
}
private string _HighLevelStepTabPageList = null;
public string HighLevelStepTabPageList
{
get { return _HighLevelStepTabPageList; }
set { _HighLevelStepTabPageList = value; }
}
private bool _NewTransToUnNumberedItem = false;
public bool NewTransToUnNumberedItem
{
get { return _NewTransToUnNumberedItem; }
set { _NewTransToUnNumberedItem = value; }
}
// put in for debugging
//public static int CacheCountPrimaryKey
//{ get { return _CacheByPrimaryKey.Count; } }
//public static int CacheCountList
//{ get { return _CacheList.Count; } }
//public override bool Equals(object obj)
//{
// ItemInfo ii = obj as ItemInfo;
// if (ii != null)
// return ii._ItemID == _ItemID;
// return false;
//}
internal static void SetFromType(ItemInfo myItemInfo)
{
myItemInfo.PrintAllAtOnce = true;
if (myItemInfo.MyContent.ContentPartCount > 0)
{
foreach (PartInfo pi in myItemInfo.MyContent.ContentParts)
{
ItemInfo il = null;
switch ((E_FromType)pi.FromType)
{
case E_FromType.Procedure:
myItemInfo._Procedures = pi.MyItems;
break;
case E_FromType.Section:
myItemInfo._Sections = pi.MyItems;
break;
case E_FromType.Step:
myItemInfo._Steps = pi.MyItems;
break;
case E_FromType.Caution:
myItemInfo._Cautions = pi.MyItems;
break;
case E_FromType.Note:
myItemInfo._Notes = pi.MyItems;
break;
case E_FromType.RNO:
myItemInfo._RNOs = pi.MyItems;
break;
case E_FromType.Table:
myItemInfo._Tables = pi.MyItems;
break;
case E_FromType.SupInfo:
myItemInfo._SupInfos = pi.MyItems;
break;
}
foreach (ItemInfo ii in pi.MyItems)
{
ii.FromType = (E_FromType)pi.FromType;
SetFromType(ii);
ii.MyPrevious = il;
il = ii;
}
}
}
}
internal static void SetParentSectionAndDocVersion(ItemInfo itemInfo, IVEDrillDownReadOnly itemParent, SectionInfo sectionInfo, ProcedureInfo procInfo, DocVersionInfo docVersionInfo)
{
if (itemInfo == null) return;
itemInfo.LoadAllAtOnce = true;
itemInfo.ActiveParent = itemParent;
itemInfo.MyParent = itemParent as ItemInfo;
// Fix for Active Section when printing. BGE_OI4 OI27D-2
if (itemInfo.IsSection && !itemInfo.IsStepSection) // If a Word Section use the current section B2016-227
itemInfo.ActiveSection = (itemInfo as SectionInfo) ?? sectionInfo;// - possible fix for not accessing correct format
else
itemInfo.ActiveSection = sectionInfo;// If not a Word Section use the parent
itemInfo.ActiveFormat = itemInfo.MyContent.MyFormat != null ? itemInfo.MyContent.MyFormat : sectionInfo == null ? itemParent.ActiveFormat : sectionInfo.ActiveFormat;
itemInfo.MyProcedure = procInfo;
itemInfo.MyDocVersion = docVersionInfo;
if (itemInfo.IsStep)
{
ItemInfo ip = itemParent as ItemInfo;
int profileDepth = ProfileTimer.Push(">>>> itemInfo.CombinedTab");
itemInfo.CombinedTab = (ip == null) ? itemInfo.MyTab.CleanText.Trim() : GetCombinedTab(itemInfo, ip.CombinedTab);
ProfileTimer.Pop(profileDepth);
}
if (itemInfo.MyContent.ContentGridCount > 0)
{
int profileDepth1 = ProfileTimer.Push(">>>> itemInfo.MyContent.LoadNonCachedGrid");
itemInfo.MyContent.LoadNonCachedGrid();
ProfileTimer.Pop(profileDepth1);
}
if (itemInfo.MyContent.ContentPartCount > 0)
foreach (PartInfo pi in itemInfo.MyContent.ContentParts)
{
//ItemInfo il = null;
foreach (ItemInfo ii in pi.MyItems)
{
SetParentSectionAndDocVersion(ii, itemInfo, (itemInfo as SectionInfo) ?? sectionInfo, procInfo, docVersionInfo);
//if (ii._MyPrevious == null && il!=null)
//ii.MyPrevious = il;
//if (il != null) il.NextItem = ii;
//il = ii;
}
}
}
/// <summary>
/// The following method is used only in print because the 'printed' data is loaded into
/// memory before printing. Find the next item from memory (do not go out to database).
/// </summary>
/// <returns></returns>
public ItemInfo GetNextItem()
{
ItemInfo mypar = this.MyParent as ItemInfo;
if (mypar == null) return null;
if (mypar.MyContent.ContentPartCount > 0)
foreach (PartInfo pi in mypar.MyContent.ContentParts)
{
bool foundMe = false;
foreach (ItemInfo ii in pi.MyItems)
{
if (foundMe) return ii;
if (ii.ItemID == ItemID) // found the current item for which we want to get next.
foundMe = true;
}
}
return null;
}
public static void ResetTranCounters()
{
TranCheckCount = 0;
TranFixCount = 0;
TranConvertCount = 0;// B2018-002 - Invalid Transitions - Initialize Transition Conversion Count
}
public static int TranCheckCount = 0;
public static int TranFixCount = 0;
public static int TranConvertCount = 0;// B2018-002 - Invalid Transitions - Declare Transition Conversion Count
internal static TransitionInfoList TransitionsToDisconnected;
internal static TransitionInfoList TransitionsToNonEditable;
internal static void MyRefreshTransitions(ItemInfo itemInfo, IVEDrillDownReadOnly itemParent, SectionInfo sectionInfo, ProcedureInfo procInfo, DocVersionInfo docVersionInfo, TransitionLookup tranLookup)
{
//TransitionInfoList til = TransitionInfoList.GetByFromID(itemInfo.ItemID);
//Console.WriteLine("Procedure: {0}, transitions: {1}", (itemInfo as ProcedureInfo).DisplayNumber, til.Count);
//foreach (TransitionInfo traninfo in til)
//{
// string oldText = itemInfo.MyContent.Text;
// itemInfo.MyContent.FixTransitionText(traninfo, tranLookup);
// string newText = itemInfo.MyContent.Text;
// if (newText != oldText)
// {
// Content content = Content.Get(itemInfo.MyContent.ContentID);
// content.FixTransitionText(traninfo);
// content.Save();
// }
//}
if (itemInfo == null) return;
if (itemInfo.MyContent.ContentPartCount > 0)
foreach (PartInfo pi in itemInfo.MyContent.ContentParts)
{
//List<ItemInfo> myItems = new List<ItemInfo>();
foreach (ItemInfo ii in pi.MyItems)
// myItems.Add(ii);
//foreach (ItemInfo ii in myItems)
MyRefreshTransitions(ii, itemInfo, (itemInfo as SectionInfo) ?? sectionInfo, procInfo, docVersionInfo, tranLookup);
}
// B2018-002 - Invalid Transitions - Convert Invalid Transitions to Text
// An invalid transition is a transition embedded in the content text that does not match the transition table record.
if(ConvertInvalidTransitionsToText(itemInfo))
{
itemInfo.ResetOrdinal();
foreach (TransitionInfo traninfo in itemInfo.MyContent.ContentTransitions)
{
bool forceConvertToText = false;
TranCheckCount++;
//if (TransitionsToNonEditable != null)
//{
// if (IsTransitionToNonEditable(traninfo))
// {
// forceConvertToText = true;
// TranFixCount++;
// itemInfo.MyContent.FixTransitionText(traninfo, itemInfo, "Reason for Change: Transition to Non-Editable Step");
// Content content = Content.Get(itemInfo.MyContent.ContentID);
// content.FixTransitionText(traninfo, true);
// content.Save();
// }
//}
if (!forceConvertToText)
{
if (traninfo.MyItemToID.ActiveSection != null)
{
SectionConfig sc = traninfo.MyItemToID.ActiveSection.MyConfig as SectionConfig;
forceConvertToText = (sc.SubSection_Edit == "N" && traninfo.MyItemToID.IsStep); // Bug fix B2016-081 also check if transition is to a step element
}
if (forceConvertToText)
{
TranFixCount++;
itemInfo.MyContent.FixTransitionText(traninfo, itemInfo, "Reason for Change: Transition to Non-Editable Step");
Content content = Content.Get(itemInfo.MyContent.ContentID);
content.FixTransitionText(traninfo, true);
content.Save();
}
}
if (!forceConvertToText)
{
if (itemInfo.MyProcedure.ItemID != traninfo.MyItemToID.MyProcedure.ItemID) //different proc
if (!itemInfo.ActiveFormat.PlantFormat.FormatData.TransData.TransTypeList[traninfo.TranType].TransMenu.Contains("Proc")) //internal format
if (!itemInfo.ActiveFormat.PlantFormat.FormatData.TransData.TransTypeList[traninfo.TranType].TransMenu.Contains("other proc")) //B2017-068 paste with transition fix
{
forceConvertToText = true;
TranFixCount++;
itemInfo.MyContent.FixTransitionText(traninfo, itemInfo, "Reason for Change: Transition to External Procedure using Internal Format");
Content content = Content.Get(itemInfo.MyContent.ContentID);
content.FixTransitionText(traninfo, true);
content.Save();
}
}
if (!forceConvertToText)
{
if (itemInfo.MyDocVersion != null && traninfo.MyItemToID.MyDocVersion != null && itemInfo.MyDocVersion.VersionID != traninfo.MyItemToID.MyDocVersion.VersionID) //different doc version
{
if (!itemInfo.ActiveFormat.PlantFormat.FormatData.TransData.TransTypeList[traninfo.TranType].TransMenu.Contains("Proc")) //internal format
if (!itemInfo.ActiveFormat.PlantFormat.FormatData.TransData.TransTypeList[traninfo.TranType].TransMenu.Contains("other proc")) //B2017-068 paste with transition fix
{
forceConvertToText = true;
TranFixCount++;
itemInfo.MyContent.FixTransitionText(traninfo, itemInfo, "Reason for Change: Transition to Outside Procedure using Internal Format");
Content content = Content.Get(itemInfo.MyContent.ContentID);
content.FixTransitionText(traninfo, true);
content.Save();
}
}
}
if (!forceConvertToText)
{
string oldText = itemInfo.MyContent.Text;
itemInfo.MyContent.FixTransitionText(traninfo, itemInfo);
string newText = itemInfo.MyContent.Text;
// B2017-165 added check of newValue (special case for old 16-bit transition that was not fixed by the customer)
string newValue = traninfo.ResolvePathTo(itemInfo.ActiveFormat, itemInfo, traninfo.TranType, traninfo.MyItemToID, traninfo.MyItemRangeID);
if (newText != oldText || newValue == "?")
{
TranFixCount++;
Content content = Content.Get(itemInfo.MyContent.ContentID);
content.FixTransitionText(traninfo);
content.Save();
}
}
}
}
}
// // B2018-002 - Invalid Transitions - Method to check for invalid transitions and convert them to text
public static bool ConvertInvalidTransitionsToText(ItemInfo itemInfo)
{
bool retval = true;
RemoveEmptyTransitions(itemInfo);//B2018-043 Cleanup Empty Transitions
MatchCollection mc = Regex.Matches(itemInfo.MyContent.Text, @"\#Link\:Transition");
if (itemInfo.MyContent.ContentTransitionCount <= 0 || mc.Count > itemInfo.MyContent.ContentTransitionCount)
{
retval = false;
if (itemInfo.MyContent.Text.Contains("Link:Transition"))
{
//Console.WriteLine("\"TranCount\"\t\"{0}\"\t{1}\t{2}\t{3}", itemInfo.ShortPath, itemInfo.ItemID, mc.Count, itemInfo.MyContent.ContentTransitionCount);
Content content = Content.Get(itemInfo.MyContent.ContentID);
//if (itemInfo.InList(616031, 615898, 5516866))
// Console.WriteLine("here");
if (itemInfo.MyContent.ContentTransitions != null)
foreach (TransitionInfo ct in itemInfo.MyContent.ContentTransitions)
Transition.Delete(ct.TransitionID);
itemInfo.MyContent.RefreshContentTransitions();
//if (content.Text.Contains("Link:TransitionRange"))
// Console.WriteLine("Here");
while (content.Text.Contains("Link:Transition"))
{
TranCheckCount++;
TranConvertCount++;
if (content.FixTransitionText(null, true))
{
ContentInfo.OnStaticContentInfoChange(itemInfo, new StaticContentInfoEventArgs("", "", ""));
if (itemInfo.MyContent.MyGrid != null)
content.ConvertTransitionToTextInGrid(null, null);
content.Save();
}
else // B2018-043 Eliminate infinite loop for invalid transition structure
{
// Add annotation for Invalid Transition
AddInvalidTransitionAnnotation(itemInfo,"Invalid Transition Format");
break;
}
}
}
}
return retval;
}
private static void AddInvalidTransitionAnnotation(ItemInfo itemInfo, string msg)
{
bool hasAnnotation = false;
AnnotationType myType = AnnotationType.GetByNameOrCreate("Link Converted To Text");
if (itemInfo.ItemAnnotations != null)
{
foreach (AnnotationInfo anot in itemInfo.ItemAnnotations)
{
if (anot.TypeID == myType.TypeID && anot.SearchText == msg)
hasAnnotation = true;
}
if (!hasAnnotation)
{
using (Item myItem = itemInfo.Get())
{
Annotation.MakeAnnotation(myItem, myType, "", msg, null);
}
}
}
}
private static void RemoveEmptyTransitions(ItemInfo itemInfo)
{
ContentInfo myContent = itemInfo.MyContent;
string txt = myContent.Text;
string regDelete = @"(\\v |)\<START\]\#Link\:Transition(|Range)\:[0-9]+ [0-9]+ [0-9]+(| [0-9]+)\[END\>(\\v0 |)";
string txt2=txt;
do{
txt = txt2;
txt2 = Regex.Replace(txt, regDelete, "");
} while(txt2 != txt);
if(txt2 != myContent.Text)
{
using(Content tmp = myContent.Get())
{
tmp.Text = txt2;
tmp.Save();
}
AddInvalidTransitionAnnotation(itemInfo, "Removed Empty Transition Text");
}
}
//private static bool IsTransitionToDisconnected(TransitionInfo ti)
//{
// foreach (TransitionInfo til in TransitionsToDisconnected)
// {
// if (ti.TransitionID == til.TransitionID)
// return true;
// }
// return false;
//}
private static bool IsTransitionToNonEditable(TransitionInfo ti)
{
foreach (TransitionInfo til in TransitionsToNonEditable)
{
if (ti.TransitionID == til.TransitionID)
return true;
}
return false;
}
public static void ResetROCounters()
{
ROCheckCount = 0;
ROFixCount = 0;
}
public static int ROCheckCount = 0;
public static int ROFixCount = 0;
private static AnnotationType _VolianCommentType = null; // Using this to flag ro value issues with byron to braidwood
public static AnnotationType VolianCommentType
{
get
{
if (_VolianCommentType == null)
_VolianCommentType = AnnotationType.GetByName("Volian Comment");
if (_VolianCommentType == null)
_VolianCommentType = AnnotationType.MakeAnnotationType("Volian Comment", null);
return _VolianCommentType;
}
}
public void UpdateROText()
{
if (this.MyDocVersion.DocVersionAssociationCount == 0) return;
ROFstInfo rofstinfo = this.MyDocVersion.DocVersionAssociations[0].MyROFst;
ROFSTLookup lookup = rofstinfo.GetROFSTLookup(this.MyDocVersion);
lookup.MyDocVersionInfo = this.MyDocVersion;
if (this.MyContent.ContentRoUsageCount > 0)
{
foreach (RoUsageInfo rousage in this.MyContent.ContentRoUsages)
{
if (this.ActiveSection != null)
{
string oldText = this.MyContent.Text;
string roval = lookup.GetTranslatedRoValue(rousage.ROID, this.ActiveSection.ActiveFormat.PlantFormat.FormatData.SectData.ConvertCaretToDelta, this.ActiveSection.ActiveFormat.PlantFormat.FormatData.SectData.UseTildaPoundCharsForSuperSubScriptInROValues);
ROFSTLookup.rochild roch = lookup.GetRoChild(rousage.ROID);
this.MyContent.FixContentText(rousage, roval, roch.type, rofstinfo, this);
string newText = this.MyContent.Text;
if (newText != oldText)
{
Content content = Content.Get(this.MyContent.ContentID);
if (roval == "?")
{
oldText = content.ConvertROToText(rousage, roval, roch.type, rofstinfo);
using (Item myitem = content.ContentItems[0].MyItem) // so that myitem does not stay in cache B2016-153
{
myitem.DisposeOfContent = false; // don't dispose of the contents may be needed if more than one RO needs processed - part of B2017-060
// B2016-225 (follow through) added more descriptive Annotation Type when RO is converted to text
Annotation.MakeAnnotation(myitem, AnnotationType.GetByNameOrCreate("Link Converted To Text"), "", string.Format("RO value ({0}) converted to text", ItemInfo.ConvertToDisplayText(oldText)), null);
}
}
else
content.FixContentText(rousage, roval, roch.type, rofstinfo);
content.Save();
}
}
}
}
}
internal static void MyRefreshReferenceObjects(ItemInfo itemInfo, IVEDrillDownReadOnly itemParent, SectionInfo sectionInfo, DocVersionInfo docVersionInfo)
{
if (itemInfo.MyContent.ContentPartCount > 0)
foreach (PartInfo pi in itemInfo.MyContent.ContentParts)
{
//List<ItemInfo> myItems = new List<ItemInfo>();
foreach (ItemInfo ii in pi.MyItems)
// myItems.Add(ii);
//foreach (ItemInfo ii in myItems)
MyRefreshReferenceObjects(ii, itemInfo, (itemInfo as SectionInfo) ?? sectionInfo, docVersionInfo);
}
ROFstInfo rofstinfo = docVersionInfo.DocVersionAssociations[0].MyROFst;
ROFSTLookup lookup = rofstinfo.GetROFSTLookup(docVersionInfo);
lookup.MyDocVersionInfo = docVersionInfo;
if (itemInfo.MyContent.ContentRoUsageCount > 0)
{
foreach (RoUsageInfo rousage in itemInfo.MyContent.ContentRoUsages)
{
if (sectionInfo != null)
{
ROCheckCount++;
string oldText = itemInfo.MyContent.Text;
string roval = lookup.GetTranslatedRoValue(rousage.ROID, sectionInfo.ActiveFormat.PlantFormat.FormatData.SectData.ConvertCaretToDelta, sectionInfo.ActiveFormat.PlantFormat.FormatData.SectData.UseTildaPoundCharsForSuperSubScriptInROValues);
ROFSTLookup.rochild roch = lookup.GetRoChild(rousage.ROID);
itemInfo.MyContent.FixContentText(rousage, roval, roch.type, rofstinfo, itemInfo);
string newText = itemInfo.MyContent.Text;
if (DifferentROtext(newText,oldText))
{
//ShowDifference(oldText, newText); // debug - display in Visual Studio Output window
ROFixCount++;
Content content = Content.Get(itemInfo.MyContent.ContentID);
if (roval == "?")
{
oldText = content.ConvertROToText(rousage, roval, roch.type, rofstinfo);
using (Item myitem = content.ContentItems[0].MyItem) // so that myitem does not stay in cache B2016-153
{
myitem.DisposeOfContent = false; // don't dispose of the contents may be needed if more than one RO needs processed - part of B2017-060
// B2016-225 (follow through) added more descriptive Annotation Type when RO is converted to text
Annotation.MakeAnnotation(myitem, AnnotationType.GetByNameOrCreate("Link Converted To Text"), "", string.Format("RO value ({0}) converted to text", ItemInfo.ConvertToDisplayText(oldText)), null);
}
}
else
{
content.FixContentText(rousage, roval, roch.type, rofstinfo);
}
content.UserID = Volian.Base.Library.VlnSettings.UserID;
content.DTS = DateTime.Now;
content.Save();
}
}
}
}
}
private static bool DifferentROtext(string newText, string oldText)
{
string nt = newText.Replace(@"\u8209?", "-").Replace(@"\u160?", " ").Replace("\xA0", " ");
string ot = oldText.Replace(@"\u8209?", "-").Replace(@"\u160?", " ").Replace("\xA0", " ");
if (nt.Equals(ot))
return false;
return true;
}
#region debug
//private static void ShowDifference(string oldText, string newText)
//{
// string nt = newText.Replace(@"\u8209?", "-").Replace(@"\u160?", " ").Replace("\xA0", " ");
// string ot = oldText.Replace(@"\u8209?", "-").Replace(@"\u160?", " ").Replace("\xA0", " ");
// ShowText("OldText", ot);
// ShowText("NewText", nt);
//}
//private static void ShowText(string title, string newText)
//{
// StringBuilder sb = new StringBuilder();
// foreach (char c in newText)
// {
// if(c<' ' || c> '\x7F')
// sb.Append(string.Format("\\x{0:X2}",((int) c)));
// else
// sb.Append(c);
// }
// Console.WriteLine("{0}='{1}'",title,sb.ToString());
//}
#endregion // debug
internal static void SetParentSectionAndDocVersionPageNum(ItemInfo itemInfo, IVEDrillDownReadOnly itemParent, SectionInfo sectionInfo, ProcedureInfo procInfo, DocVersionInfo docVersionInfo, TransitionLookup tranLookup)
{
if (itemInfo.MyContent.ContentPartCount > 0)
{
foreach (PartInfo pi in itemInfo.MyContent.ContentParts)
{
foreach (ItemInfo ii in pi.MyItems)
{
SetParentSectionAndDocVersionPageNum(ii, itemInfo, (itemInfo as SectionInfo) ?? sectionInfo, procInfo, docVersionInfo, tranLookup);
}
}
}
if (itemInfo.MyContent.ContentTransitionCount > 0)
{
foreach (TransitionInfo traninfo in itemInfo.MyContent.ContentTransitions)
{
itemInfo.MyContent.FixTransitionText(traninfo, tranLookup, itemInfo);
}
}
}
//internal static long ticksROUsage;
//internal static long ticksItems;
//internal static long ticksTrans;
//internal static void ResetTicks()
//{
// ticksROUsage = 0;
// ticksItems = 0;
// ticksTrans = 0;
//}
//internal static void ShowTicks()
//{
// Console.WriteLine("ROUsage: {0}", TimeSpan.FromTicks(ticksROUsage).TotalSeconds);
// Console.WriteLine("Items: {0}", TimeSpan.FromTicks(ticksItems).TotalSeconds);
// Console.WriteLine("Transitions: {0}", TimeSpan.FromTicks(ticksTrans).TotalSeconds);
//}
public static string GetCombinedTab(ItemInfo itemInfo, string parTab)
{
string pTab = parTab == null ? "" : parTab;
int profileDepth = ProfileTimer.Push(">>>> itemInfo.MyTab.CleanText.Trim");
string thisTab = itemInfo.MyTab.CleanText.Trim();
ProfileTimer.Pop(profileDepth);
//The following will include '(x)' where 'x' is stepnumber for VC Summer Unit 2 & 3 (vcb) Note & Caution tabs
bool vcbHeaderCheck = itemInfo.ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionPrintData.CombinedTabIncludeParenTabs &&
thisTab != null && thisTab != "" && thisTab.Length > 1 && char.IsLetterOrDigit(thisTab[1]);
// for supplemental information, bulleted tabs need to be included in the tab. The 'isletterordigit' should not occur for supinfo items -
// and this includes the parent of the supinfo since that is the tab used for supinfo concatenated with its parent. (B2017-120)
if (thisTab != null && thisTab != "" && !char.IsLetterOrDigit(thisTab[0]) && !vcbHeaderCheck && !itemInfo.IsInSupInfo && (itemInfo.SupInfos == null || itemInfo.SupInfos.Count <= 0 )) return pTab;
if (itemInfo.FormatStepData.NumberWithLevel) pTab = itemInfo.MyHLS.MyTab.CleanText.Trim();
// if the parent tab ends with a alphanumeric and this tab is alphanumeric, add a '.' to separate them
// also, include use the separator for bullets if doing the supplemental information tab (B2017-120)
bool ms = pTab != "" && char.IsLetterOrDigit(pTab.TrimEnd()[pTab.Length - 1]); // parent tab ends with alphanumeric
bool mn = thisTab.TrimStart().Length > 0 && ((itemInfo.IsInSupInfo || (itemInfo.SupInfos != null && itemInfo.SupInfos.Count > 0)) || char.IsLetterOrDigit(thisTab.TrimStart()[0]));// this starts with alpha
if (ms && mn) pTab = pTab.TrimEnd() + ".";
// remove ending '.' (if this is a hls, don't remove the '.')
if (!itemInfo.IsHigh && thisTab.EndsWith(".")) thisTab = thisTab.Substring(0, thisTab.Length - 1);
return pTab + thisTab.Trim();
}
internal static void SetParentSectionAndDocVersion(ItemInfo itemInfo, IVEDrillDownReadOnly itemParent, SectionInfo sectionInfo, DocVersionInfo docVersionInfo, TransitionLookup tranLookup)
{
if (itemInfo == null) return;
itemInfo.LoadAllAtOnce = true;
itemInfo.ActiveParent = itemParent;
itemInfo.MyParent = itemParent as ItemInfo;
// itemInfo.ActiveSection = (itemInfo as SectionInfo) ?? sectionInfo;
itemInfo.ActiveSection = sectionInfo;
itemInfo.ActiveFormat = itemInfo.MyContent.MyFormat != null ? itemInfo.MyContent.MyFormat : sectionInfo == null ? itemParent.ActiveFormat : sectionInfo.ActiveFormat;
itemInfo.MyDocVersion = docVersionInfo;
if (itemInfo.IsStep)
{
ItemInfo ip = itemParent as ItemInfo;
itemInfo.CombinedTab = (ip == null) ? itemInfo.MyTab.CleanText.Trim() : GetCombinedTab(itemInfo, ip.CombinedTab);
}
if (docVersionInfo.DocVersionAssociationCount == 1)
{
ROFstInfo rofstinfo = docVersionInfo.DocVersionAssociations[0].MyROFst;
//rofstinfo.docVer = docVersionInfo;
ROFSTLookup lookup = rofstinfo.GetROFSTLookup(docVersionInfo);
lookup.MyDocVersionInfo = docVersionInfo;
//DateTime dts = DateTime.Now;
if (itemInfo.MyContent.ContentGridCount > 0)
itemInfo.MyContent.LoadNonCachedGrid();
if (itemInfo.MyContent.ContentRoUsageCount > 0)
{
foreach (RoUsageInfo rousage in itemInfo.MyContent.ContentRoUsages)
{
if (sectionInfo != null)
{
string roval = lookup.GetTranslatedRoValue(rousage.ROID, sectionInfo.ActiveFormat.PlantFormat.FormatData.SectData.ConvertCaretToDelta, sectionInfo.ActiveFormat.PlantFormat.FormatData.SectData.UseTildaPoundCharsForSuperSubScriptInROValues);
ROFSTLookup.rochild roch = lookup.GetRoChild(rousage.ROID);
itemInfo.MyContent.FixContentText(rousage, roval, roch.type, rofstinfo, itemInfo);
}
}
}
}
else
{
// Force Error Message
docVersionInfo.GetROFst(0);
}
//TimeSpan ts = DateTime.Now.Subtract(dts);
//ticksROUsage += ts.Ticks;
//dts = DateTime.Now;
if (itemInfo.MyContent.ContentPartCount > 0)
{
foreach (PartInfo pi in itemInfo.MyContent.ContentParts)
{
//ItemInfo il = null;
foreach (ItemInfo ii in pi.MyItems)
{
SetParentSectionAndDocVersion(ii, itemInfo, (itemInfo as SectionInfo) ?? sectionInfo, docVersionInfo, tranLookup);
//if(ii._MyPrevious == null)
// ii.MyPrevious = il;
//if (il != null) il.NextItem = ii;
//il = ii;
}
}
}
//ts = DateTime.Now.Subtract(dts);
//ticksItems += ts.Ticks;
//dts = DateTime.Now;
if (itemInfo.MyContent.ContentTransitionCount > 0)
{
//itemInfo.UpdateTransitionText();
foreach (TransitionInfo traninfo in itemInfo.MyContent.ContentTransitions)
{
//itemInfo.UpdateTransitionText();
itemInfo.MyContent.FixTransitionText(traninfo, tranLookup, itemInfo);
}
}
//ts = DateTime.Now.Subtract(dts);
//ticksTrans += ts.Ticks;
}
private int _PrintBias = 0;
public int PrintBias
{
get { return _PrintBias; }
set { _PrintBias = value; }
}
private int _OffsetTab = 0;
public int OffsetTab
{
get { return _OffsetTab; }
set { _OffsetTab = value; }
}
private int _PrintLevel = 0;
public int PrintLevel
{
get
{
if (_PrintLevel != 0) return _PrintLevel;
int _PrintBias = 0;
_PrintLevel = GetStepLevel(); //ref _PrintBias);
return _PrintLevel;
}
set { _PrintLevel = value; }
}
// The following properties track the page number that this item is on if the resolved
// transition text has a Page Number associated with it. Formats that have this either
// have the UseTransitionModfier flag or have '{Page Num}' in respective transition formats.
// If the format requires page numbers in transitions text, two passes are run through the
// data for printing. The first determines page numbers, the seconds resolves the transition
// text. The PageNumberUsed value is used to determine if the page number in 1st & 2nd passes
// are different. This can be caused by the page number text causing different heights of
// the step that causes change in pagination. If this occurs, the user is presented with a
// dialog box that shows the step that causes the problem & a manual change will be necessary.
// This is a rare occurence so it was decided that the amount of coding effort to fix this
// would be so much in comparison to having the user fix manually (RHM/KBR Feb 2014).
private int _PageNumber = -1;
public int PageNumber
{
get { return _PageNumber; }
set { _PageNumber = value; }
}
private int _PageNumberUsed = 0;
public int PageNumberUsed
{
get { return _PageNumberUsed; }
set { _PageNumberUsed = value; }
}
private int _PageNumberNextPass = 0;
public int PageNumberNextPass
{
get { return _PageNumberNextPass; }
set { _PageNumberNextPass = value; }
}
private float _MSWordPageCount = 0;
public float MSWordPageCount
{
get {
if (_MSWordPageCount == 0) // C2018-011 Get the proper word page count from the saved pdf attachment
if (MyContent.MyEntry != null && MyContent.MyEntry.MyDocument != null)
{
PdfInfo pi = PdfInfo.Get(this, false);
if(pi != null) _MSWordPageCount = (float)pi.PageCount;// B2018-071 Don't crash on invalid MS Word section
}
return _MSWordPageCount;
}
set { _MSWordPageCount = value; }
}
public event ItemInfoEvent OrdinalChanged;
private void OnOrdinalChange()
{
if (OrdinalChanged != null) OrdinalChanged(this);
}
public static void OnOrdinalChange(int itemID)
{
ConvertListToDictionary();
string key = itemID.ToString();
if (_CacheByPrimaryKey.ContainsKey(key))
{
// Create a temporary list to process cache entries then use
// the temporary list which may have a side effect on the cache entries,
// thus the need for the temporary list.
List<ItemInfo> myCache = new List<ItemInfo>();
foreach (ItemInfo item in _CacheByPrimaryKey[key]) myCache.Add(item);
foreach (ItemInfo item in myCache)
item.OnOrdinalChange();
}
}
public bool IsFirstSubStep
{
get
{
if (!IsStepPart) return false;
if (IsHigh) return false;
return (MyPrevious == null);
}
}
public bool IsAutoTOCSection
{
get
{
if (!IsSection) return false;
if (MyDocStyle.StructureStyle.Style == null) return false;
return ((ActiveFormat.PlantFormat.FormatData.PurchaseOptions & E_PurchaseOptions.AutoTableOfContents) == E_PurchaseOptions.AutoTableOfContents &&
(MyDocStyle.StructureStyle.Style & E_DocStructStyle.TableOfContents) == E_DocStructStyle.TableOfContents);
}
}
public bool IsPlacekeeperSection
{
get
{
if (!IsSection) return false;
if (MyDocStyle.StructureStyle.Style == null) return false;
return ((ActiveFormat.PlantFormat.FormatData.PurchaseOptions & E_PurchaseOptions.AutoPlacekeeper) == E_PurchaseOptions.AutoPlacekeeper &&
(MyDocStyle.StructureStyle.Style & E_DocStructStyle.Placekeeper) == E_DocStructStyle.Placekeeper);
}
}
public bool CanSetPlacekeeper
{
get
{
if (IsProcedure) return false;
SectionConfig scfg = ActiveSection.MyConfig as SectionConfig;
if (MyDocStyle.StructureStyle.Style == null || scfg == null) return false;
bool PlacekeepOption = ((ActiveFormat.PlantFormat.FormatData.PurchaseOptions & E_PurchaseOptions.AutoPlacekeeper) == E_PurchaseOptions.AutoPlacekeeper)
&& scfg.Section_Placekeeper.Equals("Y");
//return (PlacekeepOption && IsHigh);
return (PlacekeepOption);
}
}
public bool MoreThanOneStepSection()
{
if (IsProcedure || IsSection) return false;
// If 'toitem' is a step, get to section.
ItemInfo par = MyParent;
while (par != null && !par.IsSection) par = par.MyParent;
if (par == null) return false;
par = par.FirstSibling;
int cntStepSect = 0;
while (par != null)
{
if (par.IsStepSection) cntStepSect++;
par = par.NextItem;
}
if (cntStepSect > 1) return true;
return false;
}
#region StepLevel
private int _StepLevel = -2;// Not yet calculated
public int StepLevel
{
get
{
if (_StepLevel == -2)
{
_StepLevel = CalcStepLevel(this);
//ItemInfo parent = ActiveParent as ItemInfo;
//Console.WriteLine("{0},{1},{2},{3},{4},{5},{6}",ItemID, DBSequence, _StepLevel, MyContent.Type % 10000, parent.MyContent.Type % 10000,HasCautionOrNote ? 1 : 0, parent.Cautions == null? 0 : 1);
}
return _StepLevel;
}
set { _StepLevel = value; }
}
public string ToolTip
{
get
{
if (IsStep)
return FormatStepData.StepEditData.TypeMenu.MenuItem; //FormatStepData.Type;
else if (IsSection)
return MyDocStyle.Name;
return "Procedure Title";
}
}
public bool HasCautionOrNote
{
get { return Cautions != null || Notes != null; }
}
private static Regex regexDBSeqPass1 = new Regex("([^.]*)[.]S([^.]*)[.]S([0-9]*)[.](.*)");
private static Regex regexDBSeqPass2 = new Regex("[.](.)([^.]*)[.]");
public string DBSequence
{
get
{
Match m1 = regexDBSeqPass1.Match(ShortPath);
MatchCollection m2s = regexDBSeqPass2.Matches(m1.Groups[4].Value);
StringBuilder retval = new StringBuilder(string.Format("\"{0}\"\t\"{1}\"\t\"{2}\"", m1.Groups[1].Value, m1.Groups[2].Value, m1.Groups[3].Value));
string prefix = "S";
string suffix = "";
foreach (Match m2 in m2s)
{
int i = ((int)'0') + int.Parse(m2.Groups[2].Value);
char c = (char)i;
suffix = c.ToString();
switch (m2.Groups[1].Value)
{
case "S":
break;
case "R":
prefix += "$";
suffix = "";
break;
case "C":
prefix = "!";
break;
case "N":
prefix = "*";
break;
case "T":
prefix += "#";
suffix = "";
break;
default:
break;
}
retval.Append(prefix + suffix);
prefix = "";
}
retval.Append(prefix + "'");
//Volian.Base.Library.DebugText.WriteLine("'{0}','{1}','{2}'", retval, ShortPath, Path);
return retval.ToString();
}
}
// B2019-121 tell us if the step item in part of a caution or note type
public bool HasAncestorCautionOrNote
{
get
{
ItemInfo item = this.ActiveParent as ItemInfo;
while (item is ItemInfo && !item.IsHigh)
{
if (item.IsInCautionOrNote)
return true;
item = item.ActiveParent as ItemInfo;
}
return false;
}
}
private static int CalcStepLevel(ItemInfo item)
{
if (item == null) return 0;
int id = 0;
// Determines the substep level.
int level = CountLevels(item);
// PaginateOnFirstSubstep allows orphans, first child can be separated from its parent.
int firstInc = item.ActiveFormat.MyStepSectionLayoutData.PaginateOnFirstSubstep ? 0 : 1;
ItemInfo parent = item.ActiveParent as ItemInfo;
// TODO: Format flag 'TreatAsSequential':
// The following needs to account for use of format flag 'TreatAsSequential' when doing
// formats that have it.
if (item.IsExactType("And") || item.IsExactType("Or") || item.IsExactType("ImplicitOr"))
level++;
//if (item.ParentAndOr)
// level++;
level += item.ParentAndOrCount;
// First substep, this is where it uses the orphan logic from above.
// The check for the parent.IsNote was added for Calvert OI3/OI-1A, section 5, step H. This is a
// very long step with a very long note (multiple notes each having 1 or more ANDs). Without
// the addition of the parent.IsNote, the note was breaking between 2 ANDs (the 1st AND was a
// steplevel of 5, but the 2nd was a steplevel of 4). If something similar is seen with Cautions,
// that check could be added.
if (!item.IsRNOPart && !item.IsHigh && (item.MyPrevious == null || (((item.ActiveFormat.PlantFormat.FormatData.PurchaseOptions & E_PurchaseOptions.EnhancedBackgrounds) != E_PurchaseOptions.EnhancedBackgrounds) && item.MyParent.IsNote)))
level += firstInc;
else
firstInc = 0;
// Try not to paginate on a step that has Cautions & Notes, keep the Caution/Note with
// the step.
if (item.IsStepPart)
{
if (item.Cautions != null || item.Notes != null)
level += 2;
else if (item.HasAncestorCautionOrNote) // B2019-121 step part is in a caution or note
level += 3;
}
// Paginate before first caution, not between cautions.
else if (item.IsCautionPart)
{
if (item.MyPrevious == null) level -= (1 + firstInc);
else level += 3;
}
// Paginate before first note, if the step does not have a caution.
// Otherwise, try to keep the notes together.
else if (item.IsNotePart)
{
if (parent.Cautions == null && item.MyPrevious == null) level -= (1 + firstInc);
else level += 3;
}
// Try not to paginate on a table.
else if (item.IsTablePart)
{
level += 2;
}
// For an RNO to the right, make it the same level as the AER item.
else if (item.IsRNOPart)
{
level = (item.ActiveParent as ItemInfo).StepLevel + item.RNOLevel - item.ColumnMode;
// RHM Change 20140522
//level = (item.ActiveParent as ItemInfo).StepLevel;// +item.RNOLevel - item.ColumnMode;
}
return level;
}
private bool ParentAndOr
{
get
{
ItemInfo parent = ActiveParent as ItemInfo;
if (parent == null) return false;
// B2018-104: Make the following check consistent with what is in CalcStepLevel (added ImplicitOr)
if (parent.IsExactType("And") || parent.IsExactType("Or") || parent.IsExactType("ImplicitOr")) return true;
return parent.ParentAndOr;
}
}
private int ParentAndOrCount
{
get
{
ItemInfo parent = ActiveParent as ItemInfo;
if (parent == null) return 0;
// B2018-104: Make the following check consistent with what is in CalcStepLevel (added ImplicitOr)
if (parent.IsExactType("And") || parent.IsExactType("Or") || parent.IsExactType("ImplicitOr")) return 1 + parent.ParentAndOrCount;
return parent.ParentAndOrCount;
}
}
/// <summary>
/// Count all levels, including substeps within RNOs. Ignore RNOs that are to the right of
/// the AER, but count those that are below higher level RNOs.
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private static int CountLevels(ItemInfo item)
{
int level = 0;
if (item.IsProcedure) return 0;
int ignoreRNOs = item.ActiveSection.ColumnMode;
while (item != null && !item.IsHigh)
{
if (ignoreRNOs > 0 && item.IsRNOPart)
ignoreRNOs--;
else
level++;
item = item.ActiveParent as ItemInfo;
}
return level;
}
// B2017-070 - when retoring a step that once had enhanced links, remove the link info for the notes and cautions as well
public void RemoveEnhancedFromConfig()
{
RemoveEnhancedFromConfig(false);
}
public void RemoveEnhancedFromConfig(bool doOneStepOnly)
{
XmlDocument xd = new XmlDocument();
if (this.MyContent.Config == null || this.MyContent.Config == "") return; // B2017-164 & B2017-172 check for null or empty config
xd.LoadXml(this.MyContent.Config);
XmlNode xn = xd.DocumentElement.SelectSingleNode("Enhanced");
if (xn != null)
{
xn.ParentNode.RemoveChild(xn);
string config = xd.OuterXml;
using (Content ctmp = this.MyContent.Get())
{
ctmp.Config = config;
ctmp.Save();
ContentInfo.Refresh(ctmp);
_MyConfig = null; // refresh the memory value
}
}
if (doOneStepOnly) return;
if (this.IsHigh)
{
if (this.Cautions != null)
foreach (ItemInfo chld in this.Cautions)
{
chld.RemoveEnhancedFromConfig(false);
}
if (this.Notes != null)
foreach (ItemInfo chld in this.Notes)
{
chld.RemoveEnhancedFromConfig(false);
}
}
}
#endregion
public bool HasHeader
{
get
{
if (MyHeader == null) return false;
if (MyHeader.CleanText == null) return false;
if (MyHeader.CleanText == "") return false;
return true;
}
}
protected void ExtensionRefreshFields(Item tmp)
{
_ActiveParent = null;
}
#region LoadAtOnce2
public static ItemInfo GetItemAndChildren2(int? itemID)
{
try
{
ItemInfo tmp = DataPortal.Fetch<ItemInfo>(new ItemAndChildrenCriteria2(itemID));
AddToCache(tmp);
if (tmp.ErrorMessage == "No Record Found") tmp = null;
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetItemAndChildren2", ex);
}
}
// Criteria to get Item and children
[Serializable()]
private class ItemAndChildrenCriteria2
{
public ItemAndChildrenCriteria2(int? itemID)
{
_ItemID = itemID;
}
private int? _ItemID;
public int? ItemID
{
get { return _ItemID; }
set { _ItemID = value; }
}
}
// Data Portal to Get Item and Children
private void DataPortal_Fetch(ItemAndChildrenCriteria2 criteria)
{
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
ApplicationContext.LocalContext["cn"] = cn;
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "getItem";
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
if (!dr.Read())
{
_ErrorMessage = "No Record Found";
return;
}
ReadData(dr);
}
}
SpinThroughChildren();
// removing of item only needed for local data portal
if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
ApplicationContext.LocalContext.Remove("cn");
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
RemoveFromCache(this);
}
private void SpinThroughChildren()
{
if (MyContent.ContentPartCount > 0)
foreach (PartInfo partInfo in MyContent.ContentParts)
foreach (ItemInfo itemInfo in partInfo.MyItems)
itemInfo.SpinThroughChildren();
}
#endregion
#region LoadAtOnce
// Method to Get Item and children
public static ItemInfo GetItemAndChildren(int? itemID, int? parentID)
{
try
{
ItemInfo tmp = DataPortal.Fetch<ItemInfo>(new ItemAndChildrenCriteria(itemID, parentID));
AddToCache(tmp);
if (tmp.ErrorMessage == "No Record Found") tmp = null;
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
}
}
// Criteria to get Item and children
[Serializable()]
private class ItemAndChildrenCriteria
{
public ItemAndChildrenCriteria(int? itemID, int? parentID)
{
_ItemID = itemID;
_ParentID = parentID;
}
private int? _ItemID;
public int? ItemID
{
get { return _ItemID; }
set { _ItemID = value; }
}
private int? _ParentID;
public int? ParentID
{
get { return _ParentID; }
set { _ParentID = value; }
}
}
// Data Portal to Get Item and Children
private void DataPortal_Fetch(ItemAndChildrenCriteria criteria)
{
//ItemInfo tmp = null;
Dictionary<int, ItemInfo> lookup = new Dictionary<int, ItemInfo>(); ;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_ListItemAndChildren";
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
cm.Parameters.AddWithValue("@ParentID", criteria.ParentID);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
if (dr.GetInt32("Level") == 0)
{
//tmp = itemInfo;
ReadData(dr);
AddContent(dr);
lookup[this.ItemID] = this;
}
else
{
ItemInfo itemInfo = null;
int itemType = dr.GetInt32("Type") / 10000;
switch (itemType)
{
case 0:
itemInfo = new ProcedureInfo(dr);
break;
case 1:
itemInfo = new SectionInfo(dr);
break;
case 2:
itemInfo = new StepInfo(dr);
break;
}
// Load Children
itemInfo.AddContent(dr);
ItemInfo parent = lookup[dr.GetInt32("ParentID")];
itemInfo._ActiveParent = parent;
itemInfo._ActiveSection = (itemInfo.IsSection ? itemInfo : parent._ActiveSection);
parent.AddPart(dr, itemInfo);
lookup.Add(itemInfo.ItemID, itemInfo);
}
}
//Console.WriteLine("I'm here {0}",this.MyContent.ContentPartCount);
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
}
internal void AddPart(SafeDataReader dr, ItemInfo itemInfo)
{
// Either a new PartInfo or an existing PartInfo
if (dr.IsDBNull(dr.GetOrdinal("PreviousID")))
{
//PartInfo prt = new PartInfo(dr, itemInfo);
_MyContent.AddPart(dr, itemInfo);
}
else
{
foreach (PartInfo pi in MyContent.ContentParts)
{
if (dr.GetInt32("FromType") == (int)pi.PartType)
{
if (pi._MyItems == null)
pi._MyItems = new ItemInfoList(itemInfo);
else
pi.MyItems.AddItem(itemInfo);
}
}
}
}
#endregion
#region IsType
private E_FromType? _FromType = null;
public E_FromType? FromType
{
get
{
//if (ItemID == 95759 && _FromType == null)
// Console.WriteLine("\"Null FromType\",{0},{1},\"{2}\",{3}", ItemID, MyContent.Type, DisplayNumber, MyItemInfoUnique);
return _FromType;
}
set { _FromType = value; }
}
public bool IsFirstCautionPart
{
get
{
if (FromType != null)
return (MyPrevious == null && FromType == E_FromType.Caution);
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Caution));
}
}
public bool IsFirstNotePart
{
get
{
if (FromType != null)
return (MyPrevious == null && FromType == E_FromType.Note);
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Note));
}
}
public bool IsCautionPart
{
get
{
if (FromType != null)
return (FromType == E_FromType.Caution);
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Caution));
}
}
public bool IsNotePart
{
get
{
if (FromType != null)
return (FromType == E_FromType.Note);
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Note));
}
}
// B2017-004 check to see if step part is inside a Caution or Note (used to determin which Table types to include in the change step type list)
public bool IsInCautionOrNote
{
get
{
bool rval = false;
ItemInfo itm = this;
while (itm != null &&!itm.IsHigh && !rval)
{
rval = itm.IsCautionOrNotePart;
if (!rval) itm = itm.MyParent;
}
return rval;
}
}
public bool IsType(string type)
{
if ((int)MyContent.Type < 20000) return false;
int stepType = ((int)MyContent.Type) % 10000;
StepDataList sdlist = ActiveFormat.PlantFormat.FormatData.StepDataList;
if (stepType > sdlist.MaxIndex)
{
Console.WriteLine("Error getting type - contentid = {0}", MyContent.ContentID);
return false;
}
StepData sd = sdlist[stepType];
while (sd.Index != 0)
{
if (sd.Type == type) return true;
sd = sdlist[sd.ParentType];
}
return false;
}
public bool IsExactType(string type)
{
if ((int)MyContent.Type < 20000) return false;
int stepType = ((int)MyContent.Type) % 10000;
StepDataList sdlist = ActiveFormat.PlantFormat.FormatData.StepDataList;
if (stepType > sdlist.MaxIndex)
{
Console.WriteLine("Error getting type - contentid = {0}", MyContent.ContentID);
return false;
}
StepData sd = sdlist[stepType];
return (sd.Type == type);
}
// determine if the the current step should automatically be placed on the Continuous Action Summary
// Note, this logic only checks the format setting of the step. We will check the value of the Tag's Check Box later on.
public bool IncludeOnContActSum
{
get
{
bool includeOnCAS = false;
if ((int)MyContent.Type < 20000) return includeOnCAS;
int stepType = ((int)MyContent.Type) % 10000;
StepDataList sdlist = ActiveFormat.PlantFormat.FormatData.StepDataList;
if (stepType > sdlist.MaxIndex)
{
//Console.WriteLine("IncludeOnContActSum - Error getting type - contentid = {0}", MyContent.ContentID);
_MyLog.InfoFormat(string.Format("IncludeOnContActSum - Error getting type - contentid = {0}", MyContent.ContentID));
return false;
}
// By default the PROMS step types that are initally identified as a Continuous Action type will return True,
// unless the format flag "ExcludeFromContActSum" is set on that step type
StepData sd = sdlist[stepType];
switch (stepType)
{
case 9: // Continuous Action High Level Step
case 44: // Continuous Action Sequential sub-step
case 45: // Continuous Action AND sub-step
case 46: // Continuous Action OR sub-step
case 47: //Continuous Actoin Paragraph sub-step
includeOnCAS = !sd.ExcludeFromContActSum; // if flag is not set then Automatically include this step/sub-step on the Continuous Action Summary
break;
default:
includeOnCAS = !sd.ExcludeFromContActSum; //false; // don't automatically include this step/sub-step on the Continuous Action Summary
break;
}
return includeOnCAS;
}
}
public bool IsSameType(ItemInfo cmpItmInfo)
{
return (((int)MyContent.Type) % 10000) == (((int)cmpItmInfo.MyContent.Type) % 10000);
}
public bool IsCautionOrNotePart
{
get
{
return (IsCautionPart || IsNotePart);
}
}
public bool IsCaution
{
get
{
return IsType("Caution");
}
}
public bool IsCaution2
{
get
{
return IsType("Caution2");
}
}
public bool IsCaution1
{
get
{
return IsType("Caution1");
}
}
public bool IsNote
{
get
{
return IsType("Note");
}
}
public bool IsNote1
{
get
{
return IsType("Note1");
}
}
public bool IsFootnote
{
get
{
if (!ActiveFormat.PlantFormat.FormatData.ProcData.NotesToFootnotes) return false;
if (!IsStep) return false;
// BGEVL had notes as footnotes, and also had HorizontalSubsteps flag
if (ActiveFormat.PlantFormat.FormatData.PrintData.HorizontalSubsteps && IsType("Note")) return true;
if (IsType("Note2")) return true; // BGEEOP had note2's as footnotes
return false;
}
}
public bool IsTable
{
get
{
return IsType("Table");
}
}
public bool IsFigure
{
get
{
return IsType("Figure");
}
}
public bool IsOr
{
get
{
return IsType("Or");
}
}
public bool IsAnd
{
get
{
return IsType("And");
}
}
public bool IsEquipmentList
{
get
{
return IsType("EquipmentList");
}
}
public bool IsTitle
{
get
{
return IsType("Title");
}
}
public bool IsAccPages
{
get
{
return IsType("AccPages");
}
}
public bool IsParagraph
{
get
{
return IsType("Paragraph");
}
}
public bool IsDefault
{
get
{
return IsType("Default");
}
}
public bool IsContAcSequential
{
get
{
return IsType("ContAcSequential");
}
}
private bool? _IsHigh = null;
public bool IsHigh
{
get
{
if (_IsHigh != null) return (bool)_IsHigh;
int profileDepth = ProfileTimer.Push(">>>> BeginIsHigh");
// check to see if ActiveParent is a section, if so it is a high level step
if (MyContent.Type / 10000 != 2) _IsHigh = false;
else
{
ItemInfo parent = ActiveParent as ItemInfo;
if (parent == null) _IsHigh = false;
// IsHigh was returning true if this item is a caution or note off of a section..
// from the (parent.MyContent.Type / 1000) == 1.
else if ((parent.MyContent.Type / 10000) != 1)
_IsHigh = false;
else if (IsCaution || IsNote) _IsHigh = false;
else _IsHigh = true;
}
ProfileTimer.Pop(profileDepth);
return (bool)_IsHigh;
}
}
public bool IsSequential
{
get
{
if ((MyContent.Type / 10000) != 2) return false;
string tabstr = FormatStepData.TabData.IdentPrint;
if (tabstr.Contains("{seq}")) return true;
return false;
}
}
public bool IsNumbered
{
get
{
if ((MyContent.Type / 10000) != 2) return true;
string tabstr = FormatStepData.TabData.IdentPrint;
if (tabstr.Contains("{seq}")) return true;
if (tabstr.Contains("{ALPHA}")) return true;
if (tabstr.Contains("{ROMAN}")) return true;
if (tabstr.Contains("{numeric}")) return true;
return false;
}
}
public bool IsTablePart
{
get
{
if (FromType != null)
return (FromType == E_FromType.Table);
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Table));
}
}
public bool IsRNOPart
{
get
{
if (FromType != null)
return (FromType == E_FromType.RNO);
bool retval = ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.RNO));
return retval;
}
}
public bool IsSupInfoPart
{
get
{
if (FromType != null)
return (FromType == E_FromType.SupInfo);
bool retval = ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.SupInfo));
return retval;
}
}
public bool IsInRNO
{
get
{
if (IsHigh) return false;
if (IsRNOPart) return true;
ItemInfo parent = ActiveParent as ItemInfo;
if (parent == null) return false;
return parent.IsInRNO;
}
}
public bool IsInSupInfo
{
get
{
if (IsHigh) return false;
if (IsSupInfoPart) return true;
ItemInfo parent = ActiveParent as ItemInfo;
if (parent == null) return false;
return parent.IsInSupInfo;
}
}
public bool IsRtfRaw
{
get
{
return (MyContent.Type > 20999);
}
}
public bool IsInCalvertConditionResponse
{
get
{
ItemInfo itmifo = this;
bool rtn = false;
if (ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm)
{
// TemplateChildColumnMode is set to 2 for the TitleWithTextBelow step type
// we want to stop searching at this level
while (!rtn && itmifo != null && itmifo.IsStep && !itmifo.TemplateChildColumnMode.Equals(2))
{
rtn = itmifo.TemplateColumnMode.Equals(2);
itmifo = itmifo.MyParent;
}
}
return rtn;
}
}
#endregion
#region Level Columns Relationships
public int RNOLevel
{
get
{
return ((IsProcedure || IsSection || IsHigh) ? 0 : (IsRNOPart ? 1 : 0) + ((ItemInfo)ActiveParent).RNOLevel);
}
}
public void CheckColumnMode(int itemID)
{
List<ItemInfo> lst = _CacheByPrimaryKey[itemID.ToString()];
foreach (ItemInfo ii in lst)
{
Console.WriteLine("{0} - {1}", ii.MyItemInfoUnique, (ii.ActiveSection as SectionInfo).SectionConfig.Section_ColumnMode);
}
}
public int ColumnMode
{
get
{
// if Calvert Alarms, the column mode may be defined in the template code - check
// for this 1st.
if (ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm)
if (TemplateColumnMode != -1) return TemplateColumnMode;
// check config value on my section, if null/default use Pmode of active format
if (ActiveSection != null)
{
SectionInfo si = null;
if (IsSection) si = this as SectionInfo;
else si = ActiveSection as SectionInfo;
if (si == null)
si = SectionInfo.Get(ActiveSection.ItemID); //ActiveSection as SectionInfo;
if (si != null)
{
// there is no longer a "default" ENUM item - SectionConfig will return format default if needed
//if (si.SectionConfig.Section_ColumnMode != SectionConfig.SectionColumnMode.Default)
return (int)si.SectionConfig.Section_ColumnMode - 1;
}
//Console.WriteLine("PMode={0}, si.ColumnMode={1}, ColumnMode={2}", ActiveFormat.MyStepSectionLayoutData.PMode ,si.ColumnMode,(ActiveFormat.MyStepSectionLayoutData.PMode ?? 2) - 1);
}
return (ActiveFormat.MyStepSectionLayoutData.PMode ?? 2) - 1;
}
}
/// <summary>
/// FormatStepType - Maps to step type in format file. All types map directly from step type in content
/// to step type in format
/// </summary>
public int FormatStepType
{
get
{
return (((int)MyContent.Type) % 10000);
}
}
/// <summary>
/// returns the format's stepdata for the given content type.
/// </summary>
public StepData FormatStepData
{
get
{
if ((int)MyContent.Type < 20000) return null;
int typ = (int)MyContent.Type - 20000;
foreach (StepData sd in ActiveFormat.PlantFormat.FormatData.StepDataList)
{
if (sd.Index == typ) return sd;
}
// Handle inheritance (step data may not be in current format, may inherit from parents:
IFormatOrFormatInfo parentFormat = ActiveFormat.PlantFormat.FormatData.MyParentFormat;
while (parentFormat != null)
{
vlnIndexedFormatList<StepData> InheritedList = parentFormat.PlantFormat.FormatData.StepDataList;
if (InheritedList != null)
{
foreach (StepData sdi in InheritedList)
{
if (sdi.Index == typ) return sdi;
}
}
parentFormat = parentFormat.PlantFormat.FormatData.MyParentFormat;
}
return null;
}
}
public ItemInfo FirstSibling
{
get
{
ItemInfo temp = this;
while (temp.MyPrevious != null) temp = temp.MyPrevious;
return temp;
}
}
public ItemInfo LastSibling
{
get
{
ItemInfo temp = this;
ItemInfo last = this;
while (temp != null)
{
last = temp;
temp = temp.GetNext();
}
return last;
}
}
public ItemInfo LastChild(E_FromType partType)
{
ItemInfoList myitems = Lookup((int)partType);
if (myitems != null) return myitems[myitems.Count - 1];
return null;
}
public ItemInfo FirstChild(E_FromType partType)
{
ItemInfoList myitems = Lookup((int)partType);
if (myitems != null) return myitems[0];
return null;
}
public bool HasAncestor(ItemInfo ancestor)
{
if (ancestor == null) return false;
ItemInfo parent = ActiveParent as ItemInfo;
if (parent == null) return false;
if (ancestor.ItemID == parent.ItemID) return true;
return parent.HasAncestor(ancestor);
}
#endregion
public int FoldoutIndex()
{
if (ActiveFormat.PlantFormat.FormatData.PrintData.SectionLevelFoldouts && (((ActiveSection.MyDocStyle.StructureStyle.Style ?? 0) & E_DocStructStyle.UseSectionFoldout) != 0)) return 0;
// now check for floating foldouts. If there is a floating foldout, also find which one it uses.
// This is data off of the ?
if (ActiveFormat.PlantFormat.FormatData.PrintData.AlternateFloatingFoldout && ActiveSection.IsDefaultSection)
{
StepConfig sc = MyConfig as StepConfig;
int iiForFoldout = sc != null ? sc.Step_FloatingFoldout : -1;
if (iiForFoldout <= 0) return -1;
int fldid = sc.Step_FloatingFoldout;
if (fldid == 0) return 0;
int indxOfFoldout = 0;
foreach (ItemInfo sect in MyProcedure.Sections)
{
SectionConfig scfe = sect.MyConfig as SectionConfig;
if (sect.ItemID == fldid) return indxOfFoldout;
if (scfe.Section_IsFoldout == "Y") indxOfFoldout++; // C2019-042 Section_ISFoldout will check for section number "FOLDOUT" or if check box is checked
}
return 0;
}
return -1; // does not have a foldout
}
#region More IsType
public bool IsProcedurePart
{
get
{
if (FromType != null)
return (FromType == E_FromType.Procedure);
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Procedure));
}
}
public bool IsSectionPart
{
get
{
if (FromType != null)
return (FromType == E_FromType.Section);
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Section));
}
}
public bool IsStepPart
{
get
{
if (FromType != null)
return (FromType == E_FromType.Step);
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Step));
}
}
public bool IsEnhancedStep
{
get
{
if (!IsStep) return false;
StepConfig sc = MyConfig as StepConfig;
if (sc.MyEnhancedDocuments != null && sc.MyEnhancedDocuments.Count == 1 && sc.MyEnhancedDocuments[0].Type == 0) return true;
return false;
}
}
public bool IsEnhancedSection
{
get
{
if (!IsSection) return false;
SectionConfig sc = MyConfig as SectionConfig;
if (sc.MyEnhancedDocuments != null && sc.MyEnhancedDocuments.Count == 1 && sc.MyEnhancedDocuments[0].Type == 0) return true;
return false;
}
}
public bool IsEnhancedSectionTitleOnly // this is an enhanced document (sectionitem) but only the title is linked.
{
get
{
if (!IsSection) return false;
SectionConfig sc = MyConfig as SectionConfig;
// go back to source & see what type is:
if (sc.MyEnhancedDocuments != null && sc.MyEnhancedDocuments.Count == 1 && sc.MyEnhancedDocuments[0].Type == 0)
{
SectionInfo siSource = SectionInfo.Get(sc.MyEnhancedDocuments[0].ItemID);
if (siSource == null) return true; //B2018-142 null check to allow deletion of unlinked background procedure
SectionConfig scs = siSource.MyConfig as SectionConfig;
if (scs.Section_LnkEnh == "T") return true;
}
return false;
}
}
public bool IsEnhancedProcedure // this is NOT a source, it is enhanced, i.e. background or deviation
{
get
{
if (!IsProcedure) return false;
ProcedureConfig pc = MyConfig as ProcedureConfig;
if (pc.MyEnhancedDocuments != null && pc.MyEnhancedDocuments.Count == 1 && pc.MyEnhancedDocuments[0].Type == 0) return true;
return false;
}
}
public bool IsInSubStep
{
get
{
if (IsHigh) return false;
if (IsStepPart) return true;
ItemInfo parent = ActiveParent as ItemInfo;
if (parent == null) return false;
return parent.IsInSubStep;
}
}
public bool IsInFirstLevelSubStep
{
get
{
ItemInfo temp = FirstSibling;
if (temp.ActiveParent.IsDocVersion) return false;
if (temp.MyParent.IsSection) return false; // already at hls
if (temp.IsProcedure || temp.IsSection) return false;
while (((ItemInfo)temp.ActiveParent).IsHigh == false)
temp = ((ItemInfo)temp.ActiveParent).FirstSibling;
return temp.IsStepPart;
}
}
public bool IsStepSection
{
get
{
//override docstyle based on content of the section. If the section has word content then return false
if (IsSection && MyContent.ContentEntryCount == 0 && MyDocStyle.IsStepSection) return true;
return false;
}
}
public bool IsSection
{
get
{
if ((MyContent.Type / 10000) == 1) return true;
return false;
}
}
public bool IsDefaultSection
{
get
{
// check to see if ActiveParent is a section, if so it is a high level step
if (MyContent.Type / 10000 != 1) return false;
// get procedure section and then
ItemInfo parent = (ItemInfo)ActiveParent;
if (!parent.IsProcedure) return false;
ProcedureConfig pc = (ProcedureConfig)parent.MyConfig;
int sectstartid = -1;
string ss = pc == null ? null : pc.SectionStart;
if (ss != null && ss != "") sectstartid = System.Convert.ToInt32(ss);
else return false;
if (ItemID == sectstartid) return true;
SectionInfo si = SectionInfo.Get(sectstartid);
if (si == null) return false;
if (si.MyProcedure.ItemID == MyProcedure.ItemID) return false;
if (si.DisplayNumber == DisplayNumber && si.DisplayText == DisplayText)
{
using (Procedure p = Procedure.Get(parent.ItemID))
{
if (p.ProcedureConfig.SectionStart != ItemID.ToString())
{
p.ProcedureConfig.SectionStart = ItemID.ToString();
p.Save();
}
}
return true;
}
return false;
}
}
public bool IsSubsection
{
get
{
if (!IsSection) return false;
ItemInfo par = ActiveParent as ItemInfo;
if (par == null || !par.IsSection) return false;
return true;
}
}
public bool IsSubsectionNumber
{
// returns whether the subsection number is derived from section number,
// for example 6.9 is subsectionnumber of 6.0. B is not a subsectionnumber of 6.9
get
{
if (!IsSection) return false;
ItemInfo par = ActiveParent as ItemInfo;
if (par == null || !par.IsSection) return false;
string parNumber = par.DisplayNumber;
string myNumber = DisplayNumber;
if (parNumber == null || myNumber == null) return false;
ItemInfo par2 = par.ActiveParent as ItemInfo;
if (par2 != null && par2.IsSection)
{
// check for 6.1 (parent) and 6.1.1.
if (DisplayNumber.StartsWith((ActiveParent as SectionInfo).DisplayNumber.Trim())) return true;
}
if (!parNumber.Trim().EndsWith(".0")) return false;
return (myNumber.Trim().StartsWith(parNumber.Trim().Substring(0, parNumber.Length - 1)));
}
}
public bool IsSeparateSubsection
{
get
{
return (IsSubsection && !IsSubsectionNumber);
}
}
public bool IsFolder
{
get
{
return false;
}
}
public bool IsDocVersion
{
get
{
return false;
}
}
public bool IsProcedure
{
get
{
if ((MyContent.Type / 10000) == 0) return true;
return false;
}
}
public bool IsStep
{
get
{
if ((MyContent.Type / 10000) == 2) return true;
return false;
}
}
private E_FromType ItemType
{
get
{
if (MyContent.Type == 0) return E_FromType.Procedure;
if (MyContent.Type < 20000) return E_FromType.Section;
return E_FromType.Step;
}
}
public Item GetByType()
{
Item tmp = null;
switch (ItemType)
{
case E_FromType.Procedure:
tmp = Procedure.Get(_ItemID);
break;
//case E_FromType.Section:
// itemInfo = new Section(dr);
// break;
//default:
// itemInfo = new Step(dr);
// break;
}
return tmp;
}
#endregion
#region Ordinal CslaType and Tostring
//[NonSerialized]
internal int? _Ordinal;
public int Ordinal
{
get
{
if (_Ordinal == null)
{
if (MyPrevious != null)
_Ordinal = MyPrevious.Ordinal + 1;
else
_Ordinal = 1;
}
return (int)_Ordinal;
}
}
public bool IsSubStep
{
get { return IsStep && !IsHigh && !IsTable && !IsFigure; }
}
public string CslaType
{ get { return this.GetType().FullName; } }
public override string ToString()
{
//Item editable = Item.GetExistingByPrimaryKey(_ItemID);
//return string.Format("{0}{1} {2}", (editable == null ? "" : (editable.IsDirty ? "* " : "")),
// (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : MyContent.Number), MyContent.Text);
ContentInfo cont = MyContent;
//string number = cont.Number;
string number = DisplayNumber;
//if (cont.Type >= 20000) number = Ordinal.ToString() + ".";
if ((cont.Type == 20036 || cont.Type == 20037 || cont.Type == 20038 || cont.Type == 20039))// && !RO
{
if (MyContent.ContentRoUsages == null || MyContent.ContentRoUsages.Count == 0)
return "Embedded Image";
}
if (IsRtfRaw) return "Equation";
if (cont.Type >= 20000) number = MyTab == null ? "" : MyTab.CleanText;
return string.Format("{0} {1}", number, DisplayText).Trim(); // Need TrimEnd(); for IP3
//return string.Format("{0} {1}", number, cont.Text).Trim();
//return string.Format("{0} {1}", cont.Number, cont.Text);
}
//public string ToString(string str,System.IFormatProvider ifp)
//{
// return ToString();
//}
#endregion
#region UnlinkEnhanced
public void DoUnlinkEnhanced(ItemInfo enhii)
{
try
{
using (ContentInfoList cil = ContentInfoList.DoEnhancedUnlink(enhii.ItemID))
{
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);
}
}
}
}
catch (Exception ex)
{
throw new DbCslaException("Error on ProcedureInfo:DoUnlinkEnhanced", ex);
}
}
#endregion UnlinkEnhanced
#region Search
internal string _SearchDVPath;
public string SearchDVPath
{
get
{
if (_SearchDVPath == null)
{
if (ActiveParent != null)
_SearchDVPath = ActiveParent.SearchDVPath;
else // RHM 20151026 - B2015-171 This was added to handle an error in the Library Document Report
_SearchDVPath = string.Format("Disconnected Data {0}", ItemID);
}
return _SearchDVPath;
}
}
internal string _SearchPath;
public string SearchPath
{
get
{
if (_SearchPath == null)
{
if (IsProcedure)
_SearchPath = ActiveParent.SearchPath + "\u0007" + (DisplayNumber ?? "") + "\u0011" + DisplayText;
else if (IsSection)
_SearchPath = ActiveParent.SearchPath + "\u0007" + (DisplayNumber ?? "") + "\u0011" + DisplayText;
else
{
PartInfo myPart = FirstSibling.ItemPartCount > 0 ? FirstSibling.ItemParts[0] : null;
if (myPart != null)
_SearchPath = myPart.SearchPath + (!IsHigh ? "." : "\u0007") + Ordinal.ToString();
else
_SearchPath = ActiveParent.SearchPath + (!IsHigh ? "." : "\u0007") + Ordinal.ToString();
}
}
return _SearchPath;
}
}
public string ShortSearchPath
{
get
{
string dtext = ConvertToDisplayText(Regex.Replace(_SearchPath ?? "", "\x11.*?\x07", "\x07"));
if (IsFigure && dtext.EndsWith("Table.")) dtext = dtext.Substring(0, dtext.Length - "Table.".Length) + "Figure.";
else if (IsRtfRaw && dtext.EndsWith("Table.") && FormatStepData.Type.Contains("Equation")) dtext = dtext.Substring(0, dtext.Length - "Table.".Length) + "Equation.";
return dtext;
}
}
internal int _SearchAnnotationID;
public int SearchAnnotationID
{
get { return _SearchAnnotationID; }
}
internal string _SearchAnnotationText;
public string SearchAnnotationText
{
get { return _SearchAnnotationText; }
set { _SearchAnnotationText = value; }
}
internal string _SearchAnnotationType;
public string SearchAnnotationType
{
get { return _SearchAnnotationType; }
}
#endregion
#region Reports
internal string _FoundROID;
public string FoundROID
{
get { return _FoundROID; }
}
#endregion
#region ProcedureConfig
[NonSerialized]
private ProcedureConfig _ProcedureConfig = null;
public PrintChangeBar PrintChangeBar
{
get
{
if (_ProcedureConfig == null) SetProcedureConfig();
return _ProcedureConfig.Print_ChangeBar;
}
}
public PrintChangeBarLoc PrintChangeBarLoc
{
get
{
if (_ProcedureConfig == null) SetProcedureConfig();
return _ProcedureConfig.Print_ChangeBarLoc;
}
}
public PrintChangeBarText PrintChangeBarText
{
get
{
if (_ProcedureConfig == null) SetProcedureConfig();
return _ProcedureConfig.Print_ChangeBarText;
}
}
public string PrintChangeBarUsrMsg1
{
get
{
if (_ProcedureConfig == null) SetProcedureConfig();
return _ProcedureConfig.Print_UserCBMess1;
}
}
public string PrintChangeBarUsrMsg2
{
get
{
if (_ProcedureConfig == null) SetProcedureConfig();
return _ProcedureConfig.Print_UserCBMess2;
}
}
private void SetProcedureConfig()
{
// Walk up tree until find my procedure. Then get its change bar (default will
// get inherited information if not set at this level).
// Find the procedure level and its config.
ItemInfo tmpitm = this;
while (tmpitm.MyContent.Type != 0)
tmpitm = tmpitm.MyParent;
ProcedureInfo pi = ProcedureInfo.Get(tmpitm.ItemID);
if (pi == null) return;
_ProcedureConfig = pi.MyConfig as ProcedureConfig;
}
#endregion
#region Formatting of Text
//jcb added inherited applicability
public bool IsApplicable(int apple)
{
if (apple == -1)
return true;
ItemInfo parent = this.ActiveParent as ItemInfo;
IItemConfig cfg = this.MyConfig as IItemConfig;
return (this.IsProcedure || parent.IsApplicable(apple)) && (cfg.MasterSlave_Applicability.GetFlags().Count == 0 || cfg.MasterSlave_Applicability.GetFlags().Contains(apple));
}
//end jcb added inherited applicability
public string FormattedDisplayText
{
get
{
string str = MyContent.Text;
str = Regex.Replace(str, @"\<[uU]\>", MyDocVersion.DocVersionConfig.Unit_Number);
//if (str.Contains("<u>"))
// str = str.Replace("<u>", MyDocVersion.DocVersionConfig.Unit_Number);
//if (str.Contains("<U>"))
// str = str.Replace("<U>", MyDocVersion.DocVersionConfig.Unit_Number);
return ConvertToDisplayText(str, false);
}
}
// Used in Comanche Peak EOP and Flex formats for step designators. Will allow a hard return to be used that that caution type.
// need to use the SameRowAsParentMultiLines format flag in that step type.
// regular DisplayText will convert the hard return to a semi-colon.
public string MulitLineStepDesignatorDisplayText
{
get
{
string str = MyContent.Text;
if (MyDocVersion != null)
{
str = Regex.Replace(str, @"\<[uU]\>", MyDocVersion.DocVersionConfig.Unit_Number);
}
else
{
_MyLog.WarnFormat("Disconnected Data - ItemID = {0}", ItemID);
}
return ConvertToMulitLineStepDesignatorDisplayText(str);
}
}
public string DisplayText
{
get
{
if (IsRtfRaw) return ("Equation");
if (IsFigure) return ("Figure"); // Added for B2016-236
string str = MyContent.Text;
if (MyDocVersion != null)
{
str = Regex.Replace(str, @"\<[uU]\>", MyDocVersion.DocVersionConfig.Unit_Number);
}
else
{
_MyLog.WarnFormat("Disconnected Data - ItemID = {0}", ItemID);
}
//if (str.Contains("<u>"))
// str = str.Replace("<u>", MyDocVersion.DocVersionConfig.Unit_Number);
//if (str.Contains("<U>"))
// str = str.Replace("<U>", MyDocVersion.DocVersionConfig.Unit_Number);
return ConvertToDisplayText(str);
}
}
static Dictionary<string, string> _SpecialCharacters = null;
static Dictionary<string, string> SpecialCharacters
{
get
{
if(_SpecialCharacters==null){
_SpecialCharacters = new Dictionary<string, string>();
_SpecialCharacters.Add(@"\u916?", "{Delta}");
_SpecialCharacters.Add(@"\line", "{Hard Return1}");
_SpecialCharacters.Add("\r\n", "{Hard Return2}");
_SpecialCharacters.Add(@"\'b0", "{Degree1}");
_SpecialCharacters.Add(@"\'B0", "{Degree2}");
_SpecialCharacters.Add(@"\u9586?","{backslash}");
_SpecialCharacters.Add(@"\u8805?","{greater than or equal}");
_SpecialCharacters.Add(@"\u8804?","{less than or equal}");
_SpecialCharacters.Add(@"\'b1","{plus minus}");
_SpecialCharacters.Add(@"\u931?","{sigma}");
_SpecialCharacters.Add(@"\u947?","{gamma}");
_SpecialCharacters.Add(@"\'bd","{half}");
_SpecialCharacters.Add(@"\u9604?","{accum}");
_SpecialCharacters.Add(@"\u9679?","{bullet}");
_SpecialCharacters.Add(@"\u8776?","{approx eq}");
_SpecialCharacters.Add(@"\u8773?","{similar eq}");
_SpecialCharacters.Add(@"\'f7","{division}");
_SpecialCharacters.Add(@"\u8730?","{square root}");
_SpecialCharacters.Add(@"\u961?","{rho}");
_SpecialCharacters.Add(@"\u960?","{pi}");
_SpecialCharacters.Add(@"\u956?","{micro}");
_SpecialCharacters.Add(@"\u948?","{lower case delta}");
_SpecialCharacters.Add(@"\u963?","{lower case sigma}");
_SpecialCharacters.Add(@"\'bc","{quarter}");
_SpecialCharacters.Add(@"\'d8","{dist zero}");
_SpecialCharacters.Add(@"\u274?","{energy}");
_SpecialCharacters.Add(@"\'ec","{grave}");
_SpecialCharacters.Add(@"\u9474?","{bar}");
_SpecialCharacters.Add(@"\u949?","{epsilon}");
_SpecialCharacters.Add(@"\u952?","{theta}");
_SpecialCharacters.Add(@"\u8857?","{dot in oval}");
_SpecialCharacters.Add(@"\u964?","{tau}");
_SpecialCharacters.Add(@"\u9830?","{diamond}");
_SpecialCharacters.Add(@"\u8593?","{Up Arrow}");
_SpecialCharacters.Add(@"\u8595?","{Down Arrow}");
}
return _SpecialCharacters;
}
}
public string DisplayTextKeepSpecialChars
{
get
{
string str = MyContent.Text;
if (MyDocVersion != null)
{
str = Regex.Replace(str, @"\<[uU]\>", MyDocVersion.DocVersionConfig.Unit_Number);
}
else
{
_MyLog.WarnFormat("Disconnected Data - ItemID = {0}", ItemID);
}
foreach (string key in SpecialCharacters.Keys)
str = str.Replace(key, SpecialCharacters[key]);
string retval = ConvertToDisplayText(str);
foreach (string key in SpecialCharacters.Keys)
retval = retval.Replace(SpecialCharacters[key],key);
return retval;
}
}
public string DisplayNumber
{
get
{
string str = MyContent.Number;
if (MyDocVersion != null)
{
str = (this.IsProcedure) ? MyDocVersion.UnitSpecific(MyContent.Number, 0) : MyContent.Number;
str = Regex.Replace(str, @"\<U-ID\>", MyDocVersion.DocVersionConfig.Unit_ID, RegexOptions.IgnoreCase);
str = Regex.Replace(str, @"\<ID\>", MyDocVersion.DocVersionConfig.Unit_ID, RegexOptions.IgnoreCase);
}
else
{
str = "*" + str;
_MyLog.WarnFormat("Disconnected Data - ItemID = {0}", ItemID);
}
//if (str.Contains("<U-ID>"))
// str = str.Replace("<U-ID>", MyDocVersion.DocVersionConfig.Unit_ID);
//if (str.Contains(@"<S\u8209?ID>"))
// str = str.Replace(@"<S\u8209?ID>", MyDocVersion.DocVersionConfig.Unit_ID);
str = ConvertToDisplayText(str);
str = Regex.Replace(str, @"\<[uU]\>", MyDocVersion.DocVersionConfig.Unit_Number); // B2017-019 - process "<u>" in section number
return str;
}
//get { return ConvertToDisplayText(MyContent.Number); }
}
// for step designators (a redefined caution type used in Comanche Peak with the SameRowAsParentMultiLines format flag)
// we what to allow for a hard return to allow for multiple designator lines - jsj 5/21/2015
public static string ConvertToMulitLineStepDesignatorDisplayText(string txt)
{
string retval = txt;
retval = StripRtfFormatting(retval);
retval = StripLinks(retval);
retval = ReplaceSpecialCharacters(retval);
retval = retval.Replace("\u2011", "-");
retval = retval.Replace("\r\n", @"\line");
retval = retval.Replace("\n", @"\line");
return retval;
}
public static string ConvertToDisplayText(string txt)
{
return ConvertToDisplayText(txt, true);
}
public static string ConvertToDisplayText(string txt, bool stripRTF)
{
string retval = txt;
if (stripRTF) retval = StripRtfFormatting(retval);
retval = StripLinks(retval);
retval = ReplaceSpecialCharacters(retval);
retval = retval.Replace("\u2011", "-");
retval = retval.Replace("\u2572", @"\"); // replace backslash symbol with a backslash
retval = Regex.Replace(retval, @"\\line ?", ";"); // better handing of hard returns - replace with semi-colon for use on tree view
retval = retval.Replace("\r\n", ";");
retval = retval.Replace("\n", ";"); //added for consistency checking with approved version
return retval;
}
public static string StripRtfFormatting(string rtf)
{
string retval = rtf;
retval = Regex.Replace(retval, @"\\b0 ?", "");
retval = Regex.Replace(retval, @"\\b ?", "");
retval = Regex.Replace(retval, @"\\ulnone ?", "");
retval = Regex.Replace(retval, @"\\ul0 ?", "");
retval = Regex.Replace(retval, @"\\ul ?", "");
retval = Regex.Replace(retval, @"\\i0 ?", "");
retval = Regex.Replace(retval, @"\\i ?", "");
//retval = Regex.Replace(retval, @"\\super ?", "");
//retval = Regex.Replace(retval, @"\\sub ?", "");
//retval = Regex.Replace(retval, @"\\nosupersub ?", "");
retval = Regex.Replace(retval, @"\\up[320] ?", "");
retval = Regex.Replace(retval, @"\\dn[320] ?", "");
retval = Regex.Replace(retval, @"\\li[0-9]+ ?", ""); // changed the * to a + to "\\line " for hard returns part of bug fix B2015-140
retval = Regex.Replace(retval, @"\\fi-[0-9]+ ?", "");
return retval;
}
public static string StripLinks(string rtf)
{
string retval = rtf;
retval = Regex.Replace(retval, @"\\v.*?\\v0 ?", "");
retval = retval.Replace("\u252C", "");// Unicode 9516 Transition
retval = retval.Replace("\u2566", "");// Unicode 9574 Transition
retval = retval.Replace("\u0015", "");// Unicode 21 RO
return retval;
}
private static string ReplaceSpecialCharacter(Match m)
{
StringBuilder sb = new StringBuilder();
int i = int.Parse(m.ToString().Substring(2, m.ToString().Length - 3));
sb.Append((char)i);
return sb.ToString();
}
private static string ReplaceSpecialHexCharacter(Match m)
{
StringBuilder sb = new StringBuilder();
int i = int.Parse(m.ToString().Substring(2), System.Globalization.NumberStyles.HexNumber);
sb.Append((char)i);
return sb.ToString();
}
private static string ReplaceSpecialCharacters(string rtf)
{
string retval = rtf;
retval = retval.Replace("`", "\u00B0");// Degree
retval = Regex.Replace(retval, @"\\u[0-9]+[?]", new MatchEvaluator(ReplaceSpecialCharacter));
retval = Regex.Replace(retval, @"\\'[0-9A-Fa-f][0-9A-Fa-f]", new MatchEvaluator(ReplaceSpecialHexCharacter));
return retval;
}
//public void ShowThis(string title)
//{
// Console.WriteLine("'{0}',,,,'i{1}','u{2}',{3},'{4}','{5}','{6}','{7}'", title, ItemID, MyItemInfoUnique, PreviousID, this, _MyPrevious, _MyParent, _ActiveParent);
//}
public VE_Font GetItemFont()
{
/*
FormatInfo fmt = ActiveFormat;
if (fmt == null)
{
ShowThis();
if (MyPrevious != null)
{
MyPrevious.ShowThis();
if (MyPrevious.ActiveFormat == null)
{
_ActiveParent = MyPrevious.MyParent;
MyPrevious._ActiveParent = _ActiveParent;
fmt = _ActiveParent.ActiveFormat;
MyPrevious._ActiveFormat = fmt;
Console.WriteLine("OOPS!");
}
else if (MyParent != null)
{
_ActiveParent = MyParent;
fmt = _ActiveParent.ActiveFormat;
}
}
}
*/
return GetItemFont(ActiveFormat);
}
public VE_Font GetItemFont(FormatInfo fmt)
{
VE_Font font = null;
try
{
FormatInfo format = (LocalFormat != null || fmt == null) ? LocalFormat : fmt;//_MyItemInfo.ActiveFormat;
int type = (int)MyContent.Type;//_MyItemInfo.MyContent.Type;
switch (type / 10000)
{
case 0: // procedure
font = format.PlantFormat.FormatData.Font;
break;
case 1: // section
if (format.PlantFormat.FormatData.SectData.SectionHeader.OnlyUnderlineTopSect && MyParent.IsSection)
{
VE_Font hdrFont = format.PlantFormat.FormatData.SectData.SectionHeader.Font;
E_Style es = (E_Style)(hdrFont.Style & E_Style.Bold);
font = new VE_Font(hdrFont.Family, (int)hdrFont.Size, es, (float)hdrFont.CPI);
}
else
font = format.PlantFormat.FormatData.SectData.SectionHeader.Font;
break;
case 2: // step types
int typindx = type - 20000; // what to do for other types rather than steps
font = format.PlantFormat.FormatData.StepDataList[typindx].Font;
if (typindx == _ParagraphType) font = AdjustForTextSubFollowsTextStyle(format, typindx, font);
if (IsRNOPart && MyParent.IsHigh && FormatStepData.BoldHighLevel) font = BoldTextStyle(font);
break;
}
}
catch (Exception ex)
{
Console.WriteLine("GetItemFont(): {0} - {1}", ex.GetType(), ex.Message);
}
return font;
}
private VE_Font BoldTextStyle(VE_Font font)
{
E_Style myStyle = (E_Style)font.Style;
myStyle |= E_Style.Bold;
if (myStyle != font.Style)
font = new VE_Font(font.Family, (int)font.Size, myStyle, (float)font.CPI);
return font;
}
private const int _ParagraphType = 24;
protected VE_Font AdjustForTextSubFollowsTextStyle(VE_Font font)
{
return AdjustForTextSubFollowsTextStyle(ActiveFormat, this.FormatStepType, font);
}
private VE_Font AdjustForTextSubFollowsTextStyle(FormatInfo format, int typindx, VE_Font font)
{
StepData myFormatStepData = format.PlantFormat.FormatData.StepDataList[typindx];
if (myFormatStepData.TextSubFollowsTextStyle && ParentNoteOrCaution != null)
{
bool isBold = (myFormatStepData.Font.Style & E_Style.Bold) > 0;
bool isMmBold = (myFormatStepData.Font.Style & E_Style.MmBold) > 0;
myFormatStepData = format.PlantFormat.FormatData.StepDataList[ParentNoteOrCaution.FormatStepType];
font = myFormatStepData.Font;
E_Style myStyle = (E_Style)font.Style;
myStyle ^= (myStyle & E_Style.Bold);
myStyle ^= (myStyle & E_Style.MmBold);
myStyle |= isBold ? E_Style.Bold : 0;
myStyle |= isMmBold ? E_Style.MmBold : 0;
if (myStyle != font.Style)
font = new VE_Font(font.Family, (int)font.Size, myStyle, (float)font.CPI);
}
return font;
}
private string RemoveToken(string str, string token)
{
// if this token is preceeded by another token and followed by a space
// leave the preceeding token the ending space
string retval = Regex.Replace(str, @"(\\[^ \\?\r\n\t]*)" + token + " ", "$1 ");
//if (retval != str) // Show the token replacement
// Console.WriteLine("Leave the preceeding token the ending space '{0}'\r\n{1}\r\n{2}",token,str,retval);
// otherwise replace the token optionally followed by a space
retval = Regex.Replace(retval, token + " ?", "");
return retval;
}
public string RemoveRtfStyles(string rtf)
{
return RemoveRtfStyles(rtf, ActiveFormat);
}
public string RemoveRtfStyles(string rtf, FormatInfo fmt)
{
string retval = rtf;
VE_Font TextFont = GetItemFont(fmt);
if (TextFont != null)
{
// remove rtf commands for any styles that were added. Note that if
// the entire item has a style, and also contains 'pieces' of text with
// the same style, the underlying rtf box removes the embedded rtf commands,
// for example, if the entire step is bolded, and 'THEN' has bold on/off
// surrounding it, the rtf box removes the bold around the 'THEN'
// These remove the command with a following space or the command alone,
// either case may exist, because if there are rtf commands following the
// style command, there will be no space character following the style command.
if (((TextFont.Style & E_Style.Bold) > 0) || ((TextFont.Style & E_Style.MmBold) > 0))
{
retval = RemoveToken(retval, @"\\b0");
retval = RemoveToken(retval, @"\\b");
}
if ((TextFont.Style & E_Style.Underline) > 0)
{
retval = RemoveToken(retval, @"\\ulnone");
retval = RemoveToken(retval, @"\\ul");
}
if ((TextFont.Style & E_Style.Italics) > 0)
{
retval = RemoveToken(retval, @"\\i0");
retval = RemoveToken(retval, @"\\i");
}
}
return retval;
}
public bool SameRowAsParent
{
get
{
return ActiveFormat.PlantFormat.FormatData.StepDataList[FormatStepType].SameRowAsParent;
}
}
public bool SameRowAsParentMultiLines
{
get
{
return ActiveFormat.PlantFormat.FormatData.StepDataList[FormatStepType].SameRowAsParentMultiLines;
}
}
public string WidthOverride
{
get
{
return ActiveFormat.PlantFormat.FormatData.StepDataList[FormatStepType].WidthOverride;
}
}
//public float? WidthOverride
//{
// get
// {
// return ActiveFormat.PlantFormat.FormatData.StepDataList[FormatStepType].WidthOverride;
// }
//}
#endregion
#region Path and Parent
public string Path
{
get
{
string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : ((DisplayNumber ?? "") == "" ? DisplayText : DisplayNumber));
ItemInfo parent = this;
while (parent.MyPrevious != null) parent = parent.MyPrevious;
if (parent.ItemPartCount == 0)
return number + ", " + DisplayText;
else
{
PartInfo partInfo = parent.ItemParts[0];
return partInfo.MyContent.ContentItems.Items[0].Path + " " + ((E_FromType)partInfo.FromType).ToString() + " " + number;
}
}
}
public string ShortPath
{
get
{
string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : ((DisplayNumber ?? "") == "" ? DisplayText : DisplayNumber));
ItemInfo parent = this;
while (parent.MyPrevious != null) parent = parent.MyPrevious;
if (parent.ItemPartCount == 0)
return number;
else
{
PartInfo partInfo = parent.ItemParts[0];
return partInfo.MyContent.ContentItems.Items[0].ShortPath + "." + ((E_FromType)partInfo.FromType).ToString().Substring(0, 1) + number;
}
}
}
public ContentInfo ParentContent
{
get
{
string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : ((MyContent.Number ?? "") == "" ? MyContent.Text : MyContent.Number));
ItemInfo parent = this;
while (parent.MyPrevious != null) parent = parent.MyPrevious;
if (parent.ItemPartCount <= 0 || parent.ItemParts.Count == 0)
return null;
else
{
return parent.ItemParts[0].MyContent;
}
}
}
internal ItemInfo _MyParent;
public ItemInfo MyParent
{
get
{
if (_MyParent == null)
{
//if (ItemDocVersionCount > 0) return ItemDocVersions[0]; Need to create one interface to support Folders, DocVersions and Items
ContentInfo parentContent = ParentContent;
if (parentContent == null || parentContent.ContentItemCount == 0) return null;
if (parentContent.ContentItems.Count == 0) return null;
_MyParent = parentContent.ContentItems[0];
}
return _MyParent;
}
set
{
_MyParent = value;
}
}
#endregion
#region Lookups and More Related
private ItemInfoList Lookup(E_FromType fromType, ref ItemInfoList itemInfoList)
{
//Console.WriteLine(itemInfoList);
if (itemInfoList == null)
itemInfoList = Lookup((int)fromType);
return itemInfoList;
}
private bool _LoadAllAtOnce;
public bool LoadAllAtOnce
{
get { return _LoadAllAtOnce; }
set { _LoadAllAtOnce = value; }
}
internal ItemInfoList Lookup(int fromType)
{
ItemInfoList itemInfoList = null;
if (MyContent.ContentPartCount != 0)
foreach (PartInfo partInfo in MyContent.ContentParts)
if (partInfo.FromType == fromType)
{
if (LoadAllAtOnce)
itemInfoList = partInfo._MyItems;// = ItemInfoList.GetList(partInfo.ItemID, partInfo.FromType);
else
itemInfoList = partInfo._MyItems = ItemInfoList.GetList(partInfo.ItemID, partInfo.FromType);
return itemInfoList;
}
return null;
}
public static void ResetParts(int itemID)
{
string key = itemID.ToString();
if (_CacheByPrimaryKey.ContainsKey(key))
{
bool firstContent = true;
foreach (ItemInfo itm in _CacheByPrimaryKey[key])
{
itm.ResetParts();
if (itm._MyContent != null && firstContent)
{
firstContent = false;// Only need to do this once.
//RefreshContentParts looks through ContentInfo objects
itm._MyContent.RefreshContentParts();
}
}
}
}
public void ResetParts()
{
_Procedures = null;
_Sections = null;
_Cautions = null;
_Notes = null;
_RNOs = null;
_Steps = null;
_Tables = null;
_SupInfos = null;
}
private ItemInfoList _Procedures;
public ItemInfoList Procedures
{ get { return Lookup(E_FromType.Procedure, ref _Procedures); } }
private ItemInfoList _Sections;
public ItemInfoList Sections
{ get { return Lookup(E_FromType.Section, ref _Sections); } }
private ItemInfoList _Cautions;
public ItemInfoList Cautions
{ get { return Lookup(E_FromType.Caution, ref _Cautions); } }
private ItemInfoList _Notes;
public ItemInfoList Notes
{ get { return Lookup(E_FromType.Note, ref _Notes); } }
private ItemInfoList _RNOs;
public ItemInfoList RNOs
{ get { return Lookup(E_FromType.RNO, ref _RNOs); } }
private ItemInfoList _Steps;
public ItemInfoList Steps
{ get { return Lookup(E_FromType.Step, ref _Steps); } }
private ItemInfoList _Tables;
public ItemInfoList Tables
{ get { return Lookup(E_FromType.Table, ref _Tables); } }
private ItemInfoList _SupInfos;
public ItemInfoList SupInfos
{ get { return Lookup(E_FromType.SupInfo, ref _SupInfos); } }
//public void ResetChildren()
//{
// _Procedures = null;
// _Sections = null;
// _Steps = null;
// _Cautions = null;
// _Notes = null;
// _RNOs = null;
// _Steps = null;
// _Tables = null;
//}
//public XmlDocument ToXml()
//{
// XmlDocument retval = new XmlDocument();
// retval.LoadXml("<root/>");
// return ToXml(retval.DocumentElement);
//}
//public void AddList(XmlNode xn,string name, ItemInfoList itemInfoList)
//{
// if (itemInfoList != null)
// {
// XmlNode nd = xn.OwnerDocument.CreateElement(name);
// xn.AppendChild(nd);
// itemInfoList.ToXml(xn);
// }
//}
//public XmlDocument ToXml(XmlNode xn)
//{
// XmlNode nd = MyContent.ToXml(xn);
// // Now add the children
// AddList(nd, "Procedures", Procedures);
// AddList(nd, "Sections", Sections);
// AddList(nd, "Cautions", Cautions);
// AddList(nd, "Notes", Notes);
// AddList(nd, "RNOs", RNOs);
// AddList(nd, "Steps", SubItems);
// AddList(nd, "Tables", Tables);
// return xn.OwnerDocument;
//}
#endregion
#region UI Tab
public string TabToolTip
{
get
{
if (MyContent.MyEntry == null)
return DisplayNumber + " - " + DisplayText;
string toolTip = MyProcedure.TabToolTip + "\r\n";
if (MyContent.Number != "")
toolTip += DisplayNumber + " - " + DisplayText;
else
toolTip += DisplayText;
DocumentInfo myDocument = MyContent.MyEntry.MyDocument;
if (myDocument.LibTitle != "")
{
toolTip += string.Format("\r\n(Library Document - {0})\r\n", myDocument.LibTitle);
toolTip += myDocument.LibraryDocumentUsage;
}
return toolTip.Replace('\xA0', ' ');//Replace Hardspace with a space
}
}
public string TabTitle
{
get
{
if (MyContent.MyEntry == null)
{
if (DisplayNumber == string.Empty)
return DisplayText.Replace("\u2011", "-").Replace("\u2572", @"\\").Split(" ,.;:-_".ToCharArray())[0] + "...";
return DisplayNumber.Replace("\u2011", "-").Replace("\u2572", @"\\");
}
if (MyContent.Number != "") // Add LIB to the Section Number
return ((MyContent.MyEntry.MyDocument.LibTitle ?? "") == "" ? "" : "\u1D38\u1D35\u1D2E ") + DisplayNumber;
if (MyContent.MyEntry.MyDocument.LibTitle != "")
{
if (DisplayText.Length <= 7) return "\u1D38\u1D35\u1D2E " + DisplayText.Replace("\u2011", "-").Replace("\u2572", @"\\");
return "\u1D38\u1D35\u1D2E " + DisplayText.Replace("\u2011", "-").Split(" ,.;:-_".ToCharArray())[0] + "...";
}
if (DisplayText.Length <= 10)
return DisplayText.Replace("\u2011", "-").Replace("\u2572", @"\\");
return DisplayText.Replace("\u2011", "-").Replace("\u2572", @"\\").Split(" ,.;:-_".ToCharArray())[0] + "...";
}
}
#endregion
#region Change Bar
public bool HasChangeBar
{
get
{
bool chg = HasChanges;
StepInfo si = this as StepInfo;
if (si == null) return false;
StepConfig sc = si.MyConfig as StepConfig;
if (sc == null) return false;
// if there is no override & return whether there was a change to the text.
if (chg && ActiveFormat.PlantFormat.FormatData.ProcData.ChangeBarData.ChangeIds &&
(sc.Step_ChangeID ?? "") == "")
return false; // No Change ID - No Change Bar
if ((sc.Step_SpellCheckerChangedText ?? "") == "NoChangeBar")
return false; // Spell Checker, in editorial mode (format flag EditoralSpellCheck) , made the change and there was no change bar prior to that change B2015-024
if (sc.Step_CBOverride == null)
return chg;
return (sc.Step_CBOverride == "On");
}
}
public bool HasChanges
{
get
{
if (this.IsAccPages || this.IsProcedure || this.IsSection) return false;
StepInfo si = this as StepInfo;
if (si == null) return false;
StepConfig sc = si.MyConfig as StepConfig;
if (sc == null) return false;
// go back to source & see what date it has:
if (sc.MyEnhancedDocuments != null && sc.MyEnhancedDocuments.Count == 1 && sc.MyEnhancedDocuments[0].Type == 0)
{
ItemInfo ii = ItemInfo.Get(sc.MyEnhancedDocuments[0].ItemID);
if (ii == null) return false; // when deleting a source step, this was causing a crash (null ii)
return (ii.MyContent.DTS > MyProcedure.ChangeBarDate);
}
// if there is no override & return whether there was a change to the text.
return (MyContent.DTS > MyProcedure.ChangeBarDate);
}
}
#endregion
#region IVEReadOnlyItem
PartInfoList _PartInfoList;
public System.Collections.IList GetChildren()
{
_PartInfoList = this.MyContent.ContentParts;
if (_PartInfoList.Count == 1 && ((IsProcedure && _PartInfoList[0].ToString() == "Sections") || _PartInfoList[0].ToString() == "Steps"))
return _PartInfoList[0].GetChildren();
return _PartInfoList;
}
public System.Collections.IList GetChildren(bool allParts)
{
_PartInfoList = this.MyContent.ContentParts;
if (allParts)
{
if (_PartInfoList.Count == 1 && ((IsProcedure && _PartInfoList[0].ToString() == "Sections") || _PartInfoList[0].ToString() == "Steps"))
return _PartInfoList[0].GetChildren();
return _PartInfoList;
}
else // Steps and Sections only
{
for (int i = 0; i < _PartInfoList.Count; i++)
if (_PartInfoList[i].ToString() == "Sections" || _PartInfoList[i].ToString() == "Steps")
return _PartInfoList[i].GetChildren();
return null;
}
}
//public bool ChildrenAreLoaded
//{
// get { return _PartInfoList == null; }
//}
public bool HasChildren
{
get { return this.MyContent.ContentPartCount > 0; }
}
public bool HasEnhancedLinkedStep
{
get
{
if (!IsStep) return false;
StepConfig sc = MyConfig as StepConfig;
if (sc.MyEnhancedDocuments != null && sc.MyEnhancedDocuments.Count > 0 && sc.MyEnhancedDocuments[0].Type != 0) return true;
return false;
}
}
public bool HasWordContent
{
get { return this.MyContent.MyEntry != null; }
}
public bool HasStepContent
{
get
{
if (MyContent.ContentPartCount == 0) return false;
if (MyContent.ContentPartCount == 1 && MyContent.ContentParts[0].PartType == E_FromType.Section) return false;
return true;
}
}
// B2018-054 added check for sub sections - fixes issue of added a new section (step section) then adding sub-section, then changing main section to word section
public bool HasSectionContent
{
get
{
if (MyContent.ContentPartCount == 0) return false;
if (MyContent.ContentPartCount == 1 && MyContent.ContentParts[0].PartType == E_FromType.Section) return true;
return false;
}
}
private ProcedureInfo _MyProcedure;
public ProcedureInfo MyProcedure
{
get
{
if (_MyProcedure == null)
{
// Walk up active parents until the parent is not an item
ItemInfo tmp = this;
while (tmp.ActiveParent != null && !tmp.ActiveParent.IsDocVersion)
tmp = (ItemInfo)tmp.ActiveParent;
if (tmp is ProcedureInfo)
_MyProcedure = tmp as ProcedureInfo;
else
_MyProcedure = ProcedureInfo.Get(tmp.ItemID);
}
return _MyProcedure;
}
set
{
_MyProcedure = value;
}
}
private ItemInfo _MyHLS = null;
public ItemInfo MyHLS
{
get
{
if (_MyHLS == null)
{
if (IsHigh) _MyHLS = this;
else
{
if (MyActiveParent is ItemInfo)
_MyHLS = ((ItemInfo)MyActiveParent).MyHLS;
}
}
return _MyHLS;
}
}
private string _CombinedTab = null;
public string CombinedTab
{
get { return _CombinedTab; }
set { _CombinedTab = value; }
}
private DocVersionInfo _MyDocVersion = null;
public DocVersionInfo MyDocVersion
{
get
{
if (_MyDocVersion == null)
{
if (ActiveParent is DocVersionInfo)
_MyDocVersion = ActiveParent as DocVersionInfo;
else
{
if (ActiveParent == null) return null;
_MyDocVersion = (ActiveParent as ItemInfo).MyDocVersion;
}
}
return _MyDocVersion;
}
set { _MyDocVersion = value; }
}
internal IVEDrillDownReadOnly _ActiveParent = null;
public IVEDrillDownReadOnly MyActiveParent { get { return _ActiveParent; } }
public IVEDrillDownReadOnly ActiveParent
{
get
{
//if (_ActiveParent == this)_ActiveParent = null;
if (_ActiveParent == null)
{
if (MyPrevious != null)
_ActiveParent = _MyPrevious.ActiveParent;
else
{
if (this.ItemDocVersions != null && this.ItemDocVersions.Count > 0)
_ActiveParent = this.ItemDocVersions[0];
else
{
//The following using command caused a cached iteminfo to be disposed.
//using (ContentInfo parentContent = ParentContent)
//{
ContentInfo parentContent = ParentContent;
if (parentContent == null)// || parentContent.ContentItemCount == 0)
_ActiveParent = this;
else
{
int itemID = 0;
if (parentContent.ContentItems.Count == 0)
parentContent.RefreshContentItems();
using (ItemInfoList list = parentContent.ContentItems)
itemID = list[0].ItemID;
if (itemID == 0)
_ActiveParent = this;
else
_ActiveParent = ItemInfo.Get(itemID);
}
//}
}
}
}
return _ActiveParent == this ? null : _ActiveParent;
}
internal set
//set
{
_ActiveParent = value;
}
}
internal ItemInfo _ActiveSection = null;
/// <summary>
/// MyActiveSection is used to determine if _ActiveSection is null or not.
/// </summary>
public ItemInfo MyActiveSection { get { return _ActiveSection; } }
public ItemInfo ActiveSection
{
get
{
if (_ActiveSection == null)
{
if (IsSection)
_ActiveSection = this;
else
{
ItemInfo parent = ActiveParent as ItemInfo;
if (parent != null)
_ActiveSection = parent.ActiveSection;
else
_ActiveSection = this;
}
// B2018-018 Approval bug fix. Active section was in cache as an ItemInfo instead of a SectionInfo
if (_ActiveSection != null && !(_ActiveSection is SectionInfo))
_ActiveSection = SectionInfo.Get(_ActiveSection.ItemID);
}
return _ActiveSection.IsSection ? _ActiveSection : null;
}
set
{
_ActiveSection = value;
}
}
private DocStyle _MyDocStyle;
public DocStyle MyDocStyle
{
get
{
if (_MyDocStyle == null && ActiveSection != null)
{
int typ = (int)ActiveSection.MyContent.Type;
int subtyp = typ % 10000;
if (ActiveFormat.PlantFormat.DocStyles.DocStyleList[subtyp] == null)
foreach (DocStyle ds in ActiveFormat.PlantFormat.DocStyles.DocStyleList)
{
if (ActiveSection.MyContent.ContentEntryCount > 0 && !ds.IsStepSection) return _MyDocStyle = ds;
else if (ds.IsStepSection) return _MyDocStyle = ds;
}
_MyDocStyle = ActiveFormat.PlantFormat.DocStyles.DocStyleList[subtyp];
}
return _MyDocStyle;
}
set
{
_MyDocStyle = value;
}
}
private FormatInfo _ActiveFormat = null;
public FormatInfo ActiveFormat
{
get
{
if (_ActiveFormat == null || !PrintAllAtOnce) // jsj added check for NULL ActiveParent
_ActiveFormat = (LocalFormat != null ? LocalFormat : (ActiveParent != null) ? ActiveParent.ActiveFormat : null);
//Console.WriteLine("Active {0}", (_ActiveFormat == null) ? "_ActiveFormat is null" : _ActiveFormat.Name);
return _ActiveFormat;
}
set
{
_ActiveFormat = value;
}
//get { return LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat; }
}
public FormatInfo LocalFormat
{
get
{
//Console.WriteLine("Local {0}", (MyContent.MyFormat==null)?"MYformat is null": MyContent.MyFormat.Name);
return MyContent.MyFormat;
}
}
private bool _IsDeleted = false;
public bool IsDeleted
{
get { return _IsDeleted; }
set
{
_IsDeleted = value;
if (value == true)
UpdateCacheIsDeleted(ItemID);
}
}
private static void UpdateCacheIsDeleted(int itemID)
{
ConvertListToDictionary();
string key = itemID.ToString();
if (key != null && _CacheByPrimaryKey.ContainsKey(key))
{
ItemInfo[] items = _CacheByPrimaryKey[key].ToArray();
foreach (ItemInfo item in items)
item._IsDeleted = true;
}
}
private ConfigDynamicTypeDescriptor _MyConfig = null;
public ConfigDynamicTypeDescriptor MyConfig
{
get
{
if (_MyConfig == null)
{
switch (MyContent.Type / 10000)
{
case 0:
//_MyConfig = new ProcedureConfig(MyContent.Config);
_MyConfig = new ProcedureConfig(this as ProcedureInfo ?? ProcedureInfo.Get(ItemID));
break;
case 1:
//_MyConfig = new SectionConfig(MyContent.Config);
_MyConfig = new SectionConfig(this as SectionInfo ?? SectionInfo.Get(ItemID));
break;
case 2:
//_MyConfig = new StepConfig(MyContent.Config);
_MyConfig = new StepConfig(this as StepInfo ?? StepInfo.Get(ItemID));
break;
}
}
return _MyConfig;
}
set
{
if (_MyConfig == null) return;
_MyConfig = null;
//MyContent.Config = value;
}
}
public void RefreshConfig()
{
string key = ItemID.ToString();
ConvertListToDictionary();
if (_CacheByPrimaryKey.ContainsKey(key))
foreach (ItemInfo tmpInfo in _CacheByPrimaryKey[key])
tmpInfo.MyConfig = null;
}
public EnhancedDocuments GetMyEnhancedDocuments()
{
switch (MyContent.Type / 10000)
{
case 0:
ProcedureConfig pConfig = MyConfig as ProcedureConfig;
return pConfig.MyEnhancedDocuments;
case 1:
SectionConfig sConfig = MyConfig as SectionConfig;
return sConfig.MyEnhancedDocuments;
case 2:
StepConfig stConfig = MyConfig as StepConfig;
return stConfig.MyEnhancedDocuments;
}
return null;
}
//public bool HasStandardSteps()
//{ return MyContent.ContentItemCount > 1; }
public Color ForeColor
{ get { return (HasBrokenRules != null ? Color.Red : (MyContent.ContentItemCount > 1 ? Color.Blue : Color.Black)); } }
public Color BackColor
{ get { return (ItemAnnotationCount > 0 ? Color.Yellow : Color.White); } }
#endregion
#region Constructor
internal ItemInfo(SafeDataReader dr, bool forIRichtem)
{
if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] ItemInfo.Constructor", GetHashCode());
try
{
ReadData(dr);
AddContent(dr);
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("ItemInfo.Constructor", ex);
throw new DbCslaException("ItemInfo.Constructor", ex);
}
}
internal void AddContent(SafeDataReader dr)
{
_MyContent = new ContentInfo(dr, true);
}
#endregion
#region MetaTags - Tabs, Headers, Footers
[NonSerialized]
protected Tab _MyTab;
public Tab MyTab
{
get
{
if (!_TagsSetup) SetupTags();
return _MyTab;
}
set
{
_MyTab = value;
_TagsSetup = true;
}
}
public string LinkedTab
{
get
{
EnhancedDocuments eds = GetMyEnhancedDocuments();
if (eds != null && eds.Count == 1 && eds[0].Type == 0)
{
ItemInfo srcItem = ItemInfo.Get(eds[0].ItemID);
if (srcItem != null) // B2018-097 handle a null reference
return srcItem.MyTab.ToString();
}
return null;
}
}
// B2019-126 Check the HLS of the source document (ex. EOP step) to see if it includes the section number prefix in its tab
public bool LinkedTabHasSectionPrefix
{
get
{
EnhancedDocuments eds = GetMyEnhancedDocuments();
if (eds != null && eds.Count == 1 && eds[0].Type == 0)
{
ItemInfo srcItem = ItemInfo.Get(eds[0].ItemID);
if (srcItem != null) // B2018-097 handle a null reference
return ((srcItem.ActiveParent as ItemInfo).FormatStepData.TabData.IdentEdit.Contains("{Section Prefix}") && FormatStepData.TabData.IdentEdit.Contains("{Section Prefix}"));
}
return false;
}
}
public int? LinkedOrdinal
{
get
{
EnhancedDocuments eds = GetMyEnhancedDocuments();
if (eds != null && eds.Count == 1 && eds[0].Type == 0)
{
// B2018-114 check for a null before getting the Ordinal value (code that uses this handles a Null return value from this Get
ItemInfo srcItem = ItemInfo.Get(eds[0].ItemID);
if (srcItem == null) return null;
if (srcItem.IsHigh) return srcItem.Ordinal;
// B2018-118: the LinkedOrdinal count must take into account cautions versus notes types:
ItemInfo hls = srcItem.MyHLS;
bool enIsCaution = this.IsCaution;
// get the first sibling and go through list for each type - go through notes first then cautions checking for each type:
// go through cautions first because these are the first parts:
int? ord = 0;
if (hls.Cautions != null && hls.Cautions.Count > 0)
{
foreach (ItemInfo caut in hls.Cautions)
{
if (caut.IsCaution && enIsCaution) ord++;
if (caut.IsNote && !enIsCaution) ord++;
if (caut.ItemID == srcItem.ItemID) return ord==0?null:ord;
}
}
if (hls.Notes != null && hls.Notes.Count > 0)
{
foreach (ItemInfo note in hls.Notes)
{
if (note.IsCaution && enIsCaution) ord++;
if (note.IsNote && !enIsCaution) ord++;
if (note.ItemID == srcItem.ItemID) return ord==0?null:ord;
}
}
}
return null;
}
}
[NonSerialized]
protected MetaTag _MyHeader;
public MetaTag MyHeader
{
get
{
if (!_TagsSetup) SetupTags();
return _MyHeader;
}
set
{
_MyHeader = value;
}
}
[NonSerialized]
protected MetaTag _MyFooter;
public MetaTag MyFooter
{
get
{
if (!_TagsSetup) SetupTags();
return _MyFooter;
}
set { _MyFooter = value; }
}
[NonSerialized]
protected bool _TagsSetup = false;
public virtual void SetupTags()
{
if (IsStep)
{
_MyTab = new Tab(AdjustForTextSubFollowsTextStyle(FormatStepData.TabData.Font));
_MyHeader = new MetaTag(FormatStepData.TabData.Font);
_MyFooter = new MetaTag(FormatStepData.TabData.Font);
SetTabText();
}
else
{
_MyTab = new Tab(ActiveFormat.PlantFormat.FormatData.Font);
_MyHeader = null;
_MyFooter = null;
_MyTab.CleanText = DisplayNumber;
}
_TagsSetup = true;
}
public bool SupplementalInformation
{
get
{
return MyDocStyle == null ? false : MyDocStyle.SupplementalInformation;
}
}
protected void SetTabText()
{
if (IsSection) // B2016-160 Support transitions to sections
{
_MyTab.Text = DisplayNumber;
_MyTab.CleanText = DisplayNumber;
return;
}
// this is used for edit, print uses combinedtabs in the print code. When combined tabs were used for edit,
// part of the supinfo text overwrote tabs on screen.
if (IsSupInfoPart)
{
_MyTab.Text = MyParent.MyTab.Text;
_MyTab.CleanText = MyParent.MyTab.CleanText;
return;
}
string cltext = null;
int stepType = (int)(MyContent.Type % 10000);
string tbformat;
if ((ActiveFormat.MyStepSectionLayoutData.UseRNOParentIdent ?? "") != "" && bool.Parse(ActiveFormat.MyStepSectionLayoutData.UseRNOParentIdent))
tbformat = IsInRNO ? FormatStepData.TabData.RNOIdentPrint == "" ? this.MyParent.FormatStepData.TabData.RNOIdentPrint : FormatStepData.TabData.RNOIdentPrint : FormatStepData.TabData.IdentPrint;
else
tbformat = IsInRNO ? FormatStepData.TabData.RNOIdentPrint : FormatStepData.TabData.IdentPrint;
string tbformate = null; // need this for background documents, to generate tab for editing.
if (IsParagraph && !IsSequential)
{
string tstr = "";
if (tbformat.Contains("{!.+?}"))
tstr = tbformat.Replace("{!.+?}", " "); // Comanche Peak Indented Paragraph
_MyTab.Text = tstr;
_MyTab.CleanText = tstr;
return;
}
if (((ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedBackgrounds) == E_PurchaseOptions.EnhancedBackgrounds) &&
((IsHigh && FormatStepData.PageBreakOnStep) || (IsRNOPart && MyHLS.FormatStepData.PageBreakOnStep)))
tbformate = IsRNOPart ? MyHLS.FormatStepData.TabData.RNOIdentEdit : FormatStepData.TabData.IdentEdit;
if (ActiveFormat.Name.ToUpper() == "WCNCKL" || ActiveFormat.Name.ToUpper() == "WSTCKL")
{
if (!IsNote && !IsCaution) tbformat = FormatStepData.TabData.IdentEdit;
if (ActiveFormat.Name.ToUpper() == "WCNCKL" && FormatStepData.StepLayoutData.AlignWithParentTab) tbformat = tbformat.TrimStart(" ".ToCharArray());
}
if (((ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedBackgrounds) == E_PurchaseOptions.EnhancedBackgrounds) ||
((ActiveFormat.PlantFormat.FormatData.PurchaseOptions.Value & E_PurchaseOptions.EnhancedDeviations) == E_PurchaseOptions.EnhancedDeviations))
{
// LinkedOrdinal & LinkedTab (in code below) are tabs from the source and account for unlinked steps. See C2016-020 and other
// references to these properties.
if (tbformat.Contains("{LNK C/N Num}"))
{
string tb = (LinkedOrdinal==null)? "NA" : LinkedOrdinal.ToString();
tbformat = tbformat.Replace("{LNK C/N Num}", tb);
if ((ActiveParent as ItemInfo).FormatStepData.TabData.IdentEdit.Contains("{Section Prefix}") && LinkedTabHasSectionPrefix) // B2019-126 Check the HLS of the source document (ex. EOP step) to see if it includes the section number prefix in its tab
tbformat = tbformat.Replace("{Section Prefix}",""); // B2018-141 remove duplicate section number
if ((ActiveParent as ItemInfo).LinkedTab != null)
tbformat = tbformat.Replace("{LNK Step Num}", (ActiveParent as ItemInfo).LinkedTab.Trim(" .".ToCharArray())); //(ActiveParent as ItemInfo).Ordinal.ToString());
tbformat = tbformat.TrimStart(" ".ToCharArray());
}
if (tbformat.Contains("{LNK Step Num}"))
tbformat = tbformat.Replace("{LNK Step Num}", LinkedTab==null?"NA":LinkedTab.Trim(" .".ToCharArray()).PadLeft(2));//Ordinal.ToString().PadLeft(2));
if (tbformate != null && tbformate.Contains("{LNK Step Num}"))
tbformate = tbformate.Replace("{LNK Step Num}", LinkedTab == null ? "NA" : LinkedTab.Trim(" .".ToCharArray()).PadLeft(2));//Ordinal.ToString());
}
if (tbformat.Contains("{indent}")) // Robinson Background format CPBCK
tbformat = tbformat.Substring(8); // we just need to remove the "{indent}" and leave the spaces
// Added the "{bullet}" token for McGuire and Catawba's Bulleted High Level Step type.
// Using the bullet set in the IdentB format variable (is a solid bullet for their format)
if (tbformat.Contains("{bullet}"))
{
string bulletChar = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB.Trim();
tbformat = tbformat.Replace("{bullet}", bulletChar);
}
// rno gets parent tab
if (IsRNOPart && FormatStepData.NumberSubs)
{
try
{
// NumberWithLevel flag is used by BGE. It does tabbing in rno column by incrementing of rno and rno substeps
if (FormatStepData.NumberWithLevel)
{
int ord = Ordinal - 1;
string incSub = Ordinal.ToString();
// get previous's tab & increment from it.
if (MyParent != null && MyParent.IsRNOPart)
ord = System.Convert.ToInt32(MyParent.MyTab.CleanText.Substring(MyParent.MyTab.CleanText.LastIndexOf(".") + 1));
incSub = (ord + 1).ToString();
if (MyParent.MyTab.CleanText.Trim().EndsWith(")"))
{
_MyTab.CleanText = MyParent.MyTab.CleanText.Trim() + "." + incSub;
_MyTab.Text = _MyTab.CleanText;
return;
}
if (MyParent.MyTab.CleanText.Contains(ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB))
{
_MyTab.CleanText = MyParent.MyTab.CleanText.Trim() + "." + incSub + " ";
_MyTab.Text = _MyTab.CleanText;
return;
}
string tmprnotab = MyParent.MyTab.CleanText.Substring(0, MyParent.MyTab.CleanText.IndexOf(".") + 1) + incSub;
_MyTab.CleanText = tmprnotab.TrimStart();
_MyTab.Text = tmprnotab.TrimStart();
return;
}
if ((((ItemInfo)ActiveParent).IsHigh && FormatStepData.NumberHighLevel) || ((!((ItemInfo)ActiveParent).IsHigh) && ((tbformat == null || tbformat == "") && (RNOLevel <= ColumnMode))))
{
_MyTab.CleanText = ((ItemInfo)ActiveParent).MyTab.CleanText;
_MyTab.Text = ((ItemInfo)ActiveParent).MyTab.Text;
_MyTab.RNOTabWidthAdjust = ((ItemInfo)ActiveParent).FormatStepData.TabData.RNOAdjustTabSize ?? 0;
if (((ItemInfo)ActiveParent).MyTab.Offset != 0) _MyTab.Offset = ((ItemInfo)ActiveParent).MyTab.Offset;
if (((ItemInfo)ActiveParent).FormatStepData.TabData.RNOExcludeMacros)
_MyTab.Text = Regex.Replace(_MyTab.Text, "{!.+?}", " ");
if (((ItemInfo)ActiveParent).FormatStepData.TabData.RNOIdentPrint.Contains("{asterisk}"))
_MyTab.AsteriskOffset = -10;
return;
}
}
catch (Exception ex)
{
Console.WriteLine("SetTabText IsRNO error {0}", ex.Message);
}
}
if (tbformat == null)
{
_MyTab.Text = "";
_MyTab.CleanText = "";
return;
}
// account for metasection indenting/tabbing in the 'PrintLevel', i.e. if we have metasection, we may be in
// a subsection. Index into the seqtabs array has to account for metasection level.
int localPrintLevel = PrintLevel;
StepSectionData sd = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData;
bool doMeta = false;
if (sd.StepSectionLayoutData.TieTabToLevel && ActiveFormat.PlantFormat.FormatData.SectData.UseMetaSections)
{
if (sd.StepSectionLayoutData.ShowSectionTitles
&& !MyDocStyle.CancelSectTitle
&& !(MyDocStyle.SpecialStepsFoldout && MyDocStyle.UseColSByLevel))
localPrintLevel = PrintLevel + (((ActiveFormat.PlantFormat.FormatData.Express && IsSequential)) ? 0 : CurrentSectionLevel());
if (!ActiveFormat.PlantFormat.FormatData.Express) doMeta = true;
}
if (sd.StepSectionLayoutData.TieTabToLevel && ActiveFormat.PlantFormat.FormatData.SectData.CountSubSectionsForLevel)
if (SectionLevel() > 1)
localPrintLevel += 1;
SeqTabFmtList seqtabs = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.SeqTabFmtList;
// Start with basic cases of alpha/numeric/seq:
// If we have metasections AND...
// If the seqtabs for this given level does not get a section number, use the seqtab rather than
// the ident of the step:
bool useSubStepTabs = false;
if (doMeta && IsHigh
&& !seqtabs[(localPrintLevel < 0 ? 0 : localPrintLevel) % seqtabs.MaxIndex].TabToken.Contains("{numericWpar}")
&& tbformat.Contains("{")) useSubStepTabs = true;
// Check to be sure the parent tab should be included... If this sequential is within a note
// or caution or equipment list, don't use parent tab AND always start the numbering as a numeric
if (doMeta && IsSequential && (InNote() || InCaution() ||
(MyParent.IsEquipmentList && !MyParent.FormatStepData.TabData.IdentPrint.Contains("{seq}"))))
{
// if immediate parent is note, caution or equip, use numeric, otherwise use alpha.
localPrintLevel = 0;
int lv = 0;
ItemInfo ii = MyParent;
while (!ii.IsCaution && !ii.IsNote && !ii.IsEquipmentList)
{
lv++;
ii = ii.MyParent;
}
lv = lv % 2;
tbformat = (lv == 0) ? "{numeric}." : "{alpha}.";
}
bool trimTabStart = false;
bool dontTrimParentTabBeforeAppending = false; // B2019-011 for Barakah Alarm format
if (useSubStepTabs || tbformat.IndexOf("{seq}") > -1)
{
// If the document style has the flag DSS_UnNumLikeRoman, don't do the normal tab, change to alpha
// and adjust level in certain conditions as shown below:
if (!IsHigh && (MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_UnNumLikeRoman) == E_DocStructStyle.DSS_UnNumLikeRoman)
{
string myParentIdent = MyParent.FormatStepData.TabData.IdentPrint;
// If there is a tab string for this step and it includes the HLS/parent tab. The HLS is numbered
// with roman numerals, so don't want to continue using the roman numeral concatenated with substep tabs.
// the parent has to have a roman numeral as its tab.
if (myParentIdent.ToUpper().Contains("ROMAN") &&
tbformat != null && tbformat != "" && tbformat.ToUpper().Contains("SEQ"))
localPrintLevel += 5; // tbformat = "{alpha}. ";
// If the parent has no tab, adjust the level by 5 (this is taken directly from 16bit logic & is needed by FNP AOPs, U1 AOP14.0 for example)
else if (tbformat != null && tbformat != "" && myParentIdent == "")
localPrintLevel += 5;
}
int itmp = (localPrintLevel + PrintBias + OffsetTab) % seqtabs.MaxIndex;
// F2018-025 Westinghouse when a high level step is used as a section number/title,
// adjust the step/substep numbering where the first level substep uses the high level step tabbing format
// and the following sub-substeps tabbing format are "shifted" accordingly (ex should look like ASS-101 Attachment 1 section 4 tabbing)
if (!IsHigh && MyHLS != null && MyHLS.FormatStepData.AppendDotZero)
{
if (localPrintLevel > 1)
{
localPrintLevel--;
itmp = (localPrintLevel + PrintBias + OffsetTab) % seqtabs.MaxIndex;
}
}
if (!tbformat.Contains(@"{!C"))
tbformat = seqtabs[itmp].PrintTabFormat; // seqtab in 16bit, i.e. '. or )' etc.
else
tbformat = tbformat.Replace("{seq}", seqtabs[itmp].PrintTabFormat);
dontTrimParentTabBeforeAppending = seqtabs[itmp].DontTrimParentTabBeforeAppending; // B2019-011 put in for Barakah Alarm format to better align the first level sub step with the high level step
string tbtoken = seqtabs[localPrintLevel % seqtabs.MaxIndex].TabToken; // seqstart in 16bit, number/letter
// if the tab has a character before the token, trim the front of tab:
int br = tbformat.IndexOf("{");
if (br > 0)
{
char isAChar = tbformat[br - 1];
if ("{} #".IndexOf(isAChar) < 0) trimTabStart = true;
}
tbformat = tbformat.Replace("{seq}", tbtoken);
}
else
// reset the print level if it's not a sequential type. The code was setting printlevel
// to a -1 for equipment lists, and if the step type was changed to a sequential, it kept the
// -1 (the printlevel property calculates the value only if the current value == 0,
// so that when the above code ran to reset the tab, it would crash because the
// printlevel was not recalculated.
PrintLevel = 0;
// If token includes 'Wpar', the parent tab prefix's the tab.
if (localPrintLevel > 0 && (tbformat.IndexOf("{numericWpar}") > -1 || tbformat.IndexOf("{alphaWpar}") > -1 || tbformat.IndexOf("{ALPHAWpar}") > -1))
{
string parentTab = null;
ItemInfo myparent = ActiveParent as ItemInfo;
if (myparent != null && myparent.IsParagraph)
{
myparent = myparent.ActiveParent as ItemInfo;
if (myparent.MyTab.CleanText.Trim() == "")
{
if ((myparent.ActiveParent as ItemInfo).MyTab.CleanText.Trim() != "")
myparent = myparent.ActiveParent as ItemInfo;
}
}
else if (myparent.IsSection || myparent.IsHigh || myparent.IsSequential || (myparent.IsRNOPart && myparent.FormatStepData.NumberHighLevel && tbformat.ToUpper().Contains("WPAR")))
{
parentTab = (dontTrimParentTabBeforeAppending) ? myparent.MyTab.CleanText : myparent.MyTab.CleanText.Trim(); // B2019-011 for Barakah Alarm format adde the don't trim flag
if ((((MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_AddDotZeroStdHLS) == E_DocStructStyle.DSS_AddDotZeroStdHLS) && myparent.MyContent.Type == 20002) ||
(myparent.IsStepPart && myparent.FormatStepData.AppendDotZero)) // F2018-022 Added step type flag to append a ".0" to the end of the high level step - put in for Westinghouse single column format (wst1), B2018-119 only do this for steps
parentTab = parentTab.Replace(".0", ""); // this was added in, remove for substeps.
tbformat = parentTab + (parentTab.EndsWith(".") ? "" : parentTab == "" ? "" : ".") + tbformat.TrimStart();
}
else if (IsSequential && ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.SkipNonSeqTabWithPar)
{
// this was added for Wolf Creek WCN1: if this has a 'wpar' flag, then walk up until finding
// a sequential or high and use that tab (ignore non-sequential steps when walking up parents).
// Note that the format flag 'SkipNonSeqTabWithPar' was added to prevent this code being run for Westinghouse and Farley.
// the following prevents the concatenation of parent tabs onto this once the indenting is
// past the number of seqtabs.
if (localPrintLevel < seqtabs.MaxIndex || (PrintLevel < seqtabs.MaxIndex && seqtabs[PrintLevel].TabToken.ToUpper().Contains("WPAR")))
{
ItemInfo mpar = myparent;
while (mpar != null && !mpar.IsSection && !mpar.IsHigh && !mpar.IsSequential) mpar = (mpar.MyParent as ItemInfo);
if (mpar != null && !mpar.IsSection)
{
parentTab = mpar.MyTab.CleanText.Trim();
tbformat = parentTab + (parentTab.EndsWith(".") ? "" : ".") + tbformat.TrimStart();
//if (_MyLog.IsInfoEnabled) _MyLog.InfoFormat("==>PARTAB: [{0}]", ShortPath + ", " + ItemID.ToString());
}
}
}
}
if (tbformat.IndexOf("#2#") > -1 || tbformat.IndexOf("#1#") > -1)
{
//16 bit code limits the #2# offset logic to the docstyle cannot have the DSS_ADDDOTZEROSTDHLS &
// its HLS is type std high:
if (!((((MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_AddDotZeroStdHLS) == E_DocStructStyle.DSS_AddDotZeroStdHLS) && this.MyHLS.MyContent.Type == 20002) ||
this.FormatStepData.AppendDotZero)) // F2018-022 Added step type flag to append a ".0" to the end of the high level step - put in for Westinghouse single column format (wst1)
{
int indxlb = tbformat.IndexOf("#");
string ofst = tbformat.Substring(indxlb + 1, 3);
_MyTab.Offset = Convert.ToInt32(ofst.Substring(0, 1)) * (int)FormatStepData.TabData.Font.CharsToTwips;
}
tbformat = tbformat.Replace("#2#", "").Replace("#1#", "");
}
if (tbformat.IndexOf("{Pos") > -1)
{
int begPos = tbformat.IndexOf("{Pos");
int endPos = tbformat.IndexOf("}");
string ofst = tbformat.Substring(begPos + 4, endPos - begPos - 4);
_MyTab.Position = -(Convert.ToInt32(ofst) * (int)FormatStepData.TabData.Font.CPI);
tbformat = tbformat.Remove(begPos, endPos + 1);
}
// if this is a caution/note type determine where 'NOTE/CAUTION' tab goes, as tab or as 'header'
// and also determine whether the tab itself gets converted to a bullet.
if (IsCaution || IsNote) tbformat = CheckNoteCautionTab(tbformat);
// if there is a section prefix, trim any spaces from the start of this tab, so we don't have
// a tab that looks like "1. 1"
if (!IsSection && !IsProcedure && tbformat.IndexOf("{Section Prefix}") >= 0)
{
string tmpsectpref = SectionPrefix(tbformat) ?? string.Empty;
if (ActiveSection.MyTab!=null && ActiveSection.MyTab.CleanText != null && ActiveSection.MyTab.CleanText != "" && tmpsectpref != string.Empty) trimTabStart = true;
tbformat = tbformat.Replace("{Section Prefix}", SectionPrefix(tbformat));
if (tbformate != null) tbformate = tbformate.Replace("{Section Prefix}", SectionPrefix(tbformate));
}
bool isAlpha = tbformat.ToUpper().Contains("ALPHA");
int ordinal = Ordinal;
bool useLinked = false; // if this is enhanced, and the LinkedTab isn't numeric, flag to use 'LinkedTab' for the tab.
if (ActiveSection != null && ActiveSection.IsEnhancedSection) // C2018-003 fixed use of getting the active section
{
if (IsEnhancedStep)
try
{
ordinal = int.Parse("0" + LinkedTab ?? "0");
}
catch (Exception ex)
{
// use LinkedTab and don't do the AlphabeticalNumbering below. LinkedTab had alpha chars
useLinked = true;
}
// commented out the following two lines to fix bug B2017-031, where sequental substeps where printing with an '@' instead of a number or letter in linked enhanced backgrounds
//else
// ordinal = 0;
}
// B2018-101: The section number was duplicated in the WCNOC step tab. This was fixed for edit, B2017-153, but not for print (see below). The code
// used for that bug fix was duplicated here (with slight modification because the tab did not have the "WCNOC" string, thus using the active
// formats, and also use tbformat rather than tbformate.
// F2018-037: An additional WCN background format was added for SAMG, so the code was made more general, i.e. to make tab
// change, check for formats that start with WCN and contain BCK:
if (useLinked)
{
if (ActiveFormat.Name.ToUpper().StartsWith("WCN") && ActiveFormat.Name.ToUpper().Contains("BCK") && tbformat.Contains(LinkedTab[0].ToString() + "{numeric}"))
tbformat = tbformat.Replace(LinkedTab[0].ToString() + "{numeric}", "{numeric}");
else if ((ActiveFormat.Name.ToUpper().StartsWith("WCN") && ActiveFormat.Name.ToUpper().Contains("BCK")) && tbformat.Contains(LinkedTab[0].ToString() + ".{numeric}"))
tbformat = tbformat.Replace(LinkedTab[0].ToString() + ".{numeric}", "{numeric}");
tbformat = tbformat.Replace("{numeric}", LinkedTab.Trim(" .".ToCharArray()).PadLeft(2));
}
string alpha = useLinked?LinkedTab.Trim():AlphabeticalNumbering(ordinal);
// B2017-211 Roman High Level steps should be followed by Uppercase alpha substeps - This is being limited to Calvert SAMG Format
if (_ActiveFormat.Name =="BGESAM1" &&MyParent != null && MyParent.IsHigh && MyParent.IsStep && MyParent.FormatStepData.TabData.IdentEdit.Contains("ROMAN"))
tbformat = tbformat.Replace("{alpha}", alpha);
else
tbformat = tbformat.Replace("{alpha}", alpha.ToLower());
tbformat = tbformat.Replace("{alphaWpar}", alpha.ToLower());
if (ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvert && tbformat.Contains("{ALPHA}") && alpha.Length > 1)
tbformat = tbformat.Replace("{ALPHA}. ", alpha + "."); // if double chars, remove one of the space for BGE
else
tbformat = tbformat.Replace("{ALPHA}", alpha);
tbformat = tbformat.Replace("{ALPHAWpar}", alpha);
if (tbformat.ToUpper().Contains("ROMAN"))
{
string roman = RomanNumbering(ordinal);
tbformat = tbformat.Replace("{roman}", roman.ToLower());
tbformat = tbformat.Replace("{ROMAN}", roman);
tbformat = tbformat.Substring(0, tbformat.Length - ((roman.Length - 1) > 0 ? (roman.Length - 1) : 0));
}
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.VirtualDotInHLSTab && tbformat.Contains("numeric") & ordinal > 9) _MyTab.AdjustTabSpace = true;
if (tbformat.Contains("{numeric}") && ((MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_AddDotZeroStdHLS) == E_DocStructStyle.DSS_AddDotZeroStdHLS) && MyContent.Type == 20002)
{
tbformat = tbformat.Replace("{numeric}", ordinal.ToString().PadLeft(2) + ".0");
tbformat = tbformat.Substring(0, tbformat.Length - 2);
}
if (tbformat.Contains("{numeric}") && (this.FormatStepData.AppendDotZero)) // F2018-022 Added step type flag to append a ".0" to the end of the high level step - put in for Westinghouse single column format (wst1)
{
string numtxt = ordinal.ToString().PadLeft(2) + ".0";
tbformat = tbformat.Replace("{numeric}.", numtxt).Replace("{numeric}", numtxt);
}
// if this is a wolf creek background, if the tbformat ends with a '.' don't add a space,
// otherwise add a space.
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.WolfCreekBackgroundFormat && IsBackgroundStep())
{
string stpTab = null;
if (useLinked)
stpTab = (!tbformat.Contains(".") ? " " : "") + ((ordinal == 0) ? "NA" : LinkedTab);
else
stpTab = (!tbformat.Contains(".") ? " " : "") + ((ordinal == 0) ? "NA" : ordinal.ToString());
tbformat = tbformat.Replace("{numeric}", stpTab);
}
else
tbformat = tbformat.Replace("{numeric}", trimTabStart ? ordinal.ToString() : FormatStepData.AtLeastTwoDigits ? ordinal.ToString().PadLeft(2, '0') : ordinal.ToString().PadLeft(2));
if (tbformate != null)
{
if (useLinked)
{
// B2017-153 - WCN Emergency Backgrounds Fix Tabs for Background Document Steps within subsections
// Prior to this fix Lettered attachment steps were repeating the section letter "EE1"
// and numbered sections were repeating the section number "3.3.1"
if (tbformate.StartsWith("WCNOC") && tbformate.Contains( LinkedTab[0].ToString() + "{numeric}"))
tbformate = tbformate.Replace(LinkedTab[0].ToString() + "{numeric}","{numeric}");
else if (tbformate.StartsWith("WCNOC") && tbformate.Contains(LinkedTab[0].ToString() + ".{numeric}"))
tbformate = tbformate.Replace(LinkedTab[0].ToString() + ".{numeric}", "{numeric}");
tbformate = tbformate.Replace("{numeric}", LinkedTab.Trim(" .".ToCharArray()).PadLeft(2));
}
if (tbformat.Contains("NA") && ordinal == 0)
tbformate = tbformate.Replace("{numeric}", "NA");
else
tbformate = tbformate.Replace("{numeric}", trimTabStart ? ordinal.ToString() : FormatStepData.AtLeastTwoDigits ? ordinal.ToString().PadLeft(2, '0') : ordinal.ToString().PadLeft(2));
}
tbformat = tbformat.Replace("{numericWpar}", ordinal.ToString());
if (tbformat.Contains("{asterisk}"))
{
// if this has a checkoff - need to set location of the asterisk - because the asterisk has to come before
// the checkoff. Otherwise, it doesn't matter
_MyTab.AsteriskOffset = -10;
tbformat = tbformat.Replace("{asterisk}", ""); // the asteriskoffset flags a '*' to be printed at xloc - this.
}
int macroindx = tbformat.IndexOf("{!C");
if (macroindx > -1)
{
// C2017-026: have visual indicator for CAS Step
if (FormatStepData.TabData.IdentEdit.Contains("*. "))
{
cltext = cltext == null ? tbformat.Substring(0, macroindx) + "*. " + tbformat.Substring(macroindx + 8) : cltext.Remove(macroindx, 5);
}
else
{
cltext = cltext == null ? tbformat.Remove(macroindx, 5) : cltext.Remove(macroindx, 5);
cltext = cltext + " ";
}
}
macroindx = tbformat.IndexOf("{!diamond1}");
if (macroindx > -1) //i found it
{
cltext = cltext == null ? tbformat.Remove(macroindx, 11) : cltext.Remove(macroindx, 11);
cltext = cltext + " ";
}
macroindx = tbformat.IndexOf("{!diamond}");
if (macroindx > -1) //i found it
{
cltext = cltext == null ? tbformat.Remove(macroindx, 10) : cltext.Remove(macroindx, 10);
cltext = cltext + " ";
}
// "{Null}" was introduced so that inheritance in format files could differentiate between an
// empty string, and null. And also, so that if a tab was null but it's parent had text in the
// tab, don't inherit the parent's tab, use a null.
if (MyPrevious != null && FormatStepData.Sep != null && FormatStepData.Sep != "{Null}")
{
// check if there is font information for the separator, use it. If not use the font information
// that is associated with the tab.
VE_Font hdrFont = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.Separator == null ? null :
ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.Separator.Font;
if (hdrFont == null) hdrFont = FormatStepData.TabData.Font;
if (_MyHeader == null) _MyHeader = new MetaTag(hdrFont);
else _MyHeader.MyFont = hdrFont;
_MyHeader.Text = FormatStepData.Sep;
_MyHeader.CleanText = StripRtfFormatting(_MyHeader.Text);
// per 16-bit format speadsheet, Location can have the following values:
// 0 - Left
// 1 - Right
// 2 or greater - Center
int sepLoc = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.Separator.Location ?? 2; //default to Center
switch (sepLoc)
{
case 0:
_MyHeader.Justify = ContentAlignment.MiddleLeft;
break;
case 1:
_MyHeader.Justify = ContentAlignment.MiddleRight;
break;
default:
_MyHeader.Justify = ContentAlignment.MiddleCenter;
break;
}
//_MyHeader.Justify = ContentAlignment.MiddleCenter;
}
#region Non Converted Plants tab TODO
// Position offset
//"{indent}");
//"{par}");
//Macros
// <!diamond> - draws a diamond around the stepnumber
// <!diamond1> - A macro
// <!asterisk>
// <> - ignored
// \241 - circle macro around step, same as <!circle>
// Also note, the format files had "<>", these get converted during input in this
// format converter code.
//wkstr = wkstr.Replace("{!asterisk}", "\\fs10 \\b*\\b0"); // was font size 20 in 16-bit
//wkstr = Regex.Replace(wkstr, @"{![.*?]}", @"{!$1}");
//wkstr = wkstr.Replace("{}", "");
//if (vefont != null && vefont.HasCircleString2()) wkstr.Insert(0,"{!C0}");
//wkstr = wkstr.Replace("j", @"{Box Step}");
#endregion
// if this has an alternate tab, use it. These have been used in background documents.
if (!IsSection && FormatStepData.TabData.IdentAltPrint != null && FormatStepData.TabData.IdentAltPrint != "")
{
string newtab = null;
int indxnewtab = FormatStepData.TabData.IdentAltPrint.LastIndexOf('\\');
if (indxnewtab >= 0)
{
_MyTab.BasicTab = isAlpha ? alpha : ordinal.ToString();
newtab = FormatStepData.TabData.IdentAltPrint.Substring(indxnewtab + 1);
if (newtab.Contains("{numeric}") || newtab.Contains("{LNK Step Num}"))
{
newtab = tbformat;
newtab = @"\ul " + newtab.Substring(0, newtab.IndexOf(":") + 1) + @"\ulnone " + newtab.Substring(newtab.IndexOf(":") + 1);
}
// also see if there is the 'pagelist' string in this tab:
// C2018-003 fixed use of getting the active section
else if ((FormatStepData.TabData.Font.Style & E_Style.Underline) == E_Style.Underline &&
ActiveSection != null && ((ActiveSection.MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_PageListSpBckgrnd) != E_DocStructStyle.DSS_PageListSpBckgrnd))
// the reason that the underline commands were not included in format file is that the '\' character
// is used as a separator and the following code will not impact other formats
HighLevelStepTabPageList = @"\ul " + FormatStepData.TabData.IdentAltPrint.Substring(0, indxnewtab).Trim() + @"\ulnone " + (tbformat.StartsWith(" ") ? "" : " ") + tbformat;
else
HighLevelStepTabPageList = FormatStepData.TabData.IdentAltPrint.Substring(0, indxnewtab) + tbformat;
_MyTab.AltPrintTab = newtab;
if (tbformate != null && tbformate != "") tbformat = tbformate;
}
}
_MyTab.Text = tbformat;
_MyTab.CleanText = cltext != null ? cltext : tbformat;
}
private int SectionLevel()
{
int level = 0;
ItemInfo ii = this;
while (!ii.IsProcedure)
{
// fix for Westinghouse single column
// - increament the level on a section only if the first character is a number B2016-075 03-09-2016
// Note that 'DisplayNumber' is used rather than MyTab. MyTab was not always set.
//if (ii.IsSection && (ii.MyTab.Text != null && ii.MyTab.Text.Length > 0 && char.IsNumber(ii.MyTab.Text.Trim()[0]))) level++;
if (ii.IsSection && (ii.DisplayNumber != null && ii.DisplayNumber.Length > 0 && char.IsNumber(ii.DisplayNumber.Trim()[0]))) level++;
ii = ii.ActiveParent as ItemInfo;
}
return level;
}
private bool InCaution()
{
// walk up until procedure level and if finding a caution type, return true, otherwise false.
ItemInfo ii = this.MyParent;
while (ii != null && !ii.IsProcedure)
{
if (ii.IsCaution) return true;
ii = ii.MyParent;
}
return false;
}
public bool IsBackgroundStep()
{
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.WolfCreekBackgroundFormat)
{
if (IsHigh || IsCaution || IsNote) return true;
if (MyParent != null && MyParent.IsStep && MyParent.FormatStepData.Type.ToUpper() == "TITLEWITHTEXTBELOW" && FormatStepData.Type.ToUpper() != "IMPLICITOR") return true;
}
return false;
}
// B2018-146 Find any steep that is part of a background step.
public bool IsBackgroundStepOrChild()
{
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.WolfCreekBackgroundFormat)
{
ItemInfo tmp = this;
while (tmp != null && tmp.IsStep)
{
if (tmp.IsHigh || tmp.IsCaution || tmp.IsNote) return true;
if (tmp.MyParent != null && tmp.MyParent.IsStep && tmp.MyParent.FormatStepData.Type.ToUpper() == "TITLEWITHTEXTBELOW" && tmp.FormatStepData.Type.ToUpper() != "IMPLICITOR") return true;
tmp = tmp.ActiveParent as ItemInfo;
}
}
return false;
}
// Function to find if in part of a Background Step
public bool IsPartOfBackgroundStep()
{
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.WolfCreekBackgroundFormat)
{
ItemInfo itm = this;
while (itm.MyPrevious != null)
{
if (itm.MyPrevious.IsBackgroundStep()) return true;
if (itm.MyPrevious != null && itm.MyPrevious.IsStep && itm.MyPrevious.FormatStepData.Type.ToUpper() == "TITLEWITHTEXTBELOW" && FormatStepData.Type.ToUpper() != "IMPLICITOR") return true;
itm = itm.MyPrevious;
}
return false;
}
return false;
}
private bool InNote()
{
// walk up until procedure level and if finding a note type, return true, otherwise false.
ItemInfo ii = this.MyParent;
while (ii != null && !ii.IsProcedure)
{
if (ii.IsNote) return true;
ii = ii.MyParent;
}
return false;
}
private string GetToken(string tbformat)
{
int stindx = tbformat.IndexOf("{");
return (tbformat.Substring(stindx, tbformat.IndexOf("}") - stindx + 1));
}
public int GetStepLevel() // ref int bias)
{
int profileDepth = ProfileTimer.Push(">>>> GetStepLevel");
int level = 0;
ItemInfo par = this;
ItemInfo LastRNO = null;
ItemInfo TopRNO = null;
while (par != null && !par.IsSection && !par.IsProcedure && !par.IsHigh)
{
if (par.IsRNOPart)
{
LastRNO = par.MyParent;
TopRNO = par;
}
if (!par.IsRNOPart && (par.IsSequential || (!(par.IsCaution || par.IsNote)
&& ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.CountAllSubLevels)))
level++;
par = par.MyParent;
}
// If high level RNOs are numbered, use the next level of tabs for lower
// level RNOs - unless DontOffsetTab format flag is set
if (LastRNO != null && LastRNO.IsHigh && TopRNO.FormatStepData.NumberHighLevel && TopRNO.FormatStepData.OffsetTab)
OffsetTab = TopRNO.FormatStepData.NumberHighLevel ? 1 : 0;
_PrintBias = 0;
if (par.FormatStepData != null && par.FormatStepData.TabData.IdentPrint.Contains("{ALPHA}"))
level--;
// ImperfectStructure is used so that the sequential numbering for substeps under an RNO is not same
// numbering (alpha vs numeric), if the HLS has substeps - WCN uses this, as well as other plants.
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructure && IsSequential
&& (LastRNO != null) && LastRNO.IsHigh && LastRNO.HasChildren
&& LastRNO.FirstChild(E_FromType.Step) != null && LastRNO.FirstChild(E_FromType.Step).IsSequential)
{
level++; // 16bit has this: I didn't and mine worked most of time.
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructurePlus4) level += 2;
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectSubstep && !ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructurePlus4)
PrintBias = -1;
}
// ImperfectStructure for substeps - only good for level 1 RNOs
else if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectSubstep && RNOLevel == 1)
{
par = this;
while (!par.IsRNOPart) par = par.MyParent; // get to the rno.
if (par.MyParent.HasChildren) // if parent has children?
{
ItemInfo tchild = par.MyParent.FirstChild(E_FromType.Step);
if (tchild != null)
{
int typ = (int)tchild.MyContent.Type - 20000;
if (ActiveFormat.PlantFormat.FormatData.StepDataList[typ].TabData.IdentPrint.Contains("{seq}"))
{
level++;
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructurePlus4) level += 1;
if (!ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructurePlus4) PrintBias = -1;
}
}
}
}
if (MyDocStyle != null && (MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_SkipOneStepLevel) == E_DocStructStyle.DSS_SkipOneStepLevel)
level++;
if (MyDocStyle != null && (MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_SkipTwoStepLevels) == E_DocStructStyle.DSS_SkipTwoStepLevels && level == 0)
level += 2;
if (level < 0) level = 0;
ProfileTimer.Pop(profileDepth);
return level;
}
public int CurrentSectionLevel()
{
int countlev = 0;
if (ActiveSection != null && (ActiveSection.MyDocStyle.StructureStyle.Style ?? 0 & E_DocStructStyle.DSS_TreatAsTrueSectNum) != 0) // C2018-003 fixed use of getting the active section
{
ItemInfo ii = ActiveSection.MyParent;
while (!ii.IsProcedure)
{
if (ii.DisplayNumber != null && ii.DisplayNumber != "")
{
SectionInfo si = SectionInfo.Get(ii.ItemID);
if (si != null)
{
SectionConfig sc = new SectionConfig(si);
//SectionConfig sc = ii.MyConfig as SectionConfig;
if (sc != null && sc.SubSection_AutoIndent == "Y")
countlev++;
}
}
ii = ii.MyParent;
}
}
return countlev;
}
private string SectionPrefix(string tbformat)
{
// if not metasection/tietabtolevel, return the 'section number'. (where the '.' may or may not exist)
if (!ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.TieTabToLevel)
{
// If the Section's 'tab' is a character or has a character preceding the '.' is an alpha character,
// just return the alpha (no '.')
// If the character preceding the '. 'is a number, return the section tab up to and including the '.'
// Otherwise, just return the section tab.
// Before checking for anything, if the DisplayNumber starts with 'ATTACHMENT ', don't use that in the Section
// prefix for the tabstring.
string attNum = ActiveSection.DisplayNumber.ToUpper().StartsWith("ATTACHMENT ") ? ActiveSection.DisplayNumber.Substring(11) : ActiveSection.DisplayNumber;
Match m = Regex.Match(attNum, @"[a-zA-Z]"); // for alpha, use non-touched displaynumber
int indx = -1;
if (m.Success)
{
indx = attNum.IndexOf(".");
if (indx < 0) return attNum;
return attNum.Substring(0, indx);
}
indx = ActiveSection.MyTab.CleanText.IndexOf(".");
if (indx > 0) return ActiveSection.MyTab.CleanText.Substring(0, indx + 1); // include the '.'
return ActiveSection.MyTab.CleanText.TrimEnd();
}
// the rest of this is for metasections (tietabtolevel format flag)
SectionInfo si = SectionInfo.Get(ActiveSection.ItemID);
// A 'TrueSectionNum' must have a '.' and cannot have lettters after the '.'.
if (si != null && si.TrueSectionNum())
{
string attNum = ActiveSection.DisplayNumber; // ActiveSection.DisplayNumber.ToUpper().StartsWith("ATTACHMENT ") ? ActiveSection.DisplayNumber.Substring(11) : ActiveSection.DisplayNumber;
// If section number is of form '1.0', return '1.'
if (attNum.Length > 1 && attNum[attNum.Length - 1] == '0' && attNum[attNum.Length - 2] == '.')
return attNum.Substring(0, attNum.Length - 1);
// If section number is of form '1', return '1.'
else if (attNum.Length > 0 && attNum[attNum.Length - 1] != '.')
return attNum + '.';
}
// For the docstyle flag DSS_TreatAsTrueSectNum, look for last space, and if one is
// found, the the Section Prefix is the text after the space with a '.' appended - for
// example, 'Attachment A' becomes 'A.'.
if ((MyDocStyle.StructureStyle.Style ?? 0 & E_DocStructStyle.DSS_TreatAsTrueSectNum) != 0)
{
int lindx = ActiveSection.DisplayNumber.LastIndexOf(" ");
if (lindx > 0)
{
return ActiveSection.DisplayNumber.Substring(lindx + 1) + ".";
}
}
// If we're in a subsection, be sure there is a '.' at the end. The following uses config flags for indenting to determine CurrentSectionLevel:
int subsection = CurrentSectionLevel();
if (subsection >= 1)
{
string tmptab = ActiveSection.MyTab.CleanText.TrimEnd();
if (tmptab.LastIndexOf(".") != tmptab.Length - 1) tmptab = tmptab + ".";
return tmptab;
}
// If the tbformat is "{Section Prefix}{numeric}" and section prefix ends in an integer, add a '.'
if (tbformat.Contains("{Section Prefix}{numeric}") && MyParent.IsSection)
{
string tmptab = ActiveSection.MyTab.CleanText.TrimEnd();
if (tmptab.Length > 0)
{
string l = tmptab.Substring(tmptab.Length - 1);
if (char.IsLetterOrDigit(l[0]))
{
if (tmptab.LastIndexOf(".") != tmptab.Length - 1) tmptab = tmptab + ".";
return tmptab;
}
}
}
return ActiveSection.MyTab.CleanText.TrimEnd();
}
private string CheckNoteCautionTab(string tbformat)
{
tbformat = ReplaceStepToken(tbformat);
string prevTbFormat = null;
string nextTbFormat = null;
StepData nextStepData = null;
if (MyPrevious != null)
{
// int prevStepType = ((int)MyPrevious.MyContent.Type) % 10000;
StepData prevStepData = MyPrevious.FormatStepData; // ActiveFormat.PlantFormat.FormatData.StepDataList[prevStepType];
prevTbFormat = MyPrevious.IsInRNO ? prevStepData.TabData.RNOIdentPrint : prevStepData.TabData.IdentPrint;
prevTbFormat = ReplaceStepToken(prevTbFormat);
}
// for calvert alarms, need to check if next item is a different type, if a different type.
// If it is the same type, clear the header so that the header text isn't printed two times.
bool specialCalvertAlarm = false;
ItemInfo nextItem = NextItem;
if (ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm)
{
if (nextItem != null && MyContent.Type != nextItem.MyContent.Type) specialCalvertAlarm = true;
}
if (nextItem != null && !specialCalvertAlarm)
{
nextStepData = nextItem.FormatStepData;
// tried to duplicate functionality from 16-bit code.
nextTbFormat = nextItem.IsInRNO ? nextStepData.TabData.RNOIdentPrint : nextStepData.TabData.IdentPrint;
nextTbFormat = ReplaceStepToken(nextTbFormat);
}
// Handle the centered tab - if this tab is centered make it a header.
if (FormatStepData.TabData.Justify == "Center")
{
_MyHeader.Justify = ContentAlignment.MiddleCenter;
_MyHeader.Text = (!FormatStepData.TabData.NoTrim) ? tbformat.Replace("\\xA0", " ").Trim() : tbformat.Replace("\\xA0", " ");
_MyHeader.CleanText = StripRtfFormatting(_MyHeader.Text);
// if there is only step in the group or we have a change in step type (caution/note) when there is
// use of the MixCautionsAndNotes format flag - no bullet is used, if more that one replace the tab
// with a bullet. Also, if only one in group and tab text ends with 'S', remove it:
bool mixCandN = MixCautionNotesDiffType();
if (((MyPrevious == null || !this.IsSameType(MyPrevious)) && ((nextItem == null || !this.IsSameType(nextItem)) || specialCalvertAlarm)) || mixCandN || FormatStepData.SeparateBox)
{
if (_MyHeader.CleanText.ToUpper().EndsWith("S"))
{
string origTxt = _MyHeader.CleanText;
_MyHeader.CleanText = _MyHeader.CleanText.Substring(0, _MyHeader.CleanText.Length - 1);
// Text may have rtf commands:
_MyHeader.Text = _MyHeader.Text.Replace(origTxt, _MyHeader.CleanText);
}
tbformat = "";
}
else
{
if (MyPrevious != null)
{
if (tbformat == prevTbFormat)
{
if (MyPrevious.FormatStepData.TabData.IsTransition)
{
if (tbformat != nextTbFormat)
{
tbformat = "";
_MyHeader = null;
return tbformat;
}
}
else
_MyHeader = null;
}
else if (nextItem == null)
tbformat = "";
}
if (!this.FormatStepData.SeparateBox)
{
// For calvert formats, if all tabs are null or empty, then don't add a bullet in.
bool allnull = ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvert && (tbformat == null || tbformat == "") && (nextTbFormat == null || tbformat == "") && (prevTbFormat == null || prevTbFormat == "");
if (!allnull && (tbformat == nextTbFormat || tbformat == prevTbFormat))
{
tbformat = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB;
TabToIdentBAdjustFont();
}
else if ((nextTbFormat == null || tbformat != nextTbFormat) && (prevTbFormat == null || tbformat != prevTbFormat))
{
tbformat = "";
}
}
}
// For VC Summer Unit 2 & 3 (vcb formats) include step number in Note & Caution header
if (FormatStepData.TabData.IncludeStepNum && _MyHeader != null && MyParent != null) // B2016-252 changed MyHeader to _Myheader to fix stack overflow during enhanced document editing
{
if (MyParent.CombinedTab != null)
{
// if my parent is a paragraph, then don't use the paragraph tab in the header, use the parent of the paragraph:
if (MyParent.IsParagraph)
{
MyHeader.Text = MyHeader.Text + ((MyParent == null) ? "" : " Step " + MyParent.MyParent.MyTab.CleanText.TrimEnd(".".ToCharArray()));
MyHeader.CleanText = MyHeader.CleanText + ((MyParent == null) ? "" : " Step " + MyParent.MyParent.MyTab.CleanText.TrimEnd(".".ToCharArray()));
}
else
{
MyHeader.Text = MyHeader.Text + ((MyParent == null) ? "" : " Step " + MyParent.MyTab.CleanText.TrimEnd(".".ToCharArray()));
MyHeader.CleanText = MyHeader.CleanText + ((MyParent == null) ? "" : " Step " + MyParent.MyTab.CleanText.TrimEnd(".".ToCharArray()));
}
}
else if (MyParent.IsStepSection && FormatStepData.TabData.IncludeSectionNum)
{
ItemInfo parent = MyParent;
if (parent.IsStepSection)
{
string parentTab = parent.MyTab.CleanText.TrimEnd(".".ToCharArray());
if (parentTab != "")
{ // F2016-058 Trim space after section number
MyHeader.Text = MyHeader.Text + ((MyParent == null) ? "" : " Section " + parentTab.TrimEnd(" ".ToCharArray()));
MyHeader.CleanText = MyHeader.CleanText + ((MyParent == null) ? "" : " Section " + parentTab.TrimEnd(" ".ToCharArray()));
}
}
}
}
return tbformat;
}
// If this has a previous, and the tabs of this & previous match
if (tbformat != null && MyPrevious != null && !FormatStepData.AlwaysTab && (!FormatStepData.MixCautionsAndNotes || (tbformat == prevTbFormat)))
{
// used in Ginna's Attachment format
// only create bullets for multiple cautions and notes if they are all exactly the same type
if (!ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.OnlyBulletSameCautionNoteType ||
(MyPrevious != null && MyPrevious.MyContent.Type == MyContent.Type) ||
(NextItem != null && nextItem.MyContent.Type == MyContent.Type))
{
tbformat = tbformat + ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB;
TabToIdentBAdjustFont();
}
}
else if (FormatStepData.TabData.IsTransition)
return tbformat;
// else if this has a next
else if (tbformat != null && nextItem != null && !FormatStepData.AlwaysTab &&
(!FormatStepData.MixCautionsAndNotes ||
(FormatStepData.TabData.UsePreviousStyle && !nextStepData.TabData.UsePreviousStyle && tbformat == nextTbFormat) ||
((prevTbFormat != tbformat && (nextItem.MyContent.Type == (int)(MyContent.Type % 10000))))))
{
tbformat = tbformat + ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB;
//string bstr = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB;
//int bstrlen = bstr.Length;
//string tstr = tbformat.Substring(tbformat.Length - bstrlen);
//bool good = true;
//for (int i = 0; i < tstr.Length; i++)
// good = (tstr[i] == ' ');
//if (good)
// tbformat = tbformat.Substring(0, tbformat.Length - bstrlen) + bstr;
//else
// tbformat = tbformat + ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB;
if (TabToIdentBAdjustFont())
_MyTab.RemovedStyleUnderline = true;
}
//// Since we append the bullet (IdentB) to the Caution or Note tab (like in 16-bit code)
//// we need to append blank characters when there is only one Note or Caution (thus no bullet)
//// in order for the Note or Caution tab to consistantly print at the same horizontal location
//else if (tbformat != null && !FormatStepData.AlwaysTab && !FormatStepData.MixCautionsAndNotes
// && (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB != null
// && ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB.Length > 0))
//{
// int identBLen = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB.Length;
// string bbstr = new string(' ', identBLen);
// tbformat = tbformat + bbstr;
// if (TabToIdentBAdjustFont())
// _MyTab.RemovedStyleUnderline = true;
//}
return tbformat;
}
public bool MixCautionNotesDiffType()
{
// for calvert alarms, if there is a note and a warning, these are both 'IsNote', but they
// have different tabs, so we want the mix to be true so that the tab code handles the
// tabbing correctly.
if (ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvertAlarm || ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvert)
{
if (MyPrevious != null && MyContent.Type != MyPrevious.MyContent.Type) return false;
if (NextItem != null && MyContent.Type != NextItem.MyContent.Type) return false;
}
// used in Ginna's Attachment format
// treat cautions and notes as different if they are all NOT exactly the same type
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.OnlyBulletSameCautionNoteType)
{
if (MyPrevious != null && MyPrevious.MyContent.Type != MyContent.Type &&
((MyPrevious.IsCaution && this.IsCaution) || (MyPrevious.IsNote && this.IsNote))) return true;
if (NextItem != null && NextItem.MyContent.Type != MyContent.Type &&
((NextItem.IsCaution && this.IsCaution) || (NextItem.IsNote && this.IsNote))) return true;
}
if (!FormatStepData.MixCautionsAndNotes) return false;
if (IsNote && ((NextItem != null && NextItem.IsCaution) || (MyPrevious != null && MyPrevious.IsCaution))) return true;
if (IsCaution && ((NextItem != null && NextItem.IsNote) || (MyPrevious != null && MyPrevious.IsNote))) return true;
return false;
}
private string ReplaceStepToken(string tbformat)
{
if (tbformat.Trim().EndsWith("`"))
{
ItemInfo tmp = this;
string sep = string.Empty;
string hlsOrdinal = string.Empty;
do
{
hlsOrdinal = tmp.MyParent.MyTab.CleanTextNoSymbols.Trim(" .".ToCharArray()) + sep + hlsOrdinal;
tmp = tmp.MyParent;
sep = ".";
} while (!tmp.IsHigh);
tbformat = tbformat.Replace("`", " " + hlsOrdinal);
}
return tbformat;
}
private bool TabToIdentBAdjustFont()
{
if ((FormatStepData.TabData.Font.Style & E_Style.Underline) > 0)
{
//FontStyle style = FontStyle.Regular;
//if ((FormatStepData.TabData.Font.Style & E_Style.Bold) > 0) style |= FontStyle.Bold;
//if ((FormatStepData.TabData.Font.Style & E_Style.Italics) > 0) style |= FontStyle.Italic;
//_MyTab.MyFont.WindowsFont = new Font(FormatStepData.TabData.Font.WindowsFont.FontFamily, FormatStepData.TabData.Font.WindowsFont.Size, style);
// clear the underlining for this tab's font:
E_Style es = ((E_Style)_MyTab.MyFont.Style) & ~E_Style.Underline;
_MyTab.MyFont = new VE_Font(_MyTab.MyFont.Family, (int)_MyTab.MyFont.Size, es, (float)_MyTab.MyFont.CPI);
return true;
}
return false;
}
private string AlphabeticalNumbering(int number)
{
string retval = string.Empty;
// BGE requires tabs to be 'AA', 'AB', 'AC'... 'BA', 'BB', 'BC', etc.
if (ActiveFormat.PlantFormat.FormatData.PrintData.SpecialCaseCalvert)
{
if (number > 26) retval += Letter((number - 1) / 26);
retval += Letter(1 + ((number - 1) % 26));
return retval;
}
// Westinghouse and 16bit had 'AA', 'BB', etc. Logic supports unlimited cases ('aa','aaa','aaaa', etc.)
retval = retval.PadRight(1 + ((number - 1) / 26), Letter(1 + ((number - 1) % 26))[0]);
return retval;
}
private string Letter(int number)
{
char c = (char)(number + 64);
return c.ToString();
}
private enum RomanOffset : int
{
Hundreds = 2,
Tens = 4,
Units = 6
}
private static string _Romans = "MDCLXVI";
private static string RomanPart(RomanOffset offset, int value)
{
int iFive = value / 5;
int iUnits = value % 5;
int iFour = iUnits / 4;
return _Romans.Substring(((int)offset), iFour) +
_Romans.Substring(((int)offset) - iFive - iFour, iFive | iFour) +
"".PadRight(iUnits % 4, _Romans[((int)offset)]);
}
public static string RomanNumbering(int number)
{
int thousands = number / 1000;
int hundreds = (number % 1000) / 100;
int tens = (number % 100) / 10;
int units = number % 10;
return "".PadRight(thousands, _Romans[0]) +
RomanPart(RomanOffset.Hundreds, hundreds) +
RomanPart(RomanOffset.Tens, tens) +
RomanPart(RomanOffset.Units, units);
}
public static void ResetTabString(int itemID)
{
ConvertListToDictionary();
string key = itemID.ToString();
if (key != null && _CacheByPrimaryKey.ContainsKey(key))
{
ItemInfo[] items = _CacheByPrimaryKey[key].ToArray();
foreach (ItemInfo item in items)
{
item._TagsSetup = false;
}
}
}
#endregion
#region EnhancedSupport
public void ClearEnhancedSectionFromSource(int srcId)
{
using (Section ssrc = Section.Get(srcId))
{
SectionConfig ssrcc = ssrc.MyConfig as SectionConfig;
EnhancedDocuments newEds = new EnhancedDocuments();
foreach (EnhancedDocument ed in ssrcc.MyEnhancedDocuments)
{
if (ed.ItemID != ItemID) newEds.Add(ed);
}
if (newEds.Count > 0)
{
ssrcc.MyEnhancedDocuments = null;
ssrcc.MyEnhancedDocuments = newEds;
ssrcc.SaveEnhancedDocuments();
ssrc.MyContent.Config = ssrcc.ToString();
ssrc.Save();
}
}
}
public void ClearEnhancedSectionLink()
{
// for this source section, clear any enhanced flags in connected section
// where the enhanced type is "T", i.e. title only
if (!IsSection) return;
SectionConfig sc = MyConfig as SectionConfig;
if (sc.Section_LnkEnh != "T" || sc.MyEnhancedDocuments == null || sc.MyEnhancedDocuments.Count == 0) return;
foreach (EnhancedDocument ed in sc.MyEnhancedDocuments)
{
using (Section s = Section.Get(ed.ItemID))
{
// have to get config from a SectionInfo, it is null off of this section (not sure why)
SectionInfo si = SectionInfo.Get(ed.ItemID);
SectionConfig esc = si.MyConfig as SectionConfig;
esc.MyEnhancedDocuments.Clear();
esc.SaveEnhancedDocuments();
s.MyContent.Config = esc.ToString();
s.Save();
}
}
sc.Section_LnkEnh = null;
using (Section mysect = Section.Get(ItemID))
{
mysect.MyContent.Config = sc.ToString();
mysect.Save();
}
}
#endregion
#region ParentNoteOrCaution
private bool _ParentNoteOrCautionLoaded = false;
private ItemInfo _ParentNoteOrCaution;
public ItemInfo ParentNoteOrCaution
{
get
{
if (!_ParentNoteOrCautionLoaded)
{
ItemInfo parent = ActiveParent as ItemInfo;
if (parent != null)
{
if (parent.IsCautionPart || parent.IsNotePart)
_ParentNoteOrCaution = parent;
else if (!parent.IsHigh)
{
_ParentNoteOrCaution = parent.ParentNoteOrCaution;
}
}
_ParentNoteOrCautionLoaded = true;
}
return _ParentNoteOrCaution;
}
}
#endregion
#region Macro List
[NonSerialized]
protected List<Macro> _MyMacros;
protected bool _MacrosSetup = false;
public List<Macro> MyMacros
{
get
{
if (!_MacrosSetup) SetupMacros();
return _MyMacros;
}
set
{
_MyMacros = value;
}
}
private void SetupMacros()
{
if (FormatStepData == null) return;
// see if each macro should be printed based on its attributes and the item we're on.
// Attributes to check are NotInRNO, i.e. only add this macro to the result list if
// the item is not in the RNO column. Also, Groupings is used to only have the macro if
// there are N or more of the type in the grouping.
List<Macro> tmp = new List<Macro>();
StepData myStepData = (FormatStepData.TextSubFollowsTextStyle && ParentNoteOrCaution != null) ? ParentNoteOrCaution.FormatStepData : FormatStepData;
// foreach (Macro macro in ActiveFormat.PlantFormat.FormatData.StepDataList[FormatStepType].TabData.MacroList)
foreach (Macro macro in myStepData.TabData.MacroList)
{
bool addToList = true;
if (macro.NotInRNO && IsInRNO) addToList = false;
if (((MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_DontDoCheckOffs) == E_DocStructStyle.DSS_DontDoCheckOffs) &&
macro.Name.ToUpper() == "CHECKOFF") addToList = false;
if (macro.Grouping != null && macro.Grouping > 0)
{
int count = 0;
ItemInfo ii = FirstSibling;
while (ii != null)
{
if (ii.MyContent.Type == MyContent.Type) count++;
ii = ii.NextItem;
}
if (count <= macro.Grouping) addToList = false;
}
if (addToList) tmp.Add(macro);
}
if (tmp.Count > 0) _MyMacros = tmp;
}
#endregion
#region UseSmartTemplate
// TemplateIndex is for Calvert only:
private int _TemplateIndex = -2; // -2 not set; -1 not a template
public int TemplateIndex
{
get
{
if (_TemplateIndex == -2)
{
_TemplateIndex = GetSmartTemplateTopLevelIndx();
if (_TemplateIndex != -1)
{
if (!IsHigh) _TemplateIndex = GetSmartTemplateIndex(_TemplateIndex, MyContent.Text);
}
}
return _TemplateIndex;
}
set { _TemplateIndex = value; }
}
private int? _TemplateChildColumnMode = null;
public int TemplateChildColumnMode
{
get
{
if (_TemplateChildColumnMode == null)
{
if (TemplateIndex >= 0)
{
_TemplateChildColumnMode = ActiveFormat.PlantFormat.FormatData.Templates[TemplateIndex].nocolm;
if (_TemplateChildColumnMode == 0) _TemplateChildColumnMode = 1; // 0 is default, set to 1 column
}
else
_TemplateChildColumnMode = -1;
}
return _TemplateChildColumnMode ?? -1;
}
}
private int? _TemplateColumnMode = null;
public int TemplateColumnMode
{
get
{
if (_TemplateColumnMode == null)
{
ItemInfo pi = ActiveParent as ItemInfo;
if (pi != null)
{
if (!pi.IsStep) // only steps are in template
_TemplateColumnMode = -1;
else if (pi.FormatStepData.UseOldTemplate)
_TemplateColumnMode = pi.TemplateChildColumnMode;
else
_TemplateColumnMode = pi.TemplateColumnMode; // go up parents until find of columnmode or section
}
}
return _TemplateColumnMode ?? -1;
}
}
public bool IsInTemplate() // is this step defined by template, i.e. included in template list
{
if (IsStep && ActiveFormat.PlantFormat.FormatData.TopTemplateTypes != null && ActiveFormat.PlantFormat.FormatData.TopTemplateTypes.ContainsKey((int)MyContent.Type - 20001)) return true;
return false;
}
public bool IsWithInSingleColumnTemplate() // is this step within a step defined by a 'single-column' template item
{
if (IsStep && ActiveFormat.PlantFormat.FormatData.TopTemplateTypes != null)
{
ItemInfo tmp = this;
while (tmp.IsStep)
{
if (tmp.TemplateIndex > 0)
{
if (ActiveFormat.PlantFormat.FormatData.Templates[tmp.TemplateIndex].nocolm == 0) return true;
return false;
}
tmp = tmp.MyParent;
}
}
return false;
}
public int GetSmartTemplateTopLevelIndxOfThisType(int oftype) // used for inserting steps
{
if (ActiveFormat == null) return -1;
FormatData formatData = ActiveFormat.PlantFormat.FormatData;
if (formatData.TopTemplateTypes == null || formatData.TopTemplateTypes.Count == 0) return -1;
if (formatData.TopTemplateTypes.ContainsKey(oftype - 20001)) return formatData.TopTemplateTypes[oftype - 20001];
return -1;
}
public int GetSmartTemplateTopLevelIndx()
{
if (FormatStepData == null) return -1;
FormatData formatData = ActiveFormat.PlantFormat.FormatData;
if (formatData.TopTemplateTypes == null || formatData.TopTemplateTypes.Count == 0) return -1;
ItemInfo tmp = this;
while (!tmp.IsSection)
{
if (formatData.TopTemplateTypes.ContainsKey((int)tmp.MyContent.Type - 20001)) return formatData.TopTemplateTypes[(int)tmp.MyContent.Type - 20001];
tmp = tmp.MyParent;
}
return -1;
}
public int GetSmartTemplateIndex(int topIndx, int curStepType)
{
FormatData formatData = ActiveFormat.PlantFormat.FormatData;
if (formatData.TopTemplateTypes == null || formatData.TopTemplateTypes.Count == 0) return -1;
int indx = topIndx;
int curType = curStepType - 20001;
while (indx < formatData.Templates.Count)
{
// now see if we're on the topType, if so, look under this one
// for the step type that we're on. If found return the index of it.
if (formatData.Templates[indx].type == curType) return indx;
indx++;
}
return -1; // didn't find this step type in the template width override list.
}
// GetSmartTemplateIndex(int topIndx, string strtxt): Added for Calvert Alarms since their
// template also uses the text, not just the type, to find a match in the template.
public int GetSmartTemplateIndex(int topIndx, string strtxt)
{
string txt = strtxt.Replace(@"\u160?", " ");
if (ActiveFormat == null) return -1;
FormatData formatData = ActiveFormat.PlantFormat.FormatData;
if (formatData.TopTemplateTypes == null || formatData.TopTemplateTypes.Count == 0) return -1;
int indx = topIndx;
while (indx < formatData.Templates.Count)
{
if (IsHigh && formatData.Templates[indx].type == (MyContent.Type - 20001)) return indx;
if (txt == null && formatData.Templates[indx].type == (MyContent.Type - 20001)) return indx;
// now see if we're on the topType, if so, look under this one for the step type
// that we're on, the TEXT ALSO NEEDS TO MATCH. If found return the index of it.
if (txt != null && formatData.Templates[indx].text != null && (txt.Trim() == formatData.Templates[indx].text.Trim())
&& ((MyContent.Type - 20001) == formatData.Templates[indx].type)) return indx;
indx++;
}
return -1; // didn't find this step type in the template width override list.
}
#endregion
#region CheckOffs
private string _SectionCheckOffHeader;
public string SectionCheckOffHeader
{
get
{
if (_SectionCheckOffHeader == null)
{
// first check if format has checkoff data, including checkoffheaders.
ProcData pd = ActiveFormat.PlantFormat.FormatData.ProcData;
if (pd.CheckOffData == null || pd.CheckOffData.CheckOffHeaderList == null || pd.CheckOffData.CheckOffHeaderList.MaxIndex <= 1) _SectionCheckOffHeader = string.Empty;
else
{
SectionConfig sc = ActiveSection.MyConfig as SectionConfig;
if (sc == null) _SectionCheckOffHeader = string.Empty;
else if (sc.Section_CheckoffHeaderSelection <= 0) _SectionCheckOffHeader = string.Empty;
else
{
_SectionCheckOffHeader = pd.CheckOffData.CheckOffHeaderList[sc.Section_CheckoffHeaderSelection].CheckOffHeading;
if (_SectionCheckOffHeader.Contains("{NO HEADING}")) _SectionCheckOffHeader = string.Empty;
}
}
}
return _SectionCheckOffHeader;
}
}
public bool SectionHasCheckOffs()
{
// To determine if the section has a checkoff...
// Section won't have checkoffs if there is no checkofflist, or
ProcData pd = ActiveFormat.PlantFormat.FormatData.ProcData;
int maxindx = pd.CheckOffUCF ? pd.CheckOffData.CheckOffList.MaxIndex : pd.CheckOffData.CheckOffList.MaxIndexNoInherit;
if (pd.CheckOffData == null || pd.CheckOffData.CheckOffList == null || maxindx <= 0) return false;
if (pd.CheckOffData.CheckOffHeaderList == null || pd.CheckOffData.CheckOffHeaderList.MaxIndex <= 1) return true;
//if (pd.CheckOffData == null || pd.CheckOffData.CheckOffHeaderList == null || pd.CheckOffData.CheckOffHeaderList.Count <= 1) return false;
// To find whether the step has a checkoff, first check that the section
// has a check off header. If it doesn't, just return -1.
// if config item is set for checkoffindex, use it. If it == 0, then use
// the section default.
SectionConfig sc = ActiveSection.MyConfig as SectionConfig;
if (sc == null) return false;
if (sc.Section_CheckoffHeaderSelection < 0) return false;
return true;
}
public int CheckOffIndex()
{
StepConfig stc = MyConfig as StepConfig;
if (stc == null) return 0; //section default.
if (stc != null && stc.Step_CheckOffIndex == 1) return -1; // index of 1, always means 'No Checkoff'
return stc.Step_CheckOffIndex;
}
private int SectionConfigCheckOffIndex
{
get
{
SectionConfig sc = ActiveSection.MyConfig as SectionConfig;
return sc.Section_CheckoffListSelection;
}
}
private int SectionDefaultCheckOffIndex()
{
ProcData pd = ActiveFormat.PlantFormat.FormatData.ProcData;
int maxindx = pd.CheckOffUCF ? pd.CheckOffData.CheckOffList.MaxIndex : pd.CheckOffData.CheckOffList.MaxIndexNoInherit;
if (pd.CheckOffData != null && pd.CheckOffData.CheckOffList != null && maxindx == 2) return 0; // if only two items, first is macro - use it.
SectionConfig sc = ActiveSection.MyConfig as SectionConfig;
return sc.Section_CheckoffListSelection;
}
public CheckOff GetCheckOffStep()
{
if (!IsStep) return null;
if (SectionDefaultEnabled) return SectionDefaultEnabledCheckOff;
if (!SectionHasCheckOffs()) return null;
int stpCoIndx = CheckOffIndex(); // this step has a checkoff defined
if (stpCoIndx == -1) return null;
if (stpCoIndx > 1)
{
if (ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffUCF && stpCoIndx >= 100)
{
// get index, if greater than 100, store that - otherwise store index down list.
// if this format does not have ucf signoffs, indx is just the selected index from the combo box.
foreach (CheckOff co in ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList)
{
if (stpCoIndx == co.Index)
{
stpCoIndx = (int)co.Index;
break;
}
}
}
return ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList[stpCoIndx]; // DO override of CheckOffList[] to get ucf
}
int sectCoIndx = SectionDefaultCheckOffIndex(); // no checkoff on step, see if there is a section default.
if (sectCoIndx == -1) return null;
if ((ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffOnHLSOnly && IsHigh)
|| (!ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffOnHLSOnly && IsLowestLevelStep && stpCheckOff)) // && !RNOsHighHasCheckOff()))
return ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList[sectCoIndx];
return null;
}
private bool stpCheckOff
{
get
{
StepConfig stc = MyConfig as StepConfig;
return (stc != null && stc.Step_CheckOffIndex == 0);
}
}
private CheckOff SectionDefaultEnabledCheckOff
{
get
{
int sectCoIndx = SectionConfigCheckOffIndex; // no checkoff on step, see if there is a section default.
if (IsLowestLevelStep) // && !RNOsHighHasCheckOff()))
return ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList[sectCoIndx];
return null;
}
}
private bool SectionDefaultEnabled
{
get
{
ProcData pd = ActiveFormat.PlantFormat.FormatData.ProcData;
int maxindx = pd.CheckOffUCF ? pd.CheckOffData.CheckOffList.MaxIndex : pd.CheckOffData.CheckOffList.MaxIndexNoInherit;
if (pd.CheckOffData != null && pd.CheckOffData.CheckOffList != null && maxindx == 2 && pd.CheckOffData.CheckOffList[0].MenuItem == "Enabled")
return true; // if only two items, first is macro - use it.
return false;
}
}
private bool IsLowestLevelStep
{
get
{
return (!(IsCaution || IsNote || IsTable || IsFigure || Steps != null || MyParent.IsCaution || MyParent.IsNote));
}
}
private bool RNOsHighHasCheckOff()
{
// If this is a High Level Step's RNO, the checkoff would be placed on the HLS, not the RNO.
if (IsRNOPart && MyParent.IsHigh && MyParent.CheckOffIndex() != -1) return true;
return false;
}
#endregion
#region JCB Item Status
private bool _IsItemNew = false;
public bool IsItemNew
{
get
{
ProcedureInfo pi = this.MyProcedure;
if (pi != null)
_IsItemNew = (this.DTS > pi.DTS);
return _IsItemNew;
}
}
private bool _IsItemChanged;
public bool IsItemChanged
{
get
{
ProcedureInfo pi = this.MyProcedure;
if (pi != null)
_IsItemChanged = (this.MyContent.DTS > pi.DTS);
return _IsItemChanged;
}
}
#endregion
}
#endregion ItemInfo
#region Tab
public class MetaTag
{
public VE_Font MyFont;
public ContentAlignment Justify = ContentAlignment.MiddleLeft;
private string _Text; // may include tokens, such as macros for circles/diamonds, etc
public string Text
{
get { return _Text; }
set { _Text = value; }
}
public string CleanText; // all tokens removed
public MetaTag()
{
}
public MetaTag(VE_Font font)
{
MyFont = new VE_Font(font.XmlNode);
}
}
public class Tab : MetaTag
{
private string _AltPrintTab = null;
public string AltPrintTab
{
get { return _AltPrintTab; }
set { _AltPrintTab = value; }
}
private string _BasicTab = null;
public string BasicTab
{
get { return _BasicTab; }
set { _BasicTab = value; }
}
private bool _RemovedStyleUnderline = false;
public bool RemovedStyleUnderline
{
get { return _RemovedStyleUnderline; }
set { _RemovedStyleUnderline = value; }
}
private bool _AdjustTabSpace = false;
public bool AdjustTabSpace
{
get { return _AdjustTabSpace; }
set { _AdjustTabSpace = value; }
}
public Tab(VE_Font font)
{
MyFont = font;
}
public override string ToString()
{
return this.CleanTextNoSymbols;
}
public int Offset;
public int Position;
private float _RNOTabWidthAdjust = 0;
public float RNOTabWidthAdjust
{
get { return _RNOTabWidthAdjust; }
set { _RNOTabWidthAdjust = value; }
}
public int AsteriskOffset;
private static Regex _ReplaceSymbols = new Regex("^[^0-9A-Za-z]*"); // trim anything that isn't an ascii alpha/numeric from the beginning
public string CleanTextNoSymbols
{
get
{
// this trims off any symbols at the start of the tab
return _ReplaceSymbols.Replace(CleanText, "").Replace("#", "");
}
}
}
public class Header : MetaTag
{
}
#endregion
#region ItemInfoList
public partial class ItemInfoList
{
//public void ToXml(XmlNode xn)
//{
// foreach (ItemInfo itemInfo in this)
// {
// itemInfo.ToXml(xn);
// }
//}
internal ItemInfoList(ItemInfo itemInfo)
{
AddItem(itemInfo);
}
public void AddItemInfo(ItemInfo ii)
{
AddItem(ii);
}
public static ItemInfoList GetMoveItem(int? itemID, int index)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new MoveItemCriteria(itemID, index));
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
}
}
public static ItemInfoList GetList(int? itemID, int type)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListCriteria(itemID, type));
ItemInfo.AddList(tmp);
tmp.AddEvents();
#if (!ItemWithContent) // If ItemWithContent is set, the content is returned with the ItemInfoList
ContentInfoList.GetList(itemID); // Performance - Load All Content
#endif
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
}
}
public static ItemInfoList GetListTranTo()
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemTranToListCriteria());
ItemInfo.AddList(tmp);
tmp.AddEvents();
#if (!ItemWithContent) // If ItemWithContent is set, the content is returned with the ItemInfoList
ContentInfoList.GetList(itemID); // Performance - Load All Content
#endif
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetTranToList", ex);
}
}
public static ItemInfoList GetListTranFrom()
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemTranFromListCriteria());
ItemInfo.AddList(tmp);
tmp.AddEvents();
#if (!ItemWithContent) // If ItemWithContent is set, the content is returned with the ItemInfoList
ContentInfoList.GetList(itemID); // Performance - Load All Content
#endif
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetTranFromList", ex);
}
}
public static ItemInfoList GetListByPartType(E_FromType fromType)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListPartTypeCriteria(fromType));
ItemInfo.AddList(tmp);
tmp.AddEvents();
#if (!ItemWithContent) // If ItemWithContent is set, the content is returned with the ItemInfoList
ContentInfoList.GetList(itemID); // Performance - Load All Content
#endif
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
}
}
[Serializable()]
private class MoveItemCriteria
{
public MoveItemCriteria(int? itemID, int index)
{
_ItemID = itemID;
_Index = index;
}
private int? _ItemID;
public int? ItemID
{
get { return _ItemID; }
set { _ItemID = value; }
}
private int _Index;
public int Index
{
get { return _Index; }
set { _Index = value; }
}
}
[Serializable()]
private class ItemListCriteria
{
public ItemListCriteria(int? itemID, int type)
{
_ItemID = itemID;
_Type = type;
}
private int? _ItemID;
public int? ItemID
{
get { return _ItemID; }
set { _ItemID = value; }
}
private int _Type;
public int Type
{
get { return _Type; }
set { _Type = value; }
}
}
[Serializable()]
private class ItemTranToListCriteria
{
}
[Serializable()]
private class ItemTranFromListCriteria
{
}
[Serializable()]
private class ItemListPartTypeCriteria
{
public ItemListPartTypeCriteria(E_FromType type)
{
_Type = type;
}
private E_FromType _Type;
public E_FromType Type
{
get { return _Type; }
set { _Type = value; }
}
}
private void DataPortal_Fetch(MoveItemCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "MoveItem";
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
cm.Parameters.AddWithValue("@Index", criteria.Index);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = new ItemInfo(dr);
//switch ((E_FromType)criteria.Type)
//{
// case E_FromType.Procedure:
// itemInfo = new ProcedureInfo(dr);
// break;
// case E_FromType.Section:
// itemInfo = new SectionInfo(dr);
// break;
// default:
// itemInfo = new StepInfo(dr);
// break;
//}
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
private void DataPortal_Fetch(ItemListCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
#if ItemWithContent
cm.CommandText = "vesp_ListItemsAndContent";
#else
cm.CommandText = "vesp_ListItems";
#endif
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = null;
switch ((E_FromType)criteria.Type)
{
case E_FromType.Procedure:
itemInfo = new ProcedureInfo(dr);
break;
case E_FromType.Section:
itemInfo = new SectionInfo(dr);
break;
default:
itemInfo = new StepInfo(dr);
break;
}
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
private void DataPortal_Fetch(ItemTranToListCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
#if ItemWithContent
cm.CommandText = "vesp_ListItemsTranToAndContent";
#else
cm.CommandText = "vesp_ListItemsTranTo";
#endif
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = new ItemInfo(dr);
//switch ((E_FromType)criteria.Type)
//{
// case E_FromType.Procedure:
// itemInfo = new ProcedureInfo(dr);
// break;
// case E_FromType.Section:
// itemInfo = new SectionInfo(dr);
// break;
// default:
// itemInfo = new StepInfo(dr);
// break;
//}
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
private void DataPortal_Fetch(ItemTranFromListCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
#if ItemWithContent
cm.CommandText = "vesp_ListItemsTranFromAndContent";
#else
cm.CommandText = "vesp_ListItemsTranFrom";
#endif
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = new ItemInfo(dr);
//switch ((E_FromType)criteria.Type)
//{
// case E_FromType.Procedure:
// itemInfo = new ProcedureInfo(dr);
// break;
// case E_FromType.Section:
// itemInfo = new SectionInfo(dr);
// break;
// default:
// itemInfo = new StepInfo(dr);
// break;
//}
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
private void DataPortal_Fetch(ItemListPartTypeCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
#if ItemWithContent
cm.CommandText = "getItemsByPartTypeAndContent";
#else
cm.CommandText = "getItemsByPartType";
#endif
cm.Parameters.AddWithValue("@FromType", (int)criteria.Type);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = null;
switch (criteria.Type)
{
case E_FromType.Procedure:
itemInfo = new ProcedureInfo(dr);
break;
case E_FromType.Section:
itemInfo = new SectionInfo(dr);
break;
default:
itemInfo = new StepInfo(dr);
break;
}
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
internal void AddItem(ItemInfo itemInfo)
{
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
#region EnhancedSupport
#region EnhancedGetTextDifferences
public static ItemInfoList GetListEnhancedTextDifferences(ItemInfo procItem)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListEnhancedTextDifferencesCriteria(procItem.ItemID));
return tmp;
}
catch (Exception ex)
{
// Don't crash on Primary Key Problem.
Exception ex1 = ex;
while (ex1 != null)
{
if (ex1.Message.Contains("PRIMARY KEY"))
return null;
ex1 = ex1.InnerException;
}
throw new DbCslaException("Error on ItemInfoList.GetListEnhancedTextDifferences", ex);
}
}
[Serializable()]
private class ItemListEnhancedTextDifferencesCriteria
{
private int _ProcID;
public int ProcID
{
get { return _ProcID; }
set { _ProcID = value; }
}
public ItemListEnhancedTextDifferencesCriteria(int procid)
{
_ProcID = procid;
}
}
private void DataPortal_Fetch(ItemListEnhancedTextDifferencesCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_ListItemsToRefresh";
cm.Parameters.AddWithValue("@ProcID", criteria.ProcID);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = new ItemInfo(dr);
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
#endregion // EnhancedGetTextDifferences
#region EnhancedGetMissingEnh
public static ItemInfoList GetListEnhancedForMissing(ItemInfo srcItem, int enhType)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListEnhancedMissingCriteria(srcItem.ItemID, enhType));
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetListEnhancedForMissing", ex);
}
}
[Serializable()]
private class ItemListEnhancedMissingCriteria
{
private int _ItemID;
public int ItemID
{
get { return _ItemID; }
set { _ItemID = value; }
}
private int _EnhType;
public int EnhType
{
get { return _EnhType; }
set { _EnhType = value; }
}
public ItemListEnhancedMissingCriteria(int itemid, int enhtype)
{
_ItemID = itemid;
_EnhType = enhtype;
}
}
private void DataPortal_Fetch(ItemListEnhancedMissingCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_ListUnlinkedItems";
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
cm.Parameters.AddWithValue("@EnhType", criteria.EnhType);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = new ItemInfo(dr);
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
#endregion // EnhancedGetMissingEnh
#endregion // EnhancedSupport
#region Text Search
public static ItemInfoList GetListFromTextSearch(string docVersionList, string stepTypeList, string searchString, int caseSensitive, ItemSearchIncludeLinks includeLinks, bool includeRtfFormatting, bool includeSpecialCharacters, string unitPrefix)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListSearchCriteria(docVersionList, stepTypeList, searchString, caseSensitive, includeLinks, includeRtfFormatting, includeSpecialCharacters, unitPrefix));
tmp.SourceOfList = "Search";
ItemInfo.AddList(tmp);
tmp.AddEvents();
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetListFromTextSearch", ex);
}
}
[Serializable()]
private class ItemListSearchCriteria
{
private string _DocVersionList;
public string DocVersionList
{
get { return _DocVersionList; }
set { _DocVersionList = value; }
}
private string _StepTypeList;
public string StepTypeList
{
get { return _StepTypeList; }
set { _StepTypeList = value; }
}
private string _SearchString;
public string SearchString
{
get { return _SearchString; }
set { _SearchString = value; }
}
private int _CaseSensitive;
public int CaseSensitive
{
get { return _CaseSensitive; }
set { _CaseSensitive = value; }
}
private ItemSearchIncludeLinks _IncludeLinks;
public ItemSearchIncludeLinks IncludeLinks
{
get { return _IncludeLinks; }
set { _IncludeLinks = value; }
}
private bool _IncludeRtfFormatting;
public bool IncludeRtfFormatting
{
get { return _IncludeRtfFormatting; }
set { _IncludeRtfFormatting = value; }
}
private bool _IncludeSpecialCharacters;
public bool IncludeSpecialCharacters
{
get { return _IncludeSpecialCharacters; }
set { _IncludeSpecialCharacters = value; }
}
private string _UnitPrefix;
public string UnitPrefix
{
get { return _UnitPrefix; }
set { _UnitPrefix = value; }
}
public ItemListSearchCriteria(string docVersionList, string stepTypeList, string searchString,
int caseSensitive, ItemSearchIncludeLinks includeLinks, bool includeRtfFormatting, bool includeSpecialCharacters, string unitPrefix)
{
_DocVersionList = docVersionList;
_StepTypeList = stepTypeList;
_SearchString = searchString;
_CaseSensitive = caseSensitive;
_IncludeLinks = includeLinks;
_IncludeRtfFormatting = includeRtfFormatting;
_IncludeSpecialCharacters = includeSpecialCharacters;
_UnitPrefix = unitPrefix;
}
}
private void DataPortal_Fetch(ItemListSearchCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_SearchItemAndChildrenNew";
cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
cm.Parameters.AddWithValue("@SearchString", criteria.SearchString);
cm.Parameters.AddWithValue("@CaseSensitive", criteria.CaseSensitive);
cm.Parameters.AddWithValue("@IncludeLinks", (int)criteria.IncludeLinks);
cm.Parameters.AddWithValue("@IncludeRtfFormatting", criteria.IncludeRtfFormatting ? 1 : 0);
cm.Parameters.AddWithValue("@IncludeSpecialCharacters", criteria.IncludeSpecialCharacters ? 1 : 0);
cm.Parameters.AddWithValue("@UnitPrefix", criteria.UnitPrefix);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = null;
int itemType = dr.GetInt32("Type") / 10000;
switch (itemType)
{
case 0:
itemInfo = new ProcedureInfo(dr);
break;
case 1:
itemInfo = new SectionInfo(dr);
break;
default:
itemInfo = new StepInfo(dr);
break;
}
itemInfo.AddContent(dr);
itemInfo._SearchDVPath = dr.GetString("DVPath");
itemInfo._SearchPath = dr.GetString("Path");
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
#endregion
#region RO Search
public static ItemInfoList GetListFromROSearch(string docVersionList, string stepTypeList, string roSearchString, string unitPrefix)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListROSearchCriteria(docVersionList, stepTypeList, roSearchString, unitPrefix));
ItemInfo.AddList(tmp);
tmp.AddEvents();
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
}
}
[Serializable()]
private class ItemListROSearchCriteria
{
private string _DocVersionList;
public string DocVersionList
{
get { return _DocVersionList; }
set { _DocVersionList = value; }
}
private string _StepTypeList;
public string StepTypeList
{
get { return _StepTypeList; }
set { _StepTypeList = value; }
}
private string _ROSearchString;
public string ROSearchString
{
get { return _ROSearchString; }
set { _ROSearchString = value; }
}
private string _UnitPrefix;
public string UnitPrefix
{
get { return _UnitPrefix; }
set { _UnitPrefix = value; }
}
public ItemListROSearchCriteria(string docVersionList, string stepTypeList, string roSearchString, string unitPrefix)
{
_DocVersionList = docVersionList;
_StepTypeList = stepTypeList;
_ROSearchString = roSearchString;
_UnitPrefix = unitPrefix;
}
}
private void DataPortal_Fetch(ItemListROSearchCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_SearchROItemAndChildren";
cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
cm.Parameters.AddWithValue("@ROSearchString", criteria.ROSearchString);
cm.Parameters.AddWithValue("@UnitPrefix", criteria.UnitPrefix);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
string FoundROs = "";
while (dr.Read())
{
ItemInfo itemInfo = null;
int itemType = dr.GetInt32("Type") / 10000;
switch (itemType)
{
case 0:
itemInfo = new ProcedureInfo(dr);
break;
case 1:
itemInfo = new SectionInfo(dr);
break;
default:
itemInfo = new StepInfo(dr);
break;
}
itemInfo.AddContent(dr);
itemInfo._SearchDVPath = dr.GetString("DVPath");
itemInfo._SearchPath = dr.GetString("Path");
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
#endregion
#region Annotation Search
public static ItemInfoList GetListFromAnnotationSearch(string docVersionList, string stepTypeList, string annotationTypeList, string searchString, bool caseSensitive, string unitPrefix)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListAnnotationSearchCriteria(docVersionList, stepTypeList, annotationTypeList, searchString, caseSensitive, unitPrefix));
ItemInfo.AddList(tmp);
tmp.AddEvents();
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
}
}
[Serializable()]
private class ItemListAnnotationSearchCriteria
{
private string _DocVersionList;
public string DocVersionList
{
get { return _DocVersionList; }
set { _DocVersionList = value; }
}
private string _StepTypeList;
public string StepTypeList
{
get { return _StepTypeList; }
set { _StepTypeList = value; }
}
private string _AnnotationTypeList;
public string AnnotationTypeList
{
get { return _AnnotationTypeList; }
set { _AnnotationTypeList = value; }
}
private string _SearchString;
public string SearchString
{
get { return _SearchString; }
set { _SearchString = value; }
}
private bool _CaseSensitive;
public bool CaseSensitive
{
get { return _CaseSensitive; }
set { _CaseSensitive = value; }
}
private string _UnitPrefix;
public string UnitPrefix
{
get { return _UnitPrefix; }
set { _UnitPrefix = value; }
}
public ItemListAnnotationSearchCriteria(string docVersionList, string stepTypeList, string annotationTypeList, string searchString, bool caseSensitive, string unitPrefix)
{
_DocVersionList = docVersionList;
_StepTypeList = stepTypeList;
_AnnotationTypeList = annotationTypeList;
_SearchString = searchString;
_CaseSensitive = caseSensitive;
_UnitPrefix = unitPrefix;
}
}
private void DataPortal_Fetch(ItemListAnnotationSearchCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_SearchAnnotationItemAndChildren";
cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
cm.Parameters.AddWithValue("@AnnotationTypeList", criteria.AnnotationTypeList);
cm.Parameters.AddWithValue("@SearchString", criteria.SearchString);
cm.Parameters.AddWithValue("@CaseSensitive", criteria.CaseSensitive ? 1 : 0);
cm.Parameters.AddWithValue("@UnitPrefix", criteria.UnitPrefix);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = null;
int itemType = dr.GetInt32("Type") / 10000;
switch (itemType)
{
case 0:
itemInfo = new ProcedureInfo(dr);
break;
case 1:
itemInfo = new SectionInfo(dr);
break;
default:
itemInfo = new StepInfo(dr);
break;
}
itemInfo.AddContent(dr);
itemInfo._SearchDVPath = dr.GetString("DVPath");
itemInfo._SearchPath = dr.GetString("Path");
itemInfo._SearchAnnotationID = dr.GetInt32("SearchAnnotationID");
itemInfo._SearchAnnotationText = dr.GetString("SearchText");
itemInfo._SearchAnnotationType = dr.GetString("AnnotationType");
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
#endregion
#region Transition Search
// added stepTypeList parameter to allow a transition search is selected step elements (B2015-055)
public static ItemInfoList GetListFromTransitionSearch(string docVersionList, int tranType, string tranCategory, string stepTypeList)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListTransitionSearchCriteria(docVersionList, tranType, tranCategory, stepTypeList));
ItemInfo.AddList(tmp);
tmp.AddEvents();
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetListFromTransitionSearch", ex);
}
}
[Serializable()]
private class ItemListTransitionSearchCriteria
{
private string _DocVersionList;
public string DocVersionList { get { return _DocVersionList; } }
private int _TranType;
public int TranType { get { return _TranType; } }
private string _TranCategory;
public string TranCategory { get { return _TranCategory; } }
// added stepTypeList parameter to allow a transition search is selected step elements (B2015-055)
private string _StepTypeList;
public string StepTypeList { get { return _StepTypeList; } }
public ItemListTransitionSearchCriteria(string docVersionList, int tranType, string tranCategory, string stepTypeList)
{
_DocVersionList = docVersionList;
_TranType = tranType;
_TranCategory = tranCategory;
_StepTypeList = stepTypeList;
}
}
private void DataPortal_Fetch(ItemListTransitionSearchCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_SearchTransitions";
cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
cm.Parameters.AddWithValue("@TranType", criteria.TranType);
cm.Parameters.AddWithValue("@TranCategory", criteria.TranCategory);
// added stepTypeList parameter to allow a transition search is selected step elements (B2015-055)
cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = null;
int itemType = dr.GetInt32("Type") / 10000;
switch (itemType)
{
case 0:
itemInfo = new ProcedureInfo(dr);
break;
case 1:
itemInfo = new SectionInfo(dr);
break;
default:
itemInfo = new StepInfo(dr);
break;
}
itemInfo.AddContent(dr);
itemInfo._SearchDVPath = dr.GetString("DVPath");
itemInfo._SearchPath = dr.GetString("Path");
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
#endregion
#region RO Reports
public static ItemInfoList GetListFromROReport(string docVersionList, string stepTypeList, string roSearchString, string unitPrefix)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListROReportCriteria(docVersionList, stepTypeList, roSearchString, unitPrefix));
ItemInfo.AddList(tmp);
tmp.AddEvents();
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
}
}
[Serializable()]
private class ItemListROReportCriteria
{
private string _DocVersionList;
public string DocVersionList
{
get { return _DocVersionList; }
set { _DocVersionList = value; }
}
private string _StepTypeList;
public string StepTypeList
{
get { return _StepTypeList; }
set { _StepTypeList = value; }
}
private string _ROSearchString;
public string ROSearchString
{
get { return _ROSearchString; }
set { _ROSearchString = value; }
}
private string _UnitPrefix;
public string UnitPrefix
{
get { return _UnitPrefix; }
set { _UnitPrefix = value; }
}
public ItemListROReportCriteria(string docVersionList, string stepTypeList, string roSearchString, string unitPrefix)
{
_DocVersionList = docVersionList;
_StepTypeList = stepTypeList;
_ROSearchString = roSearchString;
_UnitPrefix = unitPrefix;
}
}
private void DataPortal_Fetch(ItemListROReportCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_GetROUsagesByProcedure";
cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
cm.Parameters.AddWithValue("@ROSearchString", criteria.ROSearchString);
cm.Parameters.AddWithValue("@UnitPrefix", criteria.UnitPrefix);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
string FoundROs = "";
while (dr.Read())
{
ItemInfo itemInfo = null;
int itemType = dr.GetInt32("Type") / 10000;
switch (itemType)
{
case 0:
itemInfo = new ProcedureInfo(dr);
break;
case 1:
itemInfo = new SectionInfo(dr);
break;
default:
itemInfo = new StepInfo(dr);
break;
}
itemInfo.AddContent(dr);
itemInfo._SearchDVPath = dr.GetString("DVPath");
itemInfo._SearchPath = dr.GetString("Path");
itemInfo._FoundROID = dr.GetString("FoundROID");
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
#endregion
#region Applicability Search
public static ItemInfoList GetListFromApplicabilitySearch(string docVersionList, string stepTypeList, string searchString, int caseSensitive, ItemSearchIncludeLinks includeLinks, bool includeRtfFormatting, bool includeSpecialCharacters, string unitPrefix, string applicSetting)
{
try
{
ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListApplicabilitySearchCriteria(docVersionList, stepTypeList, searchString, caseSensitive, includeLinks, includeRtfFormatting, includeSpecialCharacters, unitPrefix, applicSetting));
tmp.SourceOfList = "Search";
ItemInfo.AddList(tmp);
tmp.AddEvents();
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetListFromApplicabilitySearch", ex);
}
}
[Serializable()]
private class ItemListApplicabilitySearchCriteria
{
private string _DocVersionList;
public string DocVersionList
{
get { return _DocVersionList; }
set { _DocVersionList = value; }
}
private string _StepTypeList;
public string StepTypeList
{
get { return _StepTypeList; }
set { _StepTypeList = value; }
}
private string _SearchString;
public string SearchString
{
get { return _SearchString; }
set { _SearchString = value; }
}
private int _CaseSensitive;
public int CaseSensitive
{
get { return _CaseSensitive; }
set { _CaseSensitive = value; }
}
private ItemSearchIncludeLinks _IncludeLinks;
public ItemSearchIncludeLinks IncludeLinks
{
get { return _IncludeLinks; }
set { _IncludeLinks = value; }
}
private bool _IncludeRtfFormatting;
public bool IncludeRtfFormatting
{
get { return _IncludeRtfFormatting; }
set { _IncludeRtfFormatting = value; }
}
private bool _IncludeSpecialCharacters;
public bool IncludeSpecialCharacters
{
get { return _IncludeSpecialCharacters; }
set { _IncludeSpecialCharacters = value; }
}
private string _UnitPrefix;
public string UnitPrefix
{
get { return _UnitPrefix; }
set { _UnitPrefix = value; }
}
private string _ApplicSetting;
public string ApplicSetting
{
get { return _ApplicSetting; }
set { _ApplicSetting = value; }
}
public ItemListApplicabilitySearchCriteria(string docVersionList, string stepTypeList, string searchString,
int caseSensitive, ItemSearchIncludeLinks includeLinks, bool includeRtfFormatting, bool includeSpecialCharacters, string unitPrefix, string applicSetting)
{
_DocVersionList = docVersionList;
_StepTypeList = stepTypeList;
_SearchString = searchString;
_CaseSensitive = caseSensitive;
_IncludeLinks = includeLinks;
_IncludeRtfFormatting = includeRtfFormatting;
_IncludeSpecialCharacters = includeSpecialCharacters;
_UnitPrefix = unitPrefix;
_ApplicSetting = applicSetting;
}
}
private void DataPortal_Fetch(ItemListApplicabilitySearchCriteria criteria)
{
this.RaiseListChangedEvents = false;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_SearchSepcifiedApplicability";
cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
cm.Parameters.AddWithValue("@SearchString", criteria.SearchString);
cm.Parameters.AddWithValue("@CaseSensitive", criteria.CaseSensitive);
cm.Parameters.AddWithValue("@IncludeLinks", (int)criteria.IncludeLinks);
cm.Parameters.AddWithValue("@IncludeRtfFormatting", criteria.IncludeRtfFormatting ? 1 : 0);
cm.Parameters.AddWithValue("@IncludeSpecialCharacters", criteria.IncludeSpecialCharacters ? 1 : 0);
cm.Parameters.AddWithValue("@UnitPrefix", criteria.UnitPrefix);
cm.Parameters.AddWithValue("@ApplicSetting", criteria.ApplicSetting);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
ItemInfo itemInfo = null;
int itemType = dr.GetInt32("Type") / 10000;
switch (itemType)
{
case 0:
itemInfo = new ProcedureInfo(dr);
break;
case 1:
itemInfo = new SectionInfo(dr);
break;
default:
itemInfo = new StepInfo(dr);
break;
}
itemInfo.AddContent(dr);
itemInfo._SearchDVPath = dr.GetString("DVPath");
itemInfo._SearchPath = dr.GetString("Path");
IsReadOnly = false;
this.Add(itemInfo);
IsReadOnly = true;
}
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
this.RaiseListChangedEvents = true;
}
#endregion
}
#endregion
#region new class TransitionLookup
public delegate ProcedureInfo TransitionLookupEvent(object sender, TransitionLookupEventArgs args);
public class TransitionLookupEventArgs
{
private int _ProcID;
public int ProcID
{
get { return _ProcID; }
set { _ProcID = value; }
}
private int _UnitID;
public int UnitID
{
get { return _UnitID; }
set { _UnitID = value; }
}
private DocVersionInfo _MyDocVersion;
public DocVersionInfo MyDocVersion
{
get { return _MyDocVersion; }
set { _MyDocVersion = value; }
}
private TransitionLookup _MyTranLookup;
public TransitionLookup MyTranLookup
{
get { return _MyTranLookup; }
set { _MyTranLookup = value; }
}
public TransitionLookupEventArgs(int procID, int unitID, DocVersionInfo dvi, TransitionLookup tl)
{
_ProcID = procID;
_UnitID = unitID;
_MyDocVersion = dvi;
_MyTranLookup = tl;
}
}
public partial class TransitionLookup
{
public event TransitionLookupEvent NewLookupNeeded;
private Dictionary<int, Dictionary<int, ItemInfo>> _MyLookups;
public Dictionary<int, Dictionary<int, ItemInfo>> MyLookups
{
get { return _MyLookups; }
set { _MyLookups = value; }
}
private int _ApplicabilityUnit;
public int ApplicabilityUnit
{
get { return _ApplicabilityUnit; }
set { _ApplicabilityUnit = value; }
}
public TransitionLookup(int applicabilityUnit, int procID, Dictionary<int, ItemInfo> mylookup)
{
_MyLookups = new Dictionary<int, Dictionary<int, ItemInfo>>();
_MyLookups.Add(procID, mylookup);
_ApplicabilityUnit = applicabilityUnit;
}
public void AddProcLookup(int procID, Dictionary<int, ItemInfo> mylookup)
{
if (!_MyLookups.ContainsKey(procID))
{
_MyLookups.Add(procID, mylookup);
//Console.WriteLine("AddProcLookup: {0}", procID);
}
}
public ItemInfo this[int itemID]
{
get
{
foreach (Dictionary<int, ItemInfo> mylookup in MyLookups.Values)
{
if (mylookup != null && mylookup.ContainsKey(itemID))
return mylookup[itemID];
}
return null;
}
}
public bool ContainsKey(int itemID)
{
foreach (Dictionary<int, ItemInfo> mylookup in MyLookups.Values)
{
if (mylookup != null && mylookup.ContainsKey(itemID))
return true;
}
return false;
}
}
#endregion
#region ProcedureInfo
[Serializable()]
public partial class ProcedureInfo : ItemInfo, IVEDrillDownReadOnly
{
private bool? _ProcHasSupInfoData = null;
public bool ProcHasSupInfoData
{
get
{
if (_ProcHasSupInfoData == null)
{
_ProcHasSupInfoData = GetProcHasSupInfoData();
}
return (bool)_ProcHasSupInfoData;
}
set { _ProcHasSupInfoData = value; }
}
private bool GetProcHasSupInfoData()
{
if (Sections != null) // B2017-145 If no sections don't check
{
foreach (SectionInfo mySection in Sections)
{
if (mySection.MyDocStyle.SupplementalInformation && mySection.HasSupInfoSteps) return true;
}
}
return false;
}
public bool CreateEnhanced = false;
public string PDFNumber
{
get
{
string slashReplace = this.ActiveFormat.PlantFormat.FormatData.PrintData.SlashReplace ?? "_";
return DisplayNumber.Replace("/", slashReplace).Replace("\\", slashReplace).Replace("*", "Master");
}
}
private DateTime? _ChangeBarDate = null;
public DateTime ChangeBarDate
{
get
{
if (_ChangeBarDate == null)
{
_ChangeBarDate = DTS;
string cbDTS = (MyConfig as ProcedureConfig).Print_ChangeBarDate;
if ((cbDTS ?? "") != "")
_ChangeBarDate = DateTime.Parse(cbDTS);
}
return (DateTime)_ChangeBarDate;
}
set { _ChangeBarDate = value; }
}
public Dictionary<int, ItemInfo> MyLookup = null;
public override void SetupTags()
{
base.SetupTags();
}
protected override void RefreshFields(Item tmp)
{
base.RefreshFields(tmp);
ExtensionRefreshFields(tmp);
_ChangeBarDate = null;
_ProcedureConfig = null;
}
#if ItemWithContent
public ProcedureInfo(SafeDataReader dr) : base(dr, true) { }
#else
public ProcedureInfo(SafeDataReader dr) : base(dr) { }
#endif
private ProcedureInfo() : base() { ;}
public new static ProcedureInfo Get(int itemID)
{
//if (!CanGetObject())
// throw new System.Security.SecurityException("User not authorized to view a Item");
try
{
ProcedureInfo tmp = GetCachedByPrimaryKey(itemID);
if (tmp == null)
{
tmp = DataPortal.Fetch<ProcedureInfo>(new PKCriteria(itemID));
AddToCache(tmp);
}
if (tmp.ErrorMessage == "No Record Found") tmp = null;
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on Item.Get", ex);
}
}
protected new static ProcedureInfo GetCachedByPrimaryKey(int itemID)
{
ConvertListToDictionary();
string key = itemID.ToString();
if (_CacheByPrimaryKey.ContainsKey(key))
foreach (ItemInfo ii in _CacheByPrimaryKey[key])
if (ii is ProcedureInfo)
return ii as ProcedureInfo;
return null;
}
public void MoveProcedure(IVEDrillDownReadOnly pInfo, int index)
{
MoveItem(pInfo, index);
//using (Item ii = Item.Get(this.ItemID))
//{
// ii.MoveItem(pInfo, index);
//}
}
public new Procedure Get()
{
return (Procedure)(_Editable = Procedure.Get(ItemID));
}
//public static void RefreshTransitions(ProcedureInfo tmp)
//{
// RefreshTransitions(tmp, null, null);
//}
public static void RefreshTransitions(ProcedureInfo tmp)//, TransitionInfoList transitionToDisconnected, TransitionInfoList transitionsToNonEditable)
{
//TransitionsToDisconnected = transitionToDisconnected;
//TransitionsToNonEditable = transitionsToNonEditable;
TransitionLookup tranLookup = new TransitionLookup(0, tmp.ItemID, tmp.MyLookup);
tranLookup.ApplicabilityUnit = tmp.MyDocVersion.DocVersionConfig.SelectedSlave;
tranLookup.NewLookupNeeded += new TransitionLookupEvent(GetNewLookup);
if (tmp.MyDocVersion.DocVersionConfig.SelectedSlave <= 0)
MyRefreshTransitions(tmp, tmp.MyDocVersion, null, tmp, tmp.MyDocVersion, tranLookup);
}
public static void RefreshReferenceObjects(ProcedureInfo tmp)
{
if (tmp.MyDocVersion.DocVersionConfig.SelectedSlave <= 0)
MyRefreshReferenceObjects(tmp, tmp.MyDocVersion, null, tmp.MyDocVersion);
}
public static void RefreshPageNumTransitions(ProcedureInfo tmp)
{
TransitionLookup tranLookup = new TransitionLookup(0, tmp.ItemID, tmp.MyLookup);
tranLookup.ApplicabilityUnit = tmp.MyDocVersion.DocVersionConfig.SelectedSlave;
tranLookup.NewLookupNeeded += new TransitionLookupEvent(GetNewLookup);
SetParentSectionAndDocVersionPageNum(tmp, tmp.MyDocVersion, null, tmp, tmp.MyDocVersion, tranLookup);
}
public void ClearChangeBarOverrides()
{
try
{
using (ContentInfoList cil = ContentInfoList.GetClearedCBOverrides(ItemID))
{
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);
}
}
}
}
catch (Exception ex)
{
throw new DbCslaException("Error on ProcedureInfo:ClearChangeBarOverrides", ex);
}
}
//jcb add 20120501 item and children by unit
public static ProcedureInfo GetItemAndChildrenByUnit(int? itemID, int? parentID, int? unitID)
{
try
{
ProcedureInfo tmp = DataPortal.Fetch<ProcedureInfo>(new ItemAndChildrenByUnitCriteria(itemID, parentID, unitID));
AddToCache(tmp);
if (tmp.ErrorMessage == "No Record Found") tmp = null;
if (tmp != null)
{
tmp.MyDocVersion.DocVersionConfig.SelectedSlave = (int)unitID;
(tmp.MyConfig as ProcedureConfig).SelectedSlave = (int)unitID;
TransitionLookup tranLookup = new TransitionLookup((int)unitID, (int)itemID, tmp.MyLookup);
tranLookup.NewLookupNeeded += new TransitionLookupEvent(GetNewLookup);
//ItemInfo.ResetTicks();
//DateTime dt = DateTime.Now;
tmp.FromType = E_FromType.Procedure;
SetFromType(tmp);
SetParentSectionAndDocVersion(tmp, tmp.MyDocVersion, null, tmp.MyDocVersion, tranLookup);
//TimeSpan ts = DateTime.Now.Subtract(dt);
//ticksItems = ts.Ticks - (ticksROUsage + ticksTrans);
//ItemInfo.ShowTicks();
}
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
}
}
public static ProcedureInfo GetNewLookup(object sender, TransitionLookupEventArgs args)
{
ProcedureInfo tmp = DataPortal.Fetch<ProcedureInfo>(new ItemAndChildrenByUnitCriteria(args.ProcID, 0, args.UnitID));
if (tmp.MyDocVersion != null)
{
//if (tmp.MyDocVersion.VersionID == args.MyDocVersion.VersionID)
//{
// args.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitID;
// (tmp.MyConfig as ProcedureConfig).SelectedSlave = args.UnitID;
// ItemInfo.SetParentSectionAndDocVersion(tmp, args.MyDocVersion, null, tmp, args.MyDocVersion);
//}
//else
//{
tmp.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitID;
(tmp.MyConfig as ProcedureConfig).SelectedSlave = args.UnitID;
tmp.FromType = E_FromType.Procedure;
SetFromType(tmp);
ItemInfo.SetParentSectionAndDocVersion(tmp, tmp.MyDocVersion, null, tmp, tmp.MyDocVersion);
//}
}
return tmp;
}
// Criteria to get Item and children by unit
[Serializable()]
private class ItemAndChildrenByUnitCriteria
{
public ItemAndChildrenByUnitCriteria(int? itemID, int? parentID, int? unitID)
{
_ItemID = itemID;
_ParentID = parentID;
_UnitID = unitID;
}
private int? _ItemID;
public int? ItemID
{
get { return _ItemID; }
set { _ItemID = value; }
}
private int? _ParentID;
public int? ParentID
{
get { return _ParentID; }
set { _ParentID = value; }
}
private int? _UnitID;
public int? UnitID
{
get { return _UnitID; }
set { _UnitID = value; }
}
}
// Data Portal to Get Item and Children by unit
private void DataPortal_Fetch(ItemAndChildrenByUnitCriteria criteria)
{
//ItemInfo tmp = null;
Dictionary<int, ItemInfo> lookup = new Dictionary<int, ItemInfo>(); ;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandTimeout = Database.DefaultTimeout;
cm.CommandText = "vesp_ListItemAndChildrenByUnit";
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
cm.Parameters.AddWithValue("@ParentID", criteria.ParentID);
cm.Parameters.AddWithValue("@UnitID", criteria.UnitID);
DateTime start = DateTime.Now;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
if (dr.GetInt32("Level") == 0)
{
//tmp = itemInfo;
ReadData(dr);
AddContent(dr);
lookup[this.ItemID] = this;
}
else
{
ItemInfo itemInfo = null;
int itemType = dr.GetInt32("Type") / 10000;
switch (itemType)
{
case 0:
itemInfo = new ProcedureInfo(dr);
break;
case 1:
itemInfo = new SectionInfo(dr);
break;
case 2:
itemInfo = new StepInfo(dr);
break;
}
// Load Children
itemInfo._Ordinal = dr.GetInt32("Ordinal") + 1;
itemInfo.AddContent(dr);
ItemInfo parent = lookup[dr.GetInt32("ParentID")];
itemInfo._ActiveParent = parent;
itemInfo._MyParent = parent;
itemInfo._ActiveSection = (itemInfo.IsSection ? itemInfo : parent._ActiveSection);
parent.AddPart(dr, itemInfo);
lookup.Add(itemInfo.ItemID, itemInfo);
}
}
//Console.WriteLine("I'm here {0}",this.MyContent.ContentPartCount);
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
MyLookup = lookup;
}
//jcb end add 20120501 item and children by unit
#region EnhancedProcedureRefreshTextDifferences
public ItemInfoList FindEnhancedProcedureTextDifferences()
{
// for this enhanced procedure, get a list of differences of text between it and its source document.
// Return list is list of items in ENHANCED procedure that need their text refreshed.
// first check if enhanced:
EnhancedDocuments eds = GetMyEnhancedDocuments();
if (eds == null || eds.Count == 0) return null;
if (eds[0].Type != 0) return null;
// now get its enhtype from the source:
int enhtype = -1;
ItemInfo sourceProc = ItemInfo.Get(eds[0].ItemID);
if (sourceProc == null) return null; //B2018-142 to allow an un-linked background procedure to be deleted
EnhancedDocuments sourceProcEds = sourceProc.GetMyEnhancedDocuments();
foreach (EnhancedDocument spe in sourceProcEds)
{
if (spe.ItemID == ItemID) enhtype = spe.Type;
}
if (enhtype == -1) return null; // something went wrong (it should never get to here)
// get list of differences from sql. This list does not resolve links and may have other rtf commands.
// also this list is source items, not enhanced.
ItemInfoList iil = ItemInfoList.GetListEnhancedTextDifferences(this);
if (iil == null || iil.Count == 0) return null; // no differences were found.
// from sql list, get display text of source items & compare to this procedure's items. This
// will determine true 'text' differences. Then return this list.
ItemInfoList retiil = null; // new ItemInfoList(null);
foreach (ItemInfo ii in iil)
{
EnhancedDocuments seds = ii.GetMyEnhancedDocuments();
if (seds != null && seds.Count != 0)
{
ItemInfo srcItem = ItemInfo.Get(seds[0].ItemID);
if (srcItem.DisplayTextKeepSpecialChars != ii.DisplayTextKeepSpecialChars)
{
if (retiil == null) retiil = new ItemInfoList(ii);
else retiil.AddItem(ii);
}
}
}
return retiil;
}
public void EnhancedProcedureRefreshTextDifferences(ItemInfoList iil)
{
// the input list is a list of enhanced items within a procedure where
// the text is different between the source and this enhanced item. Refresh
// the text in the enhanced item based on the displaytext of the source item.
foreach (ItemInfo ii in iil)
{
EnhancedDocuments seds = ii.GetMyEnhancedDocuments();
if (seds != null && seds.Count != 0)
{
ItemInfo srcItem = ItemInfo.Get(seds[0].ItemID);
using (Item enhItem = Item.Get(ii.ItemID))
{
enhItem.MyContent.Text = srcItem.DisplayTextKeepSpecialChars;
enhItem.Save();
}
}
}
return;
}
#endregion // EnhancedProcedureRefreshTextDifferences
#region ProcedureConfig
[NonSerialized]
private ProcedureConfig _ProcedureConfig;
public ProcedureConfig ProcedureConfig
{
get
{
if (_ProcedureConfig == null)
{
_ProcedureConfig = new ProcedureConfig(this);
this.MyContent.Changed += new ContentInfoEvent(MyContent_Changed);
}
return _ProcedureConfig;
// return (_ProcedureConfig != null ? _ProcedureConfig : _ProcedureConfig = new ProcedureConfig(this));
}
}
void MyContent_Changed(object sender)
{
this.MyContent.Changed += new ContentInfoEvent(MyContent_Changed);
}
#endregion
public new ConfigDynamicTypeDescriptor MyConfig
{
get { return ProcedureConfig; }
set { _ProcedureConfig = null; }
}
public DocVersionInfo MyDocVersion
{
get { return ActiveParent as DocVersionInfo; }
}
public static ProcedureInfo GetItemAndChildren(int? itemID)
{
try
{
ProcedureInfo tmp = DataPortal.Fetch<ProcedureInfo>(new ItemAndChildrenCriteria(itemID));
//AddToCache(tmp);
if (tmp.ErrorMessage == "No Record Found") tmp = null;
if (tmp != null)
{
int profileDepth = ProfileTimer.Push(">>>> SetParentSectionAndDocVersion");
tmp.FromType = E_FromType.Procedure;
SetFromType(tmp);
SetParentSectionAndDocVersion(tmp, tmp.MyDocVersion, null, tmp, tmp.MyDocVersion);
ProfileTimer.Pop(profileDepth);
}
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
}
}
[Serializable()]
private class ItemAndChildrenCriteria
{
public ItemAndChildrenCriteria(int? itemID)
{
_ItemID = itemID;
}
private int? _ItemID;
public int? ItemID
{
get { return _ItemID; }
set { _ItemID = value; }
}
}
// Data Portal to Get Item and Children
private void DataPortal_Fetch(ItemAndChildrenCriteria criteria)
{
//ItemInfo tmp = null;
Dictionary<int, ItemInfo> lookup = new Dictionary<int, ItemInfo>(); ;
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cm = cn.CreateCommand())
{
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "vesp_ListItemAndChildren";
cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
cm.Parameters.AddWithValue("@ParentID", 0);
cm.CommandTimeout = Database.DefaultTimeout;
using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
{
while (dr.Read())
{
if (dr.GetInt32("Level") == 0)
{
//tmp = itemInfo;
ReadData(dr);
AddContent(dr);
lookup[this.ItemID] = this;
}
else
{
ItemInfo itemInfo = null;
int itemType = dr.GetInt32("Type") / 10000;
switch (itemType)
{
case 0:
itemInfo = new ProcedureInfo(dr);
break;
case 1:
itemInfo = new SectionInfo(dr);
break;
case 2:
itemInfo = new StepInfo(dr);
break;
}
// Load Children
itemInfo.AddContent(dr);
ItemInfo parent = lookup[dr.GetInt32("ParentID")];
itemInfo._ActiveParent = parent;
itemInfo._ActiveSection = (itemInfo.IsSection ? itemInfo : parent._ActiveSection);
parent.AddPart(dr, itemInfo);
lookup.Add(itemInfo.ItemID, itemInfo);
}
}
//Console.WriteLine("I'm here {0}",this.MyContent.ContentPartCount);
}
}
}
}
catch (Exception ex)
{
Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
}
MyLookup = lookup;
}
}
[Serializable()]
public class ProcedureTransitionsCountCommand : CommandBase
{
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
private int _ProcedureTransitionsCount;
public int ProcedureTransitionsCount
{
get { return _ProcedureTransitionsCount; }
}
private int _ItemID;
public int ItemID
{
get { return _ItemID; }
set { _ItemID = value; }
}
#region Factory Methods
public static int Execute(int itemID)
{
ProcedureTransitionsCountCommand cmd = new ProcedureTransitionsCountCommand();
cmd.ItemID = itemID;
cmd = DataPortal.Execute<ProcedureTransitionsCountCommand>(cmd);
return cmd.ProcedureTransitionsCount;
}
private ProcedureTransitionsCountCommand()
{ /* require use of factory methods */ }
#endregion
#region Server-Side code
protected override void DataPortal_Execute()
{
try
{
using (SqlConnection cn = Database.VEPROMS_SqlConnection)
{
using (SqlCommand cmd = new SqlCommand("vesp_ProcedureTransitionsCount", cn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandTimeout = Database.SQLTimeout;
cmd.Parameters.AddWithValue("ItemID", _ItemID);
_ProcedureTransitionsCount = (int)cmd.ExecuteScalar();
}
}
}
catch (Exception ex)
{
if (_MyLog.IsErrorEnabled) _MyLog.Error("ProcedureTransitionsCountCommand Error", ex);
throw new ApplicationException("Failure on ProcedureTransitionsCountCommand", ex);
}
}
#endregion
}
#endregion
#region Procedure
[Serializable()]
public partial class Procedure : Item
{
public ProcedureInfo MyProcedureInfo /* Return Info version of the current Item */
{ get { return ProcedureInfo.Get(ItemID); } }
public new static Procedure Get(int itemID)
{
if (!CanGetObject())
throw new System.Security.SecurityException("User not authorized to view a Item");
try
{
Item itm = GetCachedByPrimaryKey(itemID);
Procedure tmp = itm as Procedure;
//Procedure tmp = (Procedure)GetExistingByPrimaryKey(itemID);
if (tmp == null)
{
tmp = DataPortal.Fetch<Procedure>(new PKCriteria(itemID));
AddToCache(tmp);
}
if (tmp.ErrorMessage == "No Record Found") tmp = null;
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on Item.Get", ex);
}
}
public new Procedure Save()
{
return (Procedure)base.Save();
}
public static Procedure MakeProcedure(IVEDrillDownReadOnly parentInfo, ItemInfo previousInfo, string procNumber, string procTitle, int procType)
{
int newitemid = MakeNewItem(parentInfo, previousInfo, procNumber, procTitle, procType, E_FromType.Procedure);
return Procedure.Get(newitemid);
}
#region ProcedureConfig
[NonSerialized]
private ProcedureConfig _ProcedureConfig;
public ProcedureConfig ProcedureConfig
{
get
{
if (_ProcedureConfig == null)
{
_ProcedureConfig = new ProcedureConfig(this);
_ProcedureConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_ProcedureConfig_PropertyChanged);
}
return _ProcedureConfig;
}
}
private void _ProcedureConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
MyContent.Config = _ProcedureConfig.ToString();
}
#endregion
}
#endregion
#region SectionInfo
[Serializable()]
public partial class SectionInfo : ItemInfo, IVEDrillDownReadOnly
{
// B2017-192: The two dictionaries were introduced so that the lists off of the section were always found
// by the print code that determines what sup info steps go on the facing pages (the code was accessing the
// incorrect cached step section sometimes, so the list was not found.
// Keeps track of itemids for supplemental info steps where their associated steps would have page breaks.
private static Dictionary<int, List<int>> _LookupStepSectPageBreaksForSupInfo = new Dictionary<int, List<int>>();
public static void ResetLookupStepSectPageBreaksForSupInfo()
{
_LookupStepSectPageBreaksForSupInfo.Clear();
}
public List<int> StepSectPageBreaksForSupInfo
{
get
{
if (!_LookupStepSectPageBreaksForSupInfo.ContainsKey(ItemID)) _LookupStepSectPageBreaksForSupInfo.Add(ItemID, new List<int>());
return _LookupStepSectPageBreaksForSupInfo[ItemID];
}
}
// Keeps track of step section itemids where page breaks occur
private static Dictionary<int, List<int>> _LookupStepSectPageBreaks = new Dictionary<int, List<int>>();
public static void ResetLookupStepSectPageBreaks()
{
_LookupStepSectPageBreaks.Clear();
}
public List<int> StepSectPageBreaks
{
get
{
if (!_LookupStepSectPageBreaks.ContainsKey(ItemID)) _LookupStepSectPageBreaks.Add(ItemID, new List<int>());
return _LookupStepSectPageBreaks[ItemID];
}
}
// Determine if this section contains any Supplemental information steps. This is used for print to determine
// whether some of the supinfo processing needs to occur.
private bool? _HasSupInfoSteps = null;
public bool HasSupInfoSteps
{
get
{
if (_HasSupInfoSteps == null)
{
_HasSupInfoSteps = GetSupInfoSteps(this);
}
return (bool)_HasSupInfoSteps;
}
set { _HasSupInfoSteps = value; }
}
private static bool GetSupInfoSteps(ItemInfo ii)
{
if (ii.SupInfos != null && ii.SupInfos.Count > 0) return true;
if (ii.MyContent.ContentParts != null)
foreach (PartInfo pi in ii.MyContent.ContentParts)
foreach (ItemInfo iic in pi.MyItems)
if (GetSupInfoSteps(iic)) return true;
return false;
}
private bool? _HasStepCheckOffs = null;
public bool HasStepCheckOffs
{
get
{
if (_HasStepCheckOffs == null)
{
_HasStepCheckOffs = GetStepCheckOff(this);
//Console.WriteLine("{0},'{1}','{2}'", ItemID, ShortPath, _HasStepCheckOffs);
}
return (bool)_HasStepCheckOffs;
}
}
public bool HasInitials
{
get
{
SectionConfig sectCfg = MyConfig as SectionConfig;
int sc = sectCfg.Section_CheckoffListSelection;
return (sc > 1 || HasStepCheckOffs);
}
}
private static bool GetStepCheckOff(ItemInfo ii)
{
if (ii is StepInfo && ((ii as StepInfo).MyConfig as StepConfig).Step_CheckOffIndex > 1) return true;
if (ii.MyContent.ContentParts != null)
foreach (PartInfo pi in ii.MyContent.ContentParts)
foreach (ItemInfo iic in pi.MyItems)
if (GetStepCheckOff(iic)) return true;
return false;
}
//private int? _TemplateColumnMode
public override void SetupTags()
{
_MyTab = new Tab(ActiveFormat.PlantFormat.FormatData.SectData.SectionNumber.Font);
string sectTab = GetSectionTab(false);
_MyTab.Text = sectTab;
_MyTab.CleanText = sectTab.PadRight(20);
MyHeader = new MetaTag(ActiveFormat.PlantFormat.FormatData.SectData.SectionHeader.Font);
_MyHeader.Text = null;
MyFooter = null;
_TagsSetup = true;
}
private string GetSectionTab(bool underline)
{
if (DisplayNumber == null || DisplayNumber == "" || !IsStepSection) return DisplayNumber;
if (MyDocStyle.SpecialStepsFoldout) return DisplayNumber;
if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.TieTabToLevel)
{
if (underline)
return @"\ul " + DisplayNumber + @"\ul0 ";
else
return DisplayNumber;
}
// if displaynumber ends with a '.', don't worry about catching the condition that a tab can be made such as
// 'x. x', i.e. space between the . and the rest of tab. This was added for BGEEOPs.
if (DisplayNumber.LastIndexOf('.') == DisplayNumber.Length - 1) return DisplayNumber;
string retStr = null;
string ch = DisplayNumber != null && DisplayNumber != "" ? DisplayNumber.Substring(0, 1) : null;
int Snum = GetSectionNum();
if (Snum == -1)
{
if (ch[0] == ' ') ch = DisplayNumber != null && DisplayNumber.TrimStart() != "" ? DisplayNumber.TrimStart().Substring(0, 1) : null;
retStr = ch + ".";
}
else if (Snum == -2) // -2 flags to just use display number as is, don't prepend the parent's number.
{
string tmp = DisplayNumber.Trim();
if (underline)
retStr = @"\ul " + DisplayNumber.Trim() + @"\ul0 ";
else
retStr = DisplayNumber.Trim();
}
else
{
string tmp = DisplayNumber.IndexOf(".") > -1 ? DisplayNumber.Substring(0, DisplayNumber.IndexOf(".")) : DisplayNumber;
if (underline)
retStr = @"\ul " + tmp + "." + Snum.ToString() + @"\ul0 ";
else
retStr = tmp + "." + Snum.ToString();
}
return retStr;
}
private int GetSectionNum()
{
int indx = -1;
if (DisplayNumber != null && DisplayNumber != "" && (indx = DisplayNumber.IndexOf(".")) > -1)
{
// if there is a number after the '.', return it as a number. For example if it is 001, return a 1:
string tmpstr = indx + 1 < DisplayNumber.Length ? DisplayNumber.Substring(indx + 1) : null;
// if the section's tab is a letter, we don't want a 0 on the section.... for example A.0.
if (IsSection && tmpstr == null && System.Char.IsLetter(DisplayNumber.TrimStart(), 0)) return -1;
if (tmpstr != null && tmpstr.IndexOf('-') >= 0) return -1;
if (tmpstr == null) return 0;
Int32 x;
if (Int32.TryParse(tmpstr, out x)) return x;
// flag the case where the current section's tab already has prefixed in the parent's tab:
// (without this, BGE's section headers were coming up as 6.1.6.1.1...)
if (IsSection && ActiveParent.IsSection)
{
if (DisplayNumber.StartsWith((ActiveParent as SectionInfo).DisplayNumber.Trim())) return -2;
}
return -1;
}
return (-1);
}
public bool TrueSectionNum()
{
int indx = DisplayNumber.IndexOf(".");
if (indx < 0 || indx + 1 == DisplayNumber.Length) return false;
// for it to be a 'TrueSectionNum', there can be no letters after the '.'
for (int lindx = indx + 1; lindx < DisplayNumber.Length - 1; lindx++) if (DisplayNumber[lindx] < '0' || DisplayNumber[lindx] > '9') return false;
return true;
}
// the following returns the 'index' into the format's CheckOffHeaderList.
// It returns a -1 if not set or none exist.
public int CheckOffHeadingIndex()
{
if (ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList == null || ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList.MaxIndex == 0) return -1;
SectionConfig sc = MyConfig as SectionConfig;
if (sc == null) return -1;
return sc.Section_CheckoffHeaderSelection;
}
public bool IsSeparatePagination()
{
VEPROMS.CSLA.Library.SectionConfig.SectionPagination sp = VEPROMS.CSLA.Library.SectionConfig.SectionPagination.Separate;
try
{
if (SectionConfig != null) sp = SectionConfig.Section_Pagination;
}
catch (Exception ex)
{
sp = VEPROMS.CSLA.Library.SectionConfig.SectionPagination.Separate;
}
if (sp == VEPROMS.CSLA.Library.SectionConfig.SectionPagination.Separate) return true;
return false;
}
protected override void RefreshFields(Item tmp)
{
base.RefreshFields(tmp);
ExtensionRefreshFields(tmp);
}
#if ItemWithContent
public SectionInfo(SafeDataReader dr) : base(dr, true) { }
#else
public SectionInfo(SafeDataReader dr) : base(dr) { }
#endif
private SectionInfo() : base() { ;}
public new static SectionInfo Get(int itemID)
{
//if (!CanGetObject())
// throw new System.Security.SecurityException("User not authorized to view a Item");
try
{
SectionInfo tmp = GetCachedByPrimaryKey(itemID);
if (tmp == null)
{
tmp = DataPortal.Fetch<SectionInfo>(new PKCriteria(itemID));
AddToCache(tmp);
}
if (tmp.ErrorMessage == "No Record Found") tmp = null;
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on Item.Get", ex);
}
}
protected new static SectionInfo GetCachedByPrimaryKey(int itemID)
{
ConvertListToDictionary();
string key = itemID.ToString();
if (_CacheByPrimaryKey.ContainsKey(key))
foreach (ItemInfo ii in _CacheByPrimaryKey[key])
if (ii is SectionInfo)
return ii as SectionInfo;
return null;
}
public void MoveSection(IVEDrillDownReadOnly pInfo, int index)
{
MoveItem(pInfo, index);
//using (Item ii = Item.Get(this.ItemID))
//{
// ii.MoveItem(pInfo, index);
//}
}
public new Section Get()
{
return (Section)(_Editable = Section.Get(ItemID));
}
#region SectionConfig
[NonSerialized]
private SectionConfig _SectionConfig;
public SectionConfig SectionConfig
{ get { return (_SectionConfig != null ? _SectionConfig : _SectionConfig = new SectionConfig(this)); } }
#endregion
public new ConfigDynamicTypeDescriptor MyConfig
{
get { return SectionConfig; }
set { _SectionConfig = null; }
}
}
#endregion
#region Section
[Serializable()]
public partial class Section : Item
{
public SectionInfo MySectionInfo /* Return Info version of the current Item */
{ get { return SectionInfo.Get(ItemID); } }
public new static Section Get(int itemID)
{
if (!CanGetObject())
throw new System.Security.SecurityException("User not authorized to view a Item");
try
{
Section tmp = GetCachedByPrimaryKey(itemID) as Section;
if (tmp == null)
{
tmp = DataPortal.Fetch<Section>(new PKCriteria(itemID));
AddToCache(tmp);
}
if (tmp.ErrorMessage == "No Record Found") tmp = null;
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on Item.Get", ex);
}
}
public new Section Save()
{
return (Section)base.Save();
}
public static Section MakeSection(IVEDrillDownReadOnly parentInfo, ItemInfo previousInfo, string sectNumber, string sectTitle, int sectType)
{
int newitemid = MakeNewItem(parentInfo, previousInfo, sectNumber, sectTitle, sectType, E_FromType.Section);
return Section.Get(newitemid);
}
#region SectionConfig
[NonSerialized]
private SectionConfig _SectionConfig;
public SectionConfig SectionConfig
{
get
{
if (_SectionConfig == null)
{
_SectionConfig = new SectionConfig(this);
_SectionConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_SectionConfig_PropertyChanged);
}
return _SectionConfig;
}
}
private void _SectionConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
MyContent.Config = _SectionConfig.ToString();
}
#endregion
}
#endregion
#region StepInfo
[Serializable()]
public partial class StepInfo : ItemInfo
{
#region StepConfig
private StepConfig _StepConfig;
public StepConfig StepConfig
{ get { return (_StepConfig != null ? _StepConfig : _StepConfig = new StepConfig(this)); } }
#endregion
#region Tab
public override void SetupTags()
{
_TagsSetup = true;
// B2016-160 Support transitions to sections
VE_Font fnt = new VE_Font("Arial", 10, E_Style.None, 10);
if (FormatStepData != null) fnt = FormatStepData.TabData.Font;
_MyTab = new Tab(AdjustForTextSubFollowsTextStyle(fnt));
MyHeader = new MetaTag(fnt);
MyFooter = new MetaTag(fnt);
SetTabText();
}
#endregion
protected override void RefreshFields(Item tmp)
{
base.RefreshFields(tmp);
ExtensionRefreshFields(tmp);
}
//public override string ToString()
//{
// return "Step " + base.ToString();
//}
#if ItemWithContent
public StepInfo(SafeDataReader dr) : base(dr, true) { }
#else
public StepInfo(SafeDataReader dr) : base(dr) { }
#endif
private StepInfo() : base() { ;}
public new static StepInfo Get(int itemID)
{
//if (!CanGetObject())
// throw new System.Security.SecurityException("User not authorized to view a Item");
try
{
StepInfo tmp = GetCachedByPrimaryKey(itemID);
if (tmp == null)
{
tmp = DataPortal.Fetch<StepInfo>(new PKCriteria(itemID));
AddToCache(tmp);
}
if (tmp.ErrorMessage == "No Record Found") tmp = null;
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on Item.Get", ex);
}
}
protected new static StepInfo GetCachedByPrimaryKey(int itemID)
{
ConvertListToDictionary();
string key = itemID.ToString();
if (_CacheByPrimaryKey.ContainsKey(key))
foreach (ItemInfo ii in _CacheByPrimaryKey[key])
if (ii is StepInfo)
return ii as StepInfo;
return null;
}
public void MoveStep(IVEDrillDownReadOnly pInfo, int index)
{
MoveItem(pInfo, index);
//using (Item ii = Item.Get(this.ItemID))
//{
// ii.MoveItem(pInfo, index);
//}
}
public new Step Get()
{
return (Step)(_Editable = Step.Get(ItemID));
}
//public E_FromType FromType
//{ get { return E_FromType.Step; } }
}
#endregion
#region Step
[Serializable()]
public partial class Step : Item
{
public new static Step Get(int itemID)
{
if (!CanGetObject())
throw new System.Security.SecurityException("User not authorized to view a Item");
try
{
Step tmp = (Step)GetCachedByPrimaryKey(itemID);
if (tmp == null)
{
tmp = DataPortal.Fetch<Step>(new PKCriteria(itemID));
AddToCache(tmp);
}
if (tmp.ErrorMessage == "No Record Found") tmp = null;
return tmp;
}
catch (Exception ex)
{
throw new DbCslaException("Error on Item.Get", ex);
}
}
// TODO :MakeCaution;
// TODO :MakeNote;
// TODO :MakeRNO;
// TODO :MakeSection;
// TODO :MakeSubStep;
// TODO :MakeTable;
public static Step MakeStep(IVEDrillDownReadOnly parentInfo, ItemInfo previousInfo, string stepNumber, string stepTitle, int stepType, E_FromType fromType)
{
int newitemid = MakeNewItem(parentInfo, previousInfo, stepNumber, stepTitle, stepType, fromType);
return Step.Get(newitemid);
}
//#region StepConfig
//[NonSerialized]
//private StepConfig _StepConfig;
//public StepConfig StepConfig
//{
// get
// {
// if (_StepConfig == null)
// {
// _StepConfig = new StepConfig(this);
// _StepConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_StepConfig_PropertyChanged);
// }
// return _SectionConfig;
// }
//}
//private void _StepConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
//{
// MyContent.Config = _StepConfig.ToString();
//}
//#endregion
}
#endregion
public enum ItemSearchIncludeLinks
{
Nothing = 0,
Value = 1,
Everything = 2
}
}
Reference in New Issue View Git Blame Copy Permalink