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"
 
 // do not add other dom class dependencies. Use Implementations.cpp for implementations that need total class access.
 
namespace musx {
namespace dom {
 
enum class KnownShapeDefType
{
    Blank,                      
    TenutoMark,                 
 
    // Add more known types here
};
 
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(); 
};
 
class ShapeInstructionList;
class ShapeDef : public OthersBase
{
public:
    explicit ShapeDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    enum class InstructionType
    {
        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,
    };
 
    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; }
 
    void iterateInstructions(std::function<bool(InstructionType, std::vector<int>)> callback) const;
 
 
    std::optional<KnownShapeDefType> recognize() const;
 
    constexpr static std::string_view XmlNodeName = "shapeDef"; 
    static const xml::XmlElementArray<ShapeDef>& xmlMappingArray(); 
};
    
struct ShapeInstruction
{
    struct LineWidth {
        Efix efix;  
    };
 
    struct RLineTo {
        Evpu dx;  
        Evpu dy;  
    };
 
    // add more data structs as needed...
 
    static std::optional<LineWidth> parseLineWidth(ShapeDef::InstructionType type, const std::vector<int>& data);
 
    static std::optional<RLineTo> parseRLineTo(ShapeDef::InstructionType type, const std::vector<int>& data);
 
    static std::optional<FontInfo> parseSetFont(const DocumentWeakPtr& document, ShapeDef::InstructionType type, const std::vector<int>& data);
 
    // Add more parsers as needed...
};
 
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{};                      
        ShapeDef::InstructionType 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