public void PropertyToDictionary()
{
var node = new ConstructionNode(typeof(Window))
{
Assignments = new List <MemberAssignment>()
{
new MemberAssignment()
{
Member = Member.FromStandard <Window>(window => window.Resources),
Children = new[] { new ConstructionNode(typeof(TextBlock))
{
Key = "MyKey"
}, },
}
}
};
var actual = Create(node).Result;
var expected = new Window {
Resources = new ResourceDictionary {
{ "MyKey", new TextBlock() }
}
};
Assert.Equal(expected, actual);
}
protected override void AssembleFromChildren(MemberAssignment a, ConstructionNode constructionNode,
INodeToObjectBuilder nodeToObjectBuilder, BuilderContext context)
{
var loaderInfo = metadataProvider.Get(constructionNode.ActualInstanceType).FragmentLoaderInfo;
if (loaderInfo != null)
{
if (constructionNode.ActualInstanceType == loaderInfo.Type &&
a.Member.MemberName == loaderInfo.PropertyName)
{
ConstructionNode payload = constructionNode.Assignments.First(assignment => assignment.Member.MemberName == loaderInfo.PropertyName).Values.First();
var loader = loaderInfo.Loader.Load(payload, nodeToObjectBuilder, context);
CreateInstance(constructionNode);
ApplyAssignments(constructionNode, nodeToObjectBuilder, context);
a.Values = new[] { new ConstructionNode(loader.GetType())
{
Instance = loader
} };
AssigmentApplier.ExecuteAssignment(new NodeAssignment(a, constructionNode.Instance), nodeToObjectBuilder, context);
}
}
else
{
base.AssembleFromChildren(a, constructionNode, nodeToObjectBuilder, context);
}
}
public void Collection()
{
var tree = new ConstructionNode(typeof(Collection))
{
Assignments = new[]
{
new MemberAssignment
{
SourceValue = "My title",
Member = Member.FromStandard <Collection>(collection => collection.Title)
}
},
Children = new[]
{
new ConstructionNode(typeof(TextBlock)),
new ConstructionNode(typeof(TextBlock))
}
};
var actual = Create(tree).Result;
var expected = new Collection {
new TextBlock(), new TextBlock()
};
expected.Title = "My title";
Assert.Equal(expected, actual);
}
public void BasicEvent()
{
var node = new ConstructionNode(typeof(Window))
{
Assignments = new[]
{
new MemberAssignment
{
Member = Member.FromStandard <Window>(tb => tb.Content),
Children = new List <ConstructionNode>
{
new ConstructionNode <Button>
{
Assignments = new[]
{
new MemberAssignment
{
Member = Member.FromStandard(typeof(Button), nameof(Button.Click)),
SourceValue = nameof(TestWindow.OnClick)
}
}
}
}
}
}
};
var root = new TestWindow();
Create(node, root);
(root.Content as Button).ClickButton();
Assert.True(root.ButtonClicked);
}
public void GivenSimpleExtensionThatProvidesAString_TheStringIsProvided()
{
var constructionNode = new ConstructionNode(typeof(SimpleExtension))
{
Assignments =
new List <MemberAssignment>
{
new MemberAssignment
{
Member = Member.FromStandard <SimpleExtension>(extension => extension.Property),
SourceValue = "MyText"
}
}
};
var node = new ConstructionNode(typeof(TextBlock))
{
Assignments = new[]
{
new MemberAssignment
{
Member = Member.FromStandard <TextBlock>(tb => tb.Text),
Children = new[] { constructionNode }
}
}
};
var b = Create(node);
Assert.Equal(new TextBlock {
Text = "MyText"
}, b.Result);
}
public void ContentPropertyDirectContentTextInsideChild()
{
var parseResult = ParseResult(@"<Window xmlns=""root""><TextBlock>Saludos cordiales</TextBlock></Window>");
var expected = new ConstructionNode(typeof(Window))
{
Assignments = new[]
{
new MemberAssignment
{
Member = Member.FromStandard <Window>(window => window.Content),
Children = new[]
{
new ConstructionNode(typeof(TextBlock))
{
Assignments = new[]
{
new MemberAssignment()
{
Member = Member.FromStandard <TextBlock>(tb => tb.Text),
SourceValue = "Saludos cordiales"
},
}
},
}
}
}
};
Assert.Equal(expected, parseResult.Root);
}
public void BindTest()
{
var converter = new TypeConverterSourceValueConverter();
var omniGuiInstanceCreator = new Rework.OmniGuiInstanceCreator(converter, new TypeLocator(() => new List <ControlTemplate>(), new OmniGuiPropertyEngine()));
var valuePipeline = new OmniGuiValuePipeline(new MarkupExtensionValuePipeline(new NoActionValuePipeline()), null);
var assignmentApplier = new OmniGuiMemberAssignmentApplier(converter, valuePipeline);
var sut = new OmniGuiObjectBuilder(omniGuiInstanceCreator, converter, assignmentApplier);
var node = new ConstructionNode(typeof(Button))
{
Assignments = new List <MemberAssignment>
{
new MemberAssignment
{
Member = Member.FromStandard <Button>(b => b.Content),
Children = new List <ConstructionNode>()
{
new ConstructionNode(typeof(Bind))
{
Assignments = new List <MemberAssignment>()
{
new MemberAssignment()
{
Member = Member.FromStandard <Bind>(b => b.TargetProperty),
Children = ConstructionNode.ForString("SomeProperty")
}
}
}
}
}
}
};
var instance = sut.Inflate(node);
}
public void TestMethod2()
{
var prefixAnnotator = new PrefixAnnotator();
var newTypeDirectory = GetTypeDirectory();
var sut = new PrefixedTypeResolver(prefixAnnotator, newTypeDirectory);
var childNode = new ConstructionNode(typeof(TextBlock));
var root = new ConstructionNode(typeof(Window))
{
Assignments = new List <MemberAssignment>()
{
new MemberAssignment()
{
Member = Member.FromStandard <Window>(window => window.Content),
Children = new[] { childNode, }
}
},
};
prefixAnnotator.Annotate(childNode, new List <PrefixDeclaration>()
{
new PrefixDeclaration("a", "another")
});
sut.Root = root;
var customGridType = sut.GetTypeByPrefix(childNode, "a:CustomGrid");
Assert.Equal(typeof(CustomGrid), customGridType);
}
private static CreationFixture CreateWithParams(ConstructionNode node, Func <IObjectBuilder, ConstructionNode, BuildContext, object> createFunc)
{
var constructionContext = new ObjectBuilderContext(
new SourceValueConverter(),
new AttributeBasedMetadataProvider());
var prefixAnnotator = new PrefixAnnotator();
var executingAssembly = new[] { Assembly.GetExecutingAssembly() };
var attributeBasedTypeDirectory = new AttributeBasedTypeDirectory(executingAssembly);
var builder =
new ExtendedObjectBuilder(
new InstanceCreator(constructionContext.SourceValueConverter, constructionContext, attributeBasedTypeDirectory),
constructionContext,
new ContextFactory(attributeBasedTypeDirectory, constructionContext));
var newTypeDirectory = GetTypeDirectory();
var creationContext = new BuildContext(
new NamescopeAnnotator(constructionContext.MetadataProvider),
new AmbientRegistrator(),
new InstanceLifecycleSignaler())
{
PrefixAnnotator = prefixAnnotator, PrefixedTypeResolver = new PrefixedTypeResolver(prefixAnnotator, newTypeDirectory)
};
return(new CreationFixture
{
Result = createFunc(builder, node, creationContext),
BuildContext = creationContext
});
}
public void TemplateContent()
{
var node = new ConstructionNode(typeof(ItemsControl))
{
Assignments = new List <MemberAssignment>
{
new MemberAssignment
{
Member = Member.FromStandard <ItemsControl>(control => control.ItemTemplate),
Children = new List <ConstructionNode>
{
new ConstructionNode(typeof(DataTemplate))
{
Assignments = new[]
{
new MemberAssignment
{
Member = Member.FromStandard <DataTemplate>(template => template.Content),
Children = new[] { new ConstructionNode(typeof(TextBlock)) }
}
}
}
}
}
}
};
var creationFixture = Create(node);
}
public void ParentPrefixesAreAvailableInChild()
{
var type = typeof(TextBlock);
var assembly = type.GetTypeInfo().Assembly;
var xamlNamespaces = XamlNamespace.Map("root").With(Route.Assembly(assembly).WithNamespaces(type.Namespace));
var prefixAnnotator = new PrefixAnnotator();
var sut = new PrefixedTypeResolver(prefixAnnotator, new TypeDirectory(new[] { xamlNamespaces }));
var childNode = new ConstructionNode(typeof(TextBlock));
var root = new ConstructionNode(typeof(Window))
{
Assignments = new List <MemberAssignment>()
{
new MemberAssignment()
{
Member = Member.FromStandard <Window>(window => window.Content),
Children = new[] { childNode, }
}
},
};
prefixAnnotator.Annotate(root, new List <PrefixDeclaration>()
{
new PrefixDeclaration(string.Empty, "root")
});
sut.Root = root;
var buttonType = sut.GetTypeByPrefix(childNode, "Button");
Assert.Equal(typeof(Button), buttonType);
}
private bool SubNodesAreCreated(ConstructionNode constructionNode)
{
var membersCreated = constructionNode.Assignments.All(ma => ma.Values.All(node => node.IsCreated));
var childrenCreated = constructionNode.Assignments.All(ma => ma.Values.All(node => node.IsCreated));
return(membersCreated && childrenCreated);
}
public void NodeWithChildrenShouldGetThemAsChildren()
{
var converter = new FuncStringConverterExtended((s, t) => (true, Convert.ChangeType(s, t)));
var creator = new FuncInstanceCreator((hints, type) => new CreationResult(Activator.CreateInstance(type)));
var sut = new NodeAssembler(creator, converter, null);
var constructionNode = new ConstructionNode <Collection>()
.WithChildren(
new ConstructionNode <int>
{
SourceValue = "1"
},
new ConstructionNode <int>
{
SourceValue = "2"
},
new ConstructionNode <int>
{
SourceValue = "3"
}
);
sut.Assemble(constructionNode, null);
Assert.Equal(new Collection()
{
1, 2, 3,
}, (IEnumerable)constructionNode.Instance);
}
public void Namescope()
{
var parseResult = ParseResult(@"<Window xmlns:x=""special"" xmlns=""root""><TextBlock x:Name=""One"" /></Window>");
var expectedNode = new ConstructionNode(typeof(Window))
{
Assignments = new List <MemberAssignment>
{
new MemberAssignment
{
Member = Member.FromStandard <Window>(w => w.Content),
Children = new List <ConstructionNode>
{
new ConstructionNode(typeof(TextBlock))
{
Name = "One",
Assignments = new[] { new MemberAssignment {
Member = Member.FromStandard <TextBlock>(block => block.Name), SourceValue = "One"
} }
}
}
}
}
};
Assert.Equal(expectedNode, parseResult.Root);
}
public void BasicEvent()
{
var tree = ParseResult(@"<Window xmlns=""root"">
<Button Click=""OnClick"" />
</Window>");
var expected = new ConstructionNode(typeof(Window))
{
Assignments = new[]
{
new MemberAssignment()
{
Member = Member.FromStandard <Window>(window => window.Content),
Children = new[]
{
new ConstructionNode(typeof(Button))
{
Assignments = new[] { new MemberAssignment()
{
SourceValue = "OnClick", Member = Member.FromStandard(typeof(Button), "Click")
}, }
},
}
},
}
};
Assert.Equal(expected, tree.Root);
}
public void CollectionProperty()
{
var items = new[]
{
new ConstructionNode(typeof(TextBlock)),
new ConstructionNode(typeof(TextBlock)),
new ConstructionNode(typeof(TextBlock))
};
var node = new ConstructionNode(typeof(ItemsControl))
{
Assignments = new[]
{
new MemberAssignment
{
Member = Member.FromStandard <ItemsControl>(tb => tb.Items),
Children = items
}
}
};
var result = (ItemsControl)Create(node).Result;
Assert.NotNull(result.Items);
Assert.IsAssignableFrom <IEnumerable>(result.Items);
Assert.NotEmpty(result.Items);
}
public void MarkupExtensionWithoutPrefix()
{
var parseResult = ParseResult(@"<Window xmlns=""root"" Content=""{Simple}"" />");
var expected = new ConstructionNode <Window>().WithAssignment(w => w.Content, new ConstructionNode <SimpleExtension>());
Assert.Equal(expected, parseResult.Root);
}
public void ClrNs()
{
var parseResult = ParseResult(@"<Window xmlns=""using:OmniXaml.Tests.Model;Assembly=OmniXaml.Tests"" />");
var expected = new ConstructionNode(typeof(Window));
Assert.Equal(expected, parseResult.Root);
}
public void Class()
{
var xaml = @"<Window xmlns=""root"" xmlns:x=""special"" x:Class=""OmniXaml.Tests.Model.Custom.CustomWindow;assembly=OmniXaml.Tests"" />";
var p = ParseResult(xaml);
ConstructionNode expected = new ConstructionNode(typeof(Window)) { InstantiateAs = typeof(CustomWindow) };
Assert.Equal(expected, p.Root);
}
public void CDataInsidePropertyElement()
{
var parseResult = ParseResult(@"<Window xmlns=""root""><Window.Content><![CDATA[Hello]]></Window.Content></Window>");
var expected = new ConstructionNode <Window>().WithAssignment(w => w.Content, "Hello");
Assert.Equal(expected, parseResult.Root);
}
public void PropertyElementThatIsAnAttachedProperty()
{
var parseResult = ParseResult(@"<Window xmlns=""root""><Grid.Row>1</Grid.Row></Window>");
var expected = new ConstructionNode <Window>().WithAttachedAssignment <Grid>("Row", "1");
Assert.Equal(expected, parseResult.Root);
}
public void ContentPropertyDirectContentText()
{
var parseResult = ParseResult(@"<TextBlock xmlns=""root"">Hello</TextBlock>");
var expected = new ConstructionNode <TextBlock>().WithAssignment(tb => tb.Text, "Hello");
Assert.Equal(expected, parseResult.Root);
}
public void AttachedPropertyFromPrefixedNamespace()
{
var parseResult = ParseResult(@"<Window xmlns=""root"" xmlns:a=""custom"" a:CustomGrid.Value=""1"" />");
var expected = new ConstructionNode <Window>()
.WithAttachedAssignment <CustomGrid>("Value", "1");
Assert.Equal(expected, parseResult.Root);
}
public void PropertyElementWithTextContent()
{
var parseResult = ParseResult(@"<Window xmlns=""root""><Window.Content>Hola</Window.Content></Window>");
var expected = new ConstructionNode <Window>()
.WithAssignment(w => w.Content, "Hola");
Assert.Equal(expected, parseResult.Root);
}
public void ObjectAndDirectProperties()
{
var parseResult = ParseResult(@"<Window xmlns=""root"" Title=""Saludos"" />");
var expected = new ConstructionNode <Window>()
.WithAssignment(w => w.Title, "Saludos");
Assert.Equal(expected, parseResult.Root);
}
// Update is called once per frame
void Update()
{
// Select repair items with mouse
if (selected == '\0' && Input.GetMouseButtonDown(0))
{
RaycastHit hit;
Ray ray = main_camera.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, 1000, 1 << LayerMask.NameToLayer("UI")))
{
Transform objectHit = hit.transform;
// Do something with the object that was hit by the raycast.
SelectableRepairNode ui_element = objectHit.GetComponent <SelectableRepairNode>();
selected = ui_element.hotkey;
mouse_selected = true;
SoundFactory.AddSound("event:/menuselect", null, null);
}
}
else if ((mouse_selected && Input.GetMouseButtonUp(0)) || (!mouse_selected && selected != '\0' && Input.GetMouseButtonDown(0)))
{
RaycastHit hit;
Ray ray = main_camera.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, 1000, 1 << LayerMask.NameToLayer("Build")))
{
Transform objectHit = hit.transform;
// Do something with the object that was hit by the raycast.
ConstructionNode construction_site = objectHit.GetComponentInChildren <ConstructionNode>();
construction_site.construct(buildings[selected]);
SoundFactory.AddSound("event:/menuselect", null, null);
}
selected = '\0';
mouse_selected = false;
}
KeyCode[] hotkeys = new KeyCode[] { KeyCode.Q, KeyCode.W, KeyCode.E, KeyCode.R };
// Select repair items with hotkeys (priority)
foreach (KeyCode key in hotkeys)
{
if (Input.GetKeyDown(key))
{
selected = (char)key;
mouse_selected = false;
SoundFactory.AddSound("event:/menuselect", null, null);
}
else if (Input.GetKeyUp(key) && (char)key == selected)
{
selected = '\0';
mouse_selected = false;
}
}
}
public void InvalidTypeThrows()
{
var node = new ConstructionNode(typeof(Window))
{
InstantiateAs = typeof(TextBlock)
};
Assert.Throws <InvalidOperationException>(() => Create(node));
}
public void ImmutableFromContent()
{
var parseResult = ParseResult(@"<MyImmutable xmlns=""root"">hola</MyImmutable>");
var expected = new ConstructionNode <MyImmutable> {
PositionalParameters = new[] { "hola" }
};
Assert.Equal(expected, parseResult.Root);
}
public void EventAttachedToCorrectInstance()
{
var xaml = @"<Window xmlns=""root"" xmlns:x=""special"" x:Class=""OmniXaml.Tests.Model.TestWindow;assembly=OmniXaml.Tests"" Clicked=""OnClick"" />";
var p = ParseResult(xaml);
var expected = new ConstructionNode <Window, TestWindow>()
.WithAssignment("Clicked", "OnClick");
Assert.Equal(expected, p.Root);
}
public void ContentPropertyDirectContentTextInsideChild()
{
var parseResult = ParseResult(@"<Window xmlns=""root""><TextBlock>Saludos cordiales</TextBlock></Window>");
var expected = new ConstructionNode <Window>()
.WithAssignment(w => w.Content,
new ConstructionNode <TextBlock>().WithAssignment(tb => tb.Text, "Saludos cordiales"));
Assert.Equal(expected, parseResult.Root);
}
