void CreateFieldItems(SearcherItem root, Type type, int depth)
{
var operators = GetOperatorsFromType(type);
foreach (var op in operators)
{
root.AddChild(op);
}
depth--;
if (depth <= 0)
{
return;
}
var infos = GetMemberInfos(type);
foreach (var info in infos)
{
var itemType = info.MemberType == MemberTypes.Field
? (info as FieldInfo)?.FieldType
: (info as PropertyInfo)?.PropertyType;
var item = new TypeSearcherItem(itemType.GenerateTypeHandle(m_Stencil), info.Name);
CreateFieldItems(item, itemType, depth);
// We only display item with binary operators
if (item.HasChildren)
{
root.AddChild(item);
}
}
}
public bool OnSearcherSelectEntry(SearcherItem entry, Vector2 screenMousePosition)
{
if (entry == null || (entry as SearchNodeItem).NodeGUID.node == null)
{
return(false);
}
var nodeEntry = (entry as SearchNodeItem).NodeGUID;
var node = CopyNodeForGraph(nodeEntry.node);
var windowRoot = m_EditorWindow.rootVisualElement;
var windowMousePosition = windowRoot.ChangeCoordinatesTo(windowRoot.parent, screenMousePosition); //- m_EditorWindow.position.position);
var graphMousePosition = m_GraphView.contentViewContainer.WorldToLocal(windowMousePosition);
m_Graph.owner.RegisterCompleteObjectUndo("Add " + node.name);
if (node is BlockNode blockNode)
{
if (!(target is ContextView contextView))
{
return(false);
}
// Test against all current BlockNodes in the Context
// Never allow duplicate BlockNodes
if (contextView.contextData.blocks.Where(x => x.value.name == blockNode.name).FirstOrDefault().value != null)
{
return(false);
}
// Insert block to Data
blockNode.owner = m_Graph;
int index = contextView.GetInsertionIndex(screenMousePosition);
m_Graph.AddBlock(blockNode, contextView.contextData, index);
return(true);
}
var drawState = node.drawState;
drawState.position = new Rect(graphMousePosition, Vector2.zero);
node.drawState = drawState;
m_Graph.AddNode(node);
if (connectedPort != null)
{
var connectedSlot = connectedPort.slot;
var connectedSlotReference = connectedSlot.owner.GetSlotReference(connectedSlot.id);
var compatibleSlotReference = node.GetSlotReference(nodeEntry.compatibleSlotId);
var fromReference = connectedSlot.isOutputSlot ? connectedSlotReference : compatibleSlotReference;
var toReference = connectedSlot.isOutputSlot ? compatibleSlotReference : connectedSlotReference;
m_Graph.Connect(fromReference, toReference);
nodeNeedsRepositioning = true;
targetSlotReference = compatibleSlotReference;
targetPosition = graphMousePosition;
}
return(true);
}
protected override IEnumerable <IGraphElementModel> CreateGraphElements(SearcherItem item)
{
return(item is GraphNodeModelSearcherItem graphItem
? graphItem.CreateElements.Invoke(
new GraphNodeCreationData(m_GraphModel, Vector2.zero, SpawnFlags.Orphan))
: Enumerable.Empty <IGraphElementModel>());
}
static bool OnItemSelected(SearcherItem item, Action <TypeHandle, TypeMember, BinaryOperatorKind> callback)
{
if (!(item is CriterionSearcherItem criterionItem))
{
return(false);
}
var componentType = TypeHandle.Unknown;
var path = new Stack <string>();
var parent = item.Parent;
var memberType = parent is TypeSearcherItem tsi ? tsi.Type : TypeHandle.Unknown;
while (parent != null)
{
if (parent.Parent == null && parent is TypeSearcherItem typeItem)
{
componentType = typeItem.Type;
}
else
{
path.Push(parent.Name);
}
parent = parent.Parent;
}
var op = criterionItem.Operator;
callback(componentType, new TypeMember(memberType, path.ToList()), op);
return(true);
}
public GraphElementSearcherDatabase AddFunctionMembers(IFunctionModel functionModel)
{
if (functionModel == null)
{
return(this);
}
SearcherItem parent = null;
IEnumerable <IVariableDeclarationModel> members = functionModel.FunctionParameterModels.Union(
functionModel.FunctionVariableModels);
foreach (IVariableDeclarationModel declarationModel in members)
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, k_FunctionMembers);
}
parent.AddChild(new GraphNodeModelSearcherItem(
new TypeSearcherItemData(declarationModel.DataType, SearcherItemTarget.Variable),
data => data.CreateVariableNode(declarationModel),
declarationModel.Name.Nicify()
));
}
return(this);
}
protected override void OnGraphElementsCreated(SearcherItem searcherItem,
IEnumerable <IGraphElementModel> elements)
{
if (m_DetailsPanel == null)
{
return;
}
if (m_Description == null)
{
m_Description = new VisualElement {
name = "nodeDescription"
};
m_Scrollview.Add(m_Description);
}
var elementList = elements.ToList();
if (!elementList.Any() || !(elementList.First() is IDotsNodeModel baseDotsNodeModel))
{
return;
}
m_Description.Clear();
NodeDocumentationFormatter formatter = new SearcherNodeDocumentationFormatter(m_Description);
formatter.DocumentNode(searcherItem, baseDotsNodeModel);
}
public GraphElementSearcherDatabase AddGraphAssetMembers(IGraphModel graph)
{
SearcherItem parent = null;
TypeHandle voidTypeHandle = Stencil.GenerateTypeHandle(typeof(void));
foreach (var functionModel in graph.NodeModels.OfType <FunctionModel>())
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, graph.Name);
}
if (functionModel.ReturnType == voidTypeHandle)
{
parent.AddChild(new StackNodeModelSearcherItem(
new GraphAssetSearcherItemData(graph.AssetModel),
data => data.CreateFunctionRefCallNode(functionModel),
functionModel.Title
));
continue;
}
parent.AddChild(new GraphNodeModelSearcherItem(
new GraphAssetSearcherItemData(graph.AssetModel),
data => data.CreateFunctionRefCallNode(functionModel),
functionModel.Title
));
}
return(this);
}
public GraphElementSearcherDatabase AddGraphVariables(IGraphModel graphModel)
{
SearcherItem parent = null;
var vsGraphModel = (VSGraphModel)graphModel;
foreach (IVariableDeclarationModel declarationModel in vsGraphModel.GraphVariableModels)
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, k_GraphVariables);
}
parent.AddChild(new GraphNodeModelSearcherItem(
new TypeSearcherItemData(declarationModel.DataType, SearcherItemTarget.Variable),
data => ((VSGraphModel)data.GraphModel).CreateVariableNode(
declarationModel,
data.Position,
data.SpawnFlags
),
declarationModel.Name.Nicify()
));
}
return(this);
}
public GraphElementSearcherDatabase AddConstructors(Type type, BindingFlags bindingFlags)
{
SearcherItem parent = null;
foreach (ConstructorInfo constructorInfo in type.GetConstructors(bindingFlags))
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, type.FriendlyName(false));
}
MethodDetails details = constructorInfo.GetMethodDetails();
parent.AddChild(new GraphNodeModelSearcherItem(
new ConstructorSearcherItemData(constructorInfo),
data => ((VSGraphModel)data.GraphModel).CreateFunctionCallNode(
constructorInfo,
data.Position,
data.SpawnFlags
),
details.MethodName,
details.Details
));
}
return(this);
}
public GraphElementSearcherDatabase AddUnaryOperators()
{
SearcherItem parent = SearcherItemUtility.GetItemFromPath(Items, k_Operator);
foreach (UnaryOperatorKind kind in Enum.GetValues(typeof(UnaryOperatorKind)))
{
if (kind == UnaryOperatorKind.PostDecrement || kind == UnaryOperatorKind.PostIncrement)
{
parent.AddChild(new StackNodeModelSearcherItem(
new UnaryOperatorSearcherItemData(kind),
data => data.CreateUnaryStatementNode(kind),
kind.ToString()
));
continue;
}
parent.AddChild(new GraphNodeModelSearcherItem(
new UnaryOperatorSearcherItemData(kind),
data => data.CreateUnaryStatementNode(kind),
kind.ToString()
));
}
return(this);
}
public void TestFind_Null()
{
var parent = new SearcherItem("parent");
var child = parent.Find("child");
Assert.IsNull(child);
}
public Searcher.Searcher LoadSearchWindow()
{
GenerateNodeEntries();
//create empty root for searcher tree
var root = new List <SearcherItem>();
var dummyEntry = new NodeEntry();
foreach (var nodeEntry in currentNodeEntries)
{
SearcherItem item = null;
SearcherItem parent = null;
for (int i = 0; i < nodeEntry.title.Length; i++)
{
var pathEntry = nodeEntry.title[i];
List <SearcherItem> children = parent != null ? parent.Children : root;
item = children.Find(x => x.Name == pathEntry);
if (item == null)
{
//if we have slot entries and are at a leaf, add the slot name to the entry title
if (nodeEntry.compatibleSlotId != -1 && i == nodeEntry.title.Length - 1)
{
item = new SearchNodeItem(pathEntry + ": " + nodeEntry.slotName, nodeEntry);
}
//if we don't have slot entries and are at a leaf, add userdata to the entry
else if (nodeEntry.compatibleSlotId == -1 && i == nodeEntry.title.Length - 1)
{
item = new SearchNodeItem(pathEntry, nodeEntry);
}
//if we aren't a leaf, don't add user data
else
{
item = new SearchNodeItem(pathEntry, dummyEntry);
}
if (parent != null)
{
parent.AddChild(item);
}
else
{
children.Add(item);
}
}
parent = item;
if (parent.Depth == 0 && !root.Contains(parent))
{
root.Add(parent);
}
}
}
var nodeDatabase = SearcherDatabase.Create(root, string.Empty, false);
return(new Searcher.Searcher(nodeDatabase, new SearchWindowAdapter("Create Node")));
}
private string MakePath(SearcherItem searcherItem, char separator)
{
if (searcherItem.Parent == null)
{
return(searcherItem.Name);
}
return(MakePath(searcherItem.Parent, separator) + separator + searcherItem.Name);
}
internal static SearcherDatabase Populate <T>(Func <Type, bool> filter = null, Func <Type, string> nameResolver = null, Func <Type, string> categoryResolver = null)
{
var list = new List <SearcherItem>();
var dict = new Dictionary <string, SearcherItem>();
var types = TypeCache.GetTypesDerivedFrom <T>();
foreach (var type in types)
{
if (type.IsGenericType || type.IsAbstract || type.ContainsGenericParameters || type.IsInterface)
{
continue;
}
if (!TypeConstruction.CanBeConstructed(type))
{
continue;
}
if (filter != null && !filter(type))
{
continue;
}
try
{
var typeItem = new TypeSearcherItem(type, nameResolver != null ? nameResolver(type) : string.Empty);
var category = categoryResolver != null?categoryResolver(type) : type.Namespace ?? "Global";
if (!string.IsNullOrEmpty(category))
{
if (!dict.TryGetValue(category, out var item))
{
dict[category] = item = new SearcherItem(category);
list.Add(item);
}
item.AddChild(typeItem);
}
else
{
list.Add(typeItem);
}
}
catch (Exception)
{
// ignored
}
}
foreach (var kvp in dict)
{
kvp.Value.Children.Sort(CompareByName);
}
list.Sort(CompareByName);
return(new SearcherDatabase(list));
}
bool OnTypeSelected(SearcherItem item)
{
if (item is TypeSearcherItem typeItem && TypeConstruction.TryConstruct <T>(typeItem.Type, out var instance))
{
Target = instance;
return(true);
}
return(false);
}
public GraphElementSearcherDatabase AddMethods(
Type type,
BindingFlags bindingFlags,
Dictionary <string, List <Type> > blackList = null
)
{
SearcherItem parent = null;
foreach (MethodInfo methodInfo in type.GetMethods(bindingFlags)
.Where(m => !m.IsSpecialName &&
m.GetCustomAttribute <ObsoleteAttribute>() == null &&
m.GetCustomAttribute <HiddenAttribute>() == null &&
!m.Name.StartsWith("get_", StringComparison.Ordinal) &&
!m.Name.StartsWith("set_", StringComparison.Ordinal) &&
!m.GetParameters().Any(p => p.ParameterType.IsByRef || p.IsOut || p.ParameterType.IsPointer) &&
!SearcherItemCollectionUtility.IsMethodBlackListed(m, blackList))
.OrderBy(m => m.Name))
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, type.FriendlyName(false));
}
MethodDetails details = methodInfo.GetMethodDetails();
if (methodInfo.ReturnType == typeof(void))
{
parent.AddChild(new StackNodeModelSearcherItem(
new MethodSearcherItemData(methodInfo),
data => ((StackBaseModel)data.StackModel).CreateFunctionCallNode(
methodInfo,
data.Index,
data.SpawnFlags
),
details.MethodName,
details.Details
));
continue;
}
if (!methodInfo.ReturnType.IsPointer)
{
parent.AddChild(new GraphNodeModelSearcherItem(
new MethodSearcherItemData(methodInfo),
data => ((VSGraphModel)data.GraphModel).CreateFunctionCallNode(
methodInfo,
data.Position,
data.SpawnFlags
),
details.MethodName,
details.Details
));
}
}
return(this);
}
public GraphElementSearcherDatabase AddControlFlows()
{
AddIfCondition(IfConditionMode.Basic);
AddIfCondition(IfConditionMode.Advanced);
AddIfCondition(IfConditionMode.Complete);
SearcherItem parent = null;
var loopTypes = TypeCache.GetTypesDerivedFrom <LoopStackModel>();
foreach (var loopType in loopTypes.Where(t => !t.IsAbstract))
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, k_ControlFlow);
}
var name = $"{VseUtility.GetTitle(loopType)}{k_LoopStack}";
parent.AddChild(new StackNodeModelSearcherItem(
new ControlFlowSearcherItemData(loopType),
data =>
{
var stackModel = (StackBaseModel)data.StackModel;
var elements = new List <IGraphElementModel>();
var graphModel = (VSGraphModel)stackModel.GraphModel;
var stackPosition = new Vector2(
stackModel.Position.x + k_StackOffset.x,
stackModel.Position.y + k_StackOffset.y
);
LoopStackModel loopStack = graphModel.CreateLoopStack(
loopType,
stackPosition,
data.SpawnFlags
);
var node = loopStack.CreateLoopNode(
stackModel,
data.Index,
data.SpawnFlags);
elements.Add(node);
elements.Add(loopStack);
var edge = data.SpawnFlags.IsOrphan()
? graphModel.CreateOrphanEdge(loopStack.InputPort, node.OutputPort)
: graphModel.CreateEdge(loopStack.InputPort, node.OutputPort);
elements.Add(edge);
return(elements.ToArray());
},
name
));
}
return(this);
}
public ScriptView(ScriptsConfiguration config, Action drawHackGuiAction, Action saveAssetAction)
{
ScriptModified = false;
this.config = config;
this.saveAssetAction = saveAssetAction;
editorResources = EditorResources.LoadOrDefault();
ViewRange = new IntRange(0, config.EditorPageLength - 1);
styleSheets.Add(StyleSheet);
if (EditorGUIUtility.isProSkin)
{
styleSheets.Add(DarkStyleSheet);
}
CustomStyleSheet = config.EditorCustomStyleSheet;
if (CustomStyleSheet)
{
styleSheets.Add(CustomStyleSheet);
}
var commentItem = new SearcherItem("Comment");
var labelItem = new SearcherItem("Label");
var genericTextItem = new SearcherItem("Generic Text", config.InsertLineKey != KeyCode.None
? $"{(config.InsertLineModifier != EventModifiers.None ? $"{config.InsertLineModifier}+" : string.Empty)}{config.InsertLineKey}"
: null);
var commandsItem = new SearcherItem("Commands");
foreach (var commandId in Command.CommandTypes.Keys.OrderBy(k => k))
{
commandsItem.AddChild(new SearcherItem(char.ToLowerInvariant(commandId[0]) + commandId.Substring(1)));
}
searchItems = new List <SearcherItem> {
commandsItem, genericTextItem, labelItem, commentItem
};
Add(new IMGUIContainer(drawHackGuiAction));
Add(new IMGUIContainer(() => HandleKeyDownEvent(null)));
linesContainer = new VisualElement();
Add(linesContainer);
paginationView = new PaginationView(SelectNextPage, SelectPreviousPage);
paginationView.style.display = DisplayStyle.None;
Add(paginationView);
infoLabel = new Label("Loading, please wait...");
infoLabel.name = "InfoLabel";
ColorUtility.TryParseHtmlString(EditorGUIUtility.isProSkin ? "#cccccc" : "#555555", out var color);
infoLabel.style.color = color;
Add(infoLabel);
RegisterCallback <KeyDownEvent>(HandleKeyDownEvent, TrickleDown.TrickleDown);
RegisterCallback <MouseDownEvent>(HandleMouseDownEvent, TrickleDown.TrickleDown);
new ContextualMenuManipulator(ContextMenu).target = this;
}
public static void AddToSearcherDatabase(IGraphModel graphModel, GraphElementSearcherDatabase db)
{
SearcherItem parent = db.Items.GetItemFromPath("Fake");
parent.AddChild(new GraphNodeModelSearcherItem(graphModel,
new NodeSearcherItemData(typeof(Type3FakeNodeModel)),
data => data.CreateNode <Type3FakeNodeModel>(),
nameof(Type3FakeNodeModel)
));
}
public void TestFind_NotNull()
{
var parent = new SearcherItem("parent");
parent.AddChild(new SearcherItem("child"));
var child = parent.Find("child");
Assert.NotNull(child);
Assert.AreEqual(child.Name, "child");
}
bool AddStep(SearcherItem item)
{
if (item is TypeSearcherItem typeItem)
{
m_BuildSteps.Add(BuildPipeline.CreateStepFromType(typeItem.Type));
MarkDirty();
return(true);
}
return(false);
}
public GraphElementSearcherDatabase AddGraphsMethods()
{
string[] assetGUIDs = AssetDatabase.FindAssets($"t:{typeof(VSGraphAssetModel).Name}");
List <Tuple <IGraphModel, FunctionModel> > methods = assetGUIDs.SelectMany(assetGuid =>
{
string assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
VSGraphAssetModel graphAssetModel = AssetDatabase.LoadAssetAtPath <VSGraphAssetModel>(assetPath);
if (!graphAssetModel || graphAssetModel.GraphModel == null)
{
return(Enumerable.Empty <Tuple <IGraphModel, FunctionModel> >());
}
var functionModels = graphAssetModel.GraphModel.NodeModels.OfExactType <FunctionModel>()
.Select(fm => new Tuple <IGraphModel, FunctionModel>(fm.GraphModel, fm));
return(functionModels.Concat(graphAssetModel.GraphModel.NodeModels.OfExactType <EventFunctionModel>()
.Select(fm => new Tuple <IGraphModel, FunctionModel>(fm.GraphModel, fm))));
}).ToList();
if (methods.Count == 0)
{
return(this);
}
TypeHandle voidTypeHandle = typeof(void).GenerateTypeHandle(Stencil);
foreach (Tuple <IGraphModel, FunctionModel> method in methods)
{
IGraphModel graphModel = method.Item1;
FunctionModel functionModel = method.Item2;
string graphName = graphModel.AssetModel.Name;
SearcherItem graphRoot = SearcherItemUtility.GetItemFromPath(Items, $"{k_Graphs}/{graphName}");
if (functionModel.ReturnType == voidTypeHandle)
{
graphRoot.AddChild(new StackNodeModelSearcherItem(
new FunctionRefSearcherItemData(graphModel, functionModel),
data => data.CreateFunctionRefCallNode(functionModel),
() => $"{k_Function} {functionModel.Title}"
));
continue;
}
graphRoot.AddChild(new GraphNodeModelSearcherItem(
new FunctionRefSearcherItemData(graphModel, functionModel),
data => data.CreateFunctionRefCallNode(functionModel),
() => $"{k_Function} {functionModel.Title}"
));
}
return(this);
}
public static void AddAtPath(this List <SearcherItem> items, SearcherItem item, string path = "")
{
if (!string.IsNullOrEmpty(path))
{
SearcherItem parent = SearcherItemUtility.GetItemFromPath(items, path);
parent.AddChild(item);
}
else
{
items.Add(item);
}
}
public GraphElementSearcherDatabase AddConstants(Type type)
{
TypeHandle handle = type.GenerateTypeHandle(Stencil);
SearcherItem parent = SearcherItemUtility.GetItemFromPath(Items, k_Constant);
parent.AddChild(new GraphNodeModelSearcherItem(
new TypeSearcherItemData(handle, SearcherItemTarget.Constant),
data => data.CreateConstantNode("", handle),
$"{type.FriendlyName().Nicify()} {k_Constant}"
));
return(this);
}
public GraphElementSearcherDatabase AddExtensionMethods(Type type)
{
Dictionary <Type, List <MethodInfo> > extensions = TypeSystem.GetExtensionMethods(Stencil.GetAssemblies());
if (!extensions.TryGetValue(type, out var methodInfos))
{
return(this);
}
SearcherItem parent = null;
foreach (MethodInfo methodInfo in methodInfos
.Where(m => !m.GetParameters().Any(p => p.ParameterType.IsByRef || p.IsOut)))
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, type.FriendlyName(false));
}
MethodDetails details = methodInfo.GetMethodDetails();
if (methodInfo.ReturnType != typeof(void))
{
parent.AddChild(new GraphNodeModelSearcherItem(
new MethodSearcherItemData(methodInfo),
data => ((VSGraphModel)data.GraphModel).CreateFunctionCallNode(
methodInfo,
data.Position,
data.SpawnFlags
),
details.MethodName,
details.Details
));
continue;
}
parent.AddChild(new StackNodeModelSearcherItem(
new MethodSearcherItemData(methodInfo),
data => ((StackBaseModel)data.StackModel).CreateFunctionCallNode(
methodInfo,
data.Index,
data.SpawnFlags
),
details.MethodName,
details.Details
));
}
return(this);
}
public GraphElementSearcherDatabase AddFields(Type type, BindingFlags bindingFlags)
{
SearcherItem parent = null;
foreach (FieldInfo fieldInfo in type.GetFields(bindingFlags)
.OrderBy(f => f.Name)
.Where(f => f.GetCustomAttribute <ObsoleteAttribute>() == null &&
f.GetCustomAttribute <HiddenAttribute>() == null))
{
if (parent == null)
{
parent = SearcherItemUtility.GetItemFromPath(Items, type.FriendlyName(false));
}
parent.AddChild(new GraphNodeModelSearcherItem(
new FieldSearcherItemData(fieldInfo),
data =>
{
INodeModel nodeModel = ((VSGraphModel)data.GraphModel).CreateGetPropertyGroupNode(
data.Position,
data.SpawnFlags
);
((GetPropertyGroupNodeModel)nodeModel).AddMember(fieldInfo.GetUnderlyingType(), fieldInfo.Name);
return(nodeModel);
},
fieldInfo.Name
));
if (fieldInfo.CanWrite())
{
parent.AddChild(new StackNodeModelSearcherItem(
new FieldSearcherItemData(fieldInfo),
data =>
{
INodeModel nodeModel = ((StackBaseModel)data.StackModel).CreateSetPropertyGroupNode(
data.Index
);
((SetPropertyGroupNodeModel)nodeModel).AddMember(
fieldInfo.GetUnderlyingType(),
fieldInfo.Name
);
return(nodeModel);
},
fieldInfo.Name
));
}
}
return(this);
}
private int ComputeScoreForMatch(string[] queryTerms, SearcherItem matchItem)
{
// Scoring Criteria:
// - Exact name match is most preferred.
// - Partial name match is next.
// - Exact synonym match is next.
// - Partial synonym match is next.
// - No match is last.
int score = 0;
// Split the entry name so that we can remove suffix that looks like "Clamp: In(4)"
var nameSansSuffix = matchItem.Name.Split(':').First();
int nameCharactersMatched = 0;
foreach (var queryWord in queryTerms)
{
if (nameSansSuffix.Contains(queryWord, StringComparison.OrdinalIgnoreCase))
{
score += 100000;
nameCharactersMatched += queryWord.Length;
}
// Check for synonym matches -- give a bonus to each
if (matchItem.Synonyms != null)
{
foreach (var syn in matchItem.Synonyms)
{
if (syn.Equals(queryWord, StringComparison.OrdinalIgnoreCase))
{
score += 10000;
}
else if (syn.Contains(queryWord, StringComparison.OrdinalIgnoreCase))
{
score += 1000;
score -= (syn.Length - queryWord.Length);
}
}
}
}
if (nameCharactersMatched > 0)
{
int unmatchedCharacters = (nameSansSuffix.Length - nameCharactersMatched);
score -= unmatchedCharacters;
}
return(score);
}
public void EditModel(bool isToggled, SearcherItem boundSearchItem)
{
var propertySearcherItem = (PropertySearcherItem)boundSearchItem;
var action = isToggled
? EditPropertyGroupNodeAction.EditType.Add
: EditPropertyGroupNodeAction.EditType.Remove;
propertySearcherItem.Enabled = isToggled;
var memberReference = new TypeMember(propertySearcherItem.MemberInfo.UnderlyingType,
BuildMemberPath(propertySearcherItem));
m_Store.Dispatch(new EditPropertyGroupNodeAction(action, m_PropertyGroupModel, memberReference));
}
public GraphElementSearcherDatabase AddBinaryOperators()
{
SearcherItem parent = SearcherItemUtility.GetItemFromPath(Items, k_Operator);
foreach (BinaryOperatorKind kind in Enum.GetValues(typeof(BinaryOperatorKind)))
{
parent.AddChild(new GraphNodeModelSearcherItem(
new BinaryOperatorSearcherItemData(kind),
data => data.CreateBinaryOperatorNode(kind),
kind.ToString()
));
}
return(this);
}
public static bool TryAddEnumItem(
this List <SearcherItem> items,
SearcherItem itemToAdd,
ITypeMetadata meta,
string parentName = ""
)
{
if (meta.IsEnum)
{
items.AddAtPath(itemToAdd, parentName + "/" + k_Enums);
return(true);
}
return(false);
}
