pdfoutput.h

Go to the documentation of this file.

/*
 * pdfoutput.h
 *
 * Copyright (C) 2014-2026 Hybrid Software Helix Ltd. All rights reserved.
 */
 
#ifndef JAWSMAKO_PDFOUTPUT_H
#define JAWSMAKO_PDFOUTPUT_H

 
#include <jawsmako/jawsmako.h>
#include <jawsmako/transforms.h>
 
namespace JawsMako
{
    using namespace EDL;
 
    class IPDFOutput;
    DECL_SMART_PTR(IPDFOutput);

    class IPDFOutput : public IOutput
    {
      public:
        virtual ~IPDFOutput() {}

        JAWSMAKO_API static IPDFOutputPtr create(const IJawsMakoPtr &jawsMako, 
                                                 const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         * PDF Output-specific configuration
         */
 
        /* Bit positions for ePDFVersion so that we can store a PDF version number
         * plus the flavor (like PDF/A or PDF/X). We use a total of 28 bits so it
         * fits in a 32-bit int.
         *
         *      (field:size)        (offset)
         *      variantType:8       20
         *      variantVer:4        16
         *      variantVerSub:8     8
         *      verMajor:4          4
         *      verMinor:4          0
         */
 
        #define MAKE_PDF_VERSION(major,minor)                               ( ((major) << 4) | (minor) )
        #define MAKE_PDF_VARIANT(variantType,variantVer,variantVerSub)      ( ((variantType) << 20) | ((variantVer) << 16) | ((variantVerSub) << 8) )
 
        #define GET_PDF_VERSION_MAJOR(pdfVersion)                   (((pdfVersion) >> 4) & 0x0f)
        #define GET_PDF_VERSION_MINOR(pdfVersion)                   (((pdfVersion) >> 0) & 0x0f)
 
        #define GET_PDF_VARIANT_TYPE(pdfVersion)                    (((pdfVersion) >> 20) & 0x0ff)
        #define GET_PDF_VARIANT_VER(pdfVersion)                     (((pdfVersion) >> 16) & 0x00f)
        #define GET_PDF_VARIANT_VERSUB(pdfVersion)                  (((pdfVersion) >>  8) & 0x0ff)
 
        #define GET_PDFA_VERSION(pdfVersion) ( (GET_PDF_VARIANT_TYPE(pdfVersion) == 'A') ? GET_PDF_VARIANT_VER(pdfVersion) : 0)
        #define GET_PDFX_VERSION(pdfVersion) ( (GET_PDF_VARIANT_TYPE(pdfVersion) == 'X') ? GET_PDF_VARIANT_VER(pdfVersion) : 0)

        typedef enum
        {
            ePDF1_3 = MAKE_PDF_VERSION(1,3) ,  
            ePDF1_4 = MAKE_PDF_VERSION(1,4) ,  
            ePDF1_5 = MAKE_PDF_VERSION(1,5) ,  
            ePDF1_6 = MAKE_PDF_VERSION(1,6) ,  
            ePDF1_7 = MAKE_PDF_VERSION(1,7) ,  
            ePDF2_0 = MAKE_PDF_VERSION(2,0) ,  
            ePDFA1b = MAKE_PDF_VERSION(1,4) | (MAKE_PDF_VARIANT (65, 1, 98)),      
            ePDFA2b = MAKE_PDF_VERSION(1,7) | (MAKE_PDF_VARIANT (65, 2, 98)),      
            ePDFA3b = MAKE_PDF_VERSION(1,7) | (MAKE_PDF_VARIANT (65, 3, 98)),      
            ePDFA2u = MAKE_PDF_VERSION(1,7) | (MAKE_PDF_VARIANT (65, 2, 117)),     
            ePDFUA  = MAKE_PDF_VERSION(1,7) | (MAKE_PDF_VARIANT (65, 2, 85)),      
            ePDFX1a = MAKE_PDF_VERSION(1,4) | (MAKE_PDF_VARIANT (88, 1, 97)),      
            ePDFX4  = MAKE_PDF_VERSION(1,6) | (MAKE_PDF_VARIANT (88, 4, 0)),       
        } ePDFVersion;

        virtual void setVersion(ePDFVersion version) = 0;

        virtual void setProducer(const U8String &producer) = 0;

        virtual void setEnableIncrementalOutput(bool enable = true) = 0;

        virtual void setLinearize(bool linearize = true) = 0;

        virtual void setEncryption(uint32 keyLength, uint32 permissions, bool encryptMetadata = false,
                                   const U8String &ownerPassword = "", const U8String &userPassword = "") = 0;
 
        class CPDFRecipientsInfo
        {
          public:
            CEDLVector<IRAInputStreamPtr> certificates; 
            uint32                        permissions;  
 
            bool operator== (const CPDFRecipientsInfo &other) const
            {
                return     (other.certificates == certificates)
                        && (other.permissions  == permissions);
            }
 
            bool operator!= (const CPDFRecipientsInfo &other) const
            {
                return ! (*this == other);
            }
        };

        virtual void setPublicKeyEncryption(uint32 keyLength, const CEDLVector<CPDFRecipientsInfo> &recipients, bool encryptMetadata = false) = 0;
 

        virtual void setTargetColorSpace(const IDOMColorSpacePtr &targetSpace) = 0;

        virtual void setTargetProfile(const IDOMICCProfilePtr &profile) = 0;

        virtual void setOutputIntent(const IOutputIntentPtr &outputIntent) = 0;

        virtual void setOutputIntents(const COutputIntentVect &outputIntents) = 0;

        virtual void setConvertAllColors(bool convert) = 0;

        virtual void setConvertGray(bool convert) = 0;

        virtual void setColorImageMaxResolution(float resolution, float threshold = 0.0f, IDOMImageDownsamplerFilter::eDownsamplingMethod method = IDOMImageDownsamplerFilter::eBicubic) = 0;

        virtual void setGrayImageMaxResolution(float resolution, float threshold = 0.0f, IDOMImageDownsamplerFilter::eDownsamplingMethod method = IDOMImageDownsamplerFilter::eBicubic) = 0;

        virtual void setMonoImageMaxResolution(float resolution, float threshold = 0.0f, IDOMImageDownsamplerFilter::eDownsamplingMethod method = IDOMImageDownsamplerFilter::eSubsample) = 0;

        virtual void setDownsampleMaskedImages(bool downsampleMaskedImages) = 0;

        virtual void setUseMaskResolutionForMaskedImages(bool useMaskResolutionSettingForMaskedImages) = 0;

        virtual void setRenderResolution(uint32 resolution) = 0;

        typedef enum
        {
            eICAuto,   
            eICFlate,  
            eICDCT,    
            eICLZW,    
            eICRLE,    
            eICCCITT   
        } eImageCompression;

        virtual void setPreferredColorImageCompression(eImageCompression compression) = 0;

        virtual void setPreferredGrayImageCompression(eImageCompression compression) = 0;

        virtual void setPreferredMonoImageCompression(eImageCompression compression) = 0;

        virtual void setPreferredRenderedImageCompression(eImageCompression compression) = 0;

        virtual void setJPEGQuality(uint8 quality) = 0;

        virtual void setJPEGChromaSubsampling(bool subsample) = 0;

        virtual void setFlateCompressionLevel(uint8 compressionLevel) = 0;

        virtual void setReencodeImages(bool reencode) = 0;

        virtual void setCompressPages(bool compressPages) = 0;

        virtual void setCompressObjects(bool compressObjects) = 0;

        virtual void setAutoRotatePages(bool autoRotate) = 0;

        virtual void setSubsetFonts(bool subset) = 0;

        virtual void setEmbedFonts(bool embed) = 0;

        virtual void setEmbedBase14Fonts(bool embed) = 0;

        virtual void setAlwaysEmbedFonts(CU8StringVect &fontNames) = 0;

        virtual void setNeverEmbedFonts(CU8StringVect &fontNames) = 0;

        virtual void setAllowRestrictedFonts(bool allowRestrictedFonts) = 0;

        virtual void setEmbedIdentityCidFonts(bool embed) = 0;

        virtual void setEnableTrueTypeNotDef(bool enableTrueTypeNotDef) = 0;

        virtual void setBlockNotdefGlyphs(bool blockNotdefGlyphs) = 0;

        virtual void setEmit30CmapSubtableForSymbolicTrueTypeFonts(bool emit) = 0;

        virtual void setForceEmitPageGroup(bool force) = 0;

        virtual void setForceMediaBoxOriginZero(bool force) = 0;

        virtual void overrideMaximumICCVersion(uint32 majorVersion, uint32 minorVersion) = 0;

        typedef enum
        {
            ePDNHDefault = 0,                                             
            ePDNHFailOnMissingColorantInformation = 0x1,                  
            ePDNHFailOnInconsistentColorantInformation = 0x2,             
            ePDNHFailIfBetterColorantInformationFoundAfterFirstUse = 0x4, 
            ePDNHFailIfDotGainFound = 0x8,                                
            ePDNFailOnMismatchedDeviceNProcessSpace = 0x10,               
            ePDNFailOnNonUtf8ColorantName = 0x20,                         
 
        } ePdfDeviceNHandling;

        virtual void setDeviceNErrorHandling(uint32 flags) = 0;

        typedef enum
        {
            ePOCHDefault = 0,                               
                                                            //   conformant output
            ePOCHFailOnInconsistentConfigurationName = 0x1, 
                                                            //   either has no name or whose name clashes with another
                                                            //   configuration. If not set, configurations will be named
                                                            //   with a default value or edited on a clash
            ePOCHFailOnInvalidOrder = 0x2,                  
                                                            //   present, does not contain all the groups. If not set, any
                                                            //   groups missing from the order will be added to the end, in
                                                            //   a sub-group labelled "Additional Layers".
            ePOCHFailIfAutoStateFound = 0x4,                
                                                            //   one or more Auto States. These are prohibited for PDF/X-4 and
                                                            //   PDF/A-2. If this flag is not set the auto state entries will
                                                            //   simply be dropped.
        } ePdfOptionalContentHandling;

        virtual void setOptionalContentErrorHandling(uint32 flags) = 0;

        typedef enum
        {
            ePEGSHDefault = 0,                      
            ePEGSHFailOnTransferFunction = 0x1,     
                                                    //   If not set, transfer functions will be silently dropped.
        } ePdfExtendedGraphicsStateHandling;

        virtual void setExtendedGraphicsStateErrorHandling(uint32 flags) = 0;

        typedef enum
        {
            ePAIHDefault = 0,                         
            ePAIHFailIfAlternatesFound = 0x1,         
            ePAIHFailIfDefaultForPrintingFound = 0x2, 
        } ePdfAlternateImageHandling;

        virtual void setAlternateImageErrorHandling(uint32 flags) = 0;

        virtual void setNonUtf8InkNameFallbackEncoding(eInkFallbackEncoding fallbackEncoding) = 0;

        typedef enum
        {
            eFCSJapanese,               
            eFCSKorean,                 
            eFCSSimplifiedChinese,      
            eFCSTraditionalChinese,     
        } eFormCJKCharacterSet;

        virtual void setDefaultFormCJKLanguage(eFormCJKCharacterSet characterSet) = 0;

        virtual void setRetainEmbeddedFiles(bool retainEmbeddedFiles) = 0;

        virtual void setRetainClippedContent(bool retainClippedContent) = 0;

        virtual void setAllowOptionalContentUpdateDuringWrite(bool allow) = 0;

        virtual void setIgnoreXmp(bool ignore) = 0;

        virtual void setValidateXmp(bool validate) = 0;

        virtual void setOriginalFontEncoding(bool originalEncoding) = 0;
        
        virtual void setMaxInFlightPages(uint32 maxInFlightPages) = 0;
 
    };
    #define obj2IPDFOutput(obj) IPDFOutputPtr(dynamic_cast<IPDFOutput *>((IRCObject *) (obj)), true)
}
 
#endif