78add0ccd2
Changed Through Transition Format and User Interface Added Automatic Print Options to shutoff DebugText (/NT), DebugPagination (/NP) and Compare (/NC) Added logic to allow the use of the default path for PDFs. Update the Print_PDFLocation property of the Working Draft when the user changes the value on the Working Draft property page. Fixed Bug B2013-117 Set the date/time stamp for the Document based upon the current time. Make sure that the output is set to Final without revisions and comments before ROs are replaced. Added function to restore valid previous version of MSWord document if the current version is not a valid document. Check for Null to eliminate errors. Removed Unused field DocPDF Support MSWord document restore function. Add check for Transition Node count before updating values. Restore latest valid MSWord document if the current version is not valid. Eliminate File Commands so that the user can only close the MSWord section, and then verify if the changes to the document will be saved.
5020 lines
151 KiB
C#
5020 lines
151 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 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 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 = sectionInfo;
|
||
itemInfo.MyProcedure = procInfo;
|
||
itemInfo.MyDocVersion = docVersionInfo;
|
||
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 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 = sectionInfo;
|
||
itemInfo.MyDocVersion = docVersionInfo;
|
||
ROFstInfo rofstinfo = docVersionInfo.DocVersionAssociations[0].MyROFst;
|
||
rofstinfo.docVer = docVersionInfo;
|
||
ROFSTLookup lookup = rofstinfo.ROFSTLookup;
|
||
lookup.DocVersionInfo = docVersionInfo;
|
||
//DateTime dts = DateTime.Now;
|
||
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; }
|
||
}
|
||
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 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;
|
||
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 = 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
|
||
{
|
||
if (IsSection && 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;
|
||
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;
|
||
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);
|
||
break;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Console.WriteLine("GetItemFont(): {0} - {1}", ex.GetType(), ex.Message);
|
||
}
|
||
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;
|
||
}
|
||
#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;
|
||
if (IsParagraph && !IsSequential)
|
||
{
|
||
_MyTab.Text = "";
|
||
_MyTab.CleanText = "";
|
||
return;
|
||
}
|
||
int stepType = (int)(MyContent.Type % 10000);
|
||
string tbformat = IsInRNO ? FormatStepData.TabData.RNOIdentPrint : FormatStepData.TabData.IdentPrint;
|
||
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());
|
||
}
|
||
// 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).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)
|
||
{
|
||
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)
|
||
{
|
||
parentTab = myparent.MyTab.CleanText.Trim();
|
||
tbformat = parentTab + (parentTab.EndsWith(".") ? "" : ".") + tbformat.TrimStart();
|
||
}
|
||
}
|
||
if (tbformat.IndexOf("#2#") > -1 || tbformat.IndexOf("#1#") > -1)
|
||
{
|
||
string ofst = tbformat.Substring(0, 3);
|
||
_MyTab.Offset = Convert.ToInt32(ofst.Substring(1, 1));
|
||
cltext = tbformat.Replace("#2#", "");
|
||
cltext = cltext.Replace("#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));
|
||
}
|
||
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);
|
||
string roman = RomanNumbering(ordinal);
|
||
tbformat = tbformat.Replace("{roman}", roman.ToLower());
|
||
tbformat = tbformat.Replace("{ROMAN}", roman);
|
||
tbformat = tbformat.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 + " ";
|
||
}
|
||
// "{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);
|
||
_MyHeader.Justify = ContentAlignment.MiddleCenter;
|
||
}
|
||
#region Non Converted Plants tab TODO
|
||
// other possible 'tokens'
|
||
// Position offset - do this one here, so don't get background substitution below..
|
||
// ##-3# - Offset of -3 from Parent (FNP)
|
||
// "{Pos-3}"
|
||
|
||
// Background/Deviation Documents - check for E_PurchaseOptions.(ENHANCEDBACKGROUNDS or ENHANCEDDEVIATIONS)
|
||
// # - Related Caution or Note number
|
||
// ~ - Linked Step Number
|
||
//"{LNK C/N Num}"
|
||
//"{LNK Step Num}"
|
||
|
||
// Position offset
|
||
// \257 - Indent (CALLOWAY BACKGROUNDS)
|
||
// Newline within a tab (calbck)
|
||
//"{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
|
||
_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;
|
||
}
|
||
|
||
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;
|
||
bias = 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)
|
||
bias = -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) bias = -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 += 2;
|
||
|
||
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)
|
||
{
|
||
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)
|
||
_MyHeader = null;
|
||
}
|
||
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 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);
|
||
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 (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 int GetSmartTemplateIndex()
|
||
{
|
||
FormatData formatData = FormatStepData.MyFormat.PlantFormat.FormatData;
|
||
int indx = 0;
|
||
// find the starting template in the list for the high level step type:
|
||
int highType = (int)MyHLS.MyContent.Type - 20001;
|
||
while (indx < formatData.Templates.Count)
|
||
{
|
||
// level of 0 starts a new group.
|
||
if (formatData.Templates[indx].level == 0)
|
||
{
|
||
indx++;
|
||
// now see if we're on the high level step type, 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 == highType)
|
||
{
|
||
if (MyHLS.ItemID == ItemID) return indx; // I'm on the HLS, return it.
|
||
indx++;
|
||
while (indx < formatData.Templates.Count && formatData.Templates[indx].level != 0)
|
||
{
|
||
if (formatData.Templates[indx].type == MyContent.Type - 20001)
|
||
return indx;
|
||
indx++;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
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;
|
||
}
|
||
private 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 bool _RemovedStyleUnderline = false;
|
||
public bool RemovedStyleUnderline
|
||
{
|
||
get { return _RemovedStyleUnderline; }
|
||
set { _RemovedStyleUnderline = value; }
|
||
}
|
||
public Tab(VE_Font font)
|
||
{
|
||
MyFont = font;
|
||
}
|
||
public int Offset;
|
||
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.ContainsKey(itemID))
|
||
return mylookup[itemID];
|
||
}
|
||
return null;
|
||
}
|
||
}
|
||
public bool ContainsKey(int itemID)
|
||
{
|
||
foreach (Dictionary<int, ItemInfo> mylookup in MyLookups.Values)
|
||
{
|
||
if (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));
|
||
}
|
||
//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));
|
||
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)
|
||
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, 0)) return -1;
|
||
if (tmpstr != null && tmpstr.IndexOf('-') >= 0) return -1;
|
||
return tmpstr==null?0:System.Convert.ToInt32(tmpstr);
|
||
}
|
||
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;
|
||
}
|
||
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
|
||
}
|
||
}
|