Enumerations.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
 
namespace mnx {
 
enum class AccidentalEnclosureSymbol
{
    Brackets,           
    Parentheses         
};
 
enum class AutoYesNo
{
    Auto,
    Yes,
    No
};
 
enum class BarlineType
{
    Regular,        
    Dashed,         
    Dotted,         
    Double,         
    Final,          
    Heavy,          
    HeavyHeavy,     
    HeavyLight,     
    NoBarline,      
    Short,          
    Tick            
};
 
enum class BeamHookDirection
{
    Auto,           
    Left,           
    Right           
};
 
enum class BreathMarkSymbol
{
    Auto,    
    Comma,   
    Tick,    
    Upbow,   
    Salzedo  
};
 
enum class ClefSign
{
    CClef,          
    FClef,          
    GClef           
};
 
enum class DynamicPrefix
{
    None,           
    r,              
    s,              
};
 
enum class DynamicRelativeValue
{
    Louder,             
    Softer              
};
 
enum class DynamicSuffix
{
    None,           
    z               
};
 
enum class DynamicValue
{
    f,
    ff,
    fff,
    ffff,
    fffff,
    ffffff,
    mf,
    mp,
    n,
    p,
    pp,
    ppp,
    pppp,
    ppppp,
    pppppp,
};
 
enum class DynamicWedgeType
{
    Decreasing,     
    Increasing      
};
 
enum class FermataDuration
{
    Auto,           
    Long,           
    None,           
    Normal,         
    Short,          
    VeryLong,       
    VeryShort       
};
 
enum class FermataSymbol
{
    Normal,         
    Angled,         
    Curlew,         
    DoubleAngled,   
    DoubleDot,      
    DoubleSquare,   
    HalfCurve,      
    Square          
};
 
enum class FontStyle
{
    Plain,          
    Italic          
};
 
enum class FontWeight
{
    Plain,          
    Bold            
};
 
enum class GraceType
{
    StealPrevious,      
    StealFollowing,     
    MakeTime            
};
 
enum class JumpType
{
    DsAlFine,       
    Segno           
};
 
enum class LabelRef
{
    Name,           
    ShortName       
};
 
enum class LayoutSymbol
{
    NoSymbol,       
    Brace,          
    Bracket         
};
 
enum class LineType
{
    Solid,   
    Dashed,  
    Dotted,  
    Wavy     
};
 
enum class LyricLineType
{
    End,            
    Middle,         
    Start,          
    Whole           
};
 
enum class MarkingUpDown
{
    Down,           
    Up              
};
 
enum class MarkingUpDownAuto
{
    Auto,           
    Down,           
    Up              
};
 
enum class MultiStaffOrientation
{
    Auto,       
    Above,      
    Below,      
    Between     
};
 
enum class NoteStep : int
{
    C = 0,
    D = 1,
    E = 2,
    F = 3,
    G = 4,
    A = 5,
    B = 6
};
 
enum class NoteValueBase
{
    Note4096th,
    Note2048th,
    Note1024th,
    Note512th,
    Note256th,
    Note128th,
    Note64th,
    Note32nd,
    Note16th,
    Eighth,
    Quarter,
    Half,
    Whole,
    Breve,
    Longa,
    Maxima,
    DuplexMaxima
};
 
enum class Orientation
{
    Auto,       
    Above,      
    Below       
};
 
enum class OttavaAmount : int
{
    OctaveDown = -1,            
    TwoOctavesDown = -2,        
    ThreeOctavesDown = -3,      
    OctaveUp = 1,               
    TwoOctavesUp = 2,           
    ThreeOctavesUp = 3          
};
 
enum class OttavaAmountOrZero : int
{
    NoTransposition     = 0,   
    ThreeOctavesDown    = -3,  
    TwoOctavesDown      = -2,  
    OctaveDown          = -1,  
    OctaveUp            = 1,   
    TwoOctavesUp        = 2,   
    ThreeOctavesUp      = 3    
};
 
enum class SlurTieSide
{
    Down,   
    Up,     
};
 
enum class StaffGroupBarlineStyle
{
    Individual,     
    Instrument,     
    Unified,        
    Mensurstrich    
};
 
enum class StaffGroupBarlineOverride
{
    None,           
    Unified,        
    Mensurstrich    
};
 
enum class StemDirection
{
    Down,           
    Up              
};
 
enum class TieTargetType
{
    NextNote,       
    Arpeggio,       
    CrossJump,      
    CrossVoice      
};
 
enum class TimeSignatureUnit : int
{
    Whole = 1,
    Half = 2,
    Quarter = 4,
    Eighth = 8,
    Value16th = 16,
    Value32nd = 32,
    Value64th = 64,
    Value128th = 128
};
 
enum class TimeSignatureDisplay
{
    Common,     
    Cut         
};
 
enum class TupletDisplaySetting
{
    Inner,
    NoNumber,
    Both
};
 
} // namespace mnx
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
namespace nlohmann {
 
template<>
struct adl_serializer<mnx::TimeSignatureUnit>
{
    template<typename BasicJsonType>
    static mnx::TimeSignatureUnit from_json(const BasicJsonType& j)
    { return mnx::TimeSignatureUnit(j.template get<int>()); }
 
    template<typename BasicJsonType>
    static void to_json(BasicJsonType& j, const mnx::TimeSignatureUnit& value)
    { j = int(value); }
};
 
template<>
struct adl_serializer<mnx::OttavaAmount>
{
    template<typename BasicJsonType>
    static mnx::OttavaAmount from_json(const BasicJsonType& j)
    { return mnx::OttavaAmount(j.template get<int>()); }
 
    template<typename BasicJsonType>
    static void to_json(BasicJsonType& j, const mnx::OttavaAmount& value)
    { j = int(value); }
};
 
template<>
struct adl_serializer<mnx::OttavaAmountOrZero>
{
    template<typename BasicJsonType>
    static mnx::OttavaAmountOrZero from_json(const BasicJsonType& j)
    { return mnx::OttavaAmountOrZero(j.template get<int>()); }
 
    template<typename BasicJsonType>
    static void to_json(BasicJsonType& j, const mnx::OttavaAmountOrZero& value)
    { j = int(value); }
};
 
} // namespace nlohmann
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS