Difficulty updating InkPresenter visual after removing strokes?

Question

I am creating an inkcanvas (CustomInkCanvas) that receives Gestures. At different times during its use, I am placing additional panels over different parts of the inkcanvas. All is well, and the part of the CustomInkCanvas that is not covered by another panel responds appropriately to ink and gestures.

However, occasionally a Gesture is not recognized, so in the default code of the gesture handler, I am trying to remove the ink from the CustomInkCanvas--even when it is not the uppermost panel.

How is this done?

Note: I have tried everything I can think of, including:

1. Dispatcher with Background update as:

   cink.InkPresenter.Dispatcher.Invoke(DispatcherPriority.Background, EmptyDelegate);

2. Clearing the strokes with:

   Strokes.Clear();

   cink.InkPresenter.Strokes.Clear();

3. Invalidating the visual with:

   cink.InkPresenter.InvalidateVisual(); cink.InavlidateVisual();

4. And even

   foreach (Stroke s in Strokes) { cink.InkPresenter.Strokes.Remove(s); }

Here is the full code...

 void inkCanvas_Gesture(object sender, InkCanvasGestureEventArgs e)
    {
        CustomInkCanvas cink = sender as CustomInkCanvas;
        ReadOnlyCollection<GestureRecognitionResult> gestureResults = e.GetGestureRecognitionResults();
        StylusPointCollection styluspoints = e.Strokes[0].StylusPoints;

        TextBlock tb;               // instance of the textBlock being used by the InkCanvas.
        Point editpoint;            // user point to use for the start of editing.

        TextPointer at;             // textpointer that corresponds to the lowestpoint of the gesture.
        Run parentrun;              // the selected run containing the lowest point.

        // return if there is no textBlock.
        tb = GetVisualChild<TextBlock>(cink);
        if (tb == null) return;

        // Check the first recognition result for a gesture.
        isWriting = false;
        if (gestureResults[0].RecognitionConfidence == RecognitionConfidence.Strong)
        {
            switch (gestureResults[0].ApplicationGesture)
            {
                #region [Writing]
                default:
                    bool AllowInking;

                    editpoint = GetEditorPoint(styluspoints, EditorPoints.Writing);
                    at = tb.GetPositionFromPoint(editpoint, true);

                    parentrun = tb.InputHitTest(editpoint) as Run;      

                    if (parentrun == null)
                    {
                        AllowInking = true;
                        TextPointer At = tb.ContentEnd;
                        Here = (Run)At.GetAdjacentElement(LogicalDirection.Backward);
                    }
                    else
                    {
                        Here = parentrun;
                        AllowInking = String.IsNullOrWhiteSpace(parentrun.Text);
                    }

*** THIS FAILS TO REMOVE THE INK FROM THE DISPLAY ???? *********
                    if (AllowInking == false)
                    {
                        foreach (Stroke s in Strokes)
                        {
                            cink.InkPresenter.Strokes.Remove(s);
                        }
                        // remove ink from display
                        // Strokes.Clear();
                        // cink.InkPresenter.Strokes.Clear();
                        cink.InkPresenter.InvalidateVisual();
                        cink.InkPresenter.Dispatcher.Invoke(DispatcherPriority.Background, EmptyDelegate);
                        return;
                    }

                    // stop the InkCanvas from recognizing gestures
                    EditingMode = InkCanvasEditingMode.Ink;

                    isWriting = true;

                     break;
                #endregion
            } 
        }
    }

         private static Action EmptyDelegate = delegate() { };

Thanks in advance for any help.

Answer 1

It would be nice to get a guru response to this, but for anybody else getting here, apparently the strokes that go into creating the gesture have not yet been added to the InkCanvas, so there is nothing to remove or clear from the inkcanvas from within the gesture handler. Strokes are only added to the InkCanvas AFTER the gesture handler. The solution this newbie ended up with was to set a flag when ink was not allowed, and then act on it in the StrokesChanged handler like:

if (AllowInking == false)
 {
       ClearStrokes = true;
       return;
  }

void Strokes_StrokesChanged(object sender, StrokeCollectionChangedEventArgs e)
    {
        if (ClearStrokes == true)
        {
            ClearStrokes = false;
            Strokes.Clear();
            return;
        }

All works now. Is there a better way?