ATSUnicode.h

Go to the documentation of this file.

 
#ifndef __ATSUNICODE__
#define __ATSUNICODE__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __MACMEMORY__
#include <MacMemory.h>
#endif
 
#ifndef __ATSLAYOUTTYPES__
#include <ATSLayoutTypes.h>
#endif
 
#ifndef __FONTS__
#include <Fonts.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#ifndef __SFNTTYPES__
#include <SFNTTypes.h>
#endif
 
#ifndef __SFNTLAYOUTTYPES__
#include <SFNTLayoutTypes.h>
#endif
 
#ifndef __TEXTCOMMON__
#include <TextCommon.h>
#endif
 
#ifndef __ATSTYPES__
#include <ATSTypes.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
 
  /********************************/
  /*  Types and related constants */
  /********************************/
  typedef Fixed ATSUTextMeasurement;
  typedef FMFont ATSUFontID;
  typedef UInt16 ATSUFontFeatureType;
  typedef UInt16 ATSUFontFeatureSelector;
  typedef FourCharCode ATSUFontVariationAxis;
  typedef Fixed ATSUFontVariationValue;
  typedef struct OpaqueATSUTextLayout *ATSUTextLayout;
  typedef struct OpaqueATSUStyle *ATSUStyle;
  typedef struct OpaqueATSUFontFallbacks *ATSUFontFallbacks;
  typedef UInt32 ATSUAttributeTag;
  enum
  {
    /*    Layout and Line Control Attribute Tags*/
    kATSULineWidthTag = 1L,     /*    Type:       ATSUTextMeasurement*/
                                /*    Default value: 0*/
    kATSULineRotationTag = 2L,  /*    Type:       Fixed (fixed value in degrees in
                                   right-handed coordinate system)*/
                                /*    Default value: 0*/
    kATSULineDirectionTag = 3L, /*    Type:       Boolean; values 0 or 1 (see
                                   below for value identities)*/
    /*    Default value: GetSysDirection() ? kATSURightToLeftBaseDirection :
       kATSULeftToRightBaseDirection*/
    kATSULineJustificationFactorTag =
        4L,                          /*    Type:       Fract between 0 and 1*/
                                     /*    Default value: kATSUNoJustification*/
    kATSULineFlushFactorTag = 5L,    /*    Type:       Fract between 0 and 1 */
                                     /*    Default value: kATSUStartAlignment*/
    kATSULineBaselineValuesTag = 6L, /*    Type:       BslnBaselineRecord*/
    /*    Default value: All zeros.  Calculated from other style attributes (e.g.,
       font and point size)*/
    kATSULineLayoutOptionsTag =
        7L,                        /*    Type:       ATSLineLayoutOptions (see ATSLayoutTypes.h)*/
                                   /*    Default value: kATSLineNoLayoutOptions - other options listed in
                                      ATSLayoutTypes.h*/
    kATSULineAscentTag = 8L,       /*    Type:       ATSUTextMeasurement*/
                                   /*    Default value: kATSUseLineHeight*/
    kATSULineDescentTag = 9L,      /*    Type:       ATSUTextMeasurement*/
                                   /*    Default value: kATSUseLineHeight*/
    kATSULineLangRegionTag = 10L,  /*    Type:       RegionCode - region values
                                      listed in script.h interface file*/
                                   /*    Default value: kTextRegionDontCare*/
    kATSULineTextLocatorTag = 11L, /*    Type:       TextBreakLocatorRef*/
    /*    Default value: NULL - set Region derived locator or the default Text
       Utilities locator*/
    kATSULineTruncationTag = 12L,    /*    Type:       ATSULineTruncation*/
                                     /*    Default value: kATSUTruncateNone                                  */
    kATSULineFontFallbacksTag = 13L, /*    Type:       ATSUFontFallbacks*/
    /*    Default value: globally set font fallbacks using the
       ATSUSetFontFallbacks                                                     */
    kATSUMaxLineTag = 14L,      /*    This is just for convenience - the upper limit of
                                   the ATSUTextLayout attribute tags*/
                                /* obsolete layout tags */
    kATSULineLanguageTag = 10L, /*    Use kATSULineLangRegionTag           */
                                /*    Run Style Attribute Tags*/
                                /* QuickDraw compatibility tags */
    kATSUQDBoldfaceTag = 256L,  /*    Type:       Boolean    */
                                /*    Default value: false*/
    kATSUQDItalicTag = 257L,    /*    Type:       Boolean       */
                                /*    Default value: false*/
    kATSUQDUnderlineTag = 258L, /*    Type:       Boolean    */
                                /*    Default value: false*/
    kATSUQDCondensedTag = 259L, /*    Type:       Boolean    */
                                /*    Default value: false*/
    kATSUQDExtendedTag = 260L,  /*    Type:       Boolean    */
                                /*    Default value: false*/
                                /* Common run tags */
    kATSUFontTag = 261L,        /*    Type:       ATSUFontID */
    /*    Default value: GetScriptVariable( smSystemScript, smScriptAppFond )*/
    kATSUSizeTag = 262L, /*    Type:       Fixed  */
    /*    Default value: GetScriptVariable( smSystemScript, smScriptAppFondSize )
     */
    kATSUColorTag = 263L,      /*    Type:       RGBColor   */
                               /*    Default value: (0, 0, 0)*/
                               /*    Less common run tags */
    kATSULangRegionTag = 264L, /*    Type:       RegionCode - region values listed
                                  in script.h interface file*/
    /*    Default value: GetScriptManagerVariable( smRegionCode )*/
    kATSUVerticalCharacterTag =
        265L,                   /*    Type:       ATSUVerticalCharacterType  */
                                /*    Default value: kATSUStronglyHorizontal*/
    kATSUImposeWidthTag = 266L, /*    Type:       ATSUTextMeasurement*/
    /*    Default value: 0 - all glyphs use their own font defined advance
       widths*/
    kATSUBeforeWithStreamShiftTag = 267L, /*    Type:       Fixed*/
                                          /*    Default value: 0*/
    kATSUAfterWithStreamShiftTag = 268L,  /*    Type:       Fixed*/
                                          /*    Default value: 0*/
    kATSUCrossStreamShiftTag = 269L,      /*    Type:       Fixed*/
                                          /*    Default value: 0*/
    kATSUTrackingTag = 270L,              /*    Type:       Fixed*/
                                          /*    Default value: kATSNoTracking*/
    kATSUHangingInhibitFactorTag = 271L,  /*    Type:       Fract between 0 and 1*/
                                          /*    Default value: 0*/
    kATSUKerningInhibitFactorTag = 272L,  /*    Type:       Fract between 0 and 1*/
                                          /*    Default value: 0*/
    kATSUDecompositionFactorTag = 273L,   /*    Type:       Fixed (-1.0 -> 1.0)*/
                                          /*    Default value: 0*/
    kATSUBaselineClassTag =
        274L, /*    Type:       BslnBaselineClass  (see SFNTLayoutTypes.h)*/
    /*    Default value: kBSLNRomanBaseline - set to kBSLNNoBaselineOverride to
       use intrinsic baselines*/
    kATSUPriorityJustOverrideTag =
        275L,                       /*    Type:       ATSJustPriorityWidthDeltaOverrides (see
                                       ATSLayoutTypes.h)*/
                                    /*    Default value: all zeros*/
    kATSUNoLigatureSplitTag = 276L, /*    Type:       Boolean*/
    /*    Default value: false - ligatures and compound characters have divisable
       components.*/
    kATSUNoCaretAngleTag = 277L, /*    Type:       Boolean*/
    /*    Default value: false - use the character's angularity to determine its
       boundaries*/
    kATSUSuppressCrossKerningTag = 278L, /*    Type:       Boolean*/
    /*    Default value: false - do not suppress automatic cross kerning (defined
       by font)*/
    kATSUNoOpticalAlignmentTag = 279L, /*    Type:       Boolean*/
    /*    Default value: false - do not suppress character's automatic optical
       positional alignment*/
    kATSUForceHangingTag = 280L, /*    Type:       Boolean*/
    /*    Default value: false - do not force the character's to hang beyond the
       line boundaries*/
    kATSUNoSpecialJustificationTag = 281L, /*    Type:       Boolean*/
    /*    Default value: false - perform post-compensation justification if
       needed*/
    kATSUStyleTextLocatorTag = 282L, /*    Type:       TextBreakLocatorRef*/
    /*    Default value: NULL - region derived locator or the default Text
       Utilities locator*/
    kATSUStyleRenderingOptionsTag =
        283L, /*    Type:       ATSStyleRenderingOptions (see ATSLayoutTypes.h)*/
    /*    Default value: kATSStyleApplyHints - ATS glyph rendering uses hinting*/
    kATSUMaxStyleTag = 284L, /*    This is just for convenience - the upper limit
                                of the ATSUStyle attribute tags */
                             /* obsolete style tags */
    kATSULanguageTag = 264L, /*    use kATSULangRegionTag               */
                             /* special layout tag for Mac OS X */
    kATSUCGContextTag =
        32767L, /*  Type:          CGContext, Default value:    NULL   */
                /* max */
    kATSUMaxATSUITagValue =
        65535L /*    This is the maximum Apple ATSUI reserved tag value.  Client
                  defined tags must be larger.*/
  };
 
  typedef void *ATSUAttributeValuePtr;
  typedef const void *ConstATSUAttributeValuePtr;
  struct ATSUAttributeInfo
  {
    ATSUAttributeTag fTag;
    ByteCount fValueSize;
  };
  typedef struct ATSUAttributeInfo ATSUAttributeInfo;
  struct ATSUCaret
  {
    Fixed fX;
    Fixed fY;
    Fixed fDeltaX;
    Fixed fDeltaY;
  };
  typedef struct ATSUCaret ATSUCaret;
  typedef UInt16 ATSUCursorMovementType;
  enum
  {
    kATSUByCharacter = 0,
    kATSUByTypographicCluster = 1, /* clusters based on characters or ligatures*/
    kATSUByWord = 2,
    kATSUByCharacterCluster = 3, /* clusters based on characters only*/
    kATSUByCluster = 1           /* obsolete name for kATSUByTypographicCluster*/
  };
 
  typedef UInt32 ATSULineTruncation;
  enum
  {
    kATSUTruncateNone = 0,  /* truncation specification - add to any desired
                               truncFeat bit options listed below*/
    kATSUTruncateStart = 1, /* for instance, kATSUTruncateEnd with
                               kATSUTruncFeatNoSquishing is value 0x0000000A*/
    kATSUTruncateEnd = 2,
    kATSUTruncateMiddle = 3,
    kATSUTruncateSpecificationMask =
        0x00000007, /* these bits are reserved for the truncation specification (0
                       - 7)*/
    /* the following bit-field options can be added to the chosen truncation
       specification*/
    kATSUTruncFeatNoSquishing =
        0x00000008 /* if specified, do not perform any negative justification in
                      lieu of truncation*/
  };
 
  typedef UInt16 ATSUVerticalCharacterType;
  enum
  {
    kATSUStronglyHorizontal = 0,
    kATSUStronglyVertical = 1
  };
 
  typedef UInt16 ATSUStyleComparison;
  enum
  {
    kATSUStyleUnequal = 0,
    kATSUStyleContains = 1,
    kATSUStyleEquals = 2,
    kATSUStyleContainedBy = 3
  };
 
  typedef UInt16 ATSUFontFallbackMethod;
  enum
  {
    kATSUDefaultFontFallbacks = 0,
    kATSULastResortOnlyFallback = 1,
    kATSUSequentialFallbacksPreferred = 2,
    kATSUSequentialFallbacksExclusive = 3
  };
 
#if CALL_NOT_IN_CARBON
  typedef CALLBACK_API_C(void *, ATSUCustomAllocFunc)(void *refCon,
                                                      ByteCount howMuch);
  typedef CALLBACK_API_C(void, ATSUCustomFreeFunc)(void *refCon,
                                                   void *doomedBlock);
  typedef CALLBACK_API_C(void *, ATSUCustomGrowFunc)(void *refCon, void *oldBlock,
                                                     ByteCount oldSize,
                                                     ByteCount newSize);
  union ATSUMemoryCallbacks
  {
    struct
    {
      ATSUCustomAllocFunc Alloc;
      ATSUCustomFreeFunc Free;
      ATSUCustomGrowFunc Grow;
      void *memoryRefCon;
    } callbacks;
 
    THz heapToUse;
  };
  typedef union ATSUMemoryCallbacks ATSUMemoryCallbacks;
  typedef UInt16 ATSUHeapSpec;
  enum
  {
    kATSUUseCurrentHeap = 0,
    kATSUUseAppHeap = 1,
    kATSUUseSpecificHeap = 2,
    kATSUUseCallbacks = 3
  };
 
  typedef struct OpaqueATSUMemorySetting *ATSUMemorySetting;
#endif /* CALL_NOT_IN_CARBON */
 
  /* Types for ATSUI Low Level API */
  struct ATSUGlyphInfo
  {
    GlyphID glyphID;
    UInt16 reserved;
    UInt32 layoutFlags;
    UniCharArrayOffset charIndex;
    ATSUStyle style;
    Float32 deltaY;
    Float32 idealX;
    SInt16 screenX;
    SInt16 caretX;
  };
  typedef struct ATSUGlyphInfo ATSUGlyphInfo;
  struct ATSUGlyphInfoArray
  {
    ATSUTextLayout layout;
    ItemCount numGlyphs;
    ATSUGlyphInfo glyphs[1];
  };
  typedef struct ATSUGlyphInfoArray ATSUGlyphInfoArray;
 
  /*********************************************************************************/
  /*  ATSUI Highlighting method constants and typedefs             */
  /*********************************************************************************/
  typedef UInt32 ATSUHighlightMethod;
  enum
  {
    kInvertHighlighting = 0,
    kRedrawHighlighting = 1
  };
 
  typedef UInt32 ATSUBackgroundDataType;
  enum
  {
    kATSUBackgroundColor = 0,
    kATSUBackgroundCallback = 1
  };
 
  struct ATSUBackgroundColor
  {
    float red;
    float green;
    float blue;
    float alpha;
  };
  typedef struct ATSUBackgroundColor ATSUBackgroundColor;
 
  typedef CALLBACK_API(Boolean,
                       RedrawBackgroundProcPtr)(ATSUTextLayout iLayout,
                                                UniCharArrayOffset iTextOffset,
                                                UniCharCount iTextLength,
                                                ATSTrapezoid iUnhighlightArea[],
                                                ItemCount iTrapezoidCount);
  typedef TVECTOR_UPP_TYPE(RedrawBackgroundProcPtr) RedrawBackgroundUPP;
  RedrawBackgroundUPP
  NewRedrawBackgroundUPP(RedrawBackgroundProcPtr userRoutine);
 
  void
  DisposeRedrawBackgroundUPP(RedrawBackgroundUPP userUPP);
 
  Boolean
  InvokeRedrawBackgroundUPP(ATSUTextLayout iLayout,
                            UniCharArrayOffset iTextOffset,
                            UniCharCount iTextLength,
                            ATSTrapezoid iUnhighlightArea[],
                            ItemCount iTrapezoidCount,
                            RedrawBackgroundUPP userUPP);
 
  union ATSUBackgroundData
  {
    ATSUBackgroundColor backgroundColor;
    RedrawBackgroundUPP backgroundUPP;
  };
  typedef union ATSUBackgroundData ATSUBackgroundData;
  struct ATSUUnhighlightData
  {
    ATSUBackgroundDataType dataType;
    ATSUBackgroundData unhighlightData;
  };
  typedef struct ATSUUnhighlightData ATSUUnhighlightData;
 
  /********************/
  /*  Other constants */
  /********************/
  /* Line direction types (used for kATSULineDirectionTag values) */
  enum
  {
    kATSULeftToRightBaseDirection =
        0, /*    Impose left-to-right or top-to-bottom dominant direction */
    kATSURightToLeftBaseDirection =
        1 /*    Impose right-to-left or bottom-to-top dominant direction */
  };
 
/* LineFlushFactor convenience defined values */
#define kATSUStartAlignment ((Fract)0x00000000L)
#define kATSUEndAlignment ((Fract)0x40000000L)
#define kATSUCenterAlignment ((Fract)0x20000000L)
/* LineJustificationFactor convenience defined values */
#define kATSUNoJustification ((Fract)0x00000000L)
#define kATSUFullJustification ((Fract)0x40000000L)
  /* Other constants  */
  enum
  {
    kATSUInvalidFontID = 0
  };
 
  enum
  {
    kATSUUseLineControlWidth = 0x7FFFFFFF
  };
 
  enum
  {
    kATSUNoSelector = 0x0000FFFF
  };
 
  enum
  {
    kATSUUseGrafPortPenLoc = (unsigned long)0xFFFFFFFF,
    kATSUClearAll = (unsigned long)0xFFFFFFFF
  };
 
  enum
  {
    kATSUFromTextBeginning = (unsigned long)0xFFFFFFFF,
    kATSUToTextEnd = (unsigned long)0xFFFFFFFF
  };
 
  /****************/
  /*  Functions   */
  /****************/
 
  /*  Clipboard support, flattened style version 0 (it is advised to not use these
   * routines and perform your own flattening)  */
  OSStatus
  ATSUCopyToHandle(ATSUStyle iStyle, Handle oStyleHandle);
 
  OSStatus
  ATSUPasteFromHandle(ATSUStyle iStyle, Handle iStyleHandle);
 
/*  Memory allocation specification functions (not in Carbon)   */
#if CALL_NOT_IN_CARBON
  OSStatus
  ATSUCreateMemorySetting(ATSUHeapSpec iHeapSpec,
                          ATSUMemoryCallbacks *iMemoryCallbacks,
                          ATSUMemorySetting *oMemorySetting);
 
  OSStatus
  ATSUSetCurrentMemorySetting(ATSUMemorySetting iMemorySetting);
 
  ATSUMemorySetting
  ATSUGetCurrentMemorySetting(void);
 
  OSStatus
  ATSUDisposeMemorySetting(ATSUMemorySetting iMemorySetting);
 
/*  Font fallback object functions  */
#endif /* CALL_NOT_IN_CARBON */
 
  OSStatus
  ATSUCreateFontFallbacks(ATSUFontFallbacks *oFontFallback);
 
  OSStatus
  ATSUDisposeFontFallbacks(ATSUFontFallbacks iFontFallbacks);
 
  OSStatus
  ATSUSetObjFontFallbacks(ATSUFontFallbacks iFontFallbacks,
                          ItemCount iFontFallbacksCount,
                          const ATSUFontID iFonts[],
                          ATSUFontFallbackMethod iFontFallbackMethod);
 
  OSStatus
  ATSUGetObjFontFallbacks(ATSUFontFallbacks iFontFallbacks,
                          ItemCount iMaxFontFallbacksCount, ATSUFontID oFonts[],
                          ATSUFontFallbackMethod *oFontFallbackMethod,
                          ItemCount *oActualFallbacksCount);
 
  /*  Basic style functions   */
  OSStatus
  ATSUCreateStyle(ATSUStyle *oStyle);
 
  OSStatus
  ATSUCreateAndCopyStyle(ATSUStyle iStyle, ATSUStyle *oStyle);
 
  OSStatus
  ATSUDisposeStyle(ATSUStyle iStyle);
 
  OSStatus
  ATSUSetStyleRefCon(ATSUStyle iStyle, UInt32 iRefCon);
 
  OSStatus
  ATSUGetStyleRefCon(ATSUStyle iStyle, UInt32 *oRefCon);
 
  /*  Style comparison        */
  OSStatus
  ATSUCompareStyles(ATSUStyle iFirstStyle, ATSUStyle iSecondStyle,
                    ATSUStyleComparison *oComparison);
 
  /*  Attribute manipulations */
  OSStatus
  ATSUCopyAttributes(ATSUStyle iSourceStyle, ATSUStyle iDestinationStyle);
 
  OSStatus
  ATSUOverwriteAttributes(ATSUStyle iSourceStyle, ATSUStyle iDestinationStyle);
 
  OSStatus
  ATSUUnderwriteAttributes(ATSUStyle iSourceStyle, ATSUStyle iDestinationStyle);
 
  /*  Empty styles    */
  OSStatus
  ATSUClearStyle(ATSUStyle iStyle);
 
  OSStatus
  ATSUStyleIsEmpty(ATSUStyle iStyle, Boolean *oIsClear);
 
  /*  Get and set attributes */
  OSStatus
  ATSUCalculateBaselineDeltas(ATSUStyle iStyle, BslnBaselineClass iBaselineClass,
                              BslnBaselineRecord oBaselineDeltas);
 
  OSStatus
  ATSUSetAttributes(ATSUStyle iStyle, ItemCount iAttributeCount,
                    const ATSUAttributeTag iTag[], const ByteCount iValueSize[],
                    const ATSUAttributeValuePtr iValue[]);
 
  OSStatus
  ATSUGetAttribute(ATSUStyle iStyle, ATSUAttributeTag iTag,
                   ByteCount iExpectedValueSize, ATSUAttributeValuePtr oValue,
                   ByteCount *oActualValueSize);
 
  OSStatus
  ATSUGetAllAttributes(ATSUStyle iStyle, ATSUAttributeInfo oAttributeInfoArray[],
                       ItemCount iTagValuePairArraySize,
                       ItemCount *oTagValuePairCount);
 
  OSStatus
  ATSUClearAttributes(ATSUStyle iStyle, ItemCount iTagCount,
                      const ATSUAttributeTag iTag[]);
 
  /*  Font features   */
  OSStatus
  ATSUSetFontFeatures(ATSUStyle iStyle, ItemCount iFeatureCount,
                      const ATSUFontFeatureType iType[],
                      const ATSUFontFeatureSelector iSelector[]);
 
  OSStatus
  ATSUGetFontFeature(ATSUStyle iStyle, ItemCount iFeatureIndex,
                     ATSUFontFeatureType *oFeatureType,
                     ATSUFontFeatureSelector *oFeatureSelector);
 
  OSStatus
  ATSUGetAllFontFeatures(ATSUStyle iStyle, ItemCount iMaximumFeatureCount,
                         ATSUFontFeatureType oFeatureType[],
                         ATSUFontFeatureSelector oFeatureSelector[],
                         ItemCount *oActualFeatureCount);
 
  OSStatus
  ATSUClearFontFeatures(ATSUStyle iStyle, ItemCount iFeatureCount,
                        const ATSUFontFeatureType iType[],
                        const ATSUFontFeatureSelector iSelector[]);
 
  /*  Font variations */
  OSStatus
  ATSUSetVariations(ATSUStyle iStyle, ItemCount iVariationCount,
                    const ATSUFontVariationAxis iAxes[],
                    const ATSUFontVariationValue iValue[]);
 
  OSStatus
  ATSUGetFontVariationValue(ATSUStyle iStyle,
                            ATSUFontVariationAxis iFontVariationAxis,
                            ATSUFontVariationValue *oFontVariationValue);
 
  OSStatus
  ATSUGetAllFontVariations(ATSUStyle iStyle, ItemCount iVariationCount,
                           ATSUFontVariationAxis oVariationAxes[],
                           ATSUFontVariationValue oFontVariationValues[],
                           ItemCount *oActualVariationCount);
 
  OSStatus
  ATSUClearFontVariations(ATSUStyle iStyle, ItemCount iAxisCount,
                          const ATSUFontVariationAxis iAxis[]);
 
  /*  Basic text-layout functions */
  OSStatus
  ATSUCreateTextLayout(ATSUTextLayout *oTextLayout);
 
  OSStatus
  ATSUCreateAndCopyTextLayout(ATSUTextLayout iTextLayout,
                              ATSUTextLayout *oTextLayout);
 
  OSStatus
  ATSUCreateTextLayoutWithTextPtr(
      ConstUniCharArrayPtr iText, UniCharArrayOffset iTextOffset,
      UniCharCount iTextLength, UniCharCount iTextTotalLength,
      ItemCount iNumberOfRuns, const UniCharCount iRunLengths[],
      ATSUStyle iStyles[], ATSUTextLayout *oTextLayout);
 
  OSStatus
  ATSUCreateTextLayoutWithTextHandle(
      UniCharArrayHandle iText, UniCharArrayOffset iTextOffset,
      UniCharCount iTextLength, UniCharCount iTextTotalLength,
      ItemCount iNumberOfRuns, const UniCharCount iRunLengths[],
      ATSUStyle iStyles[], ATSUTextLayout *oTextLayout);
 
  OSStatus
  ATSUClearLayoutCache(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineStart);
 
  OSStatus
  ATSUDisposeTextLayout(ATSUTextLayout iTextLayout);
 
  OSStatus
  ATSUSetTextLayoutRefCon(ATSUTextLayout iTextLayout, UInt32 iRefCon);
 
  OSStatus
  ATSUGetTextLayoutRefCon(ATSUTextLayout iTextLayout, UInt32 *oRefCon);
 
  /*  Glyph bounds retrieval  */
  OSStatus
  ATSUGetGlyphBounds(ATSUTextLayout iTextLayout,
                     ATSUTextMeasurement iTextBasePointX,
                     ATSUTextMeasurement iTextBasePointY,
                     UniCharArrayOffset iBoundsCharStart,
                     UniCharCount iBoundsCharLength, UInt16 iTypeOfBounds,
                     ItemCount iMaxNumberOfBounds, ATSTrapezoid oGlyphBounds[],
                     ItemCount *oActualNumberOfBounds);
 
  /*  Idle processing */
  OSStatus
  ATSUIdle(ATSUTextLayout iTextLayout);
 
  /*  Text location   */
  OSStatus
  ATSUSetTextPointerLocation(ATSUTextLayout iTextLayout,
                             ConstUniCharArrayPtr iText,
                             UniCharArrayOffset iTextOffset,
                             UniCharCount iTextLength,
                             UniCharCount iTextTotalLength);
 
  OSStatus
  ATSUSetTextHandleLocation(ATSUTextLayout iTextLayout, UniCharArrayHandle iText,
                            UniCharArrayOffset iTextOffset,
                            UniCharCount iTextLength,
                            UniCharCount iTextTotalLength);
 
  OSStatus
  ATSUGetTextLocation(ATSUTextLayout iTextLayout, void **oText,
                      Boolean *oTextIsStoredInHandle, UniCharArrayOffset *oOffset,
                      UniCharCount *oTextLength, UniCharCount *oTextTotalLength);
 
  /*  Text manipulation   */
  OSStatus
  ATSUTextDeleted(ATSUTextLayout iTextLayout,
                  UniCharArrayOffset iDeletedRangeStart,
                  UniCharCount iDeletedRangeLength);
 
  OSStatus
  ATSUTextInserted(ATSUTextLayout iTextLayout,
                   UniCharArrayOffset iInsertionLocation,
                   UniCharCount iInsertionLength);
 
  OSStatus
  ATSUTextMoved(ATSUTextLayout iTextLayout, ConstUniCharArrayPtr iNewLocation);
 
  /*  Layout controls */
  OSStatus
  ATSUCopyLayoutControls(ATSUTextLayout iSourceTextLayout,
                         ATSUTextLayout iDestTextLayout);
 
  OSStatus
  ATSUSetLayoutControls(ATSUTextLayout iTextLayout, ItemCount iAttributeCount,
                        const ATSUAttributeTag iTag[],
                        const ByteCount iValueSize[],
                        const ATSUAttributeValuePtr iValue[]);
 
  OSStatus
  ATSUGetLayoutControl(ATSUTextLayout iTextLayout, ATSUAttributeTag iTag,
                       ByteCount iExpectedValueSize, ATSUAttributeValuePtr oValue,
                       ByteCount *oActualValueSize);
 
  OSStatus
  ATSUGetAllLayoutControls(ATSUTextLayout iTextLayout,
                           ATSUAttributeInfo oAttributeInfoArray[],
                           ItemCount iTagValuePairArraySize,
                           ItemCount *oTagValuePairCount);
 
  OSStatus
  ATSUClearLayoutControls(ATSUTextLayout iTextLayout, ItemCount iTagCount,
                          const ATSUAttributeTag iTag[]);
 
  /*  Single line layout controls */
  OSStatus
  ATSUCopyLineControls(ATSUTextLayout iSourceTextLayout,
                       UniCharArrayOffset iSourceLineStart,
                       ATSUTextLayout iDestTextLayout,
                       UniCharArrayOffset iDestLineStart);
 
  OSStatus
  ATSUSetLineControls(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineStart,
                      ItemCount iAttributeCount, const ATSUAttributeTag iTag[],
                      const ByteCount iValueSize[],
                      const ATSUAttributeValuePtr iValue[]);
 
  OSStatus
  ATSUGetLineControl(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineStart,
                     ATSUAttributeTag iTag, ByteCount iExpectedValueSize,
                     ATSUAttributeValuePtr oValue, ByteCount *oActualValueSize);
 
  OSStatus
  ATSUGetAllLineControls(ATSUTextLayout iTextLayout,
                         UniCharArrayOffset iLineStart,
                         ATSUAttributeInfo oAttributeInfoArray[],
                         ItemCount iTagValuePairArraySize,
                         ItemCount *oTagValuePairCount);
 
  OSStatus
  ATSUClearLineControls(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineStart,
                        ItemCount iTagCount, const ATSUAttributeTag iTag[]);
 
  /*  Style run processing    */
  OSStatus
  ATSUSetRunStyle(ATSUTextLayout iTextLayout, ATSUStyle iStyle,
                  UniCharArrayOffset iRunStart, UniCharCount iRunLength);
 
  OSStatus
  ATSUGetRunStyle(ATSUTextLayout iTextLayout, UniCharArrayOffset iOffset,
                  ATSUStyle *oStyle, UniCharArrayOffset *oRunStart,
                  UniCharCount *oRunLength);
 
  OSStatus
  ATSUGetContinuousAttributes(ATSUTextLayout iTextLayout,
                              UniCharArrayOffset iOffset, UniCharCount iLength,
                              ATSUStyle oStyle);
 
  /*  Drawing and measuring   */
  OSStatus
  ATSUDrawText(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineOffset,
               UniCharCount iLineLength, ATSUTextMeasurement iLocationX,
               ATSUTextMeasurement iLocationY);
 
  OSStatus
  ATSUMeasureText(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineStart,
                  UniCharCount iLineLength, ATSUTextMeasurement *oTextBefore,
                  ATSUTextMeasurement *oTextAfter, ATSUTextMeasurement *oAscent,
                  ATSUTextMeasurement *oDescent);
 
  OSStatus
  ATSUMeasureTextImage(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineOffset,
                       UniCharCount iLineLength, ATSUTextMeasurement iLocationX,
                       ATSUTextMeasurement iLocationY, Rect *oTextImageRect);
 
  /*  Highlighting    */
  OSStatus
  ATSUHighlightText(ATSUTextLayout iTextLayout,
                    ATSUTextMeasurement iTextBasePointX,
                    ATSUTextMeasurement iTextBasePointY,
                    UniCharArrayOffset iHighlightStart,
                    UniCharCount iHighlightLength);
 
  OSStatus
  ATSUUnhighlightText(ATSUTextLayout iTextLayout,
                      ATSUTextMeasurement iTextBasePointX,
                      ATSUTextMeasurement iTextBasePointY,
                      UniCharArrayOffset iHighlightStart,
                      UniCharCount iHighlightLength);
 
  OSStatus
  ATSUGetTextHighlight(ATSUTextLayout iTextLayout,
                       ATSUTextMeasurement iTextBasePointX,
                       ATSUTextMeasurement iTextBasePointY,
                       UniCharArrayOffset iHighlightStart,
                       UniCharCount iHighlightLength, RgnHandle oHighlightRegion);
 
  /*  Hit-testing */
  OSStatus
  ATSUPositionToOffset(ATSUTextLayout iTextLayout, ATSUTextMeasurement iLocationX,
                       ATSUTextMeasurement iLocationY,
                       UniCharArrayOffset *ioPrimaryOffset, Boolean *oIsLeading,
                       UniCharArrayOffset *oSecondaryOffset);
 
  OSStatus
  ATSUOffsetToPosition(ATSUTextLayout iTextLayout, UniCharArrayOffset iOffset,
                       Boolean iIsLeading, ATSUCaret *oMainCaret,
                       ATSUCaret *oSecondCaret, Boolean *oCaretIsSplit);
 
  OSStatus
  ATSUPositionToCursorOffset(ATSUTextLayout iTextLayout,
                             ATSUTextMeasurement iLocationX,
                             ATSUTextMeasurement iLocationY,
                             ATSUCursorMovementType iMovementType,
                             UniCharArrayOffset *ioPrimaryOffset,
                             Boolean *oIsLeading,
                             UniCharArrayOffset *oSecondaryOffset);
 
  OSStatus
  ATSUOffsetToCursorPosition(ATSUTextLayout iTextLayout,
                             UniCharArrayOffset iOffset, Boolean iIsLeading,
                             ATSUCursorMovementType iMovementType,
                             ATSUCaret *oMainCaret, ATSUCaret *oSecondCaret,
                             Boolean *oCaretIsSplit);
 
  /*  Cursor movement */
  OSStatus
  ATSUNextCursorPosition(ATSUTextLayout iTextLayout,
                         UniCharArrayOffset iOldOffset,
                         ATSUCursorMovementType iMovementType,
                         UniCharArrayOffset *oNewOffset);
 
  OSStatus
  ATSUPreviousCursorPosition(ATSUTextLayout iTextLayout,
                             UniCharArrayOffset iOldOffset,
                             ATSUCursorMovementType iMovementType,
                             UniCharArrayOffset *oNewOffset);
 
  OSStatus
  ATSURightwardCursorPosition(ATSUTextLayout iTextLayout,
                              UniCharArrayOffset iOldOffset,
                              ATSUCursorMovementType iMovementType,
                              UniCharArrayOffset *oNewOffset);
 
  OSStatus
  ATSULeftwardCursorPosition(ATSUTextLayout iTextLayout,
                             UniCharArrayOffset iOldOffset,
                             ATSUCursorMovementType iMovementType,
                             UniCharArrayOffset *oNewOffset);
 
  /*  Line breaking   */
  OSStatus
  ATSUBreakLine(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineStart,
                ATSUTextMeasurement iLineWidth, Boolean iUseAsSoftLineBreak,
                UniCharArrayOffset *oLineBreak);
 
  OSStatus
  ATSUSetSoftLineBreak(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineBreak);
 
  OSStatus
  ATSUGetSoftLineBreaks(ATSUTextLayout iTextLayout,
                        UniCharArrayOffset iRangeStart, UniCharCount iRangeLength,
                        ItemCount iMaximumBreaks, UniCharArrayOffset oBreaks[],
                        ItemCount *oBreakCount);
 
  OSStatus
  ATSUClearSoftLineBreaks(ATSUTextLayout iTextLayout,
                          UniCharArrayOffset iRangeStart,
                          UniCharCount iRangeLength);
 
  /*  Font matching   */
  OSStatus
  ATSUSetFontFallbacks(ItemCount iFontFallbacksCount, const ATSUFontID iFontIDs[],
                       ATSUFontFallbackMethod iFontFallbackMethod);
 
  OSStatus
  ATSUGetFontFallbacks(ItemCount iMaxFontFallbacksCount, ATSUFontID oFontIDs[],
                       ATSUFontFallbackMethod *oFontFallbackMethod,
                       ItemCount *oActualFallbacksCount);
 
  OSStatus
  ATSUMatchFontsToText(ATSUTextLayout iTextLayout, UniCharArrayOffset iTextStart,
                       UniCharCount iTextLength, ATSUFontID *oFontID,
                       UniCharArrayOffset *oChangedOffset,
                       UniCharCount *oChangedLength);
 
  OSStatus
  ATSUSetTransientFontMatching(ATSUTextLayout iTextLayout,
                               Boolean iTransientFontMatching);
 
  OSStatus
  ATSUGetTransientFontMatching(ATSUTextLayout iTextLayout,
                               Boolean *oTransientFontMatching);
 
  /*  Font ID's   */
  OSStatus
  ATSUFontCount(ItemCount *oFontCount);
 
  OSStatus
  ATSUGetFontIDs(ATSUFontID oFontIDs[], ItemCount iArraySize,
                 ItemCount *oFontCount);
 
  OSStatus
  ATSUFONDtoFontID(short iFONDNumber, Style iFONDStyle, ATSUFontID *oFontID);
 
  OSStatus
  ATSUFontIDtoFOND(ATSUFontID iFontID, short *oFONDNumber, Style *oFONDStyle);
 
  /*  Font names  */
  OSStatus
  ATSUCountFontNames(ATSUFontID iFontID, ItemCount *oFontNameCount);
 
  OSStatus
  ATSUGetIndFontName(ATSUFontID iFontID, ItemCount iFontNameIndex,
                     ByteCount iMaximumNameLength, Ptr oName,
                     ByteCount *oActualNameLength, FontNameCode *oFontNameCode,
                     FontPlatformCode *oFontNamePlatform,
                     FontScriptCode *oFontNameScript,
                     FontLanguageCode *oFontNameLanguage);
 
  OSStatus
  ATSUFindFontName(ATSUFontID iFontID, FontNameCode iFontNameCode,
                   FontPlatformCode iFontNamePlatform,
                   FontScriptCode iFontNameScript,
                   FontLanguageCode iFontNameLanguage,
                   ByteCount iMaximumNameLength, Ptr oName,
                   ByteCount *oActualNameLength, ItemCount *oFontNameIndex);
 
  OSStatus
  ATSUFindFontFromName(Ptr iName, ByteCount iNameLength,
                       FontNameCode iFontNameCode,
                       FontPlatformCode iFontNamePlatform,
                       FontScriptCode iFontNameScript,
                       FontLanguageCode iFontNameLanguage, ATSUFontID *oFontID);
 
  /*  Font features   */
  OSStatus
  ATSUCountFontFeatureTypes(ATSUFontID iFontID, ItemCount *oTypeCount);
 
  OSStatus
  ATSUCountFontFeatureSelectors(ATSUFontID iFontID, ATSUFontFeatureType iType,
                                ItemCount *oSelectorCount);
 
  OSStatus
  ATSUGetFontFeatureTypes(ATSUFontID iFontID, ItemCount iMaximumTypes,
                          ATSUFontFeatureType oTypes[],
                          ItemCount *oActualTypeCount);
 
  OSStatus
  ATSUGetFontFeatureSelectors(ATSUFontID iFontID, ATSUFontFeatureType iType,
                              ItemCount iMaximumSelectors,
                              ATSUFontFeatureSelector oSelectors[],
                              Boolean oSelectorIsOnByDefault[],
                              ItemCount *oActualSelectorCount,
                              Boolean *oIsMutuallyExclusive);
 
  OSStatus
  ATSUGetFontFeatureNameCode(ATSUFontID iFontID, ATSUFontFeatureType iType,
                             ATSUFontFeatureSelector iSelector,
                             FontNameCode *oNameCode);
 
  /*  Font tracking value & names */
  OSStatus
  ATSUCountFontTracking(ATSUFontID iFontID,
                        ATSUVerticalCharacterType iCharacterOrientation,
                        ItemCount *oTrackingCount);
 
  OSStatus
  ATSUGetIndFontTracking(ATSUFontID iFontID,
                         ATSUVerticalCharacterType iCharacterOrientation,
                         ItemCount iTrackIndex, Fixed *oFontTrackingValue,
                         FontNameCode *oNameCode);
 
  /*  Font variations */
  OSStatus
  ATSUCountFontVariations(ATSUFontID iFontID, ItemCount *oVariationCount);
 
  OSStatus
  ATSUGetIndFontVariation(ATSUFontID iFontID, ItemCount iVariationIndex,
                          ATSUFontVariationAxis *oATSUFontVariationAxis,
                          ATSUFontVariationValue *oMinimumValue,
                          ATSUFontVariationValue *oMaximumValue,
                          ATSUFontVariationValue *oDefaultValue);
 
  OSStatus
  ATSUGetFontVariationNameCode(ATSUFontID iFontID, ATSUFontVariationAxis iAxis,
                               FontNameCode *oNameCode);
 
  /*  Font Instances  */
  OSStatus
  ATSUCountFontInstances(ATSUFontID iFontID, ItemCount *oInstances);
 
  OSStatus
  ATSUGetFontInstance(ATSUFontID iFontID, ItemCount iFontInstanceIndex,
                      ItemCount iMaximumVariations, ATSUFontVariationAxis oAxes[],
                      ATSUFontVariationValue oValues[],
                      ItemCount *oActualVariationCount);
 
  OSStatus
  ATSUGetFontInstanceNameCode(ATSUFontID iFontID, ItemCount iInstanceIndex,
                              FontNameCode *oNameCode);
 
  /*******************************************************************************/
  /* ATSUI Low-Level API */
  /*******************************************************************************/
  /* GlyphInfo access */
  OSStatus
  ATSUGetGlyphInfo(ATSUTextLayout iTextLayout, UniCharArrayOffset iLineStart,
                   UniCharCount iLineLength, ByteCount *ioBufferSize,
                   ATSUGlyphInfoArray *oGlyphInfoPtr);
 
  OSStatus
  ATSUDrawGlyphInfo(ATSUGlyphInfoArray *iGlyphInfoArray, Float32Point iLocation);
 
  /* Font Data Access */
  OSStatus
  ATSUGlyphGetIdealMetrics(ATSUStyle iATSUStyle, ItemCount iNumOfGlyphs,
                           GlyphID iGlyphIDs[], ByteOffset iInputOffset,
                           ATSGlyphIdealMetrics oIdealMetrics[]);
 
  OSStatus
  ATSUGetNativeCurveType(ATSUStyle iATSUStyle, ATSCurveType *oCurveType);
 
  /* Device specific routines */
  OSStatus
  ATSUGlyphGetScreenMetrics(ATSUStyle iATSUStyle, ItemCount iNumOfGlyphs,
                            GlyphID iGlyphIDs[], ByteOffset iInputOffset,
                            Boolean iForcingAntiAlias, Boolean iAntiAliasSwitch,
                            ATSGlyphScreenMetrics oScreenMetrics[]);
 
  /* ATSUGlyphGetQuadraticPaths callbacks */
  typedef CALLBACK_API(OSStatus, ATSQuadraticLineProcPtr)(const Float32Point *pt1,
                                                          const Float32Point *pt2,
                                                          void *callBackDataPtr);
  typedef CALLBACK_API(OSStatus,
                       ATSQuadraticCurveProcPtr)(const Float32Point *pt1,
                                                 const Float32Point *controlPt,
                                                 const Float32Point *pt2,
                                                 void *callBackDataPtr);
  typedef CALLBACK_API(OSStatus,
                       ATSQuadraticNewPathProcPtr)(void *callBackDataPtr);
  typedef CALLBACK_API(OSStatus,
                       ATSQuadraticClosePathProcPtr)(void *callBackDataPtr);
  typedef TVECTOR_UPP_TYPE(ATSQuadraticLineProcPtr) ATSQuadraticLineUPP;
  typedef TVECTOR_UPP_TYPE(ATSQuadraticCurveProcPtr) ATSQuadraticCurveUPP;
  typedef TVECTOR_UPP_TYPE(ATSQuadraticNewPathProcPtr) ATSQuadraticNewPathUPP;
  typedef TVECTOR_UPP_TYPE(ATSQuadraticClosePathProcPtr) ATSQuadraticClosePathUPP;
  ATSQuadraticLineUPP
  NewATSQuadraticLineUPP(ATSQuadraticLineProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATSQuadraticLineProcInfo = 0x00000FF0
  }; /* pascal 4_bytes Func(4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline ATSQuadraticLineUPP
  NewATSQuadraticLineUPP(ATSQuadraticLineProcPtr userRoutine)
  {
    return userRoutine;
  }
#else
#define NewATSQuadraticLineUPP(userRoutine) (userRoutine)
#endif
#endif
 
  ATSQuadraticCurveUPP
  NewATSQuadraticCurveUPP(ATSQuadraticCurveProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATSQuadraticCurveProcInfo = 0x00003FF0
  }; /* pascal 4_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline ATSQuadraticCurveUPP
  NewATSQuadraticCurveUPP(ATSQuadraticCurveProcPtr userRoutine)
  {
    return userRoutine;
  }
#else
#define NewATSQuadraticCurveUPP(userRoutine) (userRoutine)
#endif
#endif
 
  ATSQuadraticNewPathUPP
  NewATSQuadraticNewPathUPP(ATSQuadraticNewPathProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATSQuadraticNewPathProcInfo = 0x000000F0
  }; /* pascal 4_bytes Func(4_bytes) */
#ifdef __cplusplus
  inline ATSQuadraticNewPathUPP
  NewATSQuadraticNewPathUPP(ATSQuadraticNewPathProcPtr userRoutine)
  {
    return userRoutine;
  }
#else
#define NewATSQuadraticNewPathUPP(userRoutine) (userRoutine)
#endif
#endif
 
  ATSQuadraticClosePathUPP
  NewATSQuadraticClosePathUPP(ATSQuadraticClosePathProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATSQuadraticClosePathProcInfo = 0x000000F0
  }; /* pascal 4_bytes Func(4_bytes) */
#ifdef __cplusplus
  inline ATSQuadraticClosePathUPP
  NewATSQuadraticClosePathUPP(ATSQuadraticClosePathProcPtr userRoutine)
  {
    return userRoutine;
  }
#else
#define NewATSQuadraticClosePathUPP(userRoutine) (userRoutine)
#endif
#endif
 
  void
  DisposeATSQuadraticLineUPP(ATSQuadraticLineUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATSQuadraticLineUPP(ATSQuadraticLineUPP) {}
#else
#define DisposeATSQuadraticLineUPP(userUPP)
#endif
#endif
 
  void
  DisposeATSQuadraticCurveUPP(ATSQuadraticCurveUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATSQuadraticCurveUPP(ATSQuadraticCurveUPP) {}
#else
#define DisposeATSQuadraticCurveUPP(userUPP)
#endif
#endif
 
  void
  DisposeATSQuadraticNewPathUPP(ATSQuadraticNewPathUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATSQuadraticNewPathUPP(ATSQuadraticNewPathUPP) {}
#else
#define DisposeATSQuadraticNewPathUPP(userUPP)
#endif
#endif
 
  void
  DisposeATSQuadraticClosePathUPP(ATSQuadraticClosePathUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATSQuadraticClosePathUPP(ATSQuadraticClosePathUPP) {}
#else
#define DisposeATSQuadraticClosePathUPP(userUPP)
#endif
#endif
 
  OSStatus
  InvokeATSQuadraticLineUPP(const Float32Point *pt1, const Float32Point *pt2,
                            void *callBackDataPtr, ATSQuadraticLineUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeATSQuadraticLineUPP(const Float32Point *pt1,
                                            const Float32Point *pt2,
                                            void *callBackDataPtr,
                                            ATSQuadraticLineUPP userUPP)
  {
    return (*userUPP)(pt1, pt2, callBackDataPtr);
  }
#else
#define InvokeATSQuadraticLineUPP(pt1, pt2, callBackDataPtr, userUPP) \
  (*userUPP)(pt1, pt2, callBackDataPtr)
#endif
#endif
 
  OSStatus
  InvokeATSQuadraticCurveUPP(const Float32Point *pt1,
                             const Float32Point *controlPt,
                             const Float32Point *pt2, void *callBackDataPtr,
                             ATSQuadraticCurveUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeATSQuadraticCurveUPP(const Float32Point *pt1,
                                             const Float32Point *controlPt,
                                             const Float32Point *pt2,
                                             void *callBackDataPtr,
                                             ATSQuadraticCurveUPP userUPP)
  {
    return (*userUPP)(pt1, controlPt, pt2, callBackDataPtr);
  }
#else
#define InvokeATSQuadraticCurveUPP(pt1, controlPt, pt2, callBackDataPtr, \
                                   userUPP)                              \
  (*userUPP)(pt1, controlPt, pt2, callBackDataPtr)
#endif
#endif
 
  OSStatus
  InvokeATSQuadraticNewPathUPP(void *callBackDataPtr,
                               ATSQuadraticNewPathUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeATSQuadraticNewPathUPP(void *callBackDataPtr,
                                               ATSQuadraticNewPathUPP userUPP)
  {
    return (*userUPP)(callBackDataPtr);
  }
#else
#define InvokeATSQuadraticNewPathUPP(callBackDataPtr, userUPP) \
  (*userUPP)(callBackDataPtr)
#endif
#endif
 
  OSStatus
  InvokeATSQuadraticClosePathUPP(void *callBackDataPtr,
                                 ATSQuadraticClosePathUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus
  InvokeATSQuadraticClosePathUPP(void *callBackDataPtr,
                                 ATSQuadraticClosePathUPP userUPP)
  {
    return (*userUPP)(callBackDataPtr);
  }
#else
#define InvokeATSQuadraticClosePathUPP(callBackDataPtr, userUPP) \
  (*userUPP)(callBackDataPtr)
#endif
#endif
 
  OSStatus
  ATSUGlyphGetQuadraticPaths(ATSUStyle iATSUStyle, GlyphID iGlyphID,
                             ATSQuadraticNewPathUPP iNewPathProc,
                             ATSQuadraticLineUPP iLineProc,
                             ATSQuadraticCurveUPP iCurveProc,
                             ATSQuadraticClosePathUPP iClosePathProc,
                             void *iCallbackDataPtr, OSStatus *oCallbackResult);
 
  /* ATSUGlyphGetCubicPaths callbacks */
  typedef CALLBACK_API(OSStatus, ATSCubicMoveToProcPtr)(const Float32Point *pt,
                                                        void *callBackDataPtr);
  typedef CALLBACK_API(OSStatus, ATSCubicLineToProcPtr)(const Float32Point *pt,
                                                        void *callBackDataPtr);
  typedef CALLBACK_API(OSStatus, ATSCubicCurveToProcPtr)(const Float32Point *pt1,
                                                         const Float32Point *pt2,
                                                         const Float32Point *pt3,
                                                         void *callBackDataPtr);
  typedef CALLBACK_API(OSStatus, ATSCubicClosePathProcPtr)(void *callBackDataPtr);
  typedef TVECTOR_UPP_TYPE(ATSCubicMoveToProcPtr) ATSCubicMoveToUPP;
  typedef TVECTOR_UPP_TYPE(ATSCubicLineToProcPtr) ATSCubicLineToUPP;
  typedef TVECTOR_UPP_TYPE(ATSCubicCurveToProcPtr) ATSCubicCurveToUPP;
  typedef TVECTOR_UPP_TYPE(ATSCubicClosePathProcPtr) ATSCubicClosePathUPP;
  ATSCubicMoveToUPP
  NewATSCubicMoveToUPP(ATSCubicMoveToProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATSCubicMoveToProcInfo = 0x000003F0
  }; /* pascal 4_bytes Func(4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline ATSCubicMoveToUPP
  NewATSCubicMoveToUPP(ATSCubicMoveToProcPtr userRoutine)
  {
    return userRoutine;
  }
#else
#define NewATSCubicMoveToUPP(userRoutine) (userRoutine)
#endif
#endif
 
  ATSCubicLineToUPP
  NewATSCubicLineToUPP(ATSCubicLineToProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATSCubicLineToProcInfo = 0x000003F0
  }; /* pascal 4_bytes Func(4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline ATSCubicLineToUPP
  NewATSCubicLineToUPP(ATSCubicLineToProcPtr userRoutine)
  {
    return userRoutine;
  }
#else
#define NewATSCubicLineToUPP(userRoutine) (userRoutine)
#endif
#endif
 
  ATSCubicCurveToUPP
  NewATSCubicCurveToUPP(ATSCubicCurveToProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATSCubicCurveToProcInfo = 0x00003FF0
  }; /* pascal 4_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline ATSCubicCurveToUPP
  NewATSCubicCurveToUPP(ATSCubicCurveToProcPtr userRoutine)
  {
    return userRoutine;
  }
#else
#define NewATSCubicCurveToUPP(userRoutine) (userRoutine)
#endif
#endif
 
  ATSCubicClosePathUPP
  NewATSCubicClosePathUPP(ATSCubicClosePathProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppATSCubicClosePathProcInfo = 0x000000F0
  }; /* pascal 4_bytes Func(4_bytes) */
#ifdef __cplusplus
  inline ATSCubicClosePathUPP
  NewATSCubicClosePathUPP(ATSCubicClosePathProcPtr userRoutine)
  {
    return userRoutine;
  }
#else
#define NewATSCubicClosePathUPP(userRoutine) (userRoutine)
#endif
#endif
 
  void
  DisposeATSCubicMoveToUPP(ATSCubicMoveToUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATSCubicMoveToUPP(ATSCubicMoveToUPP) {}
#else
#define DisposeATSCubicMoveToUPP(userUPP)
#endif
#endif
 
  void
  DisposeATSCubicLineToUPP(ATSCubicLineToUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATSCubicLineToUPP(ATSCubicLineToUPP) {}
#else
#define DisposeATSCubicLineToUPP(userUPP)
#endif
#endif
 
  void
  DisposeATSCubicCurveToUPP(ATSCubicCurveToUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATSCubicCurveToUPP(ATSCubicCurveToUPP) {}
#else
#define DisposeATSCubicCurveToUPP(userUPP)
#endif
#endif
 
  void
  DisposeATSCubicClosePathUPP(ATSCubicClosePathUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeATSCubicClosePathUPP(ATSCubicClosePathUPP) {}
#else
#define DisposeATSCubicClosePathUPP(userUPP)
#endif
#endif
 
  OSStatus
  InvokeATSCubicMoveToUPP(const Float32Point *pt, void *callBackDataPtr,
                          ATSCubicMoveToUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeATSCubicMoveToUPP(const Float32Point *pt,
                                          void *callBackDataPtr,
                                          ATSCubicMoveToUPP userUPP)
  {
    return (*userUPP)(pt, callBackDataPtr);
  }
#else
#define InvokeATSCubicMoveToUPP(pt, callBackDataPtr, userUPP) \
  (*userUPP)(pt, callBackDataPtr)
#endif
#endif
 
  OSStatus
  InvokeATSCubicLineToUPP(const Float32Point *pt, void *callBackDataPtr,
                          ATSCubicLineToUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeATSCubicLineToUPP(const Float32Point *pt,
                                          void *callBackDataPtr,
                                          ATSCubicLineToUPP userUPP)
  {
    return (*userUPP)(pt, callBackDataPtr);
  }
#else
#define InvokeATSCubicLineToUPP(pt, callBackDataPtr, userUPP) \
  (*userUPP)(pt, callBackDataPtr)
#endif
#endif
 
  OSStatus
  InvokeATSCubicCurveToUPP(const Float32Point *pt1, const Float32Point *pt2,
                           const Float32Point *pt3, void *callBackDataPtr,
                           ATSCubicCurveToUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeATSCubicCurveToUPP(const Float32Point *pt1,
                                           const Float32Point *pt2,
                                           const Float32Point *pt3,
                                           void *callBackDataPtr,
                                           ATSCubicCurveToUPP userUPP)
  {
    return (*userUPP)(pt1, pt2, pt3, callBackDataPtr);
  }
#else
#define InvokeATSCubicCurveToUPP(pt1, pt2, pt3, callBackDataPtr, userUPP) \
  (*userUPP)(pt1, pt2, pt3, callBackDataPtr)
#endif
#endif
 
  OSStatus
  InvokeATSCubicClosePathUPP(void *callBackDataPtr, ATSCubicClosePathUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeATSCubicClosePathUPP(void *callBackDataPtr,
                                             ATSCubicClosePathUPP userUPP)
  {
    return (*userUPP)(callBackDataPtr);
  }
#else
#define InvokeATSCubicClosePathUPP(callBackDataPtr, userUPP) \
  (*userUPP)(callBackDataPtr)
#endif
#endif
 
  OSStatus
  ATSUGlyphGetCubicPaths(ATSUStyle iATSUStyle, GlyphID iGlyphID,
                         ATSCubicMoveToUPP iMoveToProc,
                         ATSCubicLineToUPP iLineToProc,
                         ATSCubicCurveToUPP iCurveToProc,
                         ATSCubicClosePathUPP iClosePathProc,
                         void *iCallbackDataPtr, OSStatus *oCallbackResult);
 
  OSStatus
  ATSUGlyphGetCurvePaths(ATSUStyle iATSUStyle, GlyphID iGlyphID,
                         ByteCount *ioBufferSize, ATSUCurvePaths *oPaths);
 
  /*************************************************************************/
  OSStatus
  ATSUSetHighlightingMethod(ATSUTextLayout iTextLayout,
                            ATSUHighlightMethod iMethod,
                            const ATSUUnhighlightData *iUnhighlightData);
 
#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 /* __ATSUNICODE__ */