Highlight all hits in documentviewer

I know that the wpf-documentviewer supports the searching in the documents, if the document is a xpsdocument. The search only highlights one hit after the other.

Is it possible to highlight all hits through the search-box?

I have the following code to create and set the document of a DocumentViewer-Control:

 public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        FixedDocument fixedDocument = CreateTestDocument();
        this.documentViewer.Document = BuildFixedDocumentSequence(fixedDocument);
    }

    private static FixedDocumentSequence BuildFixedDocumentSequence(FixedDocument fixedDocument)
    {
        MemoryStream ms = new MemoryStream();
        Uri documentUri = new Uri("pack://document.xps");
        Package p = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
        PackageStore.AddPackage(documentUri, p);
        XpsDocument xpsDocument = new XpsDocument(p, CompressionOption.NotCompressed, documentUri.AbsoluteUri);
        XpsDocumentWriter dw = XpsDocument.CreateXpsDocumentWriter(xpsDocument);
        dw.Write(fixedDocument);
        FixedDocumentSequence fixedDocumentSequence = xpsDocument.GetFixedDocumentSequence();
        if (fixedDocumentSequence == null)
            return null;
        return fixedDocumentSequence;
    }

    public FixedDocument CreateTestDocument()
    {
        FixedDocument document = new FixedDocument();
        PrintDialog printDialog = new PrintDialog();
        document.DocumentPaginator.PageSize = new Size(printDialog.PrintableAreaWidth, printDialog.PrintableAreaHeight);
        AddPage(document, "This is the first page");
        AddPage(document, "This is not the first page");
        AddPage(document, "This is the third page");
        return document;
    }

    private void AddPage(FixedDocument document, string content)
    {
        FixedPage page = new FixedPage
            {
                Width = document.DocumentPaginator.PageSize.Width,
                Height = document.DocumentPaginator.PageSize.Height
            };
        TextBlock pageText = new TextBlock
            {
                Text = content,
                FontSize = 40,
                Margin = new Thickness(96)
            };
        page.Children.Add(pageText);
        PageContent pageContent = new PageContent();
        ((IAddChild)pageContent).AddChild(page);
        document.Pages.Add(pageContent);
    }
}

The xaml-code consists just of the documentviewer. Now if i type in "page" into the search-box of the documentviewer and press return, the word "page" on the first page is highlighted. Through another time pressing the return-key the word "page" on the second page is highlighted.

What I want to achieve is that by pressing return for the first time, all words "page" are highlighted.

There is no easy way of doing this, that I could find. With a lot of trial and error, but mainly reflection (pun intended;), this can be done - I was still quite amazed when it actually worked.

I subclassed the DocumentViewer, and went from there. The http://reflector.webtropy.com site came in very handy, wouldn't have gotten anywhere without the source code.

The code behind didn't change, take it from the question post.

Usage:

<local:MyDocumentViewer x:Name="documentViewer"  />

MyDocumentViewer:

/// <summary>
/// DocumentViewer that has his Search Box overridden in order to select multiple results in the document.
/// Use IsMultiSearchEnabled to turn off this behavior.
/// The number of results can be limited with the MaxSearchResults property.
/// </summary>
public class MyDocumentViewer : DocumentViewer
{
    private ToolBar _myfindToolbar; // MS.Internal.Documents.FindToolBar
    private object _mydocumentScrollInfo; // MS.Internal.Documents.DocumentGrid

    private MethodInfo _miFind; // DocumentViewerBase.Find(FindToolBar)
    private MethodInfo _miGoToTextBox; // FindToolBar.GoToTextBox()
    private MethodInfo _miMakeSelectionVisible; // DocumentGrid.MakeSelectionVisible()

    /// <summary>
    /// Limit for returned search results. 0 for no limit, default is int.MaxValue.
    /// </summary>
    public int MaxSearchResults { get { return (int)GetValue(MaxSearchResultsProperty); } set { SetValue(MaxSearchResultsProperty, value); } }
    public static readonly DependencyProperty MaxSearchResultsProperty =
        DependencyProperty.Register("MaxSearchResults", typeof(int), typeof(MyDocumentViewer), new PropertyMetadata(int.MaxValue));


    /// <summary>
    /// Determines if the search of the find toolbox is overridden and multiple search results are selected in the document.
    /// </summary>
    public bool IsMultiSearchEnabled { get { return (bool)GetValue(IsMultiSearchEnabledProperty); } set { SetValue(IsMultiSearchEnabledProperty, value); } }
    public static readonly DependencyProperty IsMultiSearchEnabledProperty =
        DependencyProperty.Register("IsMultiSearchEnabled", typeof(bool), typeof(MyDocumentViewer), new PropertyMetadata(true));


    public override void OnApplyTemplate()
    {
        base.OnApplyTemplate();

        if (IsMultiSearchEnabled)
        {
            // get some private fields from the base class DocumentViewer
            _myfindToolbar = this.GetType().GetPrivateFieldOfBase("_findToolbar").GetValue(this) as ToolBar;
            _mydocumentScrollInfo = this.GetType().GetPrivateFieldOfBase("_documentScrollInfo").GetValue(this);

            // replace button click handler of find toolbar
            EventInfo evt = _myfindToolbar.GetType().GetEvent("FindClicked");
            ReflectionHelper.RemoveEventHandler(_myfindToolbar, evt.Name); // remove existing handler
            evt.AddEventHandler(_myfindToolbar, new EventHandler(OnFindInvoked)); // attach own handler

            // get some methods that will need to be invoked
            _miFind = this.GetType().GetMethod("Find", BindingFlags.NonPublic | BindingFlags.Instance);
            _miGoToTextBox = _myfindToolbar.GetType().GetMethod("GoToTextBox");
            _miMakeSelectionVisible = _mydocumentScrollInfo.GetType().GetMethod("MakeSelectionVisible");
        }
    }


    /// <summary>
    /// This is replacing DocumentViewer.OnFindInvoked(object sender, EventArgs e)
    /// </summary>
    private void OnFindInvoked(object sender, EventArgs e)
    {
        IList allSegments = null; // collection of text segments
        TextRange findResult = null; // could also use object, does not need type

        //Give ourselves focus, this ensures that the selection
        //will be made visible after it's made.
        this.Focus();

        // Drill down to the list of selected text segments: DocumentViewer.TextEditor.Selection.TextSegments
        object textEditor = this.GetType().GetProperty("TextEditor", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this); // System.Windows.Documents.TextEditor
        object selection = textEditor.GetType().GetProperty("Selection", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(textEditor); // System.Windows.Documents.TextSelection
        FieldInfo fiTextSegments = selection.GetType().GetPrivateFieldOfBase("_textSegments");
        IList textSegments = fiTextSegments.GetValue(selection) as IList; // List<System.Windows.Documents.TextSegment>

        // Clearing the selection in order to start search from the beginning of the document. I suspect there might be a better way of doing this.
        object segmentStart = textSegments[0].GetType().GetField("_start", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(textSegments[0]); // get segment start (one textsegment is always present)
        int currentOffset = (int)segmentStart.GetType().GetProperty("System.Windows.Documents.ITextPointer.Offset", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(segmentStart); // get offset of segment start
        segmentStart = segmentStart.GetType().GetMethod("CreatePointer", new Type[] { segmentStart.GetType(), typeof(int) }).Invoke(segmentStart, new object[] { segmentStart, -currentOffset }); // set the offset back to 0

        textSegments[0] = textSegments[0].GetType().GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { segmentStart.GetType(), segmentStart.GetType() }, null) 
                                                   .Invoke(new object[] { segmentStart, segmentStart}); // create a new textsegment with resetted offset

        for (int i = 1; i < textSegments.Count; i++)
        {
            textSegments.RemoveAt(i); // remove all other segments
        }

        // Always search down
        _myfindToolbar.GetType().GetProperty("SearchUp").SetValue(_myfindToolbar, false);

        // Search and collect the find results
        int resultCount = 0;
        do
        {
            // invoke: DocumentViewerBase.Find(findToolBar)
            findResult = _miFind.Invoke(this, new object[] { _myfindToolbar }) as TextRange;

            if (findResult != null)
            {
                // get the selected TextSegments of the search
                textSegments = fiTextSegments.GetValue(selection) as IList; // List<System.Windows.Documents.TextSegment>
                if (allSegments == null)
                    allSegments = textSegments; // first search find, set whole collection
                else
                    allSegments.Add(textSegments[0]); // after first find, add to collection

                resultCount++;
            }
        }
        while (findResult != null && (MaxSearchResults == 0 || resultCount < MaxSearchResults)); // stop if no more results were found or limit is exceeded

        if (allSegments == null)
        {
            // alert the user that we did not find anything
            string searchText = _myfindToolbar.GetType().GetProperty("SearchText").GetValue(_myfindToolbar) as string;
            string messageString = string.Format("Searched the document. Cannot find '{0}'.", searchText);

            MessageBox.Show(messageString, "Find", MessageBoxButton.OK, MessageBoxImage.Asterisk);
        }
        else
        {
            // set the textsegments field to the collected search results
            fiTextSegments.SetValue(selection, allSegments);

            // this marks the text. invoke: DocumentGrid.MakeSelectionVisible()
            _miMakeSelectionVisible.Invoke(_mydocumentScrollInfo, null);
        }

        // put the focus back on the findtoolbar textbox to search again. invoke: FindToolBar.GoToTextBox()
        _miGoToTextBox.Invoke(_myfindToolbar, null);
    }
}

public static class ReflectionExtensions
{
    /// <summary>
    /// Gets private field of base class. Normally, they are not directly accessible in a GetField call.
    /// </summary>
    public static FieldInfo GetPrivateFieldOfBase(this Type type, string fieldName)
    {
        BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic;

        // Declare variables
        FieldInfo fieldInfo = null;

        // Search as long as there is a type
        while (type != null)
        {
            // Use reflection
            fieldInfo = type.GetField(fieldName, bindingFlags);

            // Yes, do we have a field?
            if (fieldInfo != null) break;

            // Get base class
            type = type.BaseType;
        }

        // Return result
        return fieldInfo;
    }
}

/// <summary>
/// http://www.codeproject.com/Articles/103542/Removing-Event-Handlers-using-Reflection
/// </summary>
public static class ReflectionHelper
{
    static Dictionary<Type, List<FieldInfo>> dicEventFieldInfos = new Dictionary<Type, List<FieldInfo>>();

    static BindingFlags AllBindings
    {
        get { return BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static; }
    }

    static List<FieldInfo> GetTypeEventFields(Type t)
    {
        if (dicEventFieldInfos.ContainsKey(t))
            return dicEventFieldInfos[t];

        List<FieldInfo> lst = new List<FieldInfo>();
        BuildEventFields(t, lst);
        dicEventFieldInfos.Add(t, lst);
        return lst;
    }

    static void BuildEventFields(Type t, List<FieldInfo> lst)
    {
        //BindingFlags.FlattenHierarchy only works on protected & public, doesn't work because fields are private
        // Uses .GetEvents and then uses .DeclaringType to get the correct ancestor type so that we can get the FieldInfo.
        foreach (EventInfo ei in t.GetEvents(AllBindings))
        {
            Type dt = ei.DeclaringType;
            FieldInfo fi = dt.GetField(ei.Name, AllBindings);
            if (fi != null)
                lst.Add(fi);
        }
    }

    static EventHandlerList GetStaticEventHandlerList(Type t, object obj)
    {
        MethodInfo mi = t.GetMethod("get_Events", AllBindings);
        return (EventHandlerList)mi.Invoke(obj, new object[] { });
    }

    public static void RemoveAllEventHandlers(object obj) { RemoveEventHandler(obj, ""); }

    public static void RemoveEventHandler(object obj, string EventName)
    {
        if (obj == null)
            return;

        Type t = obj.GetType();
        List<FieldInfo> event_fields = GetTypeEventFields(t);
        EventHandlerList static_event_handlers = null;

        foreach (FieldInfo fi in event_fields)
        {
            if (EventName != "" && string.Compare(EventName, fi.Name, true) != 0)
                continue;

            // STATIC Events have to be treated differently from INSTANCE Events...
            if (fi.IsStatic)
            {
                if (static_event_handlers == null)
                    static_event_handlers = GetStaticEventHandlerList(t, obj);

                object idx = fi.GetValue(obj);
                Delegate eh = static_event_handlers[idx];
                if (eh == null)
                    continue;

                Delegate[] dels = eh.GetInvocationList();
                if (dels == null)
                    continue;

                EventInfo ei = t.GetEvent(fi.Name, AllBindings);
                foreach (Delegate del in dels)
                    ei.RemoveEventHandler(obj, del);
            }
            else
            {
                EventInfo ei = t.GetEvent(fi.Name, AllBindings);
                if (ei != null)
                {
                    object val = fi.GetValue(obj);
                    Delegate mdel = (val as Delegate);
                    if (mdel != null)
                    {
                        foreach (Delegate del in mdel.GetInvocationList())
                            ei.RemoveEventHandler(obj, del);
                    }
                }
            }
        }
    }
}