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 utils {
enum class PseudoTieMode;
} // namespace utils
 
namespace dom {
 
class EntryInfoPtr;
 
namespace details {
class SmartShapeEntryAssign;
}
 
namespace others {
    class SmartShapeMeasureAssign;
}
 
enum class KnownSmartShapeType
{
    Unrecognized,               
    VerticalLineRightHooks,     
 
    // Add more known types here
};
 
namespace smartshape {
 
enum class DirectionType
{
    None,   
    Under,  
    Over    
};
 
enum class EntryConnectionType
{
    HeadLeftTop,             
    HeadRightTop,            
    HeadRightBottom,         
    HeadLeftBottom,          
 
    StemLeftTop,             
    StemRightTop,            
    StemRightBottom,         
    StemLeftBottom,          
 
    NoteLeftTop,             
    NoteRightTop,            
    NoteRightBottom,         
    NoteLeftBottom,          
    NoteLeftCenter,          
    NoteRightCenter,         
 
    LyricRightCenter,        
    LyricLeftCenter,         
    LyricRightBottom,        
    HeadRightLyricBaseline,  
    DotRightLyricBaseline,   
    DurationLyricBaseline,   
 
    SystemLeft,              
    SystemRight              
};
 
class ControlPointAdjustment : public ContainedClassBase
{
public:
    using ContainedClassBase::ContainedClassBase;
 
    Evpu startCtlPtX{};             
    Evpu startCtlPtY{};             
    Evpu endCtlPtX{};               
    Evpu endCtlPtY{};               
    bool active{};                  
    DirectionType contextDir{};     
 
    static const xml::XmlElementArray<ControlPointAdjustment>& xmlMappingArray();  
};
 
class EndPoint : public ContainedClassBase
{
public:
    using ContainedClassBase::ContainedClassBase;
 
    StaffCmper staffId{};           
    MeasCmper measId{};             
    Edu eduPosition{};              
    EntryNumber entryNumber{};      
 
    [[nodiscard]] util::Fraction calcPosition() const;
 
    [[nodiscard]] util::Fraction calcGlobalPosition() const;
 
    [[nodiscard]] int compareMetricPosition(const EndPoint& other) const;
 
    [[nodiscard]] EntryInfoPtr calcAssociatedEntry(bool findExact = false) const;
 
    [[nodiscard]] MusxInstance<others::SmartShapeMeasureAssign> getMeasureAssignment() const;
 
    [[nodiscard]] MusxInstance<details::SmartShapeEntryAssign> getEntryAssignment() const;
 
    [[nodiscard]] bool calcIsAssigned() const;
 
    [[nodiscard]] MusxInstance<others::StaffComposite> createCurrentStaff() const;
 
    static const xml::XmlElementArray<EndPoint>& xmlMappingArray(); 
};
 
class EndPointAdjustment : public ContainedClassBase
{
public:
    using ContainedClassBase::ContainedClassBase;
 
    Evpu horzOffset{};                      
    Evpu vertOffset{};                      
    bool active{};                          
    DirectionType contextDir{};             
    EntryConnectionType contextEntCnct{};   
 
    [[nodiscard]] Evpu calcHorzOffset() const
    { return active ? horzOffset : 0; }
 
    [[nodiscard]] Evpu calcVertOffset() const
    { return active ? vertOffset : 0; }
 
    [[nodiscard]] bool calcHasVerticalEquivalentConnection(const EndPointAdjustment& other) const;
 
    static const xml::XmlElementArray<EndPointAdjustment>& xmlMappingArray();    
};
 
} // namespace smartshape
 
namespace others {
 
class SmartShape : public OthersBase
{
private:
public:
    explicit SmartShape(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    class TerminationSeg : public ContainedClassBase
    {
    public:
        using ContainedClassBase::ContainedClassBase;
 
        std::shared_ptr<smartshape::EndPoint> endPoint;                 
        std::shared_ptr<smartshape::EndPointAdjustment> endPointAdj;    
        std::shared_ptr<smartshape::ControlPointAdjustment> ctlPtAdj;   
        std::shared_ptr<smartshape::EndPointAdjustment> breakAdj;       
 
        void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
        {
            ContainedClassBase::integrityCheck(ptrToThis);
            if (!endPoint) {
                endPoint = std::make_shared<smartshape::EndPoint>(getParent());
            }
            if (!endPointAdj) {
                endPointAdj = std::make_shared<smartshape::EndPointAdjustment>(getParent());
            }
            if (!ctlPtAdj) {
                ctlPtAdj = std::make_shared<smartshape::ControlPointAdjustment>(getParent());
            }
            if (!breakAdj) {
                breakAdj = std::make_shared<smartshape::EndPointAdjustment>(getParent());
            }
            endPoint->integrityCheck(endPoint);
            endPointAdj->integrityCheck(endPointAdj);
            ctlPtAdj->integrityCheck(ctlPtAdj);
            breakAdj->integrityCheck(breakAdj);
        }
 
        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,  
        DashContourSlurAuto, 
    };
 
    enum class EngraverSlurState
    {
        Auto,           
        Off,            
        On,             
    };
 
    enum class SlurAvoidAccidentalsState
    {
        Auto,           
        Off,            
        On,             
        Invalid = -1    
    };
 
    enum class SystemBreakType
    {
        Same,           
        Opposite,       
    };
 
    ShapeType shapeType{};                          
    bool entryBased{};                              
    bool rotate{};                                  
    bool noPresetShape{};                           
    bool makeHorz{};                                
    bool noPushEndStart{};                          
    bool makeVert{};                                
    EngraverSlurState engraverSlurState{};          
    SlurAvoidAccidentalsState slurAvoidAcciState{}; 
    SystemBreakType yBreakType{};                   
    std::shared_ptr<TerminationSeg> startTermSeg;   
    std::shared_ptr<TerminationSeg> endTermSeg;     
    std::shared_ptr<smartshape::ControlPointAdjustment> fullCtlPtAdj; 
    bool hidden{};                                  
    NoteNumber startNoteId{};                       
    NoteNumber endNoteId{};                         
    Cmper lineStyleId{};                            
    Cmper startLyricNum{};                          
    Cmper endLyricNum{};                            
    std::optional<LyricTextType> startLyricType;    
    std::optional<LyricTextType> endLyricType;      
 
    [[nodiscard]]
    bool calcIsSlur() const;
 
    [[nodiscard]]
    bool calcAppliesTo(const EntryInfoPtr& entryInfo) const;
 
    [[nodiscard]]
    MusicRange createMusicRange() const;
 
    [[nodiscard]]
    MusicRange createGlobalMusicRange() const;
 
    [[nodiscard]] NoteInfoPtr calcArpeggiatedTieToNote(const EntryInfoPtr& forStartEntry) const;
 
    [[nodiscard]]
    CurveContourDirection calcContourDirection() const;
 
    [[nodiscard]] VerticalPlacement calcVerticalPlacementForBeatAttached() const;
    
    [[nodiscard]]
    bool calcIsDashed() const;
 
    [[nodiscard]]
    bool calcIsPseudoTie(utils::PseudoTieMode mode, const EntryInfoPtr& forStartEntry) const;
 
    bool iterateEntries(std::function<bool(const EntryInfoPtr&)> iterator, DeferredReference<MusxInstanceList<StaffUsed>> staffList = {}) const;
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        OthersBase::integrityCheck(ptrToThis);
        if (!startTermSeg) {
            startTermSeg = std::make_shared<TerminationSeg>(ptrToThis);
        }
        if (!endTermSeg) {
            endTermSeg = std::make_shared<TerminationSeg>(ptrToThis);
        }
        if (!fullCtlPtAdj) {
            fullCtlPtAdj = std::make_shared<smartshape::ControlPointAdjustment>(ptrToThis);
        }
        startTermSeg->integrityCheck(ptrToThis);
        endTermSeg->integrityCheck(ptrToThis);
        fullCtlPtAdj->integrityCheck(ptrToThis);
    }
 
    constexpr static std::string_view XmlNodeName = "smartShape"; 
    static const xml::XmlElementArray<SmartShape>& xmlMappingArray(); 
};
 
class SmartShapeCustomLine : public OthersBase
{
    util::EnigmaParsingContext getRawTextCtx(Cmper forPartId, Cmper textBlockId) const;
 
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 ContainedClassBase
    {
    public:
        explicit CharParams(const MusxInstance<EnigmaBase>& parent)
            : ContainedClassBase(parent), font(std::make_shared<FontInfo>(parent->getDocument()))
        {
        }
 
        char32_t lineChar{};            
        std::shared_ptr<FontInfo> font; 
        int baselineShiftEms{};         
 
        static const xml::XmlElementArray<CharParams>& xmlMappingArray(); 
    };
 
    class SolidParams : public ContainedClassBase
    {
    public:
        using ContainedClassBase::ContainedClassBase;
 
        Efix lineWidth{};             
 
        static const xml::XmlElementArray<SolidParams>& xmlMappingArray(); 
    };
 
    class DashedParams : public ContainedClassBase {
    public:
        using ContainedClassBase::ContainedClassBase;
 
        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{};                          
 
    [[nodiscard]] 
    util::EnigmaParsingContext getLeftStartRawTextCtx(Cmper forPartId) const
    { return getRawTextCtx(forPartId, leftStartRawTextId); }
 
    [[nodiscard]] 
    util::EnigmaParsingContext getLeftContRawTextCtx(Cmper forPartId) const
    { return getRawTextCtx(forPartId, leftContRawTextId); }
 
    [[nodiscard]] 
    util::EnigmaParsingContext getRightEndRawTextCtx(Cmper forPartId) const
    { return getRawTextCtx(forPartId, rightEndRawTextId); }
 
    [[nodiscard]] 
    util::EnigmaParsingContext getCenterFullRawTextCtx(Cmper forPartId) const
    { return getRawTextCtx(forPartId, centerFullRawTextId); }
 
    [[nodiscard]] 
    util::EnigmaParsingContext getCenterAbbrRawTextCtx(Cmper forPartId) const
    { return getRawTextCtx(forPartId, centerAbbrRawTextId); }
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        OthersBase::integrityCheck(ptrToThis);
 
        if (lineStyle == LineStyle::Char && !charParams)
            charParams = std::make_shared<CharParams>(ptrToThis);
 
        if (lineStyle == LineStyle::Solid && !solidParams)
            solidParams = std::make_shared<SolidParams>(ptrToThis);
 
        if (lineStyle == LineStyle::Dashed && !dashedParams)
            dashedParams = std::make_shared<DashedParams>(ptrToThis);
    }
 
    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<smartshape::EndPointAdjustment> startBreakAdj; 
    std::shared_ptr<smartshape::EndPointAdjustment> endBreakAdj;   
    std::shared_ptr<smartshape::ControlPointAdjustment> ctlPtAdj;  
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        if (!startBreakAdj) {
            startBreakAdj = std::make_shared<smartshape::EndPointAdjustment>(ptrToThis);
        }
        if (!endBreakAdj) {
            endBreakAdj = std::make_shared<smartshape::EndPointAdjustment>(ptrToThis);
        }
        if (!ctlPtAdj) {
            ctlPtAdj = std::make_shared<smartshape::ControlPointAdjustment>(ptrToThis);
        }
    }
 
    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