private IEnumerable<Tuple<string, string>> GetAllNodeNameDescriptionPairs()
{
var pmExtension = dynamoViewModel.Model.GetPackageManagerExtension();
var pkgLoader = pmExtension.PackageLoader;
var workspaces = new List<CustomNodeWorkspaceModel>();
foreach (var def in AllFuncDefs())
{
CustomNodeWorkspaceModel ws;
if (dynamoViewModel.Model.CustomNodeManager.TryGetFunctionWorkspace(
def.FunctionId,
DynamoModel.IsTestMode,
out ws))
{
workspaces.Add(ws);
}
}
// collect the name-description pairs for every custom node
return
workspaces
.Where(
p =>
(pkgLoader.IsUnderPackageControl(p.FileName) && pkgLoader.GetOwnerPackage(p.FileName).Name == Name)
|| !pmExtension.PackageLoader.IsUnderPackageControl(p.FileName))
.Select(
x =>
new Tuple<string, string>(
x.Name,
!String.IsNullOrEmpty(x.Description)
? x.Description
: Wpf.Properties.Resources.MessageNoNodeDescription));
}
private IEnumerable<string> GetAllFiles()
{
// get all function defs
var allFuncs = AllFuncDefs().ToList();
// all workspaces
var workspaces = new List<CustomNodeWorkspaceModel>();
foreach (var def in allFuncs)
{
CustomNodeWorkspaceModel ws;
if (dynamoViewModel.Model.CustomNodeManager.TryGetFunctionWorkspace(
def.FunctionId,
DynamoModel.IsTestMode,
out ws))
{
workspaces.Add(ws);
}
}
// make sure workspaces are saved
var unsavedWorkspaceNames =
workspaces.Where(ws => ws.HasUnsavedChanges || ws.FileName == null).Select(ws => ws.Name).ToList();
if (unsavedWorkspaceNames.Any())
{
throw new Exception(Wpf.Properties.Resources.MessageUnsavedChanges0 +
String.Join(", ", unsavedWorkspaceNames) +
Wpf.Properties.Resources.MessageUnsavedChanges1);
}
var pmExtension = dynamoViewModel.Model.GetPackageManagerExtension();
// omit files currently already under package control
var files =
workspaces.Select(f => f.FileName)
.Where(
p =>
(pmExtension.PackageLoader.IsUnderPackageControl(p)
&& (pmExtension.PackageLoader.GetOwnerPackage(p).Name == Name)
|| !pmExtension.PackageLoader.IsUnderPackageControl(p)));
// union with additional files
files = files.Union(AdditionalFiles);
files = files.Union(Assemblies.Select(x => x.Assembly.Location));
return files;
}
/// <summary>
/// This method adds relevant models to the undo recorder.
/// </summary>
/// <param name="isGroupLayout">True if all the selected models are groups.</param>
private void RecordUndoGraphLayout(bool isGroupLayout)
{
List<ModelBase> undoItems = new List<ModelBase>();
if (!isGroupLayout)
{
// Add all selected items to the undo recorder
undoItems.AddRange(Nodes);
undoItems.AddRange(Notes);
if (DynamoSelection.Instance.Selection.Count > 0)
{
undoItems = undoItems.Where(x => x.IsSelected).ToList();
}
}
else
{
// Add all models inside selected groups
foreach (var group in Annotations)
{
if (group.IsSelected)
{
group.Deselect();
undoItems.AddRange(group.SelectedModels);
}
}
}
WorkspaceModel.RecordModelsForModification(undoItems, UndoRecorder);
}
protected override void LoadNode(XmlNode nodeElement)
{
selectionOwner = DocumentManager.Instance.CurrentDBDocument;
selectedUniqueIds =
nodeElement.ChildNodes.Cast<XmlNode>()
.Where(subNode => subNode.Name.Equals("instance") && subNode.Attributes != null)
.Select(subNode => subNode.Attributes[0].Value)
.ToList();
selectedElements =
selectedUniqueIds
.Where(id => DocumentManager.Instance.ElementExistsInDocument(new ElementUUID(id)))
.Select(selectionOwner.GetElement)
.Select(x => x.Id)
.ToList();
RequiresRecalc = true;
RaisePropertyChanged("SelectedElement");
}
/// <summary>
/// Aggregates all upstream geometry for the given node then sends
/// a message that a visualization is ready
/// </summary>
/// <param name="node">The node whose upstream geometry you need.</param>
/// <returns>A render description containing all upstream geometry.</returns>
public void AggregateUpstreamRenderPackages(RenderTag tag)
{
var packages = new List<IRenderPackage>();
//send back just what the node needs
var watch = new Stopwatch();
watch.Start();
if (tag.Node == null)
{
//send back everything
List<NodeModel> copyOfNodesList = controller.DynamoModel.Nodes;
foreach (var modelNode in copyOfNodesList)
{
lock (modelNode.RenderPackagesMutex)
{
packages.AddRange(modelNode.RenderPackages);
}
}
watch.Stop();
Debug.WriteLine(String.Format("RENDER: {0} ellapsed for aggregating geometry for background preview.", watch.Elapsed));
if (packages.Any())
{
// if there are packages, send any that aren't empty
OnResultsReadyToVisualize(this,
new VisualizationEventArgs(
packages.Where(x => ((RenderPackage)x).IsNotEmpty()).Cast<RenderPackage>(), string.Empty, tag.TaskId));
}
else
{
// if there are no packages, still trigger an update
// so the view gets redrawn
OnResultsReadyToVisualize(this,
new VisualizationEventArgs(packages.Cast<RenderPackage>(), string.Empty, tag.TaskId));
}
}
else
{
watch.Stop();
Debug.WriteLine(String.Format("RENDER: {0} ellapsed for aggregating geometry for branch {1}.", watch.Elapsed, tag.Node.GUID));
//send back renderables for the branch
packages = GetUpstreamPackages(tag.Node.Inputs, 0).ToList();
if (packages.Any())
OnResultsReadyToVisualize(this, new VisualizationEventArgs(packages.Where(x => ((RenderPackage)x).IsNotEmpty()).Cast<RenderPackage>(), tag.Node.GUID.ToString(),tag.TaskId));
}
//LogVisualizationUpdateData(rd, watch.Elapsed.ToString());
}
void SelectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Reset)
return;
if (updatingPaused || dynSettings.Controller == null)
return;
var changes = new List<ISelectable>();
// Any node that has a visualizations but is
// no longer in the selection
changes.AddRange(dynSettings.Controller.DynamoModel.Nodes
.Where(x => x.HasRenderPackages)
.Where(x => !DynamoSelection.Instance.Selection.Contains(x)));
if (e.NewItems != null && e.NewItems.Cast<ISelectable>().Any())
{
changes.AddRange(e.NewItems.Cast<ISelectable>());
}
UpdateRenderPackages(
changes.Any() ?
changes.Where(sel => sel is NodeModel).Cast<NodeModel>() :
null);
}
