60ed4a9e31
Changed casting iteminfo to procedure info to just using procedureinfo object to get pdfnumber for printing pdf
2269 lines
82 KiB
C#
2269 lines
82 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Windows.Forms;
|
|
using System.Runtime.InteropServices; // For DragHelper
|
|
using System.Reflection;
|
|
using Csla;
|
|
using Csla.Validation;
|
|
using VEPROMS.CSLA.Library;
|
|
using System.IO;
|
|
using Volian.Base.Library;
|
|
|
|
namespace Volian.Controls.Library
|
|
{
|
|
#region DelegatesAndEventArgs
|
|
public delegate void vlnTreeViewEvent(object sender, vlnTreeEventArgs args);
|
|
public delegate void vlnTreeViewItemInfoEvent(object sender, vlnTreeItemInfoEventArgs args);
|
|
public delegate bool vlnTreeViewBoolEvent(object sender, vlnTreeEventArgs args);
|
|
public delegate bool vlnTreeViewItemInfoDeleteEvent(object sender, vlnTreeItemInfoEventArgs args);
|
|
public delegate bool vlnTreeViewItemInfoInsertEvent(object sender, vlnTreeItemInfoInsertEventArgs args);
|
|
public delegate bool vlnTreeViewItemInfoPasteEvent(object sender, vlnTreeItemInfoPasteEventArgs args);
|
|
public delegate TreeNode vlnTreeViewTreeNodeEvent(object sender, vlnTreeEventArgs args);
|
|
public delegate DialogResult vlnTreeViewPropertyEvent(object sender, vlnTreePropertyEventArgs args);
|
|
public delegate DialogResult vlnTreeViewPSIEvent(object sender, vlnTreeEventArgs args);
|
|
public delegate void vlnTreeViewSectionInfoEvent(object sender, vlnTreeSectionInfoEventArgs args);
|
|
public delegate void WordSectionDeletedEvent(object sender, WordSectionEventArgs args);
|
|
public delegate void vlnTreeViewPdfEvent(object sender, vlnTreeViewPdfArgs args);
|
|
public partial class vlnTreeSectionInfoEventArgs
|
|
{
|
|
private bool _IsDeleting = false;
|
|
public bool IsDeleting
|
|
{
|
|
get { return _IsDeleting; }
|
|
set { _IsDeleting = value; }
|
|
}
|
|
private SectionInfo _MySectionInfo;
|
|
public SectionInfo MySectionInfo
|
|
{
|
|
get { return _MySectionInfo; }
|
|
set { _MySectionInfo = value; }
|
|
}
|
|
public vlnTreeSectionInfoEventArgs(SectionInfo mySectionInfo)
|
|
{
|
|
_MySectionInfo = mySectionInfo;
|
|
}
|
|
public vlnTreeSectionInfoEventArgs(SectionInfo mySectionInfo,bool isDeleting)
|
|
{
|
|
_MySectionInfo = mySectionInfo;
|
|
_IsDeleting = isDeleting;
|
|
}
|
|
}
|
|
public partial class vlnTreeViewPdfArgs
|
|
{
|
|
private string _MyFilename;
|
|
public string MyFilename
|
|
{
|
|
get { return _MyFilename; }
|
|
set { _MyFilename = value; }
|
|
}
|
|
private byte[] _MyBuffer;
|
|
public byte[] MyBuffer
|
|
{
|
|
get { return _MyBuffer; }
|
|
set { _MyBuffer = value; }
|
|
}
|
|
private string _MyWatermark;
|
|
public string MyWatermark
|
|
{
|
|
get { return _MyWatermark; }
|
|
set { _MyWatermark = value; }
|
|
}
|
|
public vlnTreeViewPdfArgs(string filename, byte[] buffer, string watermark)
|
|
{
|
|
_MyFilename = filename;
|
|
_MyBuffer = buffer;
|
|
_MyWatermark = watermark;
|
|
}
|
|
}
|
|
public partial class vlnTreeEventArgs
|
|
{
|
|
#region Business Methods
|
|
private TreeNode _Node;
|
|
public TreeNode Node
|
|
{
|
|
get { return _Node; }
|
|
set { _Node = value; }
|
|
}
|
|
private TreeNode _Destination=null;
|
|
public TreeNode Destination
|
|
{
|
|
get { return _Destination; }
|
|
set { _Destination = value; }
|
|
}
|
|
private int _Index;
|
|
public int Index
|
|
{
|
|
get { return _Index; }
|
|
set { _Index = value; }
|
|
}
|
|
//jcb multiunit
|
|
private string _Unit;
|
|
public string Unit
|
|
{
|
|
get { return _Unit; }
|
|
set { _Unit = value; }
|
|
}
|
|
private int _UnitIndex = -1;
|
|
public int UnitIndex
|
|
{
|
|
get { return _UnitIndex; }
|
|
set { _UnitIndex = value; }
|
|
}
|
|
//end jcb multiunit
|
|
#endregion
|
|
#region Factory Methods
|
|
private vlnTreeEventArgs() { ;}
|
|
public vlnTreeEventArgs(TreeNode node)
|
|
{
|
|
_Node = node;
|
|
}
|
|
public vlnTreeEventArgs(TreeNode node, TreeNode destination, int index)
|
|
{
|
|
_Node = node;
|
|
_Destination = destination;
|
|
_Index = index;
|
|
}
|
|
//jcb multiunit
|
|
public vlnTreeEventArgs(TreeNode node, TreeNode destination, int index, string unit, int unitIndex)
|
|
{
|
|
_Node = node;
|
|
_Destination = destination;
|
|
_Index = index;
|
|
_Unit = unit;
|
|
_UnitIndex = unitIndex;
|
|
}
|
|
//end jcb multiunit
|
|
#endregion
|
|
}
|
|
public partial class vlnTreeItemInfoEventArgs
|
|
{
|
|
#region Business Methods
|
|
private ItemInfo _MyItemInfo;
|
|
public ItemInfo MyItemInfo
|
|
{
|
|
get { return _MyItemInfo; }
|
|
set { _MyItemInfo = value; }
|
|
}
|
|
#endregion
|
|
#region Factory Methods
|
|
private vlnTreeItemInfoEventArgs() { ;}
|
|
public vlnTreeItemInfoEventArgs(ItemInfo myItemInfo)
|
|
{
|
|
_MyItemInfo = myItemInfo;
|
|
}
|
|
#endregion
|
|
}
|
|
public enum E_InsertType {Before, After, Child};
|
|
public partial class vlnTreeItemInfoInsertEventArgs
|
|
{
|
|
#region Business Methods
|
|
private ItemInfo _MyItemInfo;
|
|
public ItemInfo MyItemInfo
|
|
{
|
|
get { return _MyItemInfo; }
|
|
set { _MyItemInfo = value; }
|
|
}
|
|
private E_InsertType _InsertType;
|
|
public E_InsertType InsertType
|
|
{
|
|
get { return _InsertType; }
|
|
set { _InsertType = value; }
|
|
}
|
|
private int _Type;
|
|
public int Type
|
|
{
|
|
get { return _Type; }
|
|
set { _Type = value; }
|
|
}
|
|
private E_FromType _FromType;
|
|
public E_FromType FromType
|
|
{
|
|
get { return _FromType; }
|
|
set { _FromType = value; }
|
|
}
|
|
private string _StepText;
|
|
public string StepText
|
|
{
|
|
get { return _StepText; }
|
|
set { _StepText = value; }
|
|
}
|
|
#endregion
|
|
#region Factory Methods
|
|
private vlnTreeItemInfoInsertEventArgs() { ;}
|
|
public vlnTreeItemInfoInsertEventArgs(ItemInfo myItemInfo, E_InsertType insertType, string stepText)
|
|
{
|
|
_MyItemInfo = myItemInfo;
|
|
_InsertType = insertType;
|
|
_StepText = stepText;
|
|
}
|
|
public vlnTreeItemInfoInsertEventArgs(ItemInfo myItemInfo, E_InsertType insertType, string stepText, int type, E_FromType fromType)
|
|
{
|
|
_MyItemInfo = myItemInfo;
|
|
_InsertType = insertType;
|
|
_StepText = stepText;
|
|
_Type = type;
|
|
_FromType = fromType;
|
|
}
|
|
#endregion
|
|
}
|
|
#region PasteEventArgs
|
|
public partial class vlnTreeItemInfoPasteEventArgs
|
|
{
|
|
#region Business Methods
|
|
private ItemInfo _MyItemInfo;
|
|
public ItemInfo MyItemInfo
|
|
{
|
|
get { return _MyItemInfo; }
|
|
set { _MyItemInfo = value; }
|
|
}
|
|
private int _CopyStartID;
|
|
public int CopyStartID
|
|
{
|
|
get { return _CopyStartID; }
|
|
set { _CopyStartID = value; }
|
|
}
|
|
private ItemInfo.EAddpingPart _PasteType;
|
|
public ItemInfo.EAddpingPart PasteType
|
|
{
|
|
get { return _PasteType; }
|
|
set { _PasteType = value; }
|
|
}
|
|
private int? _Type;
|
|
public int? Type
|
|
{
|
|
get { return _Type; }
|
|
set { _Type = value; }
|
|
}
|
|
#endregion
|
|
#region Factory Methods
|
|
private vlnTreeItemInfoPasteEventArgs() { ;}
|
|
public vlnTreeItemInfoPasteEventArgs(ItemInfo myItemInfo, int copyStartId, ItemInfo.EAddpingPart pasteType, int? type)
|
|
{
|
|
_MyItemInfo = myItemInfo;
|
|
_CopyStartID = copyStartId;
|
|
_PasteType = pasteType;
|
|
_Type = type;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#endregion
|
|
public partial class vlnTreePropertyEventArgs : EventArgs
|
|
{
|
|
private string _Title;
|
|
public string Title
|
|
{
|
|
get { return _Title; }
|
|
set { _Title = value; }
|
|
}
|
|
private object _ConfigObject;
|
|
public object ConfigObject
|
|
{
|
|
get { return _ConfigObject; }
|
|
set { _ConfigObject = value; }
|
|
}
|
|
private FolderConfig _FolderConfig;
|
|
public FolderConfig FolderConfig
|
|
{
|
|
get { return _FolderConfig; }
|
|
set { _ConfigObject = _FolderConfig = value; }
|
|
}
|
|
private DocVersionConfig _DocVersionConfig;
|
|
public DocVersionConfig DocVersionConfig
|
|
{
|
|
get { return _DocVersionConfig; }
|
|
set { _ConfigObject = _DocVersionConfig = value; }
|
|
}
|
|
private ProcedureConfig _ProcedureConfig;
|
|
public ProcedureConfig ProcedureConfig
|
|
{
|
|
get { return _ProcedureConfig; }
|
|
set { _ConfigObject = _ProcedureConfig = value; }
|
|
}
|
|
private SectionConfig _SectionConfig;
|
|
public SectionConfig SectionConfig
|
|
{
|
|
get { return _SectionConfig; }
|
|
set { _ConfigObject = _SectionConfig = value; }
|
|
}
|
|
private vlnTreePropertyEventArgs() { ;}
|
|
public vlnTreePropertyEventArgs(string title, FolderConfig folderConfig)
|
|
{
|
|
_Title = title;
|
|
FolderConfig = folderConfig;
|
|
}
|
|
public vlnTreePropertyEventArgs(string title, DocVersionConfig docVersionConfig)
|
|
{
|
|
_Title = title;
|
|
DocVersionConfig = docVersionConfig;
|
|
}
|
|
public vlnTreePropertyEventArgs(string title, ProcedureConfig procedureConfig)
|
|
{
|
|
_Title = title;
|
|
ProcedureConfig = procedureConfig;
|
|
}
|
|
public vlnTreePropertyEventArgs(string title, SectionConfig sectionConfig)
|
|
{
|
|
_Title = title;
|
|
DocStyleListConverter.MySection = sectionConfig.MySection;
|
|
SectionConfig = sectionConfig;
|
|
}
|
|
}
|
|
#endregion
|
|
public partial class vlnTreeView : TreeView
|
|
{
|
|
#region Local Vars
|
|
private static readonly log4net.ILog _MyLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
FolderInfo _LastFolderInfo = null;
|
|
ProcedureInfo _LastProcedureInfo = null;
|
|
DocVersionInfo _LastDocVersionInfo = null;
|
|
SectionInfo _LastSectionInfo = null;
|
|
VETreeNode _LastTreeNode = null;
|
|
StepInfo _LastStepInfo = null;
|
|
ItemInfo _LastItemInfo = null;
|
|
#endregion
|
|
#region Events
|
|
public event vlnTreeViewPdfEvent ViewPDF;
|
|
private void OnViewPDF(object sender, vlnTreeViewPdfArgs args)
|
|
{
|
|
if (ViewPDF != null) ViewPDF(sender, args);
|
|
}
|
|
public event vlnTreeViewItemInfoDeleteEvent DeleteItemInfo;
|
|
private bool OnDeleteItemInfo(object sender, vlnTreeItemInfoEventArgs args)
|
|
{
|
|
if (DeleteItemInfo != null) return DeleteItemInfo(sender, args);
|
|
return false;
|
|
}
|
|
public event vlnTreeViewItemInfoInsertEvent InsertItemInfo;
|
|
private bool OnInsertItemInfo(object sender, vlnTreeItemInfoInsertEventArgs args)
|
|
{
|
|
if (InsertItemInfo != null) return InsertItemInfo(sender, args);
|
|
return false;
|
|
}
|
|
public event vlnTreeViewItemInfoPasteEvent PasteItemInfo;
|
|
private bool OnPasteItemInfo(object sender, vlnTreeItemInfoPasteEventArgs args)
|
|
{
|
|
if (PasteItemInfo != null) return PasteItemInfo(sender, args);
|
|
return false;
|
|
}
|
|
public event vlnTreeViewEvent NodeMove;
|
|
private void OnNodeMove(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (NodeMove != null) NodeMove(sender, args);
|
|
}
|
|
public event vlnTreeViewEvent NodeCopy;
|
|
private void OnNodeCopy(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (NodeCopy != null) NodeCopy(sender, args);
|
|
}
|
|
public event vlnTreeViewPropertyEvent NodeOpenProperty;
|
|
private DialogResult OnNodeOpenProperty(object sender, vlnTreePropertyEventArgs args)
|
|
{
|
|
if (NodeOpenProperty != null) return NodeOpenProperty(sender, args);
|
|
return DialogResult.Cancel;
|
|
}
|
|
public event vlnTreeViewPSIEvent NodePSI;
|
|
private DialogResult OnNodePSI(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (NodePSI != null) return NodePSI(sender, args);
|
|
return DialogResult.Cancel;
|
|
}
|
|
public event vlnTreeViewEvent NodeSelect;
|
|
private void OnNodeSelect(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (NodeSelect != null) NodeSelect(sender, args);
|
|
}
|
|
public event vlnTreeViewEvent PrintProcedure;
|
|
private void OnPrintProcedure(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (PrintProcedure != null) PrintProcedure(sender, args);
|
|
}
|
|
public event vlnTreeViewEvent PrintAllProcedures;
|
|
private void OnPrintAllProcedures(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (PrintAllProcedures != null) PrintAllProcedures(sender, args);
|
|
}
|
|
public event vlnTreeViewEvent ApproveProcedure;
|
|
private void OnApproveProcedure(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (ApproveProcedure != null) ApproveProcedure(sender, args);
|
|
}
|
|
public event vlnTreeViewEvent ApproveAllProcedures;
|
|
private void OnApproveAllProcedures(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (ApproveAllProcedures != null) ApproveAllProcedures(sender, args);
|
|
}
|
|
public event vlnTreeViewEvent ApproveSomeProcedures;
|
|
private void OnApproveSomeProcedures(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (ApproveSomeProcedures != null) ApproveSomeProcedures(sender, args);
|
|
}
|
|
public event vlnTreeViewEvent ReportAllProceduresInconsistencies;
|
|
private void OnReportAllProceduresInconsistencies(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (ReportAllProceduresInconsistencies != null) ReportAllProceduresInconsistencies(sender, args);
|
|
}
|
|
public event vlnTreeViewEvent NodeNew;
|
|
private void OnNodeNew(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (NodeNew != null) NodeNew(sender, args);
|
|
}
|
|
/// <summary>
|
|
/// Raised after a new step is added.
|
|
/// </summary>
|
|
public event vlnTreeViewEvent NodeInsert;
|
|
private void OnNodeInsert(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (NodeInsert != null) NodeInsert(sender, args);
|
|
}
|
|
public event vlnTreeViewEvent NodeSelectionChange;
|
|
private void OnNodeSelectionChange(object sender, vlnTreeEventArgs args)
|
|
{
|
|
if (NodeSelectionChange != null) NodeSelectionChange(sender, args);
|
|
}
|
|
public event vlnTreeViewSectionInfoEvent SectionShouldClose;
|
|
private void OnSectionShouldClose(object sender, vlnTreeSectionInfoEventArgs args)
|
|
{
|
|
if (SectionShouldClose != null) SectionShouldClose(sender, args);
|
|
}
|
|
public event WordSectionDeletedEvent WordSectionDeleted;
|
|
internal void OnWordSectionDeleted(object sender, WordSectionEventArgs args)
|
|
{
|
|
WordSectionDeleted(sender, args);
|
|
}
|
|
public event vlnTreeViewItemInfoEvent OpenItem;
|
|
private void OnOpenItem(object sender, vlnTreeItemInfoEventArgs args)
|
|
{
|
|
if (OpenItem != null) OpenItem(sender, args);
|
|
}
|
|
#endregion
|
|
#region Constructors
|
|
public vlnTreeView()
|
|
{
|
|
InitializeComponent();
|
|
this.AllowDrop = true;
|
|
DragHelper.InitCommonControls();
|
|
this.ItemDrag += new ItemDragEventHandler(tv_ItemDrag);
|
|
this.DragDrop += new DragEventHandler(tv_DragDrop);
|
|
this.DragEnter += new DragEventHandler(tv_DragEnter);
|
|
this.DragLeave += new EventHandler(tv_DragLeave);
|
|
this.DragOver += new DragEventHandler(tv_DragOver);
|
|
this.MouseDown += new MouseEventHandler(tv_MouseDown);
|
|
this.KeyPress += new KeyPressEventHandler(tv_KeyPress);
|
|
base.AfterSelect += new TreeViewEventHandler(tv_AfterSelect);
|
|
}
|
|
#endregion
|
|
#region MenuSupport
|
|
private void tv_AfterSelect(object sender, TreeViewEventArgs e)
|
|
{
|
|
if (!_AdjustingTree)
|
|
OnNodeSelectionChange(sender, new vlnTreeEventArgs(e.Node));
|
|
}
|
|
// use to determine which menu items have been selected for those tree nodes
|
|
|
|
// that allow more than one type of operation associated with their selection.
|
|
public enum MenuSelections : int
|
|
{
|
|
Folder = 1, FolderBefore = 2, FolderAfter = 3, DocVersion = 4, Procedure = 5, ProcedureBefore = 6, ProcedureAfter = 7, Section = 8, SectionBefore = 9, SectionAfter = 10, Step = 11, StepBefore = 12, StepAfter = 13, StepReplace = 14
|
|
}
|
|
void tv_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
if (e.Button == MouseButtons.Right)
|
|
{
|
|
VETreeNode tn = this.GetNodeAt(new Point(e.X, e.Y)) as VETreeNode;
|
|
if (tn != null)
|
|
{
|
|
this.SelectedNode = tn as TreeNode;
|
|
Application.DoEvents();
|
|
// Display Menu
|
|
ToolStripMenuItem mi = new ToolStripMenuItem();
|
|
ContextMenu cm = new ContextMenu();
|
|
|
|
#region Menu_New
|
|
if (tn.VEObject as FolderInfo != null)
|
|
{
|
|
// For Folders, if no children, can add either docversion or folder. If children are
|
|
// folders then can only add another folder, and if children are docversions can only
|
|
// add docversion.
|
|
FolderInfo fi = tn.VEObject as FolderInfo;
|
|
if (fi.MyParent != null) // don't allow insert before/after if at top node
|
|
{
|
|
cm.MenuItems.Add("Insert Folder Before", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Insert Folder After", new EventHandler(mi_Click));
|
|
}
|
|
if (fi.FolderDocVersionCount == 0) cm.MenuItems.Add("New Folder", new EventHandler(mi_Click));
|
|
if (fi.ChildFolderCount == 0 && !fi.HasWorkingDraft) cm.MenuItems.Add("Create Working Draft", new EventHandler(mi_Click));
|
|
}
|
|
else if (tn.VEObject as DocVersionInfo != null) // DocVersions can only contain procs
|
|
{
|
|
cm.MenuItems.Add("New Procedure", new EventHandler(mi_Click));
|
|
DocVersionInfo dvi = tn.VEObject as DocVersionInfo;
|
|
if (dvi.MultiUnitCount > 1)
|
|
{
|
|
MenuItem mip = new MenuItem("Print All Procedures for");
|
|
MenuItem mia= new MenuItem("Approve All Procedures for");
|
|
MenuItem mis = new MenuItem("Approve Some Procedures for");
|
|
int k = 0;
|
|
foreach (string s in dvi.UnitNames)
|
|
{
|
|
k++;
|
|
MenuItem mp = mip.MenuItems.Add(s, new EventHandler(miMultiUnit_Click));
|
|
mp.Tag = k;
|
|
MenuItem ma = mia.MenuItems.Add(s, new EventHandler(miMultiUnit_Click));
|
|
ma.Tag = k;
|
|
MenuItem ms = mis.MenuItems.Add(s, new EventHandler(miMultiUnit_Click));
|
|
ms.Tag = k;
|
|
}
|
|
//MenuItem mmp = mip.MenuItems.Add("All Units", new EventHandler(miMultiUnit_Click));
|
|
//mmp.Tag = 0;
|
|
//MenuItem mma = mia.MenuItems.Add("All Units", new EventHandler(miMultiUnit_Click));
|
|
//mma.Tag = 0;
|
|
//MenuItem mms = mis.MenuItems.Add("All Units", new EventHandler(miMultiUnit_Click));
|
|
//mms.Tag = 0;
|
|
cm.MenuItems.Add(mip);
|
|
cm.MenuItems.Add(mia);
|
|
cm.MenuItems.Add(mis);
|
|
}
|
|
else
|
|
{
|
|
cm.MenuItems.Add("Print All Procedures", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Approve All Procedures", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Approve Some Procedures", new EventHandler(mi_Click));
|
|
}
|
|
cm.MenuItems.Add("Report All Procedures Inconsistencies", new EventHandler(mi_Click));
|
|
}
|
|
else if (tn.VEObject as ProcedureInfo != null) // Procs can only contain sections
|
|
{
|
|
ProcedureInfo pri = tn.VEObject as ProcedureInfo;
|
|
if (pri.ActiveFormat.PlantFormat.FormatData.ProcData.PSI.Caption != null) cm.MenuItems.Add("Procedure Specific Information", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Insert Procedure Before", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Insert Procedure After", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("New Section", new EventHandler(mi_Click));
|
|
if (pri.MyDocVersion.MultiUnitCount > 1)
|
|
{
|
|
MenuItem mip = new MenuItem("Print");
|
|
MenuItem mia = new MenuItem("Approve");
|
|
int k = 0;
|
|
foreach (string s in pri.MyDocVersion.UnitNames)
|
|
{
|
|
k++;
|
|
MenuItem mp = mip.MenuItems.Add(s, new EventHandler(miMultiUnit_Click));
|
|
mp.Tag = k;
|
|
MenuItem ma = mia.MenuItems.Add(s, new EventHandler(miMultiUnit_Click));
|
|
ma.Tag = k;
|
|
}
|
|
cm.MenuItems.Add(mip);
|
|
cm.MenuItems.Add(mia);
|
|
AddApprovedRevisionsMultiUnit(cm.MenuItems, pri);
|
|
}
|
|
else
|
|
{
|
|
cm.MenuItems.Add("Print", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Approve", new EventHandler(mi_Click));
|
|
AddApprovedRevisions(cm.MenuItems, pri);
|
|
}
|
|
}
|
|
else if (tn.VEObject as SectionInfo != null)
|
|
{
|
|
// A step Section can contain other steps or can contain subsections (either step section
|
|
// or word doc section). Also note that there can be a mix.
|
|
// A word doc section can contain another subsection (either step section or word doc section),
|
|
// but cannot contain steps.
|
|
SectionInfo si = tn.VEObject as SectionInfo;
|
|
si.MyConfig = null;
|
|
// Do not need step versus Word doc options, user enters this in property page during
|
|
// insert process.
|
|
cm.MenuItems.Add("Insert Section Before", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Insert Section After", new EventHandler(mi_Click));
|
|
if (!si.IsAutoTOCSection)
|
|
{
|
|
bool meta = si.ActiveFormat.PlantFormat.FormatData.SectData.UseMetaSections;
|
|
if (meta) cm.MenuItems.Add("New Subsection", new EventHandler(mi_Click));
|
|
// if this section has subsections, then be sure that the 'editable' data config
|
|
// is set to allow new step creation.
|
|
if (si.IsStepSection)
|
|
{
|
|
SectionConfig sc = si.MyConfig as SectionConfig;
|
|
if (si.Sections==null || si.Sections.Count==0 || (meta && sc != null && si.Sections != null && si.Sections.Count > 0 && sc.SubSection_Edit == "Y"))
|
|
cm.MenuItems.Add("New Step", new EventHandler(mi_Click));
|
|
}
|
|
}
|
|
}
|
|
else if (tn.VEObject as StepInfo != null)
|
|
{
|
|
// check the format for allowable inserts, and also,
|
|
ItemInfo i = tn.VEObject as ItemInfo;
|
|
if (AddToInsertMenu(i, 0)) cm.MenuItems.Add("Insert Step Before", new EventHandler(mi_Click));
|
|
if (AddToInsertMenu(i, 1)) cm.MenuItems.Add("Insert Step After", new EventHandler(mi_Click));
|
|
}
|
|
#endregion
|
|
#region Menu_Open
|
|
if (!tn.IsExpanded && tn.VEObject as SectionInfo != null)
|
|
{
|
|
SectionInfo si = tn.VEObject as SectionInfo;
|
|
if (si.IsStepSection) cm.MenuItems.Add("Open", new EventHandler(mi_Click));
|
|
}
|
|
else if (!tn.IsExpanded && tn.VEObject as StepInfo != null)
|
|
{
|
|
StepInfo stpi = tn.VEObject as StepInfo;
|
|
if (stpi.HasChildren) cm.MenuItems.Add("Open", new EventHandler(mi_Click));
|
|
}
|
|
else if (!tn.IsExpanded)
|
|
cm.MenuItems.Add("Open", new EventHandler(mi_Click));
|
|
#endregion
|
|
#region Menu_CutCopy
|
|
// For initial release, copy is not available for folders or docversions
|
|
if (tn.VEObject as ItemInfo != null)
|
|
{
|
|
cm.MenuItems.Add("Copy", new EventHandler(mi_Click));
|
|
}
|
|
#endregion
|
|
Menu_Paste(tn, cm);
|
|
#region Menu_Delete
|
|
// Add delete to the menu unless at the very 'top' node, on a grouping (partinfo)
|
|
// node (RNOs, Steps, Cautions, Notes) or Folder/DocVersion that contains any items.
|
|
PartInfo pi = tn.VEObject as PartInfo;
|
|
if (pi == null && tn.Parent != null) // it's not a part and it's not the top....
|
|
{
|
|
FolderInfo fi = tn.VEObject as FolderInfo;
|
|
if (fi == null || tn.Nodes.Count == 0) // it's not a folder or it has no children
|
|
{
|
|
DocVersionInfo di = tn.VEObject as DocVersionInfo;
|
|
if (di == null || tn.Nodes.Count == 0) // it's not a docversion or it has no children
|
|
cm.MenuItems.Add("Delete", new EventHandler(mi_Click));
|
|
}
|
|
}
|
|
#endregion
|
|
#region Menu_Properties
|
|
// Add Properties to the menu unless at the very 'top' node or on a grouping (partinfo)
|
|
// node (RNOs, Steps, Cautions, Notes) or at the step level.
|
|
PartInfo pia = tn.VEObject as PartInfo;
|
|
ItemInfo ii = tn.VEObject as ItemInfo;
|
|
if (pia == null && tn.VEObject as StepInfo == null) cm.MenuItems.Add("Properties...", new EventHandler(mi_Click));
|
|
#endregion
|
|
cm.Show(this, new Point(e.X, e.Y));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AddApprovedRevisionsMultiUnit(Menu.MenuItemCollection menuItemCollection, ProcedureInfo pri)
|
|
{
|
|
RevisionInfoList ril = RevisionInfoList.GetByItemID(pri.ItemID);
|
|
if (ril.Count == 0) return;
|
|
MenuItem mi = menuItemCollection.Add("Versions");
|
|
int k = 0;
|
|
int lastApprovedRevisionID = 0;
|
|
foreach (string s in pri.MyDocVersion.UnitNames)
|
|
{
|
|
k++;
|
|
MenuItem mv = mi.MenuItems.Add(s);
|
|
mv.Tag = k;
|
|
ril = RevisionInfoList.GetByItemIDandUnitID(pri.ItemID, k);
|
|
foreach (RevisionInfo ri in ril)
|
|
{
|
|
MenuItem mir = mv.MenuItems.Add(ri.ToString());
|
|
mir.Tag = ri;
|
|
if (ri.LatestVersion.MyStage.IsApproved > 0 && (ri.RevisionID > lastApprovedRevisionID))
|
|
lastApprovedRevisionID = ri.RevisionID;
|
|
if (ri.LatestVersion.PDF != null)
|
|
{
|
|
MenuItem mirp = mir.MenuItems.Add("View Procedure");
|
|
mirp.Tag = ri;
|
|
mirp.Click += new EventHandler(MultiUnitApprovedRevision_Click);
|
|
}
|
|
if (ri.LatestVersion.SummaryPDF != null)
|
|
{
|
|
MenuItem mirs = mir.MenuItems.Add("View Summary of Changes");
|
|
mirs.Tag = ri;
|
|
mirs.Click += new EventHandler(MultiUnitSummaryOfChanges_Click);
|
|
}
|
|
//end added jcb 20111031
|
|
mv.Tag = lastApprovedRevisionID;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AddApprovedRevisions(Menu.MenuItemCollection menuItemCollection, ProcedureInfo pri)
|
|
{
|
|
RevisionInfoList ril = null;
|
|
try
|
|
{
|
|
ril = RevisionInfoList.GetByItemID(pri.ItemID);
|
|
}
|
|
catch
|
|
{
|
|
return;
|
|
}
|
|
if (ril.Count == 0) return;
|
|
MenuItem mi = menuItemCollection.Add("Versions");
|
|
int lastApprovedRevisionID = 0;
|
|
foreach (RevisionInfo ri in ril)
|
|
{
|
|
MenuItem mir = mi.MenuItems.Add(ri.ToString());
|
|
mir.Tag = ri;
|
|
if (ri.LatestVersion.MyStage.IsApproved > 0 && (ri.RevisionID > lastApprovedRevisionID))
|
|
lastApprovedRevisionID = ri.RevisionID;
|
|
//mir.Click += new EventHandler(ApprovedRevision_Click);
|
|
//added jcb 20111031
|
|
if (ri.LatestVersion.PDF != null)
|
|
{
|
|
MenuItem mirp = mir.MenuItems.Add("View Procedure");
|
|
mirp.Tag = ri;
|
|
mirp.Click += new EventHandler(ApprovedRevision_Click);
|
|
}
|
|
if (ri.LatestVersion.SummaryPDF != null)
|
|
{
|
|
MenuItem mirs = mir.MenuItems.Add("View Summary of Changes");
|
|
mirs.Tag = ri;
|
|
mirs.Click += new EventHandler(SummaryOfChanges_Click);
|
|
}
|
|
//end added jcb 20111031
|
|
mi.Tag = lastApprovedRevisionID;
|
|
}
|
|
}
|
|
|
|
void ApprovedRevision_Click(object sender, EventArgs e)
|
|
{
|
|
bool superceded = false;
|
|
MenuItem mi = sender as MenuItem;
|
|
if (mi == null) return;
|
|
RevisionInfo ri = mi.Tag as RevisionInfo;
|
|
{
|
|
MenuItem mip = mi.Parent as MenuItem;
|
|
if (ri.RevisionID < int.Parse(mip.Parent.Tag.ToString()))
|
|
superceded = true;
|
|
}
|
|
vlnTreeViewPdfArgs args = new vlnTreeViewPdfArgs(Volian.Base.Library.TmpFile.CreateFileName(ProcedureInfo.Get(ri.ItemID).PDFNumber), ri.LatestVersion.PDF, superceded ? "Superceded" : "");
|
|
OnViewPDF(sender, args);
|
|
// System.Diagnostics.Process pp = System.Diagnostics.Process.Start(GetDocPdf(ri, superceded));
|
|
}
|
|
void MultiUnitApprovedRevision_Click(object sender, EventArgs e)
|
|
{
|
|
bool superceded = false;
|
|
MenuItem mi = sender as MenuItem;
|
|
if (mi == null) return;
|
|
RevisionInfo ri = mi.Tag as RevisionInfo;
|
|
{
|
|
MenuItem mip = mi.Parent as MenuItem;
|
|
if (ri.RevisionID < int.Parse(mip.Parent.Tag.ToString()))
|
|
superceded = true;
|
|
}
|
|
ItemInfo ii = ItemInfo.Get(ri.ItemID);
|
|
ii.MyDocVersion.DocVersionConfig.SelectedSlave = ri.MyConfig.Applicability_Index;
|
|
vlnTreeViewPdfArgs args = new vlnTreeViewPdfArgs(Volian.Base.Library.TmpFile.CreateFileName(ProcedureInfo.Get(ri.ItemID).PDFNumber), ri.LatestVersion.PDF, superceded ? "Superceded" : "");
|
|
OnViewPDF(sender, args);
|
|
// System.Diagnostics.Process pp = System.Diagnostics.Process.Start(GetDocPdf(ri, superceded));
|
|
}
|
|
void SummaryOfChanges_Click(object sender, EventArgs e)
|
|
{
|
|
MenuItem mi = sender as MenuItem;
|
|
if (mi == null) return;
|
|
RevisionInfo ri = mi.Tag as RevisionInfo;
|
|
vlnTreeViewPdfArgs args = new vlnTreeViewPdfArgs(Volian.Base.Library.TmpFile.CreateFileName(ProcedureInfo.Get(ri.ItemID).PDFNumber + " Summary of Changes"), ri.LatestVersion.SummaryPDF, "");
|
|
OnViewPDF(sender, args);
|
|
// System.Diagnostics.Process pps = System.Diagnostics.Process.Start(GetDocSummaryPdf(ri));
|
|
}
|
|
void MultiUnitSummaryOfChanges_Click(object sender, EventArgs e)
|
|
{
|
|
MenuItem mi = sender as MenuItem;
|
|
if (mi == null) return;
|
|
RevisionInfo ri = mi.Tag as RevisionInfo;
|
|
ItemInfo ii = ItemInfo.Get(ri.ItemID);
|
|
ii.MyDocVersion.DocVersionConfig.SelectedSlave = ri.MyConfig.Applicability_Index;
|
|
vlnTreeViewPdfArgs args = new vlnTreeViewPdfArgs(Volian.Base.Library.TmpFile.CreateFileName(ProcedureInfo.Get(ri.ItemID).PDFNumber + " Summary of Changes"), ri.LatestVersion.SummaryPDF, "");
|
|
OnViewPDF(sender, args);
|
|
// System.Diagnostics.Process pps = System.Diagnostics.Process.Start(GetDocSummaryPdf(ri));
|
|
}
|
|
//private string GetDocPdf(RevisionInfo ri, bool superceded)
|
|
//{
|
|
// string fileName = Volian.Base.Library.TmpFile.CreateFileName(ItemInfo.Get(ri.ItemID).DisplayNumber);
|
|
// FileInfo fi = new FileInfo(VlnSettings.TemporaryFolder + @"\" + fileName);
|
|
// FileStream fs = fi.Create();
|
|
// byte[] myPdf = ri.LatestVersion.PDF;
|
|
// if (myPdf != null) fs.Write(myPdf, 0, myPdf.Length);
|
|
// fs.Close();
|
|
// if (superceded)
|
|
// AddSupercededWatermark(VlnSettings.TemporaryFolder + @"\" + fileName);
|
|
// return VlnSettings.TemporaryFolder + @"\" + fileName;
|
|
//}
|
|
|
|
//private void AddSupercededWatermark(string p)
|
|
//{
|
|
// MessageBox.Show("superceded");
|
|
//}
|
|
//private string GetDocSummaryPdf(RevisionInfo ri)
|
|
//{
|
|
// string fileName = Volian.Base.Library.TmpFile.CreateFileName(ItemInfo.Get(ri.ItemID).DisplayNumber + " Summary of Changes");
|
|
// FileInfo fi = new FileInfo(VlnSettings.TemporaryFolder + @"\" + fileName);
|
|
// FileStream fs = fi.Create();
|
|
// byte[] myPdf = ri.LatestVersion.SummaryPDF;
|
|
// if (myPdf != null) fs.Write(myPdf, 0, myPdf.Length);
|
|
// fs.Close();
|
|
// return VlnSettings.TemporaryFolder + @"\" + fileName;
|
|
//}
|
|
|
|
|
|
private bool AddToInsertMenu(ItemInfo ii, int ba) // 0 = before, 1 = after
|
|
{
|
|
// set up insert buttons based on format
|
|
bool retB = true;
|
|
E_AccStep? actable = 0;
|
|
StepData sd = ii.FormatStepData;
|
|
actable = sd.StepEditData.AcTable;
|
|
if (actable == null) actable = 0;
|
|
|
|
return (ba == 0) ? !ii.IsRNOPart && (actable & E_AccStep.AddingPrev) > 0 :
|
|
!ii.IsRNOPart && (actable & E_AccStep.AddingNext) > 0;
|
|
}
|
|
private void Menu_Paste(VETreeNode tn, ContextMenu cm)
|
|
{
|
|
#region MenuPaste
|
|
// Find what's in paste buffer & determine whether the paste can occur for the selected node.
|
|
object tmpClip = Clipboard.GetData("PromsClipboard");
|
|
if (tmpClip != null)
|
|
{
|
|
PromsClipboard tstClip = (PromsClipboard)tmpClip;
|
|
ItemInfo iiClipboard = ItemInfo.Get(tstClip.itemId);
|
|
// if the item doesn't exist anymore, don't allow the paste, by not adding
|
|
// paste menu items to context menu.
|
|
if (iiClipboard == null)
|
|
{
|
|
Clipboard.Clear();
|
|
return;
|
|
}
|
|
// can it be pasted at current node.
|
|
if (tn.VEObject as DocVersionInfo != null) // paste item must be a proc
|
|
{
|
|
if (iiClipboard.IsProcedure) cm.MenuItems.Add("Paste Procedure", new EventHandler(mi_Click));
|
|
}
|
|
else
|
|
{
|
|
ItemInfo iiPasteHere = tn.VEObject as ItemInfo;
|
|
if (iiPasteHere != null)
|
|
{
|
|
if (iiPasteHere.IsProcedure && iiClipboard.IsProcedure) // procedure can be pasted before/replace/after
|
|
{
|
|
cm.MenuItems.Add("Paste Procedure Before", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Replace Existing Procedure", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Paste Procedure After", new EventHandler(mi_Click));
|
|
}
|
|
else if (iiPasteHere.IsProcedure && iiClipboard.IsSection) // procedure must have sections only
|
|
cm.MenuItems.Add("Paste Section", new EventHandler(mi_Click));
|
|
else if (iiPasteHere.IsSection && iiClipboard.IsSection)
|
|
{
|
|
cm.MenuItems.Add("Paste Section Before", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Replace Existing Section", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Paste Section After", new EventHandler(mi_Click));
|
|
}
|
|
else if (iiPasteHere.IsStepSection && iiClipboard.IsStep)
|
|
cm.MenuItems.Add("Paste Step", new EventHandler(mi_Click));
|
|
else if (iiPasteHere.IsStep && iiClipboard.IsStep)
|
|
{
|
|
if (AddToInsertMenu(iiPasteHere, 0)) cm.MenuItems.Add("Paste Step Before", new EventHandler(mi_Click));
|
|
cm.MenuItems.Add("Replace Existing Step", new EventHandler(mi_Click));
|
|
if (AddToInsertMenu(iiPasteHere, 1)) cm.MenuItems.Add("Paste Step After", new EventHandler(mi_Click));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
//jcb multiunit
|
|
void miMultiUnit_Click(object sender, EventArgs e)
|
|
{
|
|
MenuItem mi = sender as MenuItem;
|
|
MenuItem mip = mi.Parent as MenuItem;
|
|
switch (mip.Text)
|
|
{
|
|
case "Print":
|
|
OnPrintProcedure(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0, mi.Text, (int)mi.Tag));
|
|
break;
|
|
case "Print All Procedures for":
|
|
OnPrintAllProcedures(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0,mi.Text,(int)mi.Tag));
|
|
break;
|
|
case "Approve":
|
|
OnApproveProcedure(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0, mi.Text, (int)mi.Tag));
|
|
break;
|
|
case "Approve All Procedures for":
|
|
OnApproveAllProcedures(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0, mi.Text, (int)mi.Tag));
|
|
break;
|
|
case "Approve Some Procedures for":
|
|
OnApproveSomeProcedures(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0, mi.Text, (int)mi.Tag));
|
|
break;
|
|
default:
|
|
MessageBox.Show(string.Format("Unrecognized Menu Item '{0}'", mip.Text));
|
|
break;
|
|
}
|
|
}
|
|
//end jcb multiunit
|
|
void mi_Click(object sender, EventArgs e)
|
|
{
|
|
MenuItem mi = sender as MenuItem;
|
|
if (mi == null)
|
|
return;
|
|
switch (mi.Text)
|
|
{
|
|
case "Open":
|
|
OpenNode();
|
|
break;
|
|
case "Insert Folder Before":
|
|
tv_NodeNew(MenuSelections.FolderBefore);
|
|
break;
|
|
case "Insert Folder After":
|
|
tv_NodeNew(MenuSelections.FolderAfter);
|
|
break;
|
|
case "New Folder":
|
|
SelectedNode.Expand();
|
|
tv_NodeNew(MenuSelections.Folder);
|
|
break;
|
|
case "Create Working Draft":
|
|
SelectedNode.Expand();
|
|
tv_NodeNew(MenuSelections.DocVersion);
|
|
break;
|
|
case "New Procedure":
|
|
SelectedNode.Expand();
|
|
tv_NodeNew(MenuSelections.Procedure);
|
|
break;
|
|
case "Insert Procedure Before":
|
|
tv_NodeNew(MenuSelections.ProcedureBefore);
|
|
break;
|
|
case "Insert Procedure After":
|
|
tv_NodeNew(MenuSelections.ProcedureAfter);
|
|
break;
|
|
case "New Section":
|
|
case "New Subsection":
|
|
SelectedNode.Expand();
|
|
tv_NodeNew(MenuSelections.Section);
|
|
break;
|
|
case "Insert Section Before":
|
|
tv_NodeNew(MenuSelections.SectionBefore);
|
|
break;
|
|
case "Insert Section After":
|
|
tv_NodeNew(MenuSelections.SectionAfter);
|
|
break;
|
|
case "Insert Step Before":
|
|
tv_NodeNew(MenuSelections.StepBefore);
|
|
break;
|
|
case "Insert Step After":
|
|
tv_NodeNew(MenuSelections.StepAfter);
|
|
break;
|
|
case "New Step":
|
|
SelectedNode.Expand();
|
|
tv_NodeNew(MenuSelections.Step);
|
|
break;
|
|
case "Copy"://Copy the selected node
|
|
tv_NodeCopy();
|
|
break;
|
|
// lots of paste options:
|
|
case "Paste Procedure":
|
|
case "Paste Procedure Before":
|
|
case "Replace Existing Procedure":
|
|
case "Paste Procedure After":
|
|
case "Paste Section":
|
|
case "Paste Section Before":
|
|
case "Replace Existing Section":
|
|
case "Paste Section After":
|
|
case "Paste Step":
|
|
case "Paste Step Before":
|
|
case "Replace Existing Step":
|
|
case "Paste Step After":
|
|
tv_NodePaste(mi.Text);
|
|
break;
|
|
case "Delete":
|
|
if (tv_NodeDelete())
|
|
{
|
|
TreeNode myParent = SelectedNode.Parent;
|
|
SelectedNode.Remove();
|
|
SelectedNode = myParent;
|
|
OnNodeSelect(this, new vlnTreeEventArgs(SelectedNode));
|
|
}
|
|
break;
|
|
case "Properties..."://Show the properties for the selected node
|
|
SetLastValues((VETreeNode)SelectedNode);
|
|
SetupNodeProperties();
|
|
break;
|
|
case "Procedure Specific Information":
|
|
VETreeNode tn = SelectedNode as VETreeNode;
|
|
ProcedureInfo pi = tn.VEObject as ProcedureInfo;
|
|
if (pi != null)
|
|
{
|
|
using (Procedure proc = pi.Get())
|
|
{
|
|
OnNodePSI(this, new vlnTreeEventArgs(tn, null, 0));
|
|
}
|
|
}
|
|
break;
|
|
case "Print":
|
|
OnPrintProcedure(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0));
|
|
break;
|
|
case "Print All Procedures":
|
|
OnPrintAllProcedures(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0));
|
|
break;
|
|
case "Approve":
|
|
OnApproveProcedure(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0));
|
|
break;
|
|
case "Approve All Procedures":
|
|
OnApproveAllProcedures(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0));
|
|
break;
|
|
case "Approve Some Procedures":
|
|
OnApproveSomeProcedures(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0));
|
|
break;
|
|
case "Report All Procedures Inconsistencies":
|
|
OnReportAllProceduresInconsistencies(this, new vlnTreeEventArgs(SelectedNode as VETreeNode, null, 0));
|
|
break;
|
|
default:
|
|
MessageBox.Show(string.Format("Unrecognized Menu Item '{0}'", mi.Text));
|
|
break;
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public struct PromsClipboard
|
|
{
|
|
public int cType;
|
|
public int itemId;
|
|
}
|
|
public enum PromsClipboardType : int
|
|
{
|
|
Copy = 1, Cut = 2
|
|
}
|
|
private void tv_NodePaste(string p)
|
|
{
|
|
object oClip = Clipboard.GetData("PromsClipboard");
|
|
if (oClip == null) return;
|
|
|
|
PromsClipboard iClip = (PromsClipboard) oClip;
|
|
ItemInfo iiClipboard = ItemInfo.Get(iClip.itemId);
|
|
VETreeNode tn = SelectedNode as VETreeNode;
|
|
DocVersionInfo dvi = tn.VEObject as DocVersionInfo;
|
|
if (dvi != null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ItemInfo iiPaste = tn.VEObject as ItemInfo;
|
|
if (iiPaste == null) return;
|
|
if (p.IndexOf("Before") > -1)
|
|
PasteBeforeOrAfter(MenuSelections.StepBefore, tn, iiClipboard.ItemID);
|
|
else if (p.IndexOf("After") > -1)
|
|
PasteBeforeOrAfter(MenuSelections.StepAfter, tn, iiClipboard.ItemID);
|
|
else if (p.IndexOf("Replace") > -1)
|
|
PasteReplace(tn, iiClipboard.ItemID);
|
|
}
|
|
private void PasteBeforeOrAfter(MenuSelections newtype, VETreeNode tn, int copyStartID)
|
|
{
|
|
// If paste-from step is open in the editor, use the OnPasteItemInfo to paste the step and add RTBItems
|
|
// to the step editor panel.
|
|
ItemInfo ii = tn.VEObject as ItemInfo;
|
|
ItemInfo.EAddpingPart pasteOpt = newtype == MenuSelections.StepBefore ? ItemInfo.EAddpingPart.Before : ItemInfo.EAddpingPart.After;
|
|
// If parent step is open in step editor, the 'OnPasteItemInfo' event will cause
|
|
// the item to be pasted in the step editor and the tree.
|
|
if (ii.IsProcedure || !OnPasteItemInfo(this, new vlnTreeItemInfoPasteEventArgs(ii, copyStartID, pasteOpt, ii.MyContent.Type)))
|
|
{
|
|
// The parent step was not open in the step editor, just paste step (in data) and add treenode.
|
|
ItemInfo newItemInfo = null;
|
|
if (newtype == MenuSelections.StepBefore)
|
|
newItemInfo = ii.PasteSiblingBefore(copyStartID);
|
|
else
|
|
newItemInfo = ii.PasteSiblingAfter(copyStartID);
|
|
}
|
|
SelectedNode = (VETreeNode)((newtype == MenuSelections.StepAfter) ? tn.NextNode : tn.PrevNode);
|
|
}
|
|
private void PasteReplace(VETreeNode tn, int copyStartID)
|
|
{
|
|
VETreeNode prevtn = (VETreeNode) tn.PrevNode;
|
|
VETreeNode partn = (VETreeNode) tn.Parent;
|
|
ItemInfo ii = tn.VEObject as ItemInfo;
|
|
if (!OnPasteItemInfo(this, new vlnTreeItemInfoPasteEventArgs(ii, copyStartID, ItemInfo.EAddpingPart.Replace, ii.MyContent.Type)))
|
|
{
|
|
//return;
|
|
ItemInfo replItemInfo = Item.PasteReplace(ii, copyStartID);
|
|
}
|
|
SelectedNode = (VETreeNode)((prevtn != null) ? prevtn.NextNode : partn.FirstNode);
|
|
}
|
|
private void tv_NodeCopy()
|
|
{
|
|
if (SelectedNode==null)return;
|
|
VETreeNode tn = SelectedNode as VETreeNode;
|
|
ItemInfo ii = tn.VEObject as ItemInfo;
|
|
if (ii != null)
|
|
{
|
|
Clipboard.Clear();
|
|
PromsClipboard iClip;
|
|
iClip.itemId = ii.ItemID;
|
|
iClip.cType = (int)PromsClipboardType.Copy;
|
|
DataObject myDO = new DataObject();
|
|
myDO.SetText(ii.DisplayNumber==null||ii.DisplayNumber==""?" ":ii.DisplayNumber);
|
|
myDO.SetData("PromsClipboard", iClip);
|
|
Clipboard.SetDataObject(myDO);
|
|
//Clipboard.SetData("PromsClipboard", iClip);
|
|
//Clipboard.SetData(DataFormats.Text, ii.DisplayNumber);
|
|
}
|
|
}
|
|
#endregion
|
|
#region PropertyPagesInterface
|
|
private void SetupNodeProperties()
|
|
{
|
|
VETreeNode tn = SelectedNode as VETreeNode;
|
|
if (tn==null)return;
|
|
|
|
if ((tn.VEObject as FolderInfo) != null)
|
|
OpenProperties(tn.VEObject as FolderInfo);
|
|
else if ((tn.VEObject as DocVersionInfo) != null)
|
|
OpenProperties(tn.VEObject as DocVersionInfo);
|
|
else if ((tn.VEObject as ProcedureInfo) != null)
|
|
OpenProperties(tn.VEObject as ProcedureInfo);
|
|
else if ((tn.VEObject as SectionInfo) != null)
|
|
OpenProperties(tn.VEObject as SectionInfo);
|
|
else if ((tn.VEObject as StepInfo) != null)
|
|
MessageBox.Show("Open up info tab or whatever is associated with step");
|
|
tn.RefreshNode();
|
|
}
|
|
private void OpenProperties(FolderInfo folderInfo)
|
|
{
|
|
using (Folder folder = folderInfo.Get())
|
|
{
|
|
OnNodeOpenProperty(this, new vlnTreePropertyEventArgs(string.Format("{0} Properties", folder.FolderConfig.Name), folder.FolderConfig));
|
|
}
|
|
}
|
|
private void OpenProperties(DocVersionInfo dvInfo)
|
|
{
|
|
using (DocVersion dv = dvInfo.Get())
|
|
{
|
|
OnNodeOpenProperty(this, new vlnTreePropertyEventArgs(string.Format("{0} Properties", dv.DocVersionConfig.Name), dv.DocVersionConfig));
|
|
}
|
|
}
|
|
private void OpenProperties(ProcedureInfo procInfo)
|
|
{
|
|
using (Procedure proc = procInfo.Get())
|
|
{
|
|
OnNodeOpenProperty(this, new vlnTreePropertyEventArgs(string.Format("{0} {1} Properties", proc.ProcedureConfig.Number, proc.ProcedureConfig.Title), proc.ProcedureConfig));
|
|
}
|
|
}
|
|
private void OpenProperties(SectionInfo sectInfo)
|
|
{
|
|
OnSectionShouldClose(this, new vlnTreeSectionInfoEventArgs(sectInfo));
|
|
using (Section sect = sectInfo.Get())
|
|
{
|
|
string title = null;
|
|
if (sectInfo.SectionConfig.Number.Length > 0)
|
|
title = string.Format("{0} {1} Properties", sectInfo.SectionConfig.Number, sectInfo.SectionConfig.Title);
|
|
else
|
|
title = string.Format("{0} Properties", sectInfo.SectionConfig.Title);
|
|
OnNodeOpenProperty(this, new vlnTreePropertyEventArgs(title, sect.SectionConfig));
|
|
}
|
|
}
|
|
private void OpenProperties(StepInfo stpinfo)
|
|
{
|
|
using (Step stp = stpinfo.Get())
|
|
{
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region OpenNode
|
|
private void tv_KeyPress(object sender, KeyPressEventArgs e)
|
|
{
|
|
if (e.KeyChar == '\r')
|
|
{
|
|
OpenNode();
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
public void OpenNode()
|
|
{
|
|
VETreeNode tn = SelectedNode as VETreeNode;
|
|
if (tn != null)
|
|
{
|
|
if (tn.VEObject.GetType() == typeof(FolderInfo) || tn.VEObject.GetType() == typeof(DocVersionInfo) || tn.VEObject.GetType() == typeof(PartInfo))
|
|
{
|
|
if (tn.Nodes.Count > 0)
|
|
{
|
|
tn.Expand();
|
|
SelectedNode = tn.Nodes[0];
|
|
Focus();
|
|
}
|
|
}
|
|
else
|
|
OnNodeSelect(this, new vlnTreeEventArgs(SelectedNode));
|
|
}
|
|
}
|
|
#endregion
|
|
#region InsertAllLevels
|
|
public void tv_NodeNew(MenuSelections newtype)
|
|
{
|
|
VETreeNode tn = null;
|
|
if (SelectedNode == null) return;
|
|
SetLastValues((VETreeNode)SelectedNode);
|
|
|
|
#region InsertFolderOrDocVersion
|
|
if (_LastFolderInfo != null)
|
|
{
|
|
using (Folder parentfolder = _LastFolderInfo.Get())
|
|
{
|
|
if (newtype == MenuSelections.DocVersion)
|
|
{
|
|
int dvid = -1; // flag to allow user to cancel from dialog & then we remove it.
|
|
using (DocVersion docversion = DocVersion.MakeDocVersion(parentfolder, "Working Draft", "Title", null, null, null))
|
|
{
|
|
ShowBrokenRules(docversion.BrokenRulesCollection);
|
|
SetLastValues(DocVersionInfo.Get(docversion.VersionID));
|
|
if (OnNodeOpenProperty(this, new vlnTreePropertyEventArgs("Working Draft", docversion.DocVersionConfig)) == DialogResult.OK)
|
|
{
|
|
docversion.Save();
|
|
tn = new VETreeNode(_LastDocVersionInfo);
|
|
SelectedNode.Nodes.Add(tn); // add tree node to end of list.
|
|
}
|
|
else
|
|
dvid = docversion.VersionID;
|
|
}
|
|
if (dvid != -1) DocVersion.Delete(dvid);
|
|
}
|
|
else if (newtype == MenuSelections.Folder)
|
|
{
|
|
int f1 = -1; // flag to allow user to cancel from dialog & then we remove it.
|
|
string uniquename = _LastFolderInfo.UniqueChildName("New Folder");
|
|
using (Folder folder = Folder.MakeFolder(parentfolder, parentfolder.MyConnection, uniquename, string.Empty, "Short Name", null, string.Empty, DateTime.Now, VlnSettings.UserID))
|
|
{
|
|
ShowBrokenRules(folder.BrokenRulesCollection);
|
|
FolderInfo fi = FolderInfo.Get(folder.FolderID);
|
|
folder.ManualOrder = fi.ManualOrder;
|
|
SetLastValues(fi);
|
|
if (OnNodeOpenProperty(this, new vlnTreePropertyEventArgs(uniquename, folder.FolderConfig)) == DialogResult.OK)
|
|
{
|
|
folder.Save();
|
|
tn = new VETreeNode((IVEDrillDownReadOnly)_LastFolderInfo);
|
|
SelectedNode.Nodes.Add(tn); // add new tree node to end of childlist.
|
|
}
|
|
else
|
|
f1 = folder.FolderID;
|
|
}
|
|
if (f1 != -1) Folder.Delete(f1);
|
|
}
|
|
else if (newtype == MenuSelections.FolderAfter||newtype == MenuSelections.FolderBefore)
|
|
{
|
|
int f2 = -1;
|
|
string uniquename = _LastFolderInfo.MyParent.UniqueChildName("New Folder");
|
|
int myindex = SelectedNode.Index + ((newtype == MenuSelections.FolderAfter) ? 1 : 0);
|
|
FolderInfo parfolderinfo = FolderInfo.Get(parentfolder.FolderID);
|
|
double? myorder = parfolderinfo.NewManualOrder(myindex);
|
|
using (Folder folder = Folder.MakeFolder(parentfolder.MyParent, parentfolder.MyConnection, uniquename, string.Empty, "Short Name", null, myorder, string.Empty, DateTime.Now, VlnSettings.UserID))
|
|
{
|
|
ShowBrokenRules(folder.BrokenRulesCollection);
|
|
SetLastValues(FolderInfo.Get(folder.FolderID));
|
|
if (OnNodeOpenProperty(this, new vlnTreePropertyEventArgs(uniquename, folder.FolderConfig)) == DialogResult.OK)
|
|
{
|
|
folder.Save();
|
|
tn = new VETreeNode((IVEDrillDownReadOnly)_LastFolderInfo);
|
|
if (newtype == MenuSelections.FolderBefore) SelectedNode.Parent.Nodes.Insert(SelectedNode.Index, tn);
|
|
if (newtype == MenuSelections.FolderAfter) SelectedNode.Parent.Nodes.Insert(SelectedNode.Index + 1, tn);
|
|
}
|
|
else
|
|
f2 = folder.FolderID;
|
|
}
|
|
if (f2 != -1) Folder.Delete(f2);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region InsertProcedure
|
|
else if (newtype == MenuSelections.Procedure)
|
|
{
|
|
int p1 = -1;
|
|
using (Procedure procedure = Procedure.MakeProcedure(_LastDocVersionInfo, _LastDocVersionInfo.Procedures.Count!=0?_LastDocVersionInfo.Procedures[_LastDocVersionInfo.Procedures.Count-1]:null, null, "New Procedure", 0))
|
|
{
|
|
ShowBrokenRules(procedure.BrokenRulesCollection);
|
|
SetLastValues(ProcedureInfo.Get(procedure.ItemID));
|
|
if (OnNodeOpenProperty(this, new vlnTreePropertyEventArgs("New Procedure", procedure.ProcedureConfig)) == DialogResult.OK)
|
|
{
|
|
procedure.Save();
|
|
tn = new VETreeNode(_LastProcedureInfo);
|
|
SelectedNode.Nodes.Add(tn); // add tree node to end of list.
|
|
}
|
|
else
|
|
p1 = procedure.ItemID;
|
|
}
|
|
if (p1 != -1)
|
|
DeleteItemInfoAndChildren(_LastProcedureInfo);// Delete Item and reset Previous and Next
|
|
}
|
|
else if (newtype == MenuSelections.ProcedureAfter || newtype == MenuSelections.ProcedureBefore)
|
|
{
|
|
int p2 = -1;
|
|
int tvindex = SelectedNode.Index;
|
|
// if inserting before, the parent is set in case previous is null, i.e. beginning of the list.
|
|
using (Procedure procedure = Procedure.MakeProcedure((newtype == MenuSelections.ProcedureAfter) ? null : _LastProcedureInfo.ActiveParent, (newtype == MenuSelections.ProcedureAfter) ? _LastProcedureInfo : _LastProcedureInfo.MyPrevious, null, "New Procedure", 0))
|
|
{
|
|
ShowBrokenRules(procedure.BrokenRulesCollection);
|
|
SetLastValues(ProcedureInfo.Get(procedure.ItemID));
|
|
if (OnNodeOpenProperty(this, new vlnTreePropertyEventArgs("New Procedure", procedure.ProcedureConfig)) == DialogResult.OK)
|
|
{
|
|
procedure.Save();
|
|
tn = new VETreeNode(_LastProcedureInfo);
|
|
TreeNode par = SelectedNode.Parent;
|
|
par.Nodes.Insert(tvindex + ((newtype == MenuSelections.ProcedureBefore) ? 0 : 1), tn);
|
|
}
|
|
else
|
|
p2 = procedure.ItemID;
|
|
}
|
|
if (p2 != -1)
|
|
DeleteItemInfoAndChildren(_LastProcedureInfo); // Delete Item and reset Previous and Next
|
|
}
|
|
#endregion
|
|
#region InsertSection
|
|
else if (newtype == MenuSelections.Section) // Insert subsection at end of parents section list
|
|
{
|
|
int s1 = -1;
|
|
if (!(_LastProcedureInfo == null) || !(_LastSectionInfo == null))
|
|
{
|
|
// May need to create 'pseudo' nodes, for the 'Steps' and 'Sections' grouping tree nodes.
|
|
// If no grouping nodes exist off a section (we are adding a subsection), then
|
|
// add a 'pseudo' node.
|
|
// If step(s) exists, but not a section, then need 'pseudo' nodes, i.e. 'Steps' and 'Sections'
|
|
// tree nodes.
|
|
// Otherwise, the 'Sections' pseudo node will exist.
|
|
// Note that this check has to be done before the section is made, otherwise the item will
|
|
// have sections, i.e. the one getting added.
|
|
bool doPseudo = false;
|
|
if (_LastItemInfo.IsSection) // if adding off of a procedure, don't add pseuo.
|
|
{
|
|
if (SelectedNode.Nodes.Count == 0)
|
|
doPseudo = true;
|
|
else if (SelectedNode.Nodes.Count > 0)
|
|
{
|
|
// Check to see if sections already exist, if so, the pseudo node will too.
|
|
bool hasMetaSubs = _LastItemInfo.Sections != null && _LastItemInfo.Sections.Count > 0;
|
|
if (!hasMetaSubs) doPseudo = true;
|
|
}
|
|
}
|
|
using(Section section = CreateNewSection())
|
|
{
|
|
ShowBrokenRules(section.BrokenRulesCollection);
|
|
SetLastValues(SectionInfo.Get(section.ItemID));
|
|
if (OnNodeOpenProperty(this, new vlnTreePropertyEventArgs("New Section", section.SectionConfig)) == DialogResult.OK)
|
|
{
|
|
if (!doPseudo)
|
|
{
|
|
tn = new VETreeNode(_LastSectionInfo);
|
|
SelectedNode.Nodes.Add(tn); // add tree node to end of list.
|
|
OnNodeSelect(this, new vlnTreeEventArgs(tn));
|
|
}
|
|
else
|
|
{
|
|
// may have to add a 'steps' node if a step(s) already exist...
|
|
ItemInfo ii = (SelectedNode as VETreeNode).VEObject as ItemInfo;
|
|
int cpindx = 0;
|
|
if (SelectedNode.Nodes.Count>0)
|
|
{
|
|
VETreeNode vtn = SelectedNode.Nodes[0] as VETreeNode;
|
|
ItemInfo ichld1 = null;
|
|
if (vtn != null) ichld1 = vtn.VEObject as ItemInfo;
|
|
//ItemInfo ichld1 = (SelectedNode.Nodes[0] as VETreeNode).VEObject as ItemInfo;
|
|
if (ichld1 != null && ichld1.IsStep)
|
|
{
|
|
// find associated part node:
|
|
foreach (PartInfo pi in ii.MyContent.ContentParts)
|
|
{
|
|
if (pi.FromType == (int)E_FromType.Step)
|
|
{
|
|
// A 'Steps' pseudo node must be added and any existing steps
|
|
// must be moved below it:
|
|
VETreeNode tnStepPart = new VETreeNode(ii.MyContent.ContentParts[cpindx]);
|
|
foreach (TreeNode tnc in SelectedNode.Nodes)
|
|
{
|
|
TreeNode cloned = (TreeNode)tnc.Clone();
|
|
tnStepPart.Nodes.Add(cloned);
|
|
}
|
|
SelectedNode.Nodes.Clear();
|
|
SelectedNode.Nodes.Add(tnStepPart);
|
|
break;
|
|
}
|
|
cpindx++;
|
|
}
|
|
}
|
|
}
|
|
// At this level, there will only be 'Steps' or 'Sections' nodes. So, use
|
|
// the ContentParts[indx] that was not used to create the pseudo node.
|
|
if (cpindx == 1) cpindx = 0;
|
|
VETreeNode tnPart = new VETreeNode(ii.MyContent.ContentParts[cpindx]);
|
|
SelectedNode.Nodes.Add(tnPart);
|
|
tn = new VETreeNode(_LastSectionInfo);
|
|
tnPart.Nodes.Add(tn); // add tree node to end of list.
|
|
}
|
|
}
|
|
else
|
|
s1 = section.ItemID;
|
|
}
|
|
if (s1 != -1)
|
|
DeleteItemInfoAndChildren(_LastSectionInfo);// Delete Item and reset Previous and Next
|
|
}
|
|
}
|
|
else if (newtype == MenuSelections.SectionAfter || newtype == MenuSelections.SectionBefore)
|
|
{
|
|
int tvindex = SelectedNode.Index;
|
|
// if inserting before, the parent is set in case previous is null, i.e. beginning of the list.
|
|
int s2 = -1;
|
|
using (Section section = Section.MakeSection((newtype == MenuSelections.SectionAfter) ? null : _LastSectionInfo.MyParent, (newtype == MenuSelections.SectionAfter) ? _LastSectionInfo : _LastSectionInfo.MyPrevious, null, "New Section", 10000))
|
|
{
|
|
ShowBrokenRules(section.BrokenRulesCollection);
|
|
SetLastValues(SectionInfo.Get(section.ItemID));
|
|
if (OnNodeOpenProperty(this, new vlnTreePropertyEventArgs("New Section", section.SectionConfig)) == DialogResult.OK)
|
|
{
|
|
tn = new VETreeNode(_LastSectionInfo);
|
|
TreeNode par = SelectedNode.Parent;
|
|
par.Nodes.Insert(tvindex + ((newtype == MenuSelections.SectionBefore) ? 0 : 1), tn);
|
|
}
|
|
else
|
|
s2 = section.ItemID;
|
|
}
|
|
if (s2 != -1)
|
|
DeleteItemInfoAndChildren(_LastSectionInfo);// Delete Item and reset Previous and Next
|
|
}
|
|
#endregion
|
|
#region InsertStep
|
|
else if (newtype == MenuSelections.Step) // insert step from section - no substeps from tree.
|
|
{
|
|
tn = InsertChildStep((VETreeNode)SelectedNode);
|
|
}
|
|
else if (newtype == MenuSelections.StepAfter || newtype == MenuSelections.StepBefore && _LastStepInfo != null)
|
|
{
|
|
tn = InsertBeforeOrAfter(newtype, (VETreeNode)SelectedNode);
|
|
}
|
|
#endregion
|
|
|
|
if (tn != null)
|
|
{
|
|
SelectedNode = tn;
|
|
OnNodeNew(this, new vlnTreeEventArgs(SelectedNode));
|
|
Refresh();
|
|
OnNodeInsert(this, new vlnTreeEventArgs(SelectedNode));
|
|
}
|
|
}
|
|
private Section CreateNewSection()
|
|
{
|
|
if(_LastItemInfo.LastChild(E_FromType.Section) != null)
|
|
return Section.MakeSection(_LastItemInfo, _LastItemInfo.LastChild(E_FromType.Section), null, "New Section", 10000);
|
|
ItemInfo iii = _LastItemInfo.InsertChild(E_FromType.Section, 10000, "New Section", null);
|
|
return Section.Get(iii.ItemID);
|
|
}
|
|
private VETreeNode InsertChildStep(VETreeNode tn)
|
|
{
|
|
// If parent step is open in editor, use the OnInsertItemInfo to insert step & add RTBItems to step editor panel
|
|
ItemInfo ii = tn.VEObject as ItemInfo;
|
|
if (OnInsertItemInfo(this, new vlnTreeItemInfoInsertEventArgs(ii, E_InsertType.Child, "New Step", 20002, E_FromType.Step)))
|
|
{
|
|
return null; // should we try to get to the child?
|
|
}
|
|
// The parent step was not open in the step editor, just create new step and add treenode.
|
|
using (Step step = Step.MakeStep(_LastItemInfo, _LastItemInfo.LastChild(E_FromType.Step), null, "New Step", 20002, E_FromType.Step))
|
|
{
|
|
ShowBrokenRules(step.BrokenRulesCollection);
|
|
SetLastValues(StepInfo.Get(step.ItemID));
|
|
tn = new VETreeNode(_LastStepInfo);
|
|
SelectedNode.Nodes.Add(tn); // add tree node to end of list.
|
|
}
|
|
return tn;
|
|
}
|
|
|
|
private VETreeNode InsertBeforeOrAfter(MenuSelections newtype, VETreeNode tn)
|
|
{
|
|
// If parent step is open in editor, use the OnInsertItemInfo to insert step & add RTBItems to step editor panel
|
|
ItemInfo ii = tn.VEObject as ItemInfo;
|
|
if (OnInsertItemInfo(this, new vlnTreeItemInfoInsertEventArgs(ii,(newtype == MenuSelections.StepAfter) ? E_InsertType.After:E_InsertType.Before, "New Step")))
|
|
{
|
|
return (VETreeNode)((newtype == MenuSelections.StepAfter) ? tn.NextNode : tn.PrevNode);
|
|
}
|
|
// The parent step was not open in the step editor, just create new step and add treenode.
|
|
int tvindex = SelectedNode.Index;
|
|
// if inserting before, the parent is set in case previous is null, i.e. beginning of the list.
|
|
ItemInfo parent = (newtype == MenuSelections.StepAfter) ? null : _LastStepInfo.MyParent;
|
|
using (Step step = Step.MakeStep(parent, (newtype == MenuSelections.StepAfter) ? _LastStepInfo : _LastStepInfo.MyPrevious, null, "New Step", (int)_LastStepInfo.MyContent.Type, (E_FromType)_LastStepInfo.FirstSibling.ItemParts[0].FromType))
|
|
{
|
|
ShowBrokenRules(step.BrokenRulesCollection);
|
|
SetLastValues(StepInfo.Get(step.ItemID));
|
|
tn = new VETreeNode(_LastStepInfo);
|
|
_LastStepInfo.UpdateTransitionText();
|
|
TreeNode par = SelectedNode.Parent;
|
|
par.Nodes.Insert(tvindex + ((newtype == MenuSelections.StepBefore) ? 0 : 1), tn);
|
|
}
|
|
return tn;
|
|
}
|
|
private void ShowBrokenRules(BrokenRulesCollection brs)
|
|
{
|
|
if (brs != null)
|
|
{
|
|
foreach (BrokenRule br in brs)
|
|
{
|
|
Console.WriteLine("broken rule {0}", br.Description);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
#region DeleteAllLevels
|
|
private bool tv_NodeDelete()
|
|
{
|
|
SetLastValues((VETreeNode)SelectedNode);
|
|
|
|
DialogResult result = MessageBox.Show("Are you sure you want to delete " + SelectedNode.Text, "Verify Delete",
|
|
MessageBoxButtons.YesNo, MessageBoxIcon.Question);
|
|
if (result == DialogResult.Yes)
|
|
{
|
|
if (_LastFolderInfo != null)
|
|
{
|
|
Folder.Delete(_LastFolderInfo.FolderID);
|
|
_LastFolderInfo = null;
|
|
return true;
|
|
}
|
|
else if (_LastDocVersionInfo != null)
|
|
{
|
|
DocVersion.Delete(_LastDocVersionInfo.VersionID);
|
|
_LastDocVersionInfo = null;
|
|
return true;
|
|
}
|
|
else if (_LastProcedureInfo != null)
|
|
{
|
|
// always return false because an event gets fired to delete tree nodes.
|
|
if (!DeleteItemInfoAndChildren(_LastProcedureInfo)) return false;
|
|
_LastProcedureInfo = null;
|
|
return false;
|
|
}
|
|
else if (_LastSectionInfo != null)
|
|
{
|
|
OnSectionShouldClose(this, new vlnTreeSectionInfoEventArgs(_LastSectionInfo,true));
|
|
// always return false because an event gets fired to delete tree nodes.
|
|
if (!DeleteItemInfoAndChildren(_LastSectionInfo))
|
|
{
|
|
return false;
|
|
}
|
|
WordSectionEventArgs args = new WordSectionEventArgs(_LastSectionInfo);
|
|
OnWordSectionDeleted(this, args);
|
|
_LastSectionInfo = null;
|
|
return false;
|
|
}
|
|
else if (_LastStepInfo != null)
|
|
{
|
|
// always return false because an event gets fired to delete tree nodes.
|
|
if (!DeleteItemInfoAndChildren(_LastStepInfo)) return false;
|
|
_LastStepInfo = null;
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
private bool DeleteItemInfoAndChildren(ItemInfo ii)
|
|
{
|
|
try
|
|
{
|
|
// send an event to frmVeproms that sends an event to the stepeditor to
|
|
// do delete using RTBItem - this manages windowing from the step editor.
|
|
// If the procedure is open & you're deleting procedure, you want to close open
|
|
// window - this is done in DisplayTabControl-DeleteStepTabItem.
|
|
if (!OnDeleteItemInfo(this, new vlnTreeItemInfoEventArgs(ii)))
|
|
Item.DeleteItemAndChildren(ii);
|
|
return true;
|
|
}
|
|
catch (System.Data.SqlClient.SqlException ex)
|
|
{
|
|
HandleSqlExceptionOnDelete(ex, ii);
|
|
return false;
|
|
}
|
|
}
|
|
private void HandleSqlExceptionOnDelete(System.Data.SqlClient.SqlException ex, ItemInfo ii)
|
|
{
|
|
if (ex.Message.Contains("has External Transitions and has no next step"))
|
|
{
|
|
using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitions(ii.ItemID))
|
|
{
|
|
DialogResult ans = MessageBox.Show("Transitions exist to this step and cannot be adjusted automatically." +
|
|
"\r\n\r\nDo you want to be placed on the " + (exTrans.Count > 1 ? "first " : "") + "substep with the problem Transition?" +
|
|
"\r\n\r\nSubsteps with Problem Transitions" +
|
|
exTrans.Summarize(),
|
|
"Cannot Delete This Step", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
|
|
if (ans == DialogResult.Yes)
|
|
{
|
|
OnOpenItem(this, new vlnTreeItemInfoEventArgs(exTrans[0].MyContent.ContentItems[0]));
|
|
}
|
|
}
|
|
}
|
|
else if (ex.Message.Contains("has External Transitions to it's children"))
|
|
{
|
|
using (TransitionInfoList exTrans = TransitionInfoList.GetExternalTransitionsToChildren(ii.ItemID))
|
|
{
|
|
DialogResult ans = MessageBox.Show("Transitions exist to substeps of this step and cannot be adjusted automatically." +
|
|
"\r\n\r\nDo you want to be placed on the " + (exTrans.Count > 1 ? "first " : "") + "substep with the problem Transition?" +
|
|
"\r\n\r\nSubsteps with Problem Transitions:" +
|
|
exTrans.Summarize(),
|
|
"Cannot Delete This Step", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
|
|
if (ans == DialogResult.Yes)
|
|
{
|
|
OnOpenItem(this, new vlnTreeItemInfoEventArgs(exTrans[0].MyContent.ContentItems[0]));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
MessageBox.Show(ex.Message, "SQL Exception", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
|
|
}
|
|
#endregion
|
|
#region SetLastValuesAndSaveIfChangedStuff
|
|
private void SetLastValues(VETreeNode node)
|
|
{
|
|
_LastTreeNode = node;
|
|
SetLastValues(node.VEObject);
|
|
}
|
|
private void SetLastValues(IVEDrillDownReadOnly veobject)
|
|
{
|
|
_LastFolderInfo = veobject as FolderInfo;
|
|
_LastDocVersionInfo = veobject as DocVersionInfo;
|
|
_LastProcedureInfo = veobject as ProcedureInfo;
|
|
_LastSectionInfo = veobject as SectionInfo;
|
|
_LastStepInfo = veobject as StepInfo;
|
|
_LastItemInfo = veobject as ItemInfo;
|
|
}
|
|
#endregion
|
|
#region Cursor
|
|
private bool SetupDragCursor(ImageList il, TreeNode tn)
|
|
{
|
|
// Reset image list used for drag image
|
|
il.Images.Clear();
|
|
int howBig = tn.Bounds.Size.Width + this.Indent;
|
|
if (howBig > 256) howBig = 256;
|
|
il.ImageSize = new Size(howBig, tn.Bounds.Height);
|
|
|
|
// Create new bitmap
|
|
// This bitmap will contain the tree node image to be dragged
|
|
Bitmap bmp = new Bitmap(tn.Bounds.Width + this.Indent, tn.Bounds.Height);
|
|
|
|
// Get graphics from bitmap
|
|
Graphics gfx = Graphics.FromImage(bmp);
|
|
|
|
// Draw node icon into the bitmap
|
|
if (this.ImageList != null) gfx.DrawImage(this.ImageList.Images[0], 0, 0);
|
|
|
|
// Draw node label into bitmap
|
|
gfx.DrawString(tn.Text, this.Font, new SolidBrush(this.ForeColor),
|
|
// new SolidBrush(Color.Blue),
|
|
(float)this.Indent, 1.0f);
|
|
|
|
// Add bitmap to imagelist
|
|
_dragImageList.Images.Add(bmp);
|
|
|
|
// Get mouse position in client coordinates
|
|
Point p = this.PointToClient(Control.MousePosition);
|
|
|
|
// Compute delta between mouse position and node bounds
|
|
int dx = p.X + this.Indent - tn.Bounds.Left;
|
|
int dy = p.Y - tn.Bounds.Top;
|
|
|
|
// Begin dragging image
|
|
return DragHelper.ImageList_BeginDrag(_dragImageList.Handle, 0, dx, dy);
|
|
}
|
|
private void tv_ItemDrag(object sender, System.Windows.Forms.ItemDragEventArgs e)
|
|
{
|
|
// Get drag node and select it
|
|
try
|
|
{
|
|
TreeNode dragNode = (TreeNode)e.Item;
|
|
Type t = dragNode.GetType();
|
|
//if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("Item Drag {0} - {1}", t.FullName, t.BaseType.FullName);
|
|
Type t2 = Type.GetType(t.FullName);
|
|
//if(t2 != null)
|
|
// if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("Item Drag {0} - {1}", t2.FullName, t2.BaseType.FullName);
|
|
this.SelectedNode = dragNode;
|
|
ItemInfo iidrag = ((VETreeNode)dragNode).VEObject as ItemInfo;
|
|
FolderInfo fdrag = ((VETreeNode)dragNode).VEObject as FolderInfo;
|
|
DocVersionInfo ddrag = ((VETreeNode)dragNode).VEObject as DocVersionInfo;
|
|
if ((iidrag == null && fdrag == null && ddrag == null))
|
|
{
|
|
MessageBox.Show("Cannot drag/drop a grouping node.");
|
|
return;
|
|
}
|
|
// don't put up message, message kept coming up on any selection of node (to copy, properties, etc)
|
|
//if (iidrag != null && iidrag.IsStep) return;
|
|
if (SetupDragCursor(_dragImageList, dragNode))
|
|
{
|
|
this.DoDragDrop(dragNode, DragDropEffects.Move | DragDropEffects.Copy);// Begin dragging
|
|
DragHelper.ImageList_EndDrag();// End dragging image
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if(_MyLog.IsErrorEnabled)_MyLog.Error("tv_ItemDrag", ex);
|
|
}
|
|
}
|
|
#endregion
|
|
#region DragDrop
|
|
ImageList _dragImageList = new ImageList();
|
|
public enum DropPosition : int
|
|
{
|
|
Child = 0, Before = 1, After = 2
|
|
}
|
|
private class DropLocation
|
|
{
|
|
#region Business Methods
|
|
private TreeNode _dropNode;
|
|
public TreeNode DropNode
|
|
{
|
|
get { return _dropNode; }
|
|
set { _dropNode = value; }
|
|
}
|
|
private int _index;
|
|
public int Index
|
|
{
|
|
get { return _index; }
|
|
set { _index = value; }
|
|
}
|
|
private DropPosition _position;
|
|
public DropPosition Position
|
|
{
|
|
get { return _position; }
|
|
set { _position = value; }
|
|
}
|
|
DateTime _lastScroll;
|
|
public DateTime LastScroll
|
|
{
|
|
get { return _lastScroll; }
|
|
}
|
|
private string _location = string.Empty;
|
|
#endregion
|
|
#region Constructors
|
|
public DropLocation(TreeView tv, System.Windows.Forms.DragEventArgs e, DateTime lastScroll)
|
|
{
|
|
_lastScroll = lastScroll;
|
|
_dropNode = tv.GetNodeAt(tv.PointToClient(new Point(e.X, e.Y)));
|
|
if (_dropNode == null) return;
|
|
int OffsetY = tv.PointToClient(Cursor.Position).Y - _dropNode.Bounds.Top;
|
|
if (OffsetY < _dropNode.Bounds.Height / 3) // First Third - Before
|
|
{
|
|
_index = _dropNode.Index;
|
|
_dropNode = _dropNode.Parent;
|
|
_position = DropPosition.Before;
|
|
_location = string.Format("Before1 {0}[{1}] y={2}", _dropNode.Text, _index, OffsetY);
|
|
}
|
|
else if ((OffsetY / 2) < _dropNode.Bounds.Height / 3) // Second Third - Child
|
|
{
|
|
_location = string.Format("Child {0} y={1}", _dropNode.Text, OffsetY);
|
|
_position = DropPosition.Child;
|
|
_index = 0;
|
|
//if (_dropNode.Parent == null)
|
|
//{
|
|
// if(_MyLog.IsInfoEnabled)_MyLog.Info("Root Node");
|
|
//}
|
|
}
|
|
else // Last Third - After Now I need to check the X value
|
|
{
|
|
if (_dropNode.NextVisibleNode != null && _dropNode.Nodes.Count > 0 && _dropNode.IsExpanded)// Has Children & Expanded - Insert first child
|
|
{
|
|
// _dropNode = _dropNode.Nodes[0];
|
|
_index = 0;
|
|
_position = DropPosition.Before;
|
|
_location = string.Format("Before2 {0}[{1}] y={2}", _dropNode.Text, _index, OffsetY);
|
|
}
|
|
else // No Children or Children Collapsed - Insert Next at various levels depending upon horizontal location.
|
|
{
|
|
Point pt = tv.PointToClient(new Point(e.X, e.Y));
|
|
TreeNode nextParent = _dropNode.NextNode;
|
|
if (nextParent != null) nextParent = nextParent.Parent;
|
|
do
|
|
{
|
|
_index = _dropNode.Index;
|
|
_dropNode = _dropNode.Parent;
|
|
} while (pt.X < _dropNode.Bounds.X && _dropNode != nextParent);
|
|
_location = string.Format("After {0}[{1}] y={2}", _dropNode.Text, _index, OffsetY);
|
|
_position = DropPosition.After;
|
|
}
|
|
}
|
|
LimitMoves(e);
|
|
}
|
|
public void LimitMoves(DragEventArgs e)
|
|
{
|
|
if ((e.KeyState & 8) == 0)
|
|
{
|
|
//TreeNode dragNode = (TreeNode)e.Data.GetData("System.Windows.Forms.TreeNode");
|
|
//TreeNode dragNode = (TreeNode)e.Data.GetData("TreeTest.FolderTreeNode");
|
|
TreeNode dragNode = vlnTreeView.GetTreeNodeFromData(e.Data);
|
|
switch (_position)
|
|
{
|
|
case DropPosition.Before:
|
|
if (dragNode == _dropNode.Nodes[_index] || dragNode == _dropNode.Nodes[_index].PrevNode)
|
|
{
|
|
// if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("Before {0} {1} {2} {3} {4}", dragNode.Text ,_position.ToString() , _dropNode.Nodes[_index].Text
|
|
// ,_dropNode.Nodes[_index].PrevNode,_dropNode.Nodes[_index].NextNode);
|
|
_dropNode = null;
|
|
}
|
|
break;
|
|
case DropPosition.Child:
|
|
if (dragNode.Parent == _dropNode)
|
|
{
|
|
// if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("Child {0} {1} {2} {3} {4} {5}", dragNode.Text ,_position.ToString() , _dropNode.Nodes[_index].Text
|
|
// ,_dropNode.Nodes[_index].PrevNode,_dropNode.Nodes[_index].NextNode,DateTime.Now);
|
|
_dropNode = null;
|
|
}
|
|
break;
|
|
case DropPosition.After:
|
|
if (dragNode == _dropNode.Nodes[_index] || dragNode == _dropNode.Nodes[_index].NextNode)
|
|
{
|
|
// if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("After {0} {1} {2} {3} {4}", dragNode.Text ,_position.ToString() , _dropNode.Nodes[_index].Text
|
|
// ,_dropNode.Nodes[_index].PrevNode,_dropNode.Nodes[_index].NextNode);
|
|
_dropNode = null;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0}[{1}].{2}", _dropNode.Text, _index, _position.ToString());
|
|
}
|
|
#region Drawing
|
|
private void TreeNodeTriangle(Graphics g)
|
|
{
|
|
Rectangle r = _dropNode.Bounds;
|
|
int RightPos = r.Right + 6;
|
|
Point[] RightTriangle = new Point[]{
|
|
new Point(RightPos, r.Y ),
|
|
new Point(RightPos - (r.Height / 2), r.Y + (r.Height / 2)),
|
|
new Point(RightPos, r.Y + r.Height),
|
|
new Point(RightPos - (r.Height / 3), r.Y + (r.Height / 2))
|
|
};
|
|
g.FillPolygon(System.Drawing.Brushes.Black, RightTriangle);
|
|
}
|
|
private void InsertPointer(TreeNode tn, Graphics g)
|
|
{
|
|
TreeView tv = _dropNode.TreeView;
|
|
Rectangle r2 = _dropNode.Nodes[_index].Bounds;
|
|
Rectangle r3 = tn.Bounds;
|
|
int y = (_position == DropPosition.Before ? r2.Y : r3.Bottom);
|
|
int x = r2.Left;
|
|
|
|
if (y == 0)
|
|
{
|
|
return;
|
|
}
|
|
//if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("Line at {0} Node {1}[{2}] {3}", _location, _dropNode.Text, _index, _position.ToString());
|
|
Color lc = (_position == DropPosition.After ? Color.Red : Color.Blue);
|
|
Brush lb = (_position == DropPosition.After ? Brushes.Red : Brushes.Blue);
|
|
Point[] RightTriangle;
|
|
if (_position == DropPosition.After)
|
|
{
|
|
RightTriangle = new Point[]{
|
|
new Point(x, y ),
|
|
new Point(x+4, y+4),
|
|
new Point(x+8, y)};
|
|
}
|
|
else
|
|
{
|
|
RightTriangle = new Point[]{
|
|
new Point(x, y),
|
|
new Point(x+4, y-4),
|
|
new Point(x+8, y)};
|
|
}
|
|
g.DrawLine(new System.Drawing.Pen(lc, 2), new Point(r2.Left, y), new Point(tv.Width - 8, y));
|
|
g.FillPolygon(lb, RightTriangle);
|
|
}
|
|
public void ShowLocation(System.Windows.Forms.DragEventArgs e, bool ScrollOnly)
|
|
{
|
|
//if (e.Effect == DragDropEffects.None) return;
|
|
if (_dropNode != null)
|
|
{
|
|
// if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("ShowLocation1 {0} {1}", e.Effect.ToString(), DateTime.Now.Millisecond);
|
|
DragHelper.ImageList_DragShowNolock(false);
|
|
TreeView tv = _dropNode.TreeView;
|
|
TreeNode tmp = tv.GetNodeAt(tv.PointToClient(new Point(e.X, e.Y)));
|
|
// if (!ScrollOnly)
|
|
// {
|
|
if (ScrollTreeView(tmp) || !ScrollOnly)
|
|
{
|
|
//if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("ShowLocation2 {0} {1}", e.Effect.ToString(), DateTime.Now.Millisecond);
|
|
tv.Refresh();
|
|
if (e.Effect != DragDropEffects.None)
|
|
{
|
|
//tv.SelectedNode = dropNode;
|
|
Graphics g = tv.CreateGraphics();
|
|
TreeNodeTriangle(g);
|
|
if (_position != DropPosition.Child)InsertPointer(tmp, g);
|
|
}
|
|
}
|
|
// }
|
|
// else ScrollTreeView(tmp);
|
|
DragHelper.ImageList_DragShowNolock(true);
|
|
}
|
|
}
|
|
#endregion
|
|
public void ShowLocation()
|
|
{
|
|
//if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("{0}[{1}] {2}", _dropNode.Text, _index, _position.ToString());
|
|
}
|
|
#region AutoScroll
|
|
private bool ScrollTreeView(TreeNode tn)
|
|
{
|
|
bool retval = false;
|
|
TimeSpan ts = new TimeSpan(DateTime.Now.Ticks - _lastScroll.Ticks);
|
|
if (ts.Milliseconds > 100)// This controls the scroll speed
|
|
{
|
|
int top = tn.Bounds.Top;
|
|
_lastScroll = DateTime.Now;
|
|
if (tn.TreeView.ClientSize.Height < tn.Bounds.Bottom) tn.EnsureVisible();// Make sure that the current node is visible
|
|
if (tn.NextVisibleNode != null && tn.TreeView.ClientSize.Height < tn.NextVisibleNode.Bounds.Bottom)
|
|
tn.NextVisibleNode.EnsureVisible();// Make sure that the next node is visible
|
|
else
|
|
if (tn.PrevVisibleNode != null && tn.PrevVisibleNode.PrevVisibleNode != null && tn.PrevVisibleNode.PrevVisibleNode.IsVisible == false)
|
|
tn.PrevVisibleNode.PrevVisibleNode.EnsureVisible();// Make sure that the previous node is visible }
|
|
else
|
|
if (tn.PrevVisibleNode != null && tn.PrevVisibleNode.IsVisible == false)
|
|
tn.PrevVisibleNode.EnsureVisible();// Make sure that the previous node is visible
|
|
retval = (top != tn.Bounds.Top);
|
|
// if (retval) if(_MyLog.IsInfoEnabled)_MyLog.Info("Scroll");
|
|
}
|
|
return retval;
|
|
}
|
|
#endregion
|
|
public bool Equals(DropLocation dl)
|
|
{
|
|
return (dl != null && _lastScroll.Equals(dl.LastScroll) && _dropNode.Equals(dl.DropNode) &&
|
|
_position.Equals(dl.Position));
|
|
}
|
|
}
|
|
private DropLocation _LastDropLocation = null;
|
|
private void tv_DragOver(object sender, System.Windows.Forms.DragEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
TreeNode dragNode = GetTreeNodeFromData(e.Data);
|
|
// Compute drag position and move image
|
|
Point formP = this.FindForm().PointToClient(new Point(e.X, e.Y));
|
|
DragHelper.ImageList_DragMove(formP.X - this.Left, formP.Y - this.Top);
|
|
DropLocation dl = new DropLocation(this, e, _LastDropLocation == null ? DateTime.Now : _LastDropLocation.LastScroll);
|
|
string s = string.Empty;
|
|
if (dl.DropNode == null)
|
|
{
|
|
e.Effect = DragDropEffects.None;
|
|
}
|
|
else
|
|
{
|
|
DragDropEffects ee = e.Effect;
|
|
if (e.KeyState == 13) // Shift and Control Keys to do a move.
|
|
ee = DragDropEffects.Move;
|
|
else
|
|
ee = DragDropEffects.None; // Default - Do nothing
|
|
if (IsChild(dragNode, dl.DropNode)) // Don't copy or move to a child node
|
|
ee = DragDropEffects.None;
|
|
else if (IsDocVersion((VETreeNode)dragNode)) // Don't move docversions
|
|
ee = DragDropEffects.None;
|
|
else if (IsFolder((VETreeNode)dragNode)) // Folder move is only valid if moving to folder with NO docversions
|
|
{
|
|
FolderInfo fdropi = ((VETreeNode)dl.DropNode).VEObject as FolderInfo;
|
|
if (fdropi == null || fdropi.FolderDocVersionCount > 0) ee = DragDropEffects.None;
|
|
}
|
|
else if (IsSection((VETreeNode)dragNode))
|
|
{
|
|
// A section can be moved within a procedure or to a section within the same procedure...
|
|
// For HLP, just move within the same procedure
|
|
// TODO: allow for section move within subsections.
|
|
ProcedureInfo pdropi = ((VETreeNode)dl.DropNode).VEObject as ProcedureInfo;
|
|
if (pdropi == null || (dragNode.Parent != dl.DropNode)) ee = DragDropEffects.None;
|
|
}
|
|
else if (!IsFolder((VETreeNode)dragNode) && (dragNode.Parent != dl.DropNode))
|
|
ee = DragDropEffects.None;
|
|
if (e.Effect != ee) e.Effect = ee;
|
|
dl.ShowLocation(e, dl.Equals(_LastDropLocation));
|
|
_LastDropLocation = dl;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if(_MyLog.IsErrorEnabled)_MyLog.Error("tv_DragOver", ex);
|
|
}
|
|
}
|
|
|
|
private bool IsSection(VETreeNode vETreeNode)
|
|
{
|
|
SectionInfo sectInfo = vETreeNode.VEObject as SectionInfo;
|
|
if (sectInfo != null) return true;
|
|
return false;
|
|
}
|
|
private bool IsProcedure(VETreeNode vETreeNode)
|
|
{
|
|
ProcedureInfo procInfo = vETreeNode.VEObject as ProcedureInfo;
|
|
if (procInfo != null) return true;
|
|
return false;
|
|
}
|
|
private bool IsDocVersion(VETreeNode dragNode)
|
|
{
|
|
DocVersionInfo dvInfo = dragNode.VEObject as DocVersionInfo;
|
|
if (dvInfo != null) return true;
|
|
return false;
|
|
}
|
|
private static TreeNode GetTreeNodeFromData(IDataObject datobj)
|
|
{
|
|
foreach (string s in datobj.GetFormats())
|
|
{
|
|
try
|
|
{
|
|
return (TreeNode)datobj.GetData(s);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if(_MyLog.IsErrorEnabled)_MyLog.Error("GetTreeNodeFromData", ex);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
private bool IsFolder(VETreeNode veTreeNode)
|
|
{
|
|
return (veTreeNode.VEObject.GetType() == typeof(FolderInfo));
|
|
}
|
|
private void tv_DragDrop(object sender, System.Windows.Forms.DragEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
TreeNode dragNode = GetTreeNodeFromData(e.Data);
|
|
DragHelper.ImageList_DragLeave(this.Handle);
|
|
int index = _LastDropLocation.Index + (_LastDropLocation.Position == DropPosition.After ? 1 : 0);
|
|
int myIndex = index;
|
|
if (dragNode.Parent == _LastDropLocation.DropNode && dragNode.Index <= _LastDropLocation.Index) index--;
|
|
if (e.Effect == DragDropEffects.Move)// If Move Remove drag node from parent
|
|
dragNode.Remove();
|
|
else
|
|
dragNode = Clone(dragNode);
|
|
_LastDropLocation.DropNode.Nodes.Insert(index, dragNode);
|
|
this.SelectedNode = dragNode;
|
|
FolderInfo fdragi = ((VETreeNode)dragNode).VEObject as FolderInfo;
|
|
FolderInfo fdropi = ((VETreeNode)_LastDropLocation.DropNode).VEObject as FolderInfo;
|
|
if (fdragi != null && fdropi != null && fdropi.FolderDocVersionCount==0)
|
|
{
|
|
using (Folder fdrag = fdragi.Get())
|
|
{
|
|
using (Folder fdrop = fdropi.Get())
|
|
{
|
|
fdrag.ManualOrder = fdropi.NewManualOrder(myIndex);
|
|
fdrag.MyParent = fdrop;
|
|
fdrag.Save();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
// No drag/drop supported for document versions.
|
|
|
|
// Allow drag/drop of procedures within a Document Version (must have same parent). Note that drop location
|
|
// may either be a document version or a procedure depending on where the user wants to position the procedure.
|
|
ProcedureInfo pdragi = ((VETreeNode)dragNode).VEObject as ProcedureInfo;
|
|
ProcedureInfo pdropi = null;
|
|
if (pdragi != null) // moving a procedure
|
|
{
|
|
pdropi = ((VETreeNode)_LastDropLocation.DropNode).VEObject as ProcedureInfo;
|
|
if (pdropi != null && pdragi.ActiveParent == pdropi.ActiveParent)
|
|
{
|
|
pdragi.MoveProcedure(pdragi.ActiveParent, myIndex);
|
|
return;
|
|
}
|
|
DocVersionInfo dvdropi = ((VETreeNode)_LastDropLocation.DropNode).VEObject as DocVersionInfo;
|
|
DocVersionInfo dvdragpar = pdragi.ActiveParent as DocVersionInfo;
|
|
if (dvdropi != null && dvdragpar.VersionID == dvdropi.VersionID)
|
|
{
|
|
pdragi.MoveProcedure(dvdropi, myIndex);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Allow drag/drop of sections within the same procedure or same section (if subsection) (must have same parent)
|
|
SectionInfo sdragi = ((VETreeNode)dragNode).VEObject as SectionInfo;
|
|
SectionInfo sdropi = null;
|
|
if (sdragi != null) // moving a section
|
|
{
|
|
sdropi = ((VETreeNode)_LastDropLocation.DropNode).VEObject as SectionInfo;
|
|
if (sdropi != null && sdragi.ActiveParent == sdropi.ActiveParent)
|
|
{
|
|
sdragi.MoveSection(sdragi, myIndex);
|
|
return;
|
|
}
|
|
pdropi = ((VETreeNode)_LastDropLocation.DropNode).VEObject as ProcedureInfo;
|
|
if (pdropi != null && ((ItemInfo)(sdragi.ActiveParent)).ItemID == pdropi.ItemID)
|
|
{
|
|
sdragi.MoveSection(pdropi, myIndex);
|
|
sdragi.Moving = true;
|
|
OnNodeSelect(dragNode, new vlnTreeEventArgs(dragNode));
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Allow drag/drop of steps within the same parent only
|
|
StepInfo stdragi = ((VETreeNode)dragNode).VEObject as StepInfo;
|
|
StepInfo stdropi = null;
|
|
if (stdragi != null) // moving a step
|
|
{
|
|
stdropi = ((VETreeNode)_LastDropLocation.DropNode).VEObject as StepInfo;
|
|
if (stdropi != null && stdragi.ActiveParent == stdropi.ActiveParent)
|
|
{
|
|
stdragi.MoveStep(stdragi.ActiveParent, myIndex);
|
|
return;
|
|
}
|
|
sdropi = ((VETreeNode)_LastDropLocation.DropNode).VEObject as SectionInfo;
|
|
if (sdropi != null && stdragi.MyParent.ItemID == sdropi.ItemID)
|
|
{
|
|
stdragi.MoveStep(stdragi.ActiveParent, myIndex);
|
|
return;
|
|
}
|
|
// the following handles items under the app nodes of 'steps', 'notes', 'cautions', etc.
|
|
if (sdropi == null && dragNode.Parent == _LastDropLocation.DropNode)
|
|
{
|
|
stdragi.MoveStep(stdragi.ActiveParent, myIndex);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if(_MyLog.IsErrorEnabled)_MyLog.Error("tv_DragDrop", ex);
|
|
}
|
|
}
|
|
// private void DumpMembers(object o)
|
|
// {
|
|
// Type t = o.GetType();
|
|
// //if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("\r\n\r\nMembers for type {0}", t.ToString());
|
|
// MemberInfo[] mis = t.GetMembers();
|
|
// int i = 0;
|
|
// foreach (MemberInfo mi in mis)
|
|
// {
|
|
// i++;
|
|
// try
|
|
// {
|
|
// //if(mi.MemberType != MemberTypes.Method)
|
|
// //if(_MyLog.IsInfoEnabled)_MyLog.InfoFormat("{0} {1} {2}", i, mi.Name, mi.MemberType);
|
|
//// if (fi.Name == "TreeView")
|
|
//// fi.SetValue(o, null);
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// if(_MyLog.IsErrorEnabled)_MyLog.Error("DumpMembers", ex);
|
|
// }
|
|
// }
|
|
// }
|
|
private TreeNode Clone(TreeNode tn)
|
|
{
|
|
|
|
TreeNode tmp = (TreeNode)tn.Clone();
|
|
ExpandMatch(tmp,tn);
|
|
return tmp;
|
|
}
|
|
private void tv_DragDropOld(object sender, System.Windows.Forms.DragEventArgs e)
|
|
{
|
|
TreeNode dragNode = (TreeNode)e.Data.GetData("System.Windows.Forms.TreeNode");// Get the drag node
|
|
DragHelper.ImageList_DragLeave(this.Handle);
|
|
TreeNode cloneNode = (TreeNode)dragNode.Clone();// copy the source node
|
|
ExpandMatch(cloneNode, dragNode);
|
|
_LastDropLocation.DropNode.Nodes.Insert(_LastDropLocation.Index + (_LastDropLocation.Position == DropPosition.After ? 1 : 0), cloneNode);
|
|
if (e.Effect == DragDropEffects.Move)// If Move Remove drag node from parent
|
|
dragNode.Remove();
|
|
this.SelectedNode = cloneNode;
|
|
}
|
|
private void tv_DragEnter(object sender, System.Windows.Forms.DragEventArgs e)
|
|
{
|
|
DragHelper.ImageList_DragEnter(this.Handle, e.X - this.Left, e.Y - this.Top);
|
|
}
|
|
private void tv_DragLeave(object sender, System.EventArgs e)
|
|
{
|
|
DragHelper.ImageList_DragLeave(this.Handle);
|
|
this.Refresh();
|
|
}
|
|
private void ExpandMatch(TreeNode tn1, TreeNode tn2)
|
|
{
|
|
if (tn2.IsExpanded) tn1.Expand();
|
|
foreach (TreeNode tc in tn2.Nodes) ExpandMatch(tn1.Nodes[tc.Index], tc);
|
|
}
|
|
private bool IsChild(TreeNode parent, TreeNode child)
|
|
{
|
|
if (parent.Equals(child)) return true;// Check against self
|
|
foreach (TreeNode tc in parent.Nodes) if (IsChild(tc, child)) return true;//Check all children
|
|
return false;// Must not be a child at this level
|
|
}
|
|
#endregion
|
|
private bool _AdjustingTree = false;
|
|
public void AdjustTree(ItemInfo selectedItem)
|
|
{
|
|
// start at the top parent and walk down the nodes to find child
|
|
VETreeNode node = FindNodeAndExpand(selectedItem);
|
|
if (node != null)
|
|
{
|
|
_AdjustingTree = true;
|
|
this.SelectedNode = node;
|
|
_AdjustingTree = false;
|
|
}
|
|
}
|
|
public VETreeNode FindNodeAndExpand(IVEDrillDownReadOnly selectedItem)
|
|
{
|
|
if (selectedItem.ActiveParent == null)
|
|
{
|
|
return (VETreeNode)this.Nodes[0]; // Return the top node
|
|
}
|
|
VETreeNode parent = FindNodeAndExpand(selectedItem.ActiveParent);
|
|
if (parent == null) return null;
|
|
if (!parent.IsExpanded)
|
|
parent.Expand();
|
|
foreach (TreeNode childNode in parent.Nodes)
|
|
{
|
|
VETreeNode child = childNode as VETreeNode;
|
|
if (child != null && CompareVEObject(child.VEObject, selectedItem))
|
|
return child;
|
|
}
|
|
foreach (TreeNode childNode in parent.Nodes)
|
|
{
|
|
VETreeNode child = childNode as VETreeNode;
|
|
if (child.VEObject is PartInfo)
|
|
foreach (VETreeNode grandchild in child.Nodes)
|
|
if (CompareVEObject(grandchild.VEObject, selectedItem))
|
|
return grandchild;
|
|
}
|
|
return null;
|
|
}
|
|
public bool CompareVEObject(IVEDrillDownReadOnly obj1, IVEDrillDownReadOnly obj2)
|
|
{
|
|
ItemInfo myItem = obj1 as ItemInfo;
|
|
if (myItem != null)
|
|
if (myItem.ItemID == ((ItemInfo)obj2).ItemID) return true;
|
|
DocVersionInfo myDV = obj1 as DocVersionInfo;
|
|
if (myDV != null)
|
|
if (myDV.VersionID == ((DocVersionInfo)obj2).VersionID) return true;
|
|
FolderInfo myFolder = obj1 as FolderInfo;
|
|
if (myFolder != null)
|
|
if (myFolder.FolderID == ((FolderInfo)obj2).FolderID) return true;
|
|
return false;
|
|
}
|
|
}
|
|
#region DragHelper
|
|
public class DragHelper
|
|
{
|
|
[DllImport("comctl32.dll")]
|
|
public static extern bool InitCommonControls();
|
|
|
|
[DllImport("comctl32.dll", CharSet = CharSet.Auto)]
|
|
public static extern bool ImageList_BeginDrag(IntPtr himlTrack, int
|
|
iTrack, int dxHotspot, int dyHotspot);
|
|
|
|
[DllImport("comctl32.dll", CharSet = CharSet.Auto)]
|
|
public static extern bool ImageList_DragMove(int x, int y);
|
|
|
|
[DllImport("comctl32.dll", CharSet = CharSet.Auto)]
|
|
public static extern void ImageList_EndDrag();
|
|
|
|
[DllImport("comctl32.dll", CharSet = CharSet.Auto)]
|
|
public static extern bool ImageList_DragEnter(IntPtr hwndLock, int x, int y);
|
|
|
|
[DllImport("comctl32.dll", CharSet = CharSet.Auto)]
|
|
public static extern bool ImageList_DragLeave(IntPtr hwndLock);
|
|
|
|
[DllImport("comctl32.dll", CharSet = CharSet.Auto)]
|
|
public static extern bool ImageList_DragShowNolock(bool fShow);
|
|
static DragHelper()
|
|
{
|
|
InitCommonControls();
|
|
}
|
|
}
|
|
#endregion
|
|
}
|