Loading...
Searching...
No Matches
juce::PathStrokeType Class Reference

## Detailed Description

Describes a type of stroke used to render a solid outline along a path.

A PathStrokeType object can be used directly to create the shape of an outline around a path, and is used by Graphics::strokePath to specify the type of stroke to draw.

See also
  Path, Graphics::strokePath

The documentation for this class was generated from the following file:

- juce_graphics/geometry/juce_PathStrokeType.h

## Public Types

enum | JointStyle { mitered , curved , beveled }
| The type of shape to use for the corners between two adjacent line segments. More...
enum | EndCapStyle { butt , square , rounded }
| The type shape to use for the ends of lines. More...

## Public Member Functions

| PathStrokeType (float strokeThickness) noexcept
| Creates a stroke type with a given line-width, and default joint/end styles.
| PathStrokeType (float strokeThickness, JointStyle jointStyle, EndCapStyle endStyle=butt) noexcept
| Creates a stroke type.
| PathStrokeType (const PathStrokeType &) noexcept
| Creates a copy of another stroke type.
PathStrokeType & | operator= (const PathStrokeType &) noexcept
| Copies another stroke onto this one.
| ~PathStrokeType () noexcept
| Destructor.
void | createStrokedPath (Path &destPath, const Path &sourcePath, const AffineTransform &transform=AffineTransform(), float extraAccuracy=1.0f) const
| Applies this stroke type to a path and returns the resultant stroke as another Path.
void | createDashedStroke (Path &destPath, const Path &sourcePath, const float *dashLengths, int numDashLengths, const AffineTransform &transform=AffineTransform(), float extraAccuracy=1.0f) const
| Applies this stroke type to a path, creating a dashed line.
void | createStrokeWithArrowheads (Path &destPath, const Path &sourcePath, float arrowheadStartWidth, float arrowheadStartLength, float arrowheadEndWidth, float arrowheadEndLength, const AffineTransform &transform=AffineTransform(), float extraAccuracy=1.0f) const
| Applies this stroke type to a path and returns the resultant stroke as another Path.
float | getStrokeThickness () const noexcept
| Returns the stroke thickness.
void | setStrokeThickness (float newThickness) noexcept
| Sets the stroke thickness.
JointStyle | getJointStyle () const noexcept
| Returns the joint style.
void | setJointStyle (JointStyle newStyle) noexcept
| Sets the joint style.
EndCapStyle | getEndStyle () const noexcept
| Returns the end-cap style.
void | setEndStyle (EndCapStyle newStyle) noexcept
| Sets the end-cap style.
bool | operator== (const PathStrokeType &) const noexcept
| Compares the stroke thickness, joint and end styles of two stroke types.
bool | operator!= (const PathStrokeType &) const noexcept
| Compares the stroke thickness, joint and end styles of two stroke types.

## Member Enums

## JointStyle

enum juce::PathStrokeType::JointStyle

The type of shape to use for the corners between two adjacent line segments.

Enumerator
mitered | Indicates that corners should be drawn with sharp joints. Note that for angles that curve back on themselves, drawing a mitre could require extending the point too far away from the path, so a mitre limit is imposed and any corners that exceed it are drawn as bevelled instead.
curved | Indicates that corners should be drawn as rounded-off.
beveled | Indicates that corners should be drawn with a line flattening their outside edge.

## EndCapStyle

enum juce::PathStrokeType::EndCapStyle

The type shape to use for the ends of lines.

Enumerator
butt | Ends of lines are flat and don't extend beyond the end point.
square | Ends of lines are flat, but stick out beyond the end point for half the thickness of the stroke.
rounded | Ends of lines are rounded-off with a circular shape.

## Constructors and Destructors

## PathStrokeType() [1/3]

juce::PathStrokeType::PathStrokeType | ( | float | strokeThickness | ) |

explicit noexcept

Creates a stroke type with a given line-width, and default joint/end styles.

Referenced by operator!=(), operator=(), operator==(), and PathStrokeType().

## PathStrokeType() [2/3]

juce::PathStrokeType::PathStrokeType | ( | float | strokeThickness,
|  | JointStyle | jointStyle,
|  | EndCapStyle | endStyle = butt )

noexcept

Creates a stroke type.

Parameters

  strokeThickness | the width of the line to use
  jointStyle | the type of joints to use for corners
  endStyle | the type of end-caps to use for the ends of open paths.

References butt.

## PathStrokeType() [3/3]

juce::PathStrokeType::PathStrokeType | ( | const PathStrokeType & |  | ) |

noexcept

Creates a copy of another stroke type.

References PathStrokeType().

## ~PathStrokeType()

juce::PathStrokeType::~PathStrokeType | ( |  | ) |

noexcept

Destructor.

## Member Functions

## operator=()

PathStrokeType & juce::PathStrokeType::operator= | ( | const PathStrokeType & |  | ) |

noexcept

Copies another stroke onto this one.

References PathStrokeType().

## createStrokedPath()

void juce::PathStrokeType::createStrokedPath | ( | Path & | destPath,
|  | const Path & | sourcePath,
|  | const AffineTransform & | transform = AffineTransform(),
|  | float | extraAccuracy = 1.0f ) const

Applies this stroke type to a path and returns the resultant stroke as another Path.

Parameters

  destPath | the resultant stroked outline shape will be copied into this path. Note that it's ok for the source and destination Paths to be the same object, so you can easily turn a path into a stroked version of itself.
  sourcePath | the path to use as the source
  transform | an optional transform to apply to the points from the source path as they are being used
  extraAccuracy | if this is greater than 1.0, it will subdivide the path to a higher resolution, which improves the quality if you'll later want to enlarge the stroked path. So for example, if you're planning on drawing the stroke at 3x the size that you're creating it, you should set this to 3.

See also
  createDashedStroke

References createStrokedPath().

Referenced by createStrokedPath(), and juce::LowLevelGraphicsContext::strokePath().

## createDashedStroke()

void juce::PathStrokeType::createDashedStroke | ( | Path & | destPath,
|  | const Path & | sourcePath,
|  | const float * | dashLengths,
|  | int | numDashLengths,
|  | const AffineTransform & | transform = AffineTransform(),
|  | float | extraAccuracy = 1.0f ) const

Applies this stroke type to a path, creating a dashed line.

This is similar to createStrokedPath, but uses the array passed in to break the stroke up into a series of dashes.

Parameters

  destPath | the resultant stroked outline shape will be copied into this path. Note that it's ok for the source and destination Paths to be the same object, so you can easily turn a path into a stroked version of itself.
  sourcePath | the path to use as the source
  dashLengths | An array of alternating on/off lengths. E.g. { 2, 3, 4, 5 } will create a line of length 2, then skip a length of 3, then add a line of length 4, skip 5, and keep repeating this pattern.
  numDashLengths | The number of lengths in the dashLengths array. This should really be an even number, otherwise the pattern will get out of step as it repeats.
  transform | an optional transform to apply to the points from the source path as they are being used
  extraAccuracy | if this is greater than 1.0, it will subdivide the path to a higher resolution, which improves the quality if you'll later want to enlarge the stroked path. So for example, if you're planning on drawing the stroke at 3x the size that you're creating it, you should set this to 3.

References createDashedStroke().

Referenced by createDashedStroke().

## createStrokeWithArrowheads()

void juce::PathStrokeType::createStrokeWithArrowheads | ( | Path & | destPath,
|  | const Path & | sourcePath,
|  | float | arrowheadStartWidth,
|  | float | arrowheadStartLength,
|  | float | arrowheadEndWidth,
|  | float | arrowheadEndLength,
|  | const AffineTransform & | transform = AffineTransform(),
|  | float | extraAccuracy = 1.0f ) const

Applies this stroke type to a path and returns the resultant stroke as another Path.

Parameters

  destPath | the resultant stroked outline shape will be copied into this path. Note that it's ok for the source and destination Paths to be the same object, so you can easily turn a path into a stroked version of itself.
  sourcePath | the path to use as the source
  arrowheadStartWidth | the width of the arrowhead at the start of the path
  arrowheadStartLength | the length of the arrowhead at the start of the path
  arrowheadEndWidth | the width of the arrowhead at the end of the path
  arrowheadEndLength | the length of the arrowhead at the end of the path
  transform | an optional transform to apply to the points from the source path as they are being used
  extraAccuracy | if this is greater than 1.0, it will subdivide the path to a higher resolution, which improves the quality if you'll later want to enlarge the stroked path. So for example, if you're planning on drawing the stroke at 3x the size that you're creating it, you should set this to 3.

See also
  createDashedStroke

References createStrokeWithArrowheads().

Referenced by createStrokeWithArrowheads().

## getStrokeThickness()

float juce::PathStrokeType::getStrokeThickness | ( |  | ) | const

inline noexcept

Returns the stroke thickness.

References getStrokeThickness().

Referenced by getStrokeThickness().

## setStrokeThickness()

void juce::PathStrokeType::setStrokeThickness | ( | float | newThickness | ) |

inline noexcept

Sets the stroke thickness.

## getJointStyle()

JointStyle juce::PathStrokeType::getJointStyle | ( |  | ) | const

inline noexcept

Returns the joint style.

## setJointStyle()

void juce::PathStrokeType::setJointStyle | ( | JointStyle | newStyle | ) |

inline noexcept

Sets the joint style.

## getEndStyle()

EndCapStyle juce::PathStrokeType::getEndStyle | ( |  | ) | const

inline noexcept

Returns the end-cap style.

## setEndStyle()

void juce::PathStrokeType::setEndStyle | ( | EndCapStyle | newStyle | ) |

inline noexcept

Sets the end-cap style.

## operator==()

bool juce::PathStrokeType::operator== | ( | const PathStrokeType & |  | ) | const

noexcept

Compares the stroke thickness, joint and end styles of two stroke types.

References PathStrokeType().

## operator!=()

bool juce::PathStrokeType::operator!= | ( | const PathStrokeType & |  | ) | const

noexcept

Compares the stroke thickness, joint and end styles of two stroke types.

References PathStrokeType().

### Purchase

Get JUCE

### Discover

What's New in JUCE Features

### Learn

Documentaion Tutorials Made with JUCE Resources

### Support

JUCE Forum Newsletter Archive

### About

Contact Us JUCE Legal JUCE Licensing FAQ

### Events

Audio Developer Conference
© Raw Material Software Limited