InkAnalyzerBase.AddStrokes, méthode (array<Int32[], array<Int32[], array<Int32[], array<Guid[], Int32)

Article
11/05/2008

Mise à jour : November 2007

Ajoute des données de trait à l'analyseur d'entrée manuscrite pour plusieurs traits et assigne aux traits l'identificateur de culture spécifié.

Espace de noms : System.Windows.Ink.AnalysisCore
Assembly : IACore (dans IACore.dll)

Syntaxe

'Déclaration
Public Function AddStrokes ( _
    strokeIdsToAdd As Integer(), _
    strokePacketCount As Integer(), _
    strokePacketData As Integer(), _
    strokePacketDescription As Guid(), _
    languageId As Integer _
) As ContextNodeBase
'Utilisation
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

Paramètres

strokeIdsToAdd
Type : array<System.Int32[]
Tableau contenant les identificateurs des traits.

strokePacketCount
Type : array<System.Int32[]
Tableau contenant le nombre de paquets de chaque trait.

strokePacketData
Type : array<System.Int32[]
Tableau contenant les données de paquet des traits.

strokePacketDescription
Type : array<System.Guid[]
Tableau contenant les identificateurs de la propriété du paquet.

languageId
Type : System.Int32
Identificateur de culture à assigner au trait.

Valeur de retour

Type : System.Windows.Ink.AnalysisCore.ContextNodeBase
Nœud de contexte auquel l'analyseur d'entrée manuscrite a ajouté les traits.

Notes

Le InkAnalyzerBase ajoute les traits à un ContextNodeBase dont la propriété Type a la valeur UnclassifiedInk().

L'analyseur d'entrée manuscrite assigne aux traits l'identificateur de culture spécifié. Il ajoute ensuite les traits au premier nœud d'entrée manuscrite non classifié sous le nœud racine de l'analyseur d'entrée manuscrite qui contient des traits présentant le même identificateur de culture. Si l'analyseur d'entrée manuscrite ne trouve pas de nœud présentant le même identificateur de culture, il crée un ContextNodeBase sous son nœud racine et ajoute les traits au nouveau nœud d'entrée manuscrite non classifié.

strokePacketData contient des données de paquet pour tous les traits. strokePacketDescription contient les identificateurs globaux uniques (GUID) qui décrivent les types de données de paquet pour chaque point du trait. Pour obtenir la liste des propriétés de paquet disponibles, consultez la classe PacketProperty.

Seuls les traits avec les mêmes descriptions de paquet peuvent être ajoutés dans un appel unique de AddStrokes.

Cette méthode étend la propriété DirtyRegion à l'union de la valeur actuelle de la région et du cadre englobant des traits ajoutés.

Si le InkAnalyzerBase contient déjà un trait présentant le même identificateur que l'un des traits à ajouter, le InkAnalyzerBase lève une exception.

Exemples

Cet exemple définit une méthode qui convertit une collection Strokes en données de paquet et ajoute les traits à un InkAnalyzerBase. La méthode retourne le ContextNodeBase auquel l'analyseur d'entrée manuscrite a ajouté les traits.

''' <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;
}

Plateformes

Windows Vista, Windows XP SP2, Windows Server 2003

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.