private void AddType()
{
if (this.assemblyBrowser.SelectedNode is TypeNode)
{
TypeNode typeNode = (TypeNode)this.assemblyBrowser.SelectedNode;
// NOTE: Allow multiple instances of the same type (this is probably common)
//if (!this.typeDocuments.ContainsKey (typeNode.Type))
//{
WrappedType wrappedType = new WrappedType(typeNode.Type);
WrappingOptions wrappingOptions = new WrappingOptions(wrappedType);
wrappingOptions.MethodsListViewSelectedIndexChanged += this.OnListViewSelectedIndexChanged;
wrappingOptions.PropertiesListViewSelectedIndexChanged += this.OnListViewSelectedIndexChanged;
wrappingOptions.EventsListViewSelectedIndexChanged += this.OnListViewSelectedIndexChanged;
WrappedTypeDocument document = new WrappedTypeDocument(wrappingOptions);
document.SuspendLayout();
document.Guid = new Guid("A694E86E-73C0-417e-B85D-A04361C3CDC4");
document.SizeChanged += this.OnDockControlSizeChanged;
document.PerformLayout();
this.documentContainer.AddDocument(document);
//this.typeDocuments[typeNode.Type] = document;
//}
//this.typeDocuments[typeNode.Type].Activate ();
document.Activate();
}
}
public WrappingOptions(WrappedType wrappedType)
{
InitializeComponent();
InitializeWrapper();
this.wrappedType = wrappedType;
Tuple[] acquisitionModes =
{
new Tuple(Acquisition.Construct, "Construct an instance of the wrapped type"),
new Tuple(Acquisition.Parameter, "Pass an instance of the wrapped type as a parameter"),
new Tuple(Acquisition.Property, "Set an instance of the wrapped type as a property"),
new Tuple(Acquisition.UserManaged, "Allow user to control instance management of the wrapped type")
};
this.acquisitionComboBox.ValueMember = "Value1";
this.acquisitionComboBox.DisplayMember = "Values";
this.acquisitionComboBox.Items.AddRange(acquisitionModes);
this.acquisitionComboBox.SelectedIndex = 0;
this.defaultFieldName = wrappedType.FieldName;
this.fieldNameTextBox.Text = this.defaultFieldName;
// Methods
MethodInfo[] methods = wrappedType.Type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
Array.Sort <MethodInfo> (methods, this.MethodNameComparison);
foreach (MethodInfo method in methods)
{
if (!method.Name.ToLower().StartsWith("get_") && !method.Name.ToLower().StartsWith("set_") &&
!method.Name.ToLower().StartsWith("add_") && !method.Name.ToLower().StartsWith("remove_"))
{
MethodListViewItem listViewItem = new MethodListViewItem(method);
listViewItem.ImageIndex = (int)WrappingOptions.ImageIndices.Method;
this.methodsListView.Items.Add(listViewItem);
}
}
// Properties
PropertyInfo[] properties = wrappedType.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
Array.Sort <PropertyInfo> (properties, this.PropertyNameComparison);
foreach (PropertyInfo property in properties)
{
PropertyListViewItem listViewItem = new PropertyListViewItem(property);
listViewItem.ImageIndex = (int)WrappingOptions.ImageIndices.Property;
this.propertiesListView.Items.Add(listViewItem);
}
// Events
EventInfo[] events = wrappedType.Type.GetEvents(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
Array.Sort <EventInfo> (events, this.EventNameComparison);
foreach (EventInfo _event in events)
{
EventListViewItem listViewItem = new EventListViewItem(_event);
listViewItem.ImageIndex = (int)WrappingOptions.ImageIndices.Event;
this.eventsListView.Items.Add(listViewItem);
}
}
private void Set(string name, object value)
{
if (Wrapped != null)
{
PropertyInfo property = WrappedType.GetProperty(name);
if (property != null && property.CanWrite)
{
property.SetValue(Wrapped, value, null);
}
}
}
public void DictionaryToObject()
{
var entity = Entity.New(typeof(Data.InputObject));
var wrappedType = new WrappedType(entity);
var obj = wrappedType.FromDictionary(new Dictionary <string, object>
{
{ "b", 123 },
});
obj.ShouldNotBeNull();
}
private void GeneratePartialClassHeader(StringBuilder sb, bool isUserFile)
{
sb.AppendLine("// Generated class v" + this.htmlUnitVersion
+ (isUserFile ? ", can be modified" : ", don't modify"));
sb.AppendLine();
if (!isUserFile)
{
sb.AppendLine("using System;");
sb.AppendLine("using System.Collections.Generic;");
sb.AppendLine("using System.Collections.Specialized;");
sb.AppendLine("using System.Linq;");
sb.AppendLine("using System.Text;");
sb.AppendLine();
}
sb.Append("namespace ");
sb.AppendLine(TargetNamespace);
sb.AppendLine("{");
var interfaceList = new StringBuilder();
if (isUserFile)
{
sb.AppendLine(" public partial class " + TargetNameWithoutNamespace);
}
else
{
IEnumerable <Type> wrappedInterfaces = WrappedType
.GetInterfaces()
.Where(i => Repository.TypeIsWrapped(i));
foreach (var wrappedInterface in wrappedInterfaces)
{
interfaceList.AppendFormat(", {0}", Repository.GetTargetFullName(wrappedInterface));
Repository.MarkUsageOfType(wrappedInterface);
}
if (WrappedBase != null && Repository.TypeIsWrapped(WrappedBase))
{
Repository.MarkUsageOfType(WrappedBase);
}
sb.AppendFormat(
" public partial class {0} : {1}{2}\r\n",
TargetNameWithoutNamespace,
TargetBaseName,
interfaceList
);
}
sb.AppendLine(" {");
}
private Typewrapper RefCapableWrapper(WrappedType type, Structure s, out bool cached)
{
bool firstTime;
long objectId = idgenerator.GetId(s, out firstTime);
Debug.LogFormat(
"Identified object type '{0}' with id {1}, firstTime={2}; in rrefDict={3}", s.KOSName, objectId, firstTime, idMap.ContainsKey(objectId)
);
if ((cached = !firstTime)) // Assignment intentional
{
idMap[objectId]["ref"] = objectId;
return(new Typewrapper(WrappedType.Reference, objectId));
}
return(idMap[objectId] = new Typewrapper(type));
}
/// <summary>
/// Populates this instance with its class members.
/// </summary>
private void PopulateWithClassMembers()
{
var eventInfo = WrappedType.GetEvents(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
Members.AddRange(eventInfo.Select(ei => new ClassMemberViewModel(ei, MemberType.Event)));
var methodInfo = WrappedType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance).Where(m => !m.IsSpecialName);
Members.AddRange(methodInfo.Select(mi => new ClassMemberViewModel(mi, MemberType.Method)));
var propInfo = WrappedType.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
Members.AddRange(propInfo.Select(pi => new ClassMemberViewModel(pi, MemberType.Property)));
var ctors = ((TypeInfo)WrappedType).DeclaredConstructors.Cast <ConstructorInfo>();
Members.AddRange(ctors.Select(ci => new ClassMemberViewModel(ci, MemberType.Constructor)));
}
private object Get(string name)
{
if (Wrapped != null)
{
PropertyInfo prop = WrappedType.GetProperty(name);
if (prop != null)
{
try
{
return(prop.GetValue(Wrapped, null));
}
catch// (Exception ex)
{
return(null);
}
}
}
return(null);
}
/// <summary>
/// Sets the value of specified property.
/// </summary>
protected void SetProperty(string name, object value)
{
WrappedType.InvokeMember(name, BindingFlags.SetProperty, null, WrappedObject, new object[] { value });
}
/// <summary>
/// Gets the value of specified property.
/// </summary>
protected T GetProperty <T>(string name)
{
return((T)WrappedType.InvokeMember(name, BindingFlags.GetProperty, null, WrappedObject, null));
}
/// <summary>
/// Invokes the method with specified name.
/// </summary>
protected object InvokeMethod(string name, params object[] args)
{
return(WrappedType.InvokeMember(name, BindingFlags.InvokeMethod, null, WrappedObject, args != null && args.Length == 0 ? null : args));
}
public Typewrapper(WrappedType type, object data = null) : base()
{
this["type"] = type.ToString().ToLowerInvariant();
this["data"] = data;
}
private void ScanMembers(Type type)
{
// The special meal of today: find interfaces that is new on this class, and clashes with existing fields!
var newInterfacesForThisSubclass =
WrappedType
.GetInterfaces()
.Except(WrappedBase != null ? WrappedBase.GetInterfaces() : new Type[] { })
.Where(i => Repository.TypeIsWrapped(i));
var existingNames = new HashSet <string>(
Methods.Values.Select(m => m.TargetMethodInfo.Name));
var methodsOfNewInterfaces =
newInterfacesForThisSubclass
.SelectMany(il => il.GetMethods())
.Where(m => existingNames.Contains(m.Name))
.ToArray();
foreach (var wmiRo in Methods.Values)
{
var wmi = wmiRo; // To get correct lambda closure!
var conflictingMethods = methodsOfNewInterfaces
.Where(m => wmi.TargetMethodInfo.Name == m.Name)
.Where(m => IsMethodSignatureCastable(m, wmi.TargetMethodInfo))
.ToArray();
foreach (var cm in conflictingMethods)
{
Console.WriteLine("Conflicting method: " + cm);
}
if (conflictingMethods.Any())
{
throw new InvalidOperationException();
}
}
// First extract all properties and methods
IEnumerable <MethodInfo> nonObsoleteMethods = type
.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
.Where(mi => (!mi.GetCustomAttributes(typeof(ObsoleteAttribute), true).Any()))
.Where(mi => (!mi.Name.Contains("<")))
// TODO: Support methods with weird names that starts with "<bridge>"
.Where(mi =>
(type.BaseType == null ||
type.BaseType.GetMethod(mi.Name,
mi.GetParameters().Select(pi => pi.ParameterType).ToArray())
== null));
foreach (MethodInfo method in nonObsoleteMethods)
{
bool wrappedAsProperty = false;
if (method.Name.Length > 3 && method.IsPublic)
{
if (method.Name.StartsWith("get") &&
method.ReturnType != typeof(void) &&
method.GetParameters().Length == 0
// We can't convert methods to properties that will cause the property to have the same name as the type.
&& method.Name.Substring(3) != type.Name)
{
GetWrapperPropInfoFor(Properties, method.Name.Substring(3)).GetterMethod = method;
wrappedAsProperty = true;
}
else if (method.Name.StartsWith("set") &&
method.GetParameters().Length == 1 &&
method.ReturnType == typeof(void))
{
GetWrapperPropInfoFor(Properties, method.Name.Substring(3)).SetterMethod = method;
wrappedAsProperty = true;
}
}
if (!wrappedAsProperty)
{
Methods.Add(method.ToString(), new WrapperMethodInfo(this, method));
}
}
if (!type.IsAbstract)
{
// Extract constructors
var nonObsoletePublicConstructors = type
.GetConstructors()
.Where(mi => (!mi.GetCustomAttributes(typeof(ObsoleteAttribute), true).Any()))
.Where(mi => mi.DeclaringType == type)
.Where(mi => !mi.IsAbstract);
foreach (var constructor in nonObsoletePublicConstructors)
{
Constructors.Add(new WrapperConstructorInfo(this, constructor));
}
}
// Extract public static
var publicStaticFields = type
.GetFields(BindingFlags.Public | BindingFlags.Static)
.Where(mi => (!mi.GetCustomAttributes(typeof(ObsoleteAttribute), true).Any()))
.Where(f => !f.FieldType.IsInterface);
foreach (var field in publicStaticFields)
{
StaticPublicFields.Add(new WrapperStaticPublicField(this, field));
}
}
public void GenerateInterfaceCode(StringBuilder sb)
{
// {0} is namespace declarations
// {1} is namespace of interface
// {2} is name of interface
// {3} is to be filled with methods and properties etc..
var baseInterfaceString = new StringBuilder();
foreach (var baseInterface in WrappedType.GetInterfaces().Where(i => Repository.TypeIsWrapped(i)))
{
Repository.MarkUsageOfType(baseInterface);
baseInterfaceString.Append(", ");
baseInterfaceString.Append(Repository.GetTargetFullName(baseInterface));
}
const string fileFmt = @"// Wrapper for {5}
{0}
namespace {1}
{{
public interface {2} : NHtmlUnit.IObjectWrapper{3}
{{
{4}
}}
}}
";
var namespaceIncludes =
@"// Generated class v" + this.htmlUnitVersion + @", don't modify
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Text;
";
var body = new StringBuilder();
#warning HACK HACK HACK ON
if (!WrappedType.FullName.StartsWith("org.w3c.dom."))
{
foreach (var wpi in Properties.Where(x => x.Value.GetterMethod != null))
{
wpi.Value.GeneratePropertyCode(body);
}
foreach (var wm in Methods)
{
wm.Value.GenerateMethodCode(body);
}
}
sb.AppendFormat(fileFmt,
namespaceIncludes,
TargetNamespace,
TargetNameWithoutNamespace,
baseInterfaceString,
body,
WrappedType.FullName);
}