| /**************************************************************************** |
| ** |
| ** Copyright (C) 2014 John Layt <jlayt@kde.org> |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the plugins of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include <ApplicationServices/ApplicationServices.h> |
| |
| #include "qcocoaprintdevice.h" |
| |
| #if QT_CONFIG(mimetype) |
| #include <QtCore/qmimedatabase.h> |
| #endif |
| #include <qdebug.h> |
| |
| #include <QtCore/private/qcore_mac_p.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| #ifndef QT_NO_PRINTER |
| |
| // The CUPS PPD APIs were deprecated in CUPS 1.6/macOS 10.8, but |
| // the replacement APIs are unfortunately not sufficient. See: |
| // https://bugreports.qt.io/browse/QTBUG-56545 |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wdeprecated-declarations" |
| |
| static QPrint::DuplexMode macToDuplexMode(const PMDuplexMode &mode) |
| { |
| if (mode == kPMDuplexTumble) |
| return QPrint::DuplexShortSide; |
| else if (mode == kPMDuplexNoTumble) |
| return QPrint::DuplexLongSide; |
| else // kPMDuplexNone or kPMSimplexTumble |
| return QPrint::DuplexNone; |
| } |
| |
| QCocoaPrintDevice::QCocoaPrintDevice() |
| : QPlatformPrintDevice(), |
| m_printer(nullptr), |
| m_session(nullptr), |
| m_ppd(nullptr) |
| { |
| } |
| |
| QCocoaPrintDevice::QCocoaPrintDevice(const QString &id) |
| : QPlatformPrintDevice(id), |
| m_printer(nullptr), |
| m_session(nullptr), |
| m_ppd(nullptr) |
| { |
| if (!id.isEmpty()) { |
| m_printer = PMPrinterCreateFromPrinterID(id.toCFString()); |
| if (m_printer) { |
| m_name = QString::fromCFString(PMPrinterGetName(m_printer)); |
| m_location = QString::fromCFString(PMPrinterGetLocation(m_printer)); |
| CFStringRef cfMakeAndModel; |
| if (PMPrinterGetMakeAndModelName(m_printer, &cfMakeAndModel) == noErr) |
| m_makeAndModel = QString::fromCFString(cfMakeAndModel); |
| Boolean isRemote; |
| if (PMPrinterIsRemote(m_printer, &isRemote) == noErr) |
| m_isRemote = isRemote; |
| if (PMCreateSession(&m_session) == noErr) |
| PMSessionSetCurrentPMPrinter(m_session, m_printer); |
| |
| // No native api to query these options, need to use PPD directly, note is deprecated from 1.6 onwards |
| if (openPpdFile()) { |
| // Note this is if the hardware does multiple copies, not if Cups can |
| m_supportsMultipleCopies = !m_ppd->manual_copies; |
| // Note this is if the hardware does collation, not if Cups can |
| ppd_option_t *collate = ppdFindOption(m_ppd, "Collate"); |
| if (collate) |
| m_supportsCollateCopies = true; |
| m_supportsCustomPageSizes = m_ppd->custom_max[0] > 0 && m_ppd->custom_max[1] > 0; |
| m_minimumPhysicalPageSize = QSize(m_ppd->custom_min[0], m_ppd->custom_min[1]); |
| m_maximumPhysicalPageSize = QSize(m_ppd->custom_max[0], m_ppd->custom_max[1]); |
| m_customMargins = QMarginsF(m_ppd->custom_margins[0], m_ppd->custom_margins[3], |
| m_ppd->custom_margins[2], m_ppd->custom_margins[1]); |
| } |
| } |
| } |
| } |
| |
| QCocoaPrintDevice::~QCocoaPrintDevice() |
| { |
| if (m_ppd) |
| ppdClose(m_ppd); |
| for (PMPaper paper : m_macPapers) |
| PMRelease(paper); |
| // Releasing the session appears to also release the printer |
| if (m_session) |
| PMRelease(m_session); |
| else if (m_printer) |
| PMRelease(m_printer); |
| } |
| |
| bool QCocoaPrintDevice::isValid() const |
| { |
| return m_printer ? true : false; |
| } |
| |
| bool QCocoaPrintDevice::isDefault() const |
| { |
| return PMPrinterIsDefault(m_printer); |
| } |
| |
| QPrint::DeviceState QCocoaPrintDevice::state() const |
| { |
| PMPrinterState state; |
| if (PMPrinterGetState(m_printer, &state) == noErr) { |
| if (state == kPMPrinterIdle) |
| return QPrint::Idle; |
| else if (state == kPMPrinterProcessing) |
| return QPrint::Active; |
| else if (state == kPMPrinterStopped) |
| return QPrint::Error; |
| } |
| return QPrint::Error; |
| } |
| |
| QPageSize QCocoaPrintDevice::createPageSize(const PMPaper &paper) const |
| { |
| CFStringRef key; |
| double width; |
| double height; |
| CFStringRef localizedName; |
| if (PMPaperGetPPDPaperName(paper, &key) == noErr |
| && PMPaperGetWidth(paper, &width) == noErr |
| && PMPaperGetHeight(paper, &height) == noErr |
| && PMPaperCreateLocalizedName(paper, m_printer, &localizedName) == noErr) { |
| QPageSize pageSize = QPlatformPrintDevice::createPageSize(QString::fromCFString(key),QSize(width, height), |
| QString::fromCFString(localizedName)); |
| CFRelease(localizedName); |
| return pageSize; |
| } |
| return QPageSize(); |
| } |
| |
| void QCocoaPrintDevice::loadPageSizes() const |
| { |
| m_pageSizes.clear(); |
| for (PMPaper paper : m_macPapers) |
| PMRelease(paper); |
| m_macPapers.clear(); |
| m_printableMargins.clear(); |
| CFArrayRef paperSizes; |
| if (PMPrinterGetPaperList(m_printer, &paperSizes) == noErr) { |
| int count = CFArrayGetCount(paperSizes); |
| for (int i = 0; i < count; ++i) { |
| PMPaper paper = static_cast<PMPaper>(const_cast<void *>(CFArrayGetValueAtIndex(paperSizes, i))); |
| QPageSize pageSize = createPageSize(paper); |
| if (pageSize.isValid()) { |
| m_pageSizes.append(pageSize); |
| PMRetain(paper); |
| m_macPapers.insert(pageSize.key(), paper); |
| PMPaperMargins printMargins; |
| PMPaperGetMargins(paper, &printMargins); |
| m_printableMargins.insert(pageSize.key(), QMarginsF(printMargins.left, printMargins.top, |
| printMargins.right, printMargins.bottom)); |
| } |
| } |
| } |
| m_havePageSizes = true; |
| } |
| |
| QPageSize QCocoaPrintDevice::defaultPageSize() const |
| { |
| QPageSize pageSize; |
| PMPageFormat pageFormat; |
| PMPaper paper; |
| if (PMCreatePageFormat(&pageFormat) == noErr) { |
| if (PMSessionDefaultPageFormat(m_session, pageFormat) == noErr |
| && PMGetPageFormatPaper(pageFormat, &paper) == noErr) { |
| pageSize = createPageSize(paper); |
| } |
| PMRelease(pageFormat); |
| } |
| return pageSize; |
| } |
| |
| QMarginsF QCocoaPrintDevice::printableMargins(const QPageSize &pageSize, |
| QPageLayout::Orientation orientation, |
| int resolution) const |
| { |
| Q_UNUSED(orientation) |
| Q_UNUSED(resolution) |
| if (!m_havePageSizes) |
| loadPageSizes(); |
| if (m_printableMargins.contains(pageSize.key())) |
| return m_printableMargins.value(pageSize.key()); |
| return m_customMargins; |
| } |
| |
| void QCocoaPrintDevice::loadResolutions() const |
| { |
| m_resolutions.clear(); |
| UInt32 count; |
| if (PMPrinterGetPrinterResolutionCount(m_printer, &count) == noErr) { |
| // 1-based index |
| for (UInt32 i = 1; i <= count; ++i) { |
| PMResolution resolution; |
| if (PMPrinterGetIndexedPrinterResolution(m_printer, i, &resolution) == noErr) |
| m_resolutions.append(int(resolution.hRes)); |
| } |
| } |
| m_haveResolutions = true; |
| } |
| |
| int QCocoaPrintDevice::defaultResolution() const |
| { |
| int defaultResolution = 72; |
| PMPrintSettings settings; |
| if (PMCreatePrintSettings(&settings) == noErr) { |
| PMResolution resolution; |
| if (PMSessionDefaultPrintSettings(m_session, settings) == noErr |
| && PMPrinterGetOutputResolution(m_printer, settings, &resolution) == noErr) { |
| // PMPrinterGetOutputResolution usually fails with -9589 kPMKeyNotFound as not set in PPD |
| defaultResolution = int(resolution.hRes); |
| } |
| PMRelease(settings); |
| } |
| // If no value returned (usually means not set in PPD) then use supported resolutions which |
| // OSX will have populated with at least one default value (but why not returned by call?) |
| if (defaultResolution <= 0) { |
| if (!m_haveResolutions) |
| loadResolutions(); |
| if (m_resolutions.count() > 0) |
| return m_resolutions.at(0); // First value or highest? Only likely to be one anyway. |
| return 72; // TDOD More sensible default value??? |
| } |
| return defaultResolution; |
| } |
| |
| void QCocoaPrintDevice::loadInputSlots() const |
| { |
| // NOTE: Implemented in both CUPS and Mac plugins, please keep in sync |
| // TODO Deal with concatenated names like Tray1Manual or Tray1_Man, |
| // will currently show as CustomInputSlot |
| // TODO Deal with separate ManualFeed key |
| // Try load standard PPD options first |
| m_inputSlots.clear(); |
| if (m_ppd) { |
| ppd_option_t *inputSlots = ppdFindOption(m_ppd, "InputSlot"); |
| if (inputSlots) { |
| for (int i = 0; i < inputSlots->num_choices; ++i) |
| m_inputSlots.append(QPrintUtils::ppdChoiceToInputSlot(inputSlots->choices[i])); |
| } |
| // If no result, try just the default |
| if (m_inputSlots.size() == 0) { |
| inputSlots = ppdFindOption(m_ppd, "DefaultInputSlot"); |
| if (inputSlots) |
| m_inputSlots.append(QPrintUtils::ppdChoiceToInputSlot(inputSlots->choices[0])); |
| } |
| } |
| // If still no result, just use Auto |
| if (m_inputSlots.size() == 0) |
| m_inputSlots.append(QPlatformPrintDevice::defaultInputSlot()); |
| m_haveInputSlots = true; |
| } |
| |
| QPrint::InputSlot QCocoaPrintDevice::defaultInputSlot() const |
| { |
| // No native api to query, use PPD directly |
| // NOTE: Implemented in both CUPS and Mac plugins, please keep in sync |
| // Try load standard PPD option first |
| if (m_ppd) { |
| ppd_option_t *inputSlot = ppdFindOption(m_ppd, "DefaultInputSlot"); |
| if (inputSlot) |
| return QPrintUtils::ppdChoiceToInputSlot(inputSlot->choices[0]); |
| // If no result, then try a marked option |
| ppd_choice_t *defaultChoice = ppdFindMarkedChoice(m_ppd, "InputSlot"); |
| if (defaultChoice) |
| return QPrintUtils::ppdChoiceToInputSlot(*defaultChoice); |
| } |
| // Otherwise return Auto |
| return QPlatformPrintDevice::defaultInputSlot(); |
| } |
| |
| void QCocoaPrintDevice::loadOutputBins() const |
| { |
| // No native api to query, use PPD directly |
| // NOTE: Implemented in both CUPS and Mac plugins, please keep in sync |
| m_outputBins.clear(); |
| if (m_ppd) { |
| ppd_option_t *outputBins = ppdFindOption(m_ppd, "OutputBin"); |
| if (outputBins) { |
| for (int i = 0; i < outputBins->num_choices; ++i) |
| m_outputBins.append(QPrintUtils::ppdChoiceToOutputBin(outputBins->choices[i])); |
| } |
| // If no result, try just the default |
| if (m_outputBins.size() == 0) { |
| outputBins = ppdFindOption(m_ppd, "DefaultOutputBin"); |
| if (outputBins) |
| m_outputBins.append(QPrintUtils::ppdChoiceToOutputBin(outputBins->choices[0])); |
| } |
| } |
| // If still no result, just use Auto |
| if (m_outputBins.size() == 0) |
| m_outputBins.append(QPlatformPrintDevice::defaultOutputBin()); |
| m_haveOutputBins = true; |
| } |
| |
| QPrint::OutputBin QCocoaPrintDevice::defaultOutputBin() const |
| { |
| // No native api to query, use PPD directly |
| // NOTE: Implemented in both CUPS and Mac plugins, please keep in sync |
| // Try load standard PPD option first |
| if (m_ppd) { |
| ppd_option_t *outputBin = ppdFindOption(m_ppd, "DefaultOutputBin"); |
| if (outputBin) |
| return QPrintUtils::ppdChoiceToOutputBin(outputBin->choices[0]); |
| // If no result, then try a marked option |
| ppd_choice_t *defaultChoice = ppdFindMarkedChoice(m_ppd, "OutputBin"); |
| if (defaultChoice) |
| return QPrintUtils::ppdChoiceToOutputBin(*defaultChoice); |
| } |
| // Otherwise return AutoBin |
| return QPlatformPrintDevice::defaultOutputBin(); |
| } |
| |
| void QCocoaPrintDevice::loadDuplexModes() const |
| { |
| // No native api to query, use PPD directly |
| // NOTE: Implemented in both CUPS and Mac plugins, please keep in sync |
| // Try load standard PPD options first |
| m_duplexModes.clear(); |
| if (m_ppd) { |
| ppd_option_t *duplexModes = ppdFindOption(m_ppd, "Duplex"); |
| if (duplexModes) { |
| for (int i = 0; i < duplexModes->num_choices; ++i) |
| m_duplexModes.append(QPrintUtils::ppdChoiceToDuplexMode(duplexModes->choices[i].choice)); |
| } |
| // If no result, try just the default |
| if (m_duplexModes.size() == 0) { |
| duplexModes = ppdFindOption(m_ppd, "DefaultDuplex"); |
| if (duplexModes) |
| m_duplexModes.append(QPrintUtils::ppdChoiceToDuplexMode(duplexModes->choices[0].choice)); |
| } |
| } |
| // If still no result, or not added in PPD, then add None |
| if (m_duplexModes.size() == 0 || !m_duplexModes.contains(QPrint::DuplexNone)) |
| m_duplexModes.append(QPrint::DuplexNone); |
| // If have both modes, then can support DuplexAuto |
| if (m_duplexModes.contains(QPrint::DuplexLongSide) && m_duplexModes.contains(QPrint::DuplexShortSide)) |
| m_duplexModes.append(QPrint::DuplexAuto); |
| m_haveDuplexModes = true; |
| } |
| |
| QPrint::DuplexMode QCocoaPrintDevice::defaultDuplexMode() const |
| { |
| QPrint::DuplexMode defaultMode = QPrint::DuplexNone; |
| PMPrintSettings settings; |
| if (PMCreatePrintSettings(&settings) == noErr) { |
| PMDuplexMode duplexMode; |
| if (PMSessionDefaultPrintSettings(m_session, settings) == noErr |
| && PMGetDuplex(settings, &duplexMode) == noErr) { |
| defaultMode = macToDuplexMode(duplexMode); |
| } |
| PMRelease(settings); |
| } |
| return defaultMode; |
| } |
| |
| void QCocoaPrintDevice::loadColorModes() const |
| { |
| // No native api to query, use PPD directly |
| m_colorModes.clear(); |
| m_colorModes.append(QPrint::GrayScale); |
| if (!m_ppd || (m_ppd && m_ppd->color_device)) |
| m_colorModes.append(QPrint::Color); |
| m_haveColorModes = true; |
| } |
| |
| QPrint::ColorMode QCocoaPrintDevice::defaultColorMode() const |
| { |
| // No native api to query, use PPD directly |
| // NOTE: Implemented in both CUPS and Mac plugins, please keep in sync |
| // Not a proper option, usually only know if supports color or not, but some |
| // users known to abuse ColorModel to always force GrayScale. |
| if (m_ppd && supportedColorModes().contains(QPrint::Color)) { |
| ppd_option_t *colorModel = ppdFindOption(m_ppd, "DefaultColorModel"); |
| if (!colorModel) |
| colorModel = ppdFindOption(m_ppd, "ColorModel"); |
| if (!colorModel || qstrcmp(colorModel->defchoice, "Gray") != 0) |
| return QPrint::Color; |
| } |
| return QPrint::GrayScale; |
| } |
| |
| #if QT_CONFIG(mimetype) |
| void QCocoaPrintDevice::loadMimeTypes() const |
| { |
| // TODO Check how settings affect returned list |
| m_mimeTypes.clear(); |
| QMimeDatabase db; |
| PMPrintSettings settings; |
| if (PMCreatePrintSettings(&settings) == noErr) { |
| CFArrayRef mimeTypes; |
| if (PMPrinterGetMimeTypes(m_printer, settings, &mimeTypes) == noErr) { |
| int count = CFArrayGetCount(mimeTypes); |
| for (int i = 0; i < count; ++i) { |
| CFStringRef mimeName = static_cast<CFStringRef>(const_cast<void *>(CFArrayGetValueAtIndex(mimeTypes, i))); |
| QMimeType mimeType = db.mimeTypeForName(QString::fromCFString(mimeName)); |
| if (mimeType.isValid()) |
| m_mimeTypes.append(mimeType); |
| } |
| } |
| PMRelease(settings); |
| } |
| m_haveMimeTypes = true; |
| } |
| #endif // mimetype |
| |
| bool QCocoaPrintDevice::openPpdFile() |
| { |
| if (m_ppd) |
| ppdClose(m_ppd); |
| m_ppd = nullptr; |
| CFURLRef ppdURL = nullptr; |
| char ppdPath[MAXPATHLEN]; |
| if (PMPrinterCopyDescriptionURL(m_printer, kPMPPDDescriptionType, &ppdURL) == noErr |
| && ppdURL) { |
| if (CFURLGetFileSystemRepresentation(ppdURL, true, (UInt8*)ppdPath, sizeof(ppdPath))) |
| m_ppd = ppdOpenFile(ppdPath); |
| CFRelease(ppdURL); |
| } |
| return m_ppd ? true : false; |
| } |
| |
| PMPrinter QCocoaPrintDevice::macPrinter() const |
| { |
| return m_printer; |
| } |
| |
| // Returns a cached printer PMPaper, or creates and caches a new custom PMPaper |
| // Caller should never release a cached PMPaper! |
| PMPaper QCocoaPrintDevice::macPaper(const QPageSize &pageSize) const |
| { |
| if (!m_havePageSizes) |
| loadPageSizes(); |
| // If keys match, then is a supported size or an existing custom size |
| if (m_macPapers.contains(pageSize.key())) |
| return m_macPapers.value(pageSize.key()); |
| // For any other page size, whether custom or just unsupported, needs to be a custom PMPaper |
| PMPaper paper = nullptr; |
| PMPaperMargins paperMargins; |
| paperMargins.left = m_customMargins.left(); |
| paperMargins.right = m_customMargins.right(); |
| paperMargins.top = m_customMargins.top(); |
| paperMargins.bottom = m_customMargins.bottom(); |
| PMPaperCreateCustom(m_printer, QCFString(pageSize.key()), QCFString(pageSize.name()), |
| pageSize.sizePoints().width(), pageSize.sizePoints().height(), |
| &paperMargins, &paper); |
| m_macPapers.insert(pageSize.key(), paper); |
| return paper; |
| } |
| |
| #pragma clang diagnostic pop |
| |
| #endif // QT_NO_PRINTER |
| |
| QT_END_NAMESPACE |
