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"
// 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 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