public void TestThatFactoryMethodForIStickyNoteModelIsFromEM1ForGraphView()
{
var method = ExtensionMethodCache <ElementBuilder> .GetExtensionMethod(typeof(GraphView),
typeof(IStickyNoteModel), GraphElementFactory.FilterMethods, GraphElementFactory.KeySelector);
Assert.AreEqual(typeof(ExtensionMethods1).GetMethod(nameof(ExtensionMethods1.CreateForStickyNote)), method);
}
public void TestThatFactoryMethodForINodeModelIsFromDefault(Type domainType)
{
var method = ExtensionMethodCache <ElementBuilder> .GetExtensionMethod(domainType,
typeof(INodeModel), GraphElementFactory.FilterMethods, GraphElementFactory.KeySelector);
Assert.AreEqual(typeof(GraphViewFactoryExtensions).GetMethod(nameof(GraphViewFactoryExtensions.CreateNode)), method);
}
public void TestThatFactoryMethodForIPlacematModelIsFromEM1(Type domainType)
{
var method = ExtensionMethodCache <ElementBuilder> .GetExtensionMethod(domainType,
typeof(IPlacematModel), GraphElementFactory.FilterMethods, GraphElementFactory.KeySelector);
Assert.AreEqual(typeof(ExtensionMethods1).GetMethod(nameof(ExtensionMethods1.CreateForPlacemat)), method);
}
public void TestThatFactoryMethodForModel3IsFromEM2()
{
var method = ExtensionMethodCache <ElementBuilder> .GetExtensionMethod(typeof(ExtensionTestGraphView),
typeof(TestModel3), GraphElementFactory.FilterMethods, GraphElementFactory.KeySelector);
Assert.AreEqual(typeof(ExtensionMethods2).GetMethod(nameof(ExtensionMethods2.CreateForTestModel3)), method);
}
public void TestThatFactoryMethodForModel3IsNullForGraphView()
{
var method = ExtensionMethodCache <ElementBuilder> .GetExtensionMethod(typeof(GraphView),
typeof(TestModel3), GraphElementFactory.FilterMethods, GraphElementFactory.KeySelector);
Assert.IsNull(method);
}
public static VisualElement CreateEditorForNodeModel(this VisualElement element, IConstantNodeModel model, Action <IChangeEvent> onValueChanged)
{
VisualElement editorElement;
var ext = ExtensionMethodCache <IConstantEditorBuilder> .GetExtensionMethod(model.GetType(), ConstantEditorBuilder.FilterMethods, ConstantEditorBuilder.KeySelector);
var graphAsset = model.AssetModel;
if (ext != null)
{
Action <IChangeEvent> myValueChanged = evt =>
{
if (evt != null) // Enum editor sends null
{
var p = evt.GetType().GetProperty("newValue");
var newValue = p.GetValue(evt);
((ConstantNodeModel)model).ObjectValue = newValue;
onValueChanged(evt);
}
// TODO ugly but required to actually get the graph to be saved. Note that for some reason, the
// first edit works because the graph is already dirty
EditorUtility.SetDirty(graphAsset as Object);
};
var constantBuilder = new ConstantEditorBuilder(myValueChanged);
editorElement = (VisualElement)ext.Invoke(null, new object[] { constantBuilder, model });
}
else
{
Debug.Log($"Could not draw Editor GUI for node of type {model.GetType()}");
editorElement = new Label("<Unknown>");
}
return(editorElement);
}
// static StatementSyntax StatementFromExitStrategy(StackExitStrategy stackExitStrategy, ExpressionSyntax returnValue)
// {
// StatementSyntax lastStatementSyntax;
// switch (stackExitStrategy)
// {
// case StackExitStrategy.Return:
// lastStatementSyntax = ReturnStatement(returnValue);
// break;
// case StackExitStrategy.Break:
// lastStatementSyntax = BreakStatement();
// break;
// case StackExitStrategy.None:
// lastStatementSyntax = null;
// break;
// default:
// lastStatementSyntax = ContinueStatement();
// break;
// }
//
// return lastStatementSyntax;
// }
protected virtual IEnumerable <SyntaxNode> BuildNode(INodeModel statement, IPortModel portModel)
{
if (statement == null)
{
return(Enumerable.Empty <SyntaxNode>());
}
Assert.IsTrue(portModel == null || portModel.NodeModel == statement, "If a Port is provided, it must be owned by the provided node");
var ext = ExtensionMethodCache <RoslynTranslator> .GetExtensionMethod(
statement.GetType(),
FilterMethods,
KeySelector);
if (ext != null)
{
var syntaxNode = (IEnumerable <SyntaxNode>)ext.Invoke(null, new object[] { this, statement, portModel }) ?? Enumerable.Empty <SyntaxNode>();
var annotatedNodes = new List <SyntaxNode>();
foreach (var node in syntaxNode)
{
var annotatedNode = node?.WithAdditionalAnnotations(new SyntaxAnnotation(Annotations.VSNodeMetadata, statement.Guid.ToString()));
annotatedNodes.Add(annotatedNode);
}
return(annotatedNodes);
}
else
{
Debug.LogError("Roslyn Translator doesn't know how to create a node of type: " + statement.GetType());
}
return(Enumerable.Empty <SyntaxNode>());
}
// PF TODO: This API and ConstantEditorBuilder is badly designed.
/// <summary>
/// Creates an editor for a constant.
/// </summary>
/// <param name="uiContext">The view in which the editor constant will be displayed.</param>
/// <param name="portModel">The port that owns the constant, if any.</param>
/// <param name="constant">The constant.</param>
/// <param name="onValueChanged">An action to call when the user has finished editing the value.</param>
/// <param name="modelIsLocked">Whether the node owning the constant, if any, is locked.</param>
/// <returns>A VisualElement that contains an editor for the constant.</returns>
public static VisualElement CreateEditorForConstant(
IModelView uiContext, IPortModel portModel, IConstant constant,
Action <IChangeEvent, object> onValueChanged, bool modelIsLocked)
{
Action <IChangeEvent> myValueChanged = evt =>
{
if (evt != null) // Enum editor sends null
{
var p = evt.GetType().GetProperty("newValue");
var newValue = p.GetValue(evt);
if (constant is IStringWrapperConstantModel stringWrapperConstantModel)
{
stringWrapperConstantModel.StringValue = (string)newValue;
}
else
{
onValueChanged(evt, newValue);
}
}
};
var ext = ExtensionMethodCache <IConstantEditorBuilder> .GetExtensionMethod(
uiContext.GetType(), constant.GetType(),
ConstantEditorBuilder.FilterMethods, ConstantEditorBuilder.KeySelector);
if (ext != null)
{
var constantBuilder = new ConstantEditorBuilder(myValueChanged, uiContext.CommandDispatcher, modelIsLocked, portModel);
return((VisualElement)ext.Invoke(null, new object[] { constantBuilder, constant }));
}
Debug.Log($"Could not draw Editor GUI for node of type {constant.Type}");
return(new Label("<Unknown>"));
}
public void TestConstantEditorExtensionMethodsExistForBasicTypes()
{
var expectedTypes = new[]
{
typeof(StringConstant), typeof(BooleanConstant), typeof(IntConstant),
typeof(DoubleConstant), typeof(FloatConstant),
typeof(Vector2Constant), typeof(Vector3Constant), typeof(Vector4Constant), typeof(QuaternionConstant),
typeof(EnumConstant), typeof(ColorConstant),
typeof(AnimationClipConstant), typeof(MeshConstant), typeof(Texture2DConstant), typeof(Texture3DConstant),
typeof(EnumValueReference)
};
for (var i = 0; i < expectedTypes.Length; i++)
{
var type = expectedTypes[i];
var constantExtMethod = ExtensionMethodCache <IConstantEditorBuilder> .GetExtensionMethod(typeof(GraphView), type, ConstantEditorBuilder.FilterMethods, ConstantEditorBuilder.KeySelector);
Assert.IsNotNull(constantExtMethod, $"No constant editor for {type.Name}");
}
}
/// <summary>
/// Creates an instance of a class implementing <see cref="IModelUI"/> to display <paramref name="model"/>.
/// </summary>
/// <param name="view">The view in which to put the UI.</param>
/// <param name="commandDispatcher">The command dispatcher.</param>
/// <param name="model">The model.</param>
/// <param name="context">A context creation string. When a model needs different UI in
/// different contexts, use this parameter to differentiate between contexts.</param>
/// <typeparam name="T">The type of the returned object.</typeparam>
/// <returns>An instance of <see cref="IModelUI"/> that display <paramref name="model"/>.</returns>
public static T CreateUI <T>(IModelView view, CommandDispatcher commandDispatcher, IGraphElementModel model, string context) where T : class, IModelUI
{
if (view == null)
{
Debug.LogError("GraphElementFactory could not create element because view is null.");
return(null);
}
if (model == null)
{
Debug.LogError("GraphElementFactory could not create element because model is null.");
return(null);
}
var ext = ExtensionMethodCache <ElementBuilder> .GetExtensionMethod(
view.GetType(),
model.GetType(),
FilterMethods,
KeySelector
);
T newElem = null;
if (ext != null)
{
var nodeBuilder = new ElementBuilder {
View = view, Context = context
};
newElem = ext.Invoke(null, new object[] { nodeBuilder, commandDispatcher, model }) as T;
}
if (newElem == null)
{
Debug.LogError($"GraphElementFactory doesn't know how to create a UI of type {typeof(T)} for model of type: {model.GetType()}");
return(null);
}
return(newElem);
}
public void TestUINodeBuilderExtensionMethods()
{
TestExtensionMethodsAreSameFastAndSlow(mode =>
ExtensionMethodCache <ElementBuilder> .BuildFactoryMethodCache(GraphElementFactory.FilterMethods, GraphElementFactory.KeySelector, mode));
}
public void TestConstantEditorExtensionMethods()
{
TestExtensionMethodsAreSameFastAndSlow(mode =>
ExtensionMethodCache <IConstantEditorBuilder> .BuildFactoryMethodCache(ConstantEditorBuilder.FilterMethods, ConstantEditorBuilder.KeySelector, mode));
}
