Others.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 <string>
#include <unordered_map>
#include <vector>
#include <memory>
#include <stdexcept>
#include <map>
#include <tuple>
 
#include "musx/util/EnigmaString.h"
#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 Entry;
 
namespace details {
class GFrameHold;
class IndependentStaffDetails;
class StaffGroup;
}
 
namespace others {
 
class AcciAmountFlats : public OthersArray<int, 7>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "acciAmountFlats"; 
    static const xml::XmlElementArray<AcciAmountFlats>& xmlMappingArray(); 
};
 
class AcciAmountSharps : public OthersArray<int, 7>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "acciAmountSharps"; 
    static const xml::XmlElementArray<AcciAmountSharps>& xmlMappingArray(); 
};
 
class AcciOrderFlats : public OthersArray<unsigned, 7>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "acciOrderFlats"; 
    static const xml::XmlElementArray<AcciOrderFlats>& xmlMappingArray(); 
};
 
class AcciOrderSharps : public OthersArray<unsigned, 7>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "acciOrderSharps"; 
    static const xml::XmlElementArray<AcciOrderSharps>& xmlMappingArray(); 
};
 
class ArticulationDef : public OthersBase
{
public:
    enum class AutoVerticalMode
    {
        AlwaysNoteheadSide,         
        AutoNoteStem,               
        StemSide,                   
        AlwaysOnStem,               
        AboveEntry,                 
        BelowEntry,                 
    };
 
    enum class CopyMode
    {
        None,                       
        Vertical,                   
        Horizontal                  
    };
 
    enum class SlurInteractionMode
    {
        Ignore,             
        InsideSlur,
        AvoidSlur
    };
 
    explicit ArticulationDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper), fontMain(new FontInfo(document)), fontAlt(new FontInfo(document)) {}
 
    char32_t charMain{};                           
    std::shared_ptr<FontInfo> fontMain;            
    CopyMode copyMode{};                           
    bool autoHorz{};                               
    bool autoVert{};                               
    AutoVerticalMode autoVertMode{};               
    bool aboveSymbolAlt{};                         
    bool belowSymbolAlt{};                         
    bool insideSlur{};                             
    bool autoStack{};                              
    bool centerOnStem{};                           
    SlurInteractionMode slurInteractionMode{};     
    char32_t charAlt{};                            
    std::shared_ptr<FontInfo> fontAlt;             
    Evpu xOffsetMain{};                            
    Evpu yOffsetMain{};                            
    Evpu defVertPos{};                             
    bool avoidStaffLines{};                        
    bool playArtic{};                              
    Evpu xOffsetAlt{};                             
    Evpu yOffsetAlt{};                             
    bool mainIsShape{};                            
    bool altIsShape{};                             
    Cmper mainShape{};                             
    Cmper altShape{};                              
    int startTopNoteDelta{};                       
    int startBotNoteDelta{};                       
    int startTopNotePercent{};                     
    int startBotNotePercent{};                     
    int durTopNoteDelta{};                         
    int durBotNoteDelta{};                         
    int durTopNotePercent{};                       
    int durBotNotePercent{};                       
    int ampTopNoteDelta{};                         
    int ampBotNoteDelta{};                         
    int ampTopNotePercent{};                       
    int ampBotNotePercent{};                       
    bool outsideStaff{};                           
 
    bool requireAllFields() const override { return false; } 
 
    constexpr static std::string_view XmlNodeName = "articDef"; 
    static const xml::XmlElementArray<ArticulationDef>& xmlMappingArray(); 
};
 
class BeatChartElement : public OthersBase
{
public:
    explicit BeatChartElement(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    class Control
    {
    public:
        Edu totalDur{};     
        Evpu totalWidth{};  
        Evpu minWidth{};    
        Evpu allotWidth{};  
 
        static const xml::XmlElementArray<Control>& xmlMappingArray(); 
    };
 
    // Populated only when the XML node includes a <control> element
    std::shared_ptr<Control> control;  
 
    // Populated for standard beat entries (inci > 0)
    Edu dur{};         
    Evpu pos{};        
    Evpu endPos{};     
    Evpu minPos{};     
 
    void integrityCheck() override
    {
        OthersBase::integrityCheck();
        if (control && getInci() != 0) {
            MUSX_INTEGRITY_ERROR("Beat chart for measure " + std::to_string(getCmper()) + " has a control instance in inci " + std::to_string(*getInci()));
        }
        if (getInci() == 0 && !control) {
            control = std::make_shared<Control>();
            MUSX_INTEGRITY_ERROR("Beat chart for measure " + std::to_string(getCmper()) + " is missing its control instance.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "beatChart"; 
    static const xml::XmlElementArray<BeatChartElement>& xmlMappingArray(); 
};
 
class ChordSuffixElement : public OthersBase
{
public:
    enum class Prefix
    {
        None,   
        Minus,  
        Plus,   
        Sharp,  
        Flat    
    };
 
    explicit ChordSuffixElement(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci), font(new FontInfo(document))
    {
    }
 
    std::shared_ptr<FontInfo> font; 
    char32_t symbol{};              
    Evpu xdisp{};                   
    Evpu ydisp{};                   
    bool isNumber{};                
    Prefix prefix{};                
 
    constexpr static std::string_view XmlNodeName = "chordSuffix"; 
    static const xml::XmlElementArray<ChordSuffixElement>& xmlMappingArray(); 
};
 
class ChordSuffixPlayback : public OthersArray<int16_t>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "chordSuffixPlay"; 
    static const xml::XmlElementArray<ChordSuffixPlayback>& xmlMappingArray(); 
};
 
class ClefList : public OthersBase
{
public:
    explicit ClefList(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    // Public properties corresponding to the XML structure, in the same order as in the XML.
    ClefIndex clefIndex{};  
    Edu xEduPos{};          
    Evpu yEvpuPos{};        
    int percent{};          
    int xEvpuOffset{};      
    ShowClefMode clefMode{}; 
    bool unlockVert{};      
    bool afterBarline{};    
 
    constexpr static std::string_view XmlNodeName = "clefEnum"; 
    static const xml::XmlElementArray<ClefList>& xmlMappingArray(); 
};
 
class DrumStaff : public OthersBase
{
public:
    explicit DrumStaff(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Cmper whichDrumLib{};       
 
    constexpr static std::string_view XmlNodeName = "drumStaff"; 
    static const xml::XmlElementArray<DrumStaff>& xmlMappingArray();    
};
 
class DrumStaffStyle : public DrumStaff
{
public:
    using DrumStaff::DrumStaff;
 
    constexpr static std::string_view XmlNodeName = "drumStaffStyle"; 
};
 
class FontDefinition : public OthersBase
{
    static constexpr uint32_t SYMBOL_CHARSET_MAC = 0xfff; // (4095)
    static constexpr uint32_t SYMBOL_CHARSET_WIN = 2;
 
public:
    explicit FontDefinition(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    enum class CharacterSetBank
    {
        MacOS,          
        Windows         
    };
 
    // Public properties corresponding to the XML structure
    CharacterSetBank charsetBank{}; 
    int charsetVal{};               
    int pitch{};                    
    int family{};                   
    std::string name;               
 
    bool calcIsSymbolFont() const
    {
        if (charsetBank == CharacterSetBank::MacOS && charsetVal == SYMBOL_CHARSET_MAC) {
            return true;
        }
        if (charsetBank == CharacterSetBank::Windows && charsetVal == SYMBOL_CHARSET_WIN) {
            return true;
        }
        return false;
    }
 
    constexpr static std::string_view XmlNodeName = "fontName"; 
    static const xml::XmlElementArray<FontDefinition>& xmlMappingArray(); 
};
 
class Frame : public OthersBase
{
public:
    explicit Frame(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci = 0)
        : OthersBase(document, partId, shareMode, cmper, inci) {}
 
    // Public properties corresponding to the XML structure
    EntryNumber startEntry{}; 
    EntryNumber endEntry{};   
    Edu startTime{};          
 
    void iterateRawEntries(std::function<bool(const std::shared_ptr<Entry>& entry)> iterator) const;
 
    std::vector<std::shared_ptr<const Entry>> getEntries() const;
 
    void integrityCheck() override
    {
        this->OthersBase::integrityCheck();
        if (startTime && (startEntry || endEntry)) {
            MUSX_INTEGRITY_ERROR("Frame " + std::to_string(getCmper()) + " has non-zero startTime and non-zero startEntry or endEntry.");
        }
        if (!startTime && !startEntry) {
            MUSX_INTEGRITY_ERROR("Frame " + std::to_string(getCmper()) + " has no start entry.");
        }
        if (!startTime && !endEntry) {
            MUSX_INTEGRITY_ERROR("Frame " + std::to_string(getCmper()) + " has no end entry.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "frameSpec"; 
    static const xml::XmlElementArray<Frame>& xmlMappingArray();    
};
 
class Staff;
class InstrumentUsed : public OthersBase {
public:
    explicit InstrumentUsed(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci) {}
 
    InstCmper staffId{};                    
    Evpu distFromTop{};                     
    std::shared_ptr<MusicRange> range;      
 
    std::shared_ptr<Staff> getStaff() const;
 
    static std::shared_ptr<Staff> getStaffAtIndex(const std::vector<std::shared_ptr<InstrumentUsed>>& iuArray, Cmper index);
 
    static std::optional<size_t> getIndexForStaff(const std::vector<std::shared_ptr<InstrumentUsed>>& iuArray, InstCmper staffId);
 
    constexpr static std::string_view XmlNodeName = "instUsed"; 
    static const xml::XmlElementArray<InstrumentUsed>& xmlMappingArray(); 
};
 
class KeyFormat : public OthersBase {
public:
    explicit KeyFormat(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    unsigned semitones{};       
    unsigned scaleTones{};      
 
    constexpr static std::string_view XmlNodeName = "keyFormat"; 
    static const xml::XmlElementArray<KeyFormat>& xmlMappingArray(); 
};
 
class KeyMapArray : public OthersBase {
public:
    explicit KeyMapArray(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    class StepElement {
    public:
        bool diatonic{};    
        unsigned hlevel{};  
 
        static const xml::XmlElementArray<StepElement>& xmlMappingArray(); 
    };
 
    std::vector<std::shared_ptr<StepElement>> steps; 
 
    unsigned countDiatonicSteps() const
    {
        return static_cast<unsigned>(std::count_if(steps.begin(), steps.end(), [](const auto& step) {
            return step->diatonic;
        }));
    }
 
    constexpr static std::string_view XmlNodeName = "keyMap"; 
    static const xml::XmlElementArray<KeyMapArray>& xmlMappingArray(); 
};
 
class KeyAttributes : public OthersBase {
public:
    explicit KeyAttributes(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    int harmRefer{};        
    int middleCKey{};       
    Cmper fontSym{};        
    int gotoKey{};          
    Cmper symbolList{};     
    bool hasClefOctv{};     
 
    constexpr static std::string_view XmlNodeName = "keysAttrib"; 
    static const xml::XmlElementArray<KeyAttributes>& xmlMappingArray(); 
};
 
class LayerAttributes : public OthersBase {
public:
    explicit LayerAttributes(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    int restOffset{};                   
    bool freezTiesToStems{};            
    bool onlyIfOtherLayersHaveNotes{};  
    bool useRestOffset{};               
    bool freezeStemsUp{};               
    bool freezeLayer{};                 
    bool playback{};                    
    bool affectSpacing{};               
    bool ignoreHiddenNotesOnly{};       
    bool ignoreHiddenLayers{};          
    bool hideLayer{};                   
 
    constexpr static std::string_view XmlNodeName = "layerAtts"; 
    static const xml::XmlElementArray<LayerAttributes>& xmlMappingArray(); 
};
 
enum class RehearsalMarkStyle
{
    None,                       
    Letters,                    
    LetterNumbers,              
    LettersLowerCase,           
    LettersNumbersLowerCase,    
    Numbers,                    
    MeasureNumber               
};
 
enum class PlaybackType
{
    None,                   
    Tempo,                  
    MidiController,         
    KeyVelocity,            
    Transpose,              
    Channel,                
    MidiPatchChange,        
    PercussionMidiMap,      
    MidiPitchWheel,         
    ChannelPressure,        
    RestrikeKeys,           
    Dump,                   
    PlayTempoToolChanges,   
    IgnoreTempoToolChanges, 
    Swing,                  
    SmartPlaybackOn,        
    SmartPlaybackOff,       
};
 
enum class HorizontalMeasExprAlign
{
    LeftBarline,            
    Manual,                 
    LeftOfAllNoteheads,     
    LeftOfPrimaryNotehead,  
    Stem,                   
    CenterPrimaryNotehead,  
    CenterAllNoteheads,     
    RightOfAllNoteheads,    
    StartTimeSig,           
    AfterClefKeyTime,       
    StartOfMusic,           
    CenterOverBarlines,     
    CenterOverMusic,        
    RightBarline            
};
 
enum class VerticalMeasExprAlign
{
    AboveStaff,          
    Manual,              
    RefLine,             
    BelowStaff,          
    TopNote,             
    BottomNote,          
    AboveEntry,          
    BelowEntry,          
    AboveStaffOrEntry,   
    BelowStaffOrEntry    
};
 
enum class HorizontalTextJustification
{
    Left,    
    Center,  
    Right    
};
 
class ShapeExpressionDef;
class TextExpressionDef;
 
class MarkingCategory : public OthersBase {
public:
    enum class CategoryType : Cmper
    {
        Invalid,            
        Dynamics,           
        TempoMarks,         
        TempoAlterations,   
        ExpressiveText,     
        TechniqueText,      
        RehearsalMarks,     
        Misc                
    };
 
    explicit MarkingCategory(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    CategoryType categoryType{}; 
 
    // Font information for the marking category
    std::shared_ptr<FontInfo> textFont;      
    std::shared_ptr<FontInfo> musicFont;     
    std::shared_ptr<FontInfo> numberFont;    
 
    HorizontalMeasExprAlign horzAlign{};     
    VerticalMeasExprAlign vertAlign{};       
    HorizontalTextJustification justification{}; 
 
    // Vertical and horizontal offsets for positioning adjustments
    Evpu horzOffset{};         
    Evpu vertOffsetBaseline{}; 
    Evpu vertOffsetEntry{};    
 
    // Usage flags representing certain behaviors and visual elements
    bool usesTextFont{};      
    bool usesMusicFont{};     
    bool usesNumberFont{};    
    bool usesPositioning{};   
    bool usesStaffList{};     
    bool usesBreakMmRests{};  
    bool breakMmRest{};       
    bool userCreated{};       
 
    // Staff list represented as an integer
    Cmper staffList{};        
 
    std::map<Cmper, std::weak_ptr<ShapeExpressionDef>> shapeExpressions;
 
    std::map<Cmper, std::weak_ptr<TextExpressionDef>> textExpressions;
 
    std::string getName() const;
 
    constexpr static std::string_view XmlNodeName = "markingsCategory"; 
    static const xml::XmlElementArray<MarkingCategory>& xmlMappingArray(); 
};
 
class MarkingCategoryName : public OthersBase {
public:
    explicit MarkingCategoryName(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    std::string name; 
 
    constexpr static std::string_view XmlNodeName = "markingsCategoryName"; 
    static const xml::XmlElementArray<MarkingCategoryName>& xmlMappingArray(); 
};
 
class Measure : public OthersBase {
public:
    explicit Measure(const DocumentWeakPtr& document, Cmper measureId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, measureId, shareMode, cmper) {}
 
    enum class PositioningType
    {
        Manual,                     
        TimeSignature,              
        BeatChart,                  
        TimeSigPlusPositioning,     
        BeatChartPlusPositioning    
    };
 
    enum class BarlineType
    {
        None,                   
        OptionsDefault,         
        Normal,                 
        Double,                 
        Final,                  
        Solid,                  
        Dashed,                 
        Tick,                   
        Custom                  
    };
 
    enum class ShowKeySigMode
    {
        IfNeeded,               
        Always,                 
        Never                   
    };
 
    enum class ShowTimeSigMode
    {
        IfNeeded,               
        Always,                 
        Never                   
    };
 
    Evpu width{};               
    std::shared_ptr<KeySignature> globalKeySig; 
    Cmper beats{};              
    Cmper divBeat{};            
    Cmper dispBeats{};          
    Cmper dispDivbeat{};        
    Evpu frontSpaceExtra{};     
    Evpu backSpaceExtra{};      
    bool breakWordExt{};        
    bool hideCaution{};         
    bool hasSmartShape{};       
    bool showFullNames{};       
    bool allowSplitPoints{};    
    bool groupBarlineOverride{}; 
    Cmper customBarShape{};     
    Cmper customLeftBarShape{}; 
    ShowKeySigMode showKey{};   
    ShowTimeSigMode showTime{}; 
    PositioningType positioningMode{}; 
    bool beginNewSystem{};      
    bool breakMmRest{};         
    bool noMeasNum{};           
    BarlineType barlineType{};  
    bool evenlyAcrossMeasure{}; 
    bool hasExpression{};       
    bool hasTextBlock{};        
    bool forwardRepeatBar{};    
    bool backwardsRepeatBar{};  
    bool hasEnding{};           
    bool hasTextRepeat{};       
    bool hasChord{};            
    bool compositeNumerator{};  
    bool compositeDenominator{}; 
    bool abbrvTime{};           
    bool useDisplayTimesig{};   
    BarlineType leftBarlineType{}; 
    bool compositeDispNumerator{};  
    bool compositeDispDenominator{}; 
 
    bool calcShouldShowFullNames() const
    { return getCmper() == 1 || showFullNames; }
 
    int calcDisplayNumber() const;
 
    std::shared_ptr<KeySignature> createKeySignature(const std::optional<InstCmper>& forStaff = std::nullopt) const;
 
    std::shared_ptr<TimeSignature> createTimeSignature(const std::optional<InstCmper>& forStaff = std::nullopt) const;
 
    std::shared_ptr<TimeSignature> createDisplayTimeSignature(const std::optional<InstCmper>& forStaff = std::nullopt) const;
 
    util::Fraction calcDuration(const std::optional<InstCmper>& forStaff = std::nullopt) const;
 
    util::Fraction calcTimeStretch(InstCmper forStaff) const
    {
        return calcDuration() / calcDuration(forStaff);
    }
 
    void integrityCheck() override
    {
        this->OthersBase::integrityCheck();
        if (!globalKeySig) {
            globalKeySig = std::make_shared<KeySignature>(getDocument());
        }
    }
 
    bool requireAllFields() const override { return false; } 
 
    constexpr static std::string_view XmlNodeName = "measSpec"; 
    static const xml::XmlElementArray<Measure>& xmlMappingArray(); 
};
 
class MeasureExprAssign : public OthersBase
{
public:
    explicit MeasureExprAssign(const DocumentWeakPtr& document, Cmper ID, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, ID, shareMode, cmper, inci) {}
 
    // Public properties corresponding to the XML structure
    Cmper textExprId{};         
    Cmper shapeExprId{};        
    Evpu horzEvpuOff{};         
    Edu eduPosition{};          
    Evpu vertEvpuOff{};         
    InstCmper staffAssign{};    
    int layer{};                
    bool dontScaleWithEntry{};  
    Cmper staffGroup{};         
    Cmper staffList{};          
    bool hidden{};              
 
    std::shared_ptr<TextExpressionDef> getTextExpression() const;
 
    std::shared_ptr<ShapeExpressionDef> getShapeExpression() const;
 
    void integrityCheck() override
    {
        this->OthersBase::integrityCheck();
        if (!textExprId && !shapeExprId) {
            MUSX_INTEGRITY_ERROR("Expression assignment at measure " + std::to_string(getCmper()) + " inci " + std::to_string(getInci().value_or(-1))
                + " has no expression definition ID.");
        } else if (textExprId && shapeExprId) {
            MUSX_INTEGRITY_ERROR("Expression assignment at measure " + std::to_string(getCmper()) + " inci " + std::to_string(getInci().value_or(-1))
                + " has both text expr ID " + std::to_string(textExprId) + " and shape expr ID " + std::to_string(shapeExprId));
        }
    }
 
    bool requireAllFields() const override { return false; } 
 
    constexpr static std::string_view XmlNodeName = "measExprAssign"; 
    static const xml::XmlElementArray<MeasureExprAssign>& xmlMappingArray(); 
};
 
class MeasureNumberRegion : public OthersBase {
public:
    explicit MeasureNumberRegion(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    enum class AlignJustify
    {
        Left,   
        Right,  
        Center  
    };
 
    enum class TimePrecision
    {
        WholeSeconds,   
        Tenths,
        Hundredths,
        Thousandths,
    };
 
    class ScorePartData : public Base
    {
    public:
        explicit ScorePartData(const DocumentWeakPtr& document) : Base(document, 0, ShareMode::All) {}
 
        std::shared_ptr<FontInfo> startFont;          
        std::shared_ptr<FontInfo> multipleFont;       
        std::shared_ptr<FontInfo> mmRestFont;         
        std::shared_ptr<Enclosure> startEnclosure;    
        std::shared_ptr<Enclosure> multipleEnclosure; 
 
        Evpu startXdisp{};         
        Evpu startYdisp{};         
        Evpu multipleXdisp{};      
        Evpu multipleYdisp{};      
        Evpu mmRestXdisp{};        
        Evpu mmRestYdisp{};        
        char32_t leftMmBracketChar{};  
        char32_t rightMmBracketChar{}; 
        int startWith{};           
        int incidence{};           
        AlignJustify startAlign{};  
        AlignJustify multipleAlign{}; 
        AlignJustify mmRestAlign{}; 
        bool showOnStart{};        
        bool showOnEvery{};        
        bool hideFirstMeasure{};   
        bool showMmRange{};        
        bool showOnMmRest{};       
        bool useStartEncl{};       
        bool useMultipleEncl{};    
        bool showOnTop{};          
        bool showOnBottom{};       
        bool excludeOthers{};      
        bool breakMmRest{};        
        AlignJustify startJustify{}; 
        AlignJustify multipleJustify{}; 
        AlignJustify mmRestJustify{}; 
 
        static const xml::XmlElementArray<ScorePartData>& xmlMappingArray(); 
    };
 
    // Public properties
    std::shared_ptr<ScorePartData> scoreData; 
    std::shared_ptr<ScorePartData> partData;  
 
    MeasCmper startMeas{};      
    MeasCmper endMeas{};        
    char32_t startChar{};       
    int base{};                 
    int numberOffset{};         
    std::string prefix;         
    std::string suffix;         
 
    bool countFromOne{};        
    bool noZero;                
    bool doubleUp{};            
    bool time{};                
    bool includeHours{};        
    bool smpteFrames{};         
    bool useScoreInfoForPart{}; 
    int region{};               
    TimePrecision timePrecision{}; 
    bool hideScroll{};          
    bool hidePage{};            
 
    bool calcIncludesMeasure(MeasCmper measureId) const
    {
        return measureId >= startMeas && measureId < endMeas; // endMeas is non-inclusive!
    }
 
    int getStartNumber() const { return int(numberOffset + 1); }
 
    int calcDisplayNumberFor(MeasCmper measureId) const;
 
    static std::shared_ptr<MeasureNumberRegion> findMeasure(const DocumentPtr& document, MeasCmper measureId);
 
    constexpr static std::string_view XmlNodeName = "measNumbRegion"; 
    static const xml::XmlElementArray<MeasureNumberRegion>& xmlMappingArray(); 
};
 
class MultimeasureRest : public OthersBase {
public:
    explicit MultimeasureRest(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper startMeasure)
        : OthersBase(document, partId, shareMode, startMeasure) {}
 
    Evpu measWidth{};           
    MeasCmper nextMeas{};       
    Evpu numVertAdj{};          
    Cmper shapeDef{};           
    int numStart{};             
    int symbolThreshold{};      
    Evpu symbolSpacing{};       
    Evpu numHorzAdj{};          
    Evpu shapeStartAdjust{};    
    Evpu shapeEndAdjust{};      
    bool useSymbols{};          
 
    MeasCmper getStartMeasure() const { return getCmper(); }
 
    int calcNumberOfMeasures() const { return (std::max)(nextMeas - getStartMeasure(), 0); }
    
    bool calcIsNumberVisible() const { return calcNumberOfMeasures() >= numStart; }
 
    void integrityCheck() override
    {
        this->OthersBase::integrityCheck();
        if (nextMeas <= getStartMeasure()) {
            MUSX_INTEGRITY_ERROR("Multimeasure rest at " + std::to_string(getCmper()) + " in part " + std::to_string(getPartId()) + " spans 0 or fewer measures.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "mmRest"; 
    static const xml::XmlElementArray<MultimeasureRest>& xmlMappingArray(); 
};
 
class MultiStaffGroupId : public OthersBase {
public:
    explicit MultiStaffGroupId(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Cmper staffGroupId{}; 
 
    constexpr static std::string_view XmlNodeName = "multiStaffGroupID"; 
    static const xml::XmlElementArray<MultiStaffGroupId>& xmlMappingArray(); 
};
 
class MultiStaffInstrumentGroup : public OthersBase {
public:
    explicit MultiStaffInstrumentGroup(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    std::vector<InstCmper> staffNums; 
 
    std::vector<InstCmper> visualStaffNums; 
 
    std::shared_ptr<Staff> getStaffAtIndex(size_t x) const;
 
    std::shared_ptr<Staff> getFirstStaff() const;
 
    std::optional<size_t> getIndexOf(InstCmper staffId) const
    {
        for (size_t x = 0; x < staffNums.size(); x++) {
            if (staffNums[x] == staffId) return x;        
        }
        return std::nullopt;
    }
 
    std::optional<size_t> getVisualIndexOf(InstCmper staffId) const
    {
        for (size_t x = 0; x < visualStaffNums.size(); x++) {
            if (visualStaffNums[x] == staffId) return x;        
        }
        return std::nullopt;
    }
 
    std::shared_ptr<details::StaffGroup> getStaffGroup(Cmper forPartId) const;
 
    std::shared_ptr<details::StaffGroup> calcVisualStaffGroup(Cmper forPartId) const;
 
    static void calcAllMultiStaffGroupIds(const DocumentPtr& document);
 
    void integrityCheck() override
    {
        OthersBase::integrityCheck();
        if (staffNums.empty()) {
            MUSX_INTEGRITY_ERROR("MultiStaffInstrumentGroup " + std::to_string(getCmper()) + " contains no staves.");
        } else if (staffNums.size() > 3) {
            MUSX_INTEGRITY_ERROR("MultiStaffInstrumentGroup " + std::to_string(getCmper()) + " contains more than 3 staves.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "multiStaffInstGroup"; 
    static const xml::XmlElementArray<MultiStaffInstrumentGroup>& xmlMappingArray(); 
};
 
class NamePositionAbbreviated : public NamePositioning
{
public:
    using NamePositioning::NamePositioning;
 
    constexpr static std::string_view XmlNodeName = "namePosAbbrv"; 
};
 
class NamePositionStyleAbbreviated : public NamePositioning
{
public:
    using NamePositioning::NamePositioning;
 
    constexpr static std::string_view XmlNodeName = "namePosAbbrvStyle"; 
};
 
class NamePositionFull : public NamePositioning
{
public:
    using NamePositioning::NamePositioning;
 
    constexpr static std::string_view XmlNodeName = "namePosFull"; 
};
 
class NamePositionStyleFull : public NamePositioning
{
public:
    using NamePositioning::NamePositioning;
 
    constexpr static std::string_view XmlNodeName = "namePosFullStyle"; 
};
 
class Page : public OthersBase {
public:
    explicit Page(const DocumentWeakPtr& document, Cmper pageId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, pageId, shareMode, cmper) {}
 
    Evpu height{};              
    Evpu width{};               
    int percent{};              
    SystemCmper firstSystem{};  
    bool holdMargins{};         
    Evpu margTop{};             
    Evpu margLeft{};            
    Evpu margBottom{};          
    Evpu margRight{};           
 
    std::optional<SystemCmper> lastSystem; 
 
    bool isBlank() const { return firstSystem < 0; }
 
    constexpr static std::string_view XmlNodeName = "pageSpec"; 
    static const xml::XmlElementArray<Page>& xmlMappingArray(); 
};
 
class PageTextAssign : public OthersBase
{
public:
    enum class HorizontalAlignment {
        Left, // default value: leave as first (0) item
        Center,
        Right
    };
 
    enum class VerticalAlignment {
        Top, // default value: leave as first (0) item
        Center,
        Bottom
    };
 
    explicit PageTextAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    Cmper block{};                  
    Evpu xDisp{};                   
    Evpu yDisp{};                   
    Cmper startPage{};              
    Cmper endPage{};                
    HorizontalAlignment hPosLp{};   
    HorizontalAlignment hPosRp{};   
    bool hidden{};                  
    VerticalAlignment vPos{};       
    bool hPosPageEdge{};            
    bool vPosPageEdge{};            
    bool indRpPos{};                
    Evpu rightPgXDisp{};            
    Evpu rightPgYDisp{};            
 
    constexpr static std::string_view XmlNodeName = "pageTextAssign"; 
    static const xml::XmlElementArray<PageTextAssign>& xmlMappingArray(); 
};
 
class PartDefinition : public OthersBase
{
public:
    explicit PartDefinition(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    Cmper nameId{};                    
    int partOrder{};                   
    int copies{};                      
    bool extractPart{};                
    bool needsRecalc{};                
    bool useAsSmpInst{};               
    int smartMusicInst{};              
    Cmper defaultNameStaff{};          
    Cmper defaultNameGroup{};          
 
    std::string getName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    bool isScore() const { return getCmper() == SCORE_PARTID; }
 
    Cmper calcSystemIuList(Cmper systemId) const;
 
    static std::shared_ptr<PartDefinition> getScore(const DocumentPtr& document);
 
    static std::vector<std::shared_ptr<PartDefinition>> getInUserOrder(const DocumentPtr& document);
 
    bool requireAllFields() const override { return false; }
 
    constexpr static std::string_view XmlNodeName = "partDef"; 
    static const xml::XmlElementArray<PartDefinition>& xmlMappingArray(); 
};
 
class PartGlobals : public OthersBase {
public:
    explicit PartGlobals(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    bool showTransposed{};                  
    Cmper scrollViewIUlist{};               
    Cmper studioViewIUlist{};               
    Cmper specialPartExtractionIUList{};    
 
    constexpr static std::string_view XmlNodeName = "partGlobals"; 
    static const xml::XmlElementArray<PartGlobals>& xmlMappingArray(); 
};
 
class PercussionNoteInfo : public OthersBase {
public:
    explicit PercussionNoteInfo(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci) {}
 
    PercussionNoteType percNoteType{};  
    int staffPosition{};                
    char32_t closedNotehead{};          
    char32_t halfNotehead{};            
    char32_t wholeNotehead{};           
    char32_t dwholeNotehead{};          
 
    int calcStaffReferencePosition() const { return staffPosition - 10; }
 
    constexpr static std::string_view XmlNodeName = "percussionNoteInfo"; 
    static const xml::XmlElementArray<PercussionNoteInfo>& xmlMappingArray(); 
};
 
enum class RepeatActionType
{
    JumpAuto,               
    JumpAbsolute,           
    JumpRelative,           
    JumpToMark,             
    Stop,                   
    NoJump                  
};
 
enum class RepeatTriggerType
{
    Always,                 
    OnPass,                 
    UntilPass               
};
 
class RepeatBack : public OthersBase {
public:
    explicit RepeatBack(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    int passNumber{};               
    int targetValue{};              
    Evpu leftHPos{};                
    Evpu leftVPos{};                
    bool individualPlacement{};     
    bool topStaffOnly{};            
    bool resetOnAction{};           
    RepeatActionType jumpAction{};  
    RepeatTriggerType trigger{};    
    Cmper staffList{};              
    Evpu rightHPos{};               
    Evpu rightVPos{};               
    
    constexpr static std::string_view XmlNodeName = "repeatBack"; 
    static const xml::XmlElementArray<RepeatBack>& xmlMappingArray(); 
};
    
class RepeatEndingStart : public OthersBase
{
public:
    explicit RepeatEndingStart(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    Cmper staffList{};              
    int targetValue{};              
    Evpu textHPos{};                
    Evpu leftHPos{};                
    Evpu leftVPos{};                
    bool individualPlacement{};     
    bool topStaffOnly{};            
    RepeatActionType jumpAction{};  
    RepeatTriggerType trigger{};    
    bool jumpIfIgnoring{};          
    Evpu endLineVPos{};             
    Evpu textVPos{};                
    Evpu rightHPos{};               
    Evpu rightVPos{};               
 
    int calcEndingLength() const;
 
    bool calcIsOpen() const;
 
 
    void integrityCheck()
    {
        OthersBase::integrityCheck();
        if (trigger != RepeatTriggerType::OnPass) {
            MUSX_INTEGRITY_ERROR("RepeatEndingStart at measure " + std::to_string(getCmper()) + " has an unexpected trigger value " +
                std::to_string(int(trigger)));
        }
    }
 
    constexpr static std::string_view XmlNodeName = "repeatEndingStart"; 
    static const xml::XmlElementArray<RepeatEndingStart>& xmlMappingArray(); 
};
 
class RepeatEndingText : public OthersBase {
public:
    explicit RepeatEndingText(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    std::string text; 
 
    constexpr static std::string_view XmlNodeName = "repeatEndingText"; 
    static const xml::XmlElementArray<RepeatEndingText>& xmlMappingArray(); 
};
 
class RepeatPassList : public OthersArray<int>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "repeatPassList"; 
    static const xml::XmlElementArray<RepeatPassList>& xmlMappingArray(); 
};
 
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;    
 
    void iterateInstructions(std::function<bool(InstructionType, std::vector<int>)> callback) const;
 
    bool requireAllFields() const override { return false; }
 
    constexpr static std::string_view XmlNodeName = "shapeDef"; 
    static const xml::XmlElementArray<ShapeDef>& xmlMappingArray(); 
};
 
class ShapeExpressionDef : public OthersBase {
public:
    explicit ShapeExpressionDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Cmper shapeDef{};                               
    Cmper categoryId{};                             
    RehearsalMarkStyle rehearsalMarkStyle{};        
    int value{};                                    
    int auxData1{};                                 
    int playPass{};                                 
    bool breakMmRest{};                             
    bool useAuxData{};                              
    bool masterShape{};                             
    bool noPrint{};                                 
    bool noHorzStretch{};                           
    PlaybackType playbackType{};                    
    HorizontalMeasExprAlign horzMeasExprAlign{};    
    VerticalMeasExprAlign vertMeasExprAlign{};      
    HorizontalTextJustification horzExprJustification{}; 
    Evpu measXAdjust{};                             
    Evpu yAdjustEntry{};                            
    Evpu yAdjustBaseline{};                         
    bool useCategoryPos{};                          
    std::string description;                        
 
    bool requireAllFields() const override { return false; }
 
    constexpr static std::string_view XmlNodeName = "shapeExprDef"; 
    static const xml::XmlElementArray<ShapeExpressionDef>& xmlMappingArray(); 
};
 
class ShapeInstructionList : public OthersBase
{
public:
    explicit ShapeInstructionList(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
    
    class Instruction
    {
    public:
 
        int numData{};                      
        ShapeDef::InstructionType type{};   
 
        static const xml::XmlElementArray<Instruction>& xmlMappingArray();    
    };
 
    std::vector<std::shared_ptr<Instruction>> instructions; 
 
    constexpr static std::string_view XmlNodeName = "shapeList"; 
    static const xml::XmlElementArray<ShapeInstructionList>& xmlMappingArray(); 
};
 
class StaffStyle;
class Staff : public OthersBase
{
public:
    enum class AutoNumberingStyle
    {
        ArabicSuffix,       
        RomanSuffix,        
        OrdinalPrefix,      
        AlphaSuffix,        
        ArabicPrefix        
    };
 
    enum class StemDirection
    {
        Default,            
        AlwaysUp,           
        AlwaysDown          
    };
 
    enum class NotationStyle
    {
        Standard,
        Percussion,
        Tablature
    };
 
    enum class HideMode
    {
        None,           
        Cutaway,        
        ScoreParts,     
        Score           
    };
 
    enum class AlternateNotation
    {
        Normal,         
        SlashBeats,     
        Rhythmic,       
        Blank,          
        OneBarRepeat,   
        TwoBarRepeat,   
        BlankWithRests  
    };
 
    class KeySigTransposition
    {
    public:
        int interval{};     
        int adjust{};       
 
        static const xml::XmlElementArray<KeySigTransposition>& xmlMappingArray(); 
    };
 
    class ChromaticTransposition
    {
    public:
        int alteration{};   
        int diatonic{};     
 
        static const xml::XmlElementArray<ChromaticTransposition>& xmlMappingArray(); 
    };
 
    class Transposition
    {
    public:
        bool setToClef{};               
        bool noSimplifyKey{};           
        
        std::shared_ptr<KeySigTransposition> keysig;
        
        std::shared_ptr<ChromaticTransposition> chromatic;
 
        static const xml::XmlElementArray<Transposition>& xmlMappingArray(); 
    };
 
    explicit Staff(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // WARNING: Any fields added here must have a mask added in StaffStyle (if it does not already exist)
    //          and must be added to StaffComposite::applyStyle.
 
    // Public properties corresponding to the XML structure
    NotationStyle notationStyle{};  
    std::shared_ptr<FontInfo> noteFont; 
    bool useNoteFont{};             
    ClefIndex defaultClef{};        
    ClefIndex transposedClef{};     
    std::optional<int> staffLines{}; 
    std::optional<std::vector<int>> customStaff; 
    Evpu lineSpace{};               
    std::string instUuid;           
    bool floatKeys{};               
    bool floatTime{};               
    bool blineBreak{};              
    bool rbarBreak{};               
    bool hasStyles{};               
    bool showNameInParts{};         
    std::shared_ptr<Transposition> transposition; 
    bool hideNameInScore{};         
    Evpu botBarlineOffset{};        
    AlternateNotation altNotation{};
    LayerIndex altLayer{};          
    bool altHideArtics{};           
    bool altHideLyrics{};           
    bool altHideSmartShapes{};      
    bool altRhythmStemsUp{};        
    bool altSlashDots{};            
    bool altHideOtherNotes{};       
    bool altHideOtherArtics{};      
    bool altHideExpressions{};      
    bool altHideOtherLyrics{};      
    bool altHideOtherSmartShapes{}; 
    bool altHideOtherExpressions{}; 
    bool hideRepeatBottomDot{};     
    bool flatBeams{};               
    bool hideFretboards{};          
    bool blankMeasure{};            
    bool hideRepeatTopDot{};        
    bool hideLyrics{};              
    bool noOptimize{};              
    Evpu topBarlineOffset{};        
    bool hideMeasNums{};            
    bool hideRepeats{};             
    bool hideBarlines{};            
    bool hideRptBars{};             
    bool hideKeySigs{};             
    bool hideTimeSigs{};            
    bool hideClefs{};               
    bool hideStaffLines{};          
    bool hideChords{};              
    bool noKey{};                   
    Evpu dwRestOffset{};            
    Evpu wRestOffset{};             
    Evpu hRestOffset{};             
    Evpu otherRestOffset{};         
    bool hideRests{};               
    bool hideTies{};                
    bool hideDots{};                
    int stemReversal{};             
    Cmper fullNameTextId{};         
    Cmper abbrvNameTextId{};        
    Evpu botRepeatDotOff{};         
    Evpu topRepeatDotOff{};         
    Evpu vertTabNumOff{};           
    bool hideStems{};               
    StemDirection stemDirection{};  
    bool hideBeams{};               
    HideMode hideMode{};            
    bool redisplayLayerAccis{};     
    bool hideTimeSigsInParts{};     
    AutoNumberingStyle autoNumbering{}; 
    bool useAutoNumbering{};        
    bool hideKeySigsShowAccis{};    
 
    // The following values are not in xml but computed by the factory.
 
    Cmper fullNamePosId{};          
    bool fullNamePosFromStyle{};    
    Cmper abrvNamePosId{};          
    bool abrvNamePosFromStyle{};    
    Cmper multiStaffInstId{};       
    Cmper multiStaffInstVisualId{}; 
    Cmper multiStaffInstVisualGroupId{}; 
    std::optional<int> autoNumberValue; 
    std::optional<Cmper> percussionMapId; 
 
    std::string getFullName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    std::string getAbbreviatedName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    std::shared_ptr<MultiStaffInstrumentGroup> getMultiStaffInstGroup() const;
 
    std::shared_ptr<MultiStaffInstrumentGroup> getMultiStaffInstVisualGroup() const;
 
    std::string getFullInstrumentName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii, bool preferStaffName = false) const;
 
    std::string getAbbreviatedInstrumentName(util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii, bool preferStaffName = false) const;
 
    std::shared_ptr<const NamePositioning> getFullNamePosition() const;
 
    std::shared_ptr<const NamePositioning> getAbbreviatedNamePosition() const;
 
    bool showNamesForPart(Cmper partId) const
    { return partId == SCORE_PARTID ? !hideNameInScore : showNameInParts; }
 
    static void calcAllAutoNumberValues(const DocumentPtr& document);
 
    template <typename SubType>
    static void calcAllRuntimeValues(const DocumentPtr& document);
 
    std::string addAutoNumbering(const std::string& plainName) const;
 
    ClefIndex calcClefIndexAt(MeasCmper measureId, Edu position, bool forWrittenPitch = false) const;
 
    ClefIndex calcFirstClefIndex(bool forWrittenPitch = false) const
    { return calcClefIndexAt(1, 0, forWrittenPitch); }
 
    static ClefIndex calcFirstClefIndex(const DocumentPtr& document, Cmper partId, InstCmper staffCmper);
 
    int calcMiddleStaffPosition() const;
 
    int calcToplinePosition() const;
 
    bool hasInstrumentAssigned() const;
 
    std::vector<std::shared_ptr<PartDefinition>> getContainingParts(bool includeScore = true) const;
 
    std::shared_ptr<PartDefinition> firstFirstContainingPart() const;
 
    void integrityCheck() override
    {
        OthersBase::integrityCheck();
        if (!staffLines && !customStaff) {
            MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " has neither a standard nor a custom staff definition.");
        } else if (staffLines && customStaff) {
            MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " has both a standard and a custom staff definition.");            
        }
        if (customStaff) { // guarantee ascending order of staves.
            std::sort(customStaff.value().begin(), customStaff.value().end(),
                [](const auto& a, const auto& b) { return a < b; });
        }
        if (transposition) {
            if (!transposition->chromatic && !transposition->keysig) {
                MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " has transposition with neither keysig nor chromatic transposition defined.");
            } else if (transposition->chromatic && transposition->keysig) {
                MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " has transposition with both keysig and chromatic transposition defined.");
            }
        }
        if (useNoteFont && !noteFont) {
            noteFont = std::make_shared<FontInfo>(getDocument()); // do this first to avoid unreachable code warning, since MUSX_INTEGRITY_ERROR might throw
            MUSX_INTEGRITY_ERROR("Staff or StaffStyle " + std::to_string(getCmper()) + " specifies to use a custom notehead font, but no custom font was provided.");
        }
    }
 
    bool requireAllFields() const override { return false; }
 
    constexpr static std::string_view XmlNodeName = "staffSpec"; 
    static const xml::XmlElementArray<Staff>& xmlMappingArray(); 
 
private:
    template <typename NamePositionType>
    std::shared_ptr<const NamePositioning> getNamePosition() const;
};
 
class StaffStyle : public Staff
{
protected:
    explicit StaffStyle(const std::shared_ptr<Staff>& staff)
        : Staff(*staff), masks(std::make_shared<Masks>(staff->getDocument())) {}
 
public:
    explicit StaffStyle(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : Staff(document, partId, shareMode, cmper) {}
 
    class Masks : public Base // Base inheritance needed for requireAllFields
    {
    public:
        explicit Masks(const DocumentWeakPtr& document)
            : Base(document, SCORE_PARTID, ShareMode::All) {}
 
        bool floatNoteheadFont{};       
        bool flatBeams{};               
        bool blankMeasureRest{};        
        bool noOptimize{};              
        bool notationStyle{};           
        bool defaultClef{};             
        bool staffType{};               
        bool transposition{};           
        bool blineBreak{};              
        bool rbarBreak{};               
        bool negMnumb{};                
        bool negRepeat{};               
        bool negNameScore{};            
        bool hideBarlines{};            
        bool fullName{};                
        bool abrvName{};                
        bool floatKeys{};               
        bool floatTime{};               
        bool hideRptBars{};             
        bool negKey{};                  
        bool negTime{};                 
        bool negClef{};                 
        bool hideStaff{};               
        bool noKey{};                   
        bool fullNamePos{};             
        bool abrvNamePos{};             
        bool altNotation{};             
        bool showTies{};                
        bool showDots{};                
        bool showRests{};               
        bool showStems{};               
        bool hideChords{};              
        bool hideFretboards{};          
        bool hideLyrics{};              
        bool showNameParts{};           
        bool hideStaffLines{};          
        bool redisplayLayerAccis{};     
        bool negTimeParts{};            
        bool hideKeySigsShowAccis{};    
 
        bool requireAllFields() const override { return false; }
 
        static const xml::XmlElementArray<Masks>& xmlMappingArray();    
    };
 
    std::string styleName;              
    bool addToMenu;                     
    std::shared_ptr<Masks> masks;       
 
    static std::vector<std::shared_ptr<StaffStyle>> findAllOverlappingStyles(const DocumentPtr& document,
        Cmper partId, InstCmper staffId, MeasCmper measId, Edu eduPosition);
 
    bool requireAllFields() const override { return false; }
 
    void integrityCheck() override
    {
        if (!masks) {
            // Finale allows creation of staff styles with no masks, so this is just a verbose comment
            util::Logger::log(util::Logger::LogLevel::Verbose, "StaffStyle " + styleName
                + " (" + std::to_string(getCmper()) + ") does not override anything.");
            masks = std::make_shared<Masks>(getDocument());
        }
        if (useNoteFont && !masks->floatNoteheadFont && !noteFont) {
            useNoteFont = false; // silence integrity check in Staff.
        }
        Staff::integrityCheck();
    }
 
    constexpr static std::string_view XmlNodeName = "staffStyle"; 
    static const xml::XmlElementArray<StaffStyle>& xmlMappingArray(); 
};
 
class StaffStyleAssign : public MusicRange
{
public:
    explicit StaffStyleAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : MusicRange(document, partId, shareMode, cmper, inci) {}
 
    Cmper styleId{};        
 
    std::shared_ptr<StaffStyle> getStaffStyle() const;
 
    void integrityCheck() override
    {
        MusicRange::integrityCheck();
        if (!styleId) {
            MUSX_INTEGRITY_ERROR(std::string("Staff style assignment has no staff style id:")
                + " Part " + std::to_string(getPartId())
                + " Staff " + std::to_string(getCmper())
            );
        }
    }
 
    constexpr static std::string_view XmlNodeName = "staffStyleAssign"; 
    static const xml::XmlElementArray<StaffStyleAssign>& xmlMappingArray(); 
};
 
class StaffComposite : public StaffStyle
{
private:
    explicit StaffComposite(const std::shared_ptr<Staff>& staff, Cmper requestedPartId)
        : StaffStyle(staff), m_requestedPartId(requestedPartId) {}
 
    void applyStyle(const std::shared_ptr<StaffStyle>& staffStyle);
 
    const Cmper m_requestedPartId;
 
public:
    static std::shared_ptr<StaffComposite> createCurrent(const DocumentPtr& document, Cmper partId, InstCmper staffId, MeasCmper measId, Edu eduPosition);
 
    Cmper getPartId() const final override { return m_requestedPartId; }
 
    std::shared_ptr<others::Staff> getRawStaff() const;
};
 
class StaffSystem : public OthersBase
{
public:
    explicit StaffSystem(const DocumentWeakPtr& document, Cmper staffSystemId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, staffSystemId, shareMode, cmper)
    {
    }
 
    MeasCmper startMeas{};          
    MeasCmper endMeas{};            
    double horzPercent{};           
    int ssysPercent{};              
    Efix staffHeight{};             
    Evpu top{};                     
    Evpu left{};                    
    Evpu right{};                   
    Evpu bottom{};                  
    bool noNames{};                 
    bool hasStaffScaling{};         
    bool placeEndSpaceBeforeBarline{}; 
    bool scaleVert{};               
    bool holdMargins{};             
    Evpu distanceToPrev{};          
    Evpu extraStartSystemSpace{};   
    Evpu extraEndSystemSpace{};     
 
    MeasCmper getLastMeasure() const { return endMeas - 1; }
 
    int calcNumMeasures() const { return endMeas - startMeas; }
 
    std::pair<double, double> calcMinMaxStaffSizes() const;
 
    constexpr static std::string_view XmlNodeName = "staffSystemSpec"; 
    static const xml::XmlElementArray<StaffSystem>& xmlMappingArray(); 
};
 
class SystemLock : public OthersBase
{
public:
    explicit SystemLock(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    MeasCmper endMeas{}; 
 
    constexpr static std::string_view XmlNodeName = "lockMeas"; 
    static const xml::XmlElementArray<SystemLock>& xmlMappingArray(); 
};
 
class TempoChange : public OthersBase
{
public:
    explicit TempoChange(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    int ratio{};                    
    Edu eduPosition{};              
    int unit{};                     
    bool isRelative;                
 
    int getAbsoluteTempo(NoteType noteType = NoteType::Quarter) const;
 
    constexpr static std::string_view XmlNodeName = "tempoDef"; 
    static const xml::XmlElementArray<TempoChange>& xmlMappingArray(); 
};
    
class TextBlock : public OthersBase
{
public:
    enum class TextType
    {
        Block,      
        Expression  
    };
 
    explicit TextBlock(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    // Public properties corresponding to the XML structure
    Cmper textId{};                    
    int lineSpacingPercentage{};       
    bool newPos36{};                   
    bool showShape{};                  
    bool noExpandSingleWord{};         
    bool wordWrap{};                   
    Evpu width{};                      
    Evpu height{};                     
    bool roundCorners{};               
    Efix cornerRadius{};               
    TextType textType{};               
 
    std::shared_ptr<TextsBase> getRawTextBlock() const;
 
    std::string getText(bool trimTags = false, util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii) const;
 
    static std::string getText(const DocumentPtr& document, const Cmper textId, bool trimTags = false,
        util::EnigmaString::AccidentalStyle accidentalStyle = util::EnigmaString::AccidentalStyle::Ascii);
 
    bool requireAllFields() const override { return false; }
 
    constexpr static std::string_view XmlNodeName = "textBlock"; 
    static const xml::XmlElementArray<TextBlock>& xmlMappingArray(); 
};
 
class TextExpressionDef : public OthersBase {
public:
    explicit TextExpressionDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper) {}
 
    Cmper textIdKey{};                              
    Cmper categoryId{};                             
    RehearsalMarkStyle rehearsalMarkStyle{};        
    int value{};                                    
    int auxData1{};                                 
    int playPass{};                                 
    bool hideMeasureNum;                            
    bool matchPlayback;                             
    bool useAuxData{};                              
    bool hasEnclosure{};                            
    bool breakMmRest{};                             
    bool createdByHp{};                             
    PlaybackType playbackType{};                    
    HorizontalMeasExprAlign horzMeasExprAlign{};    
    VerticalMeasExprAlign vertMeasExprAlign{};      
    HorizontalTextJustification horzExprJustification{}; 
    Evpu measXAdjust{};                             
    Evpu yAdjustEntry{};                            
    Evpu yAdjustBaseline{};                         
    bool useCategoryFonts{};                        
    bool useCategoryPos{};                          
    std::string description;                        
 
    std::shared_ptr<TextBlock> getTextBlock() const;
 
    std::shared_ptr<Enclosure> getEnclosure() const;
 
    constexpr static std::string_view XmlNodeName = "textExprDef"; 
    static const xml::XmlElementArray<TextExpressionDef>& xmlMappingArray(); 
};
 
class TextExpressionEnclosure : public Enclosure {
public:
    using Enclosure::Enclosure;
 
    constexpr static std::string_view XmlNodeName = "textExpressionEnclosure"; 
    static const xml::XmlElementArray<TextExpressionEnclosure>& xmlMappingArray(); 
};
 
class TextRepeatAssign : public OthersBase
{
public:
    explicit TextRepeatAssign(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper, Inci inci)
        : OthersBase(document, partId, shareMode, cmper, inci)
    {
    }
 
    // Public properties corresponding to the XML structure
    Evpu horzPos{};                 
    int passNumber{};               
    int targetValue{};              
    Cmper textRepeatId{};           
    Evpu vertPos{};                 
    bool individualPlacement{};     
    bool topStaffOnly{};            
    bool resetOnAction{};           
    bool jumpOnMultiplePasses{};    
    RepeatActionType jumpAction{};  
    bool autoUpdate{};              
    RepeatTriggerType trigger{};    
    bool jumpIfIgnoring{};          
    Cmper staffList{};              
 
    constexpr static std::string_view XmlNodeName = "textRepeatAssign"; 
    static const xml::XmlElementArray<TextRepeatAssign>& xmlMappingArray(); 
};
    
class TextRepeatDef : public OthersBase
{
public:
    enum class PoundReplaceOption
    {
        Passes,             
        RepeatID,           
        MeasureNumber       
    };
 
    explicit TextRepeatDef(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper), font(new FontInfo(document))
    {
    }
 
    // Public properties corresponding to the XML structure
    std::shared_ptr<FontInfo> font;                 
    bool hasEnclosure{};                            
    bool useThisFont{};                             
    PoundReplaceOption poundReplace{};              
    HorizontalTextJustification justification{};    
    std::vector<int> passList;                      
 
    constexpr static std::string_view XmlNodeName = "textRepeatDef"; 
    static const xml::XmlElementArray<TextRepeatDef>& xmlMappingArray(); 
};
 
class TextRepeatEnclosure : public Enclosure
{
public:
    using Enclosure::Enclosure;
 
    constexpr static std::string_view XmlNodeName = "textRepeatEnclosure"; 
    static const xml::XmlElementArray<TextRepeatEnclosure>& xmlMappingArray(); 
};
 
class TextRepeatText : public OthersBase
{
public:
    explicit TextRepeatText(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    std::string text; 
 
    constexpr static std::string_view XmlNodeName = "textRepeatText"; 
    static const xml::XmlElementArray<TextRepeatText>& xmlMappingArray(); 
};
    
class TimeCompositeLower : public OthersBase
{
public:
    explicit TimeCompositeLower(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    class CompositeItem
    {
    public:
        Edu unit{};             
        bool startGroup{};      
 
        static const xml::XmlElementArray<CompositeItem>& xmlMappingArray(); 
    };
 
    std::vector<std::shared_ptr<CompositeItem>> items;  
 
    constexpr static std::string_view XmlNodeName = "timeLower"; 
    static const xml::XmlElementArray<TimeCompositeLower>& xmlMappingArray(); 
};
 
class TimeCompositeUpper : public OthersBase
{
public:
    explicit TimeCompositeUpper(const DocumentWeakPtr& document, Cmper partId, ShareMode shareMode, Cmper cmper)
        : OthersBase(document, partId, shareMode, cmper)
    {
    }
 
    class CompositeItem
    {
    public:
        Edu beats{};                
        util::Fraction fraction{};  
        bool startGroup{};          
 
        util::Fraction fullFraction() const { return fraction + beats; }
 
        static const xml::XmlElementArray<CompositeItem>& xmlMappingArray(); 
    };
 
    std::vector<std::shared_ptr<CompositeItem>> items;  
 
    constexpr static std::string_view XmlNodeName = "timeUpper"; 
    static const xml::XmlElementArray<TimeCompositeUpper>& xmlMappingArray(); 
};
 
class TonalCenterFlats : public OthersArray<unsigned, 8>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "fstKeyFlats"; 
    static const xml::XmlElementArray<TonalCenterFlats>& xmlMappingArray(); 
};
 
class TonalCenterSharps : public OthersArray<unsigned, 8>
{
    std::string_view xmlTag() const override { return XmlNodeName; }
 
public:
    using OthersArray::OthersArray;
 
    constexpr static std::string_view XmlNodeName = "fstKeySharps"; 
    static const xml::XmlElementArray<TonalCenterSharps>& xmlMappingArray(); 
};
 
} // namespace others
} // namespace dom
} // namespace musx