private void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
// Load annotations store
_stream = new FileStream("storage.xml", FileMode.OpenOrCreate);
_service = new AnnotationService(flowDocumentReader);
_store = new XmlStreamStore(_stream) {AutoFlush = true};
_service.Enable(_store);
// Detect when annotations are added or deleted
_service.Store.StoreContentChanged +=
AnnotationStore_StoreContentChanged;
// Bind to annotations in store
BindToAnnotations(_store.GetAnnotations());
}
void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
// Use permanent annotation storage
this.stream = new FileStream("storage.xml", FileMode.OpenOrCreate);
this.service = new AnnotationService(this.flowDocumentReader);
this.store = new XmlStreamStore(this.stream);
this.store.AutoFlush = true;
this.service.Enable(this.store);
// Detect when annotations are added or deleted
this.service.Store.StoreContentChanged += new StoreContentChangedEventHandler(AnnotationStore_StoreContentChanged);
// Bind to annotations in store
BindToAnnotations(this.store.GetAnnotations());
}
/// <summary>
/// Create an instance of LocatorManager with an optional specific store.
/// It manages the processors that are used to create and resolve locators.
/// If a store is passed in, its used to query for annotations. Otherwise
/// the service is looked for and the service's store is used.
/// </summary>
/// <param name="store">optional, store to use for query of annotations</param>
public LocatorManager(AnnotationStore store)
{
_locatorPartHandlers = new Hashtable();
_subtreeProcessors = new Hashtable();
_selectionProcessors = new Hashtable();
RegisterSubTreeProcessor(new DataIdProcessor(this), DataIdProcessor.Id);
RegisterSubTreeProcessor(new FixedPageProcessor(this), FixedPageProcessor.Id);
TreeNodeSelectionProcessor nodeProcessor = new TreeNodeSelectionProcessor();
RegisterSelectionProcessor(nodeProcessor, typeof(FrameworkElement));
RegisterSelectionProcessor(nodeProcessor, typeof(FrameworkContentElement));
TextSelectionProcessor textProcessor = new TextSelectionProcessor();
RegisterSelectionProcessor(textProcessor, typeof(TextRange));
RegisterSelectionProcessor(textProcessor, typeof(TextAnchor));
_internalStore = store;
}
/// <summary>
/// Create an instance of AnnotationDocumentPaginator for a given document and annotation store.
/// </summary>
/// <param name="originalPaginator">document to add annotations to</param>
/// <param name="annotationStore">store to retrieve annotations from</param>
/// <param name="flowDirection"></param>
public AnnotationDocumentPaginator(DocumentPaginator originalPaginator, AnnotationStore annotationStore, FlowDirection flowDirection)
{
_isFixedContent = originalPaginator is FixedDocumentPaginator || originalPaginator is FixedDocumentSequencePaginator;
if (!_isFixedContent && !(originalPaginator is FlowDocumentPaginator))
throw new ArgumentException(SR.Get(SRID.OnlyFlowAndFixedSupported));
_originalPaginator = originalPaginator;
_annotationStore = annotationStore;
_locatorManager = new LocatorManager(_annotationStore);
_flowDirection = flowDirection;
// Register for events
_originalPaginator.GetPageCompleted += new GetPageCompletedEventHandler(HandleGetPageCompleted);
_originalPaginator.ComputePageCountCompleted += new AsyncCompletedEventHandler(HandleComputePageCountCompleted);
_originalPaginator.PagesChanged += new PagesChangedEventHandler(HandlePagesChanged);
}
/// <summary>
/// Create an instance of AnnotationDocumentPaginator for a given document and annotation store.
/// </summary>
/// <param name="originalPaginator">document to add annotations to</param>
/// <param name="annotationStore">store to retrieve annotations from</param>
public AnnotationDocumentPaginator(DocumentPaginator originalPaginator, AnnotationStore annotationStore) : this(originalPaginator, annotationStore, FlowDirection.LeftToRight)
{
}
//------------------------------------------------------
//
// Public Methods
//
//------------------------------------------------------
#region Public Methods
/// <summary>
/// Enables the service with the given store.
/// </summary>
/// <param name="annotationStore">store to use for retreiving and persisting annotations</param>
/// <exception cref="ArgumentNullException">store is null</exception>
/// <exception cref="InvalidOperationException">DocumentViewerBase has content which is neither
/// FlowDocument or FixedDocument; only those two are supported</exception>
/// <exception cref="InvalidOperationException">this service or another service is already
/// enabled for the DocumentViewerBase</exception>
public void Enable(AnnotationStore annotationStore)
{
if (annotationStore == null)
throw new ArgumentNullException("annotationStore");
VerifyAccess();
if (_isEnabled)
throw new InvalidOperationException(SR.Get(SRID.AnnotationServiceIsAlreadyEnabled));
// Make sure there isn't a service above or below us
VerifyServiceConfiguration(_root);
// Post a background work item to load existing annotations. Do this early in the
// Enable method in case any later code causes an indirect call to LoadAnnotations,
// this cached operation will make that LoadAnnotations call a no-op.
_asyncLoadOperation = _root.Dispatcher.BeginInvoke(DispatcherPriority.Background, new DispatcherOperationCallback(LoadAnnotationsAsync), this);
// Enable the store and set it on the tree
_isEnabled = true;
_root.SetValue(AnnotationService.ServiceProperty, this);
_store = annotationStore;
// If our root is a DocumentViewerBase we need to setup some special processors.
DocumentViewerBase viewer = _root as DocumentViewerBase;
if (viewer != null)
{
bool isFixed = viewer.Document is FixedDocument || viewer.Document is FixedDocumentSequence;
bool isFlow = !isFixed && viewer.Document is FlowDocument;
if (isFixed || isFlow || viewer.Document == null)
{
// Take care of some special processors here
if (isFixed)
{
_locatorManager.RegisterSelectionProcessor(new FixedTextSelectionProcessor(), typeof(TextRange));
_locatorManager.RegisterSelectionProcessor(new FixedTextSelectionProcessor(), typeof(TextAnchor));
}
else if (isFlow)
{
_locatorManager.RegisterSelectionProcessor(new TextSelectionProcessor(), typeof(TextRange));
_locatorManager.RegisterSelectionProcessor(new TextSelectionProcessor(), typeof(TextAnchor));
_locatorManager.RegisterSelectionProcessor(new TextViewSelectionProcessor(), typeof(DocumentViewerBase));
}
}
else
{
throw new InvalidOperationException(SR.Get(SRID.OnlyFlowFixedSupported));
}
}
// Don't register on the store until the service is ready to accept events.
// Register for content change and anchor change events - we'll need to attach/detach
// annotations as they are added/removed from the store or their anchors change
annotationStore.StoreContentChanged += new StoreContentChangedEventHandler(OnStoreContentChanged);
annotationStore.AnchorChanged += new AnnotationResourceChangedEventHandler(OnAnchorChanged);
}
