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
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;
    }

    void SetEntnumAndInci(ENTNUM entnum, twobyte inci)
    {
        _dataid.entryDetail.entryNumber = entnum;
        _dataid.entryDetail.inci = inci;
    }

    virtual bool Load(ENTNUM entnum, twobyte inci);

    virtual bool Reload();

    bool SaveAs(ENTNUM entnum, twobyte inci);

    virtual bool LoadFirst()
    {
        if (!_pMappedEntry) return false;
                return Load(_pMappedEntry->GetEntryNumber(), 0);
    }

    virtual bool LoadNext();

    virtual void SetNoteEntry(FCNoteEntry* 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

    virtual twobyte CalcLastInci();
#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
    virtual void DebugDump()
    {
        __FCBaseData::DebugDump();
        DebugOutDigit("_dataid.entryDetail.entryNumber: ", _dataid.entryDetail.entryNumber);
        DebugOutDigit("_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() {}

    virtual bool SaveNew();

    bool SaveAt(FCNote* pNote);

    bool LoadAt(FCNote* pNote);

    bool EraseAt(FCNote* pNote);

#ifndef DOXYGEN_SHOULD_SKIP_THIS

    virtual twobyte CalcLastInci();
    
    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:
    virtual EXTAG Tag() { return ed_NoteheadMods2002; }  /* Same tag for 2002 and 2012 versions */
    virtual int DataSizeLoad();
    virtual int DataSizeSave();
    virtual void* Allocate();
    virtual EVERSION EnigmaVersion()
    {
        if (_Use2012Version()) return FINALEVERSION_2012;
        return FXT_VERSION_2K2_BASE;
    }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
            memcpy(_GetNoteheadMod(), ((FCNoteheadMod*)pSource)->_GetNoteheadMod(), DataSizeLoad());
            _datablock = _GetNoteheadMod();
            _loadedsize = DataSizeLoad();
    }

    virtual __FCBaseData* CreateObject() { return new FCNoteheadMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCNoteheadMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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;
    }

    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->GetNameByID();
    }

    void SetCustomChar(eUniChar32 ch)
    {        
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            _noteheadmod2012.fontchar = ch;
            return;
        }
#endif
        _noteheadmod.fontchar = 0xff00 | (ch & 0x00ff);
    }

    void ClearChar()
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            _noteheadmod2012.fontchar = 0;
            return;
        }
#endif
        _noteheadmod.fontchar = 0;
    }

    virtual void SetNoteID(twobyte id) 
    {
        twobyte* pValue = (twobyte*) _GetNoteIDPtr();
        *pValue = id;
    }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
    {
#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:
    virtual EXTAG Tag() { return ed_DotMods; }
    virtual int DataSizeLoad() { return sizeof(EDTDotMods); }
    virtual int DataSizeSave() { return sizeof(EDTDotMods); }
    virtual void* Allocate() { return (void*) &_dotmod; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_dotmod, ((FCDotMod*)pSource)->_GetDotMod(), sizeof(_dotmod));
        _datablock = &_dotmod;
        _loadedsize = sizeof(_dotmod);
    }

    virtual __FCBaseData* CreateObject() { return new FCDotMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCDotMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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; }

    virtual void SetNoteID(twobyte id) { _dotmod.noteID = id; }

    bool LoadRestDotAt(FCNoteEntry* pEntry);

    bool SaveRestDotAt(FCNoteEntry* pEntry);

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
    {
        return (((EDTDotMods*) pBuffer)->noteID == id);
    }

    virtual void _SetEntryFlagN(FCNote* pNote, bool state)
    {        
        pNote->_SetSpecialAltsEntryFlag(state);
    }

    virtual bool _GetEntryFlagN(FCNote* pNote)
    {
        return pNote->_GetSpecialAltsEntryFlag();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};



class FCCrossStaffMod : public __FCEntryDetailNoteID
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTCrossStaff _crossstaff;

protected:
    virtual EXTAG Tag() { return ed_CrossStaff; }
    virtual int DataSizeLoad() { return sizeof(EDTCrossStaff); }
    virtual int DataSizeSave() { return sizeof(EDTCrossStaff); }
    virtual void* Allocate() { return (void*) &_crossstaff; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_crossstaff, ((FCCrossStaffMod*)pSource)->_GetCrossStaff(), sizeof(_crossstaff));
        _datablock = &_crossstaff;
        _loadedsize = sizeof(_crossstaff);
    }

    virtual __FCBaseData* CreateObject() { return new FCCrossStaffMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCCrossStaffMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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; }
     
    virtual void SetNoteID(twobyte id) { _crossstaff.noteID = id; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
    {
        return (((EDTCrossStaff*) pBuffer)->noteID == id);
    }

    virtual void _SetEntryFlagN(FCNote* pNote, bool state)
    {
        pNote->_SetCrossStaffEntryFlag(state);  /* Set flag for entry */
        pNote->SetCrossStaff(state); /* Set flag for note */
    }

    virtual bool _GetEntryFlagN(FCNote* pNote)
    {
        return pNote->_GetCrossStaffEntryFlag(); /* Return flag for entry */
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};




class FCSecondaryBeamBreakMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTSecondaryBeamBreakMods _secondarybeambreakmod;
    protected:
    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_SecondaryBeamBreakMods; }
    virtual int DataSizeLoad() { return sizeof(EDTSecondaryBeamBreakMods); }
    virtual int DataSizeSave() { return sizeof(EDTSecondaryBeamBreakMods); }
    virtual void* Allocate() { return (void*) &_secondarybeambreakmod; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_secondarybeambreakmod, ((FCSecondaryBeamBreakMod*)pSource)->_GetSecondaryBeamBreakMod(), sizeof(_secondarybeambreakmod));
        _datablock = &_secondarybeambreakmod;
        _loadedsize = sizeof(_secondarybeambreakmod);
    }

    virtual __FCBaseData* CreateObject() { return new FCSecondaryBeamBreakMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCSecondaryBeamBreakMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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);
    }

    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

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        pNoteEntry->SetSecondaryBeamFlag(state);
    }    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};


class FCStemMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStemMods _stemmod;

protected:
    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_StemMods; }
    virtual int DataSizeLoad() { return sizeof(EDTStemMods); }
    virtual int DataSizeSave() { return sizeof(EDTStemMods); }
    virtual void* Allocate() { return (void*) &_stemmod; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_stemmod, ((FCStemMod*)pSource)->_GetStemMod(), sizeof(_stemmod));
        _datablock = &_stemmod;
        _loadedsize = sizeof(_stemmod);
    }

    virtual __FCBaseData* CreateObject() { return new FCStemMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCStemMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        pNoteEntry->SetStemDetailFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    twobyte GetVerticalUpOffset() const { return _stemmod.topVertAdjust; }

    twobyte GetVerticalDownOffset() const { return _stemmod.downVertAdjust; }

    twobyte GetHorizontalUpOffset() const
    {
        twobyte returnval = HIBYTE(_stemmod.horizAdjust);
        if (returnval & 0x80)
        {
            /* Negative */
            returnval &= ~0x80;
            returnval = -returnval;
        }
        return returnval;
    }

    twobyte GetHorizontalDownOffset() const { return _stemmod.horizAdjust & 0xff; }

    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
        EDTArticulation _articulation;
#if FXT_VERSION >= FINALEVERSION_2014B
        EDTArticulation2014b _articulation2014b;
#endif
        bool _use2014b;
protected:    
    virtual int DataSizeLoad();
    virtual int DataSizeSave();
    virtual void* Allocate();

    virtual void CloneMemoryFrom(__FCBaseData* pSource);

    virtual __FCBaseData* CreateObject() { return new FCArticulation(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual EXTAG Tag() { return ed_Articulation; }
    virtual const char* ClassName() { return "FCArticulation"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_ARTICULATION; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetArticulation() const;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCArticulation();

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        pNoteEntry->SetArticulationFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    void SetArticulationDef(FCArticulationDef* pDef) 
    {
        if (!pDef) return;
        ((EDTArticulation*)_GetArticulation())->imrkdef = pDef->GetItemNo();
    }

    void SetID(CMPER cmper) { ((EDTArticulation*)_GetArticulation())->imrkdef = cmper; }

    void SetHorizontalPos(twobyte pos)
    {
        ((EDTArticulation*)_GetArticulation())->posadd = pos;
    }

    void SetVerticalPos(twobyte pos)
    {
        ((EDTArticulation*)_GetArticulation())->noteadd = pos;
    }

    bool GetVisible() const;

    void SetVisible(bool state);

    twobyte GetHorizontalPos() const { return ((EDTArticulation*)_GetArticulation())->posadd; }

    twobyte GetVerticalPos() const { return ((EDTArticulation*)_GetArticulation())->noteadd; }

    twobyte GetID() const { return ((EDTArticulation*)_GetArticulation())->imrkdef; }

    FCArticulationDef* CreateArticulationDef();

#if PDK_FRAMEWORK_LUAFRIENDLY

    FCArticulationDef* CreateArticulationDef_GC();
#endif

    bool CalcMetricPos(FCPoint* pPoint);

    bool CalcFlippedSymbolUsed();

    void ResetPos(FCArticulationDef* pDef)
    {
        SetHorizontalPos(0);
        SetVerticalPos(pDef->GetDefaultVerticalPos());
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCEntryDetail::DebugDump();
        DebugOutDigit("Articulation ID: ", GetID());
        DebugOutDigit("Horizontal position: ", GetHorizontalPos());
        DebugOutDigit("Vertical position: ", GetVerticalPos());
    }
#endif
};




class FCTuplet : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTTuplet2005 _tuplet;

protected:    
    virtual int DataSizeLoad() { return sizeof(EDTTuplet2005); }
    virtual int DataSizeSave() { return sizeof(EDTTuplet2005); }
    virtual void* Allocate() { return (void*) &_tuplet; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_tuplet, ((FCTuplet*)pSource)->_GetTuplet(), sizeof(_tuplet));
        _datablock = &_tuplet;
        _loadedsize = sizeof(_tuplet);
    }

    virtual __FCBaseData* CreateObject()
        { return new FCTuplet(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    virtual EXTAG Tag() { 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
        };

    virtual const char* ClassName() { return "FCTuplet"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        pNoteEntry->SetTupletStartFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */



#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __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;
        }
        DebugOutDigit("Horizontal offset: ", GetHorizontalOffset());
        DebugOutDigit("Vertical offset: ", GetVerticalOffset());
        DebugOutBool("Center number using duration: ", GetCenterUsingDuration());
        DebugOutBool("Ignore Horizontal Number Offset: ", GetIgnoreNumberOffset());
        DebugOutDigit("Horizontal shape offset: ", GetHorizontalShapeOffset());
        DebugOutDigit("Vertical shape offset: ", GetVerticalShapeOffset());
        DebugOutBool("Always flat: ", GetAlwaysFlat());
        DebugOutBool("Bracket full duration: ", GetBracketFullDuration());
        DebugOutBool("Match length of hooks: ", GetMatchHookLengths());
        DebugOutDigit("Left hook length: ", GetLeftHookLength());
        DebugOutDigit("Left hook extension: ", GetLeftExtension());
        DebugOutDigit("Right hook length: ", GetRightHookLength());
        DebugOutDigit("Right hook extension: ", GetRightExtension());
        DebugOutDigit("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);
    
    FCFontInfo* _CreateFontInfo(twobyte syllablenumber);
protected:
    virtual int DataSizeLoad() { return sizeof(EDTLyric2011); }
    virtual int DataSizeSave() { return sizeof(EDTLyric2011); }
    virtual void* Allocate() { return (void*) &_syllable; }
    
    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_syllable, ((FCSyllableBase*)pSource)->_GetSyllable(), sizeof(_syllable));
        _datablock = &_syllable;
        _loadedsize = sizeof(_syllable);
    }
    
    virtual __FCBaseData* CreateObject() { return NULL; }  /* Defined by inherited class!!! */
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    
    virtual EXTAG Tag() { return 0; };  /* Defined by inherited class */
    
    virtual const char* ClassName() { 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(Tag(), GetRawTextNumber(), GetSyllableNumber(),
                NULL, 0, NULL, NULL, NULL, NULL) != 0;
    }

    virtual bool IsVerse() { return false; }

    virtual bool IsChorus() { return false; }

    virtual bool IsSection() { return false; }

    bool CalcHyphen()
    {
        tbool hyphen = false;        
        if (FX_SyllableInfo(Tag(), GetRawTextNumber(), GetSyllableNumber(),
                NULL, 0, NULL, NULL, &hyphen, NULL) == 0) return false;
        return hyphen != 0;
    }

    int CalcStringPos();

    int CalcNextStringPos();

    __FCLyricsBase* CreateLyricText();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    __FCLyricsBase* CreateLyricText_GC();
#endif

    FCFontInfo* CreateFontInfo();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCFontInfo* CreateFontInfo_GC();
#endif
    
    FCFontInfo* CreateNextFontInfo();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCFontInfo* CreateNextFontInfo_GC();
#endif
    
    bool GetText(FCString* pString);

    bool GetRawText(FCString* pString);

    bool SaveRawText(FCString* pString);
    
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        pNoteEntry->SetLyricFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
    
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCEntryDetail::DebugDump();
        DebugOutHex("lyrFlags: ", _syllable.lyrFlags);
    }
#endif
};

class FCVerseSyllable : public FCSyllableBase
{
    virtual __FCBaseData* CreateObject() { return new FCVerseSyllable(); }
public:
    virtual EXTAG Tag();
    virtual const char* ClassName() { return "FCVerseSyllable"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_VERSESYLLABLE; }

    virtual bool IsVerse() { return true; }
};

class FCChorusSyllable : public FCSyllableBase
{
    virtual __FCBaseData* CreateObject() { return new FCChorusSyllable(); }
public:
    virtual EXTAG Tag();
    virtual const char* ClassName() { return "FCChorusSyllable"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CHORUSSYLLABLE; }
    virtual bool IsChorus() { return true; }
};

class FCSectionSyllable : public FCSyllableBase
{
    virtual __FCBaseData* CreateObject() { return new FCSectionSyllable(); }
public:
    virtual EXTAG Tag();
    virtual const char* ClassName() { return "FCSectionSyllable"; } 
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SECTIONSYLLABLE; }
    virtual bool IsSection() { return true; }
};

#endif /* #ifdef __SHOULD_INCLUDE_SYLLABLE_CODE */



class FCSyllableEntryMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTLyricEntryInfo _lyricinfo;
protected:
    virtual EXTAG Tag() { return ed_LyricEntryInfo; }
    virtual int DataSizeLoad() { return sizeof(EDTLyricEntryInfo); }
    virtual int DataSizeSave() { return sizeof(EDTLyricEntryInfo); }
    virtual void* Allocate() { return (void*) &_lyricinfo; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_lyricinfo, ((FCSyllableEntryMod*)pSource)->_GetSyllableEntryMod(), sizeof(_lyricinfo));
        _datablock = &_lyricinfo;
        _loadedsize = sizeof(_lyricinfo);
    }

    virtual __FCBaseData* CreateObject() { 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
    };

    virtual const char* ClassName() { return "FCSyllableEntryMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        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
    virtual void DebugDump()
    {
        __FCEntryDetail::DebugDump();        
    }
#endif

};

class FCEntryAlterMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTAlter _alter;

protected:
    virtual EXTAG Tag() { return ed_Alter; }
    virtual int DataSizeLoad() { return sizeof(EDTAlter); }
    virtual int DataSizeSave() { return sizeof(EDTAlter); }
    virtual void* Allocate() { return (void*) &_alter; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_alter, ((FCEntryAlterMod*)pSource)->_GetAlterMod(), sizeof(_alter));
        _datablock = &_alter;
        _loadedsize = sizeof(_alter);
    }

    virtual __FCBaseData* CreateObject() { return new FCEntryAlterMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCEntryAlterMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        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
    virtual void DebugDump()
    {
        __FCEntryDetail::DebugDump();
        DebugOutDigit("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:
    virtual EXTAG Tag() { return ed_AccidentalMods2001; }
    virtual int DataSizeLoad();
    virtual int DataSizeSave();
    virtual void* Allocate();
    virtual EVERSION EnigmaVersion()
    {
        if (_Use2012Version()) return FINALEVERSION_2012;
        return FXT_VERSION_2K2_BASE;
    }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(_GetAccidentalMod(), ((FCAccidentalMod*)pSource)->_GetAccidentalMod(), DataSizeLoad());
        _datablock = _GetAccidentalMod();
        _loadedsize = DataSizeLoad();
    }

    virtual __FCBaseData* CreateObject() { return new FCAccidentalMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCAccidentalMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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->GetNameByID();
    }

    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;
    }
    
    virtual void SetNoteID(twobyte id)
    {
        twobyte* pValue = (twobyte*) _GetNoteIDPtr();
        *pValue = id;
    }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
    {
#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:
    virtual EXTAG Tag() { return ed_PercNoteCode    ; }
    virtual int DataSizeLoad() { return sizeof(EDTPercNoteCode); }
    virtual int DataSizeSave() { return sizeof(EDTPercNoteCode); }
    virtual void* Allocate() { return (void*) &_percnotemod; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_percnotemod, ((FCPercussionNoteMod*)pSource)->_GetPercussionNoteMod(), sizeof(_percnotemod));
        _datablock = &_percnotemod;
        _loadedsize = sizeof(_percnotemod);
    }

    virtual __FCBaseData* CreateObject() { return new FCPercussionNoteMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCPercussionNoteMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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; }

    virtual void SetNoteID(twobyte id) { _percnotemod.noteID = id; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
    {
        return (((EDTPercNoteCode*) pBuffer)->noteID == id);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};


class FCCustomStemMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTCustomStemMods _customstemmod;

protected:
    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_StemMods; }
    virtual int DataSizeLoad() { return sizeof(EDTCustomStemMods); }
    virtual int DataSizeSave() { return sizeof(EDTCustomStemMods); }
    virtual void* Allocate() { return (void*) &_customstemmod; }

    virtual EVERSION EnigmaVersion() { return FXT_VERSION_2K5_BASE; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_customstemmod, ((FCStemMod*)pSource)->_GetStemMod(), sizeof(_customstemmod));
        _datablock = &_customstemmod;
        _loadedsize = sizeof(_customstemmod);
    }

    virtual __FCBaseData* CreateObject() { return new FCCustomStemMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCCustomStemMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        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 _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 _PreSaveSetup()
    {
        if (_secondarybeamuse)
        {
            _beammod.beamWidth = -1;
            if (_beammod.secondaryBeamEdu == 0)
            {
                SetBeamNumber(_secondarybeamnumber);
            }
        }
        else
        {
            _beammod.secondaryBeamEdu = 0;
        }
    }

protected:
    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_BeamBelowMods; }
    virtual int DataSizeLoad() { return sizeof(EDTBeamMods); }
    virtual int DataSizeSave() { return sizeof(EDTBeamMods); }
    virtual void* Allocate() { return (void*) &_beammod; }

    virtual EVERSION EnigmaVersion() { return FXT_VERSION_2K5_BASE; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        FCBeamMod* pSourceMod = (FCBeamMod*) pSource;
        memcpy(&_beammod, pSourceMod->_GetBeamMod(), sizeof(_beammod));        
        _datablock = &_beammod;
        _loadedsize = sizeof(_beammod);
        _secondarybeamuse = pSourceMod->IsSecondaryBeam();
       _upstemuse = pSourceMod->IsUpStem();
       _secondarybeamnumber = pSourceMod->GetBeamNumber();
    }

    virtual __FCBaseData* CreateObject() { return new FCBeamMod(_secondarybeamuse); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCBeamMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_BEAMMOD; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTBeamMods* _GetBeamMod() { return &_beammod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCBeamMod(bool secondarybeam) : __FCEntryDetail()
    {
       _datablock = &_beammod;
       memset(&_beammod, 0, sizeof(_beammod));
       _beammod.mode = 2;  /* Defaults to "Flatten Beams Based On Standard Note */
       _loadedsize = sizeof(_beammod);

       _secondarybeamuse = secondarybeam;
       _upstemuse = false;
       _secondarybeamnumber = 2;
       SetCustomTag(_secondarybeamuse ? ed_BeamBelowModsSecondary : ed_BeamBelowMods);

       SetDefaultBeamThickness();
#ifdef PDK_FRAMEWORK_PREFS
       SetDefaultMode();
#endif
    }

    #ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        pNoteEntry->SetStemDetailFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    virtual bool Load(ENTNUM entnum, twobyte inci)
    {
        /* 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;
    }

    virtual bool Save()
    {
        _PreSaveSetup();
        return __FCEntryDetail::Save();
    }

    virtual bool SaveNew()
    {
        _PreSaveSetup();
       return __FCEntryDetail::SaveNew();
    }

    virtual void SetNoteEntry(FCNoteEntry* 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() { return _beammod.mode; }

    twobyte GetBeamDuration()
    {
        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; }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCEntryDetail::DebugDump();
        DebugOutDigit("Beam Duration: ", GetBeamDuration());
        DebugOutDigit("Beam Number: ", GetBeamNumber());
        DebugOutDigit("mode: ", _beammod.mode);
        DebugOutDigit("Left Vertical offset: ", GetLeftVerticalOffset());
        DebugOutDigit("Right Vertical offset: ", GetRightVerticalOffset());
        DebugOutBlock(&_beammod, 0, sizeof(_beammod));
    }
#endif
};


class FCPerformanceMod : public __FCEntryDetailNoteID
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EDTPerformanceData _performancedata;

protected:
    virtual EXTAG Tag() { return ed_PerformanceData; }
    virtual int DataSizeLoad() { return sizeof(EDTPerformanceData); }
    virtual int DataSizeSave() { return sizeof(EDTPerformanceData); }
    virtual void* Allocate() { return (void*) &_performancedata; }
    virtual EVERSION EnigmaVersion() { return FXT_VERSION_2K2_BASE; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_performancedata, ((FCPerformanceMod*)pSource)->_GetPerformanceMod(), sizeof(_performancedata));
        _datablock = &_performancedata;
        _loadedsize = sizeof(_performancedata);
    }

    virtual __FCBaseData* CreateObject() { return new FCPerformanceMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCPerformanceMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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;
    }

    virtual void SetNoteID(twobyte id) { _performancedata.noteID = id; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
    {
        return (((EDTPerformanceData*) pBuffer)->noteID == id);
    }

    virtual void _SetEntryFlagN(FCNote* pNote, bool state)
    {
        pNote->_SetPerformanceDataEntryFlag(state);
    }

    virtual bool _GetEntryFlagN(FCNote* pNote)
    {
        return pNote->_GetPerformanceDataEntryFlag();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};


class FCTieMod : public __FCEntryDetailNoteID
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        bool _starttie;
        EDTTieMods _tiemod;

protected:
    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_TieModsStart; }
    virtual int DataSizeLoad() { return sizeof(EDTTieMods); }
    virtual int DataSizeSave() { return sizeof(EDTTieMods); }
    virtual void* Allocate() { return (void*) &_tiemod; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        FCTieMod* pTieSource = (FCTieMod*) pSource;
        memcpy(&_tiemod, pTieSource->_GetTieMod(), sizeof(_tiemod));
        _datablock = &_tiemod;
        _loadedsize = sizeof(_tiemod);
        _starttie = pTieSource->IsStartTie();
    }

    virtual __FCBaseData* CreateObject() { return new FCTieMod(_starttie); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCTieMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TIEMOD; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTTieMods* _GetTieMod() { return &_tiemod; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCTieMod(bool starttie) : __FCEntryDetailNoteID()
    {

       memset(&_tiemod, 0, sizeof(_tiemod));
       _tiemod.tiePlacementOpts = 0x03ff;
       _tiemod.stPtAdj = 0x6006;
       _tiemod.enPtAdj = 0x6006;

       _datablock = &_tiemod;
       _loadedsize = sizeof(_tiemod);
       SetCustomTag(starttie ? ed_TieModsStart : ed_TieModsEnd);
       _starttie = starttie;
    }

    bool IsStartTie() { return _starttie; }

    twobyte GetStartVerticalPos() { return _tiemod.yStart; }

    twobyte GetEndVerticalPos() { return _tiemod.yEnd; }

    void SetStartVerticalPos(twobyte pos) { _tiemod.yStart = pos; }

    void SetEndVerticalPos(twobyte pos) { _tiemod.yEnd = pos; }

    virtual void SetNoteID(twobyte id) { _tiemod.noteID = id; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
    {
        return (((EDTTieMods*) pBuffer)->noteID == id);
    }

    virtual void _SetEntryFlagN(FCNote* pNote, bool state)
    {
        pNote->_SetSpecialAltsEntryFlag(state);
    }

    virtual bool _GetEntryFlagN(FCNote* pNote)
    {
        return pNote->_GetSpecialAltsEntryFlag();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};

class FCBrokenBeamMod : public __FCEntryDetail
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTBrokenBeamMods _brokenbeammod;

protected:
    virtual EXTAG Tag() { return ed_BrokenBeamMods; }
    virtual int DataSizeLoad() { return sizeof(EDTBrokenBeamMods); }
    virtual int DataSizeSave() { return sizeof(EDTBrokenBeamMods); }
    virtual void* Allocate() { return (void*) &_brokenbeammod; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_brokenbeammod, ((FCBrokenBeamMod*)pSource)->_GetBrokenBeamMod(), sizeof(_brokenbeammod));
        _datablock = &_brokenbeammod;
        _loadedsize = sizeof(_brokenbeammod);
    }

    virtual __FCBaseData* CreateObject() { return new FCBrokenBeamMod(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCBrokenBeamMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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

    virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
    {
        pNoteEntry->SetStemDetailFlag(state);
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */


    void SetLeftDirection(bool leftdirection)
    {
        _brokenbeammod.beamdir = leftdirection ? -1 : 0;
    }

};





class FCTablatureNoteMod : public __FCEntryDetailNoteID
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTablatureMods _tablaturemod;
    
protected:
    virtual EXTAG Tag() { return ed_TablatureMods; }
    virtual int DataSizeLoad() { return sizeof(EDTTablatureMods); }
    virtual int DataSizeSave() { return sizeof(EDTTablatureMods); }
    virtual void* Allocate() { return (void*) &_tablaturemod; }
    
    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_tablaturemod, ((FCTablatureNoteMod*)pSource)->_GetTablatureMod(), sizeof(_tablaturemod));
        _datablock = &_tablaturemod;
        _loadedsize = sizeof(_tablaturemod);
    }
    
    virtual __FCBaseData* CreateObject() { return new FCTablatureNoteMod(); }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCTablatureNoteMod"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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;
    }
    
    virtual void SetNoteID(twobyte id) { _tablaturemod.noteID = id; }
    
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
    {
        return (((EDTTablatureMods*) pBuffer)->noteID == id);
    }
    
    virtual void _SetEntryFlagN(FCNote* pNote, bool state)
    {
        pNote->_SetNoteDetailEntryFlag(state);
    }
    
    virtual bool _GetEntryFlagN(FCNote* pNote)
    {
        return pNote->_GetNoteDetailEntryFlag();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
};




#endif // #ifdef PDK_FRAMEWORK_ENTRIES


#endif  /* FF_ENTRYDETAILS_H */