AIPluginGroup.h File Reference

#include "AITypes.h"
#include "AIPlugin.h"
#include "AIArt.h"
#include "AIPathStyle.h"
#include "AIArtStyle.h"
#include "AIHeaderBegin.h"
#include "AIHeaderEnd.h"

Go to the source code of this file.

Classes
union	StyleUnion
	`AIPluginGroupMessage::style` value. More...
union	StyleMapUnion
	`AIPluginGroupMessage::styleMap` value. More...
struct	AIPluginGroupMessage
	Sent with the `kSelectorAINotifyEdits`, `kSelectorAIUpdateArt`, `kSelectorAICanShowContents` and `kSelectorAIInterpolateData` notifications. More...
struct	AIReplaceSymbolMessageData
	Data for the `kSelectorAIReplaceSymbol` notification. More...
struct	AIPluginArtTypeMessageData
	Data for the `kSelectorAIDisallowsArtTypeQuery` notification. More...
struct	AIPluginGroupCustomHitTestData
	Data for the `kSelectorAIPerformCustomHitTest` notification. More...
struct	AIPluginGroupCollectPaintStylesData
	Data for the `kSelectorAICollectPaintStyles` notification. More...
struct	AIPluginGroupApplyPaintStylesData
	Data for the `kSelectorAIApplyPaintStyles` message. More...
struct	AIPluginGroupAdjustColorsData
	Data for the `kSelectorAIAdjustColors` notification. More...
struct	AIAddPluginGroupData
struct	AIPluginGroupSuite
	This suite provides functions for working with plug-in groups. More...
Defines
#define	kAIPluginGroupSuite "AI Plugin Group Suite"
#define	kAIPluginGroupSuiteVersion6 AIAPI_VERSION(6)
#define	kAIPluginGroupSuiteVersion kAIPluginGroupSuiteVersion6
#define	kAIPluginGroupVersion kAIPluginGroupSuiteVersion
#define	kSelectorAINotifyObject "AI Notify Plugin Object"
#define	kSelectorAIUpdateObject "AI Update Plugin Object"
#define	kCallerAIPluginGroup "AI Plugin Group"
	See `AIPluginGroupSuite`.
#define	kSelectorAINotifyEdits "AI Notify Edits"
	Notifies a plug-in group of edits to the edit group.
#define	kSelectorAIUpdateArt "AI Update"
	Notifies a plug-in group that the result group needs to be rebuilt.
#define	kSelectorAICanShowContents "AI Show Contents"
	Asks a plug-in group whether the Layers palette shows edit groups.
#define	kSelectorAIInterpolateData "AI Interpolate Data"
	Asks a plug-in group to interpolate plug-in data and dictionary contents when interpolations are made into a blend between plug-in groups.
#define	kSelectorAIReplaceSymbol "AI Art Replace Symbol"
	Asks a plug-in group to replace symbols used in its dictionary.
#define	kSelectorAIDisallowsArtTypeQuery "AI Plugin Group Disallow Art Type"
	Asks a plug-in group whether it allows art objects of a given type in its edit group.
#define	kSelectorAIPerformCustomHitTest "AI Plugin Group Perform Custom Hit Test"
	Asks a plug-in group to perform a custom hit test.
#define	kSelectorAICollectPaintStyles "AI Plugin Group Collect Paint Styles"
	Asks a plug-in group to collect the paint styles of all objects for which it privately manages styles.
#define	kSelectorAIApplyPaintStyles "AI Plugin Group Apply Paint Styles"
	Sent only if the `kPluginGroupManagesPaintStyles` option flag is on.
#define	kSelectorAIAdjustColors "AI Plugin Group Adjust Colors"
	Asks a plug-in group to apply a developer-defined color-mapping callback function to objects for which it privately manages styles or colors.
#define	kSelectorAIShowContents "AI Plugin Group Show Contents"
	Sent to plug-ins where the `kPluginGroupAskToShowContents` option is set, to request the "Show Contents" mode.
#define	kSelectorAIPluginArtDocScaleChange "AI Plugin Group Adjust New Document Scale"
	Sent to plug-ins whose art objects have been changed after changing the document scale The plug-in should make changes to the data associated with the corresponding art object w.r.t the new scale of the document.
#define	kUnknownPluginGroupErr 'GRP?'
	Plug-in group not found (when looked up by name).
#define	kAttachedPluginGroupErr 'GRP!'
	Plug-in group already attached to an object.
#define	kTooMuchDataPluginGroupErr 'FULL'
	See `AIPluginGroupSuite::SetPluginArtDataCount()`.
#define	kPluginStoreLimit ( 32 * 1024 )
	Limit on the size of the data store in a plug-in group.
#define	kRefusePluginGroupReply 'RFSE'
	Return code for response to `kSelectorAIDisallowsArtTypeQuery` when `AIPluginGroupMessage::time` is `kCheckOperationTime`, if the edit should not happen.
#define	kCheckPluginGroupReply 'CHEK'
	Return code for response to `kSelectorAIDisallowsArtTypeQuery` when `AIPluginGroupMessage::time` is `kCheckOperationTime`, if the plug-in group wants to get a `kSelectorAINotifyEdits` message with `kCheckOperationTime` to refine the answer to the query.
#define	kWantsAfterMsgPluginGroupReply 'AFTR'
	Return code for response to `kSelectorAIInterpolateData`, if the plug-in group wants to get a `kAfterOperationTime` message before the `kSelectorAIUpdateArt` message.
#define	kDidSymbolReplacement 'dsRP'
	Return code for response to `kSelectorAIReplaceSymbol` message if the plug-in group did perform the requested replacement.
#define	kMarkValidPluginGroupReply 'VALD'
	Return code for response to `kSelectorAINotifyEdits` at `kAfterOperationTime`, if the plug-in group has already updated the object.
#define	kDontCarePluginGroupReply 'MOOT'
	Return code for response to `kSelectorAINotifyEdits` at `kAfterOperationTime`, if the edit is irrelevant to this plug-in.
#define	kDestroyPluginGroupReply 'TRSH'
	Return code for response to `kSelectorAINotifyEdits`.
#define	kCustomHitPluginGroupReply 'CHIT'
	Return code for response to `kSelectorAIPerformCustomHitTest`, message if the custom hit test wants to report a hit.
#define	kSkipEditGroupReply 'skpE'
	Return code for response to `kSelectorAIAdjustColors` message if the plug-in group does not want the colors in the edit group to be visited.
#define	kCheckOperationTime "AI Check Operation Time"
	Determine whether the plug-in allows this operation.
#define	kBeforeOperationTime "AI Before Operation Time"
	Prepare for the operation to occur.
#define	kAfterOperationTime "AI After Operation Time"
	The operation has completed.
#define	kDuringOperationTime "AI During Operation Time"
	The operation is ongoing.
#define	kReadOperationCode "AI Read Operation Code"
	Translate data from external to internal representation at `kAfterOperationTime`.
#define	kWriteOperationCode "AI Write Operation Code"
	Translate data from internal to external representation at `kBeforeOperationTime`, and back to internal at `kAfterOperationTime`.
#define	kAttachOperationCode "AI Attach Operation Code"
	Sent when `AIPluginGroupSuite::UseAIPluginGroup()` is called to associate a specific plug-in object with the plug-in group.
#define	kExpandOperationCode "AI Expand Operation Code"
	Sent only at `kCheckOperationTime` and `kBeforeOperationTime` (after an Expand, the object no longer exists).
#define	kOrderingOperationCode "AI Ordering Operation Code"
	Send to front, back, forward, backward.
#define	kTransformOperationCode "AI Transform Operation Code"
	Matrix operations on whole objects.
#define	kGeometryOperationCode "AI Geometry Operation Code"
	Segments of a path have been modified.
#define	kTopologyOperationCode "AI Topology Operation Code"
	A single object is being replaced by multiple.
#define	kDeleteOperationCode "AI Delete Operation Code"
	An element of the edit art group is being deleted.
#define	kAttributeOperationCode "AI Attribute Operation Code"
	Lock/unlock, show/hide, or changing the name or xml UID.
#define	kStyleOperationCode "AI Style Operation Code"
	Path style or text style modifications.
#define	kChangeOperationCode "AI Change Operation Code"
	Sent only at `kAfterOperationTime`, a generic or mixed operation occurred that does not fit into other categories.
#define	kIterationCanQuitReply 'DONE'
	Returned by an `AIProcessArtStyleFunc`, `AIProcessPathStyleFunc`, or `AIAdjustColorFunc` in non-error situations that nonetheless mean the iteration should be terminated without processing any remaining styles.
Typedefs
typedef const char *	AIOperationTime
	For the `kSelectorAINotifyEdits` and `kSelectorAIInterpolateData` messages, an operation time that indicates the relationship of the notification to the stage of the operation.
typedef const char *	AIOperationCode
	For `kSelectorAINotifyEdits`, an `AIPluginGroupMessage::code` value that indicates the type of editing operation being performed.
typedef struct _t_AIClassOpaque *	AIPluginGroupHandle
	Opaque reference to a plug-in group, never dereferenced.
typedef void *	AIInterruptData
	Developer-defined data for `AIInterruptProc` callback.
typedef ASErr(*	AIInterruptProc )(AIArtHandle art, AIInterruptData data)
	Callback function prototype for `AIPluginGroupMessage::proc`.
typedef AIAPI void(*	AICustomHitDataDeleteFunc )(void *)
	A callback that you must supply with the `AIPluginGroupCustomHitTestData::CustomHitData`, that casts the void* data to the appropriate type and disposes of it properly.
typedef AIAPI ASErr(*	AIProcessArtStyleFunc )(const AIArtStyleHandle artStyle, AIArtHandle gradientContext, ai::int32 usage, void *callbackData)
	Prototype for the `AIPluginGroupCollectPaintStylesData::artStyleCallback`.
typedef AIAPI ASErr(*	AIProcessPathStyleFunc )(const AIPathStyle pathStyle, const AIPathStyleMap psMap, AIArtHandle gradientContext, ai::int32 usage, void *callbackData)
	Prototype for the `AIPluginGroupCollectPaintStylesData::pathStyleCallback`.
typedef AIErr(*	AIAdjustArtStyleFunc )(AIArtStyleHandle oldArtStyle, AIArtStyleHandle newArtStyle, void userData)
	Callback function prototype used to process colors from art style handles directly contained in the dictionary of a plug-in group.
Enumerations
enum	AIPluginGroupOptions { kPluginGroupWantsOverlapUpdateOption = (1<<1), kPluginGroupWantsAutoTranslateOption = (1<<2), kPluginGroupWantsAutoUScaleOption = (1<<3), kPluginGroupWantsAutoTransformOption = (1<<4), kPluginGroupDoEditFillHitOption = (1<<5), kPluginGroupKeepWhenEmptyOption = (1<<6), kPluginGroupIsFillLike = (1<<7), kPluginGroupIsStrokeLike = (1<<8), kPluginGroupDoNotTarget = (1<<9), kPluginGroupAlwaysSmartTarget = (1<<10), kPluginGroupDoNotSmartTarget = (1<<11), kPluginGroupCanBeClipping = (1<<12), kPluginGroupAlwaysShowContents = (1<<13), kPluginGroupAskToShowContents = (1<<14), kPluginGroupDisableBlends = (1<<15), kPluginGroupBlendAsPluginGroup = (1<<16), kPluginGroupRestrictsArtTypes = (1<<17), kPluginGroupForceFillHitOnClosedPaths = (1<<18), kPluginGroupForceFillHitOnAllPaths = (1<<19), kPluginGroupManagesPaintStyles = (1<<20), kPluginGroupPermitsGroupCmds = (1<<21) }
	Options for `AIPluginGroupSuite::AddAIPluginGroup()`. More...
enum	AIChangeOperationSubcodes { kPluginSyncArtOpCode = 'PLUG' }
	Subcode values for `kChangeOperationCode` (only at `kAfterOperationTime`). More...
enum	AIOrderingOperationSubcodes { kSendToBackOpCode = 'BACK', kSendToFrontOpCode = 'FRNT', kSendBackwardOpCode = 'DOWN', kSendForwardOpCode = 'UPWD', kReverseGroupOpCode = 'RVRS', kSendInternalOpCode = 'SINT', kReorderOutCode = 'MVOT', kReorderIntoOpCode = 'MVIN' }
	Subcode values for `kOrderingOperationCode`. More...
enum	AITransformOperationSubcodes { kTranslationOpCode = 'MOVE', kRotationOpCode = 'ROTA', kUniformScaleOpCode = 'USCA', kNonUniformScaleOpCode = 'NSCA', kShearOpCode = 'SHER', kReflectionOpCode = 'REFL', kMixedTransformOpCode = 'MTFM' }
	Subcode values for `kTransformOperationCode`. More...
enum	AIGeometryOperationSubcodes { kMiscPathChangeOpCode = 'GEOM', kMovePointsOpCode = 'MPTS', kAdjustControlsOpCode = 'ADJC', kAddPointsOpCode = '+PTS', kRemovePointsOpCode = '-PTS', kReverseSegmentsOpCode = 'RVRS', kOpenCloseOpCode = 'OPCL', kSwapSymbolsOpCode = 'SWSM' }
	Subcode values for `kGeometryOperationCode`. More...
enum	AITopologyOperationSubcodes { kScissorOpCode = 'SCIZ', kPasteBelowOpCode = 'PBEL', kPasteIntoOpCode = 'PINT', kPasteAboveOpCode = 'PABV', kTransformCopyOpCode = 'TCOP', kTypePathChangeOpCode = 'TYCH', kReplaceOneOpCode = 'REP1', kReplaceByManyOpCode = 'REPM', kDuplicateInsideOpCode = 'DUPi', kDuplicateOutsideOpCode = 'DUPo', kMakeGroupOpCode = 'GRUP', kReleaseGroupOpCode = 'UNGP', kExpandInsideOpCode = 'ExpI' }
	Subcode values for `kTopologyOperationCode` These are sent at `kBeforeOperationTime`, and provide additional information about what type of change is about to occur. More...
enum	AIStyleOperationSubcodes { kPathStyleOpCode = 'PATH', kTextStyleOpCode = 'ATET', kArtStyleOpCode = 'ARTS' }
	Subcode values for `kStyleOperationCode`. More...
enum	AIAttributeOperationSubcodes { kHideOpCode = 'HIDE', kShowOpCode = 'SHOW', kLockOpCode = 'LOCK', kUnlockOpCode = 'UNLK', kSetNameOpCode = 'NAME' }
	Subcode values for `kAttributeOperationCode` By default, a c kNoErr return (usually meaning the notification was not handled) for the Name subcode does not mark the plugin group dirty, because it is not expected to change the contents of the result group for a typical plugin group. More...

Detailed Description

Define Documentation

#define kAfterOperationTime "AI After Operation Time"

The operation has completed.

An AIPluginGroupMessage::AIOperationTime value.

#define kAIPluginGroupSuite "AI Plugin Group Suite"

#define kAIPluginGroupSuiteVersion kAIPluginGroupSuiteVersion6

#define kAIPluginGroupSuiteVersion6 AIAPI_VERSION(6)

#define kAIPluginGroupVersion kAIPluginGroupSuiteVersion

#define kAttachOperationCode "AI Attach Operation Code"

Sent when AIPluginGroupSuite::UseAIPluginGroup() is called to associate a specific plug-in object with the plug-in group.

Allows you to check for consistency and confirm that the group can accept the given object.

#define kAttributeOperationCode "AI Attribute Operation Code"

Lock/unlock, show/hide, or changing the name or xml UID.

See AIAttributeOperationSubcodes for subcode values.

#define kBeforeOperationTime "AI Before Operation Time"

Prepare for the operation to occur.

An AIPluginGroupMessage::AIOperationTime value.

#define kChangeOperationCode "AI Change Operation Code"

Sent only at kAfterOperationTime, a generic or mixed operation occurred that does not fit into other categories.

Provides no other details of the operation.

#define kCheckOperationTime "AI Check Operation Time"

Determine whether the plug-in allows this operation.

Not sent for kSelectorAIInterpolateData. An AIPluginGroupMessage::time value.

#define kDeleteOperationCode "AI Delete Operation Code"

An element of the edit art group is being deleted.

#define kDuringOperationTime "AI During Operation Time"

The operation is ongoing.

Sent only for kSelectorAIInterpolateData. An AIPluginGroupMessage::AIOperationTime value.

#define kExpandOperationCode "AI Expand Operation Code"

Sent only at kCheckOperationTime and kBeforeOperationTime (after an Expand, the object no longer exists).

The plug-in art object is about to be expanded, that is, replaced by its result art contents. Remove from the result art descendants any tags or other state specific to the plug-in, and remove from the plug-in's global data anything that tracks this art object.

#define kGeometryOperationCode "AI Geometry Operation Code"

Segments of a path have been modified.

See AIGeometryOperationSubcodes for subcode values.

#define kOrderingOperationCode "AI Ordering Operation Code"

Send to front, back, forward, backward.

See AIOrderingOperationSubcodes for subcode values.

#define kPluginStoreLimit ( 32 * 1024 )

Limit on the size of the data store in a plug-in group.

#define kReadOperationCode "AI Read Operation Code"

Translate data from external to internal representation at kAfterOperationTime.

#define kSelectorAINotifyObject "AI Notify Plugin Object"

#define kSelectorAIUpdateObject "AI Update Plugin Object"

#define kStyleOperationCode "AI Style Operation Code"

Path style or text style modifications.

See AIStyleOperationSubcodes for subcode values.

#define kTopologyOperationCode "AI Topology Operation Code"

A single object is being replaced by multiple.

Also covers paste into edit art. See AITopologyOperationSubcodes for subcode values.

Note:: A join of two paths is indicated by a Geometry of one followed by a Delete of the other, not a Topology (because the preEditArt must always be a single existing descendant of the edit art group).

#define kTransformOperationCode "AI Transform Operation Code"

Matrix operations on whole objects.

See AITransformOperationSubcodes for subcode values.

#define kWriteOperationCode "AI Write Operation Code"

Translate data from internal to external representation at kBeforeOperationTime, and back to internal at kAfterOperationTime.

Also sent at kCheckOperationTime when a plug-in can reply kRefusePluginGroupReply to indicate that the plug-in art cannot be written and must be expanded (reply kNoErr otherwise).

Typedef Documentation

typedef AIErr(* AIAdjustArtStyleFunc)(AIArtStyleHandle oldArtStyle, AIArtStyleHandle *newArtStyle, void *userData)

Callback function prototype used to process colors from art style handles directly contained in the dictionary of a plug-in group.

Passed to kSelectorAIAdjustColors in AIPluginGroupAdjustColorsData::adjustArtStyleCallback. Allows various concerned plug-ins to work with the contained styles:

The plug-in with art style handles in its dictionary can use this to find those art styles,
Another plug-in that implements the effects inside the art styles can use it to access their colors.
Another plug-in can provides the color-adjustment callback to do the actual color mapping.

This callback is not typically provided by a third-party plug-in, but is provided internally by the implementation of AIPathStyleSuite::AdjustObjectAIColors(), or by AIPluginGroupSuite::PluginArtAdjustColors(). A plug-in groups with art styles in its dictionary need only call this callback, not implement it.

Parameters:

	oldArtStyle	The art style to be examined. It is not altered.
	newArtStyle	[out] A buffer in which to return the art style after color adjustment. If no colors are changed, contains the input style.
	userData	A pointer to developer-defined data needed for the modification, acquired from the message data.

typedef AIAPI void(* AICustomHitDataDeleteFunc)(void *)

A callback that you must supply with the AIPluginGroupCustomHitTestData::CustomHitData, that casts the void* data to the appropriate type and disposes of it properly.

typedef void* AIInterruptData

Developer-defined data for AIInterruptProc callback.

typedef ASErr(* AIInterruptProc)(AIArtHandle art, AIInterruptData data)

Callback function prototype for AIPluginGroupMessage::proc.

An update or interpolate handler that will take a long time can call this function any number of times, to give time back to the core for other processing (such as preview and other event handling). When it returns an error, your handler should stop processing and return the error. It will get a chance again later to update.

Parameters:

	art	The art object.
	data	Developer-defined data to pass through.

Returns:: An error to halt processing of the update or interpolate notification.

typedef const char* AIOperationCode

For kSelectorAINotifyEdits, an AIPluginGroupMessage::code value that indicates the type of editing operation being performed.

These code values refer to the entire plug-in group object:
kReadOperationCode
kWriteOperationCode
kAttachOperationCode
kExpandOperationCode

For these code values, the editing parameters, AIPluginGroupMessage::preEditArt and AIPluginGroupMessage::postEditArt indicate the edit group or member that has been or will be edited:
kOrderingOperationCode
kTransformOperationCode
kGeometryOperationCode
kTopologyOperationCode
kDeleteOperationCode
kAttributeOperationCode
kStyleOperationCode
kChangeOperationCode

The editing parameters are valid only during kCheckOperationTime and kBeforeOperationTime, where one notify-edits message is sent for each top-level affected or selected descendant of the plug-in object. For example, if an entire group is selected but its parent is not fully selected, that group is passed as the preEditArt, but not its children.

For some codes, additional subcodes indicate which of several operations of the given type is occurring. Subcodes are AIErr (four-byte char) values, that can be used in debugging as well as allowing switch statements.

typedef const char* AIOperationTime

For the kSelectorAINotifyEdits and kSelectorAIInterpolateData messages, an operation time that indicates the relationship of the notification to the stage of the operation.

An AIPluginGroupMessage::AIOperationTime value. The times are:
kCheckOperationTime
kBeforeOperationTime
kAfterOperationTime
kDuringOperationTime

Note:: You must not dispose of or reorder any artwork objects during a kCheckOperationTime or kBeforeOperationTime notification. Any editing must wait until kAfterOperationTime.

typedef struct _t_AIClassOpaque* AIPluginGroupHandle

Opaque reference to a plug-in group, never dereferenced.

Access with AIPluginGroupSuite.

typedef AIAPI ASErr(* AIProcessArtStyleFunc)(const AIArtStyleHandle artStyle, AIArtHandle gradientContext, ai::int32 usage, void *callbackData)

Prototype for the AIPluginGroupCollectPaintStylesData::artStyleCallback.

Can examine, but not modify the art styles and art objects.

Parameters:

	artStyle	The current art style.
	gradientContext	`NULL` if gradient vectors in the style are relative to the whole plug-in group. Otherwise, gradient vectors in the style are relative to this art object.
	usage	How the style is used (in fills or strokes), an `AIPaintUsage` value.
	callbackData	Developer-defined data passed from the notification message.

typedef AIAPI ASErr(* AIProcessPathStyleFunc)(const AIPathStyle *pathStyle, const AIPathStyleMap *psMap, AIArtHandle gradientContext, ai::int32 usage, void *callbackData)

Prototype for the AIPluginGroupCollectPaintStylesData::pathStyleCallback.

Can examine, but not modify the path styles and art objects.

Parameters:

	pathStyle	The current path style.
	psMap	A style map that identifies the valid fields in a partial style. Can be `NULL`.
	gradientContext	`NULL` if gradient vectors in the style are relative to the whole plug-in group. Otherwise, gradient vectors in the style are relative to this art object.
	usage	How the style is used (in fills or strokes), an `AIPaintUsage` value.
	callbackData	Developer-defined data passed from the notification message.

Enumeration Type Documentation

enum AIAttributeOperationSubcodes

Subcode values for kAttributeOperationCode By default, a c kNoErr return (usually meaning the notification was not handled) for the Name subcode does not mark the plugin group dirty, because it is not expected to change the contents of the result group for a typical plugin group.

This is in contrast to most edit notifications, which mark the plugin group dirty unless it receives a kDontCarePluginGroupReply from a kBeforeOperationTime notification or a kMarkValidPluginGroupReply from a kAfterOperationTime notification. Since there is no reply that tells the plugin group to invalidate itself on these notifications, if a rebuild is wanted on a change of name the plugin group should call AIPluginGroupSuite::MarkPluginArtDirty() while handling the message.

Enumerator:

kHideOpCode
kShowOpCode
kLockOpCode
kUnlockOpCode
kSetNameOpCode

enum AIChangeOperationSubcodes

Subcode values for kChangeOperationCode (only at kAfterOperationTime).

Enumerator:

kPluginSyncArtOpCode

Something in the edit group has been modified by plug-in calls, and Illustrator is about to pop the context.

There will have been no kBeforeOperationTime notification. Handler must not modify anything other than the plug-in object itself (because it is called in a loop that is processing the artwork tree).

enum AIGeometryOperationSubcodes

Subcode values for kGeometryOperationCode.

Enumerator:

kMiscPathChangeOpCode
kMovePointsOpCode	Unused.
kAdjustControlsOpCode	Unused.
kAddPointsOpCode	Unused.
kRemovePointsOpCode	Unused.
kReverseSegmentsOpCode	Unused.
kOpenCloseOpCode	Unused.
kSwapSymbolsOpCode	Unused.

enum AIOrderingOperationSubcodes

Subcode values for kOrderingOperationCode.

Enumerator:

kSendToBackOpCode
kSendToFrontOpCode
kSendBackwardOpCode
kSendForwardOpCode
kReverseGroupOpCode
kSendInternalOpCode	The `AIPluginGroupMessage::preEditArt` is in the plug-in group, and is being moved to another location which is also inside the plug-in group. See `AIPluginGroupMessage::insertionOrder` and `AIPluginGroupMessage::destinationArt` for the destination of the move. Used only if the movement is not equivalent to one of the more specific commands above.
kReorderOutCode	The `AIPluginGroupMessage::preEditArt` is in the plug-in group, and is about to be reordered to a location outside the plug-in group. See `AIPluginGroupMessage::insertionOrder` and `AIPluginGroupMessage::destinationArt` for the destination of the move. This is a chance to remove any private dictionary entries from the `preEditArt`.)
kReorderIntoOpCode	The `AIPluginGroupMessage::preEditArt` is outside the plug-in group, and is about to be reordered to a location inside the plug-in group, See `AIPluginGroupMessage::insertionOrder` and `AIPluginGroupMessage::destinationArt` for the destination of the move. (Typically handled in the same way as a `kPasteIntoOpCode` for `kTopologyOperationCode`.)

enum AIPluginGroupOptions

Options for AIPluginGroupSuite::AddAIPluginGroup().

Options affect how operations on a plug-in group affect the result group, and whether the notifications are sent after an operation. Notifications include kSelectorAIUpdateArt "AI Update" and kTransformOperationCode "AI Notify Edits". (Options cannot be changed after the class is defined.)

Enumerator:

kPluginGroupWantsOverlapUpdateOption	If on, updates are triggered by edits to non-descendant objects that overlap the bounds of the editable art. This is intended for objects with lens-like effects (distorting what they move over), or avoidance behavior (moving away from what moves over them).
kPluginGroupWantsAutoTranslateOption	If on, when the entire plug-in group is translated as a whole, the result group is transformed as well, and no update message is sent.
kPluginGroupWantsAutoUScaleOption	If on, when the entire plug-in group is scaled uniformly, the result group is transformed as well, and no update message is sent.
kPluginGroupWantsAutoTransformOption	If on, when the entire plug-in group is transformed as a whole by any matrix, the result group is transformed as well, and no update message is sent. The notify-edits message is sent to let the plug-in know what has been done; A zero return from the automatically-handled operation types is treated like a `kDontCarePluginGroupReply` return, so you need not register for the notify-edits message if you do not need to respond to it.
kPluginGroupDoEditFillHitOption	If on, hit testing by other tools does fill hit testing on the edit group. (The plug-in's own tool controls its own hit testing.) By default, the edit group is only outline-hit, because objects in the edit group are not previewed. Use this options if you copy the edit group contents into the result group and then add things, making it appear that the edit group paths are previewed. This allows direct selection of individual editable paths with a fill click. When on, if there are some edit group objects whose fills or strokes are not copied into the result group, you must check style change notifications to turn off any fill or stroke paint that the user has given to those objects. Otherwise, hits can occur on elements you have not painted. See also `kPluginGroupForceFillHitOnClosedPaths`.
kPluginGroupKeepWhenEmptyOption	If off (the default), when a user edit removes all objects from the edit group, the whole plug-in group object is deleted (analogous to the behavior of non-layer groups). If on, the plug-in group remains in the artwork after its edit group has been emptied. Use for objects that build their result art based entirely on private data that requires no edit art, or that behave like layers in that they can maintain the drawing insertion focus while empty. For implementing layer-like plugin groups, see also the flags kPluginGroupDoNotTarget and kPluginGroupDoNotSmartTarget.
kPluginGroupIsFillLike	If on, the objects in the result group behave like fill of the objects in the edit group. You could use this, for example, to implement ink hatching. Setting this flag informs other plug-ins of your plug-in group's behavior. For example, an Expand Fill filter could expand plug-in groups if this flag is on, or a Fill Color could refuse to assign a pattern or gradient fill to the edit group objects, knowing that the result group is acting as the fill. (Assigning solid color should be permitted, since fill-like plug-in groups often colorize their fills.) Default is off.
kPluginGroupIsStrokeLike	If on, the objects in the result group behave like stroke of the objects in the edit group. You could use this, for example, for brushes. Setting this flag informs other plug-ins of your plug-in group's behavior. For example, an Expand Stroke filter could expand plug-in groups if this flag is on, or the Stroke palette could ignore stroke attributes, knowing that the result group is acting as the stroke. Default is off. If both this and `kPluginGroupIsFillLike` are off, the result group objects are treated as related to the edit group in some way other than fill or stroke effect. An example is path interpolation blends.
kPluginGroupDoNotTarget	If on, the plug-in group object can never be targeted. Illustrator always recurses into the contents of the edit group to find targeted objects, regardless of whether the plug-in group object is fully selected. This flag prevents users from targeting the plug-in group and applying styles, transparency or effects to that level, even via the Layers or Appearance panels. Also, if this flag and kPluginGroupKeepWhenEmptyOption are both on, then the plugin group will act very much like a layer, in that commands such as Group, Cut, Delete, Copy and copy-drag will operate upon the contents of the edit group, somewhat as if it were only partially selected, rather than the entire plugin group. See also kPluginGroupDoNotSmartTarget.
kPluginGroupAlwaysSmartTarget	If on, selecting any piece inside the edit group automatically targets the plug-in group level. This targeting behavior is similar to that of compound paths. Fill/stroke changes apply to the plug-in group level, and the "Contents" field is not shown in the Appearance palette. The Compound Shapes plug-in group uses this option. Users can still target the objects inside the edit group individually in the Layers palette.
kPluginGroupDoNotSmartTarget	If on, the plug-in group is not targeted when fully selected. Users must target the plug-in group through the Layers panel or the Appearance panel. Also, if this flag and kPluginGroupKeepWhenEmptyOption are both on, then the plugin group will act very much like a layer, in that commands such as Group, Cut, Delete, Copy and copy-drag will operate upon the contents of the edit group, somewhat as if it were only partially selected, rather than the entire plugin group. See also kPluginGroupDoNotTarget. Do not set both this option and `kPluginGroupAlwaysSmartTarget` for the same plug-in group.
kPluginGroupCanBeClipping	If on, plug-in objects of this plug-in group can be clipping objects. The result art of a clipping object is used as a clip, if its type makes this possible.
kPluginGroupAlwaysShowContents	If on, the Layers palette always shows the contents of the edit group.
kPluginGroupAskToShowContents	If on, the Layers palette queries the plug-in group with the `kSelectorAICanShowContents` message to ask if it may expand the plug-in group. The plug-in group should reply with `kRefusePluginGroupReply` if it is not okay to expand.
kPluginGroupDisableBlends	Together with `kPluginGroupBlendAsPluginGroup`, defines how plug-in groups other than blends act when they appear inside a blend. This one is tested first. If on, and the selection includes any other plug-in group with this flag on, the Make Blend command is disabled. Also, fully selected plug-in groups with this option on do not respond to clicks of the Blend tool (although you can still create blends INSIDE of them.) If the selection contains no plug-in groups with this flag on, then plug-in groups that are blended to anything other than another plug-in group of the same class with the `kPluginGroupBlendAsPluginGroup` flag on are treated as if they were their result group. The interpolated objects are ordinary groups.
kPluginGroupBlendAsPluginGroup	Together with `kPluginGroupDisableBlends`, defines how plug-in groups other than blends act when they appear inside a blend. `kPluginGroupDisableBlends` is tested first. If the blend includes two adjacent plug-in groups of the same plug-in class, and this option on for that class, then the interpolated objects are also of the same plug-in class. The contents of the edit groups of the two plug-in objects are blended as if they were ordinary groups. The plug-in can then interpolate the plug-in group data and dictionary contents; see `kSelectorAIInterpolateData`. Finally the interpolated plug-in groups are sent the `kSelectorAIUpdateArt` message.
kPluginGroupRestrictsArtTypes	If on, the plug-in group restricts which types of objects can be inserted into its edit group, and should handle the `kSelectorAIDisallowsArtTypeQuery` message. This differs from the check you do for a `kBeforeOperationTime` `kSelectorAINotifyEdits` response, in that such a check passes in a specific prospective-contents object to a specific plug-in group, and checks whether that object can be inserted. The `AIPluginArtTypeMessageData` does not have a specific art object, only an art type. You can use it, for example, to disable tools or commands that might otherwise create a new object of that type, or to provide cancel feedback on mouse over.
kPluginGroupForceFillHitOnClosedPaths	Provides a lighter-weight, less flexible version of customized fill hit testing. If on, the plug-in group is treated as if it supplied fill paint on closed paths, so that selection tools select those paths in the edit group when clicking in their interiors, even if they have no fill paint of their own and no ancestor art style supplies fill paint. See also `kPluginGroupForceFillHitOnAllPaths` (the same, but for all paths) Edit fill hit testing is done only after outline testing fails to hit anything in the whole edit group, so front contents do not obscure outlines of back contents. It is also done only if something is hit in the result group, so that paths that are unfilled and that do not overlap any filled region are not selected. If on, this option takes precedence over `kPluginGroupDoEditFillHitOption`, meaning that the plug-in group has private data that it uses to supply fills (rather than edit objects being copied into the result group). This option is not the best choice if the plug-in group supplies private fills on only some parts of the edit group, or if the fill geometry is transformed. In that case, custom hit testing allows more customization, but takes longer.
kPluginGroupForceFillHitOnAllPaths	Provides a lighter-weight, less flexible version of customized fill hit testing. If on, the plug-in group is treated as if it supplied fill paint on all paths, so that selection tools select those paths in the edit group when clicking in their interiors, even if they have no fill paint of their own and no ancestor art style supplies fill paint. See `kPluginGroupForceFillHitOnClosedPaths` for additional details.
kPluginGroupManagesPaintStyles	If on, paint styles applied to content of this plug-in group should not be obtained or set by accessing the art styles of objects in the edit group, but instead by asking the plug-in group to get or set the paint styles attached to objects that it considers selected. The plug-in receives the `kSelectorAICollectPaintStyles` message when Illustrator would normally iterate the art styles attached to children of the edit group, and receives the `kSelectorAIApplyPaintStyles` message when Illustrator would normally set the art styles attached to children of the edit group. See also `AIPluginGroupCollectPaintStylesData`, `AIPluginGroupApplyPaintStylesData` Use if art styles attached to selected objects in the edit group do not reflect what the user sees as the selected styles. (The contents of the edit group are not previewed, so the styles in the result group are what the user sees, and they may not correspond directly to the styles used in the edit group.) Also useful for plug-in groups that manage selection state in a way that does not map directly onto object selection within the edit group. This flag is not compatible with any of the target flags (`kPluginGroupDoNotTarget`, `kPluginGroupAlwaysSmartTarget`, `kPluginGroupDoNotSmartTarget`).
kPluginGroupPermitsGroupCmds	If on, the plugin group allows at least some grouping operations to be performed inside of it. Grouping operations include Group, Ungroup, Make Compound, Make Clip, and their corresponding Release operations, plus Expand Appearance and Expand, since they typically convert a leaf object into a group. If off, no grouping operations are attempted and no kCheckOperationTime message is sent. The reason there is a flag rather than just using a kCheckOperationTime message before the edit, as is done for most kinds of edits, is that until CS 6, grouping operations were unilaterally disallowed inside all plugin groups. Since the default for no response to a kCheckOperationTime message is to assume that the operation IS allowed, in order not to alter the runtime environment for legacy plugins we must default to sending no message and not attempting the operation.

enum AIStyleOperationSubcodes

Subcode values for kStyleOperationCode.

Enumerator:

kPathStyleOpCode
kTextStyleOpCode	Unused.
kArtStyleOpCode	Unused.

enum AITopologyOperationSubcodes

Subcode values for kTopologyOperationCode These are sent at kBeforeOperationTime, and provide additional information about what type of change is about to occur.

Your handler can update private data, but must not make any changes to the edit group.

Enumerator:

kScissorOpCode	One path is replaced by two.
kPasteBelowOpCode	The `AIPluginGroupMessage::postEditArt` (or its children if it is a group) will be inserted into the edit art below `AIPluginGroupMessage::preEditArt` (which is the same as `AIPluginGroupMessage::destinationArt`. )
kPasteIntoOpCode	The `AIPluginGroupMessage::postEditArt` (or its children if it is a group) will be inserted above `AIPluginGroupMessage::preEditArt` (which is the same as `AIPluginGroupMessage::destinationArt`. )
kPasteAboveOpCode	The `AIPluginGroupMessage::postEditArt` (or its children if it is a group) will be inserted below `AIPluginGroupMessage::preEditArt` (which is the same as `AIPluginGroupMessage::destinationArt`. )
kTransformCopyOpCode	The `AIPluginGroupMessage::postEditArt` is a transformed copy of `preEditArt`. Typically it will be inserted above `AIPluginGroupMessage::preEditArt`. Check `AIPluginGroupMessage::destinationArt` and `AIPluginGroupMessage::insertionOrder` for the insertion location.
kTypePathChangeOpCode	The `AIPluginGroupMessage::preEditArt` will be changed into a type path.
kReplaceOneOpCode	Unused.
kReplaceByManyOpCode	Unused.
kDuplicateInsideOpCode	The `AIPluginGroupMessage::postEditArt` is a non-transformed copy of `preEditArt`, which will be inserted in the art edit group or a descendant. Check `AIPluginGroupMessage::destinationArt` and `AIPluginGroupMessage::insertionOrder` for the insertion location.
kDuplicateOutsideOpCode	Sent only at `kAfterOperationTime`. The `AIPluginGroupMessage::postEditArt` is a copy of `preEditArt` which was moved outside the plug-in group. Allows you to remove any private tags or dictionary entries from the `postEditArt`.
kMakeGroupOpCode	The selected objects inside the plugin group are to be combined into a group, compound path, or clipping group. The `AIPluginGroupMessage::preEditArt` is the first encountered selected component of the plugin group, which determines where the new group will be placed in the stacking order. At `kCheckOperationTime` and `kBeforeOperationTime` the `AIPluginGroupMessage::postEditArt` is an empty art object of the type that is going to be created. The plugin can call `AIArtSuite::GetArtType()` to determine whether a group or compound path is being created, and can call `AIGroupSuite::GetGroupClipped()` when the type is `kGroupArt` to determine when a clipping group is being created. The `postEditArt` at pre-edit time is not necessarily the same `AIArtHandle` that is created, and is definitely not in the art tree; it has a null parent. If this message is sent at `kAfterOperationTime`, the `postEditArt` is the resulting group or compound path art. This operation code is sent only if the `kPluginGroupPermitsGroupCmds` option is set. If that option is off, no group operations are attempted.
kReleaseGroupOpCode	The `AIPluginGroupMessage::preEditArt` will be ungrouped or released. If it is a nested plugin group, it will be replaced by its edit art group. This operation code is sent only if the kPluginGroupPermitsGroupCmds option is set. If that option is off, no release group operations are attempted.
kExpandInsideOpCode	If non-null, the `AIPluginGroupMessage::preEditArt` will be expanded into a group that expands all or part of the appearance. If it is a nested plugin group, it will be expanded into its result group. If it is an object with an active art style, it will be replaced by the styled art. If it has a basic appearance, either the fills or strokes or both will be expanded. If the `preEditArt` is null or is the plugin group itself, then the plugin group is partially selected and is about to be examined by one of the Expand commands. This gives the plugin group a chance to return `kRefusePluginGroupReply` to skip examination of the contents, if the plugin group disallows all expansions inside (but allows `kMakeGroupOpCode` and/or `kReleaseGroupOpCode`.) No attempt is made to inform the plugin group of the details of the operation, as there are too many variations, and the main intent is to ask whether the expansion is allowed at all. This operation code is sent only if the `kPluginGroupPermitsGroupCmds` option is set. If that option is off, no expansion operations are attempted inside the plugin group. See also `kExpandOperationCode` for notifications of the expansion of the entire plugin group.

enum AITransformOperationSubcodes

Subcode values for kTransformOperationCode.

Enumerator:

kTranslationOpCode
kRotationOpCode
kUniformScaleOpCode
kNonUniformScaleOpCode
kShearOpCode
kReflectionOpCode
kMixedTransformOpCode

AIPluginGroup.h File Reference

Classes

Defines

Typedefs

Enumerations

Detailed Description

Define Documentation

Typedef Documentation

Enumeration Type Documentation