InkOverlay.Stroke Event

  • Artículo

InkOverlay.Stroke Event

Occurs when the user finishes drawing a new stroke on any tablet.

Definition

Visual Basic .NET Public Event Stroke As InkCollectorStrokeEventHandler
C# public event InkCollectorStrokeEventHandler Stroke;
Managed C++ public: __event InkCollectorStrokeEventHandler Stroke;

Remarks

The event handler receives an argument of type InkCollectorStrokeEventArgs that contains data about this event.

When you create an InkCollectorStrokeEventHandler delegate, you identify the method that will handle the event. To associate the event with your event handler, add an instance of the delegate to the event. The event handler is called whenever the event occurs, unless you remove the delegate. The default event interest is on.

The Stroke event is fired when in select or erase mode, not just when inserting ink. This requires that you monitor the editing mode (which you are responsible for setting) and be aware of the mode before interpreting the event. The advantage of this requirement is greater freedom to innovate on the platform through greater awareness of platform events.

Note: The Stroke event fires when the user finishes drawing a stroke, not when a stroke is added to the Strokes collection. When the user first starts to draw a stroke, it is added immediately to the Strokes collection; however, the Stroke event does not fire until the stroke is complete. Therefore, strokes can exist in the Strokes collection that the Stroke event handler has not seen.

Examples

[C#]

This C# example demonstrates using the Stroke event handler to store a custom property in each stroke that contains a timestamp, by using the ExtendedProperties member. This sample started with a generated C# application and added a button and a list box to the main form. Each stroke drawn on the form stores a timestamp in its extended properties. When the button is pressed, the list box is filled with a list of the timestamps of the strokes.

//...
using Microsoft.Ink;

namespace CS_StrokeEvent
{
    public class Form1 : System.Windows.Forms.Form
    {
        private System.Windows.Forms.ListBox listBox1;
        private System.Windows.Forms.Button button1;

        //...

        // Add the following after Main() in the generated code.

        InkOverlay theInkOverlay;
        // This GUID constant will be used for the strokes'
        // timestamp extended property.
        Guid theTimeGuid = new Guid(10, 11, 12, 10, 0, 0, 0, 0, 0, 0, 0);

        private void Form1_Load(object sender, System.EventArgs e)
        {
            // Initialize the InkOverlay with the form's
            // window handle, then enable it.
            theInkOverlay = new InkOverlay(Handle);
            theInkOverlay.Enabled = true;
            // Add a handler for Stroke Events so we can record
            // an extended property with each one.
            theInkOverlay.Stroke += new InkCollectorStrokeEventHandler(TheStrokeHandler);
        }

        public void TheStrokeHandler(object sender, InkCollectorStrokeEventArgs e)
        {
            // Write the current time into this stroke.
            // First get the time as a long.
            long theTime = DateTime.Now.ToFileTime();
            // Store the data under the Guid key.
            e.Stroke.ExtendedProperties.Add(theTimeGuid, theTime);
        }

        private void PopulateList()
        {
            //Clear the list before repopulating it.
            listBox1.Items.Clear();
            // Query the InkOverlay's Ink for its strokes collection.
            Strokes theStrokes = theInkOverlay.Ink.Strokes;
            foreach (Stroke theStroke in theStrokes)
            {
                // Test for the timestamp property on this stroke.
                if (theStroke.ExtendedProperties.DoesPropertyExist(theTimeGuid))
                {
                    // Get the raw data out of this stroke's extended
                    // properties list, using the previously defined
                    // Guid as a key to the wanted extended property.
                    long theLong = (long)theStroke.ExtendedProperties[theTimeGuid].Data;
                    // Then turn it (as a FileTime) into a time string.
                    string theTime = DateTime.FromFileTime(theLong).ToString();
                    // Add the string to the listbox.
                    listBox1.Items.Add(theTime);
                }
            }
        }

        private void button1_Click(object sender, System.EventArgs e)
        {
            PopulateList();
        }

        // Event handler for the form's closed event
        private void Form1_Closed(object sender, System.EventArgs e)
        {
            theInkOverlay.Dispose();
            theInkOverlay = null;
        }
    }
}

[Visual Basic .NET]

This Microsoft® Visual Basic® .NET example demonstrates using the Stroke event handler to store a custom property in each stroke that contains a timestamp, by using the ExtendedProperties member. This sample started with a generated Visual Basic .NET application and added a button and a list box to the main form. Each stroke drawn on the form stores a timestamp in its extended properties. When the button is pressed, the list box is filled with a list of the timestamps of the strokes.

Imports Microsoft.Ink
Public Class Form1
    Inherits System.Windows.Forms.Form

#Region " Windows Form Designer generated code "
'... This section is generated automatically.
#End Region

    Private theInkOverlay As InkOverlay
    ' This GUID constant will be used for the strokes'
    ' timestamp extended property.
    Public theTimeGuid As Guid = _
        New Guid(10, 11, 12, 10, 0, 0, 0, 0, 0, 0, 0)

    Private Sub Form1_Load(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles MyBase.Load
        'Add the InkOverlay initialization and Stroke event handler.
        theInkOverlay = New InkOverlay(Handle)
        theInkOverlay.Enabled = True
        AddHandler theInkOverlay.Stroke, AddressOf TheStrokeHandler
    End Sub

    Public Sub TheStrokeHandler( _
    ByVal sender As Object, _
    ByVal e As InkCollectorStrokeEventArgs)
        ' Write the current time into this stroke.
        ' First, get the current time as a Long FileTime.
        Dim theTime As Long = DateTime.Now.ToFileTime()
        ' Then store this value using the Guid
        ' as a unique retrieval key.
        e.Stroke.ExtendedProperties.Add(theTimeGuid, theTime)
    End Sub

    Public Sub PopulateList()
        ' Clear the list before repopulating it.
        ListBox1.Items.Clear()
        ' Query the InkOverlay's Ink for its strokes collection.
        Dim theStrokes As Strokes = theInkOverlay.Ink.Strokes
        Dim theStroke As Stroke
        For Each theStroke In theStrokes
            ' If the timestamp property exists in this stroke:
            If _
            theStroke.ExtendedProperties.DoesPropertyExist(theTimeGuid) _
            Then
                Dim theLong As Long
                Dim theTime As String
                ' Get the raw data out of this stroke's extended
                ' properties list, using the previously defined
                ' Guid as a key to the extended property we want.
                theLong = theStroke.ExtendedProperties(theTimeGuid).Data
                ' Then turn that Long (as a FileTime) into a string.
                theTime = DateTime.FromFileTime(theLong).ToString()
                ListBox1.Items.Add(theTime)
            End If
        Next
    End Sub

    Private Sub Button1_Click(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles Button1.Click
        PopulateList()
    End Sub

    'Event handler for the form's closed event
    Private Sub Form1_Closed(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Closed
        theInkOverlay.Dispose()
        Set theInkOverlay = Nothing
    End Sub
End Class

See Also