Kathy
f9bfbea84a
Use ‘UseSpecificPageNo’ for printing of explicit page number transitions Allow Change Id for each procedure (not one for entire session). Request from Calvert. Implement ‘UseSpecificPageNo’ flag. Added ‘UseSpecificPageNo’ flag Change Id dialog (moved from VEPROMS UI)
964 lines
31 KiB
C#
964 lines
31 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using VEPROMS.CSLA.Library;
|
|
using Volian.Controls.Library;
|
|
using DevComponents.DotNetBar;
|
|
|
|
namespace Volian.Controls.Library
|
|
{
|
|
public delegate void DisplayTabControlEvent(object sender,EventArgs args);
|
|
public delegate void DisplayTabControlStatusEvent(object sender, DisplayTabControlStatusEventArgs args);
|
|
public partial class DisplayTabControlStatusEventArgs : EventArgs
|
|
{
|
|
private VolianStatusType _Type;
|
|
public VolianStatusType Type
|
|
{
|
|
get { return _Type; }
|
|
set { _Type = value; }
|
|
}
|
|
private int _Count;
|
|
public int Count
|
|
{
|
|
get { return _Count; }
|
|
set { _Count = value; }
|
|
}
|
|
private string _Text;
|
|
public string Text
|
|
{
|
|
get { return _Text; }
|
|
set { _Text = value; }
|
|
}
|
|
public DisplayTabControlStatusEventArgs()
|
|
{
|
|
_Type = VolianStatusType.Initialize;
|
|
_Count = 0;
|
|
_Text = "Default";
|
|
}
|
|
public DisplayTabControlStatusEventArgs(VolianStatusType type, int count, string text)
|
|
{
|
|
_Type = type;
|
|
_Count = count;
|
|
_Text = text;
|
|
}
|
|
}
|
|
public partial class DisplayTabControl : UserControl
|
|
{
|
|
public event DisplayTabControlStatusEvent StatusChanged;
|
|
public void ONStatusChanged(object Sender, DisplayTabControlStatusEventArgs args)
|
|
{
|
|
if (StatusChanged != null) StatusChanged(Sender, args);
|
|
}
|
|
public event DisplayTabControlEvent ToggleRibbonExpanded;
|
|
public void OnToggleRibbonExpanded(object sender, EventArgs args)
|
|
{
|
|
if (ToggleRibbonExpanded != null) ToggleRibbonExpanded(sender,args);
|
|
}
|
|
public event DisplayTabControlEvent SelectedDisplayTabItemChanged;
|
|
public void OnSelectedDisplayTabItemChanged(object sender, EventArgs args)
|
|
{
|
|
if (SelectedDisplayTabItemChanged != null)SelectedDisplayTabItemChanged(sender, args);
|
|
}
|
|
#region Private Fields
|
|
/// <summary>
|
|
/// This is a lookup table for all of the DisplayTabItems that are currently open
|
|
/// The key is:
|
|
/// "Item - " + Procedure ItemID for step pages
|
|
/// "Doc - " + DocumentID for Word Documents
|
|
/// </summary>
|
|
private Dictionary<string, DisplayTabItem> _MyDisplayTabItems;
|
|
/// <summary>
|
|
/// When a Tab is closed it is added to this list.
|
|
/// When another Tab is opened, any Tabs in this list are closed
|
|
/// </summary>
|
|
private List<DisplayTabItem> _RemovedDisplayTabItems = null;
|
|
/// <summary>
|
|
/// This stores a UniqueID for Bars as they are opened.
|
|
/// A bar is the docking location for the DisplayTabItems.
|
|
/// </summary>
|
|
private int _UniqueBarCount;
|
|
|
|
/// <summary>
|
|
/// ItemsChangeIds is used to store a procedure's itemid and its associated (input from dialog)
|
|
/// Change Id. Any time a user enters a procedure for the first time in this program session,
|
|
/// the user gets prompted to enter a change id. Any time a modification is made to the procedure
|
|
/// this change id is used. The user can modify this change id from the step tab ribbon/change id
|
|
/// tab (only if the format uses change ids is this tab visible).
|
|
/// </summary>
|
|
public Dictionary<int, string> ItemsChangeIds = null;
|
|
private ItemInfo _MyItemInfo = null;
|
|
private EditItem _MyEditItem = null;
|
|
private StepRTB _MyStepRTB = null;
|
|
private bool _RibbonExpanded=true;
|
|
public bool RibbonExpanded
|
|
{
|
|
get { return _RibbonExpanded; }
|
|
set
|
|
{
|
|
_RibbonExpanded = value;
|
|
foreach (DisplayTabItem tabItem in _MyDisplayTabItems.Values)
|
|
if (tabItem.MyStepTabPanel != null)
|
|
tabItem.MyStepTabPanel.MyStepTabRibbon.Expanded = _RibbonExpanded;
|
|
}
|
|
}
|
|
private ItemInfo _MyCopyStep;
|
|
|
|
public ItemInfo MyCopyStep
|
|
{
|
|
get { return _MyCopyStep; }
|
|
set { _MyCopyStep = value; }
|
|
}
|
|
private string _ChgId;
|
|
public string ChgId
|
|
{
|
|
get { return _ChgId; }
|
|
set { _ChgId = value; }
|
|
}
|
|
public bool EditorialChange
|
|
{
|
|
get
|
|
{
|
|
if (_ChgId == null) return true;
|
|
if (_ChgId == "") return true;
|
|
if (_ChgId.ToUpper() == "EC") return true;
|
|
return false;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Events
|
|
/// <summary>
|
|
/// This event is raised when a the "Tab" of a DisplayItem is clicked with a mouse.
|
|
/// So far this has just been used for demo purposes. It could be used to select a
|
|
/// step and it's children for the purpose of copying.
|
|
/// </summary>
|
|
public event StepPanelEvent ItemClick;
|
|
/// <summary>
|
|
/// Checks to see if the ItemClick event is handled and launches it
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
internal void OnItemClick(object sender, StepPanelEventArgs args)
|
|
{
|
|
if (ItemClick != null) ItemClick(sender, args);
|
|
}
|
|
/// <summary>
|
|
/// This occurs when the user moves onto or off of a link within a RichTextBox
|
|
/// or moves between RichTextBoxes or Pages.
|
|
/// </summary>
|
|
public event StepPanelLinkEvent LinkActiveChanged;
|
|
/// <summary>
|
|
/// Checks to see if the LinkActiveChanged event is handled and launches it
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
internal void OnLinkActiveChanged(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
if (LinkActiveChanged != null) LinkActiveChanged(sender, args);
|
|
else MessageBox.Show(args.LinkInfoText, "Unhandled Link Active Changed", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
/// <summary>
|
|
/// This occurs when a Transition is inserted
|
|
/// </summary>
|
|
public event StepPanelLinkEvent LinkInsertTran;
|
|
/// <summary>
|
|
/// Checks to see if the 'LinkInsertTran' event is handled and launches it
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
internal void OnLinkInsertTran(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
if (LinkInsertTran != null) LinkInsertTran(sender, args);
|
|
else MessageBox.Show(args.LinkInfoText, "Unhandled Link Insert Tran", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
/// <summary>
|
|
/// This occurs when an RO is inserted
|
|
/// </summary>
|
|
public event StepPanelLinkEvent LinkInsertRO;
|
|
/// <summary>
|
|
/// Checks to see if the 'LinkInsertRO' event is handled and launches it
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
internal void OnLinkInsertRO(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
if (LinkInsertRO != null) LinkInsertRO(sender, args);
|
|
else MessageBox.Show(args.LinkInfoText, "Unhandled Link Insert RO", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
/// <summary>
|
|
/// This occurs when a Transition is modified
|
|
/// </summary>
|
|
public event StepPanelLinkEvent LinkModifyTran;
|
|
/// <summary>
|
|
/// Checks to see if the 'LinkModifyTran' event is handled and launches it
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
internal void OnLinkModifyTran(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
if (LinkModifyTran != null) LinkModifyTran(sender, args);
|
|
else MessageBox.Show(args.LinkInfoText, "Unhandled Link Modify Tran", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
/// <summary>
|
|
/// This occurs when an RO is modified
|
|
/// </summary>
|
|
public event StepPanelLinkEvent LinkModifyRO;
|
|
/// <summary>
|
|
/// Checks to see if the 'LinkModifyRO' event is handled and launches it
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
internal void OnLinkModifyRO(object sender, StepPanelLinkEventArgs args)
|
|
{
|
|
if (LinkModifyRO != null) LinkModifyRO(sender, args);
|
|
else MessageBox.Show(args.LinkInfoText, "Unhandled Link Modify RO", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
/// <summary>
|
|
/// Occurs when the user selects a different item or page
|
|
/// </summary>
|
|
public event ItemSelectedChangedEvent ItemSelectedChanged;
|
|
/// <summary>
|
|
/// Checks to see if the 'ItemSelectedChanged' event is handled and launches it
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="args"></param>
|
|
internal void OnItemSelectedChanged(object sender, ItemSelectedChangedEventArgs args)
|
|
{
|
|
if (args != null)
|
|
{
|
|
_MyItemInfo = args.MyItemInfo;
|
|
_MyEditItem = args.MyEditItem;
|
|
if (_MyEditItem != null)
|
|
{
|
|
_MyStepRTB = _MyEditItem.MyStepRTB;
|
|
if(_MyStepRTB != null)
|
|
_MyStepRTB.Disposed += new EventHandler(_MyStepRTB_Disposed);
|
|
}
|
|
else
|
|
_MyStepRTB = null;
|
|
}
|
|
else
|
|
{
|
|
_MyItemInfo = null;
|
|
_MyEditItem = null;
|
|
_MyStepRTB = null;
|
|
}
|
|
if (ItemSelectedChanged != null) ItemSelectedChanged(sender, args);
|
|
}
|
|
void _MyStepRTB_Disposed(object sender, EventArgs e)
|
|
{
|
|
_MyStepRTB = null;
|
|
}
|
|
public event StepPanelModeChangeEvent ModeChange;
|
|
internal void OnModeChange(object sender, StepRTBModeChangeEventArgs args)
|
|
{
|
|
if (ModeChange != null) ModeChange(sender, args);
|
|
else MessageBox.Show("Cannot change mode");
|
|
}
|
|
public event StepPanelTabDisplayEvent PanelTabDisplay;
|
|
internal void OnPanelTabDisplay(object sender, StepPanelTabDisplayEventArgs args)
|
|
{
|
|
if (PanelTabDisplay != null) PanelTabDisplay(sender, args);
|
|
else MessageBox.Show("Cannot display information");
|
|
}
|
|
public event StepPanelWordSectionCloseEvent WordSectionClose;
|
|
internal void OnWordSectionClose(object sender, WordSectionEventArgs args)
|
|
{
|
|
if (WordSectionClose != null) WordSectionClose(sender, args);
|
|
else MessageBox.Show("Cannot close associated Word section");
|
|
}
|
|
public event StepPanelWordSectionDeletedEvent WordSectionDeleted;
|
|
internal void OnWordSectionDeleted(object sender, WordSectionEventArgs args)
|
|
{
|
|
if (WordSectionDeleted != null) WordSectionDeleted(sender, args);
|
|
else MessageBox.Show("Cannot delete associated Word section");
|
|
}
|
|
public event StepPanelItemPastedEvent ItemPaste;
|
|
internal void OnItemPaste(object sender, vlnTreeItemInfoPasteEventArgs args)
|
|
{
|
|
if (ItemPaste != null) ItemPaste(sender, args);
|
|
else MessageBox.Show("Cannot adjust panels for pasted item");
|
|
}
|
|
#endregion
|
|
#region Contructor & Setup
|
|
public DisplayTabControl()
|
|
{
|
|
InitializeComponent();
|
|
SetUp();
|
|
}
|
|
private void SetUp()
|
|
{
|
|
ItemsChangeIds = new Dictionary<int, string>();
|
|
_RemovedDisplayTabItems = new List<DisplayTabItem>();
|
|
Dock = DockStyle.Fill;
|
|
dotNetBarManager1.Style = DevComponents.DotNetBar.eDotNetBarStyle.Office2007;
|
|
_MyDisplayTabItems = new Dictionary<string, DisplayTabItem>();
|
|
SetupBar(_MyBar);
|
|
dotNetBarManager1.BarTearOff += new EventHandler(dotNetBarManager1_BarTearOff);
|
|
this.Resize += new EventHandler(DisplayTabControl_Resize);
|
|
}
|
|
void DisplayTabControl_Resize(object sender, EventArgs e)
|
|
{
|
|
// If the currently selected Item is in a Step, then adjust the scroll as necessary to keep it visible
|
|
if (_MyEditItem != null)
|
|
_MyEditItem.ItemShow();
|
|
}
|
|
private void SetupBar(Bar myBar)
|
|
{
|
|
if (myBar.DockTabControl != null)
|
|
{
|
|
myBar.DockTabControl.CloseButtonOnTabsVisible = true;
|
|
myBar.DockTabControl.CloseButtonVisible = false;
|
|
myBar.DockTabControl.CloseButtonPosition = DevComponents.DotNetBar.eTabCloseButtonPosition.Right;
|
|
myBar.DockTabControl.Width = ClientRectangle.Width;
|
|
}
|
|
myBar.DockTabClosing += new DockTabClosingEventHandler(myBar_DockTabClosing);
|
|
if (!myBar.Visible)
|
|
myBar.Visible = true;
|
|
myBar.RecalcLayout();
|
|
}
|
|
#endregion
|
|
#region Internal Event Handlers
|
|
/// <summary>
|
|
/// This is code recommended by DotNetBar
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void dotNetBarManager1_BarTearOff(object sender, EventArgs e)
|
|
{
|
|
Bar myBar = sender as Bar;
|
|
myBar.Enter += new EventHandler(myBar_Enter);
|
|
}
|
|
/// <summary>
|
|
/// This sets-up the bar after it is selected.
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void myBar_Enter(object sender, EventArgs e)
|
|
{
|
|
Bar myBar = sender as Bar;
|
|
myBar.Enter -= new EventHandler(myBar_Enter);
|
|
SetupBar(sender as Bar);
|
|
}
|
|
/// <summary>
|
|
/// This handles the closing of a document page
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void myBar_DockTabClosing(object sender, DockTabClosingEventArgs e)
|
|
{
|
|
e.RemoveDockTab = true;
|
|
_RemovedDisplayTabItems.Add((DisplayTabItem)e.DockContainerItem);
|
|
DisplayTabItem dti = e.DockContainerItem as DisplayTabItem;
|
|
if (dti != null && dti.MyStepTabPanel != null)
|
|
dti.MyStepTabPanel.MyStepPanel.Dispose();
|
|
DisplayTabItem myTabItem = e.DockContainerItem as DisplayTabItem;
|
|
if (myTabItem != null)
|
|
{
|
|
if (myTabItem.MyDSOTabPanel != null)
|
|
{
|
|
myTabItem.MyDSOTabPanel.CloseDSO();
|
|
}
|
|
}
|
|
MySessionInfo.CheckInItem(dti.OwnerID);
|
|
if (((Bar)sender).Items == null) return;
|
|
if (((Bar)sender).Items.Count == 1)// Remove bar if last item is closed...
|
|
{
|
|
Bar bar = sender as Bar;
|
|
if (bar != null)
|
|
{
|
|
if (dotNetBarManager1.Bars.Contains(bar.Name))
|
|
dotNetBarManager1.Bars.Remove(bar);
|
|
ActivateRemainingTab();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ActivateRemainingTab((Bar)sender);
|
|
}
|
|
}
|
|
#endregion
|
|
#region Public Methods
|
|
/// <summary>
|
|
/// Open a Step Item or a Word Item
|
|
/// </summary>
|
|
/// <param name="myItemInfo"></param>
|
|
/// <returns></returns>
|
|
public DisplayTabItem OpenItem(ItemInfo myItemInfo2)
|
|
{
|
|
ItemInfo myItemInfo = myItemInfo2;
|
|
string message = string.Empty;
|
|
if (myItemInfo.MyContent.MyEntry == null) //not a document
|
|
{
|
|
if (!MySessionInfo.CanCheckOutItem(myItemInfo.MyProcedure.ItemID, CheckOutType.Procedure, ref message))
|
|
{
|
|
MessageBox.Show(this, message, "Procedure Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!MySessionInfo.CanCheckOutItem(myItemInfo.MyContent.MyEntry.DocID, CheckOutType.Document, ref message))
|
|
{
|
|
MessageBox.Show(this, message, "Document Already Checked Out", MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
|
return null;
|
|
}
|
|
}
|
|
//if (myItemInfo.IsProcedure)
|
|
//{
|
|
// DateTime start = DateTime.Now;
|
|
// myItemInfo = ProcedureInfo.GetItemAndChildrenByUnit(myItemInfo.ItemID, 0, 2);
|
|
// TimeSpan howlong = DateTime.Now - start;
|
|
// Console.WriteLine("Overall - " + howlong.ToString());
|
|
//}
|
|
CleanUpClosedItems();
|
|
if (myItemInfo == null) return null;
|
|
// if this is an auto table of contents section, don't edit it:
|
|
if (myItemInfo.IsAutoTOCSection)
|
|
{
|
|
MessageBox.Show("This is an automatically generated 'Table of Contents' section. It is not editable. It is generated during Print.", "Item not Editable", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
|
|
return SelectedDisplayTabItem;
|
|
}
|
|
_MyBar = GetParentBar(myItemInfo); // Get the docking bar associated with this item.
|
|
if (myItemInfo.MyContent.MyEntry == null) // If it is a Word document open in step editor
|
|
return OpenStepTabPage(myItemInfo);
|
|
else // Otherwise open it in the Word editor
|
|
return OpenDSOTabPage(myItemInfo);
|
|
}
|
|
public bool PasteRTBItem(ItemInfo myItemInfo, int copyStartID, ItemInfo.EAddpingPart pasteType, int type)
|
|
{
|
|
CleanUpClosedItems();
|
|
ItemInfo proc = myItemInfo.MyProcedure; // Find procedure Item
|
|
string key = "Item - " + proc.ItemID.ToString();
|
|
|
|
if (_MyDisplayTabItems.ContainsKey(key)) // If procedure page open use it
|
|
{
|
|
DisplayTabItem pg = _MyDisplayTabItems[key];
|
|
if (pg.MyStepTabPanel.MyStepPanel._LookupEditItems.ContainsKey(myItemInfo.ItemID))
|
|
{
|
|
EditItem edtitm = pg.MyStepTabPanel.MyStepPanel._LookupEditItems[myItemInfo.ItemID];
|
|
switch (pasteType)
|
|
{
|
|
case ItemInfo.EAddpingPart.Before:
|
|
edtitm.PasteSiblingBefore(copyStartID);
|
|
break;
|
|
case ItemInfo.EAddpingPart.After:
|
|
edtitm.PasteSiblingAfter(copyStartID);
|
|
break;
|
|
case ItemInfo.EAddpingPart.Replace:
|
|
edtitm.PasteReplace(copyStartID);
|
|
edtitm.Dispose();
|
|
break;
|
|
default:
|
|
return false; ;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
public bool DeleteRTBItem(ItemInfo myItemInfo)
|
|
{
|
|
CleanUpClosedItems();
|
|
|
|
//removeitem!
|
|
ItemInfo proc = myItemInfo.MyProcedure; // Find procedure Item
|
|
string key = "Item - " + proc.ItemID.ToString();
|
|
|
|
if (_MyDisplayTabItems.ContainsKey(key)) // If procedure page open use it
|
|
{
|
|
DisplayTabItem pg = _MyDisplayTabItems[key];
|
|
// if deleting a procedure, close the tab.
|
|
if (proc.ItemID == myItemInfo.ItemID)
|
|
{
|
|
// do we need to close open doc tabs associated with this proc.
|
|
CloseTabItem(pg);
|
|
return false;
|
|
}
|
|
if (pg.MyStepTabPanel.MyStepPanel._LookupEditItems.ContainsKey(myItemInfo.ItemID))
|
|
{
|
|
EditItem edtitm = pg.MyStepTabPanel.MyStepPanel._LookupEditItems[myItemInfo.ItemID];
|
|
edtitm.RemoveItem();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
public bool InsertRTBItem(ItemInfo myItemInfo, string text, E_InsertType insertType, E_FromType fromType, int type,bool updateSelection)
|
|
{
|
|
CleanUpClosedItems();
|
|
ItemInfo proc = myItemInfo.MyProcedure; // Find procedure Item
|
|
string key = "Item - " + proc.ItemID.ToString();
|
|
|
|
if (_MyDisplayTabItems.ContainsKey(key)) // If procedure page open use it
|
|
{
|
|
DisplayTabItem pg = _MyDisplayTabItems[key];
|
|
if (pg.MyStepTabPanel.MyStepPanel._LookupEditItems.ContainsKey(myItemInfo.ItemID))
|
|
{
|
|
EditItem edtitm = pg.MyStepTabPanel.MyStepPanel._LookupEditItems[myItemInfo.ItemID];
|
|
switch (insertType)
|
|
{
|
|
case E_InsertType.Before:
|
|
edtitm.AddSiblingBefore(text,updateSelection);
|
|
break;
|
|
case E_InsertType.After:
|
|
edtitm.AddSiblingAfter(text,updateSelection);
|
|
break;
|
|
case E_InsertType.Child:
|
|
edtitm.AddChild(text, fromType, type, null);
|
|
break;
|
|
default:
|
|
return false; ;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
private void CleanUpClosedItems()
|
|
{
|
|
while (_RemovedDisplayTabItems.Count > 0) // Clean-up any items that have been closed.
|
|
{
|
|
DisplayTabItem myTabItem = _RemovedDisplayTabItems[0];
|
|
_RemovedDisplayTabItems.RemoveAt(0);
|
|
RemoveItem(myTabItem);
|
|
}
|
|
}
|
|
public void CloseWordItem(ItemInfo myItemInfo)
|
|
{
|
|
CloseWordItem(myItemInfo, false);
|
|
}
|
|
public void CloseWordItem(ItemInfo myItemInfo, bool isBeingDeleted)
|
|
{
|
|
CleanUpClosedItems();
|
|
string key = "Doc - ";
|
|
// there is no entry if it is an auto table of contents:
|
|
if (myItemInfo.MyContent.MyEntry != null)
|
|
key = key + myItemInfo.MyContent.MyEntry.MyDocument.DocID.ToString();
|
|
else
|
|
key = key + "0";
|
|
DisplayTabItem myTabItem = null;
|
|
if (_MyDisplayTabItems.ContainsKey(key)) // If page open, close it
|
|
{
|
|
myTabItem = _MyDisplayTabItems[key];
|
|
if (myTabItem.MyDSOTabPanel != null)
|
|
{
|
|
myTabItem.MyDSOTabPanel.IsBeingDeleted = isBeingDeleted;
|
|
CloseTabItem(myTabItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void CloseTabItem(DisplayTabItem myTabItem)
|
|
{
|
|
Bar b = myTabItem.ContainerControl as Bar;
|
|
if (b != null)
|
|
{
|
|
b.CloseDockTab(myTabItem);
|
|
//b.Items.Remove(myTabItem);
|
|
RemoveItem(myTabItem);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Look for a tab and set it to active.
|
|
/// </summary>
|
|
private void ActivateRemainingTab()
|
|
{
|
|
foreach (Bar myBar in dotNetBarManager1.Bars)
|
|
{
|
|
if (myBar.DockSide == eDockSide.Document && myBar.Visible)
|
|
{
|
|
ActivateRemainingTab(myBar);
|
|
return;
|
|
}
|
|
}
|
|
// No Document Tabs Remaining - need to raise OnItemSelectedChanged
|
|
OnItemSelectedChanged(this, null);
|
|
}
|
|
private DisplayTabItem FindRemainingTab(Bar myBar)
|
|
{
|
|
foreach (DisplayTabItem itm in myBar.Items)
|
|
{
|
|
if (!_RemovedDisplayTabItems.Contains(itm)) return itm;
|
|
}
|
|
return null;
|
|
}
|
|
private void ActivateRemainingTab(Bar myBar)
|
|
{
|
|
if (myBar.SelectedDockContainerItem != null)
|
|
{
|
|
if (_RemovedDisplayTabItems.Contains(myBar.SelectedDockContainerItem as DisplayTabItem))
|
|
myBar.SelectedDockContainerItem = FindRemainingTab(myBar);
|
|
myBar.SelectedDockContainerItem.Selected = true;
|
|
StepTabPanel pnl = myBar.SelectedDockContainerItem.Control as StepTabPanel;
|
|
if (pnl != null)
|
|
pnl.MyStepPanel.ItemShow();
|
|
}
|
|
}
|
|
#endregion
|
|
#region Public Properties
|
|
private SessionInfo _MySessionInfo;
|
|
public SessionInfo MySessionInfo
|
|
{
|
|
get { return _MySessionInfo; }
|
|
set { _MySessionInfo = value; }
|
|
}
|
|
public DevComponents.DotNetBar.Bar MyBar
|
|
{
|
|
get { return _MyBar; }
|
|
}
|
|
public Panel PnlCaret
|
|
{
|
|
get { return _PnlCaret; }
|
|
}
|
|
private Color _OldForeColor = Color.Empty;
|
|
private Color _OldBackColor = Color.Empty;
|
|
public void ShowCaret()
|
|
{
|
|
if (_MyStepRTB != null)
|
|
{
|
|
if (_MyEditItem.RTBLastFocus)
|
|
{
|
|
if (!_MyStepRTB.Visible)
|
|
_MyStepRTB.Visible = true;
|
|
if (_MyStepRTB.SelectionLength == 0)
|
|
{
|
|
Point pt = _MyStepRTB.GetPositionFromCharIndex(_MyStepRTB.SelectionStart);
|
|
pt = _MyStepRTB.PointToScreen(pt);
|
|
pt = this.PointToClient(pt);
|
|
PnlCaret.Location = pt;
|
|
PnlCaret.BackColor = _MyStepRTB.ForeColor;
|
|
using (Graphics gr = this.CreateGraphics())
|
|
{
|
|
SizeF sf = gr.MeasureString("Mg", _MyStepRTB.SelectionFont);
|
|
sf.Width = 1;
|
|
PnlCaret.Size = sf.ToSize();
|
|
}
|
|
tmrCaret.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
if (_MyStepRTB.SelectionColor != Color.Empty && _OldForeColor == Color.Empty)
|
|
{
|
|
_OldForeColor = _MyStepRTB.SelectionColor;
|
|
_MyStepRTB.SelectionColor = Color.White;
|
|
}
|
|
if (_MyStepRTB.SelectionBackColor != Color.Empty && _OldBackColor == Color.Empty)
|
|
{
|
|
_OldBackColor = _MyStepRTB.SelectionBackColor;
|
|
_MyStepRTB.SelectionBackColor = Color.FromName("Highlight");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void HideCaret()
|
|
{
|
|
if (_MyStepRTB != null && !_MyStepRTB.Disposing && !_MyStepRTB.Closed)
|
|
{
|
|
if (_MyStepRTB.SelectionLength == 0)
|
|
{
|
|
tmrCaret.Enabled = false;
|
|
PnlCaret.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
if (_OldForeColor != Color.Empty)
|
|
{
|
|
_MyStepRTB.SelectionColor = _OldForeColor;
|
|
_OldForeColor = Color.Empty;
|
|
}
|
|
if (_OldBackColor != Color.Empty)
|
|
{
|
|
_MyStepRTB.SelectionBackColor = _OldBackColor;
|
|
_OldBackColor = Color.Empty;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private void tmrCaret_Tick(object sender, EventArgs e)
|
|
{
|
|
PnlCaret.Visible = !PnlCaret.Visible;
|
|
}
|
|
#endregion
|
|
#region Private Methods
|
|
///// <summary>
|
|
///// Gets and sets the SelectedDisplayTabItem (Active Tab)
|
|
///// </summary>
|
|
//public DisplayTabItem SelectedDisplayTabItem1
|
|
//{
|
|
// get { return (DisplayTabItem)_MyBar.SelectedDockContainerItem; }
|
|
// set
|
|
// {
|
|
// //Volian.Base.Library.vlnStackTrace.ShowStackLocal("SelectedDisplayTabItem");
|
|
// if (value != null)
|
|
// {
|
|
// value.Focus();
|
|
// value.Selected = true;
|
|
// }
|
|
// }
|
|
//}
|
|
public void SelectDisplayTabItem(DisplayTabItem myDisplayTabItem)
|
|
{
|
|
if (myDisplayTabItem != null)
|
|
{
|
|
if (!myDisplayTabItem.Selected)
|
|
{
|
|
myDisplayTabItem.Focus();
|
|
myDisplayTabItem.Selected = true;
|
|
}
|
|
}
|
|
}
|
|
private DisplayTabItem _SelectedDisplayTabItem=null;
|
|
public DisplayTabItem SelectedDisplayTabItem
|
|
{
|
|
get { return _SelectedDisplayTabItem; }
|
|
set
|
|
{
|
|
if (_SelectedDisplayTabItem != value)
|
|
{
|
|
if (_SelectedDisplayTabItem != null && _SelectedDisplayTabItem.MyDSOTabPanel != null)
|
|
_SelectedDisplayTabItem.MyDSOTabPanel.InActive();
|
|
_SelectedDisplayTabItem = value;
|
|
OnSelectedDisplayTabItemChanged(this, new EventArgs());
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// This returns the parent bar (current docking location) for an item.
|
|
/// It creates a bar if none exist
|
|
/// </summary>
|
|
/// <param name="myItemInfo"></param>
|
|
/// <returns></returns>
|
|
private Bar GetParentBar(ItemInfo myItemInfo)
|
|
{
|
|
Bar myBar = null;
|
|
foreach (Bar b in dotNetBarManager1.Bars)
|
|
{
|
|
if (b.DockSide == eDockSide.Document && b.Visible)
|
|
{
|
|
if (myBar == null) myBar = b;// Remember the first available bar if a specific bar cannot be found
|
|
foreach (object itm in b.Items)
|
|
{
|
|
DisplayTabItem myTabItem = itm as DisplayTabItem;
|
|
if (myTabItem != null && myTabItem.MyStepTabPanel != null)
|
|
if (myTabItem.MyStepTabPanel.MyProcedureItemInfo.ItemID == myItemInfo.MyProcedure.ItemID)
|
|
return b;
|
|
}
|
|
}
|
|
}
|
|
if (myBar == null)
|
|
{
|
|
// If no documents bars found, create new one
|
|
_UniqueBarCount++;
|
|
myBar = BarUtilities.CreateDocumentBar();
|
|
myBar.DockTabClosing += new DockTabClosingEventHandler(myBar_DockTabClosing);
|
|
myBar.Name = "barDocuments" + _UniqueBarCount.ToString();
|
|
fillDocDockSite.GetDocumentUIManager().Dock(myBar);
|
|
SetupBar(myBar);
|
|
}
|
|
return myBar;
|
|
}
|
|
public StepTabPanel GetProcedureTabPanel(ItemInfo myItemInfo)
|
|
{
|
|
Bar myBar = null;
|
|
foreach (Bar b in dotNetBarManager1.Bars)
|
|
{
|
|
if (b.DockSide == eDockSide.Document && b.Visible)
|
|
{
|
|
if (myBar == null) myBar = b;// Remember the first available bar if a specific bar cannot be found
|
|
foreach (object itm in b.Items)
|
|
{
|
|
DisplayTabItem myTabItem = itm as DisplayTabItem;
|
|
if (myTabItem != null && myTabItem.MyStepTabPanel != null && myTabItem.MyStepTabPanel.MyProcedureItemInfo != null)
|
|
if (myTabItem.MyStepTabPanel.MyProcedureItemInfo.ItemID == myItemInfo.MyProcedure.ItemID)
|
|
return myTabItem.MyStepTabPanel;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
/// <summary>
|
|
/// Save the current EditItem if it is in Edit mode
|
|
/// </summary>
|
|
/// <param name="pi">ProcedureInfo</param>
|
|
public void SaveCurrentEditItem(ProcedureInfo pi)
|
|
{
|
|
DisplayTabItem dti = GetProcDisplayTabItem(pi);
|
|
if (dti == null) return;
|
|
EditItem ei = dti.MyStepTabPanel.SelectedEditItem;
|
|
if (ei == null) return;
|
|
ei.SaveCurrentAndContents();
|
|
}
|
|
/// <summary>
|
|
/// Save the current EditItem if it is in Edit mode
|
|
/// </summary>
|
|
public void SaveCurrentEditItem()
|
|
{
|
|
foreach (DisplayTabItem dti in _MyDisplayTabItems.Values)
|
|
{
|
|
StepTabPanel stp = dti.MyStepTabPanel;
|
|
if (stp != null)
|
|
{
|
|
EditItem ei = stp.SelectedEditItem;
|
|
if (ei != null)
|
|
ei.SaveCurrentAndContents();
|
|
}
|
|
}
|
|
}
|
|
public DisplayTabItem GetProcDisplayTabItem(ItemInfo myItemInfo)
|
|
{
|
|
ItemInfo proc = myItemInfo.MyProcedure; // Find procedure Item
|
|
string key = "Item - " + proc.ItemID.ToString();
|
|
DisplayTabItem pg = null;
|
|
if (_MyDisplayTabItems.ContainsKey(key)) // If procedure page open use it
|
|
return _MyDisplayTabItems[key];
|
|
return null;
|
|
}
|
|
/// <summary>
|
|
/// This opens a Step page based upon a ItemInfo.
|
|
///
|
|
/// </summary>
|
|
/// <param name="myItemInfo"></param>
|
|
/// <returns></returns>
|
|
private DisplayTabItem OpenStepTabPage(ItemInfo myItemInfo)
|
|
{
|
|
ItemInfo proc = myItemInfo.MyProcedure; // Find procedure Item
|
|
string key = "Item - " + proc.ItemID.ToString();
|
|
DisplayTabItem pg = null;
|
|
if (_MyDisplayTabItems.ContainsKey(key)) // If procedure page open use it
|
|
{
|
|
pg = _MyDisplayTabItems[key];
|
|
pg.Selected = true;
|
|
HandleChangeId(myItemInfo, pg);
|
|
if (SelectedDisplayTabItem != pg) // If the selected page doesn't match
|
|
SelectDisplayTabItem(pg); // Set the selected page
|
|
}
|
|
else // If not already open, create a new Page
|
|
{
|
|
pg = new DisplayTabItem(this.components, this, proc, key); // Open a new Procedure Tab
|
|
_MyDisplayTabItems.Add(key, pg);
|
|
pg.Selected = true;
|
|
HandleChangeId(myItemInfo, pg);
|
|
SelectDisplayTabItem(pg);
|
|
pg.MyStepTabPanel.MyProcedureItemInfo = proc;
|
|
|
|
// When more than one procedure is openned, the ribbon control cuts off the bottom of the buttons.
|
|
// This happened to all the procedure tabs after the first one.
|
|
// This is to kludge the logic into sizing the ribbon control properly.
|
|
// This is done by toggling "pg.MyStepTabPanel.MyStepTabRibbon.Expanded"
|
|
// Note that we are doing the NOT of its current setting. This takes care of when the
|
|
// ribbon bar is minimized and a new procedure tab is created
|
|
pg.MyStepTabPanel.MyStepTabRibbon.Expanded = !pg.MyStepTabPanel.MyStepTabRibbon.Expanded;
|
|
pg.MyStepTabPanel.MyStepTabRibbon.Expanded = !pg.MyStepTabPanel.MyStepTabRibbon.Expanded;
|
|
}
|
|
Application.DoEvents();
|
|
pg.SelectedItemInfo = myItemInfo; // Select the item
|
|
return pg;
|
|
}
|
|
|
|
public void HandleChangeId(ItemInfo myItemInfo, DisplayTabItem pg)
|
|
{
|
|
if (myItemInfo.ActiveFormat.PlantFormat.FormatData.ProcData.ChangeBarData.ChangeIds)
|
|
{
|
|
if (ItemsChangeIds.ContainsKey(myItemInfo.MyProcedure.ItemID)) SetChangeId(ItemsChangeIds[myItemInfo.MyProcedure.ItemID], pg);
|
|
else PromptForChangeId(myItemInfo, pg);
|
|
}
|
|
}
|
|
private void PromptForChangeId(ItemInfo myItemInfo, DisplayTabItem pg)
|
|
{
|
|
dlgChgId dlgCI = new dlgChgId(this);
|
|
dlgCI.ShowDialog(this);
|
|
ItemsChangeIds.Add(myItemInfo.MyProcedure.ItemID, ChgId);
|
|
SetChangeId(ChgId, pg);
|
|
}
|
|
|
|
private void SetChangeId(string chgid, DisplayTabItem pg)
|
|
{
|
|
if (pg == null || pg.MyStepTabPanel == null)
|
|
{
|
|
ChgId = null;
|
|
return;
|
|
}
|
|
pg.MyStepTabPanel.MyStepTabRibbon.SetChangeId(chgid);
|
|
ChgId = chgid;
|
|
}
|
|
/// <summary>
|
|
/// This opens a Word page based upon an itemInfo. Since a word document may be a library
|
|
/// document, the related DocID is used for the Word document.
|
|
/// </summary>
|
|
/// <param name="myItemInfo"></param>
|
|
/// <returns></returns>
|
|
private DisplayTabItem OpenDSOTabPage(ItemInfo myItemInfo)
|
|
{
|
|
DisplayTabItem pg = null;
|
|
EntryInfo myEntry = myItemInfo.MyContent.MyEntry;
|
|
string key = "Doc - " + myEntry.DocID;
|
|
if (_MyDisplayTabItems.ContainsKey(key)) // If document page open use it
|
|
{
|
|
pg = _MyDisplayTabItems[key];
|
|
if (pg.MyItemInfo.ItemID != myItemInfo.ItemID)
|
|
{
|
|
string msg = string.Format("{0} is already open", myItemInfo.MyContent.MyEntry.MyDocument.LibTitle);
|
|
MessageBox.Show(msg, "Library Document is Already Open", MessageBoxButtons.OK);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (DSOTabPanel.Count >= DSOTabPanel.MSWordLimit) // Limit the number of open document pages to 18
|
|
{
|
|
MessageBox.Show("Too many Word Documents Open. Please close one of the Documents before attempting to open another");
|
|
return null;
|
|
}
|
|
//if ((myItemInfo.MyContent.MyEntry.MyDocument.LibTitle ?? "") != "")
|
|
// MessageBox.Show("WARNING: All edits made to this Library Document will be applied to all uses of the Document");
|
|
pg = new DisplayTabItem(this.components, this, myItemInfo, key); // Open a new document page
|
|
_MyDisplayTabItems.Add(key, pg);
|
|
}
|
|
SelectDisplayTabItem(pg);
|
|
pg.MyDSOTabPanel.EnterPanel();
|
|
return pg;
|
|
}
|
|
public DisplayTabItem OpenDSOTabPage(DocumentInfo myDocumentInfo)
|
|
{
|
|
CleanUpClosedItems();
|
|
DisplayTabItem pg = null;
|
|
string key = "Doc - " + myDocumentInfo.DocID;
|
|
if (_MyDisplayTabItems.ContainsKey(key)) // If document page open use it
|
|
pg = _MyDisplayTabItems[key];
|
|
else
|
|
{
|
|
if (DSOTabPanel.Count > 18) // Limit the number of open document pages to 18
|
|
{
|
|
MessageBox.Show("Too many Word Documents Open. Please close one of the Documents before attempting to open another");
|
|
return null;
|
|
}
|
|
pg = new DisplayTabItem(this.components, this, myDocumentInfo, key); // Open a new document page
|
|
_MyDisplayTabItems.Add(key, pg);
|
|
}
|
|
SelectDisplayTabItem(pg);
|
|
pg.MyDSOTabPanel.EnterPanel();
|
|
return pg;
|
|
}
|
|
/// <summary>
|
|
/// Clean-up after a page is closed
|
|
/// </summary>
|
|
/// <param name="myDisplayTabItem"></param>
|
|
internal void RemoveItem(DisplayTabItem myDisplayTabItem)
|
|
{
|
|
_MyDisplayTabItems.Remove(myDisplayTabItem.MyKey);
|
|
// Dispose the Panel
|
|
if (myDisplayTabItem.MyStepTabPanel != null)
|
|
myDisplayTabItem.MyStepTabPanel.Dispose();
|
|
if (myDisplayTabItem.MyDSOTabPanel != null)
|
|
myDisplayTabItem.MyDSOTabPanel.CloseDSO();
|
|
components.Remove(myDisplayTabItem);
|
|
myDisplayTabItem.Dispose();
|
|
}
|
|
#endregion
|
|
}
|
|
}
|