Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés
Esta documentación está archivada y no tiene mantenimiento.

Creación de un control de entrada manuscrita

Puede crear un control personalizado que represente la entrada de lápiz de forma dinámica y estática. Es decir, es posible representar la entrada de lápiz mientras el usuario dibuja el trazo, con lo que parece "fluir" del lápiz de Tablet PC, y mostrar la entrada de lápiz una vez agregada al control, bien a través del lápiz de Tablet PC, pegada desde el Portapapeles o cargada desde un archivo. Para representar dinámicamente la entrada de lápiz, el control debe usar DynamicRenderer. Para representar estáticamente la entrada de lápiz, debe invalidar los métodos de evento de lápiz (OnStylusDown, OnStylusMove y OnStylusUp) para recopilar los datos de StylusPoint, crear los trazos y agregarlos a un objeto InkPresenter (que representa la entrada de lápiz en el control).

Este tema contiene las siguientes subsecciones:

Para crear un control que recopile y administre los trazos de entrada de lápiz, realice estas acciones:

  1. Derive una clase de Control o una de las clases derivadas de Control, como Label.

    
    using System;
    using System.Windows.Ink;
    using System.Windows.Input;
    using System.Windows.Input.StylusPlugIns;
    using System.Windows.Controls;
    using System.Windows;
    
    
    ...
    
    
    class InkControl : Label
    {
    
    
    ...
    
    
    }
    
    
    
  2. Agregue un objeto InkPresenter a la clase y establezca la propiedad Content en el nuevo objeto InkPresenter.

    
    InkPresenter ip;
    
    public InkControl()
    {
        // Add an InkPresenter for drawing.
        ip = new InkPresenter();
        this.Content = ip;
    }
    
    
    
  3. Asocie la propiedad RootVisual de DynamicRenderer al objeto InkPresenter mediante una llamada al método AttachVisuals y agregue DynamicRenderer a la colección StylusPlugIns. Esto permite a InkPresenter mostrar la entrada de lápiz a medida que el control recopila los datos de los puntos de lápiz.

    
    public InkControl()
    {
    
    
    ...
    
    
        // Add a dynamic renderer that 
        // draws ink as it "flows" from the stylus.
        dr = new DynamicRenderer();
        ip.AttachVisuals(dr.RootVisual, dr.DrawingAttributes);
        this.StylusPlugIns.Add(dr);
    
    }
    
    
    
  4. Invalide el método OnStylusDown. En este método, capture el lápiz con una llamada a Capture. Al capturar el lápiz, su control seguirá recibiendo eventos StylusMove y StylusUp aun cuando el lápiz abandone los límites del control. Esto no es estrictamente obligatorio, pero es deseable en la mayoría de los casos, para mejorar la experiencia del usuario. Cree una nueva StylusPointCollection para recopilar los datos de StylusPoint. Finalmente, agregue el conjunto inicial de datos de StylusPoint a StylusPointCollection.

    
    protected override void OnStylusDown(StylusDownEventArgs e)
    {
        // Capture the stylus so all stylus input is routed to this control.
        Stylus.Capture(this);
    
        // Allocate memory for the StylusPointsCollection and
        // add the StylusPoints that have come in so far.
        stylusPoints = new StylusPointCollection();
        StylusPointCollection eventPoints = 
            e.GetStylusPoints(this, stylusPoints.Description);
    
        stylusPoints.Add(eventPoints);
    
    }
    
    
    
  5. Invalide el método OnStylusMove y agregue los datos de StylusPoint al objeto StylusPointCollection que creó anteriormente.

    
    protected override void OnStylusMove(StylusEventArgs e)
    {
        if (stylusPoints == null)
        {
            return;
        }
    
        // Add the StylusPoints that have come in since the 
        // last call to OnStylusMove.
        StylusPointCollection newStylusPoints = 
            e.GetStylusPoints(this, stylusPoints.Description);
        stylusPoints.Add(newStylusPoints);
    }
    
    
    
  6. Invalide el método OnStylusUp y cree un nuevo objeto Stroke con los datos de StylusPointCollection. Agregue el objeto Stroke que ha creado a la colección Strokes de InkPresenter y libere la captura del lápiz.

    
    protected override void OnStylusUp(StylusEventArgs e)
    {
        if (stylusPoints == null)
        {
            return;
        }
    
        // Add the StylusPoints that have come in since the 
        // last call to OnStylusMove.
        StylusPointCollection newStylusPoints = 
            e.GetStylusPoints(this, stylusPoints.Description);
        stylusPoints.Add(newStylusPoints);
    
        // Create a new stroke from all the StylusPoints since OnStylusDown.
        Stroke stroke = new Stroke(stylusPoints);
    
        // Add the new stroke to the Strokes collection of the InkPresenter.
        ip.Strokes.Add(stroke);
    
        // Clear the StylusPointsCollection.
        stylusPoints = null;
    
        // Release stylus capture.
        Stylus.Capture(null);
    }
    
    
    

Si agrega el control anterior a su aplicación, lo ejecuta y usa el mouse como dispositivo de entrada, observará que no se conservan los trazos. Para conservar los trazos cuando se use el mouse como dispositivo de entrada realice los pasos siguientes:

  1. Invalide el método OnMouseLeftButtonDown y cree un nuevo objeto StylusPointCollection. Obtenga la posición del mouse cuando se produjo el evento, cree un objeto StylusPoint a partir de los datos de los puntos y agregue el objeto StylusPoint a StylusPointCollection.

    
    protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
    {
    
        base.OnMouseLeftButtonDown(e);
    
        // If a stylus generated this event, return.
        if (e.StylusDevice != null)
        {
            return;
        }
    
        // Start collecting the points.
        stylusPoints = new StylusPointCollection();
        Point pt = e.GetPosition(this);
        stylusPoints.Add(new StylusPoint(pt.X, pt.Y));
    
    }
    
    
    
  2. Invalide el método OnMouseMove. Obtenga la posición del mouse cuando se produjo el evento y cree un objeto StylusPoint con los datos de los puntos. Agregue StylusPoint al objeto StylusPointCollection que creó anteriormente.

    
    protected override void OnMouseMove(MouseEventArgs e)
    {
    
        base.OnMouseMove(e);
    
        // If a stylus generated this event, return.
        if (e.StylusDevice != null)
        {
            return;
        }
    
        // Don't collect points unless the left mouse button
        // is down.
        if (e.LeftButton == MouseButtonState.Released || 
            stylusPoints == null)
        {
            return;
        }
    
        Point pt = e.GetPosition(this);
        stylusPoints.Add(new StylusPoint(pt.X, pt.Y));
    }
    
    
    
  3. Invalide el método OnMouseLeftButtonUp. Cree un nuevo objeto Stroke con los datos de StylusPointCollection y agregue el nuevo Stroke que creó a la colección Strokes de InkPresenter.

    
    protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
    {
    
        base.OnMouseLeftButtonUp(e);
    
        // If a stylus generated this event, return.
        if (e.StylusDevice != null)
        {
            return;
        }
    
        if (stylusPoints == null)
        {
            return;
        }
    
        Point pt = e.GetPosition(this);
        stylusPoints.Add(new StylusPoint(pt.X, pt.Y));
    
        // Create a stroke and add it to the InkPresenter.
        Stroke stroke = new Stroke(stylusPoints);
        stroke.DrawingAttributes = dr.DrawingAttributes;
        ip.Strokes.Add(stroke);
    
        stylusPoints = null;
    
    }
    
    
    

En el ejemplo siguiente se ilustra un control personalizado que recopila la entrada de lápiz cuando el usuario emplea el mouse o el lápiz.


using System;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Input.StylusPlugIns;
using System.Windows.Controls;
using System.Windows;


...


// A control for managing ink input
class InkControl : Label
{
    InkPresenter ip;
    DynamicRenderer dr;

    // The StylusPointsCollection that gathers points 
    // before Stroke from is created.
    StylusPointCollection stylusPoints = null;

    public InkControl()
    {
        // Add an InkPresenter for drawing.
        ip = new InkPresenter();
        this.Content = ip;

        // Add a dynamic renderer that 
        // draws ink as it "flows" from the stylus.
        dr = new DynamicRenderer();
        ip.AttachVisuals(dr.RootVisual, dr.DrawingAttributes);
        this.StylusPlugIns.Add(dr);

    }

    static InkControl()
    {
        // Allow ink to be drawn only within the bounds of the control.
        Type owner = typeof(InkControl);
        ClipToBoundsProperty.OverrideMetadata(owner,
            new FrameworkPropertyMetadata(true));
    }

    protected override void OnStylusDown(StylusDownEventArgs e)
    {
        // Capture the stylus so all stylus input is routed to this control.
        Stylus.Capture(this);

        // Allocate memory for the StylusPointsCollection and
        // add the StylusPoints that have come in so far.
        stylusPoints = new StylusPointCollection();
        StylusPointCollection eventPoints = 
            e.GetStylusPoints(this, stylusPoints.Description);

        stylusPoints.Add(eventPoints);

    }

    protected override void OnStylusMove(StylusEventArgs e)
    {
        if (stylusPoints == null)
        {
            return;
        }

        // Add the StylusPoints that have come in since the 
        // last call to OnStylusMove.
        StylusPointCollection newStylusPoints = 
            e.GetStylusPoints(this, stylusPoints.Description);
        stylusPoints.Add(newStylusPoints);
    }

    protected override void OnStylusUp(StylusEventArgs e)
    {
        if (stylusPoints == null)
        {
            return;
        }

        // Add the StylusPoints that have come in since the 
        // last call to OnStylusMove.
        StylusPointCollection newStylusPoints = 
            e.GetStylusPoints(this, stylusPoints.Description);
        stylusPoints.Add(newStylusPoints);

        // Create a new stroke from all the StylusPoints since OnStylusDown.
        Stroke stroke = new Stroke(stylusPoints);

        // Add the new stroke to the Strokes collection of the InkPresenter.
        ip.Strokes.Add(stroke);

        // Clear the StylusPointsCollection.
        stylusPoints = null;

        // Release stylus capture.
        Stylus.Capture(null);
    }

    protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
    {

        base.OnMouseLeftButtonDown(e);

        // If a stylus generated this event, return.
        if (e.StylusDevice != null)
        {
            return;
        }

        // Start collecting the points.
        stylusPoints = new StylusPointCollection();
        Point pt = e.GetPosition(this);
        stylusPoints.Add(new StylusPoint(pt.X, pt.Y));

    }

    protected override void OnMouseMove(MouseEventArgs e)
    {

        base.OnMouseMove(e);

        // If a stylus generated this event, return.
        if (e.StylusDevice != null)
        {
            return;
        }

        // Don't collect points unless the left mouse button
        // is down.
        if (e.LeftButton == MouseButtonState.Released || 
            stylusPoints == null)
        {
            return;
        }

        Point pt = e.GetPosition(this);
        stylusPoints.Add(new StylusPoint(pt.X, pt.Y));
    }

    protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
    {

        base.OnMouseLeftButtonUp(e);

        // If a stylus generated this event, return.
        if (e.StylusDevice != null)
        {
            return;
        }

        if (stylusPoints == null)
        {
            return;
        }

        Point pt = e.GetPosition(this);
        stylusPoints.Add(new StylusPoint(pt.X, pt.Y));

        // Create a stroke and add it to the InkPresenter.
        Stroke stroke = new Stroke(stylusPoints);
        stroke.DrawingAttributes = dr.DrawingAttributes;
        ip.Strokes.Add(stroke);

        stylusPoints = null;

    }
}


Como sucede con InkCanvas, su control personalizado puede tener elementos StylusPlugIn personalizados y objetos DynamicRenderer adicionales. Agréguelos a la colección StylusPlugIns. El orden de los objetos StylusPlugIn en StylusPlugInCollection afecta a la apariencia de la entrada de lápiz cuando se representa. Supongamos que tiene un objeto DynamicRenderer denominado dynamicRenderer y un objeto StylusPlugIn personalizado denominado translatePlugin que desplaza la entrada de lápiz del lápiz de Tablet PC. Si translatePlugin es el primer StylusPlugIn de StylusPlugInCollection y dynamicRenderer es el segundo, la entrada de lápiz que "fluye" se desplazará a medida que el usuario mueva el lápiz. Si dynamicRenderer está primero y translatePlugin es el segundo, no se desplazará la entrada de lápiz hasta que el usuario levante el lápiz.

Puede crear un control que recopile y represente la entrada de lápiz si invalida los métodos de evento de lápiz. Si crea un control propio, deriva sus propias clases StylusPlugIn y las inserta en StylusPlugInCollection, podrá implementar prácticamente cualquier comportamiento imaginable con la entrada de lápiz digital. Al tener acceso a los datos de StylusPoint a medida que se generan, puede personalizar la entrada de Stylus y representarla en pantalla según sea adecuado para su aplicación. Dado que tiene este acceso tan detallado a los datos de StylusPoint, puede implementar la recopilación y representación de la entrada de lápiz con un rendimiento óptimo para su aplicación.

Mostrar: