transforms.h

Go to the documentation of this file.

/*
 * Copyright (C) 2013-2026 Hybrid Software Helix Ltd. All rights reserved.
*/
 
#ifndef JAWSMAKO_TRANSFORMS_H
#define JAWSMAKO_TRANSFORMS_H

 
#include <jawsmako/jawsmako.h>
#include <jawsmako/transforms.h>
#include <edl/idompath.h>
#include <edl/idomglyphs.h>
#include <edl/idombrush.h>
#include <edl/iabort.h>
 
namespace JawsMako
{
    using namespace EDL;
 
    class ITransform;
    DECL_SMART_PTR(ITransform);
    class ITransformChain;
    DECL_SMART_PTR(ITransformChain);

    typedef enum
    {
        eBUNone = 0,       
        eBUGeneral,        
        eBUFill,           
        eBUStroke,         
        eBUOpacityMask,    
        eBUAlternateImage, 
    } eBrushUsage;

    class JAWSMAKO_API CTransformState
    {
      public:
        CTransformState() : hasClipBounds(false), hasRenderingIntent(false), renderingIntent(eRelativeColorimetric),
                            blackPointCompensation(eBPCDefault), brushUsage(eBUNone), edgeMode(eEMDefault),
                            inUncoloredTilingBrush(false), transformPriv(NULL)
        {}

        CTransformState(const IDOMNodePtr &node);

        CTransformState stateInsideNode(const IDOMNodePtr &node, bool updateTransform = true, bool updateClip = true, bool updateRenderingIntent = true, bool updateEdgeMode = true) const;

        CTransformState stateInsideBrush(const IDOMBrushPtr &brush,
                                         eBrushUsage brushUsage,
                                         bool updateTransform = true,
                                         bool updateClip = true) const;
 
     public:
        FMatrix                 transform;              
        bool                    hasClipBounds;          
        FRect                   clipBounds;             
        IDOMColorSpacePtr       groupColorSpace;        
        bool                    hasRenderingIntent;     
        eRenderingIntent        renderingIntent;        
        eBlackPointCompensation blackPointCompensation; 
        eEdgeMode               edgeMode;               
        eBrushUsage             brushUsage;             
        bool                    inUncoloredTilingBrush; 
        void                   *transformPriv;          
    };

    class ITransform : public IRCObject
    {
      public:
        virtual ~ITransform() {}

        virtual IDOMBrushPtr transform(const IDOMBrushPtr &brush, eBrushUsage usage = eBUGeneral, const CTransformState &state = CTransformState()) = 0;

        virtual IDOMImagePtr transform(const IDOMImagePtr &image, const CTransformState &state = CTransformState()) = 0;

        virtual IDOMColorPtr transform(const IDOMColorPtr &color, const CTransformState &state = CTransformState()) = 0;

        virtual IDOMColorSpacePtr transform(const IDOMColorSpacePtr &colorSpace, const CTransformState &state = CTransformState()) = 0;

        virtual IDOMNodePtr transform(const IDOMNodePtr &node, bool &changed, bool transformChildren = true, const CTransformState &state = CTransformState()) = 0;

        virtual void transformPage(const IPagePtr &page, bool transformContent = true, bool transformAnnotations = true) = 0;

        virtual void flushCaches() = 0;

        virtual void setProgressMonitor (const IProgressMonitorPtr &progressMonitor) = 0;
 
    };

    typedef CEDLVector<ITransformPtr> CTransformVect;

    class ITransformChain : public IRCObject
    {
      public:
        virtual ~ITransformChain() {}

        static JAWSMAKO_API ITransformChainPtr create(const IJawsMakoPtr &jawsMako,
                                                      const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr(),
                                                      const CTransformVect &transforms = CTransformVect());

        virtual void removeTransform(uint32 index) = 0;

        virtual void pushTransform(const ITransformPtr &transform) = 0;

        virtual void pushTransformFront(const ITransformPtr &transform) = 0;

        virtual CTransformVect getTransforms() const = 0;

        virtual IDOMNodePtr transform(const IDOMNodePtr &node) = 0;

        virtual IDOMNodePtr transform(const IDOMNodePtr &node, bool &changed) = 0;

        virtual void transformPage(const IPagePtr &page, bool transformContent = true, bool transformAnnotations = true) = 0;

        virtual void flushCaches() = 0;

        virtual ITransformChainPtr clone() = 0;
    };
 
    /*
     * Individual ITransforms
     */
 
    class IImageEncoderTransform;
    DECL_SMART_PTR(IImageEncoderTransform);

    class IImageEncoderTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IImageEncoderTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr());
 
        /*
         *  Configuration.
         */

        virtual void setReencodeAllImages(bool value) = 0;

        virtual void setEnableTIFFEncoding(bool value) = 0;

        virtual void setReencodeMultiImageTIFF(bool value) = 0;

        typedef enum eEncodeFormat
        {
            eEFAuto,       
            eEFJPEG,       
            eEFPNG,        
            eEFTIFF        
        } eEncodeFormat;

        virtual void setPreferredFormat(eEncodeFormat format) = 0;

        virtual void setPreferredMonoFormat(eEncodeFormat format) = 0;

        virtual eEncodeFormat getPreferredMonoFormat() const = 0;

        virtual void setPreferredGrayFormat(eEncodeFormat format) = 0;

        virtual eEncodeFormat getPreferredGrayFormat() const = 0;

        virtual void setPreferredColorFormat(eEncodeFormat format) = 0;

        virtual eEncodeFormat getPreferredColorFormat() const = 0;

        virtual void setJPEGQuality(uint8 quality) = 0;

        virtual uint8 getJPEGQuality() const = 0;

        virtual void setTIFFCompression(IDOMTIFFImage::eTIFFCompression scheme) = 0;

        virtual void setMonoTIFFCompression(IDOMTIFFImage::eTIFFCompression scheme) = 0;

        virtual void setGrayTIFFCompression(IDOMTIFFImage::eTIFFCompression scheme) = 0;

        virtual void setColorTIFFCompression(IDOMTIFFImage::eTIFFCompression scheme) = 0;

        virtual void setEncodeSolidColorMaskedBrushesAsSingleImage(bool encode) = 0;
    };
 
 
    class IImageDownsamplerTransform;
    DECL_SMART_PTR(IImageDownsamplerTransform);

    class IImageDownsamplerTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IImageDownsamplerTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr());
 
        /*
         *  Configuration.
         */

        virtual void setColorDownsamplingMethod(IDOMImageDownsamplerFilter::eDownsamplingMethod method) = 0;

        virtual IDOMImageDownsamplerFilter::eDownsamplingMethod getColorDownsamplingMethod() const = 0;

        virtual void setGrayDownsamplingMethod(IDOMImageDownsamplerFilter::eDownsamplingMethod method) = 0;

        virtual IDOMImageDownsamplerFilter::eDownsamplingMethod getGrayDownsamplingMethod() const = 0;

        virtual void setMonoDownsamplingMethod(IDOMImageDownsamplerFilter::eDownsamplingMethod method) = 0;

        virtual IDOMImageDownsamplerFilter::eDownsamplingMethod getMonoDownsamplingMethod() const = 0;

        virtual void setTargetResolution(float resolution) = 0;

        virtual void setThresholdResolution(float resolution) = 0;

        virtual void setColorTargetResolution(float resolution) = 0;

        virtual float getColorTargetResolution() = 0;

        virtual void setColorThresholdResolution(float resolution) = 0;

        virtual float getColorThresholdResolution() = 0;

        virtual void setGrayTargetResolution(float resolution) = 0;

        virtual float getGrayTargetResolution() = 0;

        virtual void setGrayThresholdResolution(float resolution) = 0;

        virtual float getGrayThresholdResolution() = 0;

        virtual void setMonoTargetResolution(float resolution) = 0;

        virtual float getMonoTargetResolution() = 0;

        virtual void setMonoThresholdResolution(float resolution) = 0;

        virtual float getMonoThresholdResolution() = 0;

        virtual void setDownsampleMaskedImages(bool downsampleMaskedImages) = 0;

        virtual void setUseMaskResolutionForMaskedImages(bool useMaskResolutionSettingForMaskedImages) = 0;

        virtual void setUseFloatingPointResolutions(bool useFloatingPointResolutions) = 0;
 
    };
 
    class IImageUpsamplerTransform;
    DECL_SMART_PTR(IImageUpsamplerTransform);

    class IImageUpsamplerTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IImageUpsamplerTransformPtr create(const IJawsMakoPtr &jawsMako,
                                                               const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr());
 
        /*
         *  Configuration.
         */

        virtual void setColorUpsamplingMethod(IDOMImageUpsamplerFilter::eUpsamplingMethod method) = 0;

        virtual void setGrayUpsamplingMethod(IDOMImageUpsamplerFilter::eUpsamplingMethod method) = 0;

        virtual void setMonoUpsamplingMethod(IDOMImageUpsamplerFilter::eUpsamplingMethod method) = 0;

        virtual void setTargetResolution(float resolution) = 0;

        virtual void setThresholdResolution(float resolution) = 0;

        virtual void setColorTargetResolution(float resolution) = 0;

        virtual void setColorThresholdResolution(float resolution) = 0;

        virtual void setGrayTargetResolution(float resolution) = 0;

        virtual void setGrayThresholdResolution(float resolution) = 0;

        virtual void setMonoTargetResolution(float resolution) = 0;

        virtual void setMonoThresholdResolution(float resolution) = 0;

        virtual void setUpsampleMaskedImages(bool upsampleMaskedImages) = 0;

        virtual void setUseMaskResolutionForMaskedImages(bool useMaskResolutionSettingForMaskedImages) = 0;

        virtual void setUseFloatingPointResolutions(bool useFloatingPointResolutions) = 0;
 
    };
 
    class IColorConverterTransform;
    DECL_SMART_PTR(IColorConverterTransform);

    class IColorConverterTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IColorConverterTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  Configuration.
         */

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

        virtual IDOMColorSpacePtr getTargetSpace() = 0;

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

        virtual void setSWOPTargetSpace() = 0;

        virtual void setOverrideRenderingIntent(eRenderingIntent intent) = 0;

        virtual void useDOMRenderingIntents(bool use) = 0;

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

        virtual void setConvertOnlyDeviceIndependentColors(bool convert) = 0;

        virtual void setConvertIndependentToSimilarDeviceSpace(bool convert) = 0;

        virtual void setInspectDeviceNAlternateSpace(bool inspect) = 0;

        virtual void setInspectDeviceNColorantsAlternateSpace(bool inspect) = 0;
 

        virtual void setKeepDeviceN(bool keep) = 0;

        virtual void setIgnoreImagesWithSimilarColorSpaces(bool ignore) = 0;

        virtual void setIgnoreRenderedImages(bool ignore) = 0;

        virtual void setForceImageSampleConversion(bool force) = 0;

        virtual void setShouldConvertForSpaceType(IDOMColorSpace::eColorSpaceType type, bool convert = true) = 0;

        virtual bool wouldConvertForSpaceType(IDOMColorSpace::eColorSpaceType type) = 0;

        virtual void setConvertICCColorsWithNumComponents(uint8 numComponents, bool convert = true) = 0;

        virtual void setConvertICCSpacesWithProfileVersionGreaterThan(uint8 majorVersion, uint8 minorVersion) = 0;

        virtual void setConvertColorsInsideLuminositySoftMasks(bool convert = true) = 0;

        virtual void setConvertThroughTransparencyGroupColorSpaces(bool useGroups = true) = 0;

        virtual void setKeepOverprintMode(bool keep = true) = 0;

        virtual void setDeviceNHandling(bool convertProcess = true,
                                        bool mergeSpots = true,
                                        const IDOMColorSpaceDeviceN::CColorantInfoVect &spotsToMerge = IDOMColorSpaceDeviceN::CColorantInfoVect(),
                                        const CSpotColorNames &spotsToRetain = CSpotColorNames(),
                                        const CSpotColorNames &spotsToDrop = CSpotColorNames(),
                                        bool knockoutDroppedSpots = true) = 0;
    };
 
 
    class IComplexColorSimplifierTransform;
    DECL_SMART_PTR(IComplexColorSimplifierTransform);

    class IComplexColorSimplifierTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IComplexColorSimplifierTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  There is no configuration for this transform.
         */
    };
 
 
    class IImageMergerTransform;
    DECL_SMART_PTR(IImageMergerTransform);

    class IImageMergerTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IImageMergerTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  Configuration
         */

        virtual void setAllowMaskedResults(bool allowMasked) = 0;
 
    };
 
 
    class IOptionalContentFixerTransform;
    DECL_SMART_PTR(IOptionalContentFixerTransform);

    class IOptionalContentFixerTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IOptionalContentFixerTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  Configuration
         */
 
        typedef enum
        {
            eOCUView,
            eOCUPrint,
            eOCUExport
        } eOptionalContentUsage;

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

        virtual void setOptionalContentUsage(eOptionalContentUsage usage) = 0;
    };
 
 
    class ICFFCIDSplitterTransform;
    DECL_SMART_PTR(ICFFCIDSplitterTransform);

    class ICFFCIDSplitterTransform : public ITransform
    {
      public:
        static JAWSMAKO_API ICFFCIDSplitterTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  There is no configuration for this transform.
         */
    };
 
    class ICFFSanitizerTransform;
    DECL_SMART_PTR(ICFFSanitizerTransform);

    class ICFFSanitizerTransform : public ITransform
    {
       public:
        static JAWSMAKO_API ICFFSanitizerTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  There is no configuration for this transform.
         */
    };
 
 
    class IStrokerTransform;
    DECL_SMART_PTR(IStrokerTransform);

    class IStrokerTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IStrokerTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  Configuration
         */

        virtual void setTargetResolution(float resolution) = 0;

        virtual void setupForXPSStyleOutput() = 0;

        virtual void setupForPDFStyleOutput() = 0;

        virtual void setConvertAllStrokes(bool convert) = 0;
 
        /* @brief Conditions. If any are true a stroker will be converted to a fill */

        virtual void setConvertForDashedStrokes(bool convert) = 0;

        virtual void setConvertForNonTilingVisualOrImageStrokes(bool convert) = 0;

        virtual void setConvertForMiterTreatment(IDOMPathNode::eStrokeMiterLimitTreatment treatment, bool convert = true) = 0;

        virtual void setMiterErrorThreshold(float maxError) = 0;

        virtual void setConvertForLineCap(IDOMPathNode::eStrokeLineCap cap, bool convert = true) = 0;

        virtual void setConvertForDashCap(IDOMPathNode::eStrokeLineCap cap, bool convert = true) = 0;

        virtual void setConvertForMismatchedCaps(bool convert) = 0;

        virtual void setConvertForMismatchedDashCap(bool convert) = 0;

        virtual void setConvertForJoin(IDOMPathNode::eStrokeLineJoin join, bool convert = true) = 0;

        virtual void setConvertForNonStrokingSegments(bool convert) = 0;
 
    };
 
 
    class IFormUnpackerTransform;
    DECL_SMART_PTR(IFormUnpackerTransform);

    class IFormUnpackerTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IFormUnpackerTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  Configuration
         */

        virtual void setUnpackFlaggedFormInstancesOnly(bool unpack) = 0;
 
    };
 
 
    class IRendererTransform;
    DECL_SMART_PTR(IRendererTransform);

    class IRendererTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IRendererTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());

        virtual bool probe(const IDOMNodePtr &node) = 0;
 
        /*
         *  Configuration
         */

        virtual void setResolution(uint32 resolution) = 0;

        virtual uint32 getResolution() const = 0;

        virtual void setTargetSpace(const IDOMColorSpacePtr &space) = 0;

        virtual IDOMColorSpacePtr getTargetSpace() const = 0;

        virtual void setSWOPTargetSpace() = 0;

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

        virtual void setEnableVectorMode(bool enable) = 0;

        virtual void setUseImageResolutionForRenderingWherePossible(bool enable) = 0;

        virtual void setVectorAndTextResolution(uint32 resolution) = 0;

        virtual void setRasterFallbackThreshold(uint32 threshold) = 0;

        virtual void setRasterFallbackResolution(uint32 resolution) = 0;

        virtual void setVectorImageReuseCacheSize(uint32 reuseCacheSizeMB) = 0;

        virtual void setEnableFormSnappingForVectorReuse(bool enable) = 0;

        virtual void setVectorAreaFormReuseCacheSize(uint32 formCount) = 0;

        virtual void setVectorAreaSourceReuseCacheSize(uint32 count) = 0;

        virtual void setMarkVectorFlattenedFontsForEmbedding(bool embed) = 0;

        virtual void setFormReconstructionCacheSize(uint32 formCount) = 0;

        virtual void setRasterImageReuseCacheSize(uint32 reuseCacheSizeMB) = 0;

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

        virtual void setSpotHalftone(float frequency, bool useFullResolutionForFlattening = false) = 0;
 
        typedef CEDLVector<uint8> CThresholdArray;

        virtual void setThresholdHalftone(uint32 width, uint32 height, const CThresholdArray &thresholds) = 0;

        virtual void setPreserveSpots(const CSpotColorNames &preservedSpots) = 0;

        virtual void setPreserveAllSpots(bool preserve) = 0;

        virtual void setMergeSpots(const CSpotColorNames &mergedSpots) = 0;

        virtual void setMergeAllSpots(bool merge) = 0;

        virtual void setDropSpots(const CSpotColorNames &droppedSpots) = 0;

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

        virtual void setGenerateMasks(bool generate) = 0;

        virtual void setUseMultipleThreads(bool useMultipleThreads) = 0;

        virtual void setRenderObjectsIndividually(bool renderIndividually) = 0;

        virtual void setRenderOncePerRenderableArea(bool renderOnce) = 0;

        virtual void setMaximumImageAreaMultiple(float limit) = 0;

        virtual void setMaximumRenderedResultPixels(uint64 maximum) = 0;

        virtual void setGenerateFlateCompressedPDFImages(bool enable) = 0;

        virtual void setMinimumFlateCompressedImageSize(uint32 minSizePixels) = 0;


        virtual void renderNodesWithRenderFlagSet(bool render) = 0;
        
        virtual void ignoreNodesWithExcludeFlagSet(bool ignore) = 0;
        
        typedef bool (*ShouldRenderNodeFunc)(void *priv, const IDOMNodePtr &node);

        virtual void setShouldRenderCallback(ShouldRenderNodeFunc func, void *priv) = 0;

        virtual void renderTransparentNodes(bool render) = 0;

        virtual void setRenderTransparentNodesOnPageGroupMismatch(bool render) = 0;

        virtual void renderNonNormalBlendedNodes(bool render) = 0;

        virtual void renderNonCanvasTransparencyGroups(bool render) = 0;

        virtual void renderMaskedImages(bool render) = 0;

        virtual void renderOpacityMaskedNodes(bool render) = 0;

        virtual void renderBrush(IDOMBrush::eBrushType brushType, bool render = true) = 0;

        virtual void ignoreBrushWhileScanning(IDOMBrush::eBrushType brushType, bool ignore = true) = 0;

        virtual void renderComplexType3ShadingPatterns(bool render) = 0;

        virtual void renderComplexTilingPatterns(bool render) = 0;

        virtual void renderVisualBrushesWithViewPortLargerThan(double val) = 0;

        virtual void renderConeGradients(bool render) = 0;

        virtual void renderGlyphsWithStyleSimulation(bool render) = 0;

        virtual void renderGlyphsWithRestrictedFont(bool render) = 0;

        virtual void renderGlyphsWithNonSubsettableFont(bool render) = 0;

        virtual void renderGlyphsWithNonEditableFont(bool render) = 0;

        virtual void renderGlyphsWithType3Font(bool render) = 0;

            virtual void enableTrueTypeNotDef(bool enable) = 0;
 
        class CInkInfo
        {
          public:
            RawString       inkName;
            IDOMColorPtr    inkColor;
            typedef enum
            {
                eICSNoViableColorFound = 0,
                eICSTintTransform = 1,
                eICSSeparationSpace = 2,
                eICSColorantInfo = 3
            } eInkColorSource;
            eInkColorSource inkSource { eICSTintTransform };
 
            bool operator== (const CInkInfo &other) const
            {
                return     (other.inkName   == inkName)
                        && (other.inkColor  == inkColor);
            }
 
            bool operator!= (const CInkInfo &other) const
            {
                return ! (*this == other);
            }
 
            String getInkName() const
            {
                return inkNameToString(inkName);
            }
 
            String getInkName(eInkFallbackEncoding fallbackEncoding) const
            {
                return inkNameToString(inkName, fallbackEncoding);
            }
        };
        typedef CEDLVector<CInkInfo> CInkInfoVect;

         static JAWSMAKO_API CInkInfoVect findInks(const IJawsMakoPtr &jawsMako,
                                                   const IDOMNodePtr &nodeTree,
                                                   const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr (),
                                                   bool includeAll = false);

        static JAWSMAKO_API CInkInfoVect findInksInColorSpace(const IJawsMakoPtr &jawsMako,
                                                              const IDOMColorSpacePtr &colorSpace,
                                                              bool includeAll = false);

        static JAWSMAKO_API IDOMColorSpaceDeviceN::CColorantInfoVect inkInfoToColorantInfo(const IJawsMakoPtr &jawsMako,
                                                                                           const CInkInfoVect &inkInfo,
                                                                                           const IDOMColorSpacePtr &processSpace,
                                                                                           const CColorManagerConfigPtr &overrideConfig = CColorManagerConfigPtr());
    };
 
    class IRedactorTransform;
    DECL_SMART_PTR(IRedactorTransform);

    class IRedactorTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IRedactorTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());

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

        virtual void setResolution(uint32 resolution) = 0;

        virtual void setGenerateMasks(bool generateMasks) = 0;
    };
 
 
    class IType3UnpackerTransform;
    DECL_SMART_PTR(IType3UnpackerTransform);

    class IType3UnpackerTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IType3UnpackerTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  There is no configuration for this transform.
         */
 
    };
 
    class IOverprintSimulationTransform;
    DECL_SMART_PTR(IOverprintSimulationTransform);

    class IOverprintSimulationTransform: public ITransform
    {
      public:
        static JAWSMAKO_API IOverprintSimulationTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());

        virtual void setResolution(uint32 resolution) = 0;

        virtual void setSimulationColorSpace(const IDOMColorSpacePtr &simulationSpace) = 0;

        virtual void setSimulateBlackDeviceGrayTextOverprint(bool simulate) = 0;
        
        virtual void setUseVectorFlattener(bool useVectorFlattener) = 0;
    };
 
    class IPageCropperTransform;
    DECL_SMART_PTR(IPageCropperTransform);

    class IPageCropperTransform : public ITransform
    {
      public:
        typedef enum eBox
        {
            eBCrop,       
            eBContent,    
            eBTrim,       
            eBBleed       
        } eBox;
 

        static JAWSMAKO_API IPageCropperTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  Configuration.
         */

        virtual void setCropBox(eBox cropBox) = 0;

        virtual void setShouldClip(bool clip) = 0;
    };
 
    class IPatternConverterTransform;
    DECL_SMART_PTR(IPatternConverterTransform);

    class IPatternConverterTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IPatternConverterTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  Configuration.
         */

        virtual void setConvertType2ShadingPatterns(bool convert) = 0;

        virtual void setMaxType2Samples(uint32 maxSamples) = 0;

        virtual void setConvertType3ShadingPatterns(bool convert) = 0;

        virtual void setMaxType3Samples(uint32 maxSamples) = 0;
    };
 
    class IFontProcessorTransform;
    DECL_SMART_PTR(IFontProcessorTransform);

    class IFontProcessorTransform : public ITransform
    {
      public:
        virtual ~IFontProcessorTransform() {}

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

        virtual void setShouldSubset(bool subset) = 0;

        virtual void setShouldMerge(bool merge) = 0;

        virtual void setIgnoreUnembeddedFonts(bool ignore) = 0;

        virtual void setIgnoreRestrictedFonts(bool ignore) = 0;

        virtual void setIgnoreFonts(const CU8StringVect &ignoreFonts) = 0;

        virtual bool shouldMerge() = 0;

        virtual bool shouldSubset() = 0;
    };
 
    class IFontProcessorDeferredTransform;
    DECL_SMART_PTR(IFontProcessorDeferredTransform);

    class IFontProcessorDeferredTransform : public ITransform
    {
      public:
        virtual ~IFontProcessorDeferredTransform() {}

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

        virtual void finaliseFonts() = 0;

        virtual void setShouldSubset(bool subset) = 0;

        virtual void setShouldMerge(bool merge) = 0;

        virtual void setIgnoreUnembeddedFonts(bool ignore) = 0;

        virtual void setIgnoreRestrictedFonts(bool ignore) = 0;

        virtual void setIgnoreFonts(const CU8StringVect &ignoreFonts) = 0;

        virtual bool shouldMerge() = 0;

        virtual bool shouldSubset() = 0;
    };
 
    class IBlendSimplifierTransform;
    DECL_SMART_PTR(IBlendSimplifierTransform);

    class IBlendSimplifierTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IBlendSimplifierTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  No configuration.
         */
    };
 
    class ISoftMaskConverterTransform;
    DECL_SMART_PTR(ISoftMaskConverterTransform);

    class ISoftMaskConverterTransform : public ITransform
    {
    public:
        static JAWSMAKO_API ISoftMaskConverterTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());

        virtual void setResolution(uint32 resolution) = 0;
    };
 
    class IFormDeduplicatorTransform;
    DECL_SMART_PTR(IFormDeduplicatorTransform);

    class IFormDeduplicatorTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IFormDeduplicatorTransformPtr create(const IJawsMakoPtr &jawsMako, const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());
 
        /*
         *  No configuration.
         */
    };
    
    class IShadingPatternNoiserTransform;
    DECL_SMART_PTR(IShadingPatternNoiserTransform);

    class IShadingPatternNoiserTransform : public ITransform
    {
      public:
        static JAWSMAKO_API IShadingPatternNoiserTransformPtr create(const IJawsMakoPtr &jawsMako,
                                                                     const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr ());

        virtual void setNoiseMagnitude(uint8 magnitude) = 0;

        virtual void setResolution(double xRes, double yRes = 0.0) = 0;
        
        virtual void setCompress(bool compress) = 0;
    };
 
}
 
#endif