SmartShape.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 {
 
class EntryInfoPtr;
 
namespace others {
 
class SmartShape : public OthersBase
{
public:
    explicit SmartShape(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    class EndPoint : public Base
    {
    public:
        explicit EndPoint(const DocumentWeakPtr& document)
            : Base(document, SCORE_PARTID, ShareMode::All) {}
 
        InstCmper staffId{};            
        MeasCmper measId{};             
        Edu eduPosition{};              
        EntryNumber entryNumber{};      
 
        Edu calcEduPosition() const;
 
        EntryInfoPtr calcAssociatedEntry() const;
 
        bool requireAllFields() const override { return false; }
        static const xml::XmlElementArray<EndPoint>& xmlMappingArray(); 
    };
 
    class EndPointAdjustment : public Base
    {
    public:
        explicit EndPointAdjustment(const DocumentWeakPtr& document)
            : Base(document, SCORE_PARTID, ShareMode::All) {}
 
        Evpu horzOffset{};          
        Evpu vertOffset{};          
        bool active{};              
 
        bool requireAllFields() const override { return false; }    
        static const xml::XmlElementArray<EndPointAdjustment>& xmlMappingArray();    
    };
 
    class TerminationSeg : public Base
    {
    public:
        explicit TerminationSeg(const DocumentWeakPtr& document)
            : Base(document, SCORE_PARTID, ShareMode::All) {}
 
        std::shared_ptr<EndPoint> endPoint;                 
        std::shared_ptr<EndPointAdjustment> endPointAdj;    
        std::shared_ptr<EndPointAdjustment> breakAdj;       
 
        void integrityCheck() override
        {
            Base::integrityCheck();
            if (!endPoint) {
                endPoint = std::make_shared<EndPoint>(getDocument());
            }
            if (!endPointAdj) {
                endPointAdj = std::make_shared<EndPointAdjustment>(getDocument());
            }
            if (!breakAdj) {
                breakAdj = std::make_shared<EndPointAdjustment>(getDocument());
            }
        }
    
        bool requireAllFields() const override { return false; }    
        static const xml::XmlElementArray<TerminationSeg>& xmlMappingArray();    
    };
 
    enum class ShapeType : int
    {
        SlurDown = 0,       
        SlurUp,             
        Decrescendo,        
        Crescendo,          
        OctaveDown,         
        OctaveUp,           
        DashLineUp,         
        DashLineDown,       
        DashSlurDown,       
        DashSlurUp,         
        DashLine,           
        SolidLine,          
        SolidLineDown,      
        SolidLineUp,        
        Trill,              
        SlurAuto,           
        DashSlurAuto,       
        TrillExtension,     
        SolidLineDownBoth,  
        SolidLineUpBoth,    
        TwoOctaveDown,      
        TwoOctaveUp,        
        DashLineDownBoth,   
        DashLineUpBoth,     
        Glissando = 25,     
        TabSlide,           
        BendHat,            
        BendCurve,          
        CustomLine,         
        SolidLineUpLeft,    
        SolidLineDownLeft,  
        DashLineUpLeft,     
        DashLineDownLeft,   
        SolidLineUpDown,    
        SolidLineDownUp,    
        DashLineUpDown,     
        DashLineDownUp,     
        Hyphen,             
        WordExtension,      
        DashContourSlurDown, 
        DashContourSlurUp,  
        DashContouSlurAuto, 
    };
 
    ShapeType shapeType{};                          
    bool entryBased{};                              
    std::shared_ptr<TerminationSeg> startTermSeg;   
    std::shared_ptr<TerminationSeg> endTermSeg;     
    bool hidden{};                                  
    NoteNumber startNoteId{};                       
    NoteNumber endNoteId{};                         
    Cmper lineStyleId{};                            
 
    bool calcAppliesTo(const EntryInfoPtr& entryInfo) const;
 
    void integrityCheck() override
    {
        OthersBase::integrityCheck();
        if (!startTermSeg) {
            startTermSeg = std::make_shared<TerminationSeg>(getDocument());
        }
        if (!endTermSeg) {
            endTermSeg = std::make_shared<TerminationSeg>(getDocument());
        }
        startTermSeg->integrityCheck();
        endTermSeg->integrityCheck();
    }
 
    bool requireAllFields() const override { return false; }    
    constexpr static std::string_view XmlNodeName = "smartShape"; 
    static const xml::XmlElementArray<SmartShape>& xmlMappingArray(); 
};
 
class SmartShapeCustomLine : public OthersBase
{
public:
    explicit SmartShapeCustomLine(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    enum class LineStyle { Char, Solid, Dashed };
 
    enum class LineCapType { None, Hook, ArrowheadPreset, ArrowheadCustom };
 
    class CharParams : public Base
    {
    public:
        explicit CharParams(const DocumentWeakPtr& document)
            : Base(document, SCORE_PARTID, ShareMode::All), font(std::make_shared<FontInfo>(document))
        {
        }
 
        char32_t lineChar{};            
        std::shared_ptr<FontInfo> font; 
        int baselineShiftEms{};         
 
        static const xml::XmlElementArray<CharParams>& xmlMappingArray(); 
    };
 
    class SolidParams : public Base
    {
    public:
        explicit SolidParams(const DocumentWeakPtr& document)
            : Base(document, SCORE_PARTID, ShareMode::All)
        {
        }
 
        Efix lineWidth{};             
 
        static const xml::XmlElementArray<SolidParams>& xmlMappingArray(); 
    };
 
    class DashedParams : public Base {
    public:
        explicit DashedParams(const DocumentWeakPtr& document)
            : Base(document, SCORE_PARTID, ShareMode::All) {}
 
        Efix lineWidth{};             
        Efix dashOn{};                
        Efix dashOff{};               
 
        static const xml::XmlElementArray<DashedParams>& xmlMappingArray(); 
    };
 
    LineStyle lineStyle{};                                
    std::shared_ptr<CharParams> charParams;               
    std::shared_ptr<SolidParams> solidParams;             
    std::shared_ptr<DashedParams> dashedParams;           
 
    LineCapType lineCapStartType{};                       
    LineCapType lineCapEndType{};                         
    Cmper lineCapStartArrowId{};                          
    Cmper lineCapEndArrowId{};                            
 
    bool makeHorz{};                                      
    bool lineAfterLeftStartText{};                        
    bool lineBeforeRightEndText{};                        
    bool lineAfterLeftContText{};                         
 
    Cmper leftStartRawTextId{};                           
    Cmper leftContRawTextId{};                            
    Cmper rightEndRawTextId{};                            
    Cmper centerFullRawTextId{};                          
    Cmper centerAbbrRawTextId{};                          
 
    Evpu leftStartX{};                                    
    Evpu leftStartY{};                                    
    Evpu leftContX{};                                     
    Evpu leftContY{};                                     
    Evpu rightEndX{};                                     
    Evpu rightEndY{};                                     
    Evpu centerFullX{};                                   
    Evpu centerFullY{};                                   
    Evpu centerAbbrX{};                                   
    Evpu centerAbbrY{};                                   
 
    Evpu lineStartX{};                                    
    Evpu lineStartY{};                                    
    Evpu lineEndX{};                                      
    Evpu lineEndY{};                                      
    Evpu lineContX{};                                     
 
    Efix lineCapStartHookLength{};                        
    Efix lineCapEndHookLength{};                          
 
    void integrityCheck() override
    {
        OthersBase::integrityCheck();
 
        if (lineStyle == LineStyle::Char && !charParams)
            charParams = std::make_shared<CharParams>(getDocument());
 
        if (lineStyle == LineStyle::Solid && !solidParams)
            solidParams = std::make_shared<SolidParams>(getDocument());
 
        if (lineStyle == LineStyle::Dashed && !dashedParams)
            dashedParams = std::make_shared<DashedParams>(getDocument());
    }
 
    constexpr static std::string_view XmlNodeName = "ssLineStyle"; 
    static const xml::XmlElementArray<SmartShapeCustomLine>& xmlMappingArray(); 
};
 
class SmartShapeMeasureAssign : public OthersBase
{
public:
    explicit SmartShapeMeasureAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    Cmper shapeNum{};       
    Cmper centerShapeNum{}; 
 
    constexpr static std::string_view XmlNodeName = "smartShapeMeasMark"; 
    static const xml::XmlElementArray<SmartShapeMeasureAssign>& xmlMappingArray(); 
};
 
} // namespace others
 
namespace details {
 
class CenterShape : public DetailsBase
{
public:
 
    explicit CenterShape(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper shapeNum, Cmper centerShapeNum)
        : DetailsBase(document, partId, shareMode, shapeNum, centerShapeNum)
    {}
 
    std::shared_ptr<others::SmartShape::EndPointAdjustment> startBreakAdj; 
    std::shared_ptr<others::SmartShape::EndPointAdjustment> endBreakAdj;   
 
    void integrityCheck() override
    {
        if (!startBreakAdj) {
            startBreakAdj = std::make_shared<others::SmartShape::EndPointAdjustment>(getDocument());
        }
        if (!endBreakAdj) {
            endBreakAdj = std::make_shared<others::SmartShape::EndPointAdjustment>(getDocument());
        }
    }
 
    bool requireAllFields() const override { return false; }    
    constexpr static std::string_view XmlNodeName = "centerShape"; 
    static const xml::XmlElementArray<CenterShape>& xmlMappingArray(); 
};
 
class SmartShapeEntryAssign : public EntryDetailsBase
{
public:
    explicit SmartShapeEntryAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, EntryNumber entnum, Inci inci)
        : EntryDetailsBase(document, partId, shareMode, entnum, inci)
    {
    }
 
    Cmper shapeNum{};       
 
    constexpr static std::string_view XmlNodeName = "smartShapeEntryMark"; 
    static const xml::XmlElementArray<SmartShapeEntryAssign>& xmlMappingArray(); 
};
 
} // namespace details
 
} // namespace dom
} // namespace musx