Note:
Some Metrowerks PowerPlant classes are used in the following sample code. Please refer to Metrowerks PowerPlant documentation for these classes. C and C++ coding styles are both used in the sample code. The code is listed for demonstration purposes only.

// ------------------------------------------------------
// checking for Desktop Printer Extension
// ------------------------------------------------------
enum { kGestaltPFEFeatures = 'dtpf' };
Boolean HasDesktopExtension()
{
 OSErr err;
 Boolean hasIt = false;
 long gestaltResponse = NULL;

 err = Gestalt(kGestaltPFEFeatures, &gestaltResponse);
 if(err == noErr)
  hasIt = true;
 return hasIt;
}

// ------------------------------------------------------
// checking for Finder Scripting
// ------------------------------------------------------
Boolean HasFinderScripting()
{
 long gestaltResponse = NULL;
 return ( (Gestalt(gestaltFinderAttr, &gestaltResponse ) == noErr)
  && ((response & (1L << gestaltOSLCompliantFinder)) != 0) );
}

// --------------------------------------------------------------
// Find the printer driver in the system extensions folder w/ the
// specified minimum version, type and creator
// Note: This routine does not return an error code. If any error
// should happen, it'll be thrown to the caller w/ C++ exception
// handling.
// The caller should be prepared to handle errors including eofErr
// which indicates that the printer driver is not found.
// Parameters:
// inMinVersion- specify printer driver's minimum version
// inFileType - specify printer driver's file type
// inCreator - specify printer driver's creator
// outPrinterDrvrFsSpec - return the printer driver's FSSpec if
// found
// --------------------------------------------------------------
void FindPrinterDriver(unsigned short inMinVersion, OSType inFileType, OSType inCreator
void FSSpec& outPrinterDrvrFsSpec )
{
OSErr err;
const long kSearchBufSize = 16 * 1024;
short savedResFile = CurResFile();
short startupVRefNum;
long extDirID; // of extensions folder
CInfoPBRec targetPb;
CInfoPBRec maskPb;
CSParam catSearchPb;
FSSpec foundFsSpec;
StPointerBlock searchBuf(kSearchBufSize); // buffer for PBCatSearch
Boolean foundOne = false;

 err = FindFolder(-1, kExtensionFolderType, FALSE, &startupVRefNum, &extDirID);
 ThrowIfOSErr_(err);

 targetPb.hFileInfo.ioFlFndrInfo.fdType = inFileType;
 targetPb.hFileInfo.ioFlFndrInfo.fdCreator = inCreator;
 targetPb.hFileInfo.ioNamePtr = 0;
 targetPb.hFileInfo.ioFlAttrib = 0x00; // search for file only
 targetPb.hFileInfo.ioFlParID = extDirID; // in extensions folder only

 maskPb.hFileInfo.ioFlFndrInfo.fdType = 0xFFFFFFFF;
 maskPb.hFileInfo.ioFlFndrInfo.fdCreator = 0xFFFFFFFF;
 maskPb.hFileInfo.ioFlFndrInfo.fdFlags = 0;
 maskPb.hFileInfo.ioFlFndrInfo.fdLocation.h = 0;
 maskPb.hFileInfo.ioFlFndrInfo.fdLocation.v = 0;
 maskPb.hFileInfo.ioFlFndrInfo.fdFldr = 0;
 maskPb.hFileInfo.ioNamePtr = 0;
 maskPb.hFileInfo.ioFlAttrib = 0x10;  // directory bit
 maskPb.hFileInfo.ioFlParID = extDirID; // in extensions folder only

 Try_{
  catSearchPb.ioCatPosition.initialize = 0;
  while(!foundOne ){
   catSearchPb.ioCompletion = 0;
   catSearchPb.ioNamePtr = 0;
   catSearchPb.ioVRefNum = startupVRefNum;
   catSearchPb.ioMatchPtr = &foundFsSpec;
   catSearchPb.ioReqMatchCount = 1;
   catSearchPb.ioSearchBits = fsSBFlAttrib +
      fsSBFlFndrInfo + fsSBFlParID;
   catSearchPb.ioSearchInfo1 = &targetPb;
   catSearchPb.ioSearchInfo2 = &maskPb;
   catSearchPb.ioSearchTime = 0;
   catSearchPb.ioOptBuffer = (Ptr)searchBuf;
   catSearchPb.ioOptBufSize = kSearchBufSize;
   err = PBCatSearchSync(&catSearchPb);
   ThrowIfOSErr_(err);

    // found one w/ the specified type and creator
   LFile thePrDrFile(foundFsSpec);
   Try_{
    thePrDrFile.OpenResourceFork(fsRdPerm);
    // version of printer driver
    StResource versRsrc('vers', 1, true, true);
    // compare against minimum version
    if(**(unsigned short **)(Handle)versRsrc >= inMinVersion){
     // found one meeting the version requirement
     outPrinterDrvrFsSpec = foundFsSpec;
     foundOne = true; // get out of the loop
    }
    thePrDrFile.CloseResourceFork();
   }Catch_(inErr){
    thePrDrFile.CloseResourceFork();
    // don't throw
   }EndCatch_
  } // while
 }Catch_(inErr){
  // restore default resource file
  UseResFile(savedResFile);
  Throw_(inErr);
 }EndCatch_
}

// ---------------------------------------------------------------------------
// SetResource
// This routine change the content of an existing resource to the new content
// pointed to by inNewContentH.  The resource file containing the target resource
// must be open and set to the current resource file before this routine is
// called.
// ---------------------------------------------------------------------------
void
SetResource(ResType inResType, ResID inResID, Handle inNewContentH)
{
 // get the resource to be changed
 oldResH = Get1Resource(inResType, inResID);
 // be sure to handle error when the resource doesn't exist (oldResH == 0)

 char savedInHdlState = HGetState(inNewContentH);
  char savedRsrcHdlState = HGetState(oldResH );
 Size sz = GetHandleSize(inNewContentH);

 HUnlock(oldResH );
 SetHandleSize(oldResH, sz); // match sizes
 ThrowIfMemError_();
 HLock(oldResH );
 HLock(inNewContentH);
 BlockMove(*inNewContentH, *oldResH, sz); // copy content

 HSetState(inNewContentH, savedInHdlState);
 HSetState(oldResH , savedRsrcHdlState);
 ChangedResource(oldResH); // mark dirty
 WriteResource(oldResH);
 ThrowIfResError_();
 UpdateResFile(CurResFile());
}


// ---------------------------------------------------------------------------
// SetStrResource
// This routine changes the content of an existing 'STR ' resource to the new
// content pointed to by inStrP.  The resource file containing the target
// resource must be open and set to the current resource file before this routine
// is called.  Pay special attention to how we avoid to shrink existing resource.
// ---------------------------------------------------------------------------
void
SetStrResource(ResType inResType, ResID inResID, ConstStringPtr inStrP )
{
 // get the resource to be changed
 oldResH = Get1Resource(inResType, inResID);
 // be sure to handle error when the resource doesn't exist (oldResH == 0)

 Size sz = *inStrP + 1;
 /* If the string is longer than the handle, then
  grow the handle.
 */
 if(sz > GetHandleSize(oldResH )){
  char savedRsrcHdlState = HGetState(oldResH );
  HUnlock(oldResH );
  SetHandleSize(oldResH , sz);
  ThrowIfMemError_();
  HSetState(oldResH , savedRsrcHdlState);
 }
 BlockMoveData(inStrP, *oldResH , sz);
 ChangedResource(oldResH );
 WriteResource(oldResH);
 ThrowIfResError_();
 UpdateResFile(CurResFile());
}

// ---------------------------------------------------------------------------
// Create the Finder address we wish to send our Apple Event to;
// Note that we mean here "Finder" in the most generic sense;
// In reality, this can be the Finder or AtEase.
// ---------------------------------------------------------------------------
OSStatus getFinderAddress(AEAddressDesc *theDesc)
{
   OSErr               result = noErr;
   ProcessInfoRec      processInfo;
   ProcessSerialNumber serialNumber;

   serialNumber.highLongOfPSN = 0;
   serialNumber.lowLongOfPSN = kNoProcess;
   while ((result = GetNextProcess(&serialNumber)) == noErr)
   {
       processInfo.processInfoLength = sizeof(ProcessInfoRec);
       processInfo.processName     = nil;
       processInfo.processAppSpec  = nil;

       result = GetProcessInformation(&serialNumber, &processInfo);
       if (result == noErr){
           if ( processInfo.processType == 'FNDR' ){
               result = AECreateDesc(typeProcessSerialNumber, (Ptr)&serialNumber,
sizeof(ProcessSerialNumber), theDesc);
               return(result);
           }
       }
   }
   return(result);
}


// ---------------------------------------------------------------------------
// Send an Apple event to the Finder. The data for the event is pointed to
// by 'dataPtr' and is 'dataSize' bytes long.
// Note that the data is sub-typed so the Finder can decipher the contents.
// ---------------------------------------------------------------------------
#define kFinderExtension       'fext'
static OSStatus sendAEToFinder( Ptr dataPtr, Size dataSize)
{
 OSStatus  err = noErr;
 // the address of the Finder as an Apple event Descriptor
 AEAddressDesc  finderAddr;
 AppleEvent      theEvent;
 AppleEvent      replyEvent;

   err = getFinderAddress(&finderAddr);
 if (err == noErr) {
       err = AECreateAppleEvent(
           kCoreEventClass,        // this is a core event
           kFinderExtension,       // for a Finder extension
           &finderAddr,            // and we send it to the Finder
           kAutoGenerateReturnID,  // we aren't getting a return
           kAnyTransactionID,      // and we don't care about the transaction #
           &theEvent);             // and we create it right here
       if (err == noErr)
       {
           err = AEPutParamPtr(
               &theEvent,          // the event to shove into
               keyDirectObject,    // direct object keyword
               kFinderExtension,   // for the Finder extension
               dataPtr,            // here's the data!
               dataSize);          // here's how long it is!

           if (err == noErr)
           {
               err = AESend(
                   &theEvent,          // send the status event
                   &replyEvent,        // no reply event because -
                   kAENoReply +        // we don't want a reply
                    kAECanInteract +   // the receiver can interact with user
                    kAEDontReconnect,  // and don't bother to reconnect on error
                   kAENormalPriority,  // just a normal event
                   kAEDefaultTimeout,  // we'll wait some reasonable amount of time
                   nil, nil);          // and don't care what happens during that.
           }

                                       // now get rid of the Apple event
           (void) AEDisposeDesc(&theEvent);
       }

                                       // and get rid of the Finder address
       (void) AEDisposeDesc(&finderAddr);
   }

                                       // Fall through and return error, if any
   return(err);
}

// ---------------------------------------------------------------------------
// nessieCreateDTP
// Send an Apple event to Desktop Printer Extension asking it to create a new
// DTP for the current printer.
// ---------------------------------------------------------------------------
#define kPrintingExtension     'dtpx'
#define aePFECreateDTP         'pfcr'
typedef struct
{
   OSType      pfeCreator;
   OSType      extensionType;
} CreateDTPEvent;


// ---------------------------------------------------------------------------
// Notify Desktop Printer Extension/Finder the current printer has changed
// ---------------------------------------------------------------------------
OSStatus nessieCreateDTP()
{
 OSStatus err;
 CreateDTPEvent  myEvent;

 myEvent.pfeCreator = kPrintingExtension;
 myEvent.extensionType = aePFECreateDTP;
 // because Desktop Printer Extension is a Finder extension
 err = sendAEToFinder((Ptr) &myEvent, sizeof(myEvent));
    return err;
}

typedef struct DTPInfo{
   short    vRefNum;    // vRefNum of the DTP folder
   long  dirID;         // directory ID of the DTP folder
   Str31    DTPName;    // name of the DTP folder
   OSType   driverType; // creator type of the print driver for this DTP
   Boolean  current;    // is this DTP currently the default printer
   Str32 printerName;   // name of the acutal printer on the net (only for LW8.4)
   Str32 zoneName;      // zone where this printer resides (only for LW8.4 DTPs)
} DTPInfo, *DTPInfoPtr, **DTPInfoHdl;

#define kWaitForDTPTime   (60 * 20)
// ---------------------------------------------------------------------------
// CreateDTP
// This routine demonstrates how to create a DTP for StyleWriter1200
// ---------------------------------------------------------------------------
void
CreateDTP()
{
 OSErr err;
 short savedResFile = CurResFile();
 FSSpec printerDriverFSSpec;
 AliasHandle theAlias;
 EventRecord eventRec;
 unsigned long endTime = TickCount() + kWaitForDTPTime;
 DTPInfo DTPInfo;

                    // checking the environment
                    // make sure we have Desktop Printer Extension
                    // and Finder Scripting Extension
 if(HasDesktopExtension() && HasFinderScripting()){
  Try_{
   FindPrinterDriver(0x0120,
    'PRER', 'dblo', FSSpec& // StyleWriter1200
    printerDriverFSSpec);

   /* if you are creating DTP for LaserWriter type of
      printer driver, you'll need to write some more
      code here.
      Let's call LaserWriterExtra();
   */

   UseResFile(0);   // system file
                    // make alias for printer driver
   err = NewAlias(nil, &printerDriverFSSpec, &theAlias);
   ThrowIfOSErr_(err);
                    // set current printer to our printer driver
   SetResource('alis', -8192, theAlias);
   SetStrResource('STR ', -8192, printerDriverFSSpec.name);
   DisposeHandle(theAlias);

                    // we should notify Desktop Printer Extension
                    // that we have changed the default printer
   err = nessieCreateDTP();
                    // verify that the DTP is created
   do{
                    // give Desktop Printer Extension a chance
                    // to handle the request to create DTP
    EventAvail(everyEvent, &eventRec);
    newDTPMade = HasDTP(&DTPInfo,  &printerDriverFSSpec);
   }while((TickCount() < endTime) && (newDTPMade == FALSE));
                    // until either the DTP is made or time-out
  }Catch_(inErr){
                    // handle error...
  }EndCatch_
 }
 UseResFile(savedResFile);
}

// ---------------------------------------------------------------------------
// LaserWriterExtra for pre-8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP,
   ConstStr32Param inZone,
   ConstStr32Param inPrinterName){
 OSErr err;
 char papaState;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();

 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm);
 // handle error...

 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error...

    papaState = HGetState(papaH);
 HLock(papaH);
 // change PAPA resource content
 NBPSetEntity(*papaH, (ConstStr32Param)StringPtr(inPrinterName),
   (ConstStr32Param)("\pLaserWriter"),
   (ConstStr32Param)inZone);

 HSetState(papaH, papaState );
 ChangedResource(papaH); // mark dirty
 WriteResource(papaH);   // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

#define kNoCollection -2
OSErr psStorePrinterName(Collection prInfo, Handle papa);
/* store a normalized EntityName into collection prInfo */


/*
 add a hint to a DTP's collection
 The memory block pointed by 'bufP' of length 'size' is added as a hint of 'tag' and
   'id' to the DTP
whose PAPA is specified by 'papaH'.
 Note: the resource fork of LaserWriter must be open before this routine    is called.
*/
OSErr addHint(Handle papaH, CollectionTag tag, long id, long size, void *bufP){

 Handle lwPrefFileNameH;
 char savedHandleState;
 Collection DTPCollection;

 // we need the name of LW's pref. file
 lwPrefFileNameH= GetString(-8185 );
 // don't forget to handle error
 savedHandleState = HGetState(inHandle);
 HLock(lwPrefFileNameH);
 // use routine in SettingsLib to get the collection and add item
 DTPCollection= psGetPrefsPrinterInfo((StringPtr)(*lwPrefFileNameH), papaH);
 if(DTPCollection== nil)
  // don't forget to handle error
  err = kNoCollection;

 err = psStorePrinterName(DTPCollection, papaH);
 // handle error
 err = AddCollectionItem(DTPCollection, tag, id, size, bufP);
 // handle error
 err = psUpdatePrefsPrinterInfo(*lwPrefFileNameH, papaH, DTPCollection);
 DisposeCollection(DTPCollection);
 // clean up
 HSetState(lwPrefFileNameH, savedHandleState );
 ReleaseResource(lwPrefFileNameH);
 return (err);
}

OSStatus psGetPPDInfo(FSSpecPtr driver, Handle papaH,
long structVersion, PrinterPPDInfo *ppdInfo);
/* Return the PPD information for the printer specified by 'papaH' for the printer
 specified by 'driver'. The PPD information is returned in *'ppdInfo'.
 The caller must pass in the version of the PrinterPPDInfo structure being used,
 this should be the constant 'kPPDInfoStructVersion'. If the caller's structure is
 not compatable with the routine, then the routine returns ' errWrongStructVersion'.
*/

OSStatus psSetPPDInfo(FSSpecPtr driver, Handle papaH,
long structVersion, PrinterPPDInfo *ppdInfo);
/* Set the ppd file and the parsed ppd file for the printer driver specified
 by 'driver' and the printer specified by 'papaH'. The FSSpec's of the PPD file
 and the parsed PPD file are passed in the structure pointed to by' ppdInfo' along
 with a flag indicating whether the generic PPD should be used. If the generic PPD
 flag is set, then only the parsed PPD FSSpec need be valid. 'structVersion' indicates
 the version of the PrinterPPDInfo structure the caller is using. The caller should pass
 in the constant
*/

OSErr ppdGetParseFolder(FSSpecPtr parseFolder);
/* Fill in the FSSpec pointed to by 'parseFolder' with
 the 'vRefNum' and 'parID' of the parsed PPD folder.
 The client can place a parsed PPD file name into the
 FSSpec's 'name' field and then use the File Manager's
 Open call's to open a parsed PPD. Note that *parseFolder'
 is not the FSSpec of the parsed PPD folder.
*/

OSErr ppdParseFile (const FSSpec *ppdFileSpec, short compiledRef, short compiledResFRef,
  PPDParseErr *errInfoP);
/* Parse a PPD file, and all its includes.
 FSSpecPtr will be closed upon exit.
 The PPD is parsed into the open file with the file reference 'compiledRef'.
 If compiledResFRef is not -1, the resource fork of the ppd file is copied into it.
 If 'errInfoP' is not NULL, then any error information is returned in
 *'errInfoP'.
*/

enum PPDPresetSource {
 kPPDSourceUnknown = -1,
 kPPDSourceRSRC = 0,
 kPPDSourceGeneric = 1,
 kPPDSourceCustom = 2
};

typedef enum{
 kTriFalse = 0,
 kTriTrue,
 kTriUnknown
} TriState;

struct CustPPDInfo {
 Boolean   usePPD;
 FSSpec   fileSpec;
};
typedef struct CustPPDInfo CustPPDInfo, **CustPPDHandle;

typedef struct {
 short presetSource;  /* enum PPDPresetSource */
 TriState isSetup;
 CustPPDInfo customPPD;
} WhatPPD;

typedef struct PrinterPPDInfo{
 long  structVersion;     // Identifies the version of the rest of this structure.
 Boolean  useGenericPPD;  // True if the generic PPD should be used.
 FSSpec  ppdFile;         // FSSpec of the current PPD file.
 FSSpec  parsedPPDFile;   // FSSpec of the parsed PPD file for the printer.
}PrinterPPDInfo;


/*
This routine parse a ppd file specified ppdFsSpec
and add the corresponding hints to a DTP specified
by papaH
*/
OSErr SetPPD(FSSpec* ppdFsSpecP, Handle papaH, FSSpec* laserWriterFsSpecP)
{
 OSErr err = noErr;
 FSSpec parsedPPD;
 WhatPPD whatPPD;
 short savedResFile = ::CurResFile();
 Boolean isGeneric = false;
 short dataForkRefNum, resourceForkRefNum;
 PrinterPPDInfo ppdInfo;

 // default
 whatPPD.presetSource = kPPDSourceCustom;
 whatPPD.isSetup = kTriTrue;
 whatPPD.customPPD.usePPD = TRUE;
 whatPPD.customPPD.fileSpec = *ppdFsSpecP;

 // prepare parsed PPD FSSpec
 err = ppdGetParseFolder(&parsedPPD);
 ThrowIfOSErr_(err);
 CopyPStr(ppdFsSpecP->name, parsedPPD.name, sizeof(parsedPPD.name));

 // create parsed file and open its resource/data fork
 FSpCreateResFile(&parsedPPD, 'vgrd', 'Pref', smSystemScript);
 err = SpOpenDF(&parsedPPD, fsRdWrPerm, &dataForkRefNum);
 resourceForkRefNum = ::FSpOpenResFile(&parsedPPD, fsRdWrPerm);
 // parse ppd
 err = ppdParseFile (ppdFsSpecP, dataForkRefNum, resourceForkRefNum, NULL);
 // close resource/data fork
 CloseResFile(resourceForkRefNum);
 err = FSClose(dataForkRefNum);
 UseResFile(savedResFile);

 // associate the ppd with the printer
 err = addHint(papaH, 'pppd', 1, sizeof(parsedPPD), &parsedPPD);
 err = addHint(papaH, 'ppd ', 1, sizeof(whatPPD), &whatPPD);
 // set default hints
 err = psGetPPDInfo(laserWriterFsSpecP, papaH, 2, &ppdInfo);
 if(!err) err = psSetPPDInfo(laserWriterFsSpecP, papaH, 2, &ppdInfo);

 return (err);
}

// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP,
   ConstStr32Param inZone,
   ConstStr32Param inPrinterName){
 OSErr err;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();
 SSpec ppdFsSpec;

 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error...

 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error...

 // change PAPA resource content
 // See SettingsLib Spec  for psSetPapPapa
 err = psSetPapPapa(papaH, inPrinterName,
  (const Byte *)("\pLaserWriter"), inZone, 0);
 // handle error...

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 ChangedResource(papaH); // mark dirty
 WriteResource(papaH);   // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// where inTcpAddr is the network address of the lpr printer.
// This address can be in either name or dot format, i.e either "\plaser.rbi.com"
// or "\p204.188.109.155".
// inQNameis the name of the print queue associated with
// a spooler at inTcpAddr. If inQName is NULL then the default queue for the
// printer/spooler is used.
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP,
   ConstStr32Param inTcpAddr,
   ConstStr32Param inPrinterName,
   ConstStr32Param inQName){
 OSErr err;
 short refNum;
 Handle papaH;
 Handle ipAddrQueueH;
 short savedResFile = CurResFile();

 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error...

 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error...

 // change PAPA resource content
 // See SettingsLib Spec  for psSetLprPapa
 err = psSetLprPapa(papaH, inPrinterName, (const Byte *)("\p=LPR"),
  (const Byte *)(*inTcpAddr), (const Byte *)inQName);
 // handle error...

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 // specify domain address and queue of the printer
 err = PtrToHand(inTcpAddr, &ipAddrQueueH, inTcpAddr[0] + 1);
 err = PtrAndHand(inQName, ipAddrQueueH, inQName[0] + 1);
 HLock(ipAddrQueueH);
 err = addHint(papaH, 'LpIa', 1, GetHandleSize(ipAddrQueueH), *ipAddrQueueH);
 HUnlock(ipAddrQueueH);
 DisposHandle(ipAddrQueueH);

 ChangedResource(papaH); // mark dirty
 WriteResource(papaH); // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP,
   ConstStr32Param inPrinterName){
 OSErr err;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();

 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error...

 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error...

 // change PAPA resource content
 // See SettingsLib Spec  for psSetInfraredPapa
 err = psSetInfraredPapa(papaH, inPrinterName, ("\p=Ird"));
 // handle error...

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&pgsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 ChangedResource(papaH); // mark dirty
 WriteResource(papaH); // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

//
---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP,
   ConstStr32Param inPrinterName){
 OSErr err;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();

 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error...

 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error...

 // change PAPA resource content
 // See SettingsLib Spec  for psSetHoldPapa
 err = psSetHoldPapa(papaH, inPrinterName, ("\p=Hld"));
 // handle error...

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 ChangedResource(papaH); // mark dirty
 WriteResource(papaH); // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

 struct SaveAsFilePrefs{
 Boolean  saveToFile; // true for printing to file
 Boolean  restricted; // true for printing to file
};

// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP,
   ConstStr32Param inPrinterName,
   FSSpec* destinationFolderP){
 OSErr err;
 short refNum;
 Handle papaH;
 SaveAsFilePrefs saveToFilePref;
 AliasHandle printToDiskAliasH;
 short savedResFile = CurResFile();

 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error...

 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error...

 // change PAPA resource content
 // See SettingsLib Spec  for psSetFilePapa
 err = psSetFilePapa(papaH, inPrinterName, "\p=Fil");
 // handle error...

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 // print to disk hint
 saveToFilePref.saveToFile = TRUE;
 saveToFilePref.restricted = TRUE;
 prefCollection.AddItem('Svap', 1, sizeof(saveToFilePref), &saveToFilePref);

 // set print to disk default folder
 err = NewAliasMinimal(destinationFolderP, &printToDiskAliasH);
 HLock((Handle)printToDiskAliasH);
 err = addHint(papaH, 'Pdka', 1,
  GetHandleSize((Handle)printToDiskAliasH), *printToDiskAliasH);
 HUnlock((Handle)printToDiskAliasH);
 DisposeHandle((Handle)printToDiskAliasH);

 // change PAPA resource content
 ChangedResource(papaH); // mark dirty
 WriteResource(papaH); // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

 typedef struct{           // see "Custom DTPs".
 long flag;                // kIncludeAllFontsBut or kIncludeAllFontsBut
 unsigned char name[1];    // font name
 }FOntHint;

struct CustomAppDesc{
 OSType appSignature;      // target application's signature
 Str255 docType;           // appears in the list of doc. types
                           // when "New" menu is selected
 Str255 helpText;          // lin43, appears when the type of
                           // this DTP is selected
 Str255 usage;             // appears as the DTP usage in the window
 Str255 appFileName;       // default application file name, used in
                           // error message and etc.
 short numOfHintsFollow;   // 1 based
 HintRsrcSpec hintRsrc[1]; // variable length
};
typedef struct CustomAppDesc CustomAppDesc;
typedef struct CustomAppDesc* CustomAppDescPtr;
typedef struct CustomAppDesc** CustomAppDescHdl;


/*
 This routine adds custom DTP hints to the DTP specified papaH.
 The FSSpec of the post-processing application is pointed to by ppApp.
 Note how AliasHandle for the post-processing application is
 generated and added as a 'TGap' hint.
*/
OSErr addCustomDtpParameters(FSSpec* ppApp, Handle papaH){
 OSErr err;
 long psLevel = 1;       // postscript level 1
 Byte binaryOK = 0;      // false
 char job = 0;           // psJobPostScript
 FOntHint fontHint;
 AliasHandle targetAppAliasH;
 CustomAppDesc customAppDesc;

 // postscript level 1
 err = addHint(papaH, 'pslv', 1, siezof(psLevel ), &psLevel ){
 // no Binary
 err = addHint(papaH, 'bnok', 1, siezof(binaryOK ), &binaryOK ){
 // PostScript job
 err = addHint(papaH, 'jobt', 1, siezof(job ), &job ){
 // includeAllFonts
 fontHint.flag = 1;
 fontHint.name [0] = 0;
  err = addHint(papaH, 'font', 1, siezof(fontHint), &fontHint){

 // save target application's location
 err = ::NewAliasMinimal(ppApp, &targetAppAliasH);
 // handle error
 ::HLock((Handle)targetAppAliasH);
 err = addHint('TGap', 1,
  GetHandleSize((Handle)targetAppAliasH),    *targetAppAliasH);
 ::HUnlock((Handle)targetAppAliasH);
 ::DisposeHandle((Handle)targetAppAliasH);

 // if you want Apple's Desktop Printer Utility to recognize and being able to
 // open your DTP, you must add the 'CsDs' hint

 // fill out fields in customAppDesc for post-processing application
 customAppDesc.appSignature = 'xxxx'; // of post-processing application
 /* and all other fields...
 */
 // save custom app's description
 err = addHint(('CsDs', 1, sizeof(customAppDesc), &customAppDesc);
 return err;
}


// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP,
   ConstStr32Param inPrinterName){
 OSErr err;
 FSSpec postProcessAppFsSpec;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();

 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error...

 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error...

 // See SettingsLib Spec  for psSetCustomPapa
 err = psSetCustomPapa(papaH, inPrinterName, "\p=Cst");
 // handle error...

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 // specify post-processing app. and other parameters
 err = FSMakeFSSpec(vRefNum, dirID, "\pYourPostProcessAppName",
  &postProcessAppFsSpec);
 err = addCustomDtpParameters(&postProcessAppFsSpec, papaH);

 // change PAPA resource content
 ChangedResource(papaH); // mark dirty
 WriteResource(papaH);   // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

Acrobat version of this Note (108K).

Download