StylusPlugIn.OnStylusUpProcessed Method

Occurs on the application UI (user interface) thread when the user lifts the tablet pen from the digitizer.

Namespace:  System.Windows.Input.StylusPlugIns
Assembly:  PresentationCore (in PresentationCore.dll)

protected virtual void OnStylusUpProcessed(
	Object callbackData,
	bool targetVerified
)

Parameters

callbackData
Type: System.Object

The object that the application passed to the RawStylusInput.NotifyWhenProcessed method.

targetVerified
Type: System.Boolean

true if the pen's input was correctly routed to the StylusPlugIn; otherwise, false.

To subscribe to this method, call NotifyWhenProcessed in the OnStylusUp method

The following example creates a StylusPlugIn that checks for the Down gesture. The StylusPlugIn checks for the gesture in the OnStylusUpProcessed method, which is called from the application UI thread.

class RecognizerPlugin : StylusPlugIn
{
    GestureRecognizer recognizer;

    // StylusPointCollection that contains the stylus points of the current 
    // stroke.
    StylusPointCollection points;

    // Keeps track of the stylus to check whether two styluses are used on the 
    // digitizer. 
    int currentStylus;

    public RecognizerPlugin()
        : base()
    {
        recognizer = new GestureRecognizer();
    }

    // Collect the points as the user draws the stroke. 
    protected override void OnStylusDown(RawStylusInput rawStylusInput)
    {
        // If points is not null, there is already a stroke taking place 
        // on the digitizer, so don't create a new StylusPointsCollection. 
        if (points == null)
        {
            points = new StylusPointCollection(rawStylusInput.GetStylusPoints().Description);
            points.Add(rawStylusInput.GetStylusPoints());
            currentStylus = rawStylusInput.StylusDeviceId;
        }
    }

    // Collect the points as the user draws the stroke. 
    protected override void OnStylusMove(RawStylusInput rawStylusInput)
    {
        // Check whether the stylus that started the stroke is the same, and 
        // that the element hasn't lost focus since the stroke began. 
            if (points != null && currentStylus == rawStylusInput.StylusDeviceId)
        {
            points.Add(rawStylusInput.GetStylusPoints());
        }
    }

    // Collect the points as the user draws the stroke. 
    protected override void OnStylusUp(RawStylusInput rawStylusInput)
    {
        // Check whether the stylus that started the stroke is the same, and 
        // that the element hasn't lost focus since the stroke began. 
        if (points != null && currentStylus == rawStylusInput.StylusDeviceId)
        {
            points.Add(rawStylusInput.GetStylusPoints());

            // Subscribe to the OnStylusUpProcessed method.
            rawStylusInput.NotifyWhenProcessed(points);
        }

        points = null;
        currentStylus = 0;
    }

    // If the element loses focus, stop collecting the points and don't 
    // perform gesture recognition. 
    protected override void OnStylusLeave(RawStylusInput rawStylusInput, bool confirmed)
    {
        if (confirmed)
        {
            // Clear the StylusPointCollection
            points = null;
            currentStylus = 0;
        }
    }

    // This method is called on the application thread. 
    protected override void OnStylusUpProcessed(object callbackData, bool targetVerified)
    {
        // Check that the element actually receive the OnStylusUp input. 
        if (targetVerified && recognizer.IsRecognizerAvailable)
        {
            StylusPointCollection strokePoints = callbackData as StylusPointCollection;

            if (strokePoints == null)
            {
                return;
            }

            // Create a StrokeCollection to pass to the GestureRecognizer.
            Stroke newStroke = new Stroke(strokePoints);
            StrokeCollection strokes = new StrokeCollection();
            strokes.Add(newStroke);

            ReadOnlyCollection<GestureRecognitionResult> results = recognizer.Recognize(strokes);

            // If the GestureRecognizer recognizes the stroke as a Down 
            // gesture with strong confidence, raise an event. 
            if (results[0].ApplicationGesture == ApplicationGesture.Down &&
                results[0].RecognitionConfidence == RecognitionConfidence.Strong)
            {
                //raise event
            }
        }
    }
}

.NET Framework

Supported in: 4.6, 4.5, 4, 3.5, 3.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1
Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2015 Microsoft