optionalcontent.h

Go to the documentation of this file.

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

 
#include <jawsmako/types.h>
#include <jawsmako/hashable.h>
 
namespace JawsMako
{
    using namespace EDL;
 
    // Forward declarations
    class IOptionalContentGroupUsage;
    DECL_SMART_PTR(IOptionalContentGroupUsage);
    class IOptionalContentGroupUsageApplication;
    DECL_SMART_PTR(IOptionalContentGroupUsageApplication);
    class IOptionalContentConfiguration;
    DECL_SMART_PTR(IOptionalContentConfiguration);
    class IOptionalContentVisibilityExpression;
    DECL_SMART_PTR(IOptionalContentVisibilityExpression);
    typedef CEDLVector<IOptionalContentGroupPtr> COptionalContentGroupVect;
    typedef CEDLVector<IOptionalContentGroupUsageApplicationPtr> COptionalContentGroupUsageApplicationVect;
    typedef CEDLVector<IOptionalContentConfigurationPtr> COptionalContentConfigurationVect;
    typedef CEDLVector<IOptionalContentVisibilityExpressionPtr> COptionalContentVisibilityExpressionVect;

    typedef enum eOptionalContentVisibility
 
    {
        eOCVVisible,            
        eOCVInvisible,          
        eOCVUnchanged           
    } eOptionalContentVisibility;

    typedef enum eOptionalContentCategory
 
    {
        eOCCUnknown,            
        eOCCView,               
        eOCCPrint,              
        eOCCExport,             
        eOCCZoom,               
        eOCCUser,               
        eOCCLanguage            
    } eOptionalContentCategory;
 
    typedef CEDLVector<eOptionalContentCategory> COCCategoryVect;

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

        static JAWSMAKO_API IOptionalContentPtr create(const IJawsMakoPtr &jawsMako,
                                                       const IOptionalContentConfigurationPtr &defaultConfiguration = IOptionalContentConfigurationPtr());

        virtual IOptionalContentPtr clone() = 0;
 
        /*
         *
         * Making content optional - convenience routines.
         *
         */

        virtual IOptionalContentGroupPtr makeNewGroup(const U8String &name, bool visible) = 0;

        virtual IDOMNodePtr makeNodeOptional(const IDOMNodePtr &node, const IOptionalContentGroupPtr &group) = 0;

        IDOMNodePtr makeNodeOptionalWithNewGroup(const IDOMNodePtr &node, const U8String &newGroupName, bool visible)
        {
            IOptionalContentGroupPtr group = makeNewGroup(newGroupName, visible);
            return makeNodeOptional(node, group);
        }
 
        /*
         *
         * Visibility Queries
         *
         */

        virtual bool groupIsVisible(const IOptionalContentGroupPtr &group,
                                    eOptionalContentEvent event = eOCEView,
                                    const IOptionalContentConfigurationPtr &configuration = IOptionalContentConfigurationPtr()) = 0;

        virtual bool groupIsVisible(const IOptionalContentGroupReferencePtr &groupRef,
                                    eOptionalContentEvent event = eOCEView,
                                    const IOptionalContentConfigurationPtr &configuration = IOptionalContentConfigurationPtr()) = 0;

        virtual bool groupShouldBeIgnored(const IOptionalContentGroupPtr &group,
                                          eOptionalContentEvent event = eOCEView,
                                          const IOptionalContentConfigurationPtr &configuration = IOptionalContentConfigurationPtr()) = 0;

        virtual bool groupShouldBeIgnored(const IOptionalContentGroupReferencePtr &groupRef,
                                          eOptionalContentEvent event = eOCEView,
                                          const IOptionalContentConfigurationPtr &configuration = IOptionalContentConfigurationPtr()) = 0;
 
        /*
         *
         * Manipulation and Interrogation
         *
         */

        virtual bool groupIsPresent(const IOptionalContentGroupReferencePtr &groupRef) const = 0;

        virtual IOptionalContentGroupPtr getGroup(const IOptionalContentGroupReferencePtr &groupRef) const = 0;

        virtual void forceGroupState(const IOptionalContentGroupPtr &group, bool visible) = 0;

        virtual COptionalContentGroupVect getGroups() const = 0;

        virtual void addGroup(const IOptionalContentGroupPtr &group) = 0;

        virtual void addGroup(const IOptionalContentGroupPtr &group, const IDocumentPtr &sourceDocument) = 0;

        virtual void removeGroup(const IOptionalContentGroupPtr &group) = 0;

        virtual void setDefaultConfiguration(const IOptionalContentConfigurationPtr &configuration) = 0;

        virtual IOptionalContentConfigurationPtr getDefaultConfiguration() const = 0;

        virtual void addConfiguration(const IOptionalContentConfigurationPtr &configuration) = 0;

        virtual void removeConfiguration(const IOptionalContentConfigurationPtr &configuration) = 0;

        virtual COptionalContentConfigurationVect getConfigurations() const = 0;
    };
 

    class IOptionalContentDetails : public IRCObject, public IHashable
    {
      public:
        virtual ~IOptionalContentDetails() {}

        typedef enum
        {
            eVPAllOn,  
            eVPAnyOn,  
            eVPAnyOff, 
            eVPAllOff  
        } eVisibilityPolicy;

        static JAWSMAKO_API IOptionalContentDetailsPtr create(const IJawsMakoPtr jawsMako,
                                                              const IOptionalContentGroupReferencePtr &groupRef = IOptionalContentGroupReferencePtr(),
                                                              const IOptionalContentPtr &optionalContent = IOptionalContentPtr());

        static JAWSMAKO_API IOptionalContentDetailsPtr create(const IJawsMakoPtr jawsMako,
                                                              const COptionalContentGroupReferenceVect &groups,
                                                              eVisibilityPolicy policy,
                                                              const IOptionalContentVisibilityExpressionPtr &visibilityExpression = IOptionalContentVisibilityExpressionPtr(),
                                                              const IOptionalContentPtr &optionalContent = IOptionalContentPtr());

        virtual IOptionalContentDetailsPtr clone() const = 0;

        virtual bool getIsVisible(eOptionalContentEvent event = eOCEView,
                                  const IOptionalContentPtr &optionalContent = IOptionalContentPtr()) const = 0;

        virtual void addGroup(const IOptionalContentGroupReferencePtr &groupRef) = 0;

        virtual void removeGroup(const IOptionalContentGroupReferencePtr &groupRef) = 0;

        virtual COptionalContentGroupReferenceVect getGroupReferences() const = 0;

        virtual void setVisibilityPolicy(eVisibilityPolicy policy) = 0;

        virtual eVisibilityPolicy getVisibilityPolicy() const = 0;

        virtual void setVisibilityExpression(const IOptionalContentVisibilityExpressionPtr &expression) = 0;

        virtual IOptionalContentVisibilityExpressionPtr getVisibilityExpression() = 0;
 
    };

    class IOptionalContentGroupReference : public IRCObject, public IHashable
    {
      public:
        virtual ~IOptionalContentGroupReference() {}

        virtual bool equals(const IOptionalContentGroupReferencePtr &reference) const = 0;
    };

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

        static JAWSMAKO_API IOptionalContentGroupPtr create(const IJawsMakoPtr &jawsMako, const U8String &name);

        virtual IOptionalContentGroupPtr clone() = 0;

        virtual IOptionalContentGroupReferencePtr getReference() const = 0;

        virtual void setName(const U8String &name) = 0;

        virtual U8String getName() const = 0;

        virtual void setIntent(const U8String &intent) = 0;

        virtual void setIntents(const CU8StringVect &intents) = 0;

        virtual CU8StringVect getIntents() const = 0;

        virtual void setUsage(const IOptionalContentGroupUsagePtr &usage) = 0;

        virtual IOptionalContentGroupUsagePtr getUsage() const = 0;

        virtual U8String getGTSProcStepsType () const = 0;

        virtual void setGTSProcStepsType (const U8String &procStepsType) = 0;

        virtual U8String getGTSProcStepsGroup () const = 0;

        virtual void setGTSProcStepsGroup (const U8String &procStepsGroup) = 0;
    };
 
 
    /*
     *
     *
     *   Advanced API
     *
     *
     */
 

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

        static JAWSMAKO_API IOptionalContentGroupUsagePtr create(const IJawsMakoPtr &jawsMako);

        virtual IOptionalContentGroupUsagePtr clone() const = 0;

        virtual void setLanguage(const U8String &language, bool preferred = false) = 0;

        virtual U8String getLanguage() const = 0;

        virtual bool getLanguageIsPreferred() const = 0;

        virtual void setExportVisibility(eOptionalContentVisibility visibility) = 0;

        virtual eOptionalContentVisibility getExportVisibility() const = 0;

        virtual void setZoomVisibility(float minimumZoom, float maximumZoom) = 0;
 
#ifdef SWIG
        %apply float & OUTPUT { float &minimumZoom };
        %apply float & OUTPUT { float &maximumZoom };
#endif
        virtual void getZoomVisibility(float &minimumZoom, float &maximumZoom) const = 0;
#ifdef SWIG
        %clear float &minimumZoom;
        %clear float &maximumZoom;
#endif

        virtual void setPrintVisibility(eOptionalContentVisibility visibility, const U8String &description = U8String()) = 0;

        virtual eOptionalContentVisibility getPrintVisibility() const = 0;

        virtual U8String getPrintVisibilityDescription() const = 0;

        virtual void setViewVisibility(eOptionalContentVisibility visibility) = 0;

        virtual eOptionalContentVisibility getViewVisibility() const = 0;

        virtual void setUsers(const U8String &type, const CU8StringVect &users) = 0;

        virtual CU8StringVect getUsers(U8String &type) const = 0;

        virtual void setPageElement(const U8String &type) = 0;

        virtual U8String getPageElement() const = 0;

        virtual eOptionalContentVisibility recommendedVisibilityForCategories(const COCCategoryVect &categories) const = 0;
    };
 

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

        static JAWSMAKO_API IOptionalContentGroupUsageApplicationPtr create(const IJawsMakoPtr &jawsMako,
                                                                            eOptionalContentEvent event = eOCEView);

        virtual IOptionalContentGroupUsageApplicationPtr clone() const = 0;

        virtual void setEvent(eOptionalContentEvent event) = 0;

        virtual eOptionalContentEvent getEvent() const = 0;

        virtual void setAffectedOptionalContentGroups(const COptionalContentGroupReferenceVect &groups) = 0;

        virtual COptionalContentGroupReferenceVect getAffectedOptionalContentGroups() const = 0;

        virtual void addGroup(const IOptionalContentGroupReferencePtr &groupRef) = 0;

        virtual bool groupIsAffected(const IOptionalContentGroupReferencePtr &groupRef) const = 0;

        virtual void setCategories(const COCCategoryVect &categories) = 0;

        virtual COCCategoryVect getCategories() const = 0;

        virtual bool categoryInCategories(eOptionalContentCategory category) const = 0;

        virtual bool categoriesInCategories(const COCCategoryVect &categories) const = 0;
    };

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

        static JAWSMAKO_API IOptionalContentConfigurationPtr create(const IJawsMakoPtr &jawsMako);

        virtual IOptionalContentConfigurationPtr clone() const = 0;

        virtual void setName(const U8String &name) = 0;

        virtual U8String getName() const = 0;

        virtual void setCreator(const U8String &creator) = 0;

        virtual U8String getCreator() const = 0;

        virtual void setBaseState(eOptionalContentVisibility visibility) = 0;

        virtual eOptionalContentVisibility getBaseState() const = 0;

        virtual void setDefaultVisibleGroups(const COptionalContentGroupReferenceVect &groups) = 0;

        virtual COptionalContentGroupReferenceVect getDefaultVisibleGroups() const = 0;

        virtual bool groupInVisibleGroups(const IOptionalContentGroupReferencePtr &groupRef) const = 0;

        virtual void setDefaultInvisibleGroups(const COptionalContentGroupReferenceVect &groups) = 0;

        virtual COptionalContentGroupReferenceVect getDefaultInvisibleGroups() const = 0;

        virtual bool groupInInvisibleGroups(const IOptionalContentGroupReferencePtr &groupRef) const = 0;

        virtual void setIntent(const U8String &intent) = 0;

        virtual void setIntents(const CU8StringVect &intents) = 0;

        virtual CU8StringVect getIntents() const = 0;

        virtual bool intentInIntents(const U8String &intent) const = 0;

        virtual void setAutoStates(const COptionalContentGroupUsageApplicationVect &applications) = 0;

        virtual COptionalContentGroupUsageApplicationVect getAutoStates() const = 0;
 
        class COrderEntry;
        DECL_SMART_PTR(COrderEntry)
        typedef CEDLVector<COrderEntryPtr> COrderEntryVect;

        class JAWSMAKO_API COrderEntry : public IRCObject
        {
          public:
            static COrderEntryPtr create();

            COrderEntryPtr clone();

            bool                              isGroup;
 
            IOptionalContentGroupReferencePtr groupRef; 
 
            U8String                          name;     
            COrderEntryVect                   children; 
        };

        virtual void setOrder(const COrderEntryVect &order) = 0;

        virtual COrderEntryVect getOrder() const = 0;

        typedef enum eListMode
        {
            eLMAllPages,      
            eLMVisiblePages   
        } eListMode;

        virtual void setListMode(eListMode listMode) = 0;

        virtual eListMode getListMode() const = 0;

        virtual void setRadioButtonGroups(const CEDLVector<COptionalContentGroupReferenceVect> &rbGroups) = 0;

        virtual CEDLVector<COptionalContentGroupReferenceVect> getRadioButtonGroups() const = 0;

        virtual void setLockedGroups(const COptionalContentGroupReferenceVect &lockedGroups) = 0;

        virtual COptionalContentGroupReferenceVect getLockedGroups() const = 0;
    };

    class IOptionalContentVisibilityExpression : public IRCObject, public IHashable
    {
      public:
          virtual ~IOptionalContentVisibilityExpression() {}

        virtual IOptionalContentVisibilityExpressionPtr clone() = 0;

        typedef enum eVisibilityExpressionOperation
        {
            eVEOGroupState, 
            eVEONot,        
            eVEOAnd,        
            eVEOOr,         
        } eVisibilityExpressionOperation;

        static JAWSMAKO_API IOptionalContentVisibilityExpressionPtr createGroupState(const IOptionalContentGroupReferencePtr &groupRef);

        static JAWSMAKO_API IOptionalContentVisibilityExpressionPtr createNot(const IOptionalContentVisibilityExpressionPtr &subExpression);

        static JAWSMAKO_API IOptionalContentVisibilityExpressionPtr createAnd(const COptionalContentVisibilityExpressionVect &subExpressions);

        static JAWSMAKO_API IOptionalContentVisibilityExpressionPtr createOr(const COptionalContentVisibilityExpressionVect &subExpressions);

        virtual eVisibilityExpressionOperation getOperation() const = 0;

        virtual IOptionalContentGroupReferencePtr getGroup() const = 0;

        virtual COptionalContentVisibilityExpressionVect getSubExpressions() const = 0;

        virtual eOptionalContentVisibility evaluate(const IOptionalContentPtr &optionalContent, eOptionalContentEvent event) const = 0;
    };
 
}
 
#endif /* JAWSMAKO_OPTIONALCONTENT_H */