ff_entrydetails.h

/*
 * File:   ff_entrydetails.h
 * Author: Jari Williamsson
 *
 * Created on den 27 november 2010, 11:54
 */
 
#ifndef FF_ENTRYDETAILS_H
#define FF_ENTRYDETAILS_H
 
#include "ff_noteframe.h"
 
 
/* This whole header file requires PDK_FRAMEWORK_ENTRIES!!! */
#ifdef PDK_FRAMEWORK_ENTRIES
 
 
class __FCEntryDetail : public __FCBaseData
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    bool _RawRelink() override
    {
        DeleteData();
        return SaveNew();
    }
 
protected:
    FCNoteEntry* _pMappedEntry;
 
    bool _HasAnyMod(FCNote* pNote);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
public:
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _DecreaseInci() { _dataid.entryDetail.inci--; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 
    __FCEntryDetail() : __FCBaseData()
    {
        _pMappedEntry = NULL;
        _dataid.entryDetail.entryNumber = 0;
        _dataid.entryDetail.inci = 0;
    }
    const char* ClassName() const override { return "__FCEntryDetail"; }
 
    void SetEntnumAndInci(ENTNUM entnum, twobyte inci)
    {
        _dataid.entryDetail.entryNumber = entnum;
        _dataid.entryDetail.inci = inci;
    }
 
    virtual bool Load(ENTNUM entnum, twobyte inci);
 
    bool Reload() override;
 
    bool SaveAs(ENTNUM entnum, twobyte inci);
 
    bool LoadFirst() override
    {
        if (!_pMappedEntry) return false;
                return Load(_pMappedEntry->GetEntryNumber(), 0);
    }
 
    bool LoadNext() override;
 
    virtual void SetNoteEntry(FCNoteEntry* pEntry)
    {
        if (pEntry)
            _dataid.entryDetail.entryNumber = pEntry->GetEntryNumber();
        _pMappedEntry = pEntry;
    }
   
    FCNoteEntry* GetNoteEntry() { return _pMappedEntry; }
 
    twobyte GetItemInci() const { return _dataid.entryDetail.inci; }
 
    ENTNUM GetItemEntryNumber() const { return _dataid.entryDetail.entryNumber; }
 
    virtual bool SaveNew();
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    twobyte CalcLastInci() override;
#endif
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        pNoteEntry->SetNoteDetailFlag(state);
    }
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBaseData::DebugDump();
        DebugOutInt("_dataid.entryDetail.entryNumber: ", _dataid.entryDetail.entryNumber);
        DebugOutInt("_dataid.entryDetail.inci: ", _dataid.entryDetail.inci);
    }
#endif
 
};
 
class __FCEntryDetailNoteID : public __FCEntryDetail
{
protected:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
     EINCI _ScanForNoteID(FCNoteEntry* pEntry, twobyte noteid);
#endif
 
public:
 
    __FCEntryDetailNoteID() : __FCEntryDetail() {}
 
    const char* ClassName() const override { return "__FCEntryDetailNoteID"; }
 
    bool SaveNew() override;
 
    bool SaveAt(FCNote* pNote);
 
    bool LoadAt(FCNote* pNote);
 
    bool EraseAt(FCNote* pNote);
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    twobyte CalcLastInci() override;
    
    virtual void SetNoteID(twobyte id) = 0;
 
    virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id) = 0;
 
    virtual void _SetEntryFlagN(FCNote* pNote, bool state)
    {
        pNote->_SetNoteDetailEntryFlag(state);
    }
 
    virtual bool _GetEntryFlagN(FCNote* pNote)
    {
        return pNote->_GetNoteDetailEntryFlag();
    }
#endif
};
 
 
class FCNoteheadMod : public __FCEntryDetailNoteID
{
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTNoteheadMods2002 _noteheadmod;
    
#if FXT_VERSION >= FINALEVERSION_2012
        EDTNoteheadMods2012 _noteheadmod2012;
#endif
    
    bool _Use2012Version() const;
    
    const twobyte* _GetHorizontalPosPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_noteheadmod2012.horizpos;
#endif
        return &_noteheadmod.horizpos;
    }
    
    const twobyte* _GetVerticalPosPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_noteheadmod2012.vertpos;
#endif
        return &_noteheadmod.vertpos;
    }
 
    const FLAG_16* _GetFlagPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_noteheadmod2012.flag;
#endif
        return &_noteheadmod.flag;
    }
 
    const FLAG_16* _GetEfxPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_noteheadmod2012.efx;
#endif
        return &_noteheadmod.efx;
    }
    
    const twobyte* _GetFontSizePtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_noteheadmod2012.fontsize;
#endif
        return &_noteheadmod.fontsize;
    }
 
    const twobyte* _GetResizePercentPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_noteheadmod2012.resizepercent;
#endif
        return &_noteheadmod.resizepercent;
    }
    
    const twobyte* _GetFontIDPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_noteheadmod2012.fontID;
#endif
        return &_noteheadmod.fontID;
    }
 
    const twobyte* _GetNoteIDPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_noteheadmod2012.noteID;
#endif
        return &_noteheadmod.noteID;
    }
 
    mutable EFONTNAME _fontname; /* Use for return value. */
#if FXT_VERSION >= FINALEVERSION_25
        mutable EnigmaFontName _fontnameUTF16; /* Use for return value. */
#endif
protected:
    EXTAG Tag() const override { return ed_NoteheadMods2002; }  /* Same tag for 2002 and 2012 versions */
    int DataSizeLoad() const override;
    int DataSizeSave() const override;
    void* Allocate() override;
    EVERSION EnigmaVersion() const override
    {
        if (_Use2012Version()) return FINALEVERSION_2012;
        return FXT_VERSION_2K2_BASE;
    }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
            memcpy(_GetNoteheadMod(), ((FCNoteheadMod*)pSource)->_GetNoteheadMod(), DataSizeLoad());
            _datablock = _GetNoteheadMod();
            _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCNoteheadMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCNoteheadMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_NOTEHEADMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetNoteheadMod()
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
 
            return &_noteheadmod2012;
        }
#endif
        return &_noteheadmod;
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCNoteheadMod() : __FCEntryDetailNoteID()
    {
        _datablock = _GetNoteheadMod();
        memset(_GetNoteheadMod(), 0, DataSizeLoad());
        SetFontSize(24);
        SetResize(100);
        SetUseCustomFont(false);
        SetUseCustomVerticalPos(false);
        _loadedsize = DataSizeLoad();
    }
 
    twobyte GetHorizontalPos() const { return *_GetHorizontalPosPtr(); }
 
    twobyte GetVerticalPosIfPossible()
    {
        if (!GetUseCustomVerticalPos()) return 0;
        return *_GetVerticalPosPtr();
    }
 
    twobyte GetVerticalPos() const
    {        
        return *_GetVerticalPosPtr();
    }
 
    bool GetUseCustomVerticalPos() const
    {
        return GetBitFlag(*_GetFlagPtr(), NOTEHEAD_ALLOW_VERTPOS);
    }
 
    eUniChar32 GetCustomChar() const
    {        
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return _noteheadmod2012.fontchar;
#endif
        return _noteheadmod.fontchar;
    }
 
    bool GetUseCustomChar() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return (_noteheadmod2012.fontchar != 0);
#endif
        return (_noteheadmod.fontchar != 0);
    }
 
    twobyte GetResize() const
    {
        return *_GetResizePercentPtr();
    }
 
    bool GetUseCustomFont() const
    {
        return GetBitFlag(*_GetFlagPtr(), NOTEHEAD_CUSTOMFONT);
    }
 
    const char* GetFontName() const
    {
        if (!GetUseCustomFont()) return "";
        FX_FontNumToName(*_GetFontIDPtr(), &_fontname);
        return (const char*) &_fontname;
    }
 
#if FXT_VERSION >= FINALEVERSION_25
        const eUniChar16* GetFontNameUTF16() const
        {
                if (!GetUseCustomFont()) { return FCString::emptyUniCharStr; }
                
                FX_FontNumToName_UTF16(*_GetFontIDPtr(), _fontnameUTF16, DIM(_fontnameUTF16));
                return _fontnameUTF16;
        }
#endif
 
    twobyte GetFontSize() const
    {
        if (!GetUseCustomFont()) return 0;
        return *_GetFontSizePtr();
    }
 
    bool GetFontStyle(FCFontInfo* pInfo)
    {
        if (!GetUseCustomFont()) return false;
        pInfo->SetEnigmaStyles(*_GetEfxPtr());
        return true;
    }
 
    bool GetFontInfo(FCFontInfo* pInfo)
    {
        if (!GetUseCustomFont()) return false;
        pInfo->SetEnigmaStyles(*_GetEfxPtr());
        pInfo->SetSize(*_GetFontSizePtr());
        pInfo->SetNameByID(*_GetFontIDPtr());
        return true;
    }
 
    bool GetEnharmonicFlip() const
    {
        return GetBitFlag(*_GetFlagPtr(), NOTEHEAD_ENHARMONIC_FLIP);
    }
 
    void SetHorizontalPos(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetHorizontalPosPtr();
        *pValue = value;
    }
 
    void SetVerticalPos(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetVerticalPosPtr();
        *pValue = value;
    }
 
    void SetUseCustomVerticalPos(bool status)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), NOTEHEAD_ALLOW_VERTPOS, status);
    }
 
    void SetUseDefaultVerticalPos(bool status)
    {
        SetUseCustomVerticalPos(!status);
    }
 
    void SetResize(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetResizePercentPtr();
        *pValue = value;
    }
    
    void SetUseCustomFont(bool status)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), NOTEHEAD_CUSTOMFONT, status);
    }
 
    void SetUseDefaultFont(bool status)
    {
        SetUseCustomFont(!status);
    }
 
    void SetFontName(const char* pszFont)
    {
        twobyte fontnum = FX_FontNameToNum((EFONTNAME*) pszFont);
        twobyte* pValue = (twobyte*) _GetFontIDPtr();
        *pValue = fontnum;
    }
 
#if FXT_VERSION >= FINALEVERSION_25
    void SetFontNameUTF16(const eUniChar16* pszFont)
    {
        // This actually sets the font number based on the input font name.
                twobyte fontnum = FX_FontNameToNum_UTF16(pszFont);
        twobyte* pValue = (twobyte*) _GetFontIDPtr();
        *pValue = fontnum;
    }
#endif
 
    void SetFontSize(twobyte fontsize)
    {
        twobyte* pValue = (twobyte*) _GetFontSizePtr();
        *pValue = fontsize;
    }
 
    void SetFontStyle(FCFontInfo* pInfo)
    {
        twobyte* pValue = (twobyte*) _GetEfxPtr();
        *pValue = pInfo->GetEnigmaStyles();
    }
 
    void SetFontInfo(FCFontInfo* pInfo)
    {
        twobyte* pEfx = (twobyte*) _GetEfxPtr();
        *pEfx = pInfo->GetEnigmaStyles();
        twobyte* pFontSize = (twobyte*) _GetFontSizePtr();
        *pFontSize = pInfo->GetSize();
        twobyte* pFontID = (twobyte*) _GetFontIDPtr();
        *pFontID = pInfo->GetIDByName();
    }
 
    void SetCustomChar(eUniChar32 ch)
    {        
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            _noteheadmod2012.fontchar = ch;
            return;
        }
#endif
        _noteheadmod.fontchar = 0xff00 | (ch & 0x00ff);
    }
 
    void SetEnharmonicFlip(bool status)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), NOTEHEAD_ENHARMONIC_FLIP, status);
    }
 
    void ClearChar()
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            _noteheadmod2012.fontchar = 0;
            return;
        }
#endif
        _noteheadmod.fontchar = 0;
    }
 
    void SetNoteID(twobyte id) override
    {
        twobyte* pValue = (twobyte*) _GetNoteIDPtr();
        *pValue = id;
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _IsNoteIDMatch(void *pBuffer, twobyte id) override
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            return (((EDTNoteheadMods2012*) pBuffer)->noteID == id);            
        }
#endif
        return (((EDTNoteheadMods2002*) pBuffer)->noteID == id);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
 
class FCDotMod : public __FCEntryDetailNoteID
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTDotMods _dotmod;
 
protected:
    EXTAG Tag() const override { return ed_DotMods; }
    int DataSizeLoad() const override { return sizeof(EDTDotMods); }
    int DataSizeSave() const override { return sizeof(EDTDotMods); }
    void* Allocate() override { return (void*) &_dotmod; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_dotmod, ((FCDotMod*)pSource)->_GetDotMod(), sizeof(_dotmod));
        _datablock = &_dotmod;
        _loadedsize = sizeof(_dotmod);
    }
 
    __FCBaseData* CreateObject() override { return new FCDotMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCDotMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_DOTMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTDotMods* _GetDotMod() { return &_dotmod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCDotMod() : __FCEntryDetailNoteID()
    {
       memset(&_dotmod, 0, sizeof(_dotmod));
       _datablock = &_dotmod;
       _loadedsize = sizeof(_dotmod);
    }
 
    twobyte GetHorizontalPos() const { return _dotmod.horizpos; }
 
    twobyte GetVerticalPos() const { return _dotmod.vertpos; }
 
    void SetHorizontalPos(twobyte pos) { _dotmod.horizpos = pos; }
 
    void SetVerticalPos(twobyte pos) { _dotmod.vertpos = pos; }
 
    twobyte GetInterDotSpacing() const { return _dotmod.interspacing; }
 
    void SetInterDotSpacing(twobyte space) { _dotmod.interspacing = space; }
 
    void SetNoteID(twobyte id) override { _dotmod.noteID = id; }
 
    bool LoadRestDotAt(FCNoteEntry* pEntry);
 
    bool SaveRestDotAt(FCNoteEntry* pEntry);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _IsNoteIDMatch(void *pBuffer, twobyte id) override
    {
        return (((EDTDotMods*) pBuffer)->noteID == id);
    }
 
    void _SetEntryFlagN(FCNote* pNote, bool state) override
    {        
        pNote->_SetSpecialAltsEntryFlag(state);
    }
 
    bool _GetEntryFlagN(FCNote* pNote) override
    {
        return pNote->_GetSpecialAltsEntryFlag();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
 
 
class FCCrossStaffMod : public __FCEntryDetailNoteID
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTCrossStaff _crossstaff;
 
protected:
    EXTAG Tag() const override { return ed_CrossStaff; }
    int DataSizeLoad() const override { return sizeof(EDTCrossStaff); }
    int DataSizeSave() const override { return sizeof(EDTCrossStaff); }
    void* Allocate() override { return (void*) &_crossstaff; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_crossstaff, ((FCCrossStaffMod*)pSource)->_GetCrossStaff(), sizeof(_crossstaff));
        _datablock = &_crossstaff;
        _loadedsize = sizeof(_crossstaff);
    }
 
    __FCBaseData* CreateObject() override { return new FCCrossStaffMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCrossStaffMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CROSSSTAFFMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTCrossStaff* _GetCrossStaff() { return &_crossstaff; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCCrossStaffMod() : __FCEntryDetailNoteID()
    {
       memset(&_crossstaff, 0, sizeof(_crossstaff));
       _datablock = &_crossstaff;
       _loadedsize = sizeof(_crossstaff);
    }
    
    twobyte GetStaff() const { return _crossstaff.instrument; }
    
    void SetStaff(eStaff staff) { _crossstaff.instrument = staff; }
     
    void SetNoteID(twobyte id) override { _crossstaff.noteID = id; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _IsNoteIDMatch(void *pBuffer, twobyte id) override
    {
        return (((EDTCrossStaff*) pBuffer)->noteID == id);
    }
 
    void _SetEntryFlagN(FCNote* pNote, bool state) override
    {
        pNote->_SetCrossStaffEntryFlag(state);  /* Set flag for entry */
        pNote->SetCrossStaff(state); /* Set flag for note */
    }
 
    bool _GetEntryFlagN(FCNote* pNote) override
    {
        return pNote->_GetCrossStaffEntryFlag(); /* Return flag for entry */
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
 
 
 
class FCSecondaryBeamBreakMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTSecondaryBeamBreakMods _secondarybeambreakmod;
    protected:
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ed_SecondaryBeamBreakMods; }
    int DataSizeLoad() const override { return sizeof(EDTSecondaryBeamBreakMods); }
    int DataSizeSave() const override { return sizeof(EDTSecondaryBeamBreakMods); }
    void* Allocate() override { return (void*) &_secondarybeambreakmod; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_secondarybeambreakmod, ((FCSecondaryBeamBreakMod*)pSource)->_GetSecondaryBeamBreakMod(), sizeof(_secondarybeambreakmod));
        _datablock = &_secondarybeambreakmod;
        _loadedsize = sizeof(_secondarybeambreakmod);
    }
 
    __FCBaseData* CreateObject() override { return new FCSecondaryBeamBreakMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCSecondaryBeamBreakMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SECONDARYBEAMBREAKMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTSecondaryBeamBreakMods* _GetSecondaryBeamBreakMod() { return &_secondarybeambreakmod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCSecondaryBeamBreakMod() : __FCEntryDetail()
    {
       _datablock = &_secondarybeambreakmod;
       memset(&_secondarybeambreakmod, 0, sizeof(_secondarybeambreakmod));
    }
 
    void SetBreak(int beamindex, bool value)
    {
        if (beamindex < 0) return;
        if (beamindex > 8) return;
        _secondarybeambreakmod.breaks[beamindex] = value ? 1 : 0;
    }
 
    void SetBreakAll(bool value)
    {
        for (int i = 0; i < 9; i++) SetBreak(i, value);
    }
    
    twobyte CalcLowestBreak() const
    {
        for (int beamindex = 0; beamindex < 9; beamindex++)
            if (_secondarybeambreakmod.breaks[beamindex]) return beamindex;
        return -1;
    }
 
    bool GetBreak(int beamindex) const
    {
        if (beamindex < 0) return false;
        if (beamindex > 8) return false;
        return (_secondarybeambreakmod.breaks[beamindex] != 0);
    }
 
    bool GetBreak16th() const
    {
        return GetBreak(0);
    }
 
    void SetBreak16th(bool state)
    {
        return SetBreak(0, state);
    }
 
    bool GetBreak32nd() const
    {
        return GetBreak(1);
    }
 
    void SetBreak32nd(bool state)
    {
        return SetBreak(1, state);
    }
 
    bool GetBreak64th() const
    {
        return GetBreak(2);
    }
 
    void SetBreak64th(bool state)
    {
        return SetBreak(2, state);
    }
 
    bool GetBreak128th() const
    {
        return GetBreak(3);
    }
 
    void SetBreak128th(bool state)
    {
        return SetBreak(3, state);
    }
 
    bool GetBreak256th() const
    {
        return GetBreak(4);
    }
 
    void SetBreak256th(bool state)
    {
        return SetBreak(4, state);
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetSecondaryBeamFlag(state);
    }    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
 
 
 
class FCBeamExtensionMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTBeamExtMods _beamextensionmod;
    bool _upstemuse;
 
protected:
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ed_BeamExtBelowMods; }
    int DataSizeLoad() const override { return sizeof(_beamextensionmod); }
    int DataSizeSave() const override { return DataSizeLoad(); }
    void* Allocate() override { return (void*) &_beamextensionmod; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        FCBeamExtensionMod * pSourceMod = dynamic_cast<FCBeamExtensionMod*>(pSource);
        if (!pSourceMod) return;
        memcpy(&_beamextensionmod, pSourceMod->_GetBeamExtensionMod(), DataSizeLoad());
        _upstemuse = pSourceMod->_upstemuse;
        _datablock = _GetBeamExtensionMod();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCSecondaryBeamBreakMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCBeamExtensionMod"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_BEAMEXTENSIONMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTBeamExtMods* _GetBeamExtensionMod() { return &_beamextensionmod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCBeamExtensionMod() : __FCEntryDetail()
    {
        _upstemuse = false;
        _datablock = _GetBeamExtensionMod();
       memset(&_beamextensionmod, 0, sizeof(_beamextensionmod));
    }
 
    void UseUpStemData(bool useupstem)
    {
        SetCustomTag(useupstem ? ed_BeamExtAboveMods : ed_BeamExtBelowMods);
        _upstemuse = useupstem;
    }
 
    void SetNoteEntry(FCNoteEntry* pEntry) override
    {
        if (pEntry)
        {
            bool stemup = pEntry->CalcStemUp();
            UseUpStemData(stemup);
        }
        __FCEntryDetail::SetNoteEntry(pEntry);
    }
    
    void SetLeftAdjustment(Evpu16 adjust) { _beamextensionmod.leftadjust = adjust; }
    
    Evpu16 GetLeftAdjustment() const { return _beamextensionmod.leftadjust; }
 
    void SetRightAdjustment(Evpu16 adjust) { _beamextensionmod.rightadjust = adjust; }
    
    Evpu16 GetRightAdjustment() const { return _beamextensionmod.rightadjust; }
 
    void SetExtend(int beamindex, bool value)
    {
        if (beamindex < 0) return;
        if (beamindex > 9) return;
        if (value)
        {
            _beamextensionmod.beams |= (FCNoteEntry::NOTE_8TH >> beamindex);
            _beamextensionmod.beams |= BMEXT_HAS_BMEXT;
        }
        else
        {
            _beamextensionmod.beams &= ~(FCNoteEntry::NOTE_8TH >> beamindex);
            if (! (_beamextensionmod.beams & BMEXT_BEAM_MASK))
                _beamextensionmod.beams &= ~BMEXT_HAS_BMEXT;
        }
    }
 
    void SetExtendAll(bool value)
    {
        for (int i = 0; i <= 9; i++) SetExtend(i, value);
    }
 
    bool GetExtend(int beamindex) const
    {
        if (beamindex < 0) return false;
        if (beamindex > 9) return false;
        if (! GetBitFlag(_beamextensionmod.beams, BMEXT_HAS_BMEXT)) return false;
        return ((_beamextensionmod.beams & (FCNoteEntry::NOTE_8TH >> beamindex)) != 0);
    }
 
    bool GetExtend8th() const
    {
        return GetExtend(0);
    }
 
    void SetExtend8th(bool state)
    {
        return SetExtend(0, state);
    }
 
    bool GetExtend16th() const
    {
        return GetExtend(1);
    }
 
    void SetExtend16th(bool state)
    {
        return SetExtend(1, state);
    }
 
    bool GetExtend32nd() const
    {
        return GetExtend(2);
    }
 
    void SetExtend32nd(bool state)
    {
        return SetExtend(2, state);
    }
 
    bool GetExtend64th() const
    {
        return GetExtend(3);
    }
 
    void SetExtend64th(bool state)
    {
        return SetExtend(3, state);
    }
 
    bool GetExtend128th() const
    {
        return GetExtend(4);
    }
 
    void SetExtend128th(bool state)
    {
        return SetExtend(4, state);
    }
 
    bool GetExtend256th() const
    {
        return GetExtend(5);
    }
 
    void SetExtend256th(bool state)
    {
        return SetExtend(5, state);
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetBeamExtensionFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
 
class FCStemMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStemMods _stemmod;
 
protected:
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ed_StemMods; }
    int DataSizeLoad() const override { return sizeof(EDTStemMods); }
    int DataSizeSave() const override { return sizeof(EDTStemMods); }
    void* Allocate() override { return (void*) &_stemmod; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_stemmod, ((FCStemMod*)pSource)->_GetStemMod(), sizeof(_stemmod));
        _datablock = &_stemmod;
        _loadedsize = sizeof(_stemmod);
    }
 
    __FCBaseData* CreateObject() override { return new FCStemMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCStemMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STEMMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStemMods* _GetStemMod() { return &_stemmod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCStemMod() : __FCEntryDetail()
    {
       _datablock = &_stemmod;
       memset(&_stemmod, 0, sizeof(_stemmod));
       _loadedsize = sizeof(_stemmod);
    }
 
    #ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetStemDetailFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    twobyte GetVerticalUpOffset() const { return _stemmod.topVertAdjust; }
 
    twobyte GetVerticalDownOffset() const { return _stemmod.downVertAdjust; }
 
    twobyte GetHorizontalUpOffset() const { return HI_ONEBYTE(_stemmod.horizAdjust); }
 
    twobyte GetHorizontalDownOffset() const { return LO_ONEBYTE(_stemmod.horizAdjust); }
 
    void SetVerticalUpOffset(twobyte adjust) { _stemmod.topVertAdjust = adjust; }
 
    void SetVerticalDownOffset(twobyte adjust) { _stemmod.downVertAdjust = adjust; }
 
 
    void SetHorizontalUpOffset(twobyte adjust)
    {        
        _stemmod.horizAdjust = MAKE_TWOBYTE(_stemmod.horizAdjust & 0x00ff, adjust);
    }
 
    void SetHorizontalDownOffset(twobyte adjust)
    {
        _stemmod.horizAdjust = MAKE_TWOBYTE(adjust, _stemmod.horizAdjust & 0x00ff);
    }
 
 
    void UseBeamedData(bool usebeam) { SetCustomTag(usebeam ? ed_BeamStemMods : ed_StemMods); }
 
};
 
 
 
class FCArticulation : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if FXT_VERSION >= FINALEVERSION_26
    typedef EDTArticulation25_6 CurrEDTArticulation;
#elif FXT_VERSION >= FINALEVERSION_2014B
    typedef EDTArticulation2014b CurrEDTArticulation;
#else
    typedef EDTArticulation CurrEDTArticulation;
#endif
    CurrEDTArticulation _articulationCurr;   // each later version of EDTArticulation is an extension of the previous, which is why this works
 
protected:    
    int DataSizeLoad() const override;
    int DataSizeSave() const override
    { return DataSizeLoad(); }
    void* Allocate() override
    { return (void*) &_articulationCurr; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override;
 
    __FCBaseData* CreateObject() override { return new FCArticulation(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
public:
    EXTAG Tag() const override { return ed_Articulation; }
    const char* ClassName() const override { return "FCArticulation"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_ARTICULATION; }
 
    enum PLACEMENTMODE {
        ARTICPLACEMENT_AUTOMATIC = 0,
        ARTICPLACEMENT_ABOVE,
        ARTICPLACEMENT_BELOW
        };
 
    enum STACKINGMODE {
        ARTICSTACKING_USEDEFINITION = 0,
        ARTICSTACKING_NEVER
        };
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if FXT_VERSION >= FINALEVERSION_26
    bool SaveNew() override
    {
        _articulationCurr.numSlursAvoided = -1;
        return __FCEntryDetail::SaveNew();
    }
#endif
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCArticulation();
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetArticulationFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    void SetArticulationDef(FCArticulationDef* pDef);
 
    void SetID(CMPER cmper) { _articulationCurr.imrkdef = cmper; }
 
    void SetHorizontalPos(Evpu16 pos)
    {
        _articulationCurr.posadd = pos;
    }
 
    void SetHorizontalCopyToPos(Evpu16 pos)
    {
        _articulationCurr.posadder = pos;
    }
 
    void SetVerticalPos(Evpu16 pos)
    {
        _articulationCurr.noteadd = pos;
    }
 
    void SetVerticalCopyToPos(Evpu16 pos)
    {
        _articulationCurr.lonoadd = pos;
    }
 
    bool GetVisible() const;
 
    void SetVisible(bool state);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STACKINGMODE
#else
    int
#endif
    GetStackingMode() const;
 
    void SetStackingMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STACKINGMODE
#else
    int
#endif
    value);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    PLACEMENTMODE
#else
    int
#endif
    GetPlacementMode() const;
 
    void SetPlacementMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    PLACEMENTMODE
#else
    int
#endif
    value);
 
    Evpu16 GetHorizontalPos() const { return _articulationCurr.posadd; }
 
    Evpu16 GetHorizontalCopyToPos() const { return _articulationCurr.posadder; }
 
    Evpu16 GetVerticalPos() const { return _articulationCurr.noteadd; }
 
    Evpu16 GetVerticalCopyToPos() const { return _articulationCurr.lonoadd; }
 
    twobyte GetID() const { return _articulationCurr.imrkdef; }
 
    FCArticulationDef* CreateArticulationDef();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCArticulationDef> CreateArticulationDef_GC()
    { return makeLuaSharedPtr(CreateArticulationDef()); }
#endif
 
    bool CalcMetricPos(FCPoint* pPoint);
 
    bool CalcFlippedSymbolUsed();
 
    void ResetPos(FCArticulationDef* pDef);
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCEntryDetail::DebugDump();
        DebugOutInt("Articulation ID: ", GetID());
        DebugOutInt("Horizontal position: ", GetHorizontalPos());
        DebugOutInt("Vertical position: ", GetVerticalPos());
    }
#endif
};
 
 
class FCTuplet : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTTuplet2005 _tuplet;
 
protected:    
    int DataSizeLoad() const override { return sizeof(EDTTuplet2005); }
    int DataSizeSave() const override { return sizeof(EDTTuplet2005); }
    void* Allocate() override { return (void*) &_tuplet; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_tuplet, ((FCTuplet*)pSource)->_GetTuplet(), sizeof(_tuplet));
        _datablock = &_tuplet;
        _loadedsize = sizeof(_tuplet);
    }
 
    __FCBaseData* CreateObject() override
        { return new FCTuplet(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    EXTAG Tag() const override { return ed_Tuplet; }
 
    enum PLACEMENTMODE {
        TUPLETPLACEMENT_MANUAL = 0,
        TUPLETPLACEMENT_STEMSIDE,
        TUPLETPLACEMENT_NOTESIDE,
        TUPLETPLACEMENT_ABOVE,
        TUPLETPLACEMENT_BELOW
        };
 
    enum NUMBERSTYLE
        {
        TUPLETNUMBER_NONE = 0,
        TUPLETNUMBER_REGULAR,
        TUPLETNUMBER_RATIO,
        TUPLETNUMBER_RATIOANDNOTE,
        TUPLETNUMBER_RATIOANDNOTE_BOTH
        };
 
    enum SHAPESTYLE
        {
        TUPLETSHAPE_NONE = 0,
        TUPLETSHAPE_BRACKET,
        TUPLETSHAPE_SLUR
        };
 
    enum BRACKETMODE
        {
        TUPLETBRACKET_ALWAYS = 0,
        TUPLETBRACKET_UNBEAMEDONLY,
        TUPLETBRACKET_NEVERBEAMEDONBEAMSIDE
        };
 
    const char* ClassName() const override { return "FCTuplet"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TUPLET; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTuplet2005* _GetTuplet() { return &_tuplet; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCTuplet() : __FCEntryDetail()
    {
       memset(&_tuplet, 0, sizeof(_tuplet));
       _datablock = &_tuplet;
       _loadedsize = sizeof(_tuplet);
    }
 
    TimeEdu32 CalcFullReferenceDuration() { return GetReferenceDuration() * GetReferenceNumber(); }
 
    TimeEdu32 CalcFullSymbolicDuration() { return GetSymbolicDuration() * GetSymbolicNumber(); }
    
#ifdef PDK_FRAMEWORK_PREFS
    void PrefsReset(bool resetposition);
#endif
 
    twobyte GetSymbolicDuration() const { return _tuplet.tupsymdur; }
 
    twobyte GetSymbolicNumber() const { return _tuplet.tupnum; }
 
    twobyte GetReferenceDuration() const { return _tuplet.refdur; }
 
    twobyte GetReferenceNumber() const { return _tuplet.refnum; }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    PLACEMENTMODE 
#else
    int
#endif
    GetPlacementMode() const;
 
    bool GetEngraverTuplet() const { return GetBitFlag(_tuplet.flag, TUPLET_ENGRAVERTUPLET); }
 
    bool GetAvoidStaff() const { return GetBitFlag(_tuplet.tuplflag, TUPLET_AVOID_STAFF); }
 
    bool GetAllowHorizontalDrag() const { return GetBitFlag(_tuplet.flag, TUPLET_ALLOW_HORZ); }
 
    bool GetUseBottomNote() const { return GetBitFlag(_tuplet.flag, TUPLET_USEBOTTOM); }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    NUMBERSTYLE
#else
    int
#endif
    GetNumberStyle() const;
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SHAPESTYLE
#else
    int
#endif
    GetShapeStyle() const;
 
    bool GetBreakSlurBracket() const { return GetBitFlag(_tuplet.flag, TUPLET_BREAKBRACK); }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BRACKETMODE
#else
    int
#endif
    GetBracketMode() const;
 
    bool GetAlwaysFlat() const { return GetBitFlag(_tuplet.tuplflag, TUPLET_FLAT); }
 
    bool GetBracketFullDuration() const { return GetBitFlag(_tuplet.tuplflag, TUPLET_FULLDURA); }
 
    twobyte GetHorizontalOffset() const { return _tuplet.tupOffX; }
 
    twobyte GetVerticalOffset() const { return _tuplet.tupOffY; }
 
    bool GetCenterUsingDuration() const { return GetBitFlag(_tuplet.tuplflag, TUPLET_METRIC_CENTER); }
 
    bool GetIgnoreNumberOffset() const { return GetBitFlag(_tuplet.flag, TUPLET_IGNOREGLOFFS); }
 
    twobyte GetHorizontalShapeOffset() const { return _tuplet.brackOffX; }
 
    twobyte GetVerticalShapeOffset() const { return _tuplet.brackOffY; }
 
    bool GetMatchHookLengths() const { return GetBitFlag(_tuplet.flag, TUPLET_MATCH_HOOKS); }
 
    twobyte GetLeftHookLength() const { return -_tuplet.leftHookLen; }
 
    twobyte GetLeftExtension() const { return _tuplet.leftHookExt; }
 
    twobyte GetRightHookLength() const { return -_tuplet.rightHookLen; }
 
    twobyte GetRightExtension() const { return _tuplet.rightHookExt; }
 
    twobyte GetSlopeAdjust() const { return _tuplet.slope; }
 
    bool GetVisible() const { return !GetBitFlag(_tuplet.tuplflag, 0x20); }
 
    void SetSymbolicNumber(twobyte value) { _tuplet.tupnum = value; }
 
    void SetSymbolicDuration(twobyte value) { _tuplet.tupsymdur = value; }
 
    void SetReferenceNumber(twobyte value) { _tuplet.refnum = value; }
 
    void SetReferenceDuration(twobyte value) { _tuplet.refdur = value; }
 
    void SetPlacementMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    PLACEMENTMODE
#else
    int
#endif
    value);
 
    void SetEngraverTuplet(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_ENGRAVERTUPLET, value); }
 
    void SetAvoidStaff(bool value) { Set16BitFlag(&_tuplet.tuplflag, TUPLET_AVOID_STAFF, value); }
 
    void SetAllowHorizontalDrag(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_ALLOW_HORZ, value); }
 
    void SetUseBottomNote(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_USEBOTTOM, value); }
 
    void SetNumberStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    NUMBERSTYLE
#else
    int
#endif
    value);
 
    void SetShapeStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SHAPESTYLE
#else
    int
#endif
    value);
 
    void SetBreakSlurBracket(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_BREAKBRACK, value); }
 
    void SetBracketMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BRACKETMODE
#else
    int
#endif
    value);
 
    void SetAlwaysFlat(bool value) { Set16BitFlag(&_tuplet.tuplflag, TUPLET_FLAT, value); }
 
    void SetBracketFullDuration(bool value) { Set16BitFlag(&_tuplet.tuplflag, TUPLET_FULLDURA, value); }
 
    void SetHorizontalOffset(twobyte value) { _tuplet.tupOffX = value; }
 
    void SetVerticalOffset(twobyte value) { _tuplet.tupOffY = value; }
 
    void SetCenterUsingDuration(bool value) { Set16BitFlag(&_tuplet.tuplflag, TUPLET_METRIC_CENTER, value); }
 
    void SetIgnoreNumberOffset(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_IGNOREGLOFFS, value); }
 
    void SetHorizontalShapeOffset(twobyte value) { _tuplet.brackOffX = value; }
 
    void SetVerticalShapeOffset(twobyte value) { _tuplet.brackOffY = value; }
 
    void SetMatchHookLengths(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_MATCH_HOOKS, value); }
 
    void SetLeftHookLength(twobyte value) { _tuplet.leftHookLen = -value; }
 
    void SetLeftExtension(twobyte value) { _tuplet.leftHookExt = value; }
 
    void SetRightHookLength(twobyte value) { _tuplet.rightHookLen = -value; }
 
    void SetRightExtension(twobyte value) { _tuplet.rightHookExt = value; }
 
    void SetSlopeAdjust(twobyte value) { _tuplet.slope = value; }
 
    void SetVisible(bool value) { Set16BitFlag(&_tuplet.tuplflag, 0x20, !value); }
 
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetTupletStartFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCEntryDetail::DebugDump();
 
        switch (GetPlacementMode())
        {
            case TUPLETPLACEMENT_MANUAL:
                DebugOut("Placement mode: Manual");
                break;
            case TUPLETPLACEMENT_STEMSIDE:
                DebugOut("Placement mode: Stem/Beam Side");
                break;
            case TUPLETPLACEMENT_NOTESIDE:
                DebugOut("Placement mode: Note Side");
                break;
            case TUPLETPLACEMENT_ABOVE:
                DebugOut("Placement mode: Above");
                break;
            case TUPLETPLACEMENT_BELOW:
                DebugOut("Placement mode: Below");
                break;
        }
        DebugOutBool("Engraver tuplet: ", GetEngraverTuplet());
        DebugOutBool("Avoid staff: ", GetAvoidStaff());
        DebugOutBool("Allow horizontal drag: ", GetAllowHorizontalDrag());
        DebugOutBool("Use bottom note: ", GetUseBottomNote());
        switch (GetNumberStyle())
        {
            case TUPLETNUMBER_NONE:
                DebugOut("Number appearance: None");
                break;
            case TUPLETNUMBER_REGULAR:
                DebugOut("Number appearance: Number");
                break;
            case TUPLETNUMBER_RATIO:
                DebugOut("Number appearance: Ratio");
                break;
            case TUPLETNUMBER_RATIOANDNOTE:
                DebugOut("Number appearance: 7:8q");
                break;
            case TUPLETNUMBER_RATIOANDNOTE_BOTH:
                DebugOut("Number appearance: 7q:8q");
                break;
        }
        switch (GetShapeStyle())
        {
            case TUPLETSHAPE_NONE:
                DebugOut("Shape appearance: None");
                break;
            case TUPLETSHAPE_BRACKET:
                DebugOut("Shape appearance: Bracket");
                break;
            case TUPLETSHAPE_SLUR:
                DebugOut("Shape appearance: Slur");
                break;
        }
 
        DebugOutBool("Break slur of bracket: ", GetBreakSlurBracket());
        switch (GetBracketMode())
        {
            case TUPLETBRACKET_ALWAYS:
                DebugOut("Always use specified shape");
                break;
            case TUPLETBRACKET_UNBEAMEDONLY:
                DebugOut("Bracket unbeamed notes only");
                break;
            case TUPLETBRACKET_NEVERBEAMEDONBEAMSIDE:
                DebugOut("Never bracket beamed notes on beam side");
                break;
        }
        DebugOutInt("Horizontal offset: ", GetHorizontalOffset());
        DebugOutInt("Vertical offset: ", GetVerticalOffset());
        DebugOutBool("Center number using duration: ", GetCenterUsingDuration());
        DebugOutBool("Ignore Horizontal Number Offset: ", GetIgnoreNumberOffset());
        DebugOutInt("Horizontal shape offset: ", GetHorizontalShapeOffset());
        DebugOutInt("Vertical shape offset: ", GetVerticalShapeOffset());
        DebugOutBool("Always flat: ", GetAlwaysFlat());
        DebugOutBool("Bracket full duration: ", GetBracketFullDuration());
        DebugOutBool("Match length of hooks: ", GetMatchHookLengths());
        DebugOutInt("Left hook length: ", GetLeftHookLength());
        DebugOutInt("Left hook extension: ", GetLeftExtension());
        DebugOutInt("Right hook length: ", GetRightHookLength());
        DebugOutInt("Right hook extension: ", GetRightExtension());
        DebugOutInt("Manual slope adjustment: ", GetSlopeAdjust());
    }
#endif
};
 
 
 
/* Should FCSyllableBase be parsed by the preprocessor? This approach
got a little convoluted, since Doxygen seems to have some problem with
generating XML files correctly if the #if statements are too complicated. */
#undef __SHOULD_INCLUDE_SYLLABLE_CODE 
 
#if (FXT_VERSION > FINALEVERSION_2012)
#define __SHOULD_INCLUDE_SYLLABLE_CODE 1
#endif
 
#ifdef DOXYGEN_SHOULD_SKIP_THIS
#define __SHOULD_INCLUDE_SYLLABLE_CODE 1
#endif
 
#ifdef __SHOULD_INCLUDE_SYLLABLE_CODE
/* Not defined until the 2014 PDK. Check for DOXYGEN_SHOULD_SKIP_THIS as well,
* so Doxygen parse these classes. */
 
 
class FCSyllableBase : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTLyric2011 _syllable;
    
    int _CalcStringPos(twobyte syllablepos) const;
    
    FCFontInfo* _CreateFontInfo(twobyte syllablenumber) const;
protected:
    int DataSizeLoad() const override { return sizeof(EDTLyric2011); }
    int DataSizeSave() const override { return sizeof(EDTLyric2011); }
    void* Allocate() override { return (void*) &_syllable; }
    
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_syllable, ((FCSyllableBase*)pSource)->_GetSyllable(), sizeof(_syllable));
        _datablock = &_syllable;
        _loadedsize = sizeof(_syllable);
    }
    
    __FCBaseData* CreateObject() override { return NULL; }  /* Defined by inherited class!!! */
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    
    EXTAG Tag() const override = 0;  /* Defined by inherited class */
    
    const char* ClassName() const override { return ""; };  /* Defined by inherited class */
        
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTLyric2011* _GetSyllable() { return &_syllable; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
    FCSyllableBase() : __FCEntryDetail()
    {
        _datablock = &_syllable;
        memset(&_syllable, 0, sizeof(_syllable));
    }
 
    void SetHorizontalOffset(Evpu16 offset)
    {
        _syllable.horzOff = offset;
    }
 
    void SetVerticalOffset(Evpu16 offset)
    {
        _syllable.vertOff = offset;
    }
 
    void SetSyllableNumber(twobyte number)
    {
        _syllable.syll = number;        
    }
 
    void SetRawTextNumber(twobyte rawtextid)
    {
        _syllable.rawTextNum = rawtextid;
    }
 
    void SetWordExtensionID(twobyte smartshapeID)
    {
        _syllable.wext = smartshapeID;
    }
 
    void SetIncludeLyricNumber(bool state)
    {
        Set16BitFlag((FLAG_16*) &_syllable.lyrFlags, EDTLYRDATA_DISPLAY_VERSENUM, state);
    }
 
    void SetFloatingHorizontalOffset(Evpu16 offset)
    {
        _syllable.floatingHorzOff = offset;
    }
 
    Evpu16 GetHorizontalOffset() const
    {
        return _syllable.horzOff;
    }
 
    Evpu16 GetVerticalOffset() const
    {
        return _syllable.vertOff;
    }
 
    twobyte GetSyllableNumber() const
    {
        return _syllable.syll;
    }
 
    twobyte GetRawTextNumber() const
    {
        return _syllable.rawTextNum;
    }
 
    twobyte GetWordExtensionID() const
    {
        return _syllable.wext;
    }
 
    bool GetIncludeLyricNumber() const
    {
        return GetBitFlag(_syllable.lyrFlags, EDTLYRDATA_DISPLAY_VERSENUM);
    }
 
    twobyte GetFloatingHorizontalOffset() const
    {
        return _syllable.floatingHorzOff;
    }
 
    bool IsValidSyllableNumber()
    {
        return FX_SyllableInfo_UTF16(Tag(), GetRawTextNumber(), GetSyllableNumber(),
                NULL, 0, NULL, NULL, NULL, NULL) != 0;
    }
 
    virtual bool IsVerse() const { return false; }
 
    virtual bool IsChorus() const { return false; }
 
    virtual bool IsSection() const { return false; }
 
    bool CalcHyphen()
    {
        tbool hyphen = false;        
        if (FX_SyllableInfo_UTF16(Tag(), GetRawTextNumber(), GetSyllableNumber(),
                NULL, 0, NULL, NULL, &hyphen, NULL) == 0) return false;
        return hyphen != 0;
    }
 
    int CalcStringPos() const;
 
    int CalcNextStringPos() const;
 
    __FCLyricsBase* CreateLyricText() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<__FCLyricsBase> CreateLyricText_GC() const
    { return makeLuaSharedPtr(CreateLyricText()); }
#endif
 
    FCFontInfo* CreateFontInfo() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateFontInfo_GC() const
    { return makeLuaSharedPtr(CreateFontInfo()); }
#endif
    
    FCFontInfo* CreateNextFontInfo() const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateNextFontInfo_GC() const
    { return makeLuaSharedPtr(CreateNextFontInfo()); }
#endif
    
    bool GetText(FCString* pString) const;
 
    bool GetRawText(FCString* pString) const;
 
    bool SaveRawText(FCString* pString);
    
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetLyricFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
    
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCEntryDetail::DebugDump();
        DebugOutHex("lyrFlags: ", _syllable.lyrFlags);
    }
#endif
};
 
class FCVerseSyllable : public FCSyllableBase
{
    __FCBaseData* CreateObject() override { return new FCVerseSyllable(); }
public:
    EXTAG Tag() const override;
    const char* ClassName() const override { return "FCVerseSyllable"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_VERSESYLLABLE; }
 
    bool IsVerse() const override { return true; }
};
 
class FCChorusSyllable : public FCSyllableBase
{
    __FCBaseData* CreateObject() override { return new FCChorusSyllable(); }
public:
    EXTAG Tag() const override;
    const char* ClassName() const override { return "FCChorusSyllable"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CHORUSSYLLABLE; }
    bool IsChorus() const override { return true; }
};
 
class FCSectionSyllable : public FCSyllableBase
{
    __FCBaseData* CreateObject() override { return new FCSectionSyllable(); }
public:
    EXTAG Tag() const override;
    const char* ClassName() const override { return "FCSectionSyllable"; } 
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SECTIONSYLLABLE; }
    bool IsSection() const override { return true; }
};
 
#endif /* #ifdef __SHOULD_INCLUDE_SYLLABLE_CODE */
 
 
 
class FCSyllableEntryMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTLyricEntryInfo _lyricinfo;
protected:
    EXTAG Tag() const override { return ed_LyricEntryInfo; }
    int DataSizeLoad() const override { return sizeof(EDTLyricEntryInfo); }
    int DataSizeSave() const override { return sizeof(EDTLyricEntryInfo); }
    void* Allocate() override { return (void*) &_lyricinfo; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_lyricinfo, ((FCSyllableEntryMod*)pSource)->_GetSyllableEntryMod(), sizeof(_lyricinfo));
        _datablock = &_lyricinfo;
        _loadedsize = sizeof(_lyricinfo);
    }
 
    __FCBaseData* CreateObject() override { return new FCSyllableEntryMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    enum SYLLABLEJUSTIFICATIONS
    {
        SYLLJUST_DEFAULT = 0,
 
        SYLLJUST_CENTER = 1,
 
        SYLLJUST_LEFT = 2,
        
        SYLLJUST_RIGHT = 3
    };
 
    enum SYLLABLEALIGNS
    {
        SYLLALIGN_DEFAULT = 0,
        
        SYLLALIGN_CENTER = 1,
 
        SYLLALIGN_LEFT = 2,
 
        SYLLALIGN_RIGHT = 3
    };
 
    const char* ClassName() const override { return "FCSyllableEntryMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SYLLABLEENTRYMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTLyricEntryInfo* _GetSyllableEntryMod() { return &_lyricinfo; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCSyllableEntryMod() : __FCEntryDetail()
    {
       memset(&_lyricinfo, 0, sizeof(_lyricinfo));
       _datablock = &_lyricinfo;
       _loadedsize = sizeof(_lyricinfo);
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetLyricFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SYLLABLEALIGNS
#else
    int
#endif
    GetAlignment() const
    {
        return (SYLLABLEALIGNS) ((_lyricinfo.flag & LyricEntryInfo_AlignBits) / 0x100);
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SYLLABLEJUSTIFICATIONS
#else
    int
#endif
    GetJustification() const
    {
        return (SYLLABLEJUSTIFICATIONS) (_lyricinfo.flag & LyricEntryInfo_JustifyBits);
    }
 
 
    void SetAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SYLLABLEALIGNS
#else
    int
#endif
    value)
    {
        FLAG_16 bitflag = (FLAG_16) value;
        bitflag = bitflag & 3;
        bitflag *= 0x100;
        _lyricinfo.flag &= ~LyricEntryInfo_AlignBits;
        _lyricinfo.flag |= bitflag;
    }
 
    void SetJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SYLLABLEJUSTIFICATIONS
#else
    int
#endif
    value
    )
    {
        FLAG_16 bitflag = (FLAG_16) value;
        bitflag = bitflag & 3;
        _lyricinfo.flag &= ~LyricEntryInfo_JustifyBits;
        _lyricinfo.flag |= bitflag;
    }
 
 
#if PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCEntryDetail::DebugDump();        
    }
#endif
 
};
 
class FCEntryAlterMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTAlter _alter;
 
protected:
    EXTAG Tag() const override { return ed_Alter; }
    int DataSizeLoad() const override { return sizeof(EDTAlter); }
    int DataSizeSave() const override { return sizeof(EDTAlter); }
    void* Allocate() override { return (void*) &_alter; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_alter, ((FCEntryAlterMod*)pSource)->_GetAlterMod(), sizeof(_alter));
        _datablock = &_alter;
        _loadedsize = sizeof(_alter);
    }
 
    __FCBaseData* CreateObject() override { return new FCEntryAlterMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCEntryAlterMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_ENTRYALTERMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTAlter* _GetAlterMod() { return &_alter; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCEntryAlterMod() : __FCEntryDetail()
    {
       memset(&_alter, 0, sizeof(_alter));
       _alter.percent = 100;
       _datablock = &_alter;
       _loadedsize = sizeof(_alter);
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetNoteDetailFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    void SetResize(twobyte value)
    {
        if (value == 0) value = 100;
        _alter.percent = value;
    }
 
    twobyte GetResize() const
    {
        if (_alter.percent == 0) return 100;
        return _alter.percent;
    }
 
#if PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCEntryDetail::DebugDump();
        DebugOutInt("Resize: ", GetResize());
    }
#endif
 
};
 
class FCAccidentalMod : public __FCEntryDetailNoteID
{
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTAccidentalMods2001 _accidentalmod;
 
#if FXT_VERSION >= FINALEVERSION_2012
        EDTAccidentalMods2012 _accidentalmod2012;
#endif
 
    bool _Use2012Version() const;
 
    const twobyte* _GetHorizontalPosPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_accidentalmod2012.horizpos;
#endif
        return &_accidentalmod.horizpos;
    }
 
    const twobyte* _GetVerticalPosPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_accidentalmod2012.vertpos;
#endif
        return &_accidentalmod.vertpos;
    }
 
    const FLAG_16* _GetFlagPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_accidentalmod2012.flag;
#endif
        return &_accidentalmod.flag;
    }
 
    const FLAG_16* _GetEfxPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_accidentalmod2012.efx;
#endif
        return (FLAG_16*) &_accidentalmod.efx;
    }
 
    const twobyte* _GetFontSizePtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_accidentalmod2012.fontsize;
#endif
        return &_accidentalmod.fontsize;
    }
 
    const twobyte* _GetResizePercentPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_accidentalmod2012.resizepercent;
#endif
        return &_accidentalmod.resizepercent;
    }
 
    const twobyte* _GetFontIDPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_accidentalmod2012.fontID;
#endif
        return &_accidentalmod.fontID;
    }
 
    const twobyte* _GetNoteIDPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_accidentalmod2012.noteID;
#endif
        return &_accidentalmod.noteID;
    }
    
    mutable EFONTNAME _fontname; /* Use for return value. */
#if FXT_VERSION >= FINALEVERSION_25
        mutable EnigmaFontName _fontnameUTF16; /* Use for return value. */
#endif
protected:
    EXTAG Tag() const override { return ed_AccidentalMods2001; }
    int DataSizeLoad() const override;
    int DataSizeSave() const override;
    void* Allocate() override;
    EVERSION EnigmaVersion() const override
    {
        if (_Use2012Version()) return FINALEVERSION_2012;
        return FXT_VERSION_2K2_BASE;
    }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(_GetAccidentalMod(), ((FCAccidentalMod*)pSource)->_GetAccidentalMod(), DataSizeLoad());
        _datablock = _GetAccidentalMod();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCAccidentalMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCAccidentalMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_ACCIDENTALMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetAccidentalMod() 
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_accidentalmod2012;
#endif
        return &_accidentalmod;
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCAccidentalMod() : __FCEntryDetailNoteID()
    {
       _datablock = _GetAccidentalMod();
       memset(_GetAccidentalMod(), 0, DataSizeLoad());
       SetFontSize(24);
       SetResize(100);
       SetUseCustomFont(false);
       SetUseCustomVerticalPos(false);
       _loadedsize = DataSizeLoad();
    }
 
    twobyte GetHorizontalPos() const { return *_GetHorizontalPosPtr(); }
 
 
    twobyte GetVerticalPosIfPossible()
    {
        if (!GetUseCustomVerticalPos()) return 0;
        return *_GetVerticalPosPtr();
    }
 
    twobyte GetVerticalPos() const
    {        
        return *_GetVerticalPosPtr();
    }
 
    bool GetUseCustomVerticalPos() const
    {
        return GetBitFlag(*_GetFlagPtr(), ACCIMODS_VERTICAL_POS);
    }
 
    eUniChar32 GetCustomChar() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return _accidentalmod2012.fontchar;
#endif
        return _accidentalmod.fontchar;
    }
 
    bool GetUseCustomChar() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return (_accidentalmod2012.fontchar != 0);
#endif
        return (_accidentalmod.fontchar != 0);
    }
 
    twobyte GetResize() const
    {
        return *_GetResizePercentPtr();
    }
 
    bool GetUseCustomFont() const
    {
        return GetBitFlag(*_GetFlagPtr(), ACCIMODS_CUSTOM_FONT);
    }
 
    const char* GetFontName() const
    {
        if (!GetUseCustomFont()) return "";
        FX_FontNumToName(*_GetFontIDPtr(), &_fontname);
        return (const char*) &_fontname;
    }
 
#if FXT_VERSION >= FINALEVERSION_25
    const eUniChar16* GetFontNameUTF16() const
    {
                if (!GetUseCustomFont()) { return FCString::emptyUniCharStr; }
                
        FX_FontNumToName_UTF16(*_GetFontIDPtr(), _fontnameUTF16, DIM(_fontnameUTF16));
                
        return _fontnameUTF16;
    }
#endif
 
    twobyte GetFontSize() const
    {
        if (!GetUseCustomFont()) return 0;
        return *_GetFontSizePtr();
    }
 
    bool GetFontStyle(FCFontInfo* pInfo)
    {
        if (!GetUseCustomFont()) return false;
        pInfo->SetEnigmaStyles(*_GetEfxPtr());
        return true;
    }
 
    bool GetFontInfo(FCFontInfo* pInfo)
    {
        if (!GetUseCustomFont()) return false;
        pInfo->SetEnigmaStyles(*_GetEfxPtr());
        pInfo->SetSize(*_GetFontSizePtr());
        pInfo->SetNameByID(*_GetFontIDPtr());
        return true;
    }
 
 
    void SetHorizontalPos(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetHorizontalPosPtr();
        *pValue = value;
    }
 
    void SetVerticalPos(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetVerticalPosPtr();
        *pValue = value;
    }
 
    void SetUseCustomVerticalPos(bool status)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), ACCIMODS_VERTICAL_POS, status);
    }
 
    void SetUseDefaultVerticalPos(bool status)
    {
        SetUseCustomVerticalPos(!status);
    }
 
    void SetResize(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetResizePercentPtr();
        *pValue = value;
    }
 
    void SetUseCustomFont(bool status)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), ACCIMODS_CUSTOM_FONT, status);
    }
 
    void SetUseDefaultFont(bool status)
    {
        SetUseCustomFont(!status);
    }
 
    void SetFontName(const char* pszFont)
    {
        twobyte fontnum = FX_FontNameToNum((EFONTNAME*) pszFont);
        twobyte* pValue = (twobyte*) _GetFontIDPtr();
        *pValue = fontnum;
    }
 
#if FXT_VERSION >= FINALEVERSION_25
        void SetFontNameUTF16(const eUniChar16* pszFont)
        {
                // This actually sets the font number based on the input font name.
                twobyte fontnum = FX_FontNameToNum_UTF16(pszFont);
                twobyte* pValue = (twobyte*) _GetFontIDPtr();
                *pValue = fontnum;
        }
#endif /* FXT_VERSION >= FINALEVERSION_25 */
 
    void SetFontSize(twobyte fontsize)
    {
        twobyte* pValue = (twobyte*) _GetFontSizePtr();
        *pValue = fontsize;
    }
 
    void SetFontStyle(FCFontInfo* pInfo)
    {
        twobyte* pValue = (twobyte*) _GetEfxPtr();
        *pValue = pInfo->GetEnigmaStyles();
    }
 
    void SetFontInfo(FCFontInfo* pInfo)
    {
        twobyte* pEfx = (twobyte*) _GetEfxPtr();
        *pEfx = pInfo->GetEnigmaStyles();
        twobyte* pFontSize = (twobyte*) _GetFontSizePtr();
        *pFontSize = pInfo->GetSize();
        twobyte* pFontID = (twobyte*) _GetFontIDPtr();
        *pFontID = pInfo->GetIDByName();
    }
 
    void SetCustomChar(eUniChar32 ch)
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            _accidentalmod2012.fontchar = ch;
            return;
        }
#endif
        _accidentalmod.fontchar = 0xff00 | (ch & 0x00ff);
    }
 
    void ClearChar()
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            _accidentalmod2012.fontchar = 0;
            return;
        }
#endif
        _accidentalmod.fontchar = 0;
    }
    
    void SetNoteID(twobyte id) override
    {
        twobyte* pValue = (twobyte*) _GetNoteIDPtr();
        *pValue = id;
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _IsNoteIDMatch(void *pBuffer, twobyte id) override
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            return (((EDTAccidentalMods2012*) pBuffer)->noteID == id);
        }
#endif
        return (((EDTAccidentalMods2001*) pBuffer)->noteID == id);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
 
 
class FCPercussionNoteMod : public __FCEntryDetailNoteID
{
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTPercNoteCode _percnotemod;
 
protected:
    EXTAG Tag() const override { return ed_PercNoteCode    ; }
    int DataSizeLoad() const override { return sizeof(EDTPercNoteCode); }
    int DataSizeSave() const override { return sizeof(EDTPercNoteCode); }
    void* Allocate() override { return (void*) &_percnotemod; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_percnotemod, ((FCPercussionNoteMod*)pSource)->_GetPercussionNoteMod(), sizeof(_percnotemod));
        _datablock = &_percnotemod;
        _loadedsize = sizeof(_percnotemod);
    }
 
    __FCBaseData* CreateObject() override { return new FCPercussionNoteMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCPercussionNoteMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PERCUSSIONNOTEMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTPercNoteCode* _GetPercussionNoteMod() { return &_percnotemod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCPercussionNoteMod() : __FCEntryDetailNoteID()
    {
       _datablock = &_percnotemod;
       memset(&_percnotemod, 0, sizeof(_percnotemod));
       _loadedsize = sizeof(_percnotemod);
    }
 
    FLAG_16 GetNoteType() const { return _percnotemod.noteType; }
 
    void SetNoteType(FLAG_16 value) { _percnotemod.noteType = value; }
 
    void SetNoteID(twobyte id) override { _percnotemod.noteID = id; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _IsNoteIDMatch(void *pBuffer, twobyte id) override
    {
        return (((EDTPercNoteCode*) pBuffer)->noteID == id);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
 
class FCCustomStemMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTCustomStemMods _customstemmod;
 
protected:
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ed_StemMods; }
    int DataSizeLoad() const override { return sizeof(EDTCustomStemMods); }
    int DataSizeSave() const override { return sizeof(EDTCustomStemMods); }
    void* Allocate() override { return (void*) &_customstemmod; }
 
    EVERSION EnigmaVersion() const override { return FXT_VERSION_2K5_BASE; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_customstemmod, ((FCStemMod*)pSource)->_GetStemMod(), sizeof(_customstemmod));
        _datablock = &_customstemmod;
        _loadedsize = sizeof(_customstemmod);
    }
 
    __FCBaseData* CreateObject() override { return new FCCustomStemMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCustomStemMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CUSTOMSTEMMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTCustomStemMods* _GetStemMod() { return &_customstemmod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCCustomStemMod() : __FCEntryDetail()
    {
       _datablock = &_customstemmod;
       memset(&_customstemmod, 0, sizeof(_customstemmod));
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetStemDetailFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    void UseUpStemData(bool useupstem) { SetCustomTag(useupstem ? ed_CustomStemModsUp : ed_CustomStemModsDown); }
 
    twobyte GetShapeID() const { return _customstemmod.shapeID; }
 
    void SetShapeID(CMPER theid) { _customstemmod.shapeID = theid; }
};
 
 
class FCBeamMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTBeamMods _beammod;
 
    twobyte _secondarybeamnumber;   // 1-based beam number for secondary beams
    bool _secondarybeamuse;
    bool _upstemuse;
 
    void _PreSaveSetup()
    {
        if (_secondarybeamuse)
        {
            _beammod.beamWidth = -1;
            if (_beammod.secondaryBeamEdu == 0)
            {
                SetBeamNumber(_secondarybeamnumber);
            }
        }
        else
        {
            _beammod.secondaryBeamEdu = 0;
        }
    }
 
protected:
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ed_BeamBelowMods; }
    int DataSizeLoad() const override { return sizeof(EDTBeamMods); }
    int DataSizeSave() const override { return sizeof(EDTBeamMods); }
    void* Allocate() override { return (void*) &_beammod; }
 
    EVERSION EnigmaVersion() const override { return FXT_VERSION_2K5_BASE; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        FCBeamMod* pSourceMod = (FCBeamMod*) pSource;
        memcpy(&_beammod, pSourceMod->_GetBeamMod(), sizeof(_beammod));        
        _datablock = &_beammod;
        _loadedsize = sizeof(_beammod);
        _secondarybeamuse = pSourceMod->IsSecondaryBeam();
       _upstemuse = pSourceMod->IsUpStem();
       _secondarybeamnumber = pSourceMod->GetBeamNumber();
    }
    
    void InitializeData()
    {
        memset(&_beammod, 0, sizeof(_beammod));
        _beammod.mode = 2;  /* Defaults to "Flatten Beams Based On Standard Note */
        SetDefaultBeamThickness();
 #ifdef PDK_FRAMEWORK_PREFS
        SetDefaultMode();
 #endif
    }
 
    __FCBaseData* CreateObject() override { return new FCBeamMod(_secondarybeamuse); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCBeamMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_BEAMMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTBeamMods* _GetBeamMod() { return &_beammod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCBeamMod(bool secondarybeam) : __FCEntryDetail()
    {
        _datablock = &_beammod;
        _loadedsize = sizeof(_beammod);
 
        _secondarybeamuse = secondarybeam;
        _upstemuse = false;
        _secondarybeamnumber = 2;
        SetCustomTag(_secondarybeamuse ? ed_BeamBelowModsSecondary : ed_BeamBelowMods);
        
        InitializeData();
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetStemDetailFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    bool Load(ENTNUM entnum, twobyte inci) override
    {
        /* Work-around a Finale issue (at least in Fin2012): When
         * a load has failed of this type, the data is still
         * cleared. For this class, it will be disastrous. */
        EDTBeamMods tempbeammod;
        memcpy(&tempbeammod, &_beammod, sizeof(_beammod));
        bool returnval = __FCEntryDetail::Load(entnum, inci);
        if (!returnval) memcpy(&_beammod, &tempbeammod, sizeof(_beammod));
        return returnval;
    }
 
    bool Save() override
    {
        _PreSaveSetup();
        return __FCEntryDetail::Save();
    }
 
    bool SaveNew() override
    {
        _PreSaveSetup();
       return __FCEntryDetail::SaveNew();
    }
 
    void UseUpStemData(bool useupstem)
    {
        if (_secondarybeamuse)
        {
            // Secondary beams:
            SetCustomTag(useupstem ? ed_BeamAboveModsSecondary : ed_BeamBelowModsSecondary);
        }
        else
        {
            // Primary beams:
            SetCustomTag(useupstem ? ed_BeamAboveMods : ed_BeamBelowMods);
        }
        _upstemuse = useupstem;
    }
 
    void SetNoteEntry(FCNoteEntry* pEntry) override
    {    
        if (pEntry)
        {
            bool stemup = pEntry->CalcStemUp();
            UseUpStemData(stemup);
        }
        __FCEntryDetail::SetNoteEntry(pEntry);
    }
 
    void SetMode(twobyte mode)
    {
        _beammod.mode = mode;
    }
 
    void SetLeftHorizontalOffset(twobyte offset)
    {
        _beammod.startHorizAdjust = offset;
    }
 
    void SetRightHorizontalOffset(twobyte offset)
    {
        _beammod.endHorizAdjust = offset;
    }
 
    void SetLeftVerticalOffset(twobyte offset)
    {
        _beammod.startVertAdjust = offset;
    }
 
    void SetRightVerticalOffset(twobyte offset)
    {
        _beammod.endVertAdjust = offset;
    }
 
    void SetThickness(twobyte thickness)
    {
        if (_secondarybeamuse) return;
        _beammod.beamWidth = thickness;
    }
 
    void SetDefaultBeamThickness()
    {
        if (_secondarybeamuse) return;
        _beammod.beamWidth = -1;
    }
 
#ifdef PDK_FRAMEWORK_PREFS
    void SetDefaultMode();
#endif
 
    void SetBeamNumber(twobyte beamnumber)
    {
        if (!_secondarybeamuse) return;
        if (beamnumber <= 1) return;
        _secondarybeamnumber = beamnumber;
        twobyte duration = FCNoteEntry::NOTE_8TH;
        for (int i = 1; i < beamnumber; i++) duration /= 2;
        _beammod.secondaryBeamEdu = duration;
    }
 
    twobyte GetLeftHorizontalOffset() const
    {
        return _beammod.startHorizAdjust;
    }
 
    twobyte GetRightHorizontalOffset() const
    {
        return _beammod.endHorizAdjust;
    }
 
    twobyte GetLeftVerticalOffset() const
    {
        return _beammod.startVertAdjust;
    }
 
    twobyte GetRightVerticalOffset() const
    {
        return _beammod.endVertAdjust;
    }
 
    twobyte GetMode() const { return _beammod.mode; }
 
    twobyte GetBeamDuration() const
    {
        if (!_secondarybeamuse) return FCNoteEntry::EIGHTH_NOTE;
        return _beammod.secondaryBeamEdu;
    }
 
    twobyte GetBeamNumber()
    {
        twobyte duration = GetBeamDuration();
        if (duration == 0) return 0;
        if (duration > FCNoteEntry::EIGHTH_NOTE) return 0;
        twobyte retvalue = 1;
        TimeEdu32 tryvalue = FCNoteEntry::EIGHTH_NOTE;
        while (tryvalue)
        {
            if (tryvalue == duration) return retvalue;
            retvalue ++;
            tryvalue /= 2;
        }
        return 0;
    }
 
    twobyte GetThickness() const
    {
        if (_secondarybeamuse) return -1;
        return _beammod.beamWidth;
    }
 
    twobyte CalcLeftVerticalPos(twobyte default_separation)
    {
        if (!_secondarybeamuse) return 0;
        twobyte result = default_separation * (GetBeamNumber() - 1);
        if (_upstemuse) result = -result;
        result += GetLeftVerticalOffset();
        return result;
    }
 
    twobyte CalcRightVerticalPos(twobyte default_separation)
    {
        if (!_secondarybeamuse) return 0;
        return CalcLeftVerticalPos(default_separation) + GetRightVerticalOffset();
    }
 
    bool IsSecondaryBeam() { return _secondarybeamuse; }
 
    bool IsUpStem() { return _upstemuse; }
    
    bool LoadForBeamNumber(int beamnumber)
    {
        if (LoadFirst())
        {
            do {
                if (GetBeamNumber() == beamnumber)
                {
                    SetBeamNumber(beamnumber);
                    return true;
                }
            } while (LoadNext());
            InitializeData();
        }
        return false;
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCEntryDetail::DebugDump();
        DebugOutInt("Beam Duration: ", GetBeamDuration());
        DebugOutInt("Beam Number: ", GetBeamNumber());
        DebugOutInt("mode: ", _beammod.mode);
        DebugOutInt("Left Vertical offset: ", GetLeftVerticalOffset());
        DebugOutInt("Right Vertical offset: ", GetRightVerticalOffset());
        DebugOutBlock(&_beammod, 0, sizeof(_beammod));
    }
#endif
};
 
 
class FCPerformanceMod : public __FCEntryDetailNoteID
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTPerformanceData _performancedata;
 
protected:
    EXTAG Tag() const override { return ed_PerformanceData; }
    int DataSizeLoad() const override { return sizeof(EDTPerformanceData); }
    int DataSizeSave() const override { return sizeof(EDTPerformanceData); }
    void* Allocate() override { return (void*) &_performancedata; }
    EVERSION EnigmaVersion() const override { return FXT_VERSION_2K2_BASE; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_performancedata, ((FCPerformanceMod*)pSource)->_GetPerformanceMod(), sizeof(_performancedata));
        _datablock = &_performancedata;
        _loadedsize = sizeof(_performancedata);
    }
 
    __FCBaseData* CreateObject() override { return new FCPerformanceMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCPerformanceMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PERFORMANCEMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTPerformanceData* _GetPerformanceMod() { return &_performancedata; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCPerformanceMod() : __FCEntryDetailNoteID()
    {
       _datablock = &_performancedata;
       memset(&_performancedata, 0, sizeof(_performancedata));
       _datablock = &_performancedata;
       _loadedsize = sizeof(_performancedata);
    }
 
    void SetEndOffset(twobyte value)
    {
        _performancedata.enadd = value;
    }
 
    void SetStartOffset(twobyte value)
    {
        _performancedata.stadd = value;
    }
 
    void SetVelocityDelta(twobyte value)
    {
        _performancedata.velocity = value;
    }
 
    void SetMidiAlter(twobyte value)
    {
        _performancedata.keyadd = value;
    }
 
    twobyte GetEndOffset() const
    {
        return _performancedata.enadd;
    }
 
    twobyte GetStartOffset() const
    {
        return _performancedata.stadd;
    }
 
    twobyte GetMidiAlter() const
    {
        return _performancedata.keyadd;
    }
 
    twobyte GetVelocityDelta() const
    {
        return _performancedata.velocity;
    }
 
    void SetNoteID(twobyte id) override { _performancedata.noteID = id; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _IsNoteIDMatch(void *pBuffer, twobyte id) override
    {
        return (((EDTPerformanceData*) pBuffer)->noteID == id);
    }
 
    void _SetEntryFlagN(FCNote* pNote, bool state) override
    {
        pNote->_SetPerformanceDataEntryFlag(state);
    }
 
    bool _GetEntryFlagN(FCNote* pNote) override
    {
        return pNote->_GetPerformanceDataEntryFlag();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
 
class FCTieMod : public __FCEntryDetailNoteID
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        bool _starttie;
        EDTTieMods _tiemod;
 
protected:
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ed_TieModsStart; }
    int DataSizeLoad() const override { return sizeof(_tiemod); }
    int DataSizeSave() const override { return DataSizeLoad(); }
    void* Allocate() override { return (void*) &_tiemod; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        FCTieMod* pTieSource = (FCTieMod*) pSource;
        memcpy(&_tiemod, pTieSource->_GetTieMod(), sizeof(_tiemod));
        _datablock = &_tiemod;
        _loadedsize = DataSizeLoad();
        _starttie = pTieSource->IsStartTie();
    }
 
    __FCBaseData* CreateObject() override
    {
        return new FCTieMod(_starttie ? TIEMODTYPE_TIESTART : TIEMODTYPE_TIEEND);
    }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCTieMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TIEMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTieMods* _GetTieMod() { return &_tiemod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
    enum TIEMOD_TIETYPES
    {
        TIEMODTYPE_TIEEND = 0,
 
        TIEMODTYPE_TIESTART = 1
    };
 
    enum TIEMOD_SELECTOR
    {
        TIEMODSEL_DEFAULT = 0,
 
        TIEMODSEL_ON = 1,
 
        TIEMODSEL_OFF = 2
    };
    
enum TIEMOD_DIRECTION
{
    TIEMODDIR_AUTOMATIC = 0,
 
    TIEMODDIR_OVER = 1,
 
    TIEMODDIR_UNDER = 2
};
    
enum TIEMOD_CONNECTION_CODES
{
    TIEMODCNCT_NONE = TIE_ENTCNCT_NONE,
 
    TIEMODCNCT_ENTRYLEFT_NOTECENTER = TIE_ENTRYLEFT_NOTECENTER,
 
    TIEMODCNCT_ENTRYRIGHT_NOTECENTER = TIE_ENTRYRIGHT_NOTECENTER,
 
    TIEMODCNCT_NOTELEFT_NOTECENTER = TIE_NOTELEFT_NOTECENTER,
 
    TIEMODCNCT_NOTERIGHT_NOTECENTER = TIE_NOTERIGHT_NOTECENTER,
 
    TIEMODCNCT_NOTECENTER_NOTEBOTTOM = TIE_NOTECENTER_NOTEBOTTOM,
 
    TIEMODCNCT_NOTECENTER_NOTETOP = TIE_NOTECENTER_NOTETOP,
 
    TIEMODCNCT_DOTRIGHT_NOTECENTER = TIE_DOTRIGHT_NOTECENTER,
 
    TIEMODCNCT_ACCILEFT_NOTECENTER = TIE_ACCILEFT_NOTECENTER,
 
    TIEMODCNCT_ENTRYCENTER_NOTEBOTTOM = TIE_ENTRYCENTER_NOTEBOTTOM,
 
    TIEMODCNCT_ENTRYCENTER_NOTETOP = TIE_ENTRYCENTER_NOTETOP,
 
    TIEMODCNCT_NOTELEFT_NOTEBOTTOM = TIE_NOTELEFT_NOTEBOTTOM,
 
    TIEMODCNCT_NOTERIGHT_NOTEBOTTOM = TIE_NOTERIGHT_NOTEBOTTOM,
 
    TIEMODCNCT_NOTELEFT_NOTETOP = TIE_NOTELEFT_NOTETOP,
 
    TIEMODCNCT_NOTERIGHT_NOTETOP = TIE_NOTERIGHT_NOTETOP,
 
    TIEMODCNCT_SYSTEMEND = TIE_SYSTEMEND,
 
    TIEMODCNCT_SYSTEMSTART = TIE_SYSTEMSTART
};
    
    static_assert(TIEMODCNCT_SYSTEMSTART == (::TIE_NUM_CONNECTIONS-1), "TIEMOD_CONNECTION_CODES does not contain all connection codes in the PDK.");
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
private:
    twobyte _Get3WayValue(const FLAG_16 field, const FLAG_16 localbit, const FLAG_16 onbit) const
    {
        if (! GetBitFlag(field, localbit))
            return TIEMODSEL_DEFAULT;
        if (GetBitFlag(field, onbit))
            return TIEMODSEL_ON;
        return TIEMODSEL_OFF;
    }
    
    void _Set3WayValue(const twobyte value, FLAG_16 &field, const FLAG_16 localbit, const FLAG_16 onbit)
    {
        switch (value)
        {
            default:
            case TIEMODSEL_DEFAULT:
                Set16BitFlag(&field, localbit, false);
                Set16BitFlag(&field, TIEFLG_DOWN, false);
                break;
            case TIEMODSEL_ON:
                Set16BitFlag(&field, localbit, true);
                Set16BitFlag(&field, onbit, true);
                break;
            case TIEMODSEL_OFF:
                Set16BitFlag(&field, localbit, true);
                Set16BitFlag(&field, onbit, false);
                break;
        }
 
    }
    
    void _ActivatePlacementBits(FLAG_16 &epAdj, bool forTieOver, FLAG_16 connectionCode)
    {
        Set16BitFlag(&epAdj, TIEPT_ENDPTADJ_ON, true);
        epAdj &= ~TIEPT_CONTEXT_DIR_MASK;
        if (forTieOver)
            Set16BitFlag(&epAdj, TIEPT_CONTEXT_OVER, true);
        else
            Set16BitFlag(&epAdj, TIEPT_CONTEXT_UNDER, true);
        epAdj &= ~TIEPT_ENTCNCT_MASK;
        epAdj |= (connectionCode & TIEPT_ENTCNCT_MASK);
    }
public:
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCTieMod(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
             TIEMOD_TIETYPES
#else
             int
#endif
             tietype
        ) : __FCEntryDetailNoteID()
    {
       memset(&_tiemod, 0, sizeof(_tiemod));
       _datablock = &_tiemod;
       _loadedsize = DataSizeLoad();
        _starttie = (tietype != TIEMODTYPE_TIEEND);
       SetCustomTag(_starttie ? ed_TieModsStart : ed_TieModsEnd);
    }
 
    bool IsStartTie() const { return _starttie; }
    
    bool IsStartPointActive() const { return GetBitFlag(_tiemod.stPtAdj, TIEPT_ENDPTADJ_ON); }
 
    void ActivateStartPoint(bool fortieover,
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
             TIEMOD_CONNECTION_CODES
#else
             int
#endif
            connectioncode, Evpu16 hoffset, Evpu16 voffset)
    {
        _ActivatePlacementBits(_tiemod.stPtAdj, fortieover, connectioncode);
        _tiemod.xStart = hoffset;
        _tiemod.yStart = voffset;
    }
    
    void DeactivateStartPoint()
    {
        ActivateStartPoint(false, TIEMODCNCT_NONE, 0, 0);
        _tiemod.stPtAdj = 0;
    }
    
    bool IsEndPointActive() const { return GetBitFlag(_tiemod.enPtAdj, TIEPT_ENDPTADJ_ON); }
 
    void ActivateEndPoint(bool fortieover,
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
             TIEMOD_CONNECTION_CODES
#else
             int
#endif
            connectioncode, Evpu16 hoffset, Evpu16 voffset)
    {
        _ActivatePlacementBits(_tiemod.enPtAdj, fortieover, connectioncode);
        _tiemod.xEnd = hoffset;
        _tiemod.yEnd = voffset;
    }
    
    void DeactivateEndPoint()
    {
        ActivateEndPoint(false, TIEMODCNCT_NONE, 0, 0);
        _tiemod.enPtAdj = 0;
    }
    
#ifdef PDK_FRAMEWORK_PREFS
    void LocalizeFromPreferences();
#endif
 
    bool IsContourActive() const { return GetBitFlag(_tiemod.cpFlag, TIECTLPT_ADJ_ON); }
 
    void ActivateContour(twobyte insetleft, twobyte heightleft, twobyte insetright, twobyte heightright, bool fixedinset = false)
    {
        Set16BitFlag(&_tiemod.cpFlag, TIECTLPT_ADJ_ON, true);
        _tiemod.insetRatio1 = insetleft;
        _tiemod.height1 = heightleft;
        _tiemod.insetRatio2 = insetright;
        _tiemod.height2 = heightright;
        Set16BitFlag(&_tiemod.cpFlag, TIECTLPT_FIXED, fixedinset);
    }
    
    void DeactivateContour()
    {
        ActivateContour(0, 0, 0, 0);
        _tiemod.cpFlag = 0;
    }
    
    int GetStartConnectionCode() const
    {
        return IsStartPointActive() ? _tiemod.stPtAdj & TIEPT_ENTCNCT_MASK : TIEMODCNCT_NONE;
    }
 
    twobyte GetStartVerticalPos() const { return IsStartPointActive() ? _tiemod.yStart : 0; }
 
    twobyte GetStartHorizontalPos() const { return IsStartPointActive() ? _tiemod.xStart : 0; }
    
    int GetEndConnectionCode() const
    {
        return IsEndPointActive() ? _tiemod.enPtAdj & TIEPT_ENTCNCT_MASK : TIEMODCNCT_NONE;
    }
 
    twobyte GetEndVerticalPos() const { return IsEndPointActive() ? _tiemod.yEnd : 0; }
 
    twobyte GetEndHorizontalPos() const { return IsEndPointActive() ? _tiemod.xEnd : 0; }
 
    bool GetFixedInsetStyle() const { return IsContourActive() ? GetBitFlag(_tiemod.cpFlag, TIECTLPT_FIXED) : false; }
 
    twobyte GetLeftHeight() const { return IsContourActive() ? _tiemod.height1 : 0; }
 
    twobyte GetRightHeight() const { return IsContourActive() ? _tiemod.height2 : 0; }
 
    twobyte GetLeftInset() const { return IsContourActive() ? _tiemod.insetRatio1 : 0; }
 
    twobyte GetRightInset() const { return IsContourActive() ? _tiemod.insetRatio2 : 0; }
 
    twobyte GetTieDirection() const
    {
        if (! GetBitFlag(_tiemod.flag, TIEFLG_FREEZE))
            return TIEMODDIR_AUTOMATIC;
        if (! GetBitFlag(_tiemod.flag, TIEFLG_DOWN))
            return TIEMODDIR_OVER;
        return TIEMODDIR_UNDER;
    }
 
    twobyte GetBreakForTimeSignature() const { return _Get3WayValue(_tiemod.flag, TIEFLG_BREAK_TIME_LOCAL, TIEFLG_BREAK_TIME_ON); }
 
    twobyte GetBreakForKeySignature() const { return _Get3WayValue(_tiemod.flag, TIEFLG_KEY_LOCAL, TIEFLG_BREAK_KEY_ON); }
 
    twobyte GetOuterPlacement() const { return _Get3WayValue(_tiemod.tiePlacementOpts, TIE_PLC_OUTER_LOCAL, TIE_PLC_OUTER_ON); }
 
    bool GetAvoidStaffLines() const { return ! GetBitFlag(_tiemod.flag, TIEFLG_NO_SPECIAL_ARC); }
 
    void SetStartVerticalPos(twobyte pos) { if (IsStartPointActive()) _tiemod.yStart = pos; }
 
    void SetStartHorizontalPos(twobyte pos) { if (IsStartPointActive()) _tiemod.xStart = pos; }
 
    void SetEndVerticalPos(twobyte pos) { if (IsEndPointActive()) _tiemod.yEnd = pos; }
 
    void SetEndHorizontalPos(twobyte pos) { if (IsEndPointActive()) _tiemod.xEnd = pos; }
 
    void SetFixedInsetStyle(bool value) { if (IsContourActive()) Set16BitFlag(&_tiemod.cpFlag, TIECTLPT_FIXED, value); }
 
    void SetLeftHeight(twobyte value) { if (IsContourActive()) _tiemod.height1 = value; }
 
    void SetRightHeight(twobyte value) { if (IsContourActive()) _tiemod.height2 = value; }
 
    void SetLeftInset(twobyte value) { if (IsContourActive()) _tiemod.insetRatio1 = value; }
 
    void SetRightInset(twobyte value) { if (IsContourActive()) _tiemod.insetRatio2 = value; }
 
    void SetTieDirection(twobyte value)
    {
        switch (value)
        {
            default:
            case TIEMODDIR_AUTOMATIC:
                Set16BitFlag(&_tiemod.flag, TIEFLG_FREEZE, false);
                Set16BitFlag(&_tiemod.flag, TIEFLG_DOWN, false);
                break;
            case TIEMODDIR_OVER:
                Set16BitFlag(&_tiemod.flag, TIEFLG_FREEZE, true);
                Set16BitFlag(&_tiemod.flag, TIEFLG_DOWN, false);
                break;
            case TIEMODDIR_UNDER:
                Set16BitFlag(&_tiemod.flag, TIEFLG_FREEZE, true);
                Set16BitFlag(&_tiemod.flag, TIEFLG_DOWN, true);
                break;
        }
    }
 
    void SetBreakForTimeSignature(twobyte value) { _Set3WayValue(value, _tiemod.flag, TIEFLG_BREAK_TIME_LOCAL, TIEFLG_BREAK_TIME_ON); }
 
    void SetBreakForKeySignature(twobyte value) { _Set3WayValue(value, _tiemod.flag, TIEFLG_KEY_LOCAL, TIEFLG_BREAK_KEY_ON); }
 
    void SetOuterPlacement(twobyte value) { _Set3WayValue(value, _tiemod.tiePlacementOpts, TIE_PLC_OUTER_LOCAL, TIE_PLC_OUTER_ON); }
 
    void SetAvoidStaffLines(bool value) { Set16BitFlag(&_tiemod.flag, TIEFLG_NO_SPECIAL_ARC, !value); }
 
    void SetNoteID(twobyte id) override { _tiemod.noteID = id; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _IsNoteIDMatch(void *pBuffer, twobyte id) override
    {
        return (((EDTTieMods*) pBuffer)->noteID == id);
    }
 
    void _SetEntryFlagN(FCNote* pNote, bool state) override
    {
        pNote->_SetSpecialAltsEntryFlag(state);
    }
 
    bool _GetEntryFlagN(FCNote* pNote) override
    {
        return pNote->_GetSpecialAltsEntryFlag();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
class FCBrokenBeamMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTBrokenBeamMods _brokenbeammod;
 
protected:
    EXTAG Tag() const override { return ed_BrokenBeamMods; }
    int DataSizeLoad() const override { return sizeof(EDTBrokenBeamMods); }
    int DataSizeSave() const override { return sizeof(EDTBrokenBeamMods); }
    void* Allocate() override { return (void*) &_brokenbeammod; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_brokenbeammod, ((FCBrokenBeamMod*)pSource)->_GetBrokenBeamMod(), sizeof(_brokenbeammod));
        _datablock = &_brokenbeammod;
        _loadedsize = sizeof(_brokenbeammod);
    }
 
    __FCBaseData* CreateObject() override { return new FCBrokenBeamMod(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCBrokenBeamMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_BROKENBEAMMOD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTBrokenBeamMods* _GetBrokenBeamMod() { return &_brokenbeammod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCBrokenBeamMod() : __FCEntryDetail()
    {
       _datablock = &_brokenbeammod;
       memset(&_brokenbeammod, 0, sizeof(_brokenbeammod));
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state) override
    {
        pNoteEntry->SetStemDetailFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 
    void SetLeftDirection(bool leftdirection)
    {
        // The PDK treats beamdir as a bitwise value that allows each broken beam to be changed separately,
        // however, the Finale UI does not support this. Hence, for now this is a boolean function.
        _brokenbeammod.beamdir = leftdirection ? -1 : 0;
    }
 
    bool GetLeftDirection() const
    {
        // The PDK treats beamdir as a bitwise value that allows each broken beam to be changed separately,
        // however, the Finale UI does not support this. Hence, for now this is a boolean function.
        return _brokenbeammod.beamdir != 0;
    }
};
 
 
 
 
 
class FCTablatureNoteMod : public __FCEntryDetailNoteID
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTablatureMods _tablaturemod;
    
protected:
    EXTAG Tag() const override { return ed_TablatureMods; }
    int DataSizeLoad() const override { return sizeof(EDTTablatureMods); }
    int DataSizeSave() const override { return sizeof(EDTTablatureMods); }
    void* Allocate() override { return (void*) &_tablaturemod; }
    
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_tablaturemod, ((FCTablatureNoteMod*)pSource)->_GetTablatureMod(), sizeof(_tablaturemod));
        _datablock = &_tablaturemod;
        _loadedsize = sizeof(_tablaturemod);
    }
    
    __FCBaseData* CreateObject() override { return new FCTablatureNoteMod(); }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCTablatureNoteMod"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TABLATURENOTEMOD; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTablatureMods* _GetTablatureMod() { return &_tablaturemod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
    FCTablatureNoteMod() : __FCEntryDetailNoteID()
    {
        memset(&_tablaturemod, 0, sizeof(_tablaturemod));
        _datablock = &_tablaturemod;
        _loadedsize = sizeof(_tablaturemod);
        _tablaturemod.stringNumber = 1;
    }
    
    twobyte GetStringNumber() const
    {
        return _tablaturemod.stringNumber;
    }
 
    void SetStringNumber(twobyte value)
    {
        if (value < 1) return;
        if (value > 24) return;
        _tablaturemod.stringNumber = value;
    }
    
    void SetNoteID(twobyte id) override { _tablaturemod.noteID = id; }
    
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _IsNoteIDMatch(void *pBuffer, twobyte id) override
    {
        return (((EDTTablatureMods*) pBuffer)->noteID == id);
    }
    
    void _SetEntryFlagN(FCNote* pNote, bool state) override
    {
        pNote->_SetNoteDetailEntryFlag(state);
    }
    
    bool _GetEntryFlagN(FCNote* pNote) override
    {
        return pNote->_GetNoteDetailEntryFlag();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};
 
 
#endif // #ifdef PDK_FRAMEWORK_ENTRIES
 
 
#endif  /* FF_ENTRYDETAILS_H */