コード例 #1
0
ファイル: XslReader.cs プロジェクト: zanyants/mvp.xml
			private void ExpandBuffer()
			{
				// Buffer is too smal for this amount of attributes.
				Debug.Assert(writePos == readStartPos + buffer.Length, "no space to write next token");
				Debug.Assert(writePos == readEndPos, "all tokens ware read");
				int newMask = (mask << 1) | 1;
				XmlToken[] newBuffer = new XmlToken[newMask + 1];
				for (int i = readStartPos; i < writePos; i++)
				{
					newBuffer[i & newMask] = buffer[i & mask];
				}
				buffer = newBuffer;
				mask = newMask;
				Debug.Assert(writePos < readStartPos + buffer.Length, "we should have now space to next write token");
			}
コード例 #2
0
        /// <summary>
        /// Update the metadata tokens specified in token.
        /// </summary>
        private static void UpdateMetaData(XmlToken token, StickyNoteControl snc, SNCAnnotation sncAnnotation)
        {
            bool newCargo, newRoot;
            AnnotationResource cargo;
            XmlElement root;

            GetCargoAndRoot(sncAnnotation, XmlToken.MetaData, out cargo, out root, out newCargo, out newRoot);

            // Update Expanded
            if ((token & XmlToken.IsExpanded) != 0)
            {
                bool expanded = snc.IsExpanded;
                sncAnnotation.UpdateAttribute(root, XmlToken.IsExpanded, expanded.ToString(CultureInfo.InvariantCulture));
            }

            // Update Height
            if ((token & XmlToken.Height) != 0)
            {
                Debug.Assert(snc.IsExpanded);
                double height = (double)snc.GetValue(FrameworkElement.HeightProperty);
                sncAnnotation.UpdateAttribute(root, XmlToken.Height, height.ToString(CultureInfo.InvariantCulture));
            }

            // Update Width
            if ((token & XmlToken.Width) != 0)
            {
                Debug.Assert(snc.IsExpanded);
                double width = (double)snc.GetValue(FrameworkElement.WidthProperty);
                sncAnnotation.UpdateAttribute(root, XmlToken.Width, width.ToString(CultureInfo.InvariantCulture));
            }

            // Update Left
            if ((token & XmlToken.Left) != 0)
            {
                double left = snc.PositionTransform.X;
                // All 'left' values are persisted assuming two things:
                //  1) the top-left corner (visually) of the StickyNote is the origin of its coordinate space
                //  2) the positive x-axis of its parent is to the right
                // This flag signals that we have a positive x-axis to the left and our
                // top-right corner (visually) is our origin.  So we need to flip the
                // value before persisting it.
                if (snc.FlipBothOrigins)
                {
                    left = -(left + snc.Width);
                }
                sncAnnotation.UpdateAttribute(root, XmlToken.Left, left.ToString(CultureInfo.InvariantCulture));
            }

            // Update Top
            if ((token & XmlToken.Top) != 0)
            {
                sncAnnotation.UpdateAttribute(root, XmlToken.Top, snc.PositionTransform.Y.ToString(CultureInfo.InvariantCulture));
            }

            // Update XOffset
            if ((token & XmlToken.XOffset) != 0)
            {
                sncAnnotation.UpdateAttribute(root, XmlToken.XOffset, snc.XOffset.ToString(CultureInfo.InvariantCulture));
            }

            // Update YOffset
            if ((token & XmlToken.YOffset) != 0)
            {
                sncAnnotation.UpdateAttribute(root, XmlToken.YOffset, snc.YOffset.ToString(CultureInfo.InvariantCulture));
            }

            // Update ZOrder
            if ((token & XmlToken.ZOrder) != 0)
            {
                sncAnnotation.UpdateAttribute(root, XmlToken.ZOrder, ((IAnnotationComponent)snc).ZOrder.ToString(CultureInfo.InvariantCulture));
            }

            if (newRoot)
            {
                cargo.Contents.Add(root);
            }
            if (newCargo)
            {
                sncAnnotation._annotation.Cargos.Add(cargo);
            }
        }
コード例 #3
0
ファイル: XslReader.cs プロジェクト: zanyants/mvp.xml
			public virtual void Write(XmlNodeType nodeType, QName name, string value)
			{
				Debug.Assert(writePos <= buffer.Length);
				if (writePos == buffer.Length)
				{
					XmlToken[] temp = new XmlToken[buffer.Length * 2];
					buffer.CopyTo(temp, 0);
					buffer = temp;
				}
				Debug.Assert(writePos < buffer.Length);
				XmlToken.Set(ref buffer[writePos], nodeType, name, value);
				writePos++;
			}
コード例 #4
0
        /// <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;
        }
コード例 #5
0
        // Update ink data from/to SNC.
        private void UpdateContent(StickyNoteControl snc, bool updateAnnotation, XmlToken token)
        {
            Invariant.Assert(snc != null, "Sticky Note Control is null.");
            Invariant.Assert((token & AllContents) != 0, "No token specified.");

            StickyNoteContentControl contentControl = snc.Content;

            // Template hasn't been applied yet.  Once it has the content control will then be setup.
            if (contentControl == null)
            {
                return;
            }

            // Check whether the annotation data matches the content control.
            if ((token == XmlToken.Ink && contentControl.Type != StickyNoteType.Ink)
                || (token == XmlToken.Text && contentControl.Type != StickyNoteType.Text))
            {
                Debug.Assert(false, "The annotation data does match with the current content control in StickyNote");
                return;
            }

            XmlElement root = null;

            if (updateAnnotation)
            {
                // Update annotation from SNC

                AnnotationResource cargo = null;
                bool newRoot = false;
                bool newCargo = false;

                // Check if the text is empty.
                if (!contentControl.IsEmpty)
                {
                    GetCargoAndRoot(this, token, out cargo, out root, out newCargo, out newRoot);
                    contentControl.Save(root);
                }
                else
                {
                    string cargoName = GetCargoName(token);
                    cargo = FindCargo(cargoName);
                    if (cargo != null)
                    {
                        _annotation.Cargos.Remove(cargo);
                        _cachedXmlElements.Remove(token);
                    }
                }
                if (newRoot)
                {
                    Invariant.Assert(root != null, "XmlElement should have been created.");
                    Invariant.Assert(cargo != null, "Cargo should have been retrieved.");
                    cargo.Contents.Add(root);
                }
                if (newCargo)
                {
                    Invariant.Assert(cargo != null, "Cargo should have been created.");
                    _annotation.Cargos.Add(cargo);
                }
            }
            else
            {
                // Update SNC from annotation

                // Check if we have the text data in the xml store.
                XmlElement node = (XmlElement)FindData(token);
                if (node != null)
                {
                    contentControl.Load(node);
                }
                else
                {
                    if (!contentControl.IsEmpty)
                    {
                        contentControl.Clear();
                    }
                }
            }
        }
コード例 #6
0
        /// <summary>
        /// This method will update this StickyNoteControl data based on the internal annotation variable.
        /// </summary>
        /// <param name="tokens">The data need to be updated</param>
        private void UpdateSNCWithAnnotation(XmlToken tokens)
        {
            if (_sncAnnotation != null)
            {
                //fire trace event
                EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.UpdateSNCWithAnnotationBegin);

                // Now, we are going to update this StickyNoteControl. We will get notified for the data being changed.
                // we don't want to update our internal annotation because for the data changes which are coming
                // from the annotation itself. So, we lock our internal locker.
                using (LockHelper.AutoLocker locker = new LockHelper.AutoLocker(InternalLocker, LockHelper.LockFlag.DataChanged))
                {
                    SNCAnnotation.UpdateStickyNoteControl(tokens, this, _sncAnnotation);
                }

                //fire trace event
                EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.UpdateSNCWithAnnotationEnd);
            }
        }
コード例 #7
0
        /// <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;
        }
コード例 #8
0
 /// <summary>
 /// This static method returns the Xml name for the specified token.
 /// </summary>
 /// <param name="token">A specified token</param>
 /// <returns>The name for the Xml node</returns>
 private static string GetXmlName(XmlToken token)
 {
     return s_xmlTokeFullNames[token];
 }
コード例 #9
0
        /// <summary>
        /// This method is called by the static constructor to set up the Xml name dictionary.
        /// </summary>
        /// <param name="token">A specified token</param>
        private static void AddXmlTokenNames(XmlToken token)
        {
            // Conver the enum value to the string first.
            string xmlName = token.ToString();

            // Depending on the data, we add the proper prefix to the full name.
            switch (token)
            {
                // The element names should be qualified
                case XmlToken.MetaData:
                case XmlToken.Text:
                case XmlToken.Ink:
                    {
                        s_xmlTokeFullNames.Add(token, AnnotationXmlConstants.Prefixes.BaseSchemaPrefix + ":" + xmlName);
                    }
                    break;

                    //the attribute names should be local
                case XmlToken.Left:
                case XmlToken.Top:
                case XmlToken.XOffset:
                case XmlToken.YOffset:
                case XmlToken.Width:
                case XmlToken.Height:
                case XmlToken.IsExpanded:
                case XmlToken.ZOrder:
                default:
                    {
                        s_xmlTokeFullNames.Add(token, xmlName);
                    }
                    break;
            }
        }
コード例 #10
0
        /// <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);
            }
        }
コード例 #11
0
        /// <summary>
        /// Updates the value of the specified token on the specified XmlElement.
        /// If the value is the same, no update is made.  If the new value is null
        /// the attribute is removed.
        /// </summary>
        private void UpdateAttribute(XmlElement root, XmlToken token, string value)
        {
            string name = GetXmlName(token);

            XmlNode oldValue = root.GetAttributeNode(name, AnnotationXmlConstants.Namespaces.BaseSchemaNamespace);
            if (oldValue == null)
            {
                if (value == null)
                    return;
                else
                    root.SetAttribute(name, AnnotationXmlConstants.Namespaces.BaseSchemaNamespace, value);
            }
            else
            {
                if (value == null)
                    root.RemoveAttribute(name, AnnotationXmlConstants.Namespaces.BaseSchemaNamespace);
                else if (oldValue.Value != value)
                    root.SetAttribute(name, AnnotationXmlConstants.Namespaces.BaseSchemaNamespace, value);
            }
        }
コード例 #12
0
        /// <summary>
        /// Find the specified Annotation data
        /// </summary>
        /// <param name="token">A flag which is corresponding to the annotation data</param>
        /// <returns>The annotation data or null</returns>
        private object FindData(XmlToken token)
        {
            // Assume that we can't find any thing.
            object ret = null;

            // First, check if we have the data cached.
            if (_cachedXmlElements.ContainsKey(token))
            {
                ret = _cachedXmlElements[token];
            }
            else
            {
                // Then, we try to search the data in the current annotation.
                AnnotationResource cargo = FindCargo(GetCargoName(token));
                if (cargo != null)
                {
                    ret = SNCAnnotation.FindContent(token, cargo);

                    // If we found the data in annotation, we go ahead cache it.
                    if (ret != null)
                    {
                        _cachedXmlElements.Add(token, ret);
                    }
                }
            }

            return ret;
        }
コード例 #13
0
        /// <summary>
        /// This static method will update a StickyNoteControl object with the specified data in an Annotation
        /// </summary>
        /// <param name="token">A flag which indicates the data needs to be updated. The flag can be combinated with the any valid bits.</param>
        /// <param name="snc">A StickyNoteControl instance</param>
        /// <param name="sncAnnotation">An SNCAnnotation object which contains a CAF annotation object</param>
        public static void UpdateStickyNoteControl(XmlToken token, StickyNoteControl snc, SNCAnnotation sncAnnotation)
        {
            Invariant.Assert((token & AllValues) != 0, "No token specified.");
            Invariant.Assert(snc != null, "Sticky Note Control is null.");
            Invariant.Assert(sncAnnotation != null, "Annotation is null.");

            // 




            XmlAttribute node;

            // Update Ink
            if ((token & XmlToken.Ink) != 0 && sncAnnotation.HasInkData)
            {
                sncAnnotation.UpdateContent(snc, false, XmlToken.Ink);
            }

            // Update Text
            if ((token & XmlToken.Text) != 0 && sncAnnotation.HasTextData)
            {
                sncAnnotation.UpdateContent(snc, false, XmlToken.Text);
            }

            // Update Author
            if ((token & XmlToken.Author) != 0)
            {
                int nCount = sncAnnotation._annotation.Authors.Count;
                // Get the culture specific text separator.
                string listSeparator = snc.Language.GetSpecificCulture().TextInfo.ListSeparator;
                string authors = string.Empty;
                for (int i = 0; i < nCount; i++)
                {
                    if (i != 0)
                    {
                        authors += listSeparator + sncAnnotation._annotation.Authors[i];
                    }
                    else
                    {
                        authors += sncAnnotation._annotation.Authors[i];
                    }
                }

                // Setting the author property will cause the UI to update
                snc.SetValue(StickyNoteControl.AuthorPropertyKey, authors);
            }

            // Update Height
            if ((token & XmlToken.Height) != 0)
            {
                node = (XmlAttribute)sncAnnotation.FindData(XmlToken.Height);
                if (node != null)
                {
                    double height = Convert.ToDouble(node.Value, CultureInfo.InvariantCulture);
                    snc.SetValue(FrameworkElement.HeightProperty, height);
                }
                else
                {
                    snc.ClearValue(FrameworkElement.HeightProperty);
                }
            }

            // Update Width
            if ((token & XmlToken.Width) != 0)
            {
                node = (XmlAttribute)sncAnnotation.FindData(XmlToken.Width);
                if (node != null)
                {
                    double width = Convert.ToDouble(node.Value, CultureInfo.InvariantCulture);
                    snc.SetValue(FrameworkElement.WidthProperty, width);
                }
                else
                {
                    snc.ClearValue(FrameworkElement.WidthProperty);
                }
            }

            // Update IsExpanded
            if ((token & XmlToken.IsExpanded) != 0)
            {
                node = (XmlAttribute)sncAnnotation.FindData(XmlToken.IsExpanded);
                if (node != null)
                {
                    bool expanded = Convert.ToBoolean(node.Value, CultureInfo.InvariantCulture);
                    snc.IsExpanded = expanded;
                }
                else
                {
                    snc.ClearValue(StickyNoteControl.IsExpandedProperty);
                }
            }

            // Update ZOrder
            if ((token & XmlToken.ZOrder) != 0)
            {
                node = (XmlAttribute)sncAnnotation.FindData(XmlToken.ZOrder);
                if (node != null)
                {
                    ((IAnnotationComponent)snc).ZOrder = Convert.ToInt32(node.Value, CultureInfo.InvariantCulture);
                }
            }

            // Update Position
            if ((token & PositionValues) != 0)
            {
                TranslateTransform transform = new TranslateTransform();
                if ((token & XmlToken.Left) != 0)
                {
                    node = (XmlAttribute)sncAnnotation.FindData(XmlToken.Left);
                    if (node != null)
                    {
                        double left = Convert.ToDouble(node.Value, CultureInfo.InvariantCulture);
                        // All 'left' values are persisted assuming two things:
                        //  1) the top-left corner (visually) of the StickyNote is the origin of its coordinate space
                        //  2) the positive x-axis of its parent is to the right
                        // This flag signals that we have a positive x-axis to the left and our
                        // top-right corner (visually) is our origin.  So we need to flip the
                        // value before using it.
                        if (snc.FlipBothOrigins)
                        {
                            left = -(left + snc.Width);
                        }
                        transform.X = left;
                    }
                }

                if ((token & XmlToken.Top) != 0)
                {
                    node = (XmlAttribute)sncAnnotation.FindData(XmlToken.Top);
                    if (node != null)
                    {
                        double top = Convert.ToDouble(node.Value, CultureInfo.InvariantCulture);
                        transform.Y = top;
                    }
                }

                // Now, we update the StickyNote offset
                if ((token & XmlToken.XOffset) != 0)
                {
                    node = (XmlAttribute)sncAnnotation.FindData(XmlToken.XOffset);
                    if (node != null)
                    {
                        snc.XOffset = Convert.ToDouble(node.Value, CultureInfo.InvariantCulture);
                    }
                }

                if ((token & XmlToken.YOffset) != 0)
                {
                    node = (XmlAttribute)sncAnnotation.FindData(XmlToken.YOffset);
                    if (node != null)
                    {
                        snc.YOffset = Convert.ToDouble(node.Value, CultureInfo.InvariantCulture);
                    }
                }

                // Set the adorner layer transform.
                snc.PositionTransform = transform;
            }
        }
コード例 #14
0
        /// <summary>
        /// This method will update this internal annotation based on this StickyNoteControl.
        /// </summary>
        /// <param name="tokens"></param>
        private void UpdateAnnotationWithSNC(XmlToken tokens)
        {
            // Check if we have an annotation attached.
            // Also we don't want to update the annotation when the data changes are actually caused by UpdateSNCWithAnnotation.
            if (_sncAnnotation != null &&
                !InternalLocker.IsLocked(LockHelper.LockFlag.DataChanged))
            {
                //fire trace event
                EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.UpdateAnnotationWithSNCBegin);

                // Now, we are going to update the annotation. Since we will get notified from the annotation store,
                // we don't want to update our internal annotation if the change has been made by this instance.
                // Here we lock the internal locker.
                using (LockHelper.AutoLocker locker = new LockHelper.AutoLocker(InternalLocker, LockHelper.LockFlag.AnnotationChanged))
                {
                    // Now, update the attached annotation.
                    SNCAnnotation.UpdateAnnotation(tokens, this, _sncAnnotation);
                }
                //fire trace event
                EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.UpdateAnnotationWithSNCEnd);
            }
        }
コード例 #15
0
ファイル: XslReader.cs プロジェクト: zanyants/mvp.xml
			// it seams that it faster to set fields of structure in one call.
			// This trick is workaround of the C# limitation of declaring variable as ref to a struct.
			public static void Set(ref XmlToken evnt, XmlNodeType nodeType, QName name, string value)
			{
				evnt.NodeType = nodeType;
				evnt.Name = name;
				evnt.Value = value;
			}
コード例 #16
0
 /// <summary>
 /// Return the cargo name which hosts the specified data.
 /// </summary>
 /// <param name="token">The specified data</param>
 /// <returns>The host cargo name</returns>
 private static string GetCargoName(XmlToken token)
 {
     string cargoName;
     switch (token)
     {
         // Those tokens use *snc* prefix.
         case XmlToken.MetaData:
         case XmlToken.Left:
         case XmlToken.Top:
         case XmlToken.XOffset:
         case XmlToken.YOffset:
         case XmlToken.Width:
         case XmlToken.Height:
         case XmlToken.IsExpanded:
         case XmlToken.ZOrder:
             {
                 cargoName = SNBConstants.MetaResourceName;
             }
             break;
         // Those tokens use *media* prefix.
         case XmlToken.Text:
             {
                 cargoName = SNBConstants.TextResourceName;
             }
             break;
         case XmlToken.Ink:
             {
                 cargoName = SNBConstants.InkResourceName;
             }
             break;
         default:
             {
                 cargoName = string.Empty;
                 Debug.Assert(false);
             }
             break;
     }
     return cargoName;
 }
コード例 #17
0
ファイル: XslReader.cs プロジェクト: zanyants/mvp.xml
			public static void Get(ref XmlToken evnt, out XmlNodeType nodeType, out QName name, out string value)
			{
				nodeType = evnt.NodeType;
				name = evnt.Name;
				value = evnt.Value;
			}
コード例 #18
0
        //-------------------------------------------------------------------------------
        //
        // Public Methods
        //
        //-------------------------------------------------------------------------------

        #region Public Methods

        /// <summary>
        /// This static method will update an Annotation object with the specified data in a StickyNoteControl
        /// </summary>
        /// <param name="token">A flag which indicates the data needs to be updated. The flag can be combinated with the any valid bits.</param>
        /// <param name="snc">A StickyNoteControl instance</param>
        /// <param name="sncAnnotation">An SNCAnnotation object which contains a CAF annotation object</param>
        public static void UpdateAnnotation(XmlToken token, StickyNoteControl snc, SNCAnnotation sncAnnotation)
        {
            AnnotationService service = null;
            bool autoFlush = false;
            try
            {
                service = AnnotationService.GetService(((IAnnotationComponent)snc).AnnotatedElement);
                if (service != null && service.Store != null)
                {
                    autoFlush = service.Store.AutoFlush;
                    // Temporarily turn off autoflush until we are done
                    // updating all the necessary values
                    service.Store.AutoFlush = false;
                }

                Debug.Assert((token & AllValues) != 0);

                // Update Ink
                if ((token & XmlToken.Ink) != 0 && snc.Content.Type == StickyNoteType.Ink)
                {
                    sncAnnotation.UpdateContent(snc, true, XmlToken.Ink);
                }

                // Update Text
                if ((token & XmlToken.Text) != 0 && snc.Content.Type == StickyNoteType.Text)
                {
                    sncAnnotation.UpdateContent(snc, true, XmlToken.Text);
                }


                // Update MetaData
                if ((token & NegativeAllContents) != 0)
                {
                    UpdateMetaData(token, snc, sncAnnotation);
                }
            }
            finally
            {
                if (service != null && service.Store != null)
                {
                    // If auto flush was true before, setting it to true again should cause a flush.
                    service.Store.AutoFlush = autoFlush;
                }
            }
        }