CommonClasses.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 <numeric>
#include <filesystem>
#include <array>
 
#include "musx/util/Fraction.h"
#include "BaseClasses.h"
 
namespace music_theory {
class Transposer;
enum class DiatonicMode : int;
} // namespace music_theory
 
namespace musx {
namespace dom {
 
class EntryInfoPtr;
 
namespace details { // forward declarations
class IndependentStaffDetails;
class LyricAssign;
} // namespace details
 
namespace others { // forward declarations
class Measure;
class OssiaHeader;
class Staff;
} // namespace others
 
// This file contains common classes that are shared among Options, Others, and Details.
 
enum class NoteType : Edu
{
    Maxima = 0x8000,
    Longa = 0x4000,
    Breve = 0x2000,
    Whole = EDU_PER_WHOLE_NOTE,
    Half = 0x0800,
    Quarter = 0x0400,
    Eighth = 0x0200,
    Note16th = 0x0100,
    Note32nd = 0x0080,
    Note64th = 0x0040,
    Note128th = 0x0020,
    Note256th = 0x0010,
    Note512th = 0x0008,
    Note1024th = 0x0004,
    Note2048th = 0x0002,
    Note4096th = 0x0001
};
 
enum class DefaultClefType : ClefIndex
{
    Treble          = 0,  
    Alto            = 1,  
    Tenor           = 2,  
    Bass            = 3,  
    Percussion      = 4,  
    Treble8vb       = 5,  
    Bass8vb         = 6,  
    Baritone        = 7,  
    FrenchViolin    = 8,  
    BaritoneC       = 9,  
    MezzoSoprano    = 10, 
    Soprano         = 11, 
    AltPercussion   = 12, 
    Treble8va       = 13, 
    Bass8va         = 14, 
    Blank           = 15, 
    Tab1            = 16, 
    Tab2            = 17  
};
 
enum class ShowClefMode
{
    WhenNeeded, 
    Never,      
    Always      
};
 
class FontInfo : public CommonClassBase
{
public:
    FontInfo(const DocumentWeakPtr& document, bool sizeIsPercent = false)
        : CommonClassBase(document), m_sizeIsPercent(sizeIsPercent)
    {
    }
 
    Cmper fontId{};     
    int fontSize{};     
    bool bold{};        
    bool italic{};      
    bool underline{};   
    bool strikeout{};   
    bool absolute{};    
    bool hidden{};      
 
    bool getSizeIsPercent() const { return m_sizeIsPercent; }
 
    inline static constexpr uint16_t EnigmaStyleBold = 0x01; 
    inline static constexpr uint16_t EnigmaStyleItalic = 0x02; 
    inline static constexpr uint16_t EnigmaStyleUnderline = 0x04; 
    inline static constexpr uint16_t EnigmaStyleStrikeout = 0x20; 
    inline static constexpr uint16_t EnigmaStyleAbsolute  = 0x40; 
    inline static constexpr uint16_t EnigmaStyleHidden    = 0x80; 
 
    std::string getName() const;
 
    void setFontIdByName(const std::string& name);
 
    void setEnigmaStyles(uint16_t efx)
    {
        bold = efx & EnigmaStyleBold;
        italic = efx & EnigmaStyleItalic;
        underline = efx & EnigmaStyleUnderline;
        strikeout = efx & EnigmaStyleStrikeout;
        absolute = efx & EnigmaStyleAbsolute;
        hidden = efx & EnigmaStyleHidden;
    }
 
    uint16_t getEnigmaStyles() const
    {
        uint16_t result = 0;
        if (bold) result |= EnigmaStyleBold;
        if (italic) result |= EnigmaStyleItalic;
        if (underline) result |= EnigmaStyleUnderline;
        if (strikeout) result |= EnigmaStyleStrikeout;
        if (absolute) result |= EnigmaStyleAbsolute;
        if (hidden) result |= EnigmaStyleHidden;
        return result;
    }
 
    bool calcIsDefaultMusic() const
    { return fontId == 0; }
 
    bool calcIsSymbolFont() const;
 
    static std::optional<std::filesystem::path> calcSMuFLMetaDataPath(const std::string& fontName);
 
    std::optional<std::filesystem::path> calcSMuFLMetaDataPath() const
    { return FontInfo::calcSMuFLMetaDataPath(getName()); }
 
    bool calcIsSMuFL() const;
 
    static std::vector<std::filesystem::path> calcSMuFLPaths();
 
    static const xml::XmlElementArray<FontInfo>& xmlMappingArray(); 
 
private:
    bool m_sizeIsPercent;
};
 
class KeySignature : public CommonClassBase
{
public:
    using CommonClassBase::CommonClassBase;
 
    enum class KeyContext {
        Concert,   
        Written    
    };
 
    uint16_t key{};
    bool keyless{};                 
    bool hideKeySigShowAccis{};     
 
    Cmper getKeyMode() const { return isLinear() ? key >> 8 : key;  }
 
    int getAlteration(KeyContext ctx) const
    { return isLinear() ? int(int8_t(key & 0xff)) + getAlterationOffset(ctx) : 0; }
 
    bool isLinear() const { return (key & 0xC000) == 0; }                   
    bool isNonLinear() const { return (key & 0xC000) != 0; }                
    bool isBuiltIn() const { return isLinear() && getKeyMode() <= 1; }      
    bool isMajor() const { return getKeyMode() == 0; }                      
    bool isMinor() const { return getKeyMode() == 1; }                      
 
    std::optional<music_theory::DiatonicMode> calcDiatonicMode() const;
 
    bool isSame(const KeySignature& src) const
    {
        return isSameConcert(src) && m_alterationOffset == src.m_alterationOffset && m_octaveDisplacement == src.m_octaveDisplacement;
    }
 
    bool isSameConcert(const KeySignature& src) const
    {
        return key == src.key && keyless == src.keyless && hideKeySigShowAccis == src.hideKeySigShowAccis;
    }
 
    int calcScaleDegree(int displacement) const;
 
    void setTransposition(int interval, int keyAdjustment, bool simplify);
 
    void setTransposition(const MusxInstance<others::Staff>& staff);
 
    int calcTonalCenterIndex(KeyContext ctx) const;
 
    int calcAlterationOnNote(unsigned noteIndex, KeyContext ctx ) const;
 
    int getOctaveDisplacement(KeyContext ctx) const
    { return ctx == KeyContext::Written ? m_octaveDisplacement : 0; }
 
    int calcEDODivisions() const;
 
    std::optional<std::vector<int>> calcKeyMap() const;
 
    std::unique_ptr<music_theory::Transposer> createTransposer(int displacement, int alteration) const;
 
    void integrityCheck(const std::shared_ptr<Base>& ptrToThis) override
    {
        this->CommonClassBase::integrityCheck(ptrToThis);
        if (key >= 0x8000) {
            MUSX_INTEGRITY_ERROR("Key signature has invalid key value: " + std::to_string(key));
        }
    }
 
    static const xml::XmlElementArray<KeySignature>& xmlMappingArray(); 
 
private:
    std::vector<unsigned> calcTonalCenterArrayForSharps() const;
    std::vector<unsigned> calcTonalCenterArrayForFlats() const;
    std::vector<unsigned> calcTonalCenterArray(KeyContext ctx) const;
    std::vector<int> calcAcciAmountsArray(KeyContext ctx) const;
    std::vector<unsigned> calcAcciOrderArray(KeyContext ctx) const;
 
    int m_octaveDisplacement{};         
    int m_alterationOffset{};           
    
    int getAlterationOffset(KeyContext ctx) const
    { return ctx == KeyContext::Written ? m_alterationOffset : 0; }
 
};
 
namespace texts {
class LyricsTextBase; // forward delcaration
} // namespace texts
 
class LyricsLineInfo : CommonClassBase
{
public:
    LyricsLineInfo(const DocumentWeakPtr& document, Cmper requestedPartId, std::string_view type, Cmper lyricNo, Evpu baseline) :
        CommonClassBase(document), baselinePosition(baseline), lyricsType(type), lyricNumber(lyricNo), assignments(document, requestedPartId)
    {
    }
    
    Evpu baselinePosition;              
    std::string_view lyricsType;        
    Cmper lyricNumber;                  
    MusxInstanceList<details::LyricAssign> assignments; 
};
 
class LyricsSyllableInfo : CommonClassBase
{
public:
    std::string syllable;       
    bool hasHyphenBefore;       
    bool hasHyphenAfter;        
    int strippedUnderscores;    
 
private:
    class StyleSpan
    {
    public:
        size_t start;        // start byte
        size_t end;          // end byte (exclusive)
        size_t styleIndex;   // index into LyricsTextBase's style table
    };
 
    LyricsSyllableInfo(const DocumentWeakPtr& document, const std::string text, bool before, bool after, int underscores, std::vector<StyleSpan>&& enigmaStyleMap)
        : CommonClassBase(document), syllable(text), hasHyphenBefore(before), hasHyphenAfter(after), strippedUnderscores(underscores), m_enigmaStyleMap(std::move(enigmaStyleMap))
    {
    }
 
    std::vector<StyleSpan> m_enigmaStyleMap; 
 
    friend class texts::LyricsTextBase;
};
 
class MusicRange : public CommonClassBase
{
public:
    explicit MusicRange(const DocumentWeakPtr& document, MeasCmper startMeasId, util::Fraction startPos, MeasCmper endMeasId, util::Fraction endPos)
        : CommonClassBase(document), startMeasureId(startMeasId), startPosition(startPos), endMeasureId(endMeasId), endPosition(endPos)
    {
    }
 
    MeasCmper startMeasureId{};         
    util::Fraction startPosition{};     
    MeasCmper endMeasureId{};           
    util::Fraction endPosition{};       
 
    bool contains(MeasCmper measId, util::Fraction eduPosition) const
    {
        return (startMeasureId < measId || (startMeasureId == measId && startPosition <= eduPosition)) &&
               (endMeasureId > measId || (endMeasureId == measId && endPosition >= eduPosition));
    }
 
    // The MusicRange must be expressed in the Staff EDUs of the entry.
    bool contains(const EntryInfoPtr& entryInfo) const;
 
    std::optional<std::pair<MeasCmper, Edu>> nextLocation(const std::optional<StaffCmper>& forStaff = std::nullopt) const;
};
 
class TimeSignature : public CommonClassBase
{
public:
 
    struct TimeSigComponent
    {
        std::vector<util::Fraction> counts; 
        std::vector<Edu> units;             
 
        bool operator==(const TimeSigComponent& src) const
        { return counts == src.counts && units == src.units; }
 
        util::Fraction sumCounts() const
        { return std::accumulate(counts.begin(), counts.end(), util::Fraction{}); }
 
        Edu sumUnits() const
        { return std::accumulate(units.begin(), units.end(), Edu{}); }
    };
 
    std::vector<TimeSigComponent> components;     
 
    std::pair<util::Fraction, NoteType> calcSimplified() const;
 
    util::Fraction calcTotalDuration() const
    {
        util::Fraction result = std::accumulate(components.begin(), components.end(), util::Fraction{},
            [](const util::Fraction& acc, const TimeSigComponent& comp)
            { return acc + (comp.sumCounts() * comp.sumUnits()); }
        );
        return result / Edu(NoteType::Whole);
    }
 
    bool isSame(const TimeSignature& src) const
    {
        return components == src.components && m_abbreviate == src.m_abbreviate;
    }
 
    MusxInstance<TimeSignature> createComponent(size_t index) const
    {
        checkIndex(index);
        return MusxInstance<TimeSignature>(new TimeSignature(getDocument(), components[index], m_abbreviate));
    }
 
    std::optional<char32_t> getAbbreviatedSymbol() const;
 
    bool isCommonTime() const;
    bool isCutTime() const;
 
private:
    void checkIndex(size_t index) const
    {
        if (index > components.size()) {
            throw std::invalid_argument("Index out of range. The time signature has " + std::to_string(components.size())
                + " elements. The index requested was " + std::to_string(index) + ".");
        }
    }
 
    explicit TimeSignature(const DocumentWeakPtr& document, int beats, Edu unit, bool hasCompositeTop, bool hasCompositeBottom,
        std::optional<bool> abbreviate = std::nullopt);
 
    explicit TimeSignature(const DocumentWeakPtr& document, const TimeSigComponent& timeSigUnit, std::optional<bool> abbreviate)
        : CommonClassBase(document), m_abbreviate(abbreviate)
    {
        components.push_back(timeSigUnit);
    }
 
    std::optional<bool> m_abbreviate;
 
    friend class others::Measure;
    friend class others::OssiaHeader;
    friend class details::IndependentStaffDetails;
};
 
namespace others {
 
// The following classes are defined here because they are shared by multiple subclasses and container classes.
 
class Enclosure : public OthersBase
{
public:
    enum class Shape : uint8_t
    {
        NoEnclosure = 0,    
        Rectangle = 1,      
        Ellipse = 2,        
        Triangle = 3,       
        Diamond = 4,        
        Pentagon = 5,       
        Hexagon = 6,        
        Heptagon = 7,       
        Octogon = 8         
    };
 
    explicit Enclosure(const DocumentWeakPtr& document, Cmper partId = SCORE_PARTID, ShareMode shareMode = ShareMode::All, Cmper cmper = 0)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Evpu xAdd{};              
    Evpu yAdd{};              
    Evpu xMargin{};           
    Evpu yMargin{};           
    Efix lineWidth{};         
    Shape shape{};            
    Efix cornerRadius{};      
    bool fixedSize{};         
    bool equalAspect{};       
    bool notTall{};           
    bool opaque{};            
    bool roundCorners{};      
 
    static const xml::XmlElementArray<Enclosure>& xmlMappingArray(); 
};
 
class EnigmaMusicRange : public OthersBase
{
public:
    explicit EnigmaMusicRange(const DocumentWeakPtr& document, Cmper partId = SCORE_PARTID, ShareMode shareMode = ShareMode::All,
            Cmper cmper = 0, std::optional<Inci> inci = std::nullopt)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    MeasCmper startMeas{};      
    Edu startEdu{};             
    MeasCmper endMeas{};        
    Edu endEdu{};               
 
    bool contains(MeasCmper measId, Edu eduPosition) const
    {
        return (startMeas < measId || (startMeas == measId && startEdu <= eduPosition)) &&
               (endMeas > measId || (endMeas == measId && endEdu >= eduPosition));
    }
 
    MusicRange createMusicRange() const
    {
        return MusicRange(getDocument(), startMeas, util::Fraction::fromEdu(startEdu), endMeas, util::Fraction::fromEdu(endEdu));
    }
 
    std::optional<std::pair<MeasCmper, Edu>> nextLocation(const std::optional<StaffCmper>& forStaff = std::nullopt) const
    { return createMusicRange().nextLocation(forStaff); }
 
    static const xml::XmlElementArray<EnigmaMusicRange>& xmlMappingArray(); 
};
 
class NamePositioning : public OthersBase
{
public:
 
    explicit NamePositioning(const DocumentWeakPtr& document, Cmper partId = SCORE_PARTID, ShareMode shareMode = ShareMode::All, Cmper cmper = 0)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    enum class AlignJustify
    {
        Left,   
        Right,  
        Center  
    };
    
    Evpu horzOff{};             
    Evpu vertOff{};             
    AlignJustify justify{};     
    bool indivPos{};            
    AlignJustify hAlign{};      
    bool expand{};              
 
    static const xml::XmlElementArray<NamePositioning>& xmlMappingArray(); 
};
 
} // namespace others
} // namespace dom
} // namespace mux