// Token: 0x0600627C RID: 25212 RVA: 0x001BA4A0 File Offset: 0x001B86A0 private void FireResourceEvent(AnnotationResource resource, AnnotationAction action, AnnotationResourceChangedEventHandler handlers) { Invariant.Assert(action >= AnnotationAction.Added && action <= AnnotationAction.Modified, "Unknown AnnotationAction"); this._modified = DateTime.Now; if (handlers != null) { handlers(this, new AnnotationResourceChangedEventArgs(this, action, resource)); } }
/// <summary> /// Create an instance of AttachedAnnotation with a specified parent. Takes an optional /// parent for the attached annotation. This is useful when the parent is known before /// hand and not available through the normal means (such as in printing). /// </summary> /// <param name="manager">the LocatorManager providing processors for this anchored annotation</param> /// <param name="annotation">the annotation itself</param> /// <param name="anchor">the annotation's anchor represented by the attached anchor</param> /// <param name="attachedAnchor">the attached anchor itself</param> /// <param name="attachmentLevel">the level of the attached anchor</param> /// <param name="parent">parent of the selection</param> internal AttachedAnnotation(LocatorManager manager, Annotation annotation, AnnotationResource anchor, Object attachedAnchor, AttachmentLevel attachmentLevel, DependencyObject parent) { Debug.Assert(manager != null, "LocatorManager can not be null"); Debug.Assert(annotation != null, "Annotation can not be null"); Debug.Assert(anchor != null, "Anchor can not be null"); Debug.Assert(attachedAnchor != null, "AttachedAnchor can not be null"); _annotation = annotation; _anchor = anchor; _locatorManager = manager; Update(attachedAnchor, attachmentLevel, parent); }
/// <summary> /// Fires a ResourceChanged event for the given resource and action. /// </summary> /// <param name="resource">the resource to notify about</param> /// <param name="action">the action that took place for that resource</param> /// <param name="handlers">the handlers to notify</param> private void FireResourceEvent(AnnotationResource resource, AnnotationAction action, AnnotationResourceChangedEventHandler handlers) { // resource can be null - we allow that because it could be added or removed from the annotation. Invariant.Assert(action >= AnnotationAction.Added && action <= AnnotationAction.Modified, "Unknown AnnotationAction"); // Always update the modification time before firing change events _modified = DateTime.Now; if (handlers != null) { handlers(this, new AnnotationResourceChangedEventArgs(this, action, resource)); } }
// Token: 0x060062DE RID: 25310 RVA: 0x001BC190 File Offset: 0x001BA390 private static void SetAnchor(AnnotationService service, Annotation annot, object selection) { Invariant.Assert(annot != null && selection != null, "null input parameter"); IList <ContentLocatorBase> list = service.LocatorManager.GenerateLocators(selection); Invariant.Assert(list != null && list.Count > 0, "No locators generated for selection."); AnnotationResource annotationResource = new AnnotationResource(); foreach (ContentLocatorBase item in list) { annotationResource.ContentLocators.Add(item); } annot.Anchors.Clear(); annot.Anchors.Add(annotationResource); }
// Token: 0x060062DC RID: 25308 RVA: 0x001BC0CC File Offset: 0x001BA2CC private static Annotation CreateHighlight(AnnotationService service, ITextRange textRange, string author, Color?color) { Invariant.Assert(textRange != null, "textRange is null"); Annotation annotation = AnnotationHelper.CreateAnnotationForSelection(service, textRange, HighlightComponent.TypeName, author); if (color != null) { ColorConverter colorConverter = new ColorConverter(); XmlDocument xmlDocument = new XmlDocument(); XmlElement xmlElement = xmlDocument.CreateElement("Colors", "http://schemas.microsoft.com/windows/annotations/2003/11/base"); xmlElement.SetAttribute("Background", colorConverter.ConvertToInvariantString(color.Value)); AnnotationResource annotationResource = new AnnotationResource("Highlight"); annotationResource.Contents.Add(xmlElement); annotation.Cargos.Add(annotationResource); } return(annotation); }
// Token: 0x06006279 RID: 25209 RVA: 0x001BA218 File Offset: 0x001B8418 private void OnAnchorsChanged(object sender, NotifyCollectionChangedEventArgs e) { AnnotationAction action = AnnotationAction.Added; IList list = null; switch (e.Action) { case NotifyCollectionChangedAction.Add: action = AnnotationAction.Added; list = e.NewItems; break; case NotifyCollectionChangedAction.Remove: action = AnnotationAction.Removed; list = e.OldItems; break; case NotifyCollectionChangedAction.Replace: foreach (object obj in e.OldItems) { AnnotationResource resource = (AnnotationResource)obj; this.FireResourceEvent(resource, AnnotationAction.Removed, this.AnchorChanged); } list = e.NewItems; break; case NotifyCollectionChangedAction.Move: case NotifyCollectionChangedAction.Reset: break; default: throw new NotSupportedException(SR.Get("UnexpectedCollectionChangeAction", new object[] { e.Action })); } if (list != null) { foreach (object obj2 in list) { AnnotationResource resource2 = (AnnotationResource)obj2; this.FireResourceEvent(resource2, action, this.AnchorChanged); } } }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors /// <summary> /// Creates an instance of AnnotationResourceChangedEventArgs. /// </summary> /// <param name="annotation">the Annotation firing the event</param> /// <param name="action">the action taken on the Resource</param> /// <param name="resource">the Resource that was changed</param> /// <exception cref="ArgumentNullException">annotation or action is null</exception> /// <exception cref="InvalidEnumArgumentException">action is not a valid value from AnnotationAction</exception> public AnnotationResourceChangedEventArgs(Annotation annotation, AnnotationAction action, AnnotationResource resource) { // The resource parameter can be null here - it is possible to add a null to // the list of resources and we must fire an event signalling a change in the collection. if (annotation == null) { throw new ArgumentNullException("annotation"); } if (action < AnnotationAction.Added || action > AnnotationAction.Modified) { throw new InvalidEnumArgumentException("action", (int)action, typeof(AnnotationAction)); } _annotation = annotation; _resource = resource; _action = action; }
private static void SetAnchor(AnnotationService service, Annotation annot, object selection) { Invariant.Assert(annot != null && selection != null, "null input parameter"); // Generate locators for the selection - add them to the anchor IList<ContentLocatorBase> locators = service.LocatorManager.GenerateLocators(selection); Invariant.Assert(locators != null && locators.Count > 0, "No locators generated for selection."); // Create an annotation with a single anchor AnnotationResource anchor = new AnnotationResource(); // Add the locators to the anchor foreach (ContentLocatorBase locator in locators) { anchor.ContentLocators.Add(locator); } annot.Anchors.Clear(); annot.Anchors.Add(anchor); }
/// <summary> /// Creates a highlight annotation with the specified color and author /// </summary> /// <param name="service">the AnnotationService</param> /// <param name="textRange">highlight anchor</param> /// <param name="author">highlight author</param> /// <param name="color">highlight brush</param> /// <returns>created annotation</returns> private static Annotation CreateHighlight(AnnotationService service, ITextRange textRange, string author, Nullable<Color> color) { Invariant.Assert(textRange != null, "textRange is null"); Annotation annotation = CreateAnnotationForSelection(service, textRange, HighlightComponent.TypeName, author); // Set the cargo with highlight color if (color != null) { ColorConverter converter = new ColorConverter(); XmlDocument doc = new XmlDocument(); XmlElement colorsElement = doc.CreateElement(HighlightComponent.ColorsContentName, AnnotationXmlConstants.Namespaces.BaseSchemaNamespace); colorsElement.SetAttribute(HighlightComponent.BackgroundAttributeName, converter.ConvertToInvariantString(color.Value)); AnnotationResource cargo = new AnnotationResource(HighlightComponent.HighlightResourceName); cargo.Contents.Add(colorsElement); annotation.Cargos.Add(cargo); } return annotation; }
/// <summary>Deserializes the <see cref="T:System.Windows.Annotations.Annotation" /> from a specified <see cref="T:System.Xml.XmlReader" />. </summary> /// <param name="reader">The XML reader to use to deserialize the annotation.</param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="reader" /> is <see langword="null" />.</exception> /// <exception cref="T:System.Xml.XmlException">The serialized XML for the <see cref="T:System.Windows.Annotations.Annotation" /> is not valid.</exception> // Token: 0x06006264 RID: 25188 RVA: 0x001B9954 File Offset: 0x001B7B54 public void ReadXml(XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.DeserializeAnnotationBegin); try { XmlDocument xmlDocument = new XmlDocument(); this.ReadAttributes(reader); if (!reader.IsEmptyElement) { reader.Read(); while (XmlNodeType.EndElement != reader.NodeType || !("Annotation" == reader.LocalName)) { if ("Anchors" == reader.LocalName) { Annotation.CheckForNonNamespaceAttribute(reader, "Anchors"); if (!reader.IsEmptyElement) { reader.Read(); while (!("Anchors" == reader.LocalName) || XmlNodeType.EndElement != reader.NodeType) { AnnotationResource item = (AnnotationResource)Annotation.ResourceSerializer.Deserialize(reader); this._anchors.Add(item); } } reader.Read(); } else if ("Cargos" == reader.LocalName) { Annotation.CheckForNonNamespaceAttribute(reader, "Cargos"); if (!reader.IsEmptyElement) { reader.Read(); while (!("Cargos" == reader.LocalName) || XmlNodeType.EndElement != reader.NodeType) { AnnotationResource item2 = (AnnotationResource)Annotation.ResourceSerializer.Deserialize(reader); this._cargos.Add(item2); } } reader.Read(); } else { if (!("Authors" == reader.LocalName)) { throw new XmlException(SR.Get("InvalidXmlContent", new object[] { "Annotation" })); } Annotation.CheckForNonNamespaceAttribute(reader, "Authors"); if (!reader.IsEmptyElement) { reader.Read(); while (!("Authors" == reader.LocalName) || XmlNodeType.EndElement != reader.NodeType) { if (!("StringAuthor" == reader.LocalName) || XmlNodeType.Element != reader.NodeType) { throw new XmlException(SR.Get("InvalidXmlContent", new object[] { "Annotation" })); } XmlNode xmlNode = xmlDocument.ReadNode(reader); if (!reader.IsEmptyElement) { this._authors.Add(xmlNode.InnerText); } } } reader.Read(); } } } reader.Read(); } finally { EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.DeserializeAnnotationEnd); } }
/// <summary> /// Asks the LocatorManager to find the attached anchor for a certain anchor /// </summary> /// <param name="anchor">the anchor to be resolved</param> /// <param name="attachmentLevel">the attachment level of the resulting attached anchor</param> /// <returns></returns> private object FindAttachedAnchor(AnnotationResource anchor, out AttachmentLevel attachmentLevel) { Invariant.Assert(anchor != null, "Parameter 'anchor' is null."); attachmentLevel = AttachmentLevel.Unresolved; Object attachedAnchor = null; foreach (ContentLocatorBase locator in anchor.ContentLocators) { attachedAnchor = LocatorManager.FindAttachedAnchor(_root, null, locator, out attachmentLevel); if (attachedAnchor != null) break; } return attachedAnchor; }
/// <summary> /// handle the case when an anchor is modified /// </summary> /// <param name="annotation">the annotation which anchor was affected</param> /// <param name="anchor">the modified anchor</param> /// <returns></returns> private AttachedAnnotationChangedEventArgs AnchorModified(Annotation annotation, AnnotationResource anchor) { Invariant.Assert(annotation != null && anchor != null, "Parameter 'annotation' or 'anchor' is null."); AttachedAnnotationChangedEventArgs args = null; AttachmentLevel newAttachmentLevel; bool previouslyAttached = false; // anchor has changed, need to find new attached anchor object newAttachedAnchor = FindAttachedAnchor(anchor, out newAttachmentLevel); // Since we will be modifying this collection, we make a copy of it to iterate on IList<IAttachedAnnotation> annotations = _annotationMap.GetAttachedAnnotations(annotation.Id); IAttachedAnnotation[] list = new IAttachedAnnotation[annotations.Count]; annotations.CopyTo(list, 0); foreach (IAttachedAnnotation attachedAnnotation in list) { if (attachedAnnotation.Anchor == anchor) { previouslyAttached = true; if (newAttachmentLevel != AttachmentLevel.Unresolved) { Invariant.Assert(newAttachedAnchor != null, "AttachedAnnotation with AttachmentLevel != Unresolved should have non-null AttachedAnchor."); object oldAttachedAnchor = attachedAnnotation.AttachedAnchor; AttachmentLevel oldAttachmentLevel = attachedAnnotation.AttachmentLevel; ((AttachedAnnotation)attachedAnnotation).Update(newAttachedAnchor, newAttachmentLevel, null); // Update the full anchor FullyResolveAnchor(attachedAnnotation); // No need to update map - we just changed the AttachedAnnotation in-place args = AttachedAnnotationChangedEventArgs.Modified(attachedAnnotation, oldAttachedAnchor, oldAttachmentLevel); } else { // the new modified anchor doesn't resolve // we need to delete the original attached annotation DoRemoveAttachedAnnotation(attachedAnnotation); args = AttachedAnnotationChangedEventArgs.Deleted(attachedAnnotation); } break; } } // If it wasn't previously attached, but can be resolved now we create an AttachedAnnotation if (!previouslyAttached && newAttachmentLevel != AttachmentLevel.Unresolved && newAttachmentLevel != AttachmentLevel.Incomplete) { Invariant.Assert(newAttachedAnchor != null, "AttachedAnnotation with AttachmentLevel != Unresolved should have non-null AttachedAnchor."); AttachedAnnotation attachedAnnotation = new AttachedAnnotation( this.LocatorManager, annotation, anchor, newAttachedAnchor, newAttachmentLevel); DoAddAttachedAnnotation(attachedAnnotation); args = AttachedAnnotationChangedEventArgs.Added(attachedAnnotation); } return args; }
/// <summary>Initializes a new instance of the <see cref="M:System.Windows.Annotations.AnnotationResourceChangedEventArgs.#ctor(System.Windows.Annotations.Annotation,System.Windows.Annotations.AnnotationAction,System.Windows.Annotations.AnnotationResource)" /> class.</summary> /// <param name="annotation">The annotation that raised the event.</param> /// <param name="action">The action of the event.</param> /// <param name="resource">The <see cref="P:System.Windows.Annotations.Annotation.Anchors" /> or <see cref="P:System.Windows.Annotations.Annotation.Cargos" /> resource of the event.</param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="annotation" /> or <paramref name="action" /> is <see langword="null" />.</exception> /// <exception cref="T:System.ComponentModel.InvalidEnumArgumentException"> /// <paramref name="action" /> is not a valid <see cref="T:System.Windows.Annotations.AnnotationAction" /> value.</exception> // Token: 0x060062B7 RID: 25271 RVA: 0x001BB128 File Offset: 0x001B9328 public AnnotationResourceChangedEventArgs(Annotation annotation, AnnotationAction action, AnnotationResource resource) { if (annotation == null) { throw new ArgumentNullException("annotation"); } if (action < AnnotationAction.Added || action > AnnotationAction.Modified) { throw new InvalidEnumArgumentException("action", (int)action, typeof(AnnotationAction)); } this._annotation = annotation; this._resource = resource; this._action = action; }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors /// <summary> /// Create an instance of AttachedAnnotation. /// </summary> /// <param name="manager">the LocatorManager providing processors for this anchored annotation</param> /// <param name="annotation">the annotation itself</param> /// <param name="anchor">the annotation's anchor represented by the attached anchor</param> /// <param name="attachedAnchor">the attached anchor itself</param> /// <param name="attachmentLevel">the level of the attached anchor</param> internal AttachedAnnotation(LocatorManager manager, Annotation annotation, AnnotationResource anchor, Object attachedAnchor, AttachmentLevel attachmentLevel) : this(manager, annotation, anchor, attachedAnchor, attachmentLevel, null) { }
/// <summary> /// The method sets an instance of the IAttachedAnnotation to the StickyNoteControl. /// It will be called by IAnnotationComponent.AddAttachedAnnotation. /// </summary> /// <param name="attachedAnnotation">The instance of the IAttachedAnnotation</param> private void SetAnnotation(IAttachedAnnotation attachedAnnotation) { SNCAnnotation sncAnnotation = new SNCAnnotation(attachedAnnotation.Annotation); // Retrieve the data type. Then set the StickyNote to correct type. // If we have empty data, we won't change the current StickyNote type. bool hasInkData = sncAnnotation.HasInkData; bool hasTextData = sncAnnotation.HasTextData; if (hasInkData && hasTextData) { throw new ArgumentException(SR.Get(SRID.InvalidStickyNoteAnnotation), "attachedAnnotation"); } else if (hasInkData) { _stickyNoteType = StickyNoteType.Ink; } else if (hasTextData) { _stickyNoteType = StickyNoteType.Text; } // If we already created a Content control, make sure it matches our new type or // gets recreated to match. if (Content != null) { EnsureStickyNoteType(); } //create cargo if it is a new Annotation so it is not considered as new next time if (sncAnnotation.IsNewAnnotation) { AnnotationResource cargo = new AnnotationResource(SNBConstants.MetaResourceName); attachedAnnotation.Annotation.Cargos.Add(cargo); } // Set the internal variables _attachedAnnotation = attachedAnnotation; _attachedAnnotation.Annotation.CargoChanged += new AnnotationResourceChangedEventHandler(OnAnnotationUpdated); _attachedAnnotation.Annotation.AuthorChanged += new AnnotationAuthorChangedEventHandler(OnAuthorUpdated); _sncAnnotation = sncAnnotation; _anchor.AddAttachedAnnotation(attachedAnnotation); // Update all value UpdateSNCWithAnnotation(SNCAnnotation.AllValues); // The internal data is just [....]'ed to the store. So, reset the dirty to false. IsDirty = false; //now check if the SN must be seen if ((_attachedAnnotation.AttachmentLevel & AttachmentLevel.StartPortion) == 0) { //we do not need to show the StickyNote SetValue(UIElement.VisibilityProperty, Visibility.Collapsed); } else { //if it is seen we need to take care about bringing into view when needed RequestBringIntoView += new RequestBringIntoViewEventHandler(OnRequestBringIntoView); } }
/// <summary> /// Deserializes an Annotation from the XmlReader passed in. /// </summary> /// <param name="reader">reader to deserialize from</param> /// <exception cref="ArgumentNullException">reader is null</exception> public void ReadXml(XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } //fire trace event EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.DeserializeAnnotationBegin); XmlDocument doc = null; try { doc = new XmlDocument(); ReadAttributes(reader); if (!reader.IsEmptyElement) { reader.Read(); // Read the remainder of the "Annotation" start tag while (!(XmlNodeType.EndElement == reader.NodeType && AnnotationXmlConstants.Elements.Annotation == reader.LocalName)) { if (AnnotationXmlConstants.Elements.AnchorCollection == reader.LocalName) { CheckForNonNamespaceAttribute(reader, AnnotationXmlConstants.Elements.AnchorCollection); if (!reader.IsEmptyElement) { reader.Read(); // Reads the "Anchors" start tag while (!(AnnotationXmlConstants.Elements.AnchorCollection == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) { AnnotationResource anchor = (AnnotationResource)ResourceSerializer.Deserialize(reader); _anchors.Add(anchor); } } reader.Read(); // Reads the "Anchors" end tag (or whole tag if it was empty) } else if (AnnotationXmlConstants.Elements.CargoCollection == reader.LocalName) { CheckForNonNamespaceAttribute(reader, AnnotationXmlConstants.Elements.CargoCollection); if (!reader.IsEmptyElement) { reader.Read(); // Reads the "Cargos" start tag while (!(AnnotationXmlConstants.Elements.CargoCollection == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) { AnnotationResource cargo = (AnnotationResource)ResourceSerializer.Deserialize(reader); _cargos.Add(cargo); } } reader.Read(); // Reads the "Cargos" end tag (or whole tag if it was empty) } else if (AnnotationXmlConstants.Elements.AuthorCollection == reader.LocalName) { CheckForNonNamespaceAttribute(reader, AnnotationXmlConstants.Elements.AuthorCollection); if (!reader.IsEmptyElement) { reader.Read(); // Reads the "Authors" start tag while (!(AnnotationXmlConstants.Elements.AuthorCollection == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) { if (!(AnnotationXmlConstants.Elements.StringAuthor == reader.LocalName && XmlNodeType.Element == reader.NodeType)) { throw new XmlException(SR.Get(SRID.InvalidXmlContent, AnnotationXmlConstants.Elements.Annotation)); } XmlNode node = doc.ReadNode(reader); // Reads the entire "StringAuthor" tag if (!reader.IsEmptyElement) { _authors.Add(node.InnerText); } } } reader.Read(); // Reads the "Authors" end tag (or whole tag if it was empty) } else { // The annotation must contain some invalid content which is not part of the schema. throw new XmlException(SR.Get(SRID.InvalidXmlContent, AnnotationXmlConstants.Elements.Annotation)); } } } reader.Read(); // Read the end of the "Annotation" tag (or the whole tag if its empty) } finally { //fire trace event EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.DeserializeAnnotationEnd); } }
/// <summary> /// Find the specified data in a cargo. /// </summary> /// <param name="token">The specified data</param> /// <param name="cargo">The cargo which we are searhing in</param> /// <returns>The data object or null</returns> private static object FindContent(XmlToken token, AnnotationResource cargo) { object content = null; XmlElement root = SNCAnnotation.FindRootXmlElement(token, cargo); // If we found the root node, we should use XPath to query the node which contains the corresponding data. // The StickyNoteControl's xml schema can be found // in http://tabletpc/longhorn/Specs/WinFX%20StickyNoteControl%20M8.1.mht#_Toc79371211 if (root != null) { switch (token) { case XmlToken.Text: case XmlToken.Ink: return root; case XmlToken.IsExpanded: case XmlToken.ZOrder: case XmlToken.Top: case XmlToken.Left: case XmlToken.XOffset: case XmlToken.YOffset: case XmlToken.Width: case XmlToken.Height: return root.GetAttributeNode(GetXmlName(token), AnnotationXmlConstants.Namespaces.BaseSchemaNamespace); default: Debug.Assert(false); break; } } return content; }
/// <summary> /// The method returns the root node which contains the specified data in a cargo. /// </summary> /// <param name="token">The specified data</param> /// <param name="cargo">The specified cargo</param> /// <returns>The root node or null</returns> private static XmlElement FindRootXmlElement(XmlToken token, AnnotationResource cargo) { Debug.Assert(cargo != null); XmlElement element = null; string xmlName = string.Empty; // Get the xml name of the root node switch (token) { case XmlToken.Text: case XmlToken.Ink: xmlName = GetXmlName(token); break; case XmlToken.MetaData: case XmlToken.IsExpanded: case XmlToken.Width: case XmlToken.Height: case XmlToken.Top: case XmlToken.Left: case XmlToken.XOffset: case XmlToken.YOffset: case XmlToken.ZOrder: xmlName = GetXmlName(XmlToken.MetaData); break; default: Debug.Assert(false); break; } // Search the root in the cargo's contents. foreach (XmlElement node in cargo.Contents) { if (node.Name.Equals(xmlName)) { element = node; break; } } return element; }
/// <summary> /// Returns the AnnotationResource and the XML root for the given token from the passed in annotation. /// If the cargo or root do not exist they are created but not added to the annotation. The newCargo /// and newRoot flags specify whether they were created. The caller must use these to add the items /// to the annotation after they are done with their modifications. /// </summary> /// <param name="annotation">the current annotation</param> /// <param name="token">the token to be processed</param> /// <param name="cargo">the cargo for the token</param> /// <param name="root">the root XML element</param> /// <param name="newCargo">means a new root and new cargo was created. the root was already added to the cargo but the cargo was not added to the annotation</param> /// <param name="newRoot">means a new root was created. it has not been added to the cargo.</param> private static void GetCargoAndRoot( SNCAnnotation annotation, XmlToken token, out AnnotationResource cargo, out XmlElement root, out bool newCargo, out bool newRoot) { Invariant.Assert(annotation != null, "Annotation is null."); Invariant.Assert((token & (AllValues | XmlToken.MetaData)) != 0, "No token specified."); string cargoName = GetCargoName(token); newRoot = false; newCargo = false; cargo = annotation.FindCargo(cargoName); // Cargo exists if (cargo != null) { root = FindRootXmlElement(token, cargo); // Uncommon situation - cargo created without root XmlElement if (root == null) { newRoot = true; XmlDocument xmlDoc = new XmlDocument(); root = xmlDoc.CreateElement(GetXmlName(token), AnnotationXmlConstants.Namespaces.BaseSchemaNamespace); // Don't add it to the cargo yet - wait until all the // values are set on it } } else { newCargo = true; cargo = new AnnotationResource(cargoName); XmlDocument xmlDoc = new XmlDocument(); root = xmlDoc.CreateElement(GetXmlName(token), AnnotationXmlConstants.Namespaces.BaseSchemaNamespace); // Since the cargo is new, its safe to add the root to it // No events will make it to the annotation yet cargo.Contents.Add(root); } }
public AnnotationResourceChangedEventArgs(Annotation annotation, AnnotationAction action, AnnotationResource resource) { }
/// <summary> /// handle the case when a new anchor is added to the annotation /// </summary> /// <param name="annotation">the annotation which anchor was affected</param> /// <param name="anchor">the deleted anchor</param> /// <returns></returns> private AttachedAnnotationChangedEventArgs AnchorAdded(Annotation annotation, AnnotationResource anchor) { Invariant.Assert(annotation != null && anchor != null, "Parameter 'annotation' or 'anchor' is null."); AttachedAnnotationChangedEventArgs args = null; AttachmentLevel attachmentLevel; object attachedAnchor = FindAttachedAnchor(anchor, out attachmentLevel); if (attachmentLevel != AttachmentLevel.Unresolved && attachmentLevel != AttachmentLevel.Incomplete) { Invariant.Assert(attachedAnchor != null, "Must have a valid attached anchor."); AttachedAnnotation attachedAnnotation = new AttachedAnnotation( this.LocatorManager, annotation, anchor, attachedAnchor, attachmentLevel); DoAddAttachedAnnotation(attachedAnnotation); args = AttachedAnnotationChangedEventArgs.Added(attachedAnnotation); } return args; }
/// <summary> /// handle the case when an anchor is removed from the annotation /// </summary> /// <param name="annotation">the annotation which anchor was affected</param> /// <param name="anchor">the removed anchor</param> /// <returns>EventArgs to use when firing an AttachedAnnotationChanged event</returns> private AttachedAnnotationChangedEventArgs AnchorRemoved(Annotation annotation, AnnotationResource anchor) { Invariant.Assert(annotation != null && anchor != null, "Parameter 'annotation' or 'anchor' is null."); AttachedAnnotationChangedEventArgs args = null; IList<IAttachedAnnotation> annotations = _annotationMap.GetAttachedAnnotations(annotation.Id); if (annotations.Count > 0) { // Since we will be modifying this collection, we make a copy of it to iterate on IAttachedAnnotation[] list = new IAttachedAnnotation[annotations.Count]; annotations.CopyTo(list, 0); foreach (IAttachedAnnotation attachedAnnotation in list) { if (attachedAnnotation.Anchor == anchor) { DoRemoveAttachedAnnotation(attachedAnnotation); args = AttachedAnnotationChangedEventArgs.Deleted(attachedAnnotation); break; } } } return args; }