855 lines
23 KiB
C#
855 lines
23 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Drawing;
|
|
using System.Windows.Forms;
|
|
using System.Windows.Forms.Design;
|
|
|
|
namespace DevComponents.Tree.Design
|
|
{
|
|
/// <summary>
|
|
/// Represents windows forms designer for the control.
|
|
/// </summary>
|
|
public class TreeGXDesigner:ParentControlDesigner
|
|
{
|
|
#region Private Variables
|
|
// private Point m_MouseDownPosition=Point.Empty;
|
|
// private bool m_IgnoreMouseUp=false;
|
|
// private bool m_Capture=false;
|
|
private bool m_DragDropStarted=false;
|
|
const string TEMP_NAME="tempDragDropItem";
|
|
const int WM_RBUTTONDOWN=0x0204;
|
|
const int WM_LBUTTONDOWN=0x0201;
|
|
// const int WM_LBUTTONUP=0x0202;
|
|
// const int WM_RBUTTONUP=0x0205;
|
|
// const int WM_MOUSEMOVE=0x0200;
|
|
const int WM_LBUTTONDBLCLK=0x0203;
|
|
|
|
private Timer m_TimerAdded=null;
|
|
private Timer m_TimerDragDrop=null;
|
|
private bool m_DragLeave=false;
|
|
private bool m_ControlRemoved=false;
|
|
private DateTime m_JustAdded=DateTime.MinValue;
|
|
private bool m_NewControlAdded=false;
|
|
private Point m_MouseDownPoint=Point.Empty;
|
|
#endregion
|
|
|
|
#region Designer Implementation
|
|
/// <summary>Initializes designer with given component.</summary>
|
|
/// <param name="component">Component to initialize designer with.</param>
|
|
public override void Initialize(IComponent component)
|
|
{
|
|
base.Initialize(component);
|
|
if(!component.Site.DesignMode)
|
|
return;
|
|
|
|
ISelectionService ss =(ISelectionService)GetService(typeof(ISelectionService));
|
|
if(ss!=null)
|
|
ss.SelectionChanged+=new EventHandler(OnSelectionChanged);
|
|
|
|
// If our component is removed we need to clean-up
|
|
IComponentChangeService cc=(IComponentChangeService)GetService(typeof(IComponentChangeService));
|
|
if(cc!=null)
|
|
{
|
|
cc.ComponentRemoving+=new ComponentEventHandler(this.OnComponentRemoving);
|
|
}
|
|
|
|
if(component is Control)
|
|
{
|
|
((Control)component).ControlAdded+=new ControlEventHandler(this.ControlAdded);
|
|
((Control)component).ControlRemoved+=new ControlEventHandler(this.ControlRemoved);
|
|
}
|
|
|
|
#if !TRIAL
|
|
IDesignerHost dh = this.GetService(typeof (IDesignerHost)) as IDesignerHost;
|
|
if(dh!=null)
|
|
dh.LoadComplete+=new EventHandler(dh_LoadComplete);
|
|
#endif
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
|
|
ISelectionService ss =(ISelectionService)GetService(typeof(ISelectionService));
|
|
if(ss!=null)
|
|
ss.SelectionChanged-=new EventHandler(OnSelectionChanged);
|
|
|
|
// If our component is removed we need to clean-up
|
|
IComponentChangeService cc=(IComponentChangeService)GetService(typeof(IComponentChangeService));
|
|
if(cc!=null)
|
|
cc.ComponentRemoving-=new ComponentEventHandler(this.OnComponentRemoving);
|
|
|
|
if(this.Control!=null)
|
|
{
|
|
this.Control.ControlAdded-=new ControlEventHandler(this.ControlAdded);
|
|
this.Control.ControlRemoved-=new ControlEventHandler(this.ControlRemoved);
|
|
}
|
|
|
|
base.Dispose (disposing);
|
|
}
|
|
|
|
internal void HookControl(Control c)
|
|
{
|
|
this.HookChildControls(c);
|
|
}
|
|
|
|
// public override DesignerVerbCollection Verbs
|
|
// {
|
|
// get
|
|
// {
|
|
// DesignerVerb[] verbs = new DesignerVerb[]
|
|
// {
|
|
// new DesignerVerb("Create Node", new EventHandler(CreateNode))};
|
|
// return new DesignerVerbCollection(verbs);
|
|
// }
|
|
// }
|
|
|
|
public override void InitializeNewComponent(IDictionary defaultValues)
|
|
{
|
|
base.InitializeNewComponent(defaultValues);
|
|
SetDefaults();
|
|
}
|
|
|
|
private void SetDefaults()
|
|
{
|
|
CreateNode(null,true);
|
|
IDesignerHost dh=(IDesignerHost)GetService(typeof(IDesignerHost));
|
|
if(dh==null)
|
|
return;
|
|
Utilites.InitializeTree(this.Control as TreeGX,new ComponentFactory(dh));
|
|
#if !TRIAL
|
|
string key=GetLicenseKey();
|
|
TreeGX tree=this.Control as TreeGX;
|
|
tree.LicenseKey=key;
|
|
#endif
|
|
}
|
|
|
|
private Node CreateNode(Node parentNode, bool addToCollections)
|
|
{
|
|
TreeGX tree=this.Control as TreeGX;
|
|
|
|
IDesignerHost dh=(IDesignerHost)GetService(typeof(IDesignerHost));
|
|
if(dh==null)
|
|
return null;
|
|
|
|
Node node=null;
|
|
tree.BeginUpdate();
|
|
try
|
|
{
|
|
IComponentChangeService change=this.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
|
|
if(addToCollections)
|
|
{
|
|
if(change!=null)
|
|
{
|
|
if(parentNode!=null)
|
|
change.OnComponentChanging(this.Component,TypeDescriptor.GetProperties(parentNode).Find("Nodes",true));
|
|
else
|
|
change.OnComponentChanging(this.Component,TypeDescriptor.GetProperties(tree).Find("Nodes",true));
|
|
}
|
|
}
|
|
|
|
node=dh.CreateComponent(typeof(Node)) as Node;
|
|
|
|
if(node!=null)
|
|
{
|
|
node.Text=node.Name;
|
|
node.Expanded = true;
|
|
if(addToCollections)
|
|
{
|
|
if(parentNode==null)
|
|
tree.Nodes.Add(node);
|
|
else
|
|
parentNode.Nodes.Add(node);
|
|
|
|
if(change!=null)
|
|
{
|
|
if(parentNode!=null)
|
|
change.OnComponentChanged(this.Component,TypeDescriptor.GetProperties(parentNode).Find("Nodes",true),null,null);
|
|
else
|
|
change.OnComponentChanged(this.Component,TypeDescriptor.GetProperties(tree).Find("Nodes",true),null,null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
tree.EndUpdate();
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
private void OnSelectionChanged(object sender,EventArgs e)
|
|
{
|
|
ISelectionService ss = (ISelectionService)sender;
|
|
if(ss.PrimarySelection==this.Component)
|
|
{
|
|
TreeGX tree=this.Control as TreeGX;
|
|
tree.SelectedNode=null;
|
|
}
|
|
}
|
|
|
|
/// <summary>Called when component is about to be removed from designer.</summary>
|
|
/// <param name="sender">Event sender.</param>
|
|
/// <param name="e">Event arguments.</param>
|
|
public void OnComponentRemoving(object sender,ComponentEventArgs e)
|
|
{
|
|
if(e.Component==this.Component)
|
|
{
|
|
IDesignerHost dh=(IDesignerHost)GetService(typeof(IDesignerHost));
|
|
if(dh==null)
|
|
return;
|
|
|
|
ArrayList list = new ArrayList(this.AssociatedComponents);
|
|
foreach(IComponent c in list)
|
|
dh.DestroyComponent(c);
|
|
}
|
|
else if(e.Component is Node && ((Node)e.Component).TreeControl==this.Control)
|
|
{
|
|
OnNodeRemoving(e.Component as Node);
|
|
}
|
|
}
|
|
|
|
private void OnNodeRemoving(Node node)
|
|
{
|
|
IComponentChangeService cc=this.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
|
|
IDesignerHost dh=(IDesignerHost)GetService(typeof(IDesignerHost));
|
|
|
|
if(node.Parent!=null)
|
|
{
|
|
Node parent=node.Parent;
|
|
if(cc!=null)
|
|
cc.OnComponentChanging(parent,TypeDescriptor.GetProperties(parent)["Nodes"]);
|
|
node.Remove();
|
|
if(cc!=null)
|
|
cc.OnComponentChanged(parent,TypeDescriptor.GetProperties(parent)["Nodes"],null,null);
|
|
}
|
|
|
|
if(node.Nodes.Count>0)
|
|
{
|
|
Node[] nodes=new Node[node.Nodes.Count];
|
|
node.Nodes.CopyTo(nodes);
|
|
foreach(Node n in nodes)
|
|
{
|
|
n.Remove();
|
|
|
|
if(n.ParentConnector!=null && dh!=null)
|
|
dh.DestroyComponent(n.ParentConnector);
|
|
|
|
if(dh!=null)
|
|
dh.DestroyComponent(n);
|
|
}
|
|
}
|
|
|
|
this.RecalcLayout();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns all components associated with this control
|
|
/// </summary>
|
|
public override ICollection AssociatedComponents
|
|
{
|
|
get
|
|
{
|
|
ArrayList c=new ArrayList(base.AssociatedComponents);
|
|
TreeGX tree=this.Control as TreeGX;
|
|
if(tree!=null)
|
|
{
|
|
foreach(Node node in tree.Nodes)
|
|
GetNodesRecursive(node,c);
|
|
|
|
foreach(ElementStyle style in tree.Styles)
|
|
c.Add(style);
|
|
|
|
if(tree.NodesConnector!=null)
|
|
c.Add(tree.NodesConnector);
|
|
if(tree.RootConnector!=null)
|
|
c.Add(tree.RootConnector);
|
|
if(tree.LinkConnector!=null)
|
|
c.Add(tree.LinkConnector);
|
|
if(tree.SelectedPathConnector!=null)
|
|
c.Add(tree.SelectedPathConnector);
|
|
}
|
|
return c;
|
|
}
|
|
}
|
|
|
|
private void GetNodesRecursive(Node parent,ArrayList c)
|
|
{
|
|
c.Add(parent);
|
|
|
|
if(parent.ParentConnector!=null)
|
|
c.Add(parent.ParentConnector);
|
|
foreach(Node node in parent.Nodes)
|
|
{
|
|
c.Add(node);
|
|
if (node.Cells.Count > 1)
|
|
{
|
|
for (int i = 1; i < node.Cells.Count; i++)
|
|
{
|
|
c.Add(node.Cells[i]);
|
|
}
|
|
}
|
|
if (node.NodesColumns.Count > 0)
|
|
{
|
|
foreach (ColumnHeader ch in node.NodesColumns)
|
|
{
|
|
c.Add(ch);
|
|
}
|
|
}
|
|
GetNodesRecursive(node,c);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selection support for items on container.
|
|
/// </summary>
|
|
protected override void WndProc(ref Message m)
|
|
{
|
|
switch(m.Msg)
|
|
{
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
if(OnMouseDown(ref m,MouseButtons.Left))
|
|
return;
|
|
break;
|
|
}
|
|
case WM_RBUTTONDOWN:
|
|
{
|
|
if(OnMouseDown(ref m,MouseButtons.Right))
|
|
return;
|
|
break;
|
|
}
|
|
// case WM_LBUTTONUP:
|
|
// {
|
|
// if(OnMouseUp(ref m,MouseButtons.Left))
|
|
// return;
|
|
// break;
|
|
// }
|
|
// case WM_RBUTTONUP:
|
|
// {
|
|
// if(OnMouseUp(ref m,MouseButtons.Right))
|
|
// return;
|
|
// break;
|
|
// }
|
|
// case WM_MOUSEMOVE:
|
|
// {
|
|
// if(OnMouseMove(ref m))
|
|
// return;
|
|
// break;
|
|
// }
|
|
case WM_LBUTTONDBLCLK:
|
|
{
|
|
if(OnMouseDoubleClick())
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
|
|
base.WndProc(ref m);
|
|
}
|
|
|
|
private bool OnMouseDoubleClick()
|
|
{
|
|
bool processed=false;
|
|
|
|
ISelectionService selection = (ISelectionService) this.GetService(typeof(ISelectionService));
|
|
if(selection.PrimarySelection is Node && ((Node)selection.PrimarySelection).TreeControl==this.Control)
|
|
{
|
|
IDesignerHost host=(IDesignerHost) this.GetService(typeof(IDesignerHost));
|
|
if(host!=null)
|
|
{
|
|
IDesigner designer=host.GetDesigner(selection.PrimarySelection as IComponent);
|
|
if(designer!=null)
|
|
{
|
|
designer.DoDefaultAction();
|
|
processed=true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return processed;
|
|
}
|
|
|
|
protected virtual bool OnMouseDown(ref Message m, MouseButtons button)
|
|
{
|
|
|
|
TreeGX tree=this.Control as TreeGX;
|
|
|
|
if(tree==null)
|
|
return false;
|
|
|
|
Point pos=tree.PointToClient(System.Windows.Forms.Control.MousePosition);
|
|
//m_MouseDownPosition=pos;
|
|
|
|
Node node=tree.GetNodeAt(pos);
|
|
if(node!=null && button==MouseButtons.Right)
|
|
{
|
|
ISelectionService selection = (ISelectionService) this.GetService(typeof(ISelectionService));
|
|
ArrayList arr=new ArrayList(1);
|
|
arr.Add(node);
|
|
selection.SetSelectedComponents(arr,SelectionTypes.Primary);
|
|
|
|
tree.SelectedNode=node;
|
|
this.OnContextMenu(System.Windows.Forms.Control.MousePosition.X,System.Windows.Forms.Control.MousePosition.Y);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>Specifies selection rules for designer.</summary>
|
|
public override SelectionRules SelectionRules
|
|
{
|
|
get
|
|
{
|
|
return (SelectionRules.AllSizeable | SelectionRules.Moveable | SelectionRules.Visible);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Drag & Drop External Control Support
|
|
private void DestroyComponent(IComponent c)
|
|
{
|
|
IDesignerHost dh=(IDesignerHost)GetService(typeof(IDesignerHost));
|
|
if(dh==null)
|
|
return;
|
|
dh.DestroyComponent(c);
|
|
}
|
|
|
|
private void RecalcLayout()
|
|
{
|
|
TreeGX tree = this.Control as TreeGX;
|
|
if(tree!=null)
|
|
{
|
|
tree.RecalcLayout();
|
|
tree.Refresh();
|
|
}
|
|
}
|
|
private void ControlAdded(object sender, ControlEventArgs e)
|
|
{
|
|
if(!m_NewControlAdded)
|
|
{
|
|
if(!m_NewControlAdded)
|
|
{
|
|
if(!OnControlAdded(e))
|
|
return;
|
|
}
|
|
else
|
|
return;
|
|
}
|
|
|
|
m_TimerAdded=new Timer();
|
|
m_TimerAdded.Tick+=new EventHandler(this.TimerTick);
|
|
m_TimerAdded.Interval=50;
|
|
m_TimerAdded.Enabled=true;
|
|
m_TimerAdded.Start();
|
|
m_NewControlAdded=false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called after control has been added to container but not through drag & drop. Control added could also be
|
|
/// internal control by the bar container.
|
|
/// </summary>
|
|
/// <param name="e">Event arguments</param>
|
|
/// <returns>true if acted upon this new control otherwise false.</returns>
|
|
protected virtual bool OnControlAdded(ControlEventArgs e)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
private void ControlRemoved(object sender, ControlEventArgs e)
|
|
{
|
|
IDesignerHost dh=(IDesignerHost)GetService(typeof(IDesignerHost));
|
|
if(dh==null || dh.Loading)
|
|
return;
|
|
|
|
if(m_JustAdded!=DateTime.MinValue && DateTime.Now.Subtract(m_JustAdded).Seconds<2)
|
|
{
|
|
m_JustAdded=DateTime.MinValue;
|
|
return;
|
|
}
|
|
m_JustAdded=DateTime.MinValue;
|
|
if(m_DragLeave)
|
|
ControlRemoved(e.Control);
|
|
else if(m_TimerDragDrop!=null)
|
|
m_ControlRemoved=true;
|
|
else
|
|
{
|
|
ISelectionService ss =(ISelectionService)GetService(typeof(ISelectionService));
|
|
if(ss!=null && ss.PrimarySelection==e.Control && Utilites.FindNodeForControl(this.Control as TreeGX, e.Control)!=null)
|
|
{
|
|
ControlRemoved(e.Control);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ControlRemoved(Control control)
|
|
{
|
|
TreeGX tree = this.Control as TreeGX;
|
|
|
|
if(control!=null)
|
|
{
|
|
Node node=Utilites.FindNodeForControl(tree,control);
|
|
if(node!=null)
|
|
{
|
|
if(m_DragDropStarted)
|
|
{
|
|
tree.InternalDragLeave();
|
|
m_DragDropStarted = false;
|
|
}
|
|
|
|
if(node.Parent!=null)
|
|
{
|
|
Node parent=node.Parent;
|
|
IComponentChangeService cc = this.GetService(typeof (IComponentChangeService)) as IComponentChangeService;
|
|
if(cc!=null)
|
|
cc.OnComponentChanging(parent, TypeDescriptor.GetProperties(parent)["Nodes"]);
|
|
node.Remove();
|
|
if(cc!=null)
|
|
cc.OnComponentChanged(parent, TypeDescriptor.GetProperties(parent)["Nodes"],null,null);
|
|
}
|
|
|
|
this.DestroyComponent(node);
|
|
this.RecalcLayout();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TimerTick(object sender, EventArgs e)
|
|
{
|
|
m_TimerAdded.Stop();
|
|
m_TimerAdded.Enabled=false;
|
|
m_TimerAdded=null;
|
|
this.RecalcLayout();
|
|
ISelectionService sel=(ISelectionService)this.GetService(typeof(ISelectionService));
|
|
if(sel!=null && sel.PrimarySelection is Control && this.Control.Controls.Contains((Control)sel.PrimarySelection))
|
|
{
|
|
IComponentChangeService cc=this.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
|
|
cc.OnComponentChanged(sel.PrimarySelection,null,null,null);
|
|
}
|
|
}
|
|
|
|
private void TimerTickDragDrop(object sender, EventArgs e)
|
|
{
|
|
Point p=this.Control.PointToClient(System.Windows.Forms.Control.MousePosition);
|
|
if(this.Control.Bounds.Contains(p))
|
|
m_DragLeave=false;
|
|
else
|
|
m_DragLeave=true;
|
|
|
|
if(System.Windows.Forms.Control.MouseButtons!=MouseButtons.Left)
|
|
{
|
|
m_TimerDragDrop.Enabled=false;
|
|
m_TimerDragDrop.Stop();
|
|
m_TimerDragDrop.Tick-=new EventHandler(TimerTickDragDrop);
|
|
m_TimerDragDrop.Dispose();
|
|
m_TimerDragDrop=null;
|
|
if(m_ControlRemoved)
|
|
{
|
|
m_ControlRemoved=false;
|
|
ISelectionService sel=this.GetService(typeof(ISelectionService)) as ISelectionService;
|
|
if(sel!=null && sel.PrimarySelection is Control)
|
|
ControlRemoved((Control)sel.PrimarySelection);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnDragLeave(EventArgs e)
|
|
{
|
|
if(m_DragDropStarted)
|
|
{
|
|
TreeGX tree=this.Control as TreeGX;
|
|
tree.InternalDragLeave();
|
|
m_DragDropStarted = false;
|
|
}
|
|
base.OnDragLeave (e);
|
|
}
|
|
|
|
protected override void OnDragOver(DragEventArgs de)
|
|
{
|
|
TreeGX tree=this.Control as TreeGX;
|
|
if(tree==null)
|
|
{
|
|
base.OnDragOver(de);
|
|
return;
|
|
}
|
|
|
|
if(m_DragDropStarted)
|
|
{
|
|
DragEventArgs d=new DragEventArgs(null,de.KeyState,de.X,de.Y,DragDropEffects.All,DragDropEffects.Move);
|
|
tree.InternalDragOver(d);
|
|
de.Effect=DragDropEffects.Move;
|
|
return;
|
|
}
|
|
|
|
ISelectionService sel=(ISelectionService)this.GetService(typeof(ISelectionService));
|
|
if(sel!=null && sel.PrimarySelection!=this.Component)
|
|
{
|
|
if(sel.PrimarySelection is Control && this.Control.Controls.Contains((Control)sel.PrimarySelection))
|
|
{
|
|
Node node=Utilites.FindNodeForControl(tree,sel.PrimarySelection as Control);
|
|
if(node!=null)
|
|
{
|
|
if(tree.StartDragDrop(node))
|
|
{
|
|
if(m_TimerDragDrop==null)
|
|
{
|
|
m_TimerDragDrop=new Timer();
|
|
m_TimerDragDrop.Tick+=new EventHandler(this.TimerTickDragDrop);
|
|
m_TimerDragDrop.Interval=100;
|
|
m_TimerDragDrop.Enabled=true;
|
|
m_TimerDragDrop.Start();
|
|
}
|
|
m_DragDropStarted = true;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
else if(sel.SelectionCount>1)
|
|
{
|
|
de.Effect=DragDropEffects.None;
|
|
return;
|
|
}
|
|
else if(sel.PrimarySelection is Control && ((Control)sel.PrimarySelection).Parent!=null)
|
|
{
|
|
// New control being added to the container
|
|
Node node=new Node();
|
|
node.Name=TEMP_NAME;
|
|
node.Text = ((Control) sel.PrimarySelection).Name;
|
|
if(tree.StartDragDrop(node))
|
|
m_DragDropStarted = true;
|
|
}
|
|
}
|
|
|
|
base.OnDragOver (de);
|
|
}
|
|
|
|
protected override void OnDragDrop(DragEventArgs de)
|
|
{
|
|
TreeGX tree=this.Control as TreeGX;
|
|
if(tree==null)
|
|
{
|
|
base.OnDragDrop(de);
|
|
return;
|
|
}
|
|
|
|
ISelectionService sel=(ISelectionService)this.GetService(typeof(ISelectionService));
|
|
if(sel!=null && sel.PrimarySelection is Control && this.Control.Controls.Contains((Control)sel.PrimarySelection))
|
|
{
|
|
de.Effect=DragDropEffects.Move;
|
|
tree.InternalDragDrop(new DragEventArgs(null,0,0,0,DragDropEffects.Move,DragDropEffects.All));
|
|
}
|
|
else
|
|
{
|
|
if(sel.SelectionCount>1)
|
|
{
|
|
de.Effect=DragDropEffects.None;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Node node = tree.GetDragNode();
|
|
if(node!=null && node.Tag is Node && ((Node)node.Tag).Name==TEMP_NAME)
|
|
{
|
|
m_JustAdded=DateTime.Now;
|
|
Node dragNode=CreateNode(null,false);
|
|
TypeDescriptor.GetProperties(dragNode)["HostedControl"].SetValue(dragNode,sel.PrimarySelection as Control);
|
|
TypeDescriptor.GetProperties(dragNode)["Text"].SetValue(dragNode,dragNode.HostedControl.Name);
|
|
node.Tag = dragNode;
|
|
tree.InternalDragDrop(new DragEventArgs(null,0,0,0,DragDropEffects.Move,DragDropEffects.All));
|
|
m_NewControlAdded=true;
|
|
m_DragDropStarted = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
base.OnDragDrop(de);
|
|
}
|
|
#endregion
|
|
|
|
#region Drag & Drop support
|
|
/// <summary>
|
|
/// Called after node has been selected by designer as response to mouse action
|
|
/// </summary>
|
|
/// <param name="node">Node that is selected</param>
|
|
protected virtual void OnNodeSelected(Node node)
|
|
{
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns whether specified node can be dragged and dropped
|
|
/// </summary>
|
|
/// <param name="node">Node to verify</param>
|
|
/// <returns>true if node can be dragged and dropped</returns>
|
|
protected virtual bool CanDragNode(Node node)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected override void OnMouseDragBegin(int x, int y)
|
|
{
|
|
TreeGX tree=this.Control as TreeGX;
|
|
if(tree==null)
|
|
{
|
|
base.OnMouseDragBegin(x,y);
|
|
return;
|
|
}
|
|
|
|
Point pos=tree.PointToClient(new Point(x,y));
|
|
Node node = tree.GetNodeAt(pos);
|
|
|
|
if(node!=null)
|
|
{
|
|
Rectangle expandedRect=Display.NodeDisplay.GetNodeRectangle(eNodeRectanglePart.ExpandBounds,node,tree.NodeDisplay.Offset);
|
|
if(!expandedRect.IsEmpty && expandedRect.Contains(pos))
|
|
{
|
|
node.Expanded=!node.Expanded;
|
|
return;
|
|
}
|
|
ISelectionService selection = (ISelectionService) this.GetService(typeof(ISelectionService));
|
|
if(selection!=null)
|
|
{
|
|
ArrayList arr=new ArrayList(1);
|
|
arr.Add(node);
|
|
selection.SetSelectedComponents(arr,SelectionTypes.Primary);
|
|
OnNodeSelected(node);
|
|
}
|
|
tree.SelectedNode = node;
|
|
}
|
|
else
|
|
tree.SelectedNode = null;
|
|
|
|
if(node==null || !CanDragNode(node))
|
|
{
|
|
if(node==null)
|
|
base.OnMouseDragBegin(x,y);
|
|
else
|
|
this.Control.Capture = true; // Does same as base implementation
|
|
return;
|
|
}
|
|
|
|
m_MouseDownPoint=new Point(x,y);
|
|
this.Control.Capture = true;
|
|
}
|
|
|
|
protected override void OnMouseDragMove(int x, int y)
|
|
{
|
|
TreeGX tree=this.Control as TreeGX;
|
|
if(!m_MouseDownPoint.IsEmpty && tree.SelectedNode!=null)
|
|
{
|
|
if(Math.Abs(m_MouseDownPoint.X-x)>=SystemInformation.DragSize.Width || Math.Abs(m_MouseDownPoint.Y-y)>=SystemInformation.DragSize.Height)
|
|
{
|
|
tree.StartDragDrop(tree.SelectedNode);
|
|
m_MouseDownPoint=Point.Empty;
|
|
m_DragDropStarted=true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if(m_DragDropStarted)
|
|
{
|
|
DragEventArgs de=new DragEventArgs(null,(int)Control.ModifierKeys,x,y,DragDropEffects.All,DragDropEffects.Move);
|
|
tree.InternalDragOver(de);
|
|
}
|
|
}
|
|
|
|
protected override void OnMouseDragEnd(bool cancel)
|
|
{
|
|
this.Control.Capture = false;
|
|
Cursor.Clip = Rectangle.Empty;
|
|
TreeGX tree=this.Control as TreeGX;
|
|
if(m_DragDropStarted)
|
|
{
|
|
if(tree!=null && tree.IsDragDropInProgress)
|
|
{
|
|
if(cancel)
|
|
tree.InternalDragLeave();
|
|
else if(tree.GetDragNode()!=null)
|
|
{
|
|
IComponentChangeService change=this.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
|
|
|
|
Node dragNode=tree.GetDragNode().Tag as Node;
|
|
if(dragNode!=null)
|
|
{
|
|
Node newParent=tree.GetDragNode().Parent;
|
|
Node parent=dragNode.Parent;
|
|
|
|
if(change!=null)
|
|
{
|
|
if(parent!=null)
|
|
change.OnComponentChanging(this.Component,TypeDescriptor.GetProperties(parent).Find("Nodes",true));
|
|
else
|
|
change.OnComponentChanging(this.Component,TypeDescriptor.GetProperties(tree).Find("Nodes",true));
|
|
|
|
if(newParent!=null)
|
|
change.OnComponentChanging(this.Component,TypeDescriptor.GetProperties(newParent).Find("Nodes",true));
|
|
else
|
|
change.OnComponentChanging(this.Component,TypeDescriptor.GetProperties(tree).Find("Nodes",true));
|
|
}
|
|
|
|
tree.InternalDragDrop(new DragEventArgs(null,0,0,0,DragDropEffects.None,DragDropEffects.None));
|
|
|
|
newParent = dragNode.Parent;
|
|
|
|
if(change!=null)
|
|
{
|
|
if(parent!=null)
|
|
change.OnComponentChanged(this.Component,TypeDescriptor.GetProperties(parent).Find("Nodes",true),null,null);
|
|
else
|
|
change.OnComponentChanged(this.Component,TypeDescriptor.GetProperties(tree).Find("Nodes",true),null,null);
|
|
if(newParent!=null)
|
|
change.OnComponentChanged(this.Component,TypeDescriptor.GetProperties(newParent).Find("Nodes",true),null,null);
|
|
else
|
|
change.OnComponentChanged(this.Component,TypeDescriptor.GetProperties(tree).Find("Nodes",true),null,null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
cancel=true;
|
|
}
|
|
else
|
|
{
|
|
if(tree.SelectedNode!=null)
|
|
cancel=true;
|
|
}
|
|
|
|
m_DragDropStarted = false;
|
|
base.OnMouseDragEnd(cancel);
|
|
}
|
|
#endregion
|
|
|
|
#region Licensing Stuff
|
|
#if !TRIAL
|
|
private string GetLicenseKey()
|
|
{
|
|
string key="";
|
|
Microsoft.Win32.RegistryKey regkey=Microsoft.Win32.Registry.LocalMachine;
|
|
regkey=regkey.OpenSubKey("Software\\DevComponents\\Licenses",false);
|
|
if(regkey!=null)
|
|
{
|
|
object keyValue=regkey.GetValue("DevComponents.Tree.TreeGX");
|
|
if(keyValue!=null)
|
|
key=keyValue.ToString();
|
|
}
|
|
return key;
|
|
}
|
|
private void dh_LoadComplete(object sender, EventArgs e)
|
|
{
|
|
IDesignerHost dh = this.GetService(typeof (IDesignerHost)) as IDesignerHost;
|
|
if(dh!=null)
|
|
dh.LoadComplete-=new EventHandler(dh_LoadComplete);
|
|
|
|
string key=GetLicenseKey();
|
|
TreeGX tree=this.Control as TreeGX;
|
|
if(key!="" && tree!=null && tree.LicenseKey=="" && tree.LicenseKey!=key)
|
|
TypeDescriptor.GetProperties(tree)["LicenseKey"].SetValue(tree,key);
|
|
}
|
|
#endif
|
|
#endregion
|
|
}
|
|
}
|