Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity
SourceCode/PROMS/Volian.Controls.Library/vlnTreeView.cs
Rich 0b48ec643e Added new settings to control conversion of approved data 
Added event handler for viewing version pdfs and summary reports
added constructor to lookup based on file
added method to get library document by original file name
fixed ConvertToDisplayText to support RO tables in approved folder
added vlnTreeViewPdfEvent delegate
added vlnTreeViewPdfArgs class
added ViewPDF event
only display menu item if pdf or summary pdf exists
determined if pdf should have superceded watermark added
added sorting of consistency check report by procedure number
added method to add superceded watermark to old version pdf files
commented out approved folders
2012-02-09 16:14:36 +00:00

2078 lines
75 KiB
C#
Raw Blame History

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; }
}
#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;
}
#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));
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));
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;
// 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 AddApprovedRevisions(Menu.MenuItemCollection menuItemCollection, ProcedureInfo pri)
{
RevisionInfoList ril = RevisionInfoList.GetByItemID(pri.ItemID);
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(ItemInfo.Get(ri.ItemID).DisplayNumber), 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(ItemInfo.Get(ri.ItemID).DisplayNumber + " 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
}
void mi_Click(object sender, EventArgs e)
{
MenuItem mi = (MenuItem)sender;
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().Dispose();
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, "Test"))
{
ShowBrokenRules(folder.BrokenRulesCollection);
SetLastValues(FolderInfo.Get(folder.FolderID));
if (OnNodeOpenProperty(this, new vlnTreePropertyEventArgs(uniquename, folder.FolderConfig)) == DialogResult.OK)
{
folder.Save().Dispose();
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, "Test"))
{
ShowBrokenRules(folder.BrokenRulesCollection);
SetLastValues(FolderInfo.Get(folder.FolderID));
if (OnNodeOpenProperty(this, new vlnTreePropertyEventArgs(uniquename, folder.FolderConfig)) == DialogResult.OK)
{
folder.Save().Dispose();
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().Dispose();
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().Dispose();
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 = Section.MakeSection(_LastItemInfo, _LastItemInfo.LastChild(E_FromType.Section), null, "New Section", 10000))
{
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.
}
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)
{
ItemInfo ichld1 = (SelectedNode.Nodes[0] as VETreeNode).VEObject as ItemInfo;
if (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 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 & 8) == 8)
ee = DragDropEffects.Copy; // Copy it
else
ee = DragDropEffects.Move; // Move it
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 && sdragi.MyParent.ItemID == pdropi.ItemID)
{
sdragi.MoveSection(pdropi, myIndex);
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
}
Reference in New Issue View Git Blame Copy Permalink