5350 lines
166 KiB
C#
5350 lines
166 KiB
C#
#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;
|
||
|
||
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 && previousInfo.NextItems != null && previousInfo.NextItems.Count > 0)
|
||
nextInfo = previousInfo.NextItems[0];
|
||
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
|
||
{
|
||
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 SetParentSectionAndDocVersion(ItemInfo itemInfo, IVEDrillDownReadOnly itemParent, SectionInfo sectionInfo, ProcedureInfo procInfo, DocVersionInfo docVersionInfo)
|
||
{
|
||
if (itemInfo == null) return;
|
||
itemInfo.LoadAllAtOnce = true;
|
||
itemInfo.ActiveParent = itemParent;
|
||
// itemInfo.ActiveSection = (itemInfo as SectionInfo) ?? sectionInfo; - possible fix for not accessing correct format
|
||
itemInfo.ActiveSection = sectionInfo;
|
||
itemInfo.MyProcedure = procInfo;
|
||
itemInfo.MyDocVersion = docVersionInfo;
|
||
if (itemInfo.MyContent.ContentGridCount > 0)
|
||
itemInfo.MyContent.LoadNonCachedGrid();
|
||
if (itemInfo.MyContent.ContentPartCount > 0)
|
||
foreach (PartInfo pi in itemInfo.MyContent.ContentParts)
|
||
foreach (ItemInfo ii in pi.MyItems)
|
||
SetParentSectionAndDocVersion(ii, itemInfo, (itemInfo as SectionInfo) ?? sectionInfo, procInfo, docVersionInfo);
|
||
}
|
||
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);
|
||
}
|
||
}
|
||
}
|
||
//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);
|
||
//}
|
||
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.ActiveSection = (itemInfo as SectionInfo) ?? sectionInfo;
|
||
itemInfo.ActiveSection = sectionInfo;
|
||
itemInfo.MyDocVersion = docVersionInfo;
|
||
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);
|
||
ROFSTLookup.rochild roch = lookup.GetRoChild(rousage.ROID);
|
||
itemInfo.MyContent.FixContentText(rousage, roval, roch.type, rofstinfo);
|
||
}
|
||
}
|
||
}
|
||
//TimeSpan ts = DateTime.Now.Subtract(dts);
|
||
//ticksROUsage += ts.Ticks;
|
||
//dts = DateTime.Now;
|
||
if (itemInfo.MyContent.ContentPartCount > 0)
|
||
{
|
||
foreach (PartInfo pi in itemInfo.MyContent.ContentParts)
|
||
{
|
||
foreach (ItemInfo ii in pi.MyItems)
|
||
{
|
||
SetParentSectionAndDocVersion(ii, itemInfo, (itemInfo as SectionInfo) ?? sectionInfo, docVersionInfo, tranLookup);
|
||
}
|
||
}
|
||
}
|
||
//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);
|
||
}
|
||
}
|
||
//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 property tracks 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.
|
||
private int _PageNumber = 0;
|
||
public int PageNumber
|
||
{
|
||
get { return _PageNumber; }
|
||
set { _PageNumber = value; }
|
||
}
|
||
private float _MSWordPageCount = 0;
|
||
public float MSWordPageCount
|
||
{
|
||
get { 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))
|
||
foreach (ItemInfo item in _CacheByPrimaryKey[key])
|
||
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 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();
|
||
}
|
||
}
|
||
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 (parent != null && (parent.IsExactType("And") || parent.IsExactType("Or")))
|
||
level++;
|
||
|
||
// First substep, this is where it uses the orphan logic from above.
|
||
if (!item.IsRNOPart && !item.IsHigh && item.MyPrevious == null)
|
||
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;
|
||
}
|
||
// 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;
|
||
}
|
||
return level;
|
||
}
|
||
|
||
/// <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;
|
||
}
|
||
#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
|
||
public bool IsFirstCautionPart
|
||
{
|
||
get
|
||
{
|
||
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Caution));
|
||
}
|
||
}
|
||
public bool IsFirstNotePart
|
||
{
|
||
get
|
||
{
|
||
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Note));
|
||
}
|
||
}
|
||
|
||
public bool IsCautionPart
|
||
{
|
||
get
|
||
{
|
||
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Caution));
|
||
}
|
||
}
|
||
public bool IsNotePart
|
||
{
|
||
get
|
||
{
|
||
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Note));
|
||
}
|
||
}
|
||
|
||
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.Count)
|
||
{
|
||
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.Count)
|
||
{
|
||
Console.WriteLine("Error getting type - contentid = {0}", MyContent.ContentID);
|
||
return false;
|
||
}
|
||
StepData sd = sdlist[stepType];
|
||
return (sd.Type == type);
|
||
}
|
||
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 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");
|
||
}
|
||
}
|
||
public bool IsHigh
|
||
{
|
||
get
|
||
{
|
||
// check to see if ActiveParent is a section, if so it is a high level step
|
||
if (MyContent.Type / 10000 != 2) return false;
|
||
ItemInfo parent = ActiveParent as ItemInfo;
|
||
if (parent == null) return false;
|
||
// IsHigh was returning true if this item is a caution or note off of a section..
|
||
// from the (parent.MyContent.Type / 1000) == 1.
|
||
if (IsCaution || IsNote) return false;
|
||
if ((parent.MyContent.Type / 10000) == 1)
|
||
return true;
|
||
return false;
|
||
}
|
||
}
|
||
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
|
||
{
|
||
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Table));
|
||
}
|
||
}
|
||
public bool IsRNOPart
|
||
{
|
||
get
|
||
{
|
||
return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.RNO));
|
||
}
|
||
}
|
||
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;
|
||
}
|
||
}
|
||
#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
|
||
{
|
||
// 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;
|
||
}
|
||
}
|
||
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
|
||
{
|
||
int typ = (int)MyContent.Type - 20000;
|
||
foreach (StepData sd in ActiveFormat.PlantFormat.FormatData.StepDataList)
|
||
{
|
||
if (sd.Index == typ) return sd;
|
||
}
|
||
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;
|
||
while (temp.NextItems != null && temp.NextItems.Count > 0) temp = temp.NextItems[0];
|
||
return temp;
|
||
}
|
||
}
|
||
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)
|
||
{
|
||
if (sect.ItemID == fldid) return indxOfFoldout;
|
||
if (sect.DisplayText.ToUpper().StartsWith("FOLDOUT")) indxOfFoldout++;
|
||
}
|
||
return 0;
|
||
}
|
||
return -1; // does not have a foldout
|
||
}
|
||
#region More IsType
|
||
public bool IsProcedurePart
|
||
{
|
||
get
|
||
{
|
||
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Procedure));
|
||
}
|
||
}
|
||
public bool IsSectionPart
|
||
{
|
||
get
|
||
{
|
||
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Section));
|
||
}
|
||
}
|
||
public bool IsStepPart
|
||
{
|
||
get
|
||
{
|
||
return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Step));
|
||
}
|
||
}
|
||
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;
|
||
return false;
|
||
}
|
||
}
|
||
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 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 >= 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);
|
||
//return "Now is the time for all good men to come to the aid of their country!";
|
||
}
|
||
//public string ToString(string str,System.IFormatProvider ifp)
|
||
//{
|
||
// return ToString();
|
||
//}
|
||
#endregion
|
||
#region Search
|
||
internal string _SearchDVPath;
|
||
public string SearchDVPath
|
||
{
|
||
get
|
||
{
|
||
if (_SearchDVPath == null)
|
||
_SearchDVPath = ActiveParent.SearchDVPath;
|
||
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 { return ConvertToDisplayText(Regex.Replace(_SearchPath ?? "", "\x11.*?\x07", "\x07")); }
|
||
}
|
||
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 DisplayText
|
||
{
|
||
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);
|
||
}
|
||
}
|
||
public string DisplayNumber
|
||
{
|
||
get
|
||
{
|
||
string 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);
|
||
//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);
|
||
if (str.Contains("<u>"))
|
||
Console.WriteLine("it is still there");
|
||
return str;
|
||
}
|
||
//get { return ConvertToDisplayText(MyContent.Number); }
|
||
}
|
||
public static string ConvertToDisplayText(string txt)
|
||
{
|
||
string retval = txt;
|
||
retval = StripRtfFormatting(retval);
|
||
retval = StripLinks(retval);
|
||
retval = ReplaceSpecialCharacters(retval);
|
||
retval = retval.Replace("\u2011","-");
|
||
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] ?", "");
|
||
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
|
||
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 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;
|
||
_MyParent = parentContent.ContentItems[0];
|
||
}
|
||
return _MyParent;
|
||
}
|
||
}
|
||
#endregion
|
||
#region Lookups and More Related
|
||
private ItemInfoList Lookup(int fromType, ref ItemInfoList itemInfoList)
|
||
{
|
||
if (itemInfoList == null)
|
||
itemInfoList = Lookup(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;
|
||
}
|
||
private ItemInfoList _Procedures;
|
||
public ItemInfoList Procedures
|
||
{ get { return Lookup(1,ref _Procedures); } }
|
||
private ItemInfoList _Sections;
|
||
public ItemInfoList Sections
|
||
{ get { return Lookup(2,ref _Sections); } }
|
||
private ItemInfoList _Cautions;
|
||
public ItemInfoList Cautions
|
||
{ get { return Lookup(3,ref _Cautions); } }
|
||
private ItemInfoList _Notes;
|
||
public ItemInfoList Notes
|
||
{ get { return Lookup(4,ref _Notes); } }
|
||
private ItemInfoList _RNOs;
|
||
public ItemInfoList RNOs
|
||
{ get { return Lookup(5,ref _RNOs); } }
|
||
private ItemInfoList _Steps;
|
||
public ItemInfoList Steps
|
||
{ get { return Lookup(6,ref _Steps); } }
|
||
private ItemInfoList _Tables;
|
||
public ItemInfoList Tables
|
||
{ get { return Lookup(7,ref _Tables); } }
|
||
//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;
|
||
}
|
||
}
|
||
public string TabTitle
|
||
{
|
||
get
|
||
{
|
||
if (MyContent.MyEntry == null)
|
||
{
|
||
if(DisplayNumber == string.Empty)
|
||
return DisplayText.Replace("\u2011", "-").Split(" ,.;:-_".ToCharArray())[0] + "...";
|
||
return DisplayNumber.Replace("\u2011","-");
|
||
}
|
||
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", "-");
|
||
return "\u1D38\u1D35\u1D2E " + DisplayText.Replace("\u2011", "-").Split(" ,.;:-_".ToCharArray())[0] + "...";
|
||
}
|
||
if (DisplayText.Length <= 10)
|
||
return DisplayText.Replace("\u2011", "-");
|
||
return DisplayText.Replace("\u2011", "-").Split(" ,.;:-_".ToCharArray())[0]+ "...";
|
||
}
|
||
}
|
||
#endregion
|
||
#region Change Bar
|
||
public bool HasChangeBar
|
||
{
|
||
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;
|
||
// if there is no override & return whether there was a change to the text.
|
||
if (sc.Step_CBOverride == null)
|
||
return (MyContent.DTS > MyProcedure.ChangeBarDate);
|
||
else // override is on:
|
||
return (sc.Step_CBOverride == "On");
|
||
}
|
||
}
|
||
#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 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;
|
||
}
|
||
}
|
||
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 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;
|
||
}
|
||
}
|
||
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 (subtyp >= ActiveFormat.PlantFormat.DocStyles.DocStyleList.Count) return ActiveFormat.PlantFormat.DocStyles.DocStyleList[0];
|
||
_MyDocStyle = ActiveFormat.PlantFormat.DocStyles.DocStyleList[subtyp];
|
||
}
|
||
return _MyDocStyle;
|
||
}
|
||
set
|
||
{
|
||
_MyDocStyle = value;
|
||
}
|
||
}
|
||
private FormatInfo _ActiveFormat = null;
|
||
public FormatInfo ActiveFormat
|
||
{
|
||
get
|
||
{
|
||
//if (_ActiveFormat == null) // 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;
|
||
}
|
||
//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);
|
||
break;
|
||
case 1:
|
||
_MyConfig = new SectionConfig(MyContent.Config);
|
||
break;
|
||
case 2:
|
||
_MyConfig = new StepConfig(MyContent.Config);
|
||
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 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;
|
||
}
|
||
}
|
||
[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;
|
||
}
|
||
protected void SetTabText()
|
||
{
|
||
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")
|
||
{
|
||
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))
|
||
|
||
{
|
||
if (tbformat.Contains("{LNK C/N Num}"))
|
||
{
|
||
tbformat = tbformat.Replace("{LNK C/N Num}", Ordinal.ToString());
|
||
tbformat = tbformat.Replace("{LNK Step Num}", (ActiveParent as ItemInfo).Ordinal.ToString());
|
||
tbformat = tbformat.TrimStart(" ".ToCharArray());
|
||
}
|
||
if (tbformat.Contains("{LNK Step Num}"))
|
||
tbformat = tbformat.Replace("{LNK Step Num}", Ordinal.ToString().PadLeft(2));
|
||
if (tbformate != null && tbformate.Contains("{LNK Step Num}"))
|
||
tbformate = tbformate.Replace("{LNK Step Num}", 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
|
||
{
|
||
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 + CurrentSectionLevel();
|
||
doMeta = true;
|
||
}
|
||
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.Count].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))
|
||
{
|
||
// 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;
|
||
|
||
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.Count;
|
||
if (!tbformat.Contains(@"{!C"))
|
||
tbformat = seqtabs[itmp].PrintTabFormat; // seqtab in 16bit, i.e. '. or )' etc.
|
||
else
|
||
tbformat = tbformat.Replace("{seq}", seqtabs[itmp].PrintTabFormat);
|
||
string tbtoken = seqtabs[localPrintLevel % seqtabs.Count].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 = myparent.MyTab.CleanText.Trim();
|
||
if (((MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_AddDotZeroStdHLS) == E_DocStructStyle.DSS_AddDotZeroStdHLS) && myparent.MyContent.Type == 20002)
|
||
parentTab = parentTab.Replace(".0", ""); // this was added in, remove for substeps.
|
||
tbformat = parentTab + (parentTab.EndsWith(".") ? "" : ".") + tbformat.TrimStart();
|
||
}
|
||
}
|
||
|
||
|
||
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))
|
||
{
|
||
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.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;
|
||
string alpha = AlphabeticalNumbering(ordinal);
|
||
tbformat = tbformat.Replace("{alpha}", alpha.ToLower());
|
||
tbformat = tbformat.Replace("{alphaWpar}", alpha.ToLower());
|
||
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 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 = (!tbformat.Contains(".")?" ":"") + 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) 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)
|
||
{
|
||
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("<22>", @"{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:
|
||
else if ((FormatStepData.TabData.Font.Style & E_Style.Underline) == E_Style.Underline)
|
||
// 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 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;
|
||
}
|
||
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 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.StructureStyle.Style & E_DocStructStyle.DSS_SkipOneStepLevel) == E_DocStructStyle.DSS_SkipOneStepLevel)
|
||
level++;
|
||
if ((MyDocStyle.StructureStyle.Style & E_DocStructStyle.DSS_SkipTwoStepLevels) == E_DocStructStyle.DSS_SkipTwoStepLevels && level == 0)
|
||
level += 2;
|
||
if (level < 0) level = 0;
|
||
return level;
|
||
}
|
||
public int CurrentSectionLevel()
|
||
{
|
||
int countlev = 0;
|
||
if ((MyActiveSection.MyDocStyle.StructureStyle.Style ?? 0 & E_DocStructStyle.DSS_TreatAsTrueSectNum) != 0)
|
||
{
|
||
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.
|
||
int subsection = CurrentSectionLevel();
|
||
if (subsection >= 1)
|
||
{
|
||
string tmptab = ActiveSection.MyTab.CleanText.TrimEnd();
|
||
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);
|
||
}
|
||
if (NextItem != null)
|
||
{
|
||
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 && NextItem == null) || 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 (this.NextItem == null)
|
||
tbformat = "";
|
||
}
|
||
if (!this.FormatStepData.SeparateBox &&
|
||
(tbformat == nextTbFormat || tbformat == prevTbFormat))
|
||
{
|
||
tbformat = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB;
|
||
TabToIdentBAdjustFont();
|
||
}
|
||
|
||
}
|
||
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)))
|
||
{
|
||
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()
|
||
{
|
||
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;
|
||
// originally the code would do double alpha as 'aa', 'ab', 'ac'. This was changed to do 'aa',
|
||
// 'bb', 'cc'. The Westinghouse work required this and 16bit was tested and it worked the
|
||
// same way as the Westinghouse requirement. The original code to do 'aa', 'ab' was left here,
|
||
// commented out, in case a future plant needs it and then should tie it to a format flag.
|
||
// Changed logic to support 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 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
|
||
public bool IsInTemplate()
|
||
{
|
||
if (IsStep && FormatStepData.MyFormat.PlantFormat.FormatData.TopTemplateTypes.ContainsKey((int)MyContent.Type - 20001)) return true;
|
||
return false;
|
||
}
|
||
public int GetSmartTemplateTopLevelIndxOfThisType(int oftype)
|
||
{
|
||
if (FormatStepData == null) return -1;
|
||
FormatData formatData = FormatStepData.MyFormat.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()
|
||
{
|
||
FormatData formatData = FormatStepData.MyFormat.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 = FormatStepData.MyFormat.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.
|
||
}
|
||
#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.Count <= 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;
|
||
if (pd.CheckOffData == null || pd.CheckOffData.CheckOffList == null || pd.CheckOffData.CheckOffList.Count <= 0) return false;
|
||
if (pd.CheckOffData.CheckOffHeaderList == null || pd.CheckOffData.CheckOffHeaderList.Count <= 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;
|
||
if (pd.CheckOffData != null && pd.CheckOffData.CheckOffList != null && pd.CheckOffData.CheckOffList.Count == 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) return ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList[stpCoIndx];
|
||
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;
|
||
if (pd.CheckOffData != null && pd.CheckOffData.CheckOffList != null && pd.CheckOffData.CheckOffList.Count == 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 || 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 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, "");
|
||
}
|
||
}
|
||
|
||
}
|
||
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 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 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));
|
||
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 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
|
||
}
|
||
#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
|
||
{
|
||
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);
|
||
}
|
||
#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 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);
|
||
}
|
||
//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;
|
||
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)
|
||
{
|
||
tmp.MyDocVersion.DocVersionConfig.SelectedSlave = args.UnitID;
|
||
(tmp.MyConfig as ProcedureConfig).SelectedSlave = args.UnitID;
|
||
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.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 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)
|
||
SetParentSectionAndDocVersion(tmp, tmp.MyDocVersion, null, tmp, tmp.MyDocVersion);
|
||
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);
|
||
}
|
||
}
|
||
}
|
||
#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
|
||
{
|
||
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;
|
||
}
|
||
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
|
||
{
|
||
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;
|
||
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.Count == 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 Tab
|
||
public override void SetupTags()
|
||
{
|
||
_TagsSetup = true;
|
||
_MyTab = new Tab(AdjustForTextSubFollowsTextStyle(FormatStepData.TabData.Font));
|
||
MyHeader = new MetaTag(FormatStepData.TabData.Font);
|
||
MyFooter = new MetaTag(FormatStepData.TabData.Font);
|
||
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
|
||
}
|
||
}
|