using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Linq;
|
using System.Xml.Serialization;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// This annotation represents a context menu for a given setting. Multiple of these might be present in a single
|
/// AnnotationCollection.
|
/// </summary>
|
public sealed class MenuAnnotation : IOwnedAnnotation
|
{
|
/// <summary> Creates a 'member' menu annotation. </summary>
|
internal MenuAnnotation(IMemberData member, ITypeData type, AnnotationCollection annotations)
|
{
|
this.member = member;
|
this.type = type;
|
rootAnnotations = annotations;
|
}
|
|
/// <summary> Creates a 'member' menu annotation. </summary>
|
/// <param name="member"> Which member of an object should the menu be generated for.</param>
|
/// <param name="type"> Set this if menu items for the type should be generated. </param>
|
internal MenuAnnotation(IMemberData member, ITypeData type)
|
{
|
this.member = member;
|
this.type = type;
|
}
|
|
/// <summary> Create a 'type' menu annotation. </summary>
|
/// <param name="type"> The type for which the menu should be generated. </param>
|
internal MenuAnnotation(ITypeData type) => this.type = type;
|
|
/// <summary> The member used to construct menu items. This maybe be null if 'type' has a value.</summary>
|
readonly IMemberData member;
|
|
/// <summary> The type used to construct menu items. This maybe be null if 'model' has a value.</summary>
|
readonly ITypeData type;
|
|
List<AnnotationCollection> annotations;
|
List<IMenuModel> models;
|
object[] source;
|
readonly AnnotationCollection rootAnnotations;
|
|
List<IMenuModel> getModels()
|
{
|
var member = this.member;
|
var type = this.type;
|
if (rootAnnotations != null)
|
{
|
var val2 = rootAnnotations.Get<IObjectValueAnnotation>()?.Value;
|
if (val2 != null)
|
type = TypeData.GetTypeData(val2);
|
}
|
|
if (models == null)
|
{
|
models = new List<IMenuModel>();
|
|
// get models for type menu annotations
|
if (type != null)
|
{
|
var factoryTypes = TypeData.GetDerivedTypes<ITypeMenuModelFactory>();
|
|
foreach (var factoryType in factoryTypes)
|
{
|
if (factoryType.CanCreateInstance == false) continue;
|
try
|
{
|
var factory = (ITypeMenuModelFactory)factoryType.CreateInstance();
|
IMenuModel model = factory.CreateModel(type);
|
if (model == null) continue;
|
model.Source = source;
|
if (model is IMenuModelState active && active.Enabled == false) continue;
|
models.Add(model);
|
}
|
catch
|
{
|
|
}
|
}
|
}
|
|
if(member != null)
|
{
|
// get models for member menu annotations
|
var factoryTypes = TypeData.GetDerivedTypes<IMenuModelFactory>();
|
|
foreach (var factoryType in factoryTypes)
|
{
|
if (factoryType.CanCreateInstance == false) continue;
|
try
|
{
|
var factory = (IMenuModelFactory)factoryType.CreateInstance();
|
IMenuModel model = factory.CreateModel(member);
|
if (model == null) continue;
|
model.Source = source;
|
if (model is IMenuModelState active && active.Enabled == false) continue;
|
models.Add(model);
|
}
|
catch
|
{
|
|
}
|
}
|
}
|
}
|
|
return models;
|
}
|
|
private static bool FilterDefault2(IReflectionData m)
|
{
|
var browsable = m.GetAttribute<BrowsableAttribute>();
|
|
// Browsable overrides everything
|
if (browsable != null) return browsable.Browsable;
|
|
var xmlIgnore = m.GetAttribute<XmlIgnoreAttribute>();
|
if (xmlIgnore != null)
|
return false;
|
|
if (m is IMemberData mem)
|
{
|
if (m.HasAttribute<OutputAttribute>())
|
return true;
|
if (!mem.Writable || !mem.Readable)
|
return false;
|
return true;
|
}
|
return false;
|
}
|
|
void generateAnnotations()
|
{
|
List<IMenuModel> models = getModels();
|
List<AnnotationCollection> items = new List<AnnotationCollection>();
|
foreach (var model in models)
|
{
|
var a = AnnotationCollection.Annotate(model);
|
|
var members = a.Get<IMembersAnnotation>()?.Members
|
.Where(x =>
|
{
|
var member = x.Get<IMemberAnnotation>()?.Member;
|
if (member == null) return false;
|
return FilterDefault2(member);
|
});
|
if(members == null) continue;
|
items.AddRange(members);
|
}
|
annotations = items;
|
}
|
|
/// <summary> Gets the menu items associated with this Menu. </summary>
|
public IEnumerable<AnnotationCollection> MenuItems
|
{
|
get
|
{
|
if (annotations == null)
|
generateAnnotations();
|
return annotations;
|
}
|
}
|
|
void IOwnedAnnotation.Read(object source)
|
{
|
this.source = source as object[] ?? new []{source};
|
if (annotations == null) return;
|
|
foreach (var model in models)
|
model.Source = this.source;
|
foreach(var annotation in annotations)
|
annotation.Read();
|
}
|
|
void IOwnedAnnotation.Write(object source)
|
{
|
this.source = source as object[] ?? new []{source};
|
if (annotations == null) return;
|
foreach (var model in models)
|
model.Source = this.source;
|
foreach(var annotation in annotations)
|
annotation.Write();
|
}
|
}
|
|
/// <summary> Factory class for build menus. This can be used to extend member with additional menu annotations.</summary>
|
public interface IMenuModelFactory : ITapPlugin
|
{
|
/// <summary> Create model should create exactly one IMenuItemModel whose members will be used in the MenuAnnotation. </summary>
|
/// <param name="member">The member to show the menu for.</param>
|
/// <returns>Shall return null if the model does not support the member.</returns>
|
IMenuModel CreateModel(IMemberData member);
|
}
|
|
/// <summary> Factory class for build menus. This can be used to extend a type with additional menu annotations.</summary>
|
public interface ITypeMenuModelFactory : ITapPlugin
|
{
|
/// <summary> Create model should create exactly one IMenuItemModel whose members will be used in the MenuAnnotation. </summary>
|
/// <param name="type">The member to show the menu for.</param>
|
/// <returns>Shall return null if the model does not support the member.</returns>
|
ITypeMenuModel CreateModel(ITypeData type);
|
}
|
|
/// <summary> Base class for things in a menu item. </summary>
|
public interface IMenuModel
|
{
|
/// <summary> The source for the menu item. This may be more than one element.
|
/// It is strongly recommended to explicitly implement this property. </summary>
|
object[] Source { get; set; }
|
}
|
|
/// <summary> menu model for members </summary>
|
public interface IMemberMenuModel : IMenuModel
|
{
|
/// <summary> The member this menu model represents. </summary>
|
IMemberData Member { get; }
|
}
|
|
/// <summary> menu model for types </summary>
|
public interface ITypeMenuModel : IMenuModel
|
{
|
|
}
|
|
|
/// <summary>
|
/// A MenuModel that can signal about it's current state (Enabled/Disabled). This is useful to dynamically disable the menu model.
|
/// </summary>
|
public interface IMenuModelState : IMenuModel
|
{
|
/// <summary> Gets if the menu model is enabled or disabled. </summary>
|
bool Enabled { get; }
|
}
|
|
/// <summary> Menu models for test step properties. </summary>
|
public interface ITestStepMenuModel
|
{
|
/// <summary> The selected test steps. </summary>
|
ITestStepParent[] Source { get; }
|
/// <summary> Selected Member </summary>
|
IMemberData Member { get; }
|
}
|
|
/// <summary>
|
/// Icon names defined here others might be defined by plugins. These names are used by IconAnnotationAttribute.
|
/// </summary>
|
public static class IconNames
|
{
|
const string Common = nameof(OpenTap)+ "." + nameof(IconNames) + ".";
|
/// <summary> Parameterize command </summary>
|
public const string Parameterize = Common + nameof(Parameterize);
|
/// <summary> Parameterize command </summary>
|
public const string ParameterizeOnTestPlan = Common + nameof(ParameterizeOnTestPlan);
|
/// <summary> Parameterize command </summary>
|
public const string ParameterizeOnParent = Common + nameof(ParameterizeOnParent);
|
/// <summary> Unparameterize command </summary>
|
public const string Unparameterize = Common + nameof(Unparameterize);
|
/// <summary> Parameterize command </summary>
|
public const string EditParameter = Common + nameof(EditParameter);
|
|
/// <summary> Parameterized icon name.</summary>
|
public const string Parameterized = Common + nameof(Parameterized);
|
/// <summary> Remove Parameter Command.</summary>
|
public const string RemoveParameter = Common + nameof(RemoveParameter);
|
/// <summary> Command to assign an output. </summary>
|
public const string AssignOutput = Common + nameof(AssignOutput);
|
/// <summary> Command to unassign an output. </summary>
|
public const string UnassignOutput = Common + nameof(UnassignOutput);
|
/// <summary> This is an output.</summary>
|
public const string Output = Common + nameof(Output);
|
/// <summary> This is an output.</summary>
|
public const string OutputAssigned = Common + nameof(OutputAssigned);
|
/// <summary> This is an input</summary>
|
public const string Input = Common + nameof(Input);
|
/// <summary> Add a mixin. </summary>
|
public const string AddMixin = Common + nameof(AddMixin);
|
/// <summary> Modifies a mixin. </summary>
|
public const string ModifyMixin = Common + nameof(ModifyMixin);
|
/// <summary> Remove a mixin. </summary>
|
public const string RemoveMixin = Common + nameof(RemoveMixin);
|
|
}
|
}
|
