/// <summary> /// Adds the specified node. /// </summary> /// <param name="node">The node.</param> public override void Add(Node node) { if (_deviceManager == null) _deviceManager = CoreSystem.Managers.Find(m => m.Name.Contains("DeviceManager")) as DeviceManager; if (_displayManager == null) _displayManager = CoreSystem.Managers.Find(m => m.Name.Contains("DisplayManager")) as DisplayManager; if (!Nodes.Contains(node)) { if (node is DeviceProperty) { List<Node> devices = new List<Node>(); foreach (Plugin plugin in _deviceManager.Plugins) { if (plugin is Device) devices.Add(plugin as Device); } DeviceProperty deviceProperty = node as DeviceProperty; deviceProperty.AddDeviceList(devices.DeepClone(), _deviceManager); } if (node is Property) { Property property = node as Property; property.PropertyChanged += PropertyPropertyChanged; if (property.IsMonitored) { if (_dataStorageManager == null) _dataStorageManager = CoreSystem.Managers.Find(m => m.Name.Contains("DataStorageManager")) as DataStorageManager; _dataStorageManager.Add(property); } } _displayManager.Add(node); Nodes.Add(node); Trace.WriteLine("Property added: " + node.ToString(), LogCategory.Debug); OnNodeAdded(node); } }
private StringPropertyControl AddStringProperty(Grid grid, Node property, bool isConnectable) { StringPropertyControl control = new StringPropertyControl(property as ns.Base.Plugins.Properties.Property, isConnectable); control.TextChanged += StringPropertyControlTextChanged; SetControlGridPosition(control, grid); return control; }
/// <summary> /// Adds the specified node. /// </summary> /// <param name="node">The node.</param> public override void Add(Node node) { if (node is ImageProperty && node.Parent is Tool && ((ImageProperty)node).IsOutput) { node.PropertyChanged += ImageChangedEventHandle; base.Add(node); } else if (node is Operation) base.Add(node); }
/// <summary> /// Remove Device. /// </summary> /// <param name="node">The Device to be removed.</param> public override void Remove(Node node) { base.Remove(node); ProjectManager projectManager = CoreSystem.Managers.Find(m => m.Name.Contains("ProjectManager")) as ProjectManager; if (projectManager.Configuration.Devices.Contains(node)) { projectManager.Configuration.Devices.Remove(node as Device); } }
/// <summary> /// Removes the specified node. /// </summary> /// <param name="node">The node.</param> public override void Remove(Node node) { if (node is ImageProperty) { node.PropertyChanged -= ImageChangedEventHandle; base.Remove(node); } else if (node is Operation) base.Remove(node); }
/// <summary> /// Initializes a new instance of the <see cref="NodeTreeItem"/> class. /// </summary> /// <param name="node">The node.</param> public NodeTreeItem(Node node) : base() { _textBlock = new TextBlock(); this.Loaded += HandleLoaded; this.Style = new Style(GetType(), this.FindResource(typeof(TreeViewItem)) as Style); _node = node; CreateHeaderPanel(node, string.Empty); }
private DevicePropertyControl AddDeviceProperty(Grid grid, Node property, bool isConnectable) { DevicePropertyControl control = new DevicePropertyControl(property as ns.Base.Plugins.Properties.Property, isConnectable); SetControlGridPosition(control, grid); DeviceProperty deviceProperty = property as DeviceProperty; control.SelectionBox.SelectionChanged += SelectionBoxSelectionChanged; return control; }
/// <summary> /// Adds the tool. /// </summary> /// <exception cref="System.Exception"> /// Selected tool is NULL! /// or /// Selected operation is NULL! /// </exception> private void AddTool() { ListBox view = null; if (this.AnyTabs.SelectedItem == this.MainToolsTab) { TabItem selectedTab = this.ToolTabs.SelectedItem as TabItem; view = selectedTab.Content as ListBox; if (view != null) { Tool tool = view.SelectedItem as Tool; if (tool == null) return; if(_guiManager.SelectedNode != null && _guiManager.SelectedNode is Tool) { _guiManager.SelectNode(_guiManager.SelectedNode.Parent); } if (_guiManager.SelectedNode == null) { ProjectManager manager = CoreSystem.Managers.Find(m => m.Name.Contains("ProjectManager")) as ProjectManager; if (manager.Configuration.Operations.Count > 0) _guiManager.SelectNode(manager.Configuration.Operations[0]); } if (_guiManager.SelectedNode != null && _guiManager.SelectedNode is Operation) { _lastAddedNode = tool.Clone() as Node; _projectManager.Add(_lastAddedNode, _guiManager.SelectedNode); } } } else if (this.AnyTabs.SelectedItem == this.MainOperationsTabs) { view = this.ListViewAllOperations; Operation operation = view.SelectedItem as Operation; if (operation == null) return; _lastAddedNode = operation.Clone() as Operation; _projectManager.Add(_lastAddedNode); _guiManager.SelectNode(_lastAddedNode); } }
private void nodeManager_SelectedItemChanged(object sender, Base.Event.NodeSelectionChangedEventArgs e) { _selectedNode = e.SelectedNode; UpdateProperties(_selectedNode); }
private void GeneratePropertyControls(Grid parentGrid, Node node) { foreach (ns.Base.Plugins.Properties.Property property in node.Childs.Where(c => c is ns.Base.Plugins.Properties.Property && !((ns.Base.Plugins.Properties.Property)c).IsOutput)) { if (property.IsOutput) continue; if (property is StringProperty || property.GetType().IsAssignableFrom(typeof(StringProperty)) || property.GetType().IsSubclassOf(typeof(StringProperty))) { AddStringProperty(parentGrid, property, true); } else if (CheckPropertyIsNumberType(property)) { AddNumberProperty(parentGrid, property, true); } else if (property is DeviceProperty) { AddDeviceProperty(parentGrid, property, true); if (property.Childs.Count > 0) { GroupBox groupBox = new GroupBox(); groupBox.BorderThickness = new Thickness(0.0); groupBox.Header = property.GroupName; parentGrid.Children.Add(groupBox); RowDefinition rowDefinition = new RowDefinition(); rowDefinition.Height = GridLength.Auto; parentGrid.RowDefinitions.Add(rowDefinition); Grid.SetRow(groupBox, parentGrid.Children.Count); Grid grid = new Grid(); groupBox.Content = grid; foreach (Node child in property.Childs) { GeneratePropertyControls(grid, child); } } } else if (property is ListProperty) { AddComboBoxProperty(parentGrid, property, true); } else if (property is ImageProperty) { AddComboBoxProperty(parentGrid, property, true); }else if (property is RectangleProperty) { AddRectangleProperty(parentGrid, property, true); } } }
/// <summary> /// Adds the child nodes. /// </summary> /// <param name="node">The node.</param> /// <param name="parent">The parent.</param> private void AddChildNodes(Node node, Node parent) { List<Node> nodes = new List<Node>(); foreach (Node child in node.Childs) { Node childNode = child; if (child is Property) { Property originalProperty = child as Property; Property property = originalProperty.DeepClone() as Property; property.UID = Node.GenerateUID(); property.SetParent(parent); if (property.CanAutoConnect && !property.IsOutput) { List<Property> connectableProperties = _propertyManager.GetConnectableProperties(property); if (connectableProperties != null && connectableProperties.Count > 0) property.Connect(connectableProperties[connectableProperties.Count - 1]); } childNode = property; } nodes.Add(childNode); } node.Childs.Clear(); parent.AddChild(node); node.SetParent(parent); foreach (Node child in nodes) { node.Childs.Add(child); AddChildNodes(child, node); _propertyManager.Add(child); } }
/// <summary> /// Clones the properties. /// </summary> /// <param name="source">The source.</param> /// <param name="destination">The destination.</param> private void CloneProperties(Node source, Node destination) { List<object> listProperties = destination.Childs.FindAll(c => c is ListProperty); List<object> numberProperties = destination.Childs.DeepClone(); destination.Childs.Clear(); foreach (Property p in source.Childs.FindAll(c => c is Property)) { Property property = _propertyManager.PropertyTypes.Find(pp => pp.Fullname == p.Fullname) as Property; Property propertyClone = property.Clone() as Property; propertyClone.Value = p.Value; propertyClone.Name = p.Name; propertyClone.UID = p.UID; propertyClone.IsOutput = p.IsOutput; propertyClone.IsMonitored = p.IsMonitored; propertyClone.ConnectedToUID = p.ConnectedToUID; propertyClone.Childs = new List<object>(p.Childs); propertyClone.Tolerance = p.Tolerance; foreach (Node childNode in propertyClone.Childs) childNode.SetParent(propertyClone); propertyClone.SetParent(destination); if (propertyClone is DeviceProperty) { string uid = p.Value as string; DeviceProperty devicePropertyClone = propertyClone as DeviceProperty; ns.Base.Plugins.Device device = this.Configuration.Devices.Find(d => d.UID == uid); if (device != null) devicePropertyClone.SetDevice(_deviceManager, device); else devicePropertyClone.SetDevice(_deviceManager, uid); } else if (propertyClone is ImageProperty) { _displayManager.Add(propertyClone); } else if (propertyClone is ListProperty) { ListProperty originalListProperty = listProperties.Find(c => ((Property)c).Name == propertyClone.Name) as ListProperty; ((ListProperty)propertyClone).List = originalListProperty.List; } else if (propertyClone is NumberProperty<object>) { NumberProperty<object> targetPropertyClone = propertyClone as NumberProperty<object>; NumberProperty<object> propertyModel = numberProperties.Find(c => ((Property)c).Name == targetPropertyClone.Name) as NumberProperty<object>; targetPropertyClone.Min = propertyModel.Min; targetPropertyClone.Max = propertyModel.Max; } else if (propertyClone is DoubleProperty) { DoubleProperty targetPropertyClone = propertyClone as DoubleProperty; DoubleProperty propertyModel = numberProperties.Find(c => ((Property)c).Name == targetPropertyClone.Name) as DoubleProperty; targetPropertyClone.Min = propertyModel.Min; targetPropertyClone.Max = targetPropertyClone.Max; if(propertyClone.Tolerance != null) targetPropertyClone.Tolerance = new Tolerance<double>(Convert.ToDouble(propertyClone.Tolerance.Min), Convert.ToDouble(propertyClone.Tolerance.Max)); } else if (propertyClone is IntegerProperty) { IntegerProperty targetPropertyClone = propertyClone as IntegerProperty; IntegerProperty propertyModel = numberProperties.Find(c => ((Property)c).Name == targetPropertyClone.Name) as IntegerProperty; targetPropertyClone.Min = propertyModel.Min; targetPropertyClone.Max = targetPropertyClone.Max; if (propertyClone.Tolerance != null) targetPropertyClone.Tolerance = new Tolerance<int>(Convert.ToInt32(propertyClone.Tolerance.Min), Convert.ToInt32(propertyClone.Tolerance.Max)); } _propertyManager.Add(propertyClone); destination.Childs.Add(propertyClone); } }
/// <summary> /// Removes the specified node. /// </summary> /// <param name="node">The node.</param> public override void Remove(Node node) { if (_displayManager == null) _displayManager = CoreSystem.Managers.Find(m => m.Name.Contains("DisplayManager")) as DisplayManager; if (node is Property) { foreach (Property child in node.Childs.Where(p => p is Property)) Remove(child); _displayManager.Remove(node); base.Remove(node); } }
/// <summary> /// Removes the specified node. /// </summary> /// <param name="node">The node.</param> public override void Remove(Node node) { if(_displayManager == null) _displayManager = CoreSystem.Managers.Find(m => m.Name.Contains("DisplayManager")) as DisplayManager; if (node is Operation) { Operation operation = node as Operation; if (_configuration.Operations.Contains(operation)) { _configuration.Operations.Remove(operation); OnOperationCollectionChanged(new List<Node> { node }, true); } } else if (node is Tool) { bool enableProcessor = false; if (CoreSystem.Processor.IsRunning) { Trace.WriteLine("Stopping processor while removing a tool ...", LogCategory.Info); CoreSystem.Processor.Stop(); enableProcessor = true; } foreach (Node child in node.Childs) { if (child is Property) _propertyManager.Remove(child); } Node parentNode = node.Parent; if (parentNode != null) parentNode.RemoveChild(node); if (enableProcessor) { CoreSystem.Processor.Start(); Trace.WriteLine("... processor started again!", LogCategory.Info); } } _displayManager.Remove(node); base.Remove(node); }
private RectanglePropertyControl AddRectangleProperty(Grid grid, Node property, bool isConnectable) { RectanglePropertyControl control = new RectanglePropertyControl(property as ns.Base.Plugins.Properties.Property, isConnectable); SetControlGridPosition(control, grid); return control; }
/// <summary> /// Creates the header panel. /// </summary> /// <param name="node">The node.</param> /// <param name="additionalFormat">The additional format.</param> private void CreateHeaderPanel(Node node, string additionalFormat) { string name = node.Name; string iconUrl = string.Empty; _additionFormat = additionalFormat; node.PropertyChanged += HandlePropertyChanged; if (node is StringProperty) { if (!string.IsNullOrEmpty(additionalFormat)) { name = string.Format(additionalFormat, ((StringProperty)node).Value as string); } else name = ((StringProperty)node).Value as string; } else if(node is Operation) { iconUrl = "/ns.GUI.WPF;component/Images/Operation.png"; } else if (node is Tool) { iconUrl = "/ns.GUI.WPF;component/Images/Module.png"; string description = ((Tool)node).Description; if (!string.IsNullOrEmpty(description)) this.ToolTip = description; } StackPanel panel = new StackPanel(); panel.Orientation = Orientation.Horizontal; if (!string.IsNullOrEmpty(iconUrl)) { BitmapImage image = new BitmapImage(); image.BeginInit(); image.UriSource = new Uri(iconUrl, UriKind.Relative); image.EndInit(); _imageContainer = new Image(); _imageContainer.Source = image; _imageContainer.Width = 24; _imageContainer.Height = 23; _imageContainer.Margin = new Thickness(2, 0, 2, 0); panel.Children.Add(_imageContainer); } _textBlock.Text = name; panel.Children.Add(_textBlock); this.Header = panel; }
/// <summary> /// Removes the child. /// </summary> /// <param name="child">The child.</param> public virtual void RemoveChild(Node child) { lock (Childs) { if (Childs.Contains(child)) { child.RemoveChilds(); Childs.Remove(child); OnChildCollectionChanged(new List<Node> { }); } } }
/// <summary> /// Closes this instance. /// </summary> public virtual void Close() { if (_node != null) { _node.PropertyChanged -= HandlePropertyChanged; _node = null; } }
/// <summary> /// Adds a new Node to the Parent. /// Will trigger internal the OnChildCollectionChanged Method (ChildCollectionChanged). /// </summary> /// <param name="child">The Node that should be added.</param> public virtual void AddChild(Node child) { lock (Childs) { if (Childs.Contains(child) == false) { if (child is Node) ((Node)child).SetParent(this); Childs.Add(child); OnChildCollectionChanged(new List<Node> { child }); } } }
/// <summary> /// Removes the specified node. /// </summary> /// <param name="node">The node.</param> public override void Remove(Node node) { if (node is Property) { Property property = node as Property; DataStorageContainer container; lock (_dataStorage.Containers) { try { container = _dataStorage.Containers.Find(c => c.TreeName == property.TreeName); if (this.ContainerRemovedEvent != null) { this.ContainerRemovedEvent(this, new DataStorageContainerChangedEventArgs(property, container)); } _dataStorage.Containers.Remove(container); } catch(Exception ex) { Trace.WriteLine(ex.Message, ex.StackTrace, LogCategory.Error); } } } }
/// <summary> /// Gets the target properties. /// </summary> /// <param name="property">The property.</param> /// <param name="targetTool">The target tool.</param> /// <param name="parent">The parent.</param> /// <returns></returns> private List<Property> GetTargetProperties(Property property, Tool targetTool, Node parent) { List<ns.Base.Plugins.Properties.Property> properties = new List<ns.Base.Plugins.Properties.Property>(); foreach (Node node in parent.Childs) { if (node == targetTool) break; if (node is Property) { ns.Base.Plugins.Properties.Property prop = node as ns.Base.Plugins.Properties.Property; if (prop.IsOutput && (prop.Parent is Tool || prop.Parent is Operation) && property.GetType() == prop.GetType()) properties.Add(prop); } properties.AddRange(GetTargetProperties(property, targetTool, node)); } return properties; }
private void UpdateProperties(Node selectedNode) { this.PropertyGrid.RowDefinitions.Clear(); this.PropertyGrid.Children.Clear(); if (selectedNode == null) return; RowDefinition baseRowDefinition = new RowDefinition(); this.PropertyGrid.RowDefinitions.Add(baseRowDefinition); GroupBox baseGroupBox = new GroupBox(); baseGroupBox.Header = "Base"; baseGroupBox.BorderThickness = new Thickness(0.0); this.PropertyGrid.Children.Add(baseGroupBox); Grid baseGrid = new Grid(); baseGroupBox.Content = baseGrid; if (selectedNode is StringProperty) AddStringProperty(baseGrid, selectedNode, false); else AddStringProperty(baseGrid, "Name", selectedNode.Name); GeneratePropertyControls(baseGrid, selectedNode); }
/// <summary> /// Adds the node. /// </summary> /// <param name="node">The node.</param> /// <param name="parent">The parent.</param> public void Add(Node node, Node parent) { if(_propertyManager == null) _propertyManager = CoreSystem.Managers.Find(m => m.Name.Contains("PropertyManager")) as PropertyManager; bool enableProcessor = false; if (node is Tool && CoreSystem.Processor.IsRunning) { Trace.WriteLine("Stopping processor while attaching another tool ...", LogCategory.Info); CoreSystem.Processor.Stop(); enableProcessor = true; } AddChildNodes(node, parent); if (enableProcessor) { CoreSystem.Processor.Start(); Trace.WriteLine("... processor started again!", LogCategory.Info); } }
/// <summary> /// Adds the specified node. /// </summary> /// <param name="node">The node.</param> public override void Add(Node node) { if (_displayManager == null) _displayManager = CoreSystem.Managers.Find(m => m.Name.Contains("DisplayManager")) as DisplayManager; if (node is Operation) { Operation operation = node as Operation; if (!_configuration.Operations.Contains(operation)) { _configuration.Operations.Add(operation); _displayManager.Add(operation); OnOperationCollectionChanged(new List<Node> { node }, false); } } }
/// <summary> /// Connects the properties by node. /// </summary> /// <param name="node">The node.</param> public void ConnectPropertiesByNode(Node node) { foreach (Node c in node.Childs) { if (c is Property) { Property child = c as Property; if (!string.IsNullOrEmpty(child.ConnectedToUID)) { Property parent = this.Nodes.Find(p => p.UID == child.ConnectedToUID) as Property; if (parent != null) child.Connect(parent); } } ConnectPropertiesByNode(c); } }
/// <summary> /// Sets the parent. /// </summary> /// <param name="parent">The parent.</param> public void SetParent(Node parent) { if(_parent != null) _parent.PropertyChanged -= ParentPropertyChangedEvent; _parent = parent; _parent.PropertyChanged += ParentPropertyChangedEvent; }
/// <summary> /// Adds the Node context to DataStorage. /// </summary> /// <param name="node">The Node containing the needed context.</param> public void AddContext(Node node) { foreach (Node child in node.Childs) { if (child is Property) { Property property = child as Property; if (property.IsOutput && property.IsMonitored) { this.Add(property); } } AddContext(child); } }
/// <summary> /// Selects the node. /// </summary> /// <param name="node">The node.</param> public void SelectNode(Node node) { _selectedNode = node; if(node != null) _selectedNode.IsSelected = true; if (SelectedItemChanged != null) SelectedItemChanged(this, new NodeSelectionChangedEventArgs(node)); }
/// <summary> /// Initializes a new instance of the <see cref="Node"/> class. /// </summary> /// <param name="node">The node.</param> public Node(Node node) { this.UID = node.UID; this.Fullname = node.Fullname; this.Name = node.Name; }