GXLayout.h

Go to the documentation of this file.

 
#ifndef __GXLAYOUT__
#define __GXLAYOUT__
 
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
 
#ifndef __GXTYPES__
#include <GXTypes.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#if defined(__MWERKS__) && TARGET_CPU_68K
#pragma push
#pragma pointers_in_D0
#endif
 
#if CALL_NOT_IN_CARBON
    gxShape
    GXNewLayout(long textRunCount, const short textRunLengths[], const void *text[],
                long styleRunCount, const short styleRunLengths[],
                const gxStyle styles[], long levelRunCount,
                const short levelRunLengths[], const short levels[],
                const gxLayoutOptions *layoutOptions, const gxPoint *position);
 
    long
    GXGetLayout(gxShape layout, void *text, long *styleRunCount,
                short styleRunLengths[], gxStyle styles[], long *levelRunCount,
                short levelRunLengths[], short levels[],
                gxLayoutOptions *layoutOptions, gxPoint *position);
 
    void
    GXSetLayout(gxShape layout, long textRunCount, const short textRunLengths[],
                const void *text[], long styleRunCount,
                const short styleRunLengths[], const gxStyle styles[],
                long levelRunCount, const short levelRunLengths[],
                const short levels[], const gxLayoutOptions *layoutOptions,
                const gxPoint *position);
 
    void
    GXDrawLayout(long textRunCount, const short textRunLengths[],
                 const void *text[], long styleRunCount,
                 const short styleRunLengths[], const gxStyle styles[],
                 long levelRunCount, const short levelRunLengths[],
                 const short levels[], const gxLayoutOptions *layoutOptions,
                 const gxPoint *position);
 
    void
    GXSetLayoutParts(gxShape layout, gxByteOffset oldStartOffset,
                     gxByteOffset oldEndOffset, long newTextRunCount,
                     const short newTextRunLengths[], const void *newText[],
                     long newStyleRunCount, const short newStyleRunLengths[],
                     const gxStyle newStyles[], long newLevelRunCount,
                     const short newLevelRunLengths[], const short newLevels[]);
 
    void
    GXSetLayoutShapeParts(gxShape layout, gxByteOffset startOffset,
                          gxByteOffset endOffset, gxShape insert);
 
    long
    GXGetLayoutParts(gxShape layout, gxByteOffset startOffset,
                     gxByteOffset endOffset, void *text, long *styleRunCount,
                     short styleRunLengths[], gxStyle styles[], long *levelRunCount,
                     short levelRunLengths[], short levels[]);
 
    gxShape
    GXGetLayoutShapeParts(gxShape layout, gxByteOffset startOffset,
                          gxByteOffset endOffset, gxShape dest);
 
    long
    GXGetLayoutGlyphs(gxShape layout, gxGlyphcode *glyphs, gxPoint positions[],
                      long advance[], gxPoint tangents[], long *runCount,
                      short styleRuns[], gxStyle glyphStyles[]);
 
    gxByteOffset
    GXHitTestLayout(gxShape layout, const gxPoint *hitDown,
                    gxHighlightType highlightType, gxLayoutHitInfo *hitInfo,
                    gxShape hitTrackingArea);
 
    gxShape
    GXGetLayoutHighlight(gxShape layout, gxByteOffset startOffset,
                         gxByteOffset endOffset, gxHighlightType highlightType,
                         gxShape highlight);
 
    gxShape
    GXGetLayoutVisualHighlight(gxShape layout, gxByteOffset startOffset,
                               long startLeadingEdge, gxByteOffset endOffset,
                               long endLeadingEdge, gxHighlightType highlightType,
                               gxShape highlight);
 
    gxShape
    GXGetLayoutCaret(gxShape layout, gxByteOffset offset,
                     gxHighlightType highlightType, gxCaretType caretType,
                     gxShape caret);
 
    gxByteOffset
    GXGetLayoutBreakOffset(gxShape layout, gxByteOffset startOffset,
                           Fixed lineWidth, long hyphenationCount,
                           const gxByteOffset hyphenationPoints[],
                           Boolean *startIsStaked, gxByteOffset *priorStake,
                           gxByteOffset *nextStake);
 
    Fixed
    GXGetLayoutRangeWidth(gxShape layout, gxByteOffset startOffset,
                          gxByteOffset endOffset, gxShape supplementaryText);
 
    gxShape
    GXNewLayoutFromRange(gxShape layout, gxByteOffset startOffset,
                         gxByteOffset endOffset,
                         const gxLayoutOptions *layoutOptions,
                         gxShape supplementaryText);
 
    gxShape
    GXGetCaretAngleArea(gxShape layout, const gxPoint *hitPoint,
                        gxHighlightType highlightType, gxShape caretArea,
                        short *returnedRise, short *returnedRun);
 
    void
    GXGetStyleBaselineDeltas(gxStyle baseStyle, gxBaselineType baseType,
                             gxBaselineDeltas returnedDeltas);
 
    gxByteOffset
    GXGetRightVisualOffset(gxShape layout, gxByteOffset currentOffset);
 
    gxByteOffset
    GXGetLeftVisualOffset(gxShape layout, gxByteOffset currentOffset);
 
    void
    GXGetCompoundCharacterLimits(gxShape layout, gxByteOffset trial,
                                 gxByteOffset *minOffset, gxByteOffset *maxOffset,
                                 Boolean *onBoundary);
 
    void
    GXGetOffsetGlyphs(gxShape layout, gxByteOffset trial, long leadingEdge,
                      gxLayoutOffsetState *offsetState, unsigned short *firstGlyph,
                      unsigned short *secondGlyph);
 
    void
    GXGetGlyphOffset(gxShape layout, long trial, long onLeftTop,
                     gxByteOffset *offset, Boolean *leadingEdge,
                     Boolean *wasRealCharacter);
 
    void
    GXGetLayoutSpan(gxShape layout, Fixed *lineAscent, Fixed *lineDescent);
 
    void
    GXSetLayoutSpan(gxShape layout, Fixed lineAscent, Fixed lineDescent);
 
    Fixed
    GXGetLayoutJustificationGap(gxShape layout);
 
    void
    GXGetLayoutJustificationFactors(gxShape layout, Fixed constrainedFactors[],
                                    Fixed unconstrainedFactors[]);
 
    void
    GXSetStyleRunControls(gxStyle target, const gxRunControls *runControls);
 
    void
    GXSetStyleRunPriorityJustOverride(
        gxStyle target,
        const gxPriorityJustificationOverride *priorityJustificationOverride);
 
    void
    GXSetStyleRunGlyphJustOverrides(
        gxStyle target, long count,
        const gxGlyphJustificationOverride glyphJustificationOverrides[]);
 
    void
    GXSetStyleRunGlyphSubstitutions(gxStyle target, long count,
                                    const gxGlyphSubstitution glyphSubstitutions[]);
 
    void
    GXSetStyleRunFeatures(gxStyle target, long count,
                          const gxRunFeature runFeatures[]);
 
    void
    GXSetStyleRunKerningAdjustments(gxStyle target, long count,
                                    const gxKerningAdjustment kerningAdjustments[]);
 
    void
    GXSetShapeRunControls(gxShape target, const gxRunControls *runControls);
 
    void
    GXSetShapeRunPriorityJustOverride(
        gxShape target,
        const gxPriorityJustificationOverride *priorityJustificationOverride);
 
    void
    GXSetShapeRunGlyphJustOverrides(
        gxShape target, long count,
        const gxGlyphJustificationOverride glyphJustificationOverrides[]);
 
    void
    GXSetShapeRunGlyphSubstitutions(gxShape target, long count,
                                    const gxGlyphSubstitution glyphSubstitutions[]);
 
    void
    GXSetShapeRunFeatures(gxShape target, long count,
                          const gxRunFeature runFeatures[]);
 
    void
    GXSetShapeRunKerningAdjustments(gxShape target, long count,
                                    const gxKerningAdjustment kerningAdjustments[]);
 
    long
    GXGetStyleRunControls(gxStyle source, gxRunControls *runControls);
 
    long
    GXGetStyleRunPriorityJustOverride(
        gxStyle source,
        gxPriorityJustificationOverride *priorityJustificationOverride);
 
    long
    GXGetStyleRunGlyphJustOverrides(
        gxStyle source, gxGlyphJustificationOverride glyphJustificationOverrides[]);
 
    long
    GXGetStyleRunGlyphSubstitutions(gxStyle source,
                                    gxGlyphSubstitution glyphSubstitutions[]);
 
    long
    GXGetStyleRunFeatures(gxStyle source, gxRunFeature runFeatures[]);
 
    long
    GXGetStyleRunKerningAdjustments(gxStyle source,
                                    gxKerningAdjustment kerningAdjustments[]);
 
    long
    GXGetShapeRunControls(gxShape source, gxRunControls *runControls);
 
    long
    GXGetShapeRunPriorityJustOverride(
        gxShape source,
        gxPriorityJustificationOverride *priorityJustificationOverride);
 
    long
    GXGetShapeRunGlyphJustOverrides(
        gxShape source, gxGlyphJustificationOverride glyphJustificationOverrides[]);
 
    long
    GXGetShapeRunGlyphSubstitutions(gxShape source,
                                    gxGlyphSubstitution glyphSubstitutions[]);
 
    long
    GXGetShapeRunFeatures(gxShape source, gxRunFeature runFeatures[]);
 
    long
    GXGetShapeRunKerningAdjustments(gxShape source,
                                    gxKerningAdjustment kerningAdjustments[]);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if defined(__MWERKS__) && TARGET_CPU_68K
#pragma pop
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __GXLAYOUT__ */