public NoteViewModel(WorkspaceViewModel workspaceViewModel, NoteModel model)
{
this.WorkspaceViewModel = workspaceViewModel;
_model = model;
model.PropertyChanged += note_PropertyChanged;
DynamoSelection.Instance.Selection.CollectionChanged += SelectionOnCollectionChanged;
}
public NoteEventArgs(NoteModel n, Dictionary<string, object> d)
{
Note = n;
Data = d;
}
/// <summary>
/// Paste ISelectable objects from the clipboard to the workspace.
/// </summary>
public void Paste()
{
//clear the selection so we can put the
//paste contents in
DynamoSelection.Instance.ClearSelection();
//make a lookup table to store the guids of the
//old models and the guids of their pasted versions
var modelLookup = new Dictionary<Guid, ModelBase>();
//make a list of all newly created models so that their
//creations can be recorded in the undo recorder.
var createdModels = new List<ModelBase>();
var nodes = ClipBoard.OfType<NodeModel>();
var connectors = ClipBoard.OfType<ConnectorModel>();
var notes = ClipBoard.OfType<NoteModel>();
var annotations = ClipBoard.OfType<AnnotationModel>();
var minX = Double.MaxValue;
var minY = Double.MaxValue;
// Create the new NoteModel's
var newNoteModels = new List<NoteModel>();
foreach (var note in notes)
{
var noteModel = new NoteModel(note.X, note.Y, note.Text, Guid.NewGuid());
//Store the old note as Key and newnote as value.
modelLookup.Add(note.GUID,noteModel);
newNoteModels.Add(noteModel);
minX = Math.Min(note.X, minX);
minY = Math.Min(note.Y, minY);
}
var xmlDoc = new XmlDocument();
// Create the new NodeModel's
var newNodeModels = new List<NodeModel>();
foreach (var node in nodes)
{
NodeModel newNode;
if (CurrentWorkspace is HomeWorkspaceModel && (node is Symbol || node is Output))
{
var symbol = (node is Symbol
? (node as Symbol).InputSymbol
: (node as Output).Symbol);
var code = (string.IsNullOrEmpty(symbol) ? "x" : symbol) + ";";
newNode = new CodeBlockNodeModel(code, node.X, node.Y, LibraryServices, CurrentWorkspace.ElementResolver);
}
else
{
var dynEl = node.Serialize(xmlDoc, SaveContext.Copy);
newNode = NodeFactory.CreateNodeFromXml(dynEl, SaveContext.Copy, CurrentWorkspace.ElementResolver);
}
var lacing = node.ArgumentLacing.ToString();
newNode.UpdateValue(new UpdateValueParams("ArgumentLacing", lacing));
if (!string.IsNullOrEmpty(node.NickName))
newNode.NickName = node.NickName;
modelLookup.Add(node.GUID, newNode);
newNodeModels.Add( newNode );
minX = Math.Min(node.X, minX);
minY = Math.Min(node.Y, minY);
}
// Move all of the notes and nodes such that they are aligned with
// the top left of the workspace
var workspaceX = -CurrentWorkspace.X / CurrentWorkspace.Zoom;
var workspaceY = -CurrentWorkspace.Y / CurrentWorkspace.Zoom;
// Provide a small offset when pasting so duplicate pastes aren't directly on top of each other
CurrentWorkspace.IncrementPasteOffset();
var shiftX = workspaceX - minX + CurrentWorkspace.CurrentPasteOffset;
var shiftY = workspaceY - minY + CurrentWorkspace.CurrentPasteOffset;
foreach (var model in newNodeModels.Concat<ModelBase>(newNoteModels))
{
model.X = model.X + shiftX;
model.Y = model.Y + shiftY;
}
// Add the new NodeModel's to the Workspace
foreach (var newNode in newNodeModels)
{
CurrentWorkspace.AddAndRegisterNode(newNode, false);
createdModels.Add(newNode);
AddToSelection(newNode);
}
// TODO: is this required?
OnRequestLayoutUpdate(this, EventArgs.Empty);
// Add the new NoteModel's to the Workspace
foreach (var newNote in newNoteModels)
{
CurrentWorkspace.AddNote(newNote, false);
createdModels.Add(newNote);
AddToSelection(newNote);
}
ModelBase start;
ModelBase end;
var newConnectors =
from c in connectors
// If the guid is in nodeLookup, then we connect to the new pasted node. Otherwise we
// re-connect to the original.
let startNode =
modelLookup.TryGetValue(c.Start.Owner.GUID, out start)
? start as NodeModel
: CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.Start.Owner.GUID)
let endNode =
modelLookup.TryGetValue(c.End.Owner.GUID, out end)
? end as NodeModel
: CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.End.Owner.GUID)
// Don't make a connector if either end is null.
where startNode != null && endNode != null
select
ConnectorModel.Make(startNode, endNode, c.Start.Index, c.End.Index);
createdModels.AddRange(newConnectors);
//Grouping depends on the selected node models.
//so adding the group after nodes / notes are added to workspace.
//select only those nodes that are part of a group.
var newAnnotations = new List<AnnotationModel>();
foreach (var annotation in annotations)
{
var annotationNodeModel = new List<NodeModel>();
var annotationNoteModel = new List<NoteModel>();
//checked condition here that supports pasting of multiple groups
foreach (var models in annotation.SelectedModels)
{
ModelBase mbase;
modelLookup.TryGetValue(models.GUID, out mbase);
if (mbase is NodeModel)
{
annotationNodeModel.Add(mbase as NodeModel);
}
if (mbase is NoteModel)
{
annotationNoteModel.Add(mbase as NoteModel);
}
}
var annotationModel = new AnnotationModel(annotationNodeModel, annotationNoteModel)
{
GUID = Guid.NewGuid(),
AnnotationText = annotation.AnnotationText,
Background = annotation.Background,
FontSize = annotation.FontSize
};
newAnnotations.Add(annotationModel);
}
// Add the new Annotation's to the Workspace
foreach (var newAnnotation in newAnnotations)
{
CurrentWorkspace.AddAnnotation(newAnnotation);
createdModels.Add(newAnnotation);
AddToSelection(newAnnotation);
}
// Record models that are created as part of the command.
CurrentWorkspace.RecordCreatedModels(createdModels);
}
public void AddNote(NoteModel note, bool centered)
{
if (centered)
{
var args = new ModelEventArgs(note, true);
OnRequestNodeCentered(this, args);
}
Notes.Add(note);
}
public NoteModel AddNote(bool centerNote, double xPos, double yPos, string text, Guid id)
{
var noteModel = new NoteModel(xPos, yPos, string.IsNullOrEmpty(text) ? Resources.NewNoteString : text, id);
//if we have null parameters, the note is being added
//from the menu, center the view on the note
AddNote(noteModel, centerNote);
return noteModel;
}
private void RemoveNote(NoteModel note)
{
lock (notes)
{
if (!notes.Remove(note)) return;
}
OnNoteRemoved(note);
}
/// <summary>
/// Creates and initializes a NoteModel from its Xml representation.
/// </summary>
/// <param name="note"></param>
/// <returns></returns>
public static NoteModel LoadNoteFromXml(XmlNode note)
{
var instance = new NoteModel(0, 0, string.Empty, Guid.NewGuid());
instance.Deserialize(note as XmlElement, SaveContext.File);
return instance;
}
protected virtual void OnNoteRemoved(NoteModel note)
{
var handler = NoteRemoved;
if (handler != null) handler(note);
}
private void AddNote(NoteModel note)
{
lock (notes)
{
notes.Add(note);
}
OnNoteAdded(note);
}
private void Model_NoteRemoved(NoteModel note)
{
_notes.Remove(_notes.First(x => x.Model == note));
}
public void CreateModel(XmlElement modelData)
{
XmlElementHelper helper = new XmlElementHelper(modelData);
string typeName = helper.ReadString("type", String.Empty);
if (string.IsNullOrEmpty(typeName))
{
// If there wasn't a "type" attribute, then we fall-back onto
// the name of the XmlElement itself, which is usually the type
// name.
typeName = modelData.Name;
if (string.IsNullOrEmpty(typeName))
{
string guid = helper.ReadString("guid");
throw new InvalidOperationException(
string.Format("No type information: {0}", guid));
}
}
#if USE_DSENGINE
if (typeName.Equals("Dynamo.Nodes.DSFunction") ||
typeName.Equals("Dynamo.Nodes.DSVarArgFunction"))
{
// For DSFunction and DSVarArgFunction node types, the type name
// is actually embedded within "name" attribute (for an example,
// "UV.ByCoordinates@double,double").
//
typeName = modelData.Attributes["name"].Value;
}
#endif
if (typeName.StartsWith("Dynamo.Models.ConnectorModel"))
{
ConnectorModel connector = ConnectorModel.Make();
connector.Deserialize(modelData, SaveContext.Undo);
Connectors.Add(connector);
}
else if (typeName.StartsWith("Dynamo.Models.NoteModel"))
{
NoteModel noteModel = new NoteModel(0.0, 0.0);
noteModel.Deserialize(modelData, SaveContext.Undo);
Notes.Add(noteModel);
}
else // Other node types.
{
NodeModel nodeModel = DynamoModel.CreateNodeInstance(typeName);
nodeModel.WorkSpace = this;
nodeModel.Deserialize(modelData, SaveContext.Undo);
Nodes.Add(nodeModel);
}
}
private void Model_NoteAdded(NoteModel note)
{
var viewModel = new NoteViewModel(this, note);
_notes.Add(viewModel);
}
public NoteViewModel(NoteModel model)
{
_model = model;
model.PropertyChanged += note_PropertyChanged;
dynSettings.Controller.DynamoViewModel.Model.PropertyChanged += Model_PropertyChanged;
}
public void CreateModel(XmlElement modelData)
{
XmlElementHelper helper = new XmlElementHelper(modelData);
string typeName = helper.ReadString("type", String.Empty);
if (string.IsNullOrEmpty(typeName))
{
// If there wasn't a "type" attribute, then we fall-back onto
// the name of the XmlElement itself, which is usually the type
// name.
typeName = modelData.Name;
if (string.IsNullOrEmpty(typeName))
{
string guid = helper.ReadString("guid");
throw new InvalidOperationException(
string.Format("No type information: {0}", guid));
}
}
if (typeName.StartsWith("Dynamo.Nodes"))
{
NodeModel nodeModel = DynamoModel.CreateNodeInstance(typeName);
nodeModel.WorkSpace = this;
nodeModel.Deserialize(modelData, SaveContext.Undo);
Nodes.Add(nodeModel);
}
else if (typeName.StartsWith("Dynamo.Models.ConnectorModel"))
{
ConnectorModel connector = ConnectorModel.Make();
connector.Deserialize(modelData, SaveContext.Undo);
Connectors.Add(connector);
}
else if (typeName.StartsWith("Dynamo.Models.NoteModel"))
{
NoteModel noteModel = new NoteModel(0.0, 0.0);
noteModel.Deserialize(modelData, SaveContext.Undo);
Notes.Add(noteModel);
}
}
internal NoteModel AddNoteInternal(DynCmd.CreateNoteCommand command, WorkspaceModel workspace)
{
double x = 0.0;
double y = 0.0;
if (false == command.DefaultPosition)
{
x = command.X;
y = command.Y;
}
NoteModel noteModel = new NoteModel(x, y);
noteModel.GUID = command.NodeId;
//if we have null parameters, the note is being added
//from the menu, center the view on the note
if (command.DefaultPosition)
{
ModelEventArgs args = new ModelEventArgs(noteModel, true);
DynamoViewModel vm = dynSettings.Controller.DynamoViewModel;
vm.CurrentSpaceViewModel.OnRequestNodeCentered(this, args);
}
noteModel.Text = "New Note";
if (!string.IsNullOrEmpty(command.NoteText))
noteModel.Text = command.NoteText;
if (null == workspace)
workspace = CurrentWorkspace;
workspace.Notes.Add(noteModel);
return noteModel;
}
public NoteViewModel(WorkspaceViewModel workspaceViewModel, NoteModel model)
{
this.WorkspaceViewModel = workspaceViewModel;
_model = model;
model.PropertyChanged += note_PropertyChanged;
}