Printing.h

Go to the documentation of this file.

 
#ifndef __PRINTING__
#define __PRINTING__
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#ifndef __DIALOGS__
#include <Dialogs.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
 
  enum
  {
    kFirstPageMin = 1,   
    kLastPageMax = 32767 
  };
 
  enum
  {
    iPFMaxPgs = 128,
    iPrPgFract =
        120,      
    iPrPgFst = 1, 
    iPrPgMax = 9999,
    iPrRelease = 3, 
    iPrSavPFil = -1,
    iPrAbort = 0x0080,
    iPrDevCtl = 7,         
    lPrReset = 0x00010000, 
    lPrLineFeed = 0x00030000,
    lPrLFStd = 0x0003FFFF, 
    lPrLFSixth = 0x0003FFFF,
    lPrPageEnd = 0x00020000, 
    lPrDocOpen = 0x00010000,
    lPrPageOpen = 0x00040000,
    lPrPageClose = 0x00020000,
    lPrDocClose = 0x00050000,
    iFMgrCtl = 8, 
    iMscCtl = 9,  
    iPvtCtl = 10  
  };
 
#define sPrDrvr ".Print"
  enum
  {
    pPrGlobals = 0x00000944, 
    bDraftLoop = 0,
    bSpoolLoop = 1,
    bUser1Loop = 2,
    bUser2Loop = 3,
    fNewRunBit = 2,
    fHiResOK = 3,
    fWeOpenedRF = 4, 
    iPrBitsCtl = 4,
    lScreenBits = 0,
    lPaintBits = 1,
    lHiScreenBits = 0x00000002, 
    lHiPaintBits = 0x00000003,  
    iPrIOCtl = 5,
    iPrEvtCtl = 6,          
    lPrEvtAll = 0x0002FFFD, 
    lPrEvtTop = 0x0001FFFD, 
    iPrDrvrRef = -3
  };
 
  enum
  {
    getRslDataOp = 4,
    setRslOp = 5,
    draftBitsOp = 6,
    noDraftBitsOp = 7,
    getRotnOp = 8,
    NoSuchRsl = 1,
    OpNotImpl = 2, 
    RgType1 = 1
  };
 
  typedef SInt8 TFeed;
  enum
  {
    feedCut = 0,
    feedFanfold = 1,
    feedMechCut = 2,
    feedOther = 3
  };
 
  typedef SInt8 TScan;
  enum
  {
    scanTB = 0,
    scanBT = 1,
    scanLR = 2,
    scanRL = 3
  };
 
  typedef Rect *TPRect;
  typedef CALLBACK_API(void, PrIdleProcPtr)(void);
  typedef CALLBACK_API(void, PItemProcPtr)(DialogRef theDialog, short item);
  typedef STACK_UPP_TYPE(PrIdleProcPtr) PrIdleUPP;
  typedef STACK_UPP_TYPE(PItemProcPtr) PItemUPP;
#if CALL_NOT_IN_CARBON
  PrIdleUPP
  NewPrIdleUPP(PrIdleProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppPrIdleProcInfo = 0x00000000
  }; 
#ifdef __cplusplus
  inline PrIdleUPP NewPrIdleUPP(PrIdleProcPtr userRoutine)
  {
    return (PrIdleUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppPrIdleProcInfo, GetCurrentArchitecture());
  }
#else
#define NewPrIdleUPP(userRoutine)                                             \
  (PrIdleUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppPrIdleProcInfo, \
                                   GetCurrentArchitecture())
#endif
#endif
 
  PItemUPP
  NewPItemUPP(PItemProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppPItemProcInfo = 0x000002C0
  }; 
#ifdef __cplusplus
  inline PItemUPP NewPItemUPP(PItemProcPtr userRoutine)
  {
    return (PItemUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppPItemProcInfo, GetCurrentArchitecture());
  }
#else
#define NewPItemUPP(userRoutine)                                            \
  (PItemUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppPItemProcInfo, \
                                  GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposePrIdleUPP(PrIdleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposePrIdleUPP(PrIdleUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposePrIdleUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposePItemUPP(PItemUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposePItemUPP(PItemUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposePItemUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokePrIdleUPP(PrIdleUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokePrIdleUPP(PrIdleUPP userUPP)
  {
    CALL_ZERO_PARAMETER_UPP(userUPP, uppPrIdleProcInfo);
  }
#else
#define InvokePrIdleUPP(userUPP) \
  CALL_ZERO_PARAMETER_UPP((userUPP), uppPrIdleProcInfo)
#endif
#endif
 
  void
  InvokePItemUPP(DialogRef theDialog, short item, PItemUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokePItemUPP(DialogRef theDialog, short item, PItemUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppPItemProcInfo, theDialog, item);
  }
#else
#define InvokePItemUPP(theDialog, item, userUPP) \
  CALL_TWO_PARAMETER_UPP((userUPP), uppPItemProcInfo, (theDialog), (item))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewPrIdleProc(userRoutine) NewPrIdleUPP(userRoutine)
#define NewPItemProc(userRoutine) NewPItemUPP(userRoutine)
#define CallPrIdleProc(userRoutine) InvokePrIdleUPP(userRoutine)
#define CallPItemProc(userRoutine, theDialog, item) \
  InvokePItemUPP(theDialog, item, userRoutine)
#endif 
#if !OPAQUE_TOOLBOX_STRUCTS
  struct TPrPort
  {
    GrafPort gPort; 
    QDProcs gProcs; 
    long lGParam1;  
    long lGParam2;
    long lGParam3;
    long lGParam4;
    Boolean fOurPtr;  
    Boolean fOurBits; 
  };
  typedef struct TPrPort TPrPort;
  typedef TPrPort *TPPrPort;
#else
typedef struct OpaqueTPPrPort *TPPrPort;
#endif 
  typedef TPPrPort TPPrPortRef;
  struct TPrInfo
  {
    short iDev;  
    short iVRes; 
    short iHRes; 
    Rect rPage;  
  };
  typedef struct TPrInfo TPrInfo;
  typedef TPrInfo *TPPrInfo;
  struct TPrStl
  {
    short wDev;
    short iPageV;
    short iPageH;
    SInt8 bPort;
    TFeed feed;
  };
  typedef struct TPrStl TPrStl;
  typedef TPrStl *TPPrStl;
  struct TPrXInfo
  {
    short iRowBytes;
    short iBandV;
    short iBandH;
    short iDevBytes;
    short iBands;
    SInt8 bPatScale;
    SInt8 bUlThick;
    SInt8 bUlOffset;
    SInt8 bUlShadow;
    TScan scan;
    SInt8 bXInfoX;
  };
  typedef struct TPrXInfo TPrXInfo;
  typedef TPrXInfo *TPPrXInfo;
  struct TPrJob
  {
    short iFstPage; 
    short iLstPage;
    short iCopies;       
    SInt8 bJDocLoop;     
    Boolean fFromUsr;    
    PrIdleUPP pIdleProc; 
    StringPtr pFileName; 
    short iFileVol;      
    SInt8 bFileVers;     
    SInt8 bJobX;         
  };
  typedef struct TPrJob TPrJob;
  typedef TPrJob *TPPrJob;
  struct TPrint
  {
    short iPrVersion; 
    TPrInfo prInfo;   
    Rect rPaper;      
    TPrStl prStl;     
    TPrInfo prInfoPT; 
    TPrXInfo prXInfo; 
    TPrJob prJob;     
    short printX[19]; 
  };
  typedef struct TPrint TPrint;
  typedef TPrint *TPPrint;
  typedef TPPrint *THPrint;
  struct TPrStatus
  {
    short iTotPages;  
    short iCurPage;   
    short iTotCopies; 
    short iCurCopy;   
    short iTotBands;  
    short iCurBand;   
    Boolean fPgDirty; 
    Boolean fImaging; 
    THPrint hPrint;   
    TPPrPort pPrPort; 
    PicHandle hPic;   
  };
  typedef struct TPrStatus TPrStatus;
  typedef TPrStatus *TPPrStatus;
  typedef TPPrStatus TPPrStatusRef;
 
  struct TPfPgDir
  {
    short iPages;
    long iPgPos[129]; 
  };
  typedef struct TPfPgDir TPfPgDir;
  typedef TPfPgDir *TPPfPgDir;
  typedef TPPfPgDir *THPfPgDir;
#if !OPAQUE_TOOLBOX_STRUCTS
  struct TPrDlg
  {
    DialogRecord Dlg;         
    ModalFilterUPP pFltrProc; 
    PItemUPP pItemProc;       
    THPrint hPrintUsr;        
    Boolean fDoIt;
    Boolean fDone;
    long lUser1; 
    long lUser2; 
    long lUser3; 
    long lUser4;
  };
  typedef struct TPrDlg TPrDlg;
  typedef TPrDlg *TPPrDlg;
#else
typedef struct OpaqueTPPrDlg *TPPrDlg;
#endif 
  typedef TPPrDlg TPPrDlgRef;
  typedef CALLBACK_API(TPPrDlgRef, PDlgInitProcPtr)(THPrint hPrint);
  typedef STACK_UPP_TYPE(PDlgInitProcPtr) PDlgInitUPP;
#if CALL_NOT_IN_CARBON
  PDlgInitUPP
  NewPDlgInitUPP(PDlgInitProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppPDlgInitProcInfo = 0x000000F0
  }; 
#ifdef __cplusplus
  inline PDlgInitUPP NewPDlgInitUPP(PDlgInitProcPtr userRoutine)
  {
    return (PDlgInitUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppPDlgInitProcInfo, GetCurrentArchitecture());
  }
#else
#define NewPDlgInitUPP(userRoutine)   \
  (PDlgInitUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppPDlgInitProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposePDlgInitUPP(PDlgInitUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposePDlgInitUPP(PDlgInitUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposePDlgInitUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  TPPrDlgRef
  InvokePDlgInitUPP(THPrint hPrint, PDlgInitUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline TPPrDlgRef InvokePDlgInitUPP(THPrint hPrint, PDlgInitUPP userUPP)
  {
    return (TPPrDlgRef)CALL_ONE_PARAMETER_UPP(userUPP, uppPDlgInitProcInfo,
                                              hPrint);
  }
#else
#define InvokePDlgInitUPP(hPrint, userUPP) \
  (TPPrDlgRef) CALL_ONE_PARAMETER_UPP((userUPP), uppPDlgInitProcInfo, (hPrint))
#endif
#endif
 
#endif 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewPDlgInitProc(userRoutine) NewPDlgInitUPP(userRoutine)
#define CallPDlgInitProc(userRoutine, hPrint) \
  InvokePDlgInitUPP(hPrint, userRoutine)
#endif 
  struct TGnlData
  {
    short iOpCode;
    short iError;
    long lReserved; 
  };
  typedef struct TGnlData TGnlData;
  struct TRslRg
  {
    short iMin;
    short iMax;
  };
  typedef struct TRslRg TRslRg;
  struct TRslRec
  {
    short iXRsl;
    short iYRsl;
  };
  typedef struct TRslRec TRslRec;
  struct TGetRslBlk
  {
    short iOpCode;
    short iError;
    long lReserved;
    short iRgType;
    TRslRg xRslRg;
    TRslRg yRslRg;
    short iRslRecCnt;
    TRslRec rgRslRec[27];
  };
  typedef struct TGetRslBlk TGetRslBlk;
  struct TSetRslBlk
  {
    short iOpCode;
    short iError;
    long lReserved;
    THPrint hPrint;
    short iXRsl;
    short iYRsl;
  };
  typedef struct TSetRslBlk TSetRslBlk;
  struct TDftBitsBlk
  {
    short iOpCode;
    short iError;
    long lReserved;
    THPrint hPrint;
  };
  typedef struct TDftBitsBlk TDftBitsBlk;
  struct TGetRotnBlk
  {
    short iOpCode;
    short iError;
    long lReserved;
    THPrint hPrint;
    Boolean fLandscape;
    SInt8 bXtra;
  };
  typedef struct TGetRotnBlk TGetRotnBlk;
#if CALL_NOT_IN_CARBON
  void
  PrPurge(void);
 
  void
  PrNoPurge(void);
 
  void
  PrOpen(void);
 
  void
  PrClose(void);
 
  void
  PrintDefault(THPrint hPrint);
 
  Boolean
  PrValidate(THPrint hPrint);
 
  Boolean
  PrStlDialog(THPrint hPrint);
 
  Boolean
  PrJobDialog(THPrint hPrint);
 
  TPPrDlgRef
  PrStlInit(THPrint hPrint);
 
  TPPrDlgRef
  PrJobInit(THPrint hPrint);
 
  void
  PrJobMerge(THPrint hPrintSrc, THPrint hPrintDst);
 
  Boolean
  PrDlgMain(THPrint hPrint, PDlgInitUPP pDlgInit);
 
  TPPrPort
  PrOpenDoc(THPrint hPrint, TPPrPort pPrPort, 
            Ptr pIOBuf);
 
  void
  PrCloseDoc(TPPrPort pPrPort);
 
  void
  PrOpenPage(TPPrPort pPrPort, TPRect pPageFrame);
 
  void
  PrClosePage(TPPrPort pPrPort);
 
  void
  PrPicFile(THPrint hPrint, TPPrPort pPrPort, Ptr pIOBuf, Ptr pDevBuf,
            TPPrStatus prStatus);
 
  short
  PrError(void);
 
  void
  PrSetError(short iErr);
 
#endif 
#if CALL_NOT_IN_CARBON
  void
  PrGeneral(Ptr pData);
 
#endif 
#if CALL_NOT_IN_CARBON
  void
  PrDrvrOpen(void);
 
  void
  PrDrvrClose(void);
 
  void
  PrCtlCall(short iWhichCtl, long lParam1, long lParam2, long lParam3);
 
  Handle
  PrDrvrDCE(void);
 
  short
  PrDrvrVers(void);
 
  short
  PrLoadDriver(void);
 
#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 
* /