InkAnalyzer.InkAnalyzerStateChanging-Ereignis

Artikel
11/26/2008

Tritt auf, bevor der InkAnalyzer Analyseergebnisse abgleicht, damit eine Anwendung Daten mit dem InkAnalyzer synchronisieren kann.

Namespace: Microsoft.Ink
Assembly: Microsoft.Ink.Analysis (in Microsoft.Ink.Analysis.dll)

Syntax

'Declaration
Public Event InkAnalyzerStateChanging As InkAnalyzerStateChangingEventHandler
'Usage
Dim instance As InkAnalyzer
Dim handler As InkAnalyzerStateChangingEventHandler

AddHandler instance.InkAnalyzerStateChanging, handler

public event InkAnalyzerStateChangingEventHandler InkAnalyzerStateChanging

public:
 event InkAnalyzerStateChangingEventHandler^ InkAnalyzerStateChanging {
    void add (InkAnalyzerStateChangingEventHandler^ value);
    void remove (InkAnalyzerStateChangingEventHandler^ value);
}

/** @event */
public void add_InkAnalyzerStateChanging (InkAnalyzerStateChangingEventHandler value)
/** @event */
public void remove_InkAnalyzerStateChanging (InkAnalyzerStateChangingEventHandler value)

JScript unterstützt keine Ereignisse.

Hinweise

Verwenden Sie dieses Ereignis, wenn die Anwendung eine eigene Datenstruktur verwaltet, die mit der Datenstruktur von InkAnalyzer synchronisiert wird. Wenn InkAnalyzer dieses Ereignis auslöst, sollte die Anwendung die SubNodes-Eigenschaft für den RootNode des InkAnalyzer-Objekts auffüllen. Während der Abgleichphase verwendet InkAnalyzer diese Informationen zur Analyse und Erkennung von Freihandeingaben.

Der InkAnalyzer löst dieses Ereignis aus, nachdem er das ReadyToReconcile-Ereignis ausgelöst hat. Dieses Ereignis wird nur während der Hintergrundanalyse ausgelöst.

Sperren Sie die Datenstruktur, wenn das Freihandanalysemodul das InkAnalyzerStateChanging-Ereignis auslöst. Änderungen an der Datenstruktur während dieser Phase der Analyse können zu Fehlern in der Freihandanalyse und -synchronisierung führen. Sie können die Datenstruktur entsperren, wenn das Freihandanalysemodul das IntermediateResultsUpdated-Ereignis oder das ResultsUpdated-Ereignis auslöst.

Weitere Informationen über das Synchronisieren von Anwendungsdaten mit InkAnalyzer finden Sie unter Data Proxy with Ink Analysis.

Beispiele

In diesem Beispiel wird eine Methode mit dem Namen AttachDataProxyEventHandlers definiert, die Datenproxyereignishandler an einen InkAnalyzer mit dem Namen theInkAnalyzer anfügt.

Private Sub AttachDataProxyEventHandlers() 
    ' If the document model supports on demand data proxy, then add an
    ' event handler for the PopulateContextNode event. This event is raised
    ' when the InkAnalyzer accesses a partially populated ContextNode created
    ' by the document model.
    If Me.theDocumentModel.SupportsOnDemandDataProxy Then
        AddHandler Me.theInkAnalyzer.PopulateContextNode, AddressOf Me.PopulateContextNode
    End If

    ' Add the other data proxy related event handlers. These events are raised
    ' by the InkAnalyzer to communicate ink analysis results to the document model.
    AddHandler Me.theInkAnalyzer.ContextNodeCreated, AddressOf Me.AddContextNode
    AddHandler Me.theInkAnalyzer.ContextNodeDeleting, AddressOf Me.RemoveContextNode
    AddHandler Me.theInkAnalyzer.ContextNodeLinkAdding, AddressOf Me.AddContextNodeLink
    AddHandler Me.theInkAnalyzer.ContextNodeLinkDeleting, AddressOf Me.RemoveContextNodeLink
    AddHandler Me.theInkAnalyzer.ContextNodeMovingToPosition, AddressOf Me.MoveContextNodeToPosition
    AddHandler Me.theInkAnalyzer.ContextNodePropertiesUpdated, AddressOf Me.UpdateContextNodeProperties
    AddHandler Me.theInkAnalyzer.ContextNodeReparenting, AddressOf Me.ReparentContextNode
    AddHandler Me.theInkAnalyzer.InkAnalyzerStateChanging, AddressOf Me.InkAnalyzer_StateChanging
    AddHandler Me.theInkAnalyzer.StrokesReparented, AddressOf Me.ReparentStroke
    AddHandler Me.theInkAnalyzer.IntermediateResultsUpdated, AddressOf Me.ResultsAvailable
    AddHandler Me.theInkAnalyzer.ResultsUpdated, AddressOf Me.ResultsAvailable

End Sub 'AttachDataProxyEventHandlers

        private void AttachDataProxyEventHandlers()
        {
            // If the document model supports on demand data proxy, then add an
            // event handler for the PopulateContextNode event. This event is raised
            // when the InkAnalyzer accesses a partially populated ContextNode created
            // by the document model.
            if (this.theDocumentModel.SupportsOnDemandDataProxy)
            {
                this.theInkAnalyzer.PopulateContextNode +=
                    new Microsoft.Ink.PopulateContextNodeEventHandler(
                        this.PopulateContextNode);
            }

            // Add the other data proxy related event handlers. These events are raised
            // by the InkAnalyzer to communicate ink analysis results to the document model.
            this.theInkAnalyzer.ContextNodeCreated +=
                new Microsoft.Ink.ContextNodeCreatedEventHandler(
                    this.AddContextNode);
            this.theInkAnalyzer.ContextNodeDeleting +=
                new Microsoft.Ink.ContextNodeDeletingEventHandler(
                    this.RemoveContextNode);
            this.theInkAnalyzer.ContextNodeLinkAdding +=
                new Microsoft.Ink.ContextNodeLinkAddingEventHandler(
                    this.AddContextNodeLink);
            this.theInkAnalyzer.ContextNodeLinkDeleting +=
                new Microsoft.Ink.ContextNodeLinkDeletingEventHandler(
                    this.RemoveContextNodeLink);
            this.theInkAnalyzer.ContextNodeMovingToPosition +=
                new Microsoft.Ink.ContextNodeMovingToPositionEventHandler(
                    this.MoveContextNodeToPosition);
            this.theInkAnalyzer.ContextNodePropertiesUpdated +=
                new Microsoft.Ink.ContextNodePropertiesUpdatedEventHandler(
                    this.UpdateContextNodeProperties);
            this.theInkAnalyzer.ContextNodeReparenting +=
                new Microsoft.Ink.ContextNodeReparentingEventHandler(
                    this.ReparentContextNode);
            this.theInkAnalyzer.InkAnalyzerStateChanging +=
                new Microsoft.Ink.InkAnalyzerStateChangingEventHandler(
                    this.InkAnalyzer_StateChanging);
            this.theInkAnalyzer.StrokesReparented +=
                new Microsoft.Ink.StrokesReparentedEventHandler(
                    this.ReparentStrokes);
            this.theInkAnalyzer.IntermediateResultsUpdated +=
                new Microsoft.Ink.ResultsUpdatedEventHandler(
                    this.ResultsAvailable);
            this.theInkAnalyzer.ResultsUpdated +=
                new Microsoft.Ink.ResultsUpdatedEventHandler(
                    this.ResultsAvailable);
        }

Im folgenden Beispiel wird die InkAnalyzer_StateChanging-Methode definiert, die das InkAnalyzerStateChanging-Ereignis behandelt. Die Ereignisinformationen werden an das Dokumentmodellobjekt theDocumentModel übergeben.

Dieses Beispiel liefert nicht die Definition des Dokumentmodells und veranschaulicht nicht, wie die übergebenen Informationen verarbeitet werden.

'/ <summary>
'/ Handles the InkAnalyzer.InkAnalyzerStateChanging event.
'/ </summary>
'/ <param name="sender">The source of the event.</param>
'/ <param name="e">The event data.</param>
Private Sub InkAnalyzer_StateChanging( _
    ByVal sender As Object, _
    ByVal e As System.EventArgs)

    Me.theDocumentModel.BeginReconcilePhase()

End Sub 'InkAnalyzer_StateChanging

/// <summary>
/// Handles the InkAnalyzer.InkAnalyzerStateChanging event.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The event data.</param>
private void InkAnalyzer_StateChanging(object sender, System.EventArgs e)
{
    this.theDocumentModel.BeginReconcilePhase();
}

Plattformen

Windows Vista

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.