Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Framework / MS / Internal / Annotations / Component / HighlightComponent.cs / 1305600 / HighlightComponent.cs
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description: AnnotationComponent that visualizes highlights
//
// History:
// 01/31/2005 ssimova - Created
//
//---------------------------------------------------------------------------
using System;
using MS.Internal;
using System.Diagnostics;
using System.Collections;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Media;
using System.Windows.Shapes;
using MS.Internal.Text;
using System.Xml;
using System.IO;
using System.Windows.Annotations;
using System.Reflection;
using System.Windows.Annotations.Storage;
using System.Windows.Controls;
using MS.Internal.Annotations.Anchoring;
using MS.Utility;
namespace MS.Internal.Annotations.Component
{
// Highlight rendering for the Annotation highlight and sticky note anchor.
// TBD
internal class HighlightComponent : Canvas, IAnnotationComponent, IHighlightRange
{
#region Constructor
///
/// Creates a new instance of the HighlightComponent
///
public HighlightComponent()
{
}
///
/// Creates a new instance of the HighlightComponent with
/// nondefault priority and type;
///
/// component priority
/// if true - highlight only content of tables, figures and floaters
/// component type
public HighlightComponent(int priority, bool highlightContent, XmlQualifiedName type)
: base()
{
if (type == null)
{
throw new ArgumentNullException("type");
}
_priority = priority;
_type = type;
_highlightContent = highlightContent;
}
#endregion Constructor
#region Public Properties
///
/// Return a copy of the list of IAttachedAnnotations held by this component
///
public IList AttachedAnnotations
{
get
{
ArrayList list = new ArrayList();
if (_attachedAnnotation != null)
{
list.Add(_attachedAnnotation);
}
return list;
}
}
///
/// Sets and gets the context this annotation component is hosted in.
///
/// Context this annotation component is hosted in
public PresentationContext PresentationContext
{
get
{
return _presentationContext;
}
set
{
_presentationContext = value;
}
}
///
/// Sets and gets the Z-order of this component. NOP -
/// Highlight does not have Z-order
///
/// Context this annotation component is hosted in
public int ZOrder
{
get
{
return -1;
}
set
{
}
}
///
/// The annotation type name
///
public static XmlQualifiedName TypeName
{
get
{
return _name;
}
}
///
/// gets and sets the default backgroud color for the highlight
///
public Color DefaultBackground
{
get
{
return _defaultBackroundColor;
}
set
{
_defaultBackroundColor = value;
}
}
///
/// gets and sets the default foregroud color for the highlight
///
public Color DefaultActiveBackground
{
get
{
return _defaultActiveBackgroundColor;
}
set
{
_defaultActiveBackgroundColor = value;
}
}
///
/// Highlight color
///
public Brush HighlightBrush
{
set
{
SetValue(HighlightComponent.HighlightBrushProperty, value);
}
}
//those properies are exposed to allow external components like StickyNote to synchronize their color
// with Highlight colors
public static DependencyProperty HighlightBrushProperty = DependencyProperty.Register("HighlightBrushProperty", typeof(Brush), typeof(HighlightComponent));
///
/// Returns the one element the annotation component is attached to.
///
///
/// When the value is set to true - the AnnotatedElement content has changed -
/// save the value and invalidate the visual, so we can recalculate the geometry.
/// The value is set to false when the geometry is synced with the content
///
public bool IsDirty
{
get
{
return _isDirty;
}
set
{
_isDirty = value;
if (value)
InvalidateChildren();
}
}
#endregion Public Properties
#region Public Methods
///
/// The HighlightComponent uses built-in highlight rendering, so no transformation is needed
///
/// Transform to the AnnotatedElement.
/// Transform to the annotation component
public GeneralTransform GetDesiredTransform(GeneralTransform transform)
{
return transform;
}
///
/// Add an attached annotation to the component. The attached anchor will be used to add
/// a highlight to the appropriate TextContainer
///
/// The attached annotation to be added to the component
public void AddAttachedAnnotation(IAttachedAnnotation attachedAnnotation)
{
if (_attachedAnnotation != null)
{
throw new ArgumentException(SR.Get(SRID.MoreThanOneAttachedAnnotation));
}
//fire trace event
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.AddAttachedHighlightBegin);
//check input data and retrieve the TextContainer
ITextContainer textContainer = CheckInputData(attachedAnnotation);
TextAnchor textAnchor = attachedAnnotation.AttachedAnchor as TextAnchor;
//Get highlight Colors from the cargo. For undefined Colors the default values are used
GetColors(attachedAnnotation.Annotation, out _background, out _selectedBackground);
_range = textAnchor;
Invariant.Assert(textContainer.Highlights != null, "textContainer.Highlights is null");
//get or create AnnotationHighlightLayer in the textContainer
AnnotationHighlightLayer highlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
if (highlightLayer == null)
{
highlightLayer = new AnnotationHighlightLayer();
textContainer.Highlights.AddLayer(highlightLayer);
}
//save the attached annotation
_attachedAnnotation = attachedAnnotation;
//register for cargo changes
_attachedAnnotation.Annotation.CargoChanged += new AnnotationResourceChangedEventHandler(OnAnnotationUpdated);
//add this highlight range
highlightLayer.AddRange(this);
HighlightBrush = new SolidColorBrush(_background);
IsHitTestVisible = false;
//fire trace event
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.AddAttachedHighlightEnd);
}
///
/// Remove an attached annotation from the component
///
/// The attached annotation to be removed from the component
public void RemoveAttachedAnnotation(IAttachedAnnotation attachedAnnotation)
{
if (attachedAnnotation == null)
{
throw new ArgumentNullException("attachedAnnotation");
}
if (attachedAnnotation != _attachedAnnotation)
{
throw new ArgumentException(SR.Get(SRID.InvalidAttachedAnnotation), "attachedAnnotation");
}
Invariant.Assert(_range != null, "null highlight range");
//fire trace event
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.RemoveAttachedHighlightBegin);
//check input data and retrieve the TextContainer
ITextContainer textContainer = CheckInputData(attachedAnnotation);
Invariant.Assert(textContainer.Highlights != null, "textContainer.Highlights is null");
//get AnnotationHighlightLayer in the textContainer
AnnotationHighlightLayer highlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
Invariant.Assert(highlightLayer != null, "AnnotationHighlightLayer is not initialized");
//unregister of cargo changes
_attachedAnnotation.Annotation.CargoChanged -= new AnnotationResourceChangedEventHandler(OnAnnotationUpdated);
highlightLayer.RemoveRange(this);
//highlight is removed - remove the attached annotation and the data
_attachedAnnotation = null;
//fire trace event
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.RemoveAttachedHighlightEnd);
}
///
/// Modify an attached annotation that is held by the component
///
/// The attached annotation after modification
/// The attached anchor previously associated with the attached annotation.
/// The previous attachment level of the attached annotation.
public void ModifyAttachedAnnotation(IAttachedAnnotation attachedAnnotation, object previousAttachedAnchor, AttachmentLevel previousAttachmentLevel)
{
throw new NotSupportedException(SR.Get(SRID.NotSupported));
}
///
/// Sets highlight color to active/inactive
/// true - activate, false = deactivate
///
public void Activate(bool active)
{
//return if the state is unchanged
if (_active == active)
return;
//get the highlight layer
if (_attachedAnnotation == null)
{
throw new InvalidOperationException(SR.Get(SRID.NoAttachedAnnotationToModify));
}
TextAnchor textAnchor = _attachedAnnotation.AttachedAnchor as TextAnchor;
Invariant.Assert(textAnchor != null, "AttachedAnchor is not a text anchor");
//this should be in a fixed or flow textcontainer
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
//get AnnotationHighlightLayer in the textContainer
AnnotationHighlightLayer highlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
Invariant.Assert(highlightLayer != null, "AnnotationHighlightLayer is not initialized");
highlightLayer.ActivateRange(this, active);
_active = active;
if (active)
HighlightBrush = new SolidColorBrush(_selectedBackground);
else
HighlightBrush = new SolidColorBrush(_background);
}
#endregion Public Methods
//-----------------------------------------------------
//
// IHighlightRange implementation
//
//-----------------------------------------------------
#region IHighlightRange implementation
#region Internal Methods
///
/// Adds a new shape to the children of the corresponding visual
///
/// the new child
void IHighlightRange.AddChild(Shape child)
{
Children.Add(child);
}
///
/// Removes a shape from the children of the corresponding visual
///
/// the new child
void IHighlightRange.RemoveChild(Shape child)
{
Children.Remove(child);
}
#endregion Internal Methods
//------------------------------------------------------
//
// Internal properties
//
//-----------------------------------------------------
#region Internal Properties
///
/// Highlight Background color
///
Color IHighlightRange.Background
{
get
{
return _background;
}
}
///
/// Highlight color if highlight is active
///
Color IHighlightRange.SelectedBackground
{
get
{
return _selectedBackground;
}
}
///
/// Highlight TextSegment
///
TextAnchor IHighlightRange.Range
{
get
{
return _range;
}
}
///
/// Highlight priority
///
int IHighlightRange.Priority
{
get
{
return _priority;
}
}
///
/// if true - highlight only the content of tables, figures and floaters
///
bool IHighlightRange.HighlightContent
{
get
{
return _highlightContent;
}
}
#endregion Internal Properties
#endregion IHighlightRange implementation
#region Internal Methods
internal bool IsSelected(ITextRange selection)
{
if (selection == null)
{
throw new ArgumentNullException("selection");
}
Invariant.Assert(_attachedAnnotation != null, "No _attachedAnnotation");
// For activation based on the selection state, we need to use anchors that
// span virtualized content (i.e., content that isn't visible). For that we
// grab the 'fullly resolved' anchors instead of the anchors used by the
// framework for all other purposes.
TextAnchor fullAnchor = _attachedAnnotation.FullyAttachedAnchor as TextAnchor;
//Debug.Assert(fullAnchor != null, "null TextAnchor");
if (fullAnchor == null)
return false;
return fullAnchor.IsOverlapping(selection.TextSegments);
}
///
/// Looks for Colors from the Annotation's cargo. If corresponding Color is present
/// set it to the input parameter. Otherwise leave the parameter intact.
///
/// The Annotation
/// background Color
/// background Color for active highlight
internal static void GetCargoColors(Annotation annot, ref Nullable backgroundColor, ref Nullable activeBackgroundColor)
{
Invariant.Assert(annot != null, "annotation is null");
ICollection cargos = annot.Cargos;
if (cargos != null)
{
foreach (AnnotationResource cargo in cargos)
{
if (cargo.Name == HighlightResourceName)
{
ICollection contents = cargo.Contents;
foreach (XmlElement content in contents)
{
if ((content.LocalName == ColorsContentName) &&
(content.NamespaceURI == AnnotationXmlConstants.Namespaces.BaseSchemaNamespace))
{
if (content.Attributes[BackgroundAttributeName] != null)
backgroundColor = GetColor(content.Attributes[BackgroundAttributeName].Value);
if (content.Attributes[ActiveBackgroundAttributeName] != null)
activeBackgroundColor = GetColor(content.Attributes[ActiveBackgroundAttributeName].Value);
}
}
}
}
}
}
#endregion Internal Methods
#region Private Methods
///
/// Checks if this attachedAnnotation data - AttachedAnchor and Annotation
///
/// The AttachedAnnotation
/// The AttachedAnchor TextContainer
private ITextContainer CheckInputData(IAttachedAnnotation attachedAnnotation)
{
if (attachedAnnotation == null)
{
throw new ArgumentNullException("attachedAnnotation");
}
TextAnchor textAnchor = attachedAnnotation.AttachedAnchor as TextAnchor;
if (textAnchor == null)
{
throw new ArgumentException(SR.Get(SRID.InvalidAttachedAnchor), "attachedAnnotation");
}
//this should be in a fixed or flow textcontainer
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
if (attachedAnnotation.Annotation == null)
{
throw new ArgumentException(SR.Get(SRID.AnnotationIsNull), "attachedAnnotation");
}
//check annotation type
if (!_type.Equals(attachedAnnotation.Annotation.AnnotationType))
{
throw new ArgumentException(SR.Get(SRID.NotHighlightAnnotationType, attachedAnnotation.Annotation.AnnotationType.ToString()), "attachedAnnotation");
}
return textContainer;
}
///
/// Converts a string to Color object
///
/// Color string
/// Color object
private static Color GetColor(string color)
{
return (Color)ColorConverter.ConvertFromString(color);
}
///
/// Gets the Colors from the Annotation's cargo. If corresponding Color is not present
/// a default value is used.
///
/// The Annotation
/// background Color
/// background Color for active highlight
private void GetColors(Annotation annot, out Color backgroundColor, out Color activeBackgroundColor)
{
Nullable tempBackgroundColor = _defaultBackroundColor;
Nullable tempActiveBackgroundColor = _defaultActiveBackgroundColor;
GetCargoColors(annot, ref tempBackgroundColor, ref tempActiveBackgroundColor);
backgroundColor = (Color)tempBackgroundColor;
activeBackgroundColor = (Color)tempActiveBackgroundColor;
}
///
/// Called when the Annotation cargo changes
///
/// the sender
/// event arguments
private void OnAnnotationUpdated(object sender, AnnotationResourceChangedEventArgs args)
{
Invariant.Assert(_attachedAnnotation != null && _attachedAnnotation.Annotation == args.Annotation, "_attachedAnnotation is different than the input one");
Invariant.Assert(_range != null, "The highlight range is null");
//get text container
TextAnchor textAnchor = _attachedAnnotation.AttachedAnchor as TextAnchor;
Invariant.Assert(textAnchor != null, "wrong anchor type of the saved attached annotation");
//this should be in a fixed or flow textcontainer
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
//Get highlight Colors from the cargo and update the highlight layer
Color background, activeBackground;
GetColors(args.Annotation, out background, out activeBackground);
if (!_background.Equals(background) ||
!_selectedBackground.Equals(activeBackground))
{
//modify the highlight
Invariant.Assert(textContainer.Highlights != null, "textContainer.Highlights is null");
//get AnnotationHighlightLayer in the textContainer
AnnotationHighlightLayer highlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
if (highlightLayer == null)
{
throw new InvalidDataException(SR.Get(SRID.MissingAnnotationHighlightLayer));
}
//change the colors and invalidate
_background = background;
_selectedBackground = activeBackground;
highlightLayer.ModifiedRange(this);
}
}
///
/// Invalidating the measure on all the children (which are Shapes)
/// causes them to recalculate their desired geometry
///
private void InvalidateChildren()
{
// Invalidating the measure on all the children (which are Shapes)
// causes them to recalculate their desired geometry
foreach (Visual child in Children)
{
Shape uiChild = child as Shape;
Invariant.Assert(uiChild != null, "HighlightComponent has non-Shape children.");
uiChild.InvalidateMeasure();
}
//reset the Dirty flag
IsDirty = false;
}
#endregion Private Methods
#region Public Fields
//resource and content names
public const string HighlightResourceName = "Highlight";
public const string ColorsContentName = "Colors";
public const string BackgroundAttributeName = "Background";
public const string ActiveBackgroundAttributeName = "ActiveBackground";
#endregion Public Fields
//------------------------------------------------------
//
// Private fields
//
//------------------------------------------------------
#region Private Fields
private Color _background;
private Color _selectedBackground;
private TextAnchor _range; //the entire range for this highlight
private IAttachedAnnotation _attachedAnnotation;
private PresentationContext _presentationContext;
private static readonly XmlQualifiedName _name = new XmlQualifiedName("Highlight", AnnotationXmlConstants.Namespaces.BaseSchemaNamespace);
private XmlQualifiedName _type = _name;
private int _priority = 0; //used for highlights Z-order. The segment owners are ordered with highest
// priority first
private bool _highlightContent = true; //highlight only the content of tables, figures and floaters
private bool _active = false; //saves the highlight state - active or not
private bool _isDirty = true; //shows if the annotation is in [....] with the content of the AnnotatedElement
//default color colors
private Color _defaultBackroundColor = (Color)ColorConverter.ConvertFromString("#33FFFF00");
private Color _defaultActiveBackgroundColor = (Color)ColorConverter.ConvertFromString("#339ACD32");
#endregion Private Fields
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description: AnnotationComponent that visualizes highlights
//
// History:
// 01/31/2005 ssimova - Created
//
//---------------------------------------------------------------------------
using System;
using MS.Internal;
using System.Diagnostics;
using System.Collections;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Media;
using System.Windows.Shapes;
using MS.Internal.Text;
using System.Xml;
using System.IO;
using System.Windows.Annotations;
using System.Reflection;
using System.Windows.Annotations.Storage;
using System.Windows.Controls;
using MS.Internal.Annotations.Anchoring;
using MS.Utility;
namespace MS.Internal.Annotations.Component
{
// Highlight rendering for the Annotation highlight and sticky note anchor.
// TBD
internal class HighlightComponent : Canvas, IAnnotationComponent, IHighlightRange
{
#region Constructor
///
/// Creates a new instance of the HighlightComponent
///
public HighlightComponent()
{
}
///
/// Creates a new instance of the HighlightComponent with
/// nondefault priority and type;
///
/// component priority
/// if true - highlight only content of tables, figures and floaters
/// component type
public HighlightComponent(int priority, bool highlightContent, XmlQualifiedName type)
: base()
{
if (type == null)
{
throw new ArgumentNullException("type");
}
_priority = priority;
_type = type;
_highlightContent = highlightContent;
}
#endregion Constructor
#region Public Properties
///
/// Return a copy of the list of IAttachedAnnotations held by this component
///
public IList AttachedAnnotations
{
get
{
ArrayList list = new ArrayList();
if (_attachedAnnotation != null)
{
list.Add(_attachedAnnotation);
}
return list;
}
}
///
/// Sets and gets the context this annotation component is hosted in.
///
/// Context this annotation component is hosted in
public PresentationContext PresentationContext
{
get
{
return _presentationContext;
}
set
{
_presentationContext = value;
}
}
///
/// Sets and gets the Z-order of this component. NOP -
/// Highlight does not have Z-order
///
/// Context this annotation component is hosted in
public int ZOrder
{
get
{
return -1;
}
set
{
}
}
///
/// The annotation type name
///
public static XmlQualifiedName TypeName
{
get
{
return _name;
}
}
///
/// gets and sets the default backgroud color for the highlight
///
public Color DefaultBackground
{
get
{
return _defaultBackroundColor;
}
set
{
_defaultBackroundColor = value;
}
}
///
/// gets and sets the default foregroud color for the highlight
///
public Color DefaultActiveBackground
{
get
{
return _defaultActiveBackgroundColor;
}
set
{
_defaultActiveBackgroundColor = value;
}
}
///
/// Highlight color
///
public Brush HighlightBrush
{
set
{
SetValue(HighlightComponent.HighlightBrushProperty, value);
}
}
//those properies are exposed to allow external components like StickyNote to synchronize their color
// with Highlight colors
public static DependencyProperty HighlightBrushProperty = DependencyProperty.Register("HighlightBrushProperty", typeof(Brush), typeof(HighlightComponent));
///
/// Returns the one element the annotation component is attached to.
///
///
/// When the value is set to true - the AnnotatedElement content has changed -
/// save the value and invalidate the visual, so we can recalculate the geometry.
/// The value is set to false when the geometry is synced with the content
///
public bool IsDirty
{
get
{
return _isDirty;
}
set
{
_isDirty = value;
if (value)
InvalidateChildren();
}
}
#endregion Public Properties
#region Public Methods
///
/// The HighlightComponent uses built-in highlight rendering, so no transformation is needed
///
/// Transform to the AnnotatedElement.
/// Transform to the annotation component
public GeneralTransform GetDesiredTransform(GeneralTransform transform)
{
return transform;
}
///
/// Add an attached annotation to the component. The attached anchor will be used to add
/// a highlight to the appropriate TextContainer
///
/// The attached annotation to be added to the component
public void AddAttachedAnnotation(IAttachedAnnotation attachedAnnotation)
{
if (_attachedAnnotation != null)
{
throw new ArgumentException(SR.Get(SRID.MoreThanOneAttachedAnnotation));
}
//fire trace event
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.AddAttachedHighlightBegin);
//check input data and retrieve the TextContainer
ITextContainer textContainer = CheckInputData(attachedAnnotation);
TextAnchor textAnchor = attachedAnnotation.AttachedAnchor as TextAnchor;
//Get highlight Colors from the cargo. For undefined Colors the default values are used
GetColors(attachedAnnotation.Annotation, out _background, out _selectedBackground);
_range = textAnchor;
Invariant.Assert(textContainer.Highlights != null, "textContainer.Highlights is null");
//get or create AnnotationHighlightLayer in the textContainer
AnnotationHighlightLayer highlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
if (highlightLayer == null)
{
highlightLayer = new AnnotationHighlightLayer();
textContainer.Highlights.AddLayer(highlightLayer);
}
//save the attached annotation
_attachedAnnotation = attachedAnnotation;
//register for cargo changes
_attachedAnnotation.Annotation.CargoChanged += new AnnotationResourceChangedEventHandler(OnAnnotationUpdated);
//add this highlight range
highlightLayer.AddRange(this);
HighlightBrush = new SolidColorBrush(_background);
IsHitTestVisible = false;
//fire trace event
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.AddAttachedHighlightEnd);
}
///
/// Remove an attached annotation from the component
///
/// The attached annotation to be removed from the component
public void RemoveAttachedAnnotation(IAttachedAnnotation attachedAnnotation)
{
if (attachedAnnotation == null)
{
throw new ArgumentNullException("attachedAnnotation");
}
if (attachedAnnotation != _attachedAnnotation)
{
throw new ArgumentException(SR.Get(SRID.InvalidAttachedAnnotation), "attachedAnnotation");
}
Invariant.Assert(_range != null, "null highlight range");
//fire trace event
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.RemoveAttachedHighlightBegin);
//check input data and retrieve the TextContainer
ITextContainer textContainer = CheckInputData(attachedAnnotation);
Invariant.Assert(textContainer.Highlights != null, "textContainer.Highlights is null");
//get AnnotationHighlightLayer in the textContainer
AnnotationHighlightLayer highlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
Invariant.Assert(highlightLayer != null, "AnnotationHighlightLayer is not initialized");
//unregister of cargo changes
_attachedAnnotation.Annotation.CargoChanged -= new AnnotationResourceChangedEventHandler(OnAnnotationUpdated);
highlightLayer.RemoveRange(this);
//highlight is removed - remove the attached annotation and the data
_attachedAnnotation = null;
//fire trace event
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordAnnotation, EventTrace.Event.RemoveAttachedHighlightEnd);
}
///
/// Modify an attached annotation that is held by the component
///
/// The attached annotation after modification
/// The attached anchor previously associated with the attached annotation.
/// The previous attachment level of the attached annotation.
public void ModifyAttachedAnnotation(IAttachedAnnotation attachedAnnotation, object previousAttachedAnchor, AttachmentLevel previousAttachmentLevel)
{
throw new NotSupportedException(SR.Get(SRID.NotSupported));
}
///
/// Sets highlight color to active/inactive
/// true - activate, false = deactivate
///
public void Activate(bool active)
{
//return if the state is unchanged
if (_active == active)
return;
//get the highlight layer
if (_attachedAnnotation == null)
{
throw new InvalidOperationException(SR.Get(SRID.NoAttachedAnnotationToModify));
}
TextAnchor textAnchor = _attachedAnnotation.AttachedAnchor as TextAnchor;
Invariant.Assert(textAnchor != null, "AttachedAnchor is not a text anchor");
//this should be in a fixed or flow textcontainer
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
//get AnnotationHighlightLayer in the textContainer
AnnotationHighlightLayer highlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
Invariant.Assert(highlightLayer != null, "AnnotationHighlightLayer is not initialized");
highlightLayer.ActivateRange(this, active);
_active = active;
if (active)
HighlightBrush = new SolidColorBrush(_selectedBackground);
else
HighlightBrush = new SolidColorBrush(_background);
}
#endregion Public Methods
//-----------------------------------------------------
//
// IHighlightRange implementation
//
//-----------------------------------------------------
#region IHighlightRange implementation
#region Internal Methods
///
/// Adds a new shape to the children of the corresponding visual
///
/// the new child
void IHighlightRange.AddChild(Shape child)
{
Children.Add(child);
}
///
/// Removes a shape from the children of the corresponding visual
///
/// the new child
void IHighlightRange.RemoveChild(Shape child)
{
Children.Remove(child);
}
#endregion Internal Methods
//------------------------------------------------------
//
// Internal properties
//
//-----------------------------------------------------
#region Internal Properties
///
/// Highlight Background color
///
Color IHighlightRange.Background
{
get
{
return _background;
}
}
///
/// Highlight color if highlight is active
///
Color IHighlightRange.SelectedBackground
{
get
{
return _selectedBackground;
}
}
///
/// Highlight TextSegment
///
TextAnchor IHighlightRange.Range
{
get
{
return _range;
}
}
///
/// Highlight priority
///
int IHighlightRange.Priority
{
get
{
return _priority;
}
}
///
/// if true - highlight only the content of tables, figures and floaters
///
bool IHighlightRange.HighlightContent
{
get
{
return _highlightContent;
}
}
#endregion Internal Properties
#endregion IHighlightRange implementation
#region Internal Methods
internal bool IsSelected(ITextRange selection)
{
if (selection == null)
{
throw new ArgumentNullException("selection");
}
Invariant.Assert(_attachedAnnotation != null, "No _attachedAnnotation");
// For activation based on the selection state, we need to use anchors that
// span virtualized content (i.e., content that isn't visible). For that we
// grab the 'fullly resolved' anchors instead of the anchors used by the
// framework for all other purposes.
TextAnchor fullAnchor = _attachedAnnotation.FullyAttachedAnchor as TextAnchor;
//Debug.Assert(fullAnchor != null, "null TextAnchor");
if (fullAnchor == null)
return false;
return fullAnchor.IsOverlapping(selection.TextSegments);
}
///
/// Looks for Colors from the Annotation's cargo. If corresponding Color is present
/// set it to the input parameter. Otherwise leave the parameter intact.
///
/// The Annotation
/// background Color
/// background Color for active highlight
internal static void GetCargoColors(Annotation annot, ref Nullable backgroundColor, ref Nullable activeBackgroundColor)
{
Invariant.Assert(annot != null, "annotation is null");
ICollection cargos = annot.Cargos;
if (cargos != null)
{
foreach (AnnotationResource cargo in cargos)
{
if (cargo.Name == HighlightResourceName)
{
ICollection contents = cargo.Contents;
foreach (XmlElement content in contents)
{
if ((content.LocalName == ColorsContentName) &&
(content.NamespaceURI == AnnotationXmlConstants.Namespaces.BaseSchemaNamespace))
{
if (content.Attributes[BackgroundAttributeName] != null)
backgroundColor = GetColor(content.Attributes[BackgroundAttributeName].Value);
if (content.Attributes[ActiveBackgroundAttributeName] != null)
activeBackgroundColor = GetColor(content.Attributes[ActiveBackgroundAttributeName].Value);
}
}
}
}
}
}
#endregion Internal Methods
#region Private Methods
///
/// Checks if this attachedAnnotation data - AttachedAnchor and Annotation
///
/// The AttachedAnnotation
/// The AttachedAnchor TextContainer
private ITextContainer CheckInputData(IAttachedAnnotation attachedAnnotation)
{
if (attachedAnnotation == null)
{
throw new ArgumentNullException("attachedAnnotation");
}
TextAnchor textAnchor = attachedAnnotation.AttachedAnchor as TextAnchor;
if (textAnchor == null)
{
throw new ArgumentException(SR.Get(SRID.InvalidAttachedAnchor), "attachedAnnotation");
}
//this should be in a fixed or flow textcontainer
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
if (attachedAnnotation.Annotation == null)
{
throw new ArgumentException(SR.Get(SRID.AnnotationIsNull), "attachedAnnotation");
}
//check annotation type
if (!_type.Equals(attachedAnnotation.Annotation.AnnotationType))
{
throw new ArgumentException(SR.Get(SRID.NotHighlightAnnotationType, attachedAnnotation.Annotation.AnnotationType.ToString()), "attachedAnnotation");
}
return textContainer;
}
///
/// Converts a string to Color object
///
/// Color string
/// Color object
private static Color GetColor(string color)
{
return (Color)ColorConverter.ConvertFromString(color);
}
///
/// Gets the Colors from the Annotation's cargo. If corresponding Color is not present
/// a default value is used.
///
/// The Annotation
/// background Color
/// background Color for active highlight
private void GetColors(Annotation annot, out Color backgroundColor, out Color activeBackgroundColor)
{
Nullable tempBackgroundColor = _defaultBackroundColor;
Nullable tempActiveBackgroundColor = _defaultActiveBackgroundColor;
GetCargoColors(annot, ref tempBackgroundColor, ref tempActiveBackgroundColor);
backgroundColor = (Color)tempBackgroundColor;
activeBackgroundColor = (Color)tempActiveBackgroundColor;
}
///
/// Called when the Annotation cargo changes
///
/// the sender
/// event arguments
private void OnAnnotationUpdated(object sender, AnnotationResourceChangedEventArgs args)
{
Invariant.Assert(_attachedAnnotation != null && _attachedAnnotation.Annotation == args.Annotation, "_attachedAnnotation is different than the input one");
Invariant.Assert(_range != null, "The highlight range is null");
//get text container
TextAnchor textAnchor = _attachedAnnotation.AttachedAnchor as TextAnchor;
Invariant.Assert(textAnchor != null, "wrong anchor type of the saved attached annotation");
//this should be in a fixed or flow textcontainer
ITextContainer textContainer = textAnchor.Start.TextContainer;
Invariant.Assert(textContainer != null, "TextAnchor does not belong to a TextContainer");
//Get highlight Colors from the cargo and update the highlight layer
Color background, activeBackground;
GetColors(args.Annotation, out background, out activeBackground);
if (!_background.Equals(background) ||
!_selectedBackground.Equals(activeBackground))
{
//modify the highlight
Invariant.Assert(textContainer.Highlights != null, "textContainer.Highlights is null");
//get AnnotationHighlightLayer in the textContainer
AnnotationHighlightLayer highlightLayer = textContainer.Highlights.GetLayer(typeof(HighlightComponent)) as AnnotationHighlightLayer;
if (highlightLayer == null)
{
throw new InvalidDataException(SR.Get(SRID.MissingAnnotationHighlightLayer));
}
//change the colors and invalidate
_background = background;
_selectedBackground = activeBackground;
highlightLayer.ModifiedRange(this);
}
}
///
/// Invalidating the measure on all the children (which are Shapes)
/// causes them to recalculate their desired geometry
///
private void InvalidateChildren()
{
// Invalidating the measure on all the children (which are Shapes)
// causes them to recalculate their desired geometry
foreach (Visual child in Children)
{
Shape uiChild = child as Shape;
Invariant.Assert(uiChild != null, "HighlightComponent has non-Shape children.");
uiChild.InvalidateMeasure();
}
//reset the Dirty flag
IsDirty = false;
}
#endregion Private Methods
#region Public Fields
//resource and content names
public const string HighlightResourceName = "Highlight";
public const string ColorsContentName = "Colors";
public const string BackgroundAttributeName = "Background";
public const string ActiveBackgroundAttributeName = "ActiveBackground";
#endregion Public Fields
//------------------------------------------------------
//
// Private fields
//
//------------------------------------------------------
#region Private Fields
private Color _background;
private Color _selectedBackground;
private TextAnchor _range; //the entire range for this highlight
private IAttachedAnnotation _attachedAnnotation;
private PresentationContext _presentationContext;
private static readonly XmlQualifiedName _name = new XmlQualifiedName("Highlight", AnnotationXmlConstants.Namespaces.BaseSchemaNamespace);
private XmlQualifiedName _type = _name;
private int _priority = 0; //used for highlights Z-order. The segment owners are ordered with highest
// priority first
private bool _highlightContent = true; //highlight only the content of tables, figures and floaters
private bool _active = false; //saves the highlight state - active or not
private bool _isDirty = true; //shows if the annotation is in [....] with the content of the AnnotatedElement
//default color colors
private Color _defaultBackroundColor = (Color)ColorConverter.ConvertFromString("#33FFFF00");
private Color _defaultActiveBackgroundColor = (Color)ColorConverter.ConvertFromString("#339ACD32");
#endregion Private Fields
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CryptoApi.cs
- DragStartedEventArgs.cs
- TraceHwndHost.cs
- DefaultParameterValueAttribute.cs
- BufferBuilder.cs
- ConnectionStringsExpressionBuilder.cs
- Unit.cs
- ProcessModuleCollection.cs
- ISCIIEncoding.cs
- ObjectListCommandsPage.cs
- WebPartDesigner.cs
- TextTreeInsertElementUndoUnit.cs
- StyleReferenceConverter.cs
- ConsumerConnectionPointCollection.cs
- RuleAttributes.cs
- TdsParserSafeHandles.cs
- DesignTimeResourceProviderFactoryAttribute.cs
- WindowInteropHelper.cs
- ValuePatternIdentifiers.cs
- PassportPrincipal.cs
- Ipv6Element.cs
- SocketAddress.cs
- PropertyMapper.cs
- MissingFieldException.cs
- DeflateEmulationStream.cs
- RenderDataDrawingContext.cs
- Underline.cs
- SourceInterpreter.cs
- NumberFunctions.cs
- VoiceInfo.cs
- ListViewItemEventArgs.cs
- InternalPermissions.cs
- ReferenceSchema.cs
- MessageDescription.cs
- AttributeQuery.cs
- SpotLight.cs
- ReceiveCompletedEventArgs.cs
- ComponentManagerBroker.cs
- DependencyPropertyKey.cs
- EdmComplexTypeAttribute.cs
- BevelBitmapEffect.cs
- PerspectiveCamera.cs
- XmlSchemaType.cs
- DockPanel.cs
- DataRelationCollection.cs
- TokenFactoryCredential.cs
- ListViewInsertedEventArgs.cs
- loginstatus.cs
- BrushProxy.cs
- ReservationNotFoundException.cs
- BinaryObjectWriter.cs
- SqlDataSourceQueryEditor.cs
- CodeCompileUnit.cs
- WindowsFormsHelpers.cs
- BaseCodePageEncoding.cs
- SqlInternalConnectionTds.cs
- TemplateNameScope.cs
- DataGridViewRowHeaderCell.cs
- ClientFormsIdentity.cs
- ResourceDescriptionAttribute.cs
- Itemizer.cs
- SettingsAttributes.cs
- TextLine.cs
- DuplicateContext.cs
- IdentitySection.cs
- BindingExpression.cs
- EtwProvider.cs
- DbConnectionPool.cs
- VisualTreeUtils.cs
- ValidationPropertyAttribute.cs
- HighlightComponent.cs
- Fonts.cs
- ClusterSafeNativeMethods.cs
- RevocationPoint.cs
- ExceptionUtil.cs
- CustomError.cs
- DataGridColumnHeaderCollection.cs
- ApplicationHost.cs
- MatrixIndependentAnimationStorage.cs
- StringUtil.cs
- PlatformCulture.cs
- PresentationTraceSources.cs
- ClientEventManager.cs
- DecoratedNameAttribute.cs
- EventProxy.cs
- BitmapDecoder.cs
- TextEditorTyping.cs
- ProcessHostConfigUtils.cs
- TraceListener.cs
- TextCharacters.cs
- HTMLTagNameToTypeMapper.cs
- HtmlInputText.cs
- SafeRightsManagementPubHandle.cs
- SQLInt64.cs
- CqlParser.cs
- TypedDataSourceCodeGenerator.cs
- TypeUtil.cs
- AlphaSortedEnumConverter.cs
- SafeTimerHandle.cs
- QualifiedCellIdBoolean.cs