ff_celldetails.h

/*
 * File:   ff_celldetails.h
 * Author: Jari Williamsson
 *
 * Created on den 3 december 2010, 23:10
 */
 
#ifndef FF_CELLDETAILS_H
#define FF_CELLDETAILS_H
 
#include "ff_cell.h"
#include "ff_region.h"
#include "ff_noteframe.h"
 
#ifdef PDK_FRAMEWORK_ENTRIES
#include <variant>
#endif
 
 
class __FCCellDetail : public __FCBaseData
{
    protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
      FCCell* _pConnectedCell;
 
      virtual void _SaveMeasureFlag() = 0;
    
    private:
        bool _RawRelink() override
        {
            DeleteData();
            return SaveNew();
        }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    public:
        const char* ClassName() const override { return "__FCCellDetail"; }
 
        __FCCellDetail() : __FCBaseData()
        {
            _pConnectedCell = NULL;
        }
 
 
        void ConnectCell(FCCell* pCell) { _pConnectedCell = pCell; }
 
 
        FCCell* GetConnectedCell() const { return _pConnectedCell; }
 
        bool LoadFirst() override;
    
        bool LoadLast() override;
 
        bool LoadNext() override;
    
        bool LoadPrevious() override;
    
        virtual TimeEdu32 GetMeasurePos() const { return 0; }
 
        virtual bool SaveNew();
 
        virtual eMeas GetMeasure() const
        {
            if (GetConnectedCell())
                return GetConnectedCell()->GetMeasure();
            else
                return _dataid.detail.cmper2;
        }
 
        virtual twobyte GetStaff() const
        {
            if (GetConnectedCell())
                return GetConnectedCell()->GetStaff();
            else
                return _dataid.detail.cmper1;
        }
 
#ifdef PDK_FRAMEWORK_DEBUG
        void DebugDump() override
        {
            __FCBaseData::DebugDump();
            DebugOutInt("_dataid.detail.cmper1", _dataid.detail.cmper1);
            DebugOutInt("_dataid.detail.cmper2", _dataid.detail.cmper2);
            DebugOutInt("_dataid.detail.inci", _dataid.detail.inci);
            if (_pConnectedCell)
            {
                DebugOutInt("Cell measure: ", _pConnectedCell->GetMeasure());
                DebugOutInt("Cell staff: ", _pConnectedCell->GetStaff());
            }
        }
 
#endif
};
 
class __FCNoInciCellDetail : public __FCCellDetail
{
    bool LoadFirst() override { return __FCCellDetail::LoadFirst(); }
    bool LoadNext() override { return false; }
    bool SaveNew() override { return false; }
public:
    const char* ClassName() const override { return "__FCNoInciCellDetail"; }
 
   __FCNoInciCellDetail() : __FCCellDetail()
        {
        }
 
   bool Load() { return LoadFirst(); }
};
 
 
class __FCCollectionCellDetail : public __FCCollectionDetail
{
public:
    const char* ClassName() const override { return "__FCCollectionCellDetail"; }
 
    __FCCollectionCellDetail() : __FCCollectionDetail()
    {
    }
 
    virtual int LoadAllInCell(FCCell* pCell);
 
    int LoadAllForRegion(FCMusicRegion* pMusicRegion);
 
    int LoadAll() override;
};
 
class __FCCollectionNoInciCellDetail : public __FCCollectionDetail
{
public:
    const char* ClassName() const override { return "__FCCollectionNoInciCellDetail"; }
 
    __FCCollectionNoInciCellDetail() : __FCCollectionDetail()
    {
    }
 
    int LoadAllInRegion(FCMusicRegion* pMusicRegion);
};
 
 
class FCMidiExpression : public __FCCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTMidiExpression _midiexpression;
 
protected:
    /* No measure flag to set? */
    void _SaveMeasureFlag() override {}
 
    EXTAG Tag() const override { return dt_MidiExpression; }
    int DataSizeLoad() const override { return sizeof(EDTMidiExpression); }
    int DataSizeSave() const override { return sizeof(EDTMidiExpression); }
    void* Allocate() override { return (void*) &_midiexpression; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_midiexpression, ((FCMidiExpression*)pSource)->_GetMidiExpr(), sizeof(_midiexpression));
        _datablock = &_midiexpression;
        _loadedsize = sizeof(_midiexpression);
    }
 
    __FCBaseData* CreateObject() override { return new FCMidiExpression(); }
#endif
public:
    enum MIDI_CONTROLLER_NUMBERS
    {
        PEDAL_CONTROLLER = 64
    };
 
    const char* ClassName() const override { return "FCMidiExpression"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MIDIEXPRESSION; }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTMidiExpression* _GetMidiExpr() { return &_midiexpression; }
#endif
 
    FCMidiExpression() : __FCCellDetail()
    {
        memset(&_midiexpression, 0, sizeof(_midiexpression));
        _loadedsize = sizeof(_midiexpression);
        _datablock = &_midiexpression;
    }
 
    TimeEdu32 GetMeasurePos() const override { return _midiexpression.eldur; }
 
    bool IsController() const { return (LOBYTE(_midiexpression.status) == MIDIEXP_CONTROLLER); }
      
    twobyte GetControllerNumber() const { return IsController() ? _midiexpression.data1 : 0; }
 
    twobyte GetControllerValue() const { return IsController() ? _midiexpression.data2 : 0; }
 
    void SetUseController()
    {
        _midiexpression.status &= 0xff00;
        _midiexpression.status |= MIDIEXP_CONTROLLER;
    }
 
    void SetControllerNumber(twobyte number)
    {
        if (!IsController()) return;
        _midiexpression.data1 = number;
    }
 
    void SetControllerValue(twobyte number)
    {
        if (!IsController()) return;
        _midiexpression.data2 = number;
    }
 
    
    bool IsPressure() const { return (LOBYTE(_midiexpression.status) == MIDIEXP_PRESSURE); }
 
    void SetPressureValue(twobyte value)
    {
        if (!IsPressure()) return;
        if (value < 0) value = 0;
        if (value > 127) value = 127;
        _midiexpression.data1 = value;
    }
 
    twobyte GetPressureValue() const
    {
        if (!IsPressure()) return 0;
        return _midiexpression.data1;
    }
 
    void SetUsePressure()
    {
        _midiexpression.status &= 0xff00;
        _midiexpression.status |= MIDIEXP_PRESSURE;
    }
 
 
    bool IsPitchWheel() const { return (LOBYTE(_midiexpression.status) == MIDIEXP_PITCHWHEEL); }
 
    void SetPitchWheelValue(twobyte value)
    {
        if (!IsPitchWheel()) return;
        if (value > 8192) value = 8192;
        if (value < -8192) value = -8192;
        /* For some unknown reason, data2 & 64 is always true for 0
         * and positive values. */
        bool isnegative = (value < 0);
        _midiexpression.data1 = value & 0x7f;
        value &= ~0x7f;
        value /= 0x80;
        value &= 0x3f;
        _midiexpression.data2 = value;
        if (!isnegative) _midiexpression.data2 |= 0x40;
    }
 
    twobyte GetPitchWheelValue() const
    {
        if (!IsPitchWheel()) return 0;
        /* For some unknown reason, data2 & 64 is always true for 0
         * and positive values. */
        bool isnegative = (_midiexpression.data2 & 0x20) != 0;
        twobyte result = (_midiexpression.data1 & 0x7f);
        result = result | ((_midiexpression.data2 & 0x3f) * 0x80);
        if (isnegative) 
        {
            result = 0x2000 - result;
            result = -result;
        }        
        return result;
    }
 
    void SetUsePitchWheel()
    {
        _midiexpression.status &= 0xff00;
        _midiexpression.status |= MIDIEXP_PITCHWHEEL;
    }
 
    bool IsPatchChange() const { return (LOBYTE(_midiexpression.status) == MIDIEXP_PATCH_CHANGE); }
    
    void SetUsePatchChange()
    {
        _midiexpression.status &= 0xff00;
        _midiexpression.status |= MIDIEXP_PATCH_CHANGE;
    }
    
    void SetPatchChangeMode(twobyte mode)
    {
        if (!IsPatchChange()) return;
        if (mode < 0) return;
        if (mode > 4) return;
        twobyte patchnumber = LOBYTE(_midiexpression.data1);
        _midiexpression.data1 = MAKEWORD(patchnumber, mode);
    }
    
    twobyte GetPatchChangeMode() const
    {
        if (!IsPatchChange()) return 0;
        return HIBYTE(_midiexpression.data1);
    }
    
    void SetPatchChangeNumber(twobyte number)
    {
        if (!IsPatchChange()) return;
        if (number < 0) return;
        if (number > 255) return;
        twobyte patchmode = HIBYTE(_midiexpression.data1);
        _midiexpression.data1 = MAKEWORD(number, patchmode);
    }
    
    twobyte GetPatchChangeNumber() const
    {
        if (!IsPatchChange()) return 0;
        return LOBYTE(_midiexpression.data1);
    }
 
    
    void SetPatchChangeBankData1(twobyte mode)
    {
        if (!IsPatchChange()) return;
        if (mode < 0) return;
        if (mode > 255) return;
        twobyte patchnumber = LOBYTE(_midiexpression.data2);
        _midiexpression.data2 = MAKEWORD(patchnumber, mode);
    }
    
    twobyte GetPatchChangeBankData1() const
    {
        if (!IsPatchChange()) return 0;
        return HIBYTE(_midiexpression.data2);
    }
    
    void SetPatchChangeBankData2(twobyte number)
    {
        if (!IsPatchChange()) return;
        if (number < 0) return;
        if (number > 255) return;
        twobyte patchmode = HIBYTE(_midiexpression.data2);
        _midiexpression.data2 = MAKEWORD(number, patchmode);
    }
    
    twobyte GetPatchChangeBankData2() const
    {
        if (!IsPatchChange()) return 0;
        return LOBYTE(_midiexpression.data2);
    }
 
    
    void SetMeasurePos(TimeEdu32 value) { _midiexpression.eldur = value; }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCCellDetail::DebugDump();
        DebugOutInt("Position: ", GetMeasurePos());
        if (IsController())
        {
            DebugOutBool("Is Controller: ", IsController());
            DebugOutInt("Controller number: ", GetControllerNumber());
            DebugOutInt("Controller value: ", GetControllerValue());
        }
        if (IsPitchWheel())
        {
            DebugOutBool("Is Pitch Wheel: ", IsPitchWheel());
            DebugOutInt("data1: ", _midiexpression.data1);
            DebugOutInt("data2: ", _midiexpression.data2);
        }
    }
#endif
};
 
 
 
class FCSeparateMeasureNumber : public __FCCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    FCEnclosure _enclosure;
 
    EDTMeasNumberSeparate _separatemeasurenumberold;
    
    FIN25_4_CODE( EDTMeasNumberSeparate25_4 _separatemeasurenumber25_4; )
 
    /* Decides which version of the struct that should be used */
    const bool _Use25_4_Version() const;
    
    /* Returns the pointer to the 'flag' struct member */
    const FLAG_16* _GetFlagPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.flag; )
        return &_separatemeasurenumberold.flag;
    }
    
    /* Returns the pointer to the 'region' struct member */
    const twobyte* _GetRegionPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.region; )
        return &_separatemeasurenumberold.region;
    }
    
    /* Returns the pointer to the 'x1add' struct member */
    const twobyte* _GetX1addPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.x1add; )
        return &_separatemeasurenumberold.x1add;
    }
    
    /* Returns the pointer to the 'y1add' struct member */
    const twobyte* _GetY1addPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.y1add; )
        return &_separatemeasurenumberold.y1add;
    }
    
    /* Returns the pointer to the 'encl' struct member (different data type,
     depending on version) */
    const void* _GetEnclPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.encl; )
        return &_separatemeasurenumberold.encl;
    }
    
    /* No measure flag? */
    void _SaveMeasureFlag() override {}
protected:
    EXTAG Tag() const override;
    int DataSizeLoad() const override;
    int DataSizeSave() const override;
    void* Allocate() override;
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        int size = DataSizeLoad();
        memcpy(_GetSeparateMeasNum(), ((FCSeparateMeasureNumber*)pSource)->_GetSeparateMeasNum(), size);
        _datablock = _GetSeparateMeasNum();
        _loadedsize = size;
    }
 
    __FCBaseData* CreateObject() override { return new FCSeparateMeasureNumber(); }
#endif
public:
 
    const char* ClassName() const override { return "FCSeparateMeasureNumber"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SEPARATEMEASURENUMBER; }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void* _GetSeparateMeasNum() { return Allocate(); }
#endif
 
    FCSeparateMeasureNumber() : __FCCellDetail()
    {
        /* Don't use virtual methods in the constructor */
        if (_Use25_4_Version())
        {
#if FXT_VERSION >= FINALEVERSION_25_4
            memset(&_separatemeasurenumber25_4, 0, sizeof(_separatemeasurenumber25_4));
            _loadedsize = sizeof(_separatemeasurenumber25_4);
            _datablock = &_separatemeasurenumber25_4;
#endif
        }
        else
        {
            memset(&_separatemeasurenumberold, 0, sizeof(_separatemeasurenumberold));
            _loadedsize = sizeof(_separatemeasurenumberold);
            _datablock = &_separatemeasurenumberold;
        }
    }
 
    twobyte GetRegionNumberID() const { return *_GetRegionPtr(); }
 
    bool GetShowOverride() const { return GetBitFlag(*_GetFlagPtr(), MEASNUM_FORCE_MNUM); }
 
    bool GetHideOverride() const { return GetBitFlag(*_GetFlagPtr(), MEASNUM_HIDE_MNUM); }
 
    bool GetUseEnclosure() const { return GetBitFlag(*_GetFlagPtr(), MEASNUM_USE_ENCL); }
 
    bool GetIsAlternateNumber() const { return GetBitFlag(*_GetFlagPtr(), MEASNUM_IS_ALTNUM); }
 
    twobyte GetHorizontalPosition() const { return *_GetX1addPtr(); }
 
    twobyte GetVerticalPosition() const { return *_GetY1addPtr(); }
 
    bool AssignMeasureNumberRegion(FCMeasureNumberRegion* pRegion)
    {
        if (!pRegion) return false;
        if (pRegion->GetID() < 1) return false;
        SetRegionNumberID(pRegion->GetID());
        return true;
    }
 
    FCEnclosure* GetEnclosure() 
    {
        if (!GetUseEnclosure()) return NULL;
        _enclosure._AssignEDTEnclosure((void*) _GetEnclPtr());
        return &_enclosure;
    }
 
    void SetRegionNumberID(twobyte regionid)
    {
        if (regionid < 1) return;
        *(twobyte*)_GetRegionPtr() = regionid;
    }
 
    void SetShowOverride(bool state) { Set16BitFlag((FLAG_16*)_GetFlagPtr(), MEASNUM_FORCE_MNUM, state); }
 
    void SetHideOverride(bool state)  { Set16BitFlag((FLAG_16*)_GetFlagPtr(), MEASNUM_HIDE_MNUM, state); }
 
    void SetUseEnclosure(bool state) { Set16BitFlag((FLAG_16*) _GetFlagPtr(), MEASNUM_USE_ENCL, state); }
 
    void SetIsAlternateNumber(bool state) { Set16BitFlag((FLAG_16*) _GetFlagPtr(), MEASNUM_IS_ALTNUM, state); }
 
    void SetHorizontalPosition(twobyte value) { *(twobyte*)_GetX1addPtr() = value; }
 
    void SetVerticalPosition(twobyte value) { *(twobyte*)_GetY1addPtr() = value; }
 
   
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCCellDetail::DebugDump();
    }
#endif
};
 
class FCSeparateMeasureNumbers : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCSeparateMeasureNumber(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    
    FCSeparateMeasureNumbers() : __FCCollectionCellDetail() {}
 
    const char* ClassName() const override { return "FCSeparateMeasureNumbers"; }
 
    FCSeparateMeasureNumber* GetItemAt(int index) const { return (FCSeparateMeasureNumber*) __FCCollection::GetItemAt(index); }
};
 
 
class FCCellFrameHold : public __FCNoInciCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTGfhold2004 _tgfhold;
 
protected:
    /* No measure flag storage */
    void _SaveMeasureFlag() override {}
 
 
    EXTAG Tag() const override { return dt_Gfhold; }
    int DataSizeLoad() const override { return sizeof(EDTGfhold2004); }
    int DataSizeSave() const override { return sizeof(EDTGfhold2004); }
    void* Allocate() override { return (void*) &_tgfhold; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        // Don't use memcpy, since EDTGfhold2004 contains dynamic memory.
        _tgfhold = ((FCCellFrameHold*) pSource)->_GetTGFHold();
        _datablock = &_tgfhold;
        _loadedsize = sizeof(_tgfhold);
    }
 
    __FCBaseData* CreateObject() override { return new FCCellFrameHold(); }
 
#endif
public:
 
    const char* ClassName() const override { return "FCCellFrameHold"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CELLFRAMEHOLD; }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTGfhold2004& _GetTGFHold() { return _tgfhold; }
#endif
 
    enum CLEF_SHOW
    {
        SHOWCLEF_NORMAL = 0,
        SHOWCLEF_HIDE,
        SHOWCLEF_ALWAYS
    };
 
 
    FCCellFrameHold();
    
    twobyte GetClefIndex() const { return _tgfhold.clef; }
 
    twobyte GetClefPercent() const { return _tgfhold.clefPercent; }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    CLEF_SHOW
#else
    int
#endif
    GetClefShow() const
    {
        if (GetBitFlag(_tgfhold.flag, GF_HIDECLEF))
            return SHOWCLEF_HIDE;
        if (GetBitFlag(_tgfhold.flag, 0x0020))
            return SHOWCLEF_ALWAYS;
        else
            return SHOWCLEF_NORMAL;
    }
 
    bool GetIsClefList() const
    {
        return GetBitFlag(_tgfhold.flag, GF_CLEFISLIST);
    }
 
    bool GetClefAfterBarline() const { return GetBitFlag(_tgfhold.flag, 0x0001); }
 
    void SetClefIndex(twobyte newclef) 
    {
        if (GetIsClefList()) return;
        _tgfhold.clef = newclef;
    }
    
    void SetClefPercent(twobyte resize) 
    {
        if (GetIsClefList()) return;
        _tgfhold.clefPercent = resize;
    }
 
    void SetClefShow(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    CLEF_SHOW
#else
    twobyte
#endif
    value
    )
    {
        if (GetIsClefList()) return;
        switch (value)
        {
            case SHOWCLEF_HIDE:
                Set16BitFlag(&_tgfhold.flag, GF_HIDECLEF, true);
                Set16BitFlag(&_tgfhold.flag, 0x0020, false);
                break;
            case SHOWCLEF_ALWAYS:
                Set16BitFlag(&_tgfhold.flag, GF_HIDECLEF, false);
                Set16BitFlag(&_tgfhold.flag, 0x0020, true);
                break;
            case SHOWCLEF_NORMAL:
                Set16BitFlag(&_tgfhold.flag, GF_HIDECLEF, false);
                Set16BitFlag(&_tgfhold.flag, 0x0020, false);
                break;
        }        
    }
 
 
    void SetClefAfterBarline(bool state) 
    {
        if (GetIsClefList()) return;
        Set16BitFlag(&_tgfhold.flag, 0x0001, state);
    }
 
    bool CalcClefChange();
    
    bool CalcHasFrame() const
    {
        for (int i = 0; i < FX_GetMaxLayers(); i++)
            if (_tgfhold.frame[i])
                return true;
        return false;
    }
    
    bool CalcHasFrameAtLayer(int layernum) const
    {
        if (layernum > 0 && layernum <= FX_GetMaxLayers())
            return MAKEBOOL(_tgfhold.frame[layernum-1]);
        return false;
    }
    
    bool CalcMultiLayeredCell()
    {
        int layercount = 0;
        for (int i = 0; i < FX_GetMaxLayers(); i++)
            if (_tgfhold.frame[i])
                layercount++;
        return layercount > 1;
    }
 
    bool SaveNew() override;
    
    FCCellClefChange * CreateFirstCellClefChange() const;
    
#ifdef PDK_FRAMEWORK_PREFS
    bool MakeCellSingleClef(const FCCellClefChange *pClefInfo = nullptr);
#endif //PDK_FRAMEWORK_PREFS
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCCellClefChange> CreateFirstCellClefChange_GC()
    { return makeLuaSharedPtr(CreateFirstCellClefChange()); }
#endif
 
    FCCellClefChanges* CreateCellClefChanges();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCCellClefChanges> CreateCellClefChanges_GC()
    { return makeLuaSharedPtr(CreateCellClefChanges()); }
#endif
    
#ifdef PDK_FRAMEWORK_PREFS
    bool SetCellClefChanges(FCCellClefChanges *pClefChanges);
#endif //PDK_FRAMEWORK_PREFS
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciCellDetail::DebugDump();
        DebugOutInt("Clef: ", GetClefIndex());
        DebugOutInt("Clef Resize: ", GetClefPercent());
        DebugOutInt("Clef show: ", GetClefShow());
        DebugOutHex("Flag Bits: ", _tgfhold.flag);
    }
#endif
};
 
class FCTransposer;
 
class FCChord : public __FCCellDetail
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTChord2010 _chord;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
#ifdef PDK_FRAMEWORK_ENTRIES
    std::unique_ptr<FCTransposer> _pTransposer;
#endif // PDK_FRAMEWORK_ENTRIES
    
    void _SaveMeasureFlag() override;
 
    int DataSizeLoad() const override { return sizeof(EDTChord2010); }
    void* Allocate() override { return (void*) &_chord; }
 
    EVERSION EnigmaVersion() const override { return FINALEVERSION_2010; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_chord, ((FCChord*)pSource)->_GetChord(), sizeof(_chord));
        _datablock = &_chord;
        _loadedsize = sizeof(_chord);
    }
 
    __FCBaseData* CreateObject() override { return new FCChord(); }
    
    int _GetFretboardGroupInci() const { return _chord.fbData & CHORD_FRET_INCI; }
    void _SetFretboardGroupInci(int value)
    {
        _chord.fbData &= ~CHORD_FRET_INCI;
        _chord.fbData |= (value & CHORD_FRET_INCI);
    }
 
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    EXTAG Tag() const override { return dt_Chord2010; }  /* Some plug-ins need this - needs to be public. */
 
    const char* ClassName() const override { return "FCChord"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CHORD; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetChord() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    enum ALTERNATEBASS_PLACEMENT
    {
        ALTBASSPLACE_AFTERROOT = 0,
        ALTBASSPLACE_UNDERROOT,
        ALTBASSPLACE_SUBTEXT
    };
 
    FCChord() : __FCCellDetail()
    {
        memset(&_chord, 0, sizeof(_chord));
        _datablock = &_chord;
        _loadedsize = sizeof(_chord);
    }
 
    bool IsEarlierThan(FCChord* pTestChord)
    {
        if (!pTestChord) return false;
        if (pTestChord->GetMeasure() > GetMeasure()) return true;
        if (pTestChord->GetMeasure() < GetMeasure()) return false;
        return (pTestChord->GetMeasurePos() > GetMeasurePos());
    }
 
    TimeEdu32 GetMeasurePos() const override { return _chord.horzEDU; }
 
    void SetMeasurePos(TimeEdu32 position) { _chord.horzEDU = position; }
 
#ifdef PDK_FRAMEWORK_ENTRIES
    bool AnalyzeEntryChord(FCNoteEntry* pEntry)
    {
        tbool suffixfound;
        FCMusicRegion musicregion;
        musicregion.SetInstrumentList(0);
        musicregion.SetStartStaff(pEntry->GetStaff());
        musicregion.SetEndStaff(pEntry->GetStaff());
        musicregion.SetStartMeasure(pEntry->GetMeasure());
        musicregion.SetEndMeasure(pEntry->GetMeasure());
        musicregion.SetStartMeasurePos(pEntry->GetMeasurePos());
        musicregion.SetEndMeasurePosRight();
        EREGION eregion;
        musicregion.GetEnigmaRegion(&eregion);
#if FXT_VERSION >= FINALEVERSION_2014_5
        if (!FX_AnalyzeChord(&eregion, (EDTChord2010*) &_chord, &suffixfound)) return false;
#else
        if (!FX_AnalyzeChord(&eregion, (EDTChord*) &_chord, &suffixfound)) return false;
#endif
        SetMeasurePos(pEntry->GetMeasurePos());
        SetChordVerticalPos(0);
        return true;
    }
#endif // PDK_FRAMEWORK_ENTRIES
 
    FCChordSuffixElements* CreateChordSuffixElements() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCChordSuffixElements> CreateChordSuffixElements_GC() const
    { return makeLuaSharedPtr(CreateChordSuffixElements()); }
#endif
    
    CMPER CalcFretboardGroupID() const
    {
        if (GetChordSuffixID()) return GetChordSuffixID();
        if (GetChordRootLowercase()) return 65533;
        return 65534;
    }
    
    
    FCFretboardGroupDef* CreateFretboardGroupDef() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFretboardGroupDef> CreateFretboardGroupDef_GC() const
    { return makeLuaSharedPtr(CreateFretboardGroupDef()); }
#endif
 
#ifdef PDK_FRAMEWORK_ENTRIES
    FCTransposer* GetTransposer();
#endif // PDK_FRAMEWORK_ENTRIES
    
    /* ******* CHORD GETTERS ********** */
 
    twobyte GetChordSuffixID() const { return _chord.suffix; }
 
    twobyte GetChordHorizontalPos() const { return _chord.posadd; }
 
    twobyte GetChordVerticalPos()  const { return _chord.lineadd; }
 
    bool GetChordVisible() const { return !GetBitFlag(_chord.capoData, 0x0080); }
 
    twobyte GetChordResize() const { return _chord.chPercent; }
 
    bool GetChordRootVisible() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_SHOWROOT);
    }
 
    bool GetChordRootPlayback() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_PLAYROOT);
    }
 
    bool GetChordRootLowercase() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_LOWERCASE);
    }
 
    bool GetChordSuffixVisible() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_SHOW_SUFFIX);
    }
 
    bool GetChordSuffixPlayback() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_PLAYCHORD);
    }
 
    bool GetUseCapo() const
    {
        return GetBitFlag(_chord.capoData, CHORD_USE_LOCAL_CAPO);
    }
 
    twobyte GetCapo() const
    {
        return (_chord.capoData & CHORD_CAPO_VALUE);
    }
 
    twobyte GetScaleNumber() const
    {
        return _chord.showPlay & CHORD_SCALENUM;
    }
    
    twobyte GetAlteration() const
    {
        twobyte alteration = _chord.showPlay & CHORD_RLBITS;
        alteration >>= 8;
        if (alteration & 0x08)
        {
            /* Signed */
            alteration |= 0xfff0;
        }
        return alteration;
    }
 
    bool GetChordAlternateBassVisible() const
    {
        return GetBitFlag(_chord.altbass, CHORD_SHOWALTBASS);
    }
 
    bool GetChordAlternateBassPlayback() const
    {
        return GetBitFlag(_chord.altbass, CHORD_PLAYALTBASS);
    }
 
    bool GetChordAlternateBassLowercase() const
    {
        return GetBitFlag(_chord.altbass, CHORD_LOWERCASE);
    }
 
    twobyte GetAlternateBassScaleNumber() const
    {
        return _chord.altbass & CHORD_SCALENUM;
    }
 
        twobyte GetAlternateBassAlteration() const
        {
                twobyte alteration = _chord.altbass & CHORD_RLBITS;
                alteration >>= 8;
                if (alteration & 0x08)
                {
                        /* Signed */
                        alteration |= 0xfff0;
                }
                return alteration;
        }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ALTERNATEBASS_PLACEMENT 
#else
    int
#endif
    GetChordAlternateBassPlacement() const
    {
        if (GetBitFlag(_chord.altbass, CHORD_DOWNSIDEBIT) == false)
        {
            if (GetBitFlag(_chord.altbass, CHORD_SUBTEXTBIT))
                return ALTBASSPLACE_SUBTEXT;
            else
                return ALTBASSPLACE_AFTERROOT;
        }
        else return ALTBASSPLACE_UNDERROOT;
    }
 
    /* ******* FRETBOARD GETTERS ********** */
 
    twobyte GetFretboardStyleID() const { return _chord.fbStyleID; }
 
    twobyte GetFretboardHorizontalPos() const { return _chord.fbposadd; }
 
    twobyte GetFretboardVerticalPos() const { return _chord.fblineadd; }
 
    // Use absolute bit mask, since the CHORD_HIDE_FRETBOARD is reversed
    bool GetFretboardVisible() const { return GetBitFlag(_chord.showPlay, 0x4000); }
 
    twobyte GetFretboardResize() const { return _chord.fbPercent; }
 
    bool GetFretboardPlayback() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_PLAYFRETBOARD);
    }
 
    bool GetFretboardUseFont() const
    {
        return GetBitFlag(_chord.fbData, CHORD_USE_FRET_FONT);
    }
 
    int GetFretboardID() const { return _GetFretboardGroupInci() + 1; }
    
    /* ******* CHORD SETTERS ********** */
 
    void SetChordSuffixID(twobyte value) { _chord.suffix = value; }
 
    void SetChordHorizontalPos(twobyte value) { _chord.posadd = value; }
 
    void SetChordVerticalPos(twobyte value)  { _chord.lineadd = value; }
 
    void SetChordVisible(bool state) { Set16BitFlag(&_chord.capoData, 0x0080, !state); }
 
    void SetChordResize(twobyte value) { _chord.chPercent = value; }
 
    void SetChordRootVisible(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_SHOWROOT, state);
    }
 
    void SetChordRootPlayback(bool playback)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_PLAYROOT, playback);
    }
 
    void SetChordRootLowercase(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_LOWERCASE, state);
    }
 
    void SetChordSuffixVisible(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_SHOW_SUFFIX, state);
    }
 
    void SetChordSuffixPlayback(bool playback)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_PLAYCHORD, playback);
    }
 
    void SetChordAlternateBassVisible(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_SHOWALTBASS, state);
    }
 
    void SetChordAlternateBassPlayback(bool playback)
    {
        Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_PLAYALTBASS, playback);
    }
 
    void SetChordAlternateBassLowercase(bool lowercase)
    {
        Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_LOWERCASE, lowercase);
    }
 
    void SetChordAlternateBassPlacement(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ALTERNATEBASS_PLACEMENT
#else
    int
#endif
    placement
    )
    {
        switch (placement)
        {
            case ALTBASSPLACE_AFTERROOT:
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_DOWNSIDEBIT, false);
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_SUBTEXTBIT, false);
                break;
            case ALTBASSPLACE_UNDERROOT:
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_DOWNSIDEBIT, true);
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_SUBTEXTBIT, false);
                break;
            case ALTBASSPLACE_SUBTEXT:
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_DOWNSIDEBIT, false);
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_SUBTEXTBIT, true);
                break;
        }
    }
 
    void SetUseCapo(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.capoData, CHORD_USE_LOCAL_CAPO, state);
    }
 
    void SetCapo(twobyte value)
    {
        _chord.capoData &= ~CHORD_CAPO_VALUE;
        _chord.capoData |= (value & CHORD_CAPO_VALUE);
    }
 
    void SetScaleNumber(twobyte scalenumber)
    {
        _chord.showPlay &= ~CHORD_SCALENUM;
        _chord.showPlay |= (scalenumber & CHORD_SCALENUM);
    }
 
    void SetAlteration(twobyte alteration)
    {
        alteration <<= 8;
        alteration &= CHORD_RLBITS;
        _chord.showPlay &= ~CHORD_RLBITS;
        _chord.showPlay |= alteration;        
    }
 
    void SetAlternateBassScaleNumber(twobyte scalenumber)
    {
        _chord.altbass &= ~CHORD_SCALENUM;
        _chord.altbass |= (scalenumber & CHORD_SCALENUM);
    }
 
        void SetAlternateBassAlteration(twobyte alteration)
        {
                alteration <<= 8;
                alteration &= CHORD_RLBITS;
                _chord.altbass &= ~CHORD_RLBITS;
                _chord.altbass |= alteration;
        }
 
 
    /* ******* FRETBOARD SETTERS ********** */
 
    void SetFretboardStyleID(twobyte value) { _chord.fbStyleID = value; }
 
    void SetFretboardHorizontalPos(twobyte value) { _chord.fbposadd = value; }
 
    void SetFretboardVerticalPos(twobyte value) { _chord.fblineadd = value; }
 
    // Use absolute bit mask, since the CHORD_HIDE_FRETBOARD is reversed
    void SetFretboardVisible(bool state) { Set16BitFlag((FLAG_16*)&_chord.showPlay, 0x4000, state); }
 
    void SetFretboardResize(twobyte value) { _chord.fbPercent = value; }
 
    void SetFretboardPlayback(bool playback)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_PLAYFRETBOARD, playback);
    }
 
    void SetFretboardUseFont(bool state)
    {
        Set16BitFlag(&_chord.fbData, CHORD_USE_FRET_FONT, state);
    }
 
    void SetFretboardID(int value) { _SetFretboardGroupInci((std::max)(0, value - 1)); }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCCellDetail::DebugDump();
        DebugOutBlock(&_chord, 0, sizeof(_chord));
        DebugOutBool("Chord Visible: ", GetChordVisible());
        DebugOutBool("Fretboard Visible: ", GetFretboardVisible());
    }
#endif
};
 
 
 
class FCCellGraphic : public __FCCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTTGraphic _graphic;
 
    /* No measure flag? */
    void _SaveMeasureFlag() override {}
 
    bool SaveNew() override
    { return false; }
    
    bool _RawRelink() override;
    
protected:
    EXTAG Tag() const override { return dt_MeasGraphic; }
    int DataSizeLoad() const override { return sizeof(EDTTGraphic); }
    int DataSizeSave() const override { return sizeof(EDTTGraphic); }
    void* Allocate() override { return (void*) &_graphic; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_graphic, ((FCCellGraphic*)pSource)->_GetGraphic(), sizeof(_graphic));
        _datablock = &_graphic;
        _loadedsize = sizeof(_graphic);
    }
 
    __FCBaseData* CreateObject() override { return new FCCellGraphic(); }
#endif
public:
 
    const char* ClassName() const override { return "FCCellGraphic"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CELLGRAPHIC; }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTTGraphic* _GetGraphic() { return &_graphic; }
#endif
 
    FCCellGraphic() : __FCCellDetail()
    {
        memset(&_graphic, 0, sizeof(_graphic));
        _loadedsize = sizeof(_graphic);
        _datablock = &_graphic;
    }
 
    bool IsEmbedded()
    {
        return MAKEBOOL(_graphic.graphicCmper);
    }
    
    Evpu16 GetHorizontalPos() const
    {
        return _graphic.left;
    }
 
    Evpu16 GetVerticalPos() const
    {
        return _graphic.bottom;
    }
 
    Evpu16 GetWidth() const
    {
        return _graphic.width;
    }
 
    Evpu16 GetHeight() const
    {
        return _graphic.height;
    }
 
    Evpu16 GetOriginalWidth() const
    {
        return _graphic.origWidth;
    }
 
    Evpu16 GetOriginalHeight() const
    {
        return _graphic.origHeight;
    }
 
    bool GetVisible() const { return !GetBitFlag(_graphic.displayFlags, GRAPHIC_DISPLAY_HIDDEN); }
 
    /* SETTERS */
    
    void SetHorizontalPos(Evpu16 pos)
    {
        _graphic.left = pos;
        _graphic.rightPgLeft = pos;
    }
 
    void SetVerticalPos(Evpu16 pos)
    {
        _graphic.bottom = pos;
        _graphic.rightPgBottom = pos;
    }
 
    void SetWidth(Evpu16 width)
    {
        _graphic.width = width;
    }
    
    void SetHeight(Evpu16 height)
    {
        _graphic.height = height;
    }
 
    void SetVisible(bool state)
    {
        Set16BitFlag(&_graphic.displayFlags, GRAPHIC_DISPLAY_HIDDEN, !state);
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCCellDetail::DebugDump();
    }
#endif
};
 
 
 
 
class FCCellText : public __FCCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTMeasureText _measuretext;
 
    void _SaveMeasureFlag() override;
    
protected:
    EXTAG Tag() const override { return dt_MeasureTextBlock; }
    int DataSizeLoad() const override { return sizeof(EDTMeasureText); }
    int DataSizeSave() const override { return sizeof(EDTMeasureText); }
    void* Allocate() override { return (void*) &_measuretext; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_measuretext, ((FCCellText*)pSource)->_GetCellText(), sizeof(_measuretext));
        _datablock = &_measuretext;
        _loadedsize = sizeof(_measuretext);
    }
 
    __FCBaseData* CreateObject() override { return new FCCellText(); }
#endif // DOXYGEN_SHOULD_SKIP_THIS
public:
 
    const char* ClassName() const override { return "FCCellText"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CELLTEXT; }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTMeasureText* _GetCellText() { return &_measuretext; }
#endif
 
    FCCellText() : __FCCellDetail()
    {
        memset(&_measuretext, 0, sizeof(_measuretext));
        _loadedsize = sizeof(_measuretext);
        _datablock = &_measuretext;
    }
 
    FCString* CreateTextString()
    {
        FCTextBlock textblock;
        textblock.Load(GetTextBlockID());
        return textblock.CreateRawTextString();
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateTextString_GC()
    { return makeLuaSharedPtr(CreateTextString()); }
#endif
 
    FCTextBlock* CreateTextBlock();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCTextBlock> CreateTextBlock_GC()
    { return makeLuaSharedPtr(CreateTextBlock()); }
#endif
 
     bool SaveNewTextBlock(FCString* pString);
 
     bool SaveTextString(FCString* pString);
 
    twobyte GetTextBlockID() const
    {
        return _measuretext.block;
    }
 
    CMPER GetStringID() const;
 
    TimeEdu32 GetMeasurePos() const override
    {
        return _measuretext.xdisp;
    }
 
    twobyte GetVerticalPos() const
    {
        return _measuretext.ydisp;
    }
 
    bool GetVisible() const
    {
        return !GetBitFlag(_measuretext.flag, (MEASURETEXT_ANNOTATION));
    }
 
    void SetMeasurePos(TimeEdu32 value)
    {
        _measuretext.xdisp = (Evpu16) value;
    }
 
    void SetVerticalPos(twobyte value)
    {
        _measuretext.ydisp = value;
    }
 
    void SetVisible(bool visible)
    {
        Set16BitFlag(&_measuretext.flag, MEASURETEXT_ANNOTATION, !visible);
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCCellDetail::DebugDump();
    }
#endif
};
 
 
 
 
 
 
class FCCellGraphics : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCCellGraphic(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCellGraphics"; }
 
    FCCellGraphic* GetItemAt(int index) const { return (FCCellGraphic*) __FCCollection::GetItemAt(index); }
};
 
 
 
class FCCellTexts : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCCellText(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCCellTexts() : __FCCollectionCellDetail() {}
 
    const char* ClassName() const override { return "FCCellTexts"; }
 
    FCCellText* GetItemAt(int index) const { return (FCCellText*) __FCCollectionCellDetail::GetItemAt(index); }
};
 
 
 
 
class FCCellFrameHolds : public __FCCollectionNoInciCellDetail
{
    protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCCellFrameHold(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCellFrameHolds"; }
 
};
 
 
 
class FCMidiExpressions : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCMidiExpression(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCMidiExpressions"; }
 
    FCMidiExpression* GetItemAt(int index) const { return (FCMidiExpression*) __FCCollectionCellDetail::GetItemAt(index); }
};
 
 
class FCChords : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCChord(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCChords"; }
 
    FCChord* FindMeasurePos(TimeEdu32 durationpos)
    {
        for (int i = 0; i < GetCount(); i++ )
        {
            FCChord* pChord = (FCChord*) GetItemAt(i);
            if (pChord->GetMeasurePos() == durationpos) return pChord;
        }
        return NULL;
    }
 
    FCChord* GetItemAt(int index) const { return (FCChord*) __FCCollectionCellDetail::GetItemAt(index); }
};
 
 
 
class FCIndependentCellDetail : public __FCNoInciCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#if FXT_VERSION < FINALEVERSION_2014
    EDTMeasureFloat _measurefloat2014; /* Dummy struct */
    EDTMeasureFloat _measurefloat2001;
#else
    EDTMeasureFloat2014 _measurefloat2014;
    EDTMeasureFloat2001 _measurefloat2001;
#endif
 
    EVERSION _VersionToUse() const;
protected:
    /* Set measure flag? */
    void _SaveMeasureFlag() override {}
 
    EXTAG Tag() const override;
    int DataSizeLoad() const override;
    int DataSizeSave() const override;
    void* Allocate() override;
    EVERSION EnigmaVersion() const override { return _VersionToUse(); }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(_GetDataPtr(), ((FCIndependentCellDetail*) pSource)->_GetDataPtr(), DataSizeLoad());
        _datablock = _GetDataPtr();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCIndependentCellDetail(); }
#endif
public:
 
    const char* ClassName() const override { return "FCIndependentCellDetail"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_INDEPENDENTCELLDETAIL; }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void* _GetDataPtr();
#endif
 
    FCIndependentCellDetail() : __FCNoInciCellDetail()
    {
        int size = FCIndependentCellDetail::DataSizeLoad();  /* Assure non-virtual call in constructor */
        memset(_GetDataPtr(), 0, size);
        _datablock = _GetDataPtr();
        _loadedsize = size;
    }
 
    bool GetHasKeySignature();
 
    bool GetHasTimeSignature();
 
    bool GetHasTimeSignatureForDisplay();
 
    eKey GetKeySignatureID();
 
    twobyte GetTimeSignatureBeats();
 
    twobyte GetTimeSignatureBeatsForDisplay();
 
    twobyte GetTimeSignatureBeatDuration();
 
    twobyte GetTimeSignatureBeatDurationForDisplay();
 
    bool GetTimeSignatureCompositeTop();
 
    bool GetTimeSignatureCompositeTopForDisplay();
 
    bool GetTimeSignatureCompositeBottom();
 
    bool GetTimeSignatureCompositeBottomForDisplay();
 
    bool GetTimeSignatureAbbreviateForDisplay();
 
    void GetFullTimeSignature(FCTimeSignature* pTimeSig);
 
    bool GetFullTimeSignatureForDisplay(FCTimeSignature* pTimeSig);
 
        void SetHasKeySignature(bool state);
 
        void SetHasTimeSignature(bool state);
 
    void SetHasTimeSignatureForDisplay(bool state);
 
    void SetKeySignatureID(eKey value);
 
    void SetTimeSignatureBeats(twobyte beats);
 
    void SetTimeSignatureBeatsForDisplay(twobyte beats);
 
    void SetTimeSignatureBeatDuration(twobyte beatduration);
 
    void SetTimeSignatureBeatDurationForDisplay(twobyte beatduration);
 
    void SetTimeSignatureCompositeTop(bool state);
 
    void SetTimeSignatureCompositeTopForDisplay(bool state);
 
    void SetTimeSignatureCompositeBottom(bool state);
 
    void SetTimeSignatureCompositeBottomForDisplay(bool state);
 
    void SetTimeSignatureAbbreviateForDisplay(bool state);
 
        void SetFullTimeSignature(FCTimeSignature* pTimeSig);
 
    void SetFullTimeSignatureForDisplay(FCTimeSignature* pTimeSig);
 
        void SetFullKeySignature(FCKeySignature* pKeySig);
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciCellDetail::DebugDump();
    }
#endif
};
 
#ifdef PDK_FRAMEWORK_ENTRIES
 
class FCTransposer : public __FCBase
{
    constexpr static int kMaxAbsFinaleAleration = 7; // Finale has a hard-coded limit on the magnitude of chromatic alteration values
    using _transposeInputs = std::tuple<eHarmLev, eHarmAlt, const FCKeySignature*>;
 
    template<typename... Args>
    using _transposeFunPtr = bool(FCTransposer::*)(_transposeInputs& inputs, Args... args);
    
    // to support more target entities, add them to the std::variant
    std::variant<_transposeInputs, FCNote*, FCChord*> _target;
    
    template<typename... Args>
    bool _executeForInputs(_transposeInputs& inputs, _transposeFunPtr<Args...> funPtr, Args... args)
    { return (this->*funPtr)(inputs, args...); }
 
    template<typename... Args>
    bool _executeForNote(FCNote* pNote, _transposeFunPtr<Args...> funPtr, Args... args)
    {
        FCCell cell(pNote->GetEntry()->GetMeasure(), pNote->GetEntry()->GetStaff());
        _transposeInputs inputs = std::make_tuple(pNote->GetDisplacement(), pNote->GetRaiseLower(), cell.GetKeySignature());
        const bool success = _executeForInputs(inputs, funPtr, args...);
        if (success)
        {
            pNote->SetDisplacement(std::get<0>(inputs));
            pNote->SetRaiseLower(std::get<1>(inputs));
        }
        return success;
    }
 
    template<typename... Args>
    bool _executeForChord(FCChord* pChord, _transposeFunPtr<Args...> funPtr, Args... args)
    {
        FCCell cell(pChord->GetMeasure(), pChord->GetStaff());
        const FCKeySignature* key = cell.GetKeySignature();
        _transposeInputs inputs1 = std::make_tuple(pChord->GetScaleNumber(), pChord->GetAlteration(), key);
        _transposeInputs inputs2 = std::make_tuple(pChord->GetAlternateBassScaleNumber(), pChord->GetAlternateBassAlteration(), key);
        const bool success = _executeForInputs(inputs1, funPtr, args...) && _executeForInputs(inputs2, funPtr, args...);
        if (success)
        {
            pChord->SetScaleNumber(key->CalcScaleNumber(std::get<0>(inputs1)));
            pChord->SetAlteration(std::get<1>(inputs1));
            pChord->SetAlternateBassScaleNumber(key->CalcScaleNumber(std::get<0>(inputs2)));
            pChord->SetAlternateBassAlteration(std::get<1>(inputs2));
        }
        return success;
    }
 
    template<typename... Args>
    bool _execute(_transposeFunPtr<Args...> funPtr, Args... args)
    {
        if (std::holds_alternative<_transposeInputs>(_target))
            return _executeForInputs(std::get<0>(_target), funPtr, args...);
        else if (std::holds_alternative<FCNote*>(_target))
            return _executeForNote(std::get<1>(_target), funPtr, args...);
        else if (std::holds_alternative<FCChord*>(_target))
            return _executeForChord(std::get<2>(_target), funPtr, args...);
        else
            assert(false); // std variant not initialized, which should be impossible
        return false;
    }
 
    bool _DiatonicTranspose(_transposeInputs& inputs, eHarmLev interval)
    {
        std::get<0>(inputs) += interval;
        return true;
    }
    
    bool _OctaveTranspose(_transposeInputs& inputs, twobyte numberofoctaves)
    { return _DiatonicTranspose(inputs, 7*numberofoctaves); }
 
    bool _EDOStepTranspose(_transposeInputs& inputs, twobyte numberofsteps)
    {
        std::get<1>(inputs) += numberofsteps;
        return _SimplifySpelling(inputs, 0);
    }
 
    bool _SimplifySpelling(_transposeInputs& inputs, twobyte minAbsAlteration);
    bool _EnharmonicTranspose(_transposeInputs& inputs, twobyte direction, bool ignoreerrors);
    bool _DefaultEnharmonicTranspose(_transposeInputs& inputs);
    bool _ChromaticTranspose(_transposeInputs& inputs, eHarmLev interval, eHarmAlt alteration, bool simplify);
 
public:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const char* ClassName() const override { return "FCTransposer"; }
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
    FCTransposer(eHarmLev displacement, eHarmAlt raiselower, const FCKeySignature* key)
            : _target(std::make_tuple(displacement, raiselower, key))
    {}
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    template<class FC>
    FCTransposer(FC* pEntity) : _target(pEntity)
    {}
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
    eHarmLev GetDisplacement() const
    {
        if (std::holds_alternative<_transposeInputs>(_target))
            return std::get<0>(std::get<_transposeInputs>(_target));
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
        throw std::runtime_error("invalid target for FCTransposer::GetDisplacement");
#endif
        return 0;
    }
    
    eHarmLev GetRaiseLower() const
    {
        if (std::holds_alternative<_transposeInputs>(_target))
            return std::get<1>(std::get<_transposeInputs>(_target));
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
        throw std::runtime_error("invalid target for FCTransposer::GetRaiseLower");
#endif
        return 0;
    }
 
    void DiatonicTranspose(eHarmLev interval)
    { _execute(&FCTransposer::_DiatonicTranspose, interval); }
    
    void OctaveTranspose(twobyte numberofoctaves)
    { _execute(&FCTransposer::_OctaveTranspose, numberofoctaves); }
 
    bool EnharmonicTranspose(twobyte direction)
    { return _execute(&FCTransposer::_EnharmonicTranspose, direction, false); }
 
    bool DefaultEnharmonicTranspose()
    { return _execute(&FCTransposer::_DefaultEnharmonicTranspose); }
    
    bool SimplifySpelling()
    { return _execute(&FCTransposer::_SimplifySpelling, (twobyte)0); }
 
    bool ChromaticTranspose(eHarmLev interval, eHarmAlt alteration, bool simplify = false)
    { return _execute(&FCTransposer::_ChromaticTranspose, interval, alteration, simplify); }
 
    bool EDOStepTranspose(twobyte numberofsteps)
    { return _execute(&FCTransposer::_EDOStepTranspose, numberofsteps); }
};
 
#endif // PDK_FRAMEWORK_ENTRIES
 
 
#endif  /* FF_CELLDETAILS_H */