ff_details.h

/*
 * File:   ff_details.h
 * Author: Jari Williamsson
 *
 * Created on den 17 april 2011, 12:17
 */
 
#ifndef FF_DETAILS_H
#define FF_DETAILS_H
 
#include "ff_text.h"
 
class __FCDetail : public __FCBaseData
{
public:
    __FCDetail() : __FCBaseData() {}
   const char* ClassName() const override { return "__FCDetail"; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    CMPER _GetCmper2() { return _dataid.detail.cmper2; }
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
};
 
class __FCNoInciDetail : public __FCDetail
{
    bool LoadFirst() override { return false; }
public:
    __FCNoInciDetail() : __FCDetail() {}
   const char* ClassName() const override { return "__FCNoInciDetail"; }
 
    bool Load(CMPER cmper1, CMPER cmper2);
 
    virtual bool SaveNew(CMPER cmper1);
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCDetail::DebugDump();
        DebugOutInt("cmper1: ", _dataid.detail.cmper1);
        DebugOutInt("cmper2: ", _dataid.detail.cmper2);
    }
#endif
};
 
class FCMusicRegion;
 
class FCGroup : public __FCNoInciDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTGroupSpec _groupspec;
protected:
 
    EVERSION EnigmaVersion() const override;
 
    bool LoadFirst() override
    {
       _dataid.detail.cmper1 = 0;
       _dataid.detail.cmper2 = 0;
       _dataid.detail.inci = 0;
       return LoadNext();
    }
 
    EXTAG Tag() const override
    {
        return dt_GroupSpec;
    }
 
    int DataSizeLoad() const override
    {
        return sizeof (EDTGroupSpec);
    }
 
    void* Allocate() override
    {
        return (void*) &_groupspec;
    }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_groupspec, ((FCGroup*) pSource)->_GetGroupSpec(), sizeof (_groupspec));
        _datablock = &_groupspec;
        _loadedsize = sizeof (_groupspec);
    }
 
    __FCBaseData* CreateObject() override
    {
        return new FCGroup();
    }
 
    void _SetAbbreviatedNameID(CMPER value)
    {
        _groupspec.abrvNameID = value;
    }
 
    void _SetFullNameID(CMPER value)
    {
        _groupspec.fullNameID = value;
    }
 
#endif
 
public:
 
        enum FCGROUP_BRACKETS
        {
                GRBRAC_NONE = BRACKET_NONE,
 
                GRBRAC_PLAIN = BRACKET_PLAINBRAC,
 
                GRBRAC_CHORUS = BRACKET_CHORUSBRAC,
 
                GRBRAC_PIANO = BRACKET_PIANOBRAC,
 
                GRBRAC_REVERSECHORUS = BRACKET_REVCHORUSBRAC,
 
                GRBRAC_REVERSEPIANO = BRACKET_REVPIANOBRAC,
 
                GRBRAC_CURVEDCHORUS = BRACKET_CURVECHORUSBRAC,
 
                GRBRAC_REVERSECURVEDCHORUS = BRACKET_REVCURVECHORUSBRAC,
 
                GRBRAC_DESK = BRACKET_DESKBRAC,
 
                GRBRAC_REVERSEDESK = BRACKET_REVDESKBRAC
        };
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTGroupSpec* _GetGroupSpec()
    {
        return &_groupspec;
    }
#endif
 
    enum GROUPSTAFFHIDES    
    {
        GROUPSTAFFHIDE_NORMAL = 0,
 
        GROUPSTAFFHIDE_ALLEMPTY,
 
        GROUPSTAFFHIDE_NEVER
    };
 
    enum GROUPBARLINESTYLES
    {
        GROUPBARLINESTYLE_ONLYON = 0,
 
        GROUPBARLINESTYLE_ONLYBETWEEN,
 
        GROUPBARLINESTYLE_THROUGH
    };
 
 
    const char* ClassName() const override { return "FCGroup"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_GROUP; }
 
    FCGroup() : __FCNoInciDetail()
    {
        memset(&_groupspec, 0, sizeof (_groupspec));
        _datablock = &_groupspec;
        _loadedsize = sizeof (_groupspec);
    }
 
    int CalcStaffIndex(twobyte staff);
 
    int CalcStaffSpan();
 
    bool ContainsStaff(twobyte staff);
 
    FCString* CreateAbbreviatedNameString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateAbbreviatedNameString_GC()
    { return makeLuaSharedPtr(CreateAbbreviatedNameString()); }
#endif
 
    FCString* CreateFullNameString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateFullNameString_GC()
    { return makeLuaSharedPtr(CreateFullNameString()); }
#endif
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    FCString* CreateTrimmedFullNameString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateTrimmedFullNameString_GC()
    { return makeLuaSharedPtr(CreateTrimmedFullNameString()); }
#endif
#endif
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    FCString* CreateDisplayFullNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateDisplayFullNameString_GC()
    { return makeLuaSharedPtr(CreateDisplayFullNameString()); }
#endif
#endif
    
    FCMusicRegion * CreateMusicRegion() const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCMusicRegion> CreateMusicRegion_GC()
    { return makeLuaSharedPtr(CreateMusicRegion()); }
#endif
 
 
    CMPER GetAbbreviatedNameID() const { return _groupspec.abrvNameID; }
 
    bool GetFullNameExpandSingle() const
    {
        return GetBitFlag(_groupspec.auxflag, GROUP_AUX_EXPAND_FULL);
    }
 
    bool GetAbbreviatedNameExpandSingle() const
    {
        return GetBitFlag(_groupspec.auxflag, GROUP_AUX_EXPAND_ABRV);
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
        FCGROUP_BRACKETS
#else
        twobyte
#endif
                GetBracketStyle() const
    {           
#if FXT_VERSION >= FINALEVERSION_2014
                return (FCGROUP_BRACKETS)_groupspec.bracket.bracID;
#else
#ifdef __OBJC__
                return (FCGROUP_BRACKETS)_groupspec.bracket.bracID;
#else
                return (FCGROUP_BRACKETS)_groupspec.bracket.id;
#endif
#endif
    }
 
    Evpu16 GetBracketHorizontalPos() const
    {
        return _groupspec.bracket.bracpos;
    }
 
    Evpu16 GetBracketVerticalTopPos() const
    {
        return _groupspec.bracket.bractop;
    }
 
    Evpu16 GetBracketVerticalBottomPos() const
    {
        return _groupspec.bracket.bracbot;
    }
 
    bool GetBracketSingleStaff() const
    {
        return GetBitFlag(_groupspec.bracket.flag, BRACKET_BRACKET_ON_SINGLE);
    }
 
    twobyte GetEndStaff() const { return _groupspec.endInst; }
 
    CMPER GetFullNameID() const { return _groupspec.fullNameID; }
 
    bool GetUseFullNamePositioning() const { return GetBitFlag(_groupspec.flag, GROUP_FULLNAME_INDIVPOS); }
 
    bool GetUseAbbreviatedNamePositioning() const { return GetBitFlag(_groupspec.flag, GROUP_ABRVNAME_INDIVPOS); }
 
    Evpu16 GetFullNameHorizontalOffset() const { return _groupspec.fullNameXadj; }
 
    Evpu16 GetAbbreviatedNameHorizontalOffset() const { return _groupspec.abrvNameXadj; }
 
    Evpu16 GetFullNameVerticalOffset() const { return _groupspec.fullNameYadj; }
 
    Evpu16 GetAbbreviatedNameVerticalOffset() const { return _groupspec.abrvNameYadj; }
 
    twobyte GetStartStaff() const { return _groupspec.startInst; }
 
    twobyte GetItemID() const { return _dataid.detail.cmper2; }
 
    twobyte GetBarlineStyle() const;
 
    bool GetBarlineUse() const
    {
        return GetBitFlag(_groupspec.flag, GROUP_OWN_BARLINE);
    }
 
    twobyte GetBarlineShapeID() const;
 
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GROUPSTAFFHIDES
#else
    int
#endif
    GetEmptyStaffHide() const
    {
        if (GetBitFlag(_groupspec.auxflag, GROUP_AUX_OPT_REMOVEWHENALLEMPTY))
            return GROUPSTAFFHIDE_ALLEMPTY;
        if (GetBitFlag(_groupspec.auxflag, GROUP_AUX_OPT_REMOVENEVER))
            return GROUPSTAFFHIDE_NEVER;
        return GROUPSTAFFHIDE_NORMAL;
    }
 
    bool GetShowGroupName() const
    {
        return !GetBitFlag(_groupspec.flag, GROUP_HIDE_NAME);
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GROUPBARLINESTYLES
#else
    int
#endif
    GetDrawBarlineMode() const
    {
        switch (_groupspec.flag & GROUP_BARLINE_STYLE)
        {
            case GROUP_GROUP_BARLINES:
                return GROUPBARLINESTYLE_THROUGH;
                break;
            case GROUP_MENSURSTRICHE:
                return GROUPBARLINESTYLE_ONLYBETWEEN;
            default:
                return GROUPBARLINESTYLE_ONLYON;
        }
    }
 
    FLAG_16 GetFullNameJustify() const
    {
        return (_groupspec.flag & GROUP_JUSTIFY_FULL);
    }
 
    FLAG_16 GetAbbreviatedNameJustify() const
    {
        return ((_groupspec.flag & GROUP_JUSTIFY_ABRV) >> 3);
    }
 
    FLAG_16 GetFullNameAlign() const
    {
        return (_groupspec.auxflag & GROUP_AUX_HALIGN_FULL);
    }
 
    FLAG_16 GetAbbreviatedNameAlign() const
    {
        return (_groupspec.auxflag & GROUP_AUX_HALIGN_ABRV) >> 2;
    }
 
    bool HasFullName() { return (GetFullNameID() != 0); }
 
    bool HasAbbreviatedName() { return (GetAbbreviatedNameID() != 0); }
 
 
#if FXT_VERSION >= FINALEVERSION_2011
    twobyte GetEndMeasure() const { return _groupspec.endMeas; }
 
    twobyte GetStartMeasure() const { return _groupspec.startMeas; }
 
    void SetEndMeasure(twobyte value) { _groupspec.endMeas = value; }
 
    void SetStartMeasure(twobyte value) { _groupspec.startMeas = value; }
#endif
 
    void SetStartStaff(twobyte staffno) { _groupspec.startInst = staffno; }
 
    void SetEndStaff(twobyte staffno) { _groupspec.endInst = staffno; }
 
    bool SaveNewAbbreviatedNameBlock(FCString *pString);
 
    bool SaveNewFullNameBlock(FCString *pString);
 
    void SetUseFullNamePositioning(bool state) { Set16BitFlag(&_groupspec.flag, GROUP_FULLNAME_INDIVPOS, state); }
 
    void SetUseAbbreviatedNamePositioning(bool state) { Set16BitFlag(&_groupspec.flag, GROUP_ABRVNAME_INDIVPOS, state); }
 
    void SetFullNameHorizontalOffset(Evpu16 value) { _groupspec.fullNameXadj = value; }
 
    void SetAbbreviatedNameHorizontalOffset(Evpu16 value) { _groupspec.abrvNameXadj = value; }
 
    void SetFullNameVerticalOffset(Evpu16 value) { _groupspec.fullNameYadj = value; }
 
    void SetAbbreviatedNameVerticalOffset(Evpu16 value) { _groupspec.abrvNameYadj = value; }
 
    void SetBarlineStyle(twobyte barline);
 
    void SetBarlineUse(bool value)
    {
        Set16BitFlag(&_groupspec.flag, GROUP_OWN_BARLINE, value);
    }
 
    void SetBarlineShapeID(twobyte shapeID) {
        _groupspec.custombarshape = shapeID;
    }
 
    void SetEmptyStaffHide(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GROUPSTAFFHIDES
#else
    int
#endif
    value
    )
    {
        switch (value)
        {
            case GROUPSTAFFHIDE_ALLEMPTY:
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVEWHENALLEMPTY, true);
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVENEVER, false);
                break;
            case GROUPSTAFFHIDE_NEVER:
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVEWHENALLEMPTY, false);
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVENEVER, true);
                break;
            default:
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVEWHENALLEMPTY, false);
                Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_OPT_REMOVENEVER, false);
                break;
        }        
    }
 
    void SetShowGroupName(bool state)
    {
        Set16BitFlag(&_groupspec.flag, GROUP_HIDE_NAME, !state);
    }
 
    void SetDrawBarlineMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GROUPBARLINESTYLES
#else
    int
#endif
    value)
    {
        switch (value)
        {
            case GROUPBARLINESTYLE_THROUGH:
                _groupspec.flag &= ~GROUP_BARLINE_STYLE;
                _groupspec.flag |= GROUP_GROUP_BARLINES;
                break;
            case GROUPBARLINESTYLE_ONLYBETWEEN:
                _groupspec.flag &= ~GROUP_BARLINE_STYLE;
                _groupspec.flag |= GROUP_MENSURSTRICHE;
                break;
            case GROUPBARLINESTYLE_ONLYON:
                _groupspec.flag &= ~GROUP_BARLINE_STYLE;
                _groupspec.flag |= GROUP_NORMAL_BARLINES;
                break;
        }
    }
 
    void SetFullNameJustify(FLAG_16 value)
    {
        value &= 0x07;
        _groupspec.flag &= ~GROUP_JUSTIFY_FULL;
        _groupspec.flag |= value;
    }
 
    void SetAbbreviatedNameJustify(FLAG_16 value)
    {
        value &= 0x07;
        _groupspec.flag &= ~GROUP_JUSTIFY_ABRV;
        _groupspec.flag |= (value << 3);
    }
 
 
    void SetFullNameAlign(FLAG_16 value)
    {
        value &= 0x03;
        _groupspec.auxflag &= ~GROUP_AUX_HALIGN_FULL;
        _groupspec.auxflag |= value;
    }
 
    void SetAbbreviatedNameAlign(FLAG_16 value)
    {
        value &= 0x03;
        _groupspec.auxflag &= ~GROUP_AUX_HALIGN_ABRV;
        _groupspec.auxflag |= (value << 2);
    }
 
    void SetFullNameExpandSingle(bool state)
    {
        Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_EXPAND_FULL, state);
    }
 
    void SetAbbreviatedNameExpandSingle(bool state)
    {
        Set16BitFlag(&_groupspec.auxflag, GROUP_AUX_EXPAND_ABRV, state);
    }
 
    void SetBracketStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                FCGROUP_BRACKETS
#else
                twobyte
#endif
                bracketid
                )
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _groupspec.bracket.bracID = bracketid;
#else
#ifdef __OBJC__
        _groupspec.bracket.bracID = bracketid;
#else
        _groupspec.bracket.id = bracketid;
#endif
#endif
    }
 
    void SetBracketHorizontalPos(Evpu16 value)
    {
        _groupspec.bracket.bracpos = value;
    }
 
    void SetBracketVerticalTopPos(Evpu16 value)
    {
        _groupspec.bracket.bractop = value;
    }
 
    void SetBracketVerticalBottomPos(Evpu16 value)
    {
        _groupspec.bracket.bracbot = value;
    }
 
    void SetBracketSingleStaff(bool state)
    {
        Set16BitFlag(&_groupspec.bracket.flag, BRACKET_BRACKET_ON_SINGLE, state);
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciDetail::DebugDump();
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
        FCString *pString = CreateTrimmedFullNameString();
        DebugOutString("Full Name: ", pString);
        delete pString;
#endif
        DebugOutInt("Start staff: ", GetStartStaff());
        DebugOutInt("End staff: ", GetEndStaff());
#if FXT_VERSION >= FINALEVERSION_2011
        DebugOutInt("Start measure: ", GetStartMeasure());
        DebugOutInt("End measure: ", GetEndMeasure());
#endif
    }
#endif
};
 
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include "pragma_align_begin.h"
struct __EDTCellClefInfo
{
    twobyte clefinfoID;
    twobyte eduvalue;
    twobyte percent;
    twobyte unknown;
    twobyte AAAA;
    twobyte BBBB;
    twobyte CCCC;
    twobyte DDDD;
    twobyte EEEE;
    twobyte FFFF;
};
#include "pragma_align_end.h"
 
const EXTAG __dt_CellClefInfo = MAKEEXTAG(edDetail,'G','F');
 
#endif
 
#if FXT_VERSION < FINALEVERSION_27_3
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include "pragma_align_begin.h"
struct EDTBaseline          // dt_BASELINES_*, dt_BASELINES_Sys_*
{
    Evpu32 basedisp;
    eLyric lyricNumber;     // for lyrics baselines only, otherwise unused
    twobyte AAAA;           // unused
    twobyte BBBB;           // unused
};
#include "pragma_align_end.h"
 
const EXTAG dt_BaselineChords               = MAKEEXTAG(edDetail,'C','L');
const EXTAG dt_BaselineExprAboveStaff       = MAKEEXTAG(edDetail,'X','A');
const EXTAG dt_BaselineExprBelowStaff       = MAKEEXTAG(edDetail,'X','B');
const EXTAG dt_BaselineFretboards           = MAKEEXTAG(edDetail,'G','L');
const EXTAG dt_BaselineLyricsChorus         = MAKEEXTAG(edDetail,'B','c');
const EXTAG dt_BaselineLyricsSection        = MAKEEXTAG(edDetail,'B','s');
const EXTAG dt_BaselineLyricsVerse          = MAKEEXTAG(edDetail,'B','v');
const EXTAG dt_BaselineSysChords            = MAKEEXTAG(edDetail,'C','l');
const EXTAG dt_BaselineSysExprAboveStaff    = MAKEEXTAG(edDetail,'X','a');
const EXTAG dt_BaselineSysExprBelowStaff    = MAKEEXTAG(edDetail,'X','b');
const EXTAG dt_BaselineSysFretboards        = MAKEEXTAG(edDetail,'G','l');
const EXTAG dt_BaselineSysLyricsChorus      = MAKEEXTAG(edDetail,'b','c');
const EXTAG dt_BaselineSysLyricsSection     = MAKEEXTAG(edDetail,'B','S');
const EXTAG dt_BaselineSysLyricsVerse       = MAKEEXTAG(edDetail,'b','v');
 
#endif // DOXYGEN_SHOULD_SKIP_THIS
#endif // FXT_VERSION < FINALEVERSION_27_3
 
class FCBaseline : public __FCDetail
{
public:
    enum BASELINEMODES
    {
        BASELINEMODE_UNDEFINED = 0,
 
        BASELINEMODE_EXPRESSIONABOVE = 1,
 
        BASELINEMODE_EXPRESSIONBELOW = 2,
 
        BASELINEMODE_CHORD = 3,
 
        BASELINEMODE_FRETBOARD = 4,
 
        BASELINEMODE_LYRICSVERSE = 5,
 
        BASELINEMODE_LYRICSCHORUS = 6,
 
        BASELINEMODE_LYRICSSECTION = 7
    };
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
private:
    EDTBaseline _baseline;
    BASELINEMODES _mode;
    bool _globalscope;   /* Internal flag to indicate which type of tag that
                         * should be used. */
 
 
    EVERSION EnigmaVersion() const override { return FINALEVERSION_2010; }
 
    EXTAG Tag() const override;
 
    int DataSizeLoad() const override { return sizeof (_baseline); }
 
    void* Allocate() override { return (void*) &_baseline; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        FCBaseline* pSourceObject = (FCBaseline*) pSource;
        memcpy(&_baseline, pSourceObject->_GetBaseline(), sizeof (_baseline));
        _datablock = &_baseline;
        _loadedsize = sizeof (_baseline);
        _globalscope = pSourceObject->GetGlobalScope();
        _mode = (BASELINEMODES) pSourceObject->GetMode();
    }
 
    __FCBaseData* CreateObject() override
    {
        return new FCBaseline();
    }   
 
    bool _RawRelink() override;
#endif
 
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTBaseline* _GetBaseline() { return &_baseline; }
 
    bool LoadFirst() override { return false; }
#endif
 
    const char* ClassName() const override { return "FCBaseline"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_BASELINE; }
 
    
    FCBaseline() : __FCDetail()
    {
        memset(&_baseline, 0, sizeof (_baseline));
        _datablock = &_baseline;
        _loadedsize = sizeof (_baseline);
        _mode = BASELINEMODE_UNDEFINED;
        _globalscope = false;
    }
 
    Evpu32 GetVerticalOffset() const { return _baseline.basedisp; }
 
    twobyte GetLyricNumber() const
    { return IsLyricMode() ? _baseline.lyricNumber : 0; }
 
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    GetMode() const { return _mode; }
 
    eSsys GetSystem() const
    {
        if (GetGlobalScope()) return 0;
        return _dataid.detail.cmper1;
    }
 
    bool GetGlobalScope() const { return _globalscope; }
 
    eStaff GetStaff() const
    {        
        return _dataid.detail.cmper2;
    }
 
    void SetVerticalOffset(Evpu32 value) { _baseline.basedisp = value; }
 
    void SetLyricNumber(twobyte number)
    {
        if (number < 1) return;
        _baseline.lyricNumber = number;
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetFullMode(BASELINEMODES mode, bool globalscope)
    {
        _mode = mode;
        _globalscope = globalscope;
    }
#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    mode
    )
    {
        switch (mode)
        {
            case BASELINEMODE_UNDEFINED:
            case BASELINEMODE_EXPRESSIONABOVE:
            case BASELINEMODE_EXPRESSIONBELOW:
            case BASELINEMODE_CHORD:
            case BASELINEMODE_FRETBOARD:
            case BASELINEMODE_LYRICSVERSE:
            case BASELINEMODE_LYRICSCHORUS:
            case BASELINEMODE_LYRICSSECTION:
                _mode = (BASELINEMODES) mode;
                break;
        }
    }
 
    static bool IsModeLyricMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    mode
 );
 
    bool IsLyricMode() const
    { return IsModeLyricMode(GetMode()); }
 
    bool Load(eSsys systemno, eStaff staffno, twobyte inci);
    
    bool SaveNew(eSsys systemno, eStaff staffno);
    
    bool SaveAs(eSsys systemno, eStaff staffno, twobyte inci);
 
    bool LoadForStaff(eSsys systemno, eStaff staffno);
 
    bool LoadDefaultForMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    mode)
    {
        if (IsModeLyricMode(mode)) return false;
        _SetFullMode((BASELINEMODES) mode, true);
        return Load(0, 0, 0);
    }
 
    bool LoadDefaultForLyricNumber(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
        mode,
        eLyric lyricno
    )
    {
        if (lyricno < 1) return false;
        if (!IsModeLyricMode(mode)) return false;
        _SetFullMode((BASELINEMODES) mode, true);
        twobyte tryinci = 0;
        while (Load(0, 0, tryinci))
        {
            if (GetLyricNumber() == lyricno) return true;
            tryinci ++;
        }
        return false;
    }
 
    bool Save() override
    {
        if (_mode == BASELINEMODE_UNDEFINED) return false;
        return __FCDetail::Save();
    }
 
    static Evpu32 CalcTotalOffset(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    mode,
    eSsys system,
    eStaff staff
    );
 
    static Evpu32 CalcTotalOffsetForLyricNumber(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BASELINEMODES
#else
    int
#endif
    mode,
    eSsys system,
    eStaff staff,
    eLyric lyricno
    );
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#include "pragma_align_begin.h"
struct __FCEDTActiveLyric
{
    twobyte tag;        // dt_LYRDATA_Verse, dt_LYRDATA_Chorus, dt_LYRDATA_Section
    CMPER textID;       // cmper of current lyric text block
    twobyte syllable;   // the active syllable
private:
    twobyte filler[2];
};
#include "pragma_align_end.h"
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
constexpr EXTAG __dt_ActiveLyric = MAKEEXTAG(edDetail,'A','L');
constexpr ufourbyte __al_VerseLyric = 0x454;
constexpr ufourbyte __al_ChorusLyric = 0x452;
constexpr ufourbyte __al_SectionLyric = 0x453;
 
class FCActiveLyric : public __FCNoInciDetail
{
private:
    __FCEDTActiveLyric _activelyric;
 
    EXTAG Tag() const override { return __dt_ActiveLyric; }
 
    int DataSizeLoad() const override { return sizeof (_activelyric); }
 
    void* Allocate() override { return (void*) &_activelyric; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        FCActiveLyric* pSourceObject = dynamic_cast<FCActiveLyric*>(pSource);
        assert(pSourceObject);
        _activelyric = pSourceObject->_activelyric;
        _datablock = Allocate();
        _loadedsize = DataSizeLoad();
        _activelyric.tag = __al_VerseLyric;
    }
 
    __FCBaseData* CreateObject() override
    {
        return new FCActiveLyric();
    }
    
    bool SaveNew(CMPER) override { return false; }
    
public:
    const char* ClassName() const override { return "FCActiveLyric"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_ACTIVELYRIC; }
    
    bool Load() { return __FCNoInciDetail::Load(1, 1); }
    
 
    bool Save() override
    {
        _dataid.detail.cmper1 = 1;
        _dataid.detail.cmper2 = 1;
        _dataid.detail.inci = 0;
        _loadedsize = DataSizeLoad();
        return __FCDetail::Save();
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCRawText::RAWTEXTTYPES
#else
    int
#endif
    GetBlockType() const
    {
        switch(_activelyric.tag)
        {
            case __al_VerseLyric: return FCRawText::RAWTEXTTYPE_VERSELYRIC;
            case __al_ChorusLyric: return FCRawText::RAWTEXTTYPE_CHORUSLYRIC;
            case __al_SectionLyric: return FCRawText::RAWTEXTTYPE_SECTIONLYRIC;
        }
        // no throw on retrieval because if the file for some reason
        // does not have a valid value, we need to be able to fix it.
        return FCRawText::RAWTEXTTYPE_UNKNOWN;
    }
    
    CMPER GetTextBlockID() const { return _activelyric.textID; }
 
    int GetSyllable() const { return _activelyric.syllable; }
    
    void SetBlockType(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCRawText::RAWTEXTTYPES
#else
    int
#endif
    value)
    {
        switch(static_cast<FCRawText::RAWTEXTTYPES>(value))
        {
            default:
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
                throw std::runtime_error("block type must be for a lyrics text block");
#endif
                break;
            case FCRawText::RAWTEXTTYPE_VERSELYRIC:
                _activelyric.tag = __al_VerseLyric;
                break;
            case FCRawText::RAWTEXTTYPE_CHORUSLYRIC:
                _activelyric.tag = __al_ChorusLyric;
                break;
            case FCRawText::RAWTEXTTYPE_SECTIONLYRIC:
                _activelyric.tag = __al_SectionLyric;
                break;
        }
    }
 
    void SetTextBlockID(CMPER value) { _activelyric.textID = value; }
 
    void SetSyllable(int value) { _activelyric.syllable = value; }
};
 
#if FXT_VERSION >= FINALEVERSION_2012
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
const EXTAG __ot_FRETGROUPITEM = MAKEEXTAG(edDetail, 'f','b');
 
#include "pragma_align_begin.h"
struct __FCEDTFretItemsHeader   // __ot_FRETGROUPITEM (inci 0)
                                // cmper1 is the same cmper as FCFretboardGroupDef
                                // cmper2 is (0..11), one for each of 12 chord roots
{
    twobyte numFrets;           // "Number of Frets"
    twobyte fretboardNum;       // "Fretboard Number"
    FLAG_16 flags;
    // bits for flags:
#define FRETITEMS_LOCK_FRETBOARD        0x0001
#define FRETITEMS_SHOW_FRETBOARD_NUM    0x0004
    twobyte numFretItems;       // number of fret items in fret array
    twobyte numBarres;          // number of barres in fret array
};
#include "pragma_align_end.h"
 
#include "pragma_align_begin.h"
struct __FCEDTFretItem          // __ot_FRETGROUPITEM (inci 1..n; 2 per inci; not order-dependent)
                                // cmper1 is the same cmper as FCFretboardGroupDef
                                // cmper2 is (0..11), one for each of 12 chord roots
{
    FLAG_16 fretstring;
    // bits for fretstring:
#define FRETITEM_FRETNUM_MASK           0x00FF  // 0-based fret number (0 is open string)
#define FRETITEM_STRING_MASK            0xF800  // 1-based string number from right (or 0 when it's a barre)
    FLAG_16 symbols;            // indicates the symbol(s) on the fret
#define FRETSYMBOL_FINGER_MASK          0xE000  // 1-based finger number (1-4) or thumb (5)
#define FRETSYMBOL_SHAPE_MASK           0x00FF  // bit-oriented shape value
    // 0x0001: closed circle
    // 0x0002: open circle
    // 0x0004: X
    // 0x0008: diamond
    // 0x2000: first finger ("1")
    // 0x4000: second finger ("2")
    // 0x6000: third finger ("3")
    // 0x8000: fourth finger ("4")
    // 0xA000: thumb ("T")
    
    // for barres, the string number is set to zero and the symbols field is reinterpreted as:
    // LOBYTE = from string (on left)
    // HIBYTE = to string (on right)
};
#include "pragma_align_end.h"
 
#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
class __FCFretItemBase : public __FCBase
{
    __FCEDTFretItem _item;
    
protected:
    
    __FCFretItemBase() : __FCBase()
    {
        memset(&_item, 0, sizeof(_item));
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __FCFretItemBase(const __FCFretItemBase& src) : __FCBase()
    {
        _item = src._item;
    }
    __FCFretItemBase(const __FCEDTFretItem& srcItem) : __FCBase()
    {
        _item = srcItem;
    }
    
    int _GetStringNumber() const { return (_GetEDTItem().fretstring & FRETITEM_STRING_MASK) >> 11; }
    int _GetBarreLeftStringNumber() const { return LOBYTE(_GetEDTItem().symbols); }
    int _GetBarreRightStringNumber() const { return HIBYTE(_GetEDTItem().symbols); }
#endif
    
public:
    const char* ClassName() const override { return "__FCFretItemBase"; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const __FCEDTFretItem& _GetEDTItem() const { return _item; }
    __FCEDTFretItem& _GetEDTItem() { return _item; }
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    int GetFretNumber() const { return LOBYTE(_GetEDTItem().fretstring); }
 
    void SetFretNumber(int value) { _GetEDTItem().fretstring = MAKEWORD(value, HIBYTE(_GetEDTItem().fretstring)); }
    
    bool IsBarre() const
    {
        if (_GetStringNumber()) return false;
        if (!_GetBarreLeftStringNumber() || ! _GetBarreRightStringNumber())
            return false;
        return true;
    }
 
};
 
class FCFretItem : public __FCFretItemBase
{
public:
    const char* ClassName() const override { return "FCFretItem"; }
    
    enum FRETITEMSYMBOLS
    {
        FRETITEM_NONE = 0x0000,
        
        FRETITEM_DOT = 0x0001,
        
        FRETITEM_CIRCLE = 0x0002,
        
        FRETITEM_X = 0x0004,
        
        FRETITEM_DIAMOND = 0x0008
    };
    
    enum FRETITEMFINGERINGS
    {
        FRETFINGERING_NONE = 0,
        
        FRETFINGERING_FIRST = 1,
        
        FRETFINGERING_SECOND = 2,
        
        FRETFINGERING_THIRD = 3,
        
        FRETFINGERING_FOURTH = 4,
        
        FRETFINGERING_THUMB = 5
    };
 
    FCFretItem() : __FCFretItemBase()
    {}
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCFretItem(const FCFretItem& src) : __FCFretItemBase(src) {}
    FCFretItem(const __FCEDTFretItem& srcItem) : __FCFretItemBase(srcItem) {}
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    int GetStringNumber() const { return _GetStringNumber(); }
 
    void SetStringNumber(int value)
    {
        _GetEDTItem().fretstring = LOBYTE(_GetEDTItem().fretstring) | ((value << 11) & FRETITEM_STRING_MASK);
    }
 
    int GetFingering() const { return (_GetEDTItem().symbols & FRETSYMBOL_FINGER_MASK) >> 13; }
 
    void SetFingering(int value)
    {
        _GetEDTItem().symbols = LOBYTE(_GetEDTItem().symbols) | ((value << 13) & FRETSYMBOL_FINGER_MASK);
    }
 
    int GetSymbol() const { return LOBYTE(_GetEDTItem().symbols); }
 
    void SetSymbol(int value)
    {
        _GetEDTItem().symbols = MAKEWORD(value, HIBYTE(_GetEDTItem().symbols));
    }
 
    void SetupItem(int symbol, int fretnum, int stringnum, int fingering)
    {
        _GetEDTItem().fretstring = ((stringnum << 11) & FRETITEM_STRING_MASK) | LOBYTE(fretnum);
        _GetEDTItem().symbols = ((fingering << 13) & FRETSYMBOL_FINGER_MASK) | LOBYTE(symbol);
    }
};
 
class FCFretBarreItem : public __FCFretItemBase
{
public:
    const char* ClassName() const override { return "FCFretBarreItem"; }
 
    FCFretBarreItem() : __FCFretItemBase()
    {}
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCFretBarreItem(const FCFretItem& src) : __FCFretItemBase(src) {}
    FCFretBarreItem(const __FCEDTFretItem& srcItem) : __FCFretItemBase(srcItem) {}
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    int GetLeftStringNumber() const { return _GetBarreLeftStringNumber(); }
 
    void SetLeftStringNumber(int value)
    {
        _GetEDTItem().symbols = MAKEWORD(value, HIBYTE(_GetEDTItem().symbols));
    }
 
    int GetRightStringNumber() const { return _GetBarreRightStringNumber(); }
 
    void SetRightStringNumber(int value)
    {
        _GetEDTItem().symbols = MAKEWORD(LOBYTE(_GetEDTItem().symbols), value);
    }
 
    void SetupBarre(int fretnum, int leftstringnum, int rightstringnum)
    {
        _GetEDTItem().fretstring = LOBYTE(fretnum);
        _GetEDTItem().symbols = MAKEWORD(leftstringnum, rightstringnum);
    }
};
 
#endif // FXT_VERSION >= FINALEVERSION_2012
 
#if FXT_VERSION >= FINALEVERSION_2012
 
class FCFretItems;
class FCFretBarreItems;
 
class FCFretboardGroupItem : public __FCBase
{
    // Note that this class does not use the __FCBaseData/__FCDetail pattern because it is so
    // unusual.
    __FCEDTFretItemsHeader _header;
    std::unique_ptr<FCFretItems> _fretitems;
    std::unique_ptr<FCFretBarreItems> _barreitems;
    CMPER _fretboardGroupID;
    CMPER _cmper2;
    
    static twobyte _CalcCmper2(twobyte fretboardGroupInci, twobyte rootIndex)
    { return 16*fretboardGroupInci + rootIndex; }
    
public:
    const char* ClassName() const override { return "FCFretboardGroupItem"; }
    
    FCFretboardGroupItem();
    
    bool Load(CMPER fretboardGroupID, twobyte fretboardGroupInci, twobyte rootIndex)
    {
        _fretboardGroupID = fretboardGroupID;
        _cmper2 = _CalcCmper2(fretboardGroupInci, rootIndex);
        return Reload();
    }
    
    bool Reload();
 
    bool Save();
    
    bool SaveAs(CMPER fretboardGroupID, twobyte fretboardGroupInci, twobyte rootIndex)
    {
        _fretboardGroupID = fretboardGroupID;
        _cmper2 = _CalcCmper2(fretboardGroupInci, rootIndex);
        return Save();
    }
 
    bool Delete();
    
    FCFretItems* GetFretItems() const { return _fretitems.get(); }
    
    FCFretBarreItems* GetFretBarreItems() const { return _barreitems.get(); }
 
    twobyte GetNumberOfFrets() const { return _header.numFrets; }
 
    void SetNumberOfFrets(twobyte value) { _header.numFrets = value; }
 
    twobyte GetFretboardNumber() const { return _header.fretboardNum; }
 
    void SetFretboardNumber(twobyte value) { _header.fretboardNum = value; }
    
    bool GetLocked() const { return GetBitFlag(_header.flags, FRETITEMS_LOCK_FRETBOARD); }
    
    void SetLocked(bool state) { Set16BitFlag(&_header.flags, FRETITEMS_LOCK_FRETBOARD, state); }
    
    bool GetShowFretboardNumber() const { return GetBitFlag(_header.flags, FRETITEMS_SHOW_FRETBOARD_NUM); }
    
    void SetShowFretboardNumber(bool state) { Set16BitFlag(&_header.flags, FRETITEMS_LOCK_FRETBOARD, state); }
};
 
#endif // FXT_VERSION >= FINALEVERSION_2012
 
#endif    /* FF_DETAILS_H */