// --------------------------------------------------------------------------------------------------------------
OSStatus DoPrint(WindowRef parentWindow, void *ourDataP)
{
OSStatus status = noErr;
PMPrintSettings printSettings = NULL;
PMPageFormat pageFormat = NULL;
UInt32 minPage = 1, maxPage;
PMPrintSession printSession;
status = PMCreateSession(&printSession);
if(status == noErr){
status = MySetupPageFormatForPrinting(printSession, ourDataP, &pageFormat);
if (status == noErr)
{
status = PMCreatePrintSettings(&printSettings);
if(status == noErr)
{
status = PMSessionDefaultPrintSettings(printSession, printSettings);
if(status == noErr){
CFStringRef windowTitleRef;
status = CopyWindowTitleAsCFString(parentWindow, &windowTitleRef);
if(status == noErr)
{
// set the job name before displaying the print dialog
status = PMSetJobNameCFString (printSettings, windowTitleRef);
CFRelease (windowTitleRef);
}
}
}
if (status == noErr)
{
maxPage = MyGetDocumentNumPagesInDoc(ourDataP);
status = PMSetPageRange(printSettings, minPage, maxPage);
}
if (status == noErr)
{
Boolean accepted;
SetPrintSettingsOnPrivateData(ourDataP, printSettings);
status = PMSessionUseSheets(printSession, parentWindow, gMyPrintDialogDoneProc);
if(status == noErr)
status = PMSessionPrintDialog(printSession, printSettings,
pageFormat,
&accepted);
// when using sheets, the value of 'accepted' returned here is irrelevant
// since it is our sheet done proc that is called when the dialog is dismissed
}
}
if(status != noErr){
// if we got an error our dialog done proc will not be called so we need to clean up
if(printSettings){
SetPrintSettingsOnPrivateData(ourDataP, NULL);
(void)PMRelease(printSettings);
}
(void)PMRelease(printSession);
}
}
DoErrorAlert(status, kMyPrintErrorFormatStrKey);
return status;
}
OSStatus MakePDFDocument(WindowRef parentWindow, void *documentDataP, CFURLRef saveURL)
{
#pragma unused (parentWindow)
OSStatus err = noErr, tempErr;
PMPrintSettings printSettings = NULL;
PMPrintSession printSession;
err = PMCreateSession(&printSession);
if(err == noErr){
// validate the page format we're going to use
err = PMSessionValidatePageFormat(printSession,
GetPageFormatFromPrivateData(documentDataP),
kPMDontWantBoolean);
if (err == noErr)
{
err = PMCreatePrintSettings(&printSettings);
if(err == noErr)
{
err = PMSessionDefaultPrintSettings(printSession, printSettings);
if(err == noErr){
CFStringRef myDocumentNameRef;
err = CopyDocumentName(documentDataP, &myDocumentNameRef);
if(err == noErr)
{
// set the job name
err = PMSetJobNameCFString (printSettings, myDocumentNameRef);
CFRelease(myDocumentNameRef); // release our reference to the document name
}
}
if (err == noErr)
err = PMSetPageRange(printSettings, 1, MyGetDocumentNumPagesInDoc(documentDataP));
// set our destination to be our target URL and the format to be PDF
if(err == noErr){
// this API exists ONLY in MacOS X 10.1 and later only
if(!err)
err = Call_PMSessionSetDestination(printSession, printSettings,
kPMDestinationFile, kPMDocumentFormatPDF,
saveURL);
}
#if !NO_SAVE_STATUS_DIALOG
/*
It looks a bit odd to call PMSessionUseSheets when we aren't even
using the print dialog BUT the reason we are doing so is so that
the printing status narration will use sheets and not a modal
dialog. NOTE: this is only called when this code is built with
!NO_SAVE_STATUS_DIALOG is true, i.e. we want status narration
of the save to PDF process.
*/
if(err == noErr){
err = PMSessionUseSheets(printSession, parentWindow, NULL);
}
#endif
}
if (err == noErr)
{
err = MyDoPrintLoop(printSession,
GetPageFormatFromPrivateData(documentDataP),
printSettings,
documentDataP,
#if NO_SAVE_STATUS_DIALOG
&gMyPrintingProcsNoStatusDialog
#else
&gMyPrintingProcsWithStatusDialog
#endif
);
}
}
if(printSettings){
tempErr = PMRelease(printSettings);
if(err == noErr)
err = tempErr;
}
tempErr = PMRelease(printSession);
if(err == noErr)
err = tempErr;
}
DoErrorAlert(err, kMySaveAsPDFErrorFormatStrKey);
return err;
}
// --------------------------------------------------------------------------------------
static OSStatus MyDoPrintLoop(PMPrintSession printSession, PMPageFormat pageFormat,
PMPrintSettings printSettings, const void *ourDataP,
const PrintingProcs *printingProcsP)
{
OSStatus err = noErr;
OSStatus tempErr = noErr;
UInt32 firstPage, lastPage, totalDocPages = MyGetDocumentNumPagesInDoc(ourDataP);
if(!err)
err = PMGetFirstPage(printSettings, &firstPage);
if (!err)
err = PMGetLastPage(printSettings, &lastPage);
if(!err && lastPage > totalDocPages){
// don't draw more than the number of pages in our document
lastPage = totalDocPages;
}
if (!err) // tell the printing system the number of pages we are going to print
err = PMSetLastPage(printSettings, lastPage, false);
// Note: we don't have to worry about the number of copies. The printing
// manager handles this. So we just iterate through the document from the
// first page to be printed, to the last.
if (!err)
{
PageDrawProc *drawProc = GetMyDrawPageProc(ourDataP);
err = printingProcsP->BeginDocumentProc(printSession, printSettings, pageFormat);
if (!err){
UInt32 pageNumber = firstPage;
// need to check errors from our print loop and errors from the session for each
// time around our print loop before calling our BeginPageProc
while(pageNumber <= lastPage && err == noErr && PMSessionError(printSession) == noErr)
{
err = printingProcsP->BeginPageProc(printSession, pageFormat, NULL);
if (!err){
GrafPtr oldPort = NULL;
void *printingContext = NULL;
GetPort(&oldPort); // preserve the existing port
err = PMSessionGetGraphicsContext(printSession, kPMGraphicsContextQuickdraw,
(void **)&printingContext);
if(!err){
Rect pageRect;
SetPort((CGrafPtr)printingContext);
GetPortBounds(printingContext, &pageRect);
err = drawProc(ourDataP, &pageRect, pageNumber); // image the correct page
SetPort(oldPort); // restore the prior port
}
// we must call EndPage if BeginPage returned noErr
tempErr = printingProcsP->EndPageProc(printSession);
if(!err)err = tempErr;
}
pageNumber++;
} // end while loop
// we must call EndDocument if BeginDocument returned noErr
tempErr = printingProcsP->EndDocumentProc(printSession);
if(!err)err = tempErr;
if(!err)
err = PMSessionError(printSession);
}
}
return err;
}
// -------------------------------------------------------------------------------
OSStatus DoPrint(WindowRef parentWindow, void *documentDataP, Boolean printOne)
{
OSStatus err = noErr;
PMPrintSettings printSettings = NULL;
UInt32 minPage = 1, maxPage;
PMPrintSession printSession;
err = PMCreateSession(&printSession);
if(err == noErr){
// validate the page format we're going to use
err = PMSessionValidatePageFormat(printSession,
GetPageFormatFromPrivateData(documentDataP),
kPMDontWantBoolean);
if (err == noErr)
{
err = PMCreatePrintSettings(&printSettings);
if(err == noErr)
{
err = PMSessionDefaultPrintSettings(printSession, printSettings);
if(err == noErr){
CFStringRef myDocumentNameRef;
err = CopyDocumentName(documentDataP, &myDocumentNameRef);
if(err == noErr)
{
// set the job name before displaying the print dialog
err = PMSetJobNameCFString (printSettings, myDocumentNameRef);
CFRelease(myDocumentNameRef); // release our reference to the document name
}
}
}
if (err == noErr)
{
/*
On Mac OS X, calling PMSetPageRange has the following benefits:
(a) sets the From/To settings in the print dialog to the range of pages
in the document
AND
(b) the print dialog code enforces this so that users can't enter
values outside this range.
*/
maxPage = MyGetDocumentNumPagesInDoc(documentDataP);
err = PMSetPageRange(printSettings, minPage, maxPage);
}
if (err == noErr)
{
Boolean accepted;
static PMSheetDoneUPP myPrintDialogDoneProc = NULL;
if(!myPrintDialogDoneProc){
myPrintDialogDoneProc = NewPMSheetDoneUPP(MyPrintDialogDoneProc);
if(!myPrintDialogDoneProc)
err = memFullErr;
}
if(!err){
Boolean sheetsAreAvailable = true;
err = SetPrintSettingsOnPrivateData(documentDataP, printSettings);
if(!err){
err = PMSessionUseSheets(printSession, parentWindow, myPrintDialogDoneProc);
if(err == kPMNotImplemented){
// we get here if sheets are not available, i.e. Mac OS 8/9
err = noErr;
sheetsAreAvailable = false;
}
if(err == noErr && !printOne){
err = PMSessionPrintDialog(printSession, printSettings,
GetPageFormatFromPrivateData(documentDataP),
&accepted);
/* when using sheets, the value of 'accepted' returned here is irrelevant
since it is our sheet done proc that is called when the dialog is dismissed.
Our dialog done proc will be called when the sheet is dismissed.
If sheets are NOT implemented then WE call our DialogDone proc here
to complete the dialog.
*/
if(err == noErr && !sheetsAreAvailable)
MyPrintDialogDoneProc(printSession, parentWindow, accepted);
}else{
// if we are doing print one we have no dialog, therefore
// we have to call our dialog done proc since there is no
// dialog to do so for us
if(err == noErr)
MyPrintDialogDoneProc(printSession, parentWindow, true);
}
}
}
}
}
// need to release the print settings this function created.
if(printSettings){
OSStatus tempErr = PMRelease(printSettings);
if(err == noErr)
err = tempErr;
printSettings = NULL;
}
if(err != noErr){
/* normally the printSettings set in the Private Data and printSession would be released
by our dialog done proc but if we got an error and therefore got to this point in our code,
the dialog done proc was NOT called and therefore we need to release the
printSession here
*/
if(printSettings){
// this releases any print settings already stored on our private data
(void)SetPrintSettingsOnPrivateData(documentDataP, NULL);
}
(void)PMRelease(printSession); // ignoring error since we already have one
}
}
DoErrorAlert(err, kMyPrintErrorFormatStrKey);
return err;
}
// --------------------------------------------------------------------------------------------------------------
static OSStatus MyDoPrintLoop(PMPrintSession printSession, PMPageFormat pageFormat,
PMPrintSettings printSettings, const void *ourDataP)
{
OSStatus err = noErr;
OSStatus tempErr = noErr;
UInt32 firstPage, lastPage, totalDocPages = MyGetDocumentNumPagesInDoc(ourDataP);
PMResolution res;
float ourAppScaling = 1.;
err = PMGetResolution(pageFormat, &res);
if(!err){
ourAppScaling = res.hRes/72.; // the scale factor we are applying
}
if(!err)
err = PMGetFirstPage(printSettings, &firstPage);
if (!err)
err = PMGetLastPage(printSettings, &lastPage);
if(!err && lastPage > totalDocPages){
// don't draw more than the number of pages in our document
lastPage = totalDocPages;
}
if (!err) // tell the printing system the number of pages we are going to print
err = PMSetLastPage(printSettings, lastPage, false);
if (!err)
{
PageDrawProc *drawProc = GetMyDrawPageProc(ourDataP);
err = PMSessionBeginDocument(printSession, printSettings, pageFormat);
if (!err){
UInt32 pageNumber;
for(pageNumber = firstPage;
err == noErr && (err = PMSessionError(printSession)) == noErr && pageNumber <= lastPage;
pageNumber++
){
err = PMSessionBeginPage(printSession, pageFormat, NULL);
if (!err){
GrafPtr oldPort = NULL;
void *printingContext = NULL;
GetPort(&oldPort); // preserve the existing port
err = PMSessionGetGraphicsContext(printSession, kPMGraphicsContextQuickdraw,
(void **)&printingContext);
if(!err){
SetPort((CGrafPtr)printingContext);
err = drawProc(ourDataP, ourAppScaling); // supply app drawing resolution
SetPort(oldPort); // restore the prior port
}
tempErr = PMSessionEndPage(printSession);
if(!err)err = tempErr;
}
} // end for loop
tempErr = PMSessionEndDocument(printSession);
if(!err)err = tempErr;
}
}
return err;
}
