ShapeDesigner.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 "musx/util/Logger.h"
#include "musx/util/Fraction.h"
 
#include "BaseClasses.h"
#include "CommonClasses.h"
#include "Details.h"
 
 // do not add other dom class dependencies. Use Implementations.cpp for implementations that need total class access.
 
namespace musx {
namespace dom {
 
enum class KnownShapeDefType
{
    Unrecognized,               
    Blank,                      
    TenutoMark,                 
    SlurTieCurveRight,          
    SlurTieCurveLeft,           
    PedalArrowheadDown,         
    PedalArrowheadUp,           
    PedalArrowheadShortUpDownLongUp, 
    PedalArrowheadLongUpDownShortUp, 
 
    // Add more known types here
};
 
enum class ShapeDefInstructionType
{
    Undocumented,
 
    Bracket,
 
    CloneChar,
 
    ClosePath,
 
    CurveTo,
 
    DrawChar,
 
    Ellipse,
 
    EndGroup,
 
    ExternalGraphic,
 
    FillAlt,
 
    FillSolid,
 
    GoToOrigin,
 
    GoToStart,
 
    LineWidth,
 
    Rectangle,
 
    RLineTo,
 
    RMoveTo,
 
    SetArrowhead,
 
    SetBlack,
 
    SetDash,
 
    SetFont,
 
    SetGray,
 
    SetWhite,
 
    Slur,
 
    StartGroup,
 
    StartObject,
 
    Stroke,
 
    VerticalMode,
};
 
struct ShapeDefInstruction
{
    struct Undocumented {
        std::vector<int> data; 
    };
 
    struct Bracket {
        details::Bracket::BracketStyle bracketStyle{}; 
    };
 
    struct CloneChar {
        Evpu dx{};            
        Evpu dy{};            
        int unused2{};        
        int  baselineShift{}; 
        char32_t codePoint{}; 
    };
 
    struct CurveTo {
        Evpu c1dx{}; 
        Evpu c1dy{}; 
        Evpu c2dx{}; 
        Evpu c2dy{}; 
        Evpu edx{};  
        Evpu edy{};  
    };
 
    struct DrawChar {
        char32_t codePoint{}; 
    };
 
    struct Ellipse {
        Evpu width{};  
        Evpu height{}; 
    };
 
    struct ExternalGraphic {
        Evpu width{};   
        Evpu height{};  
        Cmper cmper{};  
    };
 
    struct LineWidth {
        Efix efix{}; 
    };
 
    struct Rectangle {
        Evpu width{};  
        Evpu height{}; 
    };
 
    struct RLineTo {
        Evpu dx{}; 
        Evpu dy{}; 
    };
 
    struct RMoveTo {
        Evpu dx{}; 
        Evpu dy{}; 
    };
 
    struct SetArrowhead {
        int packedKindCodes{};  
        int startArrowId{};     
        int endArrowId{};       
        int extra{};            
 
        int startKindCode() const noexcept
        { return static_cast<int>(static_cast<unsigned int>(packedKindCodes) & 0xFFFFu); }
 
        int endKindCode() const noexcept
        { return static_cast<int>((static_cast<unsigned int>(packedKindCodes) >> 16) & 0xFFFFu); }
    };
 
    struct SetDash {
        Evpu dashLength{};  
        Evpu spaceLength{}; 
    };
 
    struct SetFont {
        SetFont(const DocumentWeakPtr& document) : font(document)
        {}
        FontInfo font;  
    };
 
    struct SetGray {
        int gray{}; 
    };
 
    struct Slur {
        Evpu16ths c1dx{}; 
        Evpu16ths c1dy{}; 
        Evpu16ths c2dx{}; 
        Evpu16ths c2dy{}; 
        Evpu16ths edx{};  
        Evpu16ths edy{};  
    };
 
    struct StartObject {
        Evpu originX{};  
        Evpu originY{};  
        Evpu left{};     
        Evpu top{};      
        Evpu right{};    
        Evpu bottom{};   
        int  scaleX{};   
        int  scaleY{};   
        int  rotation{}; 
        int  unused9{};  
        int  unused10{}; 
    };
 
    struct StartGroup {
        Evpu originX{};  
        Evpu originY{};  
        Evpu left{};     
        Evpu top{};      
        Evpu right{};    
        Evpu bottom{};   
        int  scaleX{};   
        int  scaleY{};   
        int  rotation{}; 
        int  unused9{};  
        int  unused10{}; 
    };
 
    enum class VerticalAlign {
        Center = 1, 
        Left   = 2, 
        Right  = 3  
    };
 
    struct VerticalMode {
        VerticalAlign mode; 
    };
 
 
    using InstructionData = std::variant<
        std::monostate,   // for commands with no data
        Undocumented,
        Bracket,
        CloneChar,
        CurveTo,
        DrawChar,
        Ellipse,
        ExternalGraphic,
        LineWidth,
        Rectangle,
        RLineTo,
        RMoveTo,
        SetArrowhead,
        SetDash,
        SetFont,
        SetGray,
        Slur,
        StartGroup,
        StartObject,
        VerticalMode
    >;
 
    struct Decoded
    {
        ShapeDefInstructionType type{};             
        InstructionData data{std::monostate{}};     
 
        bool valid() const noexcept { return m_valid; }
 
        template <typename T>
        void setPayload(std::optional<T>&& optData)
        {
            if (optData) {
                // Move the contained T into the variant
                data = std::move(*optData);
                m_valid = true;
            } else {
                // We *tried* to parse data and failed
                m_valid = false;
            }
        }
 
    private:
        bool m_valid{true};  
    };
 
    static std::optional<Undocumented> parseUndocumented(const std::vector<int>& data);
 
    static std::optional<Bracket> parseBracket(const std::vector<int>& data);
 
    static std::optional<CloneChar> parseCloneChar(const std::vector<int>& data);
 
    static std::optional<CurveTo> parseCurveTo(const std::vector<int>& data);
 
    static std::optional<DrawChar> parseDrawChar(const std::vector<int>& data);
 
    static std::optional<Ellipse> parseEllipse(const std::vector<int>& data);
 
    static std::optional<ExternalGraphic> parseExternalGraphic(const std::vector<int>& data);
 
    static std::optional<LineWidth> parseLineWidth(const std::vector<int>& data);
 
    static std::optional<Rectangle> parseRectangle(const std::vector<int>& data);
 
    static std::optional<RLineTo> parseRLineTo(const std::vector<int>& data);
 
    static std::optional<RMoveTo> parseRMoveTo(const std::vector<int>& data);
 
    static std::optional<SetArrowhead> parseSetArrowhead(const std::vector<int>& data);
 
    static std::optional<SetDash> parseSetDash(const std::vector<int>& data);
 
    static std::optional<SetFont> parseSetFont(const DocumentWeakPtr& document, const std::vector<int>& data);
 
    static std::optional<SetGray> parseSetGray(const std::vector<int>& data);
 
    static std::optional<Slur> parseSlur(const std::vector<int>& data);
 
    static std::optional<StartGroup> parseStartGroup(const std::vector<int>& data);
 
    static std::optional<StartObject> parseStartObject(const std::vector<int>& data);
 
    static std::optional<VerticalMode> parseVerticalMode(const std::vector<int>& data);
};
 
namespace others {
 
class ShapeData : public OthersArray<int>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "shapeData"; 
    static const xml::XmlElementArray<ShapeData>& xmlMappingArray(); 
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
class ShapeDefTestAccessor; // used by tests to access private iterator in ShapeDef
#endif
 
class ShapeInstructionList;
class ShapeDef : public OthersBase
{
private:
    bool iterateInstructions(std::function<bool(ShapeDefInstructionType, std::vector<int>)> callback) const;
 
    friend class ShapeDefTestAccessor; // gives tests access, but users don't see it
 
public:
    explicit ShapeDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    enum class ShapeType
    {
        Other = 0,          
        Articulation = 1,   
        Barline = 2,        
        Executable = 3,     
        Expression = 4,     
        CustomStem = 5,     
        Frame = 6,          
        Arrowhead = 7,      
        Fretboard = 8,      
        Clef = 9            
    };
 
    Cmper instructionList{};    
    Cmper dataList{};           
    ShapeType shapeType{};      
 
    bool isBlank() const
    { return instructionList == 0; }
 
    bool iterateInstructions(std::function<bool(const ShapeDefInstruction::Decoded&)> callback) const;
 
    KnownShapeDefType recognize() const;
 
    std::optional<Evpu> calcWidth() const;
 
    CurveContourDirection calcSlurContour() const;
 
    constexpr static std::string_view XmlNodeName = "shapeDef"; 
    static const xml::XmlElementArray<ShapeDef>& xmlMappingArray(); 
};
 
class ShapeInstructionList : public OthersBase
{
public:
    explicit ShapeInstructionList(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    class InstructionInfo
    {
    public:
 
        int numData{};                      
        ShapeDefInstructionType type{};     
 
        static const xml::XmlElementArray<InstructionInfo>& xmlMappingArray();    
    };
 
    std::vector<std::shared_ptr<InstructionInfo>> instructions; 
 
    constexpr static std::string_view XmlNodeName = "shapeList"; 
    static const xml::XmlElementArray<ShapeInstructionList>& xmlMappingArray(); 
};
 
} // namespace others
} // namespace dom
} // namespace musx