customtransform.h

Go to the documentation of this file.

/*
* Copyright (C) 2017-2025 Global Graphics Software Ltd. All rights reserved.
*/
 
#ifndef JAWSMAKO_CUSTOMTRANSFORM_H
#define JAWSMAKO_CUSTOMTRANSFORM_H

 
#include <jawsmako/transforms.h>
#include <edl/idomcharpathgroup.h>
#include <edl/idomcanvas.h>
 
namespace JawsMako
{
    using namespace EDL;
 
    class ICustomTransform;
    DECL_SMART_PTR(ICustomTransform);
 
#ifdef SWIG
#ifdef SWIGPYTHON
    %apply bool &           DIRECTOROUT    { bool &changed };
    %apply unsigned int &   DIRECTOROUT    { uint32 &index };
#else
    %apply bool     &INOUT          { bool &changed };
    %apply uint32_t &OUTPUT         { uint32 &index };
#endif
#endif
    class ICustomTransform : public ITransform
    {
      public:
        virtual ~ICustomTransform() {}

        class IImplementation
        {
          public:
            virtual ~IImplementation() {}

            virtual void transformAnnotation(IImplementation *genericImplementation, const IAnnotationPtr &annotation)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return;
                }
                genericImplementation->transformAnnotation(nullptr, annotation);
            }

            virtual IAnnotationAppearancePtr transformAnnotationAppearance(IImplementation *genericImplementation, const IAnnotationAppearancePtr &appearance, const FRect &annotationRect)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformAnnotationAppearance(nullptr, appearance, annotationRect);
            }

            virtual IDOMColorPtr transformColor(IImplementation *genericImplementation, const IDOMColorPtr &color, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformColor(nullptr, color, state);
            }

            virtual IDOMColorSpacePtr transformColorSpace(IImplementation *genericImplementation, const IDOMColorSpacePtr &colorSpace, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformColorSpace(nullptr, colorSpace, state);
            }

            virtual IDOMImagePtr transformImage(IImplementation *genericImplementation, const IDOMImagePtr &image, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformImage(nullptr, image, state);
            }

            virtual IDOMNodePtr transformNode(IImplementation *genericImplementation, const IDOMNodePtr &node, bool &changed, bool transformChildren, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformNode(nullptr, node, changed, transformChildren, state);
            }

            virtual IDOMNodePtr transformFixedPage(IImplementation *genericImplementation, const IDOMFixedPagePtr &page, bool &changed, bool transformChildren, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformFixedPage(nullptr, page, changed, transformChildren, state);
            }

            virtual IDOMNodePtr transformGroup(IImplementation *genericImplementation, const IDOMGroupPtr &group, bool &changed, bool transformChildren, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformGroup(nullptr, group, changed, transformChildren, state);
            }

            virtual IDOMNodePtr transformCharPathGroup(IImplementation *genericImplementation, const IDOMCharPathGroupPtr &group, bool &changed, bool transformChildren, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformCharPathGroup(nullptr, group, changed, transformChildren, state);
            }

            virtual IDOMNodePtr transformTransparencyGroup(IImplementation *genericImplementation, const IDOMTransparencyGroupPtr &group, bool &changed, bool transformChildren, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformTransparencyGroup(nullptr, group, changed, transformChildren, state);
            }

            virtual IDOMNodePtr transformCanvas(IImplementation *genericImplementation, const IDOMCanvasPtr &canvas, bool &changed, bool transformChildren, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformCanvas(nullptr, canvas, changed, transformChildren, state);
            }

            virtual IDOMNodePtr transformGlyphs(IImplementation *genericImplementation, const IDOMGlyphsPtr &glyphs, bool &changed, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformGlyphs(nullptr, glyphs, changed, state);
            }

            virtual IDOMFontPtr transformFont(IImplementation *genericImplementation, const IDOMFontPtr &font, uint32 &index, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformFont(nullptr, font, index, state);
            }

            virtual IDOMNodePtr transformPath(IImplementation *genericImplementation, const IDOMPathNodePtr &path, bool &changed, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformPath(nullptr, path, changed, state);
            }

            virtual IDOMNodePtr transformVisualRoot(IImplementation *genericImplementation, const IDOMVisualRootPtr &root, bool &changed, bool transformChildren, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformVisualRoot(nullptr, root, changed, transformChildren, state);
            }

            virtual IDOMNodePtr transformForm(IImplementation *genericImplementation, const IDOMFormPtr &form, bool &changed, bool transformChildren, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformForm(nullptr, form, changed, transformChildren, state);
            }

            virtual IDOMNodePtr transformFormInstance(IImplementation *genericImplementation, const IDOMFormInstancePtr &instance, bool &changed, bool transformChildren, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformFormInstance(nullptr, instance, changed, transformChildren, state);
            }

            virtual IDOMBrushPtr transformBrush(IImplementation *genericImplementation, const IDOMBrushPtr &brush, eBrushUsage usage, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformBrush(nullptr, brush, usage, state);
            }

            virtual IDOMBrushPtr transformSolidColorBrush(IImplementation *genericImplementation, const IDOMSolidColorBrushPtr &brush, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformSolidColorBrush(nullptr, brush, state);
            }

            virtual IDOMBrushPtr transformGradientBrush(IImplementation *genericImplementation, const IDOMGradientBrushPtr &gradient, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformGradientBrush(nullptr, gradient, state);
            }

            virtual IDOMBrushPtr transformLinearGradientBrush(IImplementation *genericImplementation, const IDOMLinearGradientBrushPtr &gradient, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformLinearGradientBrush(nullptr, gradient, state);
            }

            virtual IDOMBrushPtr transformRadialGradientBrush(IImplementation *genericImplementation, const IDOMRadialGradientBrushPtr &gradient, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformRadialGradientBrush(nullptr, gradient, state);
            }

            virtual IDOMBrushPtr transformVisualBrush(IImplementation *genericImplementation, const IDOMVisualBrushPtr &brush, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformVisualBrush(nullptr, brush, state);
            }

            virtual IDOMBrushPtr transformImageBrush(IImplementation *genericImplementation, const IDOMImageBrushPtr &brush, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformImageBrush(nullptr, brush, state);
            }

            virtual IDOMBrushPtr transformTilingPatternBrush(IImplementation *genericImplementation, const IDOMTilingPatternBrushPtr &brush, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformTilingPatternBrush(nullptr, brush, state);
            }

            virtual IDOMBrushPtr transformShadingPatternBrush(IImplementation *genericImplementation, const IDOMShadingPatternBrushPtr &brush, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformShadingPatternBrush(nullptr, brush, state);
            }

            virtual IDOMBrushPtr transformSoftMaskBrush(IImplementation *genericImplementation, const IDOMSoftMaskBrushPtr &brush, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformSoftMaskBrush(nullptr, brush, state);
            }

            virtual IDOMBrushPtr transformMaskedBrush(IImplementation *genericImplementation, const IDOMMaskedBrushPtr &brush, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformMaskedBrush(nullptr, brush, state);
            }

            virtual IDOMBrushPtr transformNullBrush(IImplementation *genericImplementation, const IDOMNullBrushPtr &brush, const CTransformState &state)
            {
                if (!genericImplementation)
                {
                    throwEDLError(EDL_ERR_BAD_ARGUMENTS);
                    return nullptr;
                }
                return genericImplementation->transformNullBrush(nullptr, brush, state);
            }
 
        };
#ifdef SWIG
        %clear bool &changed;
        %clear uint32 &index;
#endif

        static JAWSMAKO_API ICustomTransformPtr create(const IJawsMakoPtr &jawsMako,
                                                       IImplementation *implementation,
                                                       const IProgressMonitorPtr &progressMonitor = IProgressMonitorPtr (),
                                                       bool dependsOnClipBounds = true,
                                                       bool dependsOnGroupSpace = true,
                                                       bool dependsOnRenderingIntent = true,
                                                       bool dependsOnTransform = true,
                                                       bool dependsOnBrushUsage = true,
                                                       bool dependsOnEdgeMode = true,
                                                       bool dependsOnUncoloredTilingBrush = true)
        {
            return ICustomTransform::create(jawsMako, implementation, progressMonitor,
                                            dependsOnClipBounds, dependsOnGroupSpace, dependsOnRenderingIntent,
                                            dependsOnTransform, dependsOnTransform, dependsOnBrushUsage,
                                            dependsOnEdgeMode, dependsOnUncoloredTilingBrush);
        }
 

        static JAWSMAKO_API ICustomTransformPtr create(const IJawsMakoPtr &jawsMako,
                                                       IImplementation *implementation,
                                                       const IProgressMonitorPtr &progressMonitor,
                                                       bool dependsOnClipBounds,
                                                       bool dependsOnGroupSpace,
                                                       bool dependsOnRenderingIntent,
                                                       bool dependsOnTransformScale,
                                                       bool dependsOnTransformOffset,
                                                       bool dependsOnBrushUsage,
                                                       bool dependsOnEdgeMode,
                                                       bool dependsOnUncoloredTilingBrush);
 
    };
}
 
#endif