public CustomNodeWorkspaceModel( WorkspaceInfo info, NodeFactory factory) : this( factory, Enumerable.Empty<NodeModel>(), Enumerable.Empty<NoteModel>(), Enumerable.Empty<AnnotationModel>(), info) { }
public CustomNodeWorkspaceModel( WorkspaceInfo info, NodeFactory factory) : this( factory, Enumerable.Empty<NodeModel>(), Enumerable.Empty<NoteModel>(), Enumerable.Empty<AnnotationModel>(), Enumerable.Empty<PresetModel>(), new ElementResolver(), info) { }
public CustomNodeWorkspaceModel( NodeFactory factory, IEnumerable<NodeModel> e, IEnumerable<NoteModel> n, IEnumerable<AnnotationModel> a, IEnumerable<PresetModel> presets, ElementResolver elementResolver, WorkspaceInfo info) : base(e, n,a, info, factory,presets, elementResolver) { HasUnsavedChanges = false; CustomNodeId = Guid.Parse(info.ID); Category = info.Category; Description = info.Description; PropertyChanged += OnPropertyChanged; }
public CustomNodeWorkspaceModel( NodeFactory factory, IEnumerable<NodeModel> nodes, IEnumerable<NoteModel> notes, IEnumerable<AnnotationModel> annotations, IEnumerable<PresetModel> presets, ElementResolver elementResolver, WorkspaceInfo info) : base(nodes, notes,annotations, info, factory,presets, elementResolver) { HasUnsavedChanges = false; CustomNodeId = Guid.Parse(info.ID); Category = info.Category; Description = info.Description; IsVisibleInDynamoLibrary = info.IsVisibleInDynamoLibrary; PropertyChanged += OnPropertyChanged; }
public CustomNodeWorkspaceModel( NodeFactory factory, IEnumerable<NodeModel> e, IEnumerable<NoteModel> n, IEnumerable<AnnotationModel> a, WorkspaceInfo info, ElementResolver elementResolver = null) : base(e, n,a,info, factory) { HasUnsavedChanges = false; CustomNodeId = Guid.Parse(info.ID); Category = info.Category; Description = info.Description; if (elementResolver != null) { ElementResolver.CopyResolutionMap(elementResolver); } PropertyChanged += OnPropertyChanged; }
/// <summary> /// Creates a new Custom Node in the manager. /// </summary> /// <param name="name">Name of the custom node.</param> /// <param name="category">Category for the custom node.</param> /// <param name="description">Description of the custom node.</param> /// <param name="functionId"> /// Optional identifier to be used for the custom node. By default, will make a new unique one. /// </param> /// <returns>Newly created Custom Node Workspace.</returns> public WorkspaceModel CreateCustomNode(string name, string category, string description, Guid? functionId = null) { var newId = functionId ?? Guid.NewGuid(); var info = new WorkspaceInfo() { Name = name, Category = category, Description = description, X = 0, Y = 0, ID = newId.ToString(), FileName = string.Empty }; var workspace = new CustomNodeWorkspaceModel(info, nodeFactory); RegisterCustomNodeWorkspace(workspace); return workspace; }
private bool InitializeCustomNode( WorkspaceInfo workspaceInfo, XmlDocument xmlDoc, out CustomNodeWorkspaceModel workspace) { // Add custom node definition firstly so that a recursive // custom node won't recursively load itself. SetPreloadFunctionDefinition(Guid.Parse(workspaceInfo.ID)); var nodeGraph = NodeGraph.LoadGraphFromXml(xmlDoc, nodeFactory); var newWorkspace = new CustomNodeWorkspaceModel( nodeFactory, nodeGraph.Nodes, nodeGraph.Notes, nodeGraph.Annotations, nodeGraph.Presets, workspaceInfo); RegisterCustomNodeWorkspace(newWorkspace); workspace = newWorkspace; return true; }
/// <summary> /// Opens a Custom Node workspace from an XmlDocument, given a pre-constructed WorkspaceInfo. /// </summary> /// <param name="xmlDoc">XmlDocument representing the parsed custom node file.</param> /// <param name="workspaceInfo">Workspace header describing the custom node file.</param> /// <param name="isTestMode"> /// Flag specifying whether or not this should operate in "test mode". /// </param> /// <param name="workspace"></param> /// <returns></returns> public bool OpenCustomNodeWorkspace( XmlDocument xmlDoc, WorkspaceInfo workspaceInfo, bool isTestMode, out WorkspaceModel workspace) { CustomNodeWorkspaceModel customNodeWorkspace; if (InitializeCustomNode( workspaceInfo, xmlDoc, out customNodeWorkspace)) { workspace = customNodeWorkspace; return true; } workspace = null; return false; }
private bool OpenHomeWorkspace( XmlDocument xmlDoc, WorkspaceInfo workspaceInfo, out WorkspaceModel workspace) { var nodeGraph = NodeGraph.LoadGraphFromXml(xmlDoc, NodeFactory); var newWorkspace = new HomeWorkspaceModel( EngineController, Scheduler, NodeFactory, Utils.LoadTraceDataFromXmlDocument(xmlDoc), nodeGraph.Nodes, nodeGraph.Notes, nodeGraph.Annotations, nodeGraph.Presets, nodeGraph.ElementResolver, workspaceInfo, DebugSettings.VerboseLogging, IsTestMode ); RegisterHomeWorkspace(newWorkspace); workspace = newWorkspace; return true; }
private bool OpenFile(WorkspaceInfo workspaceInfo, XmlDocument xmlDoc, out WorkspaceModel workspace) { CustomNodeManager.AddUninitializedCustomNodesInPath( Path.GetDirectoryName(workspaceInfo.FileName), IsTestMode); var result = workspaceInfo.IsCustomNodeWorkspace ? CustomNodeManager.OpenCustomNodeWorkspace(xmlDoc, workspaceInfo, IsTestMode, out workspace) : OpenHomeWorkspace(xmlDoc, workspaceInfo, out workspace); workspace.OnCurrentOffsetChanged( this, new PointEventArgs(new Point2D(workspaceInfo.X, workspaceInfo.Y))); return result; }
protected WorkspaceModel( IEnumerable<NodeModel> e, IEnumerable<NoteModel> n, IEnumerable<AnnotationModel> a, WorkspaceInfo info, NodeFactory factory, IEnumerable<PresetModel> presets) { guid = Guid.NewGuid(); nodes = new ObservableCollection<NodeModel>(e); notes = new ObservableCollection<NoteModel>(n); annotations = new ObservableCollection<AnnotationModel>(a); // Set workspace info from WorkspaceInfo object Name = info.Name; X = info.X; Y = info.Y; FileName = info.FileName; Zoom = info.Zoom; HasUnsavedChanges = false; LastSaved = DateTime.Now; WorkspaceVersion = AssemblyHelper.GetDynamoVersion(); undoRecorder = new UndoRedoRecorder(this); NodeFactory = factory; this.presets = new List<PresetModel>(presets); // Update ElementResolver from nodeGraph.Nodes (where node is CBN) ElementResolver = new ElementResolver(); foreach (var node in nodes) { RegisterNode(node); var cbn = node as CodeBlockNodeModel; if (cbn != null && cbn.ElementResolver != null) { ElementResolver.CopyResolutionMap(cbn.ElementResolver); } } foreach (var connector in Connectors) RegisterConnector(connector); SetModelEventOnAnnotation(); }
/// <summary> /// Attempts to migrate a workspace to the current version of Dynamo. /// </summary> /// <param name="workspaceInfo"></param> /// <param name="xmlDoc"></param> /// <returns></returns> public bool ProcessWorkspace(WorkspaceInfo workspaceInfo, XmlDocument xmlDoc, bool isTestMode, NodeFactory factory) { Version fileVersion = VersionFromString(workspaceInfo.Version); var currentVersion = AssemblyHelper.GetDynamoVersion(includeRevisionNumber: false); if (fileVersion > currentVersion) { bool resume = displayFutureFileMessage( workspaceInfo.FileName, fileVersion, currentVersion); if (!resume) return false; } var decision = ProcessWorkspace( xmlDoc, fileVersion, currentVersion, workspaceInfo.FileName, isTestMode, factory); if (decision != Decision.Abort) return true; displayObsoleteFileMessage(workspaceInfo.FileName, fileVersion, currentVersion); return false; }
protected WorkspaceModel( IEnumerable<NodeModel> e, IEnumerable<NoteModel> n, IEnumerable<AnnotationModel> a, WorkspaceInfo info, NodeFactory factory, IEnumerable<PresetModel> presets, ElementResolver resolver) { guid = Guid.NewGuid(); nodes = new ObservableCollection<NodeModel>(e); notes = new ObservableCollection<NoteModel>(n); annotations = new ObservableCollection<AnnotationModel>(a); // Set workspace info from WorkspaceInfo object Name = info.Name; Description = info.Description; X = info.X; Y = info.Y; FileName = info.FileName; Zoom = info.Zoom; HasUnsavedChanges = false; LastSaved = DateTime.Now; WorkspaceVersion = AssemblyHelper.GetDynamoVersion(); undoRecorder = new UndoRedoRecorder(this); NodeFactory = factory; this.presets = new List<PresetModel>(presets); ElementResolver = resolver; foreach (var node in nodes) RegisterNode(node); foreach (var connector in Connectors) RegisterConnector(connector); SetModelEventOnAnnotation(); }
public HomeWorkspaceModel( EngineController engine, DynamoScheduler scheduler, NodeFactory factory, IEnumerable<KeyValuePair<Guid, List<string>>> traceData, IEnumerable<NodeModel> e, IEnumerable<NoteModel> n, IEnumerable<AnnotationModel> a, IEnumerable<PresetModel> presets, ElementResolver resolver, WorkspaceInfo info, bool verboseLogging, bool isTestMode) : base(e, n,a, info, factory,presets, resolver) { EvaluationCount = 0; // This protects the user from a file that might have crashed during // its last run. As a side effect, this also causes all files set to // run auto but lacking the HasRunWithoutCrash flag to run manually. if (info.RunType == RunType.Automatic && !info.HasRunWithoutCrash) { info.RunType = RunType.Manual; } RunSettings = new RunSettings(info.RunType, info.RunPeriod); PreloadedTraceData = traceData; this.scheduler = scheduler; this.verboseLogging = verboseLogging; IsTestMode = isTestMode; EngineController = engine; // The first time the preloaded trace data is set, we cache // the data as historical. This will be used after the initial // run of this workspace, when the PreloadedTraceData has been // nulled, to check for node deletions and reconcile the trace data. // We do a deep copy of this data because the PreloadedTraceData is // later set to null before the graph update. var copiedData = new List<KeyValuePair<Guid, List<string>>>(); foreach (var kvp in PreloadedTraceData) { var strings = kvp.Value.Select(string.Copy).ToList(); copiedData.Add(new KeyValuePair<Guid, List<string>>(kvp.Key, strings)); } historicalTraceData = copiedData; }
public static bool FromXmlDocument( XmlDocument xmlDoc, string path, bool isTestMode, ILogger logger, out WorkspaceInfo workspaceInfo) { try { string funName = null; double cx = 0; double cy = 0; double zoom = 1.0; string id = ""; string category = ""; string description = ""; string version = ""; var runType = RunType.Manual; int runPeriod = RunSettings.DefaultRunPeriod; bool hasRunWithoutCrash = false; var topNode = xmlDoc.GetElementsByTagName("Workspace"); // legacy support if (topNode.Count == 0) { topNode = xmlDoc.GetElementsByTagName("dynWorkspace"); } // load the header foreach (XmlNode node in topNode) { foreach (XmlAttribute att in node.Attributes) { if (att.Name.Equals("X")) { cx = double.Parse(att.Value, CultureInfo.InvariantCulture); } else if (att.Name.Equals("Y")) { cy = double.Parse(att.Value, CultureInfo.InvariantCulture); } else if (att.Name.Equals("zoom")) { zoom = double.Parse(att.Value, CultureInfo.InvariantCulture); } else if (att.Name.Equals("Name")) { funName = att.Value; } else if (att.Name.Equals("ID")) { id = att.Value; } else if (att.Name.Equals("Category")) { category = att.Value; } else if (att.Name.Equals("Description")) { description = att.Value; } else if (att.Name.Equals("HasRunWithoutCrash")) { hasRunWithoutCrash = bool.Parse(att.Value); } else if (att.Name.Equals("Version")) { version = att.Value; } else if (att.Name.Equals("RunType")) { if (!Enum.TryParse(att.Value, false, out runType)) { runType = RunType.Manual; } } else if (att.Name.Equals("RunPeriod")) { runPeriod = Int32.Parse(att.Value); } } } // we have a dyf and it lacks an ID field, we need to assign it // a deterministic guid based on its name. By doing it deterministically, // files remain compatible if (string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(funName) && funName != "Home") { id = GuidUtility.Create(GuidUtility.UrlNamespace, funName).ToString(); } workspaceInfo = new WorkspaceInfo { ID = id, Name = funName, X = cx, Y = cy, Zoom = zoom, FileName = path, Category = category, Description = description, Version = version, RunType = runType, RunPeriod = runPeriod, HasRunWithoutCrash = hasRunWithoutCrash }; return(true); } catch (Exception ex) { logger.Log(Properties.Resources.OpenWorkbenchError); logger.Log(ex); Debug.WriteLine(ex.Message + ":" + ex.StackTrace); //TODO(Steve): Need a better way to handle this kind of thing. -- MAGN-5712 if (isTestMode) { throw; // Rethrow for NUnit. } workspaceInfo = null; return(false); } }
public static bool FromXmlDocument( XmlDocument xmlDoc, string path, bool isTestMode, bool forceManualExecutionMode, ILogger logger, out WorkspaceInfo workspaceInfo) { try { string funName = null; double cx = 0; double cy = 0; double zoom = 1.0; string id = ""; string category = ""; string description = ""; string version = ""; var runType = RunType.Manual; int runPeriod = RunSettings.DefaultRunPeriod; bool hasRunWithoutCrash = false; var topNode = xmlDoc.GetElementsByTagName("Workspace"); // legacy support if (topNode.Count == 0) { topNode = xmlDoc.GetElementsByTagName("dynWorkspace"); } // load the header foreach (XmlNode node in topNode) { foreach (XmlAttribute att in node.Attributes) { if (att.Name.Equals("X")) cx = double.Parse(att.Value, CultureInfo.InvariantCulture); else if (att.Name.Equals("Y")) cy = double.Parse(att.Value, CultureInfo.InvariantCulture); else if (att.Name.Equals("zoom")) zoom = double.Parse(att.Value, CultureInfo.InvariantCulture); else if (att.Name.Equals("Name")) funName = att.Value; else if (att.Name.Equals("ID")) id = att.Value; else if (att.Name.Equals("Category")) category = att.Value; else if (att.Name.Equals("Description")) description = att.Value; else if (att.Name.Equals("HasRunWithoutCrash")) hasRunWithoutCrash = bool.Parse(att.Value); else if (att.Name.Equals("Version")) version = att.Value; else if (att.Name.Equals("RunType")) { if (forceManualExecutionMode || !Enum.TryParse(att.Value, false, out runType)) { runType = RunType.Manual; } } else if (att.Name.Equals("RunPeriod")) runPeriod = Int32.Parse(att.Value); } } // we have a dyf and it lacks an ID field, we need to assign it // a deterministic guid based on its name. By doing it deterministically, // files remain compatible if (string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(funName) && funName != "Home") { id = GuidUtility.Create(GuidUtility.UrlNamespace, funName).ToString(); } workspaceInfo = new WorkspaceInfo { ID = id, Name = funName, X = cx, Y = cy, Zoom = zoom, FileName = path, Category = category, Description = description, Version = version, RunType = runType, RunPeriod = runPeriod, HasRunWithoutCrash = hasRunWithoutCrash }; return true; } catch (Exception ex) { logger.Log(Properties.Resources.OpenWorkbenchError); logger.Log(ex); Debug.WriteLine(ex.Message + ":" + ex.StackTrace); //TODO(Steve): Need a better way to handle this kind of thing. -- MAGN-5712 if (isTestMode) throw; // Rethrow for NUnit. workspaceInfo = null; return false; } }