StylusPlugIn Klasse

Referenz

Definition

Namespace:: System.Windows.Input.StylusPlugIns

Assembly:: PresentationCore.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt ein Plug-In dar, das der StylusPlugIns-Eigenschaft eines Steuerelements hinzugefügt werden kann.

public ref class StylusPlugIn abstract

public abstract class StylusPlugIn

type StylusPlugIn = class

Public MustInherit Class StylusPlugIn

Vererbung: Object
StylusPlugIn

Abgeleitet: System.Windows.Input.StylusPlugIns.DynamicRenderer

Beispiele

Im folgenden Beispiel wird eine benutzerdefinierte Benutzerdefinierte StylusPlugIn erstellt, die die Freihandeingabe auf einen bestimmten Bereich des Steuerelements beschränkt.

// EventArgs for the StrokeRendered event.
public class StrokeRenderedEventArgs : EventArgs
{
    StylusPointCollection strokePoints;

    public StrokeRenderedEventArgs(StylusPointCollection points)
    {
        strokePoints = points;
    }

    public StylusPointCollection StrokePoints
    {
        get
        {
            return strokePoints;
        }
    }
}

// EventHandler for the StrokeRendered event.
public delegate void StrokeRenderedEventHandler(object sender, StrokeRenderedEventArgs e);

// A StylusPlugin that restricts the input area
class FilterPlugin : StylusPlugIn
{
    StylusPointCollection collectedPoints;
    int currentStylus = -1;
    public event StrokeRenderedEventHandler StrokeRendered;

    protected override void OnStylusDown(RawStylusInput rawStylusInput)
    {
        // Run the base class before modifying the data
        base.OnStylusDown(rawStylusInput);

        if (currentStylus == -1)
        {
            StylusPointCollection pointsFromEvent = rawStylusInput.GetStylusPoints();

            // Create an emtpy StylusPointCollection to contain the filtered
            // points.
            collectedPoints = new StylusPointCollection(pointsFromEvent.Description);
            
            // Restrict the stylus input and add the filtered 
            // points to collectedPoints. 
            StylusPointCollection points = FilterPackets(pointsFromEvent);
            rawStylusInput.SetStylusPoints(points);
            collectedPoints.Add(points);

            currentStylus = rawStylusInput.StylusDeviceId;
        }
    }

    protected override void OnStylusMove(RawStylusInput rawStylusInput)
    {
        // Run the base class before modifying the data
        base.OnStylusMove(rawStylusInput);

        if (currentStylus == rawStylusInput.StylusDeviceId)
        {
            StylusPointCollection pointsFromEvent = rawStylusInput.GetStylusPoints();

            // Restrict the stylus input and add the filtered 
            // points to collectedPoints. 
            StylusPointCollection points = FilterPackets(pointsFromEvent);
            rawStylusInput.SetStylusPoints(points);
            collectedPoints.Add(points);
        }
    }

    protected override void OnStylusUp(RawStylusInput rawStylusInput)
    {
        // Run the base class before modifying the data
        base.OnStylusUp(rawStylusInput);

        if (currentStylus == rawStylusInput.StylusDeviceId)
        {
            StylusPointCollection pointsFromEvent = rawStylusInput.GetStylusPoints();

            // Restrict the stylus input and add the filtered 
            // points to collectedPoints. 
            StylusPointCollection points = FilterPackets(pointsFromEvent);
            rawStylusInput.SetStylusPoints(points);
            collectedPoints.Add(points);

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

            currentStylus = -1;
        }
    }

    private StylusPointCollection FilterPackets(StylusPointCollection stylusPoints)
    {
        // Modify the (X,Y) data to move the points 
        // inside the acceptable input area, if necessary
        for (int i = 0; i < stylusPoints.Count; i++)
        {
            StylusPoint sp = stylusPoints[i];
            if (sp.X < 50) sp.X = 50;
            if (sp.X > 250) sp.X = 250;
            if (sp.Y < 50) sp.Y = 50;
            if (sp.Y > 250) sp.Y = 250;
            stylusPoints[i] = sp;
        }

        // Return the modified StylusPoints.
        return stylusPoints;
    }

    // This 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)
        {
            StylusPointCollection strokePoints = callbackData as StylusPointCollection;

            if (strokePoints == null)
            {
                return;
            }

            // Raise the StrokeRendered event so the consumer of the plugin can
            // add the filtered stroke to its StrokeCollection.
            StrokeRenderedEventArgs e = new StrokeRenderedEventArgs(strokePoints);
            OnStrokeRendered(e);
        }
    }

    protected virtual void OnStrokeRendered(StrokeRenderedEventArgs e)
    {
        if (StrokeRendered != null)
        {
            StrokeRendered(this, e);
        }
    }
}

' EventArgs for the StrokeRendered event.
Public Class StrokeRenderedEventArgs
    Inherits EventArgs

    Private currentStrokePoints As StylusPointCollection

    Public Sub New(ByVal points As StylusPointCollection)

        currentStrokePoints = points

    End Sub


    Public ReadOnly Property StrokePoints() As StylusPointCollection
        Get
            Return currentStrokePoints
        End Get
    End Property
End Class

' EventHandler for the StrokeRendered event.
Public Delegate Sub StrokeRenderedEventHandler(ByVal sender As Object, ByVal e As StrokeRenderedEventArgs) 


' A StylusPlugin that restricts the input area
Class FilterPlugin
    Inherits StylusPlugIn

    Private collectedPoints As StylusPointCollection
    Private currentStylus As Integer = -1
    Public Event StrokeRendered As StrokeRenderedEventHandler


    Protected Overrides Sub OnStylusDown(ByVal rawStylusInput As RawStylusInput)

        ' Run the base class before we modify the data
        MyBase.OnStylusDown(rawStylusInput)

        If currentStylus = -1 Then

            Dim pointsFromEvent As StylusPointCollection = rawStylusInput.GetStylusPoints()

            ' Create an emtpy StylusPointCollection to contain the filtered
            ' points.
            collectedPoints = New StylusPointCollection(pointsFromEvent.Description)

            ' Restrict the stylus input and add the filtered 
            ' points to collectedPoints. 
            Dim points As StylusPointCollection = FilterPackets(pointsFromEvent)
            rawStylusInput.SetStylusPoints(points)
            collectedPoints.Add(points)

            currentStylus = rawStylusInput.StylusDeviceId

        End If

    End Sub


    Protected Overrides Sub OnStylusMove(ByVal rawStylusInput As RawStylusInput)

        ' Run the base class before we modify the data
        MyBase.OnStylusMove(rawStylusInput)

        If currentStylus = rawStylusInput.StylusDeviceId Then

            Dim pointsFromEvent As StylusPointCollection = rawStylusInput.GetStylusPoints()

            ' Restrict the stylus input and add the filtered 
            ' points to collectedPoints. 
            Dim points As StylusPointCollection = FilterPackets(pointsFromEvent)
            rawStylusInput.SetStylusPoints(points)
            collectedPoints.Add(points)

        End If

    End Sub

    Protected Overrides Sub OnStylusUp(ByVal rawStylusInput As RawStylusInput)

        ' Run the base class before we modify the data
        MyBase.OnStylusUp(rawStylusInput)

        If currentStylus = rawStylusInput.StylusDeviceId Then

            Dim pointsFromEvent As StylusPointCollection = rawStylusInput.GetStylusPoints()

            ' Restrict the stylus input and add the filtered 
            ' points to collectedPoints. 
            Dim points As StylusPointCollection = FilterPackets(pointsFromEvent)
            rawStylusInput.SetStylusPoints(points)
            collectedPoints.Add(points)

            RecordPoints(collectedPoints, "collectPoints - StylusUp")
            ' Subscribe to the OnStylusUpProcessed method.
            rawStylusInput.NotifyWhenProcessed(collectedPoints)

            currentStylus = -1

        End If

    End Sub


    Private Function FilterPackets(ByVal stylusPoints As StylusPointCollection) As StylusPointCollection

        ' Modify the (X,Y) data to move the points 
        ' inside the acceptable input area, if necessary.
        Dim i As Integer

        For i = 0 To stylusPoints.Count - 1

            Dim sp As StylusPoint = stylusPoints(i)

            If sp.X < 50 Then
                sp.X = 50
            End If

            If sp.X > 250 Then
                sp.X = 250
            End If

            If sp.Y < 50 Then
                sp.Y = 50
            End If

            If sp.Y > 250 Then
                sp.Y = 250
            End If

            stylusPoints(i) = sp

        Next i

        ' Return the modified StylusPoints.
        Return stylusPoints

    End Function 'FilterPackets

    ' This is called on the application thread.
    Protected Overrides Sub OnStylusUpProcessed(ByVal callbackData As Object, _
                                                ByVal targetVerified As Boolean)

        ' Check that the element actually receive the OnStylusUp input.
        If targetVerified Then
            Dim strokePoints As StylusPointCollection

            strokePoints = CType(callbackData, StylusPointCollection)

            If strokePoints Is Nothing Then
                Return
            End If

            ' Raise the StrokeRendered event so the consumer of the plugin can
            ' add the filtered stroke to its StrokeCollection.
            RecordPoints(strokePoints, "onStylusUpProcessed")
            Dim e As New StrokeRenderedEventArgs(strokePoints)
            OnStrokeRendered(e)
        End If

    End Sub


    Protected Overridable Sub OnStrokeRendered(ByVal e As StrokeRenderedEventArgs)

        RaiseEvent StrokeRendered(Me, e)

    End Sub

    Public Sub RecordPoints(ByVal points As StylusPointCollection, ByVal name As String)

        System.Diagnostics.Debug.WriteLine(name)
        For Each point As StylusPoint In points
            System.Diagnostics.Debug.WriteLine("   x: " & point.X & " y: " & point.Y)
        Next
    End Sub
End Class

Hinweise

Mit der StylusPlugIn Möglichkeit können Sie Objekte auf separaten Threads bearbeiten StylusPoint . Separate Threads werden verwendet, sodass die Freihandeingabe weiterhin als Tablet-Stift Daten eingibt, auch wenn die Anwendung etwas anderes ausführt.

Um Eingabestiftpunkte aus der Hardware abzufangen, erstellen Sie eine Klasse, die von der StylusPlugIn Klasse erbt. Die StylusPlugIn Klasse verfügt über die folgenden Methoden, die Sie überschreiben können, um Objekte in einem Thread im Stiftthreadpool zu bearbeiten StylusPoint .

Die Eingabe des Stifts wird an das Stiftthread an ein Element StylusPlugIn weitergeleitet. Da genaue Treffertests auf dem Stiftthread nicht ausgeführt werden können, erhalten einige Elemente gelegentlich Eingaben, die für andere Elemente vorgesehen sind. Wenn Sie sicherstellen müssen, dass die Eingabe korrekt weitergeleitet wurde, bevor Sie einen Vorgang ausführen, abonnieren und ausführen Sie den Vorgang in der OnStylusDownProcessed, OnStylusMoveProcessedoder OnStylusUpProcessed Methode. Diese Methoden werden vom Hauptanwendungsthread aufgerufen, nachdem genaue Treffertests durchgeführt wurden. Um diese Methoden zu abonnieren, rufen Sie die Methode in der Methode auf, die NotifyWhenProcessed im Stiftthread auftritt. Wenn Sie z. B. in anrufen NotifyWhenProcessed OnStylusMove, tritt dies OnStylusMoveProcessed auf.

Hinweis

Wenn Sie ein StylusPlugIn Steuerelement verwenden, sollten Sie das Plug-In testen und umfassend steuern, um sicherzustellen, dass sie keine unbeabsichtigten Ausnahmen auslösen.

XAML-Textverwendung

Diese Klasse wird in XAML in der Regel nicht verwendet.

Konstruktoren

StylusPlugIn()

Initialisiert eine neue Instanz der StylusPlugIn-Klasse.

Eigenschaften

Element	Ruft das UIElement ab, an das das StylusPlugIn angefügt ist.
ElementBounds	Ruft die zwischengespeicherten Grenzen des Elements ab.
Enabled	Ruft ab oder legt fest, ob das StylusPlugIn aktiv ist.
IsActiveForInput	Ruft ab, ob das StylusPlugIn Eingaben akzeptieren kann.

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
OnAdded()	Tritt auf, wenn der StylusPlugIn einem Element hinzugefügt wird.
OnEnabledChanged()	Tritt ein, wenn sich die Enabled-Eigenschaft ändert.
OnIsActiveForInputChanged()	Tritt ein, wenn sich die IsActiveForInput-Eigenschaft ändert.
OnRemoved()	Tritt ein, wenn das StylusPlugIn aus einem Element entfernt wird.
OnStylusDown(RawStylusInput)	Tritt in einem Thread im Stiftthreadpool auf, wenn der Tablettstift den Digitizer berührt.
OnStylusDownProcessed(Object, Boolean)	Tritt im UI-Thread (User Interface, Benutzeroberfläche) der Anwendung auf, wenn der Tablettstift den Digitizer berührt.
OnStylusEnter(RawStylusInput, Boolean)	Tritt in einem Stiftthread auf, wenn der Cursor in die Grenzen eines Elements eintritt.
OnStylusLeave(RawStylusInput, Boolean)	Tritt in einem Stiftthread auf, wenn der Cursor die Grenzen eines Elements verlässt.
OnStylusMove(RawStylusInput)	Tritt in einem Stiftthread auf, wenn der Tablettstift auf dem Digitizer bewegt wird.
OnStylusMoveProcessed(Object, Boolean)	Tritt im UI-Thread (User Interface, Benutzeroberfläche) der Anwendung auf, wenn der Tablettstift auf dem Digitizer bewegt wird.
OnStylusUp(RawStylusInput)	Tritt in einem Stiftthread auf, wenn der Benutzer den Tablettstift vom Digitizer abhebt.
OnStylusUpProcessed(Object, Boolean)	Tritt im UI-Thread (User Interface, Benutzeroberfläche) der Anwendung auf, wenn der Benutzer den Tablettstift vom Digitizer abhebt.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Gilt für

Freigeben über