/// <summary>
/// the event handler for CargoChanged Annotation event
/// internally it calls the store AnnotationModified delegate
/// </summary>
/// <param name="sender">annotation that changed</param>
/// <param name="args">args describing the change</param>
private void OnCargoChanged(object sender, AnnotationResourceChangedEventArgs args)
{
_currentAnnotations[args.Annotation.Id].Dirty = true;
_cargoChanged(sender, args);
}
/// <summary>
/// Should be called when any annotation's cargo changes.
/// This will fire the CargoChanged event and cause a flush
/// if AutoFlush is true.
/// </summary>
/// <param name="args">the args for the event</param>
protected virtual void OnCargoChanged(AnnotationResourceChangedEventArgs args)
{
AnnotationResourceChangedEventHandler cargoChanged = null;
// Ignore null resources added to an annotation
if (args.Resource == null)
return;
lock (SyncRoot)
{
cargoChanged = CargoChanged;
}
if (AutoFlush)
{
Flush();
}
if (cargoChanged != null)
{
cargoChanged(this, args);
}
}
/// <summary>
/// Called when an anchor on any attached annotation changes.
/// We need to handle these changes by updating the set of
/// attached annotations and firing any necessary events.
/// </summary>
/// <param name="sender">the annotation whose anchor changed</param>
/// <param name="args">args describing the action and which anchor was changed</param>
private void OnAnchorChanged(object sender, AnnotationResourceChangedEventArgs args)
{
VerifyAccess();
// Ignore null resources added to an annotation
if (args.Resource == null)
return;
AttachedAnnotationChangedEventArgs newArgs = null;
switch (args.Action)
{
case AnnotationAction.Added:
newArgs = AnchorAdded(args.Annotation, args.Resource);
break;
case AnnotationAction.Removed:
newArgs = AnchorRemoved(args.Annotation, args.Resource);
break;
case AnnotationAction.Modified:
newArgs = AnchorModified(args.Annotation, args.Resource);
break;
default:
Invariant.Assert(false, "Unknown AnnotationAction.");
break;
}
if (newArgs != null)
{
AttachedAnnotationChanged(this, newArgs);
}
}
/// <summary>
/// Used as CargoChanged event handler for all annotations
/// handed out by the map.
/// </summary>
/// <param name="sender">annotation that sent the event</param>
/// <param name="e">args for the event</param>
private void HandleCargoChanged(object sender, AnnotationResourceChangedEventArgs e)
{
lock (SyncRoot)
{
_dirty = true;
}
OnCargoChanged(e);
}
/// <summary>
/// Called when the Annotation cargo changes
/// </summary>
/// <param name="sender">the sender</param>
/// <param name="args">event arguments</param>
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);
}
}
// A registered handler for a bubble listening to the annotation store update event.
// obj - The sender of the event
// args - event arguement
private void OnAnnotationUpdated(object obj, AnnotationResourceChangedEventArgs args)
{
Debug.Assert(_attachedAnnotation != null && _attachedAnnotation.Annotation == args.Annotation);
if (!InternalLocker.IsLocked(LockHelper.LockFlag.AnnotationChanged))
{
SNCAnnotation sncAnnotation = new SNCAnnotation(args.Annotation);
_sncAnnotation = sncAnnotation;
UpdateSNCWithAnnotation(SNCAnnotation.AllValues);
IsDirty = true;
}
}