// --------------------------------------------------------------------------------------------------------------
OSStatus DoPageSetup(WindowRef window, void *docDataP)
{
OSStatus err = noErr;
if(docDataP){
PMPrintSession printSession;
PMPageFormat pageFormat = NULL;
err = PMCreateSession(&printSession);
if(!err){
Boolean accepted;
err = MySetupPageFormatForPrinting(printSession, docDataP, &pageFormat);
if(!err){
Cursor arrow;
SetCursor(GetQDGlobalsArrow(&arrow));
err = PMSessionUseSheets(printSession, window, gMyPageSetupDoneProc);
if(!err)
err = PMSessionPageSetupDialog(printSession, 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(err){ // only if there is an error do we release the session
// otherwise we'll do that in our sheet done proc
(void)PMRelease(printSession);
}
}
}
DoErrorAlert(err, kMyPrintErrorFormatStrKey);
return err;
} // DoPageSetup
// ---------------------------------------------------------------------------
//
// ------------
bool bXMapPrintSetup::process(int msg, void* prm){
_bTrace_("bXMapPrintSetup::process",true);
PMPrintSession ps=NULL;
PMPageFormat pf=kPMNoPageFormat;
OSStatus status=PMCreateSession(&ps);
_gapp->printMgr()->get_page_format(&pf,kMapPageFormatName);
for(;;){
if(status!=noErr){
break;
}
status=DoPageSetupDialog(ps,&pf);
if(status!=noErr){
break;
}
break;
}
if(pf!=kPMNoPageFormat){
_gapp->printMgr()->set_page_format(pf,kMapPageFormatName);
(void)PMRelease(pf);
}
if(ps){
(void)PMRelease(ps);
}
return(true);
}
//-----------------------------------------------------------------------------------------------------------------------
void ProcessPrintCommand(DocStoragePtr docStP, UInt32 commandID)
{
OSStatus err = noErr;
PMPrintSession printSession = NULL;
if ( PMCreateSession(&printSession) == noErr )
{
if (commandID == kHICommandPageSetup)
{
DoPageSetupDialog(printSession, &docStP->pageFormat, &docStP->flattenedPageFormat);
}
else if (commandID == kHICommandPrint)
{
if (docStP->pageFormat == NULL)
{
err = MyCreatePageFormat(printSession, &docStP->pageFormat);
}
if (DoPrintDialog(printSession, docStP->pageFormat, &docStP->printSettings) == noErr)
{
DoPrintLoop(docStP, printSession, docStP->pageFormat, docStP->printSettings);
}
}
PMRelease(printSession);
}
else
{
fprintf(stderr, "PMCreateSession FAILED\n");
}
} // ProcessPrintCommand
OSStatus OpenPrinterAndValidate(void)
{
OSStatus err = noErr;
#if TARGET_API_MAC_CARBON
/////////////////////////////////////////////////
err = PMCreateSession(&gPrintSession);
if(err) return err;
// get and validate the page formatting
if (gPageFormat == kPMNoPageFormat) { // Set up a valid PageFormat object
err = PMCreatePageFormat(&gPageFormat);
// Note that PMPageFormat is not session-specific, but calling
// PMSessionDefaultPageFormat assigns values specific to the printer
// associated with the current printing session.
if ((err == noErr) && (gPageFormat != kPMNoPageFormat))
err = PMSessionDefaultPageFormat(gPrintSession, gPageFormat);
}
else{
err = PMSessionValidatePageFormat(gPrintSession, gPageFormat, kPMDontWantBoolean);
}
if(err) return err;
/////////////////////////////////////////////////
// let's also get and validate the print settings
if (gPrintSettings == kPMNoPrintSettings)
{
err = PMCreatePrintSettings(&gPrintSettings);
// Note that PMPrintSettings is not session-specific, but calling
// PMSessionDefaultPrintSettings assigns values specific to the printer
// associated with the current printing session.
if ((err == noErr) && (gPrintSettings != kPMNoPrintSettings))
err = PMSessionDefaultPrintSettings(gPrintSession, gPrintSettings);
}
else {
err = PMSessionValidatePrintSettings(gPrintSession, gPrintSettings, kPMDontWantBoolean);
}
return err;
#else //// MACB4CARBON ////////////////////////////////////////
/////////////////////////////////////////////////
PrOpen();
err = PrError();
if(err) return err;
// always use the global
if(gPrRecHdl == nil){
gPrRecHdl = (THPrint)_NewHandleClear(sizeof(TPrint));
if(!gPrRecHdl)return memFullErr;
PrintDefault(gPrRecHdl);
}
PrValidate(gPrRecHdl);
// We ignore the returned value
return(noErr);
#endif
}
// --------------------------------------------------------------------------------------------------------------
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;
}
bool QPrinter::cmd(int c, QPainter *, QPDevCmdParam *)
{
if (!psession && PMCreateSession(&psession) != noErr)
return FALSE;
if (c == PdcBegin) { // begin; start printing
if (state != PST_IDLE) {
qDebug("Qt: internal: printer: two PdcBegin(s).");
return FALSE;
}
//just to be sure they've been setup
prepare(&pformat);
prepare(&psettings);
//validate the settings
if (PMSessionValidatePrintSettings(psession, psettings, kPMDontWantBoolean) != noErr)
return FALSE;
if (PMSessionValidatePageFormat(psession, pformat, kPMDontWantBoolean) != noErr)
return FALSE;
if (PMSessionBeginDocument(psession, psettings, pformat) != noErr) //begin the document
return FALSE;
if (PMSessionBeginPage(psession, pformat, 0) != noErr) //begin the page
return FALSE;
if (PMSessionGetGraphicsContext(psession, kPMGraphicsContextQuickdraw,
&hd) != noErr) //get the gworld
return FALSE;
state = PST_ACTIVE;
if (fullPage()) {
uint top, left, bottom, right;
qt_get_margins(pformat, &top, &left, &bottom, &right);
QMacSavedPortInfo mp(this);
SetOrigin(top, left);
} else {
QMacSavedPortInfo mp(this);
SetOrigin(0, 0);
}
} else if (c == PdcEnd) {
if (hd && state != PST_IDLE) {
PMSessionEndPage(psession);
PMSessionEndDocument(psession);
hd = NULL;
}
state = PST_IDLE;
} else { // all other commands...
if (state == PST_ABORTED || ((state == PST_ACTIVE || state == PST_ERROR) && PMSessionError(psession) != noErr))
return FALSE;
}
return TRUE;
}
void wxMacCarbonPrintData::ValidateOrCreate()
{
OSStatus err = noErr ;
if ( m_macPrintSession == kPMNoReference )
{
err = PMCreateSession( (PMPrintSession *) &m_macPrintSession ) ;
}
// Set up a valid PageFormat object.
if ( m_macPageFormat == kPMNoPageFormat)
{
err = PMCreatePageFormat((PMPageFormat *) &m_macPageFormat);
// Note that PMPageFormat is not session-specific, but calling
// PMSessionDefaultPageFormat assigns values specific to the printer
// associated with the current printing session.
if ((err == noErr) &&
( m_macPageFormat != kPMNoPageFormat))
{
err = PMSessionDefaultPageFormat((PMPrintSession) m_macPrintSession,
(PMPageFormat) m_macPageFormat);
}
}
else
{
err = PMSessionValidatePageFormat((PMPrintSession) m_macPrintSession,
(PMPageFormat) m_macPageFormat,
kPMDontWantBoolean);
}
// Set up a valid PrintSettings object.
if ( m_macPrintSettings == kPMNoPrintSettings)
{
err = PMCreatePrintSettings((PMPrintSettings *) &m_macPrintSettings);
// Note that PMPrintSettings is not session-specific, but calling
// PMSessionDefaultPrintSettings assigns values specific to the printer
// associated with the current printing session.
if ((err == noErr) &&
( m_macPrintSettings != kPMNoPrintSettings))
{
err = PMSessionDefaultPrintSettings((PMPrintSession) m_macPrintSession,
(PMPrintSettings) m_macPrintSettings);
}
}
else
{
err = PMSessionValidatePrintSettings((PMPrintSession) m_macPrintSession,
(PMPrintSettings) m_macPrintSettings,
kPMDontWantBoolean);
}
}
// -----------------------------------------------------------------
OSStatus DoPageSetup(WindowRef window, void *docDataP)
{
OSStatus err = noErr;
if(docDataP){
PMPrintSession printSession;
err = PMCreateSession(&printSession);
if(!err){
Boolean accepted;
static PMSheetDoneUPP myPageSetupDoneProc = NULL;
if(!myPageSetupDoneProc){
myPageSetupDoneProc = NewPMSheetDoneUPP(MyPageSetupDoneProc);
if(!myPageSetupDoneProc){
err = memFullErr;
}
}
if(!err) // validate the page format we're going to pass to the dialog code
err = PMSessionValidatePageFormat(printSession, GetPageFormatFromPrivateData(docDataP),
kPMDontWantBoolean);
if(!err){
Boolean sheetsAreAvailable = true;
err = PMSessionUseSheets(printSession, window, myPageSetupDoneProc);
if(err == kPMNotImplemented){
// sheets are not available (aka, Mac OS 8/9)
err = noErr;
sheetsAreAvailable = false;
}
if(!err){
err = PMSessionPageSetupDialog(printSession, GetPageFormatFromPrivateData(docDataP), &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)
MyPageSetupDoneProc(printSession, window, accepted);
}
}
if(err){ // only if there is an error do we release the session,
// otherwise we'll do that in our sheet done proc
(void)PMRelease(printSession);
}
}
}
DoErrorAlert(err, kMyPrintErrorFormatStrKey);
return err;
} // DoPageSetup
wxOSXCarbonPrintData::wxOSXCarbonPrintData()
{
if ( PMCreateSession( &m_macPrintSession ) == noErr )
{
if ( PMCreatePageFormat(&m_macPageFormat) == noErr )
{
PMSessionDefaultPageFormat(m_macPrintSession,
m_macPageFormat);
PMGetPageFormatPaper(m_macPageFormat, &m_macPaper);
}
if ( PMCreatePrintSettings(&m_macPrintSettings) == noErr )
{
PMSessionDefaultPrintSettings(m_macPrintSession,
m_macPrintSettings);
}
}
}
static boolean
carbonSessionPrintSession()
{
#if TARGET_API_MAC_CARBON == 1
OSStatus theErr;
if (nil == shellprintinfo.printhandle)
{
theErr = PMCreateSession(&shellprintinfo.printhandle);
if(theErr != noErr)
{
shellprintinfo.printhandle = nil;
return (false);
}
}
#endif
return(true);
}
/*------------------------------------------------------------------------------
Allow the user define the page setup for printing to current printer
Parameters:
printSession - current printing session
pageFormat - a PageFormat object addr
Description:
If the caller passes in an empty PageFormat object, create a new one,
otherwise validate the one provided by the caller.
Invokes the Page Setup dialog and checks for Cancel.
Flattens the PageFormat object so it can be saved with the document.
Note that the PageFormat object is modified by this function.
------------------------------------------------------------------------------*/
static void _doPageSetupDialog(PMPageFormat* pageFormat)
{
OSStatus status;
Boolean accepted;
PMPrintSession printSession;
status = PMCreateSession(&printSession);
if ( noErr != status )
{
PostPrintingErrors(status);
return;
}
// Set up a valid PageFormat object.
if (*pageFormat == kPMNoPageFormat)
{
status = PMCreatePageFormat(pageFormat);
// Note that PMPageFormat is not session-specific, but calling
// PMSessionDefaultPageFormat assigns values specific to the printer
// associated with the current printing session.
if ((status == noErr) && (*pageFormat != kPMNoPageFormat))
status = PMSessionDefaultPageFormat(printSession, *pageFormat);
}
else
{
status = PMSessionValidatePageFormat(printSession, *pageFormat, kPMDontWantBoolean);
}
// Display the Page Setup dialog.
if (status == noErr)
{
status = PMSessionPageSetupDialog(printSession, *pageFormat, &accepted);
if (!accepted)
{
status = kPMCancel; // user clicked Cancel button
}
}
status = PMRelease(printSession);
return;
}
static void initPrinter () {
Boolean result;
PMResolution res300 = { 300, 300 }, res600 = { 600, 600 };
if (! theMacPrintSettings) { // once
PMCreateSession (& theMacPrintSession); // initialize the Printing Manager
PMCreatePageFormat (& theMacPageFormat);
PMCreatePrintSettings (& theMacPrintSettings);
PMSessionDefaultPageFormat (theMacPrintSession, theMacPageFormat);
PMSessionDefaultPrintSettings (theMacPrintSession, theMacPrintSettings);
}
PMSessionValidatePageFormat (theMacPrintSession, theMacPageFormat, & result);
PMSessionValidatePrintSettings (theMacPrintSession, theMacPrintSettings, & result);
/*
* BUG.
* If we now ask for the available printer resolutions,
* we may get the answer that there's only 300 dpi (perhaps PostScript drivers say so?).
* So we don't rely on that and have a buggy assumption instead.
*/
PMSetResolution (theMacPageFormat, & res300); // perhaps all printers have this...
PMSetResolution (theMacPageFormat, & res600); // ... but this is preferred
}
bool
QPrinter::prepare(PMPrintSettings *s)
{
if (!psession && PMCreateSession(&psession) != noErr)
return FALSE;
if (*s == kPMNoPrintSettings) {
if (PMCreatePrintSettings(s) != noErr)
return FALSE;
if (PMSessionDefaultPrintSettings(psession, *s) != noErr)
return FALSE;
} else {
if (PMSessionValidatePrintSettings(psession, *s, kPMDontWantBoolean) != noErr)
return FALSE;
}
if (minPage() != 0 || maxPage() != 0)
PMSetPageRange(*s, minPage(), maxPage());
if (d->printRange != AllPages) {
PMSetFirstPage(*s, fromPage(), TRUE);
PMSetLastPage(*s, toPage(), TRUE);
}
PMSetColorMode(*s, colorMode() == GrayScale ? kPMGray : kPMColor);
PMSetCopies(*s, numCopies(), TRUE);
if (outputToFile()) {
CFStringRef cfstring = qstring2cfstring(outputFileName());
CFURLRef outFile = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, cfstring,
kCFURLPOSIXPathStyle, false);
PMSessionSetDestination(psession, *s, kPMDestinationFile, kPMDocumentFormatPDF, outFile);
CFRelease(outFile);
CFRelease(cfstring);
}
QString printName = printerName();
if (!printName.isEmpty()) {
CFStringRef pname = qstring2cfstring(printName);
PMSessionSetCurrentPrinter(psession, pname);
CFRelease(pname);
}
return TRUE;
}
// -----------------------------------------------------------------------
OSStatus CreateDefaultPageFormatForDocument(void *docDataP)
{
OSStatus err = noErr, tempErr;
PMPrintSession printSession;
err = PMCreateSession(&printSession);
if(!err){
PMPageFormat pageFormat;
err = PMCreatePageFormat(&pageFormat); // we own a reference to this page format
if(err == noErr)
{
err = PMSessionDefaultPageFormat(printSession, pageFormat);
if (err == noErr){
// this routine will keep its own reference to the pageFormat
err = SetPageFormatOnPrivateData(docDataP, pageFormat);
}
tempErr = PMRelease(pageFormat);// release our reference obtained from PMCreatePageFormat
if(!err)err = tempErr;
}
tempErr = PMRelease(printSession);
if(!err)err = tempErr;
}
return err;
}
/*!
\internal
*/
bool QPrinter::pageSetup()
{
if(!psession && PMCreateSession(&psession) != noErr)
return FALSE;
QMacBlockingFunction block;
//page format
if(!prepare(&pformat))
return FALSE;
{ //simulate modality
QWidget modal_widg(0, __FILE__ "__modal_dlg",
Qt::WType_TopLevel | Qt::WStyle_Customize | Qt::WStyle_DialogBorder);
qt_enter_modal(&modal_widg);
Boolean ret;
if(PMSessionPageSetupDialog(psession, pformat, &ret) != noErr)
ret = FALSE;
qt_leave_modal(&modal_widg);
if(!ret)
return FALSE;
}
interpret(&pformat);
return TRUE;
}
bool
QPrinter::prepare(PMPageFormat *f)
{
if (!psession && PMCreateSession(&psession) != noErr)
return FALSE;
if (*f == kPMNoPageFormat) {
if (PMCreatePageFormat(f) != noErr)
return FALSE;
if (PMSessionDefaultPageFormat(psession, *f) != noErr)
return FALSE;
} else {
if (PMSessionValidatePageFormat(psession, *f, kPMDontWantBoolean) != noErr)
return FALSE;
}
if (page_size != carbonSize2QPrinterSize(*f))
qprinterSize2CarbonSize(page_size, *f, psession);
PMSetOrientation(*f, orientation() == Portrait ? kPMPortrait : kPMLandscape, TRUE);
PMResolution pres;
pres.hRes = res;
pres.vRes = res;
PMSetResolution(*f, &pres);
return TRUE;
}
/*------------------------------------------------------------------------------
Description:
Uses PMCreateSession/PMRelease instead of PMBegin/PMEnd. Note that the two
printing objects, PMPageSetup and PMPrintSettings are valid outside the
printing session. This was not the case with PMBegin/PMEnd in the previous
version of this sample code. Note also that no nesting of printing sessions
is allowed for Carbon applications running under MacOS 8 or 9.
------------------------------------------------------------------------------*/
int ioPrintSetup(PrintingLogicPtr *token)
{
OSStatus status = noErr;
PrintingLogicPtr printJob;
printJob = *token = calloc(1,sizeof(PrintingLogic));
printJob->printSession = NULL;
printJob->pageFormat = kPMNoPageFormat;
printJob->printSettings = kPMNoPrintSettings;
printJob->flatFormatHandle = NULL;
printJob->numberOfPages = 0;
printJob->aGWorld = NULL;
// Initialize the printing manager and create a printing session.
status = PMCreateSession(&printJob->printSession);
if (status != noErr)
return -1; // pointless to continue if PMCreateSession fails
// Display the Page Setup dialog.
if (status == noErr) {
status = DoPageSetupDialog(printJob);
}
return status;
}
// -------------------------------------------------------------------------------
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;
}
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;
}
bool QPrinter::setup(QWidget *)
{
if (!psession && PMCreateSession(&psession) != noErr)
return FALSE;
return (printSetup() && pageSetup());
}
void QMacPrintEnginePrivate::initialize()
{
Q_ASSERT(!session);
Q_Q(QMacPrintEngine);
if (!paintEngine)
paintEngine = new QCoreGraphicsPaintEngine();
q->gccaps = paintEngine->gccaps;
fullPage = false;
if (PMCreateSession(&session) != noErr)
session = 0;
PMPrinter printer;
if (session && PMSessionGetCurrentPrinter(session, &printer) == noErr) {
QList<QVariant> resolutions = supportedResolutions();
if (!resolutions.isEmpty() && mode != QPrinter::ScreenResolution) {
if (resolutions.count() > 1 && mode == QPrinter::HighResolution) {
int max = 0;
for (int i = 0; i < resolutions.count(); ++i) {
int value = resolutions.at(i).toInt();
if (value > max)
max = value;
}
resolution.hRes = resolution.vRes = max;
} else {
resolution.hRes = resolution.vRes = resolutions.at(0).toInt();
}
if(resolution.hRes == 0)
resolution.hRes = resolution.vRes = 600;
} else {
resolution.hRes = resolution.vRes = qt_defaultDpi();
}
}
bool settingsInitialized = (settings != 0);
bool settingsOK = !settingsInitialized ? PMCreatePrintSettings(&settings) == noErr : true;
if (settingsOK && !settingsInitialized)
settingsOK = PMSessionDefaultPrintSettings(session, settings) == noErr;
bool formatInitialized = (format != 0);
bool formatOK = !formatInitialized ? PMCreatePageFormat(&format) == noErr : true;
if (formatOK) {
if (!formatInitialized) {
formatOK = PMSessionDefaultPageFormat(session, format) == noErr;
}
formatOK = PMSessionValidatePageFormat(session, format, kPMDontWantBoolean) == noErr;
}
#ifndef Q_OS_MAC64
# if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
if (QSysInfo::MacintoshVersion < QSysInfo::MV_10_4)
# endif
{
if(paintEngine->type() == QPaintEngine::CoreGraphics) {
CFStringRef strings[1] = { kPMGraphicsContextCoreGraphics };
QCFType<CFArrayRef> contextArray = CFArrayCreate(kCFAllocatorDefault,
reinterpret_cast<const void **>(strings),
1, &kCFTypeArrayCallBacks);
OSStatus err = PMSessionSetDocumentFormatGeneration(session, kPMDocumentFormatPDF,
contextArray, 0);
if(err != noErr) {
qWarning("QMacPrintEngine::initialize: Cannot set format generation to PDF: %ld", err);
state = QPrinter::Error;
}
}
}
#endif
if (!settingsOK || !formatOK) {
qWarning("QMacPrintEngine::initialize: Unable to initialize QPainter");
state = QPrinter::Error;
}
QHash<QMacPrintEngine::PrintEnginePropertyKey, QVariant>::const_iterator propC;
for (propC = valueCache.constBegin(); propC != valueCache.constEnd(); propC++) {
q->setProperty(propC.key(), propC.value());
}
}
QPrinter::QPrinter(PrinterMode m) : QPaintDevice(QInternal::Printer | QInternal::ExternalDevice)
{
d = new QPrinterPrivate;
if (PMCreateSession(&psession) != noErr)
psession = NULL;
switch (m) {
case Compatible:
devFlags |= QInternal::CompatibilityMode;
// fall through
case PrinterResolution:
case HighResolution: {
bool found = FALSE;
PMPrinter printer = 0;
if (psession && PMSessionGetCurrentPrinter(psession, &printer) == noErr) {
PMResolution pres;
UInt32 count = 0, maxRes = 0;
if (PMPrinterGetPrinterResolutionCount(printer, &count) == noErr && count)
for (; count > 0; --count)
if (PMPrinterGetIndexedPrinterResolution(printer, count, &pres) == noErr) {
found = TRUE;
maxRes = QMAX((uint)pres.vRes, maxRes);
res = maxRes;
}
}
if (!found)
res = 600; //just to have something
break;
}
case ScreenResolution: {
short vr, hr;
ScreenRes(&hr, &vr);
res = vr;
break;
}
}
if (PMCreatePageFormat(&pformat) == noErr &&
PMSessionDefaultPageFormat(psession, pformat) == noErr)
page_size = carbonSize2QPrinterSize(pformat);
else
page_size = A4;
//other
orient = Portrait;
page_order = FirstPageFirst;
paper_source = OnlyOne;
color_mode = GrayScale;
ncopies = 1;
from_pg = to_pg = min_pg = max_pg = 0;
state = PST_IDLE;
output_file = FALSE;
to_edge = FALSE;
//mac specific
pformat = kPMNoPageFormat;
psettings = kPMNoPrintSettings;
prepare(&pformat);
prepare(&psettings);
interpret(&pformat);
interpret(&psettings);
d->printerOptions = 0;
setPrintRange(AllPages);
}
