public void DeleteElement(BaseElement el)
{
if ((el == null) || (el is ConnectorElement)) return;
//Delete link
if (el is BaseLinkElement)
{
var lnk = (BaseLinkElement) el;
DeleteLink(lnk);
return;
}
//Delete node
if (el is NodeElement)
{
var conn = ((NodeElement) el);
foreach (var elconn in conn.Connectors)
{
for (var i = elconn.Links.Count - 1; i>=0; i--)
{
var lnk = (BaseLinkElement) elconn.Links[i];
DeleteLink(lnk);
}
}
if (SelectedNodes.Contains(el))
SelectedNodes.Remove(el);
}
if (SelectedElements.Contains(el))
SelectedElements.Remove(el);
Elements.Remove(el);
OnAppearancePropertyChanged(new EventArgs());
}
private void ToggleCheck(KTreeNode node)
{
if (_checkManager == null || node == null || !node.CheckBoxEnabled)
{
return;
}
if (!SelectedNodes.Contains(node) || SelectedNodes.Count == 1)
{
// Update the single node if it's not part of the selection, or it's the only selection
_checkManager.ToggleCheck(node);
}
else
{
// Update all selected nodes
BeginUpdate();
try
{
_checkManager.ToggleCheck(SelectedNodes);
}
finally
{
EndUpdate();
}
}
}
private void NodeControl_HeaderMouseDown(object sender, MouseButtonEventArgs e)
{
if (e.LeftButton == MouseButtonState.Released || Keyboard.IsKeyDown(Key.Space))
{
return;
}
NodeControl nodeControl = sender as NodeControl;
ContentPresenter contentPresenter = VisualTreeHelper.GetParent(nodeControl) as ContentPresenter;
Canvas canvas = VisualTreeHelper.GetParent(contentPresenter) as Canvas;
contentPresenter.SetValue(Panel.ZIndexProperty, currentZIndex++);
if (!SelectedNodes.Contains(nodeControl.NodeInfo))
{
if (Keyboard.IsKeyUp(Key.LeftCtrl) && Keyboard.IsKeyUp(Key.RightCtrl) && Keyboard.IsKeyUp(Key.LeftShift) && Keyboard.IsKeyUp(Key.RightShift))
{
SelectedNodes.Clear();
}
SelectedNodes.Add(nodeControl.NodeInfo);
}
movingNodeOrigins = SelectedNodes.Select(n => nodeControls[n]).ToDictionary(n => n, n => movingNodeOrigins.ContainsKey(n) ? movingNodeOrigins[n] : null);
movingNodeOffsets = SelectedNodes.Select(n => nodeControls[n]).ToDictionary(n => n, n => movingNodeOffsets.ContainsKey(n) ? movingNodeOffsets[n] : null);
foreach (NodeControl n in movingNodeOrigins.Keys.ToArray())
{
movingNodeOrigins[n] = new Point(n.NodeInfo.X, n.NodeInfo.Y);
movingNodeOffsets[n] = e.GetPosition(n);
}
}
void DetermineSelection()
{
Rect r = new Rect(selectionRect.Margin.Left, selectionRect.Margin.Top, selectionRect.Width, selectionRect.Height);
int count = 0;
foreach (UINode n in GraphNodes)
{
if (n.IsInRect(r))
{
if (SelectedNodes.Contains(n))
{
SelectedNodes.Remove(n);
n.HideBorder();
}
else
{
SelectedNodes.Add(n);
n.ShowBorder();
}
count++;
}
}
if (count == 0)
{
ClearMultiSelect();
}
}
private void CreateTreeData()
{
try
{
List <string> SelectedNodes = (List <string>)Session["SelectedNodes"];
List <AccountCode> AccountCodesData = (List <AccountCode>)Session["AccountCodesData"];
List <AccountCodeTreeHelper> TreeData = new List <AccountCodeTreeHelper>();
if (AccountCodesData.Count > 0)
{
TreeData = AccountCodesData.Where(x => x.ParentAccountCode == string.Empty && x.Status == "A").OrderBy(x => x.AccountCode1).Select(x =>
new AccountCodeTreeHelper()
{
AccountCode = x.AccountCode1,
AccountDesc = x.AccountDesc,
Keterangan = x.Keterangan,
Pengiraan = x.Pengiraan,
ParentAccountCode = x.ParentAccountCode,
Status = x.Status,
Level = 0,
ChildCount = AccountCodesData.Where(y => y.ParentAccountCode == x.AccountCode1).Count()
}).ToList();
if (SelectedNodes == null || SelectedNodes.Count == 0)
{
Session["SelectedNodes"] = new List <string>();
SelectedNodes = new List <string>();
}
else
{
for (int i = 0; i < TreeData.Count; i++)
{
if (SelectedNodes.Contains(TreeData[i].AccountCode))
{
foreach (AccountCode sd in AccountCodesData.Where(x => x.ParentAccountCode == TreeData[i].AccountCode && x.Status == "A").OrderByDescending(x => x.AccountCode1))
{
AccountCodeTreeHelper objSH = new AccountCodeTreeHelper()
{
AccountCode = sd.AccountCode1,
AccountDesc = sd.AccountDesc,
Keterangan = sd.Keterangan,
Pengiraan = sd.Pengiraan,
ParentAccountCode = sd.ParentAccountCode,
Status = sd.Status,
Level = TreeData[i].Level + 1,
ChildCount = AccountCodesData.Where(y => y.ParentAccountCode == sd.AccountCode1).Count()
};
TreeData.Insert(i + 1, objSH);
}
}
}
}
}
Session["AccountCodesTree"] = TreeData;
}
catch (Exception ex)
{
((SiteMaster)this.Master).ShowMessage("Error", "An error occurred", ex, true);
}
}
//suitable to made virtual?
public void DeSelectNodes(ArrayList nodes)
{
foreach (TreeNode tn in nodes)
{
if (SelectedNodes.Contains(tn))
{
tn.ForeColor = GetFileColor(tn.Name);
}
}
}
public bool IsIdSelected(Guid id)
{
if (SelectedNodes == null || !SelectedNodes.Any())
{
return(true);
}
if (SelectedNodes.Contains(id))
{
return(true);
}
return(false);
}
private void DrawNodeAsNormal(TreeNode node)
{
if (SelectedNodes.Contains(node))
{
node.ForeColor = SystemColors.HighlightText;
node.BackColor = SystemColors.Highlight;
}
else
{
node.BackColor = ThemeColorTable.ListBoxBackColor;
node.ForeColor = ThemeColorTable.ForeColor;
}
}
public void GroupNodes()
{
if (SelectedNodes.Count <= 1)
{
return;
}
var nodeGroup = new NodeGroup(this)
{
ChildNodes =
NodeCollection.Where(node => SelectedNodes.Contains(node)).ToTrulyObservableCollection()
};
}
public void ToggleMultiSelect(UINode n)
{
if (SelectedNodes.Contains(n))
{
SelectedNodes.Remove(n);
n.HideBorder();
}
else
{
SelectedNodes.Add(n);
n.ShowBorder();
}
}
private void OnSelectionChanged(ITreeItem item)
{
if (item != null)
{
if (item.IsSelected && !SelectedNodes.Contains(item))
{
SelectedNodes.Insert(0, item);
}
else
{
SelectedNodes.Remove(item);
}
}
}
private void ChildNodes_ItemsRemoved(object sender, ObservableListModified <DarkTreeNode> e)
{
foreach (var node in e.Items)
{
if (SelectedNodes.Contains(node))
{
SelectedNodes.Remove(node);
}
UnhookNodeEvents(node);
}
UpdateNodes();
}
/// <summary>
/// call grab if pointer is pointing at a gameobject that is one of the selected node
/// </summary>
public void GrabIfPointingAt()
{
if (ObjectPointer.Instance.HitInfo.collider != null)
{
GameObject hitObject = ObjectPointer.Instance.HitInfo.collider.gameObject;
Node hitNode = null;
if (Dict.TryGetValue(hitObject, out hitNode))
{
if (SelectedNodes.Contains(hitNode))
{
MovableFrame.transform.position = ObjectPointer.Instance.HitInfo.point;
Grab();
}
}
}
}
public void DrawNodes()
{
var defaultColor = Handles.color;
foreach (var drawInfo in _nodeDrawInfos.Values)
{
var drawingPosition = DrawingContext.Current.ApplyScroll(drawInfo.Position);
if (SelectedNodes.Contains(drawInfo))
{
Handles.color = Color.yellow;;
Handles.DrawSolidDisc(drawingPosition, Vector3.forward, drawInfo.Radius + SelectionRadius * DrawingContext.Current.Zoom);
}
Handles.color = Color.red;
Handles.DrawSolidDisc(drawingPosition, Vector3.forward, drawInfo.Radius);
}
Handles.color = defaultColor;
}
/// <summary>
/// Raises the <see cref="TreeView.ItemDrag"/> event.
/// </summary>
/// <remarks>
/// This starts the drag operation of item in the tree view.
/// </remarks>
/// <param name="e">A <see cref="ItemDragEventArgs"/> that describes the event arguments.</param>
protected override void OnItemDrag(ItemDragEventArgs e)
{
base.OnItemDrag(e);
List <FileSystemTreeNode> lstAffectedNodes = new List <FileSystemTreeNode>();
if (SelectedNodes.Contains((FileSystemTreeNode)e.Item))
{
foreach (FileSystemTreeNode tndNode in SelectedNodes)
{
lstAffectedNodes.Add(tndNode);
}
}
else
{
lstAffectedNodes.Add((FileSystemTreeNode)e.Item);
}
DoDragDrop(lstAffectedNodes, DragDropEffects.Move);
}
protected override void OnDrawNode(DrawTreeNodeEventArgs e)
{
if (!bNoRedraw)
{
if (e.State == TreeNodeStates.Focused)
{
e.Graphics.FillRectangle(SystemBrushes.Window, e.Node.Bounds);
if (ModifierKeys != Keys.Shift && ModifierKeys != Keys.Control)
{
ClearSelectedNodes();
}
SelectNode(e.Node);
OnAfterSelect(new TreeViewEventArgs(e.Node));
}
Rectangle bounds = e.Node.Bounds;
if (bounds.Top == 0 && bounds.Left == 0 && bounds.Height == 0 && bounds.Width == 0)
{
return;
}
e.DrawDefault = false;
try
{
SizeF textsize = e.Graphics.MeasureString(e.Node.Name, Font);
Brush brush = SystemBrushes.Window;
int rightWidth = e.Node.Bounds.Width + 17;
if (SelectedNodes.Contains(e.Node))
{
brush = SystemBrushes.MenuHighlight;
rightWidth = (int)Math.Round(textsize.Width, 0) + 4;
}
Rectangle selectRect = new Rectangle(e.Node.Bounds.Left - 1 - (e.Node.ImageIndex > 0 ? 0 : 16), e.Node.Bounds.Top, rightWidth, e.Node.Bounds.Height);
e.Graphics.FillRectangle(brush, selectRect);
e.Graphics.DrawString(e.Node.Name, Font, SystemBrushes.WindowText,
e.Node.Bounds.Left - (e.Node.ImageIndex > 0 ? 0 : 16),
e.Node.Bounds.Top + 2);
}
catch (Exception ex)
{
throw ex;
}
}
}
/// <summary>
/// Raises the <see cref="TreeView.AfterSelect"/> event.
/// </summary>
/// <remarks>
/// This handles the selection and unselection of nodes.
/// </remarks>
/// <param name="e">A <see cref="TreeViewEventArgs"/> describing the event arguments.</param>
protected override void OnAfterSelect(TreeViewEventArgs e)
{
if (MultiSelect)
{
if (((ModifierKeys & Keys.Control) > 0))
{
if (!SelectedNodes.Contains(e.Node))
{
SelectedNodes.Add(e.Node);
}
else
{
SelectedNodes.Remove(e.Node);
}
}
else
{
if (((ModifierKeys & Keys.Shift) > 0) && (m_tndFirst != null))
{
SelectedNodes.Clear();
SelectedNodes.AddRange(FindPath(m_tndFirst, e.Node));
}
else
{
if (SelectedNodes.Count > 0)
{
SelectedNodes.Clear();
}
SelectedNodes.Add(e.Node);
}
}
}
base.OnAfterSelect(e);
if (!MultiSelect)
{
if (!SelectedNodes.Contains(e.Node))
{
SelectedNodes.Clear();
SelectedNodes.Add(e.Node);
}
}
}
/// <summary>
/// select the specified node
/// </summary>
public void Select(Node node)
{
if (node.Locked)
{
return;
}
node.Selected = true;
if (node.HasMesh)
{
node.GameObject.GetComponent <Renderer>().material = new Material(HighlightMaterial);
}
if (!SelectedNodes.Contains(node))
{
SelectedNodes.Add(node);
}
if (OnSelectEvent != null)
{
OnSelectEvent.Invoke(node);
}
}
public void DeleteElement(BaseElement element)
{
if ((element != null) && !(element is ConnectorElement))
{
//Delete link
if (element is BaseLinkElement)
{
var linkElement = (BaseLinkElement)element;
DeleteLink(linkElement);
return;
}
//Delete node
if (element is NodeElement)
{
var conn = (NodeElement)element;
foreach (var connectorElement in conn.Connectors)
{
for (var i = connectorElement.Links.Count - 1; i >= 0; i--)
{
var linkElement = (BaseLinkElement)connectorElement.Links[i];
DeleteLink(linkElement);
}
}
if (SelectedNodes.Contains(element))
{
SelectedNodes.Remove(element);
}
}
if (SelectedElements.Contains(element))
{
SelectedElements.Remove(element);
}
_elements.Remove(element);
OnAppearancePropertyChanged(new EventArgs());
}
}
private void treeView_DrawNode(object sender, DrawTreeNodeEventArgs e)
{
int colstart = 500;
int colwidth = 100;
Core.Ent ent = (Core.Ent)e.Node.Tag;
e.Graphics.FillRectangle(new SolidBrush(treeView.BackColor), e.Bounds);
e.Graphics.DrawString(ent.Name, treeView.Font, new SolidBrush(SelectedNodes.Contains(e.Node) ? Color.Green : Color.Black), new Point(e.Bounds.X, e.Bounds.Y));
for (int i = 0; i < ent.Infos.Length; i++)
{
Font font;
Brush brush;
GetInfoFontAndBrush(ent, i, out font, out brush);
if (ent.Infos[i] != null)
{
e.Graphics.DrawString(DescribeInfo(ent.Infos[i]), font, brush,
new Point(colstart + i * colwidth, e.Bounds.Y));
}
}
}
private void SelectActions()
{
_hoverNode = MouseOverNode();
_hoverPort = MouseOverPort();
if (_hoverNode != null)
{
if (!SelectedNodes.Contains(_hoverNode))
{
SelectedNodes.Clear();
SelectedNodes.Add(_hoverNode);
}
Event.current.Use();
}
else if (_hoverPort != null)
{
Event.current.Use();
}
else
{
SelectedNodes.Clear();
}
}
private void CheckNodeClick(DarkTreeNode node, Point location, MouseButtons button)
{
var rect = GetNodeFullRowArea(node);
if (rect.Contains(location))
{
if (node.ExpandArea.Contains(location))
{
if (button == MouseButtons.Left)
{
node.Expanded = !node.Expanded;
}
}
else
{
if (button == MouseButtons.Left)
{
if (MultiSelect && ModifierKeys == Keys.Shift)
{
SelectAnchoredRange(node);
}
else if (MultiSelect && ModifierKeys == Keys.Control)
{
ToggleNode(node);
}
else
{
if (!SelectedNodes.Contains(node))
{
SelectNode(node);
}
_dragPos = OffsetMousePosition;
_provisionalDragging = true;
_provisionalNode = node;
}
return;
}
else if (button == MouseButtons.Right)
{
if (MultiSelect && ModifierKeys == Keys.Shift)
{
return;
}
if (MultiSelect && ModifierKeys == Keys.Control)
{
return;
}
if (!SelectedNodes.Contains(node))
{
SelectNode(node);
}
return;
}
}
}
if (node.Expanded)
{
foreach (var childNode in node.Nodes)
{
CheckNodeClick(childNode, location, button);
}
}
}
/// <summary>
/// Event raised while the user is dragging a node.
/// </summary>
private void NodeItem_Dragging(object source, NodeDraggingEventArgs e)
{
e.Handled = true;
//
// Cache the NodeItem for each selected node whilst dragging is in progress.
//
if (this.cachedSelectedNodeItems == null)
{
this.cachedSelectedNodeItems = new List <Node>();
foreach (var selectedNode in this.SelectedNodes)
{
Node nodeItem = FindAssociatedNodeItem(selectedNode);
if (nodeItem == null)
{
throw new ApplicationException("Unexpected code path!");
}
this.cachedSelectedNodeItems.Add(nodeItem);
}
}
//
// Update the position of the node within the Canvas.
//
foreach (var nodeItem in this.cachedSelectedNodeItems)
{
nodeItem.X += e.HorizontalChange;
nodeItem.Y += e.VerticalChange;
NodeViewModelBase vm = nodeItem.Content as NodeViewModelBase;
if (vm != null)
{
vm.Left.X += e.HorizontalChange;
vm.Left.Y += e.VerticalChange;
vm.Right.X += e.HorizontalChange;
vm.Right.Y += e.VerticalChange;
}
}
//Detect Selected node insert operation
Point p = Mouse.GetPosition(this);
List <object> unselected = new List <object>();
foreach (var node in Nodes)
{
if (!SelectedNodes.Contains(node))
{
unselected.Add(node);
}
}
foreach (var node in unselected)
{
Node nodeItem = FindAssociatedNodeItem(node);
NodeViewModelBase vm = nodeItem.Content as NodeViewModelBase;
if (vm == null)
{
throw new NotSupportedException("Node Control contents must inherit from NodeViewModelBase.");
}
var targetRect = new Rect(new Point(vm.Left.X, vm.Left.Y), new Size(vm.Left.Width, vm.Left.Height));
}
var eventArgs = new NodeDraggingEventArgs(NodeDraggingEvent, this, this.SelectedNodes, e.HorizontalChange, e.VerticalChange);
RaiseEvent(eventArgs);
}
private void DrawNode(DarkTreeNode node, Graphics g)
{
var rect = GetNodeFullRowArea(node);
// 1. Draw background
var bgColor = node.Odd ? Colors.HeaderBackground : Colors.GreyBackground;
if (SelectedNodes.Count > 0 && SelectedNodes.Contains(node))
{
bgColor = Focused ? Colors.BlueSelection : Colors.GreySelection;
}
if (IsDragging && _dropNode == node)
{
bgColor = Focused ? Colors.BlueSelection : Colors.GreySelection;
}
using (var b = new SolidBrush(bgColor))
{
g.FillRectangle(b, rect);
}
// 2. Draw plus/minus icon
if (node.Nodes.Count > 0)
{
var pos = new Point(node.ExpandArea.Location.X - 1, node.ExpandArea.Location.Y - 1);
var icon = _nodeOpen;
if (node.Expanded && !node.ExpandAreaHot)
{
icon = _nodeOpen;
}
else if (node.Expanded && node.ExpandAreaHot && !SelectedNodes.Contains(node))
{
icon = _nodeOpenHover;
}
else if (node.Expanded && node.ExpandAreaHot && SelectedNodes.Contains(node))
{
icon = _nodeOpenHoverSelected;
}
else if (!node.Expanded && !node.ExpandAreaHot)
{
icon = _nodeClosed;
}
else if (!node.Expanded && node.ExpandAreaHot && !SelectedNodes.Contains(node))
{
icon = _nodeClosedHover;
}
else if (!node.Expanded && node.ExpandAreaHot && SelectedNodes.Contains(node))
{
icon = _nodeClosedHoverSelected;
}
g.DrawImageUnscaled(icon, pos);
}
// 3. Draw icon
if (ShowIcons && node.Icon != null)
{
if (node.Expanded && node.ExpandedIcon != null)
{
g.DrawImageUnscaled(node.ExpandedIcon, node.IconArea.Location);
}
else
{
g.DrawImageUnscaled(node.Icon, node.IconArea.Location);
}
}
// 4. Draw text
using (var b = new SolidBrush(Colors.LightText))
{
var stringFormat = new StringFormat
{
Alignment = StringAlignment.Near,
LineAlignment = StringAlignment.Center
};
g.DrawString(node.Text, Font, b, node.TextArea, stringFormat);
}
// 5. Draw child nodes
if (node.Expanded)
{
foreach (var childNode in node.Nodes)
{
DrawNode(childNode, g);
}
}
}
public void ToggleNode(TreeNode node)
{
if (SelectedNodes.Contains(node))
{
SelectedNodes.Remove(node);
// If we just removed both the anchor start AND end then reset them
if (_anchoredNodeStart == node && _anchoredNodeEnd == node)
{
if (SelectedNodes.Count > 0)
{
_anchoredNodeStart = SelectedNodes[0];
_anchoredNodeEnd = SelectedNodes[0];
}
else
{
_anchoredNodeStart = null;
_anchoredNodeEnd = null;
}
}
// If we just removed the anchor start then update it accordingly
if (_anchoredNodeStart == node)
{
if (_anchoredNodeEnd.VisibleIndex < node.VisibleIndex)
{
_anchoredNodeStart = node.PrevVisibleNode;
}
else if (_anchoredNodeEnd.VisibleIndex > node.VisibleIndex)
{
_anchoredNodeStart = node.NextVisibleNode;
}
else
{
_anchoredNodeStart = _anchoredNodeEnd;
}
}
// If we just removed the anchor end then update it accordingly
if (_anchoredNodeEnd == node)
{
if (_anchoredNodeStart.VisibleIndex < node.VisibleIndex)
{
_anchoredNodeEnd = node.PrevVisibleNode;
}
else if (_anchoredNodeStart.VisibleIndex > node.VisibleIndex)
{
_anchoredNodeEnd = node.NextVisibleNode;
}
else
{
_anchoredNodeEnd = _anchoredNodeStart;
}
}
}
else
{
SelectedNodes.Add(node);
_anchoredNodeStart = node;
_anchoredNodeEnd = node;
}
Invalidate();
}
public bool IsNodeSelected(TreeNode node)
{
return(SelectedNodes.Contains(node));
}
private void OnKeyDown(object sender, KeyEventArgs keyEventArgs)
{
switch (keyEventArgs.Key)
{
case Key.Down:
for (var index = 0; index < SelectedNodes.Count; index++)
{
var node = SelectedNodes[index];
node.Y = node.Y + 5;
node.Focus();
}
break;
case Key.Up:
for (var index = 0; index < SelectedNodes.Count; index++)
{
var node = SelectedNodes[index];
node.Y = node.Y - 5;
node.Focus();
}
break;
case Key.Left:
for (var index = 0; index < SelectedNodes.Count; index++)
{
var node = SelectedNodes[index];
node.X = node.X - 5;
node.Focus();
}
break;
case Key.Right:
for (var index = 0; index < SelectedNodes.Count; index++)
{
var node = SelectedNodes[index];
node.X = node.X + 5;
node.Focus();
}
break;
case Key.Delete:
if (SelectedNodes.Contains(RootNode))
{
SelectedNodes.Remove(RootNode);
}
for (var index = 0; index < SelectedNodes.Count; index++)
{
var node = SelectedNodes[index];
Nodes.Remove(node);
if (node.IsCollapsed == false)
{
node.Delete();
}
}
break;
case Key.C:
if (Keyboard.IsKeyDown(Key.LeftCtrl) && Keyboard.IsKeyDown(Key.LeftShift))
{
//This code is still under exp
//var collapsedRegion = new NodesContainer(this, SelectedNodes.ToList());
}
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
Copy();
}
break;
case Key.V:
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
Paste();
}
break;
case Key.Subtract:
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
ZoomOut();
keyEventArgs.Handled = true;
}
break;
case Key.Add:
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
ZoomIn();
keyEventArgs.Handled = true;
}
break;
case Key.A:
SelectedNodes.Clear();
if (Keyboard.FocusedElement is Node)
{
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
if (Nodes != null)
{
for (var index = 0; index < Nodes.Count; index++)
{
var node = Nodes[index];
node.Focus();
SelectedNodes.Add(node);
}
}
}
}
break;
case Key.F:
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
SearchForm.Show();
}
break;
case Key.X:
if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
{
Copy();
DeleteSelected();
}
break;
case Key.Escape:
if (Keyboard.FocusedElement is Node)
{
if (SelectedNodes.Count != 0)
{
for (var index = 0; index < SelectedNodes.Count; index++)
{
var node = SelectedNodes[index];
node.IsSelected = false;
}
SelectedNodes.Clear();
}
}
break;
}
}
public bool IsNodeSelected(BonsaiNode node)
{
return(SelectedNodes.Contains(node));
}
private void SelectNodes ()
{
int controlID = GUIUtility.GetControlID (FocusType.Passive);
switch (currentEvent.rawType) {
case EventType.MouseDown:
GUIUtility.hotControl = controlID;
selectionStartPosition = mousePosition;
Node node = MouseOverNode ();
Transition transition = MouseOverTransition ();
if (transition != null && node == null) {
this.selection.Clear ();
this.selection.Add (transition.FromNode);
UpdateUnitySelection ();
SelectTransition (transition);
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
Event.current.Use ();
return;
}
if (node != null) {
if (!SelectedNodes.Contains (node)) {
SelectTransition (null);
}
if (fromNode != null) {
AddTransition (fromNode, node);
fromNode = null;
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
return;
}
if (node.GetType () == typeof(StateMachine) && currentEvent.clickCount == 2) {
SelectStateMachine ((StateMachine)node);
} else {
if (EditorGUI.actionKey || currentEvent.shift) {
if (!this.selection.Contains (node)) {
this.selection.Add (node);
} else {
this.selection.Remove (node);
}
} else if (!this.selection.Contains (node)) {
this.selection.Clear ();
this.selection.Add (node);
}
}
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
UpdateUnitySelection ();
return;
}
fromNode = null;
selectionMode = SelectionMode.Pick;
if (!EditorGUI.actionKey && !currentEvent.shift) {
this.selection.Clear ();
SelectTransition (null);
UpdateUnitySelection ();
}
currentEvent.Use ();
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == controlID) {
selectionMode = SelectionMode.None;
GUIUtility.hotControl = 0;
currentEvent.Use ();
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == controlID && !EditorGUI.actionKey && !currentEvent.shift && (selectionMode == SelectionMode.Pick || selectionMode == SelectionMode.Rect)) {
selectionMode = SelectionMode.Rect;
SelectNodesInRect (FromToRect (selectionStartPosition, mousePosition));
currentEvent.Use ();
}
break;
case EventType.Repaint:
if (GUIUtility.hotControl == controlID && selectionMode == SelectionMode.Rect) {
FsmEditorStyles.selectionRect.Draw (FromToRect (selectionStartPosition, mousePosition), false, false, false, false);
}
break;
}
}
