// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.ComponentModel;
|
using System.Linq;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Identifies settings, properties, or methods that should only be valid/enabled when another property or setting has a certain value.
|
/// </summary>
|
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Method, AllowMultiple = true)]
|
public class EnabledIfAttribute : Attribute
|
{
|
/// <summary>
|
/// Gets or sets if the property should be hidden when disabled.
|
/// </summary>
|
public bool HideIfDisabled { get; set; }
|
|
/// <summary> Gets or sets if the enabling value is individual flags from an enum. </summary>
|
public bool Flags { get; set; }
|
|
/// <summary> Gets or sets if the value should enable or disable(inverted) the setting. </summary>
|
public bool Invert { get; set; }
|
|
static readonly TraceSource log = Log.CreateSource("EnabledIf");
|
|
/// <summary>
|
/// Name of the property to enable. Must exactly match a name of a property in the current class.
|
/// </summary>
|
public string PropertyName { get; }
|
|
/// <summary>
|
/// Value(s) the property must have for the item to be valid/enabled. If multiple values are specified, the item is enabled if just one value is equal.
|
/// If no values are specified, 'true' is the assumed value.
|
/// </summary>
|
// note, IComparable is not for equality comparing. It is meant for sorting, hence it does not really matter here.
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
[Obsolete("Use Values instead.")]
|
public IComparable[] PropertyValues => Values.OfType<IComparable>().ToArray();
|
|
/// <summary>
|
/// Value(s) the property must have for the item to be valid/enabled. If multiple values are specified, the item is enabled if just one value is equal.
|
/// If no values are specified, 'true' is the assumed value.
|
/// </summary>
|
public object[] Values { get; }
|
/// <summary>
|
/// Identifies settings, properties, or methods that are only valid/enabled when another property or setting has a certain value.
|
/// </summary>
|
/// <param name="propertyName">Name of the property to enable. Must exactly match a name of a property in the current class. </param>
|
/// <param name="propertyValues">Value(s) the property must have for the item to be valid/enabled. If multiple values are specified, the item is enabled if just one value is equal.
|
/// If no values are specified, 'true' is the assumed value.</param>
|
public EnabledIfAttribute(string propertyName, params object[] propertyValues)
|
{
|
PropertyName = propertyName;
|
if ((propertyValues == null) || (propertyValues.Length <= 0))
|
Values = new object[] {true};
|
else
|
Values = propertyValues;
|
}
|
|
internal virtual (bool enabled, bool hidden) IsEnabled(object instance, ITypeData instanceType, out IMemberData dependentProp)
|
{
|
bool newEnabled = true;
|
dependentProp = instanceType.GetMember(PropertyName);
|
|
if (dependentProp == null)
|
{
|
// We cannot be sure that the step developer has used this attribute correctly
|
// (could just be a typo in the (weakly typed) property name), thus we need to
|
// provide a good error message that leads the developer to where the error is.
|
log.Warning("Could not find property '{0}' on '{1}'. EnabledIfAttribute can only refer to properties of the same class as the property it is decorating.", PropertyName, instanceType.Name);
|
return (false, false);
|
}
|
|
var depValue = dependentProp.GetValue(instance);
|
|
try
|
{
|
newEnabled = calcEnabled(this, depValue);
|
}
|
catch (ArgumentException)
|
{
|
// CompareTo throws ArgumentException when obj is not the same type as this instance.
|
newEnabled = false;
|
}
|
bool hidden = false;
|
if (HideIfDisabled)
|
hidden = !newEnabled;
|
return (newEnabled, hidden);
|
}
|
|
/// <summary> Returns true if a member is enabled. </summary>
|
public static bool IsEnabled(IMemberData property, object instance,
|
out IMemberData dependentProp, out IComparable dependentValue, out bool hidden)
|
{
|
if (property == null)
|
throw new ArgumentNullException(nameof(property));
|
if (instance == null)
|
throw new ArgumentNullException(nameof(instance));
|
ITypeData instanceType = TypeData.GetTypeData(instance);
|
var dependencyAttrs = property.GetAttributes<EnabledIfAttribute>();
|
dependentProp = null;
|
dependentValue = 0;
|
hidden = false;
|
bool enabled = true;
|
foreach (var at in dependencyAttrs)
|
{
|
var (enabled2, hidden2) = at.IsEnabled(instance, instanceType, out dependentProp);
|
|
enabled &= enabled2;
|
if (hidden2)
|
hidden = true;
|
}
|
return enabled;
|
}
|
|
static bool calcEnabled(EnabledIfAttribute at, object value)
|
{
|
if(at.Invert)
|
return !calcEnabled2(at, value);
|
return calcEnabled2(at, value);
|
}
|
|
/// <summary> Calculate if an enabled if is enabled by a given value. </summary>
|
static bool calcEnabled2(EnabledIfAttribute at, object depValue)
|
{
|
if (at.Flags)
|
{
|
int value = (int)Convert.ChangeType(depValue, TypeCode.Int32);
|
foreach (var flag in at.Values)
|
{
|
int flagCode = (int) Convert.ChangeType(flag, TypeCode.Int32);
|
if ((value & flagCode) != 0)
|
return true;
|
}
|
return false;
|
}
|
|
if (depValue is IEnabled e)
|
depValue = e.IsEnabled;
|
|
foreach (var val in at.Values)
|
{
|
if (Equals(val, depValue))
|
return true;
|
}
|
|
return false;
|
}
|
|
/// <summary>
|
/// Checks whether a given property is enabled according to the <see cref="EnabledIfAttribute"/>.
|
/// </summary>
|
/// <param name="at">The attribute enabling this property.</param>
|
/// <param name="instance">Instance of the object that has 'property'.</param>
|
/// <returns>true if property dependent property has the correct value.</returns>
|
internal static bool IsEnabled(EnabledIfAttribute at, object instance)
|
{
|
IMemberData dependentProp = TypeData.GetTypeData(instance).GetMember(at.PropertyName);
|
if (dependentProp == null)
|
{
|
// We cannot be sure that the step developer has used this attribute correctly
|
// (could just be a typo in the (weakly typed) property name), thus we need to
|
// provide a good error message that leads the developer to where the error is.
|
log.Warning(
|
$"Could not find property '{at.PropertyName}' on '{instance.GetType().Name}'. " +
|
$"EnabledIfAttribute can only refer to properties of the same class as the property it is decorating.");
|
return false;
|
}
|
|
var depValue = dependentProp.GetValue(instance);
|
try
|
{
|
return calcEnabled(at, depValue);
|
}
|
catch (ArgumentException)
|
{
|
// CompareTo throws ArgumentException when obj is not the same type as this instance.
|
return false;
|
}
|
}
|
|
|
/// <summary>
|
/// Checks whether a given property is enabled according to the <see cref="EnabledIfAttribute"/>.
|
/// </summary>
|
/// <param name="instance">Instance that has property.</param>
|
/// <param name="property">Property to be checked for if it is enabled.</param>
|
/// <returns>True if property is enabled.</returns>
|
public static bool IsEnabled(IMemberData property, object instance)
|
{
|
return IsEnabled(property, instance, out _, out _, out _);
|
}
|
}
|
}
|
