Options.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 <optional>
#include <stdexcept>
 
#include "music_theory/music_theory.hpp"
#include "BaseClasses.h"
#include "CommonClasses.h"
 // do not add other dom class dependencies. Use Implementations.h for implementations that need total class access.
 
namespace musx {
namespace dom {
 
namespace others {
class Staff;
} // namespace others
 
namespace options {
 
class AccidentalOptions : public OptionsBase {
public:
    explicit AccidentalOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    int minOverlap{};                       
    Evpu multiCharSpace{};                  
    bool crossLayerPositioning{};           
    Evpu startMeasureSepar{};               
    Evpu acciNoteSpace{};                   
    Evpu acciAcciSpace{};                   
 
    constexpr static std::string_view XmlNodeName = "accidentalOptions"; 
    static const xml::XmlElementArray<AccidentalOptions>& xmlMappingArray(); 
};
 
class AlternateNotationOptions : public OptionsBase {
public:
    explicit AlternateNotationOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    Evpu halfSlashLift{};       
    Evpu wholeSlashLift{};      
    Evpu dWholeSlashLift{};     
    Evpu halfSlashStemLift{};   
    Evpu quartSlashStemLift{};  
    Evpu quartSlashLift{};      
    Evpu twoMeasNumLift{};      
 
    constexpr static std::string_view XmlNodeName = "alternateNotationOptions"; 
    static const xml::XmlElementArray<AlternateNotationOptions>& xmlMappingArray(); 
};
 
class AugmentationDotOptions : public OptionsBase {
public:
    explicit AugmentationDotOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    Evpu dotUpFlagOffset{};     
    Evpu dotOffset{};           
    bool adjMultipleVoices{};   
    Evpu dotNoteOffset{};      
    Evpu dotLift{};             
    bool useLegacyFlippedStemPositioning{};
 
    constexpr static std::string_view XmlNodeName = "augmentationDotOptions"; 
    static const xml::XmlElementArray<AugmentationDotOptions>& xmlMappingArray(); 
};
 
class BarlineOptions : public OptionsBase {
public:
    explicit BarlineOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    bool drawBarlines{};                    
    bool drawCloseSystemBarline{};          
    bool drawCloseFinalBarline{};           
    bool drawFinalBarlineOnLastMeas{};      
    bool drawDoubleBarlineBeforeKeyChanges{}; 
    bool drawLeftBarlineSingleStaff{};      
    bool drawLeftBarlineMultipleStaves{};   
    bool leftBarlineUsePrevStyle{};         
    Efix thickBarlineWidth{};               
    Efix barlineWidth{};                    
    Efix doubleBarlineSpace{};              
    Efix finalBarlineSpace{};               
    Evpu barlineDashOn{};                   
    Evpu barlineDashOff{};                  
 
    constexpr static std::string_view XmlNodeName = "barlineOptions"; 
    static const xml::XmlElementArray<BarlineOptions>& xmlMappingArray(); 
};
 
class BeamOptions : public OptionsBase {
public:
    explicit BeamOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    enum class FlattenStyle
    {
        OnEndNotes,         
        OnStandardNote,     
        OnExtremeNote,      
        AlwaysFlat          
    };
 
    Evpu beamStubLength{};                   
    Evpu maxSlope{};                         
    Evpu beamSepar{};                        
    Evpu maxFromMiddle{};                    
    FlattenStyle beamingStyle{};             
    bool extendBeamsOverRests{};             
    bool incRestsInFourGroups{};             
    bool beamFourEighthsInCommonTime{};      
    bool beamThreeEighthsInCommonTime{};     
    bool dispHalfStemsOnRests{};             
    bool oldFinaleRestBeams{};               
    bool spanSpace{};                        
    bool extendSecBeamsOverRests{};          
    Efix beamWidth{};                        
 
    constexpr static std::string_view XmlNodeName = "beamOptions"; 
    static const xml::XmlElementArray<BeamOptions>& xmlMappingArray(); 
};
 
class ChordOptions : public OptionsBase {
public:
    explicit ChordOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    enum class ChordAlignment
    {
        Left,                       
        Center
    };
 
    enum class ChordStyle
    {
        Standard,                   
        European,
        German,
        Roman,
        NashvilleA,
        NashvilleB,
        Solfeggio,                  // xml value is "solfeggio"
        Scandinavian
    };
 
    double fretPercent{};            
    double chordPercent{};           
    Evpu chordSharpLift{};           
    Evpu chordFlatLift{};            
    Evpu chordNaturalLift{};         
    bool showFretboards{};           
    Cmper fretStyleId{};             
    Cmper fretInstId{};              
    bool multiFretItemsPerStr{};     
    bool useFretboardFont{};         
    bool italicizeCapoChords{};      
    ChordAlignment chordAlignment{}; 
    ChordStyle chordStyle{};         
    bool useSimpleChordSpelling{};   
    bool chordPlayback{};            
 
    constexpr static std::string_view XmlNodeName = "chordOptions"; 
    static const xml::XmlElementArray<ChordOptions>& xmlMappingArray(); 
};
 
class ClefOptions : public OptionsBase {
public:
    using ClefInfo = std::pair<music_theory::ClefType, int>;
 
    explicit ClefOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    class ClefDef : public ContainedClassBase
    {
    public:
        using ContainedClassBase::ContainedClassBase;
 
        int middleCPos{};               
        char32_t clefChar{};            
        int staffPosition{};             
        Efix baselineAdjust{};          
        Cmper shapeId{};                
        bool isShape{};                 
        bool scaleToStaffHeight{};      
        bool useOwnFont{};              
        std::shared_ptr<FontInfo> font; 
 
        bool isBlank() const;
 
        ClefInfo calcInfo(const MusxInstance<others::Staff>& currStaff = nullptr) const;
 
 
        MusxInstance<FontInfo> calcFont() const;
 
        static const xml::XmlElementArray<ClefDef>& xmlMappingArray(); 
    };
 
    ClefIndex defaultClef{};            
    int clefChangePercent{};            
    Evpu clefChangeOffset{};            
    Evpu clefFrontSepar{};              
    Evpu clefBackSepar{};               
    bool showClefFirstSystemOnly{};     
    Evpu clefKeySepar{};                
    Evpu clefTimeSepar{};               
    bool cautionaryClefChanges{};       
 
    std::vector<MusxInstance<ClefDef>> clefDefs;
 
    MusxInstance<ClefDef> getClefDef(ClefIndex clefIndex) const
    {
        MUSX_ASSERT_IF(clefIndex >= clefDefs.size()) {
            throw std::out_of_range("Clef index " + std::to_string(clefIndex) + " does not exist in document.");
        }
        return clefDefs[clefIndex];
    }
 
    constexpr static std::string_view XmlNodeName = "clefOptions";
    static const xml::XmlElementArray<ClefOptions>& xmlMappingArray(); 
};
 
class FlagOptions : public OptionsBase {
public:
    explicit FlagOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    bool straightFlags{};                   
    Efix upHAdj{};                          
    Efix downHAdj{};                        
    Efix upHAdj2{};                         
    Efix downHAdj2{};                       
    Efix upHAdj16{};                        
    Efix downHAdj16{};                      
    Efix eighthFlagHoist{};                 
    Efix stUpHAdj{};                        
    Efix stDownHAdj{};                      
    Efix upVAdj{};                          
    Efix downVAdj{};                        
    Efix upVAdj2{};                         
    Efix downVAdj2{};                       
    Efix upVAdj16{};                        
    Efix downVAdj16{};                      
    Efix stUpVAdj{};                        
    Efix stDownVAdj{};                      
    Evpu flagSpacing{};                     
    Evpu secondaryGroupAdj{};               
 
    constexpr static std::string_view XmlNodeName = "flagOptions"; 
    static const xml::XmlElementArray<FlagOptions>& xmlMappingArray(); 
};
 
class FontOptions : public OptionsBase {
public:
    explicit FontOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    enum class FontType
    {
        Music,             
        Key,               
        Clef,              
        Time,              
        Chord,             
        ChordAcci,         
        Ending,            
        Tuplet,            
        TextBlock,         
        LyricVerse,        
        LyricChorus,       
        LyricSection,      
        MultiMeasRest,     
        Tablature,         
        ChordSuffix,       
        Expression,        
        Repeat,            
        Fretboard,         
        Flags,             
        Accis,             
        AltNotSlash,       
        AltNotNum,         
        Rests,             
        ReptDots,          
        Noteheads,         
        AugDots,           
        TimePlus,          
        Articulation,      
        Percussion,        
        SmartShape8va,     
        MeasNumb,          
        StaffNames,        
        AbbrvStaffNames,   
        GroupNames,        
        SmartShape8vb,     
        SmartShape15ma,    
        SmartShape15mb,    
        SmartShapeTrill,   
        SmartShapeWiggle,  
        AbbrvGroupNames,   
        BendCurveFull,     
        BendCurveWhole,    
        BendCurveFrac,     
        TimeParts,         
        TimePlusParts      
    };
 
    std::unordered_map<FontType, MusxInstance<FontInfo>> fontOptions;
 
    MusxInstance<FontInfo> getFontInfoOrNull(FontType type) const;
 
    static MusxInstance<FontInfo> getFontInfoOrNull(const DocumentPtr& document, FontType type);
 
    MusxInstance<FontInfo> getFontInfo(FontType type) const;
 
    static MusxInstance<FontInfo> getFontInfo(const DocumentPtr& document, FontType type);
 
    constexpr static std::string_view XmlNodeName = "fontOptions";
    static const xml::XmlElementArray<FontOptions>& xmlMappingArray(); 
};
 
class GraceNoteOptions : public OptionsBase {
public:
    explicit GraceNoteOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    int tabGracePerc{};              
    int gracePerc{};                 
    Edu playbackDuration{};          
    Evpu entryOffset{};              
    bool slashFlaggedGraceNotes{};   
    Efix graceSlashWidth{};          
 
    constexpr static std::string_view XmlNodeName = "graceNoteOptions"; 
    static const xml::XmlElementArray<GraceNoteOptions>& xmlMappingArray(); 
};
 
class KeySignatureOptions : public OptionsBase {
public:
    explicit KeySignatureOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    bool doKeyCancel{};                        
    bool doCStart{};                           
    bool redisplayOnModeChange{};              
    Evpu keyFront{};                           
    Evpu keyMid{};                             
    Evpu keyBack{};                            
    Evpu acciAdd{};                            
    bool showKeyFirstSystemOnly{};             
    Evpu keyTimeSepar{};                       
    bool simplifyKeyHoldOctave{};              
    bool cautionaryKeyChanges{};               
    bool doKeyCancelBetweenSharpsFlats{};      
 
    constexpr static std::string_view XmlNodeName = "keySignatureOptions"; 
    static const xml::XmlElementArray<KeySignatureOptions>& xmlMappingArray(); 
};
 
class LineCurveOptions : public OptionsBase {
public:
    explicit LineCurveOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    int bezierStep{};                    
    Efix enclosureWidth{};               
    bool enclosureRoundCorners{};        
    Efix enclosureCornerRadius{};        
    Efix staffLineWidth{};               
    Efix legerLineWidth{};               
    Evpu legerFrontLength{};             
    Evpu legerBackLength{};              
    Evpu restLegerFrontLength{};         
    Evpu restLegerBackLength{};          
    double psUlDepth{};                  
    double psUlWidth{};                  
    EvpuFloat pathSlurTipWidth{};        
 
    constexpr static std::string_view XmlNodeName = "lineCurveOptions"; 
    static const xml::XmlElementArray<LineCurveOptions>& xmlMappingArray(); 
};
 
class LyricOptions : public OptionsBase {
public:
    explicit LyricOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    enum class SmartHyphenStart {
        Always,     
        Sometimes,  
        Never       
    };
 
    enum class AutoNumberingAlign {
        None,       
        Align       
    };
 
    enum class WordExtConnectIndex {
        LyricRightBottom,
        HeadRightLyrBaseline,
        SystemLeft,
        SystemRight,
        DotRightLyrBaseline,
        DurationLyrBaseline
    };
 
    enum class WordExtConnectStyleType {
        DefaultStart,
        DefaultEnd,
        SystemStart,
        SystemEnd,
        DottedEnd,
        DurationEnd,
        OneEntryEnd,
        ZeroLengthEnd,
        ZeroOffset
    };
 
    enum class SyllablePosStyleType {
        Default,        
        WordExt,        
        First,          
        SystemStart     
    };
 
    char32_t hyphenChar{};                         
    Evpu maxHyphenSeparation{};                    
    Evpu wordExtVertOffset{};                      
    Evpu wordExtHorzOffset{};                      
    bool useSmartWordExtensions{};                 
    bool useAltHyphenFont{};                       
    std::shared_ptr<FontInfo> altHyphenFont;       
    bool useSmartHyphens{};                        
    SmartHyphenStart smartHyphenStart{};           
    bool wordExtNeedUnderscore{};                  
    Evpu wordExtMinLength{};                       
    bool wordExtOffsetToNotehead{};                
    bool lyricUseEdgePunctuation{};                
    std::string lyricPunctuationToIgnore;          
    bool showAutoNumbersOnVerses{};                
    bool showAutoNumbersOnChoruses{};              
    bool showAutoNumbersOnSections{};              
    AutoNumberingAlign lyricAutoNumType{};         
    Efix wordExtLineWidth{};                       
 
    struct SyllablePosStyle {
        AlignJustify align{};                      
        AlignJustify justify{};                    
        bool on{};                                 
 
        static const xml::XmlElementArray<SyllablePosStyle>& xmlMappingArray(); 
    };
 
    struct WordExtConnectStyle {
        WordExtConnectIndex connectIndex{};        
        Evpu xOffset{};                            
        Evpu yOffset{};                            
 
        static const xml::XmlElementArray<WordExtConnectStyle>& xmlMappingArray(); 
    };
 
    std::unordered_map<SyllablePosStyleType, std::shared_ptr<SyllablePosStyle>> syllablePosStyles;     
    std::unordered_map<WordExtConnectStyleType, std::shared_ptr<WordExtConnectStyle>> wordExtConnectStyles; 
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OptionsBase::integrityCheck(ptrToThis);
        if (!altHyphenFont) {
            altHyphenFont = std::make_shared<FontInfo>(getDocument());
        }
        if (lyricPunctuationToIgnore.empty()) {
            lyricPunctuationToIgnore = ",.?!;:'\"“”‘’";  // this default punctuation set is taken from Document Without Libraries
        }
    }
 
    constexpr static std::string_view XmlNodeName = "lyricOptions"; 
    static const xml::XmlElementArray<LyricOptions>& xmlMappingArray(); 
};
 
class MiscOptions : public OptionsBase {
public:
    explicit MiscOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    bool showRepeatsForParts{};             
    Edu pickupValue{};                      
    bool keepWrittenOctaveInConcertPitch{}; 
    bool showActiveLayerOnly{};             
    bool consolidateRestsAcrossLayers{};    
    Evpu shapeDesignerDashLength{};         
    Evpu shapeDesignerDashSpace{};          
    Evpu restWidthAdjust{};                 
    Evpu dblWholeVertAdjust{};              
    bool alignMeasureNumbersWithBarlines{}; 
 
    constexpr static std::string_view XmlNodeName = "miscOptions"; 
    static const xml::XmlElementArray<MiscOptions>& xmlMappingArray(); 
};
 
class MultimeasureRestOptions : public OptionsBase {
public:
    explicit MultimeasureRestOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    Evpu measWidth{};            
    Evpu numAdjY{};              
    Cmper shapeDef{};            
    int numStart{};              
    int useSymsThreshold{};      
    Evpu symSpacing{};           
    Evpu numAdjX{};              
    Evpu startAdjust{};          
    Evpu endAdjust{};            
    bool useSymbols{};           
    bool noHorizontalStretch{};  
    bool autoUpdateMmRests{};    
 
    constexpr static std::string_view XmlNodeName = "multimeasureRestOptions"; 
    static const xml::XmlElementArray<MultimeasureRestOptions>& xmlMappingArray(); 
};
 
class MusicSpacingOptions : public OptionsBase {
public:
    explicit MusicSpacingOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    enum class ColUnisonsChoice
    {
        None,           
        DiffNoteheads,  
        All             
    };
 
    enum class GraceNoteSpacing
    {
        ResetToEntry,   
        Automatic,      
        KeepCurrent     
    };
 
    enum class ManualPositioning
    {
        Clear,          
        Ignore,         
        Incorporate     
    };
 
    // layoutType appears to be cruft left over from legacy Finale. The only value seems to be "entry".
    Evpu minWidth{};                        
    Evpu maxWidth{};                        
    Evpu minDistance{};                     
    Evpu minDistTiedNotes{};                
    bool avoidColNotes{};                   
    bool avoidColLyrics{};                  
    bool avoidColChords{};                  
    bool avoidColArtics{};                  
    bool avoidColClefs{};                   
    bool avoidColSeconds{};                 
    bool avoidColStems{};                   
    ColUnisonsChoice avoidColUnisons{};     
    bool avoidColLedgers{};                 
    ManualPositioning manualPositioning{};  
    bool ignoreHidden{};                    
    bool interpolateAllotments{};           
    bool usePrinter{};                      
    bool useAllottmentTables{};             
    Edu referenceDuration{};                
    Evpu referenceWidth{};                  
    double scalingFactor{};                 
    Evpu defaultAllotment{};                
    Evpu minDistGrace{};                    
    GraceNoteSpacing graceNoteSpacing{};    
    Evpu musFront{};                        
    Evpu musBack{};                         
 
    constexpr static std::string_view XmlNodeName = "musicSpacingOptions"; 
    static const xml::XmlElementArray<MusicSpacingOptions>& xmlMappingArray(); 
};
 
class MusicSymbolOptions : public OptionsBase
{
public:
    explicit MusicSymbolOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode)
    {
    }
 
    char32_t noteheadQuarter{};         
    char32_t noteheadHalf{};            
    char32_t noteheadWhole{};           
    char32_t noteheadDblWhole{};        
    char32_t natural{};                 
    char32_t flat{};                    
    char32_t sharp{};                   
    char32_t dblFlat{};                 
    char32_t dblSharp{};                
    char32_t parenNatural{};            
    char32_t parenFlat{};               
    char32_t parenSharp{};              
    char32_t parenDblFlat{};            
    char32_t parenDblSharp{};           
    char32_t chordNatural{};            
    char32_t chordFlat{};               
    char32_t chordSharp{};              
    char32_t chordDblFlat{};            
    char32_t chordDblSharp{};           
    char32_t keySigNatural{};           
    char32_t keySigFlat{};              
    char32_t keySigSharp{};             
    char32_t keySigDblFlat{};           
    char32_t keySigDblSharp{};          
    char32_t restLonga{};               
    char32_t restDblWhole{};            
    char32_t restWhole{};               
    char32_t restHalf{};                
    char32_t restQuarter{};             
    char32_t restEighth{};              
    char32_t rest16th{};                
    char32_t rest32nd{};                
    char32_t rest64th{};                
    char32_t rest128th{};               
    char32_t restDefMeas{};             
    char32_t oneBarRepeat{};            
    char32_t twoBarRepeat{};            
    char32_t slashBar{};                
    char32_t quarterSlash{};            
    char32_t halfSlash{};               
    char32_t wholeSlash{};              
    char32_t dblWholeSlash{};           
    char32_t timeSigPlus{};             
    char32_t timeSigPlusParts{};        
    char32_t timeSigAbrvCommon{};       
    char32_t timeSigAbrvCut{};          
    char32_t timeSigAbrvCommonParts{};  
    char32_t timeSigAbrvCutParts{};     
    char32_t augDot{};                  
    char32_t forwardRepeatDot{};        
    char32_t backRepeatDot{};           
    char32_t eightVaUp{};               
    char32_t eightVbDown{};             
    char32_t fifteenMaUp{};             
    char32_t fifteenMbDown{};           
    char32_t trillChar{};               
    char32_t wiggleChar{};              
    char32_t flagUp{};                  
    char32_t flagDown{};                
    char32_t flag16Up{};                
    char32_t flag16Down{};              
    char32_t flag2Up{};                 
    char32_t flag2Down{};               
    char32_t flagStraightUp{};          
    char32_t flagStraightDown{};        
 
    constexpr static std::string_view XmlNodeName = "musicSymbolOptions"; 
    static const xml::XmlElementArray<MusicSymbolOptions>& xmlMappingArray(); 
};
 
class NoteRestOptions : public OptionsBase {
public:
    explicit NoteRestOptions(const DocumentPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    class NoteColor {
    public:
        uint16_t red{};         
        uint16_t green{};       
        uint16_t blue{};        
 
        static const xml::XmlElementArray<NoteColor>& xmlMappingArray();
    };
 
    bool doShapeNotes{};            
    bool doCrossStaffNotes{};       
    Evpu drop8thRest{};             
    Evpu drop16thRest{};            
    Evpu drop32ndRest{};            
    Evpu drop64thRest{};            
    Evpu drop128thRest{};           
    bool scaleManualPositioning{};  
    bool drawOutline{};             
    std::vector<std::shared_ptr<NoteColor>> noteColors{}; 
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OptionsBase::integrityCheck(ptrToThis);
        const size_t currentSize = noteColors.size();
        if (currentSize < music_theory::STANDARD_12EDO_STEPS) {
            for (size_t x = currentSize; x < music_theory::STANDARD_12EDO_STEPS; x++) {
                noteColors.emplace_back(std::make_shared<NoteColor>());  // default values are all zero, so this is setting missing values to black color
            }
            MUSX_INTEGRITY_ERROR("Only " + std::to_string(currentSize) + " note colors provided. "
                + std::to_string(music_theory::STANDARD_12EDO_STEPS) + " were expected.");
        } else if (currentSize > music_theory::STANDARD_12EDO_STEPS) {
            noteColors.resize(music_theory::STANDARD_12EDO_STEPS);
            MUSX_INTEGRITY_ERROR(std::to_string(currentSize) + " note colors provided. Only "
                + std::to_string(music_theory::STANDARD_12EDO_STEPS) + " were expected.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "noteRestOptions";      
    static const xml::XmlElementArray<NoteRestOptions>& xmlMappingArray();  
};
 
class PageFormatOptions : public OptionsBase {
public:
    enum class AdjustPageScope
    {
        Current,        
        All,            
        LeftOrRight,    
        PageRange       
    };
 
    class PageFormat
    {
    public:
        Evpu pageHeight{};               
        Evpu pageWidth{};                
        int pagePercent{};               
        int sysPercent{};                
        Evpu16ths rawStaffHeight{};      
        Evpu leftPageMarginTop{};        
        Evpu leftPageMarginLeft{};       
        Evpu leftPageMarginBottom{};     
        Evpu leftPageMarginRight{};      
        Evpu rightPageMarginTop{};       
        Evpu rightPageMarginLeft{};      
        Evpu rightPageMarginBottom{};    
        Evpu rightPageMarginRight{};     
        Evpu sysMarginTop{};             
        Evpu sysMarginLeft{};            
        Evpu sysMarginBottom{};          
        Evpu sysMarginRight{};           
        Evpu sysDistanceBetween{};       
        Evpu firstPageMarginTop{};       
        Evpu firstSysMarginTop{};        
        Evpu firstSysMarginLeft{};       
        Evpu firstSysMarginDistance{};   
        bool facingPages{};              
        bool differentFirstSysMargin{};  
        bool differentFirstPageMargin{}; 
 
        util::Fraction calcPageScaling() const { return util::Fraction::fromPercent(pagePercent); }
 
        util::Fraction calcSystemScaling() const
        { return util::Fraction::fromPercent(sysPercent) * util::Fraction(rawStaffHeight, int(EVPU_PER_SPACE) * 4 * 16); }
 
        util::Fraction calcCombinedSystemScaling() const { return calcPageScaling() * calcSystemScaling(); }
 
        PageFormat() = default;
 
        static const xml::XmlElementArray<PageFormat>& xmlMappingArray(); 
    };
 
    // Properties
    AdjustPageScope adjustPageScope{};    
    std::shared_ptr<PageFormat> pageFormatScore; 
    std::shared_ptr<PageFormat> pageFormatParts; 
    bool avoidSystemMarginCollisions{};   
 
    MusxInstance<PageFormat> calcPageFormatForPart(Cmper partId) const;
 
    explicit PageFormatOptions(const DocumentPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    constexpr static std::string_view XmlNodeName = "pageFormatOptions";
    static const xml::XmlElementArray<PageFormatOptions>& xmlMappingArray(); 
};
 
class PianoBraceBracketOptions : public OptionsBase {
public:
    explicit PianoBraceBracketOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    Evpu defBracketPos{};                   
    EvpuFloat centerThickness{};            
    EvpuFloat tipThickness{};               
    EvpuFloat outerBodyV{};                 
    EvpuFloat innerTipV{};                  
    EvpuFloat innerBodyV{};                 
    EvpuFloat outerTipH{};                  
    EvpuFloat outerTipV{};                  
    EvpuFloat outerBodyH{};                 
    EvpuFloat width{};                      
    EvpuFloat innerTipH{};                  
    EvpuFloat innerBodyH{};                 
 
    constexpr static std::string_view XmlNodeName = "pianoBraceBracketOptions"; 
    static const xml::XmlElementArray<PianoBraceBracketOptions>& xmlMappingArray(); 
};
 
class RepeatOptions : public OptionsBase {
public:
    explicit RepeatOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    enum class WingStyle
    {
        None,
        Curved,
        SingleLine,
        DoubleLine
    };
 
    enum class BackToBackStyle
    {
        Thin,
        Mixed,
        Thick
    };
 
    int maxPasses{};                       
    bool addPeriod{};                      
    Efix thickLineWidth{};                 
    Efix thinLineWidth{};                  
    Efix lineSpace{};                      
    BackToBackStyle backToBackStyle{};     
    Evpu forwardDotHPos{};                 
    Evpu backwardDotHPos{};                
    Evpu upperDotVPos{};                   
    Evpu lowerDotVPos{};                   
    WingStyle wingStyle{};                 
    Evpu afterClefSpace{};                 
    Evpu afterKeySpace{};                  
    Evpu afterTimeSpace{};                 
    Evpu bracketHeight{};                  
    Evpu bracketHookLen{};                 
    Efix bracketLineWidth{};               
    Evpu bracketStartInset{};              
    Evpu bracketEndInset{};                
    Evpu bracketTextHPos{};                
    Evpu bracketTextVPos{};                
    Evpu bracketEndHookLen{};              
    bool bracketEndAnchorThinLine{};       
    bool showOnTopStaffOnly{};             
    Cmper showOnStaffListNumber{};         
 
    constexpr static std::string_view XmlNodeName = "repeatOptions"; 
    static const xml::XmlElementArray<RepeatOptions>& xmlMappingArray(); 
};
 
class SmartShapeOptions : public OptionsBase {
public:
    explicit SmartShapeOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    enum class ConnectionIndex
    {
        HeadLeftTop,
        HeadRightTop,
        HeadRightBottom,
        HeadLeftBottom,
        StemLeftTop,
        StemRightTop,
        StemRightBottom,
        StemLeftBottom,
        NoteLeftTop,
        NoteRightTop,
        NoteRightBottom,
        NoteLeftBottom,
        NoteLeftCenter,
        NoteRightCenter
    };
 
    enum class SlurConnectStyleType
    {
        OverNoteStart,
        OverNoteEnd,
        OverStemStart,
        OverStemEnd,
        UnderNoteStart,
        UnderNoteEnd,
        UnderStemStart,
        UnderStemEnd,
        OverMixStemStart,
        OverMixStemEnd,
        OverStemGrace,
        OverStemPrincipal,
        UnderStemGrace,
        UnderStemPrincipal,
        UnderNoteGrace,
        UnderStemNotePrincipal,
        OverNoteGrace,
        OverStemNotePrincipal,
        OverBeamStart,
        OverBeamEnd,
        UnderBeamStart,
        UnderBeamEnd,
        OverMixFlagStart,
        OverFlagStart,
        UnderFlagStart,
        OverTabNumStart,
        OverTabNumEnd,
        UnderTabNumStart,
        UnderTabNumEnd
    };
 
    enum class TabSlideConnectStyleType
    {
        DiffLevelPitchUpLineStart,
        DiffLevelPitchUpLineEnd,
        DiffLevelPitchUpSpaceStart,
        DiffLevelPitchUpSpaceEnd,
        DiffLevelPitchDownLineStart,
        DiffLevelPitchDownLineEnd,
        DiffLevelPitchDownSpaceStart,
        DiffLevelPitchDownSpaceEnd,
        SameLevelPitchUpLineStart,
        SameLevelPitchUpLineEnd,
        SameLevelPitchUpSpaceStart,
        SameLevelPitchUpSpaceEnd,
        SameLevelPitchDownLineStart,
        SameLevelPitchDownLineEnd,
        SameLevelPitchDownSpaceStart,
        SameLevelPitchDownSpaceEnd,
        SameLevelPitchSameStart,
        SameLevelPitchSameEnd
    };
 
    enum class GlissandoConnectStyleType
    {
        DefaultStart,
        DefaultEnd
    };
 
    enum class BendCurveConnectStyleType
    {
        NoteStart,
        StaffEnd,
        StaffStart,
        NoteEnd,
        StaffToTopLineStart,
        StaffFromTopLineEnd,
        StaffEndOffset,
        StaffFromTopEndOffset
    };
 
    enum class SlurControlStyleType
    {
        ShortSpan,
        MediumSpan,
        LongSpan,
        ExtraLongSpan
    };
 
    Evpu shortHairpinOpeningWidth{};         
    Evpu crescHeight{};                      
    Evpu maximumShortHairpinLength{};       
    Efix crescLineWidth{};                  
    Evpu hookLength{};                       
    Efix smartLineWidth{};                  
    bool showOctavaAsText{};                   
    Evpu smartDashOn{};                      
    Evpu smartDashOff{};                     
    bool crescHorizontal{};                    
    ShapeDirection direction{};              
    Evpu slurThicknessCp1X{};                
    Evpu slurThicknessCp1Y{};                
    Evpu slurThicknessCp2X{};                
    Evpu slurThicknessCp2Y{};                
    bool slurAvoidAccidentals{};               
    Evpu slurAvoidStaffLinesAmt{};            
    Efix maxSlurStretch{};                 
    Efix maxSlurLift{};                    
    int slurSymmetry{};                   
    bool useEngraverSlurs{};                   
    Evpu slurLeftBreakHorzAdj{};              
    Evpu slurRightBreakHorzAdj{};            
    Evpu slurBreakVertAdj{};                 
    bool slurAvoidStaffLines{};             
    Evpu slurPadding{};                      
    Efix maxSlurAngle{};                   
    Evpu slurAcciPadding{};                  
    bool slurDoStretchFirst{};              
    bool slurStretchByPercent{};            
    int maxSlurStretchPercent{};          
    Evpu articAvoidSlurAmt{};                 
    Cmper ssLineStyleCmpCustom{};              
    Cmper ssLineStyleCmpGlissando{};           
    Cmper ssLineStyleCmpTabSlide{};            
    Cmper ssLineStyleCmpTabBendCurve{};        
    EvpuFloat smartSlurTipWidth{};            
    bool guitarBendUseParens{};                
    bool guitarBendHideBendTo{};               
    bool guitarBendGenText{};                  
    bool guitarBendUseFull{};                  
 
    struct ConnectionStyle {
        ConnectionIndex connectIndex{}; 
        Evpu xOffset{};                
        Evpu yOffset{};                
 
        static const xml::XmlElementArray<ConnectionStyle>& xmlMappingArray(); 
    };
 
    struct ControlStyle {
        Efix span{};                  
        Efix inset{};                 
        Evpu height{};               
 
        static const xml::XmlElementArray<ControlStyle>& xmlMappingArray(); 
    };
 
    std::unordered_map<SlurConnectStyleType, std::shared_ptr<ConnectionStyle>> slurConnectStyles; 
    std::unordered_map<SlurControlStyleType, std::shared_ptr<ControlStyle>> slurControlStyles; 
    std::unordered_map<TabSlideConnectStyleType, std::shared_ptr<ConnectionStyle>> tabSlideConnectStyles; 
    std::unordered_map<GlissandoConnectStyleType, std::shared_ptr<ConnectionStyle>> glissandoConnectStyles; 
    std::unordered_map<BendCurveConnectStyleType, std::shared_ptr<ConnectionStyle>> bendCurveConnectStyles; 
 
    constexpr static std::string_view XmlNodeName = "smartShapeOptions"; 
    static const xml::XmlElementArray<SmartShapeOptions>& xmlMappingArray(); 
};
 
class StaffOptions : public OptionsBase {
using NamePositioning = others::NamePositioning;
 
public:
    explicit StaffOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    Evpu staffSeparation{};         
    Evpu staffSeparIncr{};          
    bool autoAdjustStaffSepar{};    
 
    std::shared_ptr<NamePositioning> namePos;           
    std::shared_ptr<NamePositioning> namePosAbbrv;      
    std::shared_ptr<NamePositioning> groupNameFullPos;  
    std::shared_ptr<NamePositioning> groupNameAbbrvPos; 
 
    constexpr static std::string_view XmlNodeName = "staffOptions"; 
    static const xml::XmlElementArray<StaffOptions>& xmlMappingArray(); 
};
 
class StemOptions : public OptionsBase {
public:
    explicit StemOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode)
    {
    }
 
    class StemConnection
    {
    public:
        Cmper fontId{};       
        char32_t symbol{};    
        Efix upStemVert{};    
        Efix downStemVert{};  
        Efix upStemHorz{};    
        Efix downStemHorz{};  
 
        static const xml::XmlElementArray<StemConnection>& xmlMappingArray(); 
    };
 
    Evpu halfStemLength{};     
    Evpu stemLength{};         
    Evpu shortStemLength{};    
    Evpu revStemAdj{};         
    bool noReverseStems{};     
    Efix stemWidth{};          
    Efix stemOffset{};         
    bool useStemConnections{}; 
 
    std::vector<std::shared_ptr<StemConnection>> stemConnections;
 
    constexpr static std::string_view XmlNodeName = "stemOptions"; 
    static const xml::XmlElementArray<StemOptions>& xmlMappingArray(); 
};
 
enum class AccidentalInsertSymbolType
{
    Sharp,
    Flat,
    Natural,
    DblSharp,
    DblFlat
};
 
class TextOptions : public OptionsBase
{
public:
    static constexpr int DEFAULT_LINE_SPACING_PERCENT = 100;
 
    explicit TextOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode)
    {
    }
 
    using HorizontalAlignment = AlignJustify;
 
    enum class VerticalAlignment
    {
        Top, // default value: leave as first (0) item
        Center,
        Bottom
    };
 
    enum class TextJustify {
        Left,           
        Center,         
        Right,          
        Full,           
        ForcedFull      
    };
 
    std::optional<int> textLineSpacingPercent;
    std::optional<Evpu> textLineSpacingEvpu;      
    bool showTimeSeconds{};                       
    DateFormat dateFormat{};                      
    int tabSpaces{};                              
    int textTracking{};                           
    Evpu textBaselineShift{};                     
    Evpu textSuperscript{};                       
    bool textWordWrap{};                          
    Evpu textPageOffset{};                        
    TextJustify textJustify{};                    
    bool textExpandSingleWord{};                  
    HorizontalAlignment textHorzAlign{};          
    VerticalAlignment textVertAlign{};            
    bool textIsEdgeAligned{};                     
 
    struct InsertSymbolInfo : public ContainedClassBase
    {
        using ContainedClassBase::ContainedClassBase;
 
        int trackingBefore{};                     
        int trackingAfter{};                      
        int baselineShiftPerc{};                  
        std::shared_ptr<FontInfo> symFont;        
        char32_t symChar{};                       
 
        void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
        {
            this->ContainedClassBase::integrityCheck(ptrToThis);
            if (!symFont) {
                symFont = std::make_shared<FontInfo>(getDocument(), /*sizeIsPercent*/ true);
                symFont->fontSize = 100;
                MUSX_INTEGRITY_ERROR("Text options accidental insert information is missing its font information.");
            }
        }
 
        static const xml::XmlElementArray<InsertSymbolInfo>& xmlMappingArray(); 
    };
 
    std::unordered_map<AccidentalInsertSymbolType, std::shared_ptr<InsertSymbolInfo>> symbolInserts; 
 
    void integrityCheck(const std::shared_ptr<EnigmaBase>& ptrToThis) override
    {
        this->OptionsBase::integrityCheck(ptrToThis);
        if (textLineSpacingPercent && textLineSpacingEvpu) {
            textLineSpacingEvpu.reset();
            MUSX_INTEGRITY_ERROR("Text options specify both a percent and an absolute line spacing. "
                "The absolute value was discarded.");
        } else if (!textLineSpacingPercent && !textLineSpacingEvpu) {
            textLineSpacingPercent = DEFAULT_LINE_SPACING_PERCENT;
            MUSX_INTEGRITY_ERROR("Text options specify no line spacing. "
                + std::to_string(DEFAULT_LINE_SPACING_PERCENT) + " percent was assumed.");
        }
    }
 
    constexpr static std::string_view XmlNodeName = "textOptions"; 
    static const xml::XmlElementArray<TextOptions>& xmlMappingArray(); 
};
 
class TieOptions : public OptionsBase {
public:
    explicit TieOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    enum class SecondsPlacement
    {
        None,                   
        ShiftForSeconds         
    };
 
    enum class ChordTieDirType
    {
        OutsideInside,          
        StemReversal,           
        SplitEvenly,            
        Unknown                 
    };
 
    enum class MixedStemDirection
    {
        Over,
        Under,
        OppositeFirst           
    };
 
    enum class SpecialPosMode
    {
        None,       
        Avoid       
    };
 
    enum class InsetStyle
    {
        Fixed,                  
        Percent
    };
 
    enum class ControlStyleType
    {
        ShortSpan,
        MediumSpan,
        LongSpan,
        TieEnds
    };
 
    Evpu frontTieSepar{};                       
    Evpu thicknessRight{};                      
    Evpu thicknessLeft{};                       
    bool breakForTimeSigs{};                    
    bool breakForKeySigs{};                     
    Evpu breakTimeSigLeftHOffset{};             
    Evpu breakTimeSigRightHOffset{};            
    Evpu breakKeySigLeftHOffset{};              
    Evpu breakKeySigRightHOffset{};             
    Evpu sysBreakLeftHAdj{};                    
    Evpu sysBreakRightHAdj{};                   
    bool useOuterPlacement{};                   
    SecondsPlacement secondsPlacement{};        
    ChordTieDirType chordTieDirType{};          
    bool chordTieDirOpposingSeconds{};          
    MixedStemDirection mixedStemDirection{};    
    bool afterSingleDot{};                      
    bool afterMultipleDots{};                   
    bool beforeAcciSingleNote{};                
    SpecialPosMode specialPosMode{};            
    Evpu avoidStaffLinesDistance{};             
    InsetStyle insetStyle{};                    
    bool useInterpolation{};                    
    bool useTieEndCtlStyle{};                   
    bool avoidStaffLinesOnly{};                 
    EvpuFloat tieTipWidth{};                    
 
    struct ConnectStyle {
        Evpu offsetX{}; 
        Evpu offsetY{}; 
 
        static const xml::XmlElementArray<ConnectStyle>& xmlMappingArray(); 
    };
 
    std::unordered_map<TieConnectStyleType, std::shared_ptr<ConnectStyle>> tieConnectStyles;
 
    struct ControlPoint {
        Efix insetRatio{}; 
        Evpu height{}; 
        Evpu insetFixed{}; 
 
        static const xml::XmlElementArray<ControlPoint>& xmlMappingArray(); 
    };
 
    struct ControlStyle {
        Evpu span{}; 
        std::shared_ptr<ControlPoint> cp1; 
        std::shared_ptr<ControlPoint> cp2; 
 
        static const xml::XmlElementArray<ControlStyle>& xmlMappingArray(); 
    };
 
    std::unordered_map<ControlStyleType, std::shared_ptr<ControlStyle>> tieControlStyles;
 
    constexpr static std::string_view XmlNodeName = "tieOptions"; 
    static const xml::XmlElementArray<TieOptions>& xmlMappingArray(); 
};
 
class TimeSignatureOptions : public OptionsBase
{
public:
    explicit TimeSignatureOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    Evpu timeUpperLift{};           
    Evpu timeFront{};               
    Evpu timeBack{};                
    Evpu timeFrontParts{};          
    Evpu timeBackParts{};           
    Evpu timeUpperLiftParts{};      
    Evpu timeLowerLiftParts{};      
    Evpu timeAbrvLiftParts{};       
    bool timeSigDoAbrvCommon{};     
    bool timeSigDoAbrvCut{};        
    int numCompositeDecimalPlaces{};
    bool cautionaryTimeChanges{};   
    Evpu timeLowerLift{};           
    Evpu timeAbrvLift{};            
 
    constexpr static std::string_view XmlNodeName = "timeSignatureOptions"; 
    static const xml::XmlElementArray<TimeSignatureOptions>& xmlMappingArray(); 
};
 
class TupletOptions : public OptionsBase {
public:
    explicit TupletOptions(const DocumentWeakPtr& document, Cmper partId = 0, ShareMode shareMode = ShareMode::All)
        : OptionsBase(document, partId, shareMode) {}
 
    enum class AutoBracketStyle
    {
        Always,             
        UnbeamedOnly,       
        NeverBeamSide,      
    };
 
    enum class NumberStyle
    {
        Nothing,                    
        Number,                     
        UseRatio,                   
        RatioPlusDenominatorNote,   
        RatioPlusBothNotes,         
    };
 
    enum class PositioningStyle
    {
        Manual,     
        BeamSide,   
        NoteSide,   
        Above,      
        Below       
    };
 
    enum class BracketStyle
    {
        Nothing,    
        Slur,       
        Bracket     
    };
 
    int displayNumber{};                    
    Edu displayDuration{};                  
    int referenceNumber{};                  
    Edu referenceDuration{};                
    bool alwaysFlat{};                      
    bool fullDura{};                        
    bool metricCenter{};                    
    bool avoidStaff{};                      
    AutoBracketStyle autoBracketStyle{};    
    Evpu tupOffX{};                         
    Evpu tupOffY{};                         
    Evpu brackOffX{};                       
    Evpu brackOffY{};                       
    NumberStyle numStyle{};                 
    PositioningStyle posStyle{};            
    bool allowHorz{};                       
    bool ignoreHorzNumOffset{};             
    bool breakBracket{};                    
    bool matchHooks{};                      
    bool useBottomNote{};                   
    BracketStyle brackStyle{};              
    bool smartTuplet{};                     
    Evpu leftHookLen{};                     
    Evpu leftHookExt{};                     
    Evpu rightHookLen{};                    
    Evpu rightHookExt{};                    
    Evpu manualSlopeAdj{};                  
    int tupMaxSlope{};                      
    Efix tupLineWidth{};                    
    Evpu tupNUpstemOffset{};                
    Evpu tupNDownstemOffset{};              
 
    constexpr static std::string_view XmlNodeName = "tupletOptions"; 
    static const xml::XmlElementArray<TupletOptions>& xmlMappingArray(); 
};
 
} // namespace options
} // namespace dom
} // namespace musx