layout.h

Go to the documentation of this file.

/*
 * Copyright (C) 2023-2025 Global Graphics Software Ltd. All rights reserved.
 */
 
#ifndef JAWSMAKO_LAYOUT_H
#define JAWSMAKO_LAYOUT_H
 
#include <utility>
#include <cstdint>
#include <edl/idomcolor.h>
#include <edl/idomfont.h>
#include <jawsmako/types.h>
 
namespace JawsMako
{
    using namespace EDL;
 
    // Forward declarations
    class ILayout;
    DECL_SMART_PTR(ILayout);
    class ILayoutFrame;
    DECL_SMART_PTR(ILayoutFrame);
    class ILayoutParagraph;
    DECL_SMART_PTR(ILayoutParagraph);
    typedef CEDLVector<ILayoutParagraphPtr> CLayoutParagraphVect;
    class ILayoutRun;
    DECL_SMART_PTR(ILayoutRun);
    class ILayoutTextRun;
    DECL_SMART_PTR(ILayoutTextRun);
    class ILayoutImageRun;
    DECL_SMART_PTR(ILayoutImageRun);
    typedef CEDLVector<ILayoutRunPtr> CLayoutRunVect;
    class ILayoutFont;
    DECL_SMART_PTR(ILayoutFont);
    class ILayoutFontWeight;
    DECL_SMART_PTR(ILayoutFontWeight);

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

        typedef enum
        {
            eVATop,    
            eVACenter, 
            eVABottom  
        } eVerticalAlignment;

        static JAWSMAKO_API ILayoutFramePtr create(const FRect &bounds,
                                                   eVerticalAlignment verticalAlignment = eVATop);

        virtual ILayoutFramePtr clone() const = 0;

        virtual const FRect &getBounds() const = 0;

        virtual eVerticalAlignment getVerticalAlignment() const = 0;
    };

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

        typedef enum
        {
            eHALeft,     
            eHACenter,   
            eHARight,    
            eHAJustified 
        } eHorizontalAlignment;

        static JAWSMAKO_API ILayoutParagraphPtr create(eHorizontalAlignment horizontalAlignment = eHALeft,
                                                       double spacingAfter = 0.0, double spacingBefore = 0.0,
                                                       double leading = 1.0,
                                                       const IDOMColorPtr &defaultColor = IDOMColorPtr(),
                                                       const ILayoutFontPtr &defaultFont = ILayoutFontPtr(),
                                                       bool exact = true,
                                                       double defaultFontSize = -1.0);

        static JAWSMAKO_API ILayoutParagraphPtr create(eHorizontalAlignment horizontalAlignment,
                                                       double spacingAfter, double spacingBefore,
                                                       double leading,
                                                       const IDOMColorPtr &defaultColor,
                                                       const IDOMFontOpenTypePtr &defaultFont,
                                                       uint32 defaultFontIndex = 0,
                                                       double defaultFontSize = -1.0);

        virtual ILayoutParagraphPtr clone() const = 0;

        virtual void addRun(const ILayoutRunPtr &run) = 0;

        virtual const CLayoutRunVect &getRuns() const = 0;

        virtual eHorizontalAlignment getHorizontalAlignment() const = 0;

        virtual void setSpacing(double spacing, bool before = false) = 0;

        virtual double getSpacing(bool before = false) const = 0;

        virtual void setLeading(double leading) = 0;

        virtual double getLeading() const = 0;

        virtual void setDefaultFont(const ILayoutFontPtr &defaultFont, bool exact = true) = 0;

        virtual void setDefaultFont(const IDOMFontOpenTypePtr &defaultFont,
                                    uint32 defaultFontIndex) = 0;
 

        virtual const IDOMFontOpenTypePtr &getDefaultFont() const = 0;

        virtual uint32 getDefaultFontIndex() const = 0;

        virtual void setDefaultFontSize(double defaultFontSize) = 0;

        virtual double getDefaultFontSize() const = 0;

        virtual void setDefaultColor(const IDOMColorPtr &defaultColor) = 0;

        virtual const IDOMColorPtr &getDefaultColor() const = 0;

        virtual void addBreak() = 0;
    };

    class ILayoutRun : public IRCObject
    {
      public:
        virtual ~ILayoutRun() {}
    };

    class ILayoutTextRun : public ILayoutRun
    {
      public:
        virtual ~ILayoutTextRun() {}

        static JAWSMAKO_API ILayoutTextRunPtr create(const U8String &text,
                                                     const IDOMFontOpenTypePtr &font,
                                                     uint32 fontIndex,
                                                     double size,
                                                     const IDOMColorPtr &color = IDOMColorPtr(),
                                                     double letterSpacing = 0.0);

        static JAWSMAKO_API ILayoutTextRunPtr create(const String &text,
                                                     const IDOMFontOpenTypePtr &font,
                                                     uint32 fontIndex,
                                                     double size,
                                                     const IDOMColorPtr &color = IDOMColorPtr(),
                                                     double letterSpacing = 0.0);

        static JAWSMAKO_API ILayoutTextRunPtr create(const U8String &text,
                                                     const ILayoutFontPtr &font,
                                                     double size,
                                                     bool exact = true,
                                                     const IDOMColorPtr &color = IDOMColorPtr(),
                                                     double letterSpacing = 0.0);

        static JAWSMAKO_API ILayoutTextRunPtr create(const String &text,
                                                     const ILayoutFontPtr &font,
                                                     double size,
                                                     bool exact = true,
                                                     const IDOMColorPtr &color = IDOMColorPtr(),
                                                     double letterSpacing = 0.0);

        static JAWSMAKO_API ILayoutTextRunPtr create(const IJawsMakoPtr &jawsMako,
                                                     const U8String &text,
                                                     const U8String &fontName,
                                                     double size,
                                                     const IDOMColorPtr &color = IDOMColorPtr(),
                                                     double letterSpacing = 0.0);

        static JAWSMAKO_API ILayoutTextRunPtr create(const IJawsMakoPtr &jawsMako,
                                                     const String &text,
                                                     const U8String &fontName,
                                                     double size,
                                                     const IDOMColorPtr &color = IDOMColorPtr(),
                                                     double letterSpacing = 0.0);

        virtual const U8String &getText() const = 0;

        virtual const IDOMFontOpenTypePtr &getFont() const = 0;

        virtual uint32 getFontIndex() const = 0;

        virtual double getSize() const = 0;

        virtual void setColor(const IDOMColorPtr &color) = 0;

        virtual const IDOMColorPtr &getColor() const = 0;

        virtual void setLetterSpacing(double letterSpacing) = 0;

        virtual double getLetterSpacing() const = 0;
 
    };
    #define obj2ILayoutTextRun(obj) ILayoutTextRunPtr(dynamic_cast<ILayoutTextRun *>((IRCObject *) obj), true)

    class ILayoutImageRun : public ILayoutRun
    {
      public:
        virtual ~ILayoutImageRun() {}

        static JAWSMAKO_API ILayoutImageRunPtr create(const IJawsMakoPtr &jawsMako, const IDOMImagePtr &image, double width = 0.0, double height = 0.0);

        virtual const IDOMImagePtr &getImage() const = 0;

        virtual double getWidth() const = 0;

        virtual double getHeight() const = 0;
    };
    #define obj2ILayoutImageRun(obj) ILayoutImageRunPtr(dynamic_cast<ILayoutImageRun *>((IRCObject *) obj), true)

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

        typedef enum
        {
            eAny = 0,           
            eThin = 100,        
            eExtraLight = 200,  
            eLight = 300,       
            eSemiLight = 350,   
            eNormal = 400,      
            eMedium = 500,      
            eSemiBold = 600,    
            eBold = 700,        
            eExtraBold = 800,   
            eBlack = 900,       
            eExtraBlack = 950   
        } eFontWeight;

        static JAWSMAKO_API ILayoutFontWeightPtr create(uint16 weight = eAny, uint16 allowedError = 0);

        static JAWSMAKO_API ILayoutFontWeightPtr createFromVect(const CUInt16Vect &weights, uint16 allowedError = 0);

        static JAWSMAKO_API ILayoutFontWeightPtr createFromRange(uint16 weightLow, uint16 weightHigh);

        virtual bool match(uint16 weight) const = 0;

        virtual uint16 difference(uint16 weight) const = 0;

        virtual bool equals(const ILayoutFontWeightPtr &weight) const = 0;
    };
    #define obj2ILayoutFontWeight(obj) ILayoutFontWeightPtr(dynamic_cast<ILayoutFontWeight *>((IRCObject *) obj), true)

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

        typedef enum
        {
            eFSAny,          
            eFSItalic = 1,   
            eFSRegular = 64  
        } eFontStyle;

        typedef enum
        {
            eFPAny,          
            eFPMonoSpaced,   
            eFPProportional  
        } eFontProportion;

        typedef enum
        {
            eFSSAny,         
            eFSSSerif,       
            eFSSSansSerif    
        } eFontSerifStyle;

        static JAWSMAKO_API ILayoutFontPtr create(const IJawsMakoPtr &jawsMako,
                                                  const ILayoutFontWeightPtr &weight = ILayoutFontWeightPtr(),
                                                  eFontStyle style = eFSAny,
                                                  eFontProportion proportion = eFPAny,
                                                  eFontSerifStyle serifStyle = eFSSAny,
                                                  uint64 codePage = UINT64_MAX);
 
        /*
         * @brief   Set the font weight.
         *
         * @param   weight Weights used when finding fonts.
         */
        virtual void setWeight(const ILayoutFontWeightPtr &weight) = 0;
 
        /*
         * @brief   Set the font style.
         *
         * @param   style The style to be used when finding fonts.
         */
        virtual void setStyle(eFontStyle style) = 0;
 
        /*
         * @brief   Set the font proportion type.
         *
         * @param   proportion The proportion type used when finding fonts.
         */
        virtual void setProportion(eFontProportion proportion) = 0;
 
        /*
         * @brief   Set the serif style.
         *
         * @param   serifStyle The Serif style used when finding fonts.
         */
        virtual void setSerif(eFontSerifStyle serifStyle) = 0;
 
        /*
         * @brief   Set the code page ranges.
         *
         * @param   codePage The code page character ranges used when finding fonts.
         */
        virtual void setCodePage(uint64 codePage) = 0;

        class CLayoutFontItem
        {
          public:
            IDOMFontOpenTypePtr     domFont;
            uint32                  fontIndex;
 
            CLayoutFontItem (const IDOMFontOpenTypePtr &domFont, uint32 fontIndex)
            {
                this->domFont    = domFont;
                this->fontIndex  = fontIndex;
            }
 
            CLayoutFontItem ()
            {
                fontIndex = 0;
            }
 
            bool operator== (const CLayoutFontItem &other) const
            {
                return      (other.domFont      == domFont)
                        &&  (other.fontIndex    == fontIndex);
            }
 
            bool operator!= (const CLayoutFontItem &other) const
            {
                return ! (*this == other);
            }
 
            bool operator< (const CLayoutFontItem &other) const
            {
                if (domFont == other.domFont)
                    return fontIndex < other.fontIndex;
                else
                    return domFont < other.domFont;
            }
 
        };
 
        typedef CEDLVector<CLayoutFontItem> CLayoutFontVect;

        virtual CLayoutFontVect findFonts() const = 0;

        virtual void findFont(IDOMFontOpenTypePtr &font, uint32 &fontIndex, bool exact = true) const = 0;
    };
    #define obj2ILayoutFont(obj) ILayoutFontPtr(dynamic_cast<ILayoutFont *>((IRCObject *) obj), true)

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

        static JAWSMAKO_API ILayoutPtr create(const IJawsMakoPtr &jawsMako);

        static JAWSMAKO_API ILayoutPtr createWithFrame(const IJawsMakoPtr &jawsMako,
                                                       const FRect &frameBounds,
                                                       ILayoutFrame::eVerticalAlignment frameVerticalAlignment = ILayoutFrame::eVACenter);

        virtual void addFrame(const ILayoutFramePtr &frame) = 0;

        virtual IDOMNodePtr layout(const CLayoutParagraphVect &paragraphs) = 0;

        virtual IDOMNodePtr layout(const ILayoutParagraphPtr &paragraph) = 0;

        virtual IDOMNodePtr layout(const ILayoutRunPtr &run,
                                   ILayoutParagraph::eHorizontalAlignment horizontalAlignment,
                                   double spacingAfter = 0.0,
                                   double spacingBefore = 0.0,
                                   double leading = 1.0) = 0;
    };
}
#endif