InkAnalyzerBase.AddStrokes-Methode (array<Int32[], array<Int32[], array<Int32[], array<Guid[], Int32)

Artikel
11/26/2008

Fügt dem Freihandanalysemodul Strichdaten für mehrere Striche hinzu und weist den Strichen den angegebenen Kulturbezeichner zu.

Namespace: System.Windows.Ink.AnalysisCore
Assembly: IACore (in IACore.dll)

Syntax

'Declaration
Public Function AddStrokes ( _
    strokeIdsToAdd As Integer(), _
    strokePacketCount As Integer(), _
    strokePacketData As Integer(), _
    strokePacketDescription As Guid(), _
    languageId As Integer _
) As ContextNodeBase
'Usage
Dim instance As InkAnalyzerBase
Dim strokeIdsToAdd As Integer()
Dim strokePacketCount As Integer()
Dim strokePacketData As Integer()
Dim strokePacketDescription As Guid()
Dim languageId As Integer
Dim returnValue As ContextNodeBase

returnValue = instance.AddStrokes(strokeIdsToAdd, _
    strokePacketCount, strokePacketData, _
    strokePacketDescription, languageId)

public ContextNodeBase AddStrokes(
    int[] strokeIdsToAdd,
    int[] strokePacketCount,
    int[] strokePacketData,
    Guid[] strokePacketDescription,
    int languageId
)

public:
ContextNodeBase^ AddStrokes(
    array<int>^ strokeIdsToAdd, 
    array<int>^ strokePacketCount, 
    array<int>^ strokePacketData, 
    array<Guid>^ strokePacketDescription, 
    int languageId
)

public ContextNodeBase AddStrokes(
    int[] strokeIdsToAdd,
    int[] strokePacketCount,
    int[] strokePacketData,
    Guid[] strokePacketDescription,
    int languageId
)

public function AddStrokes(
    strokeIdsToAdd : int[], 
    strokePacketCount : int[], 
    strokePacketData : int[], 
    strokePacketDescription : Guid[], 
    languageId : int
) : ContextNodeBase

Parameter

strokeIdsToAdd
Typ: array<System.Int32[]
Ein Array, das die Strichbezeichner enthält.

strokePacketCount
Typ: array<System.Int32[]
Ein Array, das die Anzahl der Pakete in den einzelnen Strichen enthält.

strokePacketData
Typ: array<System.Int32[]
Ein Array, das die Paketdaten für die Striche enthält.

strokePacketDescription
Typ: array<System.Guid[]
Ein Array, das die Eigenschaftenbezeichner für Pakete enthält.

languageId
Typ: System.Int32
Der Kulturbezeichner, der dem Strich zugewiesen werden soll.

Rückgabewert

Typ: System.Windows.Ink.AnalysisCore.ContextNodeBase
Der Kontextknoten, dem das Freihandanalysemodul die Striche hinzugefügt hat.

Hinweise

InkAnalyzerBase fügt die Striche einer ContextNodeBase hinzu, die über einen Type-Eigenschaftswert von UnclassifiedInk() verfügt.

Das Freihandanalysemodul weist den Strichen den angegebenen Kulturbezeichner zu. Anschließend fügt es die Striche dem ersten nicht klassifizierten Freihandknoten unter dem Stammknoten des Freihanderkennungsmodul hinzu, der Striche mit demselben Kulturbezeichner enthält. Wenn das Freihandanalysemodul keinen Knoten mit demselben Kulturbezeichner finden kann, erstellt es einen ContextNodeBase unter seinem Stammknoten und fügt die Striche dem neuen nicht klassifizierten Freihandknoten hinzu.

strokePacketData enthält Paketdaten für alle Striche. strokePacketDescription enthält die GUIDs (Globally Unique Identifier), die die Paketdatentypen beschreiben, die für die einzelnen Punkte im Strich enthalten sind. Eine vollständige Liste der verfügbaren Paketeigenschaften finden Sie unter der PacketProperty-Klasse.

In einem einzelnen Aufruf von AddStrokes können nur Striche mit gleichen Paketbeschreibungen hinzugefügt werden.

Bei dieser Methode wird der DirtyRegion auf die Gesamtmenge des aktuellen Werts des Bereichs und des umgebenden Felds für die hinzugefügten Striche erweitert.

Wenn InkAnalyzerBase bereits einen Strich mit demselben Bezeichner wie einer der hinzuzufügenden Striche enthält, löst InkAnalyzerBase eine Ausnahme aus.

Beispiele

In diesem Beispiel wird eine Methode definiert, die eine Strokes-Auflistung in Paketdaten umwandelt und die Striche einem InkAnalyzerBase hinzufügt. Die Methode gibt die ContextNodeBase zurück, der das Freihandanalysemodul die Striche hinzugefügt hat.

''' <summary>
''' Adds a collection of strokes to an InkAnalyzerBase and assigns a
''' language identifier to each stroke.
''' </summary>
''' <param name="baseInkAnalyzer">
''' The analyzer that receives the strokes.</param>
''' <param name="theStrokes">The strokes to add.</param>
''' <param name="languageIdentifier">
''' The language identifier to assign to the strokes.</param>
''' <returns>The node to which the analyzer added the strokes.</returns>
''' <remarks>
''' This method converts stroke data to packet data for example only.
''' The InkAnalyzerBase is used when your application is handling packet
''' data. If your application uses stroke data from an Ink object, then
''' you would use InkAnalyzer.
''' </remarks>
Public Overloads Shared Function MyAddStrokes( _
ByVal baseInkAnalyzer As System.Windows.Ink.AnalysisCore.InkAnalyzerBase, _
ByVal theStrokes As Microsoft.Ink.Strokes, _
ByVal languageIdentifier As Integer) _
As System.Windows.Ink.AnalysisCore.ContextNodeBase
    ' Check that the parameters are valid
    If Nothing Is baseInkAnalyzer Then
        Throw New ArgumentNullException("baseInkAnalyzer")
    End If

    If Nothing Is theStrokes Then
        Throw New ArgumentNullException("theStrokes")
    End If

    If 0 = theStrokes.Count Then
        Throw New ArgumentException("Empty strokes collection.")
    End If

    ' Only strokes that have the same packet description GUIDs
    ' can be added in one call to InkAnalyzerBase.AddStrokes.
    Dim thePacketDescription As Guid() = theStrokes(0).PacketDescription

    ' Accumulate the stroke data in collections.
    Dim theStrokeIdentifiers As New ArrayList()
    Dim thePacketCounts As New ArrayList()
    Dim thePacketData As New ArrayList()

    Dim aStroke As Microsoft.Ink.Stroke
    For Each aStroke In theStrokes
        If Not InkAnalyzerHelper.AreElementwiseEquivalent( _
            aStroke.PacketDescription, thePacketDescription) Then

            Throw New ApplicationException( _
                "The strokes collection contains strokes with different packet descriptions.")
        End If

        ' Add the stroke data to the collections.
        theStrokeIdentifiers.Add(aStroke.Id)
        thePacketCounts.Add(aStroke.PacketCount)
        thePacketData.AddRange(aStroke.GetPacketData())
    Next aStroke

    ' Add the stroke data to the base layer ink analyzer.
    Dim result As System.Windows.Ink.AnalysisCore.ContextNodeBase = baseInkAnalyzer.AddStrokes( _
        DirectCast(theStrokeIdentifiers.ToArray(GetType(Integer)), Integer()), _
        DirectCast(thePacketCounts.ToArray(GetType(Integer)), Integer()), _
        DirectCast(thePacketData.ToArray(GetType(Integer)), Integer()), _
        thePacketDescription)

    Return result

End Function 'AddStrokes

/// <summary>
/// Adds a collection of strokes to an InkAnalyzerBase and assigns a
/// language identifier to each stroke.
/// </summary>
/// <param name="baseInkAnalyzer">
/// The analyzer that receives the strokes.</param>
/// <param name="theStrokes">The strokes to add.</param>
/// <param name="languageIdentifier">
/// The language identifier to assign to the strokes.</param>
/// <returns>The node to which the analyzer added the strokes.</returns>
/// <remarks>
/// This method converts stroke data to packet data for example only.
/// The InkAnalyzerBase is used when your application is handling packet
/// data. If your application uses stroke data from an Ink object, then
/// you would use InkAnalyzer.
/// </remarks>
public static System.Windows.Ink.AnalysisCore.ContextNodeBase MyAddStrokes(
System.Windows.Ink.AnalysisCore.InkAnalyzerBase baseInkAnalyzer,
    Microsoft.Ink.Strokes theStrokes,
    int languageIdentifier)
{
    // Check that the parameters are valid
    if (null == baseInkAnalyzer)
    {
        throw new ArgumentNullException("baseInkAnalyzer");
    }

    if (null == theStrokes)
    {
        throw new ArgumentNullException("theStrokes");
    }

    if (0 == theStrokes.Count)
    {
        throw new ArgumentException("Empty strokes collection.");
    }

    // Only strokes that have the same packet description GUIDs
    // can be added in one call to InkAnalyzerBase.AddStrokes.
    Guid[] thePacketDescription = theStrokes[0].PacketDescription;

    // Accumulate the stroke data in collections.
    ArrayList theStrokeIdentifiers = new ArrayList();
    ArrayList thePacketCounts = new ArrayList();
    ArrayList thePacketData = new ArrayList();

    foreach (Microsoft.Ink.Stroke aStroke in theStrokes)
    {
        if (!InkAnalyzerHelper.AreElementwiseEquivalent(
            aStroke.PacketDescription, thePacketDescription))
        {
            throw new ApplicationException(
                "The strokes collection contains strokes with different packet descriptions.");
        }

        // Add the stroke data to the collections.
        theStrokeIdentifiers.Add(aStroke.Id);
        thePacketCounts.Add(aStroke.PacketCount);
        thePacketData.AddRange(aStroke.GetPacketData());
    }

    // Add the stroke data to the base layer ink analyzer.
    System.Windows.Ink.AnalysisCore.ContextNodeBase result = baseInkAnalyzer.AddStrokes(
        theStrokeIdentifiers.ToArray(typeof(int)) as int[],
        thePacketCounts.ToArray(typeof(int)) as int[],
        thePacketData.ToArray(typeof(int)) as int[],
        thePacketDescription,
        languageIdentifier);

    return result;
}

Plattformen

Windows Vista, Windows XP SP2, Windows Server 2003

.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.