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);
}
}
public void ClearSelection()
{
foreach (Node node in graph.Nodes)
{
node.IsSelected = false;
foreach (Edge edge in node.edges)
{
edge.IsSelected = false;
foreach (EdgePart edgePart in edge.EdgeParts)
{
edgePart.IsSelected = false;
}
foreach (EdgeBreak edgeBreak in edge.EdgeBreaks)
{
edgeBreak.IsSelected = false;
}
}
}
SelectedNodes.Clear();
SelectedEdgeBreak = null;
SelectedEdgePart = null;
SelectionChanged();
}
/// <summary>
/// setup root and dictionary
/// </summary>
public void Setup()
{
// clear selected nodes
SelectedNodes.Clear();
// if there's no child object, clear dictionary and null root
if (this.gameObject.transform.childCount == 0)
{
Dict.Clear();
Root = null;
return;
}
else // construct internal data structure and dictionary if there's a loaded object
{
// initialize root
Root = new Node(this.transform.GetChild(0).gameObject, null, this.transform);
// setup dictionary
Dict.Clear();
List <Node> curNodes = new List <Node>();
curNodes.Add(Root);
while (curNodes.Count > 0)
{
Node curNode = curNodes[0];
Dict.Add(curNode.GameObject, curNode);
foreach (var child in curNode.Childs)
{
curNodes.Add(child);
}
curNodes.RemoveAt(0);
}
}
}
private void BuildSelectedNodesMenu()
{
SelectedNodes.Clear();
if (Presentation == null)
{
return;
}
var transformations = Presentation.GetModule <ITransformationModule>();
var captions = Presentation.GetModule <ICaptionModule>();
var selections = Presentation.GetPropertySetFor <Selection>();
var nodes = transformations.Graph.Nodes
.Union(Presentation.Graph.Nodes)
.Where(n => selections.TryGet(n.Id)?.IsSelected ?? false)
.Distinct()
.Select(n => new NodeWithCaption(n, captions.Get(n.Id).DisplayText))
.OrderBy(n => n.DisplayText);
foreach (var n in nodes)
{
SelectedNodes.Add(n);
}
mySelectionMenuUpdatePending = false;
}
public void ClearMultiSelect()
{
foreach (UINode n in SelectedNodes)
{
n.HideBorder();
}
SelectedNodes.Clear();
}
public void ClearAllSelectedNodes()
{
for (var index = 0; index < SelectedNodes.Count; index++)
{
var node = SelectedNodes[index];
node.IsSelected = false;
}
SelectedNodes.Clear();
}
public void AddNode(Node child, double x, double y, bool addedByBrain = false)
{
AddChildren(child);
SetLeft(child, x);
SetTop(child, y);
Nodes.Add(child);
SelectedNodes.Clear();
SelectedNodes.Add(child);
}
/// <summary>
/// Method to reset all the class properties to the default values.
/// </summary>
public static void Reset()
{
ActiveLink = null;
UriLink = UriLinkType.None;
LinkAction = LinkAction.None;
PublicNode = null;
DownloadPath = null;
SelectedNodes.Clear();
}
public void SelectNode(TreeNode node)
{
SelectedNodes.Clear();
SelectedNodes.Add(node);
_anchoredNodeStart = node;
_anchoredNodeEnd = node;
Invalidate();
}
public void ClearMultiSelect()
{
List <UINode> toRemove = SelectedNodes.ToList();
SelectedNodes.Clear();
foreach (UINode n in toRemove)
{
n.HideBorder();
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
foreach (var item in Nodes)
{
item.IsSelected = false;
foreach (var child in item.Descendents)
{
child.IsSelected = false;
}
}
SelectedNodes.Clear();
}
public static void ClearSelectedNodes()
{
foreach (var node in SelectedNodes)
{
if (node != null)
{
node.DisplayMode = NodeDisplayMode.Normal;
}
}
SelectedNodes.Clear();
}
protected override void OnAfterSelect(TreeViewEventArgs e)
{
// Save old selection for invalidating
var selectedNodesOld = SelectedNodes.ToArray();
TreeNodeMS node = (TreeNodeMS)e.Node;
// Don't change the selection if this is a right click and the node is in the
// selection.
if (node != null && !(_inRightClick && node.IsInSelection))
{
if (IsDisjointSelect)
{
// Toggle selection on the node
SelectNode(node, !IsNodeSelected(e.Node));
}
else if (IsRangeSelect && !ReferenceEquals(_anchorNode, node))
{
// Figure out top and bottom of the range to be selected
TreeNodeMS upperNode = _anchorNode;
TreeNodeMS bottomNode = node;
if (upperNode.BoundsMS.Top > bottomNode.BoundsMS.Top)
{
Helpers.Swap(ref upperNode, ref bottomNode);
}
// Set new selection to contain all visible nodes between top and bottom
SelectedNodes.Clear();
while (upperNode != null && !ReferenceEquals(upperNode, bottomNode))
{
SelectNode(upperNode, true);
upperNode = (TreeNodeMS)upperNode.NextVisibleNode;
}
SelectNode(bottomNode, true);
}
else
{
// Make this a single selection of the selected node.
SelectedNodes.Clear();
SelectNode(node, true);
}
// Invalidate the changed nodes
var unchangedNodes = new HashSet <TreeNodeMS>(selectedNodesOld.Intersect(SelectedNodes));
InvalidateChangedNodes(selectedNodesOld, unchangedNodes);
InvalidateChangedNodes(SelectedNodes, unchangedNodes);
}
Invalidate();
// Make sure selection is updated before after select event is fired
base.OnAfterSelect(e);
}
private void HandleMouseUp(object sender, MouseButtonEventArgs e)
{
switch (MouseMode)
{
case MouseModes.Nothing:
var mouseUpOnNode = false;
foreach (var node in NodeCollection)
{
if (VisualTreeHelper.HitTest(node.Border, e.GetPosition(node)) != null)
{
mouseUpOnNode = true;
}
}
// if mouse up in empty space unselect all nodes
if (!mouseUpOnNode && e.ChangedButton != MouseButton.Right)
{
foreach (var node in SelectedNodes)
{
node.IsSelected = false;
}
SelectedNodes.Clear();
}
break;
case MouseModes.Panning:
foreach (var node in NodeCollection)
{
MouseMove -= node.HostCanvas_MouseMove;
}
Console.WriteLine(NodeCollection.Count);
MouseMode = MouseModes.Nothing;
break;
case MouseModes.Selection:
Children.Remove(selectionRectangle);
selectionRectangle = null;
MouseMode = MouseModes.Nothing;
break;
}
}
private void UnselectAllElements()
{
foreach (var node in SelectedNodes)
{
node.IsSelected = false;
}
foreach (var conn in ConnectorCollection)
{
conn.IsSelected = false;
}
SelectedNodes.Clear();
SelectedConnectors.Clear();
SelectedUiElements.Clear();
}
public void SelectNodes(List <TreeNode> nodes, bool updateAnchors = true)
{
SelectedNodes.Clear();
foreach (var node in nodes)
{
SelectedNodes.Add(node);
}
if (updateAnchors && SelectedNodes.Count > 0)
{
_anchoredNodeStart = SelectedNodes[SelectedNodes.Count - 1];
_anchoredNodeEnd = SelectedNodes[SelectedNodes.Count - 1];
}
Invalidate();
}
/// <summary>
/// setup internal node structure
/// </summary>
public void Setup()
{
// clear selected nodes
SelectedNodes.Clear();
// if there's no child object, clear dictionary and null root
if (this.gameObject.transform.childCount == 0)
{
Root = null;
return;
}
else // construct internal data structure and dictionary if there's a loaded object
{
// initialize root
Root = new Node(this.transform.GetChild(0).gameObject, null, this.transform);
}
}
public void TryAndDelete()
{
foreach (UINode n in SelectedNodes)
{
if (UINodeParameters.Instance != null)
{
if (UINodeParameters.Instance.node == n.Node)
{
UINodeParameters.Instance.ClearView();
}
}
n.Dispose();
}
SelectedNodes.Clear();
}
private void OnMouseUp(object sender, MouseButtonEventArgs mouseButtonEventArgs)
{
if (MouseMode == MouseMode.SelectionRectangle && Children.Contains(_selectionZone))
{
Children.Remove(_selectionZone);
SelectedNodes.Clear();
for (var index = 0; index < Nodes.Count; index++)
{
var node = Nodes[index];
if (node.IsSelected)
{
SelectedNodes.Add(node);
}
}
MouseMode = MouseMode.Nothing;
}
if (MouseMode == MouseMode.ResizingComment)
{
TempComment.Cursor = Cursors.Arrow;
TempComment = null;
}
HideLinkingPossiblity();
Cursor = Cursors.Arrow;
if (WireMode == WireMode.FirstPortSelected && (TemExecPort != null || TemObjectPort != null))
{
NodesTree.Show();
MouseMode = MouseMode.Nothing;
WireMode = WireMode.Nothing;
}
else
{
Children.Remove(TempConn);
MouseMode = MouseMode.Nothing;
WireMode = WireMode.Nothing;
}
_mouseEffect.Show(this, Colors.DarkGray);
Task.Factory.StartNew(() =>
{
Thread.Sleep(300);
Application.Current.Dispatcher.BeginInvoke(new Action(() => { _mouseEffect.Remove(this); }));
});
}
/// <summary>
/// ノードドラッグ中
/// </summary>
private void NodeItem_Dragging(object sender, NodeDraggingEventArgs e)
{
// フォーカス取得
Focus();
var ctrl = e.OriginalSource as NodeControl;
if (ctrl == null)
{
return;
}
//
// 以下無駄が多いので仮
//
// 選択されていなければ選択状態にする
foreach (var a in e.Nodes)
{
NodeListItem item = PART_NodeList_.FindAssociatedNodeItem(a);
if (!item.IsSelected)
{
// Ctrlが押されていない場合セレクションリストをクリア
if ((Keyboard.Modifiers & ModifierKeys.Control) == 0)
{
SelectedNodes.Clear();
}
item.IsSelected = true;
}
else
{
}
}
// 選択中オブジェクトに移動値を加算する
// TODO:毎回検索するのが無駄なのでキャッシュする
foreach (var n in SelectedNodes)
{
NodeListItem item = PART_NodeList_.FindAssociatedNodeItem(n);
Canvas.SetLeft(item, Canvas.GetLeft(item) + e.HorizontalChange);
Canvas.SetTop(item, Canvas.GetTop(item) + e.VerticalChange);
}
}
public void Paste()
{
try
{
SelectedNodes.Clear();
var dummyList = Cipher.DeSerializeFromString <List <NodeProperties> >(Clipboard.GetText());
for (var index = dummyList.Count - 1; index >= 0; index--)
{
var copiednode = dummyList[index];
var typename = copiednode.Name;
Node newNode = null;
foreach (var node in Hub.LoadedExternalNodes)
{
if (node.ToString() != typename)
{
continue;
}
newNode = node.Clone();
AddNode(newNode, copiednode.X, copiednode.Y);
newNode.DeSerializeData(copiednode.InputData, copiednode.OutputData);
break;
}
if (newNode != null)
{
continue;
}
var type = Type.GetType(typename);
try
{
var instance = Activator.CreateInstance(type, this, false);
AddNode(instance as Node, copiednode.X, copiednode.Y);
}
catch (Exception)
{
//Ignored
}
}
}
catch
{
//ignored
}
}
/// <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);
}
}
}
private void Canvas_MouseDown(object sender, MouseButtonEventArgs e)
{
Canvas canvas = sender as Canvas;
if (Keyboard.IsKeyDown(Key.Space) || e.MiddleButton == MouseButtonState.Pressed)
{
Panning = true;
panningStart = e.GetPosition(EditorScroller);
canvas.CaptureMouse();
}
else if (e.LeftButton == MouseButtonState.Pressed)
{
if (e.OriginalSource != EditorScroller)
{
return;
}
SelectedNodes.Clear();
foreach (NodeInfo nodeInfo in FlowInfo.Nodes)
{
foreach (VariableInfo variable in nodeInfo.Inputs)
{
variable.Selected = false;
}
}
foreach (VariableInfo variable in FlowInfo.Variables)
{
variable.Selected = false;
}
Point mousePosition = e.GetPosition(EditorCanvas);
Selecting = true;
SelectionStart = SelectionEnd = new Point(mousePosition.X + PanX, mousePosition.Y + PanY);
canvas.CaptureMouse();
}
}
/// <summary>
/// Called when the user releases the mouse.
/// </summary>
protected override void OnMouseUp(MouseButtonEventArgs e)
{
base.OnMouseUp(e);
if (e.ChangedButton == MouseButton.Left)
{
var wasDragSelectionApplied = false;
if (_isDraggingSelectionRect)
{
//
// Drag selection has ended, apply the 'selection rectangle'.
//
_isDraggingSelectionRect = false;
ApplyDragSelectionRect();
e.Handled = true;
wasDragSelectionApplied = true;
}
if (_isControlAndLeftMouseButtonDown)
{
_isControlAndLeftMouseButtonDown = false;
ReleaseMouseCapture();
e.Handled = true;
}
if (!wasDragSelectionApplied && IsClearSelectionOnEmptySpaceClickEnabled)
{
//
// A click and release in empty space clears the selection.
//
SelectedNodes.Clear();
}
}
}
/// <summary>
/// Called when the user holds down the mouse.
/// </summary>
protected override void OnMouseDown(MouseButtonEventArgs e)
{
base.OnMouseDown(e);
Focus();
if (e.ChangedButton == MouseButton.Left &&
(Keyboard.Modifiers & ModifierKeys.Control) != 0)
{
//
// Clear selection immediately when starting drag selection.
//
SelectedNodes.Clear();
_isControlAndLeftMouseButtonDown = true;
_origMouseDownPoint = e.GetPosition(this);
CaptureMouse();
e.Handled = true;
}
}
protected override void OnMouseUp(MouseEventArgs e)
{
// If you clicked on a node that WAS previously
// selected then, reselect it now. This will clear
// any other selected nodes. e.g. A B C D are selected
// the user clicks on B, now A C & D are no longer selected.
try
{
// Check to see if a node was clicked on
TreeNode node = this.GetNodeAt(e.Location);
if (node != null)
{
if (e.Button == System.Windows.Forms.MouseButtons.Right)
{
SelectedNodes.Clear();
SelectedNode = node;
}
else if (ModifierKeys == Keys.None && m_SelectedNodes.Contains(node))
{
// Allow user to click on image
int leftBound = node.Bounds.X; // - 20;
// Give a little extra room
int rightBound = node.Bounds.Right + 10;
if (e.Location.X > leftBound && e.Location.X < rightBound)
{
SelectNode(node);
}
}
}
base.OnMouseUp(e);
}
catch (Exception ex)
{
HandleException(ex);
}
}
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();
}
}
internal void ExcludeSelected()
{
if (!SelectedNodes.Any() || _currentCsprojFile == null)
{
return;
}
var content = SelectedNodes
.Where(n => n.NodeModel != null)
.Select(p => p.NodeModel)
.ToArray();
_writer.WriteExclusions(content, _currentCsprojFile);
foreach (var node in Tree)
{
foreach (var desc in node.Descendents)
{
desc.IsSelected = false;
}
}
SelectedNodes.Clear();
}
public bool SelectMultipleItemsForMove()
{
int count = ChildNodes.Count(n => n.IsMultiSelected);
if (count < 1)
{
return(false);
}
SelectedNodes.Clear();
foreach (var node in ChildNodes.Where(n => n.IsMultiSelected))
{
node.DisplayMode = NodeDisplayMode.SelectedForCopyOrMove;
SelectedNodes.Add(node);
}
this.IsMultiSelectActive = false;
this.PreviousDisplayMode = this.CurrentDisplayMode;
this.CurrentDisplayMode = DriveDisplayMode.CopyOrMoveItem;
return(true);
}
public void GoForNode(Node node)
{
node.X = Math.Truncate(node.X);
node.Y = Math.Truncate(node.Y);
var origin = BasisOrigin;
origin.X -= node.ActualWidth - 10;
origin.X = Math.Truncate(origin.X);
origin.Y = Math.Truncate(origin.Y);
var difference = Point.Subtract(origin, new Point(node.X, node.Y));
var timer = new DispatcherTimer {
Interval = new TimeSpan(0, 0, 0, 0, 01)
};
foreach (var n in Nodes)
{
if (difference.X < 0)
{
n.X += difference.X;
}
else
{
n.X += difference.X;
}
if (difference.Y < 0)
{
n.Y += difference.Y;
}
else
{
n.Y += difference.Y;
}
NeedsRefresh = true;
}
difference.X = 10;
difference.Y = 0;
if (difference.X != 0 || difference.Y != 0)
{
timer.Start();
}
timer.Tick += (s, e) =>
{
if (difference.X == 0 && difference.Y == 0)
{
timer.Stop();
}
foreach (var n in Nodes)
{
if (difference.X > 0)
{
n.X++;
}
else
{
n.X--;
}
if (difference.Y > 0)
{
n.Y++;
}
else
{
n.Y--;
}
}
if (difference.X > 0)
{
difference.X--;
}
else
{
difference.X++;
}
if (difference.Y > 0)
{
difference.Y--;
}
else
{
difference.Y++;
}
};
SelectedNodes.Clear();
SelectedNodes.Add(node);
}
