Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
A DrawingAttributes propriedade de um traço permite que você especifique a aparência de um traço, como seu tamanho, cor e forma, mas pode haver momentos em que você deseja personalizar a aparência além do que DrawingAttributes permite. Talvez você queira personalizar a aparência da tinta renderizando na aparência de um pincel de ar, tinta a óleo e muitos outros efeitos. O WPF (Windows Presentation Foundation) permite que você renderize tinta personalizada implementando um DynamicRenderer e Stroke objeto personalizado.
Este tópico contém as seguintes subseções:
Arquitetura
A renderização de tinta ocorre duas vezes: quando um usuário escreve em uma superfície de tinta, e novamente depois que o traço é adicionado à superfície habilitada para tinta. DynamicRenderer renderiza a tinta quando o usuário move a caneta do tablet no digitalizador, e o Stroke renderiza-se uma vez que é adicionado a um elemento.
Há três classes a serem implementadas ao renderizar dinamicamente a tinta.
DynamicRenderer: implementar uma classe que deriva de DynamicRenderer. Essa classe é uma StylusPlugIn especializada que renderiza o traço conforme ele é desenhado. Ele DynamicRenderer faz a renderização em um thread separado, de modo que a superfície de escrita à tinta parece coletar tinta mesmo quando o thread da interface do usuário do aplicativo é bloqueado. Para obter mais informações sobre o modelo de threading, consulte The Ink Threading Model. Para personalizar dinamicamente a renderização de um traçado, substitua o método OnDraw.
Stroke: Implementar uma classe que deriva de Stroke. Essa classe é responsável pela renderização estática dos StylusPoint dados depois de serem convertidos em um Stroke objeto. Sobrescreva o método DrawCore para garantir que a renderização estática do traço seja consistente com a renderização dinâmica.
InkCanvas: Implementar uma classe que deriva de InkCanvas. Atribua o DynamicRenderer personalizado à propriedade DynamicRenderer. Sobrescreva o método OnStrokeCollected e adicione um traço personalizado à propriedade Strokes. Isso garante que a aparência da tinta seja consistente.
Implementando um renderizador dinâmico
Embora a DynamicRenderer classe seja uma parte padrão do WPF, para executar uma renderização mais especializada, você deve criar um renderizador dinâmico personalizado que deriva do DynamicRenderer método e substituir o OnDraw método.
O exemplo a seguir demonstra um DynamicRenderer personalizado desenhando com tinta usando um efeito de pincel de gradiente linear.
using System;
using System.Windows.Media;
using System.Windows;
using System.Windows.Input.StylusPlugIns;
using System.Windows.Input;
using System.Windows.Ink;
Imports System.Windows.Media
Imports System.Windows
Imports System.Windows.Input.StylusPlugIns
Imports System.Windows.Input
Imports System.Windows.Ink
// A StylusPlugin that renders ink with a linear gradient brush effect.
class CustomDynamicRenderer : DynamicRenderer
{
[ThreadStatic]
static private Brush brush = null;
[ThreadStatic]
static private Pen pen = null;
private Point prevPoint;
protected override void OnStylusDown(RawStylusInput rawStylusInput)
{
// Allocate memory to store the previous point to draw from.
prevPoint = new Point(double.NegativeInfinity, double.NegativeInfinity);
base.OnStylusDown(rawStylusInput);
}
protected override void OnDraw(DrawingContext drawingContext,
StylusPointCollection stylusPoints,
Geometry geometry, Brush fillBrush)
{
// Create a new Brush, if necessary.
brush ??= new LinearGradientBrush(Colors.Red, Colors.Blue, 20d);
// Create a new Pen, if necessary.
pen ??= new Pen(brush, 2d);
// Draw linear gradient ellipses between
// all the StylusPoints that have come in.
for (int i = 0; i < stylusPoints.Count; i++)
{
Point pt = (Point)stylusPoints[i];
Vector v = Point.Subtract(prevPoint, pt);
// Only draw if we are at least 4 units away
// from the end of the last ellipse. Otherwise,
// we're just redrawing and wasting cycles.
if (v.Length > 4)
{
// Set the thickness of the stroke based
// on how hard the user pressed.
double radius = stylusPoints[i].PressureFactor * 10d;
drawingContext.DrawEllipse(brush, pen, pt, radius, radius);
prevPoint = pt;
}
}
}
}
' A StylusPlugin that renders ink with a linear gradient brush effect.
Class CustomDynamicRenderer
Inherits DynamicRenderer
<ThreadStatic()> _
Private Shared brush As Brush = Nothing
<ThreadStatic()> _
Private Shared pen As Pen = Nothing
Private prevPoint As Point
Protected Overrides Sub OnStylusDown(ByVal rawStylusInput As RawStylusInput)
' Allocate memory to store the previous point to draw from.
prevPoint = New Point(Double.NegativeInfinity, Double.NegativeInfinity)
MyBase.OnStylusDown(rawStylusInput)
End Sub
Protected Overrides Sub OnDraw(ByVal drawingContext As DrawingContext, _
ByVal stylusPoints As StylusPointCollection, _
ByVal geometry As Geometry, _
ByVal fillBrush As Brush)
' Create a new Brush, if necessary.
If brush Is Nothing Then
brush = New LinearGradientBrush(Colors.Red, Colors.Blue, 20.0)
End If
' Create a new Pen, if necessary.
If pen Is Nothing Then
pen = New Pen(brush, 2.0)
End If
' Draw linear gradient ellipses between
' all the StylusPoints that have come in.
Dim i As Integer
For i = 0 To stylusPoints.Count - 1
Dim pt As Point = CType(stylusPoints(i), Point)
Dim v As Vector = Point.Subtract(prevPoint, pt)
' Only draw if we are at least 4 units away
' from the end of the last ellipse. Otherwise,
' we're just redrawing and wasting cycles.
If v.Length > 4 Then
' Set the thickness of the stroke based
' on how hard the user pressed.
Dim radius As Double = stylusPoints(i).PressureFactor * 10.0
drawingContext.DrawEllipse(brush, pen, pt, radius, radius)
prevPoint = pt
End If
Next i
End Sub
End Class
Implementando estilos de traço personalizados
Implementar uma classe que deriva de Stroke. Essa classe é responsável por renderizar StylusPoint dados depois de serem convertidos em um Stroke objeto. Substitua a classe DrawCore para realizar o desenho propriamente dito.
Sua classe Stroke também pode armazenar dados personalizados usando o AddPropertyData método. Esses dados são armazenados com os dados de traçado quando são persistidos.
A Stroke classe também pode executar testes de clique. Você também pode implementar seu próprio algoritmo de teste de colisão substituindo o método HitTest na classe atual.
O código C# a seguir demonstra uma classe personalizada Stroke que renderiza StylusPoint dados como um traço 3D.
using System;
using System.Windows.Media;
using System.Windows;
using System.Windows.Input.StylusPlugIns;
using System.Windows.Input;
using System.Windows.Ink;
Imports System.Windows.Media
Imports System.Windows
Imports System.Windows.Input.StylusPlugIns
Imports System.Windows.Input
Imports System.Windows.Ink
// A class for rendering custom strokes
class CustomStroke : Stroke
{
Brush brush;
Pen pen;
public CustomStroke(StylusPointCollection stylusPoints)
: base(stylusPoints)
{
// Create the Brush and Pen used for drawing.
brush = new LinearGradientBrush(Colors.Red, Colors.Blue, 20d);
pen = new Pen(brush, 2d);
}
protected override void DrawCore(DrawingContext drawingContext,
DrawingAttributes drawingAttributes)
{
// Allocate memory to store the previous point to draw from.
Point prevPoint = new Point(double.NegativeInfinity,
double.NegativeInfinity);
// Draw linear gradient ellipses between
// all the StylusPoints in the Stroke.
for (int i = 0; i < this.StylusPoints.Count; i++)
{
Point pt = (Point)this.StylusPoints[i];
Vector v = Point.Subtract(prevPoint, pt);
// Only draw if we are at least 4 units away
// from the end of the last ellipse. Otherwise,
// we're just redrawing and wasting cycles.
if (v.Length > 4)
{
// Set the thickness of the stroke
// based on how hard the user pressed.
double radius = this.StylusPoints[i].PressureFactor * 10d;
drawingContext.DrawEllipse(brush, pen, pt, radius, radius);
prevPoint = pt;
}
}
}
}
' A class for rendering custom strokes
Class CustomStroke
Inherits Stroke
Private brush As Brush
Private pen As Pen
Public Sub New(ByVal stylusPoints As StylusPointCollection)
MyBase.New(stylusPoints)
' Create the Brush and Pen used for drawing.
brush = New LinearGradientBrush(Colors.Red, Colors.Blue, 20.0)
pen = New Pen(brush, 2.0)
End Sub
Protected Overrides Sub DrawCore(ByVal drawingContext As DrawingContext, _
ByVal drawingAttributes As DrawingAttributes)
' Allocate memory to store the previous point to draw from.
Dim prevPoint As New Point(Double.NegativeInfinity, Double.NegativeInfinity)
' Draw linear gradient ellipses between
' all the StylusPoints in the Stroke.
Dim i As Integer
For i = 0 To Me.StylusPoints.Count - 1
Dim pt As Point = CType(Me.StylusPoints(i), Point)
Dim v As Vector = Point.Subtract(prevPoint, pt)
' Only draw if we are at least 4 units away
' from the end of the last ellipse. Otherwise,
' we're just redrawing and wasting cycles.
If v.Length > 4 Then
' Set the thickness of the stroke
' based on how hard the user pressed.
Dim radius As Double = Me.StylusPoints(i).PressureFactor * 10.0
drawingContext.DrawEllipse(brush, pen, pt, radius, radius)
prevPoint = pt
End If
Next i
End Sub
End Class
Implementando um InkCanvas personalizado
A maneira mais fácil de usar seu traço DynamicRenderer personalizado é implementar uma classe que deriva InkCanvas e usa essas classes. O InkCanvas tem uma propriedade DynamicRenderer que especifica como o traço é renderizado quando o usuário o está desenhando.
Para renderizar traços personalizados em um InkCanvas deve-se fazer o seguinte:
Crie uma classe derivada do InkCanvas.
Atribua sua propriedade personalizada DynamicRenderer à propriedade InkCanvas.DynamicRenderer.
Substituir o método OnStrokeCollected. Neste método, remova o traço original que foi adicionado ao InkCanvas. Em seguida, crie um traço personalizado, adicione-o à propriedade Strokes e chame a classe base com um novo InkCanvasStrokeCollectedEventArgs que contenha o traço personalizado.
O seguinte código C# demonstra uma classe personalizada InkCanvas que utiliza DynamicRenderer personalizado e coleta traços personalizados.
public class CustomRenderingInkCanvas : InkCanvas
{
CustomDynamicRenderer customRenderer = new CustomDynamicRenderer();
public CustomRenderingInkCanvas() : base()
{
// Use the custom dynamic renderer on the
// custom InkCanvas.
this.DynamicRenderer = customRenderer;
}
protected override void OnStrokeCollected(InkCanvasStrokeCollectedEventArgs e)
{
// Remove the original stroke and add a custom stroke.
this.Strokes.Remove(e.Stroke);
CustomStroke customStroke = new CustomStroke(e.Stroke.StylusPoints);
this.Strokes.Add(customStroke);
// Pass the custom stroke to base class' OnStrokeCollected method.
InkCanvasStrokeCollectedEventArgs args =
new InkCanvasStrokeCollectedEventArgs(customStroke);
base.OnStrokeCollected(args);
}
}
Um InkCanvas pode ter mais de um DynamicRenderer. Você pode adicionar vários DynamicRenderer objetos ao InkCanvas adicioná-los à StylusPlugIns propriedade.
Conclusão
Você pode personalizar a aparência da tinta derivando suas próprias DynamicRenderer, Stroke, e InkCanvas classes. Juntas, essas classes garantem que a aparência do traço seja consistente quando o usuário desenha o traço e depois de ser coletado.
Consulte também
Colaborar conosco no GitHub
A fonte deste conteúdo pode ser encontrada no GitHub, onde você também pode criar e revisar problemas e solicitações de pull. Para obter mais informações, confira o nosso guia para colaboradores.
.NET Desktop feedback