jawsmako.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008-2025 Global Graphics Software Ltd. All rights reserved.
 */
 
#ifndef JAWSMAKO_H
#define JAWSMAKO_H
 
#include <map>
#include <edl/platform.h>
#include <edl/iabort.h>
#include <edl/idomsecurity.h>
#include <jawsmako/optionalcontent.h>
#include <jawsmako/pagelabels.h>









 


 
 
#include <jawsmako/types.h>
#include <jawsmako/interactive.h>
#include <edl/idompage.h>
 
namespace JawsMako
{
    using namespace EDL;

    typedef enum
    {
        eFFPDF,     
        eFFXPS,     
        eFFPS,      
        eFFEPS,     
        eFFSVG,     
        eFFPCL5,    
        eFFPCLXL,   
        eFFIJPDS,   
        eFFPPML,    
        eFFOXPS,    
        eFFPRN,     
        eFFUnknown  
    } eFileFormat;

    class IJawsMako : virtual public ISession, virtual public IEDLClassFactory
    {
      public:
        virtual ~IJawsMako() = default;

        static JAWSMAKO_API IJawsMakoPtr create(const U8String &tempDir = U8String(""),
                                                const U8String &cacheDir = U8String(""),
                                                const CTemporaryStoreParameters &tempStoreParams = CTemporaryStoreParameters(),
                                                const std::map<std::string, std::string> &initialParams = std::map<std::string, std::string> ());

        static JAWSMAKO_API void enablePDFInput(const IJawsMakoPtr &jawsMako);

        static JAWSMAKO_API void enablePDFOutput(const IJawsMakoPtr &jawsMako);

        static JAWSMAKO_API void enablePSInput(const IJawsMakoPtr &jawsMako);

        static JAWSMAKO_API void enablePSOutput(const IJawsMakoPtr &jawsMako);

        static JAWSMAKO_API void enableAllFeatures(const IJawsMakoPtr &jawsMako)
        {
            enablePDFInput(jawsMako);
            enablePDFOutput(jawsMako);
            enablePSInput(jawsMako);
            enablePSOutput(jawsMako);
        }
 
#ifdef __APPLE__
        virtual void lockOpenFiles(bool lock) = 0;
#endif

        virtual void freeMemory() = 0;
 
    #ifdef SWIG
        %apply uint32_t &OUTPUT { uint32_t &fontIndex };
    #endif
        virtual IDOMFontPtr findFont(const U8String &fontName, uint32_t &fontIndex) = 0;
    #ifdef SWIG
        %clear uint32_t &fontIndex;
    #endif

        virtual bool findFont(const U8String &fontName) = 0;

        virtual void setImageDecompressorCacheSize(uint32 decompressorCacheSizeMB) = 0;
    };

    class IInput : public IRCObject
    {
      public:
        virtual ~IInput() = default;

        static JAWSMAKO_API IInputPtr create(const IJawsMakoPtr &jawsMako, eFileFormat format, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr());

        virtual IDocumentAssemblyPtr open(const U8String &pathToFile) = 0;

        virtual IDocumentAssemblyPtr open(const String &pathToFile) = 0;

        virtual IDocumentAssemblyPtr open(const IInputStreamPtr &inputStream) = 0;

        virtual void setSequentialMode(bool sequential) = 0;

        virtual void setParameter(const U8String &param, const U8String &value) = 0;
    };
 
 

    class IOutput : public IRCObject
    {
      public:
        virtual ~IOutput() = default;

        static JAWSMAKO_API IOutputPtr create(const IJawsMakoPtr &jawsMako, eFileFormat format, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         * Configuration
         */

        virtual void setPreset(const U8String &preset) = 0;

        virtual void setParameter(const U8String &param, const U8String &value) = 0;

        virtual void setAllowedPermissionsFlags(uint32 allowedPermissions) = 0;
 

        virtual void writeAssembly(const IDocumentAssemblyPtr &assembly,
                                   const U8String &pathToFile) = 0;

        virtual void writeAssembly(const IDocumentAssemblyPtr &assembly,
                                   const String &pathToFile) = 0;

        virtual void writeAssembly(const IDocumentAssemblyPtr &assembly,
                                   const IOutputStreamPtr &stream) = 0;

        virtual IOutputWriterPtr openWriter(const IDocumentAssemblyPtr &assembly, const U8String &pathToFile) = 0;

        virtual IOutputWriterPtr openWriter(const IDocumentAssemblyPtr &assembly, const String &pathToFile) = 0;

        virtual IOutputWriterPtr openWriter(const IDocumentAssemblyPtr &assembly, const IOutputStreamPtr &stream) = 0;
    };
 
 

    class IOutputWriter : public IRCObject
    {
      public:
        virtual ~IOutputWriter() = default;

        virtual void beginDocument(const IDocumentPtr &document) = 0;

        virtual void endDocument() = 0;

        virtual void writePage(const IPagePtr &page) = 0;

        virtual void finish() = 0;
    };

    class IDocumentAssembly : public IRCObject
    {
      public:
        virtual ~IDocumentAssembly() = default;

        static JAWSMAKO_API IDocumentAssemblyPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());

        virtual uint32 getNumDocuments() = 0;

        virtual IDocumentPtr getDocument(uint32 index = 0) = 0;

        virtual bool documentExists(uint32 index) = 0;

        virtual void insertDocument(const IDocumentPtr &document, uint32 index = 0) = 0;

        virtual void removeDocument(uint32 index) = 0;

        virtual void removeDocument(const IDocumentPtr &document) = 0;

        virtual void appendDocument(const IDocumentPtr &document) = 0;

        virtual IDOMJobTkPtr getJobTicket() const = 0;

        virtual void setJobTicket(const IDOMJobTkPtr &jobTicket) = 0;
 
    #ifdef SWIG
        %apply uint32_t &OUTPUT { uint32 &docNum  };
        %apply uint32_t &OUTPUT { uint32 &pageNum };
    #endif
        virtual void findTarget(DOMid targetId, uint32 &docNum, uint32 &pageNum) = 0;
    #ifdef SWIG
        %clear uint32 &docNum;
        %clear uint32 &pageNum;
    #endif

        virtual IAnnotationPtr findAnnotation(const IAnnotationReferencePtr &reference) = 0;
 
    #ifdef SWIG
        %apply uint32_t &OUTPUT { uint32 &docNum  };
        %apply uint32_t &OUTPUT { uint32 &pageNum };
    #endif
        virtual IAnnotationPtr findAnnotation(const IAnnotationReferencePtr &reference, uint32 &docNum, uint32 &pageNum) = 0;
    #ifdef SWIG
        %clear uint32 &docNum;
        %clear uint32 &pageNum;
    #endif

        virtual IDocumentAssemblyPtr clone() = 0;

        virtual IDOMMetadataPtr getJobMetadata() const = 0;

        virtual void setJobMetadata(const IDOMMetadataPtr &metadata) = 0;

        virtual IInputStreamPtr getXmpPacket() const = 0;

        virtual void setXmpPacket(const IInputStreamPtr &xmpPacket) = 0;

        virtual IDOMSecurityInfoPtr getSecurityInfo() const = 0;

        virtual IDOMImagePtr getThumbnail() const = 0;

        virtual void setThumbnail(const IDOMImagePtr &thumbnail) = 0;
    };
 

    class IDocument : public IRCObject
    {
      public:
        virtual ~IDocument() = default;

        static JAWSMAKO_API IDocumentPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());

        virtual uint32 getNumPages() = 0;

        virtual IPagePtr getPage(uint32 index = 0) = 0;

        virtual bool pageExists(uint32 index) = 0;

        virtual void insertPage(const IPagePtr &page, uint32 index = 0, const IDocumentPtr &sourceDocument = IDocumentPtr()) = 0;

        virtual void appendPage(const IPagePtr &page, const IDocumentPtr &sourceDocument = IDocumentPtr()) = 0;

        virtual void removePage(uint32 index) = 0;

        virtual void removePage(const IPagePtr &page) = 0;
 
    #ifdef SWIG
        %apply uint32_t &OUTPUT { uint32 &pageNum };
    #endif
        virtual void findTarget(DOMid targetId, uint32 &pageNum) = 0;
    #ifdef SWIG
        %clear uint32 &pageNum;
    #endif

        virtual IAnnotationPtr findAnnotation(const IAnnotationReferencePtr &reference) = 0;
 
    #ifdef SWIG
        %apply uint32_t &OUTPUT { uint32 &pageNum };
    #endif
        virtual IAnnotationPtr findAnnotation(const IAnnotationReferencePtr &reference, uint32 &pageNum) = 0;
    #ifdef SWIG
        %clear uint32 &pageNum;
    #endif

        virtual IDOMJobTkPtr getJobTicket() const = 0;

        virtual void setJobTicket(const IDOMJobTkPtr &jobTicket) = 0;

        virtual COutputIntentVect getOutputIntents() const = 0;

        virtual IOptionalContentPtr getOptionalContent() const = 0;

        virtual void setOptionalContent(const IOptionalContentPtr &optionalContent) = 0;

        virtual IStructurePtr getStructure() const = 0;

        virtual void setStructure(const IStructurePtr &structure) = 0;

        virtual IDOMOutlinePtr getOutline() const = 0;

        virtual void setOutline(const IDOMOutlinePtr &outline) = 0;

        virtual IFormPtr getForm() const = 0;

        virtual void setForm(const IFormPtr &form) = 0;

        virtual CFileSpecAsEmbeddedDataVect getEmbeddedStreams() = 0;

        virtual void addEmbeddedStream(const IFileSpecAsEmbeddedDataPtr &embeddedData) = 0;

        virtual CNamedDestinationVect getNamedDestinations() = 0;

        virtual void addNamedDestination(const INamedDestinationPtr &namedDestination) = 0;

        virtual void setNamedDestinations(const CNamedDestinationVect &namedDestinations) = 0;

        virtual IThreadsPtr getThreads() const = 0;

        virtual IDocumentPtr clone() = 0;
 
        //
        // PDF-specific object editing and interrogation
        //

        virtual IPDFObjectPtr lookupFarReference(const IPDFFarReferencePtr &farReference, IPDFObjectStorePtr &store) = 0;

        virtual IPDFObjectStorePtr getObjectStore() = 0;

        virtual IPDFObjectPtr readPdfObject(const IPDFReferencePtr &reference) = 0;

        virtual IPDFDictionaryPtr readPdfTrailerDictionary() = 0;
 
    };

    class IPageRaster : public IRCObject, public IHashable
    {
      public:

        virtual uint32 getWidth () const = 0;

        virtual uint32 getHeight () const = 0;

        virtual uint32 getResX () const = 0;

        virtual uint32 getResY () const = 0;

        virtual uint32 getBPC () const = 0;

        virtual uint32 getNumComponents () const = 0;

        virtual uint32 getRawBytesPerRow () const = 0;

        virtual bool isBlank () const = 0;

        virtual uint8  *getFrameBuffer () const = 0;

        virtual IDOMImagePtr getAsDOMImage () const = 0;

        virtual void releaseFrameBuffer () = 0;
 
    };
    DECL_SMART_PTR (IPageRaster);

    class IPage : public IRCObject
    {
      public:
        virtual ~IPage() = default;

        static JAWSMAKO_API IPagePtr create(const IJawsMakoPtr &jawsMako);

        virtual double getWidth() = 0;

        virtual double getHeight() = 0;

        virtual FRect getCropBox() = 0;

        virtual FRect getBleedBox() = 0;

        virtual FRect getTrimBox() = 0;

        virtual FRect getContentBox() = 0;

        virtual int32 getRotate() = 0;

        virtual void setRotate(int32 rotate) = 0;

        virtual IDOMFixedPagePtr getContent() = 0;

        virtual IPageRasterPtr getPageRaster () = 0;

        virtual IDOMFixedPagePtr edit() = 0;

        virtual void revert() = 0;

        virtual bool isLoaded() = 0;

        virtual bool isEdited() = 0;

        virtual void setMetadataChanged() const = 0;

        virtual void setContent(const IDOMFixedPagePtr &content) = 0;

        virtual void release() = 0;

        virtual CAnnotationVect getAnnotations() = 0;

        virtual void addAnnotation(const IAnnotationPtr &annotation) = 0;

        virtual IAnnotationPtr findAnnotation(const IAnnotationReferencePtr &reference) = 0;

        virtual void removeAnnotation(uint32 index) = 0;

        virtual void removeAnnotation(const IAnnotationPtr &annotation) = 0;

        virtual void removeAnnotations() = 0;

        virtual void getTextRuns(CTextRunVect &runs) = 0;

        virtual IDOMCatalogPtr getCatalog() const = 0;

        virtual DOMid getPageId() = 0;

        virtual COutputIntentVect getOutputIntents() = 0;

        virtual IDOMJobTkPtr getJobTicket() const = 0;

        virtual void setJobTicket(const IDOMJobTkPtr &jobTicket) = 0;

        virtual IPagePtr clone() = 0;
 
        //
        // PDF-specific object editing and interrogation
        //

        virtual IPDFObjectPtr lookupFarReference(const IPDFFarReferencePtr &farReference, IPDFObjectStorePtr &store,
                                                 const IDocumentPtr &document = IDocumentPtr()) = 0;

        virtual IPDFObjectStorePtr getObjectStore() = 0;
 
        //
        // PDF-specific Media Box handling
        //

        virtual FBox getMediaBox() const = 0;

        virtual void setMediaBox(const FBox &mediaBox) = 0;

        virtual IPageLabelPtr getPageLabel() = 0;

        virtual void setPageLabel(const IPageLabelPtr &pageLabel) = 0;

        virtual float getUserUnit(bool fixed = false) = 0;
    };
 

    class IJawsRenderer : public IRCObject
    {
      public:
        virtual ~IJawsRenderer() = default;

        static JAWSMAKO_API IJawsRendererPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());

        virtual IDOMImagePtr render(const IDOMNodePtr &node, uint32 dpi = 72, uint8 depth = 8,
                                    const IDOMColorSpacePtr &colorSpace = IDOMColorSpacePtr(),
                                    const FRect &bounds = FRect(),
                                    bool  maskToInterestingNodes = false,
                                    const CSpotColorNames &retainedSpotColors = CSpotColorNames(),
                                    const IOptionalContentPtr &optionalContent = IOptionalContentPtr(),
                                    eOptionalContentEvent optionalContentUsage = eOCEView) = 0;

        virtual CEDLVector<IDOMImagePtr> renderSeparations(const IDOMNodePtr &node,
                                                           const uint8 depth = 8,
                                                           const IDOMColorSpacePtr &colorSpace = IDOMColorSpacePtr(),
                                                           uint8 antiAliased = 0,
                                                           const FRect &bounds = FRect(),
                                                           uint32 destWidth = 0,
                                                           uint32 destHeight = 0,
                                                           const CSpotColorNames &retainedSpotColors = CSpotColorNames(),
                                                           const IOptionalContentPtr &optionalContent = IOptionalContentPtr(),
                                                           eOptionalContentEvent optionalContentUsage = eOCEView,
                                                           const CU8StringVect &processColorNames = CU8StringVect(),
                                                           bool alphaGeneration = false,
                                                           uint64 bandMemorySize = 0,
                                                           const CSpotColorNames &ignoreSpotColors = CSpotColorNames()) = 0;

        class CFrameBufferInfo
        {
          public:
            void    *buffer;         
            uint32  bufferOfs;       
            uint8   bufferOfsBits;   
            int32   rowStride;       
            int32   pixelStride;     
            int8    pixelStrideBits; 
 
            CFrameBufferInfo()
            {
                buffer          = nullptr;
                bufferOfs       = 0;
                bufferOfsBits   = 0;
                rowStride       = 0;
                pixelStride     = 0;
                pixelStrideBits = 0;
            }
 
            bool operator== (const CFrameBufferInfo &other) const
            {
                return      (other.buffer         == buffer)
                        &&  (other.bufferOfs      == bufferOfs)
                        &&  (other.bufferOfsBits  == bufferOfsBits)
                        &&  (other.rowStride      == rowStride)
                        &&  (other.pixelStride    == pixelStride)
                        && (other.pixelStrideBits == pixelStrideBits)
                    ;
            }
 
            bool operator!= (const CFrameBufferInfo &other) const
            {
                return ! (*this == other);
            }
        };
 
        typedef CEDLVector<CFrameBufferInfo> CFrameBufferInfoVect;

        virtual void renderSeparationsToFrameBuffers(const IDOMNodePtr &node,
                                                     uint8 depth,
                                                     bool hostEndian,
                                                     uint32 destWidth,
                                                     uint32 destHeight,
                                                     const IDOMColorSpacePtr &colorSpace,
                                                     CFrameBufferInfoVect &frameBuffers,
                                                     uint8 antiAliased = 0,
                                                     const FRect &bounds = FRect(),
                                                     const CSpotColorNames &retainedSpotColors = CSpotColorNames(),
                                                     const IOptionalContentPtr &optionalContent = IOptionalContentPtr(),
                                                     eOptionalContentEvent optionalContentUsage = eOCEView,
                                                     const CU8StringVect &processColorNames = CU8StringVect(),
                                                     bool alphaGeneration = false,
                                                     uint64 bandMemorySize = 0,
                                                     const CSpotColorNames &ignoreSpotColors = CSpotColorNames()) = 0;
 
#ifdef SWIG
#if SWIGJAVA
    %apply unsigned char *NIOBUFFER { void * buffer };
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] { void * buffer };
#endif
#if SWIGPYTHON
    %apply unsigned char INOUT[] { void * buffer };
#endif
#endif

        virtual void renderToFrameBuffer(const IDOMNodePtr &node,
                                         void *buffer, 
                                         uint32 stride,
                                         uint32 destWidth,
                                         uint32 destHeight,
                                         const IDOMColorSpacePtr &colorSpace = IDOMColorSpacePtr(),
                                         const FRect &bounds = FRect(),
                                         const IOptionalContentPtr &optionalContent = IOptionalContentPtr(),
                                         eOptionalContentEvent optionalContentUsage = eOCEView) = 0;
#ifdef SWIG
    %clear void * buffer;
#endif
 
#ifdef SWIG
#if SWIGJAVA
    %apply unsigned char *NIOBUFFER { void * buffer };
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] { void * buffer };
#endif
#if SWIGPYTHON
    %apply unsigned char INOUT[] { void * buffer };
#endif
#endif

        virtual void renderToFrameBufferPadAndReverse(const IDOMNodePtr &node,
                                                      void *buffer,
                                                      uint32 stride,
                                                      uint32 pixelStride,
                                                      bool reverseComponents,
                                                      uint32 destWidth,
                                                      uint32 destHeight,
                                                      const IDOMColorSpacePtr &colorSpace = IDOMColorSpacePtr(),
                                                      const FRect &bounds = FRect(),
                                                      const IOptionalContentPtr &optionalContent = IOptionalContentPtr(),
                                                      eOptionalContentEvent optionalContentUsage = eOCEView) = 0;
 
    #ifdef SWIG
        %clear void * buffer;
    #endif

        virtual IDOMImagePtr renderAntiAliased(const IDOMNodePtr &node,
                                               uint32 dpi = 72,
                                               uint8 quality = 3,
                                               const FRect &bounds = FRect()) = 0;

        class IHalftone
        {
          public:
            virtual ~IHalftone() {}
        };
        
        class CSpotHalftone : public IHalftone
        {
          public:
            // The frequency must be greater than 0.
            CSpotHalftone(float freq, bool useFullResForFlattening = false)
            {
                frequency = freq;
                useFullResolutionForFlattening = useFullResForFlattening;
            }
            float frequency; 
            bool useFullResolutionForFlattening; 
                                                 //   images occurs is capped at twice the frequency. For some
                                                 //   content, this may not be appropriate. Set this to true to
                                                 //   use the full device resolution.
        };
        
        class CColorSpotHalftone : public IHalftone
        {
          public:
            // Default is CMYK. Resize and set angles to suit
            CColorSpotHalftone(float freq, bool useFullResForFlattening = false,
                               float cyanAngle = 15.0, float magentaAngle = 75.0f, float yellowAngle = 0.0f, float blackAngle = 45.0f)
            {
                frequency = freq;
                useFullResolutionForFlattening = useFullResForFlattening;
                angles.resize(4);
                angles[0] = cyanAngle;
                angles[1] = magentaAngle;
                angles[2] = yellowAngle;
                angles[3] = blackAngle;
            }
            float frequency;    
            bool  useFullResolutionForFlattening; 
                                                  //   images occurs is capped at twice the frequency. For some
                                                  //   content, this may not be appropriate. Set this to true to
                                                  //   use the full device resolution.
            CEDLVector<float> angles; 
        };
        
        class CThresholdArrayHalftone : public IHalftone
        {
          public:
            CThresholdArrayHalftone()
            {
                width = 0;
                height = 0;
            }
 
            uint32 width;  
            uint32 height; 
            CEDLVector<uint8> thresholdArray; 
        };

        class CColorThresholdArrayHalftone : public IHalftone
        {
          public:
            CColorThresholdArrayHalftone()
            {
                width = 0;
                height = 0;
            }
 
            uint32 width;  
            uint32 height; 
            CEDLVector< CEDLVector<uint8> > thresholdArrays; 
        };

        class CThresholdHalftone : public IHalftone
        {
          public:
            CThresholdHalftone(uint8 thresh = 127)
            {
                threshold = thresh;
            }
 
            uint8 threshold; 
        };

        class CEDSHalftone : public IHalftone
        {
          public:
            CEDSHalftone()
            {
                // Default is a simple Atkinson monochrome error diffusion screen
                dropSizes = 1;
                rows = 3;
                columns = 4;
                pixelColumn = 1;
                denominator = 6;
                weights[ 0] = 0; weights[ 1] = 0; weights[ 2] = 1; weights[ 3] = 1; weights[ 4] = 0;
                weights[ 5] = 1; weights[ 6] = 1; weights[ 7] = 1; weights[ 8] = 0; weights[ 9] = 0;
                weights[10] = 0; weights[11] = 1; weights[12] = 0; weights[13] = 0; weights[14] = 0;
                weights[15] = 0; weights[16] = 0; weights[17] = 0; weights[18] = 0; weights[19] = 0;
                useSerpentine = false;
                perturbation = 0.0f;
            }
 
            uint8  dropSizes;     
            uint8  rows;          
            uint8  columns;       
            uint8  pixelColumn;   
            uint32 denominator;   
            uint8  weights[20];   
            bool   useSerpentine; 
            float  perturbation;  
        };

        virtual CEDLVector<IDOMImagePtr> renderScreened (const IDOMNodePtr &node, uint32 dpi,
                                                         const IHalftone *halftone,
                                                         const IDOMColorSpacePtr &colorSpace = IDOMColorSpacePtr(),
                                                         const FRect &bounds = FRect(),
                                                         const bool useCC = true,
                                                         const IOptionalContentPtr &optionalContent = IOptionalContentPtr(),
                                                         eOptionalContentEvent optionalContentUsage = eOCEView) = 0;
        virtual IDOMImagePtr renderMonochrome(const IDOMNodePtr &node,
                                              uint32 dpi = 72, const IHalftone *halftone = nullptr,
                                              const IDOMColorSpacePtr &colorSpace = IDOMColorSpacePtr(),
                                              const FRect &bounds = FRect(),
                                              const bool useCC = false
        )
        {
            // Use renderScreened
            CSpotHalftone defaultHalftone(60);
            const IHalftone *useHalftone = halftone ? halftone : &defaultHalftone;
            return renderScreened(node, dpi, useHalftone, colorSpace, bounds, useCC)[0];
        }
 
#ifdef SWIG
#if SWIGJAVA
    %apply char DOUBLEDIM_FIXED[][] { void **buffers };
    %apply uint32_t[] { uint32 *strides };
#endif
#if SWIGCSHARP
    %csmethodmodifiers renderScreenedToFrameBuffers "public unsafe";
    %apply unsigned char DOUBLEDIM_FIXED[][] { void **buffers };
    %apply unsigned int FIXED[] { uint32 *strides };
#endif
#if SWIGPYTHON
    %apply unsigned char DOUBLEDIM_FIXED[][] { void **buffers };
    %apply int ARRAY[] { uint32 *strides };
#endif
#endif
        virtual void renderScreenedToFrameBuffers (const IDOMNodePtr &node,
                                                   void **buffers, uint32 *strides,
                                                   uint32 destWidth,
                                                   uint32 destHeight,
                                                   const IHalftone *halftone,
                                                   const IDOMColorSpacePtr &colorSpace = IDOMColorSpacePtr(),
                                                   const FRect &bounds = FRect(),
                                                   const bool useCC = true,
                                                   const IOptionalContentPtr &optionalContent = IOptionalContentPtr(),
                                                   eOptionalContentEvent optionalContentUsage = eOCEView) = 0;
 
#ifdef SWIG
    %clear void **buffers;
    %clear uint32 *strides;
#endif
 
#ifdef SWIG
#if SWIGJAVA
    %apply char *BYTE { void *buffer };
#endif
#if SWIGCSHARP
    %apply unsigned char INPUT[] { void * buffer };
#endif
#if SWIGPYTHON
    %apply unsigned char INOUT[] { void * buffer };
#endif
#endif
        void renderMonochromeToFrameBuffer(const IDOMNodePtr &node,
                                           void *buffer, uint32 stride,
                                           uint32 destWidth, uint32 destHeight,
                                           const IHalftone *halftone,
                                           const IDOMColorSpacePtr& colorSpace = IDOMColorSpacePtr(),
                                           const FRect &bounds = FRect(),
                                           const bool useCC = false,
                                           const IOptionalContentPtr &optionalContent = IOptionalContentPtr(),
                                           eOptionalContentEvent optionalContentUsage = eOCEView)
        {
            // Use renderScreenedToFrameBuffers
            renderScreenedToFrameBuffers(node, &buffer, &stride, destWidth, destHeight, halftone, colorSpace,
                                         bounds, useCC, optionalContent, optionalContentUsage);
        }
    #ifdef SWIG
        %clear void * buffer;
    #endif

        virtual void setEnableTrueTypeNotDef(bool enable) = 0;

        virtual void setEnableRasterCompression(bool enable) = 0;

        virtual void setBlackPreservation(bool preserveForText, bool preserveForOther) = 0;

        virtual void setIgnoreMatchingDeviceIntercept(bool ignoreDeviceIntercept) = 0;
 
    };
 

    class IMediaHandler
    {
      public:
        virtual ~IMediaHandler() = default;

        virtual void sizeRequest(const PValue &size, double &pageWidth, double &pageHeight) = 0;
    };
}

#endif