1HEADmaster

1 files changed, 1887 insertions, 0 deletions

diff --git a/common/quicktime_win32/GXTypes.h b/common/quicktime_win32/GXTypes.h
new file mode 100644
index 0000000..6c6fd69
--- /dev/null
+++ b/common/quicktime_win32/GXTypes.h
@@ -0,0 +1,1887 @@
+/*
+     File:       GXTypes.h
+ 
+     Contains:   QuickDraw GX object and constant definitions
+ 
+     Version:    Technology: Quickdraw GX 1.1
+                 Release:    QuickTime 7.3
+ 
+     Copyright:  (c) 2007 (c) 1994-1999 by Apple Computer, Inc., all rights reserved.
+ 
+     Bugs?:      For bug reports, consult the following page on
+                 the World Wide Web:
+ 
+                     http://developer.apple.com/bugreporter/
+ 
+*/
+#ifndef __GXTYPES__
+#define __GXTYPES__
+
+#ifndef __MACTYPES__
+#include <MacTypes.h>
+#endif
+
+#ifndef __MIXEDMODE__
+#include <MixedMode.h>
+#endif
+
+#ifndef __FIXMATH__
+#include <FixMath.h>
+#endif
+
+#ifndef __GXMATH__
+#include <GXMath.h>
+#endif
+
+#ifndef __IMAGECODEC__
+#include <ImageCodec.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
+
+
+
+typedef struct OpaquegxShape*           gxShape;
+typedef struct OpaquegxStyle*           gxStyle;
+typedef struct OpaquegxInk*             gxInk;
+typedef struct OpaquegxTransform*       gxTransform;
+typedef struct OpaquegxTag*             gxTag;
+typedef struct OpaquegxColorSet*        gxColorSet;
+typedef struct OpaquegxColorProfile*    gxColorProfile;
+typedef struct OpaquegxGraphicsClient*  gxGraphicsClient;
+typedef struct OpaquegxViewGroup*       gxViewGroup;
+typedef struct OpaquegxViewPort*        gxViewPort;
+typedef struct OpaquegxViewDevice*      gxViewDevice;
+
+typedef long                            gxColorSpace;
+/* gxShape enumerations */
+enum {
+  gxEmptyType                   = 1,
+  gxPointType                   = 2,
+  gxLineType                    = 3,
+  gxCurveType                   = 4,
+  gxRectangleType               = 5,
+  gxPolygonType                 = 6,
+  gxPathType                    = 7,
+  gxBitmapType                  = 8,
+  gxTextType                    = 9,
+  gxGlyphType                   = 10,
+  gxLayoutType                  = 11,
+  gxFullType                    = 12,
+  gxPictureType                 = 13
+};
+
+typedef long                            gxShapeType;
+enum {
+  gxNoFill                      = 0,
+  gxOpenFrameFill               = 1,
+  gxFrameFill                   = gxOpenFrameFill,
+  gxClosedFrameFill             = 2,
+  gxHollowFill                  = gxClosedFrameFill,
+  gxEvenOddFill                 = 3,
+  gxSolidFill                   = gxEvenOddFill,
+  gxWindingFill                 = 4,
+  gxInverseEvenOddFill          = 5,
+  gxInverseSolidFill            = gxInverseEvenOddFill,
+  gxInverseFill                 = gxInverseEvenOddFill,
+  gxInverseWindingFill          = 6
+};
+
+typedef long                            gxShapeFill;
+enum {
+  gxNoAttributes                = 0,
+  gxDirectShape                 = 0x0001,
+  gxRemoteShape                 = 0x0002,
+  gxCachedShape                 = 0x0004,
+  gxLockedShape                 = 0x0008,
+  gxGroupShape                  = 0x0010,
+  gxMapTransformShape           = 0x0020,
+  gxUniqueItemsShape            = 0x0040,
+  gxIgnorePlatformShape         = 0x0080,
+  gxNoMetricsGridShape          = 0x0100,
+  gxDiskShape                   = 0x0200,
+  gxMemoryShape                 = 0x0400
+};
+
+typedef long                            gxShapeAttribute;
+/* gxShape editing enumerations */
+enum {
+  gxBreakNeitherEdit            = 0,
+  gxBreakLeftEdit               = 0x0001,
+  gxBreakRightEdit              = 0x0002,
+  gxRemoveDuplicatePointsEdit   = 0x0004
+};
+
+/* if the new first (or last) point exactly matches the point before it in */
+/* the same contour, then remove it) */
+typedef long                            gxEditShapeFlag;
+enum {
+  gxSelectToEnd                 = -1
+};
+
+#define gxSetToNil  (void *)(-1)
+#define gxAnyNumber     1
+enum {
+  gxCounterclockwiseDirection   = 0,
+  gxClockwiseDirection          = 1
+};
+
+typedef long                            gxContourDirection;
+/* gxShape structures */
+/* The type 'gxPoint' is defined in "GXMath.h" */
+struct gxLine {
+  gxPoint             first;
+  gxPoint             last;
+};
+typedef struct gxLine                   gxLine;
+struct gxCurve {
+  gxPoint             first;
+  gxPoint             control;
+  gxPoint             last;
+};
+typedef struct gxCurve                  gxCurve;
+struct gxRectangle {
+  Fixed               left;
+  Fixed               top;
+  Fixed               right;
+  Fixed               bottom;
+};
+typedef struct gxRectangle              gxRectangle;
+struct gxPolygon {
+  long                vectors;
+  gxPoint             vector[1];
+};
+typedef struct gxPolygon                gxPolygon;
+struct gxPolygons {
+  long                contours;
+  gxPolygon           contour[1];
+};
+typedef struct gxPolygons               gxPolygons;
+/* Now defined in ImageCodec.i*/
+#if 0
+struct gxPath {
+  long                vectors;
+  long                controlBits[1];
+  gxPoint             vector[1];
+};
+typedef struct gxPath                   gxPath;
+struct gxPaths {
+  long                contours;
+  gxPath              contour[1];
+};
+typedef struct gxPaths                  gxPaths;
+#endif  /* 0 */
+
+struct gxBitmap {
+    char            *image;     /* pointer to pixels */
+    long            width;      /* width in pixels */
+    long            height;     /* height in pixels */
+    long            rowBytes;   /* width in bytes */
+    long            pixelSize;      /* physical bits per pixel */
+    gxColorSpace    space;
+    gxColorSet      set;
+    gxColorProfile  profile;
+};
+typedef struct gxBitmap gxBitmap;
+struct gxLongRectangle {
+  long                left;
+  long                top;
+  long                right;
+  long                bottom;
+};
+typedef struct gxLongRectangle          gxLongRectangle;
+/* gxStyle enumerations */
+enum {
+  gxCenterFrameStyle            = 0,
+  gxSourceGridStyle             = 0x0001,
+  gxDeviceGridStyle             = 0x0002,
+  gxInsideFrameStyle            = 0x0004,
+  gxOutsideFrameStyle           = 0x0008,
+  gxAutoInsetStyle              = 0x0010
+};
+
+
+typedef long                            gxStyleAttribute;
+enum {
+  gxBendDash                    = 0x0001,
+  gxBreakDash                   = 0x0002,
+  gxClipDash                    = 0x0004,
+  gxLevelDash                   = 0x0008,
+  gxAutoAdvanceDash             = 0x0010
+};
+
+typedef long                            gxDashAttribute;
+enum {
+  gxPortAlignPattern            = 0x0001,
+  gxPortMapPattern              = 0x0002
+};
+
+typedef long                            gxPatternAttribute;
+enum {
+  gxSharpJoin                   = 0x0000,
+  gxCurveJoin                   = 0x0001,
+  gxLevelJoin                   = 0x0002,
+  gxSnapJoin                    = 0x0004
+};
+
+typedef long                            gxJoinAttribute;
+enum {
+  gxLevelStartCap               = 0x0001,
+  gxLevelEndCap                 = 0x0002
+};
+
+typedef long                            gxCapAttribute;
+enum {
+  gxAutoAdvanceText             = 0x0001,
+  gxNoContourGridText           = 0x0002,
+  gxNoMetricsGridText           = 0x0004,
+  gxAnchorPointsText            = 0x0008,
+  gxVerticalText                = 0x0010,
+  gxNoOpticalScaleText          = 0x0020
+};
+
+typedef long                            gxTextAttribute;
+enum {
+  gxLeftJustify                 = 0,
+  gxCenterJustify               = fract1 / 2,
+  gxRightJustify                = fract1,
+  gxFillJustify                 = -1
+};
+
+enum {
+  gxUnderlineAdvanceLayer       = 0x0001, /* a gxLine is drawn through the advances */
+  gxSkipWhiteSpaceLayer         = 0x0002, /* except characters describing white space */
+  gxUnderlineIntervalLayer      = 0x0004, /* (+ gxStringLayer) a gxLine is drawn through the gaps between advances */
+  gxUnderlineContinuationLayer  = 0x0008, /* (+ gxStringLayer) join this underline with another face */
+  gxWhiteLayer                  = 0x0010, /* the layer draws to white instead of black */
+  gxClipLayer                   = 0x0020, /* the characters define a clip */
+  gxStringLayer                 = 0x0040 /* all characters in run are combined */
+};
+
+typedef long                            gxLayerFlag;
+/* gxStyle structures */
+struct gxFaceLayer {
+  gxShapeFill         outlineFill;            /* outline framed or filled */
+  gxLayerFlag         flags;                  /* various additional effects */
+  gxStyle             outlineStyle;           /* outline */
+  gxTransform         outlineTransform;       /* italic, condense, extend */
+  gxPoint             boldOutset;             /* bold */
+};
+typedef struct gxFaceLayer              gxFaceLayer;
+struct gxTextFace {
+  long                faceLayers;             /* layer to implement shadow */
+  gxMapping           advanceMapping;         /* algorithmic change to advance width */
+  gxFaceLayer         faceLayer[1];           /* zero or more face layers describing the face */
+};
+typedef struct gxTextFace               gxTextFace;
+struct gxJoinRecord {
+  gxJoinAttribute     attributes;
+  gxShape             join;
+  Fixed               miter;
+};
+typedef struct gxJoinRecord             gxJoinRecord;
+struct gxDashRecord {
+  gxDashAttribute     attributes;
+  gxShape             dash;                   /* similar to pattern, except rotated to gxLine slope */
+  Fixed               advance;                /* specifies repeating frequency of dash */
+  Fract               phase;                  /* specifies offset into the gxPath to start dashing */
+  Fixed               scale;                  /* specifies height of dash to be mapped to penWidth */
+};
+typedef struct gxDashRecord             gxDashRecord;
+struct gxPatternRecord {
+  gxPatternAttribute  attributes;
+  gxShape             pattern;
+  gxPoint             u;
+  gxPoint             v;
+};
+typedef struct gxPatternRecord          gxPatternRecord;
+struct gxCapRecord {
+  gxCapAttribute      attributes;
+  gxShape             startCap;
+  gxShape             endCap;
+};
+typedef struct gxCapRecord              gxCapRecord;
+
+/* gxInk enumerations */
+enum {
+  gxPortAlignDitherInk          = 0x0001,
+  gxForceDitherInk              = 0x0002,
+  gxSuppressDitherInk           = 0x0004,
+  gxSuppressHalftoneInk         = 0x0008
+};
+
+
+typedef long                            gxInkAttribute;
+enum {
+  gxNoMode                      = 0,
+  gxCopyMode                    = 1,
+  gxAddMode                     = 2,
+  gxBlendMode                   = 3,
+  gxMigrateMode                 = 4,
+  gxMinimumMode                 = 5,
+  gxMaximumMode                 = 6,
+  gxHighlightMode               = 7,
+  gxAndMode                     = 8,
+  gxOrMode                      = 9,
+  gxXorMode                     = 10,
+  gxRampAndMode                 = 11,
+  gxRampOrMode                  = 12,
+  gxRampXorMode                 = 13,
+  gxOverMode                    = 14,   /* Alpha channel modes          */
+  gxAtopMode                    = 15,   /* Note: In England = Beta channel modes   */
+  gxExcludeMode                 = 16,
+  gxFadeMode                    = 17
+};
+
+typedef unsigned char                   gxComponentMode;
+enum {
+  gxRejectSourceTransfer        = 0x0001, /* at least one component must be out of range       */
+  gxRejectDeviceTransfer        = 0x0002, /* at least one component must be out of range       */
+  gxSingleComponentTransfer     = 0x0004 /* duplicate gxTransferComponent[0] for all components in transfer */
+};
+
+typedef long                            gxTransferFlag;
+enum {
+  gxOverResultComponent         = 0x01, /* & result gxColor with 0xFFFF before clamping   */
+  gxReverseComponent            = 0x02  /* reverse source and device before moding       */
+};
+
+typedef unsigned char                   gxComponentFlag;
+/* gxInk structures */
+struct gxTransferComponent {
+  gxComponentMode     mode;                   /* how the component is operated upon */
+  gxComponentFlag     flags;                  /* flags for each component   */
+  gxColorValue        sourceMinimum;
+  gxColorValue        sourceMaximum;          /* input filter range */
+  gxColorValue        deviceMinimum;
+  gxColorValue        deviceMaximum;          /* output filter range */
+  gxColorValue        clampMinimum;
+  gxColorValue        clampMaximum;           /* output clamping range */
+  gxColorValue        operand;                /* ratio for blend, step for migrate, gxColor for highlight   */
+};
+typedef struct gxTransferComponent      gxTransferComponent;
+struct gxTransferMode {
+    gxColorSpace        space;          /* the gxColor-space the transfer mode is to operate in */
+    gxColorSet          set;
+    gxColorProfile      profile;
+    Fixed               sourceMatrix[5][4];
+    Fixed               deviceMatrix[5][4];
+    Fixed               resultMatrix[5][4];
+    gxTransferFlag      flags;
+    gxTransferComponent component[4];  /* how each component is operated upon           */
+};
+typedef struct gxTransferMode gxTransferMode;
+
+/* gxColor space enumerations */
+enum {
+  gxNoColorPacking              = 0x0000, /* 16 bits per channel */
+  gxAlphaSpace                  = 0x0080, /* space includes alpha channel */
+  gxWord5ColorPacking           = 0x0500, /* 5 bits per channel, right-justified */
+  gxLong8ColorPacking           = 0x0800, /* 8 bits per channel, right-justified */
+  gxLong10ColorPacking          = 0x0A00, /* 10 bits per channel, right-justified */
+  gxAlphaFirstPacking           = 0x1000 /* alpha channel is the first field in the packed space */
+};
+
+enum {
+  gxNoSpace                     = 0,
+  gxRGBSpace                    = 1,
+  gxCMYKSpace                   = 2,
+  gxHSVSpace                    = 3,
+  gxHLSSpace                    = 4,
+  gxYXYSpace                    = 5,
+  gxXYZSpace                    = 6,
+  gxLUVSpace                    = 7,
+  gxLABSpace                    = 8,
+  gxYIQSpace                    = 9,
+  gxNTSCSpace                   = gxYIQSpace,
+  gxPALSpace                    = gxYIQSpace,
+  gxGraySpace                   = 10,
+  gxIndexedSpace                = 11,
+  gxRGBASpace                   = gxRGBSpace + gxAlphaSpace,
+  gxGrayASpace                  = gxGraySpace + gxAlphaSpace,
+  gxRGB16Space                  = gxWord5ColorPacking + gxRGBSpace,
+  gxRGB32Space                  = gxLong8ColorPacking + gxRGBSpace,
+  gxARGB32Space                 = gxLong8ColorPacking + gxAlphaFirstPacking + gxRGBASpace,
+  gxCMYK32Space                 = gxLong8ColorPacking + gxCMYKSpace,
+  gxHSV32Space                  = gxLong10ColorPacking + gxHSVSpace,
+  gxHLS32Space                  = gxLong10ColorPacking + gxHLSSpace,
+  gxYXY32Space                  = gxLong10ColorPacking + gxYXYSpace,
+  gxXYZ32Space                  = gxLong10ColorPacking + gxXYZSpace,
+  gxLUV32Space                  = gxLong10ColorPacking + gxLUVSpace,
+  gxLAB32Space                  = gxLong10ColorPacking + gxLABSpace,
+  gxYIQ32Space                  = gxLong10ColorPacking + gxYIQSpace,
+  gxNTSC32Space                 = gxYIQ32Space,
+  gxPAL32Space                  = gxYIQ32Space
+};
+
+/* gxColor space structures */
+struct gxRGBColor {
+  gxColorValue        red;
+  gxColorValue        green;
+  gxColorValue        blue;
+};
+typedef struct gxRGBColor               gxRGBColor;
+struct gxRGBAColor {
+  gxColorValue        red;
+  gxColorValue        green;
+  gxColorValue        blue;
+  gxColorValue        alpha;
+};
+typedef struct gxRGBAColor              gxRGBAColor;
+struct gxHSVColor {
+  gxColorValue        hue;
+  gxColorValue        saturation;
+  gxColorValue        value;
+};
+typedef struct gxHSVColor               gxHSVColor;
+struct gxHLSColor {
+  gxColorValue        hue;
+  gxColorValue        lightness;
+  gxColorValue        saturation;
+};
+typedef struct gxHLSColor               gxHLSColor;
+struct gxCMYKColor {
+  gxColorValue        cyan;
+  gxColorValue        magenta;
+  gxColorValue        yellow;
+  gxColorValue        black;
+};
+typedef struct gxCMYKColor              gxCMYKColor;
+struct gxXYZColor {
+  gxColorValue        x;
+  gxColorValue        y;
+  gxColorValue        z;
+};
+typedef struct gxXYZColor               gxXYZColor;
+struct gxYXYColor {
+  gxColorValue        capY;
+  gxColorValue        x;
+  gxColorValue        y;
+};
+typedef struct gxYXYColor               gxYXYColor;
+struct gxLUVColor {
+  gxColorValue        l;
+  gxColorValue        u;
+  gxColorValue        v;
+};
+typedef struct gxLUVColor               gxLUVColor;
+struct gxLABColor {
+  gxColorValue        l;
+  gxColorValue        a;
+  gxColorValue        b;
+};
+typedef struct gxLABColor               gxLABColor;
+struct gxYIQColor {
+  gxColorValue        y;
+  gxColorValue        i;
+  gxColorValue        q;
+};
+typedef struct gxYIQColor               gxYIQColor;
+struct gxGrayAColor {
+  gxColorValue        gray;
+  gxColorValue        alpha;
+};
+typedef struct gxGrayAColor             gxGrayAColor;
+
+typedef long                            gxColorIndex;
+struct gxIndexedColor {
+    gxColorIndex    index;
+    gxColorSet      set;
+};
+typedef struct gxIndexedColor gxIndexedColor;
+struct gxColor {
+  gxColorSpace        space;
+  gxColorProfile      profile;
+  union {
+    gxCMYKColor         cmyk;
+    gxRGBColor          rgb;
+    gxRGBAColor         rgba;
+    gxHSVColor          hsv;
+    gxHLSColor          hls;
+    gxXYZColor          xyz;
+    gxYXYColor          yxy;
+    gxLUVColor          luv;
+    gxLABColor          lab;
+    gxYIQColor          yiq;
+    gxColorValue        gray;
+    gxGrayAColor        graya;
+    unsigned short      pixel16;
+    unsigned long       pixel32;
+    gxIndexedColor      indexed;
+    gxColorValue        component[4];
+  }                       element;
+};
+typedef struct gxColor                  gxColor;
+
+/* gxColorSet structures */
+union gxSetColor {
+  gxCMYKColor         cmyk;
+  gxRGBColor          rgb;
+  gxRGBAColor         rgba;
+  gxHSVColor          hsv;
+  gxHLSColor          hls;
+  gxXYZColor          xyz;
+  gxYXYColor          yxy;
+  gxLUVColor          luv;
+  gxLABColor          lab;
+  gxYIQColor          yiq;
+  gxColorValue        gray;
+  gxGrayAColor        graya;
+  unsigned short      pixel16;
+  unsigned long       pixel32;
+  gxColorValue        component[4];
+};
+typedef union gxSetColor                gxSetColor;
+/* gxTransform enumerations */
+/* parts of a gxShape considered in hit testing: */
+enum {
+  gxNoPart                      = 0,    /* (in order of evaluation) */
+  gxBoundsPart                  = 0x0001,
+  gxGeometryPart                = 0x0002,
+  gxPenPart                     = 0x0004,
+  gxCornerPointPart             = 0x0008,
+  gxControlPointPart            = 0x0010,
+  gxEdgePart                    = 0x0020,
+  gxJoinPart                    = 0x0040,
+  gxStartCapPart                = 0x0080,
+  gxEndCapPart                  = 0x0100,
+  gxDashPart                    = 0x0200,
+  gxPatternPart                 = 0x0400,
+  gxGlyphBoundsPart             = gxJoinPart,
+  gxGlyphFirstPart              = gxStartCapPart,
+  gxGlyphLastPart               = gxEndCapPart,
+  gxSideBearingPart             = gxDashPart,
+  gxAnyPart                     = gxBoundsPart | gxGeometryPart | gxPenPart | gxCornerPointPart | gxControlPointPart | gxEdgePart | gxJoinPart | gxStartCapPart | gxEndCapPart | gxDashPart | gxPatternPart
+};
+
+
+typedef long                            gxShapePart;
+/* gxTransform structures */
+struct gxHitTestInfo {
+  gxShapePart         what;                   /* which part of gxShape */
+  long                index;                  /* control gxPoint index */
+  Fixed               distance;               /* how far from gxPoint or outside of area click was */
+
+                                              /* these fields are only set by GXHitTestPicture */
+  gxShape             which;
+  gxShape             containerPicture;       /* picture which contains gxShape hit */
+  long                containerIndex;         /* the index within that picture  */
+  long                totalIndex;             /* the total index within the root picture */
+};
+typedef struct gxHitTestInfo            gxHitTestInfo;
+/* gxViewPort enumerations */
+enum {
+  gxGrayPort                    = 0x0001,
+  gxAlwaysGridPort              = 0x0002,
+  gxEnableMatchPort             = 0x0004
+};
+
+
+typedef long                            gxPortAttribute;
+/* gxViewDevice enumerations */
+enum {
+  gxDirectDevice                = 0x01, /* for the device gxBitmap baseAddr pointer */
+  gxRemoteDevice                = 0x02,
+  gxInactiveDevice              = 0x04
+};
+
+typedef long                            gxDeviceAttribute;
+enum {
+  gxRoundDot                    = 1,
+  gxSpiralDot                   = 2,
+  gxSquareDot                   = 3,
+  gxLineDot                     = 4,
+  gxEllipticDot                 = 5,
+  gxTriangleDot                 = 6,
+  gxDispersedDot                = 7,
+  gxCustomDot                   = 8
+};
+
+typedef long                            gxDotType;
+/* gxViewPort structures */
+enum {
+  gxNoTint                      = 0,
+  gxLuminanceTint               = 1,    /* use the luminance of the gxColor */
+  gxAverageTint                 = 2,    /* add all the components and divide by the number of components */
+  gxMixtureTint                 = 3,    /* find the closest gxColor on the axis between the foreground and background */
+  gxComponent1Tint              = 4,    /* use the value of the first component of the gxColor */
+  gxComponent2Tint              = 5,    /* ... etc. */
+  gxComponent3Tint              = 6,
+  gxComponent4Tint              = 7
+};
+
+typedef long                            gxTintType;
+struct gxHalftone {
+  Fixed               angle;
+  Fixed               frequency;
+  gxDotType           method;
+  gxTintType          tinting;
+  gxColor             dotColor;
+  gxColor             backgroundColor;
+  gxColorSpace        tintSpace;
+};
+typedef struct gxHalftone               gxHalftone;
+struct gxHalftoneMatrix {
+  Fixed               dpiX;                   /* intended resolution */
+  Fixed               dpiY;
+  long                width;                  /* width of matrix (in device pixels) */
+  long                height;                 /* height of matrix (in device pixels) */
+  long                tileShift;              /* shift amount (in samples) for rectangular tiling */
+  unsigned short      samples[1];             /* samples from 0..MAX(halftone tintSpace) */
+};
+typedef struct gxHalftoneMatrix         gxHalftoneMatrix;
+/* gxViewGroup enumerations */
+#define gxAllViewDevices        ((gxViewGroup) 0)
+#define gxScreenViewDevices     ((gxViewGroup) 1)
+/* graphics stream constants and structures */
+enum {
+  gxOpenReadSpool               = 1,
+  gxOpenWriteSpool              = 2,
+  gxReadSpool                   = 3,
+  gxWriteSpool                  = 4,
+  gxCloseSpool                  = 5
+};
+
+
+typedef long                            gxSpoolCommand;
+typedef unsigned char                   gxGraphicsOpcode;
+typedef struct gxSpoolBlock             gxSpoolBlock;
+typedef CALLBACK_API_C( long , gxSpoolProcPtr )(gxSpoolCommand command, gxSpoolBlock *block);
+typedef STACK_UPP_TYPE(gxSpoolProcPtr)                          gxSpoolUPP;
+struct gxSpoolBlock {
+  gxSpoolUPP          spoolProcedure;         /* these fields are read only */
+  void *              buffer;                 /* source/destination pointer to data */
+  long                bufferSize;             /* how many bytes for the system to read (flatten) / write (unflatten) */
+                                              /* these fields are written to (but are not read from) */
+  long                count;                  /* how many bytes for the caller to read (unflatten) /write (flatten) */
+  long                operationSize;          /* operation size (including operand byte) */
+  long                operationOffset;        /* the data offset, if any, within the current operation */
+  gxGraphicsOpcode    lastTypeOpcode;         /* type of last created object */
+  gxGraphicsOpcode    currentOperation;       /* operation emitted by flatten, or intrepreted by last unflatten */
+  gxGraphicsOpcode    currentOperand;         /* e.g., gxTransformTypeOpcode, gxInkTagOpcode */
+  unsigned char       compressed;             /* one of: gxTwoBitCompressionValues */
+};
+
+#if CALL_NOT_IN_CARBON
+/*
+ *  NewgxSpoolUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( gxSpoolUPP )
+NewgxSpoolUPP(gxSpoolProcPtr userRoutine);
+#if !OPAQUE_UPP_TYPES
+  enum { uppgxSpoolProcInfo = 0x000003F1 };  /* 4_bytes Func(4_bytes, 4_bytes) */
+  #ifdef __cplusplus
+    inline DEFINE_API_C(gxSpoolUPP) NewgxSpoolUPP(gxSpoolProcPtr userRoutine) { return (gxSpoolUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppgxSpoolProcInfo, GetCurrentArchitecture()); }
+  #else
+    #define NewgxSpoolUPP(userRoutine) (gxSpoolUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppgxSpoolProcInfo, GetCurrentArchitecture())
+  #endif
+#endif
+
+/*
+ *  DisposegxSpoolUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void )
+DisposegxSpoolUPP(gxSpoolUPP userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(void) DisposegxSpoolUPP(gxSpoolUPP userUPP) { DisposeRoutineDescriptor((UniversalProcPtr)userUPP); }
+  #else
+      #define DisposegxSpoolUPP(userUPP) DisposeRoutineDescriptor(userUPP)
+  #endif
+#endif
+
+/*
+ *  InvokegxSpoolUPP()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   available as macro/inline
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long )
+InvokegxSpoolUPP(
+  gxSpoolCommand  command,
+  gxSpoolBlock *  block,
+  gxSpoolUPP      userUPP);
+#if !OPAQUE_UPP_TYPES
+  #ifdef __cplusplus
+      inline DEFINE_API_C(long) InvokegxSpoolUPP(gxSpoolCommand command, gxSpoolBlock * block, gxSpoolUPP userUPP) { return (long)CALL_TWO_PARAMETER_UPP(userUPP, uppgxSpoolProcInfo, command, block); }
+  #else
+    #define InvokegxSpoolUPP(command, block, userUPP) (long)CALL_TWO_PARAMETER_UPP((userUPP), uppgxSpoolProcInfo, (command), (block))
+  #endif
+#endif
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
+    /* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
+    #define NewgxSpoolProc(userRoutine)                         NewgxSpoolUPP(userRoutine)
+    #define CallgxSpoolProc(userRoutine, command, block)        InvokegxSpoolUPP(command, block, userRoutine)
+#endif /* CALL_NOT_IN_CARBON */
+
+
+enum {
+  gxFontListFlatten             = 0x01, /* if set, generate a gxTag containing list of each gxFont referenced */
+  gxFontGlyphsFlatten           = 0x02, /* if set, generate a gxTag containing the list of glyphs referenced inside the gxFont */
+  gxFontVariationsFlatten       = 0x04, /* if set, append the gxTag with separate [variation] coordinates */
+  gxBitmapAliasFlatten          = 0x08  /* if set, open bitmap alias files and flatten out their image data */
+};
+
+
+typedef long                            gxFlattenFlag;
+/* gxGraphicsClient constants */
+#define gxGraphicsSystemClient      (gxGraphicsClient)(-1)
+enum {
+  gxStaticHeapClient            = 0x0001
+};
+
+typedef long                            gxClientAttribute;
+/* graphics patching constants */
+enum {
+  gxOriginalGraphicsFunction    = -1,
+  gxOriginalGraphicsIdentifier  = FOUR_CHAR_CODE('grfx')
+};
+
+struct gxBitmapDataSourceAlias {
+  unsigned long       fileOffset;             /* file offset (in bytes) of top-left pixel */
+  unsigned long       aliasRecordSize;        /* size of alias record below */
+  unsigned char       aliasRecord[1];         /* the actual alias record data */
+};
+typedef struct gxBitmapDataSourceAlias  gxBitmapDataSourceAlias;
+enum {
+  gxBitmapFileAliasTagType      = FOUR_CHAR_CODE('bfil'),
+  gxPICTFileAliasTagType        = FOUR_CHAR_CODE('pict'),
+  gxBitmapFileAliasImageValue   = 1L
+};
+
+typedef struct OpaquegxFont*            gxFont;
+enum {
+  gxNoPlatform                  = 0,
+  gxNoScript                    = 0,
+  gxNoLanguage                  = 0,
+  gxNoFontName                  = 0,
+  gxGlyphPlatform               = -1
+};
+
+enum {
+  gxUnicodePlatform             = 1,
+  gxMacintoshPlatform           = 2,
+  gxReservedPlatform            = 3,
+  gxMicrosoftPlatform           = 4,
+  gxCustomPlatform              = 5
+};
+
+
+typedef long                            gxFontPlatform;
+enum {
+  gxUnicodeDefaultSemantics     = 1,
+  gxUnicodeV1_1Semantics        = 2,
+  gxISO10646_1993Semantics      = 3
+};
+
+enum {
+  gxRomanScript                 = 1,
+  gxJapaneseScript              = 2,
+  gxTraditionalChineseScript    = 3,
+  gxChineseScript               = gxTraditionalChineseScript,
+  gxKoreanScript                = 4,
+  gxArabicScript                = 5,
+  gxHebrewScript                = 6,
+  gxGreekScript                 = 7,
+  gxCyrillicScript              = 8,
+  gxRussian                     = gxCyrillicScript,
+  gxRSymbolScript               = 9,
+  gxDevanagariScript            = 10,
+  gxGurmukhiScript              = 11,
+  gxGujaratiScript              = 12,
+  gxOriyaScript                 = 13,
+  gxBengaliScript               = 14,
+  gxTamilScript                 = 15,
+  gxTeluguScript                = 16,
+  gxKannadaScript               = 17,
+  gxMalayalamScript             = 18,
+  gxSinhaleseScript             = 19,
+  gxBurmeseScript               = 20,
+  gxKhmerScript                 = 21,
+  gxThaiScript                  = 22,
+  gxLaotianScript               = 23,
+  gxGeorgianScript              = 24,
+  gxArmenianScript              = 25,
+  gxSimpleChineseScript         = 26,
+  gxTibetanScript               = 27,
+  gxMongolianScript             = 28,
+  gxGeezScript                  = 29,
+  gxEthiopicScript              = gxGeezScript,
+  gxAmharicScript               = gxGeezScript,
+  gxSlavicScript                = 30,
+  gxEastEuropeanRomanScript     = gxSlavicScript,
+  gxVietnameseScript            = 31,
+  gxExtendedArabicScript        = 32,
+  gxSindhiScript                = gxExtendedArabicScript,
+  gxUninterpretedScript         = 33
+};
+
+enum {
+  gxMicrosoftSymbolScript       = 1,
+  gxMicrosoftStandardScript     = 2
+};
+
+enum {
+  gxCustom8BitScript            = 1,
+  gxCustom816BitScript          = 2,
+  gxCustom16BitScript           = 3
+};
+
+typedef long                            gxFontScript;
+enum {
+  gxEnglishLanguage             = 1,
+  gxFrenchLanguage              = 2,
+  gxGermanLanguage              = 3,
+  gxItalianLanguage             = 4,
+  gxDutchLanguage               = 5,
+  gxSwedishLanguage             = 6,
+  gxSpanishLanguage             = 7,
+  gxDanishLanguage              = 8,
+  gxPortugueseLanguage          = 9,
+  gxNorwegianLanguage           = 10,
+  gxHebrewLanguage              = 11,
+  gxJapaneseLanguage            = 12,
+  gxArabicLanguage              = 13,
+  gxFinnishLanguage             = 14,
+  gxGreekLanguage               = 15,
+  gxIcelandicLanguage           = 16,
+  gxMalteseLanguage             = 17,
+  gxTurkishLanguage             = 18,
+  gxCroatianLanguage            = 19,
+  gxTradChineseLanguage         = 20,
+  gxUrduLanguage                = 21,
+  gxHindiLanguage               = 22,
+  gxThaiLanguage                = 23,
+  gxKoreanLanguage              = 24,
+  gxLithuanianLanguage          = 25,
+  gxPolishLanguage              = 26,
+  gxHungarianLanguage           = 27,
+  gxEstonianLanguage            = 28,
+  gxLettishLanguage             = 29,
+  gxLatvianLanguage             = gxLettishLanguage,
+  gxSaamiskLanguage             = 30,
+  gxLappishLanguage             = gxSaamiskLanguage,
+  gxFaeroeseLanguage            = 31,
+  gxFarsiLanguage               = 32,
+  gxPersianLanguage             = gxFarsiLanguage,
+  gxRussianLanguage             = 33,
+  gxSimpChineseLanguage         = 34,
+  gxFlemishLanguage             = 35,
+  gxIrishLanguage               = 36,
+  gxAlbanianLanguage            = 37,
+  gxRomanianLanguage            = 38,
+  gxCzechLanguage               = 39,
+  gxSlovakLanguage              = 40,
+  gxSlovenianLanguage           = 41,
+  gxYiddishLanguage             = 42,
+  gxSerbianLanguage             = 43,
+  gxMacedonianLanguage          = 44,
+  gxBulgarianLanguage           = 45,
+  gxUkrainianLanguage           = 46,
+  gxByelorussianLanguage        = 47,
+  gxUzbekLanguage               = 48,
+  gxKazakhLanguage              = 49,
+  gxAzerbaijaniLanguage         = 50,
+  gxAzerbaijanArLanguage        = 51,
+  gxArmenianLanguage            = 52,
+  gxGeorgianLanguage            = 53,
+  gxMoldavianLanguage           = 54,
+  gxKirghizLanguage             = 55,
+  gxTajikiLanguage              = 56,
+  gxTurkmenLanguage             = 57,
+  gxMongolianLanguage           = 58,
+  gxMongolianCyrLanguage        = 59,
+  gxPashtoLanguage              = 60,
+  gxKurdishLanguage             = 61,
+  gxKashmiriLanguage            = 62,
+  gxSindhiLanguage              = 63,
+  gxTibetanLanguage             = 64,
+  gxNepaliLanguage              = 65,
+  gxSanskritLanguage            = 66,
+  gxMarathiLanguage             = 67,
+  gxBengaliLanguage             = 68,
+  gxAssameseLanguage            = 69,
+  gxGujaratiLanguage            = 70,
+  gxPunjabiLanguage             = 71,
+  gxOriyaLanguage               = 72,
+  gxMalayalamLanguage           = 73,
+  gxKannadaLanguage             = 74,
+  gxTamilLanguage               = 75,
+  gxTeluguLanguage              = 76,
+  gxSinhaleseLanguage           = 77,
+  gxBurmeseLanguage             = 78,
+  gxKhmerLanguage               = 79,
+  gxLaoLanguage                 = 80,
+  gxVietnameseLanguage          = 81,
+  gxIndonesianLanguage          = 82,
+  gxTagalogLanguage             = 83,
+  gxMalayRomanLanguage          = 84,
+  gxMalayArabicLanguage         = 85,
+  gxAmharicLanguage             = 86,
+  gxTigrinyaLanguage            = 87,
+  gxGallaLanguage               = 88,
+  gxOromoLanguage               = gxGallaLanguage,
+  gxSomaliLanguage              = 89,
+  gxSwahiliLanguage             = 90,
+  gxRuandaLanguage              = 91,
+  gxRundiLanguage               = 92,
+  gxChewaLanguage               = 93,
+  gxMalagasyLanguage            = 94,
+  gxEsperantoLanguage           = 95,
+  gxWelshLanguage               = 129,
+  gxBasqueLanguage              = 130,
+  gxCatalanLanguage             = 131,
+  gxLatinLanguage               = 132,
+  gxQuechuaLanguage             = 133,
+  gxGuaraniLanguage             = 134,
+  gxAymaraLanguage              = 135,
+  gxTatarLanguage               = 136,
+  gxUighurLanguage              = 137,
+  gxDzongkhaLanguage            = 138,
+  gxJavaneseRomLanguage         = 139,
+  gxSundaneseRomLanguage        = 140
+};
+
+typedef long                            gxFontLanguage;
+enum {
+  gxCopyrightFontName           = 1,
+  gxFamilyFontName              = 2,
+  gxStyleFontName               = 3,
+  gxUniqueFontName              = 4,
+  gxFullFontName                = 5,
+  gxVersionFontName             = 6,
+  gxPostscriptFontName          = 7,
+  gxTrademarkFontName           = 8,
+  gxManufacturerFontName        = 9,
+  gxLastReservedFontName        = 256
+};
+
+typedef long                            gxFontName;
+typedef long                            gxFontTableTag;
+typedef long                            gxFontVariationTag;
+typedef long                            gxFontFormatTag;
+typedef long                            gxFontStorageTag;
+typedef gxFontVariationTag              gxFontDescriptorTag;
+struct gxFontVariation {
+  gxFontVariationTag  name;
+  Fixed               value;
+};
+typedef struct gxFontVariation          gxFontVariation;
+typedef gxFontVariation                 gxFontDescriptor;
+struct gxFontFeatureSetting {
+  unsigned short      setting;
+  unsigned short      nameID;
+};
+typedef struct gxFontFeatureSetting     gxFontFeatureSetting;
+enum {
+  gxSystemFontAttribute         = 0x0001,
+  gxReadOnlyFontAttribute       = 0x0002
+};
+
+
+typedef long                            gxFontAttribute;
+enum {
+  gxMutuallyExclusiveFeature    = 0x00008000
+};
+
+typedef long                            gxFontFeatureFlag;
+typedef long                            gxFontFeature;
+enum {
+  gxResourceFontStorage         = FOUR_CHAR_CODE('rsrc'),
+  gxHandleFontStorage           = FOUR_CHAR_CODE('hndl'),
+  gxFileFontStorage             = FOUR_CHAR_CODE('bass'),
+  gxNfntFontStorage             = FOUR_CHAR_CODE('nfnt')
+};
+
+typedef void *                          gxFontStorageReference;
+typedef unsigned short                  gxGlyphcode;
+/* single glyph in a font */
+/* byte offset within backing store */
+typedef long                            gxByteOffset;
+/* The actual constants for feature types and selectors have been moved to a library. */
+typedef unsigned short                  gxRunFeatureType;
+typedef unsigned short                  gxRunFeatureSelector;
+/* If tracking is not desired, specify the following value in the track field in the
+        gxRunControls record (note that a track of 0 does *not* mean to turn tracking off;
+        rather, it means to use normal tracking). */
+enum {
+  gxNoTracking                  = gxNegativeInfinity
+};
+
+/* The special "gxNoStake" value is returned by the GXGetLayoutBreakOffset call to
+        indicate the absence of a character offset that is stable with respect to
+        metamorphosis and contextual kerning. */
+enum {
+  gxNoStake                     = -1
+};
+
+/* A glyph's behavior with respect to other glyphs on its line is defined in part by its
+        gxBaselineType. These types allow correct alignment of the baselines of all glyphs on
+        the line. */
+enum {
+  gxRomanBaseline               = 0,
+  gxIdeographicCenterBaseline   = 1,
+  gxIdeographicLowBaseline      = 2,
+  gxHangingBaseline             = 3,
+  gxMathBaseline                = 4,
+  gxLastBaseline                = 31,
+  gxNumberOfBaselineTypes       = gxLastBaseline + 1,
+  gxNoOverrideBaseline          = 255
+};
+
+typedef unsigned long                   gxBaselineType;
+typedef Fixed                           gxBaselineDeltas[32];
+/* gxJustificationPriority defines the point during the justification process at which a
+    glyph will begin to receive deltas before and after itself. */
+enum {
+  gxKashidaPriority             = 0,
+  gxWhiteSpacePriority          = 1,
+  gxInterCharPriority           = 2,
+  gxNullJustificationPriority   = 3,
+  gxNumberOfJustificationPriorities = 4
+};
+
+typedef unsigned char                   gxJustificationPriority;
+/* gxJustificationFlags are used to control which fields of a gxWidthDeltaRecord are to
+        be overridden and which are not if a gxPriorityJustificationOverride or
+        gxGlyphJustificationOverride (qq.v.) is specified. */
+enum {
+  gxOverridePriority            = 0x8000, /* use priority value from override */
+  gxOverrideLimits              = 0x4000, /* use limits values from override */
+  gxOverrideUnlimited           = 0x2000, /* use unlimited flag from override */
+  gxUnlimitedGapAbsorption      = 0x1000, /* glyph can take unlimited gap */
+  gxJustificationPriorityMask   = 0x000F, /* justification priority */
+  gxAllJustificationFlags       = (gxOverridePriority | gxOverrideLimits | gxOverrideUnlimited | gxUnlimitedGapAbsorption | gxJustificationPriorityMask)
+};
+
+typedef unsigned short                  gxJustificationFlags;
+/* The directional behavior of a glyph can be overridden using a gxDirectionOverride. */
+enum {
+  gxNoDirectionOverride         = 0,
+  gxImposeLeftToRight           = 1,
+  gxImposeRightToLeft           = 2,
+  gxImposeArabic                = 3
+};
+
+typedef unsigned short                  gxDirectionOverride;
+/* gxRunControlFlags describe the nonparametric layout options contained in a gxStyle. */
+enum {
+  gxNoCaretAngle                = 0x40000000,
+  gxImposeWidth                 = 0x20000000,
+  gxNoCrossKerning              = 0x10000000,
+  gxNoOpticalAlignment          = 0x08000000,
+  gxForceHanging                = 0x04000000,
+  gxNoSpecialJustification      = 0x02000000,
+  gxDirectionOverrideMask       = 0x00000003,
+  gxNoLigatureSplits            = (long)0x80000000
+};
+
+enum {
+  gxAllRunControlFlags          = (gxNoLigatureSplits | gxNoCaretAngle | gxImposeWidth | gxNoCrossKerning | gxNoOpticalAlignment | gxForceHanging | gxNoSpecialJustification | gxDirectionOverrideMask)
+};
+
+typedef unsigned long                   gxRunControlFlags;
+/* gxHighlightType is used to distinguish various highlighting methods, both in terms of
+        character offset based vs. visual based, and in terms of angled sides vs. non-angled
+        sides. */
+enum {
+  gxHighlightStraight           = 0,    /* straight-edged simple highlighting */
+  gxHighlightAverageAngle       = 1     /* takes average of two edge angles */
+};
+
+typedef unsigned long                   gxHighlightType;
+/* gxCaretType is used to control whether the caret that is returned from GXGetLayoutCaret
+        is a split caret or a (keyboard-syncronized) single caret. */
+enum {
+  gxSplitCaretType              = 0,    /* returns Mac-style split caret (default) */
+  gxLeftRightKeyboardCaret      = 1,    /* single caret in left-right position */
+  gxRightLeftKeyboardCaret      = 2     /* single caret in right-left position */
+};
+
+typedef unsigned long                   gxCaretType;
+/* gxLayoutOffsetState describes the characteristics of a given gxByteOffset in some
+        layout. It is returned by the GXGetOffsetGlyphs call. Note that the
+        gxOffsetInsideLigature value is returned in addition to the 8/16 (or invalid)
+        indication. */
+enum {
+  gxOffset8_8                   = 0,
+  gxOffset8_16                  = 1,
+  gxOffset16_8                  = 2,
+  gxOffset16_16                 = 3,
+  gxOffsetInvalid               = 4
+};
+
+enum {
+  gxOffsetInsideLigature        = 0x8000
+};
+
+typedef unsigned short                  gxLayoutOffsetState;
+/* gxLayoutOptionsFlags are single-bit flags contained in a gxLayoutOptions record. We
+    also define here some utility constants that are useful in setting various fields in
+    the gxLayoutOptions record. */
+enum {
+  gxNoLayoutOptions             = 0,
+  gxLineIsDisplayOnly           = 0x00000001,
+  gxKeepSpacesInMargin          = 0x00000002,
+  gxLimitReorderingToTwoLevels  = 0x00000004,
+  gxLineLeftEdgeNotAtMargin     = 0x00000008,
+  gxLineRightEdgeNotAtMargin    = 0x00000010,
+  gxAllLayoutOptionsFlags       = gxLineIsDisplayOnly | gxKeepSpacesInMargin | gxLimitReorderingToTwoLevels | gxLineLeftEdgeNotAtMargin | gxLineRightEdgeNotAtMargin,
+  gxMaxRunLevel                 = 15,
+  gxFlushLeft                   = 0,
+  gxFlushCenter                 = fract1 / 2,
+  gxFlushRight                  = fract1,
+  gxNoJustification             = 0,
+  gxFullJustification           = fract1
+};
+
+typedef unsigned long                   gxLayoutOptionsFlags;
+/* A gxRunFeature describes a feature and a level for that feature. */
+struct gxRunFeature {
+  gxRunFeatureType    featureType;
+  gxRunFeatureSelector  featureSelector;
+};
+typedef struct gxRunFeature             gxRunFeature;
+/* A gxWidthDeltaRecord contains all of the information needed to describe the behavior of one
+        class of glyphs during the justification process. */
+struct gxWidthDeltaRecord {
+  Fixed               beforeGrowLimit;        /* ems AW can grow by at most on LT */
+  Fixed               beforeShrinkLimit;      /* ems AW can shrink by at most on LT */
+  Fixed               afterGrowLimit;         /* ems AW can grow by at most on RB */
+  Fixed               afterShrinkLimit;       /* ems AW can shrink by at most on RB */
+  gxJustificationFlags  growFlags;            /* flags controlling grow case */
+  gxJustificationFlags  shrinkFlags;          /* flags controlling shrink case */
+};
+typedef struct gxWidthDeltaRecord       gxWidthDeltaRecord;
+/* A gxPriorityJustificationOverride contains an array of WidthDeltaRecords, one for each
+        gxJustificationPriority. */
+struct gxPriorityJustificationOverride {
+  gxWidthDeltaRecord  deltas[4];              /* overrides for each of the priorities */
+};
+typedef struct gxPriorityJustificationOverride gxPriorityJustificationOverride;
+/* A gxGlyphJustificationOverride contains a gxWidthDeltaRecord that is to be used for a
+        specific glyph in a specific run (this limitation is because glyphcodes vary by font). */
+struct gxGlyphJustificationOverride {
+  gxGlyphcode         glyph;
+  gxWidthDeltaRecord  override;
+};
+typedef struct gxGlyphJustificationOverride gxGlyphJustificationOverride;
+
+/* gxRunControls contains flags, shifts, imposed widths and overrides for a run. */
+/* NOTE: a value of "gxNoTracking" (see above) in track disables tracking */
+struct gxRunControls {
+  gxRunControlFlags   flags;
+  Fixed               beforeWithStreamShift;
+  Fixed               afterWithStreamShift;
+  Fixed               crossStreamShift;
+  Fixed               imposedWidth;
+  Fixed               track;
+  Fract               hangingInhibitFactor;
+  Fract               kerningInhibitFactor;
+  Fixed               decompositionAdjustmentFactor;
+  gxBaselineType      baselineType;
+};
+typedef struct gxRunControls            gxRunControls;
+/* A gxGlyphSubstitution describes one client-provided substitution that occurs after all
+        other automatic glyph changes have happened. */
+struct gxGlyphSubstitution {
+  gxGlyphcode         originalGlyph;          /* Whenever you see this glyph... */
+  gxGlyphcode         substituteGlyph;        /* ...change it to this one. */
+};
+typedef struct gxGlyphSubstitution      gxGlyphSubstitution;
+/* gxKerningAdjustmentFactors specify an adjustment to automatic kerning. The adjustment
+        is ax + b where x is the automatic kerning value, a is scaleFactor, and b is
+        adjustmentPointSizeFactor times the run's point size. */
+struct gxKerningAdjustmentFactors {
+  Fract               scaleFactor;
+  Fixed               adjustmentPointSizeFactor;
+};
+typedef struct gxKerningAdjustmentFactors gxKerningAdjustmentFactors;
+/* A gxKerningAdjustment identifies with- and cross-stream kerning adjustments
+        for specific glyph pairs. */
+struct gxKerningAdjustment {
+  gxGlyphcode         firstGlyph;
+  gxGlyphcode         secondGlyph;
+  gxKerningAdjustmentFactors  withStreamFactors;
+  gxKerningAdjustmentFactors  crossStreamFactors;
+};
+typedef struct gxKerningAdjustment      gxKerningAdjustment;
+/* A value of gxResetCrossStreamFactor in crossStreamFactors.adjustmentPointSizeFactor
+        will reset the cross-stream kerning to the baseline. */
+enum {
+  gxResetCrossStreamFactor      = gxNegativeInfinity
+};
+
+/* gxLayoutHitInfo contains the output from the GXHitTestLayout call. */
+struct gxLayoutHitInfo {
+  Fixed               firstPartialDist;
+  Fixed               lastPartialDist;
+  gxByteOffset        hitSideOffset;
+  gxByteOffset        nonHitSideOffset;
+  Boolean             leadingEdge;
+  Boolean             inLoose;
+};
+typedef struct gxLayoutHitInfo          gxLayoutHitInfo;
+/* A gxLineBaselineRecord contains the deltas from 0 to all the different baselines for
+        the layout. It can be filled via a call to GetBaselineDeltas (q.v.). */
+struct gxLineBaselineRecord {
+  gxBaselineDeltas    deltas;
+};
+typedef struct gxLineBaselineRecord     gxLineBaselineRecord;
+/* The gxLayoutOptions type contains information about the layout characteristics of the
+        whole line. */
+struct gxLayoutOptions {
+  Fixed               width;
+  Fract               flush;
+  Fract               just;
+  gxLayoutOptionsFlags  flags;
+  gxLineBaselineRecord * baselineRec;
+};
+typedef struct gxLayoutOptions          gxLayoutOptions;
+enum {
+  gxNewObjectOpcode             = 0x00, /* create new object */
+  gxSetDataOpcode               = 0x40, /* add reference to current object */
+  gxSetDefaultOpcode            = 0x80, /* replace current default with this object */
+  gxReservedOpcode              = 0xC0, /* (may be used in future expansion) */
+  gxNextOpcode                  = 0xFF  /* used by currentOperand field to say opcode is coming */
+};
+
+/* new object types (new object opcode) */
+enum {
+  gxHeaderTypeOpcode            = 0x00, /* byte following new object uses bottom 6 bits for type */
+                                        /* gxShape types use values 1 (gxEmptyType) through 13 (gxPictureType) */
+  gxStyleTypeOpcode             = 0x28,
+  gxInkTypeOpcode               = 0x29,
+  gxTransformTypeOpcode         = 0x2A,
+  gxColorProfileTypeOpcode      = 0x2B,
+  gxColorSetTypeOpcode          = 0x2C,
+  gxTagTypeOpcode               = 0x2D,
+  gxBitImageOpcode              = 0x2E,
+  gxFontNameTypeOpcode          = 0x2F,
+  gxTrailerTypeOpcode           = 0x3F
+};
+
+/* fields of objects (set data opcodes) */
+enum {
+  gxShapeAttributesOpcode       = 0,
+  gxShapeTagOpcode              = 1,
+  gxShapeFillOpcode             = 2
+};
+
+enum {
+  gxOmitPathPositionXMask       = 0xC0,
+  gxOmitPathPositionYMask       = 0x30,
+  gxOmitPathDeltaXMask          = 0x0C,
+  gxOmitPathDeltaYMask          = 0x03
+};
+
+enum {
+  gxOmitPathPositionXShift      = 6,
+  gxOmitPathPositionYShift      = 4,
+  gxOmitPathDeltaXShift         = 2,
+  gxOmitPathDeltaYShift         = 0
+};
+
+enum {
+  gxOmitBitmapImageMask         = 0xC0,
+  gxOmitBitmapWidthMask         = 0x30,
+  gxOmitBitmapHeightMask        = 0x0C,
+  gxOmitBitmapRowBytesMask      = 0x03
+};
+
+enum {
+  gxOmitBitmapImageShift        = 6,
+  gxOmitBitmapWidthShift        = 4,
+  gxOmitBitmapHeightShift       = 2,
+  gxOmitBitmapRowBytesShift     = 0
+};
+
+enum {
+  gxOmitBitmapPixelSizeMask     = 0xC0,
+  gxOmitBitmapSpaceMask         = 0x30,
+  gxOmitBitmapSetMask           = 0x0C,
+  gxOmitBitmapProfileMask       = 0x03
+};
+
+enum {
+  gxOmitBitmapPixelSizeShift    = 6,
+  gxOmitBitmapSpaceShift        = 4,
+  gxOmitBitmapSetShift          = 2,
+  gxOmitBitmapProfileShift      = 0
+};
+
+enum {
+  gxOmitBitmapPositionXMask     = 0xC0,
+  gxOmitBitmapPositionYMask     = 0x30
+};
+
+enum {
+  gxOmitBitmapPositionXShift    = 6,
+  gxOmitBitmapPositionYShift    = 4
+};
+
+enum {
+  gxOmitBitImageRowBytesMask    = 0xC0,
+  gxOmitBitImageHeightMask      = 0x30,
+  gxOmitBitImageDataMask        = 0x08
+};
+
+enum {
+  gxOmitBitImageRowBytesShift   = 6,
+  gxOmitBitImageHeightShift     = 4,
+  gxOmitBitImageDataShift       = 3
+};
+
+enum {
+  gxCopyBitImageBytesOpcode     = 0x00,
+  gxRepeatBitImageBytesOpcode   = 0x40,
+  gxLookupBitImageBytesOpcode   = 0x80,
+  gxRepeatBitImageScanOpcode    = 0xC0
+};
+
+enum {
+  gxOmitTextCharactersMask      = 0xC0,
+  gxOmitTextPositionXMask       = 0x30,
+  gxOmitTextPositionYMask       = 0x0C,
+  gxOmitTextDataMask            = 0x02
+};
+
+enum {
+  gxOmitTextCharactersShift     = 6,
+  gxOmitTextPositionXShift      = 4,
+  gxOmitTextPositionYShift      = 2,
+  gxOmitTextDataShift           = 1
+};
+
+enum {
+  gxOmitGlyphCharactersMask     = 0xC0,
+  gxOmitGlyphLengthMask         = 0x30,
+  gxOmitGlyphRunNumberMask      = 0x0C,
+  gxOmitGlyphOnePositionMask    = 0x02,
+  gxOmitGlyphDataMask           = 0x01
+};
+
+enum {
+  gxOmitGlyphCharactersShift    = 6,
+  gxOmitGlyphLengthShift        = 4,
+  gxOmitGlyphRunNumberShift     = 2,
+  gxOmitGlyphOnePositionShift   = 1,
+  gxOmitGlyphDataShift          = 0
+};
+
+enum {
+  gxOmitGlyphPositionsMask      = 0xC0,
+  gxOmitGlyphAdvancesMask       = 0x20,
+  gxOmitGlyphTangentsMask       = 0x18,
+  gxOmitGlyphRunsMask           = 0x04,
+  gxOmitGlyphStylesMask         = 0x03
+};
+
+enum {
+  gxOmitGlyphPositionsShift     = 6,
+  gxOmitGlyphAdvancesShift      = 5,
+  gxOmitGlyphTangentsShift      = 3,
+  gxOmitGlyphRunsShift          = 2,
+  gxOmitGlyphStylesShift        = 0
+};
+
+enum {
+  gxOmitLayoutLengthMask        = 0xC0,
+  gxOmitLayoutPositionXMask     = 0x30,
+  gxOmitLayoutPositionYMask     = 0x0C,
+  gxOmitLayoutDataMask          = 0x02
+};
+
+enum {
+  gxOmitLayoutLengthShift       = 6,
+  gxOmitLayoutPositionXShift    = 4,
+  gxOmitLayoutPositionYShift    = 2,
+  gxOmitLayoutDataShift         = 1
+};
+
+enum {
+  gxOmitLayoutWidthMask         = 0xC0,
+  gxOmitLayoutFlushMask         = 0x30,
+  gxOmitLayoutJustMask          = 0x0C,
+  gxOmitLayoutOptionsMask       = 0x03
+};
+
+enum {
+  gxOmitLayoutWidthShift        = 6,
+  gxOmitLayoutFlushShift        = 4,
+  gxOmitLayoutJustShift         = 2,
+  gxOmitLayoutOptionsShift      = 0
+};
+
+enum {
+  gxOmitLayoutStyleRunNumberMask = 0xC0,
+  gxOmitLayoutLevelRunNumberMask = 0x30,
+  gxOmitLayoutHasBaselineMask   = 0x08,
+  gxOmitLayoutStyleRunsMask     = 0x04,
+  gxOmitLayoutStylesMask        = 0x03
+};
+
+enum {
+  gxOmitLayoutStyleRunNumberShift = 6,
+  gxOmitLayoutLevelRunNumberShift = 4,
+  gxOmitLayoutHasBaselineShift  = 3,
+  gxOmitLayoutStyleRunsShift    = 2,
+  gxOmitLayoutStylesShift       = 0
+};
+
+enum {
+  gxOmitLayoutLevelRunsMask     = 0x80,
+  gxOmitLayoutLevelsMask        = 0x40
+};
+
+enum {
+  gxOmitLayoutLevelRunsShift    = 7,
+  gxOmitLayoutLevelsShift       = 6
+};
+
+enum {
+  gxInkAttributesOpcode         = 0,
+  gxInkTagOpcode                = 1,
+  gxInkColorOpcode              = 2,
+  gxInkTransferModeOpcode       = 3
+};
+
+enum {
+  gxOmitColorsSpaceMask         = 0xC0,
+  gxOmitColorsProfileMask       = 0x30,
+  gxOmitColorsComponentsMask    = 0x0F,
+  gxOmitColorsIndexMask         = 0x0C,
+  gxOmitColorsIndexSetMask      = 0x03
+};
+
+enum {
+  gxOmitColorsSpaceShift        = 6,
+  gxOmitColorsProfileShift      = 4,
+  gxOmitColorsComponentsShift   = 0,
+  gxOmitColorsIndexShift        = 2,
+  gxOmitColorsIndexSetShift     = 0
+};
+
+enum {
+  gxOmitTransferSpaceMask       = 0xC0,
+  gxOmitTransferSetMask         = 0x30,
+  gxOmitTransferProfileMask     = 0x0C
+};
+
+enum {
+  gxOmitTransferSpaceShift      = 6,
+  gxOmitTransferSetShift        = 4,
+  gxOmitTransferProfileShift    = 2
+};
+
+enum {
+  gxOmitTransferSourceMatrixMask = 0xC0,
+  gxOmitTransferDeviceMatrixMask = 0x30,
+  gxOmitTransferResultMatrixMask = 0x0C,
+  gxOmitTransferFlagsMask       = 0x03
+};
+
+enum {
+  gxOmitTransferSourceMatrixShift = 6,
+  gxOmitTransferDeviceMatrixShift = 4,
+  gxOmitTransferResultMatrixShift = 2,
+  gxOmitTransferFlagsShift      = 0
+};
+
+enum {
+  gxOmitTransferComponentModeMask = 0x80,
+  gxOmitTransferComponentFlagsMask = 0x40,
+  gxOmitTransferComponentSourceMinimumMask = 0x30,
+  gxOmitTransferComponentSourceMaximumMask = 0x0C,
+  gxOmitTransferComponentDeviceMinimumMask = 0x03
+};
+
+enum {
+  gxOmitTransferComponentModeShift = 7,
+  gxOmitTransferComponentFlagsShift = 6,
+  gxOmitTransferComponentSourceMinimumShift = 4,
+  gxOmitTransferComponentSourceMaximumShift = 2,
+  gxOmitTransferComponentDeviceMinimumShift = 0
+};
+
+enum {
+  gxOmitTransferComponentDeviceMaximumMask = 0xC0,
+  gxOmitTransferComponentClampMinimumMask = 0x30,
+  gxOmitTransferComponentClampMaximumMask = 0x0C,
+  gxOmitTransferComponentOperandMask = 0x03
+};
+
+enum {
+  gxOmitTransferComponentDeviceMaximumShift = 6,
+  gxOmitTransferComponentClampMinimumShift = 4,
+  gxOmitTransferComponentClampMaximumShift = 2,
+  gxOmitTransferComponentOperandShift = 0
+};
+
+enum {
+  gxStyleAttributesOpcode       = 0,
+  gxStyleTagOpcode              = 1,
+  gxStyleCurveErrorOpcode       = 2,
+  gxStylePenOpcode              = 3,
+  gxStyleJoinOpcode             = 4,
+  gxStyleDashOpcode             = 5,
+  gxStyleCapsOpcode             = 6,
+  gxStylePatternOpcode          = 7,
+  gxStyleTextAttributesOpcode   = 8,
+  gxStyleTextSizeOpcode         = 9,
+  gxStyleFontOpcode             = 10,
+  gxStyleTextFaceOpcode         = 11,
+  gxStylePlatformOpcode         = 12,
+  gxStyleFontVariationsOpcode   = 13,
+  gxStyleRunControlsOpcode      = 14,
+  gxStyleRunPriorityJustOverrideOpcode = 15,
+  gxStyleRunGlyphJustOverridesOpcode = 16,
+  gxStyleRunGlyphSubstitutionsOpcode = 17,
+  gxStyleRunFeaturesOpcode      = 18,
+  gxStyleRunKerningAdjustmentsOpcode = 19,
+  gxStyleJustificationOpcode    = 20
+};
+
+enum {
+  gxOmitDashAttributesMask      = 0xC0,
+  gxOmitDashShapeMask           = 0x30,
+  gxOmitDashAdvanceMask         = 0x0C,
+  gxOmitDashPhaseMask           = 0x03
+};
+
+enum {
+  gxOmitDashAttributesShift     = 6,
+  gxOmitDashShapeShift          = 4,
+  gxOmitDashAdvanceShift        = 2,
+  gxOmitDashPhaseShift          = 0
+};
+
+enum {
+  gxOmitDashScaleMask           = 0xC0
+};
+
+enum {
+  gxOmitDashScaleShift          = 6
+};
+
+enum {
+  gxOmitPatternAttributesMask   = 0xC0,
+  gxOmitPatternShapeMask        = 0x30,
+  gxOmitPatternUXMask           = 0x0C,
+  gxOmitPatternUYMask           = 0x03
+};
+
+enum {
+  gxOmitPatternAttributesShift  = 6,
+  gxOmitPatternShapeShift       = 4,
+  gxOmitPatternUXShift          = 2,
+  gxOmitPatternUYShift          = 0
+};
+
+enum {
+  gxOmitPatternVXMask           = 0xC0,
+  gxOmitPatternVYMask           = 0x30
+};
+
+enum {
+  gxOmitPatternVXShift          = 6,
+  gxOmitPatternVYShift          = 4
+};
+
+enum {
+  gxOmitJoinAttributesMask      = 0xC0,
+  gxOmitJoinShapeMask           = 0x30,
+  gxOmitJoinMiterMask           = 0x0C
+};
+
+enum {
+  gxOmitJoinAttributesShift     = 6,
+  gxOmitJoinShapeShift          = 4,
+  gxOmitJoinMiterShift          = 2
+};
+
+enum {
+  gxOmitCapAttributesMask       = 0xC0,
+  gxOmitCapStartShapeMask       = 0x30,
+  gxOmitCapEndShapeMask         = 0x0C
+};
+
+enum {
+  gxOmitCapAttributesShift      = 6,
+  gxOmitCapStartShapeShift      = 4,
+  gxOmitCapEndShapeShift        = 2
+};
+
+enum {
+  gxOmitFaceLayersMask          = 0xC0,
+  gxOmitFaceMappingMask         = 0x30
+};
+
+enum {
+  gxOmitFaceLayersShift         = 6,
+  gxOmitFaceMappingShift        = 4
+};
+
+enum {
+  gxOmitFaceLayerFillMask       = 0xC0,
+  gxOmitFaceLayerFlagsMask      = 0x30,
+  gxOmitFaceLayerStyleMask      = 0x0C,
+  gxOmitFaceLayerTransformMask  = 0x03
+};
+
+enum {
+  gxOmitFaceLayerFillShift      = 6,
+  gxOmitFaceLayerFlagsShift     = 4,
+  gxOmitFaceLayerStyleShift     = 2,
+  gxOmitFaceLayerTransformShift = 0
+};
+
+enum {
+  gxOmitFaceLayerBoldXMask      = 0xC0,
+  gxOmitFaceLayerBoldYMask      = 0x30
+};
+
+enum {
+  gxOmitFaceLayerBoldXShift     = 6,
+  gxOmitFaceLayerBoldYShift     = 4
+};
+
+enum {
+  gxColorSetReservedOpcode      = 0,
+  gxColorSetTagOpcode           = 1
+};
+
+enum {
+  gxColorProfileReservedOpcode  = 0,
+  gxColorProfileTagOpcode       = 1
+};
+
+enum {
+  gxTransformReservedOpcode     = 0,
+  gxTransformTagOpcode          = 1,
+  gxTransformClipOpcode         = 2,
+  gxTransformMappingOpcode      = 3,
+  gxTransformPartMaskOpcode     = 4,
+  gxTransformToleranceOpcode    = 5
+};
+
+enum {
+  gxTypeOpcode                  = 0,
+  gxSizeOpcode                  = 1
+};
+
+/* used by currentOperand when currentOperation is gxNextOpcode */
+/*    format of top byte:
+xx yyyyyy   xx == 0x00, 0x40, 0x80, 0xC0: defines graphics operation (see gxGraphicsOperationOpcode)
+            yyyyyy == size of operation in bytes
+            if (yyyyyy == 0), byte size follows. If byte following == 0, word size follows; if == 0, long follows
+            word and long, if present, are specified in high-endian order (first byte is largest magnitude)
+            
+format of byte following size specifiers, if any:
+xx yyyyyy   xx == 0x00, 0x40, 0x80, 0xC0: defines compression level (0 == none, 0xC0 == most)
+            exact method of compression is defined by type of data
+            yyyyyy == data type selector (0 to 63): see gxGraphicsNewOpcode, __DataOpcode
+*/
+enum {
+  gxOpcodeShift                 = 6,
+  gxObjectSizeMask              = 0x3F,
+  gxCompressionShift            = 6,
+  gxObjectTypeMask              = 0x3F,
+  gxBitImageOpcodeMask          = 0xC0,
+  gxBitImageCountMask           = 0x3F,
+  gxBitImageOpcodeShift         = 6
+};
+
+enum {
+  gxNoCompression               = 0,
+  gxWordCompression             = 1,
+  gxByteCompression             = 2,
+  gxOmitCompression             = 3,
+  gxCompressionMask             = 0x03
+};
+
+/*    the following structures define how primitives without a public geometry
+    are stored (their format mirrors that of the New call to create them)   */
+struct gxFlatFontName {
+  unsigned char       name;                   /* gxFontName */
+  unsigned char       platform;               /* gxFontPlatform */
+  unsigned char       script;                 /* gxFontScript */
+  unsigned char       language;               /* gxFontLanguage */
+  short               length;                 /* byte length */
+};
+typedef struct gxFlatFontName           gxFlatFontName;
+enum {
+  gxFlatFontListItemTag         = FOUR_CHAR_CODE('flst')
+};
+
+struct gxFlatFontListItem {
+  gxFont              fontID;                 /*** if we get rid of this, remove #include "font types.h", above */
+  unsigned char       name;                   /* gxFontName */
+  unsigned char       platform;               /* gxFontPlatform */
+  unsigned char       script;                 /* gxFontScript */
+  unsigned char       language;               /* gxFontLanguage */
+  short               length;                 /* byte length of the name that follows */
+  unsigned short      glyphCount;             /* CountFontGlyphs or 0 if gxFontGlyphsFlatten is false */
+  unsigned short      axisCount;              /* CountFontVariations or 0 if gxFontVariationsFlatten is false */
+  unsigned short      variationCount;         /* number of bitsVariationPairs that follow the (optional) glyphBits */
+};
+typedef struct gxFlatFontListItem       gxFlatFontListItem;
+struct gxFlatFontList {
+  long                count;
+  gxFlatFontListItem  items[1];
+};
+typedef struct gxFlatFontList           gxFlatFontList;
+struct gxFlattenHeader {
+  Fixed               version;
+  unsigned char       flatFlags;
+  SInt8               padding;
+};
+typedef struct gxFlattenHeader          gxFlattenHeader;
+enum {
+  gxOmitPictureShapeMask        = 0xC0,
+  gxOmitOverrideStyleMask       = 0x30,
+  gxOmitOverrideInkMask         = 0x0C,
+  gxOmitOverrideTransformMask   = 0x03
+};
+
+enum {
+  gxOmitPictureShapeShift       = 0x06,
+  gxOmitOverrideStyleShift      = 0x04,
+  gxOmitOverrideInkShift        = 0x02,
+  gxOmitOverrideTransformShift  = 0x00
+};
+
+enum {
+  gxPostScriptTag               = FOUR_CHAR_CODE('post'),
+  gxPostControlTag              = FOUR_CHAR_CODE('psct')
+};
+
+enum {
+  gxNoSave                      = 1,    /* don't do save-restore around PS data */
+  gxPSContinueNext              = 2     /* next shape is continuation of this shape's PS -- only obeyed if gxNoSave is true */
+};
+
+struct gxPostControl {
+  long                flags;                  /* PostScript state flags */
+};
+typedef struct gxPostControl            gxPostControl;
+enum {
+  gxDashSynonymTag              = FOUR_CHAR_CODE('sdsh')
+};
+
+struct gxDashSynonym {
+  long                size;                   /* number of elements in array */
+  Fixed               dashLength[1];          /* Array of dash lengths */
+};
+typedef struct gxDashSynonym            gxDashSynonym;
+enum {
+  gxLineCapSynonymTag           = FOUR_CHAR_CODE('lcap')
+};
+
+enum {
+  gxButtCap                     = 0,
+  gxRoundCap                    = 1,
+  gxSquareCap                   = 2,
+  gxTriangleCap                 = 3
+};
+
+/* gxLine cap type */
+
+typedef long                            gxLineCapSynonym;
+enum {
+  gxCubicSynonymTag             = FOUR_CHAR_CODE('cubx')
+};
+
+enum {
+  gxIgnoreFlag                  = 0x0000, /* Ignore this word, get next one */
+  gxLineToFlag                  = 0x0001, /* Draw a gxLine to gxPoint following this flag */
+  gxCurveToFlag                 = 0x0002, /* Draw a gxCurve through the 3 points following this flag */
+  gxMoveToFlag                  = 0x0003, /* Start a new contour at the gxPoint following this flag */
+  gxClosePathFlag               = 0x0004 /* Close the contour */
+};
+
+typedef long                            gxCubicSynonym;
+enum {
+  gxCubicInstructionMask        = 0x000F /* low four bits are gxPoint instructions */
+};
+
+/* Low four bits are instruction (moveto, lineto, curveto, closepath) */
+typedef short                           gxCubicSynonymFlags;
+enum {
+  gxPatternSynonymTag           = FOUR_CHAR_CODE('ptrn')
+};
+
+enum {
+  gxHatch                       = 0,
+  gxCrossHatch                  = 1
+};
+
+struct gxPatternSynonym {
+  long                patternType;            /* one of the gxPatterns: gxHatch or gxCrossHatch */
+  Fixed               angle;                  /* angle at which pattern is drawn */
+  Fixed               spacing;                /* distance between two parallel pattern lines */
+  Fixed               thickness;              /* thickness of the pattern */
+  gxPoint             anchorPoint;            /* gxPoint with with respect to which pattern position is calculated */
+};
+typedef struct gxPatternSynonym         gxPatternSynonym;
+enum {
+  gxURLTag                      = FOUR_CHAR_CODE('urlt')
+};
+
+
+#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 /* __GXTYPES__ */
+