private VisualizationNodeData AddNodeCacheForNode(string id, string type)
{
string key = NodeDependencyLookupUtility.GetNodeKey(id, type);
if (!_cachedVisualizationNodeDatas.ContainsKey(key))
{
INodeHandler nodeHandler = GetNodeHandlerForType(type);
ITypeHandler typeHandler = GetTypeHandlerForType(type);
VisualizationNodeData data = typeHandler.CreateNodeCachedData(id);
_nodeDependencyLookupContext.NodeHandlerLookup = GetNodeHandlerLookup();
if (_showThumbnails || DisplayData.ShowAdditionalInformation)
{
data.OwnSize = NodeDependencyLookupUtility.GetNodeSize(true, false, id, type, new HashSet <string>(), _nodeDependencyLookupContext, _cachedSizes);
data.HierarchySize = NodeDependencyLookupUtility.GetNodeSize(true, true, id, type, new HashSet <string>(), _nodeDependencyLookupContext, _cachedSizes);
}
data.Id = id;
data.Type = type;
data.NodeHandler = nodeHandler;
data.TypeHandler = typeHandler;
data.Name = typeHandler.GetName(id);
data.IsEditorAsset = nodeHandler.IsNodeEditorOnly(id, type);
data.IsPackedToApp = NodeDependencyLookupUtility.IsNodePackedToApp(id, type, _nodeDependencyLookupContext, new HashSet <string>());
_cachedVisualizationNodeDatas.Add(key, data);
}
return(_cachedVisualizationNodeDatas[key]);
}
public Pathfinder(INodeHandler nodeHandler)
{
this.nodeHandler = nodeHandler;
this.g = new Dictionary <INode, double>();
this.f = new Dictionary <INode, double>();
this.cameFrom = new Dictionary <INode, INode>();
this.open = new PriorityQueue <INode>();
}
public WorkFlowNodeRequire Load(INodeHandler handler)
{
this.Handler = handler;
this.Key = this.Handler.GetType().GetCustomAttribute <KeyAttribute>()?.KeyValue;
this.RequrieName = this.Handler.GetType().GetCustomAttribute <NodeRequireAttribute>()?.Names;
if (string.IsNullOrEmpty(Key) || this.RequrieName == null || !this.RequrieName.Any())
{
return(null);
}
return(this);
}
private void CreateNodeHandlers()
{
_nodeHandlerStates.Clear();
List <Type> types = NodeDependencyLookupUtility.GetTypesForBaseType(typeof(INodeHandler));
foreach (Type type in types)
{
INodeHandler nodeHandler = NodeDependencyLookupUtility.InstantiateClass <INodeHandler>(type);
_nodeHandlerStates.Add(new NodeHandlerState(nodeHandler));
}
}
public static int GetNodeSize(bool own, bool tree, string id, string type, HashSet <string> traversedNodes,
NodeDependencyLookupContext stateContext, Dictionary <string, int> ownSizeCache = null)
{
if (ownSizeCache == null)
{
ownSizeCache = new Dictionary <string, int>();
}
string key = GetNodeKey(id, type);
if (traversedNodes.Contains(key) || !stateContext.NodeHandlerLookup.ContainsKey(type))
{
return(0);
}
traversedNodes.Add(key);
int size = 0;
INodeHandler nodeHandler = stateContext.NodeHandlerLookup[type];
if (own && (!tree || nodeHandler.ContributesToTreeSize()))
{
if (!ownSizeCache.ContainsKey(key))
{
ownSizeCache[key] = nodeHandler.GetOwnFileSize(id, type, stateContext);
}
size += ownSizeCache[key];
}
if (tree)
{
Node node = stateContext.RelationsLookup.GetNode(id, type);
if (node != null)
{
foreach (Connection connection in node.GetRelations(RelationType.DEPENDENCY))
{
if (stateContext.ConnectionTypeLookup.GetDependencyType(connection.Type).IsHard)
{
Node childNode = connection.Node;
size += GetNodeSize(true, true, childNode.Id, childNode.Type, traversedNodes, stateContext, ownSizeCache);
}
}
}
}
return(size);
}
public void SetHandler(string nodeType, INodeHandler nodeHandler)
{
if (nodeHandlers == null)
{
nodeHandlers = new Dictionary <string, INodeHandler>();
}
if (nodeHandlers.ContainsKey(nodeType))
{
nodeHandlers[nodeType] = nodeHandler;
}
else
{
nodeHandlers.Add(nodeType, nodeHandler);
}
}
/// <summary>
/// Right now this only works if the asset or one of its parents (referencers) are in a packaged scene or in a resources folder.
/// If the asset is just in a bundle this is currently not tracked. Trying to find a solution for this.
/// </summary>
public static bool IsNodePackedToApp(string id, string type, NodeDependencyLookupContext stateContext,
HashSet <string> visitedKeys)
{
if (visitedKeys.Contains(id))
{
return(false);
}
visitedKeys.Add(id);
Node node = stateContext.RelationsLookup.GetNode(id, type);
if (node == null)
{
return(false);
}
foreach (KeyValuePair <string, INodeHandler> pair in stateContext.NodeHandlerLookup)
{
INodeHandler nodeHandler = pair.Value;
if (nodeHandler.GetHandledNodeTypes().Contains(type) && nodeHandler.IsNodePackedToApp(id, type))
{
return(true);
}
}
foreach (Connection connection in node.Referencers)
{
Node refNode = connection.Node;
if (!stateContext.ConnectionTypeLookup.GetDependencyType(connection.Type).IsIndirect&&
IsNodePackedToApp(refNode.Id, refNode.Type, stateContext, visitedKeys))
{
return(true);
}
}
return(false);
}
public RegexReplaceHandler(INodeHandler NodeHandler)
{
this.nodeHandler = NodeHandler;
}
public ProcessNode(INodeHandler nodeHandler)
{
NodeHandler = nodeHandler;
}
private void tvProjects_AfterSelect(object sender, TreeViewEventArgs e)
{
INodeHandler handler = e.Node.Tag as INodeHandler;
if (handler != null)
{
if (handler.IsFirstClick)
{
handler.OnFirstClick();
}
else
{
handler.OnClick();
}
}
splitContainer1.Panel2.Controls.Clear();
IDeleteable del = handler as IDeleteable;
tsbtnDelete.Enabled = false;
if (del != null)
{
tsbtnDelete.Enabled = true;
tsbtnDelete.ToolTipText = del.TitleOfDelete;
menuProject.Items.Add(del.TitleOfDelete, actImgs.Images["delete"], cmDelete_Click);
}
IAddable add = handler as IAddable;
tsbtnAdd.Enabled = false;
if (add != null)
{
tsbtnAdd.Enabled = true;
tsbtnAdd.ToolTipText = add.TitleOfAdd;
menuProject.Items.Add(add.TitleOfAdd, actImgs.Images["add"], cmAdd_Click);
}
IReloadable reload = handler as IReloadable;
tsbtnReload.Enabled = false;
if (reload != null)
{
tsbtnReload.Enabled = true;
}
ITestable test = handler as ITestable;
tsbtnTest.Enabled = false;
if (test != null)
{
tsbtnTest.Image = actImgs.Images[test.TestImageKey];
tsbtnTest.Enabled = true;
}
IRenameable rename = handler as IRenameable;
tsbtnRename.Enabled = false;
if (rename != null)
{
tsbtnRename.Enabled = true;
}
IExportable export = handler as IExportable;
tsbtnExport.Enabled = false;
if (export != null)
{
tsbtnExport.Enabled = true;
}
ISetupable setup = handler as ISetupable;
cmSetup.Enabled = false;
if (setup != null)
{
cmSetup.Enabled = true;
}
IDeployable deploy = handler as IDeployable;
cmDeploy.Enabled = false;
if (deploy != null)
{
cmDeploy.Enabled = true;
}
IDeployToPhysical phyDeploy = handler as IDeployToPhysical;
tsbtnDeployToPhysical.Enabled = false;
if (phyDeploy != null)
{
tsbtnDeployToPhysical.Enabled = true;
}
IImportFromPhysical phyImport = handler as IImportFromPhysical;
tsbtnImportFromPhysical.Enabled = false;
if (phyImport != null)
{
tsbtnImportFromPhysical.Enabled = true;
}
IImportable import = handler as IImportable;
tsbtnImport.Enabled = false;
if (import != null)
{
tsbtnImport.Enabled = true;
}
IJoinProject joinProject = handler as IJoinProject;
tsbtnJoinProject.Enabled = false;
if (joinProject != null)
{
tsbtnJoinProject.Enabled = true;
}
ILeaveProject leaveProject = handler as ILeaveProject;
tsbtnLeaveProject.Enabled = false;
if (leaveProject != null)
{
tsbtnLeaveProject.Enabled = true;
}
ISyncUpload syncUplaod = handler as ISyncUpload;
cmUpload.Enabled = false;
if (syncUplaod != null)
{
cmUpload.Enabled = true;
}
ISyncUpload syncDownload = handler as ISyncUpload;
cmDownload.Enabled = false;
if (syncDownload != null)
{
cmDownload.Enabled = true;
}
tsEditMode.Items.Clear();
rsbtnSave.Enabled = false;
IEditorManager manager = handler as IEditorManager;
if (manager != null)
{
rsbtnSave.Enabled = false;
foreach (IEditable editable in manager.Editors)
{
ToolStripItem item = tsEditMode.Items.Add(editable.ModeTitle, actImgs.Images[editable.ImageKey], cmEdit_Click);
item.ToolTipText = editable.ModeTitle;
item.Text = string.Empty;
item.Tag = editable;
}
}
}
public NodeDragService(INodeHandler nodeHandler, IJSRuntime jsRuntime)
{
this.nodeHandler = nodeHandler;
this.jsRuntime = jsRuntime;
jsRuntime.InvokeVoidAsync("addDotNetSingletonService", "DotNetNodeDragService", DotNetObjectReference.Create(this));
}
public NodeDragService(INodeHandler nodeHandler, IJSRuntime jsRuntime)
{
this.nodeHandler = nodeHandler;
this.jsRuntime = jsRuntime;
//jsRuntime.InvokeAsync<object>("initNodeDropHandler", DotNetObjectRef.Create(this));
}
public NodeDragService(INodeHandler nodeHandler, IJSRuntime jsRuntime)
{
this.nodeHandler = nodeHandler;
this.jsRuntime = jsRuntime;
}
public NodeHandlerState(INodeHandler nodeHandler)
{
NodeHandler = nodeHandler;
}
