private static void Merge(object source, object target, Type type)
{
var browser = TypeBrowser.Create(type);
foreach (TypeBrowser.ElementInfo element in browser.Attributes.Concat(browser.Elements))
{
object value = element.GetValue(source);
if (element.IsCollection)
{
foreach (object item in (IEnumerable)value)
{
MergeValue(element, target, item);
}
}
else
{
MergeValue(element, target, value);
}
}
if (source is IHtmlContent htmlContent && (htmlContent.Text != null))
{
((IHtmlContent)target).Text = htmlContent.Text;
}
}
public void TestElements()
{
TypeBrowser browser = TypeBrowser.Create(typeof(DerivedClass));
// Check that the base was searched
var property = browser.FindElement(new XmlComponent(null, "Base.Private", null));
Assert.That(property.Name, Is.EqualTo("BPrivate"));
property = browser.FindElement(new XmlComponent(null, "Base.Protected", null));
Assert.That(property.Name, Is.EqualTo("BProtected"));
// Check namespaces
property = browser.FindElement(new XmlComponent(null, "Derived.Public", null));
Assert.That(property.Name, Is.EqualTo("DPublic"));
property = browser.FindElement(new XmlComponent(null, "Derived.Public", "ns"));
Assert.That(property.Name, Is.EqualTo("DPublicNs"));
// Check a readonly property
property = browser.FindElement(new XmlComponent(null, "Derived.Private", null));
Assert.That(property.Name, Is.EqualTo("DPrivate"));
// Makes sure we don't have any attributes
Assert.That(browser.FindElement(new XmlComponent(null, "Derived.Attribute", null)),
Is.Null);
Assert.That(browser.FindElement(new XmlComponent(null, "Derived.Field", null)),
Is.Null);
Assert.That(browser.Elements.Count(), Is.EqualTo(6));
}
public void ShowStateBrowser()
{
TypeBrowser currentBrowser = TypeBrowser.ShowBrowser();
currentBrowser.CreateNewFunc += this.CreateStateData;
currentBrowser.InitBrowser(typeof(StateDataBase));
}
public void ShowTransitionBrowser()
{
TypeBrowser currentBrowser = TypeBrowser.ShowBrowser();
currentBrowser.CreateNewFunc += this.CreateTransition;
currentBrowser.InitBrowser(typeof(TransitionDataBase));
}
public void TestDomainAssemblies()
{
var browser = new TypeBrowser(engine.Models);
var n = 0;
var known = browser.KnownTypes.Select(t => new { Value = t, Number = n++ })
.FirstOrDefault(t => typeof(Person) == t.Value);
//browser.FriendlyAssemblies.ToList().ForEach(assembly => Debug.WriteLine(assembly.FullName));
Assert.AreEqual(5, browser.FriendlyAssemblies.Count());
Assert.IsTrue(known.Number < 250);
}
/// <summary>Writes the start of an XML element.</summary>
/// <param name="writer">An <see cref="XmlWriter"/> to write to.</param>
public void CreateStartElement(XmlWriter writer)
{
if (this.State != ItemIconStates.None) // Make sure there's something to save
{
var attributes = from v in States
where (v != ItemIconStates.None) && this.State.HasFlag(v)
select TypeBrowser.GetEnum(v).ElementName;
string value = string.Join(" ", attributes);
writer.WriteElementString("state", KmlNamespaces.Kml22Namespace, value);
}
}
/// <summary>
/// Writes the start of an XML element.
/// </summary>
/// <param name="writer">An <see cref="XmlWriter"/> to write to.</param>
public void CreateStartElement(XmlWriter writer)
{
// Make sure there's something to save
if (this.State != ItemIconStates.None)
{
IEnumerable <string> attributes = States.Where(s => (s != ItemIconStates.None) && this.State.HasFlag(s))
.Select(s => TypeBrowser.GetEnum(s))
.Where(a => a != null)
.Select(a => a.ElementName);
string value = string.Join(" ", attributes);
writer.WriteElementString("state", KmlNamespaces.Kml22Namespace, value);
}
}
/// <summary>
/// Static create function.
/// </summary>
/// <param name="name">The name of the Definition to create.</param>
/// <param name="callback">A UICallback.</param>
/// <returns></returns>
internal static void Create(String name, EditUICallback callback, CompositeSimObjectDefinition simObjectDef)
{
if (behaviorBrowser == null)
{
behaviorBrowser = new TypeBrowser("Behaviors", "Choose Behavior", typeof(Behavior));
}
callback.showBrowser <Type>(behaviorBrowser, delegate(Type behaviorType, ref String errorMessage)
{
if (behaviorType != null)
{
simObjectDef.addElement(new BehaviorDefinition(name, (Behavior)Activator.CreateInstance(behaviorType)));
return(true);
}
return(false);
});
}
/// <summary>
/// Launch the user interface for developer to pick a contract type.
/// </summary>
/// <param name="localAssemblyName">The local assembly name.</param>
/// <param name="referencedAssemblies">The list of referenced assembly names.</param>
/// <param name="editingContext">The editing context.</param>
/// <returns>The contract type selected by user or null if user cancels.</returns>
public static Type SelectContractType(AssemblyName localAssemblyName, IList <AssemblyName> referencedAssemblies, EditingContext editingContext)
{
AssemblyContextControlItem assemblyContextControlItem = new AssemblyContextControlItem {
LocalAssemblyName = localAssemblyName, ReferencedAssemblyNames = referencedAssemblies
};
TypeBrowser typeBrowser = new TypeBrowser(assemblyContextControlItem, editingContext, FilterFunction);
bool? dialogResult = typeBrowser.ShowDialog(/* owner = */ null);
if (dialogResult.HasValue && dialogResult.Value)
{
return(typeBrowser.ConcreteType);
}
else
{
return(null);
}
}
void ShowBrowserUseTypeBrowserData(TypeBrowser type)
{
switch (type)
{
case TypeBrowser.System:
/* IDC_WebBrowser WebBrowser = new IDC_WebBrowser();
* Data.Browser = WebBrowser;*/
break;
case TypeBrowser.Own:
IDD_INT INT = new IDD_INT();
Data.Browser = INT;
break;
default:
break;
}
Data.Browser.ShowDialog();
}
private void addTrack(EditUICallback callback)
{
callback.getInputString("Enter a name for the track.", delegate(String trackName, ref String trackErrorPrompt)
{
if (String.IsNullOrEmpty(trackName))
{
trackErrorPrompt = "You must enter a name for the track.";
return(false);
}
TypeBrowser browser = new TypeBrowser("Track Types", "Choose a track type", typeof(ShowPropSubAction));
callback.showBrowser(browser, delegate(Type resultType, ref String typeBrowseErrorPrompt)
{
addTrack(new ShowPropSubActionPrototype(resultType, trackName));
return(true);
});
return(true);
});
}
public void TestAttributes()
{
TypeBrowser browser = TypeBrowser.Create(typeof(DerivedClass));
// Make sure the namespaces work
var property = browser.FindAttribute(new XmlComponent(null, "Derived.Attribute", null));
Assert.That(property.Name, Is.EqualTo("DAttribute"));
Assert.That(browser.FindAttribute(new XmlComponent(null, "Derived.Public", null)),
Is.Null); // This is an element
Assert.That(browser.FindAttribute(new XmlComponent(null, "Derived.Field", null)),
Is.Null); // This isn't a property
Assert.That(browser.Attributes.Count(), Is.EqualTo(1));
// Make sure the cache works
Assert.That(TypeBrowser.Create(typeof(DerivedClass)), Is.SameAs(browser));
Assert.That(TypeBrowser.Create(typeof(BaseClass)), Is.Not.SameAs(browser));
}
/// <summary>
/// Retrieves and returns the selected type from the user.
/// </summary>
/// <param name="selectedType">The type to select in the type selection dialog.</param>
/// <param name="baseType">The base type (class or interface) from which the constrained type should derive.</param>
/// <param name="selectorIncludes">Indicates the types that can be browsed.</param>
/// <param name="configurationType">The base type from which a type specified by the
/// <see cref="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ConfigurationElementTypeAttribute"/>
/// bound to the constrained type should derive, or <see langword="null"/> if no such constraint is necessary.
/// </param>
/// <returns>
/// The selected <see cref="Type"/> or <see langword="null"/> if not type is selected.
/// </returns>
protected virtual Type GetSelectedType(Type selectedType, Type baseType, TypeSelectorIncludes selectorIncludes, Type configurationType)
{
var viewModel = new TypeBrowserViewModel(new TypeBuildNodeConstraint(baseType, configurationType, selectorIncludes), this);
var selector = new TypeBrowser(viewModel, this.discoveryService);
Nullable <bool> result = false;
if (this.UIService != null)
{
result = UIService.ShowDialog(selector);
}
else
{
result = selector.ShowDialog();
}
if (result.HasValue && result.Value)
{
return(selector.SelectedType);
}
return(null);
}
public void SetUp()
{
this.browser = TypeBrowser.Create(typeof(DerivedClass));
}
/// <summary>
/// Rewrites the target methods by the proxy ones.
/// </summary>
/// <param name="assembly">The assembly to modify.</param>
private void Rewrite(Assembly assembly)
{
Contract.Requires(assembly != null);
var types = new AssemblyBrowser(assembly, assembly, new TypeMatching()).FindTypes().ToList();
foreach (var type in types)
{
var entryHook = type.Proxy.FindMethods(MemberType.Static, typeof(EntryHookAttribute)).SingleOrDefault();
var exitHook = type.Proxy.FindMethods(MemberType.Static, typeof(ExitHookAttribute)).SingleOrDefault();
Trace.WriteLine(string.Format("Rewriting type {0}.", string.Join(", ", type.Target.FullName)));
var pairs = new TypeBrowser(type.Proxy, type.Target, new MethodMatching()).FindTypes();
foreach (var pair in pairs)
{
Trace.WriteLine(string.Format("Rewriting pair {0}.", pair.Target.Name));
pair.Target.ReplaceBody(pair.Proxy, entryHook, exitHook);
}
}
}
