Microsoft.Expression.Drawing
Renders a callout shape supporting several shapes combined with a callout arrow.
Provides a base class of a composite shape that derives from and implements .
implements interface,
and supports rendering a geometry similar to , but the geometry can be rendered outside the layout boundary.
A typical implementation has a customized default template in generic.xaml which template-binds most shape properties to a .
It should also extend the property to customize the appearance of the .
This class also supports showing content together with the shape.
Provides an interface to describe the parameters of a Shape.
This interface is the data for communication between Shape and GeometrySource.
Typically, a concrete implementation of IShape will implement this interface and pass it into
GeometrySource.UpdateGeometry(), which will then consume the shape as a read-only data provider.
Provides the necessary interface to define a Shape.
Both primitive and composite shapes need to match this interface, although they might derive from different types of FrameworkElement.
Invalidates the geometry for a . After the invalidation, the will recompute the geometry, which will occur asynchronously.
Gets or sets the that specifies how to paint the interior of the shape.
A that describes how the shape's interior is painted. The default is null.
Gets or sets the that specifies how the outline is painted.
A that specifies how the outline is painted.
Gets or sets the width of the stroke outline.
The width of the outline, in pixels.
Gets or sets a enumeration value that describes how the shape fills its allocated space.
One of the enumeration values. The default value at runtime depends on the type of .
Gets the rendered geometry presented by the rendering engine.
Gets the margin between logical bounds and actual geometry bounds.
This can be either positive (as in ) or negative (as in ).
Occurs when RenderedGeometry is changed.
Extends how the shape is drawn with creating geometry source.
Invalidates the geometry for a . After the invalidation, the will recompute the geometry, which will occur asynchronously.
Provides the behavior for the Arrange portion of a Silverlight layout pass. Classes can override this method to define their own Arrange pass behavior.
The actual size used once the element is arranged in layout.
The final area within the parent that this object should use to arrange itself and its children.
will recompute the Geometry when it's invalidated and update the RenderedGeometry and GeometryMargin.
Transforms a string content into with center alignment and multiple line support.
Use template-binding to instead of to enable this method.
Gets or sets the that specifies how to paint the interior of the shape.
A that describes how the shape's interior is painted.
Gets or sets the that specifies how the outline is painted.
A that specifies how the outline is painted.
Gets or sets the width of the stroke outline.
The width of the outline, in pixels.
Gets or sets a enumeration value that describes how the shape fills its allocated space.
One of the enumeration values.
Gets or sets a enumeration value that describes the at the start of a .
A value of the enumeration that specifies the shape at the start of a .
Gets or sets a enumeration value that describes the at the end of a line.
One of the enumeration values for .
Gets or sets a enumeration value that specifies the type of join that is used at the vertices of a .
A value of the enumeration that specifies the join appearance.
Gets or sets a limit on the ratio of the miter length to half the of a element.
The limit on the ratio of the miter length to the of a element. This value is always a positive number that is greater than or equal to 1.
Gets or sets a collection of values that indicate the pattern of dashes and gaps that is used to outline shapes.
A collection of values that specify the pattern of dashes and gaps.
Gets or sets a enumeration value that specifies how the ends of a dash are drawn.
One of the enumeration values for . The default is .
Gets or sets a that specifies the distance within the dash pattern where a dash begins.
A that represents the distance within the dash pattern where a dash begins. The default value is 0.
Gets the rendered geometry presented by the rendering engine.
Gets the margin between the logical bounds and the actual geometry bounds.
This can be either positive (as in ) or negative (as in ).
Gets or sets the internal content that converts a string into a center-aligned, multiple-line TextBlock.
Occurs when RenderedGeometry is changed.
Gets or sets the position of the callout relative to the top and left corner.
Gets or sets the callout style.
Provides a base class of a composite shape that derives from and implements .
implements interface,
and supports rendering a geometry similar to , but the geometry can be rendered outside the layout boundary.
A typical implementation has a customized default template in generic.xaml which template-binds most shape properties to a .
It should also extend the property to customize the appearance of the .
Extends how the shape is drawn with creating geometry source.
Invalidates the geometry for a . After the invalidation, the will recompute the geometry, which will occur asynchronously.
Provides the behavior for the Arrange portion of a Silverlight layout pass. Classes can override this method to define their own Arrange pass behavior.
The actual size used once the element is arranged in layout.
The final area within the parent that this object should use to arrange itself and its children.
will recompute the Geometry when it's invalidated and update the RenderedGeometry and GeometryMargin.
Gets or sets the that specifies how to paint the interior of the shape.
A that describes how the shape's interior is painted.
Gets or sets the that specifies how the outline is painted.
A that specifies how the outline is painted.
Gets or sets the width of the stroke outline.
The width of the outline, in pixels.
Gets or sets a enumeration value that describes how the shape fills its allocated space.
One of the enumeration values.
Gets or sets a enumeration value that describes the at the start of a .
A value of the enumeration that specifies the shape at the start of a .
Gets or sets a enumeration value that describes the at the end of a line.
One of the enumeration values for .
Gets or sets a enumeration value that specifies the type of join that is used at the vertices of a .
A value of the enumeration that specifies the join appearance.
Gets or sets a limit on the ratio of the miter length to half the of a element.
The limit on the ratio of the miter length to the of a element. This value is always a positive number that is greater than or equal to 1.
Gets or sets a collection of values that indicate the pattern of dashes and gaps that is used to outline shapes.
A collection of values that specify the pattern of dashes and gaps.
Gets or sets a enumeration value that specifies how the ends of a dash are drawn.
One of the enumeration values for . The default is .
Gets or sets a that specifies the distance within the dash pattern where a dash begins.
A that represents the distance within the dash pattern where a dash begins. The default value is 0.
Gets the rendered geometry presented by the rendering engine.
Gets the margin between the logical bounds and the actual geometry bounds.
This can be either positive (as in ) or negative (as in ).
Occurs when RenderedGeometry is changed.
Renders a bent line segment with optional arrow heads on both ends.
Provides the behavior for the Measure pass of Silverlight layout. Classes can override this method to define their own Measure pass behavior.
The size that this object determines it requires during layout, based on its calculations of child object allotted sizes, or possibly on other considerations such as fixed container size.
The available size that this object can give to child objects. Infinity () can be specified as a value to indicate that the object will size to whatever content is available.
A default can render at anysize.
The will stretch to the layout boundary and render to the outside if necessary.
Gets or sets the amount of bend for the arrow.
The bend amount between 0 and 1.
Gets or sets how the arrow head is rendered at the start of the line.
Gets or sets how the arrow head is rendered at the end of the line.
Gets or sets from which corner to start drawing the arrow.
Gets or sets the length of the arrow in pixels.
Provides an items control that displays one selected item, and allows panning between items using touch gestures.
The constructor for PanningItems.
Called when the PanningItems template is applied.
Gets or sets the orientation of items in the control.
Gets or sets the flick tolerance. This can be a value between 0 and 1.
It represents the percentage of the size of the PanningItems needed to be covered by the flick gesture to trigger an items change.
Gets or sets the item before the selected item.
Gets or sets the item after the selected item.
Gets or sets whether the contents of the items control will loop, so that the first item will follow the last item.
Gets or sets the value of the slider controlling the panning motion.
Helper class to work with PathGeometry.
Converts a string in the path mini-language into a PathGeometry.
A string in the path mini-language.
Converts the given geometry into a single PathGeometry.
Updates the given geometry as PathGeometry with a polyline matching a given point list.
Parses abbreviated geometry sytax.
Helper class to convert an ArcSegment to BezierSegment(s).
Helper class to work with PathSegment and all variations.
Strategy classes to handle different types of PathSegment.
Converts an arc segment into Bezier format.
Returns BezierSegment, PolyBezierSegment, LineSegment, or null.
When returning null, the arc degenerates into the start point.
Avoid calling the three-parameter constructor, since it always sets a local value for IsStroked.
Updates the SegmentCollection with a given polyline matching a given point list.
Tries to keep changes minimum and returns false if nothing has been changed.
Updates the collection[index] segment with a poly-Bezier segment matching a given point list.
A given point list must contain 3*N points for N Bezier segments.
Tests if a given path segment is empty.
Gets the point count in a given path segment.
Gets the last point of a given path segment.
Gets the point of a given index in a given segment.
If input is (-1), returns the last point.
Flattens a given segment and adds resulting points into a given point list.
The segment to be flatten.
The resulting points list.
The start point of the segment.
The error tolerance. Must be positive. Can be zero. Fallback to default tolerance.
ArcToBezier, computes the Bezier approximation of an arc.
This utility computes the Bezier approximation for an elliptical arc as
it is defined in the SVG arc spec. The ellipse from which the arc is
carved is axis-aligned in its own coordinates, and defined there by its
x and y radii. The rotation angle defines how the ellipse's axes are
rotated relative to the x axis. The start and end points define one of 4
possible arcs; the sweep and large-arc flags determine which one of
these arcs will be chosen.
Returning cPieces = 0 indicates a line instead of an arc
cPieces = -1 indicates that the arc degenerates to a point
Gets the number of Bezier arcs, and sine/cosine of each.
This is a private utility used by ArcToBezier. Breaks the arc into
pieces so that no piece will span more than 90 degrees. The input
points are on the unit circle.
GetBezierDistance returns the distance as a fraction of the radius.
Get the distance from a circular arc's end points to the control points
of the Bezier arc that approximates it, as a fraction of the arc's
radius.
Since the result is relative to the arc's radius, it depends strictly on
the arc's angle. The arc is assumed to be of 90 degrees or less, so the
angle is determined by the cosine of that angle, which is derived from
rDot = the dot product of two radius vectors. We need the Bezier curve
that agrees with the arc's points and tangents at the ends and midpoint.
Here we compute the distance from the curve's endpoints to its control
points.
Since we are looking for the relative distance, we can work on the unit
circle. Place the center of the circle at the origin, and put the X axis
as the bisector between the 2 vectors. Let a be the angle between the
vectors. Then the X coordinates of the 1st and last points are cos(a/2).
Let x be the X coordinate of the 2nd and 3rd points. At t=1/2 we have a
point at (1,0). But the terms of the polynomial there are all equal:
(1-t)^3 = t*(1-t)^2 = t^2*(1-t) = t^3 = 1/8,
so from the Bezier formula there we have:
1 = (1/8) * (cos(a/2) + 3x + 3x + cos(a/2)),
hence
x = (4 - cos(a/2)) / 3
The X difference between that and the 1st point is:
DX = x - cos(a/2) = 4(1 - cos(a/2)) / 3.
But DX = distance / sin(a/2), hence the distance is
dist = (4/3)*(1 - cos(a/2)) / sin(a/2).
Rather than the angle a, we are given rDot = R^2 * cos(a), so we
multiply top and bottom by R:
dist = (4/3)*(R - Rcos(a/2)) / Rsin(a/2)
and use some trig:
________________
cos(a/2) = \/(1 + cos(a)) / 2
______________________
R*cos(a/2) = \/(R^2 + R^2 cos(a)) / 2
________________
= \/(R^2 + rDot) / 2
Let A = (R^2 + rDot)/2.
____________________
R*sin(a/2) = \/R^2 - R^2 cos^2(a/2)
_______
= \/R^2 - A
so:
_
4 R - \/A
dist = - * ------------
3 _______
\/R^2 - A
History:
5/29/2001 MichKa
Created it.
Returns false if the radius is too small compared to the chord length (returns true on NaNs)
radius is modified to the value that is accepted.
A utility class to flatten Bezier curves.
Flattens a Bezier cubic curve and adds the resulting polyline to the third parameter.
The four Bezier cubic control points.
The maximum distance between two corresponding points on the true curve
and on the flattened polyline. Must be strictly positive.
Where to add the flattened polyline.
True to skip the first control point when adding the flattened polyline.
Where to add the value of the Bezier curve parameter associated with
each of the polyline vertices.
If is empty, the first control point
and its associated parameter are always added.
Flattens a Bezier quadratic curve and adds the resulting polyline to the third parameter.
Uses degree elevation for Bezier curves to reuse the code for the cubic case.
The three Bezier quadratic control points.
The maximum distance between two corresponding points on the true curve
and on the flattened polyline. Must be strictly positive.
Where to add the flattened polyline.
Whether to skip the first control point when adding the flattened polyline.
Where to add the value of the Bezier curve parameter associated with
each of the polyline vertices.
If is empty, the first control point and
its associated parameter are always added.
Extension methods that support non-geometry types.
Allows the application of an action delegate (often a very simple lambda) against an entire sequence.
Allows the application of an action delegate (often a very simple lambda) against an entire sequence.
Allows the application of an action delegate (often a very simple lambda) against an entire sequence with the index of each item.
Ensures the count of a list to a given count. Creates with a given factory or removes items when necessary.
If Input IList is a List, AddRange or RemoveRange is used when there's no factory.
Ensures the count of a list is at least the given count. Creates with a given factory.
Add a range of items to the end of a collection.
If a collection is a list, List.AddRange is used.
Gets the last item of a given list.
Removes the last item from the given list.
Makes a copy of obj and all it's public properties, including all collection properties.
Sets the value if different. Avoids setting a local value if possible.
Returns true when the value has been changed.
Clears the dependency property when it is locally set on the given dependency object.
Returns false if the dependeny property is not locally set.
Finds all visual descendants of a given type and condition using breadth-first search.
Gets all visual children in IEnumerable.
Unifies the interface of PropertyMetadata in WPF and Silverlight.
Provides the necessary notification about render, arrange, or measure.
This private Ctor should only be used by AttachCallback.
Chain InternalCallback() to attach the instance of DrawingPropertyMetadata on property callback.
In Silverlight, the property metadata is thrown away after setting. Use callback to remember it.
Before chaining the original callback, trigger DrawingPropertyChangedEvent.
Extension methods for geometry-related data structures (Point/Vector/Size/Rect).
Resizes the rectangle to a relative size while keeping the center invariant.
Gets the difference vector between two points.
Memberwise plus for Point.
Memberwise minus for Point.
Converts a string of mini-languages to a .
See: Path Markup Syntax(http://msdn.microsoft.com/en-us/library/cc189041(VS.95).aspx)
The string of path mini-languages for describing geometric paths.
A converted from the the path mini-languages.
Flattens a and adds result points to a given .
The input .
The point list to which result points will append.
A positive number specifying the maximum allowed error from the result points to the input path figure. A Value of zero allows the algorithm to pick the tolerance automatically.
Gets the normalized arc in a (0,0)(1,1) box.
Zero degrees is mapped to [0.5, 0] (up), and clockwise.
Gets the absolute arc point in a given bound with a given relative radius.
Gets the angle on an arc relative to a (0,0)(1,1) box.
Zero degrees is mapped to [0.5, 0] (up), and clockwise.
Gets the angle on an arc from a given absolute point relative to a bound.
Computes the transform that moves "Rect from" to "Rect to".
Computes the transform from the coordinate space of one UIElement to another.
The source element.
The destination element.
The transform between the UIElements, or null if it cannot be computed.
Maps a relative point to an absolute point using the mapping from a given bound to a (0,0)(1,1) box.
Maps an absolute point to a relative point using the mapping from a (0,0)(1,1) box to a given bound.
Computes the bound after stretching within a given logical bound.
If stretch to uniform, use given aspectRatio.
If aspectRatio is empty, it's equivalent to Fill.
If stretch is None, it's equivalent to Fill or Uniform.
Returns the mid point of two points.
The first point.
The second point.
The mid point between and .
Returns the dot product of two vectors.
The first vector.
The second vector.
The dot product of and .
Returns the dot product of two points.
Returns the distance between two points.
The first point.
The second point.
The distance between and .
Returns the square of the distance between two points.
The first point.
The second point.
The square of the distance between and .
Determinant of the cross product. Equivalent to directional area.
Computes the normal direction vector of given line segments.
Computes the perpendicular vector, 90-degrees, counter-clockwise.
Vector to the right perpendicular results in a vector to up.
Returns whether the two geometries are identical.
Ensures the value is an instance of result type (T). If not, replace with a new instance of type (T).
Ensures the list[index] is an instance of result type (T). If not, replace with a new instance of type (T).
Helper class that provides static properties and methods related to floating point arithmetic.
The minimum distance to consider that two values are same.
Note: internal floating point in MIL/SL is float, not double.
The value of the angle of a full circle.
The inner radius for a pentagram polygon shape, at precision of three digits in percentage.
(1 - Sin36 * Sin72 / Sin54) / (Cos36) ^ 2, which is 0.47210998990512996761913067272407
Determines whether a System.Double value is small enough to be considered
equivalent to zero.
True if value is smaller than DoubleTolerance;
otherwise, False.
Returns the value that's within the given range.
A given min/max that is null equals no limit.
Computes the Euclidean norm of the vector (x, y).
The first component.
The second component.
The Euclidean norm of the vector (x, y).
Computes a real number from the mantissa and exponent.
The value of x * 2^exp if successful.
Tests a double.
The double to test.
True if x is not a NaN and is not equal to plus or minus infinity;
otherwise, False.
Helper class to work with PathFigure.
Flattens the given figure and adds result points to the given point list.
The error tolerance. Must be positive. Can be zero. Fallback to default tolerance.
Iterates all segments inside a given figure, and returns the correct start point for each segment.
Synchronizes the figure to the given list of points as a single polyline segment.
Tries to keep the change to a minimum and returns false if nothing has been changed.
Synchronizes the given figure to be a closed ellipse with two arc segments.
A Tuple data structure for PathSegment and the corresponding StartPoint.
Represents a polyline with a list of connecting points.
A closed polygon is represented by repeating the first point at the end.
The differences, normals, angles, and lengths are computed on demand.
Constructs a polyline with two or more points.
The forward difference vector of polyline.
Points[i] + Differences[i] = Points[i+1]
Compute the normal vector of given location (lerp(index, index+1, fraction).
If the location is within range of cornerRadius, interpolate the normal direction.
The range of normal smoothless. If zero, no smoothness and return the exact normal on index.
The polyline is closed when the first and last points are repeated.
The count of points in this polyline.
The total arc length of this polyline.
The point array of this polyline.
The length between line segments, Points[i] to Points[i+1].
The list of normal vectors for each segment.
Normals[i] is the normal of segment p[i] to p[i + 1].
Normals[N-1] == Normals[N-2].
The list of Cos(angle) between two line segments on point p[i].
Note: The value is cos(angle) = Dot(u, v). Not in degrees.
The list of accumulated length from points[i] to points[0].
The data structure to communicate with the PathMarch algorithm.
Gets the interpolated position of this MarchLocation on a given point list.
Get the interpolated normal direction of this MarchLocation on a given normal vector list.
Gets the arc length of this MarchLocation to the start of the entire polyline.
The reason why this location is sampled.
The index of the point on a polyline point list.
Ratio: [0, 1], which is always before / (before + after).
Arc length before a stop point. Non-negative and less than Length[index].
Arc length after the stop point. Non-negative and less than Length[index].
Remaining length within a step to hit next stop. Positive to go forward. Negative to go backward.
Helper class to work with list of points
March the given polyline with a given interval and output each stop through callback.
The polyline points to march on.
The arc length to march before stopping at the first point.
The max angle between edges to be considered a corner vertex.
Callback when marching algorithm stop at a point. The callback returns the arc length for next stop.
If the asked length is negative, march backwards. If callback returns NaN, finish marching.
Reorders the given list of polylines so that the polyline with a given arc length in the list is the first.
Polylines that preceded this line are concatenated to the end of the list, with the first polyline at the very end.
A list of polylines.
The arc length in the entire list of polylines at which to find the start line.
The arc length into that line is returned in this variable.
The reordered and wrapped list.
A random generator that supports uniform and Gaussian distributions.
Generates a pair of independent, standard, normally distributed random numbers,
zero expectation, unit variance, using polar form of the Box-Muller transformation.
Private constructor. Force to use factory methods.
Creates a line segment
Creates a cubic bezier segment from quatratic curve (3 control points)
Creates a cubic bezier segment with 4 control points.
Control points of path segment. Length is variant.
Line segment has 2 points, Cubic bezier has 4 points.
Compares two transforms for an exact match. Transforms with the same value but different structure (e.g. Translate(0,0) and Rotate(0) are not considered equivalent).
The first transform.
The second transform.
Specifies the unit of thickness.
Unit in pixels.
Unit in percentage relative to the bounding box.
Provides the base class of a source of geometry.
Generates and caches the geometry based on the input parameters and the layout bounds.
A typical implementation will extend the UpdateCachedGeometry() to update this.cachedGeometry.
This base class will then handle the invalidation, pipeline to the geometry effects, and then cache relative to the layout bounds.
An implementation should try to reuse the cached geometry as much as possible to avoid reconstruction in the rendering thread.
An implementation can extend the ComputeLogicalBounds to handle Stretch differently.
The type of geometry source parameter on which the base class is working on.
Provides an interface to describe the source of a geometry.
This interface is designed to expose the geometry source in a non-generic way.
Typical implementation should subclass GeometrySource instead of implementing this interface directly.
Notifies that the geometry has been invalidated because of external changes.
Geometry is typically invalidated when parameters are changed.
If any geometry has been invalidated externally, the geometry will be recomputed even if the layout bounds change.
Update the geometry using the given parameters and the layout bounds.
Returns false if nothing has been updated.
Gets or sets the resulting geometry after the latest UpdateGeometry().
Gets the bounding box where the geometry should stretch to.
The actual geometry might be smaller or larger than this.
should already take stroke thickness and stretch into consideration.
Gets the actual bounds of FrameworkElement.
includes logical bounds, stretch, and stroke thickness.
Specifics the geometry from the previous geometry effect process.
Notifies that the geometry has been invalidated because of external changes.
The geometry is typically invalidated when parameters are changed.
If any geometry has been invalidated externally, the geometry will be recomputed regardless if the layout bounds change.
Update the geometry based on the given parameters and layoutBounds.
Returns false if the geometry hasn't been changed.
Extends the way to provide geometry by implementing this function.
Returns true when any of the geometry is changed.
Extends the way to handle stretch mode.
The default is to always use Stretch.Fill and center stroke.
Apply the geometry effect when dirty or forced and update this.Geometry.
Otherwise, keep this.Geometry as this.cachedGeometry.
Gets or sets the resulting geometry after the latest UpdateGeometry().
Gets the bounding box that the geometry should stretch to.
The actual geometry might be smaller or larger than this.
should already take stroke thickness and stretch into consideration.
Gets the actual bounds of FrameworkElement.
includes logical bounds, stretch and stroke thickness.
Arc recognizes Stretch.None as the same as Stretch.Fill, assuming aspect ratio = 1:1.
Normalize thickness, both relative to the bounding box and the absolute pixel.
Relative thickness = 0 -> full circle radius or clamped.
Relative thickness = 1 -> shrank to a dot, or degenerated.
The arc is degenerated to a line pointing to center / normal inward.
Compute a list of angle pairs, defining the ranges in which arc sample should locate.
The return value have 2, 4, or 6 double values, each pair defines a range and they are in the order
to span the angles from given start to end angles. The ranges will break at the self-intersect angle.
If input start/end are within the invalid range between self intersect angle, it will be moved to neighboring self intersect.
Move angle to 0-90 range.
Compute all pieces of inner curves with each pair of input angles, and connect them with poly Bezier segments.
The new segments are output to given figure.Segments list from the given index. The start point is output seperately.
Compute one piece of inner curve with given angle range, and output one piece of smooth curve in format of poly Beizer semgents.
Compute the parameter (angle) of the self-intersect point for given ellipse with given thickness.
The result is always in first quadrant, and might be 0 or 90 indicating no self-intersect.
Basic algorithm is to binary search for the angle that sample point is not in first quadrant.
Specifies the direction the arrow points.
The arrow points to the left.
The arrow points to the right.
The arrow points up.
The arrow points down.
B
/|
/ C--D
A |
\ C--D
\|
B
Algorithm only uses Width/Height assuming top-left at 0,0.
Specifies the rendering style of a callout shape.
A rectangular callout.
A rectangular callout with rounded corners.
A oval-shaped callout.
A cloud-shaped callout.
Updates the edge line, and then connects to the anchor point if necessary.
Updates the polyline segment, and then connects start, anchor, and end points with the callout style.
Updates the line segment to a given point.
Computes the corner points in a clockwise direction, with eight points for the four corners.
The corner arc is always smaller than a 90-degree arc.
Provides the base class for GeometryEffect that transforms a geometry into another geometry.
This class provides the basic implementation of processing the rendered geometry of a IShape before it's passed to rendering.
A typical implementation will extend the virtual function to transform the input geometry.
is typically attached to as an attached property and activated when geometry is updated.
The of a will replace the rendered geometry in .
Gets the geometry effect as an attached property on a given dependency object.
Sets the geometry effect as an attached property on a given dependency object.
Makes a deep copy of the using its current values.
Makes a deep copy of the geometry effect. Implements CloneCurrentValue in Silverlight.
A clone of the current instance of the geometry effect.
Tests if the given geometry effect is equivalent to the current instance.
A geometry effect to compare with.
Returns true when two effects render with the same appearance.
Specifics the geometry from the previous geometry effect process.
Invalidates the geometry effect without actually computing the geometry.
Notifies all parent shapes or effects to invalidate accordingly.
Processes the geometry effect on a given input geometry.
Stores the result in GeometryEffect.OutputGeometry.
Returns false if nothing has been changed.
Extends the way of updating cachedGeometry based on a given input geometry.
Notified when detached from a parent chain.
Notified when attached to a parent chain.
Invalidates the geometry on a given dependency object when
the object is a valid parent type (IShape or GeometryEffect).
Implement the Freezable in WPF.
The default geometry effect that only passes through the input geometry.
Gets the output geometry of this geometry effect.
Parent can be either IShape or GeometryEffectGroup.
Provides the conversion between string and geometry effects.
This class enables the brief syntax in XAML like `GeometryEffect="Sketch"`

.
Creates a clone of the instance of the geometry effect so it can be used as a resource.
Builds a preset list of supported geometry effects.
A GeometryEffect that can be converted from a string type.
A GeometryEffect that can be converted to a string type.
Converts a string to a geometry effect. The fallback value is null.
Converts a geometry effect into a string. The fallback value is null.
Specifies the reason of being called.
Geometry has been invalidated because a property has been changed.
Geometry has been invalidated because a property is being animated.
Geometry has been invalidated because a child has been invalidated.
Geometry has been invalidated because a parent has been invalidated.
Geometry has been invalidated because a new template has been applied.
Provides helper extension methods to work with IGeometrySource and parameters.
Specifies the arrow head type.
No arrow head.
A triangle arrow head.
A stealth triangle arrow head.
An open triangle arrow head.
An oval arrow head.
Specifies the corner location.
On the top left of the bounding box.
On the top right of the bounding box.
On the bottom right of the bounding box.
On the bottom left of the bounding box.
Polygon recognizes Stretch.None as the same as Stretch.Fill.
A geometry effect that transforms any geometry into a Sketch style as in SketchFlow.
Makes a deep copy of the geometry effect.
A clone of the current instance of the geometry effect.
Tests if the given geometry effect is equivalent to the current instance.
A geometry effect to compare with.
Returns true when two effects render with the same appearance.
Updating cachedGeometry based on the given input geometry.
An input geometry.
Returns true when anything on cachedGeometry has been updated.
Use the same random seed on creation to keep visual flickering to a minimum.
Iterates all simple segments in given path figure including the closing chord.
Renders an arc shape supporting Arc, Ring, and Pie mode controlled by ArcThickness.
Platform-neutral implementation of Shape deriving from WPF:Shape or SL:Path.
Provides the WPF implementation of Shape that derives from the platform Shape.
Extends how the shape is drawn with creating geometry source.
Invalidates the geometry for a . After the invalidation, the will recompute the geometry, which will occur asynchronously.
Provides the behavior for the Measure portion of Silverlight layout pass. Classes can override this method to define their own Measure pass behavior.
The size that this object determines it requires during layout, based on its calculations of child object allotted sizes, or possibly on other considerations such as fixed container size.
The available size that this object can provide to child objects. Infinity () can be specified as a value to indicate that the object will size to whatever content is available.
In WPF, measure override works from Shape.DefiningGeometry which is not always as expected
see bug 99497 for details where WPF is not having correct measure by default.
In Silverlight, measure override on Path does not work the same as primitive shape works.
We should return the smallest size this shape can correctly render without clipping.
By default a shape can render as small as a dot, therefore returning the strokethickness.
Provides the behavior for the Arrange portion of Silverlight layout pass. Classes can override this method to define their own Arrange pass behavior.
The actual size used once the element is arranged in layout.
The final area within the parent that this object should use to arrange itself and its children.
will recompute the Geometry when it's invalidated and update the RenderedGeometry and GeometryMargin.
Occurs when RenderedGeometry is changed.
Gets the margin between logical bounds and actual geometry bounds.
This can be either positive (as in ) or negative (as in ).
Gets or sets the start angle.
The start angle in degrees. Zero degrees is pointing up.
Gets or sets the end angle.
The end angle in degrees. Zero degrees is pointing up.
Gets or sets the arc thickness.
The arc thickness in pixels or percentage depending on "ArcThicknessUnit".
Gets or sets the arc thickness unit.
The arc thickness unit in pixels or percentage.
Renders a block arrow shape that supports resizable arrow head and body.
Gets or sets the orientation.
The orientation where the arrow is pointing to.
Gets or sets the arrow head angle.
The arrow head angle in degrees.
Gets or sets the size of the arrow body.
The size of the arrow body in pixels.
Renders a regular polygon shape or corresponding star shape with variable number of points.
Gets or sets the number of points of the .
Gets or sets the the distance between the center and the innermost point.
The distance between the center and the innermost point.