Samuele Locatelli
504 lines
17 KiB
C#
504 lines
17 KiB
C#
/* ========================================================================
|
|
* Copyright (c) 2005-2020 The OPC Foundation, Inc. All rights reserved.
|
|
*
|
|
* OPC Foundation MIT License 1.00
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* The complete license agreement can be found here:
|
|
* http://opcfoundation.org/License/MIT/1.00/
|
|
* ======================================================================*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using Opc.Ua;
|
|
using Opc.Ua.Client;
|
|
|
|
namespace Opc.Ua.Client.Controls
|
|
{
|
|
/// <summary>
|
|
/// A control which displays browse tree.
|
|
/// </summary>
|
|
public partial class BrowseTreeViewCtrl : UserControl
|
|
{
|
|
#region Constructors
|
|
/// <summary>
|
|
/// Creates a new instance of the control.
|
|
/// </summary>
|
|
public BrowseTreeViewCtrl()
|
|
{
|
|
InitializeComponent();
|
|
BrowseTV.ImageList = new ClientUtils().ImageList;
|
|
m_typeImageMapping = new Dictionary<NodeId, int>();
|
|
}
|
|
#endregion
|
|
|
|
#region Private Fields
|
|
private Session m_session;
|
|
private NodeId m_rootId;
|
|
private NodeId[] m_referenceTypeIds;
|
|
private NodeId m_selectedNodeId;
|
|
private event EventHandler m_AfterSelect;
|
|
private ViewDescription m_view;
|
|
private Dictionary<NodeId, int> m_typeImageMapping;
|
|
#endregion
|
|
|
|
#region Public Interface
|
|
/// <summary>
|
|
/// The view to use.
|
|
/// </summary>
|
|
public AttributesListViewCtrl AttributesControl { get; set; }
|
|
|
|
/// <summary>
|
|
/// Initializes the control with a root and a set of hierarchial reference types to follow.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="rootId">The root of the hierarchy to browse.</param>
|
|
/// <param name="referenceTypeIds">The reference types to follow.</param>
|
|
public void Initialize(
|
|
Session session,
|
|
NodeId rootId,
|
|
params NodeId[] referenceTypeIds)
|
|
{
|
|
// set default root.
|
|
if (NodeId.IsNull(rootId))
|
|
{
|
|
rootId = Opc.Ua.ObjectIds.ObjectsFolder;
|
|
}
|
|
|
|
// set default reference type.
|
|
if (referenceTypeIds == null)
|
|
{
|
|
referenceTypeIds = new NodeId[] { Opc.Ua.ReferenceTypeIds.HierarchicalReferences };
|
|
}
|
|
|
|
m_rootId = rootId;
|
|
m_referenceTypeIds = referenceTypeIds;
|
|
|
|
// save session.
|
|
ChangeSession(session, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selects a node in the control.
|
|
/// </summary>
|
|
public bool SelectNode(NodeId nodeId)
|
|
{
|
|
return SelectNode(BrowseTV.Nodes, nodeId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the session used by the control.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
public void ChangeSession(Session session)
|
|
{
|
|
if (Object.ReferenceEquals(session, m_session))
|
|
{
|
|
return;
|
|
}
|
|
|
|
ChangeSession(session, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The view to use.
|
|
/// </summary>
|
|
public ViewDescription View
|
|
{
|
|
get
|
|
{
|
|
return m_view;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (AttributesControl != null)
|
|
{
|
|
AttributesControl.View = value;
|
|
}
|
|
|
|
m_view = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the context menu for the browse tree.
|
|
/// </summary>
|
|
public ContextMenuStrip BrowseMenuStrip
|
|
{
|
|
get { return BrowseTV.ContextMenuStrip; }
|
|
set { BrowseTV.ContextMenuStrip = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The reference for the currently selected node.
|
|
/// </summary>
|
|
public ReferenceDescription SelectedNode
|
|
{
|
|
get
|
|
{
|
|
if (BrowseTV.SelectedNode == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return BrowseTV.SelectedNode.Tag as ReferenceDescription;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The reference for the parent of the currently selected node.
|
|
/// </summary>
|
|
public ReferenceDescription SelectedParent
|
|
{
|
|
get
|
|
{
|
|
if (BrowseTV.SelectedNode == null || BrowseTV.SelectedNode.Parent == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return BrowseTV.SelectedNode.Parent.Tag as ReferenceDescription;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the child node at the specified index.
|
|
/// </summary>
|
|
public ReferenceDescription GetChildOfSelectedNode(int index)
|
|
{
|
|
if (BrowseTV.SelectedNode == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (BrowseTV.SelectedNode.Nodes.Count == 1 && BrowseTV.SelectedNode.Nodes[0].Text == String.Empty)
|
|
{
|
|
BrowseTV.SelectedNode.Expand();
|
|
}
|
|
|
|
if (index < 0 || index >= BrowseTV.SelectedNode.Nodes.Count)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return BrowseTV.SelectedNode.Nodes[index].Tag as ReferenceDescription;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The reference for the parent of the currently selected node.
|
|
/// </summary>
|
|
public void RefreshSelection()
|
|
{
|
|
if (BrowseTV.SelectedNode == null || BrowseTV.SelectedNode.Parent == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
BrowseTV.SelectedNode.Collapse();
|
|
BrowseTV.SelectedNode.Nodes.Clear();
|
|
BrowseTV.SelectedNode.Nodes.Add(new TreeNode());
|
|
BrowseTV.SelectedNode.Expand();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raised after a node is selected in the control.
|
|
/// </summary>
|
|
public event EventHandler AfterSelect { add { m_AfterSelect += value; } remove { m_AfterSelect -= value; } }
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
/// <summary>
|
|
/// Recursively finds and selects a node in the control.
|
|
/// </summary>
|
|
private bool SelectNode(TreeNodeCollection nodes, NodeId nodeId)
|
|
{
|
|
foreach (TreeNode node in nodes)
|
|
{
|
|
ReferenceDescription reference = node.Tag as ReferenceDescription;
|
|
|
|
if (reference != null)
|
|
{
|
|
if (reference.NodeId == nodeId)
|
|
{
|
|
BrowseTV.SelectedNode = node;
|
|
node.EnsureVisible();
|
|
node.Checked = true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
SelectNode(node.Nodes, nodeId);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the session used by the control.
|
|
/// </summary>
|
|
private void ChangeSession(Session session, bool refresh)
|
|
{
|
|
m_session = session;
|
|
|
|
if (AttributesControl != null)
|
|
{
|
|
AttributesControl.ChangeSession(session);
|
|
}
|
|
|
|
BrowseTV.Nodes.Clear();
|
|
|
|
if (m_session != null)
|
|
{
|
|
INode node = m_session.NodeCache.Find(m_rootId);
|
|
|
|
if (node != null)
|
|
{
|
|
TreeNode root = new TreeNode(node.ToString());
|
|
root.ImageIndex = ClientUtils.GetImageIndex(m_session, node.NodeClass, node.TypeDefinitionId, false);
|
|
root.SelectedImageIndex = ClientUtils.GetImageIndex(m_session, node.NodeClass, node.TypeDefinitionId, true);
|
|
|
|
ReferenceDescription reference = new ReferenceDescription();
|
|
reference.NodeId = node.NodeId;
|
|
reference.NodeClass = node.NodeClass;
|
|
reference.BrowseName = node.BrowseName;
|
|
reference.DisplayName = node.DisplayName;
|
|
reference.TypeDefinition = node.TypeDefinitionId;
|
|
root.Tag = reference;
|
|
|
|
root.Nodes.Add(new TreeNode());
|
|
BrowseTV.Nodes.Add(root);
|
|
root.Expand();
|
|
BrowseTV.SelectedNode = root;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Event Handlers
|
|
/// <summary>
|
|
/// Handles the DoubleClick event of the BrowseTV control.
|
|
/// </summary>
|
|
private void BrowseTV_DoubleClick(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (BrowseTV.SelectedNode == null)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles the AfterSelect event of the BrowseTV control.
|
|
/// </summary>
|
|
private void BrowseTV_AfterSelect(object sender, TreeViewEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
m_selectedNodeId = null;
|
|
|
|
if (BrowseTV.SelectedNode == null)
|
|
{
|
|
if (m_AfterSelect != null) m_AfterSelect(this, new EventArgs());
|
|
return;
|
|
}
|
|
|
|
// get node to browse.
|
|
ReferenceDescription reference = (ReferenceDescription)e.Node.Tag;
|
|
NodeId nodeId = m_rootId;
|
|
|
|
if (reference != null)
|
|
{
|
|
nodeId = (NodeId)reference.NodeId;
|
|
}
|
|
|
|
m_selectedNodeId = nodeId;
|
|
|
|
if (AttributesControl != null)
|
|
{
|
|
AttributesControl.ReadAttributes(m_selectedNodeId, true);
|
|
}
|
|
|
|
// raise event.
|
|
if (m_AfterSelect != null) m_AfterSelect(this, new EventArgs());
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles the BeforeExpand event of the BrowseTV control.
|
|
/// </summary>
|
|
private void BrowseTV_BeforeExpand(object sender, TreeViewCancelEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
ReferenceDescription reference = (ReferenceDescription)e.Node.Tag;
|
|
e.Node.Nodes.Clear();
|
|
|
|
// build list of references to browse.
|
|
BrowseDescriptionCollection nodesToBrowse = new BrowseDescriptionCollection();
|
|
|
|
for (int ii = 0; ii < m_referenceTypeIds.Length; ii++)
|
|
{
|
|
BrowseDescription nodeToBrowse = new BrowseDescription();
|
|
|
|
nodeToBrowse.NodeId = m_rootId;
|
|
nodeToBrowse.BrowseDirection = BrowseDirection.Forward;
|
|
nodeToBrowse.ReferenceTypeId = m_referenceTypeIds[ii];
|
|
nodeToBrowse.IncludeSubtypes = true;
|
|
nodeToBrowse.NodeClassMask = 0;
|
|
nodeToBrowse.ResultMask = (uint)BrowseResultMask.All;
|
|
|
|
if (reference != null)
|
|
{
|
|
nodeToBrowse.NodeId = (NodeId)reference.NodeId;
|
|
}
|
|
|
|
nodesToBrowse.Add(nodeToBrowse);
|
|
}
|
|
|
|
// add the childen to the control.
|
|
SortedDictionary<ExpandedNodeId, TreeNode> dictionary = new SortedDictionary<ExpandedNodeId, TreeNode>();
|
|
|
|
ReferenceDescriptionCollection references = ClientUtils.Browse(m_session, View, nodesToBrowse, false);
|
|
|
|
for (int ii = 0; references != null && ii < references.Count; ii++)
|
|
{
|
|
reference = references[ii];
|
|
|
|
// ignore out of server references.
|
|
if (reference.NodeId.IsAbsolute)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (dictionary.ContainsKey(reference.NodeId))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TreeNode child = new TreeNode(reference.ToString());
|
|
|
|
child.Nodes.Add(new TreeNode());
|
|
child.Tag = reference;
|
|
|
|
if (!reference.TypeDefinition.IsAbsolute)
|
|
{
|
|
try
|
|
{
|
|
if (!m_typeImageMapping.ContainsKey((NodeId)reference.TypeDefinition))
|
|
{
|
|
List<NodeId> nodeIds = ClientUtils.TranslateBrowsePaths(m_session, (NodeId)reference.TypeDefinition, m_session.NamespaceUris, Opc.Ua.BrowseNames.Icon);
|
|
|
|
if (nodeIds.Count > 0 && nodeIds[0] != null)
|
|
{
|
|
DataValue value = m_session.ReadValue(nodeIds[0]);
|
|
byte[] bytes = value.Value as byte[];
|
|
|
|
if (bytes != null)
|
|
{
|
|
System.IO.MemoryStream istrm = new System.IO.MemoryStream(bytes);
|
|
Image icon = Image.FromStream(istrm);
|
|
BrowseTV.ImageList.Images.Add(icon);
|
|
m_typeImageMapping[(NodeId)reference.TypeDefinition] = BrowseTV.ImageList.Images.Count - 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
Utils.Trace(exception, "Error loading image.");
|
|
}
|
|
}
|
|
|
|
int index = 0;
|
|
|
|
if (!m_typeImageMapping.TryGetValue((NodeId)reference.TypeDefinition, out index))
|
|
{
|
|
child.ImageIndex = ClientUtils.GetImageIndex(m_session, reference.NodeClass, reference.TypeDefinition, false);
|
|
child.SelectedImageIndex = ClientUtils.GetImageIndex(m_session, reference.NodeClass, reference.TypeDefinition, true);
|
|
}
|
|
else
|
|
{
|
|
child.ImageIndex = index;
|
|
child.SelectedImageIndex = index;
|
|
}
|
|
|
|
dictionary[reference.NodeId] = child;
|
|
}
|
|
|
|
// add nodes to tree.
|
|
foreach (TreeNode node in dictionary.Values.OrderBy(i => i.Text))
|
|
{
|
|
e.Node.Nodes.Add(node);
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void BrowseTV_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
BrowseTV.SelectedNode = BrowseTV.GetNodeAt(e.X, e.Y);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void Browse_RefreshMI_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
RefreshSelection();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|