InkAnalyzerBase.AddStrokes (Método) (array<Int32[], array<Int32[], array<Int32[], array<Guid[])

Artículo
10/28/2008

Actualización: noviembre 2007

Agrega datos de trazo para varios trazos al analizador de entrada manuscrita y asigna a los trazos el identificador de referencia cultural del subproceso de entrada activo.

Espacio de nombres: System.Windows.Ink.AnalysisCore
Ensamblado: IACore (en IACore.dll)

Sintaxis

'Declaración
Public Function AddStrokes ( _
    strokeIdsToAdd As Integer(), _
    strokePacketCount As Integer(), _
    strokePacketData As Integer(), _
    strokePacketDescription As Guid() _
) As ContextNodeBase
'Uso
Dim instance As InkAnalyzerBase
Dim strokeIdsToAdd As Integer()
Dim strokePacketCount As Integer()
Dim strokePacketData As Integer()
Dim strokePacketDescription As Guid()
Dim returnValue As ContextNodeBase

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

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

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

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

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

Parámetros

strokeIdsToAdd
Tipo: array<System.Int32[]
Matriz que contiene los identificadores de los trazos.

strokePacketCount
Tipo: array<System.Int32[]
Matriz que contiene el número de paquetes de cada trazo.

strokePacketData
Tipo: array<System.Int32[]
Matriz que contiene los datos del paquete de los trazos.

strokePacketDescription
Tipo: array<System.Guid[]
Matriz que contiene los identificadores de las propiedades del paquete.

Valor devuelto

Tipo: System.Windows.Ink.AnalysisCore.ContextNodeBase
Nodo de contexto al que el analizador de entrada manuscrita agregó los trazos.

Comentarios

El objeto InkAnalyzerBase agrega los trazos a un objeto ContextNodeBase que tiene una propiedad Type con un valor de UnclassifiedInk().

El analizador de entrada manuscrita asigna el identificador de referencia cultural del subproceso de entrada activo a los trazos. Después, agrega los trazos al primer nodo de entrada manuscrita no clasificado que está situado bajo el nodo raíz del analizador de entrada manuscrita que contiene trazos con el mismo identificador de referencia cultural. Si el analizador de entrada manuscrita no encuentra un nodo con el mismo identificador de referencia cultural, crea un nuevo objeto ContextNodeBase bajo su nodo raíz y agrega los trazos al nuevo nodo de entrada manuscrita no clasificado.

strokePacketData contiene datos de paquete para todos los trazos. strokePacketDescription contiene los identificadores únicos globales (GUID) que describen los tipos de datos de paquete incluidos para cada punto de cada trazo. Para obtener una lista completa de las propiedades del paquete disponibles, vea la clase PacketProperty.

Sólo se pueden agregar trazos con las mismas descripciones de paquete en una única llamada a AddStrokes.

Este método expande la propiedad DirtyRegion a la unión del valor actual de la región y el cuadro de límite de los trazos agregados.

Si InkAnalyzerBase ya contiene un trazo con el mismo identificador que uno de los trazos que se van a agregar, InkAnalyzerBase inicia una excepción.

Ejemplos

En este ejemplo, se define un método que convierte una colección Strokes en datos de paquete y agrega los trazos a un objeto InkAnalyzerBase. El método devuelve el objeto ContextNodeBase al que el analizador de entrada manuscrita agregó los trazos.

''' <summary>
''' Adds a collection of strokes to an InkAnalyzerBase.
''' </summary>
''' <param name="baseInkAnalyzer">
''' The analyzer that receives the strokes.</param>
''' <param name="theStrokes">The strokes to add.</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) _
As System.Windows.Ink.AnalysisCore.ContextNodeBase
    ' Check that the parameters are valid
    If baseInkAnalyzer Is Nothing Then
        Throw New ArgumentNullException("baseInkAnalyzer")
    End If

    If theStrokes Is Nothing 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.
/// </summary>
/// <param name="baseInkAnalyzer">
/// The analyzer that receives the strokes.</param>
/// <param name="theStrokes">The strokes to add.</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)
{
    // 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);

    return result;
}

Plataformas

Windows Vista, Windows XP SP2, Windows Server 2003

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.