Samuele Locatelli
1559 lines
47 KiB
C#
1559 lines
47 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;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.Xml;
|
|
using System.Reflection;
|
|
|
|
namespace Opc.Ua.Client.Controls.Common
|
|
{
|
|
/// <summary>
|
|
/// Allows the user to edit a complex value.
|
|
/// </summary>
|
|
public partial class EditComplexValueCtrl : UserControl
|
|
{
|
|
/// <summary>
|
|
/// Constructs the object.
|
|
/// </summary>
|
|
public EditComplexValueCtrl()
|
|
{
|
|
InitializeComponent();
|
|
MaxDisplayTextLength = 100;
|
|
ValuesDV.AutoGenerateColumns = false;
|
|
ImageList = new ClientUtils().ImageList;
|
|
|
|
m_dataset = new DataSet();
|
|
m_dataset.Tables.Add("Values");
|
|
|
|
m_dataset.Tables[0].Columns.Add("AccessInfo", typeof(AccessInfo));
|
|
m_dataset.Tables[0].Columns.Add("Name", typeof(string));
|
|
m_dataset.Tables[0].Columns.Add("DataType", typeof(string));
|
|
m_dataset.Tables[0].Columns.Add("Value", typeof(string));
|
|
m_dataset.Tables[0].Columns.Add("Icon", typeof(Image));
|
|
|
|
ValuesDV.DataSource = m_dataset.Tables[0];
|
|
}
|
|
|
|
#region Private Fields
|
|
private DataSet m_dataset;
|
|
private Session m_session;
|
|
private AccessInfo m_value;
|
|
private bool m_readOnly;
|
|
private int m_maxDisplayTextLength;
|
|
private event EventHandler m_ValueChanged;
|
|
#endregion
|
|
|
|
private class AccessInfo
|
|
{
|
|
public AccessInfo Parent { get; set; }
|
|
public PropertyInfo PropertyInfo { get; set; }
|
|
public int[] Indexes;
|
|
public TypeInfo TypeInfo;
|
|
public object Value;
|
|
public string Name;
|
|
}
|
|
|
|
#region Public Members
|
|
/// <summary>
|
|
/// The maximum length of a value string displayed in a column.
|
|
/// </summary>
|
|
[DefaultValue(100)]
|
|
public int MaxDisplayTextLength
|
|
{
|
|
get
|
|
{
|
|
return m_maxDisplayTextLength;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value < 20)
|
|
{
|
|
m_maxDisplayTextLength = 20;
|
|
}
|
|
|
|
m_maxDisplayTextLength = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the Back command can be called.
|
|
/// </summary>
|
|
public bool CanGoBack
|
|
{
|
|
get
|
|
{
|
|
return (NavigationMENU.Items.Count > 1);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the ArraySize can be changed.
|
|
/// </summary>
|
|
public bool CanSetArraySize
|
|
{
|
|
get
|
|
{
|
|
if (m_readOnly)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
AccessInfo info = NavigationMENU.Items[NavigationMENU.Items.Count - 1].Tag as AccessInfo;
|
|
|
|
if (info != null)
|
|
{
|
|
return info.TypeInfo.ValueRank >= 0;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the data type can be changed.
|
|
/// </summary>
|
|
public bool CanChangeType
|
|
{
|
|
get
|
|
{
|
|
if (m_readOnly)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (NavigationMENU.Items.Count > 0)
|
|
{
|
|
AccessInfo info = NavigationMENU.Items[NavigationMENU.Items.Count - 1].Tag as AccessInfo;
|
|
|
|
if (info != null)
|
|
{
|
|
return info.Parent != null && info.Parent.TypeInfo != null && info.Parent.TypeInfo.BuiltInType == BuiltInType.Variant;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the current data type.
|
|
/// </summary>
|
|
public BuiltInType CurrentType
|
|
{
|
|
get
|
|
{
|
|
if (NavigationMENU.Items.Count > 0)
|
|
{
|
|
AccessInfo info = NavigationMENU.Items[NavigationMENU.Items.Count - 1].Tag as AccessInfo;
|
|
|
|
if (info != null)
|
|
{
|
|
Variant? value = info.Value as Variant?;
|
|
|
|
if (value != null && value.Value.TypeInfo != null)
|
|
{
|
|
return value.Value.TypeInfo.BuiltInType;
|
|
}
|
|
|
|
return info.TypeInfo.BuiltInType;
|
|
}
|
|
}
|
|
|
|
return BuiltInType.Variant;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raised when the value is changed.
|
|
/// </summary>
|
|
public event EventHandler ValueChanged
|
|
{
|
|
add { m_ValueChanged += value; }
|
|
remove { m_ValueChanged -= value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the session used for editing the value.
|
|
/// </summary>
|
|
public void ChangeSession(Session session)
|
|
{
|
|
m_session = session;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Moves the displayed value back.
|
|
/// </summary>
|
|
public void Back()
|
|
{
|
|
if (!CanGoBack)
|
|
{
|
|
return;
|
|
}
|
|
|
|
NavigationMENU_Click(NavigationMENU.Items[NavigationMENU.Items.Count - 2], null);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Changes the array size.
|
|
/// </summary>
|
|
public void SetArraySize()
|
|
{
|
|
if (!CanSetArraySize)
|
|
{
|
|
return;
|
|
}
|
|
|
|
EndEdit();
|
|
|
|
AccessInfo info = NavigationMENU.Items[NavigationMENU.Items.Count - 1].Tag as AccessInfo;
|
|
|
|
TypeInfo currentType = info.TypeInfo;
|
|
object currentValue = info.Value;
|
|
|
|
if (info.Value is Variant)
|
|
{
|
|
Variant variant = (Variant)info.Value;
|
|
currentValue = variant.Value;
|
|
|
|
if (currentValue != null)
|
|
{
|
|
currentType = variant.TypeInfo;
|
|
|
|
if (currentType == null)
|
|
{
|
|
currentType = TypeInfo.Construct(currentValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
int[] dimensions = null;
|
|
|
|
Array array = currentValue as Array;
|
|
|
|
if (array != null)
|
|
{
|
|
dimensions = new int[array.Rank];
|
|
|
|
for (int ii = 0; ii < array.Rank; ii++)
|
|
{
|
|
dimensions[ii] = array.GetLength(ii);
|
|
}
|
|
}
|
|
|
|
IList list = currentValue as IList;
|
|
|
|
if (array == null && list != null)
|
|
{
|
|
dimensions = new int[1];
|
|
dimensions[0] = list.Count;
|
|
}
|
|
|
|
Matrix matrix = currentValue as Matrix;
|
|
|
|
if (matrix != null)
|
|
{
|
|
dimensions = matrix.Dimensions;
|
|
array = matrix.ToArray();
|
|
}
|
|
|
|
SetTypeDlg.SetTypeResult result = new SetTypeDlg().ShowDialog(currentType, dimensions);
|
|
|
|
if (result == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// convert to new type.
|
|
object newValue = currentValue;
|
|
|
|
if (result.ArrayDimensions == null || result.ArrayDimensions.Length < 1)
|
|
{
|
|
newValue = Convert(currentValue, currentType, result.TypeInfo, result.UseDefaultOnError);
|
|
}
|
|
else
|
|
{
|
|
if (array == null && list != null)
|
|
{
|
|
Type elementType = GetListElementType(list);
|
|
|
|
for (int ii = result.ArrayDimensions[0]; ii < list.Count; ii++)
|
|
{
|
|
list.RemoveAt(ii);
|
|
}
|
|
|
|
for (int ii = list.Count; ii < result.ArrayDimensions[0]; ii++)
|
|
{
|
|
list.Add(Activator.CreateInstance(elementType));
|
|
}
|
|
|
|
newValue = list;
|
|
}
|
|
|
|
if (array != null)
|
|
{
|
|
Array newArray = null;
|
|
|
|
if (currentValue is Array)
|
|
{
|
|
newArray = Array.CreateInstance(currentValue.GetType().GetElementType(), result.ArrayDimensions);
|
|
}
|
|
else
|
|
{
|
|
newArray = TypeInfo.CreateArray(result.TypeInfo.BuiltInType, result.ArrayDimensions);
|
|
}
|
|
|
|
int maxCount = result.ArrayDimensions[0];
|
|
|
|
for (int ii = 1; ii < result.ArrayDimensions.Length; ii++)
|
|
{
|
|
maxCount *= result.ArrayDimensions[ii];
|
|
}
|
|
|
|
int count = 0;
|
|
|
|
foreach (object element in array)
|
|
{
|
|
if (maxCount <= count)
|
|
{
|
|
break;
|
|
}
|
|
|
|
object newElement = Convert(element, currentType, result.TypeInfo, result.UseDefaultOnError);
|
|
int[] indexes = GetIndexFromCount(count++, result.ArrayDimensions);
|
|
newArray.SetValue(newElement, indexes);
|
|
}
|
|
|
|
newValue = newArray;
|
|
}
|
|
}
|
|
|
|
NavigationMENU.Items.RemoveAt(NavigationMENU.Items.Count - 1);
|
|
|
|
info.TypeInfo = result.TypeInfo;
|
|
info.Value = newValue;
|
|
ShowValue(info);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the data type.
|
|
/// </summary>
|
|
public void SetType(BuiltInType builtInType)
|
|
{
|
|
if (!CanChangeType)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AccessInfo info = NavigationMENU.Items[NavigationMENU.Items.Count - 1].Tag as AccessInfo;
|
|
|
|
TypeInfo currentType = info.TypeInfo;
|
|
object currentValue = info.Value;
|
|
|
|
try
|
|
{
|
|
EndEdit();
|
|
currentValue = info.Value;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
currentValue = TypeInfo.GetDefaultValue(currentType.BuiltInType);
|
|
}
|
|
|
|
if (info.Value is Variant)
|
|
{
|
|
Variant variant = (Variant)info.Value;
|
|
currentValue = variant.Value;
|
|
|
|
if (currentValue != null)
|
|
{
|
|
currentType = variant.TypeInfo;
|
|
|
|
if (currentType == null)
|
|
{
|
|
currentType = TypeInfo.Construct(currentValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
TypeInfo targetType = new TypeInfo(builtInType, currentType.ValueRank);
|
|
object newValue = Convert(currentValue, currentType, targetType, true);
|
|
|
|
NavigationMENU.Items.RemoveAt(NavigationMENU.Items.Count - 1);
|
|
|
|
info.TypeInfo = targetType;
|
|
info.Value = newValue;
|
|
ShowValueNoNotify(info);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts the old type to the new type.
|
|
/// </summary>
|
|
private object Convert(object oldValue, TypeInfo oldType, TypeInfo newType, bool useDefaultOnError)
|
|
{
|
|
object newValue = oldValue;
|
|
|
|
if (oldType.BuiltInType != newType.BuiltInType)
|
|
{
|
|
try
|
|
{
|
|
newValue = TypeInfo.Cast(oldValue, oldType, newType.BuiltInType);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (!useDefaultOnError)
|
|
{
|
|
throw new FormatException("Could not cast value to requested type.", e);
|
|
}
|
|
|
|
newValue = TypeInfo.GetDefaultValue(newType.BuiltInType);
|
|
}
|
|
}
|
|
|
|
return newValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the value in the control.
|
|
/// </summary>
|
|
public void ShowValue(
|
|
NodeId nodeId,
|
|
uint attributeId,
|
|
string name,
|
|
object value,
|
|
bool readOnly)
|
|
{
|
|
m_readOnly = readOnly;
|
|
NavigationMENU.Items.Clear();
|
|
|
|
if (m_readOnly)
|
|
{
|
|
ValuesDV.EditMode = DataGridViewEditMode.EditProgrammatically;
|
|
TextValueTB.ReadOnly = true;
|
|
}
|
|
|
|
Type type = null;
|
|
|
|
// determine the expected data type for non-value attributes.
|
|
if (attributeId != 0 && attributeId != Attributes.Value)
|
|
{
|
|
BuiltInType builtInType = TypeInfo.GetBuiltInType(Attributes.GetDataTypeId(attributeId));
|
|
int valueRank = Attributes.GetValueRank(attributeId);
|
|
type = TypeInfo.GetSystemType(builtInType, valueRank);
|
|
}
|
|
|
|
// determine the expected data type for value attributes.
|
|
else if (!NodeId.IsNull(nodeId))
|
|
{
|
|
IVariableBase variable = m_session.NodeCache.Find(nodeId) as IVariableBase;
|
|
|
|
if (variable != null)
|
|
{
|
|
BuiltInType builtInType = TypeInfo.GetBuiltInType(variable.DataType, m_session.TypeTree);
|
|
int valueRank = variable.ValueRank;
|
|
type = TypeInfo.GetSystemType(builtInType, valueRank);
|
|
|
|
if (builtInType == BuiltInType.ExtensionObject && valueRank < 0)
|
|
{
|
|
type = TypeInfo.GetSystemType(variable.DataType, m_session.Factory);
|
|
}
|
|
}
|
|
}
|
|
|
|
// use the value.
|
|
else if (value != null)
|
|
{
|
|
type = value.GetType();
|
|
}
|
|
|
|
// go with default.
|
|
else
|
|
{
|
|
type = typeof(string);
|
|
}
|
|
|
|
// assign a name.
|
|
if (String.IsNullOrEmpty(name))
|
|
{
|
|
if (attributeId != 0)
|
|
{
|
|
name = Attributes.GetBrowseName(attributeId);
|
|
}
|
|
else
|
|
{
|
|
name = type.Name;
|
|
}
|
|
}
|
|
|
|
AccessInfo info = new AccessInfo();
|
|
info.Value = Utils.Clone(value);
|
|
info.TypeInfo = TypeInfo.Construct(type);
|
|
|
|
if (value == null && info.TypeInfo.ValueRank < 0)
|
|
{
|
|
info.Value = TypeInfo.GetDefaultValue(info.TypeInfo.BuiltInType);
|
|
}
|
|
|
|
info.Name = name;
|
|
m_value = info;
|
|
|
|
ShowValue(info);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the value in the control.
|
|
/// </summary>
|
|
public void ShowValue(
|
|
string name,
|
|
NodeId dataType,
|
|
int valueRank,
|
|
object value)
|
|
{
|
|
if (value == null && m_session != null)
|
|
{
|
|
BuiltInType builtInType = TypeInfo.GetBuiltInType(dataType, m_session.TypeTree);
|
|
|
|
if (builtInType == BuiltInType.ExtensionObject)
|
|
{
|
|
Type type = m_session.Factory.GetSystemType(dataType);
|
|
|
|
if (type != null)
|
|
{
|
|
if (valueRank < 0)
|
|
{
|
|
value = Activator.CreateInstance(type);
|
|
}
|
|
else
|
|
{
|
|
value = Array.CreateInstance(type, new int[valueRank]);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
value = TypeInfo.GetDefaultValue(dataType, valueRank, m_session.TypeTree);
|
|
}
|
|
}
|
|
|
|
ShowValue(null, name, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the value in the control.
|
|
/// </summary>
|
|
public void ShowValue(
|
|
TypeInfo expectedType,
|
|
string name,
|
|
object value)
|
|
{
|
|
m_readOnly = false;
|
|
NavigationMENU.Items.Clear();
|
|
|
|
// assign a type.
|
|
if (expectedType == null)
|
|
{
|
|
if (value == null)
|
|
{
|
|
expectedType = TypeInfo.Scalars.String;
|
|
}
|
|
else
|
|
{
|
|
expectedType = TypeInfo.Construct(value);
|
|
}
|
|
}
|
|
|
|
// assign a name.
|
|
if (String.IsNullOrEmpty(name))
|
|
{
|
|
name = expectedType.ToString();
|
|
}
|
|
|
|
AccessInfo info = new AccessInfo();
|
|
info.Value = Utils.Clone(value);
|
|
info.TypeInfo = expectedType;
|
|
|
|
if (value == null && info.TypeInfo.ValueRank < 0)
|
|
{
|
|
info.Value = TypeInfo.GetDefaultValue(info.TypeInfo.BuiltInType);
|
|
}
|
|
|
|
// ensure value is the target type.
|
|
info.Value = TypeInfo.Cast(info.Value, expectedType.BuiltInType);
|
|
|
|
info.Name = name;
|
|
m_value = info;
|
|
|
|
ShowValue(info);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the edited value.
|
|
/// </summary>
|
|
public object GetValue()
|
|
{
|
|
return m_value.Value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates the value currently being edited.
|
|
/// </summary>
|
|
public void EndEdit()
|
|
{
|
|
if (NavigationMENU.Items.Count < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!TextValueTB.Visible)
|
|
{
|
|
ValuesDV.EndEdit();
|
|
return;
|
|
}
|
|
|
|
AccessInfo info = NavigationMENU.Items[NavigationMENU.Items.Count - 1].Tag as AccessInfo;
|
|
object newValue = TypeInfo.Cast(TextValueTB.Text, info.TypeInfo.BuiltInType);
|
|
info.Value = newValue;
|
|
UpdateParent(info);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the value in the control.
|
|
/// </summary>
|
|
private void ShowValue(AccessInfo parent)
|
|
{
|
|
ShowValueNoNotify(parent);
|
|
|
|
if (m_ValueChanged != null)
|
|
{
|
|
m_ValueChanged(this, null);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays the value in the control.
|
|
/// </summary>
|
|
private void ShowValueNoNotify(AccessInfo parent)
|
|
{
|
|
m_dataset.Tables[0].Clear();
|
|
ValuesDV.Visible = true;
|
|
TextValueTB.Visible = false;
|
|
|
|
ToolStripItem item = NavigationMENU.Items.Add(parent.Name);
|
|
item.Click += new EventHandler(NavigationMENU_Click);
|
|
item.Tag = parent;
|
|
|
|
TypeInfo typeInfo = parent.TypeInfo;
|
|
object value = parent.Value;
|
|
|
|
if (value is Variant)
|
|
{
|
|
Variant variant = (Variant)value;
|
|
value = variant.Value;
|
|
|
|
if (value != null)
|
|
{
|
|
parent.TypeInfo = typeInfo = variant.TypeInfo;
|
|
|
|
if (typeInfo == null)
|
|
{
|
|
parent.TypeInfo = typeInfo = TypeInfo.Construct(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (typeInfo.ValueRank >= 0)
|
|
{
|
|
Matrix matrix = value as Matrix;
|
|
|
|
if (matrix != null)
|
|
{
|
|
value = matrix.ToArray();
|
|
}
|
|
|
|
System.Collections.IEnumerable enumerable = value as System.Collections.IEnumerable;
|
|
|
|
if (enumerable != null)
|
|
{
|
|
// get the dimensions of any array.
|
|
int[] dimensions = null;
|
|
|
|
// calculate them.
|
|
if (matrix == null)
|
|
{
|
|
Array array = enumerable as Array;
|
|
|
|
if (array != null)
|
|
{
|
|
dimensions = new int[array.Rank];
|
|
|
|
for (int ii = 0; ii < array.Rank; ii++)
|
|
{
|
|
dimensions[ii] = array.GetLength(ii);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dimensions = new int[1];
|
|
System.Collections.IList list = enumerable as System.Collections.IList;
|
|
|
|
if (list != null)
|
|
{
|
|
dimensions[0] = list.Count;
|
|
}
|
|
}
|
|
}
|
|
|
|
// get them from the matrix.
|
|
else
|
|
{
|
|
dimensions = matrix.Dimensions;
|
|
}
|
|
|
|
// display the array elements.
|
|
int count = 0;
|
|
TypeInfo elementType = new TypeInfo(typeInfo.BuiltInType, ValueRanks.Scalar);
|
|
|
|
ValuesDV.Visible = true;
|
|
TextValueTB.Visible = false;
|
|
|
|
foreach (object element in enumerable)
|
|
{
|
|
int[] indexes = GetIndexFromCount(count++, dimensions);
|
|
|
|
AccessInfo info = new AccessInfo();
|
|
info.Parent = parent;
|
|
info.Indexes = indexes;
|
|
info.TypeInfo = elementType;
|
|
info.Value = element;
|
|
|
|
ShowIndexedValue(info);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// check for null.
|
|
if (value == null)
|
|
{
|
|
if (parent.Parent != null && parent.Parent.Value is Array)
|
|
{
|
|
parent.Value = value = Activator.CreateInstance(parent.Parent.Value.GetType().GetElementType());
|
|
}
|
|
else if (parent.Parent != null && parent.PropertyInfo != null)
|
|
{
|
|
parent.Value = value = Activator.CreateInstance(parent.PropertyInfo.PropertyType);
|
|
}
|
|
else
|
|
{
|
|
ShowTextValue(value, parent.TypeInfo);
|
|
return;
|
|
}
|
|
}
|
|
|
|
object structure = value;
|
|
|
|
// check for extension object.
|
|
ExtensionObject extension = structure as ExtensionObject;
|
|
|
|
if (extension != null)
|
|
{
|
|
structure = extension.Body;
|
|
}
|
|
|
|
// check for XmlElements.
|
|
if (structure is XmlElement)
|
|
{
|
|
ShowTextValue((XmlElement)structure);
|
|
return;
|
|
}
|
|
|
|
// check for ByteString.
|
|
if (structure is byte[])
|
|
{
|
|
ShowTextValue((byte[])structure);
|
|
return;
|
|
}
|
|
|
|
// check for NodeId.
|
|
if (structure is NodeId)
|
|
{
|
|
ShowTextValue(((NodeId)structure).ToString());
|
|
return;
|
|
}
|
|
|
|
// check for ExpandedNodeId.
|
|
if (structure is ExpandedNodeId)
|
|
{
|
|
ShowTextValue(((ExpandedNodeId)structure).ToString());
|
|
return;
|
|
}
|
|
|
|
// check for QualifiedName.
|
|
if (structure is QualifiedName)
|
|
{
|
|
ShowTextValue(((QualifiedName)structure).ToString());
|
|
return;
|
|
}
|
|
|
|
// check for Guid.
|
|
if (structure is Guid)
|
|
{
|
|
ShowTextValue(((Guid)structure).ToString());
|
|
return;
|
|
}
|
|
|
|
// check for Uuid.
|
|
if (structure is Uuid)
|
|
{
|
|
ShowTextValue(((Uuid)structure).ToString());
|
|
return;
|
|
}
|
|
|
|
// check for StatusCode.
|
|
if (structure is StatusCode)
|
|
{
|
|
ShowTextValue(Utils.Format("0x{0:X8}", ((StatusCode)structure).Code));
|
|
return;
|
|
}
|
|
|
|
ValuesDV.Visible = true;
|
|
TextValueTB.Visible = false;
|
|
|
|
// use reflection to display the properties of the structure.
|
|
bool isStructure = false;
|
|
PropertyInfo[] properties = structure.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
|
|
|
foreach (PropertyInfo property in properties)
|
|
{
|
|
if (property.GetIndexParameters().Length > 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
object element = property.GetValue(structure, null);
|
|
|
|
string name = null;
|
|
|
|
foreach (object attribute in property.GetCustomAttributes(true))
|
|
{
|
|
if (typeof(System.Runtime.Serialization.DataMemberAttribute).IsInstanceOfType(attribute))
|
|
{
|
|
name = ((System.Runtime.Serialization.DataMemberAttribute)attribute).Name;
|
|
|
|
if (name == null)
|
|
{
|
|
name = property.Name;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (name == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AccessInfo info = new AccessInfo();
|
|
info.Parent = parent;
|
|
info.PropertyInfo = property;
|
|
info.TypeInfo = TypeInfo.Construct(property.PropertyType);
|
|
info.Value = element;
|
|
info.Name = name;
|
|
|
|
ShowNamedValue(info);
|
|
isStructure = true;
|
|
}
|
|
|
|
if (!isStructure)
|
|
{
|
|
ShowTextValue(parent.Value, parent.TypeInfo);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
/// <summary>
|
|
/// Returns the index based on the current count.
|
|
/// </summary>
|
|
private int[] GetIndexFromCount(int count, int[] dimensions)
|
|
{
|
|
int[] indexes = new int[(dimensions != null) ? dimensions.Length : 1];
|
|
|
|
for (int ii = indexes.Length - 1; ii >= 0; ii--)
|
|
{
|
|
indexes[ii] = count % dimensions[ii];
|
|
count /= dimensions[ii];
|
|
}
|
|
|
|
return indexes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the value at an array index to the control.
|
|
/// </summary>
|
|
private void ShowIndexedValue(AccessInfo info)
|
|
{
|
|
DataRow row = m_dataset.Tables[0].NewRow();
|
|
|
|
StringBuilder buffer = new StringBuilder();
|
|
buffer.Append("[");
|
|
|
|
if (info.Indexes != null)
|
|
{
|
|
for (int ii = 0; ii < info.Indexes.Length; ii++)
|
|
{
|
|
if (ii > 0)
|
|
{
|
|
buffer.Append(",");
|
|
}
|
|
|
|
buffer.Append(info.Indexes[ii]);
|
|
}
|
|
}
|
|
|
|
buffer.Append("]");
|
|
info.Name = buffer.ToString();
|
|
|
|
row[0] = info;
|
|
row[1] = info.Name;
|
|
row[2] = GetDataTypeString(info);
|
|
row[3] = ValueToString(info.Value, info.TypeInfo);
|
|
row[4] = ImageList.Images[ClientUtils.GetImageIndex(Attributes.Value, info.Value)];
|
|
|
|
m_dataset.Tables[0].Rows.Add(row);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the element type for a list.
|
|
/// </summary>
|
|
private Type GetListElementType(IList list)
|
|
{
|
|
if (list != null)
|
|
{
|
|
for (Type type = list.GetType(); type != null; type = type.BaseType)
|
|
{
|
|
if (type.IsGenericType)
|
|
{
|
|
Type[] argTypes = type.GetGenericArguments();
|
|
|
|
if (argTypes.Length > 0)
|
|
{
|
|
return argTypes[0];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return typeof(object);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the data type of the value.
|
|
/// </summary>
|
|
private Type GetDataType(AccessInfo accessInfo)
|
|
{
|
|
if (accessInfo == null || accessInfo.TypeInfo == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (accessInfo.TypeInfo.BuiltInType == BuiltInType.ExtensionObject)
|
|
{
|
|
if (accessInfo.Value != null)
|
|
{
|
|
return accessInfo.Value.GetType();
|
|
}
|
|
|
|
if (accessInfo.PropertyInfo != null)
|
|
{
|
|
return accessInfo.PropertyInfo.PropertyType;
|
|
}
|
|
|
|
if (accessInfo.Parent != null)
|
|
{
|
|
if (accessInfo.Parent.Value is Array)
|
|
{
|
|
Array array = (Array)accessInfo.Parent.Value;
|
|
return array.GetType().GetElementType();
|
|
}
|
|
|
|
if (accessInfo.Parent.Value is IList)
|
|
{
|
|
IList list = (IList)accessInfo.Parent.Value;
|
|
return GetListElementType(list);
|
|
}
|
|
}
|
|
}
|
|
|
|
return TypeInfo.GetSystemType(accessInfo.TypeInfo.BuiltInType, accessInfo.TypeInfo.ValueRank);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the data type of the value.
|
|
/// </summary>
|
|
private string GetDataTypeString(AccessInfo accessInfo)
|
|
{
|
|
Type type = GetDataType(accessInfo);
|
|
|
|
if (type == null)
|
|
{
|
|
return accessInfo.TypeInfo.ToString();
|
|
}
|
|
|
|
return type.Name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the value with the specified name to the control.
|
|
/// </summary>
|
|
private void ShowNamedValue(AccessInfo info)
|
|
{
|
|
DataRow row = m_dataset.Tables[0].NewRow();
|
|
|
|
row[0] = info;
|
|
row[1] = (info.Name != null) ? info.Name : "unknown";
|
|
row[2] = GetDataTypeString(info);
|
|
row[3] = ValueToString(info.Value, info.TypeInfo);
|
|
row[4] = ImageList.Images[ClientUtils.GetImageIndex(Attributes.Value, info.Value)];
|
|
|
|
m_dataset.Tables[0].Rows.Add(row);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays a value in the control.
|
|
/// </summary>
|
|
private void ShowTextValue(object value, TypeInfo typeInfo)
|
|
{
|
|
switch (typeInfo.BuiltInType)
|
|
{
|
|
case BuiltInType.ByteString:
|
|
{
|
|
ShowTextValue((byte[])value);
|
|
break;
|
|
}
|
|
|
|
case BuiltInType.XmlElement:
|
|
{
|
|
ShowTextValue((XmlElement)value);
|
|
break;
|
|
}
|
|
|
|
case BuiltInType.String:
|
|
{
|
|
ShowTextValue((string)value);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
ShowTextValue(ValueToString(value, typeInfo));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays a string in the control.
|
|
/// </summary>
|
|
private void ShowTextValue(string value)
|
|
{
|
|
ValuesDV.Visible = false;
|
|
TextValueTB.Visible = true;
|
|
|
|
if (value != null && value.Length > MaxDisplayTextLength)
|
|
{
|
|
TextValueTB.ScrollBars = ScrollBars.Both;
|
|
}
|
|
else
|
|
{
|
|
TextValueTB.ScrollBars = ScrollBars.None;
|
|
}
|
|
|
|
TextValueTB.Font = new Font("Segoe UI", TextValueTB.Font.Size);
|
|
TextValueTB.Text = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays a complete byte string in the control.
|
|
/// </summary>
|
|
private void ShowTextValue(byte[] value)
|
|
{
|
|
ValuesDV.Visible = false;
|
|
TextValueTB.Visible = true;
|
|
|
|
StringBuilder buffer = new StringBuilder();
|
|
|
|
if (value != null)
|
|
{
|
|
for (int ii = 0; ii < value.Length; ii++)
|
|
{
|
|
if (buffer.Length > 0 && (ii % 30) == 0)
|
|
{
|
|
buffer.Append("\r\n");
|
|
}
|
|
|
|
buffer.AppendFormat("{0:X2} ", value[ii]);
|
|
}
|
|
}
|
|
|
|
TextValueTB.Font = new Font("Courier New", TextValueTB.Font.Size);
|
|
TextValueTB.Text = buffer.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays a complete XML element in the control.
|
|
/// </summary>
|
|
private void ShowTextValue(XmlElement value)
|
|
{
|
|
ValuesDV.Visible = false;
|
|
TextValueTB.Visible = true;
|
|
|
|
StringBuilder buffer = new StringBuilder();
|
|
|
|
if (value != null)
|
|
{
|
|
XmlWriterSettings settings = new XmlWriterSettings();
|
|
settings.Indent = true;
|
|
settings.OmitXmlDeclaration = true;
|
|
settings.NewLineHandling = NewLineHandling.Replace;
|
|
settings.NewLineChars = "\r\n";
|
|
settings.IndentChars = " ";
|
|
|
|
using (XmlWriter writer = XmlWriter.Create(buffer, settings))
|
|
{
|
|
using (XmlNodeReader reader = new XmlNodeReader(value))
|
|
{
|
|
writer.WriteNode(reader, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
TextValueTB.Font = new Font("Courier New", TextValueTB.Font.Size);
|
|
TextValueTB.Text = buffer.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts a value to a string for display in the grid.
|
|
/// </summary>
|
|
private string ValueToString(object value, TypeInfo typeInfo)
|
|
{
|
|
if (value == null)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
|
|
if (value is Variant)
|
|
{
|
|
Variant variant = (Variant)value;
|
|
value = variant.Value;
|
|
|
|
if (value != null)
|
|
{
|
|
typeInfo = variant.TypeInfo;
|
|
|
|
if (typeInfo == null)
|
|
{
|
|
typeInfo = TypeInfo.Construct(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (typeInfo.ValueRank >= 0)
|
|
{
|
|
StringBuilder buffer = new StringBuilder();
|
|
|
|
System.Collections.IEnumerable enumerable = value as System.Collections.IEnumerable;
|
|
|
|
if (enumerable != null)
|
|
{
|
|
buffer.Append("{ ");
|
|
|
|
foreach (object element in enumerable)
|
|
{
|
|
if (buffer.Length > 2)
|
|
{
|
|
buffer.Append(" | ");
|
|
}
|
|
|
|
if (buffer.Length > MaxDisplayTextLength)
|
|
{
|
|
buffer.Append("...");
|
|
break;
|
|
}
|
|
|
|
buffer.Append(ValueToString(element, new TypeInfo(typeInfo.BuiltInType, ValueRanks.Scalar)));
|
|
}
|
|
|
|
buffer.Append(" }");
|
|
}
|
|
|
|
return buffer.ToString();
|
|
}
|
|
|
|
switch (typeInfo.BuiltInType)
|
|
{
|
|
case BuiltInType.String:
|
|
{
|
|
string text = (string)value;
|
|
|
|
if (text != null && text.Length > MaxDisplayTextLength)
|
|
{
|
|
return text.Substring(0, MaxDisplayTextLength) + "...";
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
case BuiltInType.ByteString:
|
|
{
|
|
StringBuilder buffer = new StringBuilder();
|
|
|
|
byte[] bytes = (byte[])value;
|
|
|
|
for (int ii = 0; ii < bytes.Length; ii++)
|
|
{
|
|
if (buffer.Length > MaxDisplayTextLength)
|
|
{
|
|
buffer.Append("...");
|
|
break;
|
|
}
|
|
|
|
buffer.AppendFormat("{0:X2}", bytes[ii]);
|
|
}
|
|
|
|
return buffer.ToString();
|
|
}
|
|
|
|
case BuiltInType.Enumeration:
|
|
{
|
|
return ((int)value).ToString();
|
|
}
|
|
|
|
case BuiltInType.ExtensionObject:
|
|
{
|
|
string text = null;
|
|
|
|
ExtensionObject extension = value as ExtensionObject;
|
|
|
|
if (extension != null)
|
|
{
|
|
if (extension.Body is byte[])
|
|
{
|
|
return ValueToString(extension.Body, new TypeInfo(BuiltInType.ByteString, ValueRanks.Scalar));
|
|
}
|
|
|
|
if (extension.Body is XmlElement)
|
|
{
|
|
return ValueToString(extension.Body, new TypeInfo(BuiltInType.XmlElement, ValueRanks.Scalar));
|
|
}
|
|
|
|
if (extension.Body is IEncodeable)
|
|
{
|
|
text = new Variant(extension).ToString();
|
|
}
|
|
}
|
|
|
|
if (text == null)
|
|
{
|
|
IEncodeable encodeable = value as IEncodeable;
|
|
|
|
if (encodeable != null)
|
|
{
|
|
text = new Variant(encodeable).ToString();
|
|
}
|
|
}
|
|
|
|
if (text != null && text.Length > MaxDisplayTextLength)
|
|
{
|
|
return text.Substring(0, MaxDisplayTextLength) + "...";
|
|
}
|
|
|
|
return text;
|
|
}
|
|
}
|
|
|
|
return (string)TypeInfo.Cast(value, BuiltInType.String);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether the value can be edited in the grid view.
|
|
/// </summary>
|
|
private bool IsSimpleValue(AccessInfo info)
|
|
{
|
|
if (info == null || info.TypeInfo == null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
TypeInfo typeInfo = info.TypeInfo;
|
|
object value = info.Value;
|
|
|
|
if (value is Variant)
|
|
{
|
|
Variant variant = (Variant)info.Value;
|
|
typeInfo = variant.TypeInfo;
|
|
value = variant.Value;
|
|
|
|
if (typeInfo == null)
|
|
{
|
|
typeInfo = TypeInfo.Construct(value);
|
|
}
|
|
}
|
|
|
|
if (typeInfo.ValueRank >= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (typeInfo.BuiltInType)
|
|
{
|
|
case BuiltInType.String:
|
|
{
|
|
string text = value as string;
|
|
|
|
if (text != null && text.Length >= MaxDisplayTextLength)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
case BuiltInType.ByteString:
|
|
case BuiltInType.XmlElement:
|
|
case BuiltInType.QualifiedName:
|
|
case BuiltInType.LocalizedText:
|
|
case BuiltInType.DataValue:
|
|
case BuiltInType.ExtensionObject:
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
private void NavigationMENU_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
EndEdit();
|
|
|
|
ToolStripItem item = sender as ToolStripItem;
|
|
|
|
if (item != null)
|
|
{
|
|
// remove all menu items appearing after the selected item.
|
|
for (int ii = NavigationMENU.Items.Count-1; ii >= 0; ii--)
|
|
{
|
|
ToolStripItem target = NavigationMENU.Items[ii];
|
|
NavigationMENU.Items.Remove(target);
|
|
|
|
if (Object.ReferenceEquals(target, item))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// show the current value.
|
|
AccessInfo info = (AccessInfo)item.Tag;
|
|
ShowValue(info);
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void ValuesDV_DoubleClick(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
foreach (DataGridViewCell cell in ValuesDV.SelectedCells)
|
|
{
|
|
DataRowView source = ValuesDV.Rows[cell.RowIndex].DataBoundItem as DataRowView;
|
|
|
|
if (cell.ColumnIndex == 3)
|
|
{
|
|
AccessInfo info = (AccessInfo)source.Row[0];
|
|
ShowValue(info);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
private void ValuesDV_CellValidating(object sender, DataGridViewCellValidatingEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (this.Visible && e.ColumnIndex == 3)
|
|
{
|
|
DataRowView source = ValuesDV.Rows[e.RowIndex].DataBoundItem as DataRowView;
|
|
AccessInfo info = (AccessInfo)source.Row[0];
|
|
|
|
if (IsSimpleValue(info))
|
|
{
|
|
TypeInfo.Cast(e.FormattedValue, info.TypeInfo.BuiltInType);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
e.Cancel = true;
|
|
}
|
|
}
|
|
|
|
private void ValuesDV_CellValueChanged(object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (this.Visible && e.RowIndex >= 0 && e.ColumnIndex == 3)
|
|
{
|
|
DataRowView source = ValuesDV.Rows[e.RowIndex].DataBoundItem as DataRowView;
|
|
AccessInfo info = (AccessInfo)source.Row[0];
|
|
|
|
if (IsSimpleValue(info))
|
|
{
|
|
object newValue = TypeInfo.Cast((string)source.Row[3], info.TypeInfo.BuiltInType);
|
|
info.Value = newValue;
|
|
UpdateParent(info);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
ClientUtils.HandleException(this.Text, exception);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recusivesly updates the parent values.
|
|
/// </summary>
|
|
private void UpdateParent(AccessInfo info)
|
|
{
|
|
if (info.Parent == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
object parentValue = info.Parent.Value;
|
|
|
|
if (info.Parent.TypeInfo.BuiltInType == BuiltInType.Variant && info.Parent.TypeInfo.ValueRank < 0)
|
|
{
|
|
parentValue = ((Variant)info.Parent.Value).Value;
|
|
}
|
|
|
|
if (info.PropertyInfo != null && info.Parent.TypeInfo.ValueRank < 0)
|
|
{
|
|
ExtensionObject extension = parentValue as ExtensionObject;
|
|
|
|
if (extension != null)
|
|
{
|
|
parentValue = extension.Body;
|
|
}
|
|
|
|
info.PropertyInfo.SetValue(parentValue, info.Value, null);
|
|
}
|
|
|
|
else if (info.Indexes != null)
|
|
{
|
|
int[] indexes = info.Indexes;
|
|
Array array = parentValue as Array;
|
|
|
|
Matrix matrix = parentValue as Matrix;
|
|
|
|
if (matrix != null)
|
|
{
|
|
int count = 0;
|
|
int block = 1;
|
|
|
|
for (int ii = info.Indexes.Length-1; ii >= 0 ; ii--)
|
|
{
|
|
count += info.Indexes[ii] * block;
|
|
block *= matrix.Dimensions[ii];
|
|
}
|
|
|
|
array = matrix.Elements;
|
|
indexes = new int[] { count };
|
|
}
|
|
|
|
if (array != null)
|
|
{
|
|
if (info.Parent.TypeInfo.BuiltInType == BuiltInType.Variant && info.Parent.TypeInfo.ValueRank >= 0)
|
|
{
|
|
array.SetValue(new Variant(info.Value), indexes);
|
|
}
|
|
else
|
|
{
|
|
array.SetValue(info.Value, indexes);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IList list = parentValue as IList;
|
|
|
|
if (info.Parent.TypeInfo.BuiltInType == BuiltInType.Variant && info.Parent.TypeInfo.ValueRank >= 0)
|
|
{
|
|
list[indexes[0]] = new Variant(info.Value);
|
|
}
|
|
else
|
|
{
|
|
list[indexes[0]] = info.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (info.Parent != null)
|
|
{
|
|
UpdateParent(info.Parent);
|
|
}
|
|
}
|
|
}
|
|
}
|