GXGraphics.h

Go to the documentation of this file.

 
#ifndef __GXGRAPHICS__
#define __GXGRAPHICS__
 
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __FONTS__
#include <Fonts.h>
#endif
 
#ifndef __GXERRORS__
#include <GXErrors.h>
#endif
 
#ifndef __GXTYPES__
#include <GXTypes.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#if defined(__MWERKS__) && TARGET_CPU_68K
#pragma push
#pragma pointers_in_D0
#endif
 
#if CALL_NOT_IN_CARBON
    gxGraphicsClient
    GXNewGraphicsClient(void *memoryStart, long memoryLength,
                        gxClientAttribute attributes);
 
    gxGraphicsClient
    GXGetGraphicsClient(void);
 
    void
    GXSetGraphicsClient(gxGraphicsClient client);
 
    void
    GXDisposeGraphicsClient(gxGraphicsClient client);
 
#endif /* CALL_NOT_IN_CARBON */
 
/*returns the count */
#if CALL_NOT_IN_CARBON
    long
    GXGetGraphicsClients(long index, long count, gxGraphicsClient clients[]);
 
    void
    GXEnterGraphics(void);
 
    void
    GXExitGraphics(void);
 
    gxGraphicsError
    GXGetGraphicsError(gxGraphicsError *stickyError);
 
    gxGraphicsNotice
    GXGetGraphicsNotice(gxGraphicsNotice *stickyNotice);
 
    gxGraphicsWarning
    GXGetGraphicsWarning(gxGraphicsWarning *stickyWarning);
 
    void
    GXPostGraphicsError(gxGraphicsError error);
 
    void
    GXPostGraphicsWarning(gxGraphicsWarning warning);
 
    gxUserErrorUPP
    GXGetUserGraphicsError(long *reference);
 
    gxUserNoticeUPP
    GXGetUserGraphicsNotice(long *reference);
 
    gxUserWarningUPP
    GXGetUserGraphicsWarning(long *reference);
 
    void
    GXSetUserGraphicsError(gxUserErrorUPP userFunction, long reference);
 
    void
    GXSetUserGraphicsNotice(gxUserNoticeUPP userFunction, long reference);
 
    void
    GXSetUserGraphicsWarning(gxUserWarningUPP userFunction, long reference);
 
    void
    GXIgnoreGraphicsWarning(gxGraphicsWarning warning);
 
    void
    GXPopGraphicsWarning(void);
 
    gxShape
    GXNewShapeVector(gxShapeType aType, const Fixed vector[]);
 
    void
    GXSetShapeVector(gxShape target, const Fixed vector[]);
 
    gxShape
    GXNewBitmap(const gxBitmap *data, const gxPoint *position);
 
    gxShape
    GXNewCurve(const gxCurve *data);
 
    gxShape
    GXNewGlyphs(long charCount, const unsigned char text[],
                const gxPoint positions[], const long advance[],
                const gxPoint tangents[], const short styleRuns[],
                const gxStyle glyphStyles[]);
 
    gxShape
    GXNewLine(const gxLine *data);
 
    gxShape
    GXNewPaths(const gxPaths *data);
 
    gxShape
    GXNewPicture(long count, const gxShape shapes[], const gxStyle styles[],
                 const gxInk inks[], const gxTransform transforms[]);
 
    gxShape
    GXNewPoint(const gxPoint *data);
 
    gxShape
    GXNewPolygons(const gxPolygons *data);
 
    gxShape
    GXNewRectangle(const gxRectangle *data);
 
    gxShape
    GXNewText(long charCount, const unsigned char text[], const gxPoint *position);
 
    gxBitmap *
    GXGetBitmap(gxShape source, gxBitmap *data, gxPoint *position);
 
    gxCurve *
    GXGetCurve(gxShape source, gxCurve *data);
 
    /* returns byte length of glyphs */
    long
    GXGetGlyphs(gxShape source, long *charCount, unsigned char text[],
                gxPoint positions[], long advance[], gxPoint tangents[],
                long *runCount, short styleRuns[], gxStyle glyphStyles[]);
 
    gxLine *
    GXGetLine(gxShape source, gxLine *data);
 
    /* returns byte length */
    long
    GXGetPaths(gxShape source, gxPaths *data);
 
    /* returns count */
    long
    GXGetPicture(gxShape source, gxShape shapes[], gxStyle styles[], gxInk inks[],
                 gxTransform transforms[]);
 
    gxPoint *
    GXGetPoint(gxShape source, gxPoint *data);
 
    /* returns byte length */
    long
    GXGetPolygons(gxShape source, gxPolygons *data);
 
    gxRectangle *
    GXGetRectangle(gxShape source, gxRectangle *data);
 
    /* returns byte length */
    long
    GXGetText(gxShape source, long *charCount, unsigned char text[],
              gxPoint *position);
 
    void
    GXSetBitmap(gxShape target, const gxBitmap *data, const gxPoint *position);
 
    void
    GXSetCurve(gxShape target, const gxCurve *data);
 
    void
    GXSetGlyphs(gxShape target, long charCount, const unsigned char text[],
                const gxPoint positions[], const long advance[],
                const gxPoint tangents[], const short styleRuns[],
                const gxStyle glyphStyles[]);
 
    void
    GXSetLine(gxShape target, const gxLine *data);
 
    void
    GXSetPaths(gxShape target, const gxPaths *data);
 
    void
    GXSetPicture(gxShape target, long count, const gxShape shapes[],
                 const gxStyle styles[], const gxInk inks[],
                 const gxTransform transforms[]);
 
    void
    GXSetPoint(gxShape target, const gxPoint *data);
 
    void
    GXSetPolygons(gxShape target, const gxPolygons *data);
 
    void
    GXSetRectangle(gxShape target, const gxRectangle *data);
 
    void
    GXSetText(gxShape target, long charCount, const unsigned char text[],
              const gxPoint *position);
 
    void
    GXDrawBitmap(const gxBitmap *data, const gxPoint *position);
 
    void
    GXDrawCurve(const gxCurve *data);
 
    void
    GXDrawGlyphs(long charCount, const unsigned char text[],
                 const gxPoint positions[], const long advance[],
                 const gxPoint tangents[], const short styleRuns[],
                 const gxStyle glyphStyles[]);
 
    void
    GXDrawLine(const gxLine *data);
 
    void
    GXDrawPaths(const gxPaths *data, gxShapeFill fill);
 
    void
    GXDrawPicture(long count, const gxShape shapes[], const gxStyle styles[],
                  const gxInk inks[], const gxTransform transforms[]);
 
    void
    GXDrawPoint(const gxPoint *data);
 
    void
    GXDrawPolygons(const gxPolygons *data, gxShapeFill fill);
 
    void
    GXDrawRectangle(const gxRectangle *data, gxShapeFill fill);
 
    void
    GXDrawText(long charCount, const unsigned char text[], const gxPoint *position);
 
    gxColorProfile
    GXNewColorProfile(long size, void *colorProfileData);
 
    gxColorSet
    GXNewColorSet(gxColorSpace space, long count, const gxSetColor colors[]);
 
    gxInk
    GXNewInk(void);
 
    gxShape
    GXNewShape(gxShapeType aType);
 
    gxStyle
    GXNewStyle(void);
 
    gxTag
    GXNewTag(long tagType, long length, const void *data);
 
    gxTransform
    GXNewTransform(void);
 
    gxViewDevice
    GXNewViewDevice(gxViewGroup group, gxShape bitmapShape);
 
    gxViewGroup
    GXNewViewGroup(void);
 
    gxViewPort
    GXNewViewPort(gxViewGroup group);
 
    void
    GXDisposeColorProfile(gxColorProfile target);
 
    void
    GXDisposeColorSet(gxColorSet target);
 
    void
    GXDisposeInk(gxInk target);
 
    void
    GXDisposeShape(gxShape target);
 
    void
    GXDisposeStyle(gxStyle target);
 
    void
    GXDisposeTag(gxTag target);
 
    void
    GXDisposeTransform(gxTransform target);
 
    void
    GXDisposeViewDevice(gxViewDevice target);
 
    void
    GXDisposeViewGroup(gxViewGroup target);
 
    void
    GXDisposeViewPort(gxViewPort target);
 
    gxColorProfile
    GXCloneColorProfile(gxColorProfile source);
 
    gxColorSet
    GXCloneColorSet(gxColorSet source);
 
    gxInk
    GXCloneInk(gxInk source);
 
    gxShape
    GXCloneShape(gxShape source);
 
    gxStyle
    GXCloneStyle(gxStyle source);
 
    gxTag
    GXCloneTag(gxTag source);
 
    gxTransform
    GXCloneTransform(gxTransform source);
 
    gxColorProfile
    GXCopyToColorProfile(gxColorProfile target, gxColorProfile source);
 
    gxColorSet
    GXCopyToColorSet(gxColorSet target, gxColorSet source);
 
    gxInk
    GXCopyToInk(gxInk target, gxInk source);
 
    gxShape
    GXCopyToShape(gxShape target, gxShape source);
 
    gxStyle
    GXCopyToStyle(gxStyle target, gxStyle source);
 
    gxTag
    GXCopyToTag(gxTag target, gxTag source);
 
    gxTransform
    GXCopyToTransform(gxTransform target, gxTransform source);
 
    gxViewDevice
    GXCopyToViewDevice(gxViewDevice target, gxViewDevice source);
 
    gxViewPort
    GXCopyToViewPort(gxViewPort target, gxViewPort source);
 
    Boolean
    GXEqualColorProfile(gxColorProfile one, gxColorProfile two);
 
    Boolean
    GXEqualColorSet(gxColorSet one, gxColorSet two);
 
    Boolean
    GXEqualInk(gxInk one, gxInk two);
 
    Boolean
    GXEqualShape(gxShape one, gxShape two);
 
    Boolean
    GXEqualStyle(gxStyle one, gxStyle two);
 
    Boolean
    GXEqualTag(gxTag one, gxTag two);
 
    Boolean
    GXEqualTransform(gxTransform one, gxTransform two);
 
    Boolean
    GXEqualViewDevice(gxViewDevice one, gxViewDevice two);
 
    Boolean
    GXEqualViewPort(gxViewPort one, gxViewPort two);
 
    void
    GXResetInk(gxInk target);
 
    void
    GXResetShape(gxShape target);
 
    void
    GXResetStyle(gxStyle target);
 
    void
    GXResetTransform(gxTransform target);
 
    void
    GXLoadColorProfile(gxColorProfile target);
 
    void
    GXLoadColorSet(gxColorSet target);
 
    void
    GXLoadInk(gxInk target);
 
    void
    GXLoadShape(gxShape target);
 
    void
    GXLoadStyle(gxStyle target);
 
    void
    GXLoadTag(gxTag target);
 
    void
    GXLoadTransform(gxTransform target);
 
    void
    GXUnloadColorProfile(gxColorProfile target);
 
    void
    GXUnloadColorSet(gxColorSet target);
 
    void
    GXUnloadInk(gxInk target);
 
    void
    GXUnloadShape(gxShape target);
 
    void
    GXUnloadStyle(gxStyle target);
 
    void
    GXUnloadTag(gxTag target);
 
    void
    GXUnloadTransform(gxTransform target);
 
    void
    GXCacheShape(gxShape source);
 
    gxShape
    GXCopyDeepToShape(gxShape target, gxShape source);
 
    void
    GXDrawShape(gxShape source);
 
    void
    GXDisposeShapeCache(gxShape target);
 
    gxColorProfile
    GXGetDefaultColorProfile(void);
 
    gxShape
    GXGetDefaultShape(gxShapeType aType);
 
    gxColorSet
    GXGetDefaultColorSet(long pixelDepth);
 
    void
    GXSetDefaultShape(gxShape target);
 
    void
    GXSetDefaultColorSet(gxColorSet target, long pixelDepth);
 
    long
    GXGetTag(gxTag source, long *tagType, void *data);
 
    void
    GXSetTag(gxTag target, long tagType, long length, const void *data);
 
    gxRectangle *
    GXGetShapeBounds(gxShape source, long index, gxRectangle *bounds);
 
    gxShapeFill
    GXGetShapeFill(gxShape source);
 
    gxInk
    GXGetShapeInk(gxShape source);
 
    long
    GXGetShapePixel(gxShape source, long x, long y, gxColor *data, long *index);
 
    gxStyle
    GXGetShapeStyle(gxShape source);
 
    gxTransform
    GXGetShapeTransform(gxShape source);
 
    gxShapeType
    GXGetShapeType(gxShape source);
 
    gxRectangle *
    GXGetShapeTypographicBounds(gxShape source, gxRectangle *bounds);
 
    gxShape
    GXGetBitmapParts(gxShape source, const gxLongRectangle *bounds);
 
    void
    GXGetStyleFontMetrics(gxStyle sourceStyle, gxPoint *before, gxPoint *after,
                          gxPoint *caretAngle, gxPoint *caretOffset);
 
    void
    GXGetShapeFontMetrics(gxShape source, gxPoint *before, gxPoint *after,
                          gxPoint *caretAngle, gxPoint *caretOffset);
 
    void
    GXSetShapeBounds(gxShape target, const gxRectangle *newBounds);
 
    void
    GXSetShapeFill(gxShape target, gxShapeFill newFill);
 
    void
    GXSetShapeInk(gxShape target, gxInk newInk);
 
    void
    GXSetShapePixel(gxShape target, long x, long y, const gxColor *newColor,
                    long newIndex);
 
    void
    GXSetShapeStyle(gxShape target, gxStyle newStyle);
 
    void
    GXSetShapeTransform(gxShape target, gxTransform newTransform);
 
    void
    GXSetShapeType(gxShape target, gxShapeType newType);
 
    void
    GXSetBitmapParts(gxShape target, const gxLongRectangle *bounds,
                     gxShape bitmapShape);
 
    void
    GXSetShapeGeometry(gxShape target, gxShape geometry);
 
    Fixed
    GXGetShapeCurveError(gxShape source);
 
    gxDashRecord *
    GXGetShapeDash(gxShape source, gxDashRecord *dash);
 
    gxCapRecord *
    GXGetShapeCap(gxShape source, gxCapRecord *cap);
 
    /* returns the number of layers */
    long
    GXGetShapeFace(gxShape source, gxTextFace *face);
 
    gxFont
    GXGetShapeFont(gxShape source);
 
    gxJoinRecord *
    GXGetShapeJoin(gxShape source, gxJoinRecord *join);
 
    Fract
    GXGetShapeJustification(gxShape source);
 
    gxPatternRecord *
    GXGetShapePattern(gxShape source, gxPatternRecord *pattern);
 
    Fixed
    GXGetShapePen(gxShape source);
 
    gxFontPlatform
    GXGetShapeEncoding(gxShape source, gxFontScript *script,
                       gxFontLanguage *language);
 
    Fixed
    GXGetShapeTextSize(gxShape source);
 
    long
    GXGetShapeFontVariations(gxShape source, gxFontVariation variations[]);
 
    long
    GXGetShapeFontVariationSuite(gxShape source, gxFontVariation variations[]);
 
    Fixed
    GXGetStyleCurveError(gxStyle source);
 
    gxDashRecord *
    GXGetStyleDash(gxStyle source, gxDashRecord *dash);
 
    gxCapRecord *
    GXGetStyleCap(gxStyle source, gxCapRecord *cap);
 
    /* returns the number of layers */
    long
    GXGetStyleFace(gxStyle source, gxTextFace *face);
 
    gxFont
    GXGetStyleFont(gxStyle source);
 
    gxJoinRecord *
    GXGetStyleJoin(gxStyle source, gxJoinRecord *join);
 
    Fract
    GXGetStyleJustification(gxStyle source);
 
    gxPatternRecord *
    GXGetStylePattern(gxStyle source, gxPatternRecord *pattern);
 
    Fixed
    GXGetStylePen(gxStyle source);
 
    gxFontPlatform
    GXGetStyleEncoding(gxStyle source, gxFontScript *script,
                       gxFontLanguage *language);
 
    Fixed
    GXGetStyleTextSize(gxStyle source);
 
    long
    GXGetStyleFontVariations(gxStyle source, gxFontVariation variations[]);
 
    long
    GXGetStyleFontVariationSuite(gxStyle source, gxFontVariation variations[]);
 
    void
    GXSetShapeCurveError(gxShape target, Fixed error);
 
    void
    GXSetShapeDash(gxShape target, const gxDashRecord *dash);
 
    void
    GXSetShapeCap(gxShape target, const gxCapRecord *cap);
 
    void
    GXSetShapeFace(gxShape target, const gxTextFace *face);
 
    void
    GXSetShapeFont(gxShape target, gxFont aFont);
 
    void
    GXSetShapeJoin(gxShape target, const gxJoinRecord *join);
 
    void
    GXSetShapeJustification(gxShape target, Fract justify);
 
    void
    GXSetShapePattern(gxShape target, const gxPatternRecord *pattern);
 
    void
    GXSetShapePen(gxShape target, Fixed pen);
 
    void
    GXSetShapeEncoding(gxShape target, gxFontPlatform platform, gxFontScript script,
                       gxFontLanguage language);
 
    void
    GXSetShapeTextSize(gxShape target, Fixed size);
 
    void
    GXSetShapeFontVariations(gxShape target, long count,
                             const gxFontVariation variations[]);
 
    void
    GXSetStyleCurveError(gxStyle target, Fixed error);
 
    void
    GXSetStyleDash(gxStyle target, const gxDashRecord *dash);
 
    void
    GXSetStyleCap(gxStyle target, const gxCapRecord *cap);
 
    void
    GXSetStyleFace(gxStyle target, const gxTextFace *face);
 
    void
    GXSetStyleFont(gxStyle target, gxFont aFont);
 
    void
    GXSetStyleJoin(gxStyle target, const gxJoinRecord *join);
 
    void
    GXSetStyleJustification(gxStyle target, Fract justify);
 
    void
    GXSetStylePattern(gxStyle target, const gxPatternRecord *pattern);
 
    void
    GXSetStylePen(gxStyle target, Fixed pen);
 
    void
    GXSetStyleEncoding(gxStyle target, gxFontPlatform platform, gxFontScript script,
                       gxFontLanguage language);
 
    void
    GXSetStyleTextSize(gxStyle target, Fixed size);
 
    void
    GXSetStyleFontVariations(gxStyle target, long count,
                             const gxFontVariation variations[]);
 
    gxColor *
    GXGetShapeColor(gxShape source, gxColor *data);
 
    gxTransferMode *
    GXGetShapeTransfer(gxShape source, gxTransferMode *data);
 
    gxColor *
    GXGetInkColor(gxInk source, gxColor *data);
 
    gxTransferMode *
    GXGetInkTransfer(gxInk source, gxTransferMode *data);
 
    void
    GXSetShapeColor(gxShape target, const gxColor *data);
 
    void
    GXSetShapeTransfer(gxShape target, const gxTransferMode *data);
 
    void
    GXSetInkColor(gxInk target, const gxColor *data);
 
    void
    GXSetInkTransfer(gxInk target, const gxTransferMode *data);
 
    gxShape
    GXGetShapeClip(gxShape source);
 
    gxShapeType
    GXGetShapeClipType(gxShape source);
 
    gxMapping *
    GXGetShapeMapping(gxShape source, gxMapping *map);
 
    gxShapePart
    GXGetShapeHitTest(gxShape source, Fixed *tolerance);
 
    long
    GXGetShapeViewPorts(gxShape source, gxViewPort list[]);
 
    gxShape
    GXGetTransformClip(gxTransform source);
 
    gxShapeType
    GXGetTransformClipType(gxTransform source);
 
    gxMapping *
    GXGetTransformMapping(gxTransform source, gxMapping *map);
 
    gxShapePart
    GXGetTransformHitTest(gxTransform source, Fixed *tolerance);
 
    long
    GXGetTransformViewPorts(gxTransform source, gxViewPort list[]);
 
    void
    GXSetShapeClip(gxShape target, gxShape clip);
 
    void
    GXSetShapeMapping(gxShape target, const gxMapping *map);
 
    void
    GXSetShapeHitTest(gxShape target, gxShapePart mask, Fixed tolerance);
 
    void
    GXSetShapeViewPorts(gxShape target, long count, const gxViewPort list[]);
 
    void
    GXSetTransformClip(gxTransform target, gxShape clip);
 
    void
    GXSetTransformMapping(gxTransform target, const gxMapping *map);
 
    void
    GXSetTransformHitTest(gxTransform target, gxShapePart mask, Fixed tolerance);
 
    void
    GXSetTransformViewPorts(gxTransform target, long count, const gxViewPort list[]);
 
    long
    GXGetColorSet(gxColorSet source, gxColorSpace *space, gxSetColor colors[]);
 
    long
    GXGetColorProfile(gxColorProfile source, void *colorProfileData);
 
    void
    GXSetColorSet(gxColorSet target, gxColorSpace space, long count,
                  const gxSetColor colors[]);
 
    void
    GXSetColorProfile(gxColorProfile target, long size, void *colorProfileData);
 
    gxShape
    GXGetViewDeviceBitmap(gxViewDevice source);
 
    gxShape
    GXGetViewDeviceClip(gxViewDevice source);
 
    gxMapping *
    GXGetViewDeviceMapping(gxViewDevice source, gxMapping *map);
 
    gxViewGroup
    GXGetViewDeviceViewGroup(gxViewDevice source);
 
    void
    GXSetViewDeviceBitmap(gxViewDevice target, gxShape bitmapShape);
 
    void
    GXSetViewDeviceClip(gxViewDevice target, gxShape clip);
 
    void
    GXSetViewDeviceMapping(gxViewDevice target, const gxMapping *map);
 
    void
    GXSetViewDeviceViewGroup(gxViewDevice target, gxViewGroup group);
 
    long
    GXGetViewPortChildren(gxViewPort source, gxViewPort list[]);
 
    gxShape
    GXGetViewPortClip(gxViewPort source);
 
    long
    GXGetViewPortDither(gxViewPort source);
 
    Boolean
    GXGetViewPortHalftone(gxViewPort source, gxHalftone *data);
 
    gxMapping *
    GXGetViewPortMapping(gxViewPort source, gxMapping *map);
 
    gxViewPort
    GXGetViewPortParent(gxViewPort source);
 
    gxViewGroup
    GXGetViewPortViewGroup(gxViewPort source);
 
    long
    GXGetViewPortHalftoneMatrix(gxViewPort source, gxViewDevice sourceDevice,
                                gxHalftoneMatrix *theMatrix);
 
    void
    GXSetViewPortChildren(gxViewPort target, long count, const gxViewPort list[]);
 
    void
    GXSetViewPortClip(gxViewPort target, gxShape clip);
 
    void
    GXSetViewPortDither(gxViewPort target, long level);
 
    void
    GXSetViewPortHalftone(gxViewPort target, const gxHalftone *data);
 
    void
    GXSetViewPortMapping(gxViewPort target, const gxMapping *map);
 
    void
    GXSetViewPortParent(gxViewPort target, gxViewPort parent);
 
    void
    GXSetViewPortViewGroup(gxViewPort target, gxViewGroup group);
 
    long
    GXGetColorProfileTags(gxColorProfile source, long tagType, long index,
                          long count, gxTag items[]);
 
    long
    GXGetColorSetTags(gxColorSet source, long tagType, long index, long count,
                      gxTag items[]);
 
    long
    GXGetInkTags(gxInk source, long tagType, long index, long count, gxTag items[]);
 
    long
    GXGetShapeTags(gxShape source, long tagType, long index, long count,
                   gxTag items[]);
 
    long
    GXGetStyleTags(gxStyle source, long tagType, long index, long count,
                   gxTag items[]);
 
    long
    GXGetTransformTags(gxTransform source, long tagType, long index, long count,
                       gxTag items[]);
 
    long
    GXGetViewDeviceTags(gxViewDevice source, long tagType, long index, long count,
                        gxTag items[]);
 
    long
    GXGetViewPortTags(gxViewPort source, long tagType, long index, long count,
                      gxTag items[]);
 
    void
    GXSetColorProfileTags(gxColorProfile target, long tagType, long index,
                          long oldCount, long newCount, const gxTag items[]);
 
    void
    GXSetColorSetTags(gxColorSet target, long tagType, long index, long oldCount,
                      long newCount, const gxTag items[]);
 
    void
    GXSetInkTags(gxInk target, long tagType, long index, long oldCount,
                 long newCount, const gxTag items[]);
 
    void
    GXSetShapeTags(gxShape target, long tagType, long index, long oldCount,
                   long newCount, const gxTag items[]);
 
    void
    GXSetStyleTags(gxStyle target, long tagType, long index, long oldCount,
                   long newCount, const gxTag items[]);
 
    void
    GXSetTransformTags(gxTransform target, long tagType, long index, long oldCount,
                       long newCount, const gxTag items[]);
 
    void
    GXSetViewDeviceTags(gxViewDevice target, long tagType, long index,
                        long oldCount, long newCount, const gxTag items[]);
 
    void
    GXSetViewPortTags(gxViewPort target, long tagType, long index, long oldCount,
                      long newCount, const gxTag items[]);
 
    gxInkAttribute
    GXGetInkAttributes(gxInk source);
 
    gxShapeAttribute
    GXGetShapeAttributes(gxShape source);
 
    gxInkAttribute
    GXGetShapeInkAttributes(gxShape source);
 
    gxStyleAttribute
    GXGetShapeStyleAttributes(gxShape source);
 
    gxStyleAttribute
    GXGetStyleAttributes(gxStyle source);
 
    gxTextAttribute
    GXGetShapeTextAttributes(gxShape source);
 
    gxTextAttribute
    GXGetStyleTextAttributes(gxStyle source);
 
    gxDeviceAttribute
    GXGetViewDeviceAttributes(gxViewDevice source);
 
    gxPortAttribute
    GXGetViewPortAttributes(gxViewPort source);
 
    void
    GXSetInkAttributes(gxInk target, gxInkAttribute attributes);
 
    void
    GXSetShapeAttributes(gxShape target, gxShapeAttribute attributes);
 
    void
    GXSetShapeInkAttributes(gxShape target, gxInkAttribute attributes);
 
    void
    GXSetShapeStyleAttributes(gxShape target, gxStyleAttribute attributes);
 
    void
    GXSetStyleAttributes(gxStyle target, gxStyleAttribute attributes);
 
    void
    GXSetShapeTextAttributes(gxShape target, gxTextAttribute attributes);
 
    void
    GXSetStyleTextAttributes(gxStyle target, gxTextAttribute attributes);
 
    void
    GXSetViewDeviceAttributes(gxViewDevice target, gxDeviceAttribute attributes);
 
    void
    GXSetViewPortAttributes(gxViewPort target, gxPortAttribute attributes);
 
    long
    GXGetColorProfileOwners(gxColorProfile source);
 
    long
    GXGetColorSetOwners(gxColorSet source);
 
    long
    GXGetInkOwners(gxInk source);
 
    long
    GXGetShapeOwners(gxShape source);
 
    long
    GXGetStyleOwners(gxStyle source);
 
    long
    GXGetTagOwners(gxTag source);
 
    long
    GXGetTransformOwners(gxTransform source);
 
    void
    GXLockShape(gxShape target);
 
    void
    GXLockTag(gxTag target);
 
    void
    GXUnlockShape(gxShape target);
 
    void
    GXUnlockTag(gxTag target);
 
    void *
    GXGetShapeStructure(gxShape source, long *length);
 
    void *
    GXGetTagStructure(gxTag source, long *length);
 
    Fixed
    GXGetColorDistance(const gxColor *target, const gxColor *source);
 
    gxPoint *
    GXShapeLengthToPoint(gxShape target, long index, Fixed length,
                         gxPoint *location, gxPoint *tangent);
 
    wide *
    GXGetShapeArea(gxShape source, long index, wide *area);
 
    long
    GXGetShapeCacheSize(gxShape source);
 
    gxPoint *
    GXGetShapeCenter(gxShape source, long index, gxPoint *center);
 
    gxContourDirection
    GXGetShapeDirection(gxShape source, long contour);
 
    long
    GXGetShapeIndex(gxShape source, long contour, long vector);
 
    wide *
    GXGetShapeLength(gxShape source, long index, wide *length);
 
    long
    GXGetShapeSize(gxShape source);
 
    long
    GXCountShapeContours(gxShape source);
 
    long
    GXCountShapePoints(gxShape source, long contour);
 
    /* returns the number of positions */
    long
    GXGetShapeDashPositions(gxShape source, gxMapping dashMappings[]);
 
    long
    GXGetShapeDeviceArea(gxShape source, gxViewPort port, gxViewDevice device);
 
    Boolean
    GXGetShapeDeviceBounds(gxShape source, gxViewPort port, gxViewDevice device,
                           gxRectangle *bounds);
 
    gxColorSet
    GXGetShapeDeviceColors(gxShape source, gxViewPort port, gxViewDevice device,
                           long *width);
 
    Boolean
    GXGetShapeGlobalBounds(gxShape source, gxViewPort port, gxViewGroup group,
                           gxRectangle *bounds);
 
    long
    GXGetShapeGlobalViewDevices(gxShape source, gxViewPort port,
                                gxViewDevice list[]);
 
    long
    GXGetShapeGlobalViewPorts(gxShape source, gxViewPort list[]);
 
    gxRectangle *
    GXGetShapeLocalBounds(gxShape source, gxRectangle *bounds);
 
    /* returns the number of positions */
    long
    GXGetShapePatternPositions(gxShape source, gxPoint positions[]);
 
    void
    GXGetShapeLocalFontMetrics(gxShape sourceShape, gxPoint *before, gxPoint *after,
                               gxPoint *caretAngle, gxPoint *caretOffset);
 
    void
    GXGetShapeDeviceFontMetrics(gxShape sourceShape, gxViewPort port,
                                gxViewDevice device, gxPoint *before,
                                gxPoint *after, gxPoint *caretAngle,
                                gxPoint *caretOffset);
 
    long
    GXGetViewGroupViewDevices(gxViewGroup source, gxViewDevice list[]);
 
    long
    GXGetViewGroupViewPorts(gxViewGroup source, gxViewPort list[]);
 
    gxMapping *
    GXGetViewPortGlobalMapping(gxViewPort source, gxMapping *map);
 
    long
    GXGetViewPortViewDevices(gxViewPort source, gxViewDevice list[]);
 
    gxShape
    GXHitTestPicture(gxShape target, const gxPoint *test, gxHitTestInfo *result,
                     long level, long depth);
 
    Boolean
    GXIntersectRectangle(gxRectangle *target, const gxRectangle *source,
                         const gxRectangle *operand);
 
    gxRectangle *
    GXUnionRectangle(gxRectangle *target, const gxRectangle *source,
                     const gxRectangle *operand);
 
    Boolean
    GXTouchesRectanglePoint(const gxRectangle *target, const gxPoint *test);
 
    Boolean
    GXTouchesShape(gxShape target, gxShape test);
 
    Boolean
    GXTouchesBoundsShape(const gxRectangle *target, gxShape test);
 
    Boolean
    GXContainsRectangle(const gxRectangle *container, const gxRectangle *test);
 
    Boolean
    GXContainsShape(gxShape container, gxShape test);
 
    Boolean
    GXContainsBoundsShape(const gxRectangle *container, gxShape test, long index);
 
    gxColor *
    GXConvertColor(gxColor *target, gxColorSpace space, gxColorSet aSet,
                   gxColorProfile profile);
 
    gxColor *
    GXCombineColor(gxColor *target, gxInk operand);
 
    Boolean
    GXCheckColor(const gxColor *source, gxColorSpace space, gxColorSet aSet,
                 gxColorProfile profile);
 
    gxShape
    GXCheckBitmapColor(gxShape source, const gxLongRectangle *area,
                       gxColorSpace space, gxColorSet aSet, gxColorProfile profile);
 
    Fixed
    GXGetHalftoneDeviceAngle(gxViewDevice source, const gxHalftone *data);
 
    long
    GXGetColorSetParts(gxColorSet source, long index, long count,
                       gxColorSpace *space, gxSetColor data[]);
 
    /* returns the glyph count */
    long
    GXGetGlyphParts(gxShape source, long index, long charCount, long *byteLength,
                    unsigned char text[], gxPoint positions[], long advanceBits[],
                    gxPoint tangents[], long *runCount, short styleRuns[],
                    gxStyle styles[]);
 
    long
    GXGetPathParts(gxShape source, long index, long count, gxPaths *data);
 
    long
    GXGetPictureParts(gxShape source, long index, long count, gxShape shapes[],
                      gxStyle styles[], gxInk inks[], gxTransform transforms[]);
 
    long
    GXGetPolygonParts(gxShape source, long index, long count, gxPolygons *data);
 
    gxShape
    GXGetShapeParts(gxShape source, long index, long count, gxShape destination);
 
    long
    GXGetTextParts(gxShape source, long index, long charCount, unsigned char text[]);
 
    void
    GXSetColorSetParts(gxColorSet target, long index, long oldCount, long newCount,
                       const gxSetColor data[]);
 
    void
    GXSetGlyphParts(gxShape source, long index, long oldCharCount,
                    long newCharCount, const unsigned char text[],
                    const gxPoint positions[], const long advanceBits[],
                    const gxPoint tangents[], const short styleRuns[],
                    const gxStyle styles[]);
 
    void
    GXSetPathParts(gxShape target, long index, long count, const gxPaths *data,
                   gxEditShapeFlag flags);
 
    void
    GXSetPictureParts(gxShape target, long index, long oldCount, long newCount,
                      const gxShape shapes[], const gxStyle styles[],
                      const gxInk inks[], const gxTransform transforms[]);
 
    void
    GXSetPolygonParts(gxShape target, long index, long count,
                      const gxPolygons *data, gxEditShapeFlag flags);
 
    void
    GXSetShapeParts(gxShape target, long index, long count, gxShape insert,
                    gxEditShapeFlag flags);
 
    void
    GXSetTextParts(gxShape target, long index, long oldCharCount, long newCharCount,
                   const unsigned char text[]);
 
    long
    GXGetShapePoints(gxShape source, long index, long count, gxPoint data[]);
 
    void
    GXSetShapePoints(gxShape target, long index, long count, const gxPoint data[]);
 
    long
    GXGetGlyphPositions(gxShape source, long index, long charCount, long advance[],
                        gxPoint positions[]);
 
    long
    GXGetGlyphTangents(gxShape source, long index, long charCount,
                       gxPoint tangents[]);
 
    void
    GXSetGlyphPositions(gxShape target, long index, long charCount,
                        const long advance[], const gxPoint positions[]);
 
    void
    GXSetGlyphTangents(gxShape target, long index, long charCount,
                       const gxPoint tangents[]);
 
    long
    GXGetGlyphMetrics(gxShape source, gxPoint glyphOrigins[],
                      gxRectangle boundingBoxes[], gxPoint sideBearings[]);
 
    void
    GXDifferenceShape(gxShape target, gxShape operand);
 
    void
    GXExcludeShape(gxShape target, gxShape operand);
 
    void
    GXIntersectShape(gxShape target, gxShape operand);
 
    void
    GXMapShape(gxShape target, const gxMapping *map);
 
    void
    GXMoveShape(gxShape target, Fixed deltaX, Fixed deltaY);
 
    void
    GXMoveShapeTo(gxShape target, Fixed x, Fixed y);
 
    void
    GXReverseDifferenceShape(gxShape target, gxShape operand);
 
    void
    GXRotateShape(gxShape target, Fixed degrees, Fixed xOffset, Fixed yOffset);
 
    void
    GXScaleShape(gxShape target, Fixed hScale, Fixed vScale, Fixed xOffset,
                 Fixed yOffset);
 
    void
    GXSkewShape(gxShape target, Fixed xSkew, Fixed ySkew, Fixed xOffset,
                Fixed yOffset);
 
    void
    GXUnionShape(gxShape target, gxShape operand);
 
    void
    GXDifferenceTransform(gxTransform target, gxShape operand);
 
    void
    GXExcludeTransform(gxTransform target, gxShape operand);
 
    void
    GXIntersectTransform(gxTransform target, gxShape operand);
 
    void
    GXMapTransform(gxTransform target, const gxMapping *map);
 
    void
    GXMoveTransform(gxTransform target, Fixed deltaX, Fixed deltaY);
 
    void
    GXMoveTransformTo(gxTransform target, Fixed x, Fixed y);
 
    void
    GXReverseDifferenceTransform(gxTransform target, gxShape operand);
 
    void
    GXRotateTransform(gxTransform target, Fixed degrees, Fixed xOffset,
                      Fixed yOffset);
 
    void
    GXScaleTransform(gxTransform target, Fixed hScale, Fixed vScale, Fixed xOffset,
                     Fixed yOffset);
 
    void
    GXSkewTransform(gxTransform target, Fixed xSkew, Fixed ySkew, Fixed xOffset,
                    Fixed yOffset);
 
    void
    GXUnionTransform(gxTransform target, gxShape operand);
 
    void
    GXBreakShape(gxShape target, long index);
 
    void
    GXChangedShape(gxShape target);
 
    gxShapePart
    GXHitTestShape(gxShape target, const gxPoint *test, gxHitTestInfo *result);
 
    gxShape
    GXHitTestDevice(gxShape target, gxViewPort port, gxViewDevice device,
                    const gxPoint *test, const gxPoint *tolerance);
 
    void
    GXInsetShape(gxShape target, Fixed inset);
 
    void
    GXInvertShape(gxShape target);
 
    void
    GXPrimitiveShape(gxShape target);
 
    void
    GXReduceShape(gxShape target, long contour);
 
    void
    GXReverseShape(gxShape target, long contour);
 
    void
    GXSimplifyShape(gxShape target);
 
    void
    GXLockColorProfile(gxColorProfile source);
 
    void
    GXUnlockColorProfile(gxColorProfile source);
 
    void *
    GXGetColorProfileStructure(gxColorProfile source, long *length);
 
    void
    GXFlattenShape(gxShape source, gxFlattenFlag flags, gxSpoolBlock *block);
 
    gxShape
    GXUnflattenShape(gxSpoolBlock *block, long count, const gxViewPort portList[]);
 
    void
    GXPostGraphicsNotice(gxGraphicsNotice notice);
 
    void
    GXIgnoreGraphicsNotice(gxGraphicsNotice notice);
 
    void
    GXPopGraphicsNotice(void);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if defined(__MWERKS__) && TARGET_CPU_68K
#pragma pop
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __GXGRAPHICS__ */