Encuadernación rectangular de forma WPF
https://stackoverflow.com/questions/434832
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Estoy tratando de hacer algún tipo de forma en wpf, que se redimensiona al contenido (que debería ser texto). Desafortunadamente, la propiedad de estiramiento no es lo correcto, ya que solo quiero que el ancho de la Forma se redimensione y sin los bordes (pls copie el ejemplo inferior en xamlpad para verlo por sí mismo) de esta forma estirada. Las fronteras deben permanecer como están, o al menos escalar en Uniforme. He intentado muchas ideas. Con diferentes cortes de la forma en una cuadrícula, panel de pila, o con un panel recortado y etc. Mi próximo enfoque sería el siguiente:
<Page xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"><Page.Resources>
<LinearGradientBrush StartPoint="0.0,1" EndPoint="0.0,0" x:Key="brushYellow">
<LinearGradientBrush.GradientStops>
<GradientStop Offset="0.000000" Color="#fffef4a6"/>
<GradientStop Offset="0.175824" Color="#fffef9d6"/>
<GradientStop Offset="0.800000" Color="#fffef9d6"/>
<GradientStop Offset="1.000000" Color="#fffef4a6"/>
</LinearGradientBrush.GradientStops>
</LinearGradientBrush></Page.Resources><Grid>
<Path Stroke="#fffce90d" StrokeThickness="1" Fill="{StaticResource brushYellow}">
<Path.Data>
<CombinedGeometry GeometryCombineMode="Exclude">
<CombinedGeometry.Geometry1>
<RectangleGeometry RadiusX="15" RadiusY="15">
<!--RectangleGeometry.Rect>
<Binding StringFormat="{}{0 0 {0} 82}" ElementName="Text" Path="Width"/>
</RectangleGeometry.Rect-->
<RectangleGeometry.Rect>
<Rect Width="150" Height="82"/>
</RectangleGeometry.Rect>
</RectangleGeometry>
</CombinedGeometry.Geometry1>
<CombinedGeometry.Geometry2>
<PathGeometry>
<PathGeometry.Figures>
<PathFigureCollection>
<PathFigure IsClosed="True" StartPoint="0,15">
<PathFigure.Segments>
<PathSegmentCollection>
<LineSegment Point="17,41" />
<LineSegment Point="0,67" />
</PathSegmentCollection>
</PathFigure.Segments>
</PathFigure>
</PathFigureCollection>
</PathGeometry.Figures>
</PathGeometry>
</CombinedGeometry.Geometry2>
</CombinedGeometry>
</Path.Data>
</Path>
<TextBox Name="Text" Background="Transparent" BorderThickness="0" MinWidth="150" Margin="0"/>
</Grid></Page>
Esto funcionará de inmediato en xamlpad. La parte no comentada en la línea 19 es lo que realmente quiero lograr: vincular el Rect del Rectángulo a otra cosa. Desafortunadamente, el ancho de Rect no es dp, es por eso que estoy usando directamente un enlace con formato de cadena para rectificar.
Como se esperaba con la vida, eso no funciona (no se ve nada): D ¿Qué estoy haciendo mal aquí?
Solución
Utilizo un conjunto de clases llamadas ViewboxPath, ViewboxLine, ViewboxPolyline, etc. que cambian la semántica de estiramiento de Shape para que sea un poco más manejable. No estoy seguro de haber entendido su pregunta, así que no sé si mi técnica resolverá su problema o no.
Mientras lo leo, o quieres controlar el estiramiento, que proporcionará esta solución, o quieres que los trazos se estiren junto con la imagen, que la respuesta de Sam proporcionará.
De todos modos, a continuación se muestra el código para estas clases y así es como se usan:
<edf:ViewboxPolyline
Viewbox="0 0 1 1" <!-- Actually the default, can be omitted -->
Stretch="Fill" <!-- Also default, can be omitted -->
Stroke="Blue"
Points="0,0 0.2,0 0.2,0.3 0.4,0.3" />
<edf:ViewboxPolygon
Viewbox="0 0 10 10"
Stroke="Blue"
Points="5,0 10,5 5,10 0,5" />
<edf:ViewboxPath
Viewbox="0 0 10 10"
Stroke="Blue"
Data="M10,5 L4,4 L5,10" />
Mis clases de forma de Viewbox se usan igual que las formas normales ( Polyline , Polygon , Path y Línea ) excepto por el parámetro adicional Viewbox y el hecho de que por defecto son Stretch = " Fill " . El parámetro Viewbox especifica, en el sistema de coordenadas utilizado para especificar la forma, el área de la geometría que se debe estirar usando Fill , Uniform o UniformToFill configuración, en lugar de usar Geometry.GetBounds .
Esto proporciona un control muy preciso sobre el estiramiento y facilita que las formas separadas se alineen con precisión entre sí.
Aquí está el código real para mis clases de forma de Viewbox , incluida la clase base abstracta ViewboxShape que contiene una funcionalidad común:
public abstract class ViewboxShape : Shape
{
Matrix _transform;
Pen _strokePen;
Geometry _definingGeometry;
Geometry _renderGeometry;
static ViewboxShape()
{
StretchProperty.OverrideMetadata(typeof(ViewboxShape), new FrameworkPropertyMetadata
{
AffectsRender = true,
DefaultValue = Stretch.Fill,
});
}
// The built-in shapes compute stretching using the actual bounds of the geometry.
// ViewBoxShape and its subclasses use this Viewbox instead and ignore the actual bounds of the geometry.
public Rect Viewbox { get { return (Rect)GetValue(ViewboxProperty); } set { SetValue(ViewboxProperty, value); } }
public static readonly DependencyProperty ViewboxProperty = DependencyProperty.Register("Viewbox", typeof(Rect), typeof(ViewboxShape), new UIPropertyMetadata
{
DefaultValue = new Rect(0,0,1,1),
});
// If defined, replaces all the Stroke* properties with a single Pen
public Pen Pen { get { return (Pen)GetValue(PenProperty); } set { SetValue(PenProperty, value); } }
public static readonly DependencyProperty PenProperty = DependencyProperty.Register("Pen", typeof(Pen), typeof(Pen), new UIPropertyMetadata
{
DefaultValue = null
});
// Subclasses override this to define geometry if caching is desired, or just override DefiningGeometry
protected virtual Geometry ComputeDefiningGeometry()
{
return null;
}
// Subclasses can use this PropertyChangedCallback for properties that affect the defining geometry
protected static void OnGeometryChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
var shape = sender as ViewboxShape;
if(shape!=null)
{
shape._definingGeometry = null;
shape._renderGeometry = null;
}
}
// Compute viewport from box & constraint
private Size ApplyStretch(Stretch stretch, Rect box, Size constraint)
{
double uniformScale;
switch(stretch)
{
default:
return new Size(box.Width, box.Height);
case Stretch.Fill:
return constraint;
case Stretch.Uniform:
uniformScale = Math.Min(constraint.Width / box.Width, constraint.Height / box.Height);
break;
case Stretch.UniformToFill:
uniformScale = Math.Max(constraint.Width / box.Width, constraint.Height / box.Height);
break;
}
return new Size(uniformScale * box.Width, uniformScale * box.Height);
}
protected override Size MeasureOverride(Size constraint)
{
// Clear pen cache if settings have changed
if(_strokePen!=null)
if(Pen!=null)
_strokePen = null;
else
if(_strokePen.Thickness != StrokeThickness ||
_strokePen.Brush != Stroke ||
_strokePen.StartLineCap != StrokeStartLineCap ||
_strokePen.EndLineCap != StrokeEndLineCap ||
_strokePen.DashCap != StrokeDashCap ||
_strokePen.LineJoin != StrokeLineJoin ||
_strokePen.MiterLimit != StrokeMiterLimit ||
_strokePen.DashStyle.Dashes != StrokeDashArray ||
_strokePen.DashStyle.Offset != StrokeDashOffset)
_strokePen = null;
_definingGeometry = null;
_renderGeometry = null;
return ApplyStretch(Stretch, Viewbox, constraint);
}
protected override Size ArrangeOverride(Size availableSize)
{
Stretch stretch = Stretch;
Size viewport;
Matrix transform;
// Compute new viewport and transform
if(stretch==Stretch.None)
{
viewport = availableSize;
transform = Matrix.Identity;
}
else
{
Rect box = Viewbox;
viewport = ApplyStretch(stretch, box, availableSize);
double scaleX = viewport.Width / box.Width;
double scaleY = viewport.Height / box.Height;
transform = new Matrix(scaleX, 0, 0, scaleY, -box.Left * scaleX, -box.Top * scaleY);
}
if(_transform!=transform)
{
_transform = transform;
_renderGeometry = null;
InvalidateArrange();
}
return viewport;
}
protected Pen PenOrStroke
{
get
{
if(Pen!=null)
return Pen;
if(_strokePen==null)
_strokePen = new Pen
{
Thickness = StrokeThickness,
Brush = Stroke,
StartLineCap = StrokeStartLineCap,
EndLineCap = StrokeEndLineCap,
DashCap = StrokeDashCap,
LineJoin = StrokeLineJoin,
MiterLimit = StrokeMiterLimit,
DashStyle =
StrokeDashArray.Count==0 && StrokeDashOffset==0 ? DashStyles.Solid :
new DashStyle(StrokeDashArray, StrokeDashOffset),
};
return _strokePen;
}
}
protected Matrix Transform
{
get
{
return _transform;
}
}
protected override Geometry DefiningGeometry
{
get
{
if(_definingGeometry==null)
_definingGeometry = ComputeDefiningGeometry();
return _definingGeometry;
}
}
protected Geometry RenderGeometry
{
get
{
if(_renderGeometry==null)
{
Geometry defining = DefiningGeometry;
if(_transform==Matrix.Identity || defining==Geometry.Empty)
_renderGeometry = defining;
else
{
Geometry geo = defining.CloneCurrentValue();
if(object.ReferenceEquals(geo, defining)) geo = defining.Clone();
geo.Transform = new MatrixTransform(
geo.Transform==null ? _transform : geo.Transform.Value * _transform);
_renderGeometry = geo;
}
}
return _renderGeometry;
}
}
protected override void OnRender(DrawingContext drawingContext)
{
drawingContext.DrawGeometry(Fill, PenOrStroke, RenderGeometry);
}
}
[ContentProperty("Data")]
public class ViewboxPath : ViewboxShape
{
public Geometry Data { get { return (Geometry)GetValue(DataProperty); } set { SetValue(DataProperty, value); } }
public static readonly DependencyProperty DataProperty = DependencyProperty.Register("Data", typeof(Geometry), typeof(ViewboxPath), new UIPropertyMetadata
{
DefaultValue = Geometry.Empty,
PropertyChangedCallback = OnGeometryChanged,
});
protected override Geometry DefiningGeometry
{
get { return Data ?? Geometry.Empty; }
}
}
public class ViewboxLine : ViewboxShape
{
public double X1 { get { return (double)GetValue(X1Property); } set { SetValue(X1Property, value); } }
public double X2 { get { return (double)GetValue(X2Property); } set { SetValue(X2Property, value); } }
public double Y1 { get { return (double)GetValue(Y1Property); } set { SetValue(Y1Property, value); } }
public double Y2 { get { return (double)GetValue(Y2Property); } set { SetValue(Y2Property, value); } }
public static readonly DependencyProperty X1Property = DependencyProperty.Register("X1", typeof(double), typeof(ViewboxLine), new FrameworkPropertyMetadata { PropertyChangedCallback = OnGeometryChanged, AffectsRender = true });
public static readonly DependencyProperty X2Property = DependencyProperty.Register("X2", typeof(double), typeof(ViewboxLine), new FrameworkPropertyMetadata { PropertyChangedCallback = OnGeometryChanged, AffectsRender = true });
public static readonly DependencyProperty Y1Property = DependencyProperty.Register("Y1", typeof(double), typeof(ViewboxLine), new FrameworkPropertyMetadata { PropertyChangedCallback = OnGeometryChanged, AffectsRender = true });
public static readonly DependencyProperty Y2Property = DependencyProperty.Register("Y2", typeof(double), typeof(ViewboxLine), new FrameworkPropertyMetadata { PropertyChangedCallback = OnGeometryChanged, AffectsRender = true });
protected override Geometry ComputeDefiningGeometry()
{
return new LineGeometry(new Point(X1, Y1), new Point(X2, Y2));
}
}
[ContentProperty("Points")]
public class ViewboxPolyline : ViewboxShape
{
public ViewboxPolyline()
{
Points = new PointCollection();
}
public PointCollection Points { get { return (PointCollection)GetValue(PointsProperty); } set { SetValue(PointsProperty, value); } }
public static readonly DependencyProperty PointsProperty = DependencyProperty.Register("Points", typeof(PointCollection), typeof(ViewboxPolyline), new FrameworkPropertyMetadata
{
PropertyChangedCallback = OnGeometryChanged,
AffectsRender = true,
});
public FillRule FillRule { get { return (FillRule)GetValue(FillRuleProperty); } set { SetValue(FillRuleProperty, value); } }
public static readonly DependencyProperty FillRuleProperty = DependencyProperty.Register("FillRule", typeof(FillRule), typeof(ViewboxPolyline), new FrameworkPropertyMetadata
{
DefaultValue = FillRule.EvenOdd,
PropertyChangedCallback = OnGeometryChanged,
AffectsRender = true,
});
public bool CloseFigure { get { return (bool)GetValue(CloseFigureProperty); } set { SetValue(CloseFigureProperty, value); } }
public static readonly DependencyProperty CloseFigureProperty = DependencyProperty.Register("CloseFigure", typeof(bool), typeof(ViewboxPolyline), new FrameworkPropertyMetadata
{
DefaultValue = false,
PropertyChangedCallback = OnGeometryChanged,
AffectsRender = true,
});
protected override Geometry ComputeDefiningGeometry()
{
PointCollection points = Points;
if(points.Count<2) return Geometry.Empty;
var geometry = new StreamGeometry { FillRule = FillRule };
using(var context = geometry.Open())
{
context.BeginFigure(Points[0], true, CloseFigure);
context.PolyLineTo(Points.Skip(1).ToList(), true, true);
}
return geometry;
}
}
public class ViewboxPolygon : ViewboxPolyline
{
static ViewboxPolygon()
{
CloseFigureProperty.OverrideMetadata(typeof(ViewboxPolygon), new FrameworkPropertyMetadata
{
DefaultValue = true,
});
}
}
¡Disfruta!
Otros consejos
Puede intentar usar una transformación para cambiar el tamaño del rectángulo en lugar de vincular el ancho del rectángulo directamente. Creo que esto debería funcionar.
Por ejemplo. ponga algo como esto en su etiqueta RectangleGeometry :
<RectangleGeometry.Transform>
<ScaleTransform ScaleX="{Binding ElementName=textBoxName, Path=Width,
Converter=MyScaleWidthConverter}" />
</RectangleGeometry.Transform>
Donde textBoxName es el nombre de su cuadro de texto. No pude llamarlo Texto, demasiado confuso.
Deberá proporcionar un convertidor para garantizar que la escala sea correcta, p. ej. Probablemente desee devolver algo como Ancho / 150 dado su código de muestra.
Veo un comportamiento ligeramente extraño cuando el ancho del rectángulo se establece en Auto en el diseñador de Visual Studio; creo que esto es probablemente una peculiaridad del diseñador. Debería funcionar una vez que el convertidor esté conectado en tiempo de ejecución.
¿Qué hay de usar tu camino como Brush? En el siguiente código, uso un DrawingBrush como fondo para TextBox o como fondo para un borde que lo encierra. Solo una pista ... Espero que esto ayude.
<Window x:Class="MarkupWpf.BrushTest"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="BrushTest" Height="300" Width="300">
<Window.Resources>
<LinearGradientBrush StartPoint="0.0,1" EndPoint="0.0,0" x:Key="brushYellow">
<LinearGradientBrush.GradientStops>
<GradientStop Offset="0.000000" Color="#fffef4a6"/>
<GradientStop Offset="0.175824" Color="#fffef9d6"/>
<GradientStop Offset="0.800000" Color="#fffef9d6"/>
<GradientStop Offset="1.000000" Color="#fffef4a6"/>
</LinearGradientBrush.GradientStops>
</LinearGradientBrush>
<DrawingBrush x:Key="FabBrush">
<DrawingBrush.Drawing>
<GeometryDrawing Brush="{StaticResource brushYellow}">
<GeometryDrawing.Pen>
<Pen Thickness="1" Brush="#fffce90d" />
</GeometryDrawing.Pen>
<GeometryDrawing.Geometry>
<CombinedGeometry GeometryCombineMode="Exclude">
<CombinedGeometry.Geometry1>
<RectangleGeometry RadiusX="15" RadiusY="15">
<RectangleGeometry.Rect>
<Rect Width="150" Height="82"/>
</RectangleGeometry.Rect>
</RectangleGeometry>
</CombinedGeometry.Geometry1>
<CombinedGeometry.Geometry2>
<PathGeometry>
<PathGeometry.Figures>
<PathFigureCollection>
<PathFigure IsClosed="True" StartPoint="0,15">
<PathFigure.Segments>
<PathSegmentCollection>
<LineSegment Point="17,41" />
<LineSegment Point="0,67" />
</PathSegmentCollection>
</PathFigure.Segments>
</PathFigure>
</PathFigureCollection>
</PathGeometry.Figures>
</PathGeometry>
</CombinedGeometry.Geometry2>
</CombinedGeometry>
</GeometryDrawing.Geometry>
</GeometryDrawing>
</DrawingBrush.Drawing>
</DrawingBrush>
</Window.Resources>
<Grid>
<Grid.RowDefinitions>
<RowDefinition />
<RowDefinition />
</Grid.RowDefinitions>
<TextBox Grid.Row="0" Background="{StaticResource FabBrush}" BorderThickness="0" MinWidth="150" Margin="0"/>
<Grid Grid.Row="1">
<Border Background="{StaticResource FabBrush}">
<TextBox Grid.Row="0" BorderThickness="0" MinWidth="150" Margin="20" />
</Border>
</Grid>
</Grid>
</Window>
Estoy haciendo algo como esto. Quiero formas personalizadas que cambien de tamaño automáticamente cuando cambie el tamaño de la ventana. para mi solución derivaba de la forma y anulé la propiedad definingGeometry. Para las dimensiones de mi forma, uso las propiedades ActualWidth y ActualHeight, ya que reflejan el ancho y la altura reales. También estoy exagerando el método measureOverride () como este
protected override Size MeasureOverride(Size constraint)
{
return this.DesiredSize;
}
Estoy generando la forma en código usando (como dije antes) actualWidth y actualHeight como valores máximos. espero que esto ayude
