private async Task <AnnotationModel> UpdateAnnotation(AnnotationModel model)
{
var entity = await _annotations
.Include(a => a.CreatedUser)
.Include(a => a.Target)
.Include(a => a.Group)
.Include(a => a.License)
.Include(a => a.AnnotationType)
.Include(a => a.Tags).ThenInclude(at => at.Tag)
.FirstOrDefaultAsync(a => a.AnnotationId == model.Id);
if (entity != null)
{
entity = model.ToEntity(entity);
entity.UpdatedDate = DateTime.UtcNow;
await _unitOfWork.SaveChangesAsync();
var updated = entity.ToModel();
return(updated);
}
else
{
throw new NotFoundException($"Annotation with id {model.Id} not found.");
}
}
public async Task <IViewComponentResult> InvokeAsync(string entityName, string recordId)
{
ApplicationUser curUser = await Helpers.Common.GetCurrentUser(_userManager, HttpContext.User);
curUser = curUser == null ? new ApplicationUser() : curUser;
var annotations = await _context.Annotation.Select(n => new Annotation
{
Annotation_Id = n.Annotation_Id,
ObjectName = n.ObjectName,
ObjectId = n.ObjectId,
CreatedBy = n.CreatedBy,
CreatedOn = n.CreatedOn,
FileName = n.FileName,
FileSize = n.FileSize,
Id = n.Id,
IsDocument = n.IsDocument,
IsPrivate = n.IsPrivate,
MimeType = n.MimeType,
ModifiedBy = n.ModifiedBy,
ModifiedOn = n.ModifiedOn,
NoteText = n.NoteText,
Subject = n.Subject
}).Where(n => n.ObjectName == entityName && n.ObjectId == recordId &&
(!n.IsPrivate || (n.IsPrivate && n.CreatedBy == curUser.Id))).
OrderByDescending(n => n.CreatedOn).ToListAsync();
List <AnnotationViewModel> notesModel = new List <AnnotationViewModel>();
foreach (var note in annotations)
{
notesModel.Add(new AnnotationViewModel
{
Annotation_Id = note.Annotation_Id,
ObjectName = note.ObjectName,
ObjectId = note.ObjectId,
CreatedBy = Helpers.Common.ResolveUser(_context, note.CreatedBy),
CreatedOn = note.CreatedOn,
FileName = note.FileName,
FileSize = note.FileSize,
Id = note.Id,
IsDocument = note.IsDocument,
IsPrivate = note.IsPrivate,
MimeType = note.MimeType,
ModifiedBy = Helpers.Common.ResolveUser(_context, note.CreatedBy),
ModifiedOn = note.ModifiedOn,
NoteText = note.NoteText,
Subject = note.Subject
});
}
AnnotationModel notes = new AnnotationModel
{
EntityName = entityName,
RecordId = recordId,
CurrentUserId = curUser.Id,
Notes = notesModel
};
return(View(notes));
}
private async Task <AnnotationModel> AddAnnotation(AnnotationModel model)
{
var target = model.Target?.ToEntity();
if (target != null && target.AnnotationTargetId < 1)
{
await _annotationTargets.AddAsync(target);
}
var entity = model.ToEntity();
entity.AnnotationTargetId = target.AnnotationTargetId;
entity.CreatedDate = DateTime.UtcNow;
entity.CreatedUserId = model.CreatedUserId;
entity.GroupId = model.GroupId;
await _annotations.AddAsync(entity);
await _unitOfWork.SaveChangesAsync();
var added = await _annotations
.Include(a => a.CreatedUser)
.Include(a => a.Target)
.Include(a => a.Group)
.Include(a => a.License)
.Include(a => a.AnnotationType)
.Include(a => a.Tags).ThenInclude(at => at.Tag)
.SingleOrDefaultAsync(a => a.AnnotationId == entity.AnnotationId);
return(added.ToModel());
}
internal void RecordGroupModelBeforeUngroup(AnnotationModel annotation)
{
using (undoRecorder.BeginActionGroup()) // Start a new action group.
{
undoRecorder.RecordModificationForUndo(annotation);
}
}
public async Task <IActionResult> CreateAnnotation([FromBody] AnnotationModel model)
{
var newAnnotation = new Annotation();
try
{
if (!ModelState.IsValid)
{
ValidModel();
}
newAnnotation = new Annotation()
{
IsChecked = model.IsChecked,
StudentId = model.StudentId,
Type = model.Type,
Content = model.Content
};
await _service.AnnotationService.AddAsync(newAnnotation);
}
catch (Exception e)
{
return(ErrorResult(e.Message));
}
return(SuccessResult(newAnnotation, "Created Annotation successfully."));
}
public static AnnotationModel ToModel(this Annotation entity, bool includeChildren = true)
{
AnnotationModel model = null;
if (entity != null)
{
model = new AnnotationModel
{
Id = entity.AnnotationId,
Body = entity.Body,
TargetId = entity.AnnotationTargetId,
Target = entity.Target?.ToModel(),
CreatedDate = entity.CreatedDate,
UpdatedDate = entity.UpdatedDate,
CreatedUser = entity.CreatedUser?.Email,
UpdatedUser = entity.UpdatedUser?.Email,
GroupId = entity.GroupId,
GroupName = entity.Group?.GroupName,
CreatedUserId = entity.CreatedUserId,
UpdatedUserId = entity.UpdatedUserId,
LicenseId = entity.LicenseId,
License = entity.License?.ToModel(),
AnnotationTypeId = entity.AnnotationTypeId,
AnnotationType = entity.AnnotationType?.ToModel(),
Annotations = includeChildren ? entity.Annotations?.ToList().ConvertAll(a => a.ToModel()) : new List <AnnotationModel>(),
ParentId = entity.ParentId,
Tags = entity.Tags?.ToList().ConvertAll(t => t.ToTagModel())
};
}
return(model);
}
private void AnnotateButtonClick()
{
// TODO: check if tracking
byte[] png;
if (DebugImage != null)
{
png = DebugImage.EncodeToPNG();
}
else
{
png = ArUtils.GetCameraImage(ARInterface.GetInterface());
if (png == null)
{
return;
}
}
var imageModel = new ImageModel(png);
imageModel.Save();
var annotationModel =
new AnnotationModel(
new Pose(Camera.main.transform.position, Camera.main.transform.rotation),
Camera.main.aspect,
imageModel);
annotationModel.Save();
AddAnnotation(annotationModel);
}
public IActionResult Annotation([FromBody] AnnotationModel model)
{
var annotation = ModelFactory.MapAnnotation(model);
//return Ok(DataService.AddAnnotation(annotation));
return(Ok(DataService.AddAnnotation(annotation)));
}
internal static AnnotationModel LoadAnnotationFromXml(XmlNode annotation, IEnumerable <NodeModel> nodes, IEnumerable <NoteModel> notes)
{
var instance = new AnnotationModel(nodes, notes);
instance.Deserialize(annotation as XmlElement, SaveContext.File);
return(instance);
}
public Annotation Parse(AnnotationModel model)
{
return new Annotation
{
Body = model.Body,
Date = model.Date
};
}
void Awake()
{
SocketService.GetInstance().OnCreate["annotation"] = json =>
{
var annotationModel = new AnnotationModel(json);
AddAnnotation(annotationModel);
};
}
public void Update(AnnotationModel _annotation)
{
using (ISession session = NHibernateHelper.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
session.Update(_annotation);
transaction.Commit();
}
}
public IActionResult AnnotationDummy(AnnotationModel model)
{
if (!ModelState.IsValid)
{
ViewData["IsError"] = "Fehler verursacht";
}
return(View(model));
}
private void AddAnnotation(AnnotationModel annotationModel)
{
var annotationController = Instantiate(AnnotationPrefab);
annotationController.Setup(annotationModel);
annotationController.TargetPosition = AnchorPosition.transform;
annotationController.OnLeaveInactiveMode += OnAnnotationControllerSelect;
annotationController.OnInactiveMode += OnAnnotationControllerDeselect;
MapCanvasController.AddAnnotation(annotationController);
}
public AnnotationViewModel(WorkspaceViewModel workspaceViewModel, AnnotationModel model)
{
annotationModel = model;
this.WorkspaceViewModel = workspaceViewModel;
model.PropertyChanged += model_PropertyChanged;
// Group is created already.So just populate it.
var selectNothing = new DynamoModel.SelectModelCommand(Guid.Empty, System.Windows.Input.ModifierKeys.None.AsDynamoType());
WorkspaceViewModel.DynamoViewModel.ExecuteCommand(selectNothing);
}
public static void AddAnnotation(AnnotationModel a)
{
DataVariables._annotationRepo.Add(a);
DataVariables.Active_Annotation = a;
DataVariables.Annotations.Add(DataVariables.Active_Annotation);
DataVariables.Annotations = DataVariables.Annotations.Where(x => x.HideShowRow == false).ToList();//.OrderByDescending(x => x.Date_Time < DateTime.Now).ToList();
DataVariables.Annotations.Sort((x, y) => x.Date_Time.CompareTo(y.Date_Time));
DataVariables.Annotations.Reverse();
}
public void Remove(AnnotationModel _annotation)
{
//using (ISession session = NHibernateHelper.OpenSession())
//using (ITransaction transaction = session.BeginTransaction())
{
//session.Delete(_annotation);
//transaction.Commit();
Update(_annotation);
}
}
public IActionResult Put(int id, [FromBody] AnnotationModel model)
{
var annotation = ModelFactory.MapAnnotation(model);
annotation.AnnotationId = id;
if (!DataService.UpdateAnnotation(annotation))
{
return(NotFound());
}
return(Ok());
}
public IActionResult GetAnnotration(int Pid)
{
var annot = _repository.GetAnnotationById(Pid);
var annotationModel = new AnnotationModel();
annotationModel.MarkingLink = Url.Link(nameof(MarkingController.GetMarking), new { Pid = annot.MarkedPostId });
annotationModel.AnnotationText = annot.Annotation;
annotationModel.EditAnnotation = Url.Link(nameof(AnnotationController.EditAnnotation), new { AnnotId = annot.Annotationid, text = annot.Annotation });
annotationModel.RemoveAnnotation = Url.Link(nameof(AnnotationController.RemoveAnnotation), new { AnnotId = annot.Annotationid });
return(Ok(annotationModel));
}
public AnnotationModel GetByName(string name)
{
using (ISession session = NHibernateHelper.OpenSession())
{
AnnotationModel _annotation = session
.CreateCriteria(typeof(AnnotationModel))
.Add(Restrictions.Eq("Name", name))
.UniqueResult <AnnotationModel>();
return(_annotation);
}
}
public IActionResult EditAnnotation(AnnotationModel model)
{
if (ModelState.IsValid)
{
_context.Annotations.Update(model);
_context.SaveChanges();
return(RedirectToAction("Annotations"));
}
return(View(model));
}
public IActionResult EditAnnotation(Guid id)
{
AnnotationModel ann = _context.Annotations.FirstOrDefault(x => x.ID == id);
if (ann != null)
{
return(View(ann));
}
TempData["Error"] = "Nie znaleziono obiektu o podanym ID.";
return(RedirectToAction("Annotations"));
}
public async Task <IActionResult> UploadAttachment(AnnotationModel newAttachment)
{
bool uploaded = await UploadAttachmentDragDrop(newAttachment);
if (uploaded)
{
return(RedirectToAction("Details", "HRCase", new { id = newAttachment.CaseId }, "tabAttachments"));
}
else
{
return(null);
}
}
public IActionResult AddAnnotation(int Pid, [FromBody] AnnotationModel obj)
{
var addedAnnotation = _repository.AddAnnotation(Pid, obj.AnnotationText, (int)obj.From, (int)obj.To);
var annotationModel = new AnnotationModel();
annotationModel.MarkingLink = Url.Link(nameof(MarkingController.GetMarking), new { Pid = addedAnnotation.MarkedPostId });
annotationModel.AnnotationText = addedAnnotation.Annotation;
annotationModel.From = obj.From;
annotationModel.To = obj.To;
annotationModel.EditAnnotation = Url.Link(nameof(AnnotationController.EditAnnotation), new { AnnotId = addedAnnotation.Annotationid, text = addedAnnotation.Annotation });
annotationModel.RemoveAnnotation = Url.Link(nameof(AnnotationController.RemoveAnnotation), new { AnnotId = addedAnnotation.Annotationid });
return(Created($"api/marking/{Pid}/annotation", annotationModel));
}
public IActionResult AddAnnotation(AnnotationModel model)
{
if (ModelState.IsValid)
{
_context.Annotations.Add(model);
_context.SaveChanges();
return(RedirectToAction("Annotations"));
}
ViewBag.Usr = _usermanager.GetUserId(User);
return(View(model));
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var workspaceView = (WorkspaceViewModel)value;
writer.WriteStartObject();
writer.WritePropertyName("Dynamo");
serializer.Serialize(writer, workspaceView.DynamoPreferences);
writer.WritePropertyName("Camera");
serializer.Serialize(writer, workspaceView.Camera);
writer.WritePropertyName("NodeViews");
writer.WriteStartArray();
foreach (var nodeView in workspaceView.Nodes)
{
serializer.Serialize(writer, nodeView);
}
writer.WriteEndArray();
writer.WritePropertyName("Annotations");
writer.WriteStartArray();
foreach (var annotation in workspaceView.Annotations)
{
serializer.Serialize(writer, annotation);
}
foreach (var note in workspaceView.Notes)
{
AnnotationModel convertedNote = new AnnotationModel(new NodeModel[0], new NoteModel[0]);
convertedNote.GUID = note.Model.GUID;
convertedNote.X = note.Left;
convertedNote.Y = note.Top;
convertedNote.AnnotationText = note.Text;
serializer.Serialize(writer, new AnnotationViewModel(workspaceView, convertedNote));
}
writer.WriteEndArray();
writer.WritePropertyName("X");
writer.WriteValue(workspaceView.X);
writer.WritePropertyName("Y");
writer.WriteValue(workspaceView.Y);
writer.WritePropertyName("Zoom");
writer.WriteValue(workspaceView.Zoom);
writer.WriteEndObject();
}
private static void EdmReadAnnotationDemo()
{
Console.WriteLine("EdmReadAnnotationDemo");
var annotationModel = new AnnotationModel();
var model = annotationModel.Model;
var person = (IEdmEntityType)model.FindType("TestNS.Person");
var annotation = model.FindVocabularyAnnotations <IEdmValueAnnotation>(person, "TestNS.OutColor").First();
var memberExp = (IEdmEnumMemberExpression)annotation.Value;
foreach (var member in memberExp.EnumMembers)
{
Console.WriteLine(member.Name);
}
}
public AnnotationViewModel(WorkspaceViewModel workspaceViewModel, AnnotationModel model)
{
annotationModel = model;
this.WorkspaceViewModel = workspaceViewModel;
model.PropertyChanged += model_PropertyChanged;
//https://jira.autodesk.com/browse/QNTM-3770
//Notes and Groups are serialized as annotations. Do not unselect the node selection during
//Notes serialization
if (model.Nodes.Count() > 0)
{
// Group is created already.So just populate it.
var selectNothing = new DynamoModel.SelectModelCommand(Guid.Empty, System.Windows.Input.ModifierKeys.None.AsDynamoType());
WorkspaceViewModel.DynamoViewModel.ExecuteCommand(selectNothing);
}
}
public void Add(AnnotationModel _annotation)
{
using (ISession session = NHibernateHelper.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
try
{
session.Save(_annotation);
transaction.Commit();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
public IHttpActionResult Put(int id, AnnotationModel annotationModel)
{
var annotation = new Annotation
{
Body = annotationModel.Body,
MarkingStart = annotationModel.MarkingStart,
MarkingEnd = annotationModel.MarkingEnd,
PostId = annotationModel.PostId,
CommentId = annotationModel.CommentId,
SearchUserId = annotationModel.SearchUserId
};
if (!_repository.Update(id, annotation))
{
return(NotFound());
}
return(Ok());
}
private static Annotation PopulateEntity(AnnotationModel model, Annotation entity)
{
entity.Body = model.Body;
entity.AnnotationTargetId = model.TargetId > 0 ? model.TargetId : model.Target.Id;
entity.CreatedDate = model.CreatedDate;
entity.CreatedUserId = model.CreatedUserId;
entity.UpdatedDate = model.UpdatedDate;
entity.UpdatedUserId = model.UpdatedUserId;
entity.GroupId = model.GroupId;
entity.LicenseId = model.LicenseId;
entity.AnnotationTypeId = model.AnnotationTypeId;
entity.ParentId = model.ParentId;
var modelTags = model.Tags?.ToList();
if (modelTags == null)
{
if (entity.Tags.Count > 1)
{
entity.Tags.ToList().RemoveRange(0, entity.Tags.Count);
}
}
else
{
// delete first all that have been removed
entity.Tags.ToList().ForEach(t => {
if (modelTags.FindIndex(mt => mt.id == t.TagId) < 0)
{
entity.Tags.Remove(t);
}
});
modelTags.ForEach(t =>
{
if (!entity.Tags.Any(e => e.TagId == t.id))
{
entity.Tags.Add(t.ToAnnotationTagEntity());
}
});
}
return(entity);
}
/// <summary>
/// Paste ISelectable objects from the clipboard to the workspace at specified point.
/// </summary>
/// <param name="targetPoint">Location where data will be pasted</param>
/// <param name="useOffset">Indicates whether we will use current workspace offset or paste nodes
/// directly in this point. </param>
public void Paste(Point2D targetPoint, bool useOffset = true)
{
if (useOffset)
{
// Provide a small offset when pasting so duplicate pastes aren't directly on top of each other
CurrentWorkspace.IncrementPasteOffset();
}
//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>();
// 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);
}
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) && !(node is Symbol) && !(node is Output))
newNode.NickName = node.NickName;
newNode.Width = node.Width;
newNode.Height = node.Height;
modelLookup.Add(node.GUID, newNode);
newNodeModels.Add(newNode);
}
var newItems = newNodeModels.Concat<ModelBase>(newNoteModels);
var shiftX = targetPoint.X - newItems.Min(item => item.X);
var shiftY = targetPoint.Y - newItems.Min(item => item.Y);
var offset = useOffset ? CurrentWorkspace.CurrentPasteOffset : 0;
foreach (var model in newItems)
{
model.X = model.X + shiftX + offset;
model.Y = model.Y + shiftY + offset;
}
// Add the new NodeModel's to the Workspace
foreach (var newNode in newNodeModels)
{
CurrentWorkspace.AddAndRegisterNode(newNode, false);
createdModels.Add(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);
}
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>();
// some models can be deleted after copying them,
// so they need to be in pasted annotation as well
var modelsToRestore = annotation.DeletedModelBases.Intersect(ClipBoard);
var modelsToAdd = annotation.SelectedModels.Concat(modelsToRestore);
// checked condition here that supports pasting of multiple groups
foreach (var models in modelsToAdd)
{
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);
}
// adding an annotation overrides selection, so add nodes and notes after
foreach (var item in newItems)
{
AddToSelection(item);
}
// Record models that are created as part of the command.
CurrentWorkspace.RecordCreatedModels(createdModels);
}
public AnnotationModel AddAnnotation(string text, Guid id)
{
var selectedNodes = this.Nodes == null ? null:this.Nodes.Where(s => s.IsSelected);
var selectedNotes = this.Notes == null ? null: this.Notes.Where(s => s.IsSelected);
if (!CheckIfModelExistsInSameGroup(selectedNodes, selectedNotes))
{
var annotationModel = new AnnotationModel(selectedNodes, selectedNotes)
{
GUID = id,
AnnotationText = text
};
annotationModel.ModelBaseRequested += annotationModel_GetModelBase;
annotationModel.Disposed += (_) => annotationModel.ModelBaseRequested -= annotationModel_GetModelBase;
AddNewAnnotation(annotationModel);
HasUnsavedChanges = true;
return annotationModel;
}
return null;
}
public void AddAnnotation(AnnotationModel annotationModel)
{
annotationModel.ModelBaseRequested += annotationModel_GetModelBase;
annotationModel.Disposed += (_) => annotationModel.ModelBaseRequested -= annotationModel_GetModelBase;
AddNewAnnotation(annotationModel);
}
private void RemoveAnnotation(AnnotationModel annotation)
{
lock (annotations)
{
if (!annotations.Remove(annotation)) return;
}
OnAnnotationRemoved(annotation);
}
private void AddNewAnnotation(AnnotationModel annotation)
{
lock (annotations)
{
annotations.Add(annotation);
}
OnAnnotationAdded(annotation);
}
protected virtual void OnAnnotationRemoved(AnnotationModel annotation)
{
var handler = AnnotationRemoved;
if (handler != null) handler(annotation);
}
public void CreateModel(XmlElement modelData)
{
var 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.Equals("Dynamo.Graph.Nodes.ZeroTouch.DSFunction") ||
typeName.Equals("Dynamo.Graph.Nodes.ZeroTouch.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;
}
*/
if (typeName.Contains("ConnectorModel"))
{
var connector = NodeGraph.LoadConnectorFromXml(modelData,
Nodes.ToDictionary(node => node.GUID));
// It is possible that in some cases connector can't be created,
// for example, connector connects to a custom node instance
// whose input ports have been changed, so connector can't find
// its end port owner.
if (connector == null)
{
var guidAttribute = modelData.Attributes["guid"];
if (guidAttribute == null)
{
throw new InvalidOperationException("'guid' field missing from recorded model");
}
undoRecorder.RecordModelAsOffTrack(Guid.Parse(guidAttribute.Value));
}
else
{
OnConnectorAdded(connector); // Update view-model and view.
}
}
else if (typeName.Contains("NoteModel"))
{
var noteModel = NodeGraph.LoadNoteFromXml(modelData);
AddNote(noteModel);
//check whether this note belongs to a group
foreach (var annotation in Annotations)
{
//this note "was" in a group
if (annotation.DeletedModelBases.Any(m => m.GUID == noteModel.GUID))
{
annotation.AddToSelectedModels(noteModel);
}
}
}
else if (typeName.Contains("AnnotationModel"))
{
var selectedNodes = this.Nodes == null ? null : this.Nodes.Where(s => s.IsSelected);
var selectedNotes = this.Notes == null ? null : this.Notes.Where(s => s.IsSelected);
var annotationModel = new AnnotationModel(selectedNodes, selectedNotes);
annotationModel.ModelBaseRequested += annotationModel_GetModelBase;
annotationModel.Disposed += (_) => annotationModel.ModelBaseRequested -= annotationModel_GetModelBase;
annotationModel.Deserialize(modelData, SaveContext.Undo);
AddNewAnnotation(annotationModel);
}
else if (typeName.Contains("PresetModel"))
{
var preset = new PresetModel(this.Nodes);
preset.Deserialize(modelData, SaveContext.Undo);
presets.Add(preset);
//we raise this property change here so that this event bubbles up through
//the model and to the DynamoViewModel so that presets show in the UI menu if our undo/redo
//created the first preset
RaisePropertyChanged("EnablePresetOptions");
}
else // Other node types.
{
NodeModel nodeModel = NodeFactory.CreateNodeFromXml(modelData, SaveContext.Undo, ElementResolver);
AddAndRegisterNode(nodeModel);
//check whether this node belongs to a group
foreach (var annotation in Annotations)
{
//this node "was" in a group
if (annotation.DeletedModelBases.Any(m=>m.GUID == nodeModel.GUID))
{
annotation.AddToSelectedModels(nodeModel);
}
}
}
}
internal void RecordGroupModelBeforeUngroup(AnnotationModel annotation)
{
using (undoRecorder.BeginActionGroup()) // Start a new action group.
{
undoRecorder.RecordModificationForUndo(annotation);
}
}
public AnnotationViewModel(WorkspaceViewModel workspaceViewModel, AnnotationModel model)
{
annotationModel = model;
this.WorkspaceViewModel = workspaceViewModel;
model.PropertyChanged += model_PropertyChanged;
// Group is created already.So just populate it.
var selectNothing = new DynamoModel.SelectModelCommand(Guid.Empty, System.Windows.Input.ModifierKeys.None.AsDynamoType());
WorkspaceViewModel.DynamoViewModel.ExecuteCommand(selectNothing);
}
private void Model_AnnotationAdded(AnnotationModel annotation)
{
var viewModel = new AnnotationViewModel(this, annotation);
_annotations.Add(viewModel);
}
private void Model_AnnotationRemoved(AnnotationModel annotation)
{
_annotations.Remove(_annotations.First(x => x.AnnotationModel == annotation));
}
