AIBeautifulStrokesSuite Struct Reference
[API Suite List]

This suite allows you to control advanced features for stroking paths. More...

#include <AIBeautifulStrokes.h>

Public Attributes
AIAPI AIErr(*	GenerateArt )(ConstAILiveEffectParameters effectParams, AIArtHandle inArt, AIArtHandle sourceArt, AIBoolean outputOnTop, AIArtHandle outGroup, AIArtHandle *outArt, AIGenerateArtProgressProc progressProc)
	Applies settings in a BeautifulStrokes parameters dictionary to the focal stroke on source art to generate new stroked art in the output group.
AIAPI AIErr(*	CreateParamsDict )(AILiveEffectParameters effectParams, AIDictionaryRef &params)
	Creates a new BeautifulStrokes params dictionary.
AIAPI AIErr(*	GetParamsDict )(ConstAILiveEffectParameters effectParams, AIDictionaryRef &params)
	Retrieves a BeautifulStrokes parameters dictionary from a set of LiveEffect parameters.
AIAPI AIBoolean(*	Equiv )(ConstAIDictionaryRef params1, ConstAIDictionaryRef params2)
	Reports whether two parameters dictionaries are equivalent.
AIAPI AIErr(*	AccumulateParams )(ConstAILiveEffectParameters effectParams, AIDictionaryRef accumulator)
	Accumulates common parameters in a dictionary to be used later with `ApplyParams()`.
AIAPI AIErr(*	ApplyParams )(ConstAIDictionaryRef params, AIDictionaryRef target)
	Applies a set of parameters from one dictionary to another.
AIAPI AIBoolean(*	ContainsParams )(ConstAIDictionaryRef paramsDict)
	Reports whether a dictionary contains meaningful Beautiful Strokes parameters.
AIAPI AIErr(*	GetArtStrokeParams )(AIArtHandle art, AIDictionaryRef &paramDict, AIStrokeStyle strokeStyle, AIBoolean hasBrush, AIReal scaleFactor, AIBoolean canAccept)
	Retrieves the BeautifulStrokes params dictionary, if any, associated with the focal stroke of an art object.
AIAPI AIErr(*	InterpolateParams )(ConstAILiveEffectParameters effectParams1, ConstAILiveEffectParameters effectParams2, AILiveEffectParameters effectParamsOut, AIReal dist)
	Interpolates beautiful stroke parameters between two appearances.
AIAPI AIErr(*	SetFlipAcross )(AIDictionaryRef params, AIBoolean flipAcross)
	Sets the option in a Beautiful Strokes dictionary to flip art across path to reverse vertical orientation.
AIAPI AIBoolean(*	GetFlipAcross )(ConstAIDictionaryRef params)
	Retrieves the option from a Beautiful Strokes dictionary to flip art across path to reverse vertical orientation.
AIAPI AIErr(*	SetFlipAlong )(AIDictionaryRef params, AIBoolean flipAlong)
	Sets the option in a Beautiful Strokes dictionary to flip art along path to reverse lateral orientation.
AIAPI AIBoolean(*	GetFlipAlong )(ConstAIDictionaryRef params)
	Retrieves the option from a Beautiful Strokes dictionary to flip art along path to reverse lateral orientation.
AIAPI AIErr(*	SetScale )(AIDictionaryRef params, AIReal scale, const AIReal mnScale, const AIReal mxScale)
	Sets the scale (width) of art applied to path in a Beautiful Strokes dictionary.
AIAPI AIErr(*	GetScale )(ConstAIDictionaryRef params, AIReal &scale, AIReal mnScale, AIReal mxScale)
	Retrieves the scale (width) of art applied to path from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetFoldAdjustment )(AIDictionaryRef params, AIBoolean adjust)
	Set fold adjustment on or off.
AIAPI AIBoolean(*	GetFoldAdjustment )(ConstAIDictionaryRef params, AIBoolean *mixed)
	Retrieves the fold adjustment status from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetArtPaint )(AIDictionaryRef params, AIPatternHandle art)
	Sets the pattern to be applied along path in a Beautiful Strokes dictionary.
AIAPI AIPatternHandle(*	GetArtPaint )(ConstAIDictionaryRef params)
	Retrieves the pattern to be applied along path from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetStretch )(AIDictionaryRef params, AIBoolean stretch)
	Sets the stretching option in a Beautiful Strokes dictionary.
AIAPI AIBoolean(*	GetStretch )(ConstAIDictionaryRef params)
	Retrieves the stretching option from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetStartEndSegmentLength )(AIDictionaryRef params, AIReal startSegmentLength, AIReal endSegmentLength)
	Sets the lengths of non-stretching start and end segments for a segmented brush in a Beautiful Strokes dictionary.
AIAPI AIErr(*	GetStartEndSegmentLength )(ConstAIDictionaryRef params, AIReal &startSegmentLength, AIReal &endSegmentLength)
	Retrieves the lengths of non-stretching start and end segments for a segmented brush from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetArtPatternPaint )(AIDictionaryRef params, AIPatternHandle beginArt, AIPatternHandle endArt, AIPatternHandle sideArt, AIPatternHandle insideCornerArt, AIPatternHandle outsideCornerArt, RepeatedArtAdjustment adjustment, AIReal spacing, RepeatedArtCorner insideAutoCornerOption, RepeatedArtCorner outsideAutoCornerOption)
	Sets options for repeating pattern tiles along a path in a Beautiful Strokes dictionary.
AIAPI AIErr(*	GetArtPatternPaint )(ConstAIDictionaryRef params, AIPatternHandle &beginArt, AIPatternHandle &endArt, AIPatternHandle &sideArt, AIPatternHandle &insideCornerArt, AIPatternHandle &outsideCornerArt, RepeatedArtAdjustment &adjustment, AIReal &spacing, RepeatedArtCorner &insideAutoCornerOption, RepeatedArtCorner &outsideAutoCornerOption)
	Retrieves options for repeating pattern tiles along a path from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetDashAdjustment )(AIDictionaryRef params, AIBoolean adjust)
	Sets or clears the dash adjustment option in a Beautiful Strokes dictionary.
AIAPI AIBoolean(*	GetDashAdjustment )(ConstAIDictionaryRef params, AIBoolean *mixed)
	Retrieves the dash adjustment status from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetGradientStrokeApplication )(AIDictionaryRef params, GradientStrokeApplication application)
	Sets the gradient stroke application method.
AIAPI AIErr(*	GetGradientStrokeApplication )(ConstAIDictionaryRef params, GradientStrokeApplication &application, AIBoolean *mixed)
	Retrieves the gradient stroke application method status from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetArrowheadOptions )(AIDictionaryRef params, AIPatternHandle beginSymbol, AIPatternHandle endSymbol, AIReal beginScale, AIReal endScale, ArrowTipAlignment alignment)
	Sets arrowhead-related stroke options in a Beautiful Strokes dictionary.
AIAPI AIErr(*	GetArrowheadOptions )(ConstAIDictionaryRef params, AIPatternHandle beginSymbol, AIPatternHandle endSymbol, AIReal beginScale, AIReal endScale, ArrowTipAlignment alignment, AIBoolean mixedBeginArrows, AIBoolean *mixedEndArrows)
	Retrieves arrowhead-related stroke options from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetWidthSource )(AIDictionaryRef params, StrokeWidthSource source)
	Sets the source of stroke width in a Beautiful Strokes dictionary.
AIAPI StrokeWidthSource(*	GetWidthSource )(ConstAIDictionaryRef params)
	Retrieves the source of stroke width from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetWidthTabletDataSource )(AIDictionaryRef params, AITabletDataType dataType)
	Sets the type of tablet data to use for stroke width in the art passed to `GenerateArt()`, in a Beautiful Strokes dictionary.
AIAPI AIErr(*	GetWidthTabletDataSource )(ConstAIDictionaryRef params, AITabletDataType &dataType)
	Retrieves the tablet-data type option from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetCenteredWidthProfile )(AIDictionaryRef params, AIArrayRef tVals, AIArrayRef widths)
	Sets centered width profile for output art in a Beautiful Strokes dictionary.
AIAPI AIErr(*	GetCenteredWidthProfile )(ConstAIDictionaryRef params, AIArrayRef &distances, AIArrayRef &widths)
	Retrieves the centered width profile for output art from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetUncenteredWidthProfile )(AIDictionaryRef params, AIArrayRef tVals, AIArrayRef leftWidths, AIArrayRef rightWidths)
	Sets an uncentered width profile for output art in a Beautiful Strokes dictionary, with independent left and right width values.
AIAPI AIErr(*	GetUncenteredWidthProfile )(ConstAIDictionaryRef params, AIArrayRef &tVals, AIArrayRef &leftWidths, AIArrayRef &rightWidths)
	Retrieves the uncentered width profile for output art from a Beautiful Strokes dictionary.
AIAPI AIErr(*	SetWidthProfileDetails )(AIDictionaryRef params, AIArrayRef markerOptions, AIArrayRef incomingLeftSmoothness, AIArrayRef outgoingLeftSmoothness, AIArrayRef incomingRightSmoothness, AIArrayRef outgoingRightSmoothness)
	INTENDED FOR FUTURE ENHANCEMENTS - All non-default options are currently ignored.
AIAPI AIErr(*	GetWidthProfileDetails )(ConstAIDictionaryRef params, AIArrayRef &markerOptions, AIArrayRef &incomingLeftSmoothness, AIArrayRef &outgoingLeftSmoothness, AIArrayRef &incomingRightSmoothness, AIArrayRef &outgoingRightSmoothness)
	Retrieves the options for the width profile markers from a Beautiful Strokes dictionary.
AIAPI AIErr(*	GetPathAdjustedWidthDistances )(AIArtHandle path, AIArrayRef &adjustedDistances)
	If a path has variable widths (either centered or uncentered), retrieves a vector of the values from the distance array, after adjustment to shift any anchored width points to the relative distance along that path of the path positions they are anchored to.
AIAPI AIErr(*	GetWidthsAtDistance )(AIArtHandle path, AIReal &lengthFraction, AIReal tolerance, AIReal totalWidth, AIReal leftWidth, AIReal rightWidth, StrokeWidthSource widthSource, ai::int16 markerIndex, WidthMarkerFlags markerDetails)
	Retrieves the left, right, and combined widths of the focal stroke at a fraction of the distance along a path, and reports the source of the widths.
AIAPI AIErr(*	SetCenteredWidthAtDistance )(AIArtHandle path, AIReal lengthFraction, AIReal width, WidthMarkerFlags options)
	Sets the total width of the focal stroke at a given fraction of the distance along the path.
AIAPI AIErr(*	SetUncenteredWidthsAtDistance )(AIArtHandle path, AIReal lengthFraction, AIReal leftWidth, AIReal rightWidth, WidthMarkerFlags options)
	Sets the left and right widths of the focal stroke at a given fraction of the distance along the given path.
AIAPI AIErr(*	SlideWidthMarkerToNewT )(AIArtHandle path, ai::int16 markerIndex, AIReal &newTValue, WidthMarkerFlags options)
	Moves the width marker at the given index to a new t value.
AIAPI AIErr(*	DeleteWidthPoint )(AIArtHandle path, ai::int16 markerIndex)
	Deletes the width point at the given index position from the given path.
AIAPI AIErr(*	AdjustWidthAnchorsBeforePathEdit )(AIArtHandle path, const PathEditDescription &editDescription)
	Adds, removes, or reindexes width profile anchors as needed before editing a path.
AIAPI AIErr(*	StrokeHitTest )(AIArtHandle path, const AIRealPoint &cursor, AIReal tolerance, StrokeHitResults *hitResults)
	Tests whether a cursor point on a path is within a given tolerance of the region covered by the stroke, and if so, reports additional details about what part of the stroke was hit; see `StrokeHitResults`.

Detailed Description

This suite allows you to control advanced features for stroking paths.

Setting are kept in a BeautifulStrokes params dictionary, which is contained in an AILiveEffectParameters dictionary, such as one returned by AIPathStyleSuite::GetCurrentPathStyle().
One way to use this suite is to create a BeautifulStrokes params dictionary, add the stroke settings to the dictionary, then use that dictionary to apply the settings to source art. This generates new art in a destination group. For example:

        void Fn(AIArtHandle srcPath, AIArtHandle dstGroup)
        {
                AIDictionaryRef params = 0;
                sAIBeautifulStrokes->CreateParamsDict(NULL, params);
                sAIBeautifulStrokes->SetDashAdjustment(params, true);
                sAIBeautifulStrokes->GenerateArt(params, srcPath, NULL, TRUE, dstGroup, NULL);
                sAIDictionary->Release(params);
        }

Counted object note: Suite functions that return counted object types such as AIDictionarySuite::AIDictionaryRef and AIArraySuite::AIArrayRef increment the reference count and the caller must release unneeded references to avoid memory leaks, as shown in the examples. Documentation for individual parameters mentions those that are reference counted and need to be released. See also AICountedObjectSuite and the ai::Ref C++ class.

The example above uses the AIDictionarySuite::Release() directly. The following example uses the ai::Ref C++ class to manage the counted object. (Note that AICountedObjectSuite::Release() is equivalent to AIDictionarySuite::Release()):

        void Fn_Ref(AILiveEffectParameters effectParams)
        {
                ai::Ref<AIDictionaryRef> params;
                sAIBeautifulStrokes->CreateParamsDict(NULL, *(params << ai::Replace));
                sAIBeautifulStrokes->SetDashAdjustment(params, true);
                sAIBeautifulStrokes->GenerateArt(params, srcPath, NULL, TRUE, dstGroup, NULL);
        }

Acquire this suite using SPBasicSuite::AcquireSuite() with the constants kAIBeautifulStrokesSuite and kAIBeautifulStrokesVersion.

Member Data Documentation

AIAPI AIErr(* AIBeautifulStrokesSuite::AccumulateParams)(ConstAILiveEffectParameters effectParams, AIDictionaryRef accumulator)

Accumulates common parameters in a dictionary to be used later with ApplyParams().

Call repeatedly with different parameter sets to collect the combined BeautifulStrokes attributes of multiple objects (or multiple art styles). You can use this to collect common attributes of objects that are not necessarily selected, or to ignore some of the selected objects, such as finding the combined BeautifulStrokes attributes of all the objects on a layer, whether they are selected or not.

Parameters:

	effectParams	A set of LiveEffect parameters containing a Beautiful Strokes params dictionary.
	accumulator	Common parameters being accumulated.

AIAPI AIErr(* AIBeautifulStrokesSuite::AdjustWidthAnchorsBeforePathEdit)(AIArtHandle path, const PathEditDescription &editDescription)

Adds, removes, or reindexes width profile anchors as needed before editing a path.

An editing tool or command calls this before modifying the geometry of a path or applying a different art style.

Modifies anchors at a subset of the same places that cause kSelectorAINotifyEdits to be sent to plug-in groups ancestral to the edited path. It is not necessary to send this message if the path is being transformed in its entirety in a way that does not change the relative lengths of path segments.

If width anchors already exist at the relevant anchor points, and the numbers of anchor points are not changing, does nothing.

Parameters:

	path	The path to be edited.
	editDescription	The type of edit to be done.

AIAPI AIErr(* AIBeautifulStrokesSuite::ApplyParams)(ConstAIDictionaryRef params, AIDictionaryRef target)

Applies a set of parameters from one dictionary to another.

For keys that exist in both dictionaries, the value from the source overwrites the value in the destination.

Parameters:

	params	The source dictionary containing a set of parameters to be applied. Typically obtained from `AIPathStyleSuite::GetCurrentPathStyle()`, from an art object or art style. If an accumulated dictionary is passed as the source, values that vary (were mixed in the selection) do not change value in the target dictionary. This is consistent with the behavior of `AIPathStyleSuite::SetCurrentPathStyle()`. See also `AccumulateParams()`.
	target	The target dictionary.

AIAPI AIBoolean(* AIBeautifulStrokesSuite::ContainsParams)(ConstAIDictionaryRef paramsDict)

Reports whether a dictionary contains meaningful Beautiful Strokes parameters.

(Note that this function returns a Boolean value, not an error code.) Call on an accumulator to check whether it contains any BeautifulStrokes parameters; if not, it can be freed or ignored. See AccumulateParams(). Both a used accumulator and a new dictionary contain some bookkeeping entries, so you cannot just check for the dictionary being empty of all keys. A new dictionary just created by CreateParamsDict() returns false to this call.

This does not recurse into sub-dictionaries. To test for nested dictionaries, call GetParamsDict(), and if it is non-null check the contained dictionary.

Parameters:

paramsDict

Dictionary to be examined.

Returns:: True if the dictionary contains Beautiful Strokes parameters.

AIAPI AIErr(* AIBeautifulStrokesSuite::CreateParamsDict)(AILiveEffectParameters effectParams, AIDictionaryRef &params)

Creates a new BeautifulStrokes params dictionary.

You must release the dictionary when no longer needed using AIDictionarySuite::Release().

Parameters:

	effectParams	[optional] A set of LiveEffect parameters. If supplied, the new BeautifulStrokes params dictionary is added to this dictionary, or, if a BeautifulStrokes dictionary already exists, `params` is set to this existing dictionary.
	params	A reference to a new or the existing BeautifulStrokes params dictionary. The reference count on this dictionary is incremented on return and must be released when no longer needed.

AIAPI AIErr(* AIBeautifulStrokesSuite::DeleteWidthPoint)(AIArtHandle path, ai::int16 markerIndex)

Deletes the width point at the given index position from the given path.

The first and last width points cannot be deleted.

Parameters:

	path	The path.
	markerIndex	The index position of the point to delete.

AIAPI AIBoolean(* AIBeautifulStrokesSuite::Equiv)(ConstAIDictionaryRef params1, ConstAIDictionaryRef params2)

Reports whether two parameters dictionaries are equivalent.

Parameters:

	params1	The first dictionary.
	params2	The second dictionary.

Returns:: True if equivalent.

AIAPI AIErr(* AIBeautifulStrokesSuite::GenerateArt)(ConstAILiveEffectParameters effectParams, AIArtHandle inArt, AIArtHandle sourceArt, AIBoolean outputOnTop, AIArtHandle outGroup, AIArtHandle *outArt, AIGenerateArtProgressProc progressProc)

Applies settings in a BeautifulStrokes parameters dictionary to the focal stroke on source art to generate new stroked art in the output group.

Parameters:

	effectParams	An effect parameters dictionary that contains a BeautifulStrokes params dictionary in which BeautifulStrokes settings are defined. This can also be a BeautifulStrokes params dictionary.
	inArt	The art (path) to which the parameters are to be applied.
	sourceArt	[optional] The non-styled art (path) possibly containing width anchors that can be used to adjust the width profile placement. (See `AIBeautifulStrokesSuite::GetPathAdjustedWidthDistances()`.) This parameter is ignored if inArt is not styled art (see `AIArtSuite::IsArtStyledArt()`), since non-styled art will carry its own anchors. But art dictionaries are stripped from the input art to live effects. Thus, if `inArt` is the input art to a live effect execution for a stroke filter, and the art style being executed was attached to a path, then passing `sourceArt` as the non-styled path art object to which that art style was attached will allow access to the width anchors. (If there are no vector pre-effects before the stroke filter, then `inArt` will generally be a duplicate of `sourceArt`, but if there are vector pre-effects, then it may be substantially different.) Passing this parameter as null when inArt is styled art will cause any width profile in the effectParams to be applied without width anchor adjustment.
	outputOnTop	True to place the output art into the output group on top, false to place it inside the output group on the bottom.
	outGroup	The destination group for the generated output art.
	outArt	[optional] A pointer to an AIArtHandle in which to return the AIArtHandle for the generated output art.
	progressProc	A callback procedure for displaying a progress bar during computation (from which the user can cancel the operation) or `nil` to show no progress bar.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetArrowheadOptions)(ConstAIDictionaryRef params, AIPatternHandle *beginSymbol, AIPatternHandle *endSymbol, AIReal *beginScale, AIReal *endScale, ArrowTipAlignment *alignment, AIBoolean *mixedBeginArrows, AIBoolean *mixedEndArrows)

Retrieves arrowhead-related stroke options from a Beautiful Strokes dictionary.

All pointer arguments are optional and may be null if those options are not being queried.

Parameters:

	params	The parameters dictionary to be searched. May be an accumulation of multiple paths, if returned from `AIPathStyleSuite::GetCurrentPathStyle()`.
	beginSymbol	[out] A buffer in which to return the symbol used as the arrowhead at the beginning of the path, null if none.
	endSymbol	[out] A buffer in which to return the symbol used as the arrowhead at the end of the path, null if none.
	beginScale	[out] A buffer in which to return the factor to uniformly scale the begin arrow by, as a percentage relative to the default scale. Returns `kAIRealUnknown` if the params dict represents an accumulation with mixed values.
	endScale	[out] A buffer in which to return the factor to scale the end arrow by, as a percentage relative to the default scale Returns `kAIRealUnknown` if the params dict represents an accumulation with mixed values.
	alignment	[out] A buffer in which to return the rule for positioning the arrows at the ends of the path. Must be the same for both ends. Returns `kUnknownArrowAlignment` if the params dict represents an accumulation and the selection is mixed (including if some paths have no arrowheads).
	mixedBeginArrows	[out] A buffer in which to return true if there are different choices for the begin-symbol in a mixed selection (including if some paths have no begin arrow and some do.)
	mixedEndArrows	[out] A buffer in which to return true if there are different choices for the end-symbol in a mixed selection (including if some paths have no begin arrow and some do.)

AIAPI AIPatternHandle(* AIBeautifulStrokesSuite::GetArtPaint)(ConstAIDictionaryRef params)

Retrieves the pattern to be applied along path from a Beautiful Strokes dictionary.

Note that this function returns an object, not an error code.

Parameters:

params

The parameters dictionary.

Returns:: The brush pattern.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetArtPatternPaint)(ConstAIDictionaryRef params, AIPatternHandle &beginArt, AIPatternHandle &endArt, AIPatternHandle &sideArt, AIPatternHandle &insideCornerArt, AIPatternHandle &outsideCornerArt, RepeatedArtAdjustment &adjustment, AIReal &spacing, RepeatedArtCorner &insideAutoCornerOption, RepeatedArtCorner &outsideAutoCornerOption)

Retrieves options for repeating pattern tiles along a path from a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	beginArt	[out] A reference in which to return the brush pattern tile art to be applied to the beginning of the path. May be NULL.
	endArt	[out] A reference in which to return the brush pattern tile art to be applied to the end of the path. May be NULL.
	sideArt	[out] A reference in which to return the brush pattern tile art to be applied to the main part of the path. May be NULL.
	insideCornerArt	[out] A reference in which to return the brush pattern tile art to be applied to inside corners of the path. May be NULL.
	outsideCornerArt	[out] A reference in which to return the brush pattern tile art to be applied to outside corners of the path. May be NULL.
	adjustment	[out] A reference in which to return the method to use to apply art along path; see `RepeatedArtAdjustment()`.
	spacing	[out] A reference in which to return the relative spacing between tiles. For example, 0.5 sets spacing to half the width of the tile. Relevant only when adjustment method is `kAddSpace`.
	insideAutoCornerOption	[out] A reference in which to return the type of Automatically Generated Corner to be used for Inside Corner. see `RepeatedArtCorner()`.
	outsideAutoCornerOption	[out] A reference in which to return the type of Automatically Generated Corner to be used for Outside Corner. see `RepeatedArtCorner()`.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetArtStrokeParams)(AIArtHandle art, AIDictionaryRef &paramDict, AIStrokeStyle *strokeStyle, AIBoolean *hasBrush, AIReal *scaleFactor, AIBoolean *canAccept)

Retrieves the BeautifulStrokes params dictionary, if any, associated with the focal stroke of an art object.

Optionally retrieves the stroke style and other information about the stroke attributes.

Parameters:

	art	The art object.
	paramDict	[out] A reference in which to return the BeautifulStrokes params dictionary, or null if none. The reference count on this dictionary is incremented on return and must be released when no longer needed.
	strokeStyle	[out][optional] A buffer in which to return the focal stroke style from the paint attributes.
	hasBrush	[out][optional] A buffer in which to return true if the focal stroke carries a brush effect.
	scaleFactor	[out][optional] A buffer in which to return the combined scale factor that incorporates: the object scale factor reported by `AIArtStyleSuite::GetArtStyleScaleFactor()`, the width of the art design on art brushes or the side tile on pattern brushes, and the scale factor from the brush options for brushes. Multiplying these widths by this factor gives the width that the stroke edges preview at, assuming that any brush art fills the brush tile boundaries. (Does not include the stroke weight or the width returned by `GetWidthsAtDistance()`, and so on.)
	canAccept	[out][optional] A buffer in which to return true if the art object has a style that can accept BeautifulStrokes parameters. (For CS5, it has a stroke, and the focal stroke is not a Calligraphic or Scatter brush, and is not inside/outside aligned.)

AIAPI AIErr(* AIBeautifulStrokesSuite::GetCenteredWidthProfile)(ConstAIDictionaryRef params, AIArrayRef &distances, AIArrayRef &widths)

Retrieves the centered width profile for output art from a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	distances	A reference in which to return an array of `AIReal` values ranging from [0-1] representing fractional distances along the path.
	widths	A reference in which to return an array of `AIReal` values the same size as `tVals` representing the fractional stroke width at the corresponding offset in the `tVals` array.

AIAPI AIBoolean(* AIBeautifulStrokesSuite::GetDashAdjustment)(ConstAIDictionaryRef params, AIBoolean *mixed)

Retrieves the dash adjustment status from a Beautiful Strokes dictionary.

See SetDashAdjustment(). (Note that this function returns a Boolean value, not an error code.)

Parameters:

	params	The parameters dictionary.
	mixed	[optional] [out] A buffer in which to return true if the dictionary represents an accumulation returned from `AIPathStyleSuite::GetCurrentPathStyle()`, and the selection is mixed. By convention, mixed values return false.

Returns:: True if the option is set, false if it is clear.

AIAPI AIBoolean(* AIBeautifulStrokesSuite::GetFlipAcross)(ConstAIDictionaryRef params)

Retrieves the option from a Beautiful Strokes dictionary to flip art across path to reverse vertical orientation.

Note that this function returns a Boolean value, not an error code.

Parameters:

params

The parameters dictionary.

Returns:: True if the option is set, false if it is clear.

AIAPI AIBoolean(* AIBeautifulStrokesSuite::GetFlipAlong)(ConstAIDictionaryRef params)

Retrieves the option from a Beautiful Strokes dictionary to flip art along path to reverse lateral orientation.

Note that this function returns a Boolean value, not an error code.

Parameters:

params

The parameters dictionary.

Returns:: True if the option is set, false if it is clear.

AIAPI AIBoolean(* AIBeautifulStrokesSuite::GetFoldAdjustment)(ConstAIDictionaryRef params, AIBoolean *mixed)

Retrieves the fold adjustment status from a Beautiful Strokes dictionary.

This adjusts the folding across corners or bends. Note that this function returns a Boolean value, not an error code.

Parameters:

	params	The parameters dictionary.
	mixed	[optional] [out] A buffer in which to return true if the dictionary represents an accumulation returned from `AIPathStyleSuite::GetCurrentPathStyle()`, and the selection is mixed. By convention, mixed values return false.

Returns:: True if the option is set, false if it is clear.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetGradientStrokeApplication)(ConstAIDictionaryRef params, GradientStrokeApplication &application, AIBoolean *mixed)

Retrieves the gradient stroke application method status from a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	type	The type of gradient stroke application.
	mixed	[optional] [out] A buffer in which to return true if the dictionary represents an accumulation returned from `AIPathStyleSuite::GetCurrentPathStyle()`, and the selection is mixed. By convention, mixed values return false.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetParamsDict)(ConstAILiveEffectParameters effectParams, AIDictionaryRef &params)

Retrieves a BeautifulStrokes parameters dictionary from a set of LiveEffect parameters.

Parameters:

	effectParams	A set of LiveEffect parameters for an art object.
	params	A reference to the BeautifulStrokes params dictionary or NULL if one does not exist. The reference count on this dictionary is incremented on return and must be released when no longer needed.

Returns:: No error is returned if the dictionary does not exist.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetPathAdjustedWidthDistances)(AIArtHandle path, AIArrayRef &adjustedDistances)

If a path has variable widths (either centered or uncentered), retrieves a vector of the values from the distance array, after adjustment to shift any anchored width points to the relative distance along that path of the path positions they are anchored to.

If the path has no variable widths, the returned vector is empty.
If the path has variable widths but no width profile anchors, the returned vector contains the same distance values that are in the distance array returned by GetCenteredWidthProfile() or GetUncenteredWidthProfile().

Parameters:

	path	The path.
	adjustedDistances	A reference in which to return the result vector. The reference count on this array is incremented on return and must be released when no longer needed.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetScale)(ConstAIDictionaryRef params, AIReal &scale, AIReal *mnScale, AIReal *mxScale)

Retrieves the scale (width) of art applied to path from a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	scale	[out] A reference in which to return the single scale for art not using tablet data.
	mnScale	[optional] [out] A buffer in which to return the minimum scale for art using tablet data.
	mxScale	[optional] [out] A buffer in which to return the maximum scale for art using tablet data.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetStartEndSegmentLength)(ConstAIDictionaryRef params, AIReal &startSegmentLength, AIReal &endSegmentLength)

Retrieves the lengths of non-stretching start and end segments for a segmented brush from a Beautiful Strokes dictionary.

Lengths are expressed as absolute values in document points.

Parameters:

	params	The parameters dictionary.
	startSegmentLength	[out] A reference in which to return the start-segment length.
	endSegmentLength	[out] A reference in which to return the end-segment length.

AIAPI AIBoolean(* AIBeautifulStrokesSuite::GetStretch)(ConstAIDictionaryRef params)

Retrieves the stretching option from a Beautiful Strokes dictionary.

Note that this function returns a Boolean value, not an error code.

Parameters:

params

The parameters dictionary.

Returns:: True if the option is set (stretch tiles non-uniformly along the path), false if it is clear (scale up uniformly for the path length).

AIAPI AIErr(* AIBeautifulStrokesSuite::GetUncenteredWidthProfile)(ConstAIDictionaryRef params, AIArrayRef &tVals, AIArrayRef &leftWidths, AIArrayRef &rightWidths)

Retrieves the uncentered width profile for output art from a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	tVals	A reference in which to return an array of `AIReal` values ranging from [0-1] representing fractional distances along the path. The reference count on this array is incremented on return and must be released when no longer needed.
	leftWidths	A reference in which to return an array of `AIReal` the same size as `tVals` representing the width of the left side of the stroke at corresponding distances in `tVals`. The reference count on this array is incremented on return and must be released when no longer needed.
	rightWidths	A reference in which to return an array of `AIReal` the same size as `tVals` representing the width of the right side of the stroke at corresponding distances in `tVals`. The reference count on this array is incremented on return and must be released when no longer needed.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetWidthProfileDetails)(ConstAIDictionaryRef params, AIArrayRef &markerOptions, AIArrayRef &incomingLeftSmoothness, AIArrayRef &outgoingLeftSmoothness, AIArrayRef &incomingRightSmoothness, AIArrayRef &outgoingRightSmoothness)

Retrieves the options for the width profile markers from a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	markerOptions	A reference in which to return an array of integers parallel to the t values, interpreted as a bit vector of `WidthMarkerFlagValues`. The reference count on this array is incremented on return and must be released when no longer needed.
	incomingLeftSmoothness	A reference in which to return an array of `AIReal` numbers parallel to the t values. The reference count on this array is incremented on return and must be released when no longer needed.
	outgoingLeftSmoothness	A reference in which to return an array of `AIReal` numbers parallel to the t values. The reference count on this array is incremented on return and must be released when no longer needed.
	incomingRightSmoothness	A reference in which to return an array of `AIReal` numbers parallel to the t values. The reference count on this array is incremented on return and must be released when no longer needed.
	outgoingRightSmoothness	A reference in which to return an array of `AIReal` numbers parallel to the t values. The reference count on this array is incremented on return and must be released when no longer needed.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetWidthsAtDistance)(AIArtHandle path, AIReal &lengthFraction, AIReal tolerance, AIReal *totalWidth, AIReal *leftWidth, AIReal *rightWidth, StrokeWidthSource *widthSource, ai::int16 *markerIndex, WidthMarkerFlags *markerDetails)

Retrieves the left, right, and combined widths of the focal stroke at a fraction of the distance along a path, and reports the source of the widths.

The widths are analogous to the stroke weights as returned by the AIArtStyleSuite::GetPaintAttributes(). As such, they include the stroke weight scaling, but do not include the impact of pattern or art brush scale options or pattern or art brush tile sizes.

Parameters:

	path	[in] The path to be examined for width data.
	lengthFraction	[in/out] Upon input, the fraction of the path length at which the width is being queried. Upon output, if the width source is `kCenteredProfileMark` or `kUncenteredProfileMark`, the possibly snapped position of that mark. To find whether snapping has occurred, cache the original length fraction and compare it to the returned value.
	tolerance	[in] If positive and the path has a user-specified variable width profile, and the input length fraction is within this tolerance of one of the t values in the width array, then the length fraction is snapped to that t value. If zero or negative, a tolerance of .001 is used.
	totalWidth	[out][optional] A buffer in which to return the total width at the given position, as obtained from the width source.
	leftWidth	[out][optional] A buffer in which to return the stroke width on the left side of the path at the given position, as obtained from the width source.
	rightWidth	[out][optional] A buffer in which to return the stroke width on the right side of the path at the given position, as obtained from the width source.
	widthSource	[out][optional] A buffer in which to return the width-source constant. It will be one of kConstantWidth, kTabletData, kCenteredProfileMark, kUncenteredProfileMark, kCenteredProfileInterpolation, kUncenteredProfileInterpolation.
	markerIndex	[out][optional] A buffer in which to return the marker index. If width source is from a centered or uncentered profile, the index into the parallel t and width arrays of the marker. For `kCenteredProfileMark` and `kUncenteredProfileMark`, it is the index of the marker at that location; for `kCenteredProfileInterpolation` and `kUncenteredProfileInterpolation`, it is the index of the preceding marker.
	markerDetails	[in/out][optional] On input, the only meaningful flag values are `kIncomingWidthMarker` and `kOutgoingWidthMarker`. These specify which of the two markers should be returned in the event that there are two markers at exactly the input length fraction. (If snapping occurs, then the flags are ignored; the incoming marker is returned when it snaps upward, and the outgoing when it snaps downward.) If null or if neither or both of those flags are on, and there are two markers at exactly the input length fraction, then the larger of the two is returned. On output, if width source is `kCenteredProfileMark` or `kUncenteredProfileMark`, can contain one of `kIncomingWidthMarker` or `kOutgoingWidthMarker`, and/or `kCornerWidthMarker`.

AIAPI StrokeWidthSource(* AIBeautifulStrokesSuite::GetWidthSource)(ConstAIDictionaryRef params)

Retrieves the source of stroke width from a Beautiful Strokes dictionary.

(Note that this function returns a constant value, not an error code.)

Parameters:

params

The parameters dictionary.

Returns:: The width source constant.

AIAPI AIErr(* AIBeautifulStrokesSuite::GetWidthTabletDataSource)(ConstAIDictionaryRef params, AITabletDataType &dataType)

Retrieves the tablet-data type option from a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	dataType	The type of tablet data to use for stroke width in the art passed to `GenerateArt()`.

See also:: AITabletDataType

AIAPI AIErr(* AIBeautifulStrokesSuite::InterpolateParams)(ConstAILiveEffectParameters effectParams1, ConstAILiveEffectParameters effectParams2, AILiveEffectParameters effectParamsOut, AIReal dist)

Interpolates beautiful stroke parameters between two appearances.

Parameters:

	effectParams1	[optional] The effects parameters dictionary of a stroke filter, which may (or may not) contain a Beautiful Strokes params dictionary.
	effectParams2	[optional] The effects parameters dictionary of a stroke filter which may (or may not) contain a Beautiful Strokes params dictionary.
	effectParamsOut	The effects parameters dictionary of a stroke filter that represents the results of interpolating between effectParams1 and effectParams2.
	dist	A number in the range [0-1], where 0 is interpreted as matching effectParams1, and 1 is interpreted as matching effectParams2. (Negative values are interpreted as if they were 0, and values greater than 1 as if they were 1.)

If either effectParams1 or effectParams2 contains a Beautiful Strokes parameter dictionary, then those parameters will be interpolated, and the results placed in effectParamsOut (which should not be null if either input parameter is null.)

AIAPI AIErr(* AIBeautifulStrokesSuite::SetArrowheadOptions)(AIDictionaryRef params, AIPatternHandle *beginSymbol, AIPatternHandle *endSymbol, AIReal beginScale, AIReal endScale, ArrowTipAlignment alignment)

Sets arrowhead-related stroke options in a Beautiful Strokes dictionary.

The arrowhead symbols can be in a library rather than the current document. If so, they are retargeted to the document that the params dictionary is attached to, and placed in the "hidden symbols" of that document; that is, they do not appear in the Symbols panel. The symbols are parsed to determine the alignment parameters and the default scale.

Any unpainted closed rectangle in the back of the symbol definition is ignored and stripped from the art that is used to determine the "tip" of the arrow and placed on the path. These unpainted rectangles are assumed to be only for the purpose of making the symbol thumbnails a uniform size.

Arrowhead art inside the symbol is assumed to be positioned the way it would be when applied as an end arrow to a horizontal open path that started at the left and ended at the right. If applied as a start arrow, it is reflected horizontally before it is applied.

If there is a stroked open straight line in the back of the symbol definition (either above or below the bounding rectangle if there is one), then the right endpoint of that line is used to specify the truncation point. If it additionally has an internal anchor point, the furthest right such anchor point is used to specify the attachment point, otherwise the attachment point is the same as the truncation point.

The tip is treated as the point along the right edge of the bounding box (after removing the bounding tile, if any) which is at the same height as the positioning line. The stroke weight of the positioning line is used to determine the default scale of the arrowhead. For example, if the positioning stroke is 2 pts, then the arrowhead is scaled 50% when it is applied to a path with a 1 pt stroke, and scaled 150% when it is applied to a path with a 3 pt stroke. The begin-scale or end-scale factors are applied additionally.

If there is no positioning line, the default is to use a 100% default scale; that is, to treat the symbol as if it were scaled appropriately for a 1 pt line, and to put both the attachment and truncation points in the center of the symbol.

Parameters:

	params	The parameters dictionary.
	beginSymbol	A pointer to the symbol to apply as the arrowhead at the beginning of the path. To not change the existing settings, pass null. To remove the arrowhead, pass a pointer to null.
	endSymbol	The symbol to apply as the arrowhead at the end of the path, null if none To not change the existing settings, pass null. To remove the arrowhead, pass a pointer to null.
	beginScale	The factor by which to scale the begin arrow by, as a percentage relative to the default scale. To not change the existing settings, pass `kAIRealUnknown`.
	endScale	The factor by which to scale the end arrow by, as a percentage relative to the default scale. To not change the existing settings, pass `kAIRealUnknown`.
	alignment	The rule for positioning the arrows at the ends of the path. To not change the existing settings, pass `kUnknownArrowAlignment`.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetArtPaint)(AIDictionaryRef params, AIPatternHandle art)

Sets the pattern to be applied along path in a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	art	The brush pattern.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetArtPatternPaint)(AIDictionaryRef params, AIPatternHandle beginArt, AIPatternHandle endArt, AIPatternHandle sideArt, AIPatternHandle insideCornerArt, AIPatternHandle outsideCornerArt, RepeatedArtAdjustment adjustment, AIReal spacing, RepeatedArtCorner insideAutoCornerOption, RepeatedArtCorner outsideAutoCornerOption)

Sets options for repeating pattern tiles along a path in a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	beginArt	Brush pattern tile art to be applied to the beginning of the path. May be NULL.
	endArt	Brush pattern tile art to be applied to the end of the path. May be NULL.
	sideArt	Brush pattern tile art to be applied to the main part of the path. May be NULL.
	insideCornerArt	Brush pattern tile art to be applied to inside corners of the path. May be NULL.
	outsideCornerArt	Brush pattern tile art to be applied to outside corners of the path. May be NULL.
	adjustment	Method to use to apply art along path; see `RepeatedArtAdjustment()`.
	spacing	Relative spacing between tiles; for example, 0.5 sets spacing to half the width of the tile. Relevant only when adjustment method is `kAddSpace`.
	insideAutoCornerOption	Method to use to generate insideCornerArt automatically; see `RepeatedArtCorner()`.
	outsideAutoCornerOption	Method to use to generate outsideCornerArt automatically; see `RepeatedArtCorner()`.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetCenteredWidthAtDistance)(AIArtHandle path, AIReal lengthFraction, AIReal width, WidthMarkerFlags options)

Sets the total width of the focal stroke at a given fraction of the distance along the path.

(If lengthFraction is within 0.001 of an existing t value in the width profile, modifies the existing width at that t value rather than inserting a new one.)

If there is already a centered width profile, inserts the indicated value into it.
If there is already an uncentered profile, this is equivalent to setting the left and right widths to half the input width.
If there is not yet any user specified width profile, creates a centered width profile from the current stroke source and then modifies it and sets the stroke-width source to kUserProfile.

Parameters:

	path	The path.
	lengthFraction	A fraction of the distance along the path at which to set the width. If within 0.001 of an existing t value in the width profile, modifies the existing width at that t value rather than inserting a new one.
	width	The new width.
	options	A logical OR of bit flags that determine how to perform the operation.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetCenteredWidthProfile)(AIDictionaryRef params, AIArrayRef tVals, AIArrayRef widths)

Sets centered width profile for output art in a Beautiful Strokes dictionary.

Pass NULL for both arrays to clear the profile. A style cannot carry both an uncentered and centered width profile, so if there is an existing centered width profile, this function removes it.

Other than length, the array values are not examined for validity at the time they are set. Instead, they are examined when used, and any invalid entries are ignored. A width profile in which all the array entries are used to form the stroke contour has the following properties:

The first distance is 0
The last distance is 1
Every distance value should be no less than the previous distance, and no more than the next one
There should be no more than two consecutive distance values at the same distance

When interpreting the width profile:

If the first distance value is not zero, the function acts as if there was an additional value at the beginning of both arrays, with the distance being zero and the width being whatever the width is in the first entry in the widths array.
If any distance value is more than 1, or less than the preceding distance value, or equal to both the preceding distance value and the following distance value, the function ignores the array entries at that index
If the last distance value is not 1, the function acts as if there were an additional pair of entries with the distance equal to 1, and the width equal to the width at the last valid distance entry
Negative values are interpreted as if they were 0. Values greater than 1 are allowed, but cause the stroke to be wider at those places than the width shown in the Stroke panel, so should be avoided.

Note that this differs from the interpretation of widths in the functions such as SetCenteredWidthAtDistance() that take a path object and query or modify the width at specific offsets; these incorporate the stroke weight scaling. This is because the functions that manage entire width arrays may be dealing with profiles that are shared across multiple paths of different weights or belong to unattached preset dictionaries.

Parameters:

	params	The parameters dictionary.
	tVals	An array of `AIReal` values ranging from [0-1] representing fractional distances along the path.
	widths	An array of `AIReal` values the same size as `tVals` representing the fractional stroke width at the corresponding offset in the `tVals` array. Values are fractions of the stroke weight as shown in the Stroke panel, in the range [0-1].

Returns:: The error kBadParameterErr if the arrays are of different lengths, or if one is null and the other is not.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetDashAdjustment)(AIDictionaryRef params, AIBoolean adjust)

Sets or clears the dash adjustment option in a Beautiful Strokes dictionary.

When on, adjusts dashes so a certain fraction of the dash length always appears at the ends, corners, and intersections of dashed lines. (Note that dash/gap intervals are obtained from the art.)

Parameters:

	params	The parameters dictionary.
	adjust	True to set the option, false to clear it.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetFlipAcross)(AIDictionaryRef params, AIBoolean flipAcross)

Sets the option in a Beautiful Strokes dictionary to flip art across path to reverse vertical orientation.

Parameters:

	params	The parameters dictionary.
	flipAcross	True to set the option, false to clear it.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetFlipAlong)(AIDictionaryRef params, AIBoolean flipAlong)

Sets the option in a Beautiful Strokes dictionary to flip art along path to reverse lateral orientation.

Parameters:

	params	The parameters dictionary.
	flipAlong	True to set the option, false to clear it.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetFoldAdjustment)(AIDictionaryRef params, AIBoolean adjust)

Set fold adjustment on or off.

This adjusts the brush folding across corners or bends.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetGradientStrokeApplication)(AIDictionaryRef params, GradientStrokeApplication application)

Sets the gradient stroke application method.

This determines how the current stroke color, if a gradient, will be applied to the stroke. Not applicable to some objects such as art brushes, etc.

Parameters:

	params	The parameters dictionary.
	type	The type of gradient stroke application. Pass kGradientStroke_dummy to clear the corresponding dictionary entry.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetScale)(AIDictionaryRef params, AIReal scale, const AIReal *mnScale, const AIReal *mxScale)

Sets the scale (width) of art applied to path in a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	scale	Single scale for art not using tablet data.
	mnScale	[optional] Minimum scale for art using tablet data.
	mxScale	[optional] Maximum scale for art using tablet data.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetStartEndSegmentLength)(AIDictionaryRef params, AIReal startSegmentLength, AIReal endSegmentLength)

Sets the lengths of non-stretching start and end segments for a segmented brush in a Beautiful Strokes dictionary.

Lengths are expressed as absolute values in document points. If both values are zero, the brush is a non-segmented brush.

Parameters:

	params	The parameters dictionary.
	startSegmentLength	Length of start segment.
	endSegmentLength	Length of end segment.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetStretch)(AIDictionaryRef params, AIBoolean stretch)

Sets the stretching option in a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	stretch	True to stretch tiles non-uniformly along the path, false to scale up uniformly for the path length.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetUncenteredWidthProfile)(AIDictionaryRef params, AIArrayRef tVals, AIArrayRef leftWidths, AIArrayRef rightWidths)

Sets an uncentered width profile for output art in a Beautiful Strokes dictionary, with independent left and right width values.

Left and right are interpreted by following the path from the start point to the end point. A path cannot carry both an uncentered and centered width profile, so if there is an existing centered width profile, this function removes it.

Parameters:

	params	The parameters dictionary.
	tVals	An array of `AIReal` values ranging from [0-1] representing fractional distances along the path.
	leftWidths	An array of `AIReal` the same size as `tVals` representing the width of the left side of the stroke at corresponding distances in `tVals`.
	rightWidths	An array of `AIReal` the same size as `tVals` representing the width of the right side of the stroke at corresponding distances in `tVals`.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetUncenteredWidthsAtDistance)(AIArtHandle path, AIReal lengthFraction, AIReal leftWidth, AIReal rightWidth, WidthMarkerFlags options)

Sets the left and right widths of the focal stroke at a given fraction of the distance along the given path.

(If lengthFraction is within 0.001 of an existing t value in the width profile, modifies the existing width at that t value rather than inserting a new one.)

If there is already an uncentered width profile, it inserts the indicated values into it.
If left and right widths are equal and there is already a centered width profile, inserts their sum into it.
If left and right widths are unequal and there is not yet an uncentered width profile, or if they are equal and there is not yet any width profile, it creates one from the current stroke source and then modifies it and sets the stroke-width source to kUserProfile.

Parameters:

	path	The path.
	lengthFraction	A fraction of the distance along the path at which to set the width. If within 0.001 of an existing t value in the width profile, modifies the existing width at that t value rather than inserting a new one.
	leftWidth	The new left width.
	rightWidth	The new right width.
	options	A logical OR of bit flags that determine how to perform the operation.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetWidthProfileDetails)(AIDictionaryRef params, AIArrayRef markerOptions, AIArrayRef incomingLeftSmoothness, AIArrayRef outgoingLeftSmoothness, AIArrayRef incomingRightSmoothness, AIArrayRef outgoingRightSmoothness)

INTENDED FOR FUTURE ENHANCEMENTS - All non-default options are currently ignored.

Can only be called after setting the width profile with SetCenteredWidthProfile() or SetUncenteredWidthProfile(). If not present (the usual case), all width markers use default options, which are dependent upon the context. All arrays can be null. The defaults are for markers that are concurrent with corner anchor points of the path to be treated as tethered corner width markers, and for all other markers to be untethered smooth markers, with the default smoothness values.

To save space, there is a single array of marker options for both centered and uncentered width profiles, with different flag values to distinguish when the options are different for the left and right sides of the stroke (for example, if it is smooth on the left side but cornered on the right.) If an incoming smoothness array exists but the outgoing smoothness array does not exist on that side of the path, then the outgoing smoothness is inherited from the incoming smoothness. Similarly, if the left smoothness array(s) exist but the right smoothness arrays do not, then the right smoothness is inherited from the left smoothness.

You must only call this function AFTER either SetCenteredWidthProfile() or SetUncenteredWidthProfile(); it returns /c kBadParameterErr if any of the arrays are non-null and either there is no width profile, or the existing width profile has a different number of markers than the size of the detail arrays. No validation is done on the contents of the arrays, other than their lengths.

Parameters:

	params	The parameters dictionary.
	markerOptions	An array of integers parallel to the t values, interpreted as a bit vector of WidthMarkerFlagValues
	incomingLeftSmoothness	An array of `AIReal` numbers ranging from [0-1] parallel to the t values, ranging from minimally smooth at 0 to maximally smooth at 1.
	outgoingLeftSmoothness	An array of `AIReal` numbers ranging from [0-1] parallel to the t values, ranging from minimally smooth at 0 to maximally smooth at 1.
	incomingRightSmoothness	An array of `AIReal` numbers ranging from [0-1] parallel to the t values, ranging from minimally smooth at 0 to maximally smooth at 1.
	outgoingRightSmoothness	An array of `AIReal` numbers ranging from [0-1] parallel to the t values, ranging from minimally smooth at 0 to maximally smooth at 1.

Returns:: The error kBadParameterErr if any of the arrays are non-null and either there is no width profile, or the existing width profile has a different number of markers than the size of the detail arrays.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetWidthSource)(AIDictionaryRef params, StrokeWidthSource source)

Sets the source of stroke width in a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	source	Source of width information for stroke. If `kTabletData`, set related values with `SetWidthTabletDataSource()` and `and` SetScale(), particularly minimum and maximum. If `kUserProfile`, call `SetCenteredWidthProfile()` to set centered width values or `SetUncenteredWidthProfile()` to set independent left and right width values.

AIAPI AIErr(* AIBeautifulStrokesSuite::SetWidthTabletDataSource)(AIDictionaryRef params, AITabletDataType dataType)

Sets the type of tablet data to use for stroke width in the art passed to GenerateArt(), in a Beautiful Strokes dictionary.

Parameters:

	params	The parameters dictionary.
	dataType	The type of tablet data.

See also:: AITabletDataType

AIAPI AIErr(* AIBeautifulStrokesSuite::SlideWidthMarkerToNewT)(AIArtHandle path, ai::int16 markerIndex, AIReal &newTValue, WidthMarkerFlags options)

Moves the width marker at the given index to a new t value.

If the given marker is incoming-only or outgoing-only due to two markers being at the same t value, both are moved together. Only the content of the tValue array changes, so this works for either centered or non-centered widths.

Parameters:

	path	The path.
	markerIndex	The 0-based index position of the marker to move.
	newTValue	[in, out] Fraction of length along whole path to which the marker should be moved. In the range [0-1].
	options	A logical OR of bit flags that determine how to perform the operation: If `kCopyMarker` is on, the marker is duplicated and the new copy moved, while the old one remains at the prior location. There must always be a marker at 0 and one at 1, so any movement of the first or last marker is implicitly a duplication even if this flag is off. If `kSpreadWidthChanges` is on, the other markers on the side that this marker is moving away from are spread out proportionally to cover the larger distance, and the other markers on the side that this marker is moving towards are compressed proportionally to fit in the smaller distance. The scope of the spreading is limited by the selection state and corner status of the adjacent anchor points. If `kSpreadWidthChanges` is off and `kLimitAtNeighbors` is on, and there is another width marker between the current t value at the given index and the new t value, then the marker stops when it hits the adjacent marker. No error code is returned in this case, but `newTValue` is updated to the actual destination. To determine whether it stopped, cache the original value and compare with the returned value. (Note that this causes the two markers at the same location to become an incoming-only outgoing only pair where the width may jump discontinuously.) If `kSpreadWidthChanges` and `kLimitAtNeighbors` are both off, then the moved marker is allowed to jump past other markers as if they were not there.

Returns:: The error kBadParameterErr if the path does not have a user width profile or if the new t value is not in the range [0-1].

AIAPI AIErr(* AIBeautifulStrokesSuite::StrokeHitTest)(AIArtHandle path, const AIRealPoint &cursor, AIReal tolerance, StrokeHitResults *hitResults)

Tests whether a cursor point on a path is within a given tolerance of the region covered by the stroke, and if so, reports additional details about what part of the stroke was hit; see StrokeHitResults.

For brush strokes, the entire region within the brush design's tile box is considered to be stroked.

Parameters:

	path	The path.
	cursor	The cursor point.
	tolerance	The tolerance value.
	hitResults	A buffer in which to return the result.

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

AIBeautifulStrokes.h

AIBeautifulStrokesSuite Struct Reference [API Suite List]

Public Attributes

Detailed Description

Member Data Documentation

AIBeautifulStrokesSuite Struct Reference
[API Suite List]