Graphics.h

/*
 * Copyright (C) 2025, Robert Patterson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include "BaseClasses.h"
#include "CommonClasses.h"
#include "Others.h"
 // do not add other dom class dependencies. Use .cpp files for implementations that need total class access.
 
namespace musx {
namespace dom {
 
namespace others {
 
class FileAlias : public OthersBase
{
public:
    explicit FileAlias(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    size_t length{};                            
    std::vector<std::uint8_t> aliasHandle{};    
 
    void integrityCheck(const std::shared_ptr<Base>& ptrToThis) override
    {
        OthersBase::integrityCheck(ptrToThis);
        if (length != aliasHandle.size()) {
            MUSX_INTEGRITY_ERROR("Stated length does not match actual size of FileAlias " + std::to_string(getCmper()) + ".");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "fileAlias"; 
    static const xml::XmlElementArray<FileAlias>& xmlMappingArray(); 
};
 
class FileDescription : public OthersBase
{
public:
    explicit FileDescription(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    enum class PathType
    {
        DosPath,                
        MacFsSpec,              
        MacAlias,               
        MacPosixPath,           
        MacUrlBookmark          
    };
 
    uint32_t version{};         
    int volRefNum{};            
    int dirId{};                
    PathType pathType;          
    Cmper pathId{};             
 
    constexpr static std::string_view XmlNodeName = "fileDesc"; 
    static const xml::XmlElementArray<FileDescription>& xmlMappingArray(); 
};
 
class FilePath : public OthersBase
{
public:
    explicit FilePath(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    std::string path;   
 
    constexpr static std::string_view XmlNodeName = "filePath"; 
    static const xml::XmlElementArray<FilePath>& xmlMappingArray(); 
};
 
class FileUrlBookmark : public OthersBase
{
public:
    explicit FileUrlBookmark(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    size_t length{};                                
    std::vector<std::uint8_t> urlBookmarkData{};    
 
    void integrityCheck(const std::shared_ptr<Base>& ptrToThis) override
    {
        OthersBase::integrityCheck(ptrToThis);
        if (length != urlBookmarkData.size()) {
            MUSX_INTEGRITY_ERROR("Stated length does not match actual size of FileUrlBookmark " + std::to_string(getCmper()) + ".");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "fileURLBookmark"; 
    static const xml::XmlElementArray<FileUrlBookmark>& xmlMappingArray(); 
};
 
class PageGraphicAssign : public OthersBase
{
public:
 
    enum class PageAssignType
    {
        AllPages,
        Even,
        Odd,
        One
    };
 
    enum class PositionFrom
    {
        Margins,    
        PageEdge    
    };
 
    using HorizontalAlignment = options::TextOptions::HorizontalAlignment;  
    using VerticalAlignment = options::TextOptions::VerticalAlignment;      
 
    explicit PageGraphicAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    uint32_t version{};                 
    Evpu left{};                        
    Evpu bottom{};                      
    Evpu width{};                       
    Evpu height{};                      
    Cmper fDescId{};                    
    PageAssignType displayType{};       
    bool hidden{};                      
    HorizontalAlignment hAlign{};       
    VerticalAlignment vAlign{};         
    PositionFrom posFrom{};             
    bool fixedPerc{};                   
    PageCmper startPage{};              
    PageCmper endPage{};                
    bool savedRecord{};                 
    Evpu origWidth{};                   
    Evpu origHeight{};                  
    HorizontalAlignment rightPgHAlign{};
    VerticalAlignment rightPgVAlign{};  
    PositionFrom rightPgPosFrom{};      
    bool rightPgFixedPerc{};            
    Evpu rightPgLeft{};                 
    Evpu rightPgBottom{};               
    Cmper graphicCmper{};               
 
    std::optional<PageCmper> calcStartPageNumber(Cmper forPartId) const;
 
    std::optional<PageCmper> calcEndPageNumber(Cmper forPartId) const;
 
    bool isMultiPage() const
    { return getCmper() == 0 && startPage != endPage; }
 
    bool isMultiAssignedThruLastPage() const
    { return isMultiPage() && endPage == 0; }
 
    void integrityCheck(const std::shared_ptr<Base>& ptrToThis) override
    {
        this->OthersBase::integrityCheck(ptrToThis);
        if (getCmper() != 0) {
            if (startPage != getCmper() || endPage != getCmper()) {
                MUSX_INTEGRITY_ERROR("PageGraphicAssign " + std::to_string(getCmper()) + " inci " + std::to_string(getInci().value_or(0)) +
                    " has startPage or endPage value that does not match.");
            }
        }
    }
 
    static MusxInstance<others::PageGraphicAssign> getForPageId(const DocumentPtr& document, Cmper partId, PageCmper pageId, Inci inci);
 
    static MusxInstanceList<others::PageGraphicAssign> getArrayForPageId(const DocumentPtr& document, Cmper partId, PageCmper pageId);
 
    constexpr static std::string_view XmlNodeName = "pageGraphicAssign"; 
    static const xml::XmlElementArray<PageGraphicAssign>& xmlMappingArray(); 
};
 
class ShapeGraphicAssign : public OthersBase
{
public:
    explicit ShapeGraphicAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    using HorizontalAlignment = options::TextOptions::HorizontalAlignment;  
    using VerticalAlignment = options::TextOptions::VerticalAlignment;      
 
    uint32_t version{};     
    Evpu left{};            
    Evpu bottom{};          
    Evpu width{};           
    Evpu height{};          
    Cmper fDescId{};        
    HorizontalAlignment hAlign{};  
    VerticalAlignment vAlign{};    
    bool fixedPerc{};       
    bool hidden{};          
    bool savedRecord{};     
    Evpu origWidth{};       
    Evpu origHeight{};      
    Cmper graphicCmper{};   
 
    constexpr static std::string_view XmlNodeName = "shapeGraphicAssign"; 
    static const xml::XmlElementArray<ShapeGraphicAssign>& xmlMappingArray(); 
};
 
} //namespace others
 
namespace details {
 
class MeasureGraphicAssign : public DetailsBase
{
public:
    explicit MeasureGraphicAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper staffId, Cmper meas, Inci inci)
        : DetailsBase(document, partId, shareMode, staffId, meas, inci)
    {
    }
 
    uint32_t version{};     
    Evpu left{};            
    Evpu bottom{};          
    Evpu width{};           
    Evpu height{};          
    Cmper fDescId{};        
    bool hidden{};          
    bool savedRecord{};     
    Evpu origWidth{};       
    Evpu origHeight{};      
    Cmper graphicCmper{};   
 
    constexpr static std::string_view XmlNodeName = "measGraphicAssign"; 
    static const xml::XmlElementArray<MeasureGraphicAssign>& xmlMappingArray(); 
};
 
} //namespace details
 
} //namespace dom
} //namespace musx