QuickdrawText.h

Go to the documentation of this file.

 
#ifndef __QUICKDRAWTEXT__
#define __QUICKDRAWTEXT__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#ifndef __INTLRESOURCES__
#include <IntlResources.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
 
  OSStatus
  StandardGlyphs(void *dataStream, ByteCount size);
 
  enum
  {
    leftCaret = 0,   
    rightCaret = -1, 
    kHilite = 1      
  };
 
  enum
  {
    smLeftCaret = 0,   
    smRightCaret = -1, 
    smHilite = 1       
  };
 
  enum
  {
    onlyStyleRun = 0,    
    leftStyleRun = 1,    
    rightStyleRun = 2,   
    middleStyleRun = 3,  
    smOnlyStyleRun = 0,  
    smLeftStyleRun = 1,  
    smRightStyleRun = 2, 
    smMiddleStyleRun = 3 
  };
 
  typedef short JustStyleCode;
  typedef short TruncCode;
  enum
  {
    truncEnd = 0,          
    truncMiddle = 0x4000,  
    smTruncEnd = 0,        
    smTruncMiddle = 0x4000 
  };
 
  enum
  {
    notTruncated = 0,   
    truncated = 1,      
    truncErr = -1,      
    smNotTruncated = 0, 
    smTruncated = 1,    
    smTruncErr = -1     
  };
 
  typedef SInt8 StyledLineBreakCode;
  enum
  {
    smBreakWord = 0,
    smBreakChar = 1,
    smBreakOverflow = 2
  };
 
  enum
  {
    tfAntiAlias = 1 << 0,
    tfUnicode = 1 << 1
  };
 
  struct FontInfo
  {
    short ascent;
    short descent;
    short widMax;
    short leading;
  };
  typedef struct FontInfo FontInfo;
 
  typedef short FormatOrder[1];
  typedef FormatOrder *FormatOrderPtr;
  typedef CALLBACK_API(Boolean, StyleRunDirectionProcPtr)(short styleRunIndex,
                                                          void *dirParam);
  typedef STACK_UPP_TYPE(StyleRunDirectionProcPtr) StyleRunDirectionUPP;
  StyleRunDirectionUPP
  NewStyleRunDirectionUPP(StyleRunDirectionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppStyleRunDirectionProcInfo = 0x00000390
  }; 
#ifdef __cplusplus
  inline StyleRunDirectionUPP
  NewStyleRunDirectionUPP(StyleRunDirectionProcPtr userRoutine)
  {
    return (StyleRunDirectionUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppStyleRunDirectionProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewStyleRunDirectionUPP(userRoutine)                                \
  (StyleRunDirectionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),       \
                                              uppStyleRunDirectionProcInfo, \
                                              GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeStyleRunDirectionUPP(StyleRunDirectionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeStyleRunDirectionUPP(StyleRunDirectionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeStyleRunDirectionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  Boolean
  InvokeStyleRunDirectionUPP(short styleRunIndex, void *dirParam,
                             StyleRunDirectionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline Boolean InvokeStyleRunDirectionUPP(short styleRunIndex, void *dirParam,
                                            StyleRunDirectionUPP userUPP)
  {
    return (Boolean)CALL_TWO_PARAMETER_UPP(userUPP, uppStyleRunDirectionProcInfo,
                                           styleRunIndex, dirParam);
  }
#else
#define InvokeStyleRunDirectionUPP(styleRunIndex, dirParam, userUPP)        \
  (Boolean) CALL_TWO_PARAMETER_UPP((userUPP), uppStyleRunDirectionProcInfo, \
                                   (styleRunIndex), (dirParam))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewStyleRunDirectionProc(userRoutine) \
  NewStyleRunDirectionUPP(userRoutine)
#define CallStyleRunDirectionProc(userRoutine, styleRunIndex, dirParam) \
  InvokeStyleRunDirectionUPP(styleRunIndex, dirParam, userRoutine)
#endif 
#if CALL_NOT_IN_CARBON
  short
  Pixel2Char(Ptr textBuf, short textLen, short slop, short pixelWidth,
             Boolean *leadingEdge);
 
  short
  Char2Pixel(Ptr textBuf, short textLen, short slop, short offset,
             short direction);
 
#endif 
  short
  PixelToChar(Ptr textBuf, long textLength, Fixed slop, Fixed pixelWidth,
              Boolean *leadingEdge, Fixed *widthRemaining,
              JustStyleCode styleRunPosition, Point numer, Point denom);
 
  short
  CharToPixel(Ptr textBuf, long textLength, Fixed slop, long offset,
              short direction, JustStyleCode styleRunPosition, Point numer,
              Point denom);
 
  void
  DrawJustified(Ptr textPtr, long textLength, Fixed slop,
                JustStyleCode styleRunPosition, Point numer, Point denom);
 
  void
  MeasureJustified(Ptr textPtr, long textLength, Fixed slop, Ptr charLocs,
                   JustStyleCode styleRunPosition, Point numer, Point denom);
 
  Fixed
  PortionLine(Ptr textPtr, long textLen, JustStyleCode styleRunPosition,
              Point numer, Point denom);
 
  void
  HiliteText(Ptr textPtr, short textLength, short firstOffset, short secondOffset,
             OffsetTable offsets);
 
#if CALL_NOT_IN_CARBON
  void
  DrawJust(Ptr textPtr, short textLength, short slop);
 
  void
  MeasureJust(Ptr textPtr, short textLength, short slop, Ptr charLocs);
 
  Fixed
  PortionText(Ptr textPtr, long textLength);
 
#endif 
  long
  VisibleLength(Ptr textPtr, long textLength);
 
  void
  GetFormatOrder(FormatOrderPtr ordering, short firstFormat, short lastFormat,
                 Boolean lineRight, StyleRunDirectionUPP rlDirProc, Ptr dirParam);
 
  void
  TextFont(short font);
 
  TextFace(bold | italic);           /* set to bold and italic */
  TextFace(thePort->txFace | bold);  /* add bolding */
  TextFace(thePort->txFace & ~bold); /* remove bolding */
  TextFace(0);                       /* set to plain text */
The "condense" and "extend" variations change the spacing between
characters to an arbitrary value set by the Font Manager. Another way to
compress expand text is to call SetFScaleDisable and use a smaller or
larger font. You may use SpaceExtra for spacing control;
e.g., as an aid in
                  displaying right -
              justified text.</ pre>
                  * \copyright THINK Reference © 1991 -
              1992 Symantec Corporation
                  *    \non_carbon_cfm in InterfaceLib 7.1 and
          later
              *    \carbon_lib in CarbonLib 1.0 and
          later
              *    \mac_os_x in version 10.0 and
          later
                  * /
              void
              TextFace(StyleParameter face);
 
void TextMode(short mode);
 
void TextSize(short size);
 
void SpaceExtra(Fixed extra);
 
void DrawChar(CharParameter ch);
 
void DrawString(ConstStr255Param s);
 
#if TARGET_OS_MAC
#define MacDrawText DrawText
#endif
  void
  MacDrawText(const void *textBuf, short firstByte, short byteCount);
 
  short
  CharWidth(CharParameter ch);
 
  short
  StringWidth(ConstStr255Param s);
 
  short
  TextWidth(const void *textBuf, short firstByte, short byteCount);
 
  void
  MeasureText(short count, const void *textAddr, void *charLocs);
 
  void
  GetFontInfo(FontInfo *info);
 
  void
  CharExtra(Fixed extra);
 
  void
  StdText(short count, const void *textAddr, Point numer, Point denom);
 
  short
  StdTxMeas(short byteCount, const void *textAddr, Point *numer, Point *denom,
            FontInfo *info);
 
  StyledLineBreakCode
  StyledLineBreak(Ptr textPtr, long textLen, long textStart, long textEnd,
                  long flags, Fixed *textWidth, long *textOffset);
 
  short
  TruncString(short width, Str255 theString, TruncCode truncWhere);
 
  short
  TruncText(short width, Ptr textPtr, short *length, TruncCode truncWhere);
 
#if CALL_NOT_IN_CARBON
  void
  drawstring(const char *s);
 
  short
  stringwidth(const char *s);
 
#endif 
  void
  stdtext(short count, const void *textAddr, const Point *numer,
          const Point *denom);
 
#if OLDROUTINENAMES
#define NPixel2Char(textBuf, textLen, slop, pixelWidth, leadingEdge,           \
                    widthRemaining, styleRunPosition, numer, denom)            \
  PixelToChar(textBuf, textLen, slop, pixelWidth, leadingEdge, widthRemaining, \
              styleRunPosition, numer, denom)
#define NChar2Pixel(textBuf, textLen, slop, offset, direction,             \
                    styleRunPosition, numer, denom)                        \
  CharToPixel(textBuf, textLen, slop, offset, direction, styleRunPosition, \
              numer, denom)
#define NDrawJust(textPtr, textLength, slop, styleRunPosition, numer, denom) \
  DrawJustified(textPtr, textLength, slop, styleRunPosition, numer, denom)
#define NMeasureJust(textPtr, textLength, slop, charLocs, styleRunPosition, \
                     numer, denom)                                          \
  MeasureJustified(textPtr, textLength, slop, charLocs, styleRunPosition,   \
                   numer, denom)
#define NPortionText(textPtr, textLen, styleRunPosition, numer, denom) \
  PortionLine(textPtr, textLen, styleRunPosition, numer, denom)
#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            
* / endif         
        * /*/*/ * /*/*/