ff_other.h

/*
 * File:   ff_other.h
 * Author: Jari Williamsson
 *
 * Created on den 26 december 2009, 14:09
 */
 
#ifndef _FF_OTHER_H
#define _FF_OTHER_H
 
#include <cassert>
#include <cmath>
 
#include "ff_timesig.h"
#include "ff_base.h"
#include "ff_region.h"
 
 
 
class __FCOther : public __FCBaseData {
public:
    void SetCmperAndInci(CMPER cmper, twobyte inci)
    {
        _dataid.other.cmper = cmper;
        _dataid.other.inci = inci;
    }
 
 
public:
    const char* ClassName() const override { return "__FCOther"; }
 
    __FCOther() : __FCBaseData() {}
 
 
    bool IsIdenticalRecord(__FCOther* pCompare)
    {
        if (!DataIsLoaded()) return false;
        if (_dataid.other.cmper != pCompare->_GetDataID()->other.cmper) return false;
        if (_dataid.other.inci != pCompare->_GetDataID()->other.inci) return false;
        return true;
    }
};
 
 
class __FCInciOther : public __FCOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool LoadFirst() override { return false; }
    
    bool _RawRelink() override
    {
        DeleteData();
        return SaveNew(GetItemCmper());
    }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    __FCInciOther() : __FCOther() {}
    const char* ClassName() const override { return "__FCInciOther"; }
 
    virtual bool Load(CMPER itemno, twobyte inci);
    
    twobyte CalcLastInci() override;
 
    bool Reload() override;
 
    virtual bool SaveNew(CMPER itemno);
 
    void _SetCmper(CMPER cmper) { _dataid.other.cmper = cmper; }
 
 
    int GetItemCmper() const
    {
        if (!DataIsLoaded()) return kNewCmper;
        return _dataid.other.cmper;
    }
 
    int GetItemInci() const
    {
        if (!DataIsLoaded()) return kNewInci;
        return _dataid.other.inci;
    }
    
    
    virtual eMeas GetMeasure() const { return 0; }
    
    virtual eStaff GetStaff() const { return 0; }
    
    virtual bool HasStaffValue() const { return false; }
    
    virtual TimeEdu32 GetMeasurePos() const { return 0; }
};
 
class FCOtherInci : public __FCInciOther
{
        twobyte _inciblock[6];
 
        int DataSizeLoad() const override { return sizeof(_inciblock); }  /* A standard inci */
        void* Allocate() override { return _GetDataPtr(); }
        EXTAG Tag() const override { return GetCustomTag();  }
 
        void CloneMemoryFrom(__FCBaseData* pSource) override
        {
                memcpy(&_inciblock, ((FCOtherInci*)pSource)->_GetDataPtr(), sizeof(_inciblock));
                _datablock = &_inciblock;
                _loadedsize = sizeof(_inciblock);
        }
 
        __FCBaseData* CreateObject() override
        {
                return new FCOtherInci();
        }
public:
 
    FCOtherInci(EXTAG customTag = 0) : __FCInciOther()
        {
        if (customTag) SetCustomTag(customTag);
                memset(&_inciblock, 0, sizeof(_inciblock));
                _datablock = &_inciblock;
                _loadedsize = sizeof(_inciblock);
        _TagDocumentID();
        }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        void* _GetDataPtr() { return &_inciblock; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
        const char* ClassName() const override { return "FCOtherInci"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_OTHERINCI; }
};
 
 
 
class __FCNoInciOther : public __FCOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    int _DataSizeLoadFullCmper(CMPER cmper, ETAG othertag) const;
 
    bool _SaveOtherFullCmper(CMPER cmper, void* buffer, int size, ETAG othertag);
 
    bool _LoadOtherFullCmper(CMPER cmper, void* buffer, int size, ETAG othertag);
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "__FCNoInciOther"; }
 
    __FCNoInciOther() : __FCOther() {}
 
    virtual bool Load(CMPER itemno);
 
    bool Reload() override;
 
    virtual bool SaveAs(CMPER itemno);
 
    virtual bool DeepSaveAs(CMPER itemno)
    {
        return SaveAs(itemno);
    }
 
    bool DeepDeleteData() override
    {
        return DeleteData();
    }
 
    virtual bool SaveNew();
 
    virtual CMPER GetItemNo() const { return _dataid.other.cmper; }
 
    void SetItemNo(CMPER cmper)
    {
        _dataid.other.cmper = cmper;
        _dataid.other.inci = 0;
    }
 
    bool LoadFirst() override { return Load(1); }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCOther::DebugDump();
        DebugOutInt("dataid.other.cmper: ", _dataid.other.cmper);
    }
#endif
 
};
 
 
class __FCCompositeTimeSigTopElement : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTCompositeTimeUpper _compositetimeupperdata;
 
protected:
    EXTAG Tag() const override { return ot_CompositeTimeUpper; }
    int DataSizeLoad() const override { return sizeof(EDTCompositeTimeUpper); }
    void* Allocate() override { return (void*) &_compositetimeupperdata; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_compositetimeupperdata, ((__FCCompositeTimeSigTopElement*)pSource)->_GetDataPtr(), sizeof(_compositetimeupperdata));
        _datablock = &_compositetimeupperdata;
        _loadedsize = sizeof(_compositetimeupperdata);
    }
 
    __FCBaseData* CreateObject() override
    {
        return new __FCCompositeTimeSigTopElement();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "__FCCompositeTimeSigTopElement"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_COMPOSITETIMESIGTOPELEMENT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetDataPtr() { return &_compositetimeupperdata; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    __FCCompositeTimeSigTopElement() : __FCInciOther()
    {
        memset(&_compositetimeupperdata, 0, sizeof(_compositetimeupperdata));
        _datablock = &_compositetimeupperdata;
        _loadedsize = sizeof(_compositetimeupperdata);
    }
 
    ECompositeTimeUpper* _GetFirstRecordPtr() { return &_compositetimeupperdata.elements[0]; }
 
    ECompositeTimeUpper* _GetSecondRecordPtr() { return &_compositetimeupperdata.elements[1]; }
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
    }
#endif
};
 
 
 
class __FCCompositeTimeSigBottomElement : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTCompositeTimeLower _compositetimelowerdata;
 
protected:
    EXTAG Tag() const override { return ot_CompositeTimeLower; }
    int DataSizeLoad() const override { return sizeof(EDTCompositeTimeLower); }
    void* Allocate() override { return (void*) &_compositetimelowerdata; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_compositetimelowerdata, ((__FCCompositeTimeSigBottomElement*)pSource)->_GetDataPtr(), sizeof(_compositetimelowerdata));
        _datablock = &_compositetimelowerdata;
        _loadedsize = sizeof(_compositetimelowerdata);
    }
 
    __FCBaseData* CreateObject() override
    {
        return new __FCCompositeTimeSigBottomElement();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "__FCCompositeTimeSigBottomElement"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_COMPOSITETIMESIGBOTTOMELEMENT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetDataPtr() { return &_compositetimelowerdata; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    __FCCompositeTimeSigBottomElement() : __FCInciOther()
    {
        memset(&_compositetimelowerdata, 0, sizeof(_compositetimelowerdata));
        _datablock = &_compositetimelowerdata;
        _loadedsize = sizeof(_compositetimelowerdata);
    }
 
    ECompositeTimeLower* _GetFirstRecordPtr() { return &_compositetimelowerdata.elements[0]; }
 
    ECompositeTimeLower* _GetSecondRecordPtr() { return &_compositetimelowerdata.elements[1]; }
 
    ECompositeTimeLower* _GetThirdRecordPtr() { return &_compositetimelowerdata.elements[2]; }
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
    }
#endif
};
 
 
 
#ifdef PDK_FRAMEWORK_COMPOSITETIMESIGS
class FCCompositeTimeSigTop : public __FCCollectionInciOther
{
    ECompositeTimeUpper* _pArray;
 
    int _arraycounter;
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    ECompositeTimeUpper* _GetGroupElementPtr(int groupindex, int subindex) const
    {
        groupindex++; /* Make the index 1-based internally for this method */
        int currentindex = 0;
        int subindexcount = 0;
        for (int i = 0; i < _arraycounter; i++)
        {
            if (_pArray[i].chainstart) currentindex++;
            if (currentindex == groupindex)
            {
                if (subindexcount == subindex) return &_pArray[i];
                subindexcount++;
            }
            if (currentindex > groupindex) return NULL;
        }
        return NULL;
    }
 
    void _RedistributeArray(CMPER cmper = 0)
    {
        if (cmper == 0)
        {
            if (GetCount() == 0) return; /* To prevent crash */
            __FCCompositeTimeSigTopElement* pFirstInci = (__FCCompositeTimeSigTopElement*) GetItemAt(0);
            cmper = pFirstInci->_GetDataID()->other.cmper;
        }
        ClearAll();
        twobyte inci = 0;
        __FCCompositeTimeSigTopElement* pCurrentObject = NULL;
        for (int i = 0; i < _arraycounter; i++)
        {
            if (i % 2 == 0)
            {
                pCurrentObject = new __FCCompositeTimeSigTopElement();
                EDataID* pDataID = (EDataID*) pCurrentObject->_GetDataID(); /* "Turn off" const */
                pDataID->other.cmper = cmper;
                pDataID->other.inci = inci;
                inci++;
                memcpy(pCurrentObject->_GetFirstRecordPtr(), &_pArray[i], sizeof(ECompositeTimeUpper));
            }
            else
            {
                memcpy(pCurrentObject->_GetSecondRecordPtr(), &_pArray[i], sizeof(ECompositeTimeUpper));
                Add(pCurrentObject);
                pCurrentObject = NULL;
            }
        }
        if (pCurrentObject) Add(pCurrentObject);        
    }
#endif
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new __FCCompositeTimeSigTopElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    public:
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _BuildArray()
    {
        delete [] _pArray;
        _pArray = NULL;
        _arraycounter = 0;
        if (GetCount() == 0) return;
        /* Count the number of active records in the array */
        int activerecords = 0;
        for (int i = 0; i < GetCount(); i++)
        {
            __FCCompositeTimeSigTopElement* pData = (__FCCompositeTimeSigTopElement*) GetItemAt(i);
            ECompositeTimeUpper* pCompositeTimeUpper = pData->_GetFirstRecordPtr();
            if ((pCompositeTimeUpper->main == 0) &&
                    (pCompositeTimeUpper->fraction ==  0)) continue;
            activerecords ++;
            pCompositeTimeUpper = pData->_GetSecondRecordPtr();
            if ((pCompositeTimeUpper->main == 0) &&
                    (pCompositeTimeUpper->fraction ==  0)) continue;
            activerecords ++;
        }
        if (activerecords == 0) return;
        // Allocate memory and copy:
        _pArray = new ECompositeTimeUpper[activerecords];
        int currentindex = 0;
        for (int i = 0; i < GetCount(); i++)
        {
            __FCCompositeTimeSigTopElement* pData = (__FCCompositeTimeSigTopElement*) GetItemAt(i);
            ECompositeTimeUpper* pCompositeTimeUpper = pData->_GetFirstRecordPtr();
            if ((pCompositeTimeUpper->main == 0) &&
                    (pCompositeTimeUpper->fraction ==  0)) continue;
            memcpy(&_pArray[currentindex], pCompositeTimeUpper, sizeof(ECompositeTimeUpper));
            currentindex ++;
            pCompositeTimeUpper = pData->_GetSecondRecordPtr();
            if ((pCompositeTimeUpper->main == 0) &&
                    (pCompositeTimeUpper->fraction ==  0)) continue;
            memcpy(&_pArray[currentindex], pCompositeTimeUpper, sizeof(ECompositeTimeUpper));
            currentindex ++;
        }
        _arraycounter = activerecords;
    }
#endif
 
        const char* ClassName() const override { return "FCCompositeTimeSigTop"; }
 
        FCCompositeTimeSigTop() : __FCCollectionInciOther()
        {
            _pArray = NULL;
            _arraycounter = 0;
        }
 
        virtual ~FCCompositeTimeSigTop()
        {
            delete [] _pArray;
            _pArray = NULL;
            _arraycounter = 0;
        }
 
        int GetGroupCount() const
        {
            int groupcount = 0;
            for (int i = 0; i < _arraycounter; i++)
            {
                if (_pArray[i].chainstart) groupcount++;
            }
            return groupcount;
        }
 
        int AddGroup(int elementcount)
        {            
            if (elementcount < 1) return -1;
            if (elementcount > 10) return -1;
            
            ECompositeTimeUpper* pNewArray = new ECompositeTimeUpper[_arraycounter + elementcount];
            
            if (_pArray)
            {
                /* Copy the old data and remove it */
                int bytesize = sizeof(ECompositeTimeUpper) * _arraycounter;
                memcpy(pNewArray, _pArray, bytesize);
                delete [] _pArray;
            }
            
            /* Initialize the new data */
            ECompositeTimeUpper* pNewAddedData = &pNewArray[_arraycounter];
            for (int i = 0; i < elementcount; i++)
            {
                pNewAddedData->chainstart = (i == 0);
                pNewAddedData->fraction = 0;
                pNewAddedData->main = 1;
                pNewAddedData ++;
            }
                        
            /* Set new info: */
            _arraycounter += elementcount;
            _pArray = pNewArray;
                        
            return GetGroupCount() - 1;
        }
 
        void MergeWithPreviousGroup(int groupindex)
        {
            if (groupindex < 1) return;
            ECompositeTimeUpper* pData = _GetGroupElementPtr(groupindex, 0);
            if (!pData) return;
            pData->chainstart = false;
        }
 
 
        int GetGroupElementCount(int index) const
        {
            index++; /* Make the index 1-based internally for this method */
            int currentindex = 0;
            int count = 0;
            for (int i = 0; i < _arraycounter; i++)
            {
                if (_pArray[i].chainstart) currentindex++;
                if (currentindex == index) count++;
                if (currentindex > index) return count;
            }
            return count;            
        }
 
        int CalcTotalGroupBeats(int groupindex) const
        {
            int beatcount = 0;
            int elementcount = GetGroupElementCount(groupindex);
            for (int elementidx = 0; elementidx < elementcount; elementidx++)
            {
                beatcount += GetGroupElementBeats(groupindex, elementidx);
            }
            return beatcount;
        }
 
        int GetGroupElementBeats(int groupindex, int subindex) const
        {
            ECompositeTimeUpper* pCompositeTimeUpper = _GetGroupElementPtr(groupindex, subindex);
            if (!pCompositeTimeUpper) return 0;
            return pCompositeTimeUpper->main;
        }
 
        double GetGroupElementBeatsWithFraction(int groupindex, int subindex) const
        {
            ECompositeTimeUpper* pCompositeTimeUpper = _GetGroupElementPtr(groupindex, subindex);
            if (!pCompositeTimeUpper) return 0;
            if (! pCompositeTimeUpper->fraction) return pCompositeTimeUpper->main;
            assert(LO_UONEBYTE(pCompositeTimeUpper->fraction) != 0);
            return static_cast<double>(pCompositeTimeUpper->main) +
                    (static_cast<double>(HI_UONEBYTE(pCompositeTimeUpper->fraction)) / static_cast<double>(LO_UONEBYTE(pCompositeTimeUpper->fraction)));
        }
 
        int GetElementCount() const
        {
            return _arraycounter;
        }
 
        void SetGroupElementBeats(int groupindex, int subindex, twobyte value)
        {
            ECompositeTimeUpper* pCompositeTimeUpper = _GetGroupElementPtr(groupindex, subindex);            
            if (!pCompositeTimeUpper) return;
            pCompositeTimeUpper->main = value;
        }
 
        void SetGroupElementBeatsWithFraction(int groupindex, int subindex, double value)
        {
            ECompositeTimeUpper* pCompositeTimeUpper = _GetGroupElementPtr(groupindex, subindex);
            if (!pCompositeTimeUpper) return;
            if (value == std::floor(value))
            {
                pCompositeTimeUpper->main = std::floor(value);
                pCompositeTimeUpper->fraction = 0;
            }
            else
            {
                double integer;
                double fraction = std::modf(value, &integer);
                pCompositeTimeUpper->main = integer;
                pCompositeTimeUpper->fraction = MAKE_TWOBYTE(120, std::lround(fraction * 120.0));
            }
        }
 
        bool SaveAll() override
        {
            if (_arraycounter == 0) return false;
            if (GetCount() == 0)
            {
#ifdef PDK_FRAMEWORK_DIAGNOSE
                DebugOut("FCCompositeTimeSigTop()::SaveAll(): No existing collection items to read CMPER.");
#endif
                return false; /* There must be an existing CMPER to save to */
            }
            _RedistributeArray();
            __FCCompositeTimeSigTopElement* pFirstInci = (__FCCompositeTimeSigTopElement*) GetItemAt(0);
            CMPER cmper = pFirstInci->_GetDataID()->other.cmper;
            DeleteDataForItem(cmper);
            return __FCCollectionInciOther::SaveAll();
        }
 
        bool SaveAllForItem(CMPER cmper) override
        {
            if (_arraycounter == 0) return false;
 
            _RedistributeArray(cmper);
            
            if (GetCount() == 0)
            {
#ifdef PDK_FRAMEWORK_DIAGNOSE
                DebugOut("FCCompositeTimeSigTop()::SaveAllForItem(): No existing collection items to read CMPER.");
#endif
                return false; /* There must be an existing CMPER to save to */
            }
                        
            DeleteDataForItem(cmper);
            __FCCollectionInciOther::SaveAll();
 
            return true;
        }
};
 
#endif /*PDK_FRAMEWORK_COMPOSITETIMESIGS*/
 
 
#ifdef PDK_FRAMEWORK_COMPOSITETIMESIGS
class FCCompositeTimeSigBottom : public __FCCollectionInciOther
{
    ECompositeTimeLower* _pArray;
 
    int _arraycounter;
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    ECompositeTimeLower* _GetGroupElementPtr(int groupindex, int subindex) const
    {
        groupindex++; /* Make the index 1-based internally for this method */
        int currentindex = 0;
        int subindexcount = 0;
        for (int i = 0; i < _arraycounter; i++)
        {
            if (_pArray[i].chainstart) currentindex++;
            if (currentindex == groupindex)
            {
                if (subindexcount == subindex) return &_pArray[i];
                subindexcount++;
            }
            if (currentindex > groupindex) return NULL;
        }
        return NULL;
    }
 
    void _RedistributeArray(CMPER cmper = 0)
    {
        if (cmper == 0)
        {
            if (GetCount() == 0) return; /* To avoid crashes */
            __FCCompositeTimeSigBottomElement* pFirstInci = (__FCCompositeTimeSigBottomElement*) GetItemAt(0);
            cmper = pFirstInci->_GetDataID()->other.cmper;
        }
        ClearAll();
        twobyte inci = 0;
        __FCCompositeTimeSigBottomElement* pCurrentObject = NULL;
        EDataID* pDataID = NULL;
        for (int i = 0; i < _arraycounter; i++)
        {
            switch (i % 3) {
                case 0:
                    pCurrentObject = new __FCCompositeTimeSigBottomElement();
                    pDataID = (EDataID*) pCurrentObject->_GetDataID(); /* "Turn off" const */
                    pDataID->other.cmper = cmper;
                    pDataID->other.inci = inci;
                    inci++;
                    memcpy(pCurrentObject->_GetFirstRecordPtr(), &_pArray[i], sizeof (ECompositeTimeLower));
                    break;
                case 1:
                    memcpy(pCurrentObject->_GetSecondRecordPtr(), &_pArray[i], sizeof (ECompositeTimeLower));
                    break;
                default:
                    memcpy(pCurrentObject->_GetThirdRecordPtr(), &_pArray[i], sizeof (ECompositeTimeLower));
                    Add(pCurrentObject);
                    pCurrentObject = NULL;
                    break;
            }
        }
        if (pCurrentObject) Add(pCurrentObject);
    }
#endif
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new __FCCompositeTimeSigBottomElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    public:
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _BuildArray()
    {
        delete [] _pArray;
        _pArray = NULL;
        _arraycounter = 0;
        if (GetCount() == 0) return;
        /* Count the number of active records in the array */
        int activerecords = 0;
        for (int i = 0; i < GetCount(); i++)
        {
            __FCCompositeTimeSigBottomElement* pData = (__FCCompositeTimeSigBottomElement*) GetItemAt(i);
            ECompositeTimeLower* pCompositeTimeLower = pData->_GetFirstRecordPtr();
            if (pCompositeTimeLower->main == 0) continue;
            activerecords ++;
            pCompositeTimeLower = pData->_GetSecondRecordPtr();
            if (pCompositeTimeLower->main == 0) continue;
            activerecords ++;
            pCompositeTimeLower = pData->_GetThirdRecordPtr();
            if (pCompositeTimeLower->main == 0) continue;
            activerecords ++;
        }
        if (activerecords == 0) return;
        // Allocate memory and copy:
        _pArray = new ECompositeTimeLower[activerecords];
        int currentindex = 0;
        for (int i = 0; i < GetCount(); i++)
        {
            __FCCompositeTimeSigBottomElement* pData = (__FCCompositeTimeSigBottomElement*) GetItemAt(i);
            ECompositeTimeLower* pCompositeTimeLower = pData->_GetFirstRecordPtr();
            if (pCompositeTimeLower->main == 0) continue;
            memcpy(&_pArray[currentindex], pCompositeTimeLower, sizeof(ECompositeTimeLower));
            currentindex ++;
            pCompositeTimeLower = pData->_GetSecondRecordPtr();
            if (pCompositeTimeLower->main == 0) continue;
            memcpy(&_pArray[currentindex], pCompositeTimeLower, sizeof(ECompositeTimeLower));
            currentindex ++;
            pCompositeTimeLower = pData->_GetThirdRecordPtr();
            if (pCompositeTimeLower->main == 0) continue;
            memcpy(&_pArray[currentindex], pCompositeTimeLower, sizeof(ECompositeTimeLower));
            currentindex ++;
        }
        _arraycounter = activerecords;
    }
#endif
 
        const char* ClassName() const override { return "FCCompositeTimeSigBottom"; }
 
        FCCompositeTimeSigBottom() : __FCCollectionInciOther()
        {
            _pArray = NULL;
            _arraycounter = 0;
        }
 
        virtual ~FCCompositeTimeSigBottom()
        {
            delete [] _pArray;
            _pArray = NULL;
            _arraycounter = 0;
        }
 
        int GetGroupCount() const
        {            
            int groupcount = 0;
            for (int i = 0; i < _arraycounter; i++)
            {
                if (_pArray[i].chainstart) groupcount++;
            }
            return groupcount;
        }
 
        int GetGroupElementCount(int groupindex) const
        {
            groupindex++; /* Make the index 1-based internally for this method */
            int currentindex = 0;
            int count = 0;
            for (int i = 0; i < _arraycounter; i++)
            {
                if (_pArray[i].chainstart) currentindex++;
                if (currentindex == groupindex) count++;
                if (currentindex > groupindex) return count;
            }
            return count;
        }
 
        int GetGroupElementBeatDuration(int groupindex, int subindex) const
        {
            ECompositeTimeLower* pCompositeTimeLower = _GetGroupElementPtr(groupindex, subindex);
            if (!pCompositeTimeLower) return 0;
            return pCompositeTimeLower->main;
        }
 
        int GetElementCount() const
        {
            return _arraycounter;
        }
 
        int AddGroup(int elementcount = 1)
        {            
            if (elementcount < 1) return -1;
            if (elementcount > 10) return -1;
 
            ECompositeTimeLower* pNewArray = new ECompositeTimeLower[_arraycounter + elementcount];
 
            if (_pArray)
            {
                /* Copy the old data and remove it */
                int bytesize = sizeof(ECompositeTimeLower) * _arraycounter;
                memcpy(pNewArray, _pArray, bytesize);
                delete [] _pArray;
            }
 
            /* Initialize the new data */
            ECompositeTimeLower* pNewAddedData = &pNewArray[_arraycounter];
            for (int i = 0; i < elementcount; i++)
            {
                pNewAddedData->chainstart = (i == 0);
                pNewAddedData->main = 1024;
                pNewAddedData ++;
            }
 
            /* Set new info: */
            _arraycounter += elementcount;
            _pArray = pNewArray;
 
            return GetGroupCount() - 1;
        }
 
        bool DeleteGroup(int groupindex)
        {
            // JW seems to have believed that each group could only contain one element.
            // (This is certainly the most typical scenario.)
            // However, groups can definitely contain multiple elements, so this function
            // DOES NOT WORK as written! Hence, it is not Lua-connected. RGP 12/27/2021
            if (groupindex < 0) return false;
            if (groupindex >= GetElementCount()) return false;
 
            /* Assumes that all groups are one element long!!! */
            for (int idx = groupindex; idx < _arraycounter - 1; idx ++)
            {
                TimeEdu32 value = GetGroupElementBeatDuration(idx + 1, 0);
                SetGroupElementBeatDuration(idx, 0, value);
            }
            
            _arraycounter --;
            return true;
        }
 
        void SetGroupElementBeatDuration(int groupindex, int subindex, twobyte value)
        {
            ECompositeTimeLower* pCompositeTimeLower = _GetGroupElementPtr(groupindex, subindex);
            if (!pCompositeTimeLower) return;
            pCompositeTimeLower->main = value;
        }
 
        bool SaveAll() override
        {
            if (_arraycounter == 0) return false;
            if (GetCount() == 0)
            {
#ifdef PDK_FRAMEWORK_DIAGNOSE
                DebugOut("FCCompositeTimeSigBottom()::SaveAll(): No existing collection items to read CMPER.");
#endif
                return false; /* There must be an existing CMPER to save to */
            }
            _RedistributeArray();
            __FCCompositeTimeSigBottomElement* pFirstInci = (__FCCompositeTimeSigBottomElement*) GetItemAt(0);
            CMPER cmper = pFirstInci->_GetDataID()->other.cmper;
            DeleteDataForItem(cmper);
            return __FCCollectionInciOther::SaveAll();
        }
 
        bool SaveAllForItem(CMPER cmper) override
        {
            if (_arraycounter == 0) return false;
            _RedistributeArray(cmper);
            if (GetCount() == 0)
            {
#ifdef PDK_FRAMEWORK_DIAGNOSE
                DebugOut("FCCompositeTimeSigBottom()::SaveAllForItem(): No existing collection items to read CMPER.");
#endif
                return false; /* There must be an existing CMPER to save to */
            }
            
            DeleteDataForItem(cmper);
            __FCCollectionInciOther::SaveAll();
 
            return true;
        }
};
#endif
 
 
#ifdef PDK_FRAMEWORK_SHAPES
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
#include "pragma_align_begin.h"
#if OPERATING_SYSTEM == WINDOWS
struct __EDTPathData2014  /* 13 bytes */
{    
        double          f;
        fourbyte        l;
        onebyte         isFloat;
};
#elif OPERATING_SYSTEM == MAC_OS
struct __EDTPathData2014  /* 16 bytes */
{
    double              f;
    fourbyte    l;
    fourbyte    isFloat;
};
#endif
#include "pragma_align_end.h"
 
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
class FCShapeDefInstruction : public __FCBase
{
    ETAG _tag;   /* Instruction tag */
    int _size;  /* number of parameters */    
    EDTPathData2002* _pPathDataOld;  /* Pointer to data (pre-2014) */
    __EDTPathData2014* _pPathData2014;  /* Pointer to data for Finale 2014 */
#if FXT_VERSION >= FINALEVERSION_2014B
    EDTPathData2014b* _pPathData2014b;  /* Pointer to data for Finale 2014b and later */
#endif
    mutable FCString _tagstring;    /* For GetTagAsString() */
 
    bool _Is2014Format() const;
    bool _Is2014bFormat() const;
    
    void _SetTag(ETAG tag)
    {
        _tag = tag;
    }
 
    void _AllocateParameters(int parametercount);
 
    void _SetFourbyteParameter(int parameterindex, fourbyte intvalue);
 
public:
    
    enum SHAPEDEFTAGS
    {
        SHAPETAG_SETFONT = st_setfont,
        
        SHAPETAG_STARTOBJECT = st_startobject,
        
        SHAPETAG_STARTGROUP = st_startgroup,
        
        SHAPETAG_ENDGROUP = st_endgroup,
        
        SHAPETAG_DRAWCHAR = st_drawchar,
        
        SHAPETAG_STROKE = st_stroke,
        
        SHAPETAG_RMOVETO = st_rmoveto,
        
        SHAPETAG_LINEWIDTH = st_linewidth,
        
        SHAPETAG_SETDASH = st_setdash,
        
        SHAPETAG_LINETO = st_rlineto,
        
        SHAPETAG_SETGRAY = st_setgray,
        
        SHAPETAG_ELLIPSE = st_ellipse,
        
        SHAPETAG_FILLSOLID = st_fillsolid,
        
        SHAPETAG_CURVETO = st_curveto,
        
        SHAPETAG_SLUR = st_slur,
        
        SHAPETAG_RECTANGLE = st_rectangle,
        
        SHAPETAG_CLOSEPATH = st_closepath,
        
        SHAPETAG_BRACKET = st_bracket,
        
        SHAPETAG_NULL = st_null
    };
    
    FCShapeDefInstruction(ETAG tag, int instructionsize,
                                void* pPathData);
 
    /* Constructor for using new, created data */
    FCShapeDefInstruction();
    const char* ClassName() const override { return "FCShapeDefInstruction"; }
 
    void _SetMemory(EDTPathInst* pPathInstruction, void* pPathData, int offset);
 
    virtual ~FCShapeDefInstruction();
 
    int GetCount() const { return _size; }
    
    ETAG GetTag() const
    {
        return _tag;
    }
    
    bool IsIdentical(const __FCBase* pTestObject) const override
    {
        const FCShapeDefInstruction* pTestInstruction = dynamic_cast<const FCShapeDefInstruction*>(pTestObject);
        if(!pTestInstruction) return false;
        if (GetCount() != pTestInstruction->GetCount()) return false;
        if (GetTag() != pTestInstruction->GetTag()) return false;
        int count = GetCount();
        for (int i = 0; i < count; i++)
        {
            if (GetFourbyteData(i) != pTestInstruction->GetFourbyteData(i)) return false;
        }
        return true;
    }
 
    const char* GetTagAsString() const
    {
        _tagstring.Clear();
        switch (GetTag()) {
            case st_setfont:
                _tagstring.SetCString("setfont");
                break;
            case st_startobject:
                _tagstring.SetCString("startobject");
                break;
            case st_startgroup:
                _tagstring.SetCString("startgroup");
                break;
            case st_endgroup:
                _tagstring.SetCString("endgroup");
                break;
            case st_drawchar:
                _tagstring.SetCString("drawchar");
                break;
            case st_stroke:
                _tagstring.SetCString("stroke");
                break;
            case st_rmoveto:
                _tagstring.SetCString("rmoveto");
                break;
            case st_linewidth:
                _tagstring.SetCString("linewidth");
                break;
            case st_setdash:
                _tagstring.SetCString("setdash");
                break;
            case st_rlineto:
                _tagstring.SetCString("rlineto");
                break;
            case st_setgray:
                _tagstring.SetCString("setgrey");
                break;
            case st_ellipse:
                _tagstring.SetCString("ellipse");
                break;
            case st_fillsolid:
                _tagstring.SetCString("fillsolid");
                break;
            case st_curveto:
                _tagstring.SetCString("curveto");
                break;
            case st_slur:
                _tagstring.SetCString("slur");
                break;
            case st_rectangle:
                _tagstring.SetCString("rectangle");
                break;
            case st_closepath:
                _tagstring.SetCString("closepath");
                break;
            case st_bracket:
                _tagstring.SetCString("bracket");
                break;
            case 0:
                _tagstring.SetCString("Null");
                break;
            default:
                _tagstring.AppendCharacter((GetTag() & 0xff00) / 256);
                _tagstring.AppendCharacter(GetTag() & 0xff);
                break;
        }
 
        return _tagstring.GetCString();
    }
 
    fourbyte GetFourbyteData(int index) const;
 
        bool SetFourbyteData(int index, fourbyte fbvalue)
        {
                if (index < 0) return false;
                if (index >= _size) return false;
                _SetFourbyteParameter(index, fbvalue);
                return true;
        }       
 
    double GetFloatData(int index);
    
    void Init_StartObject(int xorigin, int yorigin, int left, int top, int right, int bottom, int xtransform = 1000, int ytransform = 1000, int rotation = 0)
    {
        _SetTag(st_startobject);
        _AllocateParameters(11);
        _SetFourbyteParameter(0, xorigin);
        _SetFourbyteParameter(1, yorigin);
        _SetFourbyteParameter(2, left);
        _SetFourbyteParameter(3, top);
        _SetFourbyteParameter(4, right);
        _SetFourbyteParameter(5, bottom);
        _SetFourbyteParameter(6, xtransform);
        _SetFourbyteParameter(7, ytransform);
        _SetFourbyteParameter(8, rotation);
        /* The rest of the parameters is 0 */
    }
 
    void Init_StartGroup(int xorigin, int yorigin, int left, int top, int right, int bottom, int xtransform = 1000, int ytransform = 1000, int rotation = 0)
    {
        _SetTag(st_startgroup);
        _AllocateParameters(11);
        _SetFourbyteParameter(0, xorigin);
        _SetFourbyteParameter(1, yorigin);
        _SetFourbyteParameter(2, left);
        _SetFourbyteParameter(3, top);
        _SetFourbyteParameter(4, right);
        _SetFourbyteParameter(5, bottom);
        _SetFourbyteParameter(6, xtransform);
        _SetFourbyteParameter(7, ytransform);
        _SetFourbyteParameter(8, rotation);
        /* The rest of the parameters is 0 */
    }
 
    void Init_EndGroup()
    {
        _SetTag(st_endgroup);
        _AllocateParameters(0);
    }
 
    void Init_RMoveTo(int x, int y)
    {
        _SetTag(st_rmoveto);
        _AllocateParameters(2);
        _SetFourbyteParameter(0, x);
        _SetFourbyteParameter(1, y);
    }
 
    void Init_CurveTo(int x1, int y1, int x2, int y2, int endpt_x, int endpt_y)
    {
        _SetTag(st_curveto);
        _AllocateParameters(6);
        _SetFourbyteParameter(0, x1);
        _SetFourbyteParameter(1, y1);
        _SetFourbyteParameter(2, x2);
        _SetFourbyteParameter(3, y2);
        _SetFourbyteParameter(4, endpt_x);
        _SetFourbyteParameter(5, endpt_y);
    }
 
    void Init_Slur(int x1, int y1, int x2, int y2, int endpt_x, int endpt_y)
    {
        _SetTag(st_slur);
        _AllocateParameters(6);
        _SetFourbyteParameter(0, x1);
        _SetFourbyteParameter(1, y1);
        _SetFourbyteParameter(2, x2);
        _SetFourbyteParameter(3, y2);
        _SetFourbyteParameter(4, endpt_x);
        _SetFourbyteParameter(5, endpt_y);
    }
 
 
    void Init_LineWidth(int linewidth)
    {
        _SetTag(st_linewidth);
        _AllocateParameters(1);
        _SetFourbyteParameter(0, linewidth);
    }
 
    void Init_SetGrey(int greyvalue)
    {
        _SetTag(st_setgray);
        _AllocateParameters(1);
        _SetFourbyteParameter(0, greyvalue);
    }
 
    void Init_FillSolid()
    {
        _SetTag(st_fillsolid);
        _AllocateParameters(0);
    }
 
    void Init_ClosePath()
    {
        _SetTag(st_closepath);
        _AllocateParameters(0);
    }
 
    void Init_Ellipse(int width, int height)
    {
        _SetTag(st_ellipse);
        _AllocateParameters(2);
        _SetFourbyteParameter(0, width);
        _SetFourbyteParameter(1, height);
    }
 
    void Init_Rectangle(int width, int height)
    {
        _SetTag(st_rectangle);
        _AllocateParameters(2);
        _SetFourbyteParameter(0, width);
        _SetFourbyteParameter(1, height);
    }
 
    void Init_DrawChar(eUniChar16 character)
    {
        _SetTag(st_drawchar);
        _AllocateParameters(1);
        _SetFourbyteParameter(0, character);
    }
 
    void Init_SetFont(FCFontInfo* pFontInfo)
    {
        _SetTag(st_setfont);
        _AllocateParameters(3);
        _SetFourbyteParameter(0, pFontInfo->GetIDByName());  /* Enigma font ID */
        _SetFourbyteParameter(1, pFontInfo->GetSize());  /* font size */
        _SetFourbyteParameter(2, pFontInfo->GetEnigmaStyles());   /* efx */
    }
 
    void Init_SetDash(int dashlength, int spacebetween)
    {
        _SetTag(st_setdash);
        _AllocateParameters(2);
        _SetFourbyteParameter(0, dashlength);
        _SetFourbyteParameter(1, spacebetween);
    }
 
    void Init_RLineTo(int x, int y)
    {
        _SetTag(st_rlineto);
        _AllocateParameters(2);
        _SetFourbyteParameter(0, x);
        _SetFourbyteParameter(1, y);
    }
 
    void Init_Bracket(int brackettype)
    {
        _SetTag(st_bracket);
        _AllocateParameters(1);
        _SetFourbyteParameter(0, brackettype);
    }
 
    void Init_Stroke()
    {
        _SetTag(st_stroke);
        _AllocateParameters(0);
    }
 
    void Init_Null()
    {
        _SetTag(0);
        _AllocateParameters(0);
    }
 
 
#if PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();
 
        DebugOutInt("sizeof double: ", sizeof(double));
        DebugOutString("Tag: ", GetTagAsString());
        
        DebugOutInt("No of parameters: ", _size);
        for (int i = 0; i < _size; i++)
        {
            FCString parameterstring("Parameter ");
            parameterstring.AppendInteger(i + 1);
            parameterstring.AppendCString(": ");
            parameterstring.AppendInteger(GetFourbyteData(i));
            parameterstring.AppendCString("   (");
            parameterstring.AppendFloat(GetFloatData(i));
            parameterstring.AppendCString(")");
            DebugOutString("", &parameterstring);            
        }
    }
#endif
};
#endif  /* PDK_FRAMEWORK_SHAPES */
 
 
#ifdef PDK_FRAMEWORK_SHAPES
 
class FCShapeDefInstructions : public __FCCollection
{
public:
    const char* ClassName() const override { return "FCShapeDefInstructions"; }
 
    FCShapeDefInstruction* GetItemAt(int index) const { return (FCShapeDefInstruction*) __FCCollection::GetItemAt(index); }
 
    FCShapeDefInstruction* AddNull()
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_Null();
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddStartObject(FCPoint* pOrigin, FCPoint* pBoundLeftTop,
                                    FCPoint* pBoundRightBottom,
                                    int xtransform = 1000, int ytransform = 1000,
                                    int rotation = 0)
    {
        if (!pOrigin) return NULL;
        if (!pBoundLeftTop) return NULL;
        if (!pBoundRightBottom) return NULL;
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
 
        pInstruction->Init_StartObject((int) pOrigin->GetX(),
                                (int) pOrigin->GetY(),
                                (int) pBoundLeftTop->GetX(),
                                (int) pBoundLeftTop->GetY(),
                                (int) pBoundRightBottom->GetX(),
                                (int) pBoundRightBottom->GetY(),
                                xtransform, ytransform, rotation);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddStartGroup(FCPoint* pOrigin, FCPoint* pBoundLeftTop,
                                    FCPoint* pBoundRightBottom,
                                    int xtransform = 1000, int ytransform = 1000,
                                    int rotation = 0)
    {
        if (!pOrigin) return NULL;
        if (!pBoundLeftTop) return NULL;
        if (!pBoundRightBottom) return NULL;
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
 
        pInstruction->Init_StartGroup((int) pOrigin->GetX(),
                                (int) pOrigin->GetY(),
                                (int) pBoundLeftTop->GetX(),
                                (int) pBoundLeftTop->GetY(),
                                (int) pBoundRightBottom->GetX(),
                                (int) pBoundRightBottom->GetY(),
                                xtransform, ytransform, rotation);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddEndGroup()
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_EndGroup();
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddLineWidth(int linewidth)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_LineWidth(linewidth);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddSetGrey(int percent)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_SetGrey(percent);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddFillSolid()
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_FillSolid();
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddClosePath()
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_ClosePath();
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddEllipse(int width, int height)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_Ellipse(width, height);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddRectangle(int width, int height)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_Rectangle(width, height);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddCurveTo(int ctrlpt_height = 72)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_CurveTo(72, ctrlpt_height, 144, 0, 72, -ctrlpt_height);
        Add(pInstruction);
        return pInstruction;
    }
    
    FCShapeDefInstruction* AddCurveToDetails(int x1, int y1, int x2, int y2, int endpt_x, int endpt_y)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_CurveTo(x1, y1, x2, y2, endpt_x, endpt_y);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddSlur(int ctrlpt_height = 72)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_Slur(72, ctrlpt_height, 144, 0, 72, -ctrlpt_height);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddStroke()
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_Stroke();
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddSetDash(int dashlength, int spacebetween)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_SetDash(dashlength, spacebetween);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddRLineTo(int x, int y)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_RLineTo(x, y);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddBracket(int brackettype)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_Bracket(brackettype);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddSolidLineStyle()
    {
        return AddSetDash(18, 0);
    }
 
    FCShapeDefInstruction* AddRMoveTo(int x, int y)
    {
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_RMoveTo(x, y);
        Add(pInstruction);
        return pInstruction;
    }
 
    FCShapeDefInstruction* AddSetFont(FCFontInfo* pFontInfo)
    {
        if (!pFontInfo) return NULL;
        FCShapeDefInstruction* pInstruction = new FCShapeDefInstruction();
        pInstruction->Init_SetFont(pFontInfo);
        Add(pInstruction);
        return pInstruction;
    }
 
        FCShapeDefInstruction* AddDrawChar(eUniChar16 character);
 
    FCShapeDefInstruction* AddDrawChars(const char* pszString)
    {
        if (!pszString) return NULL;
        int length = (int) strlen(pszString);
        FCShapeDefInstruction* pReturn = NULL;
        for (int i = 0; i < length; i++)
        {
            pReturn = AddDrawChar(pszString[i]);
        }
        return pReturn;
    }
    
    FCShapeDefInstruction* AddDrawCharsString(FCString* pString)
    {
        if (!pString) return NULL;
        int length = pString->GetLength();
        FCShapeDefInstruction* pReturn = NULL;
        for (int i = 0; i < length; i++)
        {
            pReturn = AddDrawChar(pString->GetCharacterAt(i));
        }
        return pReturn;
    }
};
#endif  /* PDK_FRAMEWORK_SHAPES */
 
#ifdef PDK_FRAMEWORK_SHAPES
#define __ot_Shape_WORKAROUNDTAG MAKEEXTAG(edOther,'S','D')
 
class FCShapeDef : public __FCNoInciOther
{
public:
    enum SHAPEDEF_TYPES
    {
        SHAPEDEFTYPE_UNKNOWN = -1,
        SHAPEDEFTYPE_OTHER = 0,
        SHAPEDEFTYPE_ARTICULATION = 1,
        SHAPEDEFTYPE_BARLINE = 2,
        SHAPEDEFTYPE_EXECUTABLESHAPE = 3,
        SHAPEDEFTYPE_EXPRESSION = 4,
        SHAPEDEFTYPE_NOTE = 5,
        SHAPEDEFTYPE_FRAME = 6,
        SHAPEDEFTYPE_ARROWHEAD = 7,
        SHAPEDEFTYPE_FRETBOARD = 8,
        SHAPEDEFTYPE_CLEF = 9
    };
 
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTShape* _TypeCast() const { return (EDTShape*)_datablock; }
#if FXT_VERSION >= FINALEVERSION_2014B
    EDTShape2014b* _TypeCast2014b() const { return (EDTShape2014b*)_datablock; }
#endif
    /* _isemptyshape & _shapedeftype are used for pre2014b, to
     try to work around load crashes for empty shapes on Windows */
    bool _isemptyshape;
    SHAPEDEF_TYPES _shapedeftype;
    
    void _AllocateMemory(int size)
    {
       if (size == 0)
        {
            _datablock = NULL;
                        _loadedsize = 0;
            return;
        }
        _datablock = new char [size];
        memset(_datablock, 0, size);
        _loadedsize = size;
    }
 
    bool _Is2014Format() const;
 
    bool _Is2014bFormat() const;
 
    bool _SaveType(SHAPEDEF_TYPES shapedeftype)
    {
        /* On Fin2014b, the shape type is available in the struct. */
        if (_Is2014bFormat()) return true;
        
        twobyte oneinci[6];             
        EDataID dataID;
        dataID.other.cmper = _dataid.other.cmper;
        dataID.other.inci = 0;
        fourbyte size = sizeof(oneinci);
        /* Load the raw data (no special extag!) */
        if (!FX_LoadEData(__ot_Shape_WORKAROUNDTAG, &dataID, &oneinci, &size)) return false;
        oneinci[2] = (twobyte) shapedeftype;
        _shapedeftype = shapedeftype;
        return FX_SaveEData(__ot_Shape_WORKAROUNDTAG, &dataID, &oneinci, size) != 0;
    }
 
    bool _LoadType()
    {
        /* On Fin2014b, the shape type is available in the struct */
        if (_Is2014bFormat()) return true;
        
        twobyte oneinci[6];
        EDataID dataID;
        dataID.other.cmper = _dataid.other.cmper;
        dataID.other.inci = 0;
        fourbyte size = sizeof(oneinci);
        /* Load the raw data (no special extag!) */
        if (!FX_LoadEData(__ot_Shape_WORKAROUNDTAG, &dataID, &oneinci, &size)) return false;
        _shapedeftype = (SHAPEDEF_TYPES) oneinci[2];
        return true;
    }
 
protected:
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ot_Shape; }
 
    EVERSION EnigmaVersion() const override;
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        /* Copy the heap: */
        __FCNoInciOther::CloneMemoryFrom(pSource);
        /* Copy the empty shape state */
        _isemptyshape = ((FCShapeDef*) pSource)->_GetIsEmptyShape();
    }
 
    int DataSizeLoad() const override
    {
        fourbyte size;
        if (!FX_LoadEData(Tag(), &_dataid, NULL, &size, EnigmaVersion())) return 0;
        
#if !defined(__LP64__) && !defined(_WIN64)
        if (!_Is2014bFormat())
        {
            /* Attempt to workaround for empty shape crashes on earlier Finale versions. */
            SetCustomTag((size == sizeof(EDTShape)) ? __ot_Shape_WORKAROUNDTAG : ot_Shape);
        }
#endif // 32-bit only
        
        return size;
    }
 
    void* Allocate() override
    {
        _AllocateMemory(DataSizeLoad());
        return _datablock;
    }
 
    void Deallocate() override
    {
        if (_datablock) delete [] (char*) _datablock;
                _datablock = NULL;
        _loadedsize = 0;
    }
 
    bool IsDynamicSize() override { return true; }
 
    __FCBaseData* CreateObject() override { return new FCShapeDef(); }
 
    EDTPathInst* _GetPathInstructionArray()
    {
        if (_isemptyshape) return NULL;
        if (_Is2014bFormat())
        {
#if FXT_VERSION >= FINALEVERSION_2014B
            return (EDTPathInst*) ((char *)_datablock + _TypeCast2014b()->instrucOff);
#endif
        }
        else
        {
            return (EDTPathInst*) ((char *)_datablock + _TypeCast()->instrucOff);
        }
        return NULL;
    }
 
    void* _GetPathDataArray()
    {
        if (_isemptyshape) return NULL;
        if (_Is2014bFormat())
        {
#if FXT_VERSION >= FINALEVERSION_2014B
            return (void*) ((char *)_datablock + _TypeCast2014b()->dataOff);
#endif
        }
        else
        {
            return (void*) ((char *)_datablock + _TypeCast()->dataOff);
        }
        return NULL;
    }
 
    bool _EmptyShapeCheck(CMPER cmper, bool* pIsEmpty)
    {
#ifdef PDK_FRAMEWORK_DIAGNOSE
        if (_Is2014bFormat())
        {
            DebugOut("FCShapeDef::_EmptyShapeCheck was called on 2014b struct.");
            return false;
        }
#endif
        
        *pIsEmpty = true;
        //twobyte shapetestinci[6];
                EDTShape shapetest;
        memset(&shapetest, 0, sizeof(shapetest));
        EDataID dataID;
        dataID.other.cmper = cmper;
        dataID.other.inci = 0;
        fourbyte size = sizeof(shapetest);
        /* Load the raw data (no special extag) */
        bool result = FX_LoadEData(__ot_Shape_WORKAROUNDTAG,
                    &dataID, &shapetest, &size, EnigmaVersion()) != 0;
        if (!result) return false;
        int loopcount = size / sizeof(twobyte);
        twobyte* pNonZeroCheck = (twobyte*) &shapetest;
        for (int i = 0; i < loopcount; i++)
        {
            if (pNonZeroCheck[i])
            {
                                if (i == 1) continue; /* On the 1st twobyte (0-based), there might
                                                                           be data even for empty shapes!!! */ 
                                if (i == 2) continue; /* On the 2nd twobyte (0-based), there might
                                                                           be data even for empty shapes!!! */
                *pIsEmpty = false;
                return true;
            }
        }
        return true;
    }
 
 
    void* _GetInstructionDataPointer(int index);
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCShapeDef"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SHAPEDEF; }
 
    FCShapeDef() : __FCNoInciOther()
    {
        _isemptyshape = true;
        _shapedeftype = SHAPEDEFTYPE_UNKNOWN;
    }
 
    /* Virtual destructor */
    virtual ~FCShapeDef()
    {
        Deallocate();
    }
 
    bool _GetIsEmptyShape() { return _isemptyshape; }
 
    bool CalcProtected()
    {
        if (_Is2014bFormat()) return false;
        
        EDataID dataID;
        twobyte buffer[6];
        dataID.other.cmper = GetItemNo();
        dataID.other.inci = 0;
        fourbyte size = sizeof(buffer);
        memset(buffer, 0, sizeof(buffer));
        if (!FX_LoadEData(__ot_Shape_WORKAROUNDTAG, &dataID, buffer, &size, FINALEVERSION_2010)) return false;
        return ((buffer[2] & 0x0008) != 0);
    }
 
    bool LoadFirst() override
    {
        return Load(1);
    }
 
    bool DeleteData() override
    {
        if (CalcProtected()) return false;
        return __FCNoInciOther::DeleteData();
    }
 
    bool LoadNext() override
    {
        return Load(GetItemNo() + 1);
    }
 
    bool Load(CMPER itemno) override
    {    
        bool isemptyshape;
        
        bool result = false;
        if (_Is2014bFormat())
        {
            /* Normal load */
            result = __FCNoInciOther::Load(itemno);
            if (result)
            {
#if FXT_VERSION >= FINALEVERSION_2014B
                _shapedeftype = (SHAPEDEF_TYPES) _TypeCast2014b()->shapeType;
                /* _isemptyshape shouldn't actively be used on 2014b+ */
                _isemptyshape = (_TypeCast2014b()->instrucLen == 0);
#endif
            }
            else
            {
                _shapedeftype = SHAPEDEFTYPE_UNKNOWN;
                _isemptyshape = true;
            }
        }
        else
        {
            /* On pre2014b, try to work around the empty shape crash bug */
            if (!_EmptyShapeCheck(itemno, &isemptyshape)) return false;
            SetCustomTag(isemptyshape ? __ot_Shape_WORKAROUNDTAG : ot_Shape);
            _isemptyshape = isemptyshape;
            result = __FCNoInciOther::Load(itemno);
            if (result)
                _LoadType();
            else
                _shapedeftype = SHAPEDEFTYPE_UNKNOWN;
        }
        return result;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SHAPEDEF_TYPES
#else
    int
#endif
    GetType() const {
        if (!DataIsLoaded()) return SHAPEDEFTYPE_UNKNOWN;
        if (_Is2014bFormat())
        {
#if FXT_VERSION >= FINALEVERSION_2014B
            return (FCShapeDef::SHAPEDEF_TYPES) _TypeCast2014b()->shapeType;
#endif
        }
        return _shapedeftype;
    }
 
    bool SaveNewWithType(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SHAPEDEF_TYPES
#else
    int
#endif
    shapedeftype
    )
    {
        if (_Is2014bFormat())
        {
            /* On Finale 2014b, the shape type is in the struct */
#if FXT_VERSION >= FINALEVERSION_2014B
            _TypeCast2014b()->shapeType = shapedeftype;
#endif
        }
        if (!SaveNew()) return false;
        if (!_Is2014bFormat())
        {
            if (!_SaveType((SHAPEDEF_TYPES) shapedeftype)) return false;
        }
        return true;
    }
    
    bool SaveWithType(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SHAPEDEF_TYPES
#else
    twobyte
#endif
    shapedeftype)
    {
        if (_Is2014bFormat())
        {
            /* In Finale 2014b, the shape type is in the struct */
#if FXT_VERSION >= FINALEVERSION_2014B
            _TypeCast2014b()->shapeType = shapedeftype;
#endif
        }
        if (!Save()) return false;  /* Aug 05, 2017: This was SaveNew(), seems very wrong? */
        if (!_Is2014bFormat())
        {
            if (!_SaveType((SHAPEDEF_TYPES) shapedeftype)) return false;
        }
        return true;
    }
 
 
    fourbyte GetDataCount() const 
    {
        if (_Is2014bFormat())
        {
#if FXT_VERSION >= FINALEVERSION_2014B
            return _isemptyshape ? 0 : _TypeCast2014b()->dataLen;
#endif
        }
        else
        {
            return _isemptyshape ? 0 : _TypeCast()->dataLen;
        }
        return 0;
    }
 
    fourbyte GetInstructionsCount() const
    {
        int returnval = 0;
        if (_Is2014bFormat())
        {
#if FXT_VERSION >= FINALEVERSION_2014B
            /* On 2014b+, _isemptyshape shouldn't be used. */
            returnval = _TypeCast2014b()->instrucLen;
#endif
        }
        else
        {
            returnval = _isemptyshape ? 0 : _TypeCast()->instrucLen;
            /* Have some range check, since empty shapes can have
             very strange values on earlier Finale versions. */
            if ((returnval > 300) || (returnval < 0)) return -1;
        }
        return returnval;
    }
 
    ETAG GetInstructionTag(int index)
    {
        if (index < 0) return 0;
        if (index >= GetInstructionsCount()) return 0;
        EDTPathInst* pPathArray = _GetPathInstructionArray();
        return pPathArray[index].tag;
    }
 
    int GetInstructionSize(int index)
    {
        if (index < 0) return -1;
        if (index >= GetInstructionsCount()) return -1;
        EDTPathInst* pPathArray = _GetPathInstructionArray();
        return pPathArray[index].numdata;
    }
 
    FCShapeDefInstructions* CreateInstructions();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCShapeDefInstructions> CreateInstructions_GC()
    { return makeLuaSharedPtr(CreateInstructions()); }
#endif
 
    FCStrings* CreateTextStrings();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCStrings> CreateTextStrings_GC()
    { return makeLuaSharedPtr(CreateTextStrings()); }
#endif
    
    
    bool RebuildInstructions(FCShapeDefInstructions* pCollection);
 
    bool GetFontInfo(int index, FCFontInfo* pFontInfo);
 
    bool SetFontInfo(int index, FCFontInfo* pFontInfo);
    
    bool ExportAsSVGFile(FCString* pFileName, float scaling, const char* pszUnit);
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Data size: ", (int) _loadedsize);
        DebugOutInt("Instruction count: ", GetInstructionsCount());
        DebugOutInt("Data count: ", GetDataCount());
        DebugOutInt("sizeof EDTShape: ", sizeof(EDTShape));
        DebugOutInt("sizeof EDTPathInst: ", sizeof(EDTPathInst));
        DebugOutInt("sizeof EDTPathData2002: ", sizeof(EDTPathData2002));
        
 
        //FCShapeDefInstructions* pInstructions = CreateInstructions();
        //pInstructions->DebugDump();
        //delete pInstructions;
        
/*        DebugOutInt("Instruction count: ", GetInstructionsCount());
        for (int i = 0; i < GetInstructionsCount(); i++)
        {
            DebugOutInt("Instruction: ", i);
            if (GetInstructionTag(i) == 0)
            {
                DebugOut("Tag: st_null");
            }
            else
            {
                FCString firstchar, secondchar;
                firstchar.Append((GetInstructionTag(i) & 0xff00) / 0x100);
                secondchar.Append((GetInstructionTag(i) & 0x00ff));
                FCString resultstring;
                resultstring.Append(&firstchar);
                resultstring.Append(", ");
                resultstring.Append(&secondchar);
                DebugOutString("Tag: ", &resultstring);
            }
        }  */
    }
 
    void InstructionDebugDump(int instructionindex);
    
#endif /* PDK_FRAMEWORK_DEBUG */
};
#endif /* PDK_FRAMEWORK_SHAPES */
 
 
 
class FCEnclosure : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTEnclosure    _enclosuredataold;  /* For loaded enclosures - DO
                                      * NOT REFERENCE this directly in the code!!!! */
    
    FIN25_4_CODE(EDTEnclosure25_4  _enclosuredata25_4;)  /* For loaded enclosures - DO
                                         * NOT REFERENCE this directly in the code!!!!
                                         * Note that this data use a different EXTAG
                                         * than the old data */
    
    EDTEnclosure*   _pEnclosureOld;     /* Assigned pointer, pre 25.4 */
    FIN25_4_CODE(EDTEnclosure25_4* _pEnclosure25_4;)  /* Assigned pointer, Finale 25.4 */
    
    
    /* Returns true if the 25.4 version of the struct should be used. */
    bool Use25_4Version() const;
    
    /* Returns a pointer to the flag member of the struct */
    const FLAG_16* _GetFlagPtr() const
    {
        FIN25_4_CODE( if (Use25_4Version()) return &_pEnclosure25_4->flag; )
        return &_pEnclosureOld->flag;
    }
    
    /* Returns a pointer to the lineWidth member of the struct */
    const EVPUFixedShort* _GetLineWidthPtr() const
    {
        FIN25_4_CODE( if (Use25_4Version()) return &_pEnclosure25_4->lineWidth; )
        return &_pEnclosureOld->lineWidth;
    }
    
    /* Returns a pointer to the xAdd member of the struct */
    const Evpu16* _GetXAddPtr() const
    {
        FIN25_4_CODE( if (Use25_4Version()) return &_pEnclosure25_4->xAdd; )
        return &_pEnclosureOld->xAdd;
    }
    
    /* Returns a pointer to the yAdd member of the struct */
    const Evpu16* _GetYAddPtr() const
    {
        FIN25_4_CODE( if (Use25_4Version()) return &_pEnclosure25_4->yAdd; )
        return &_pEnclosureOld->yAdd;
    }
    
    /* Returns a pointer to the xMargin member of the struct */
    const Evpu16* _GetXMarginPtr() const
    {
        FIN25_4_CODE( if (Use25_4Version()) return &_pEnclosure25_4->xMargin; )
        return &_pEnclosureOld->xMargin;
    }
    
    /* Returns a pointer to the yMargin member of the struct */
    const Evpu16* _GetYMarginPtr() const
    {
        FIN25_4_CODE( if (Use25_4Version()) return &_pEnclosure25_4->yMargin; )
        return &_pEnclosureOld->yMargin;
    }
 
protected:
    EXTAG Tag() const override
    {
        if (GetCustomTag()) return GetCustomTag();
        FIN25_4_CODE( if (Use25_4Version()) return ot_TextExpEnclosure25_4; )
        return ot_TextExpEnclosure;
    }
    int DataSizeLoad() const override
    {
        FIN25_4_CODE( if (Use25_4Version()) return sizeof(EDTEnclosure25_4); )
        return sizeof(EDTEnclosure);
    }
    
    /* Returns a pointer either to the 25.4 or the old enclosure struct */
    void* Allocate() override
    {
        FIN25_4_CODE( if (Use25_4Version()) return (void*) _pEnclosure25_4; )
        return (void*) _pEnclosureOld;
    }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        void* pData = _GetEnclosure();
        int size = DataSizeLoad();
        memcpy(pData, ((FCEnclosure*)pSource)->_GetEnclosure(), size);
        _datablock = pData;
        _loadedsize = size;
    }
 
    __FCBaseData* CreateObject() override { return new FCEnclosure(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCEnclosure"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_ENCLOSURE; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetEnclosure() const {
        FIN25_4_CODE( if (Use25_4Version()) return (void*) _pEnclosure25_4; )
        return (void*) _pEnclosureOld;
    }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    enum ENCLOSURESHAPE
    {
        ENCLOSURE_NONE = 0,
 
        ENCLOSURE_RECTANGLE = 1,
 
        ENCLOSURE_ELLIPSE = 2,
 
        ENCLOSURE_TRIANGLE = 3,
 
        ENCLOSURE_DIAMOND = 4,
 
        ENCLOSURE_PENTAGON = 5,
 
        ENCLOSURE_HEXAGON = 6,
 
        ENCLOSURE_SEPTAGON = 7,
 
        ENCLOSURE_OCTAGON = 8
    };
 
    enum ENCLOSUREMODES
    {
        ENCLOSUREMODE_NONE = 0,
 
        ENCLOSUREMODE_MINWIDTH,
 
        ENCLOSUREMODE_MATCHDIMENSIONS
    };
 
    FCEnclosure() : __FCNoInciOther()
    {
        // Defaults to pointing to self-contained storage. (See comment above.)
        //
        if (Use25_4Version())
        {
            FIN25_4_CODE( _pEnclosure25_4 = &_enclosuredata25_4; )
        }
        else
        {
            _pEnclosureOld = &_enclosuredataold;
        }
        void* pData = _GetEnclosure();
        memset(pData, 0, DataSizeLoad());
        _datablock = pData;
    }
    
    void _AssignEDTEnclosure(void* pPointer)
    {
        if (Use25_4Version())
        {
            FIN25_4_CODE( _pEnclosure25_4 = (EDTEnclosure25_4*) pPointer; )
        }
        else
        {
            _pEnclosureOld = (EDTEnclosure*) pPointer;
        }
    }
 
    void SetShape(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ENCLOSURESHAPE
#else
    int
#endif
    shape)
    {
        if (!_GetEnclosure()) return;
        if (shape < 0) return;
        if (shape > 15) return;
        *(FLAG_16*)_GetFlagPtr() &= ~NEWSIDES;
        *(FLAG_16*)_GetFlagPtr() |= shape;
    }
 
 
    void SetLineWidth(int width)
    {
        if (!_GetEnclosure()) return;
        *(Evpu16*)_GetLineWidthPtr() = width;
    }
 
    void SetHorizontalOffset(int offset)
    {
        if (!_GetEnclosure()) return;
        *(Evpu16*)_GetXAddPtr() = offset;
    }
 
    void SetVerticalOffset(int offset)
    {
        if (!_GetEnclosure()) return;
        *(Evpu16*)_GetYAddPtr() = offset;
    }
 
    void SetHorizontalMargin(int margin)
    {
        if (!_GetEnclosure()) return;
        *(Evpu16*)_GetXMarginPtr() = margin;
    }
 
    void SetVerticalMargin(int margin)
    {
        if (!_GetEnclosure()) return;
        *(Evpu16*)_GetYMarginPtr() = margin;
    }
 
    void SetFixedSize(bool state)
    {
        if (!_GetEnclosure()) return;
        Set16BitFlag((FLAG_16*)_GetFlagPtr(), FIXED_SIZE, state);
    }
 
    void SetOpaque(bool state)
    {
        if (!_GetEnclosure()) return;
        Set16BitFlag((FLAG_16*)_GetFlagPtr(), ENCL_OPAQUE, state);
    }
    
    void SetRoundedCorners(bool state)
    {
        FIN25_4_CODE( if (Use25_4Version()) Set16BitFlag((FLAG_16*)_GetFlagPtr(), 0x0400  /* ROUND_CORNERS */, state); )
    }
    
    void SetRoundedCornerRadius(Efix32 radius)
    {
        FIN25_4_CODE( if (Use25_4Version()) _pEnclosure25_4->m_cornerRadius = radius; )
    }
 
    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ENCLOSUREMODES
#else
    int
#endif
    enclosuremode)
    {
        switch (enclosuremode)
        {
            case ENCLOSUREMODE_NONE:
                Set16BitFlag((FLAG_16*)_GetFlagPtr(), NOT_TALL, false);
                Set16BitFlag((FLAG_16*)_GetFlagPtr(), EQUAL_ASPECT, false);
                break;
            case ENCLOSUREMODE_MINWIDTH:
                Set16BitFlag((FLAG_16*)_GetFlagPtr(), NOT_TALL, true);
                Set16BitFlag((FLAG_16*)_GetFlagPtr(), EQUAL_ASPECT, false);
                break;
            case ENCLOSUREMODE_MATCHDIMENSIONS:
                Set16BitFlag((FLAG_16*)_GetFlagPtr(), NOT_TALL, false);
                Set16BitFlag((FLAG_16*)_GetFlagPtr(), EQUAL_ASPECT, true);
                break;
        }
    }
 
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ENCLOSURESHAPE 
#else
    int
#endif
    GetShape() const
    {
        if (!_GetEnclosure()) return ENCLOSURE_NONE;
        return (ENCLOSURESHAPE ) (*_GetFlagPtr() & NEWSIDES);
    }
 
    int GetLineWidth() const
    {
        if (!_GetEnclosure()) return 0;
        return *_GetLineWidthPtr();
    }
 
    int GetHorizontalOffset() const
    {
        if (!_GetEnclosure()) return 0;
        return *_GetXAddPtr();
    }
 
    int GetVerticalOffset() const
    {
        if (!_GetEnclosure()) return 0;
        return *_GetYAddPtr();
    }
 
    int GetHorizontalMargin() const
    {
        if (!_GetEnclosure()) return 0;
        return *_GetXMarginPtr();
    }
 
    int GetVerticalMargin() const
    {
        if (!_GetEnclosure()) return 0;
        return *_GetYMarginPtr();
    }
 
    bool GetFixedSize() const
    {
        if (!_GetEnclosure()) return false;
        return GetBitFlag(*_GetFlagPtr(), FIXED_SIZE);
    }
 
    bool GetOpaque() const
    {
        if (!_GetEnclosure()) return false;
        return GetBitFlag(*_GetFlagPtr(), ENCL_OPAQUE);
    }
    
    bool GetRoundedCorners() const
    {
        FIN25_4_CODE( if (Use25_4Version()) return GetBitFlag(*_GetFlagPtr(), 0x0400  /* ROUND_CORNERS */); )
        return false;
    }
    
    Efix32 GetRoundedCornerRadius() const
    {
        FIN25_4_CODE( if (Use25_4Version()) return _pEnclosure25_4->m_cornerRadius; )
        return 0;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ENCLOSUREMODES
#else
    int
#endif
    GetMode() const
    {
        if (!_GetEnclosure()) return ENCLOSUREMODE_NONE;
        if (GetBitFlag(*_GetFlagPtr(), NOT_TALL)) return ENCLOSUREMODE_MINWIDTH;
        if (GetBitFlag(*_GetFlagPtr(), EQUAL_ASPECT)) return ENCLOSUREMODE_MATCHDIMENSIONS;
        return ENCLOSUREMODE_NONE;
    }
 
    bool SaveAs(CMPER itemno) override
    {
        if (! DataIsLoaded())
            _loadedsize = DataSizeLoad();
        return __FCNoInciOther::SaveAs(itemno);
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
    }
#endif
 
};
 
 
#ifdef PDK_FRAMEWORK_LAYOUT
 
class FCPage : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTPageSpec pagespec;
protected:
    EXTAG Tag() const override { return ot_EDTPageSpec; }
    int DataSizeLoad() const override { return sizeof(EDTPageSpec); }
    void* Allocate() override { return (void*) &pagespec; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&pagespec, ((FCPage*)pSource)->_GetPageSpec(), sizeof(pagespec));
        _datablock = &pagespec;
        _loadedsize = sizeof(pagespec);
    }
 
    __FCBaseData* CreateObject() override { return new FCPage(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCPage"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PAGE; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetPageSpec() { return &pagespec; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCPage() : __FCNoInciOther() {}
 
    eSsys GetFirstSystem();
 
    void SetFirstSystem(eSsys firstsysno);
    
    void UpdateLayout(bool bUnfreezeMeasures = false);
 
    bool IsPortrait() const
    {
        return (GetHeight() > GetWidth());
    }
    
    bool IsBlank() const
    {
        return pagespec.stavestr == -1;
    }
 
    Evpu32 GetWidth() const { return pagespec.width; }
 
    Evpu32 GetHeight() const { return pagespec.height; }
 
    Evpu16 GetLeftMargin() const { return pagespec.margLeft; }
 
    Evpu16 GetRightMargin() const { return -pagespec.margRight; }
 
    Evpu16 GetTopMargin() const { return -pagespec.margTop; }
 
    Evpu16 GetBottomMargin() const { return pagespec.margBottom; }
 
    twobyte GetPercent() const { return pagespec.percent; }
 
    bool GetHoldMargins() const { return GetBitFlag(pagespec.pageflag, PAGESPEC_MARGSCOPING); }
 
        /***********/
        /* SETTERS */
        /***********/
 
    void SetWidth(Evpu32 width) { pagespec.width = width; }
 
    void SetHeight(Evpu32 height) { pagespec.height = height; }
 
    void SetLeftMargin(Evpu16 margin) { pagespec.margLeft = margin; }
 
    void SetRightMargin(Evpu16 margin) { pagespec.margRight = -margin; }
 
    void SetTopMargin(Evpu16 margin) { pagespec.margTop = -margin; }
 
    void SetBottomMargin(Evpu16 margin) { pagespec.margBottom = margin; }
 
    void SetPercent(twobyte percent) { pagespec.percent = percent; }
 
    void SetHoldMargins(bool state) { Set16BitFlag(&pagespec.pageflag, PAGESPEC_MARGSCOPING, state); }
 
    eSsys CalcLastSystem();
 
    eMeas CalcFirstMeasure();
 
    eMeas CalcLastMeasure();
 
    int CalcInteriorHeight(bool resize);
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("First system: ", GetFirstSystem());
        DebugOutInt("Last system: ", CalcLastSystem());
    }
#endif
};
#endif // PDK_FRAMEWORK_LAYOUT
 
 
#ifdef PDK_FRAMEWORK_LAYOUT
 
#ifdef PDK_FRAMEWORK_DEBUG
#include <stddef.h> /* Needed for the FCStaffSystem constructor in debug mode. */
#endif
 
class FCSystemStaves;
class FCFreezeSystem;
class FCMusicRegion;
class FCStaffSystem : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTStaffSystemSpec2005 _staffsystem;
protected:
    EXTAG Tag() const override { return ot_EDTStaffSystemSpec; }
    int DataSizeLoad() const override { return sizeof(EDTStaffSystemSpec2005); }
    void* Allocate() override { return (void*) &_staffsystem; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_staffsystem, ((FCStaffSystem*)pSource)->_GetStaffSystemSpec(), sizeof(_staffsystem));
        _datablock = &_staffsystem;
        _loadedsize = sizeof(_staffsystem);
    }
 
 
    __FCBaseData* CreateObject() override { return new FCStaffSystem(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCStaffSystem"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STAFFSYSTEM; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetStaffSystemSpec() { return &_staffsystem; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCStaffSystem() : __FCNoInciOther() 
    {
#ifdef PDK_FRAMEWORK_DEBUG
        /* This should normally be used with PDK_FRAMEWORK_DIAGNOSE, but since
         * it's so important that this is correct, place it on the
         * PDK_FRAMEWORK_DEBUG level!
         *  */
        if ((offsetof(EDTStaffSystemSpec2005, horzPercent) - offsetof(EDTStaffSystemSpec2005, mend)) != 2)
        {
            DebugOut("ERROR: Packed struct alignment isn't set up correctly in the compiler options! Use "
                    "-fpack-struct=1 for GCC.");
        }
#endif
    }
    
 
    void SetFirstMeasure(eMeas measure)
        { ((EDTStaffSystemSpec2005*) _datablock)->mestart = measure; }
 
    void SetNextSysMeasure(eMeas measure)
        { ((EDTStaffSystemSpec2005*) _datablock)->mend = measure; }
 
 
    void SetSpaceBeforeMusic(twobyte space)
        { ((EDTStaffSystemSpec2005*) _datablock)->extraStartSystemSpace = space; }
 
    void SetSpaceAfterMusic(twobyte space)
        { ((EDTStaffSystemSpec2005*) _datablock)->extraEndSystemSpace = space; }
 
    void SetSpaceAbove(twobyte space)
        { ((EDTStaffSystemSpec2005*) _datablock)->betweensystems = -space; }
    
    void SetTopMargin(Evpu16 margin)
        { ((EDTStaffSystemSpec2005*) _datablock)->top = -margin; }
 
    void SetBottomMargin(Evpu16 margin)
        { ((EDTStaffSystemSpec2005*) _datablock)->bottom = -margin; }
 
    void SetLeftMargin(Evpu16 margin)
        { ((EDTStaffSystemSpec2005*) _datablock)->left = margin; }
 
    void SetRightMargin(Evpu16 margin)
        { ((EDTStaffSystemSpec2005*) _datablock)->right = margin; }
 
    void SetResize(twobyte value)
    {
        _staffsystem.ssysPercent = value;
    }
 
    void SetStaffHeight(twobyte value)
        { _staffsystem.staffHeight = value; }
 
    void SetResizeVerticalSpace(bool value)
    {
        Set16BitFlag(&_staffsystem.staveflag, SSPEC_RESIZE_VERT, value);
    }
 
    void SetUseStaffResize(bool state)
    {
        Set16BitFlag(&_staffsystem.staveflag, SSPEC_LINEPERC, state);
    }
 
    void SetHoldMargins(bool state)
    {
        Set16BitFlag(&_staffsystem.staveflag, SSPEC_HOLD_MARGINS, state);
    }
 
    eMeas GetFirstMeasure() const
        { return ((EDTStaffSystemSpec2005*) _datablock)->mestart; }
 
    eMeas GetNextSysMeasure() const
        { return ((EDTStaffSystemSpec2005*) _datablock)->mend; }
 
    twobyte GetSpaceBeforeMusic() const
        { return ((EDTStaffSystemSpec2005*) _datablock)->extraStartSystemSpace; }
 
    twobyte GetSpaceAfterMusic() const
        { return ((EDTStaffSystemSpec2005*) _datablock)->extraEndSystemSpace; }
 
    twobyte GetSpaceAbove() const
        { return -((EDTStaffSystemSpec2005*) _datablock)->betweensystems; }
 
    Evpu16 GetTopMargin() const
        { return -((EDTStaffSystemSpec2005*) _datablock)->top; }
 
    Evpu16 GetBottomMargin() const
        { return -((EDTStaffSystemSpec2005*) _datablock)->bottom; }
 
    Evpu16 GetLeftMargin() const
        { return ((EDTStaffSystemSpec2005*) _datablock)->left; }
 
    Evpu16 GetRightMargin() const
        { return ((EDTStaffSystemSpec2005*) _datablock)->right; }
 
    twobyte GetStaffHeight() const
        { return ((EDTStaffSystemSpec2005*) _datablock)->staffHeight; }
 
    twobyte GetResize() const
        { return ((EDTStaffSystemSpec2005*) _datablock)->ssysPercent; }
 
    bool GetResizeVerticalSpace() const
        { return GetBitFlag(((EDTStaffSystemSpec2005*) _datablock)->staveflag, SSPEC_RESIZE_VERT); }
 
    bool GetUseStaffResize() const
    {
        return GetBitFlag(_staffsystem.staveflag, SSPEC_LINEPERC);
    }
 
    bool GetHoldMargins() const
    {
        return GetBitFlag(_staffsystem.staveflag, SSPEC_HOLD_MARGINS);
    }
 
    twobyte GetTopStaff() const;
 
    Int100 GetHorizontalStretch() const
    {
        return _staffsystem.horzPercent;
    }
 
    bool HasPageBreak();
 
    eStaff CalcTopStaff();
 
    eStaff CalcBottomStaff();
 
    int CalcStavesSpan();
 
    int CalcHeight(bool verticalresize);
    
    int CalcWhiteSpaceBottom(bool verticalresize);
 
    bool IsOptimized() const;
 
    bool ContainsMeasure(eMeas measurenumber)
    {
        if (measurenumber < GetFirstMeasure()) return false;
        if (measurenumber >= GetNextSysMeasure()) return false;
        return true;
    }
 
    FCSystemStaves* CreateSystemStaves();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCSystemStaves> CreateSystemStaves_GC()
    { return makeLuaSharedPtr(CreateSystemStaves()); }
#endif
 
    FCFreezeSystem* CreateFreezeSystem(bool force_create = true);
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFreezeSystem> CreateFreezeSystem_GC(bool force_create)
    { return makeLuaSharedPtr(CreateFreezeSystem(force_create)); }
#endif
 
    bool CalcRegion(FCMusicRegion* pRegion);
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("First measure: ", GetFirstMeasure());
        DebugOutInt("Next System Measure: ", GetNextSysMeasure());
        DebugOutInt("Space Above: ", GetSpaceAbove());
        DebugOutInt("Top Margin: ", GetTopMargin());
        DebugOutInt("Bottom Margin: ", GetBottomMargin());
        DebugOutInt("Staff Height: ", GetStaffHeight());
        DebugOutInt("Resize (percent): ", GetResize());
    }
#endif
};
#endif // PDK_FRAMEWORK_LAYOUT
 
 
class FCBeatChartElements;
class FCExpressions;
class FCTempoElements;
 
class FCTimeSignature;
 
class FCMeasure : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    mutable FCKeySignature* _pKeySig;
 
    mutable FCTimeSignature* _pTimeSig;
 
    mutable FCTimeSignature* _pTimeSigDisplay;
 
    EVERSION _VersionToUse() const;
 
    EDTMeasureSpec2005 _measurespec2005;
 
#if FXT_VERSION >= FINALEVERSION_2014
    EDTMeasureSpec2014 _measurespec2014;
#endif
 
    FLAG_16* _GetMeFlagPtr() const;
 
    FLAG_16* _GetNewFlagPtr() const;
 
    FLAG_16* _GetAuxFlagPtr() const;
 
    void _SetMeFlag(FLAG_16 mask, bool state);
 
    bool _GetMeFlag(FLAG_16 mask) const
    {
        return GetBitFlag(*_GetMeFlagPtr(), mask);
    }
 
    void _SetNewFlag(FLAG_16 mask, bool state);
 
    bool _GetNewFlag(FLAG_16 mask) const { return GetBitFlag(*_GetNewFlagPtr(), mask); }
 
    void _SetAuxFlag(FLAG_16 mask, bool state);
 
    bool _GetAuxFlag(FLAG_16 mask) const { return GetBitFlag(*_GetAuxFlagPtr(), mask); }
 
    FCString* _CreateNumberString(bool qualified, bool showAllRepeatPasses)
    {
        FCString* retval = new FCString;
        eUniChar16 buffer[512];
        if (! FX_GetMeasureNumberString(GetItemNo(), buffer, DIM(buffer), qualified, showAllRepeatPasses))
            if (qualified)
                retval->FormatCString("#%d", GetItemNo());
            else
                retval->FormatCString("%d", GetItemNo());
        else
            retval->SetUnicodeString(buffer);
        return retval;
    }
 
protected:
    EVERSION EnigmaVersion() const override 
    { 
        return _VersionToUse();
    }
    EXTAG Tag() const override { return ot_MeasureSpec; }
    int DataSizeLoad() const override {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014) return sizeof(EDTMeasureSpec2014);
#endif
        return sizeof(EDTMeasureSpec2005);
    }
    
    void* Allocate() override 
    {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014) return (void*) &_measurespec2014;
#endif
        return (void*) &_measurespec2005;
    }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {            
            memcpy(&_measurespec2014, ((FCMeasure*)pSource)->_GetMeasureSpec(), sizeof(_measurespec2014));
            _datablock = &_measurespec2014;
            _loadedsize = sizeof(_measurespec2014);            
            return;
        }
#endif
        memcpy(&_measurespec2005, ((FCMeasure*)pSource)->_GetMeasureSpec(), sizeof(_measurespec2005));
        _datablock = &_measurespec2005;
        _loadedsize = sizeof(_measurespec2005);
    }
 
    __FCBaseData* CreateObject() override { return new FCMeasure(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    enum BARLINE_STYLES {
 
        BARLINE_NONE = 0,
 
        BARLINE_NORMAL,
 
        BARLINE_DOUBLE,
 
        BARLINE_DASHED,
 
        BARLINE_THICK,
 
        BARLINE_FINAL,
 
        BARLINE_TICK,
 
        BARLINE_SHAPE,
 
        BARLINE_DEFAULT
    };
 
private:
    bool _GetBarlineMask(
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
int
#else
FCMeasure::BARLINE_STYLES
#endif
    style, FLAG_16* pFlag);
 
public:
 
    enum POSITIONING_MODES {
 
        POSITIONING_TIMESIG = 0,
 
        POSITIONING_MANUALLY,
 
        POSITIONING_BEATCHART
    };
 
    enum SHOW_STATES {
 
        SHOWSTATE_IFNEEDED = 0,
 
        SHOWSTATE_SHOW,
 
        SHOWSTATE_HIDE
    };
 
    const char* ClassName() const override { return "FCMeasure"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MEASURE; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetMeasureSpec()
    {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014) return &_measurespec2014;
#endif        
        return &_measurespec2005;
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCMeasure() : __FCNoInciOther()
    {
        _pKeySig = NULL;
        _pTimeSig = NULL;
        _pTimeSigDisplay = NULL;
    }
 
    virtual ~FCMeasure() {
        if (_pKeySig) delete _pKeySig;
        if (_pTimeSig) delete _pTimeSig;
        if (_pTimeSigDisplay) delete _pTimeSigDisplay;
    }
 
    bool Save() override;
 
    bool Load(CMPER itemno) override;
 
    FCBeatChartElements* CreateBeatChartElements();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    /* GC version of #CreateBeatChartElements for Lua. */
    luabridge::RefCountedPtr<FCBeatChartElements> CreateBeatChartElements_GC()
    { return makeLuaSharedPtr(CreateBeatChartElements()); }
#endif
 
    FCExpressions* CreateExpressions();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    /* GC version of #CreateExpressions for Lua. */
    luabridge::RefCountedPtr<FCExpressions> CreateExpressions_GC()
    { return makeLuaSharedPtr(CreateExpressions()); }
#endif
 
    FCTempoElements* CreateTempoElements();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    /* GC version of #CreateTempoElements for Lua. */
    luabridge::RefCountedPtr<FCTempoElements> CreateTempoElements_GC()
    { return makeLuaSharedPtr(CreateTempoElements()); }
#endif
 
 
    void SetKeyless(bool state)
    {
        if (_VersionToUse() != FINALEVERSION_2014) return;
#if FXT_VERSION >= FINALEVERSION_2014
        _measurespec2014.isKeyless = state;
#endif        
    }
 
    void SetHideKeySigShowAccis(bool state)
    {
        if (_VersionToUse() != FINALEVERSION_2014) return;
#if FXT_VERSION >= FINALEVERSION_2014
        _measurespec2014.hideKeySigShowAccis = state;
#endif
    }
    
 
    void SetPageBreak(bool state)
        { _SetNewFlag(MEAS_PAGEBREAK, state); }
 
    void SetBreakMMRest(bool state)
        { _SetMeFlag(MEAS_BREAKREST, state); }
 
    void SetForwardRepeat(bool state)    
        { _SetMeFlag(MEAS_FORREPBAR, state); }
    
    void SetExpressionFlag(bool state)
        { _SetMeFlag(MEAS_DYNAMBIT, state); }
 
    void SetTextFlag(bool state)
        { _SetMeFlag(MEAS_MEASURETEXT, state); }
 
    void SetBackwardRepeat(bool state)    
        { _SetMeFlag(MEAS_BACREPBAR, state); }
 
    void SetRepeatBracketFlag(bool state) {  _SetMeFlag(MEAS_BARENDING, state); }
 
    void SetTextRepeatFlag(bool state) { _SetMeFlag(MEAS_REPEATS, state); }
 
    void SetSystemBreak(bool state) { _SetMeFlag(MEAS_MS_LINEBREAK, state); }
 
    void SetHideCautionary(bool state) { _SetAuxFlag(MEAS_HIDECAUTION, state); }
 
    void SetWidth(Evpu16 width) {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            _measurespec2014.measpace = width;
            return;
        }
#endif
        _measurespec2005.measpace = width;
    }
 
    void SetSpaceBefore(Evpu16 space)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            _measurespec2014.frontSpaceExtra = space;
            return;
        }
#endif
        _measurespec2005.frontSpaceExtra = space;
    }
 
    void SetSpaceAfter(Evpu16 space) 
    {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            _measurespec2014.backSpaceExtra = space;
            return;
        }
#endif
        _measurespec2005.backSpaceExtra = space;
    }
 
    void SetAllowHorizontalSplit(bool state) { _SetAuxFlag(MEAS_POSSPLIT, state); }
 
    void SetShowKeySignature(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SHOW_STATES state
#else
    int state
#endif
    );
 
    void SetShowTimeSignature(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SHOW_STATES state
#else
    int state
#endif
    );
 
    void SetShowFullNames(bool state);
    
    void SetContainsManualMeasureNumbers(bool state) { _SetAuxFlag(MEAS_MNSEPPLACE, state); }
 
    void SetBreakWordExtension(bool state) { _SetAuxFlag(0x8000, state); }
 
    void SetIncludeInNumbering(bool state) { _SetMeFlag(MEAS_NO_MEAS_NUM, !state); }
 
    void SetOverrideGroupBarlines(bool state) { _SetAuxFlag(MEAS_GRP_BARLINE_OVERRIDE, state); }
 
    void SetPositioningNotesMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
POSITIONING_MODES mode
#else
int mode
#endif
    );
 
    void SetPositionEvenly(bool state) { _SetAuxFlag(MEAS_INDIVPOSDEF, state); }
 
    void SetBarline(
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
int
#else
FCMeasure::BARLINE_STYLES
#endif
    style);
 
    void SetBarlineShapeID(twobyte shapeID) { 
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            _measurespec2014.custombarshape = shapeID; 
            return;
        }
#endif        
        _measurespec2005.custombarshape = shapeID;
    }
 
    void SetLeftBarlineShapeID(twobyte shapeID) 
    {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            _measurespec2014.customleftbarshape = shapeID;
            return;
        }
#endif
        _measurespec2005.customleftbarshape = shapeID;
    }
 
    void SetLeftBarline(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BARLINE_STYLES style
#else
    int style
#endif
    );
 
    void SetSmartShapeFlag(bool state) { _SetAuxFlag(MEAS_SMARTSHAPEBIT, state); }
 
    void SetChordFlag(bool state) { _SetNewFlag(0x0008, state); }
 
    TimeEdu32 GetDuration()
    {
        return FX_GetMeasureDuration(0, GetItemNo());
    }
 
 
    bool GetKeyless() const
    {
        if (_VersionToUse() != FINALEVERSION_2014) return false;
#if FXT_VERSION >= FINALEVERSION_2014        
        return _measurespec2014.isKeyless != 0;
#endif
        return false;
    }
 
    bool GetHideKeySigShowAccis() const
    {
        if (_VersionToUse() != FINALEVERSION_2014) return false;
#if FXT_VERSION >= FINALEVERSION_2014
        return _measurespec2014.hideKeySigShowAccis != 0;
#endif
        return false;
    }
 
 
    bool GetPageBreak() const { return _GetNewFlag(MEAS_PAGEBREAK); }
 
    bool GetBreakMMRest() const { return _GetMeFlag(MEAS_BREAKREST); }
 
    bool GetSystemBreak() const { return _GetMeFlag(MEAS_MS_LINEBREAK); }
 
    bool GetForwardRepeat() const { return _GetMeFlag(MEAS_FORREPBAR); }
 
    bool GetExpressionFlag() const { return _GetMeFlag(MEAS_DYNAMBIT); }
 
    bool GetTextFlag() const { return _GetMeFlag(MEAS_MEASURETEXT); }
 
    bool GetBackwardRepeat() const { return _GetMeFlag(MEAS_BACREPBAR); }
 
    bool GetRepeatBracketFlag() const { return _GetMeFlag(MEAS_BARENDING); }
 
    bool GetTextRepeatFlag() const { return _GetMeFlag(MEAS_REPEATS); }
 
    bool GetHideCautionary() const { return _GetAuxFlag(MEAS_HIDECAUTION); }
 
    Evpu16 GetWidth() const {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            return _measurespec2014.measpace;            
        }
#endif
        return _measurespec2005.measpace;
    }
 
    Evpu16 GetSpaceBefore() const {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            return _measurespec2014.frontSpaceExtra;
        }
#endif
        return _measurespec2005.frontSpaceExtra;
    }
 
    Evpu16 GetSpaceAfter() const {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            return _measurespec2014.backSpaceExtra;
        }
#endif
        return _measurespec2005.backSpaceExtra;
    }
 
    bool GetAllowHorizontalSplit() const { return _GetAuxFlag(MEAS_POSSPLIT); }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SHOW_STATES
#else
    int
#endif
    GetShowKeySignature() const;
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SHOW_STATES
#else
    int
#endif
    GetShowTimeSignature() const;
 
    bool GetUseTimeSigForDisplay() const { return _GetNewFlag(MEAS_USE_DISPLAY_TIMESIG); }
 
    bool GetShowFullNames() const;
 
    bool GetContainsManualMeasureNumbers() const { return _GetAuxFlag(MEAS_MNSEPPLACE); }
 
    bool GetBreakWordExtension() const { return _GetAuxFlag(0x8000); }
 
    bool GetIncludeInNumbering() const { return !_GetMeFlag(MEAS_NO_MEAS_NUM); }
 
    bool GetOverrideGroupBarlines() const { return _GetAuxFlag(MEAS_GRP_BARLINE_OVERRIDE); }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    POSITIONING_MODES
#else
    int
#endif
    GetPositioningNotesMode() const;
 
    bool GetPositionEvenly() const { return _GetAuxFlag(MEAS_INDIVPOSDEF); }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
     int
#else
     FCMeasure::BARLINE_STYLES
#endif
     GetBarline() const;
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BARLINE_STYLES 
#else
    int
#endif
    GetLeftBarline() const;
 
    CMPER GetBarlineShapeID() const {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            return _measurespec2014.custombarshape;
        }
#endif
        return _measurespec2005.custombarshape;
    }
 
    CMPER GetLeftBarlineShapeID() const {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            return _measurespec2014.customleftbarshape;
        }
#endif
        return _measurespec2005.customleftbarshape;
    }
 
    FCKeySignature* GetKeySignature() const {
        if (!DataIsLoaded()) return NULL;
        if (_pKeySig) return _pKeySig;
        if (!_pKeySig) _pKeySig = new FCKeySignature();
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            _pKeySig->SetID(_measurespec2014.key);
        } else
#endif
        {
            _pKeySig->SetID(_measurespec2005.key);
        }
        return _pKeySig;
    }
 
    bool GetSmartShapeFlag() const { return _GetAuxFlag(MEAS_SMARTSHAPEBIT); }
 
    bool GetChordFlag() const { return _GetNewFlag(0x0008); }
 
    FCTimeSignature* GetTimeSignature() const
    {
        if (!DataIsLoaded()) return NULL;
        if (_pTimeSig) return _pTimeSig;
        if (!_pTimeSig) _pTimeSig = new FCTimeSignature();
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            _pTimeSig->SetBeats(_measurespec2014.beats);
            _pTimeSig->SetBeatDuration(_measurespec2014.divbeat);
        } else
#endif
        {
            _pTimeSig->SetBeats(_measurespec2005.beats);
            _pTimeSig->SetBeatDuration(_measurespec2005.divbeat);
        }
        _pTimeSig->SetCompositeTop(_GetAuxFlag(MEAS_ALTNUMTSIG));
        _pTimeSig->SetCompositeBottom(_GetAuxFlag(MEAS_ALTDENTSIG));
        _pTimeSig->SetAbbreviate(false);
        return _pTimeSig;
    }
 
    FCTimeSignature* GetTimeSignatureForDisplay() const
    {
        if (!DataIsLoaded()) return NULL;
        if (!GetUseTimeSigForDisplay()) return NULL;
        if (_pTimeSigDisplay) return _pTimeSigDisplay;
        if (!_pTimeSigDisplay) _pTimeSigDisplay = new FCTimeSignature();
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014)
        {
            _pTimeSigDisplay->SetBeats(_measurespec2014.dispBeats);
            _pTimeSigDisplay->SetBeatDuration(_measurespec2014.dispDivbeat);
        } else
#endif
        {
            _pTimeSigDisplay->SetBeats(_measurespec2005.dispBeats);
            _pTimeSigDisplay->SetBeatDuration(_measurespec2005.dispDivbeat);
        }
        _pTimeSigDisplay->SetCompositeTop(_GetNewFlag(MEAS_DISPLAY_ALTNUMTSIG));
        _pTimeSigDisplay->SetCompositeBottom(_GetNewFlag(MEAS_DISPLAY_ALTDENTSIG));
        _pTimeSigDisplay->SetAbbreviate(_GetNewFlag(MEAS_ABBRVTIME));
        return _pTimeSigDisplay;
    }
 
    void SetUseTimeSigForDisplay(bool value)
    {
        if (!DataIsLoaded()) return;
        if (GetUseTimeSigForDisplay() == value) return;
        if (!value)
        {
            if (_pTimeSigDisplay)
            {
                delete _pTimeSigDisplay;
                _pTimeSigDisplay = NULL;
            }
        }
        return _SetNewFlag(MEAS_USE_DISPLAY_TIMESIG, value);
    }
    
    FCString* CreateNumberString(bool showAllRepeatPasses = false)
    {
        return _CreateNumberString(true, showAllRepeatPasses);
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateNumberString_GC(bool showAllRepeatPasses = false)
    { return makeLuaSharedPtr(CreateNumberString(showAllRepeatPasses)); }
#endif
    
    FCString* CreateNumberStringUnqualified(bool showAllRepeatPasses = false)
    {
        return _CreateNumberString(false, showAllRepeatPasses);
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateNumberStringUnqualified_GC(bool showAllRepeatPasses = false)
    { return makeLuaSharedPtr(CreateNumberStringUnqualified(showAllRepeatPasses)); }
#endif
};
 
/* Forward declaration, required for measure references FCMeasureNumberRegion */
class FCMeasures;
 
class FCMeasureNumberRegion : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    /* Reference table for checking the "Include measure in measure numbering" states.
     Use AssignAllNonNumberedMeasures() to set */
    FCNumbers* _pNonIncludedMeasures;
    
    /* Used for the _SetTempAllMeasures() etc mechanism. This is where the real value of
     * _pAllMeasures is stored, during a temporary collection assignment. */
    FCNumbers* _pTempNonIncludedMeasuresStorage;
    
    FIN25_4_CODE(EDTMeasNumberRegion25_4 _measureregion25_4;)     
    FIN2012_CODE(EDTMeasNumberRegion2012 _measureregion2012;)     
    EDTMeasNumberRegion2010 _measureregion2010;     
    EDTMeasNumberRegion _measureregionold;          
    FCEnclosure _startEnclosureScore;  // Set up by the constructor
    FCEnclosure _startEnclosureParts; // Set up by the constructor
    FCEnclosure _multipleEnclosureScore;   // Set up by the constructor
    FCEnclosure _multipleEnclosureParts;   // Set up by the constructor
 
    
    /* Returns a pointer to the correct 'flags' member of the score/part struct */
    const FLAG_16* _GetScorePartFlagsPtr(bool parts);
    
    /* Returns a pointer to the correct 'flags2' member of the score/part struct */
    const FLAG_16* _GetScorePartFlags2Ptr(bool parts);
    
    /* Returns a pointer to the correct 'incidence' member of the score/part struct */
    const twobyte* _GetScorePartIncidencePtr(bool parts) const;
    
    /* Returns a pointer to the correct 'startxdisp' (or xdisp) member of the score/part struct */
    const twobyte* _GetScorePartStartxdispPtr(bool parts) const;
 
    /* Returns a pointer to the correct 'startxdisp' (or xdisp) member of the score/part struct */
    const twobyte* _GetScorePartStartydispPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'multiplexdisp' member of the score/part struct */
    const twobyte* _GetScorePartMultiplexdispPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'multipleydisp' member of the score/part struct */
    const twobyte* _GetScorePartMultipleydispPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'mmrestxdisp' member of the score/part struct */
    const twobyte* _GetScorePartMmrestxdispPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'mmrestydisp' member of the score/part struct */
    const twobyte* _GetScorePartMmrestydispPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'startWith' member of the score/part struct */
    const twobyte* _GetScorePartStartWithPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'leftMMBracketChar' member of the score/part struct
     eUniChar32 on Fin2012+
     EWCHAR on pre-Fin2012
     */
    const void* _GetScorePartLeftMMBracketCharPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'rightMMBracketChar' member of the score/part struct
     eUniChar32 on Fin2012+
     EWCHAR on pre-Fin2012
     */
    const void* _GetScorePartRightMMBracketCharPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'startFont' member of the score/part struct */
    const EFONTID* _GetScorePartStartFontPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'startEfx' member of the score/part struct */
    const FLAG_16* _GetScorePartStartEfxPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'startSize' member of the score/part struct */
    const twobyte* _GetScorePartStartSizePtr(bool parts) const;
    
    /* Returns a pointer to the correct 'multipleFont' member of the score/part struct */
    const EFONTID* _GetScorePartMultipleFontPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'multipleEfx' member of the score/part struct */
    const FLAG_16* _GetScorePartMultipleEfxPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'multipleSize' member of the score/part struct */
    const twobyte* _GetScorePartMultipleSizePtr(bool parts) const;
    
    /* Returns a pointer to the correct 'mmRestFont' member of the score/part struct */
    const EFONTID* _GetScorePartMmRestFontPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'mmRestEfx' member of the score/part struct */
    const FLAG_16* _GetScorePartMmRestEfxPtr(bool parts) const;
    
    /* Returns a pointer to the correct 'mmRestSize' member of the score/part struct */
    const twobyte* _GetScorePartMmRestSizePtr(bool parts) const;
    
    /* Returns a pointer to the correct 'startMeas' member */
    const twobyte* _GetStartMeasPtr() const;
    
    /* Returns a pointer to the correct 'endMeas' member */
    const twobyte* _GetEndMeasPtr() const;
    
    /* Returns a pointer to the correct 'offset' member */
    const twobyte* _GetOffsetPtr() const;
    
    /* Returns a pointer to the correct 'prefix' member. Finale 2012+ uses eUniChar16 buffer,
     earlier versions use ECHAR buffer. */
    const void* _GetPrefixPtr() const;
    
    /* Returns a pointer to the correct 'suffix' member */
    const void* _GetSuffixPtr() const;
    
    /* Returns a pointer to the correct 'flag' member */
    const FLAG_16* _GetFlagPtr() const;
    
    /* Returns a pointer to the correct 'flag2' member */
    const FLAG_16* _GetFlag2Ptr() const;
    
    /* Returns a pointer to the correct 'region' member */
    const twobyte* _GetRegionPtr() const;
    
    /* Returns a pointer to the correct 'base' member */
    const twobyte* _GetBasePtr() const;
    
    /* Returns a pointer to the correct 'startchar' member
     Finale 2012+ uses eUniChar32, earlier versions use twobyte.
     */
    const void* _GetStartcharPtr() const;
    
    bool _GetScorePartFlags(bool parts, FLAG_16 flag);
    void _SetScorePartFlags(bool parts, FLAG_16 flag, bool state);
 
    FLAG_16 _GetScorePartFlagsValue(bool parts);
    void _SetScorePartFlagsValue(bool parts, FLAG_16 flag);
    FLAG_16 _GetScorePartFlags2Value(bool parts);
    void _SetScorePartFlags2Value(bool parts, FLAG_16 flag2);
 
    /* Non-virtual method to decide the FXT version */
    EVERSION _FXTVersionToUse() const;
    
    /* For internal use only. Formats a display version of the measure number index.
     The measure number index is the 0-based index within the numbering sequence.
     */
    void _FormatDisplayedNumberForIndex(twobyte meas_num_index, FCString* pString);
protected:
    EXTAG Tag() const override { return ot_MeasNumberRegion; }
    int DataSizeLoad() const override;
    void* Allocate() override;
 
    EVERSION EnigmaVersion() const override;
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(_GetData(), ((FCMeasureNumberRegion*)pSource)->_GetData(), DataSizeLoad());
        _datablock = Allocate();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCMeasureNumberRegion(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    enum NUMBERINGSTYLE
    {
        NUMBERING_DIGITS = 0,
 
        NUMBERING_LOWERCASEDOUBLE,
 
        NUMBERING_UPPERCASEDOUBLE,
 
        NUMBERING_LOWERCASE,
 
        NUMBERING_UPPERCASE,
        
        NUMBERING_TIME_SECONDS,
        
        NUMBERING_TIME_10,
        
        NUMBERING_TIME_100,
        
        NUMBERING_TIME_1000,
        
        NUMBERING_FRAMES,
        
        NUMBERING_CUSTOM = 101 /* Set this style above all other */
    };
 
    enum NUMBERVIEWS
    {
        NUMBERVIEW_ALL = 0,
 
        NUMBERVIEW_PAGEONLY,
 
        NUMBERVIEW_SCROLLONLY
    };
 
    enum MNALIGNMENTS
    {
        MNALIGN_LEFT = 0,
 
        MNALIGN_CENTER,
 
        MNALIGN_RIGHT
    };
 
    enum MNJUSTIFICATIONS
    {
        MNJUSTIFY_LEFT = TEXT_JUSTIFY_LEFT,
 
        MNJUSTIFY_CENTER = TEXT_JUSTIFY_CENTER,
 
        MNJUSTIFY_RIGHT = TEXT_JUSTIFY_RIGHT
    };
 
    const char* ClassName() const override { return "FCMeasureNumberRegion"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MEASURENUMBERREGION; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetData() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCMeasureNumberRegion();
 
    void SetStartMeasure(twobyte measure);
 
    void SetEndMeasure(twobyte measure);
 
    void SetStartNumber(twobyte offset);
 
    void SetPrefix(FCString* pString);
 
    void SetSuffix(FCString* pString);
 
    void SetUseScoreInfoForParts(bool value);
 
    void SetID(twobyte newid);
 
    void SetStartFontInfo(FCFontInfo* pFontInfo, bool parts);
 
    void SetMultipleFontInfo(FCFontInfo* pFontInfo, bool parts);
 
    void SetMultiMeasureFontInfo(FCFontInfo* pFontInfo, bool parts);
 
    void SetUseEnclosureStart(bool use, bool parts);
 
    void SetExcludeOtherStaves(bool exclude, bool parts);
 
    void SetUseEnclosureMultiple(bool use, bool parts);
 
    void SetShowOnTopStaff(bool showontop, bool parts);
 
    void SetShowOnSystemStart(bool showonstart, bool parts);
 
    void SetShowOnBottomStaff(bool showonbottom, bool parts);
 
    void SetShowMultiples(bool showmultiples, bool parts);
 
    void SetHideFirstNumber(bool hide, bool parts);
 
    void SetShowMultiMeasureRange(bool show, bool parts);
 
    void SetShowOnMultiMeasureRests(bool show, bool parts);
 
    void SetMultipleValue(twobyte value, bool parts);
 
    void SetMultipleStartMeasure(twobyte measure, bool parts);
 
    void SetMultiMeasureBracketLeft(eUniChar32 character, bool parts);
 
    void SetMultiMeasureBracketRight(eUniChar32 character, bool parts);
 
    void SetBreakMultiMeasureRests(bool breakstate, bool parts);
 
    void SetStartAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
MNALIGNMENTS
#else
int
#endif
    alignment,
    bool parts);
 
    void SetStartJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
MNJUSTIFICATIONS
#else
int
#endif
justification,
        bool parts);
 
    void SetMultipleAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
MNALIGNMENTS
#else
int
#endif
    alignment,
    bool parts);
 
    void SetMultipleJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
MNJUSTIFICATIONS
#else
int
#endif
justification,
        bool parts);
 
    void SetMultiMeasureAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
MNALIGNMENTS
#else
int
#endif
    alignment,
    bool parts);
 
    void SetMultiMeasureJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
MNJUSTIFICATIONS
#else
int
#endif
justification,
        bool parts);
 
    void SetStartHorizontalPosition(twobyte distance, bool parts);
 
    void SetStartVerticalPosition(twobyte distance, bool parts);
 
    void SetMultipleHorizontalPosition(twobyte distance, bool parts);
 
    void SetMultipleVerticalPosition(twobyte distance, bool parts);
 
    void SetMultiMeasureHorizontalPosition(twobyte distance, bool parts);
 
    void SetMultiMeasureVerticalPosition(twobyte distance, bool parts);
 
    void SetView(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    NUMBERVIEWS
#else
    int
#endif
    view
    );
 
    void SetNumberingStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    NUMBERINGSTYLE
#else
    int
#endif    
    style
    );
 
    void SetBase(twobyte base);
 
    void SetStartCharacter(eUniChar32 character);
 
    void SetTime(bool state);
    
    void SetTimeFrames(bool state);
    
    void SetUseHours(bool state);
    
    void SetTimePrecision(twobyte precision);
    
    void SetCountFromOne(bool value);
 
    void SetNoZero(bool value);
 
    void SetDoubleUp(bool value);
 
    twobyte GetStartMeasure() const;
 
    twobyte GetEndMeasure() const;
 
    twobyte GetStartNumber() const;
    
    bool GetTime() const;
    
    bool GetTimeFrames() const;
    
    bool GetUseHours() const;
    
    twobyte GetTimePrecision() const;
 
    bool GetNoZero() const;
    
    bool GetDoubleUp() const;
 
    bool GetCountFromOne() const;
 
    eUniChar32 GetStartCharacter() const;
 
    twobyte GetBase() const;
 
    bool GetUseScoreInfoForParts() const;
 
    twobyte GetID();
 
    bool GetDisplayedNumber(eMeas number, FCString* pString);
    
    bool GetDisplayedNumberWithID(eMeas number, FCString* pString);
    
    void GetPrefix(FCString* pString);
 
    void GetSuffix(FCString* pString);
    
    FCEnclosure* GetEnclosureStart(bool parts)
    {
        return parts ? &_startEnclosureParts : &_startEnclosureScore;
    }
 
    FCEnclosure* GetEnclosureMultiple(bool parts)
    {
        return parts ? &_multipleEnclosureParts : &_multipleEnclosureScore;
    }
 
    bool GetUseEnclosureStart(bool parts);
 
    bool GetExcludeOtherStaves(bool parts);
 
    bool GetUseEnclosureMultiple(bool parts);
    
    bool GetShowOnTopStaff(bool parts);
 
    bool GetShowOnSystemStart(bool parts);
 
    bool GetShowOnBottomStaff(bool parts);
 
    bool GetShowMultiples(bool parts);
 
    bool GetHideFirstNumber(bool parts);
 
    bool GetShowMultiMeasureRange(bool parts);
 
    bool GetShowOnMultiMeasureRests(bool parts);
 
    twobyte GetMultipleValue(bool parts);
 
    twobyte GetMultipleStartMeasure(bool parts);
 
    eUniChar32 GetMultiMeasureBracketLeft(bool parts);
 
    eUniChar32 GetMultiMeasureBracketRight(bool parts);
 
    bool GetBreakMultiMeasureRests(bool parts);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    MNALIGNMENTS 
#else
    int
#endif
    GetStartAlignment(bool parts);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    MNJUSTIFICATIONS
#else
    int
#endif
    GetStartJustification(bool parts);
 
 
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    MNALIGNMENTS
#else
    int
#endif
    GetMultipleAlignment(bool parts);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    MNJUSTIFICATIONS
#else
    int
#endif
    GetMultipleJustification(bool parts);
 
 
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    MNALIGNMENTS
#else
    int
#endif
    GetMultiMeasureAlignment(bool parts);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    MNJUSTIFICATIONS
#else
    int
#endif
    GetMultiMeasureJustification(bool parts);
 
 
    twobyte GetStartHorizontalPosition(bool parts);
 
    twobyte GetStartVerticalPosition(bool parts);
 
    twobyte GetMultipleHorizontalPosition(bool parts);
 
    twobyte GetMultipleVerticalPosition(bool parts);
 
    twobyte GetMultiMeasureHorizontalPosition(bool parts);
 
    twobyte GetMultiMeasureVerticalPosition(bool parts);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    NUMBERVIEWS
#else
    int 
#endif
    GetView() const;
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    NUMBERINGSTYLE
#else
    int
#endif    
     GetNumberingStyle() const;
 
    void GetStartFontInfo(FCFontInfo* pFontInfo, bool parts);
 
    FCFontInfo* CreateStartFontInfo(bool parts)
    {
        FCFontInfo* pFontInfo = new FCFontInfo();
        GetStartFontInfo(pFontInfo, parts);
        return pFontInfo;
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateStartFontInfo_GC(bool parts)
    { return makeLuaSharedPtr(CreateStartFontInfo(parts)); }
#endif
 
    void GetMultipleFontInfo(FCFontInfo* pFontInfo, bool parts);
 
    FCFontInfo* CreateMultipleFontInfo(bool parts)
    {
        FCFontInfo* pFontInfo = new FCFontInfo();
        GetMultipleFontInfo(pFontInfo, parts);
        return pFontInfo;
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateMultipleFontInfo_GC(bool parts)
    { return makeLuaSharedPtr(CreateMultipleFontInfo(parts)); }
#endif
 
    void GetMultiMeasureFontInfo(FCFontInfo* pFontInfo, bool parts);
 
    FCFontInfo* CreateMultiMeasureFontInfo(bool parts)
    {
        FCFontInfo* pFontInfo = new FCFontInfo();
        GetMultiMeasureFontInfo(pFontInfo, parts);
        return pFontInfo;
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateMultiMeasureFontInfo_GC(bool parts)
    { return makeLuaSharedPtr(CreateMultiMeasureFontInfo(parts)); }
#endif
 
    FCString* CreateDisplayedString(twobyte measure);
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateDisplayedString_GC(twobyte measure)
    { return makeLuaSharedPtr(CreateDisplayedString(measure)); }
#endif
 
 
    void CloneFormattingFrom(FCMeasureNumberRegion* pRegionFrom, bool score, bool parts);
 
    bool IsMeasureIncluded(twobyte measureno)
    {
        if (measureno > GetEndMeasure()) return false;
        if (measureno < GetStartMeasure()) return false;
        return true;
    }
    
    bool AssignAllNonNumberedMeasures(FCNumbers* pAllNonNumberedMeasures);
    
    void _SetTempNonIncludedMeasures(FCNumbers* pNonNumberedMeasuresToUse)
    {
        /* Store the "actual" value, restore it with _RestoreTempNonIncludedMeasures() */
                _pTempNonIncludedMeasuresStorage = _pNonIncludedMeasures;        
        /* Set temp value */
                _pNonIncludedMeasures = pNonNumberedMeasuresToUse;
    }
    
    void _RestoreTempNonIncludedMeasures()
    {
        /* Restore from temporary storage to the "real" storage */
                _pNonIncludedMeasures = _pTempNonIncludedMeasuresStorage;
    }
    
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Start measure: ", GetStartMeasure());
        DebugOutInt("End measure: ", GetEndMeasure());
    }
#endif
};
 
class FCSystemStaff : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTInstrumentUsed _instrumentused;    
    int _resize;
 
    bool LoadFirst() override { return false; }
protected:
    EXTAG Tag() const override { return ot_InstrumentUsed; }
    int DataSizeLoad() const override { return sizeof(EDTInstrumentUsed); }
    void* Allocate() override { return (void*) &_instrumentused; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_instrumentused, ((FCSystemStaff*)pSource)->_GetDataPtr(), sizeof(_instrumentused));
        _datablock = &_instrumentused;
        _loadedsize = sizeof(_instrumentused);
        _resize = ((FCSystemStaff*)pSource)->GetResize();
    }
 
    __FCBaseData* CreateObject() override { return new FCSystemStaff(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCSystemStaff"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SYSTEMSTAFF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetDataPtr() { return &_instrumentused; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCSystemStaff() : __FCInciOther()
    {
        memset(&_instrumentused, 0, sizeof(_instrumentused));
        _datablock = &_instrumentused;
        _loadedsize = sizeof(_instrumentused);
        _resize = 100;
    }
 
    bool Load(CMPER itemno, twobyte inci) override;
 
    bool SaveNew(CMPER itemno) override;
 
    bool Save() override;
    
 
    void SetDistance(Evpu32 distance) { _instrumentused.separ = -distance; }
 
    void SetStaff(eStaff staffno) { _instrumentused.inst = staffno; }
 
    Evpu32 GetDistance() const { return -_instrumentused.separ; }
 
    eStaff GetStaff() const override { return _instrumentused.inst; }
 
    int GetResize() const 
    {
        if (_dataid.other.cmper == 0) return 100;
        return _resize;
    }
 
    void SetResize(int value)
    {
        _resize = value;
    }
 
    bool DeleteResizeData()
    {        
        if (_dataid.other.cmper == 0) return false;
        if (!DataIsLoaded()) return false;
        EDataID dataID;
        dataID.detail.cmper1 = _dataid.other.cmper; /* System */
        dataID.detail.cmper2 = _instrumentused.inst; /* Staff */
        dataID.detail.inci = 0; /* Should be 0 */                
        return FX_DeleteEData(dt_StaffEnduction, &dataID, EnigmaVersion()) != 0;
    }
       
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
        DebugOutInt("Distance: ", GetDistance());
    }
#endif
};
 
class FCPercussionLayoutNotes;
 
class FCPercussionStaff  : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTDrumStaff2010 _drumstaff;
 
    bool LoadFirst() override { return false; }
protected:
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ot_DrumStaff2010; } /* Custom tags might be used!!! */
    int DataSizeLoad() const override { return sizeof(EDTDrumStaff2010); }
    void* Allocate() override { return (void*) &_drumstaff; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_drumstaff, ((FCPercussionStaff*)pSource)->_GetDataPtr(), sizeof(_drumstaff));
        _datablock = &_drumstaff;
        _loadedsize = sizeof(_drumstaff);
    }
 
    __FCBaseData* CreateObject() override { return new FCPercussionStaff(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCPercussionStaff"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PERCUSSIONSTAFF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetDataPtr() { return &_drumstaff; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCPercussionStaff() : __FCNoInciOther()
    {
        memset(&_drumstaff, 0, sizeof(_drumstaff));
        _datablock = &_drumstaff;
        _loadedsize = sizeof(_drumstaff);
    }
 
    CMPER GetPercussionLibrary()
    {
        return _drumstaff.whichDrumLib;
    }
 
    void SetPercussionLibrary(CMPER cmper)
    {
        _drumstaff.whichDrumLib = cmper;
    }
    
    FCPercussionLayoutNotes* CreateLayoutNotes();
    
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Percussion Library: ", GetPercussionLibrary());
    }
#endif
};
 
#ifdef PDK_FRAMEWORK_PREFS
class FCStaffNamePosition : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
 
    bool _fullnamepos; /* Needed for calculating the preferences*/
 
    EDTNamePos _namepos;
 
    bool LoadFirst() override { return false; }
protected:
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ot_NamePosFull; } /* Custom tags SHOULD be used!!! */
    int DataSizeLoad() const override { return sizeof(EDTNamePos); }
    void* Allocate() override { return (void*) &_namepos; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_namepos, ((FCStaffNamePosition*)pSource)->_GetDataPtr(), sizeof(_namepos));
        _datablock = &_namepos;
        _loadedsize = sizeof(_namepos);
        _fullnamepos = ((FCStaffNamePosition*)pSource)->_GetFullNamePos();
    }
 
    __FCBaseData* CreateObject() override { return new FCStaffNamePosition(_fullnamepos); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCStaffNamePosition"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STAFFNAMEPOSITION; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _GetFullNamePos() {  return _fullnamepos; }
 
    void* _GetDataPtr() { return &_namepos; }
    
    bool Load(CMPER itemno) override
    {
        const EDTNamePos savenamepos = _namepos;
        const bool retval = __FCNoInciOther::Load(itemno);
        if (! retval)
        {
            _loadedsize = DataSizeLoad();
            _namepos = savenamepos;
        }
        return retval;
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCStaffNamePosition(bool fullname);
 
    twobyte GetHorizontalOffset() const { return _namepos.horizAdjust; }
 
    twobyte GetVerticalOffset() const { return _namepos.vertAdjust; }
 
    FLAG_16 GetJustification() const { return (_namepos.flag & (NAMEPOS_JUSTIBITS & 0x7)); }
 
    FLAG_16 GetAlignment() const { return (_namepos.flag & NAMEPOS_HALIGNBITS) >> 4; }
 
    bool GetExpandSingleWord() const { return GetBitFlag(_namepos.flag, NAMEPOS_EXPAND_SINGLE_WORD); }
 
        bool GetUsePositioning() const { return GetBitFlag(_namepos.flag, 0x0008);  }
 
        // *******
        // SETTERS
        // *******
 
    void SetHorizontalOffset(twobyte value) { _namepos.horizAdjust = value; }
 
    void SetVerticalOffset(twobyte value) { _namepos.vertAdjust = value; }
 
    void SetJustification(FLAG_16 justification)
    {
        const FLAG_16 actualJustiBits = (NAMEPOS_JUSTIBITS & 0x7);
        justification &= actualJustiBits;
        _namepos.flag &= ~actualJustiBits;
        _namepos.flag |= justification;
    }
 
    void SetAlignment(FLAG_16 alignment)
    {
        alignment = alignment << 4;
        alignment &= NAMEPOS_HALIGNBITS;
        _namepos.flag &= ~NAMEPOS_HALIGNBITS;
        _namepos.flag |= alignment;
    }
 
    void SetExpandSingleWord(bool state)
    {
        Set16BitFlag(&_namepos.flag, NAMEPOS_EXPAND_SINGLE_WORD, state);
    }
 
        void SetUsePositioning(bool state) { Set16BitFlag(&_namepos.flag, 0x0008, state); }
 
    Evpu16 CalcHorizontalPosition();
 
    Evpu16 CalcVerticalPosition();
};
#endif /* PDK_FRAMEWORK_PREFS */
/* End of FCStaffNamePosition */
 
 
class FCInstrumentDef;
class FCInstrumentPlaybackData;
class FCFretInstrumentDef;
 
class __FCStaffBase : public __FCNoInciOther
{
    mutable FCString _uuid;  /* Used for #GetInstrumentUUID */
 
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#ifdef PDK_FRAMEWORK_PREFS
    std::unique_ptr<FCStaffNamePosition> _pFullNamePosition;
    std::unique_ptr<FCStaffNamePosition> _pAbbreviatedNamePosition;
#endif // PDK_FRAMEWORK_PREFS
 
    EVERSION _VersionToUse() const;
 
    
    /* PURE VIRTUAL METHODS
     *
     * Used for data pointer access.
     */
    
    virtual const uonebyte* _GetInstUUIDPtr() const = 0;
    
    virtual const FLAG_16* _GetInstFlagPtr() const = 0;
    
    virtual const FLAG_16* _GetFlagPtr() const = 0;
    
        virtual const FLAG_16* _GetAltFlagPtr() const = 0;
 
        virtual const FLAG_16* _GetAltFlag2Ptr() const = 0;
    
        virtual const twobyte* _GetTranspositionPtr() const = 0;
    
    virtual const FLAG_16* _GetMoreFlagsPtr() const = 0;
 
    virtual const FLAG_16* _GetMoreFlags2Ptr() const = 0;
 
    virtual const FLAG_16* _GetMoreFlags3Ptr() const = 0;
        
    virtual const twobyte* _GetAbbrvNamePtr() const = 0;
    
    virtual const twobyte* _GetFullNamePtr() const = 0;
    
        virtual const twobyte* _GetClefsPtr() const = 0;
    
    virtual const Efix32* _GetVertTabNumOffPtr() const = 0;
    
    virtual const CMPER* _GetFretInstIDPtr() const = 0;
    
    virtual const Evpu16* _GetBottomBarlineOffsetPtr() const = 0;
    
    virtual const Evpu16* _GetTopBarlineOffsetPtr() const = 0;
    
    virtual const utwobyte* _GetCapoLowFretPtr() const = 0;
    
    virtual const FLAG_16* _GetBotLinesPtr() const = 0;
    
    virtual const FLAG_16* _GetTopLinesPtr() const = 0;
    
    virtual const Efix32* _GetLineSpacePtr() const = 0;
 
    virtual const twobyte* _GetDwWRestPtr() const = 0;
 
    virtual const twobyte* _GetStemReversalPtr() const = 0;
    
    virtual const twobyte* _GetRepeatDotsOffPtr() const = 0;
 
    virtual const twobyte* _GetHOtherRestPtr() const = 0;
 
    virtual const EFONTID* _GetMFontPtr() const = 0;
 
    virtual const twobyte* _GetSizeEfxPtr() const = 0;
 
    virtual const Efix32* _GetHorzStemOffUpPtr() const = 0;
 
    virtual const Efix32* _GetHorzStemOffDownPtr() const = 0;
 
    virtual const Efix32* _GetVertStemStartOffUpPtr() const = 0;
 
    virtual const Efix32* _GetVertStemStartOffDownPtr() const = 0;
 
    virtual const Efix32* _GetVertStemEndOffUpPtr() const = 0;
 
    virtual const Efix32* _GetVertStemEndOffDownPtr() const = 0;
 
    virtual EXTAG _GetFullNamePosTag() const = 0;
    
    virtual twobyte _GetFullNamePosCmper() const = 0;
 
    virtual EXTAG _GetAbbreviatedNamePosTag() const = 0;
    
    virtual twobyte _GetAbbreviatedNamePosCmper() const = 0;
    
#ifdef PDK_FRAMEWORK_PREFS
    virtual bool _SaveNewFullNamePos() = 0;
 
    virtual bool _SaveNewAbbreviatedNamePos() = 0;
#endif // PDK_FRAMEWORK_PREFS
    
    void _SetFlag(FLAG_16 mask, bool state)
    {
        FLAG_16* pFlag = (FLAG_16*) _GetFlagPtr();
        return Set16BitFlag(pFlag, mask, state);
    }
    
#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
private:
    /* ACCESSOR METHODS */
    
    bool _GetInstFlag(FLAG_16 mask) const
    {
        return GetBitFlag(*_GetInstFlagPtr(), mask);
    }
    
    void _SetInstFlag(FLAG_16 mask, bool state)
    {
        FLAG_16* pInstFlag = (FLAG_16*) _GetInstFlagPtr();
        return Set16BitFlag(pInstFlag, mask, state);
    }
    
    bool _GetFlag(FLAG_16 mask) const
    {
        return GetBitFlag(*_GetFlagPtr(), mask);
    }
    
    bool _GetAltFlag(FLAG_16 mask) const
    {
        return GetBitFlag(*_GetAltFlagPtr(), mask);
    }
    
    void _SetAltFlag(FLAG_16 mask, bool state)
    {
        FLAG_16* pFlag = (FLAG_16*) _GetAltFlagPtr();
        return Set16BitFlag(pFlag, mask, state);
    }
    
    bool _GetTranspositionFlag(FLAG_16 mask) const
    {
        return GetBitFlag(*_GetTranspositionPtr(), mask);
    }
    
    void _SetTranspositionFlag(FLAG_16 mask, bool state)
    {
        FLAG_16* pFlag = (FLAG_16*) _GetTranspositionPtr();
        return Set16BitFlag(pFlag, mask, state);
    }
    
    bool _GetMoreFlags(FLAG_16 mask) const
    {
        return GetBitFlag(*_GetMoreFlagsPtr(), mask);
    }
    
    bool _GetMoreFlags2(FLAG_16 mask) const
    {
        return GetBitFlag(*_GetMoreFlags2Ptr(), mask);
    }
 
    bool _GetMoreFlags3(FLAG_16 mask) const
    {
        return GetBitFlag(*_GetMoreFlags3Ptr(), mask);
    }
 
    void _SetMoreFlags(FLAG_16 mask, bool state)
    {
        FLAG_16* pFlag = (FLAG_16*) _GetMoreFlagsPtr();
        return Set16BitFlag(pFlag, mask, state);
    }
    
        void _SetMoreFlags2(FLAG_16 mask, bool state)
    {
        FLAG_16* pFlag = (FLAG_16*) _GetMoreFlags2Ptr();
        return Set16BitFlag(pFlag, mask, state);
    }
 
    void _SetMoreFlags3(FLAG_16 mask, bool state)
    {
        FLAG_16* pFlag = const_cast<FLAG_16*>(_GetMoreFlags3Ptr());
        return Set16BitFlag(pFlag, mask, state);
    }
 
    void _SetAbbreviatedNameID(CMPER cmperid)
    {
        CMPER* pCmper = (CMPER*) _GetAbbrvNamePtr();
        *pCmper = cmperid;
    }
    
    void _SetFullNameID(CMPER cmperid)
    {
        CMPER* pCmper = (CMPER*) _GetFullNamePtr();
        *pCmper = cmperid;
    }
    
public:
    const char* ClassName() const override { return "__FCStaffBase"; }
 
#if FXT_VERSION >= FINALEVERSION_2012
    
    static const char FFUUID_BLANKSTAFF[];
    static const char FFUUID_GRANDSTAFF[];
    static const char FFUUID_UNKNOWN[];
    
    /* Strings */
    
    static const char FFUUID_VIOLIN[];
    static const char FFUUID_VIOLA[];
    static const char FFUUID_CELLO[];
    static const char FFUUID_DOUBLEBASS[];
    static const char FFUUID_VIOLINSECTION[];
    static const char FFUUID_VIOLASECTION[];
    static const char FFUUID_CELLOSECTION[];
    static const char FFUUID_VIOLONCELLOSECTION[];
    static const char FFUUID_DOUBLEBASSSECTION[];
    static const char FFUUID_CONTRABASSSECTION[];
    static const char FFUUID_STRINGENSEMBLE[];
    static const char FFUUID_VIOLADAMORE[];
    static const char FFUUID_AJAENG[];
    static const char FFUUID_ARPEGGIONE[];
    static const char FFUUID_BARYTON[];
    static const char FFUUID_BYZANTINELYRA[];
    static const char FFUUID_CRETANLYRA[];
    static const char FFUUID_CRWTH[];
    static const char FFUUID_DAHU[];
    static const char FFUUID_DANGAO[];
    static const char FFUUID_DIHU[];
    static const char FFUUID_ERHU[];
    static const char FFUUID_ERXIAN[];
    static const char FFUUID_FIDDLE[];
    static const char FFUUID_GAOHU[];
    static const char FFUUID_GEHU[];
    static const char FFUUID_HAEGEUM[];
    static const char FFUUID_HARDANGERFIDDLE[];
    static const char FFUUID_HURDYGURDY[];
    static const char FFUUID_IGIL[];
    static const char FFUUID_KAMANCHA[];
    static const char FFUUID_KOKYU[];
    static const char FFUUID_KORA[];
    static const char FFUUID_LARUAN[];
    static const char FFUUID_LEIQIN[];
    static const char FFUUID_LIRONE[];
    static const char FFUUID_MORINKHUUR[];
    static const char FFUUID_NYCKELHARPA[];
    static const char FFUUID_OCTOBASS[];
    static const char FFUUID_REBAB[];
    static const char FFUUID_REBEC[];
    static const char FFUUID_SARANGI[];
    static const char FFUUID_SARANGIDRONE[];
    static const char FFUUID_STROHVIOLIN[];
    static const char FFUUID_TROMBAMARINA[];
    static const char FFUUID_VIELLE[];
    static const char FFUUID_VIOL[];
    static const char FFUUID_VIOLADAGAMBA[];
    static const char FFUUID_VIOLINOPICCOLO[];
    static const char FFUUID_VIOLONCELLOPICCOLO[];
    static const char FFUUID_VIOLOTTA[];
    static const char FFUUID_ZHONGHU[];
    
    /* Keyboards */
    
    static const char FFUUID_PIANO[];
    static const char FFUUID_PIANONONAME[];
    static const char FFUUID_HARPSICHORD[];
    static const char FFUUID_ORGAN[];
    static const char FFUUID_ORGAN2STAFF[];
    static const char FFUUID_CELESTA[];
    static const char FFUUID_ACCORDION[];
    static const char FFUUID_MELODICA[];
    static const char FFUUID_ELECTRICPIANO[];
    static const char FFUUID_CLAVINET[];
    static const char FFUUID_SYNTHPAD[];
    static const char FFUUID_SYNTHLEAD[];
    static const char FFUUID_SYNTHBRASS[];
    static const char FFUUID_SYNTHSOUNDTRACK[];
    static const char FFUUID_SOUNDFX[];
    static const char FFUUID_HARMONIUM[];
    static const char FFUUID_ONDESMARTENOT[];
    static const char FFUUID_THEREMIN[];
    static const char FFUUID_VIRGINAL[];
    static const char FFUUID_CLAVICHORD[];
    
    /* Voices */
    
    static const char FFUUID_SOPRANOVOICE[];
    static const char FFUUID_ALTOVOICE[];
    static const char FFUUID_TENORVOICE[];
    static const char FFUUID_BARITONEVOICE[];
    static const char FFUUID_BASSVOICE[];
    static const char FFUUID_VOCALS[];
    static const char FFUUID_VOICE[];
    static const char FFUUID_VOICENONAME[];
    static const char FFUUID_MEZZOSOPRANOVOICE[];
    static const char FFUUID_CONTRALTOVOICE[];
    static const char FFUUID_COUNTERTENORVOICE[];
    static const char FFUUID_BASSBAROTONEVOICE[];
    static const char FFUUID_CHOIRAAHS[];
    static const char FFUUID_CHOIROOHS[];
    static const char FFUUID_YODEL[];
    static const char FFUUID_BEATBOX[];
    static const char FFUUID_KAZOO[];
    static const char FFUUID_TALKBOX[];
    static const char FFUUID_VOCALPERCUSSION[];
    
    /* Woodwinds */
    
    static const char FFUUID_PICCOLO[];
    static const char FFUUID_FLUTE[];
    static const char FFUUID_ALTOFLUTE[];
    static const char FFUUID_OBOE[];
    static const char FFUUID_OBOEDAMORE[];
    static const char FFUUID_ENGLISHHORN[];
    static const char FFUUID_CLARINETBFLAT[];
    static const char FFUUID_CLARINETA[];
    static const char FFUUID_CLARINETEFLAT[];
    static const char FFUUID_ALTOCLARINET[];
    static const char FFUUID_CONTRALTOCLARINET[];
    static const char FFUUID_BASSCLARINET[];
    static const char FFUUID_CONTRABASSCLARINET[];
    static const char FFUUID_BASSOON[];
    static const char FFUUID_CONTRABASSOON[];
    static const char FFUUID_WINDSECTION[];
    static const char FFUUID_SOPRANOSAX[];
    static const char FFUUID_ALTOSAX[];
    static const char FFUUID_TENORSAX[];
    static const char FFUUID_BARITONESAX[];
    static const char FFUUID_SOPRANORECORDER[];
    static const char FFUUID_SOPRANINORECORDER[];
    static const char FFUUID_ALTORECORDER[];
    static const char FFUUID_TENORRECORDER[];
    static const char FFUUID_BASSRECORDER[];
    static const char FFUUID_DESCANTRECORDER[];
    static const char FFUUID_OCARINA[];
    static const char FFUUID_PENNYWHISTLE[];
    static const char FFUUID_PENNYWHISTLED[];
    static const char FFUUID_PENNYWHISTLEG[];
    static const char FFUUID_LOWIRISHWHISTLE[];
    static const char FFUUID_TINWHISTLEBFLAT[];
    static const char FFUUID_HARMONICA[];
    static const char FFUUID_BASSHARMONICA[];
    static const char FFUUID_CONCERTINA[];
    static const char FFUUID_BANDONEON[];
    static const char FFUUID_HORNF_WWQUINTET[];
    static const char FFUUID_BAGPIPES[];
    static const char FFUUID_UILLEANNPIPES[];
    static const char FFUUID_GAIDAPIPES[];
    static const char FFUUID_CONTRAALTOFLUTE[];
    static const char FFUUID_BASSFLUTE[];
    static const char FFUUID_CONTRABASSFLUTE[];
    static const char FFUUID_DOUBLECONTRABASSFLUTE[];
    static const char FFUUID_HYPERBASSFLUTE[];
    static const char FFUUID_PANPIPES[];
    static const char FFUUID_FIFE[];
    static const char FFUUID_BOTTLEBLOW[];
    static const char FFUUID_JUG[];
    static const char FFUUID_PICCOLOOBOE[];
    static const char FFUUID_PICCOLOHECKELPHONE[];
    static const char FFUUID_HECKELPHONE[];
    static const char FFUUID_BASSOBOE[];
    static const char FFUUID_BASSETCLARINET[];
    static const char FFUUID_BASSETHORN[];
    static const char FFUUID_HORNPIPE[];
    static const char FFUUID_PICCOLOCLARINET[];
    static const char FFUUID_SAXONETTE[];
    static const char FFUUID_SOPRANINOSAX[];
    static const char FFUUID_MEZZOSOPRANOSAX[];
    static const char FFUUID_SOPRILLO[];
    static const char FFUUID_CMELODYSAX[];
    static const char FFUUID_AULOCHROME[];
    static const char FFUUID_XAPHOON[];
    static const char FFUUID_BASSSAX[];
    static const char FFUUID_CONTRABASSSAX[];
    static const char FFUUID_SUBCONTRABASSSAX[];
    static const char FFUUID_TUBAX[];
    static const char FFUUID_BANSURI[];
    static const char FFUUID_DANSO[];
    static const char FFUUID_DIZI[];
    static const char FFUUID_DILLIKAVAL[];
    static const char FFUUID_DIPLE[];
    static const char FFUUID_DOUBLEFLUTE[];
    static const char FFUUID_DVOJNICE[];
    static const char FFUUID_DVOJNICEDRONE[];
    static const char FFUUID_FLAGEOLET[];
    static const char FFUUID_FUJARA[];
    static const char FFUUID_GEMSHORN[];
    static const char FFUUID_HOCCHIKU[];
    static const char FFUUID_HUN[];
    static const char FFUUID_IRISHFLUTE[];
    static const char FFUUID_KAVAL[];
    static const char FFUUID_KHLUI[];
    static const char FFUUID_KNOTWEEDFLUTE[];
    static const char FFUUID_KONCOVKAALTOFLUTE[];
    static const char FFUUID_KOUDI[];
    static const char FFUUID_NEY[];
    static const char FFUUID_NOHKAN[];
    static const char FFUUID_NOSEFLUTE[];
    static const char FFUUID_PALENDAG[];
    static const char FFUUID_QUENA[];
    static const char FFUUID_RYUTEKI[];
    static const char FFUUID_SHAKUHACHI[];
    static const char FFUUID_SHEPHERDSPIPE[];
    static const char FFUUID_SHINOBUE[];
    static const char FFUUID_SHIVAWHISTLE[];
    static const char FFUUID_SHVI[];
    static const char FFUUID_SULING[];
    static const char FFUUID_TARKA[];
    static const char FFUUID_TENOROVERTONEFLUTE[];
    static const char FFUUID_TUMPONG[];
    static const char FFUUID_VENU[];
    static const char FFUUID_XIAO[];
    static const char FFUUID_XUN[];
    static const char FFUUID_ALBOGUE[];
    static const char FFUUID_ALBOKA[];
    static const char FFUUID_ALTOCRUMHORN[];
    static const char FFUUID_ARGHUL[];
    static const char FFUUID_BAWU[];
    static const char FFUUID_CHALUMEAU[];
    static const char FFUUID_CLARINETTEDAMOUR[];
    static const char FFUUID_CORNAMUSE[];
    static const char FFUUID_DIPLICA[];
    static const char FFUUID_DOUBLECLARINET[];
    static const char FFUUID_HECKELCLARINA[];
    static const char FFUUID_HECKELPHONECLARINET[];
    static const char FFUUID_HIRTENSCHALMEI[];
    static const char FFUUID_LAUNEDDAS[];
    static const char FFUUID_MAQRUNAH[];
    static const char FFUUID_MIJWIZ[];
    static const char FFUUID_OCTAVIN[];
    static const char FFUUID_PIBGORN[];
    static const char FFUUID_RAUSCHPFEIFE[];
    static const char FFUUID_SIPSI[];
    static const char FFUUID_MODERNTAROGATO[];
    static const char FFUUID_TENORCRUMHORN[];
    static const char FFUUID_ZHALEIKA[];
    static const char FFUUID_ALGAITA[];
    static const char FFUUID_BIFORA[];
    static const char FFUUID_BOMBARDE[];
    static const char FFUUID_CROMORNE[];
    static const char FFUUID_DUDUK[];
    static const char FFUUID_DULCIAN[];
    static const char FFUUID_DULZAINA[];
    static const char FFUUID_GUAN[];
    static const char FFUUID_GUANZI[];
    static const char FFUUID_HICHIRIKI[];
    static const char FFUUID_HNE[];
    static const char FFUUID_JOGIBAJA[];
    static const char FFUUID_KENBAU[];
    static const char FFUUID_MIZMAR[];
    static const char FFUUID_NADASWARAM[];
    static const char FFUUID_OBOEDACACCIA[];
    static const char FFUUID_PI[];
    static const char FFUUID_PIRI[];
    static const char FFUUID_PUNGISNAKECHARMER[];
    static const char FFUUID_RACKETT[];
    static const char FFUUID_REEDCONTRABASS[];
    static const char FFUUID_RHAITA[];
    static const char FFUUID_ROTHPHONE[];
    static const char FFUUID_SARRUSOPHONE[];
    static const char FFUUID_SHAWM[];
    static const char FFUUID_SHEHNAI[];
    static const char FFUUID_SOPILA[];
    static const char FFUUID_SORNA[];
    static const char FFUUID_SRALAI[];
    static const char FFUUID_SUONA[];
    static const char FFUUID_SURNAY[];
    static const char FFUUID_TAEPYEONGSO[];
    static const char FFUUID_ANCIENTTAROGATO[];
    static const char FFUUID_TROMPETACHINA[];
    static const char FFUUID_ZURLA[];
    static const char FFUUID_ZURNA[];
    static const char FFUUID_KHAENMOUTHORGAN[];
    static const char FFUUID_HULUSI[];
    static const char FFUUID_SHENG[];
    
    /* Brass */
    static const char FFUUID_TRUMPETBFLAT[];
    static const char FFUUID_TRUMPETC[];
    static const char FFUUID_TRUMPETD[];
    static const char FFUUID_CORNET[];
    static const char FFUUID_FLUGELHORN[];
    static const char FFUUID_MELLOPHONE[];
    static const char FFUUID_HORNF[];
    static const char FFUUID_TROMBONE[];
    static const char FFUUID_BASSTROMBONE[];
    static const char FFUUID_EUPHONIUM[];
    static const char FFUUID_BARITONEBC[];
    static const char FFUUID_BARITONETC[];
    static const char FFUUID_TUBA[];
    static const char FFUUID_BASSTUBA[];
    static const char FFUUID_SOUSAPHONE[];
    static const char FFUUID_BRASSSECTION[];
    static const char FFUUID_PICCOLOTRUMPETA[];
    static const char FFUUID_BUGLE[];
    static const char FFUUID_CORNETEFLAT[];
    static const char FFUUID_HORNEFLAT[];
    static const char FFUUID_ALTOTROMBONE[];
    static const char FFUUID_TENORTROMBONE[];
    static const char FFUUID_CONTRABASSTROMBONE[];
    static const char FFUUID_ALPHORN[];
    static const char FFUUID_ALTOHORN[];
    static const char FFUUID_DIDGERIDOO[];
    static const char FFUUID_POSTHORN[];
    static const char FFUUID_VIENNAHORN[];
    static const char FFUUID_WAGNERTUBA[];
    static const char FFUUID_BAROQUETRUMPET[];
    static const char FFUUID_BASSTRUMPET[];
    static const char FFUUID_CORNETTO[];
    static const char FFUUID_FISCORN[];
    static const char FFUUID_KUHLOHORN[];
    static const char FFUUID_POCKETTRUMPET[];
    static const char FFUUID_SAXHORN[];
    static const char FFUUID_SLIDETRUMPET[];
    static const char FFUUID_CIMBASSO[];
    static const char FFUUID_DOUBLEBELLEUPHONIUM[];
    static const char FFUUID_SACKBUT[];
    static const char FFUUID_HELICON[];
    static const char FFUUID_OPHICLEIDE[];
    static const char FFUUID_SERPENT[];
    static const char FFUUID_SUBCONTRABASSTUBA[];
    static const char FFUUID_CONCHSHELL[];
    static const char FFUUID_HORAGAI[];
    static const char FFUUID_SHOFAR[];
    static const char FFUUID_VUVUZELA[];
    
    /* Plucked strings */
    static const char FFUUID_HARP[];
    static const char FFUUID_TROUBADORHARP[];
    static const char FFUUID_GUITAR[];
    static const char FFUUID_GUITAR8VB[];
    static const char FFUUID_ACOUSTICGUITAR[];
    static const char FFUUID_CLASSICALGUITAR[];
    static const char FFUUID_ELECTRICGUITAR[];
    static const char FFUUID_STEELGUITAR[];
    static const char FFUUID_BANJO[];
    static const char FFUUID_TENORBANJO[];
    static const char FFUUID_ACOUSTICBASS[];
    static const char FFUUID_BASSGUITAR[];
    static const char FFUUID_ELECTRICBASS[];
    static const char FFUUID_FRETLESSBASS[];
    static const char FFUUID_STRINGBASS[];
    static const char FFUUID_MANDOLIN[];
    static const char FFUUID_DULCIMER[];
    static const char FFUUID_HAMMEREDDULCIMER[];
    static const char FFUUID_DULCIMER8VB[];
    static const char FFUUID_AUTOHARP[];
    static const char FFUUID_LUTE[];
    static const char FFUUID_UKULELE[];
    static const char FFUUID_TENORUKULELE[];
    static const char FFUUID_SITAR[];
    static const char FFUUID_ZITHER[];
    static const char FFUUID_ARCHLUTE[];
    static const char FFUUID_BAGLAMA[];
    static const char FFUUID_BALALAIKA[];
    static const char FFUUID_BANDURA[];
    static const char FFUUID_BANJOLELE[];
    static const char FFUUID_BARBAT[];
    static const char FFUUID_BEGENA[];
    static const char FFUUID_BIWA[];
    static const char FFUUID_BOLON[];
    static const char FFUUID_BORDONUA[];
    static const char FFUUID_BOUZOUKI[];
    static const char FFUUID_BULGARIANTAMBURA[];
    static const char FFUUID_CHAPMANSTICK[];
    static const char FFUUID_CHARANGO[];
    static const char FFUUID_CHITARRABATTENTE[];
    static const char FFUUID_CHOAZHOUGUZHENG[];
    static const char FFUUID_CIMBALOM[];
    static const char FFUUID_CITTERN[];
    static const char FFUUID_CUATRO[];
    static const char FFUUID_DANBAU[];
    static const char FFUUID_DANNGUYET[];
    static const char FFUUID_DANTAMTHAPLUC[];
    static const char FFUUID_DANTRANH[];
    static const char FFUUID_DANTYBA[];
    static const char FFUUID_DIDDLEYBOW[];
    static const char FFUUID_DOBRO[];
    static const char FFUUID_DOMRA[];
    static const char FFUUID_DUTAR[];
    static const char FFUUID_DUXIANQIN[];
    static const char FFUUID_EKTARA1[];
    static const char FFUUID_FLAMENCOGUITAR[];
    static const char FFUUID_GEOMUNGO[];
    static const char FFUUID_EKTARA2[];
    static const char FFUUID_GOTTUVADHYAM[];
    static const char FFUUID_GUITARRAQUINTAHUAPANGUERA[];
    static const char FFUUID_GUITARRON[];
    static const char FFUUID_GUITJO[];
    static const char FFUUID_GUITJODOUBLENECK[];
    static const char FFUUID_GUQIN[];
    static const char FFUUID_GUZHENG[];
    static const char FFUUID_HARPGUITAR[];
    static const char FFUUID_IRISHBOUZOUKI[];
    static const char FFUUID_JARANAHUASTECA[];
    static const char FFUUID_JARANAJAROCHO[];
    static const char FFUUID_JARANAMOSQUITO[];
    static const char FFUUID_JARANASEGUNDA[];
    static const char FFUUID_JARANATERCERA[];
    static const char FFUUID_KABOSY[];
    static const char FFUUID_KANTELE[];
    static const char FFUUID_KAYAGUM[];
    static const char FFUUID_KHIM[];
    static const char FFUUID_KOBZA[];
    static const char FFUUID_KOMUZ[];
    static const char FFUUID_KOTO[];
    static const char FFUUID_KUTIYAPI[];
    static const char FFUUID_LANGELEIK[];
    static const char FFUUID_LYRE[];
    static const char FFUUID_MANDOBASS[];
    static const char FFUUID_MANDOCELLO[];
    static const char FFUUID_MANDOLA[];
    static const char FFUUID_MANDORA[];
    static const char FFUUID_MANDORE[];
    static const char FFUUID_MANGBETU[];
    static const char FFUUID_MAROVANY[];
    static const char FFUUID_MOHANVEENA[];
    static const char FFUUID_MOODSWINGER[];
    static const char FFUUID_MUSICALBOW[];
    static const char FFUUID_NGONI[];
    static const char FFUUID_OCTAVEMANDOLIN[];
    static const char FFUUID_OUD[];
    static const char FFUUID_PIPA[];
    static const char FFUUID_PORTUGUESEGUITAR[];
    static const char FFUUID_PSALTERY[];
    static const char FFUUID_REQUINTOGUITAR[];
    static const char FFUUID_RUAN[];
    static const char FFUUID_RUDRAVEENA[];
    static const char FFUUID_SALLANEH[];
    static const char FFUUID_SANSHIN[];
    static const char FFUUID_SANTOOR[];
    static const char FFUUID_SANXIAN[];
    static const char FFUUID_SAROD[];
    static const char FFUUID_SAUNG[];
    static const char FFUUID_SAZ[];
    static const char FFUUID_SE[];
    static const char FFUUID_SETAR[];
    static const char FFUUID_SHAMISEN[];
    static const char FFUUID_TAMBURA[];
    static const char FFUUID_TAR_PLUCKED[];
    static const char FFUUID_THEORBO[];
    static const char FFUUID_TIMPLE[];
    static const char FFUUID_TRES[];
    static const char FFUUID_TSYMBALY[];
    static const char FFUUID_VALIHA[];
    static const char FFUUID_VEENA[];
    static const char FFUUID_VICHITRAVEENA[];
    static const char FFUUID_VIHUELAMEXICO[];
    static const char FFUUID_VIHUELASPAIN[];
    static const char FFUUID_WASHTUBBASS[];
    static const char FFUUID_WHAMOLA[];
    static const char FFUUID_XALAM[];
    static const char FFUUID_YANGQIN[];
    static const char FFUUID_YAZHENG[];
    static const char FFUUID_YUEQIN[];
    
    /* Tablature */
    static const char FFUUID_TAB_GUITAR[];
    static const char FFUUID_TAB_GUITARNONAME[];
    static const char FFUUID_TAB_GUITARSTEMS[];
    static const char FFUUID_TAB_GUITAR_D[];
    static const char FFUUID_TAB_GUITAR_DADGAD[];
    static const char FFUUID_TAB_GUITAR_DOUBLED[];
    static const char FFUUID_TAB_GUITAR_DROPD[];
    static const char FFUUID_TAB_GUITAR_G[];
    static const char FFUUID_TAB_GUITAR_7STRING[];
    static const char FFUUID_TAB_BANJO_G[];
    static const char FFUUID_TAB_TENORBANJO[];
    static const char FFUUID_TAB_BANJO_C[];
    static const char FFUUID_TAB_BANJO_D[];
    static const char FFUUID_TAB_BANJO_DOUBLEC[];
    static const char FFUUID_TAB_BANJO_GMODAL[];
    static const char FFUUID_TAB_BANJO_PLECTRUM[];
    static const char FFUUID_TAB_BASSGUITAR_4[];
    static const char FFUUID_TAB_BASSGUITAR_5[];
    static const char FFUUID_TAB_BASSGUITAR_6[];
    static const char FFUUID_TAB_DULCIMER_DAA[];
    static const char FFUUID_TAB_DULCIMER_DAAUNISON[];
    static const char FFUUID_TAB_DULCIMER_DAD[];
    static const char FFUUID_TAB_GAMBA[];
    static const char FFUUID_TAB_LUTEITALIAN[];
    static const char FFUUID_TAB_LUTELETTERS[];
    static const char FFUUID_TAB_MANDOLIN[];
    static const char FFUUID_TAB_REQUINTO[];
    static const char FFUUID_TAB_SITAR_SHANKAR[];
    static const char FFUUID_TAB_SITAR_KHAN[];
    static const char FFUUID_TAB_UKULELE[];
    static const char FFUUID_TAB_VIHUELA[];
    
    /* Pitched Percussion */
    static const char FFUUID_TIMPANI[];
    static const char FFUUID_MALLETS[];
    static const char FFUUID_BELLS[];
    static const char FFUUID_CHIMES[];
    static const char FFUUID_CROTALES[];
    static const char FFUUID_GLOCKENSPIEL[];
    static const char FFUUID_SOPRANOGLOCKENSPIEL[];
    static const char FFUUID_ALTOGLOCKENSPIEL[];
    static const char FFUUID_MARIMBA[];
    static const char FFUUID_BASSMARIMBA[];
    static const char FFUUID_MARIMBASINGLESTAFF[];
    static const char FFUUID_TUBULARBELLS[];
    static const char FFUUID_VIBRAPHONE[];
    static const char FFUUID_XYLOPHONE[];
    static const char FFUUID_SOPRANOXYLOPHONE[];
    static const char FFUUID_ALTOXYLOPHONE[];
    static const char FFUUID_BASSXYLOPHONE[];
    static const char FFUUID_XYLORIMBA[];
    static const char FFUUID_BELL_LYRE[];
    static const char FFUUID_BOOMWHACKERS[];
    static const char FFUUID_CHROMANOTESINSTRUMENTS[];
    static const char FFUUID_CARILLON[];
    static const char FFUUID_CRYSTALGLASSES[];
    static const char FFUUID_FLEXATONE_PITCHED[];
    static const char FFUUID_GLASSHARMONICA[];
    static const char FFUUID_GLASSMARIMBA[];
    static const char FFUUID_HANDBELLS[];
    static const char FFUUID_HANDBELLS_TCLEF[];
    static const char FFUUID_HANDBELLS_BCLEF[];
    static const char FFUUID_HANG_TCLEF[];
    static const char FFUUID_JAWHARP[];
    static const char FFUUID_KALIMBA[];
    static const char FFUUID_SOPRANOMETALLOPHONE[];
    static const char FFUUID_ALTOMETALLOPHONE[];
    static const char FFUUID_BASSMETALLOPHONE[];
    static const char FFUUID_MUSICALSAW[];
    static const char FFUUID_SLIDEWHISTLE[];
    static const char FFUUID_STEELDRUMS_TCLEF[];
    static const char FFUUID_STEELDRUMS_BCLEF[];
    static const char FFUUID_BONANGGAMELAN[];
    static const char FFUUID_GANGSAGAMELAN[];
    static const char FFUUID_GENDERGAMELAN[];
    static const char FFUUID_GIYINGGAMELAN[];
    static const char FFUUID_KANTILGAMELAN[];
    static const char FFUUID_PELOGPANERUSGAMELAN[];
    static const char FFUUID_PEMADEGAMELAN[];
    static const char FFUUID_PENYACAHGAMELAN[];
    static const char FFUUID_SARONBARUNGGAMELAN[];
    static const char FFUUID_SARONDEMONGGAMELAN[];
    static const char FFUUID_SARONPANERUSGAMELAN[];
    static const char FFUUID_SLENDROPANERUSGAMELAN[];
    static const char FFUUID_SLENTHEMSGAMELAN[];
    static const char FFUUID_ALMGLOCKEN[];
    static const char FFUUID_ANGKLUNG[];
    static const char FFUUID_ARRAYMBIRA[];
    static const char FFUUID_BALAFON[];
    static const char FFUUID_BALAPHON[];
    static const char FFUUID_BIANQING[];
    static const char FFUUID_BIANZHONG[];
    static const char FFUUID_FANGXIANG[];
    static const char FFUUID_GANDINGANAKAYO[];
    static const char FFUUID_GYIL[];
    static const char FFUUID_KUBING[];
    static const char FFUUID_KULINTANG[];
    static const char FFUUID_KULINTANGAKAYO[];
    static const char FFUUID_KULINTANGATINIOK[];
    static const char FFUUID_LAMELLAPHONE[];
    static const char FFUUID_LIKEMBE[];
    static const char FFUUID_LUNTANG[];
    static const char FFUUID_MBIRA[];
    static const char FFUUID_MURCHANG[];
    static const char FFUUID_RANATEKLEK[];
    static const char FFUUID_RANATTHUMLEK[];
    static const char FFUUID_SANZA[];
    static const char FFUUID_TAIKODRUMS[];
    static const char FFUUID_TEMPLEBELLS[];
    static const char FFUUID_TIBETANBELLS[];
    static const char FFUUID_TIBETANSINGINGBOWLS[];
    
    /* Drums */
    
    static const char FFUUID_SNAREDRUM[];
    static const char FFUUID_BASSDRUM[];
    static const char FFUUID_DRUMSET[];
    static const char FFUUID_TENORDRUM[];
    static const char FFUUID_QUADTOMS[];
    static const char FFUUID_QUINTTOMS[];
    static const char FFUUID_ROTOTOMS[];
    static const char FFUUID_TENORLINE[];
    static const char FFUUID_SNARELINE[];
    static const char FFUUID_BASSDRUMS_5LINE[];
    static const char FFUUID_DJEMBE[];
    static const char FFUUID_BONGODRUMS[];
    static const char FFUUID_CONGADRUMS[];
    static const char FFUUID_LOGDRUM[];
    static const char FFUUID_TABLAS[];
    static const char FFUUID_TIMBALES[];
    static const char FFUUID_AFRICANLOGDRUM[];
    static const char FFUUID_APENTEMMA[];
    static const char FFUUID_ARABIANFRAMEDRUM[];
    static const char FFUUID_ASHIKO[];
    static const char FFUUID_ATABAQUE[];
    static const char FFUUID_BATA[];
    static const char FFUUID_BENDIR[];
    static const char FFUUID_BODHRAN[];
    static const char FFUUID_BOMBO[];
    static const char FFUUID_BOUGARABOU[];
    static const char FFUUID_BUFFALODRUM[];
    static const char FFUUID_CHENDA[];
    static const char FFUUID_CHUDAIKO[];
    static const char FFUUID_DABAKAN[];
    static const char FFUUID_DAIBYOSI[];
    static const char FFUUID_DAMROO[];
    static const char FFUUID_DARABUKA[];
    static const char FFUUID_DATANGULIONDRUM[];
    static const char FFUUID_DHOL[];
    static const char FFUUID_DHOLAK[];
    static const char FFUUID_DOLLU[];
    static const char FFUUID_DONDO[];
    static const char FFUUID_DOUNDOUNBA[];
    static const char FFUUID_DUFF[];
    static const char FFUUID_DUMBEK[];
    static const char FFUUID_EWEDRUMKAGAN[];
    static const char FFUUID_EWEDRUMKPANLOGO1LARGE[];
    static const char FFUUID_EWEDRUMKPANLOGO2MEDIUM[];
    static const char FFUUID_EWEDRUMKPANLOGO3COMBO[];
    static const char FFUUID_EWEDRUMSOGO[];
    static const char FFUUID_FONTOMFROM[];
    static const char FFUUID_GEDUK[];
    static const char FFUUID_HANDDRUM[];
    static const char FFUUID_HIRADAIKO[];
    static const char FFUUID_IGIHUMURIZO[];
    static const char FFUUID_INGOMA[];
    static const char FFUUID_INYAHURA[];
    static const char FFUUID_JANGGU[];
    static const char FFUUID_KAKKO[];
    static const char FFUUID_KANJIRA[];
    static const char FFUUID_KENDANGGAMELAN[];
    static const char FFUUID_KENKENI[];
    static const char FFUUID_KHOL[];
    static const char FFUUID_KODAIKO[];
    static const char FFUUID_KUDUM[];
    static const char FFUUID_LAMBEGDRUM[];
    static const char FFUUID_MADAL[];
    static const char FFUUID_MADDALE[];
    static const char FFUUID_MOROCCODRUM[];
    static const char FFUUID_MRIDANGAM[];
    static const char FFUUID_NAAL[];
    static const char FFUUID_NAGADODAIKO[];
    static const char FFUUID_NAGARA[];
    static const char FFUUID_NAQARA[];
    static const char FFUUID_NATIVELOGDRUM[];
    static const char FFUUID_NIGERIANLOGDRUM[];
    static const char FFUUID_ODAIKO[];
    static const char FFUUID_OKAWA[];
    static const char FFUUID_OKEDODAIKO[];
    static const char FFUUID_PAHUHULA[];
    static const char FFUUID_PAKHAVAJ[];
    static const char FFUUID_PANDERO[];
    static const char FFUUID_POWWOWDRUM[];
    static const char FFUUID_PUEBLODRUM[];
    static const char FFUUID_REPINIQUE[];
    static const char FFUUID_SABAR[];
    static const char FFUUID_SAKARA[];
    static const char FFUUID_SAMPHO[];
    static const char FFUUID_SANGBAN[];
    static const char FFUUID_SHIMEDAIKO[];
    static const char FFUUID_SURDO[];
    static const char FFUUID_TALKINGDRUM[];
    static const char FFUUID_TAMA[];
    static const char FFUUID_TAMBORITA[];
    static const char FFUUID_TAMTE[];
    static const char FFUUID_TANTAN[];
    static const char FFUUID_TANGKU[];
    static const char FFUUID_TAPHON[];
    static const char FFUUID_TARDRUM[];
    static const char FFUUID_TASHA[];
    static const char FFUUID_THAVIL[];
    static const char FFUUID_TOMBAK[];
    static const char FFUUID_TUMBAK[];
    static const char FFUUID_TSUZUMI[];
    static const char FFUUID_UCHIWADAIKO[];
    static const char FFUUID_UDAKU[];
    static const char FFUUID_ZARB[];
    
    /* Percussion */
    
    static const char FFUUID_PERCUSSIONGENERAL[];
    static const char FFUUID_PERCACCESSORIES[];
    static const char FFUUID_WINDCHIMES[];
    static const char FFUUID_CHIMETREE[];
    static const char FFUUID_BELLTREE[];
    static const char FFUUID_JINGLEBELLS[];
    static const char FFUUID_TAMBOURINE[];
    static const char FFUUID_TRIANGLE[];
    static const char FFUUID_CYMBALS[];
    static const char FFUUID_FINGERCYMBALS[];
    static const char FFUUID_CRASHCYMBAL[];
    static const char FFUUID_HIHATCYMBAL[];
    static const char FFUUID_RIDECYMBAL[];
    static const char FFUUID_SPLASHCYMBAL[];
    static const char FFUUID_TAMTAM[];
    static const char FFUUID_GONG[];
    static const char FFUUID_AGOGOBELLS[];
    static const char FFUUID_AIRHORN[];
    static const char FFUUID_BRAKEDRUM[];
    static const char FFUUID_CABASA[];
    static const char FFUUID_CAJON[];
    static const char FFUUID_CASTANETS[];
    static const char FFUUID_CLAP[];
    static const char FFUUID_CLAPPER[];
    static const char FFUUID_CLAVES[];
    static const char FFUUID_COWBELL[];
    static const char FFUUID_CUICA[];
    static const char FFUUID_GUIRO[];
    static const char FFUUID_MARACAS[];
    static const char FFUUID_POLICEWHISTLE[];
    static const char FFUUID_RAINSTICK[];
    static const char FFUUID_RATCHET[];
    static const char FFUUID_RATTLE[];
    static const char FFUUID_SANDBLOCK[];
    static const char FFUUID_SHAKERS[];
    static const char FFUUID_SPOONS[];
    static const char FFUUID_TEMPLEBLOCKS[];
    static const char FFUUID_VIBRASLAP[];
    static const char FFUUID_WASHBOARD[];
    static const char FFUUID_WHIP[];
    static const char FFUUID_WINDMACHINE[];
    static const char FFUUID_WOODBLOCKS[];
    static const char FFUUID_CENGCENGGAMELAN[];
    static const char FFUUID_GONGAGENGGAMELAN[];
    static const char FFUUID_KEMPULGAMELAN[];
    static const char FFUUID_KEMPYANGGAMELAN[];
    static const char FFUUID_KENONGGAMELAN[];
    static const char FFUUID_KETUKGAMELAN[];
    static const char FFUUID_REYONGGAMELAN[];
    static const char FFUUID_ADODO[];
    static const char FFUUID_AEOLIANHARP[];
    static const char FFUUID_AFOXE[];
    static const char FFUUID_AGOGOBLOCK[];
    static const char FFUUID_AGUNG[];
    static const char FFUUID_AGUNGATAMLANG[];
    static const char FFUUID_AHOKO[];
    static const char FFUUID_BABENDIL[];
    static const char FFUUID_BASICINDIANPERCUSSION[];
    static const char FFUUID_BERIMBAU[];
    static const char FFUUID_BO[];
    static const char FFUUID_BONES[];
    static const char FFUUID_BONGOBELLS[];
    static const char FFUUID_BULLROARER[];
    static const char FFUUID_CAXIXI[];
    static const char FFUUID_CHACHABELLS[];
    static const char FFUUID_CHABARA[];
    static const char FFUUID_CHANCHIKI[];
    static const char FFUUID_CHIMTA[];
    static const char FFUUID_CHINATEMPLEBLOCKS[];
    static const char FFUUID_CHINESECYMBALS[];
    static const char FFUUID_CHINESEGONGS[];
    static const char FFUUID_CHINESEPERCUSSIONENSEMBLE[];
    static const char FFUUID_CHING[];
    static const char FFUUID_CHIPPLI[];
    static const char FFUUID_DAFF[];
    static const char FFUUID_DAFLI[];
    static const char FFUUID_DAWURO[];
    static const char FFUUID_DEF[];
    static const char FFUUID_DOIRA[];
    static const char FFUUID_EWEDRUMATOKE[];
    static const char FFUUID_EWEDRUMAXATSE[];
    static const char FFUUID_EWEDRUMGANGOKUI[];
    static const char FFUUID_FLEXATONE_PERC[];
    static const char FFUUID_GANDINGAN[];
    static const char FFUUID_GANZA[];
    static const char FFUUID_GHATAM[];
    static const char FFUUID_GHUNGROO[];
    static const char FFUUID_GOME[];
    static const char FFUUID_GUBAN[];
    static const char FFUUID_HANDCYMBAL[];
    static const char FFUUID_HANG[];
    static const char FFUUID_HATHELI[];
    static const char FFUUID_HOSHO[];
    static const char FFUUID_HYOUSHIGI[];
    static const char FFUUID_IBO[];
    static const char FFUUID_INDIANGONG[];
    static const char FFUUID_IPU[];
    static const char FFUUID_JAWBONE[];
    static const char FFUUID_KAEKEEKE[];
    static const char FFUUID_KAGUL[];
    static const char FFUUID_KALAAU[];
    static const char FFUUID_KASHIKLAR[];
    static const char FFUUID_KESI[];
    static const char FFUUID_KHARTAL[];
    static const char FFUUID_KKWAENGGWARI[];
    static const char FFUUID_KPOKOKPOKO[];
    static const char FFUUID_KRINSLITDRUM[];
    static const char FFUUID_LAVASTONES[];
    static const char FFUUID_LUOGONG[];
    static const char FFUUID_MANJEERA[];
    static const char FFUUID_PANCLAPPERS[];
    static const char FFUUID_PATSCHEN[];
    static const char FFUUID_RATTLECOG[];
    static const char FFUUID_RIQ[];
    static const char FFUUID_SHEKERE[];
    static const char FFUUID_SISTRE[];
    static const char FFUUID_SISTRUM[];
    static const char FFUUID_SLIDEWHISTLE_PERCCLEF[];
    static const char FFUUID_SLITDRUM[];
    static const char FFUUID_SNAP[];
    static const char FFUUID_STAMP[];
    static const char FFUUID_STIRDRUM[];
    static const char FFUUID_TEBYOSHI[];
    static const char FFUUID_TELEVI[];
    static const char FFUUID_TEPONAXTLI[];
    static const char FFUUID_THAIGONG[];
    static const char FFUUID_TIBETANCYMBALS[];
    static const char FFUUID_TICTOCBLOCK[];
    static const char FFUUID_TIMBALEBELL[];
    static const char FFUUID_TINAJA[];
    static const char FFUUID_TINGSHA[];
    static const char FFUUID_TOERE[];
    static const char FFUUID_TONETANG[];
    static const char FFUUID_TRYCHEL[];
    static const char FFUUID_UDU[];
    static const char FFUUID_ZILLS[];
    
#endif
 
    enum STAFFNOTATION_STYLE
    {
        STAFFNOTATION_NORMAL = 0,
        
        STAFFNOTATION_PERCUSSION = 1,
        
        STAFFNOTATION_TABLATURE = 2
    };
    
    enum STAFFSTEMDIRS
    {
        STAFFSTEMDIR_DEFAULT = 0,
        
        STAFFSTEMDIR_ALWAYS_UP = 1,
        
        STAFFSTEMDIR_ALWAYS_DOWN = 2
    };
    
    enum ALTERNATE_STAFF {
        
        ALTSTAFF_NORMAL = FXUseNormalNotation,
        
        ALTSTAFF_SLASHBEATS = FXUseSlashBeatsNotation,
        
        ALTSTAFF_RHYTHMIC = FXUseRhythmicNotation,
        
        ALTSTAFF_ONEBARREPEAT = FXUseOneBarRepeatSymbol,
        
        ALTSTAFF_TWOBARREPEAT = FXUseTwoBarRepeatSymbol,
        
        ALTSTAFF_BLANKNOTATIONRESTS = 5,
        
        ALTSTAFF_BLANKNOTATION = FXUseBlankNotation
    };
    
    enum STAFF_HIDEMODES
    {
        STAFFHIDE_NORMAL = 0,
        
        STAFFHIDE_SCORE = 1,
        
        STAFFHIDE_SCORE_AND_PARTS = 2,
        
        STAFFHIDE_CUTAWAY = 3
    };
    
    bool Save() override;
 
    /***********/
    /* GETTERS */
    /***********/
    
    bool GetIgnoreKeySig() const { return _GetInstFlag(STAFF_NOKEY); }
    
    bool GetIndependentTimeSig() const { return _GetInstFlag(STAFF_FLOATTIME); }
    
    bool GetIndependentKeySig() const { return _GetInstFlag(STAFF_FLOATKEYS); }
    
    bool GetShowMeasureNumbers() const { return !_GetInstFlag(STAFF_NEGMNUMB); }
    
    bool GetShowKeySignatures() const { return !_GetInstFlag(STAFF_NEGKEY); }
    
 
        bool GetShowTimeSignatures() const
        {
#if FXT_VERSION < FINALEVERSION_25
                return !_GetInstFlag(STAFF_NEGTIME); /* 32-bit PDK */
#else
                return !_GetInstFlag(STAFF_NEGTIME_SCORE);  /* This is just a rename of the old STAFF_NEGTIME constant */
#endif
        }
 
    bool GetShowScoreTimeSignatures() const 
        { 
                return GetShowTimeSignatures();
        }
 
    bool GetShowPartTimeSignatures() const
    {
#if FXT_VERSION >= FINALEVERSION_25
        return !_GetMoreFlags3(STAFF_MF3_NEGTIME_PARTS);   /* 64-bit PDK */
#else
        return GetShowScoreTimeSignatures(); /* 32-bit PDK */
#endif
    }
 
 
    bool GetShowClefs() const { return !_GetInstFlag(STAFF_NEGCLEF); }
    
    bool GetShowChords() const { return !_GetInstFlag(0x0002 /*STAFF_HIDE_CHORDS*/); }
    
    bool GetShowBarlines() const { return !_GetInstFlag(STAFF_HIDE_BARLINES); }
    
    bool GetShowTextRepeats() const { return !_GetInstFlag(STAFF_NEGREPEAT); }
    
    bool GetShowRepeats() const { return !_GetInstFlag(STAFF_HIDE_RPT_BARS); }
    
    bool GetShowScoreStaffNames() const { return !_GetInstFlag(STAFF_NEGNAME); }
    
        bool GetBreakBarlines() const { return _GetInstFlag(STAFF_BLINEBREAK); }
    
        bool GetBreakRepeatBarlines() const { return _GetInstFlag(STAFF_RBARBREAK); }
    
    bool GetShowAugmentationDots() const { return _GetMoreFlags(STAFF_MF_SHOW_DOTS); }
 
        bool GetIndependentFont() const { return _GetFlag(STAFF_USESMFONT); }
    
        bool GetShowNoteColors() const { return _GetFlag(STAFF_SHOW_NOTE_COLORS); }
    
        bool GetShowNoteShapes() const { return _GetFlag(STAFF_SF_DOSHAPENOTES); }
 
    twobyte GetHalfRestPosition() const { return LO_ONEBYTE(*_GetHOtherRestPtr()); }
 
    twobyte GetOtherRestPosition() const { return HI_ONEBYTE(*_GetHOtherRestPtr()); }
    
    twobyte GetWholeRestPosition() const { return HI_ONEBYTE(*_GetDwWRestPtr()); }
 
    twobyte GetDoubleWholeRestPosition() const { return LO_ONEBYTE(*_GetDwWRestPtr()); }
    
    twobyte GetStemReversalPosition() const { return *_GetStemReversalPtr(); }
    
    bool GetShowTopRepeatDot() const
    {
        return !GetBitFlag(*_GetFlagPtr(), STAFF_HIDE_REPEAT_TOP_DOT);
    }
    
    bool GetShowBottomRepeatDot() const
    {
        return !GetBitFlag(*_GetFlagPtr(), STAFF_HIDE_REPEAT_BOTTOM_DOT);
    }
    
    twobyte GetTopRepeatDotPosition() const { return HI_ONEBYTE(*_GetRepeatDotsOffPtr()); }
    
    twobyte GetBottomRepeatDotPosition() const { return LO_ONEBYTE(*_GetRepeatDotsOffPtr()); }    
    
    bool GetTransposeChromatic() const { return _GetTranspositionFlag(STAFF_CHROMTRANS); }
    
    bool GetTransposeUseClef() const { return _GetTranspositionFlag(STAFF_SETTOCLEF); }
    
    bool GetShowLyrics() const { return !_GetFlag(0x0010 /*STAFF_HIDE_LYRICS*/); }
    
    bool GetShowRests() const { return _GetMoreFlags(STAFF_MF_SHOW_RESTS); }
    
    bool GetShowPartStaffNames() const { return _GetFlag(0x0008 /*STAFF_SHOWNAME_PARTS*/); }
    
    bool GetShowStems() const { return _GetMoreFlags(STAFF_MF_SHOW_STEMS); }
    
    bool GetShowBeams() const { return _GetMoreFlags(STAFF_MF_SHOW_BEAMS); }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STAFFSTEMDIRS
#else
    twobyte
#endif
    GetStemsDirection() const
    {
        switch(*_GetMoreFlagsPtr() & STAFF_MF_STEM_DIR_MASK)
        {
            case STAFF_MF_STEM_DIR_ALWAYS_UP:
                return STAFFSTEMDIR_ALWAYS_UP;
            case STAFF_MF_STEM_DIR_ALWAYS_DOWN:
                return STAFFSTEMDIR_ALWAYS_DOWN;
            case STAFF_MF_STEM_DIR_DEFAULT:
            default:
                return STAFFSTEMDIR_DEFAULT;
        }
    }
    
    bool GetStemsUseVerticalOffsetForNoteheadEnd() const { return _GetMoreFlags(STAFF_MF_STEMS_FIXED_START); }
    
    bool GetStemsNoteheadEndFixedToStaff() const { return _GetMoreFlags(STAFF_MF_STEM_STRT_FROM_STAFF); }
    
    bool GetStemsUseVerticalOffsetForBeamEnd() const { return _GetMoreFlags(STAFF_MF_STEMS_FIXED_END); }
    
    Efix32 GetStemsUpHorizontalOffset() const { return *_GetHorzStemOffUpPtr(); }
    
    Efix32 GetStemsDownHorizontalOffset() const { return *_GetHorzStemOffDownPtr(); }
    
    Efix32 GetStemsUpVerticalOffsetForNoteheadEnd() const { return *_GetVertStemStartOffUpPtr(); }
    
    Efix32 GetStemsDownVerticalOffsetForNoteheadEnd() const { return *_GetVertStemStartOffDownPtr(); }
    
    Efix32 GetStemsUpVerticalOffsetForBeamEnd() const { return *_GetVertStemEndOffUpPtr(); }
    
    Efix32 GetStemsDownVerticalOffsetForBeamEnd() const { return *_GetVertStemEndOffDownPtr(); }
 
    bool GetShowTies() const { return _GetMoreFlags(STAFF_MF_SHOW_TIES); }
    
    bool GetAltNotationDisplayOtherLayerNotes() const
    {
        return _GetAltFlag(STAFF_ALT_SHOWOTHERNOTES);
    }
    
    bool GetTransposeSimplifyKey() const { return !_GetTranspositionFlag(STAFF_NOKEYOPT); }
    
        bool GetDisplayEmptyRests() const { return !_GetFlag(STAFF_BLANKMEASURE); }
    
        bool GetFlatBeams() const { return _GetFlag(STAFF_FLAT_BEAMS); }
    
    bool GetShowTuplets() const
    {
        return _GetMoreFlags(STAFF_MF_SHOW_TUPLETS);
    }
    
    bool GetShowOnlyFirstMeasureClef() const
    {
        return _GetMoreFlags(STAFF_MF_CLEF_FIRST_MEAS_ONLY);
    }
 
    bool GetFretLetters() const
    {
        return _GetMoreFlags(STAFF_MF_USE_TAB_LETTERS);
    }
    
    bool GetBreakTablatureLines() const
    {
        return _GetMoreFlags(STAFF_MF_BREAK_LINES_AT_NOTES);
    }
    
    bool GetShowFretboards() const { return !_GetFlag(0x0800 /*STAFF_HIDE_FRETBOARDS*/); }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STAFFNOTATION_STYLE
#else
    int
#endif
    GetNotationStyle() const
    {
        if (_GetFlag(STAFF_DOPERCUSSIONNOTES)) return STAFFNOTATION_PERCUSSION;
        if (_GetFlag(STAFF_TABNOTES)) return STAFFNOTATION_TABLATURE;
        return STAFFNOTATION_NORMAL;
    }
    
        bool GetAllowHiding() const;
 
    twobyte GetTransposeInterval() const;
    
    bool GetShowStaffLines() const;
    
    twobyte GetLineCount() const;
    
    Efix32 GetLineSpacing() const
    {
        return *_GetLineSpacePtr();
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
        __FCStaffBase::ALTERNATE_STAFF GetAltNotationStyle() { return (__FCStaffBase::ALTERNATE_STAFF) (*_GetAltFlagPtr() & STAFF_ALTNOTATION); }
#else
        FLAG_16 GetAltNotationStyle() const { return *_GetAltFlagPtr() & STAFF_ALTNOTATION; }
#endif
    
    twobyte GetAltNotationLayer() const {
                return ((*_GetAltFlagPtr() & STAFF_ALTLAYER) >> 4) + 1;
        }
    
    bool GetAltShowArticulations() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWARTICS); }
    
    bool GetAltShowLyrics() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWLYRICS); }
 
    bool GetAltShowSmartShapes() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWSMARTSHAPES); }
 
    bool GetAltShowExpression() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWEXPRESSIONS); }
    
    bool GetAltShowOtherNotes() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWOTHERNOTES); }
 
    bool GetAltShowOtherArticulations() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWOTHERARTICS); }
 
    bool GetAltShowOtherLyrics() const { return GetBitFlag(*_GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHERLYRICS); }
 
    bool GetAltShowOtherSmartShapes() const { return GetBitFlag(*_GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHERSMARTSHAPES); }
 
    bool GetAltShowOtherExpressions() const { return GetBitFlag(*_GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHEREXPRESSIONS); }
    
    bool GetAltRhythmStemsUp() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_RHYTHM_STEMS_UP); }
 
    bool GetAltSlashDots() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SLASH_DOTS); }
    
    twobyte GetTransposeClefIndex() const { return (*_GetClefsPtr() & 0xff00) / 0x100; }
    
    twobyte GetDefaultClef() const { return *_GetClefsPtr() & 0xff; }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STAFF_HIDEMODES
#else
    int
#endif
    GetHideMode() const;
    
        bool GetRedisplayOtherLayerAccidentals() const
    {
                const FLAG_16 *pMoreFlags3 = _GetMoreFlags3Ptr();
                if ( !pMoreFlags3 ) return false;
        return (_GetMoreFlags3(0x0001 /* STAFF_MF3_REDISPLAY_LAYER_ACCIS */));
    }
    
        bool GetNoKeySigShowAccidentals() const
    {
                const FLAG_16 *pMoreFlags2 = _GetMoreFlags2Ptr();
                if ( !pMoreFlags2 ) return false;
        return (_GetMoreFlags2(0x0001 /*STAFF_MF2_HIDE_KEYSIG_SHOW_ACCIS*/));
    }
    
    CMPER GetAbbreviatedNameID() { return *_GetAbbrvNamePtr(); }
    
    CMPER GetFullNameID() { return *_GetFullNamePtr(); }
 
#ifdef PDK_FRAMEWORK_PREFS
    virtual FCStaffNamePosition* GetFullNamePosition();
 
    virtual FCStaffNamePosition* GetAbbreviatedNamePosition();
#endif
 
    twobyte GetCapoPosition() const
    {
        return LOBYTE(*_GetCapoLowFretPtr());
    }
    
    twobyte GetLowestFret() const
    {
        return HIBYTE(*_GetCapoLowFretPtr());
    }
    
    Efix32 GetVerticalFretOffset() const
    {
        return *_GetVertTabNumOffPtr();
    }
    
    CMPER GetFretInstrumentDefID() const
    {
        return *_GetFretInstIDPtr();
    }
    
    Evpu16 GetBottomBarlineOffset() const
    {
        return *_GetBottomBarlineOffsetPtr();
    }
    
    Evpu16 GetTopBarlineOffset() const
    {
        return *_GetTopBarlineOffsetPtr();
    }
 
#if FXT_VERSION >= FINALEVERSION_2012
    const char* GetInstrumentUUID() const
    {
        if (_VersionToUse() < FINALEVERSION_2012) return "";
        _uuid.Clear();
        
        const uonebyte* pInstUUID = _GetInstUUIDPtr();
        for (int i = 0; i < UUID_SIZE_PDK; i++)
        {
            uonebyte abyte = pInstUUID[i];
            int highnibble = (abyte & 0xf0) >> 4;
            int lownibble = (abyte & 0x0f);
            if (highnibble < 10)
                _uuid.AppendCharacter(highnibble + '0');
            else
                _uuid.AppendCharacter(highnibble + 'a' - 10);
            if (lownibble < 10)
                _uuid.AppendCharacter(lownibble + '0');
            else
                _uuid.AppendCharacter(lownibble + 'a' - 10);
            switch (i)
            {
                case 3:
                case 5:
                case 7:
                case 9:
                    _uuid.AppendCharacter('-');
                    break;
            }
        }
        return _uuid.GetCString();
    }
#endif
    
    /***********/
    /* SETTERS */
    /***********/
    
    void SetIgnoreKeySig(bool state) { return _SetInstFlag(STAFF_NOKEY, state); }
    
    void SetIndependentTimeSig(bool state) { _SetInstFlag(STAFF_FLOATTIME, state); }
    
    void SetShowMeasureNumbers(bool value) { _SetInstFlag(STAFF_NEGMNUMB, !value); }
    
    void SetShowKeySignatures(bool value) { _SetInstFlag(STAFF_NEGKEY, !value); }
    
    void SetShowTimeSignatures(bool value)
        {
                SetShowScoreTimeSignatures(value);
                SetShowPartTimeSignatures(value);
        }
 
        void SetShowScoreTimeSignatures(bool value) 
        {
#if FXT_VERSION < FINALEVERSION_25
                _SetInstFlag(STAFF_NEGTIME, !value);  /* 32-bit PDK */
#else
                _SetInstFlag(STAFF_NEGTIME_SCORE, !value);   /* 64-bit PDK */
#endif
        }
    
    void SetShowPartTimeSignatures(bool value)
        {
#if FXT_VERSION >= FINALEVERSION_25
                _SetMoreFlags3(STAFF_MF3_NEGTIME_PARTS, !value);
#endif
        }
    
    void SetShowClefs(bool value) { _SetInstFlag(STAFF_NEGCLEF, !value); }
    
    void SetShowChords(bool value) { _SetInstFlag(0x0002 /*STAFF_HIDE_CHORDS*/, !value); }
    
    void SetShowBarlines(bool value) { _SetInstFlag(STAFF_HIDE_BARLINES, !value); }
    
    void SetShowTextRepeats(bool value) { _SetInstFlag(STAFF_NEGREPEAT, !value); }
    
    void SetShowRepeats(bool value) { _SetInstFlag(STAFF_HIDE_RPT_BARS, !value); }
    
    void SetShowScoreStaffNames(bool value) { _SetInstFlag(STAFF_NEGNAME, !value); }
    
        void SetBreakBarlines(bool state) { _SetInstFlag(STAFF_BLINEBREAK, state); }
    
        void SetBreakRepeatBarlines(bool state) { _SetInstFlag(STAFF_RBARBREAK, state); }
    
    void SetShowAugmentationDots(bool value) { _SetMoreFlags(STAFF_MF_SHOW_DOTS, value); }
    
        void SetIndependentFont(bool state) { _SetFlag(STAFF_USESMFONT, state); }
    
        void SetShowNoteColors(bool state) { _SetFlag(STAFF_SHOW_NOTE_COLORS, state); }
    
        void SetShowNoteShapes(bool state) { _SetFlag(STAFF_SF_DOSHAPENOTES, state); }
    
    void SetHalfRestPosition(twobyte position)
    {
        *const_cast<twobyte*>(_GetHOtherRestPtr()) = MAKE_TWOBYTE(position, HI_ONEBYTE(*_GetHOtherRestPtr()));
    }
    
    void SetOtherRestPosition(twobyte position)
    {
        *const_cast<twobyte*>(_GetHOtherRestPtr()) = MAKE_TWOBYTE(LO_ONEBYTE(*_GetHOtherRestPtr()), position);
    }
    
    void SetWholeRestPosition(twobyte position)
    {
        *const_cast<twobyte*>(_GetDwWRestPtr()) = MAKE_TWOBYTE(LO_ONEBYTE(*_GetDwWRestPtr()), position);
    }
 
    void SetDoubleWholeRestPosition(twobyte position)
    {
        *const_cast<twobyte*>(_GetDwWRestPtr()) = MAKE_TWOBYTE(position, HI_ONEBYTE(*_GetDwWRestPtr()));
    }
    
    void SetStemReversalPosition(twobyte position)
    {
        twobyte* pStemReversal = (twobyte*) _GetStemReversalPtr();
        *pStemReversal = position;
    }
    
    void SetShowTopRepeatDot(bool state)
    {
        Set16BitFlag((FLAG_16*)_GetFlagPtr(), STAFF_HIDE_REPEAT_TOP_DOT, !state);
    }
    
    void SetShowBottomRepeatDot(bool state)
    {
        Set16BitFlag((FLAG_16*)_GetFlagPtr(), STAFF_HIDE_REPEAT_BOTTOM_DOT, !state);
    }
    
    void SetTopRepeatDotPosition(twobyte position)
    { *const_cast<twobyte*>(_GetRepeatDotsOffPtr()) = MAKE_TWOBYTE(LO_ONEBYTE(*_GetRepeatDotsOffPtr()), position); }
    
    void SetBottomRepeatDotPosition(twobyte position)
    { *const_cast<twobyte*>(_GetRepeatDotsOffPtr()) = MAKE_TWOBYTE(position, HI_ONEBYTE(*_GetRepeatDotsOffPtr())); }
    
    void SetTransposeChromatic(bool state) { _SetTranspositionFlag(STAFF_CHROMTRANS, state); }
    
    void SetTransposeUseClef(bool state) { _SetTranspositionFlag(STAFF_SETTOCLEF, state); }
    
    void SetShowFretboards(bool value) { _SetFlag(0x0800 /*STAFF_HIDE_FRETBOARDS*/, !value); }
    
    void SetShowLyrics(bool value) { _SetFlag(0x0010 /*STAFF_HIDE_LYRICS*/, !value); }
    
    void SetShowRests(bool value) { _SetMoreFlags(STAFF_MF_SHOW_RESTS, value); }
    
    void SetShowPartStaffNames(bool value) { _SetFlag(0x0008 /*STAFF_SHOWNAME_PARTS*/, value); }
 
    void SetShowStems(bool value) { _SetMoreFlags(STAFF_MF_SHOW_STEMS, value); }
    
    void SetShowBeams(bool value) { _SetMoreFlags(STAFF_MF_SHOW_BEAMS, value); }
    
    void SetStemsDirection(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STAFFSTEMDIRS
#else
    twobyte
#endif
    value)
    {
        FLAG_16 mask = 0;
        switch (value)
        {
            case STAFFSTEMDIR_ALWAYS_UP:
                mask = STAFF_MF_STEM_DIR_ALWAYS_UP;
                break;
            case STAFFSTEMDIR_ALWAYS_DOWN:
                mask = STAFF_MF_STEM_DIR_ALWAYS_DOWN;
                break;
            default:
            case STAFFSTEMDIR_DEFAULT:
                mask = STAFF_MF_STEM_DIR_DEFAULT;
                break;
        }
        *const_cast<FLAG_16*>(_GetMoreFlagsPtr()) = (*_GetMoreFlagsPtr() & ~STAFF_MF_STEM_DIR_MASK) | mask;
    }
 
    void SetStemsUseVerticalOffsetForNoteheadEnd(bool value) { _SetMoreFlags(STAFF_MF_STEMS_FIXED_START, value); }
    
    void SetStemsNoteheadEndFixedToStaff(bool value) { _SetMoreFlags(STAFF_MF_STEM_STRT_FROM_STAFF, value); }
    
    void SetStemsUseVerticalOffsetForBeamEnd(bool value) { _SetMoreFlags(STAFF_MF_STEMS_FIXED_END, value); }
    
    void SetStemsUpHorizontalOffset(Efix32 value) { *const_cast<Efix32*>(_GetHorzStemOffUpPtr()) = value; }
    
    void SetStemsDownHorizontalOffset(Efix32 value) { *const_cast<Efix32*>(_GetHorzStemOffDownPtr()) = value; }
 
    void SetStemsUpVerticalOffsetForNoteheadEnd(Efix32 value) { *const_cast<Efix32*>(_GetVertStemStartOffUpPtr()) = value; }
 
    void SetStemsDownVerticalOffsetForNoteheadEnd(Efix32 value) { *const_cast<Efix32*>(_GetVertStemStartOffDownPtr()) = value; }
 
    void SetStemsUpVerticalOffsetForBeamEnd(Efix32 value) { *const_cast<Efix32*>(_GetVertStemEndOffUpPtr()) = value; }
 
    void SetStemsDownVerticalOffsetForBeamEnd(Efix32 value) { *const_cast<Efix32*>(_GetVertStemEndOffDownPtr()) = value; }
 
    void SetShowTies(bool state) { _SetMoreFlags(STAFF_MF_SHOW_TIES, state); }
    
    void SetAltNotationDisplayOtherLayerNotes(bool state)
    {
        _SetAltFlag(STAFF_ALT_SHOWOTHERNOTES, state);
    }
    
    void SetTransposeSimplifyKey(bool state) { _SetTranspositionFlag(STAFF_NOKEYOPT, !state); }
    
        void SetDisplayEmptyRests(bool state) { _SetFlag(STAFF_BLANKMEASURE, !state); }
    
        void SetFlatBeams(bool state) { _SetFlag(STAFF_FLAT_BEAMS, state); }
    
    void SetShowTuplets(bool state)
    {
        _SetMoreFlags(STAFF_MF_SHOW_TUPLETS, state);
    }
    
    void SetShowOnlyFirstMeasureClef(bool state)
    {
        _SetMoreFlags(STAFF_MF_CLEF_FIRST_MEAS_ONLY, state);
    }
    
    void SetFretLetters(bool state)
    {
        _SetMoreFlags(STAFF_MF_USE_TAB_LETTERS, state);
    }
    
    void SetBreakTablatureLines(bool state)
    {
        _SetMoreFlags(STAFF_MF_BREAK_LINES_AT_NOTES, state);
    }
    
    void SetNotationStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                          STAFFNOTATION_STYLE
#else
                          int
#endif
                          value)
    {
        switch (value)
        {
            case STAFFNOTATION_PERCUSSION:
                _SetFlag(STAFF_DOPERCUSSIONNOTES, true);
                _SetFlag(STAFF_TABNOTES, false);
                break;
            case STAFFNOTATION_TABLATURE:
                _SetFlag(STAFF_DOPERCUSSIONNOTES, false);
                _SetFlag(STAFF_TABNOTES, true);
                break;
            case STAFFNOTATION_NORMAL:
                _SetFlag(STAFF_DOPERCUSSIONNOTES, false);
                _SetFlag(STAFF_TABNOTES, false);
                break;
        }                
    }
 
    void SetIndependentKeySig(bool state) { _SetInstFlag(STAFF_FLOATKEYS, state); }
    
        void SetAllowHiding(bool state);
    
    twobyte GetTransposeAlteration() const;
    
    void SetTransposeAlteration(twobyte value);
    
    void SetTransposeInterval(twobyte value);
    
    void SetShowStaffLines(bool value);
 
    void SetLineCount(twobyte value);
    
    void SetLineSpacing(Efix32 distance)
    {
        Efix32* pStorage = (Efix32*) _GetLineSpacePtr();
        *pStorage = (distance / 64) * 64;
    }
        
    void SetAltNotationStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                ALTERNATE_STAFF value
#else
                FLAG_16 value
#endif
    )
        {
                FLAG_16* pAltFlag = (FLAG_16*)_GetAltFlagPtr();
                *pAltFlag &= ~STAFF_ALTNOTATION;
                *pAltFlag |= value;
        }
    
    void SetAltNotationLayer(int value)
        {
                if (value < 1) return;
                if (value > FX_GetMaxLayers()) return;
                value--;
                value = value << 4;
                FLAG_16* pAltFlag = (FLAG_16*) _GetAltFlagPtr();
                *pAltFlag &= ~STAFF_ALTLAYER;
                *pAltFlag |= value;
        }
    
    void SetAltShowArticulations(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWARTICS, state); }
    
    void SetAltShowLyrics(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWLYRICS, state); }
    
    void SetAltShowSmartShapes(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWSMARTSHAPES, state); }
    
    void SetAltShowExpression(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWEXPRESSIONS, state); }
    
    void SetAltShowOtherNotes(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWOTHERNOTES, state); }
    
    void SetAltShowOtherArticulations(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWOTHERARTICS, state); }
    
    void SetAltShowOtherLyrics(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHERLYRICS, state); }
    
    void SetAltShowOtherSmartShapes(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHERSMARTSHAPES, state); }
    
    void SetAltShowOtherExpressions(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHEREXPRESSIONS, state); }
    
    void SetAltRhythmStemsUp(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_RHYTHM_STEMS_UP, state); }
    
    void SetAltSlashDots(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SLASH_DOTS, state); }
    
    void SetHideMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                     STAFF_HIDEMODES
#else
                     int
#endif
                     value
                     );
    
    void SetTransposeClefIndex(twobyte clefindex)
        {
                clefindex &= 0x00ff;
                clefindex *= 0x100;
                twobyte* pClefs = (twobyte*)_GetClefsPtr();
                *pClefs &= 0x00ff;
                *pClefs |= clefindex;
        }
    
    void SetDefaultClef(twobyte clefindex)
    {
        clefindex &= 0xff;
        twobyte* pClefs = (twobyte*) _GetClefsPtr();
        *pClefs &= ~0xff;
        *pClefs |= clefindex;
    }        
         
        void SetRedisplayOtherLayerAccidentals(bool state)
    {
                const FLAG_16 *pMoreFlags3 = _GetMoreFlags3Ptr();
                if ( !pMoreFlags3 ) return;
                _SetMoreFlags3(0x0001 /*STAFF_MF3_REDISPLAY_LAYER_ACCIS*/,state);
    }
    
        void SetNoKeySigShowAccidentals(bool state)
    {
                const FLAG_16 *pMoreFlags2 = _GetMoreFlags2Ptr();
                if ( !pMoreFlags2 ) return;
                _SetMoreFlags2(0x0001 /*STAFF_MF2_HIDE_KEYSIG_SHOW_ACCIS*/,state);
    }
    
    void SetLowestFret(twobyte value)
    {
        BYTE lobyte = LOBYTE(*_GetCapoLowFretPtr());
        utwobyte* pCapoLowFret = (utwobyte*) _GetCapoLowFretPtr();
        *pCapoLowFret = MAKEWORD(lobyte, value);
    }
    
    void SetCapoPosition(twobyte value)
    {
        BYTE hibyte = HIBYTE(*_GetCapoLowFretPtr());
        utwobyte* pCapoLowFret = (utwobyte*) _GetCapoLowFretPtr();
        *pCapoLowFret = MAKEWORD(value, hibyte);
    }
 
    void SetVerticalFretOffset(Efix32 value)
    {
        Efix32* pVertTabNumOff = (Efix32*) _GetVertTabNumOffPtr();
        *pVertTabNumOff = value;
    }
    
    void SetFretInstrumentDefID(CMPER newid)
    {
        CMPER* pFretInstID = (CMPER*) _GetFretInstIDPtr();
        *pFretInstID = newid;
    }
    
    void SetBottomBarlineOffset(Evpu16 distance)
    {
        Evpu16* pData = (Evpu16*) _GetBottomBarlineOffsetPtr();
        *pData = distance;
    }
    
    void SetTopBarlineOffset(Evpu16 distance)
    {
        Evpu16* pData = (Evpu16*) _GetTopBarlineOffsetPtr();
        *pData = distance;
    }
    
#if FXT_VERSION >= FINALEVERSION_2012
    void SetInstrumentUUID(const char* pszUUID)
    {
        if (_VersionToUse() < FINALEVERSION_2012) return;
        if (!pszUUID) return;
        if (strlen(pszUUID) != 36) return; /* Wrong string format */
        if (pszUUID[8] != '-') return; /* No first dash */
        if (pszUUID[13] != '-') return; /* No second dash */
        if (pszUUID[18] != '-') return; /* No third dash */
        if (pszUUID[23] != '-') return; /* No fourth dash */
        for (int i = 0; i < 36; i++)
        {
            switch (i)
            {
                case 8:
                case 13:
                case 18:
                case 23:
                    if (pszUUID[i] != '-') return;
                    break;
                default:
                    if ((pszUUID[i] >= 'a') && (pszUUID[i] <= 'f')) break;
                    if ((pszUUID[i] >= '0') && (pszUUID[i] <= '9')) break;
                    return;
            }
        }
        /* UUID validation ok - store the UUID */
        const char* pszCurrent = pszUUID;
        for (int i = 0; i < UUID_SIZE_PDK; i++)
        {
            int result1, result2;
            if (*pszCurrent >= 'a') result1 = *pszCurrent - 'a' + 10;
            else if (*pszCurrent >= 'A') result1 = *pszCurrent - 'A' + 10;
            else result1 = *pszCurrent - '0';
            pszCurrent ++;
            if (*pszCurrent >= 'a') result2 = *pszCurrent - 'a' + 10;
            else if (*pszCurrent >= 'A') result2 = *pszCurrent - 'A' + 10;
            else result2 = *pszCurrent - '0';
            int result = (result1 * 0x10) | result2;
            uonebyte* pInstUUID = (uonebyte*) _GetInstUUIDPtr();
            pInstUUID[i] = result;
            pszCurrent ++;
            if ((i == 3) || (i == 5) || (i == 7) || (i == 9)) pszCurrent ++;
        }
    }
#endif
    
    /****************/
    /* MISC METHODS */
    /****************/
    
    void MakeNormalNotation()
    {
        _SetFlag(STAFF_DOPERCUSSIONNOTES, false);
        _SetFlag(STAFF_TABNOTES, false);
    }
    
    bool IsPercussion()
    {
        return (GetNotationStyle() == STAFFNOTATION_PERCUSSION);
    }
    
    bool IsTablature()
    {
        return (GetNotationStyle() == STAFFNOTATION_TABLATURE);
    }
    
    bool IsNormalNotation()
    {
        return (GetNotationStyle() == STAFFNOTATION_NORMAL);
    }
    
    bool GetTranspose() const
    {
        /* Fix Oct 22, 2012: STAFF_NOKEYOPT might be set even if no transposition
         * is used */
        return ((*_GetTranspositionPtr() & ~STAFF_NOKEYOPT) != 0);
    }
    
    int CalcTopStaffLinePosition(bool forledgerlines = false) const;
    
    int CalcBottomStaffLinePosition(bool forledgerlines = false) const;
 
    bool SaveFullNameString(FCString* pString);
    
    bool SaveAbbreviatedNameString(FCString* pString);
    
    bool SaveNewFullNameString(FCString* pString);
    
    bool SaveNewAbbreviatedNameString(FCString* pString);
    
    void MakeStandard5LineStaff()
    {
        SetLineCount(5);
        SetLineSpacing(24 * 64);
        SetTopBarlineOffset(0);
        SetBottomBarlineOffset(0);
        SetDoubleWholeRestPosition(-4);
        SetWholeRestPosition(-4);
        SetHalfRestPosition(-4);
        SetOtherRestPosition(-4);
        SetStemReversalPosition(-4);
        SetShowTopRepeatDot(true);
        SetTopRepeatDotPosition(-3);
        SetShowBottomRepeatDot(true);
        SetBottomRepeatDotPosition(-5);
    }
 
    void Make1LineFullBarlineStaff()
    {
        SetLineCount(1);
        SetLineSpacing(24 * 64);
        SetTopBarlineOffset(48);
        SetBottomBarlineOffset(-48);
        SetDoubleWholeRestPosition(-5);
        SetWholeRestPosition(-6);
        SetHalfRestPosition(-4);
        SetOtherRestPosition(-4);
        SetStemReversalPosition(-4);
        SetShowTopRepeatDot(true);
        SetTopRepeatDotPosition(-3);
        SetShowBottomRepeatDot(true);
        SetBottomRepeatDotPosition(-5);
    }
    
    void Make1LineShortBarlineStaff()
    {
        SetLineCount(1);
        SetLineSpacing(24 * 64);
        SetTopBarlineOffset(24);
        SetBottomBarlineOffset(-24);
        SetDoubleWholeRestPosition(-5);
        SetWholeRestPosition(-6);
        SetHalfRestPosition(-4);
        SetOtherRestPosition(-4);
        SetStemReversalPosition(-4);
        SetShowTopRepeatDot(true);
        SetTopRepeatDotPosition(-3);
        SetShowBottomRepeatDot(true);
        SetBottomRepeatDotPosition(-5);
    }
    
    void Make0LineFullBarlineStaff()
    {
        SetLineCount(0);
        SetLineSpacing(24 * 64);
        SetTopBarlineOffset(0);
        SetBottomBarlineOffset(0);
        SetDoubleWholeRestPosition(-4);
        SetWholeRestPosition(-4);
        SetHalfRestPosition(-4);
        SetOtherRestPosition(-4);
        SetStemReversalPosition(-4);
        SetShowTopRepeatDot(true);
        SetTopRepeatDotPosition(-3);
        SetShowBottomRepeatDot(true);
        SetBottomRepeatDotPosition(-5);
    }
    
    FCFontInfo* CreateIndependentFontInfo() const
    {
        FCFontInfo* retval = new FCFontInfo();
        retval->SetFontID(*_GetMFontPtr());
        retval->SetNameByID(*_GetMFontPtr());
        retval->SetSize(HIBYTE(*_GetSizeEfxPtr()));
        retval->SetEnigmaStyles(LOBYTE(*_GetSizeEfxPtr()));
        return retval;
    }
 
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateIndependentFontInfo_GC() const
    { return makeLuaSharedPtr(CreateIndependentFontInfo()); }
#endif
 
    void SetIndependentFontInfo(const FCFontInfo& font)
    {
        *const_cast<EFONTID*>(_GetMFontPtr()) = font.GetIDByName();
        *const_cast<twobyte*>(_GetSizeEfxPtr()) = MAKE_TWOBYTE(font.GetEnigmaStyles(), font.GetSize());
    }
    
    FCString* CreateFullNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateFullNameString_GC()
    { return makeLuaSharedPtr(CreateFullNameString()); }
#endif
    
    FCString* CreateAbbreviatedNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateAbbreviatedNameString_GC()
    { return makeLuaSharedPtr(CreateAbbreviatedNameString()); }
#endif
    
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
    FCString* CreateDisplayFullNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateDisplayFullNameString_GC()
    { return makeLuaSharedPtr(CreateDisplayFullNameString()); }
#endif
 
        FCString* CreateDisplayAbbreviatedNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateDisplayAbbreviatedNameString_GC()
    { return makeLuaSharedPtr(CreateDisplayAbbreviatedNameString()); }
#endif
 
    FCString* CreateTrimmedFullNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateTrimmedFullNameString_GC()
    { return makeLuaSharedPtr(CreateTrimmedFullNameString()); }
#endif
    
    FCString* CreateTrimmedAbbreviatedNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateTrimmedAbbreviatedNameString_GC()
    { return makeLuaSharedPtr(CreateTrimmedAbbreviatedNameString()); }
#endif
    
#endif /* #ifdef PDK_FRAMEWORK_ENIGMASTRINGS */
    
    
#if FXT_VERSION >= FINALEVERSION_2012
    bool InstrumentMatchesUUID(const char* pszUUID)
    {
        if (_VersionToUse() < FINALEVERSION_2012) return false;
        uonebyte* pInstUUID = (uonebyte*) _GetInstUUIDPtr();
        
        if (strlen(pszUUID) != 36) return false; /* Wrong string format */
        if (pszUUID[8] != '-') return false; /* No first dash */
        if (pszUUID[13] != '-') return false; /* No second dash */
        if (pszUUID[18] != '-') return false; /* No third dash */
        if (pszUUID[23] != '-') return false; /* No fourth dash */
        const char* pszCurrent = pszUUID;
        for (int i = 0; i < UUID_SIZE_PDK; i++)
        {
            int result1, result2;
            if (*pszCurrent >= 'a') result1 = *pszCurrent - 'a' + 10;
            else if (*pszCurrent >= 'A') result1 = *pszCurrent - 'A' + 10;
            else result1 = *pszCurrent - '0';
            pszCurrent ++;
            if (*pszCurrent >= 'a') result2 = *pszCurrent - 'a' + 10;
            else if (*pszCurrent >= 'A') result2 = *pszCurrent - 'A' + 10;
            else result2 = *pszCurrent - '0';
            int result = (result1 * 0x10) | result2;
            if (result != pInstUUID[i]) return false;
            pszCurrent ++;
            if ((i == 3) || (i == 5) || (i == 7) || (i == 9)) pszCurrent ++;
        }
        return true;
    }
#endif
    
#if FXT_VERSION >= FINALEVERSION_2012
    bool HasInstrumentAssigned()
    {
        if (_VersionToUse() < FINALEVERSION_2012) return false;
        uonebyte* pInstUUID = (uonebyte*) _GetInstUUIDPtr();
        bool blockisempty = true;
        for (int i = 0; i < UUID_SIZE_PDK; i++) if (pInstUUID[i]) blockisempty = false;
        if (blockisempty) return false;
        if (InstrumentMatchesUUID(FFUUID_BLANKSTAFF)) return false;
        if (InstrumentMatchesUUID(FFUUID_UNKNOWN)) return false;
        return true;
    }
#endif
    
 
};
 
 
/* Macro to only refer to the EDTStaffSpec2012 on 2012 PDKs and later. */
#if FXT_VERSION >= FINALEVERSION_2012
#define PROTECTED2012STAFFSPEC(code) code
#else
#define PROTECTED2012STAFFSPEC(code)
#endif
 
/* Macro to only refer to the EDTStaffSpec2014 on 2014 PDKs and later. */
#if FXT_VERSION >= FINALEVERSION_2014
#define PROTECTED2014STAFFSPEC(code) code
#else
#define PROTECTED2014STAFFSPEC(code)
#endif
 
 
class FCStaff : public __FCStaffBase
{
    const bool _skipWorkaround;
    
    void _InitEDTStructs()
    {
        int size = 0;
        switch (_VersionToUse())
        {
            case FINALEVERSION_2010:
                size = sizeof(_staffspec2010);
                memset(&_staffspec2010, 0, size);
                break;
            case FINALEVERSION_2012:
                PROTECTED2012STAFFSPEC(size = sizeof(_staffspec2012);)
                PROTECTED2012STAFFSPEC(memset(&_staffspec2012, 0, size));
                break;
            default:
                PROTECTED2014STAFFSPEC(size = sizeof(_staffspec2014);)
                PROTECTED2014STAFFSPEC(memset(&_staffspec2014, 0, size));
                break;
        }
    }
 
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStaffSpec2010 _staffspec2010;
    PROTECTED2012STAFFSPEC(EDTStaffSpec2012 _staffspec2012;)
    PROTECTED2014STAFFSPEC(EDTStaffSpec2014 _staffspec2014;)
 
    EXTAG Tag() const override { return ot_EDTStaffSpec; }
    int DataSizeLoad() const override 
    {
        switch (_VersionToUse())
        {
            case FINALEVERSION_2010:
                return sizeof(EDTStaffSpec2010);
            case FINALEVERSION_2012:
                PROTECTED2012STAFFSPEC(return sizeof(EDTStaffSpec2012));
                break;
            default:
                PROTECTED2014STAFFSPEC(return sizeof(EDTStaffSpec2014));
                break;
        }
    }
    void* Allocate() override 
    {
        switch (_VersionToUse())
        {            
            case FINALEVERSION_2010:
                return (void*) &_staffspec2010;
#if FXT_VERSION >= FINALEVERSION_2012
            case FINALEVERSION_2012:
                return (void*) &_staffspec2012;
#endif
            default:
                PROTECTED2014STAFFSPEC(return (void*) &_staffspec2014);
                return NULL;
        }
    }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        void* pStaffSpec = NULL;
        fourbyte size = 0;
        switch (_VersionToUse())
        {
            case FINALEVERSION_2010:
                pStaffSpec = &_staffspec2010;
                size = sizeof(_staffspec2010);
                break;
            case FINALEVERSION_2012:
                PROTECTED2012STAFFSPEC(
                pStaffSpec = &_staffspec2012;
                size = sizeof(_staffspec2012);)
                break;
            default:
                PROTECTED2014STAFFSPEC(
                pStaffSpec = &_staffspec2014;
                size = sizeof(_staffspec2014);)
                break;
        }
 
        memcpy(pStaffSpec, ((FCStaff*)pSource)->_GetStaffSpec(), size);
        _datablock = pStaffSpec;
        _loadedsize = size;
    }
 
    __FCBaseData* CreateObject() override { return new FCStaff(); }
 
 
    const uonebyte* _GetInstUUIDPtr() const override
    {
        if (_VersionToUse() >= FINALEVERSION_2014)
                return _staffspec2014.instUUID;
        if (_VersionToUse() >= FINALEVERSION_2012)
                return _staffspec2012.instUUID;
        return NULL;
    }
    
    const FLAG_16* _GetInstFlagPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->instflag;
    }
    
    const FLAG_16* _GetFlagPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->flag;
    }
    
        const FLAG_16* _GetAltFlagPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->altFlag;
    }
    
        const FLAG_16* _GetAltFlag2Ptr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->altFlag2;
    }
    
        const twobyte* _GetTranspositionPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->transposition;
    }
    
    const FLAG_16* _GetMoreFlagsPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->moreFlags;
    }
        
    const FLAG_16* _GetMoreFlags2Ptr() const override
    {
                if (_VersionToUse() < FINALEVERSION_2014) return NULL;
#if FXT_VERSION < FINALEVERSION_25
                return (const FLAG_16*)&((EDTStaffSpec2014*)_GetStaffSpec())->hideKeySigsShowAccis;
#else
                return &((EDTStaffSpec2014*)_GetStaffSpec())->moreFlags2;
#endif
    }
 
    const FLAG_16* _GetMoreFlags3Ptr() const override
    {
                if (_VersionToUse() < FINALEVERSION_2014) return NULL;
#if FXT_VERSION < FINALEVERSION_25
                return (const FLAG_16*) &((EDTStaffSpec2014*)_GetStaffSpec())->redisplayLayerAccis;
#else
                return &((EDTStaffSpec2014*)_GetStaffSpec())->moreFlags3;
#endif
    }
 
    FLAG_16* _GetAutoNumPtr() const
    {
        if (_VersionToUse() < FINALEVERSION_2012) return NULL;
        if (_VersionToUse() < FINALEVERSION_2014)
            return (FLAG_16*)&((EDTStaffSpec2012*)_GetStaffSpec())->autoNum;
        return (FLAG_16*)&((EDTStaffSpec2014*)_GetStaffSpec())->autoNum;
    }
 
    const twobyte* _GetAbbrvNamePtr() const override
    {           
        return &((EDTStaffSpec2010*)_GetStaffSpec())->abbrvName;
    }
    
    const twobyte* _GetFullNamePtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->fullName;
    }
    
        const twobyte* _GetClefsPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->clefs;
    }
    
    const Efix32* _GetVertTabNumOffPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->vertTabNumOff;
    }
    
    const CMPER* _GetFretInstIDPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->fretInstID;
    }
    
    const Evpu16* _GetBottomBarlineOffsetPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->botBarlineOffset;
    }
    
    const Evpu16* _GetTopBarlineOffsetPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->topBarlineOffset;
    }
    
    const utwobyte* _GetCapoLowFretPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->capoLowFret;
    }
    
    const FLAG_16* _GetBotLinesPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->botLines;
    }
    
    const FLAG_16* _GetTopLinesPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->topLines;
    }
    
    const Efix32* _GetLineSpacePtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->lineSpace;
    }
    
    const twobyte* _GetDwWRestPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->dw_wRest;
    }
 
    const twobyte* _GetStemReversalPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->stemReversal;
    }
 
    const twobyte* _GetRepeatDotsOffPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->repeatDotsOff;
    }
    
    const twobyte* _GetHOtherRestPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->h_otherRest;
    }
 
    const ETAG* _GetFullNamePosTagPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->fullNamePosTag;
    }
    
    const twobyte* _GetFullNamePosCmperPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->fullNamePosCmper;
    }
    
    const ETAG* _GetAbbrvNamePosTagPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->abbrvNamePosTag;
    }
    
    const EFONTID* _GetMFontPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->mfont;
    }
    
    const twobyte* _GetSizeEfxPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->sizeefx;
    }
 
    const Efix32* _GetHorzStemOffUpPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->horzStemOffUp;
    }
 
    const Efix32* _GetHorzStemOffDownPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->horzStemOffDown;
    }
 
    const Efix32* _GetVertStemStartOffUpPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->vertStemStartOffUp;
    }
 
    const Efix32* _GetVertStemStartOffDownPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->vertStemStartOffDown;
    }
 
    const Efix32* _GetVertStemEndOffUpPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->vertStemEndOffUp;
    }
 
    const Efix32* _GetVertStemEndOffDownPtr() const override
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->vertStemEndOffDown;
    }
 
    const twobyte* _GetAbbrvNamePosCmperPtr() const { return &((EDTStaffSpec2010*)_GetStaffSpec())->abbrvNamePosCmper; }
    
    EXTAG _GetFullNamePosTag() const override
    { return (ufourbyte)( ((ufourbyte)edOther<<16) | (ufourbyte)*_GetFullNamePosTagPtr() ); }
    
    twobyte _GetFullNamePosCmper() const override { return *_GetFullNamePosCmperPtr(); }
 
    EXTAG _GetAbbreviatedNamePosTag() const override
    { return (ufourbyte)( ((ufourbyte)edOther<<16) | (ufourbyte)*_GetAbbrvNamePosTagPtr() ); }
    
    twobyte _GetAbbreviatedNamePosCmper() const override { return *_GetAbbrvNamePosCmperPtr(); }
 
#ifdef PDK_FRAMEWORK_PREFS
    virtual bool _SaveNewFullNamePos() override
    {
        if (!_pFullNamePosition || !_pFullNamePosition->SaveNew()) return false;
        ((EDTStaffSpec2010*)_GetStaffSpec())->fullNamePosCmper = _pFullNamePosition->GetItemNo();
        return true;
    }
 
    virtual bool _SaveNewAbbreviatedNamePos() override
    {
        if (!_pAbbreviatedNamePosition || !_pAbbreviatedNamePosition->SaveNew()) return false;
        ((EDTStaffSpec2010*)_GetStaffSpec())->abbrvNamePosCmper = _pAbbreviatedNamePosition->GetItemNo();
        return true;
    }
#endif // PDK_FRAMEWORK_PREFS
        
    bool _SaveRawFields() const;
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EVERSION EnigmaVersion() const override
    {
        return _VersionToUse();
    }
#endif
 
    const char* ClassName() const override { return "FCStaff"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STAFF; }
 
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    const void* _GetStaffSpec() const
    {
        switch (_VersionToUse())
        {
            case FINALEVERSION_2010:
                return &_staffspec2010;
            case FINALEVERSION_2012:
                PROTECTED2012STAFFSPEC(return &_staffspec2012);
                return NULL;
            default:
                PROTECTED2014STAFFSPEC(return &_staffspec2014);
                return NULL;
        }
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool LoadFirst() override
    {
        SetCmperAndInci(0, 0);
        return LoadNext();
    }
    
    bool Load(CMPER itemno) override;
    
    bool LoadNext() override;
    
    bool Save() override
    {
        if (! __FCNoInciOther::Save()) return false;
        return _SaveRawFields();
    }
    
    bool SaveNew() override
    {
        if (! __FCNoInciOther::SaveNew()) return false;
        return _SaveRawFields();
    }
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
    enum STAFFAUTONUMBER_STYLE
    {
        STAFFAUTONUMBER_ARABIC_SUFFIX = EDTStaffSpec2014::PDK_STAFF_AUTONUM_ARABIC_SUFFIX,
        
        STAFFAUTONUMBER_ROMAN_SUFFIX = EDTStaffSpec2014::PDK_STAFF_AUTONUM_ROMAN_SUFFIX,
        
        STAFFAUTONUMBER_ORDINAL_PREFIX = EDTStaffSpec2014::PDK_STAFF_AUTONUM_ORDINAL_PREFIX,
        
        STAFFAUTONUMBER_ALPHA_SUFFIX = EDTStaffSpec2014::PDK_STAFF_AUTONUM_ALPHA_SUFFIX,
        
        STAFFAUTONUMBER_ARABIC_PREFIX = 4
    };
 
 
    FCStaff() : __FCStaffBase(), _skipWorkaround(false)
    { _InitEDTStructs(); }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    FCStaff(bool skipWorkaround) : __FCStaffBase(), _skipWorkaround(skipWorkaround)
    { _InitEDTStructs(); }
 
    static FCStaff* FCStaff_Lua(void* ptr, lua_State* L)
    {
        return _OneOptionalParamLuaConstructor<FCStaff, bool>(ptr, L);
    }
#endif // PDK_FRAMEWORK_LUAFRIENDLY
 
    FCInstrumentPlaybackData* CreateInstrumentPlaybackData();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCInstrumentPlaybackData> CreateInstrumentPlaybackData_GC()
    { return makeLuaSharedPtr(CreateInstrumentPlaybackData()); }
#endif
 
    FCFretInstrumentDef* CreateFretInstrumentDef();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFretInstrumentDef> CreateFretInstrumentDef_GC()
    { return makeLuaSharedPtr(CreateFretInstrumentDef()); }
#endif
    
    bool GetUseAutoNumberingStyle() const
    {
        const FLAG_16 * pAutoNum = _GetAutoNumPtr();
        if (pAutoNum)
            return GetBitFlag(*pAutoNum, PDK_STAFF_USE_AUTONUM_MASK);
        return false;
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STAFFAUTONUMBER_STYLE
#else
    int
#endif
    GetAutoNumberingStyle() const
    {
        const FLAG_16 * pAutoNum = _GetAutoNumPtr();
        if (pAutoNum)
            return (STAFFAUTONUMBER_STYLE)(*pAutoNum & PDK_STAFF_AUTONUM_TYPE_MASK);
        return STAFFAUTONUMBER_ARABIC_SUFFIX;
    }
 
    void SetUseAutoNumberingStyle(bool state)
    {
        FLAG_16 * pAutoNum = _GetAutoNumPtr();
        if (pAutoNum)
            Set16BitFlag(pAutoNum, PDK_STAFF_USE_AUTONUM_MASK, state);
    }
 
    void SetAutoNumberingStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
            STAFFAUTONUMBER_STYLE
#else
            int
#endif
            value
    )
    {
        FLAG_16 * pAutoNum = _GetAutoNumPtr();
        if (pAutoNum)
        {
            *pAutoNum &= ~PDK_STAFF_AUTONUM_TYPE_MASK;
            *pAutoNum |= value;
        }
    }
 
    int CalcPercussionLayoutID();
    
    FCPercussionStaff* CreatePercussionStaff();
    
    bool SavePercussionLayout(int layoutID, int mapID);
    
    FCInstrumentDef* CreateLayerInstrumentDef(int layer);
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCInstrumentDef> CreateLayerInstrumentDef_GC(int layer)
    { return makeLuaSharedPtr(CreateLayerInstrumentDef(layer)); }
#endif
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutBool("Transposition: ", GetTranspose());
        DebugOutBool("Chromatic Transposition:" , GetTransposeChromatic());
        DebugOutBool("Transposition - Set to clef: ", GetTransposeUseClef());
        DebugOutBool("Transposition - Simplify key: ", GetTransposeSimplifyKey());
        DebugOutInt("Transposition - Alteration: ", GetTransposeAlteration());
        DebugOutInt("Transposition - Interval: ", GetTransposeInterval());
        DebugOutHex("topLines :", ((EDTStaffSpec2010*)_GetStaffSpec())->topLines);
        DebugOutHex("botLines :", ((EDTStaffSpec2010*)_GetStaffSpec())->botLines);
        DebugOutInt("drumStaffCmper: ", ((EDTStaffSpec2010*)_GetStaffSpec())->drumStaffCmper);
    }
#endif
 
};
 
class FCNoteEntry;
class FCCell;
 
class FCCurrentStaffSpec : public FCStaff
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool Load([[maybe_unused]]CMPER itemno) override { return false; }
 
    bool SaveAs([[maybe_unused]]CMPER itemno) override { return false; }
 
    bool SaveNew() override { return false; }
    
    CMPER GetItemNo() const override { return GetConnectedStaff(); }
 
    EXTAG Tag() const override { return ot_EDTCurrStaffSpec; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCurrentStaffSpec"; }
 
#ifdef PDK_FRAMEWORK_ENTRIES
    bool LoadForEntry(const FCNoteEntry* pNoteEntry);
#endif
 
    bool LoadForCell(FCCell* pCell, TimeEdu32 durationpos);
 
    int GetConnectedDurationPos() const { return _dataid.staffSpec.eduPos; }
 
    int GetConnectedMeasure() const { return _dataid.staffSpec.measNum; }
 
    int GetConnectedStaff() const { return _dataid.staffSpec.staffNum; }
};
 
 
class FCArticulation;
 
class FCArticulationDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTArticulationDefinition _articdefold;
 
#if FXT_VERSION >= FINALEVERSION_2012
#if FXT_VERSION >= FINALEVERSION_26
    typedef EDTArticulationDefinition25_6 CurrEDTArticulationDefinition;
#else
    typedef EDTArticulationDefinition2012 CurrEDTArticulationDefinition;
#endif
    CurrEDTArticulationDefinition _articdefCurr;
#endif
 
    bool Use2012Version() const;
 
    mutable EFONTNAME _mainsymbolfontname;      /* For return value only */
    mutable EFONTNAME _flippedsymbolfontname;   /* For return value only */
 
    const FLAG_16* _GetFlag1Ptr() const;
    const FLAG_16* _GetFlag2Ptr() const;
    const twobyte* _GetMainShapePtr() const;
    const twobyte* _GetFlippedShapePtr() const;
    const twobyte* _GetStartTopNotePtr() const;
    const twobyte* _GetStartBotNotePtr() const;
    const twobyte* _GetDurTopNotePtr() const;
    const twobyte* _GetDurBotNotePtr() const;
    const twobyte* _GetAmpTopNotePtr() const;
    const twobyte* _GetAmpBotNotePtr() const;
    const Evpu16* _GetDefaultVerticalPosPtr() const;
    const Evpu16* _GetMainHandleVerticalOffsetPtr() const;
    const Evpu16* _GetMainHandleHorizontalOffsetPtr() const;
    const Evpu16* _GetFlippedHandleVerticalOffsetPtr() const;
    const Evpu16* _GetFlippedHandleHorizontalOffsetPtr() const;
 
    bool _GetFlag1State(FLAG_16 state) const { return GetBitFlag(*_GetFlag1Ptr(), state); }
    void _SetFlag1State(FLAG_16 flagbits, bool state)
    {
        FLAG_16* pData = (FLAG_16*) _GetFlag1Ptr();
        Set16BitFlag(pData, flagbits, state);
    }
    bool _GetFlag2State(FLAG_16 state) const { return GetBitFlag(*_GetFlag2Ptr(), state); }
    void _SetFlag2State(FLAG_16 flagbits, bool state)
    {
        FLAG_16* pData = (FLAG_16*) _GetFlag2Ptr();
        Set16BitFlag(pData, flagbits, state);
    }
    
protected:
    EXTAG Tag() const override { return ot_ArticulationDefinition; }
    int DataSizeLoad() const override;
    void* Allocate() override;
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(_GetArticDef(), ((FCArticulationDef*)pSource)->_GetArticDef(), DataSizeLoad());
        _datablock = _GetArticDef();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCArticulationDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    enum ARTPOSITIONING_SIDES {
        ARTPOS_MANUAL_POSITIONING,
        ARTPOS_AUTO_NOTESTEM,
        ARTPOS_ALWAYS_NOTE_SIDE,
        ARTPOS_ALWAYS_STEM_SIDE,
        ARTPOS_BELOW_ENTRY,
        ARTPOS_ABOVE_ENTRY,
        ARTPOS_ALWAYS_ON_STEM
    };
    
    enum ARTSLUR_INTERACTION {
        ARTSLURINT_IGNORE,
        ARTSLURINT_INSIDE,
        ARTSLURINT_AUTO_INOUT
    };
 
 
    const char* ClassName() const override { return "FCArticulationDef"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_ARTICULATIONDEF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetArticDef() { return Allocate(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCArticulationDef() : __FCNoInciOther()
    {
        memset(_GetArticDef(), 0, DataSizeLoad());
        _datablock = _GetArticDef();
        _loadedsize = DataSizeLoad();
    }
 
    bool GetOnScreenOnly() const { return _GetFlag1State(ARTIC_NOPRINT); }
 
    FCFontInfo* CreateMainSymbolFontInfo() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateMainSymbolFontInfo_GC() const
    { return makeLuaSharedPtr(CreateMainSymbolFontInfo()); }
#endif
 
    FCFontInfo* CreateFlippedSymbolFontInfo() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateFlippedSymbolFontInfo_GC() const
    { return makeLuaSharedPtr(CreateFlippedSymbolFontInfo()); }
#endif
 
    eUniChar32 GetAboveSymbolChar() const
    {
        if (GetAboveUsesMain())
            return GetMainSymbolChar();
        else
            return GetFlippedSymbolChar();
    }
 
    eUniChar32 GetBelowSymbolChar() const
    {
        if (GetBelowUsesMain())
            return GetMainSymbolChar();
        else
            return GetFlippedSymbolChar();
    }
 
 
    eUniChar32 GetMainSymbolChar() const;
 
    twobyte GetMainSymbolShapeID() const { return GetMainSymbolIsShape() ? *_GetMainShapePtr() : 0; }
 
    eUniChar32 GetFlippedSymbolChar() const;
 
    twobyte GetFlippedSymbolShapeID() const { return GetFlippedSymbolIsShape() ? *_GetFlippedShapePtr() : 0; }
 
    std::string GetMainSymbolFont() const;
    
    const EFONTID GetMainSymbolFontID() const;
 
    std::string GetFlippedSymbolFont() const;
    
    const EFONTID GetFlippedSymbolFontID() const;
 
    twobyte GetMainSymbolSize() const;
 
    twobyte GetFlippedSymbolSize() const;
 
    bool GetAboveUsesMain() const { return !_GetFlag1State(ARTIC_ABOVE_SYMBOL); }
 
    bool GetBelowUsesMain() const { return !_GetFlag1State(ARTIC_BELOW_SYMBOL); }
 
    bool GetCopyMainSymbol() const { return _GetFlag1State(ARTIC_IMRKITERANT); }
 
    bool GetCopyMainSymbolHorizontally() const { return _GetFlag1State(ARTIC_HORZITERANT); }
 
    bool GetPlayback() const { return _GetFlag2State(ARTIC_PLAY); }
 
    bool GetAttackIsPercent() const { return _GetFlag2State(ARTIC_START_IS_PERCENT); }
 
    twobyte GetTopAttack() const { return *_GetStartTopNotePtr(); }
 
    twobyte GetBottomAttack() const { return *_GetStartBotNotePtr(); }
 
    bool GetDurationIsPercent() const { return _GetFlag2State(ARTIC_DUR_IS_PERCENT); }
 
    twobyte GetTopDuration() const { return *_GetDurTopNotePtr(); }
 
    twobyte GetBottomDuration() const { return *_GetDurBotNotePtr(); }
 
    bool GetVelocityIsPercent() const { return _GetFlag2State(ARTIC_AMP_IS_PERCENT); }
 
    twobyte GetTopVelocity() const { return *_GetAmpTopNotePtr(); }
 
    twobyte GetBottomVelocity() const { return *_GetAmpBotNotePtr(); }
 
    twobyte GetOnStemDistanceFromStemEnd() const;
 
    bool GetAvoidStaffLines() const { return _GetFlag2State(ARTIC_AVOID_STAFF_LINES); }
 
    bool GetAlwaysPlaceOutsideStaff() const { return _GetFlag1State(ARTIC_OUTSIDESTAFF); }
 
    bool GetCenterHorizontally() const { return _GetFlag1State(ARTIC_AUTOHORZ); }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ARTSLUR_INTERACTION
#else
    int
#endif
    GetSlurInteraction() const;
 
    bool GetInsideSlurs() const { return _GetFlag1State(ARTIC_INSIDE_SLUR); }
 
    bool GetAttachToTopNote() const { return _GetFlag1State(ARTIC_USETOPNOTE); }
 
    bool GetStackAutomatically() const;
 
    bool GetCenterOnStemWhenStemSide() const;
 
    bool GetStemSideWhenMultipleLayers() const;
 
    Evpu16 GetDefaultVerticalPos() const { return *_GetDefaultVerticalPosPtr(); }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ARTPOSITIONING_SIDES
#else
    int
#endif
    GetAutoPosSide() const;
 
    Evpu16 GetMainHandleVerticalOffset() const { return *_GetMainHandleVerticalOffsetPtr(); }
 
    Evpu16 GetMainHandleHorizontalOffset() const { return *_GetMainHandleHorizontalOffsetPtr(); }
 
    Evpu16 GetFlippedHandleVerticalOffset() const { return *_GetFlippedHandleVerticalOffsetPtr(); }
 
    Evpu16 GetFlippedHandleHorizontalOffset() const { return *_GetFlippedHandleHorizontalOffsetPtr(); }
 
    bool GetMainSymbolIsShape() const { return _GetFlag2State(ARTIC_MAIN_IS_SHAPE); }
 
     bool GetFlippedSymbolIsShape() const { return _GetFlag2State(ARTIC_FLIPPED_IS_SHAPE); }
 
     bool IsShapeUsed()
     {
        if (GetAboveUsesMain())
        {
            if (GetMainSymbolIsShape()) return true;
        }
        else
        {
            if (GetFlippedSymbolIsShape()) return true;
        }
        if (GetBelowUsesMain())
        {
            if (GetMainSymbolIsShape()) return true;
        }
        else
        {
            if (GetFlippedSymbolIsShape()) return true;
        }
        return false;
     }
 
    bool IsMainSymbolFont(const char* pszFontName) const;
 
    bool IsFlippedSymbolFont(const char* pszFontName) const;
 
    bool IsIdenticalTo(const FCArticulationDef& compareWith, bool playbackinfo, bool positioningvalues, bool positioningoptions, bool defaultside) const;
            
    void GetMainSymbolFontInfo(FCFontInfo* pFontInfo) const;
 
    void GetFlippedSymbolFontInfo(FCFontInfo* pFontInfo) const;
 
    void SetOnScreenOnly(bool state) { _SetFlag1State(ARTIC_NOPRINT, state); }
 
    void SetMainSymbolFontInfo(FCFontInfo* pFontInfo);
 
    void SetFlippedSymbolFontInfo(FCFontInfo* pFontInfo);
 
    void SetMainSymbolSize(twobyte size);
 
    void SetFlippedSymbolSize(twobyte size);
 
    void SetMainSymbolFont(const std::string& pszFontName);
    
    void SetMainSymbolFontID(EFONTID fontid);
 
    void SetFlippedSymbolFont(const std::string& pszFontName);
    
    void SetFlippedSymbolFontID(EFONTID fontid);
 
    void SetAboveSymbolChar(eUniChar32 symbol)
    {
        if (GetAboveUsesMain())
            SetMainSymbolChar(symbol);
        else
            SetFlippedSymbolChar(symbol);
    }
 
    void SetBelowSymbolChar(eUniChar32 symbol)
    {
        if (GetBelowUsesMain())
            SetMainSymbolChar(symbol);
        else
            SetFlippedSymbolChar(symbol);
    }
 
 
    void SetMainSymbolChar(eUniChar32 symbol)
    {
        if (Use2012Version())
        {
#if FXT_VERSION >= FINALEVERSION_2012
            _articdefCurr.charMain = symbol;
#endif            
        }
        else
        {
            _articdefold.efxsymbolMain &= 0xff00;
            _articdefold.efxsymbolMain |= (symbol & 0xff);
        }
    }
 
    void SetMainSymbolIsShape(bool useshape)
    {
        _SetFlag2State(ARTIC_MAIN_IS_SHAPE, useshape); 
    }
 
    void SetFlippedSymbolIsShape(bool useshape)
    {
        _SetFlag2State(ARTIC_FLIPPED_IS_SHAPE, useshape);
    }
 
    void SetMainSymbolShapeID(CMPER shapeID)
    {
        CMPER* pValue = (CMPER*) _GetMainShapePtr();
        *pValue = shapeID;
    }
 
    void SetFlippedSymbolShapeID(twobyte shapeID)
    {
        CMPER* pValue = (CMPER*) _GetFlippedShapePtr();
        *pValue = shapeID;
    }
 
    void SetFlippedSymbolChar(eUniChar32 symbol)
    {
        if (Use2012Version())
        {
#if FXT_VERSION >= FINALEVERSION_2012
            _articdefCurr.charAlt = symbol;
#endif
        }
        else
        {
            _articdefold.efxsymbolFlipped &= 0xff00;
            _articdefold.efxsymbolFlipped |= (symbol & 0xff);
        }
    }
 
    void SetAboveUsesMain(bool state) { _SetFlag1State(ARTIC_ABOVE_SYMBOL, !state); }
 
    void SetBelowUsesMain(bool state) { _SetFlag1State(ARTIC_BELOW_SYMBOL, !state); }
 
    void SetCopyMainSymbol(bool state) { _SetFlag1State(ARTIC_IMRKITERANT, state); }
 
    void SetCopyMainSymbolHorizontally(bool state) { _SetFlag1State(ARTIC_HORZITERANT, state); }
 
    void SetPlayback(bool state) { _SetFlag2State(ARTIC_PLAY, state); }
 
    void SetAttackIsPercent(bool state) { _SetFlag2State(ARTIC_START_IS_PERCENT, state); }
 
    void SetTopAttack(twobyte value) 
    {
        twobyte* pValue = (twobyte*) _GetStartTopNotePtr();
        *pValue = value;
    }
 
    void SetBottomAttack(twobyte value) 
    {
        twobyte* pValue = (twobyte*) _GetStartBotNotePtr();
        *pValue = value;
    }
 
    void SetAutoPosSide(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                ARTPOSITIONING_SIDES mode
#else
                int mode
#endif
    );
 
    void SetAlwaysPlaceOutsideStaff(bool state) { _SetFlag1State(ARTIC_OUTSIDESTAFF, state); }
 
    void SetCenterHorizontally(bool state) { _SetFlag1State(ARTIC_AUTOHORZ, state); }
 
    void SetAvoidStaffLines(bool state) { _SetFlag2State(ARTIC_AVOID_STAFF_LINES, state); }
 
    void SetSlurInteraction(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                ARTSLUR_INTERACTION mode
#else
                int mode
#endif
    );
 
    void SetInsideSlurs(bool state) { _SetFlag1State(ARTIC_INSIDE_SLUR, state); }
 
    void SetAttachToTopNote(bool state) { _SetFlag1State(ARTIC_USETOPNOTE, state); }
 
    void SetStackAutomatically(bool state);
 
    void SetCenterOnStemWhenStemSide(bool state);
 
    void SetStemSideWhenMultipleLayers(bool state);
 
    void SetDefaultVerticalPos(Evpu16 value)
    {
        Evpu16* pValue = (Evpu16*) _GetDefaultVerticalPosPtr();
        *pValue = value;
    }
 
    void SetMainHandleVerticalOffset(Evpu16 value)
    {
        Evpu16* pValue = (Evpu16*) _GetMainHandleVerticalOffsetPtr();
        *pValue = value;
    }
 
    void SetMainHandleHorizontalOffset(Evpu16 value)
    {
        Evpu16* pValue = (Evpu16*) _GetMainHandleHorizontalOffsetPtr();
        *pValue = value;
    }
 
    void SetFlippedHandleVerticalOffset(Evpu16 value)
    {
        Evpu16* pValue = (Evpu16*) _GetFlippedHandleVerticalOffsetPtr();
        *pValue = value;
    }
 
    void SetFlippedHandleHorizontalOffset(Evpu16 value) 
    {
        Evpu16* pValue = (Evpu16*) _GetFlippedHandleHorizontalOffsetPtr();
        *pValue = value;
    }
            
    void SetTopDuration(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetDurTopNotePtr();
        *pValue = value;        
    }
 
    void SetBottomDuration(twobyte value) 
    {
        twobyte* pValue = (twobyte*) _GetDurBotNotePtr();
        *pValue = value;        
    }
 
    void SetDurationIsPercent(bool value) { _SetFlag2State(ARTIC_DUR_IS_PERCENT, value); }
 
    void SetTopVelocity(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetAmpTopNotePtr();
        *pValue = value;
    }
 
    void SetBottomVelocity(twobyte value) 
    {
        twobyte* pValue = (twobyte*) _GetAmpBotNotePtr();
        *pValue = value;
    }
 
    void SetOnStemDistanceFromStemEnd(twobyte value);
 
    void SetVelocityIsPercent(bool value) { _SetFlag2State(ARTIC_AMP_IS_PERCENT, value); }
    
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        std::unique_ptr<FCString> fontStr(std::unique_ptr<FCFontInfo>(CreateMainSymbolFontInfo())->CreateDescription());
        DebugOutInt("Main symbol char: ", GetMainSymbolChar());
        DebugOutString("Main symbol font: ", fontStr->GetCString());
    }
#endif
 
};
 
 
class FCCategoryDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTMarkingCategory _categorydefold;
    
    friend struct __FCEDTMarkingCategoryRaw;
    
#if FXT_VERSION >= FINALEVERSION_2012
    EDTMarkingCategory2012 _categorydef2012;
#endif
    
    bool _Use2012Version() const;
 
    const FLAG_16* _GetFlagPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.categoryFlags;
#endif
        return &_categorydefold.categoryFlags;
    }
    
    const twobyte* _GetCatIDPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.catID;
#endif
        return &_categorydefold.catID;
    }
    
    const twobyte* _GetCatTypePtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.categoryType;
#endif
        return &_categorydefold.categoryType;;
    }
 
    const twobyte* _GetStaffListPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.staffList;
#endif
        return &_categorydefold.staffList;
    }
    
    const twobyte* _GetVertAlignPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.vertAlign;
#endif
        return &_categorydefold.vertAlign;
    }
 
    const twobyte* _GetVertOffsetBaseLinePtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.vertOffsetBaseline;
#endif
        return &_categorydefold.vertOffsetBaseline;
    }
 
    const twobyte* _GetVertOffsetEntryPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.vertOffsetEntry;
#endif
        return &_categorydefold.vertOffsetEntry;
    }
    
    const twobyte* _GetJustificationPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.justification;
#endif
        return &_categorydefold.justification;
    }
    
    const twobyte* _GetHorzAlignPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.horzAlign;
#endif
        return &_categorydefold.horzAlign;
    }
    
    const twobyte* _GetHorzOffsetPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.horzOffset;
#endif
        return &_categorydefold.horzOffset;
    }
    
    const EEnigmaFont* _GetTextFontPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.textFont;
#endif
        return &_categorydefold.textFont;
    }
    
    const EEnigmaFont* _GetMusicFontPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.musicFont;
#endif
        return &_categorydefold.musicFont;
    }
 
    const EEnigmaFont* _GetNumberFontPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.numberFont;
#endif
        return &_categorydefold.numberFont;
    }
    
    bool _GetFlagState(FLAG_16 state) const
    {
        FLAG_16* pValue = (FLAG_16*) _GetFlagPtr();
        return GetBitFlag(*pValue, state);
    }
    
    void _SetFlagState(FLAG_16 mask, bool state)
    {
        FLAG_16* pValue = (FLAG_16*) _GetFlagPtr();
        return Set16BitFlag(pValue, mask, state);
    }
    
    bool DeleteData() override
    { return false; } // prevent deletion
    
    bool SaveNew() override
    { return false; } // prevent raw SaveNew call
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return ot_MarkingCategory; }
    
    int DataSizeLoad() const override
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return sizeof(EDTMarkingCategory2012);
#endif
        return sizeof(EDTMarkingCategory);
    }
    
    void* Allocate() override
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return (void*) &_categorydef2012;
#endif
        return (void*) &_categorydefold;
    }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(_GetCategoryDef(), ((FCCategoryDef*)pSource)->_GetCategoryDef(), DataSizeLoad());
        _datablock = _GetCategoryDef();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCCategoryDef(); }
 
    // Class doesn't yet support Unicode
    EVERSION EnigmaVersion() const override
    {
        if (_Use2012Version()) return FINALEVERSION_2012;
        return FINALEVERSION_2010;
    }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
        enum CATEGORY_DEFAULTIDS
        {
                DEFAULTCATID_DYNAMICS = 1,
 
                DEFAULTCATID_TEMPOMARKS = 2,
 
                DEFAULTCATID_TEMPOALTERATIONS = 3,
 
                DEFAULTCATID_EXPRESSIVETEXT = 4,
 
                DEFAULTCATID_TECHNIQUETEXT = 5,
 
                DEFAULTCATID_REHEARSALMARK = 6
        };
 
 
    enum CATEGORY_MODE
    {
        CATEGORYMODE_NONE = 0,
 
        CATEGORYMODE_TEXT = 1,
 
        CATEGORYMODE_MUSIC = 2,
 
        CATEGORYMODE_NUMBER = 3
    };
 
    const char* ClassName() const override { return "FCCategoryDef"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CATEGORYDEF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetCategoryDef() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    enum VERT_ALIGNMENT
    {
        ALIGNVERT_CLICKPOS = 2,
 
        ALIGNVERT_STAFF_REFERENCE_LINE = 3,
 
        ALIGNVERT_ABOVE_STAFF_BASELINE = 0,
 
        ALIGNVERT_BELOW_STAFF_BASELINE = 1,
 
        ALIGNVERT_TOPNOTE = 4,
 
        ALIGNVERT_BOTTOMNOTE = 5,
 
        ALIGNVERT_ABOVEENTRY = 6,
 
        ALIGNVERT_BELOWENTRY = 7,
 
        ALIGNVERT_ABOVE_STAFF_BASELINE_OR_ENTRY = 8,
 
        ALIGNVERT_BELOW_STAFF_BASELINE_OR_ENTRY = 9
    };
 
    enum HORIZ_ALIGNMENT
    {
        ALIGNHORIZ_CLICKPOS = 3,
 
        ALIGNHORIZ_LEFTOFALLNOTEHEAD = 9,
 
        ALIGNHORIZ_LEFTOFPRIMARYNOTEHEAD = 13,
 
        ALIGNHORIZ_STEM = 10,
 
        ALIGNHORIZ_CENTERPRIMARYNOTEHEAD = 11,
 
        ALIGNHORIZ_CENTERALLNOTEHEADS = 12,
 
        ALIGNHORIZ_RIGHTALLNOTEHEADS = 14,
 
        ALIGNHORIZ_LEFTBARLINE = 0,
 
        ALIGNHORIZ_TIMESIGSTART = 1,
 
        ALIGNHORIZ_AFTERCLEFKEYTIMEREPEAT = 2,
 
        ALIGNHORIZ_STARTOFMUSIC = 7,
 
        ALIGNHORIZ_CENTERBETWEENBARLINES = 4,
 
        ALIGNHORIZ_CENTEROVERUNDERMUSIC = 5,
 
        ALIGNHORIZ_RIGHTBARLINE = 6,
 
    };
 
    enum HORIZ_JUSTIFICATION
    {
        EXPRJUSTIFY_LEFT = 0,       
 
        EXPRJUSTIFY_CENTER = 1,
 
        EXPRJUSTIFY_RIGHT  = 2
    };
 
    FCCategoryDef() : __FCNoInciOther()
    {
        memset(_GetCategoryDef(), 0, DataSizeLoad());
        _datablock = _GetCategoryDef();
        _loadedsize = DataSizeLoad();
    }
 
    bool IsIdentical(const __FCBase* pObject) const override
    {
        const FCCategoryDef* pOtherCategory = dynamic_cast<const FCCategoryDef*>(pObject);
        if (!pOtherCategory) return false;
        if (pOtherCategory->GetID() != GetID()) return false;
        if (*pOtherCategory->_GetFlagPtr() != *_GetFlagPtr()) return false;
        FCString thisname, othername;
        pOtherCategory->GetName(&othername);
        GetName(&thisname);
        return othername.IsEqualString(thisname);
    }
 
    bool GetBreakMMRest() const
    {
        return _GetFlagState(MC_BREAK_MMREST);
    }
 
    bool GetOverrideStaffList() const
    {        
        return _GetFlagState(MC_USES_STAFF_LIST);
    }
 
    twobyte GetID() const
    {
        return *_GetCatIDPtr();
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    CATEGORY_DEFAULTIDS
#else
    twobyte
#endif
    GetType() const
    {
        return static_cast<CATEGORY_DEFAULTIDS>(*_GetCatTypePtr());
    }
    
    bool SaveNewWithType(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    CATEGORY_DEFAULTIDS
#else
    int
#endif
    type);
 
    twobyte GetStaffListID() const
    {
        return *_GetStaffListPtr();
    }
 
    void GetName(FCString* pString) const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            pString->SetUnicodeString(_categorydef2012.name);
            return;
        }
#endif
        pString->SetCString(_categorydefold.name);
    }
 
    FCString* CreateName() 
    {
        FCString* pString = new FCString();
        GetName(pString);
        return pString;
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateName_GC()
    { return makeLuaSharedPtr(CreateName()); }
#endif
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    VERT_ALIGNMENT 
#else
    int
#endif
    GetVerticalAlignmentPoint() const { return (VERT_ALIGNMENT) *_GetVertAlignPtr(); }
 
    twobyte GetVerticalBaselineOffset() const { return *_GetVertOffsetBaseLinePtr(); }
 
    twobyte GetVerticalEntryOffset() const { return *_GetVertOffsetEntryPtr(); }
 
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    HORIZ_JUSTIFICATION
#else
    int
#endif
    GetHorizontalJustification() const
    {
        return (HORIZ_JUSTIFICATION) *_GetJustificationPtr();
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    HORIZ_ALIGNMENT 
#else
    int
#endif
    GetHorizontalAlignmentPoint() const
    {
        return (HORIZ_ALIGNMENT) *_GetHorzAlignPtr();
    }
 
    twobyte GetHorizontalOffset() const
    {
        return *_GetHorzOffsetPtr();
    }
 
    bool GetTextFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesTextFont()) return false;
        pInfo->ParseEnigmaFont(_GetTextFontPtr());
        return true;
    }
 
    bool GetMusicFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesMusicFont()) return false;
        pInfo->ParseEnigmaFont(_GetMusicFontPtr());
        return true;
    }
 
    bool GetNumberFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesNumberFont()) return false;
        pInfo->ParseEnigmaFont(_GetNumberFontPtr());
        return true;
    }
 
 
    bool SetTextFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesTextFont()) return false;
        EEnigmaFont* pFont = (EEnigmaFont*) _GetTextFontPtr();
        pFont->font = pInfo->GetIDByName();
        pFont->efx = pInfo->GetEnigmaStyles();
        pFont->size = pInfo->GetSize();
        return true;
    }
 
    bool SetMusicFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesMusicFont()) return false;
        EEnigmaFont* pFont = (EEnigmaFont*) _GetMusicFontPtr();
        pFont->font = pInfo->GetIDByName();
        pFont->efx = pInfo->GetEnigmaStyles();
        pFont->size = pInfo->GetSize();
        return true;
    }
 
    bool SetNumberFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesNumberFont()) return false;
        EEnigmaFont* pFont = (EEnigmaFont*) _GetNumberFontPtr();
        pFont->font = pInfo->GetIDByName();
        pFont->efx = pInfo->GetEnigmaStyles();
        pFont->size = pInfo->GetSize();
        return true;
    }
 
    void SetStaffListID(twobyte value)
    {
        twobyte* pStaffList = (twobyte*) _GetStaffListPtr();
        *pStaffList = value;
    }
 
    FCFontInfo* CreateTextFontInfo()
    {
        FCFontInfo* pFontInfo = new FCFontInfo();
        pFontInfo->ParseEnigmaFont(_GetTextFontPtr());
        return pFontInfo;
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateTextFontInfo_GC()
    { return makeLuaSharedPtr(CreateTextFontInfo()); }
#endif
 
    bool GetUserCreated() const
    {
        return _GetFlagState(MC_USER_CREATED);
    }
 
    bool IsDefaultMiscellaneous()
    {
        if (GetUserCreated()) return false;
        return GetID() == 7;
    }
 
    bool IsDefaultDynamics()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_DYNAMICS;
    }
 
    bool IsDefaultTempoMarks()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_TEMPOMARKS;
    }
 
    bool IsDefaultTempoAlterations()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_TEMPOALTERATIONS;
    }
 
    bool IsDefaultExpressiveText()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_EXPRESSIVETEXT;
    }
 
    bool IsDefaultTechniqueText()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_TECHNIQUETEXT;
    }
 
    bool IsDefaultRehearsalMarks()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_REHEARSALMARK;
    }
 
    bool UsesStaffList() { return _GetFlagState(MC_STAFFLIST); }
 
    bool UsesTextFont() { return _GetFlagState(0x0001); }  /* For some reason MC_OVERRIDE_TEXT_FONT doesn't work*/
 
    bool UsesMusicFont() { return _GetFlagState(0x0002); } /* For some reason MC_OVERRIDE_MUSIC_FONT doesn't work*/
 
    bool UsesNumberFont() { return _GetFlagState(0x0004); }  /* For some reason MC_OVERRIDE_NUMBER_FONT doesn't work*/
 
    void SetName(FCString* pString) 
    {
        if (!pString) return;
        /* Make sure there isn't any overflow of the text */
        FCString tempstring;
        tempstring.SetString(pString);
        tempstring.TruncateAt(63);
        /* Copy the text */
        if (_Use2012Version())
        {
#if FXT_VERSION >= FINALEVERSION_2012
            int len = tempstring.GetLength();
            memcpy(_categorydef2012.name, tempstring._GetUnicodeBuffer(), (len + 1) * sizeof (eUniChar16));
            _categorydef2012.name[len] = 0; /* For safety add a NULL */
#endif
        }
        else
        {
            strcpy(_categorydefold.name, tempstring.GetCString());
        }
    }
 
    void SetVerticalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    VERT_ALIGNMENT
#else
    twobyte
#endif
    value
    )
    {
        twobyte* pAlign = (twobyte*) _GetVertAlignPtr();
        *pAlign = (twobyte) value;
    }
 
    void SetUserCreated(bool value) { _SetFlagState(MC_USER_CREATED, value); }
 
    void SetBreakMMRest(bool state)
    {
        _SetFlagState(MC_BREAK_MMREST, state);
    }
 
    void SetOverrideStaffList(bool state)
    {
        _SetFlagState(MC_USES_STAFF_LIST, state);
    }
 
        void SetID(twobyte catID)
        {
                twobyte* pData = (twobyte*) _GetCatIDPtr();
                *pData = catID;
        }
 
    void SetVerticalBaselineOffset(twobyte value)
    {
        twobyte* pVertOffsetBase = (twobyte*) _GetVertOffsetBaseLinePtr();
        *pVertOffsetBase = value;
    }
 
    void SetVerticalEntryOffset(twobyte value)
    {
        twobyte* pOffset = (twobyte*) _GetVertOffsetEntryPtr();
        *pOffset = value;
    }
 
    void SetHorizontalJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    HORIZ_JUSTIFICATION
#else
    int
#endif
    value)
    {
        switch (value)
        {
            case EXPRJUSTIFY_LEFT:
            case EXPRJUSTIFY_CENTER:
            case EXPRJUSTIFY_RIGHT:
                break;
            default:
                return;
        }
        twobyte* pJustification = (twobyte*) _GetJustificationPtr();
        *pJustification = value;
    }
 
 
    void SetHorizontalOffset(twobyte value)
    {
        twobyte* pHorizontalOffset = (twobyte*) _GetHorzOffsetPtr();
        *pHorizontalOffset = value;
    }
 
    void SetHorizontalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    HORIZ_ALIGNMENT
#else
    twobyte
#endif
    value
    )
    {
        twobyte* pHorizAlign = (twobyte*) _GetHorzAlignPtr();
        *pHorizAlign = (twobyte) value;
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Category ID: ", GetID());
        DebugOutBool("User created: ", GetUserCreated());
        FCString string;
        GetName(&string);
        DebugOutString("Name: ", string.GetCString());
    }
#endif
};
 
 
 
 
class FCFreezeSystem : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTFreezeMeasures _freezemeasures;
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return ot_FreezeMeasures; }
    int DataSizeLoad() const override { return sizeof(EDTFreezeMeasures); }
    void* Allocate() override { return (void*) &_freezemeasures; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_freezemeasures, ((FCFreezeSystem*)pSource)->_GetFreezeMeasures(), sizeof(_freezemeasures));
        _datablock = &_freezemeasures;
        _loadedsize = sizeof(_freezemeasures);
    }
 
    __FCBaseData* CreateObject() override { return new FCFreezeSystem(); }
 
    // Doesn't support First/Next
    bool LoadFirst() override { return false; }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCFreezeSystem"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_FREEZESYSTEM; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetFreezeMeasures() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCFreezeSystem() : __FCNoInciOther()
    {
        memset(&_freezemeasures, 0, sizeof(_freezemeasures));
        _freezemeasures.mode = 1;
        _datablock = &_freezemeasures;
        _loadedsize = sizeof(_freezemeasures);
    }
 
    void SetNextSysMeasure(twobyte measure) { _freezemeasures.measure = measure; }
 
    twobyte GetNextSysMeasure() const { return _freezemeasures.measure; }
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Next system measure: ", GetNextSysMeasure());
    }
#endif
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
// missing playback type defines
#define _EXP_NO_PLAYBACK 0x00
#define _EXP_MIDI_PERCUSSION_MAP 0x13
#define _EXP_SWING 0x0e
#define _EXP_HUMAN_PLAYBACK_ON 0x10
#define _EXP_HUMAN_PLAYBACK_OFF 0x11
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
class FCTextExpressionDef : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if FXT_VERSION >= FINALEVERSION_2012
    typedef EDTTextExpression2012 CurrEDTTextExpression;
#else
    typedef EDTTextExpression2004 CurrEDTTextExpression;
#endif
    CurrEDTTextExpression _nullexpression;  /* A data block for when the _datablock is NULL.
                                             This should never be accessed directly. It's only
                                             available to prevent crashes. */
    CurrEDTTextExpression* _TypeCast() const
    {
        if (!_datablock) return (CurrEDTTextExpression*) &_nullexpression;
        return (CurrEDTTextExpression*)_datablock;
    }
 
    void _AllocateMemory(int size);
protected:
    EXTAG Tag() const override { return ot_TextExpression; }
    EVERSION EnigmaVersion() const override;
 
    int DataSizeLoad() const override;
    int DataSizeSave() const override;
    void* Allocate() override;
    void Deallocate() override;
    bool IsDynamicSize() override { return true; }
 
    __FCBaseData* CreateObject() override { return new FCTextExpressionDef(); }
 
    bool LoadNext() override
    {
        return Load(GetItemNo() + 1); // FX_NextEData can sometimes cause problems!!!
    }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    enum REHEARSALMARK_STYLES
    {
        REHMARKSTYLE_MANUAL = FX_EXPR_REHEARSAL_MANUAL,
 
        REHMARKSTYLE_LETTER = FX_EXPR_REHERASAL_LETTERS,
 
        REHMARKSTYLE_LETNUM = FX_EXPR_REHEARSAL_LETNUM,
 
        REHMARKSTYLE_LETTER_LC = FX_EXPR_REHEARSAL_LETTERS_LC,
 
        REHMARKSTYLE_LETNUM_LC = FX_EXPR_REHEARSAL_LETNUM_LC,
 
        REHMARKSTYLE_NUMBER = FX_EXPR_REHEARSAL_NUMBERS,
 
        REHMARKSTYLE_MEASNUM = FX_EXPR_REHEARSAL_MEASNUM
    };
 
        enum EXPR_PLAYBACK_TYPES
        {
                EXPPLAYTYPE_UNKNOWN = 0,
 
                EXPPLAYTYPE_KEYVELOCITY = 1,
 
                EXPPLAYTYPE_TEMPO = 2,
        
        EXPPLAYTYPE_CONTROLLER = 3,
 
                EXPPLAYTYPE_TRANSPOSE = 4,
                
                EXPPLAYTYPE_MIDIDUMP = 5,
                
                EXPPLAYTYPE_MIDICHANNEL = 6,
                
                EXPPLAYTYPE_RESTRIKEKEYS = 7,
                
                EXPPLAYTYPE_PLAYTEMPOTOOL = 8,
 
                EXPPLAYTYPE_IGNORETEMPOTOOL = 9,
        
        EXPPLAYTYPE_PATCHCHANGE = 10,
        
        EXPPLAYTYPE_CHANNELPRESSURE = 11,
        
        EXPPLAYTYPE_PITCHWHEEL = 12,
        
        EXPPLAYTYPE_PERCUSSIONMAP = 13,
 
        EXPPLAYTYPE_SWING = 14,
        
        EXPPLAYTYPE_HUMANPLAYBACKON = 15,
        
        EXPPLAYTYPE_HUMANPLAYBACKOFF = 16,
        
        EXPPLAYTYPE_NONE = 100 // keep this last
        };
    
    const char* ClassName() const override { return "FCTextExpressionDef"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TEXTEXPRESSIONDEF; }
 
    FCTextExpressionDef();
 
    virtual ~FCTextExpressionDef();
 
    bool DeepSaveAs(CMPER itemno) override
    {
       FCString* pString = CreateTextString();
       SaveNewTextBlock(pString);
       delete pString;
 
       FCEnclosure* pEnclosure = CreateEnclosure();
       if (pEnclosure)
       {
           pEnclosure->SaveAs(itemno);
           delete pEnclosure;
       }
 
       return SaveAs(itemno);
    }
 
    bool DeepDeleteData() override;
    
 
    CMPER GetTextBlockID();
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    EXPR_PLAYBACK_TYPES
#else
    int
#endif
    GetPlaybackType() const;
 
        void SetPlaybackType(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    EXPR_PLAYBACK_TYPES
#else
    int
#endif
        playbackmode);
 
    bool GetUseExecutableShape() const
    {
        return GetBitFlag(_TypeCast()->flag, EXP_VALUEisEXEC);
    }
 
    twobyte GetExecutableShapeID() const
    {
        if (!GetUseExecutableShape()) return 0;
        return _TypeCast()->value;
    }
 
    void SetExecutableShapeID(twobyte shapeID)
    {
        _TypeCast()->value = shapeID;
        SetUseExecutableShape((shapeID != 0) ? true : false);
    }
 
    void SetUseExecutableShape(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, EXP_VALUEisEXEC, state);
    }
    
    bool GetHideMeasureNumbers() const
    {
        return GetBitFlag(_TypeCast()->flag, TEXT_EXP_HIDEMEASURENUM);
    }
    
    void SetHideMeasureNumbers(bool value)
    {
        Set16BitFlag(&_TypeCast()->flag, TEXT_EXP_HIDEMEASURENUM, value);
    }
 
    bool GetUseEnclosure() const
    {
        return GetBitFlag(_TypeCast()->flag, TEXT_EXP_NEWENCLOSURE);
    }
 
    void SetUseEnclosure(bool value)
    {
        Set16BitFlag(&_TypeCast()->flag, TEXT_EXP_NEWENCLOSURE, value);
    }
 
    twobyte GetCategoryID() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (_TypeCast()->category & 0x3fff);
#else
        return (_TypeCast()->measYadjust & 0x3fff); 
#endif
    }
 
    twobyte GetTextID() const { return (_TypeCast()->textIDKey); }
 
    twobyte GetPlaybackTempoValue()
    {
        if (!GetBitFlag(_TypeCast()->flag, EXP_USEauxDATA)) return 0;
                if (!IsPlaybackTempo()) return 0;
        return _TypeCast()->value;        
    }
 
    twobyte GetPlaybackTempoDuration()
    {
        if (!GetBitFlag(_TypeCast()->flag, EXP_USEauxDATA)) return 0;
                if (!IsPlaybackTempo()) return 0;
        return _TypeCast()->auxdata1;
    }
 
        twobyte GetPlaybackPass() const
        {
                return _TypeCast()->playPass;
        }
 
        void SetPlaybackPass(twobyte value)
        {
                _TypeCast()->playPass = value;
        }
 
        twobyte GetPlaybackKeyVelocity() const
        { 
                if (GetPlaybackType() != EXPPLAYTYPE_KEYVELOCITY) return 0;
                return _TypeCast()->value;
        }
 
        void SetPlaybackKeyVelocity(twobyte value)
        {
                if (value < 0) value = 0;
                if (value > 127) value = 127;
                SetPlaybackType(EXPPLAYTYPE_KEYVELOCITY);
                _TypeCast()->value = value;
        }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::VERT_ALIGNMENT 
#else 
    int
#endif
    GetVerticalAlignmentPoint() const
    {
        return (FCCategoryDef::VERT_ALIGNMENT) _TypeCast()->vertMeasExprAlign;
    }
 
    twobyte GetVerticalBaselineOffset() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return _TypeCast()->yAdjustBaseline;
#else
        return _TypeCast()->noteYadjustBaseline;
#endif
    }
 
    twobyte GetVerticalEntryOffset() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return _TypeCast()->yAdjustEntry;
#else
        return _TypeCast()->noteYadjustEntry;
#endif
 
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REHEARSALMARK_STYLES
#else 
    int
#endif
    GetRehearsalMarkStyle() const
    {
        return (REHEARSALMARK_STYLES) _TypeCast()->categorySpecific;
    }
 
    void SetRehearsalMarkStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REHEARSALMARK_STYLES
#else
    int
#endif
    value
    )
    {
        _TypeCast()->categorySpecific = value;
    }
 
    bool GetBreakMMRest() const
    {
        return GetBitFlag(_TypeCast()->flag, TEXT_EXP_BREAKREST);
    }
 
    void SetBreakMMRest(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, TEXT_EXP_BREAKREST, state);
    }
 
     void SetCategoryID(twobyte ID)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->category &= 0xc000;
        _TypeCast()->category |= (ID & 0x3fff);
#else
        _TypeCast()->measYadjust &= 0xc000;
        _TypeCast()->measYadjust |= (ID & 0x3fff);
#endif
    }
 
 
    void SetUseCategoryFont(bool value);
 
    void SetUseCategoryPos(bool value);
    
    twobyte GetPlaybackControllerValue() const
    {
        if (GetPlaybackType() == EXPPLAYTYPE_CONTROLLER)
            return _TypeCast()->value;
        return 0;
    }
    
    twobyte GetPlaybackControllerNumber() const
    {
        if (GetPlaybackType() == EXPPLAYTYPE_CONTROLLER)
            return _TypeCast()->auxdata1;
        return 0;
    }
 
    void SetPlaybackController(twobyte controllernumber, twobyte value)
    {
        Set16BitFlag(&_TypeCast()->flag, EXP_USEauxDATA, true);
        _TypeCast()->flag &= ~EXP_DYTYPEBITS;
        _TypeCast()->flag |= EXP_MIDI_CONTROLLER;
        _TypeCast()->value = value;
        _TypeCast()->auxdata1 = controllernumber;
    }
 
    void SetPlaybackTempo(TimeEdu32 eduduration, int tempo)
    {
        Set16BitFlag(&_TypeCast()->flag, EXP_USEauxDATA, true);
        _TypeCast()->flag &= ~EXP_DYTYPEBITS;
        _TypeCast()->flag |= EXP_TIME;
        _TypeCast()->value = tempo;
        _TypeCast()->auxdata1 = eduduration;
    }
    
    twobyte GetPlaybackTransposition() const
    {
        if (GetPlaybackType() == EXPPLAYTYPE_TRANSPOSE)
            return _TypeCast()->value;
        return 0;
    }
 
    void SetPlaybackTransposition(twobyte halfsteps)
    {
        SetPlaybackType(EXPPLAYTYPE_TRANSPOSE);
        _TypeCast()->value = halfsteps;
    }
    
    twobyte GetPitchWheelValue() const
    {
        if (GetPlaybackType() == EXPPLAYTYPE_PITCHWHEEL)
            return _TypeCast()->value - 8192;
        return 0;
    }
 
    void SetPitchWheelValue(twobyte value)
    {
        SetPlaybackType(EXPPLAYTYPE_PITCHWHEEL);
        _TypeCast()->value = (std::min)((std::max)(0, static_cast<int>(value) + 8192), 2*8192);
    }
 
    void SetVerticalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::VERT_ALIGNMENT
#else
    int
#endif
    value)
    {
        _TypeCast()->vertMeasExprAlign = (twobyte) value;
    }
 
    void SetVerticalBaselineOffset(twobyte value)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->yAdjustBaseline = value;
#else
        _TypeCast()->noteYadjustBaseline = value;
#endif
    }
 
    void SetVerticalEntryOffset(twobyte value)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->yAdjustEntry = value;
#else
        _TypeCast()->noteYadjustEntry = value;
#endif
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_JUSTIFICATION
#else
    int
#endif
    GetHorizontalJustification() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (FCCategoryDef::HORIZ_JUSTIFICATION) _TypeCast()->horzExprAlign;
#else
        return (FCCategoryDef::HORIZ_JUSTIFICATION) _TypeCast()->measExprAlign;
#endif
    }
 
    void SetHorizontalJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_JUSTIFICATION
#else
    int
#endif
    value)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->horzExprAlign = (twobyte) value;
#else
        _TypeCast()->measExprAlign = (twobyte) value;
#endif
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_ALIGNMENT
#else
    int
#endif
    GetHorizontalAlignmentPoint() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (FCCategoryDef::HORIZ_ALIGNMENT) _TypeCast()->horzMeasExprAlign;
#else
        return (FCCategoryDef::HORIZ_ALIGNMENT) _TypeCast()->measAlign;
#endif
    }
 
    void SetHorizontalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_ALIGNMENT
#else
    int
#endif
    value)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->horzMeasExprAlign = (twobyte) value;
#else
        _TypeCast()->measAlign = (twobyte) value;
#endif
    }
 
 
    twobyte GetHorizontalOffset() const
    {
        return _TypeCast()->measXadjust;
    }
 
    void SetHorizontalOffset(twobyte value)
    {
        _TypeCast()->measXadjust = value;
    }
 
     FCString* CreateTextString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateTextString_GC()
    { return makeLuaSharedPtr(CreateTextString()); }
#endif
 
     FCEnclosure* CreateEnclosure();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCEnclosure> CreateEnclosure_GC()
    { return makeLuaSharedPtr(CreateEnclosure()); }
#endif
 
     bool IsPlaybackTempo() const
     {
                 return (GetPlaybackType() == EXPPLAYTYPE_TEMPO);
     }
 
         bool IsSmartMusicMarker() const
         {
                 return false;
         }
 
         bool IsKeyVelocity() const
         {
                 return (GetPlaybackType() == EXPPLAYTYPE_KEYVELOCITY);
         }
 
     bool IsAutoRehearsalMark() const
         {
         return (GetRehearsalMarkStyle() != REHMARKSTYLE_MANUAL);
     }
 
     bool MakeRehearsalMark(FCString* pString, int measure);
 
     bool SaveTextString(FCString* pString);
 
     bool SaveNewTextBlock(FCString* pString);
 
     bool DeleteTextBlock();
 
     bool AssignToCategory(FCCategoryDef* pDef);
     
     bool GetUseCategoryFont() const;
     
     bool GetUseCategoryPos() const;
     
 
     void SetDescription(FCString* pDescriptionString);
 
     void GetDescription(FCString* pDescriptionString);
 
     FCString* CreateDescription();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateDescription_GC()
    { return makeLuaSharedPtr(CreateDescription()); }
#endif
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        FCString description;
        GetDescription(&description);
        DebugOutString("Description: ", description.GetCString());
        DebugOutInt("Category ID: ", GetCategoryID());
        FCString* pString = CreateTextString();
        DebugOutString("Rawstring: ", pString->GetCString());
        delete pString;
    }
#endif
};
 
 
 
class FCShapeExpressionDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _unicode;
 
    EDTShapeExpression2004* _TypeCast() const { return (EDTShapeExpression2004*)_datablock; }
    
    const char* _TypeCastTextPtr() const
    {
        if (_loadedsize <= 36) return NULL;
        char* pszReturn = (char*) _datablock;
        pszReturn += 36;  /* 3 full incis */
        return pszReturn;
    }
    
    void _AllocateMemory(int size);
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override {
        /* DataSizeLoad() sets the custom tag!!! */
        return GetCustomTag() ? GetCustomTag() : ot_ShapeExpression2004;
    }
    EVERSION EnigmaVersion() const override { return _unicode ? FINALEVERSION_2012 : FINALEVERSION_2010; }
    
    int DataSizeLoad() const override;
    int DataSizeSave() const override;
    void* Allocate() override;
    void Deallocate() override;
    bool IsDynamicSize() override { return true; }
  
    
    __FCBaseData* CreateObject() override { return new FCShapeExpressionDef(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:    
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    bool Load(CMPER cmper) override;
 
    bool Save() override;
 
    bool SaveNew() override;
 
    const char* ClassName() const override { return "FCShapeExpressionDef"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SHAPEEXPRESSIONDEF; }
 
    void* _GetShapeExpression() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCShapeExpressionDef();
 
    virtual ~FCShapeExpressionDef();
 
 
#ifdef PDK_FRAMEWORK_SHAPES
    bool LoadFirst() override { return Load(1); }
 
    bool LoadNext() override
    {
        if (!DataIsLoaded()) return false;
        return Load(GetItemNo() + 1);
    }
 
    FCShapeDef* CreateShapeDef();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCShapeDef> CreateShapeDef_GC()
    { return makeLuaSharedPtr(CreateShapeDef()); }
#endif
    
#endif // PDK_FRAMEWORK_SHAPES
    
    bool GetUseExecutableShape() const
    {
        return GetBitFlag(_TypeCast()->flag, EXP_VALUEisEXEC);
    }
 
 
    bool GetAllowHorizontalStretching() const
    {
        return !GetBitFlag(_TypeCast()->flag, SHAPE_EXP_LOCKDOWN);
    }
 
    bool GetNoPrint() const
    {
        return GetBitFlag(_TypeCast()->flag, SHAPE_EXP_NOPRINT);
    }
 
    bool GetBreakMMRest() const
    {
        return GetBitFlag(_TypeCast()->flag, SHAPE_EXP_BREAKMMREST);
    }
 
    twobyte GetExecutableShapeID()
    {
        if (!GetUseExecutableShape()) return 0;
        return _TypeCast()->value;
    }
 
    twobyte GetID() const
    {
        return _TypeCast()->shapedef;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_JUSTIFICATION
#else
    int
#endif
    GetHorizontalJustification() const
    {
        twobyte setting;  /* Shape expr def have another order than text expr defs */
#if FXT_VERSION >= FINALEVERSION_2014
        setting = (FCCategoryDef::HORIZ_JUSTIFICATION) _TypeCast()->horzExprAlign;
#else
        setting = (FCCategoryDef::HORIZ_JUSTIFICATION) _TypeCast()->measExprAlign;
#endif
        switch (setting)
        {
            case 0:
                return FCCategoryDef::EXPRJUSTIFY_LEFT;
            case 1:
                return FCCategoryDef::EXPRJUSTIFY_CENTER;
            default:
                return FCCategoryDef::EXPRJUSTIFY_RIGHT;
        }
 
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_ALIGNMENT
#else
    int
#endif
    GetHorizontalAlignmentPoint() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (FCCategoryDef::HORIZ_ALIGNMENT) _TypeCast()->horzMeasExprAlign;
#else
        return (FCCategoryDef::HORIZ_ALIGNMENT) _TypeCast()->measAlign;
#endif
    }
 
    bool GetUseCategoryPos() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
    return GetBitFlag(_TypeCast()->category, USE_CATEGORY_POS_MASK);
#elif FXT_VERSION >= FINALEVERSION_2012
    return GetBitFlag(_TypeCast()->measYadjust, USE_CATEGORY_POS_MASK);
#else
    return GetBitFlag(_TypeCast()->measYadjust, 0x4000);
#endif
    }
 
    twobyte GetHorizontalOffset() const
    {
        return _TypeCast()->measXadjust;
    }
 
    twobyte GetVerticalEntryOffset() const { 
#if FXT_VERSION < FINALEVERSION_2014
        return _TypeCast()->noteYadjustEntry;
#else
        return _TypeCast()->yAdjustEntry;
#endif
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::VERT_ALIGNMENT
#else
    int
#endif
    GetVerticalAlignmentPoint() const
    {
        return (FCCategoryDef::VERT_ALIGNMENT) _TypeCast()->vertMeasExprAlign;
    }
 
    twobyte GetVerticalBaselineOffset() const {
#if FXT_VERSION < FINALEVERSION_2014
        return _TypeCast()->noteYadjustBaseline;
#else
        return _TypeCast()->yAdjustBaseline;
#endif
    }
    
    void GetDescription(FCString* pName);
    
 
    void SetID(twobyte shapeID)
    {
        _TypeCast()->shapedef = shapeID;
    }
 
    void SetExecutableShapeID(twobyte shapeID)
    {
        _TypeCast()->value = shapeID;
        SetUseExecutableShape((shapeID != 0) ? true : false);
    }
 
    void SetUseExecutableShape(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, EXP_VALUEisEXEC, state);
    }
 
    void SetAllowHorizontalStretching(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, SHAPE_EXP_LOCKDOWN, !state);
    }
 
    void SetNoPrint(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, SHAPE_EXP_NOPRINT, state);
    }
 
    void SetBreakMMRest(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, SHAPE_EXP_BREAKMMREST, state);
    }
 
 
    twobyte GetCategoryID() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (_TypeCast()->category & 0x3fff);
#else
        return (_TypeCast()->measYadjust & 0x3fff);
#endif
    }
 
     void SetCategoryID(twobyte ID)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->category &= 0xc000;
        _TypeCast()->category |= (ID & 0x3fff);
#else
        _TypeCast()->measYadjust &= 0xc000;
        _TypeCast()->measYadjust |= (ID & 0x3fff);
#endif    
     }
 
 
    void SetHorizontalJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_JUSTIFICATION
#else
    int
#endif
    value)
    {
        /* Shape expr defs have the flags in another way than text expr defs... */
        twobyte setting = 0;
        switch (value)
        {
            case FCCategoryDef::EXPRJUSTIFY_LEFT:
                setting = 0;
                break;
            case FCCategoryDef::EXPRJUSTIFY_CENTER:
                setting = 1;
                break;
            case FCCategoryDef::EXPRJUSTIFY_RIGHT:
                setting = 2;
                break;
        }        
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->horzExprAlign = (twobyte) setting;
#else
        _TypeCast()->measExprAlign = (twobyte) setting;
#endif
    }
 
    void SetHorizontalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_ALIGNMENT
#else
    int
#endif
    value)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->horzMeasExprAlign = (twobyte) value;
#else
        _TypeCast()->measAlign = (twobyte) value;
#endif
    }
 
    void SetUseCategoryPos(bool value)
    {
#if FXT_VERSION >= FINALEVERSION_2014    
        Set16BitFlag((FLAG_16*) &_TypeCast()->category, USE_CATEGORY_POS_MASK, value);
#elif FXT_VERSION >= FINALEVERSION_2012    
        Set16BitFlag((FLAG_16*) &_TypeCast()->measYadjust, USE_CATEGORY_POS_MASK, value);
#else
        Set16BitFlag((FLAG_16*) &_TypeCast()->measYadjust, 0x4000, value);
#endif
    }
 
    void SetHorizontalOffset(twobyte value)
    {
        _TypeCast()->measXadjust = value;
    }
 
    void SetVerticalEntryOffset(twobyte value)
    {
#if FXT_VERSION < FINALEVERSION_2014
        _TypeCast()->noteYadjustEntry = value;
#else
        _TypeCast()->yAdjustEntry = value;
#endif
    }
 
    void SetVerticalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::VERT_ALIGNMENT
#else
    int
#endif
    value)
    {
        _TypeCast()->vertMeasExprAlign = (twobyte) value;
    }
 
    void SetVerticalBaselineOffset(twobyte value) {
#if FXT_VERSION < FINALEVERSION_2014
        _TypeCast()->noteYadjustBaseline = value;
#else
        _TypeCast()->yAdjustBaseline = value;
#endif
    }
 
    void SetDescription(FCString* pName);
 
#ifdef PDK_FRAMEWORK_SHAPES
    bool AssignShapeDef(FCShapeDef* pShapeDef)
    {
        if (!pShapeDef) return false;
        if (pShapeDef->GetItemNo() < 1) return false;
        _TypeCast()->shapedef = pShapeDef->GetItemNo();
        return true;
    }
#endif
 
    FCString* CreateDescription();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateDescription_GC()
    { return makeLuaSharedPtr(CreateDescription()); }
#endif
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Category ID: ", GetCategoryID());
    }
#endif
};
 
 
class FCTextBlock : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTextBlock2004 _textblock2004;    /* Pre 25.4-version of the struct */
#if FXT_VERSION >= FINALEVERSION_25_4
    EDTTextBlock25_4 _textblock25_4;    /* 25.4 and above */
#endif
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
    /* If true, use the 25.4 struct. If false, use the old 2004 struct. */
    bool UseVersion25_4() const;
    
    /* Returns the pointer to the flag member in the struct. */
    const FLAG_16* _GetFlagPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.flag; )
        return &_textblock2004.flag;
    }
    
    /* Returns the pointer to the textID member in the struct. */
    const eText* _GetTextIDPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.textID; )
        return &_textblock2004.textID;
    }
    
    /* Returns the pointer to the shapeID member in the struct. */
    const eShape* _GetShapeIDPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.shapeID; )
        return &_textblock2004.shapeID;
    }
    
    /* Returns the pointer to the lineSpacing member in the struct. */
    const twobyte* _GetLineSpacingPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.lineSpacing; )
        return &_textblock2004.lineSpacing;
    }
    
    /* Returns the pointer to the textTag member in the struct. */
    const ETAG* _GetTextTagPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.textTag; )
        return &_textblock2004.textTag;
    }
    
    /* Returns the pointer to the width member in the struct. */
    const Evpu16* _GetWidthPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.width; )
        return &_textblock2004.width;
    }
    
    /* Returns the pointer to the height member in the struct. */
    const Evpu16* _GetHeightPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.height; )
        return &_textblock2004.height;
    }
    
    /* Returns the pointer to the xadd member in the struct. */
    const Evpu16* _GetXaddPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.xadd; )
        return &_textblock2004.xadd;
    }
    
    /* Returns the pointer to the yadd member in the struct. */
    const Evpu16* _GetYaddPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.yadd; )
        return &_textblock2004.yadd;
    }
    
    /* Returns the pointer to the insethi member in the struct. */
    const EVPUFixedShort* _GetInsetHiPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.insethi; )
        return &_textblock2004.insethi;
    }
    
    /* Returns the pointer to the insetlo member in the struct. */
    const EVPUFixedShort* _GetInsetLoPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.insetlo; )
        return &_textblock2004.insetlo;
    }
    
    /* Returns the pointer to the stdlinelo member in the struct. */
    const EVPUFixedShort* _GetStdLineLoPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.stdlinelo; )
        return &_textblock2004.stdlinelo;
    }
    
    /* Returns the pointer to the stdlinehi member in the struct. */
    const EVPUFixedShort* _GetStdLineHiPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.stdlinehi; )
        return &_textblock2004.stdlinehi;
    }
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return ot_TextBlock; }
    
    int DataSizeLoad() const override {
        FIN25_4_CODE(if (UseVersion25_4()) return sizeof(EDTTextBlock25_4);)
        return sizeof(EDTTextBlock2004);
    }
    void* Allocate() override
    {
        FIN25_4_CODE( if (UseVersion25_4()) return (void*) &_textblock25_4; )
        return (void*) &_textblock2004;
    }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        void* pTextBlock = Allocate();
        memcpy(pTextBlock, ((FCTextBlock*)pSource)->_GetTextBlock(), DataSizeLoad());
        _datablock = pTextBlock;
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCTextBlock(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    enum TEXTBLOCKJUSTIFY
    {
        TEXTJUSTIFY_LEFT = TEXT_JUSTIFY_LEFT,
        TEXTJUSTIFY_RIGHT = TEXT_JUSTIFY_RIGHT,
        TEXTJUSTIFY_CENTER = TEXT_JUSTIFY_CENTER,
        TEXTJUSTIFY_FULL = TEXT_JUSTIFY_FULL,
        TEXTJUSTIFY_FORCED_FULL = TEXT_JUSTIFY_FORCED_FULL
    };
 
 
    const char* ClassName() const override { return "FCTextBlock"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TEXTBLOCK; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetTextBlock() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCTextBlock() : __FCNoInciOther()
    {
        void* pTextBlock = Allocate();
        int size = DataSizeLoad();
        memset(pTextBlock, 0, size);
        Set16BitFlag( (FLAG_16*)_GetFlagPtr(),
                TEXTBLOCK_NEWPOS | TEXTBLOCK_SHOWMAINSHAPE |
                TEXTBLOCK_WORDWRAP | TEXTBLOCK_LINESPACINGISPERCENT,
                true);
        SetLineSpacing(100);
        SetRawText(0, LO_UTWOBYTE(tx_TextBlock));  /* Default to tx_TextBlock */
       _datablock = pTextBlock;
       _loadedsize = size;
    }
 
    twobyte GetRawTextID() const { return *_GetTextIDPtr(); }
 
    void _SetRawTextID(twobyte therawtextid) { *(eText*)_GetTextIDPtr() = therawtextid; }
 
    EXTAG GetRawTextExtag()
    {
        EXTAG rawtextextag = tx_TextBlock;
        rawtextextag &= 0xffff0000;
        rawtextextag |= *_GetTextTagPtr();
        return rawtextextag;
    }   
 
    twobyte GetShapeID() const { return *_GetShapeIDPtr(); }
 
    FCString* CreateRawTextString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateRawTextString_GC()
    { return makeLuaSharedPtr(CreateRawTextString()); }
#endif
 
    bool SaveRawTextString(FCString* pString);
 
    bool SaveNewRawTextString(FCString* pString);
 
    void SetShapeID(twobyte shapeID) { *(eShape*)_GetShapeIDPtr() = shapeID; }
 
    void SetRawText(twobyte theid, ETAG tag = LO_UTWOBYTE(tx_TextBlock))
    {
        *(eText*)_GetTextIDPtr() = theid;
        *(ETAG*)_GetTextTagPtr() = tag;
    }
 
    void SetJustification(FLAG_16 justification)
    {
        FLAG_16* pFlag = (FLAG_16*) _GetFlagPtr();
        *pFlag &= ~TEXTBLOCK_JUSTIBITS;
        *pFlag |= (justification % TEXTBLOCK_JUSTIBITS);
    }
 
    bool DeepDeleteData() override
    {
        FCRawText rawtext;
        rawtext.SetCustomTag(GetRawTextExtag());
        rawtext.Load(GetRawTextID());                
        rawtext.DeleteData();
        return DeleteData();
    }
 
    twobyte GetLineSpacing() const { return *_GetLineSpacingPtr(); }
    
 
    void SetLineSpacing(twobyte linespacing) { *(twobyte*)_GetLineSpacingPtr() = linespacing; }
 
 
    FLAG_16 GetJustification() const
    {
        return (*_GetFlagPtr() & TEXTBLOCK_JUSTIBITS);
    }
 
    bool GetFrameReference() const
    {
        return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_NEWPOS);
    }
 
    bool GetLineSpacingIsPercent() const
    {
        return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_LINESPACINGISPERCENT);
    }
 
    bool GetWordWrap() const
    {
        return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_WORDWRAP);
    }
 
    bool GetExpandSingleWord() const
    {
        return !GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_NOEXPANDSINGLEWORD);
    }
    
    bool GetRoundedCorners() const
    {
        FIN25_4_CODE( if (UseVersion25_4()) return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_ROUND_CORNERS); )
        return false;
    }
    
    Efix32 GetRoundedCornerRadius() const
    {
        FIN25_4_CODE( if (UseVersion25_4()) return _textblock25_4.m_cornerRadius; )
        return 0;
    }
    
 
    void SetFrameReference(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_NEWPOS, state);
    }
 
    void SetLineSpacingIsPercent(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_LINESPACINGISPERCENT, state);
    }
 
    void SetWordWrap(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_WORDWRAP, state);
    }
 
    void SetExpandSingleWord(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_NOEXPANDSINGLEWORD, !state);
    }
 
    void SetRoundedCorners(bool state)
    {
        FIN25_4_CODE( if (UseVersion25_4()) Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_ROUND_CORNERS, state); )
    }
    
    void SetRoundedCornerRadius(Efix32 radius)
    {
        FIN25_4_CODE( if (UseVersion25_4()) _textblock25_4.m_cornerRadius = radius; )
    }
    
    void SetLineWidth(int value)
    {
        *(EVPUFixedShort*)_GetStdLineLoPtr() = LOWORD(value);
        *(EVPUFixedShort*)_GetStdLineHiPtr() = HIWORD(value);
    }
 
    void SetLineInset(int value)
    {
        *(EVPUFixedShort*)_GetInsetLoPtr() = LOWORD(value);
        *(EVPUFixedShort*)_GetInsetHiPtr() = HIWORD(value);
    }
    
    void SetHorizontalTextOffset(int value)
    {
        *(Evpu16*) _GetXaddPtr() = value;
    }
 
    void SetVerticalTextOffset(int value)
    {
        *(Evpu16*) _GetYaddPtr() = value;
    }
    
    void SetShowBorders(bool state)
    {
        Set16BitFlag((FLAG_16*)_GetFlagPtr(), TEXTBLOCK_SHOWMAINSHAPE, state);
    }
 
    void SetWidth(Evpu16 width)
    {
        *(Evpu16*)_GetWidthPtr() = width;
    }
 
    void SetHeight(Evpu16 height)
    {
        *(Evpu16*)_GetHeightPtr() = height;
    }
 
    
    int GetLineWidth() const
    {
        return MAKELONG(*_GetStdLineLoPtr(), *_GetStdLineHiPtr());
    }
    
    int GetLineInset() const
    {
        return MAKELONG(*_GetInsetLoPtr(), *_GetInsetHiPtr());
    }
    
    int GetHorizontalTextOffset() const
    {
        return *_GetXaddPtr();
    }
    
    int GetVerticalTextOffset() const
    {
        return *_GetYaddPtr();
    }
    
    bool GetShowBorders() const
    {
        return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_SHOWMAINSHAPE);
    }
 
    Evpu16 GetWidth() const
    {
        return *_GetWidthPtr();
    }
 
    Evpu16 GetHeight() const
    {
        return *_GetHeightPtr();
    }
 
    bool GetExpandHorizontally() const
    {
        return (GetWidth() == 0);
    }
 
    bool GetExpandVertically() const
    {
        return (GetHeight() == 0);
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Raw text ID: ", GetRawTextID());
        DebugOutHex("Text tag (hex): ", *_GetTextTagPtr());
        DebugOutHex("flag (hex): ", *_GetFlagPtr());
    }
#endif
};
 
 
class FCPageText  : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTPageText _pagetext;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return ot_PageText; }
    int DataSizeLoad() const override { return sizeof(EDTPageText); }
    void* Allocate() override { return (void*) &_pagetext; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_pagetext, ((FCPageText*)pSource)->_GetPageText(), sizeof(_pagetext));
        _datablock = &_pagetext;
        _loadedsize = sizeof(_pagetext);
    }
 
    __FCBaseData* CreateObject() override
                { return new FCPageText(); }
 
 
    bool LoadFirst() override
    {
        SetCmperAndInci(0, 0);
        if (Load(0, 0)) return true;
        return LoadNext();
    }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    enum TEXT_HORIZONTAL_ALIGN
    {
        TEXTHORIZALIGN_LEFT = TEXT_HALIGN_LEFT,
        TEXTHORIZALIGN_RIGHT = TEXT_HALIGN_RIGHT,
        TEXTHORIZALIGN_CENTER = TEXT_HALIGN_CENTER
    };
 
    enum TEXT_VERTICAL_ALIGN
    {
        TEXTVERTALIGN_TOP = TEXT_VALIGN_TOP,
        TEXTVERTALIGN_BOTTOM = TEXT_VALIGN_BOTTOM,
        TEXTVERTALIGN_CENTER = TEXT_VALIGN_CENTER        
    };
 
    enum TEXT_ASSIGNMENT
    {
        TEXTASSIGN_ALL = PAGETEXT_ASSIGN_ALL,
        TEXTASSIGN_ODD = PAGETEXT_ASSIGN_ODD,
        TEXTASSIGN_EVEN = PAGETEXT_ASSIGN_EVEN
    };
 
    const char* ClassName() const override { return "FCPageText"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PAGETEXT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetPageText() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCPageText() : __FCInciOther()
    {
        memset(&_pagetext, 0, sizeof(_pagetext));
        _datablock = &_pagetext;
        _loadedsize = sizeof(_pagetext);
    }
 
    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
 
    twobyte GetFirstPage() const
    {
        return _pagetext.startPage;
    }
 
    twobyte GetLastPage() const
    {
        return _pagetext.endPage;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_HORIZONTAL_ALIGN
#else
    int
#endif
    GetHorizontalAlignment() const
    {
        return (TEXT_HORIZONTAL_ALIGN) ((_pagetext.flag & PAGETEXT_HPOS_LP_BITS) >> 2);
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_VERTICAL_ALIGN
#else
    int
#endif
    GetVerticalAlignment() const
    {
        return (TEXT_VERTICAL_ALIGN) ((_pagetext.flag & PAGETEXT_VPOS_BITS) >> 8);
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_HORIZONTAL_ALIGN
#else
    int
#endif
     GetHorizontalAlignmentRightPage() const
     {
         return (TEXT_HORIZONTAL_ALIGN) ((_pagetext.flag & PAGETEXT_HPOS_RP_BITS) >> 4);
     }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_ASSIGNMENT
#else
    int
#endif
    GetPageAssignment() const
    {
         return (TEXT_ASSIGNMENT) (_pagetext.flag & PAGETEXT_OE_BITS);
    }
 
    bool GetPageEdgeRef() const
    {
        return GetBitFlag(_pagetext.flag, PAGETEXT_HPOS_PAGE_EDGE);
    }
 
    bool GetFrameEdgeRef() const
    {
        FCTextBlock textblock;
        if (!textblock.Load(GetTextBlockID())) return false;
        return textblock.GetFrameReference();
    }
 
 
    twobyte GetHorizontalPos() const
    {
        return _pagetext.xdisp;
    }
 
    twobyte GetHorizontalPosRightPage() const
    {
        return _pagetext.rightpgxdisp;
    }
 
    twobyte GetVerticalPos() const
    {
        return _pagetext.ydisp;
    }
 
    twobyte GetVerticalPosRightPage() const
    {
        return _pagetext.rightpgydisp;
    }
 
    bool GetVisible() const
    {
        return !GetBitFlag(_pagetext.flag, (PAGETEXT_ANNOTATION));
    }
 
    bool GetIndependentRightPage() const
    {
        return GetBitFlag(_pagetext.flag, PAGETEXT_INDRP_POS);
    }
 
    CMPER GetTextBlockID() const
    {
        return _pagetext.block;
    }
 
    void _SetTextBlockID(CMPER textblockid)
    {
        _pagetext.block = textblockid;
    }
 
    CMPER GetStringID() const;
 
     bool SaveNewTextBlock(FCString* pString);
 
     bool SaveTextString(FCString* pString);
 
     void SetHorizontalAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_HORIZONTAL_ALIGN
#else
    FLAG_16
#endif
    alignment
     )
     {
         _pagetext.flag &= ~PAGETEXT_HPOS_LP_BITS;
         _pagetext.flag |= ((alignment << 2) & PAGETEXT_HPOS_LP_BITS);
         if (!GetIndependentRightPage()) SetHorizontalAlignmentRightPage(alignment);
     }
 
     void SetHorizontalAlignmentRightPage(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_HORIZONTAL_ALIGN
#else
    FLAG_16
#endif
     alignment)
     {
         _pagetext.flag &= ~PAGETEXT_HPOS_RP_BITS;
         _pagetext.flag |= ((alignment << 4) & PAGETEXT_HPOS_RP_BITS);
     }
 
    void SetVerticalAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_VERTICAL_ALIGN
#else
    int
#endif
    alignment
    )
    {
         _pagetext.flag &= ~PAGETEXT_VPOS_BITS;
         _pagetext.flag |= ((alignment << 8) & PAGETEXT_VPOS_BITS);
    }
 
    void SetPageAssignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_ASSIGNMENT
#else
    int
#endif
    assign
    )
    {
        _pagetext.flag &= ~PAGETEXT_OE_BITS;
        _pagetext.flag |= (assign & PAGETEXT_OE_BITS);
    }
 
     void SetFirstPage(ePage page)
     {
         _pagetext.startPage = page;
     }
 
    void SetLastPage(ePage page)
    {
        _pagetext.endPage = page;
    }
 
    void SetHorizontalPos(twobyte value)
    {
        _pagetext.xdisp = value;
        if (!GetIndependentRightPage()) SetHorizontalPosRightPage(value);
    }
 
    void SetHorizontalPosRightPage(twobyte value)
    {
        _pagetext.rightpgxdisp = value;
    }
 
    void SetVerticalPos(twobyte value)
    {
        _pagetext.ydisp = value;
        if (!GetIndependentRightPage()) SetVerticalPosRightPage(value);
    }
 
    void SetVerticalPosRightPage(twobyte value)
    {
        _pagetext.rightpgydisp = value;
    }
 
    void SetVisible(bool visible)
    {
        Set16BitFlag(&_pagetext.flag, PAGETEXT_ANNOTATION, !visible);
    }
 
    void SetIndependentRightPage(bool state)
    {
        Set16BitFlag(&_pagetext.flag, PAGETEXT_INDRP_POS, state);
    }
 
    void SetPageEdgeRef(bool state)
    {
        Set16BitFlag(&_pagetext.flag, PAGETEXT_HPOS_PAGE_EDGE, state);
        Set16BitFlag(&_pagetext.flag, PAGETEXT_VPOS_PAGE_EDGE, state);
    }
 
    void SetFrameEdgeRef(bool state)
    {
        FCTextBlock textblock;
        if (!textblock.Load(GetTextBlockID())) return;
        textblock.SetFrameReference(state);
        textblock.Save();
    }
 
    bool DeepDeleteData() override
    {
        FCTextBlock textblock;
        textblock.Load(GetTextBlockID());
        textblock.DeepDeleteData();
        return DeleteData();
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
        DebugOutInt("First page: ", GetFirstPage());
        DebugOutInt("Last page: ", GetLastPage());
        DebugOutHex("Flag (hex): ", _pagetext.flag);
    }
#endif
};
 
 
 
 
 
class FCSeparatePlacement : public __FCInciOther
{    
    private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTSeparatePlacement _separateplacement;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ot_SeparateBackwardRepeatPlacement; }
    int DataSizeLoad() const override { return sizeof(EDTSeparatePlacement); }
    void* Allocate() override { return (void*) &_separateplacement; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_separateplacement, ((FCSeparatePlacement*)pSource)->_GetSeparatePlacement(), sizeof(_separateplacement));
        _datablock = &_separateplacement;
        _loadedsize = sizeof(_separateplacement);
    }
 
    __FCBaseData* CreateObject() override { return new FCSeparatePlacement(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    enum SEPARATEPLACEMENT_MODES
    {        
        SEPARMODE_BACKWARDREPEAT = 0,
 
        SEPARMODE_TEXTREPEAT = 1,
 
        SEPARMODE_ENDINGREPEAT = 2,
 
        SEPARMODE_ENDINGREPEATTEXT = 3
    };
 
    const char* ClassName() const override { return "FCSeparatePlacement"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SEPARATEPLACEMENT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetSeparatePlacement() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCSeparatePlacement() : __FCInciOther()
    {
        memset(&_separateplacement, 0, sizeof(_separateplacement));
        _datablock = &_separateplacement;
        _loadedsize = sizeof(_separateplacement);
    }
 
 
    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SEPARATEPLACEMENT_MODES 
#else
    int
#endif
    mode
    )
    {
        switch (mode)
        {
            case FCSeparatePlacement::SEPARMODE_TEXTREPEAT:
                SetCustomTag(ot_SeparateTextRepeatPlacement);
                break;
            case FCSeparatePlacement::SEPARMODE_BACKWARDREPEAT:
                SetCustomTag(ot_SeparateBackwardRepeatPlacement);
                break;
            case FCSeparatePlacement::SEPARMODE_ENDINGREPEAT:
                SetCustomTag(ot_SeparateEndingRepeatPlacement);
                break;
            case FCSeparatePlacement::SEPARMODE_ENDINGREPEATTEXT:
                SetCustomTag(ot_SeparateEndingRepeatTextPlacement);
                break;
        }
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SEPARATEPLACEMENT_MODES
#else
    int
#endif
    GetMode() const
    {
        switch(GetCustomTag())
        {
            case ot_SeparateTextRepeatPlacement:
                return FCSeparatePlacement::SEPARMODE_TEXTREPEAT;
            case ot_SeparateEndingRepeatPlacement:
                return FCSeparatePlacement::SEPARMODE_ENDINGREPEAT;
            case ot_SeparateEndingRepeatTextPlacement:
                return FCSeparatePlacement::SEPARMODE_ENDINGREPEATTEXT;
            case ot_SeparateBackwardRepeatPlacement:
            default:
                return FCSeparatePlacement::SEPARMODE_BACKWARDREPEAT;
        }
    }
 
    eStaff GetStaff() const override { return _separateplacement.instno; }
    
    bool HasStaffValue() const override { return true; }
 
    twobyte GetMeasure() const override
    {
        if (GetMode() == SEPARMODE_TEXTREPEAT)
            return _separateplacement.measure;
        return 0;
    }
 
        Evpu16 GetHorizontalOffset1() const { return _separateplacement.x1add; }
 
    Evpu16 GetVerticalOffset1() const { return _separateplacement.y1add; }
 
        Evpu16 GetHorizontalOffset2() const
    {
        switch (GetMode())
        {
            case SEPARMODE_ENDINGREPEAT:
            case SEPARMODE_BACKWARDREPEAT:
                return _separateplacement.x2add;
                
            default:
                break;
        }
        return 0;
    }
 
    Evpu16 GetVerticalOffset2() const
    {
        switch (GetMode())
        {
            case SEPARMODE_ENDINGREPEAT:
            case SEPARMODE_BACKWARDREPEAT:
                return _separateplacement.y2add;
                
            default:
                break;
        }
        return 0;
    }
 
    void SetStaff(eStaff staff) { _separateplacement.instno = staff; }
 
    void SetMeasure(twobyte meas)
    {
        if (GetMode() == SEPARMODE_TEXTREPEAT)
            _separateplacement.measure = meas;
    }
 
    void SetHorizontalOffset1(Evpu16 value) { _separateplacement.x1add = value; }
 
    void SetVerticalOffset1(Evpu16 value) { _separateplacement.y1add = value; }
 
    void SetHorizontalOffset2(Evpu16 value)
    {
        switch (GetMode())
        {
            case SEPARMODE_ENDINGREPEAT:
            case SEPARMODE_BACKWARDREPEAT:
                _separateplacement.x2add = value;
                break;
                
            default:
                break;
        }
    }
 
    void SetVerticalOffset2(Evpu16 value)
    {
        switch (GetMode())
        {
            case SEPARMODE_ENDINGREPEAT:
            case SEPARMODE_BACKWARDREPEAT:
                _separateplacement.y2add = value;
                break;
                
            default:
                break;
        }
    }
    
    bool GetVisible() const
    {
        switch (GetMode())
        {
            case SEPARMODE_ENDINGREPEAT:
            case SEPARMODE_BACKWARDREPEAT:
                return !GetBitFlag(_separateplacement.measure, SEPARATES_HIDDEN); // reverse bit
                
            case SEPARMODE_TEXTREPEAT:
                return !GetBitFlag(_separateplacement.y2add, SEPARATES_HIDDEN);
                
            default:
                break;
        }
        return true;
    }
    
    void SetVisible(bool state)
    {
        switch (GetMode())
        {
            case SEPARMODE_ENDINGREPEAT:
            case SEPARMODE_BACKWARDREPEAT:
                return Set16BitFlag(reinterpret_cast<FLAG_16*>(&_separateplacement.measure), SEPARATES_HIDDEN, !state); // reverse bit
                
            case SEPARMODE_TEXTREPEAT:
                return Set16BitFlag(reinterpret_cast<FLAG_16*>(&_separateplacement.y2add), SEPARATES_HIDDEN, !state);
                
            default:
                break;
        }
    }
};
 
 
class FCCell;
 
class FCExpression : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTScoreExpression2009 _expression;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    int DataSizeLoad() const override { return sizeof(EDTScoreExpression2009); }
    void* Allocate() override { return (void*) &_expression; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_expression, ((FCExpression*)pSource)->_GetExpression(), sizeof(_expression));
        _datablock = &_expression;
        _loadedsize = sizeof(_expression);
    }
 
    __FCBaseData* CreateObject() override { return new FCExpression(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
        enum EXPRESSION_PLAYBACK_STARTPOINTS
        {
                EXPRPLAYSTART_POSINMEASURE = 0,
                
                EXPRPLAYSTART_ALIGNMENTPOINT = 1,
 
                EXPRPLAYSTART_BEGINNINGOFMEASURE = 2
        };
 
 
    const char* ClassName() const override { return "FCExpression"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_EXPRESSION; }
 
    EXTAG Tag() const override { return ot_ScoreExpression2009; }  /* Tag is required to be public for some plug-ins */
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetExpression() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCExpression() : __FCInciOther()
    {
        memset(&_expression, 0, sizeof(_expression));
        _datablock = &_expression;
        _loadedsize = sizeof(_expression);
    }
 
 
    bool AssignTextExpressionDef(FCTextExpressionDef* pDef);
 
    bool AssignShapeExpressionDef(FCShapeExpressionDef* pDef);
 
    bool CalcMetricPos(FCPoint* pPoint);        
    
    void ResetPos()
    {
        SetHorizontalPos(0);
        SetVerticalPos(0);
    }
 
    twobyte GetStaff() const override { return _expression.staffAssign; }
 
#ifdef PDK_FRAMEWORK_LAYOUT
    eStaff CalcStaffInPageView() const;
    
    eStaff CalcStaffInScrollView() const;
    
    eStaff CalcStaffInCurrentView() const;
#endif // PDK_FRAMEWORK_LAYOUT
 
    bool HasStaffValue() const override { return true; }
 
    eMeas GetMeasure() const override { return _dataid.other.cmper; }
 
    twobyte GetLayerAssignment() const { return _expression.flag & 0x7; }
 
    twobyte GetPlaybackLayerAssignment() const
    {        
        return (_expression.flag & 0x70) >> 4;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
        EXPRESSION_PLAYBACK_STARTPOINTS
#else
        int 
#endif
        GetPlaybackStart() const
        {
                if (GetBitFlag(_expression.flag, 0x0400)) return EXPRPLAYSTART_POSINMEASURE;
                if (GetBitFlag(_expression.flag, 0x0200)) return EXPRPLAYSTART_ALIGNMENTPOINT;
                return EXPRPLAYSTART_BEGINNINGOFMEASURE;
        }
 
    bool GetScoreAssignment() const
    {
        return !GetBitFlag(_expression.flag, 0x1000);
    }
 
    bool GetPartAssignment() const
    {
        return !GetBitFlag(_expression.flag, 0x0800);
    }
 
    twobyte GetStaffListID() const { return _expression.staffList; }
 
    twobyte GetStaffGroupID() const { return _expression.staffGroup; }
    
    twobyte GetRehearsalMarkOffset() const { return _expression.rehearsalMarkOffset; }
 
    bool GetVisible() const { return !GetBitFlag(_expression.flag, 0x4000); }
 
    bool GetScaleWithEntry() const { return !GetBitFlag(_expression.flag, 0x0100); }
 
    TimeEdu32 GetMeasurePos() const override { return 0x10000 * _expression.horzEDUOffHi + _expression.horzEDUOffLo; }
 
    twobyte GetHorizontalPos() const { return _expression.horzEVPUOff; }
 
    twobyte GetVerticalPos() const { return _expression.vertOff; }
 
    twobyte GetGraceNoteIndex() const { return _expression.graceNoteIndex; }
    
    bool GetTracksVoice2() const { return _expression.flag & 0x08; }
 
    bool IsVisibleOnStaff(twobyte staff);
   
    FCShapeExpressionDef* CreateShapeExpressionDef();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCShapeExpressionDef> CreateShapeExpressionDef_GC()
    { return makeLuaSharedPtr(CreateShapeExpressionDef()); }
#endif
 
    FCTextExpressionDef* CreateTextExpressionDef();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCTextExpressionDef> CreateTextExpressionDef_GC()
    { return makeLuaSharedPtr(CreateTextExpressionDef()); }
#endif
 
    bool IsShape() const { return GetBitFlag(_expression.flag, SCOREEXP_SHAPE_OBJECT); }
 
    bool IsSingleStaffAssigned() { return (GetStaff() > 0); }
 
    bool GetShape() const { return GetBitFlag(_expression.flag, SCOREEXP_SHAPE_OBJECT); }
 
    twobyte GetID() const { return _expression.dynumber; }
 
    bool SaveNewToCell(FCCell* pCell);
 
    void SetID(twobyte id) { _expression.dynumber = id; }
 
    void SetLayerAssignment(twobyte layer)
    {
        layer &= 0x07;
        _expression.flag &= ~0x07;
        _expression.flag |= layer;
    }
 
    void SetScoreAssignment(bool value)
    {
        Set16BitFlag(&_expression.flag, 0x1000, !value);
    }
 
    void SetPartAssignment(bool value)
    {
        Set16BitFlag(&_expression.flag, 0x0800, !value);
    }
 
    void SetPlaybackLayerAssignment(twobyte layer)
    {
        layer &= 0x07;
        layer <<= 4;
        _expression.flag &= ~0x70;
        _expression.flag |= layer;       
    }
 
        void SetPlaybackStart(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                EXPRESSION_PLAYBACK_STARTPOINTS
#else
                int
#endif
                value
                )
        {
                switch (value)
                {
                        case EXPRPLAYSTART_POSINMEASURE:
                                Set16BitFlag(&_expression.flag, 0x0400, true);
                                Set16BitFlag(&_expression.flag, 0x0200, false);
                                break;
                        case EXPRPLAYSTART_ALIGNMENTPOINT:
                                Set16BitFlag(&_expression.flag, 0x0400, false);
                                Set16BitFlag(&_expression.flag, 0x0200, true);
                                break;
                        default: /* EXPRPLAYSTART_BEGINNINGOFMEASURE */
                                Set16BitFlag(&_expression.flag, 0x0400, false);
                                Set16BitFlag(&_expression.flag, 0x0200, false);
                                break;
                }               
        }
 
    void SetStaff(twobyte staffno) { _expression.staffAssign = staffno; }
 
    void SetShape(bool isshape) { Set16BitFlag(&_expression.flag, SCOREEXP_SHAPE_OBJECT, isshape); }
 
    void SetStaffListID(twobyte ID) { _expression.staffList = ID; }
 
    void SetStaffGroupID(twobyte value) { _expression.staffGroup = value; }
 
    void SetRehearsalMarkOffset(twobyte value) { _expression.rehearsalMarkOffset = value; }
 
    void SetVisible(bool state) { Set16BitFlag(&_expression.flag, 0x4000, !state); }
 
    void SetScaleWithEntry(bool state) { Set16BitFlag(&_expression.flag, 0x0100, !state); }
 
    void SetMeasurePos(TimeEdu32 value) 
    {        
        _expression.horzEDUOffHi = (value & 0xffff0000) / 0x10000;
        _expression.horzEDUOffLo = value & 0x0000ffff;
    }
 
    void SetHorizontalPos(twobyte value) { _expression.horzEVPUOff = value; }
 
    void SetVerticalPos(twobyte value) {  _expression.vertOff = value; }
    
    void SetGraceNoteIndex(twobyte index) {
        if (index < 0) return; /* Negative indexes aren't allowed */
        _expression.graceNoteIndex = index;
    }
    
    void SetTracksVoice2(bool value) { Set16BitFlag(&_expression.flag, 0x08, value); }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
        DebugOutBlock(&_expression, 0, sizeof(_expression));
        DebugOutHex("Flag bits (hex): ", _expression.flag);
        DebugOutInt("Attached to Staff: ", GetStaff());
        DebugOutInt("Staff List ID: ", GetStaffListID());
        DebugOutInt("Rehearsal Mark Offset: ", GetRehearsalMarkOffset());
        DebugOutInt("Measure Pos (EDUs): ", GetMeasurePos());
        DebugOutInt("Horizontal Pos (EVPUs): ", GetHorizontalPos());
        DebugOutInt("Vertical Pos: ", GetVerticalPos());
    }
#endif
};
 
 
/* Macro for accessing same-name fields in different versions
 of the Staff Style Def struct: */
#define __STAFFSTYLEDEF_RETURN_FIELD_PTR(field) \
switch (_VersionToUse()) \
{ \
    case FINALEVERSION_2014: \
        return &_staffstyledef2014.field; \
    case FINALEVERSION_2012: \
        return &_staffstyledef2012.field; \
    default: \
        return &_staffstyledef2010.field; \
} \
 
 
class FCStaffStyleDef : public __FCStaffBase
{
private:
    const bool _skipWorkaround;
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStaffStyle2010 _staffstyledef2010;
    
#if FXT_VERSION >= FINALEVERSION_2012
    EDTStaffStyle2012 _staffstyledef2012;
#else
    EDTStaffStyle2010 _staffstyledef2012; /* Dummy struct for unsupported PDKs */
#endif
    
#if FXT_VERSION >= FINALEVERSION_2014
    EDTStaffStyle2014 _staffstyledef2014;
#else
    EDTStaffStyle2010 _staffstyledef2014;  /* Dummy struct for unsupported PDKs */
#endif
    
    const uonebyte* _GetInstUUIDPtr() const override
    {
        if (_VersionToUse() >= FINALEVERSION_2014)
            return _staffstyledef2014.instUUID;
        if (_VersionToUse() >= FINALEVERSION_2012)
            return _staffstyledef2012.instUUID;
        return NULL;
    }
    
    const FLAG_16* _GetInstFlagPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(instflag);
    }
    
    const FLAG_16* _GetFlagPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(flag);
    }
    
        const FLAG_16* _GetAltFlagPtr() const override
        {
                __STAFFSTYLEDEF_RETURN_FIELD_PTR(altFlag);
        }
    
        const FLAG_16* _GetAltFlag2Ptr() const override
        {
                __STAFFSTYLEDEF_RETURN_FIELD_PTR(altFlag2);
        }
    
        const twobyte* _GetTranspositionPtr() const override
        {
                __STAFFSTYLEDEF_RETURN_FIELD_PTR(transposition);
        }
    
    const FLAG_16* _GetMoreFlagsPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(moreFlags);
    }
 
    const FLAG_16* _GetMoreFlags2Ptr() const override
    {
                if (_VersionToUse() < FINALEVERSION_2014) return NULL;
#if FXT_VERSION < FINALEVERSION_25
                return (const FLAG_16*) &_staffstyledef2014.hideKeySigsShowAccis;
#else
                return &_staffstyledef2014.moreFlags2;
#endif
    }
 
    const FLAG_16* _GetMoreFlags3Ptr() const override
    {
                if (_VersionToUse() < FINALEVERSION_2014) return NULL;
#if FXT_VERSION < FINALEVERSION_25
                return (const FLAG_16*) &_staffstyledef2014.redisplayLayerAccis;
#else
                return &_staffstyledef2014.moreFlags3;
#endif          
    }
                
    const FLAG_16* _GetMask1FlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(mask1);
    }
 
    const FLAG_16* _GetMask2FlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(mask2);
    }
 
    const FLAG_16* _GetMask3FlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(mask3);
    }
 
    const FLAG_16* _GetSFFlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(sfflag);
    }
 
    const twobyte* _GetAbbrvNamePtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(abbrvName);
    }
    
    const twobyte* _GetFullNamePtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(fullName);
    }
 
        const twobyte* _GetClefsPtr() const override
        {
                __STAFFSTYLEDEF_RETURN_FIELD_PTR(clefs);
        }
    
    const Efix32* _GetVertTabNumOffPtr() const override
        {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(vertTabNumOff);
    }
 
    const CMPER* _GetFretInstIDPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(fretInstID);
    }
 
    const Evpu16* _GetBottomBarlineOffsetPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(botBarlineOffset);
    }
 
    const Evpu16* _GetTopBarlineOffsetPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(topBarlineOffset);
    }
    
    const utwobyte* _GetCapoLowFretPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(capoLowFret);
    }
    
    const FLAG_16* _GetBotLinesPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(botLines);
    }
    
    const FLAG_16* _GetTopLinesPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(topLines);
    }
    
    const Efix32* _GetLineSpacePtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(lineSpace);
    }
    
    const twobyte* _GetDwWRestPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(dw_wRest);
    }
    
    const twobyte* _GetStemReversalPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(stemReversal);
    }
    
    const twobyte* _GetRepeatDotsOffPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(repeatDotsOff);
    }
    
    const twobyte* _GetHOtherRestPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(h_otherRest);
    }
    
    const EFONTID* _GetMFontPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(mfont);
    }
    
    const twobyte* _GetSizeEfxPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(sizeefx);
    }
 
    const Efix32* _GetHorzStemOffUpPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(horzStemOffUp);
    }
 
    const Efix32* _GetHorzStemOffDownPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(horzStemOffDown);
    }
 
    const Efix32* _GetVertStemStartOffUpPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(vertStemStartOffUp);
    }
 
    const Efix32* _GetVertStemStartOffDownPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(vertStemStartOffDown);
    }
 
    const Efix32* _GetVertStemEndOffUpPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(vertStemEndOffUp);
    }
 
    const Efix32* _GetVertStemEndOffDownPtr() const override
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(vertStemEndOffDown);
    }
    
    FLAG_16 GetMask1() const { return *_GetMask1FlagPtr(); }
    
    FLAG_16 GetMask2() const { return *_GetMask2FlagPtr(); }
    
    FLAG_16 GetMask3() const { return *_GetMask3FlagPtr(); }
    
    EXTAG _GetFullNamePosTag() const override { return ot_NamePosFullStyle; }
    
    twobyte _GetFullNamePosCmper() const override { return GetItemNo(); }
 
    EXTAG _GetAbbreviatedNamePosTag() const override { return ot_NamePosAbbrvStyle; }
    
    twobyte _GetAbbreviatedNamePosCmper() const override { return GetItemNo(); }
 
#ifdef PDK_FRAMEWORK_PREFS
    virtual bool _SaveNewFullNamePos() override
    {  return this->_pFullNamePosition && this->_pFullNamePosition->SaveAs(GetItemNo()); }
    
    virtual bool _SaveNewAbbreviatedNamePos() override
    { return this->_pAbbreviatedNamePosition && this->_pAbbreviatedNamePosition->SaveAs(GetItemNo()); }
#endif
    
        bool LoadFirst() override 
        { 
        /* Since there can be holes in the staff style "chain", there
         need to be a better method to find items. Scanning a gap of 2000 items
         should be an ok workaround for just about any documents. In fact,
         attempting to load non-existent items takes almost zero time.*/
                for (int i = 1; i <= 2000; i++)
                {
                        if (Load(i)) return true;
                }
                return false; 
        }
 
        bool LoadNext() override 
        { 
        /* Since there can be holes in the staff style "chain", there
         need to be a better method to find items. Scanning a gap of 2000 items
         should be an ok workaround for just about any documents. In fact,
         attempting to load non-existent items takes almost zero time.*/
                int itemno = GetItemNo();
                for (int i = 1; i <= 2000; i++)
                {
                        if (Load(itemno + i)) return true;
                }               
                return false;
        }
    
    bool _SaveRawFields() const;
 
    void _Init()
    {
        memset(_GetStaffStyle(), 0, DataSizeLoad());
        _datablock = _GetStaffStyle();
        _loadedsize = DataSizeLoad();
    }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    EXTAG Tag() const override { return ot_EDTStaffStyle2010; }
    int DataSizeLoad() const override
    {
        switch (_VersionToUse())
        {
            case FINALEVERSION_2014:
                return sizeof(EDTStaffStyle2014);
            case FINALEVERSION_2012:
                return sizeof(EDTStaffStyle2012);
            default:
                return sizeof(EDTStaffStyle2010);
        }
    }
    void* Allocate() override
    {
        switch (_VersionToUse())
        {
            case FINALEVERSION_2014:
                return (void*) &_staffstyledef2014;
            case FINALEVERSION_2012:
                return (void*) &_staffstyledef2012;
            default:
                return (void*) &_staffstyledef2010;
        }
    }
    EVERSION EnigmaVersion() const override { return _VersionToUse(); }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(_GetStaffStyle(), ((FCStaffStyleDef*)pSource)->_GetStaffStyle(), DataSizeLoad());
        _datablock = _GetStaffStyle();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCStaffStyleDef(); }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCStaffStyleDef"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STAFFSTYLEDEF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetStaffStyle() { return Allocate(); }
 
        bool Load(CMPER itemno) override;
    
    bool Save() override
    {
        if (! __FCNoInciOther::Save()) return false;
        return _SaveRawFields();
    }
    
    bool SaveNew() override
    {
        if (! __FCNoInciOther::SaveNew()) return false;
        return _SaveRawFields();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCStaffStyleDef() : __FCStaffBase(), _skipWorkaround(false)
    { _Init(); }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    FCStaffStyleDef(bool skipWorkaround) : __FCStaffBase(), _skipWorkaround(skipWorkaround)
    { _Init(); }
 
    static FCStaffStyleDef* FCStaffStyleDef_Lua(void* ptr, lua_State* L)
    {
        return _OneOptionalParamLuaConstructor<FCStaffStyleDef, bool>(ptr, L);
    }
#endif // PDK_FRAMEWORK_LUAFRIENDLY
 
 
    /************************
     *** GETTERS for data ***
     ************************/
    
        bool GetCopyable() const { return GetBitFlag(*_GetSFFlagPtr(), SFFLAG_COPYABLE); }
 
        bool GetAddToMenu() const { return GetBitFlag(*_GetSFFlagPtr(), SFFLAG_ADDTOMENU); }
 
    
    /*************************************
     *** GETTERS for Staff Style usage ***
     *************************************/
    
    bool GetUseShowKeySignatures() const { return GetBitFlag(GetMask2(), SFMASK2_NEGKEY); }
 
    bool GetUseShowMeasureNumbers() const { return GetBitFlag(GetMask1(), SFMASK1_NEGMNUMB); }
    
    bool GetUseShowTimeSignatures() const { return GetBitFlag(GetMask2(), SFMASK2_NEGTIME); }
    
    bool GetUseShowPartTimeSignatures() const { return GetBitFlag(GetMask3(), SFMASK3_NEGTIME_PARTS); }
 
    bool GetUseShowClefs() const { return GetBitFlag(GetMask2(), SFMASK2_NEGCLEF); }
 
        bool GetUseShowChords() const { return GetBitFlag(GetMask3(), SFMASK3_HIDE_CHORDS); }
                
        bool GetUseShowAugmentationDots() const { return GetBitFlag(GetMask2(), SFMASK2_SHOWDOTS); }
                
        bool GetUseShowFretboards() const { return GetBitFlag(GetMask3(), SFMASK3_HIDE_FRETBOARDS); }
 
        bool GetUseShowLyrics() const { return GetBitFlag(GetMask3(), SFMASK3_HIDE_LYRICS); }
 
        bool GetUseShowRepeats() const { return GetBitFlag(GetMask2(), SFMASK2_HIDE_RPT_BARS); }
 
        bool GetUseShowRests() const { return GetBitFlag(GetMask2(), SFMASK2_SHOWRESTS); }
 
        bool GetUseShowStaffLines() const;
 
        bool GetUseShowScoreStaffNames() const { return GetBitFlag(GetMask1(), SFMASK1_NEGNAME); }
 
        bool GetUseShowPartStaffNames() const { return GetBitFlag(GetMask3(), SFMASK3_SHOWNAME_PARTS); }
 
        bool GetUseShowStems() const { return GetBitFlag(GetMask3(), SFMASK3_SHOWSTEMS); }
 
        bool GetUseShowTies() const { return GetBitFlag(GetMask2(), SFMASK2_SHOWTIES); }
                
        bool GetUseIndependentFont() const { return GetBitFlag(GetMask1(), SFMASK1_FLOATNOTEHEADFONT); }
 
        bool GetUseFlatBeams() const { return GetBitFlag(GetMask1(), SFMASK1_FLAT_BEAMS); }
 
        bool GetUseNotationStyle() const { return GetBitFlag(GetMask1(), SFMASK1_NOTATIONSTYLE); }
 
        bool GetUseDisplayEmptyRests() const { return GetBitFlag(GetMask1(), SFMASK1_BLANKMEASURE); }
 
        bool GetUseAllowHiding() const { return GetBitFlag(GetMask1(), SFMASK1_NO_OPTIMIZE); }
 
        bool GetUseDefaultClef() const { return GetBitFlag(GetMask1(), SFMASK1_DEFAULTCLEF); }
 
        bool GetUseStafflineAdjustments() const { return GetBitFlag(GetMask1(), SFMASK1_STAFFLINES); }
 
        bool GetUseTransposition() const { return GetBitFlag(GetMask1(), SFMASK1_TRANSPOSITION); }
 
        bool GetUseBreakBarlines() const { return GetBitFlag(GetMask1(), SFMASK1_BLINEBREAK); }
 
        bool GetUseBreakRepeatBarlines() const { return GetBitFlag(GetMask1(), SFMASK1_RBARBREAK); }
 
        bool GetUseShowTextRepeats() const { return GetBitFlag(GetMask1(), SFMASK1_NEGREPEAT); }
 
        bool GetUseShowBarlines() const { return GetBitFlag(GetMask1(), SFMASK1_HIDE_BARLINES); }
 
        bool GetUseFullName() const { return GetBitFlag(GetMask2(), SFMASK2_FULLNAME); }
 
        bool GetUseAbbreviatedName() const { return GetBitFlag(GetMask2(), SFMASK2_ABBRVNAME); }
 
        bool GetUseIndependentKeySig() const { return GetBitFlag(GetMask2(), SFMASK2_FLOATKEYS); }
 
        bool GetUseIndependentTimeSig() const { return GetBitFlag(GetMask2(), SFMASK2_FLOATTIME); }
 
        bool GetUseHideMode() const { return GetBitFlag(GetMask2(), SFMASK2_HIDESTAFF); }
 
        bool GetUseIgnoreKeySig() const { return GetBitFlag(GetMask2(), SFMASK2_NOKEY); }
 
        bool GetUseFullNamePosition() const { return GetBitFlag(GetMask2(), SFMASK2_FULLNAMEPOS); }
 
        bool GetUseAbbreviatedPosition() const { return GetBitFlag(GetMask2(), SFMASK2_ABBRVNAMEPOS); }
 
        bool GetUseAltNotationStyle() const { return GetBitFlag(GetMask2(), SFMASK2_ALTNOTATION); }
 
        bool GetUseShowNoteColors() const { return GetBitFlag(GetMask3(), SFMASK3_SHOW_NOTE_COLORS); }
 
        bool GetUseShowNoteShapes() const;
 
        bool GetUseNoKeySigShowAccidentals() const;
 
    bool GetUseRedisplayOtherLayerAccidentals() const;
 
 
    /* **********************
     *** SETTERS for data ***
     ************************/
    
        void SetCopyable(bool value) { Set16BitFlag((FLAG_16*)_GetSFFlagPtr(), SFFLAG_COPYABLE, value); }
 
    void SetAddToMenu(bool value) { Set16BitFlag((FLAG_16*) _GetSFFlagPtr(), SFFLAG_ADDTOMENU, value); }
    
    /* ***********************************
     *** SETTERS for Staff Style usage ***
     *************************************/
    
    void SetUseShowKeySignatures(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetMask2FlagPtr(), SFMASK2_NEGKEY, state);
    }
 
        void SetUseShowMeasureNumbers(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NEGMNUMB, state);            
        }
 
    void SetUseShowTimeSignatures(bool state)
    {
        Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_NEGTIME, state);
    }
    
    void SetUseShowPartTimeSignatures(bool state)
    {
        Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_NEGTIME_PARTS, state);
    }
 
    void SetUseShowClefs(bool state)
    {
        Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_NEGCLEF, state);
    }
 
        void SetUseShowChords(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_HIDE_CHORDS, state);
        }
        
        void SetUseShowAugmentationDots(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_SHOWDOTS, state);
        }
                
        void SetUseShowFretboards(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_HIDE_FRETBOARDS, state);
        }
 
        void SetUseShowLyrics(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_HIDE_LYRICS, state);
        }
 
        void SetUseShowRepeats(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_HIDE_RPT_BARS, state);
        }
 
        void SetUseShowRests(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_SHOWRESTS, state);
        }
 
        void SetUseShowStaffLines(bool state);
 
        void SetUseShowScoreStaffNames(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NEGNAME, state);
        }
 
        void SetUseShowPartStaffNames(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_SHOWNAME_PARTS, state);
        }
 
        void SetUseShowStems(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_SHOWSTEMS, state);
        }
 
        void SetUseShowTies(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_SHOWTIES, state);
        }
 
        void SetUseIndependentFont(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_FLOATNOTEHEADFONT, state); }
 
        void SetUseFlatBeams(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_FLAT_BEAMS, state); }
 
        void SetUseNotationStyle(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NOTATIONSTYLE, state); }
 
        void SetUseDisplayEmptyRests(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_BLANKMEASURE, state); }
 
        void SetUseAllowHiding(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NO_OPTIMIZE, state); }
 
        void SetUseDefaultClef(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_DEFAULTCLEF, state); }
 
        void SetUseStafflineAdjustments(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_STAFFLINES, state); }
 
        void SetUseTransposition(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_TRANSPOSITION, state); }
 
        void SetUseBreakBarlines(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_BLINEBREAK, state); }
 
        void SetUseBreakRepeatBarlines(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_RBARBREAK, state); }
 
        void SetUseShowTextRepeats(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NEGREPEAT, state); }
 
        void SetUseShowBarlines(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_HIDE_BARLINES, state); }
 
        void SetUseFullName(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_FULLNAME, state); }
 
        void SetUseAbbreviatedName(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_ABBRVNAME, state); }
 
        void SetUseIndependentKeySig(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_FLOATKEYS, state); }
 
        void SetUseIndependentTimeSig(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_FLOATTIME, state); }
 
        void SetUseHideMode(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_HIDESTAFF, state); }
 
        void SetUseIgnoreKeySig(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_NOKEY, state); }
 
        void SetUseFullNamePosition(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_FULLNAMEPOS, state); }
 
        void SetUseAbbreviatedPosition(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_ABBRVNAMEPOS, state); }
 
        void SetUseAltNotationStyle(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_ALTNOTATION, state); }
 
        void SetUseShowNoteColors(bool state) { Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_SHOW_NOTE_COLORS, state); }
 
        void SetUseShowNoteShapes(bool state);
 
        void SetUseNoKeySigShowAccidentals(bool state);
 
        void SetUseRedisplayOtherLayerAccidentals(bool state);
 
    /*********************
     *** MISC. METHODS ***
     *********************/
    
    bool IsInstrumentChange();
 
#ifdef PDK_FRAMEWORK_PREFS
    FCStaffNamePosition* GetFullNamePosition() override
    {
        SetUseFullNamePosition(true);
        return __FCStaffBase::GetFullNamePosition();
    }
 
    FCStaffNamePosition* GetAbbreviatedNamePosition() override
    {
        SetUseAbbreviatedPosition(true);
        return __FCStaffBase::GetAbbreviatedNamePosition();
    }
#endif
 
        void GetName(FCString* pString);
 
    void SetName(FCString* pString);
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutBool("Is 2012 Instrument Change: ", IsInstrumentChange());
    }
#endif
};
 
 
 
class FCStaffStyleAssign : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStaffStyleAssign _staffstyleassign;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return ot_EDTStaffStyleAssign; }
    int DataSizeLoad() const override { return sizeof(EDTStaffStyleAssign); }
    void* Allocate() override { return (void*) &_staffstyleassign; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_staffstyleassign, ((FCStaffStyleAssign*)pSource)->_GetStaffStyleAssign(), sizeof(_staffstyleassign));
        _datablock = &_staffstyleassign;
        _loadedsize = sizeof(_staffstyleassign);
    }
 
    __FCBaseData* CreateObject() override
                { return new FCStaffStyleAssign(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCStaffStyleAssign"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STAFFSTYLEASSIGN; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetStaffStyleAssign() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCStaffStyleAssign() : __FCInciOther()
    {
        memset(&_staffstyleassign, 0, sizeof(_staffstyleassign));
        _datablock = &_staffstyleassign;
        _loadedsize = sizeof(_staffstyleassign);
        _staffstyleassign.range.end.edu = 0x7fffffff;
    }
 
    twobyte GetStyleID() const { return _staffstyleassign.style; };
 
    eMeas GetStartMeasure() const { return _staffstyleassign.range.start.meas; };
 
    TimeEdu32 GetStartMeasurePos() const { return _staffstyleassign.range.start.edu; };
 
    eMeas GetEndMeasure() const { return _staffstyleassign.range.end.meas; };
 
    TimeEdu32 GetEndMeasurePos() const { return _staffstyleassign.range.end.edu; };
 
    void SetStartMeasure(eMeas value) { _staffstyleassign.range.start.meas = value; }
 
    void SetStartMeasurePos(TimeEdu32 value) { _staffstyleassign.range.start.edu = value; }
 
    void SetEndMeasure(eMeas value) { _staffstyleassign.range.end.meas = value; }
 
    void SetEndMeasurePos(TimeEdu32 value) { _staffstyleassign.range.end.edu = value; }
 
    void SetStyleID(twobyte value) { _staffstyleassign.style = value; }
 
    eStaff GetStaff() const override { return _dataid.other.cmper; };
 
    void SetEndMeasurePosRight() { SetEndMeasurePos(0x7fffffff); }
 
    bool IsOverlapping(FCMusicRegion* pRegion)
    {
        if (!pRegion) return false;
        if (GetEndMeasure() < pRegion->GetStartMeasure()) return false;
        if (GetStartMeasure() > pRegion->GetEndMeasure()) return false;
        if (GetEndMeasure() == pRegion->GetStartMeasure())
        {
            if (GetEndMeasurePos() < pRegion->GetStartMeasurePos()) return false;
        }
        if (GetStartMeasure() == pRegion->GetEndMeasure())
        {
            if (GetStartMeasurePos() > pRegion->GetEndMeasurePos()) return false;
        }
        // Horizontally, it's an overlap - check the staff:
        if (pRegion->IsStaffIncluded(GetStaff())) return true;
        return false;
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
        DebugOutInt("Style ID: ", GetStyleID());
        DebugOutInt("Start measure: ", GetStartMeasure());
        DebugOutInt("End measure: ", GetEndMeasure());
    }
#endif
};
 
 
 
class FCMultiMeasureRest : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTMultimeasureRest _mmrest;
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return ot_MultimeasureRest; }
    int DataSizeLoad() const override { return sizeof(EDTMultimeasureRest); }
    void* Allocate() override { return (void*) &_mmrest; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_mmrest, ((FCMultiMeasureRest*)pSource)->_GetMMRest(), sizeof(_mmrest));
        _datablock = &_mmrest;
        _loadedsize = sizeof(_mmrest);
    }
 
    __FCBaseData* CreateObject() override { return new FCMultiMeasureRest(); }
 
    bool LoadFirst() override
    {
        Load(0);
        return LoadNext();
    }
 
    bool SaveNew() override { return false; }  // Disabled: Save() has to be used
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCMultiMeasureRest"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MULTIMEASUREREST; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetMMRest() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCMultiMeasureRest() : __FCNoInciOther()
    {
        memset(&_mmrest, 0, sizeof(_mmrest));
        SetWidth(300);  /* Just to set a width */
        _datablock = &_mmrest;
        _loadedsize = sizeof(_mmrest);
    }
 
    twobyte GetStartMeasure() const { return _dataid.other.cmper; }
 
    twobyte GetEndMeasure() const { return _mmrest.stopBefore - 1; }
 
    twobyte GetWidth() const { return _mmrest.measureWidth; }
 
    twobyte GetShapeID() const { return _mmrest.shape; }
 
    bool GetUseSymbols() const
    {
        return GetBitFlag(_mmrest.flag, MMREST_USE_SYMBOLS);
    }
 
    twobyte GetUseSymbolsLessThan() const
    {
        return _mmrest.symbolMeasures;
    }
 
    bool GetStretchHorizontally() const;
 
    twobyte GetShapeEndAdjust() const { return _mmrest.adjustEndPoint; }
 
    twobyte GetShapeStartAdjust() const { return _mmrest.adjustStartPoint; }
 
    twobyte GetSymbolSpace() const { return _mmrest.spaceBetween; }
 
    twobyte GetStartNumberingAt() const { return _mmrest.startNumbering; }
 
    twobyte GetNumberHorizontalAdjust() const { return _mmrest.horizNumberAdjust; }
 
    twobyte GetNumberVerticalAdjust() const { return _mmrest.vertNumberAdjust; }
 
    twobyte CalcMeasureSpan() { return GetEndMeasure() - GetStartMeasure() + 1; }
 
    void SetWidth(twobyte value) { _mmrest.measureWidth = value; }
 
    void SetStartMeasure(twobyte measure) { _dataid.other.cmper = measure; }
 
    void SetEndMeasure(twobyte measure) { _mmrest.stopBefore = measure + 1; }
 
    void SetShapeEndAdjust(twobyte value) { _mmrest.adjustEndPoint = value; }
 
    void SetShapeStartAdjust(twobyte value) { _mmrest.adjustStartPoint = value; }
 
    void SetShapeID(twobyte shapeID) { _mmrest.shape = shapeID; }
 
 
    void SetUseSymbols(bool value)
    {
        Set16BitFlag(&_mmrest.flag, MMREST_USE_SYMBOLS, value);
    }
 
    void SetUseSymbolsLessThan(twobyte value)
    {
        _mmrest.symbolMeasures = value;
    }
 
    void SetStretchHorizontally( bool value );
 
    void SetSymbolSpace(twobyte space) { _mmrest.spaceBetween = space; }
 
    void SetStartNumberingAt(twobyte value) { _mmrest.startNumbering = value; }
 
    void SetNumberHorizontalAdjust(twobyte value) { _mmrest.horizNumberAdjust = value; }
 
    void SetNumberVerticalAdjust(twobyte value) { _mmrest.vertNumberAdjust = value; }
 
    bool IsMeasureIncluded(int measure)
    {
        if (measure < GetStartMeasure()) return false;
        if (measure > GetEndMeasure()) return false;
        return true;
    }
 
    bool IsShape()
    {
        if (!GetUseSymbols()) return true;
        if (GetUseSymbolsLessThan() >= CalcMeasureSpan()) return true;
        return false;
    }
    
#ifdef PDK_FRAMEWORK_PREFS
    void PrefsReset();
#endif
 
    
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Start measure: ", GetStartMeasure());
        DebugOutInt("End measure: ", GetEndMeasure());
    }
#endif
};
 
#if FXT_VERSION >= FINALEVERSION_2012
class FCMultiStaffInstrument : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTMultiStaffInstGroup _multistaffinstgroup;
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return otx_MultiStaffInstGroup; }
    int DataSizeLoad() const override { return sizeof(EDTMultiStaffInstGroup); }
    void* Allocate() override { return (void*) &_multistaffinstgroup; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_multistaffinstgroup, ((FCMultiStaffInstrument*)pSource)->_GetMultiStaffInstGroup(), sizeof(_multistaffinstgroup));
        _datablock = &_multistaffinstgroup;
        _loadedsize = sizeof(_multistaffinstgroup);
    }
 
    __FCBaseData* CreateObject() override { return new FCMultiStaffInstrument(); }
 
    /*bool LoadFirst() override
    {
        Load(0);
        return LoadNext();
    } */
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCMultiStaffInstrument"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MULTISTAFFINSTRUMENT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetMultiStaffInstGroup() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCMultiStaffInstrument() : __FCNoInciOther()
    {
        memset(&_multistaffinstgroup, 0, sizeof(_multistaffinstgroup));
    }
 
    bool ContainsStaff(CMPER staffno)
    {
        if (staffno == 0) return false;
        if (staffno == GetFirstStaff()) return true;
        if (staffno == GetSecondStaff()) return true;
        if (staffno == GetThirdStaff()) return true;
        return false;
    }
 
    CMPER GetFirstStaff() const { return _multistaffinstgroup.staffNum1; }
 
    CMPER GetSecondStaff() const { return _multistaffinstgroup.staffNum2; }
 
    CMPER GetThirdStaff() const { return _multistaffinstgroup.staffNum3; }
 
    eStaffGroup GetGroupID() const
    {
        return _multistaffinstgroup.staffGroupID;
    }
 
 
    void SetFirstStaff(CMPER value) { _multistaffinstgroup.staffNum1 = value; }
 
    void SetSecondStaff(CMPER value) { _multistaffinstgroup.staffNum2 = value; }
 
    void SetThirdStaff(CMPER value) { _multistaffinstgroup.staffNum3 = value; }
 
    void SetGroupID(eStaffGroup value)
    {
        _multistaffinstgroup.staffGroupID = value;
    }
    
 
    CMPER CalcTopStaff()
    {
        CMPER returnvalue = 0;
        twobyte lowestslot = 10000;
        twobyte slottest = FX_InstToSlot(GetFirstStaff(), 0);
        if (slottest)
        {
            lowestslot = slottest;
            returnvalue = GetFirstStaff();
        }
        slottest = FX_InstToSlot(GetSecondStaff(), 0);
        if ((slottest) && (slottest < lowestslot))
        {
            lowestslot = slottest;
            returnvalue = GetSecondStaff();
        }
        slottest = FX_InstToSlot(GetThirdStaff(), 0);
        if ((slottest) && (slottest < lowestslot))
        {
            returnvalue = GetThirdStaff();
        }
        return returnvalue;
    }
 
    CMPER CalcBottomStaff()
    {
        CMPER returnvalue = 0;
        twobyte highestslot = -10000;
        twobyte slottest = FX_InstToSlot(GetFirstStaff(), 0);
        if (slottest)
        {
            highestslot = slottest;
            returnvalue = GetFirstStaff();
        }
        slottest = FX_InstToSlot(GetSecondStaff(), 0);
        if ((slottest) && (slottest > highestslot))
        {
            highestslot = slottest;
            returnvalue = GetSecondStaff();
        }
        slottest = FX_InstToSlot(GetThirdStaff(), 0);
        if ((slottest) && (slottest > highestslot))
        {
            returnvalue = GetThirdStaff();
        }
        return returnvalue;
    }
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("First staff: ", GetFirstStaff());
        DebugOutInt("Second staff: ", GetSecondStaff());
        DebugOutInt("Third staff: ", GetThirdStaff());
        DebugOutInt("Group ID: ", GetGroupID());
    }
#endif
};
#endif // #if FXT_VERSION >= FINALEVERSION_2012
 
 
class FCAllotment : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTAllotment _allotment;
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return ot_Allotment; }
    int DataSizeLoad() const override { return sizeof(EDTAllotment); }
    void* Allocate() override { return (void*) &_allotment; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_allotment, ((FCAllotment*)pSource)->_GetAllotment(), sizeof(_allotment));
        _datablock = &_allotment;
        _loadedsize = sizeof(_allotment);
    }
 
    __FCBaseData* CreateObject() override { return new FCAllotment(); }
 
    bool LoadFirst() override
    {
        if (!Load(0)) return LoadNext();
        return true;
    }
    
    bool LoadNext() override
    {
        EDTAllotment scratch;
        if (!FX_NextEData(Tag(), &_dataid, &scratch, sizeof(scratch), EnigmaVersion())) return false;
        return LoadDataBlock();
    }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCAllotment"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_ALLOTMENT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetAllotment() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCAllotment() : __FCNoInciOther()
    {
        memset(&_allotment, 0, sizeof(_allotment));
        _datablock = &_allotment;
        _loadedsize = sizeof(_allotment);
    }
 
    void SetWidth(Evpu16 width)
    {
        _allotment.allotment = width;
    }
 
 
    Evpu16 GetWidth() const
    {
        return _allotment.allotment;
    }
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutInt("Allotment Width: ", GetWidth());
    }
#endif
};
 
 
 
class FCPageGraphic : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTGraphic _graphic;
 
    EXTAG Tag() const override { return ot_PageGraphic; }
    int DataSizeLoad() const override { return sizeof(EDTTGraphic); }
    void* Allocate() override { return (void*) &_graphic; }
 
    EVERSION EnigmaVersion() const override { return FINALEVERSION_2010; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_graphic, ((FCPageGraphic*)pSource)->_GetGraphic(), sizeof(_graphic));
        _datablock = &_graphic;
        _loadedsize = sizeof(_graphic);
    }
 
    bool LoadFirst() override
    {
        SetCmperAndInci(0, 0);
        if (Load(0, 0)) return true; /* 0, 0 is a valid record! */
        return LoadNext();
    }
 
    bool SaveNew(CMPER) override
    { return false; }
    
    bool _RawRelink() override;
 
    __FCBaseData* CreateObject() override { return new FCPageGraphic(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
public:
    const char* ClassName() const override { return "FCPageGraphic"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PAGEGRAPHIC; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetGraphic() { return &_graphic; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 
    enum GRAPHIC_HORIZONTAL_ALIGN
    {
        GRAPHICHORIZALIGN_LEFT = 0,
        GRAPHICHORIZALIGN_RIGHT = 1,
        GRAPHICHORIZALIGN_CENTER = 2
    };
 
    enum GRAPHIC_VERTICAL_ALIGN
    {
        GRAPHICVERTALIGN_TOP = 0,
        GRAPHICVERTALIGN_BOTTOM = 1,
        GRAPHICVERTALIGN_CENTER = 2
    };
 
 
 
    FCPageGraphic() : __FCInciOther()
    {
        memset(&_graphic, 0, sizeof(_graphic));
    }
 
    bool IsEmbedded()
    {
        return MAKEBOOL(_graphic.graphicCmper);
    }
 
    int GetFirstPage() const
    {
        return _graphic.start;
    }
 
    int GetLastPage() const
    {
        return _graphic.end;
    }
    
    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); }
 
    bool GetPageEdgeRef() const { return GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_PAPER); }
    
    bool GetIndependentRightPage() const { return (_graphic.rightPgAlignFlags != 0); }
 
    Evpu16 GetHorizontalPosRightPage() const { return _graphic.rightPgLeft; }
 
    Evpu16 GetVerticalPosRightPage() const { return _graphic.rightPgBottom; }
 
    bool GetFixedPercent() const { return GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_FIXEDPERC); }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_HORIZONTAL_ALIGN
#else
    int
#endif
    GetHorizontalAlignment() const
    {
        if (GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_LEFT)) return GRAPHICHORIZALIGN_LEFT;
        if (GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_RIGHT)) return GRAPHICHORIZALIGN_RIGHT;
        return GRAPHICHORIZALIGN_CENTER;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_HORIZONTAL_ALIGN
#else
    int
#endif
    GetHorizontalAlignmentRightPage() const
    {
        if (GetBitFlag(_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_LEFT)) return GRAPHICHORIZALIGN_LEFT;
        if (GetBitFlag(_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_RIGHT)) return GRAPHICHORIZALIGN_RIGHT;
        return GRAPHICHORIZALIGN_CENTER;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_VERTICAL_ALIGN
#else
    int
#endif
    GetVerticalAlignment() const
    {
        if (GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_TOP)) return GRAPHICVERTALIGN_TOP;
        if (GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_BOTTOM)) return GRAPHICVERTALIGN_BOTTOM;
        return GRAPHICVERTALIGN_CENTER;
    }
 
    /* SETTERS */
    
    void SetFirstPage(int pageno)
    {
        _graphic.start = pageno;
    }
 
    void SetLastPage(int pageno)
    {
        _graphic.end = pageno;
    }
    
    void SetHorizontalPos(Evpu16 pos)
    {
        _graphic.left = pos;
        if (!GetIndependentRightPage()) SetHorizontalPosRightPage(pos);
    }
 
    void SetVerticalPos(Evpu16 pos)
    {
        _graphic.bottom = pos;
        if (!GetIndependentRightPage()) SetVerticalPosRightPage(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);
    }
 
    void SetPageEdgeRef(bool state)
    {
        Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_MARGINS, !state);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_PAPER, state);
    }
    
    void SetIndependentRightPage(bool state)
    {
        if (GetIndependentRightPage() == state) return;
        /* Copy the alignment */
        if (state)
            _graphic.rightPgAlignFlags = _graphic.alignFlags;
        else
            _graphic.rightPgAlignFlags = 0;
    }
 
    void SetHorizontalPosRightPage(Evpu16 value)
    {
        _graphic.rightPgLeft = value;
    }
 
    void SetVerticalPosRightPage(Evpu16 value)
    {
        _graphic.rightPgBottom = value;
    }
 
    void SetFixedPercent(bool state) { Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_FIXEDPERC, state); }
 
     void SetHorizontalAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_HORIZONTAL_ALIGN
#else
    FLAG_16
#endif
    alignment
     )
    {
         switch (alignment)
         {
             case GRAPHICHORIZALIGN_LEFT:
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_LEFT, true);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_RIGHT, false);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERH, false);
                 break;
             case GRAPHICHORIZALIGN_RIGHT:
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_LEFT, false);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_RIGHT, true);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERH, false);
                 break;
             default: /* Horizontally centered */
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_LEFT, false);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_RIGHT, false);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERH, true);
                 break;       
         }
         if (!GetIndependentRightPage()) SetHorizontalAlignmentRightPage(alignment);
    }
 
     void SetHorizontalAlignmentRightPage(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_HORIZONTAL_ALIGN
#else
    FLAG_16
#endif
     alignment)
    {
         switch (alignment)
         {
             case GRAPHICHORIZALIGN_LEFT:
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_LEFT, true);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_RIGHT, false);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERH, false);
                 break;
             case GRAPHICHORIZALIGN_RIGHT:
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_LEFT, false);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_RIGHT, true);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERH, false);
                 break;
             default: /* Horizontally centered */
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_LEFT, false);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_RIGHT, false);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERH, true);
                 break;
         }
    }
 
    void SetVerticalAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_VERTICAL_ALIGN
#else
    int
#endif
    alignment
    )
    {
        /* If GetIndependentRightPage() is ON, copy the vertical alignment
         * there as well (to make sure they are in synch). */
        switch (alignment)
        {
            case GRAPHICVERTALIGN_TOP:
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_TOP, true);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_BOTTOM, false);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERV, false);
                if (GetIndependentRightPage())
                {
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_TOP, true);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_BOTTOM, false);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERV, false);
                }
                break;
            case GRAPHICVERTALIGN_BOTTOM:
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_TOP, false);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_BOTTOM, true);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERV, false);
                if (GetIndependentRightPage())
                {
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_TOP, false);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_BOTTOM, true);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERV, false);
                }
                break;
            default:
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_TOP, false);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_BOTTOM, false);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERV, true);
                if (GetIndependentRightPage())
                {
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_TOP, false);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_BOTTOM, false);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERV, true);
                }
                break;
        }
    }
};
 
 
class FCTextRepeatDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTextRepeatStyle2005 _repeatdef;
 
protected:
    EXTAG Tag() const override { return ot_TextRepeatStyle; }
    int DataSizeLoad() const override { return sizeof(EDTTextRepeatStyle2005); }
    void* Allocate() override { return (void*) &_repeatdef; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_repeatdef, ((FCTextRepeatDef*)pSource)->_GetRepeatDef(), sizeof(_repeatdef));
        _datablock = &_repeatdef;
        _loadedsize = sizeof(_repeatdef);
    }
 
 
    bool LoadFirst() override
    {
        bool returnval = __FCNoInciOther::LoadFirst();
        if (!returnval) return false;
        /* Check that a string exists as well.
         * Otherwise, it might be possible that it returns true
         * even if there are no text repeats at all. */
        FCString* pString = CreateTextString();
        bool stringexists = !pString->IsEmpty();
        delete pString;
        return stringexists;
    }
 
 
    __FCBaseData* CreateObject() override { return new FCTextRepeatDef(); }
 
    bool _SaveTextAs(FCString* pString, CMPER itemno);
 
    bool _DeleteText();
 
    bool _DeleteEnclosure();
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    enum TEXT_REPEAT_JUSTIFICATION
    {
        TEXTREPJUST_LEFT = TEXT_REPEAT_LEFTJUST,
 
        TEXTREPJUST_RIGHT = TEXT_REPEAT_RITEJUST,
 
        TEXTREPJUST_CENTER = TEXT_REPEAT_CENTERED,
 
        TEXTREPJUST_FULL = TEXT_REPEAT_FULLJUST
    };
 
    enum REPEAT_REPLACE_MODE
    {
        REPEATREPLACE_TIMESPLAYED = 0,
 
        REPEATREPLACE_TARGETTEXT,
 
        REPEATREPLACE_TARGETMEASURE
    };
 
 
    const char* ClassName() const override { return "FCTextRepeatDef"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TEXTREPEATDEF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetRepeatDef() { return &_repeatdef; }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCTextRepeatDef();
 
    bool DeepSaveAs(CMPER itemno) override;
 
    bool DeepDeleteData() override
    {
        _DeleteEnclosure();
        _DeleteText();
        return DeleteData();
    }
        
    FCString* CreateTextString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateTextString_GC()
    { return makeLuaSharedPtr(CreateTextString()); }
#endif
    
    bool SaveTextString(FCString *pString);
 
    bool DeepSaveNew(FCString* pString, FCEnclosure* pEnclosure);
 
    FCEnclosure* CreateEnclosure();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCEnclosure> CreateEnclosure_GC()
    { return makeLuaSharedPtr(CreateEnclosure()); }
#endif
 
    bool SaveEnclosure(FCEnclosure* pEnclosure);
    
     void GetFontInfo(FCFontInfo* pInfo)
     {
         if (!pInfo) return;
         pInfo->SetNameByID(_repeatdef.font);
         pInfo->SetEnigmaStyles(_repeatdef.efx);
         pInfo->SetSize(_repeatdef.size);
     }
 
     void SetFontInfo(FCFontInfo* pInfo)
     {         
         if (!pInfo) return;         
         _repeatdef.font = pInfo->GetIDByName();
         _repeatdef.efx = pInfo->GetEnigmaStyles();
         _repeatdef.size = pInfo->GetSize();
     }
 
     bool GetUseThisFont() const
     {
         return GetBitFlag(_repeatdef.flag, TEXT_REPEAT_USETHISFONT);
     }
 
     void SetUseThisFont(bool state)
     {
         return Set16BitFlag(&_repeatdef.flag, TEXT_REPEAT_USETHISFONT, state);
     }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     TEXT_REPEAT_JUSTIFICATION
#else
     int 
#endif
     GetJustification() const;
 
     void SetJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     TEXT_REPEAT_JUSTIFICATION
#else
     int
#endif
     value
     );
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     REPEAT_REPLACE_MODE
#else
     int
#endif
     GetReplaceMode() const;
 
     
    void SetReplaceMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     REPEAT_REPLACE_MODE
#else
     int
#endif
    value
    );
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
    }
#endif
 
};
 
 
class FCSeparatePlacements;
 
class FCTextRepeat : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTextRepeat2005 _textrepeat;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return ot_TextRepeat2005; }
    int DataSizeLoad() const override { return sizeof(EDTTextRepeat2005); }
    void* Allocate() override { return (void*) &_textrepeat; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_textrepeat, ((FCTextRepeat*)pSource)->_GetTextRepeat(), sizeof(_textrepeat));
        _datablock = &_textrepeat;
        _loadedsize = sizeof(_textrepeat);
    }
 
    __FCBaseData* CreateObject() override { return new FCTextRepeat(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCTextRepeat"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TEXTREPEAT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetTextRepeat() { return &_textrepeat; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    enum REPSHOWMODES
    {
        REPSHOW_ALL = 0,
 
        REPSHOW_TOPSTAFF,
 
        REPSHOW_STAFFLIST
    };
 
    enum REPTARGETTRIGGERS
    {   
        REPTARGET_UNDEFINED = 0,
 
        REPTARGET_DEFID = 3,
 
        REPTARGET_MEASURENUM = 1,
 
        REPTARGET_BACKWARDS = 2,
 
        REPTARGET_NEVERSKIPENDING = 5,
 
        REPTARGET_FORWARDS = 8,
 
        REPTARGET_NEXTENDING = 9
    };
       
 
    enum REPACTIONS
     {
        REPACTION_NEVERJUMP = 0,
 
        REPACTION_ALWAYSJUMP = 1,
 
        REPACTION_JUMPONPASS = 2,
 
        REPACTION_PLAYSECTION = 3,
 
        REPACTION_STOPONPASS = 4
     };
 
    FCTextRepeat() : __FCInciOther()
    {
        memset(&_textrepeat, 0, sizeof(_textrepeat));
        _datablock = &_textrepeat;
        _loadedsize = sizeof(_textrepeat);
    }
 
    bool AssignTextRepeatDef(FCTextRepeatDef* pDef);
 
 
    FCTextRepeatDef* CreateTextRepeatDef();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCTextRepeatDef> CreateTextRepeatDef_GC()
    { return makeLuaSharedPtr(CreateTextRepeatDef()); }
#endif
 
    FCSeparatePlacements* CreateSeparatePlacements();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCSeparatePlacements> CreateSeparatePlacements_GC()
    { return makeLuaSharedPtr(CreateSeparatePlacements()); }
#endif
 
    twobyte GetID() const { return _textrepeat.repnum; }
 
    void SetID(twobyte id) { _textrepeat.repnum = id; }
 
    Evpu16 GetHorizontalPos() const { return _textrepeat.horzPos; }
 
    void SetHorizontalPos(Evpu32 value) { _textrepeat.horzPos = value; }
 
    Evpu16 GetVerticalPos() const { return _textrepeat.vertPos; }
 
    void SetVerticalPos(Evpu32 value) { _textrepeat.vertPos = value; }
 
    int GetTarget() const { return _textrepeat.target; }
 
    void SetTarget(int value) { _textrepeat.target = value; }
 
    bool GetAutoUpdateTarget() const { return GetBitFlag(_textrepeat.flag, TXTRPT_AUTOUPDATE); }
 
    void SetAutoUpdateTarget(bool state) { Set16BitFlag(&_textrepeat.flag, TXTRPT_AUTOUPDATE, state); }
 
    bool GetIndividualPositioning() const
    {
        return GetBitFlag(_textrepeat.flag, TXTRPT_INDIVPLAC);
    }
 
    void SetIndividualPositioning(bool state)
    {
        Set16BitFlag(&_textrepeat.flag, TXTRPT_INDIVPLAC, state);
    }
    
    bool GetVisible() const
    {
        return !GetBitFlag(_textrepeat.flag, 0x4000); // this is a reverse bit
    }
 
    void SetVisible(bool state)
    {
        Set16BitFlag(&_textrepeat.flag, 0x4000, !state);
    }
 
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPSHOWMODES
#else
    int
#endif
    GetShowMode() const;
 
    void SetShowMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPSHOWMODES
#else
    int
#endif
    mode);
 
    twobyte GetStaffListID() const {  return _textrepeat.staffList; }
 
    void SetStaffListID(twobyte list)
    {
        if (list < 0) return;
        _textrepeat.staffList = list;
        Set16BitFlag(&_textrepeat.flag, TXTRPT_TOPSTAFFONLY, false);
    }
 
    twobyte GetTotalPasses() const {  return _textrepeat.actuate; }
 
    void SetTotalPasses(twobyte totalpasses)
    {        
        _textrepeat.actuate = totalpasses;
    }
 
 
    bool GetJumpIfIgnore() const { return GetBitFlag(_textrepeat.flag, TXTRPT_JMPIGNORE); }
 
    void SetJumpIfIgnore(bool state) { Set16BitFlag(&_textrepeat.flag, TXTRPT_JMPIGNORE, state); }
 
 
    bool GetResetOnRepeat() const { return GetBitFlag(_textrepeat.flag, TXTRPT_CLRonCHANGE); }
 
    void SetResetOnRepeat(bool state) { Set16BitFlag(&_textrepeat.flag, TXTRPT_CLRonCHANGE, state); }
 
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPTARGETTRIGGERS
#else
    int
#endif
    GetTargetTrigger() const;
 
    void SetTargetTrigger(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPTARGETTRIGGERS
#else
    int
#endif
    mode);
 
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPACTIONS
#else
    int
#endif
    GetAction() const;
 
    void SetAction(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPACTIONS
#else
    int
#endif
    mode);
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
        DebugOutHex("FCTextRepeat:flag: ", _textrepeat.flag);
    }
#endif
};
 
 
class FCExecutableShapeDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTExecutableShapeDef _executableshapedef;
 
protected:
    EXTAG Tag() const override { return ot_ExecutableShapeDef; }
    int DataSizeLoad() const override { return sizeof(EDTExecutableShapeDef); }
    void* Allocate() override { return (void*) &_executableshapedef; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_executableshapedef, ((FCExecutableShapeDef*)pSource)->_GetExecutableShapeDef(), sizeof(_executableshapedef));
        _datablock = &_executableshapedef;
        _loadedsize = sizeof(_executableshapedef);
    }
 
    bool LoadNext() override
    {
        EDataID olddataID = _dataid;
        _dataid.other.cmper ++;
        if (LoadDataBlock()) return true;
        _dataid = olddataID;
        return false;
    }
 
    __FCBaseData* CreateObject() override { return new FCExecutableShapeDef(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCExecutableShapeDef"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_EXECUTABLESHAPEDEF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetExecutableShapeDef() { return &_executableshapedef; }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCExecutableShapeDef() : __FCNoInciOther() {}
 
    twobyte GetShapeID() { return _executableshapedef.shapeID; }
 
    void SetShapeID(twobyte shapeID) { _executableshapedef.shapeID = shapeID; }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
    }
#endif
 
};
 
 
class FCChordSuffixElement : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTChordSuffix _chordsuffixold;
#if FXT_VERSION >= FINALEVERSION_2012
    EDTChordSuffix2012 _chordsuffix2012;
#endif
protected:
    bool _Use2012Version() const;
 
    EXTAG Tag() const override { return ot_ChordSuffix; }
    int DataSizeLoad() const override 
    {        
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return sizeof(EDTChordSuffix2012);
#endif     
        return sizeof(EDTChordSuffix);
    }
    void* Allocate() override
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return (void*) &_chordsuffix2012;
#endif
        return (void*) &_chordsuffixold;
    }
    EVERSION EnigmaVersion() const override 
    {
        if (_Use2012Version()) return FINALEVERSION_2012;
        return FINALEVERSION_2010;
    }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override;
 
    __FCBaseData* CreateObject() override { return new FCChordSuffixElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCChordSuffixElement"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CHORDSUFFIXELEMENT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetDataPtr() 
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_chordsuffix2012;
#endif
        return &_chordsuffixold;
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCChordSuffixElement();
 
    void GetFontInfo(FCFontInfo* pFontInfo);
 
    void SetFontInfo(FCFontInfo* pFontInfo);
 
    eUniChar32 GetSymbol() const;
 
    void SetSymbol(eUniChar32 symbol);
 
    bool GetNumberRepresentation() const;
 
    void SetNumberRepresentation(bool state);
 
    bool GetPrefixFlat() const;
 
    void SetPrefixFlat(bool state);
 
    bool GetPrefixSharp() const;
 
    void SetPrefixSharp(bool state);
 
    bool GetPrefixPlus() const;
 
    void SetPrefixPlus(bool state);
 
    bool GetPrefixMinus() const;
 
    void SetPrefixMinus(bool state);
 
    twobyte GetHorizontalOffset() const;
 
    void SetHorizontalOffset(twobyte value);
 
    twobyte GetVerticalOffset() const;
 
    void SetVerticalOffset(twobyte value);
        
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
    }
#endif
};
 
 
#if FXT_VERSION >= FINALEVERSION_2012
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
// the conversion to Unicode names may have happened before Finale 25, but
// we only support 64-bit Finale in 2023, so no extra effort is going into
// supporting 32-bit versions.
#if FXT_VERSION >= FINALEVERSION_25
const EXTAG __ot_FRETSTYLE = MAKEEXTAG(MAKETAG(edMultiInciOther,31), 'f','t');
const int __MAX_FRET_NAME_LEN       = 48 * sizeof(eUniChar16);    // Max number of characters of names of
const int __MAX_FRET_NUM_TEXT_LEN   = 24 * sizeof(eUniChar16);
#else
const EXTAG __ot_FRETSTYLE = MAKEEXTAG(MAKETAG(edMultiInciOther,13), 'f','t');
const int __MAX_FRET_NAME_LEN       = 48;    // Max number of characters of names of
const int __MAX_FRET_NUM_TEXT_LEN   = 24;
#endif
 
 
#include "pragma_align_begin.h"
struct __FCFretStyle    // ot_FRETSTYLE (1 logical incidences, 14 physical incidences (0..13))
                                        // cmper comes from EDTChord2010::fbStyleID
{
        // start of physical incident 0 (0 based)
        tbool           showLastFret;                   // Show the last fret when drawing fretboards
        tbool           rotate;                                 // Rotate the diagram so the nut is on the left
        tbool           fingNumWhite;                   // Draw fingering numbers white.
 
        // CMPERs of the various shapes that can be drawn on the fretboard diagram. When these
        // are zero, the hardcoded shapes will be used. (Hardcoded shapes are designed to look
        // like the Seville Font.)
 
        eShape          fingStrShapeID;                 // ID of ot_SHAPEDEF record used for drawing
                                                                                // a fingered (closed) string shape
        eShape          openStrShapeID;                 // ID of ot_SHAPEDEF record used for drawing
                                                                                // an open string shape
        eShape          muteStrShapeID;                 // ID of ot_SHAPEDEF record used for drawing
                                                                                // a muted string shape
        // start of physical incident 1 (0 based)
        eShape          barreShapeID;                   // ID of ot_SHAPEDEF record used for drawing
                                                                                // the fretboard barre shape
        eShape          customShapeID;                  // ID of the ot_SHAPEDEF record used for
                                                                                // drawing the user defined shape
        utwobyte        defNumFrets;                    // The number of frets to show by default in this style
 
        // Following are the high and low twobyte fields that, together, designate various
        // Efix32 values for the fretboard style.
 
        twobyte         stringGapHi;                    // High and low twobyte values for
        twobyte         stringGapLo;                    // Efix32 string gap (right edge to right edge)
 
        twobyte         fretGapHi;                              // High and low twobyte values for
        // start of physical incident 2 (0 based)
        twobyte         fretGapLo;                              // Efix32 fret gap (bottom edge to bottom edge)
 
        twobyte         stringWidthHi;                  // High and low twobyte values for
        twobyte         stringWidthLo;                  // Efix32 width of strings
 
        twobyte         fretWidthHi;                    // High and low twobyte values for
        twobyte         fretWidthLo;                    // Efix32 width of frets
 
        twobyte         nutWidthHi;                             // High and low twobyte values for
        // start of physical incident 3 (0 based)
        twobyte         nutWidthLo;                             // Efix32 width of the nut
 
        twobyte         vertTextOffHi;                  // High and low twobyte values for
        twobyte         vertTextOffLo;                  // Efix32 vert offset of fret number text
 
        twobyte         horzTextOffHi;                  // High and low twobyte values for
        twobyte         horzTextOffLo;                  // Efix32 horz offset of fret number text
 
        twobyte         horzHandleOffHi;                // High and low twobyte values for
        // start of physical incident 4 (0 based)
        twobyte         horzHandleOffLo;                // Efix32 horz offset of the fretboard's handle
 
        twobyte         vertHandleOffHi;                // High and low twobyte values for
        twobyte         vertHandleOffLo;                // Efix32 vert offset of the fretboard's handle
 
        twobyte         whiteoutHi;                             // High and low twobyte values for
        twobyte         whiteoutLo;                             // Efix32 whiteout of strings for fingering numbers
 
        // Font information
 
        EFONTID         fretNumFontID;                  // Font ID, size and EFX data for the
        // start of physical incident 5 (0 based)
        FontPoints16    fretNumFontSize;                // fret number font. (Designates which
        FLAG_16         fretNumFontEfx;                 // fret is the first shown in the diagram
 
        EFONTID         fingNumFontID;                  // Font ID, size and EFX data for the
        FontPoints16    fingNumFontSize;                // fingering numbers font used in the.
        FLAG_16         fingNumFontEfx;                 // fretboard diagrams
 
        // Fingering number offsets
        twobyte         horzFingNumOffHi;               // High and low twobyte values for
        // start of physical incident 6 (0 based)
        twobyte         horzFingNumOffLo;               // Efix32 horizontal finger number offset
 
        twobyte         vertFingNumOffHi;               // High and low twobyte values for
        twobyte         vertFingNumOffLo;               // Efix32 vertical finger number offset
 
        twobyte         pad[3];                                 // Unused--padding to make size mult of OTSIZE
 
#if FXT_VERSION >= FINALEVERSION_25
    // start of physical incident 7 (0 based)
    eUniChar16  name[__MAX_FRET_NAME_LEN];    // The name of the fretboard style
 
    // start of physical incident 23 (0 based)
    eUniChar16  fretNumText[__MAX_FRET_NUM_TEXT_LEN];
                                                // The text to display after the
                                                // fret number (e.g., 'fr' or 'fret')
    // end of physical incident 30 (0 based)
#else
        // start of physical incident 7 (0 based)
        ECHAR           name[__MAX_FRET_NAME_LEN];      // The name of the fretboard style
 
    // start of physical incident 11 (0 based)
        ECHAR           fretNumText[__MAX_FRET_NUM_TEXT_LEN];
                                                                                                // The text to display after the
                                                                                                // fret number (e.g., 'fr' or 'fret')
        // end of physical incident 12 (0 based)
#endif
};
#include "pragma_align_end.h"
 
#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
 
class FCFretboardStyleDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        /* The data storage for the object. */
        __FCFretStyle _fretstyledef;
 
protected:
        EXTAG Tag() const override { return __ot_FRETSTYLE; }
        int DataSizeLoad() const override { return sizeof(__FCFretStyle); }
        void* Allocate() override { return (void*)&_fretstyledef; }
        EVERSION EnigmaVersion() const override { return FINALEVERSION_2010; }
 
        void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_fretstyledef, ((FCFretboardStyleDef*)pSource)->_GetFretStyleDef(), sizeof(_fretstyledef));
        _datablock = &_fretstyledef;
        _loadedsize = sizeof(_fretstyledef);
    }
 
        bool LoadNext() override
        {
                EDataID olddataID = _dataid;
                _dataid.other.cmper++;
                if (LoadDataBlock()) return true;
                _dataid = olddataID;
                return false;
        }
 
        __FCBaseData* CreateObject() override { return new FCFretboardStyleDef(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
        const char* ClassName() const override { return "FCFretboardStyleDef"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_FRETBOARDSTYLEDEF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        void* _GetFretStyleDef() { return &_fretstyledef; }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
        FCFretboardStyleDef() : __FCNoInciOther()
    {
        memset(&_fretstyledef, 0, sizeof(_fretstyledef));
        _datablock = &_fretstyledef;
        _loadedsize = sizeof(_fretstyledef);
    }
        
    // *******
    // GETTERS
    // *******
    
        void GetName(FCString* pString) const
    {
        if (!pString) return;
#if FXT_VERSION >= FINALEVERSION_25
        pString->SetUnicodeString(_fretstyledef.name);
#else
        pString->SetCString(_fretstyledef.name);
#endif
    }
 
        Efix32 GetStringSpacing() const { return MAKELONG(_fretstyledef.stringGapLo, _fretstyledef.stringGapHi); }
 
        Efix32 GetStringThickness() const { return MAKELONG(_fretstyledef.stringWidthLo, _fretstyledef.stringWidthHi); }
 
        Efix32 GetFretSpacing() const { return MAKELONG(_fretstyledef.fretGapLo, _fretstyledef.fretGapHi); }
 
        Efix32 GetFretThickness() const { return MAKELONG(_fretstyledef.fretWidthLo, _fretstyledef.fretWidthHi); }
 
        Efix32 GetNutThickness() const { return MAKELONG(_fretstyledef.nutWidthLo, _fretstyledef.nutWidthHi); }
 
        Efix32 GetHorizontalFingeringOffset() const { return MAKELONG(_fretstyledef.horzFingNumOffLo, _fretstyledef.horzFingNumOffHi); }
 
        Efix32 GetVerticalFingeringOffset() const { return MAKELONG(_fretstyledef.vertFingNumOffLo, _fretstyledef.vertFingNumOffHi); }
 
        Efix32 GetFingeringWhiteout() const { return MAKELONG(_fretstyledef.whiteoutLo, _fretstyledef.whiteoutHi); }
 
        Efix32 GetHorizontalHandleOffset() const { return MAKELONG(_fretstyledef.horzHandleOffLo, _fretstyledef.horzHandleOffHi); }
 
        Efix32 GetVerticalHandleOffset() const { return MAKELONG(_fretstyledef.vertHandleOffLo, _fretstyledef.vertHandleOffHi); }
 
        void GetFretNumberText(FCString* pString) const
        {
                if (!pString) return;
#if FXT_VERSION >= FINALEVERSION_25
        pString->SetUnicodeString(_fretstyledef.fretNumText);
#else
                pString->SetCString(_fretstyledef.fretNumText);
#endif
        }
 
        Efix32 GetHorizontalFretNumberOffset() const { return MAKELONG(_fretstyledef.horzTextOffLo, _fretstyledef.horzTextOffHi); }
 
        Efix32 GetVerticalFretNumberOffset() const { return MAKELONG(_fretstyledef.vertTextOffLo, _fretstyledef.vertTextOffHi); }
 
        int GetFretCountDefault() const { return _fretstyledef.defNumFrets; }
 
        bool GetShowLastFret() const { return _fretstyledef.showLastFret != 0; }
        
        bool GetRotate() const { return _fretstyledef.rotate != 0;  }   
 
        bool GetDrawFingeringWhite() const { return _fretstyledef.fingNumWhite != 0; }
 
    twobyte GetFingeredShapeID() const
    {
        return _fretstyledef.fingStrShapeID;
    }
 
    twobyte GetOpenStringShapeID() const
    {
        return _fretstyledef.openStrShapeID;
    }
 
    twobyte GetMuteStringShapeID() const
    {
        return _fretstyledef.muteStrShapeID;
    }
 
    twobyte GetBarreShapeID() const
    {
        return _fretstyledef.barreShapeID;
    }
 
    twobyte GetCustomShapeID() const
    {
        return _fretstyledef.customShapeID;
    }
 
        void GetFingeringFontInfo(FCFontInfo* pFontInfo)
        {
                if (!pFontInfo) return;
                pFontInfo->SetNameByID(_fretstyledef.fingNumFontID);
                pFontInfo->SetSize(_fretstyledef.fingNumFontSize);
                pFontInfo->SetEnigmaStyles(_fretstyledef.fingNumFontEfx);
        }
 
        void GetFretNumberFontInfo(FCFontInfo* pFontInfo)
        {
                if (!pFontInfo) return;
                pFontInfo->SetNameByID(_fretstyledef.fretNumFontID);
                pFontInfo->SetSize(_fretstyledef.fretNumFontSize);
                pFontInfo->SetEnigmaStyles(_fretstyledef.fretNumFontEfx);
        }
 
    // *******
    // SETTERS
    // *******
    
        void SetName(const FCString* pString)
    {
        if (!pString) return;
        memset(&_fretstyledef.name, 0, sizeof(_fretstyledef.name));
#if FXT_VERSION >= FINALEVERSION_25
        pString->CopyToUnicodeBuffer(_fretstyledef.name, DIM(_fretstyledef.name));
#else
        strncpy(_fretstyledef.name, pString->GetCString(), sizeof(_fretstyledef.name) - 1);
#endif
    }
    
        void SetStringSpacing(Efix32 value)
    {
        _fretstyledef.stringGapLo = LOWORD(value);
        _fretstyledef.stringGapHi = HIWORD(value);
    }
    
        void SetStringThickness(Efix32 value)
    {
        _fretstyledef.stringWidthLo = LOWORD(value);
        _fretstyledef.stringWidthHi = HIWORD(value);
    }
    
        void SetFretSpacing(Efix32 value)
    {
        _fretstyledef.fretGapLo = LOWORD(value);
        _fretstyledef.fretGapHi = HIWORD(value);
    }
    
        void SetFretThickness(Efix32 value)
    {
        _fretstyledef.fretWidthLo = LOWORD(value);
        _fretstyledef.fretWidthHi = HIWORD(value);
    }
    
        void SetNutThickness(Efix32 value)
    {
        _fretstyledef.nutWidthLo = LOWORD(value);
        _fretstyledef.nutWidthHi = HIWORD(value);
    }
    
        void SetHorizontalFingeringOffset(Efix32 value)
    {
        _fretstyledef.horzFingNumOffLo = LOWORD(value);
        _fretstyledef.horzFingNumOffHi = HIWORD(value);
    }
    
        void SetVerticalFingeringOffset(Efix32 value)
    {
        _fretstyledef.vertFingNumOffLo = LOWORD(value);
        _fretstyledef.vertFingNumOffHi = HIWORD(value);
    }
    
        void SetFingeringWhiteout(Efix32 value)
    {
        _fretstyledef.whiteoutLo = LOWORD(value);
        _fretstyledef.whiteoutHi = HIWORD(value);
    }
    
        void SetHorizontalHandleOffset(Efix32 value)
    {
        _fretstyledef.horzHandleOffLo = LOWORD(value);
        _fretstyledef.horzHandleOffHi = HIWORD(value);
    }
    
        void SetVerticalHandleOffset(Efix32 value)
    {
        _fretstyledef.vertHandleOffLo = LOWORD(value);
        _fretstyledef.vertHandleOffHi = HIWORD(value);
    }
    
        void SetFretNumberText(const FCString* pString)
        {
                if (!pString) return;
        memset(&_fretstyledef.fretNumText, 0, sizeof(_fretstyledef.fretNumText));
#if FXT_VERSION >= FINALEVERSION_25
        pString->CopyToUnicodeBuffer(_fretstyledef.fretNumText, DIM(_fretstyledef.fretNumText));
#else
        strncpy(_fretstyledef.fretNumText, pString->GetCString(), sizeof(_fretstyledef.fretNumText) - 1);
#endif
        }
    
        void SetHorizontalFretNumberOffset(Efix32 value)
    {
        _fretstyledef.horzTextOffLo = LOWORD(value);
        _fretstyledef.horzTextOffHi = HIWORD(value);
    }
    
        void SetVerticalFretNumberOffset(Efix32 value)
    {
        _fretstyledef.vertTextOffLo = LOWORD(value);
        _fretstyledef.vertTextOffHi = HIWORD(value);
    }
    
        void SetFretCountDefault(int value) { _fretstyledef.defNumFrets = value; }
    
        void SetShowLastFret(bool state) { _fretstyledef.showLastFret = state; }
        
        void SetRotate(bool state) { _fretstyledef.rotate = state;  }
    
        void SetDrawFingeringWhite(bool state) { _fretstyledef.fingNumWhite = state; }
 
    void SetFingeredShapeID(twobyte value)
    {
        _fretstyledef.fingStrShapeID = value;
    }
 
    void SetOpenStringShapeID(twobyte value)
    {
        _fretstyledef.openStrShapeID = value;
    }
 
    void SetMuteStringShapeID(twobyte value)
    {
        _fretstyledef.muteStrShapeID = value;
    }
 
    void SetBarreShapeID(twobyte value)
    {
        _fretstyledef.barreShapeID = value;
    }
 
    void SetCustomShapeID(twobyte value)
    {
        _fretstyledef.customShapeID = value;
    }
 
        void SetFingeringFontInfo(FCFontInfo* pFontInfo)
        {
                if (!pFontInfo) return;
                _fretstyledef.fingNumFontID = pFontInfo->GetIDByName();
                _fretstyledef.fingNumFontSize = pFontInfo->GetSize();
                _fretstyledef.fingNumFontEfx = pFontInfo->GetEnigmaStyles();
        }
    
        void SetFretNumberFontInfo(FCFontInfo* pFontInfo)
        {
                if (!pFontInfo) return;
                _fretstyledef.fretNumFontID = pFontInfo->GetIDByName();
                _fretstyledef.fretNumFontSize = pFontInfo->GetSize();
                _fretstyledef.fretNumFontEfx = pFontInfo->GetEnigmaStyles();
        }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
    }
#endif
 
};
 
#endif // FXT_VERSION >= FINALEVERSION_2012
 
 
#if FXT_VERSION >= FINALEVERSION_2012
 
class FCFretboardGroupDef : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTFretGroup2012 _fretgroup;
 
protected:
    EXTAG Tag() const override { return otx_FretGroup; }
    int DataSizeLoad() const override { return sizeof(EDTFretGroup2012); }
    void* Allocate() override { return (void*) &_fretgroup; }
    EVERSION EnigmaVersion() const override { return FINALEVERSION_2012; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_fretgroup, ((FCFretboardGroupDef*)pSource)->_GetDataPtr(), sizeof(_fretgroup));
        _datablock = &_fretgroup;
        _loadedsize = sizeof(_fretgroup);
    }
 
    __FCBaseData* CreateObject() override { return new FCFretboardGroupDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCFretboardGroupDef"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_FRETBOARDGROUPDEF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetDataPtr() { return &_fretgroup; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCFretboardGroupDef() : __FCInciOther() {}
 
    bool LoadFirst() override
    {
        return Load(1, 0);
    }
 
    twobyte _GetInci() { return _dataid.other.inci; }
    
    FCFretInstrumentDef* CreateFretInstrumentDef() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFretInstrumentDef> CreateFretInstrumentDef_GC()
    { return makeLuaSharedPtr(CreateFretInstrumentDef()); }
#endif
 
    FCFretboardGroup* CreateFretboardGroup() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFretboardGroup> CreateFretboardGroup_GC()
    { return makeLuaSharedPtr(CreateFretboardGroup()); }
#endif
 
    CMPER GetFretInstrumentID() const { return _fretgroup.fretInstID; }
    
    void SetFretInstrumentID(CMPER value) { _fretgroup.fretInstID = value; }
    
    void GetName(FCString* pString) const { pString->SetUnicodeString(_fretgroup.name); }
    
    void SetName(const FCString* pString) { pString->CopyToUnicodeBuffer(_fretgroup.name, DIM(_fretgroup.name)); }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
    }
#endif
};
 
#endif
 
 
 
class FCEndingRepeat : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    /* Data is dynamically stored! */
 
protected:
    EXTAG Tag() const override { return ot_EndingRepeat; }
 
    void _AllocateMemory(int size);
 
    int DataSizeLoad() const override;
    int DataSizeSave() const override;
    void* Allocate() override;
    void Deallocate() override;
    bool IsDynamicSize() override { return true; }
    
    __FCBaseData* CreateObject() override { return new FCEndingRepeat(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    const char* ClassName() const override { return "FCEndingRepeat"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_ENDINGREPEAT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EDTEndingRepeat2005* _TypeCast() const { return (EDTEndingRepeat2005*) _datablock; }     
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCEndingRepeat() : __FCNoInciOther()
    {
        _AllocateMemory(sizeof(EDTEndingRepeat2005));
    }
 
    bool DeepDeleteData() override;
 
    bool DeepSaveAs(CMPER itemno) override;
    
    twobyte GetStaffListID() const {  return _TypeCast()->staffList; }
 
    bool GetSkipOnIgnore() const
    {
        return GetBitFlag(_TypeCast()->flag, EndRepeat_JMPIGNORE);
    }
 
    eMeas GetTargetMeasure() const
    {
        return _TypeCast()->nextend;
    }
 
    bool GetIndividualPositioning() const
    {
        return GetBitFlag(_TypeCast()->flag, EndRepeat_INDIVPLAC);
    }
 
    bool GetVisible() const
    {
        return !GetBitFlag(_TypeCast()->flag, 0x0004); // this is a reverse bit
    }
 
    Evpu16 GetVerticalTopBracketPosition() const
    {
        return _TypeCast()->line2;
    }
 
    Evpu16 GetHorizontalLeftBracketPosition() const
    {
        return _TypeCast()->pos;
    }
    
    Evpu16 GetVerticalLeftBracketPosition() const
    {
        return _TypeCast()->line;
    }
 
    Evpu16 GetHorizontalRightBracketPosition() const
    {
        return _TypeCast()->pos2;
    }
    
    Evpu16 GetVerticalRightBracketPosition() const
    {
        return _TypeCast()->endline;
    }
    
    Evpu16 GetHorizontalTextPosition() const
    {
        return _TypeCast()->textpos;
    }
 
    Evpu16 GetVerticalTextPosition() const
    {
        return _TypeCast()->textline;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPSHOWMODES
#else
    int
#endif
    GetShowMode() const;
    
    int GetPassNumbersCount() const { return _TypeCast()->numTotalPasses; }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
FCTextRepeat::REPTARGETTRIGGERS
#else
int
#endif
    GetTargetTrigger() const
    {
        switch (_TypeCast()->flag & EndRepeat_ACTION_BITS)
        {
            case 0:
                return FCTextRepeat::REPTARGET_NEXTENDING;
            case 0x10:
                return FCTextRepeat::REPTARGET_MEASURENUM;
            case 0x20:
                return FCTextRepeat::REPTARGET_FORWARDS;
            case 0x50:
                return FCTextRepeat::REPTARGET_NEVERSKIPENDING;
            default:
                return FCTextRepeat::REPTARGET_UNDEFINED;
        }
    }
 
    void SetStaffListID(twobyte list)
    {
        if (list < 0) return;
        _TypeCast()->staffList = list;
        Set16BitFlag(&_TypeCast()->flag, EndRepeat_TOPSTAFFONLY, false);
    }
    
    void SetSkipOnIgnore(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, EndRepeat_JMPIGNORE, state);
    }
 
    void SetTargetMeasure(eMeas measure)
    {
        _TypeCast()->nextend = measure;
    }
 
    void SetIndividualPositioning(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, EndRepeat_INDIVPLAC, state);
    }
 
    void SetVisible(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, 0x004, !state);
    }
 
    void SetVerticalTopBracketPosition(Evpu16 position)
    {
        _TypeCast()->line2 = position;
    }
 
    void SetHorizontalLeftBracketPosition(Evpu16 position)
    {
        _TypeCast()->pos = position;
    }
    
    void SetVerticalLeftBracketPosition(Evpu16 position)
    {
        _TypeCast()->line = position;
    }
 
    void SetHorizontalRightBracketPosition(Evpu16 position)
    {
        _TypeCast()->pos2 = position;
    }
    
    void SetVerticalRightBracketPosition(Evpu16 position)
    {
        _TypeCast()->endline = position;
    }
 
    void SetHorizontalTextPosition(Evpu16 position)
    {
        _TypeCast()->textpos = position;
    }
    
    void SetVerticalTextPosition(Evpu16 position)
    {
        _TypeCast()->textline = position;
    }
 
   
    void SetShowMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPSHOWMODES
#else
    int
#endif
    mode);
    
    
    FCString* CreateTextString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateTextString_GC()
    { return makeLuaSharedPtr(CreateTextString()); }
#endif
    
    bool SaveTextString(FCString* pString);
 
    bool GetPassNumbers(FCNumbers* pNumbers);
 
    bool SetPassNumbers(FCNumbers* pNumbers);
 
    void SetTargetTrigger(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
FCTextRepeat::REPTARGETTRIGGERS
#else
int
#endif
    value
    )
    {
        switch (value)
        {
            case FCTextRepeat::REPTARGET_MEASURENUM:
                _TypeCast()->flag &= ~EndRepeat_ACTION_BITS;
                _TypeCast()->flag |= 0x10;
                break;
            case FCTextRepeat::REPTARGET_FORWARDS:
                _TypeCast()->flag &= ~EndRepeat_ACTION_BITS;
                _TypeCast()->flag |= 0x20;
                break;
            case FCTextRepeat::REPTARGET_NEVERSKIPENDING:
                _TypeCast()->flag &= ~EndRepeat_ACTION_BITS;
                _TypeCast()->flag |= 0x50;
                break;
            case FCTextRepeat::REPTARGET_NEXTENDING:
                _TypeCast()->flag &= ~EndRepeat_ACTION_BITS;
                break;
                        case FCTextRepeat::REPTARGET_UNDEFINED:
                        case FCTextRepeat::REPTARGET_DEFID:
                        case FCTextRepeat::REPTARGET_BACKWARDS:
                                break;
       }
    }
 
 
    FCSeparatePlacements* CreateSeparatePlacements();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCSeparatePlacements> CreateSeparatePlacements_GC()
    { return makeLuaSharedPtr(CreateSeparatePlacements()); }
#endif
 
    FCSeparatePlacements* CreateTextSeparatePlacements();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCSeparatePlacements> CreateTextSeparatePlacements_GC()
    { return makeLuaSharedPtr(CreateTextSeparatePlacements()); }
#endif
};
 
 
class FCBackwardRepeat : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS     
    EDTBackwardRepeat2005 _backwardrepeat;
 
protected:
    EXTAG Tag() const override { return ot_BackwardRepeat; }
    int DataSizeLoad() const override { return sizeof(EDTBackwardRepeat2005); }
    void* Allocate() override { return (void*) &_backwardrepeat; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_backwardrepeat, ((FCBackwardRepeat*)pSource)->_GetBackwardRepeat(), sizeof(_backwardrepeat));
        _datablock = &_backwardrepeat;
        _loadedsize = sizeof(_backwardrepeat);
    }
 
    __FCBaseData* CreateObject() override { return new FCBackwardRepeat(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    const char* ClassName() const override { return "FCBackwardRepeat"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_BACKWARDREPEAT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetBackwardRepeat() { return &_backwardrepeat; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCBackwardRepeat() : __FCNoInciOther()
    {
        memset(&_backwardrepeat, 0, sizeof(_backwardrepeat));
        _datablock = &_backwardrepeat;
        _loadedsize = sizeof(_backwardrepeat);
    }
 
 
    eMeas GetTargetMeasure() const
    {
        return _backwardrepeat.target;
    }
 
    bool GetIndividualPositioning() const
    {
        return GetBitFlag(_backwardrepeat.flag, BackRepeat_INDIVPLAC);
    }
 
    bool GetVisible() const
    {
        return !GetBitFlag(_backwardrepeat.flag, 0x4000); // this is a reverse bit
    }
 
    twobyte GetTotalPasses() const
    {
        return _backwardrepeat.actuate;
    }
 
    Evpu16 GetTopBracketPosition() const
    {
        return _backwardrepeat.line2;
    }
 
    Evpu16 GetBottomBracketPosition() const
    {
        return _backwardrepeat.line1;
    }
 
    Evpu16 GetRightBracketPosition() const
    {
        return _backwardrepeat.pos1;
    }
 
    Evpu16 GetLeftBracketPosition() const
    {
        return _backwardrepeat.pos2;
    }
 
    twobyte GetStaffListID() const
    {
        return _backwardrepeat.staffList;
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPSHOWMODES
#else
    int
#endif
    GetShowMode() const
    {
        if (GetBitFlag(_backwardrepeat.flag, BackRepeat_TOPSTAFFONLY)) return FCTextRepeat::REPSHOW_TOPSTAFF;
        if (_backwardrepeat.staffList) return FCTextRepeat::REPSHOW_STAFFLIST;
        return FCTextRepeat::REPSHOW_ALL;
    }
 
    void SetShowMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPSHOWMODES
#else
    int
#endif
    mode)
    {
        switch (mode)
        {
            case FCTextRepeat::REPSHOW_TOPSTAFF:
                Set16BitFlag(&_backwardrepeat.flag, BackRepeat_TOPSTAFFONLY, true);
                _backwardrepeat.staffList = 0;
                break;
            case FCTextRepeat::REPSHOW_STAFFLIST:
                Set16BitFlag(&_backwardrepeat.flag, BackRepeat_TOPSTAFFONLY, false);
                if (!_backwardrepeat.staffList) _backwardrepeat.staffList = 1;
                break;
            case FCTextRepeat::REPSHOW_ALL:
                Set16BitFlag(&_backwardrepeat.flag, BackRepeat_TOPSTAFFONLY, false);
                _backwardrepeat.staffList = 0;
                break;
        }
    }
 
 
    void SetTargetMeasure(eMeas measure)
    {
        _backwardrepeat.target = measure;
    }
 
    void SetIndividualPositioning(bool state)
    {
        return Set16BitFlag(&_backwardrepeat.flag, BackRepeat_INDIVPLAC, state);
    }
 
    void SetVisible(bool state)
    {
        return Set16BitFlag(&_backwardrepeat.flag, 0x4000, !state);
    }
 
    void SetTotalPasses(twobyte passes)
    {
        _backwardrepeat.actuate = passes;
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
FCTextRepeat::REPTARGETTRIGGERS
#else
int
#endif
    GetTargetTrigger() const
    {        
        switch (_backwardrepeat.flag & BackRepeat_ACTION_BITS)
        {
            case 0:
                return FCTextRepeat::REPTARGET_NEXTENDING;
            case 0x10:
                return FCTextRepeat::REPTARGET_MEASURENUM;
            case 0x20:
                return FCTextRepeat::REPTARGET_FORWARDS;
            default:
                return FCTextRepeat::REPTARGET_UNDEFINED;
        }
    }
 
    bool GetResetOnRepeatAction() const
    {
        return GetBitFlag(_backwardrepeat.flag, BackRepeat_CLRonCHANGE);
    }
 
    void SetTopBracketPosition(Evpu16 position)
    {
        _backwardrepeat.line2 = position;
    }
 
    void SetBottomBracketPosition(Evpu16 position)
    {
        _backwardrepeat.line1 = position;
    }
 
    void SetRightBracketPosition(Evpu16 position)
    {
        _backwardrepeat.pos1 = position;
    }
 
    void SetLeftBracketPosition(Evpu16 position)
    {
        _backwardrepeat.pos2 = position;
    }
 
    void SetStaffListID(twobyte stafflistid)
    {
        _backwardrepeat.staffList = stafflistid;
    }
 
    void SetTargetTrigger(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
FCTextRepeat::REPTARGETTRIGGERS
#else
int
#endif
    value
    )
    {
        switch (value)
        {
            case FCTextRepeat::REPTARGET_MEASURENUM:
                _backwardrepeat.flag &= ~BackRepeat_ACTION_BITS;
                _backwardrepeat.flag |= 0x10;
                break;
            case FCTextRepeat::REPTARGET_FORWARDS:
                _backwardrepeat.flag &= ~BackRepeat_ACTION_BITS;
                _backwardrepeat.flag |= 0x20;
                break;            
            case FCTextRepeat::REPTARGET_NEXTENDING:
                _backwardrepeat.flag &= ~BackRepeat_ACTION_BITS;
                break;
                        case FCTextRepeat::REPTARGET_UNDEFINED:
                        case FCTextRepeat::REPTARGET_DEFID:
                        case FCTextRepeat::REPTARGET_BACKWARDS:
                        case FCTextRepeat::REPTARGET_NEVERSKIPENDING:
                                break;
        }
    }
 
    void SetResetOnRepeatAction(bool state)
    {
        Set16BitFlag(&_backwardrepeat.flag, BackRepeat_CLRonCHANGE, state);
    }
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPACTIONS
#else
    int
#endif
    GetAction() const
    {
        switch (_backwardrepeat.flag & 0xc00)
        {
            case 0x00:
                return FCTextRepeat::REPACTION_ALWAYSJUMP;
            case 0x400:
                return FCTextRepeat::REPACTION_JUMPONPASS;
            case 0x800:
                return FCTextRepeat::REPACTION_PLAYSECTION;
            default:
                break;
        }
    
#ifdef PDK_FRAMEWORK_DEBUG
    DebugOutHex("Undefined flag state for FCBackwardRepeat:GetAction: ", _backwardrepeat.flag);
#endif
        return FCTextRepeat::REPACTION_ALWAYSJUMP;
    }
 
    void SetAction(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPACTIONS
#else
    int
#endif
    mode)
    {
        switch (mode)
        {
            case FCTextRepeat::REPACTION_ALWAYSJUMP:
                /* 0x0c40 bits should all be off */
                Set16BitFlag(&_backwardrepeat.flag, 0x0c00, false);
                break;
 
            case FCTextRepeat::REPACTION_JUMPONPASS:
                /* 0x0400 (in the 0x0c40 bit set) represents the "jump on pass" */
                Set16BitFlag(&_backwardrepeat.flag, 0x0c00, false);
                Set16BitFlag(&_backwardrepeat.flag, 0x0400, true);                
                break;
 
            case FCTextRepeat::REPACTION_PLAYSECTION:
                /* 0x0800 (in the 0x0c40 bit set) represents the "play section" */
                Set16BitFlag(&_backwardrepeat.flag, 0x0c00, false);
                Set16BitFlag(&_backwardrepeat.flag, 0x0800, true);                
                break;
        
            case FCTextRepeat::REPACTION_NEVERJUMP:
            case FCTextRepeat::REPACTION_STOPONPASS:
                                break;
        }
    }
 
    FCSeparatePlacements* CreateSeparatePlacements();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCSeparatePlacements> CreateSeparatePlacements_GC()
    { return makeLuaSharedPtr(CreateSeparatePlacements()); }
#endif
 
};
 
 
class FCBeatChartElement : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    struct __FCEDTBeatChartHeader
    {
       TimeEdu32 totalDur;        // total duration of beat chart (should be equal to total duration of measure)
       Evpu16 totalWidth;        // total "ideal width" (equal to last nextposi in array)
       Evpu16 minWidth;        // final minpos value
       Evpu16 allotWidth;
       tbool incizero;         // always 1
    };
 
    EDTBeatChartElement _beatchartelement;
    
    const __FCEDTBeatChartHeader* _GetDataAsHeader() const
    { return reinterpret_cast<const __FCEDTBeatChartHeader*>(&_beatchartelement); }
    
    __FCEDTBeatChartHeader* _GetDataAsHeader()
    { return reinterpret_cast<__FCEDTBeatChartHeader*>(&_beatchartelement); }
 
protected:
    EXTAG Tag() const override { return ot_BeatChartElement; }
    int DataSizeLoad() const override { return sizeof(EDTBeatChartElement); }
    void* Allocate() override { return (void*) &_beatchartelement; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_beatchartelement, ((FCBeatChartElement*)pSource)->_GetBeatChartElement(), sizeof(_beatchartelement));
        _datablock = &_beatchartelement;
        _loadedsize = sizeof(_beatchartelement);
    }
 
    __FCBaseData* CreateObject() override { return new FCBeatChartElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    const char* ClassName() const override { return "FCBeatChartElement"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_BEATCHARTELEMENT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetBeatChartElement() { return &_beatchartelement; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCBeatChartElement() : __FCInciOther()
    {
        memset(&_beatchartelement, 0, sizeof(_beatchartelement));
        _datablock = &_beatchartelement;
        _loadedsize = sizeof(_beatchartelement);
    }
 
    TimeEdu32 GetMeasurePos() const override { return _beatchartelement.dura; }
 
    Evpu16 GetHorizontalPosition() const { return _beatchartelement.posi; }
 
    Evpu16 GetNextHorizontalPosition() const
    {
        if (GetInitElement()) return 0;
        return _beatchartelement.nextposi;
    }
 
    Evpu16 GetMinimumPosition() const
    {
        if (GetInitElement()) return 0;
        return _beatchartelement.minpos;
    }
 
    TimeEdu32 GetTotalDuration() const
    {
        if (!GetInitElement()) return 0;
        return _GetDataAsHeader()->totalDur;
    }
 
    Evpu16 GetFullSpan() const
    {
        if (!GetInitElement()) return 0;
        return _GetDataAsHeader()->totalWidth;
    }
 
    Evpu16 GetMinimumWidth() const
    {
        if (!GetInitElement()) return 0;
        return _GetDataAsHeader()->minWidth;
    }
 
    Evpu16 GetReferenceWidth() const
    {
        if (!GetInitElement()) return 0;
        return _GetDataAsHeader()->allotWidth;
    }
 
    bool GetInitElement() const { return _beatchartelement.incizero != 0; }
 
    Evpu16 CalcWidth()
    {
        if (GetInitElement()) return 0;
        return (GetNextHorizontalPosition() - GetHorizontalPosition());
    }
    
    void SetMeasurePos(TimeEdu32 edupos) { _beatchartelement.dura = edupos; }
 
    void SetWidth(Evpu16 width) 
    {
        if (GetInitElement()) return;
        _beatchartelement.nextposi = width + _beatchartelement.posi;
    }
 
    void SetHorizontalPosition(Evpu16 position)
    {
        if (GetInitElement()) return;
        _beatchartelement.posi = position;
    }
 
    void SetNextHorizontalPosition(Evpu16 value)
    {
        if (GetInitElement()) return;
        _beatchartelement.nextposi = value;
    }
 
    void SetMinimumPosition(Evpu16 value)
    {
        if (GetInitElement()) return;
        _beatchartelement.minpos = value;
    }
 
    void SetTotalDuration(TimeEdu32 dura)
    {
        if (!GetInitElement()) return;
        _GetDataAsHeader()->totalDur = dura;
    }
 
    void SetFullSpan(Evpu16 span)
    {
        if (!GetInitElement()) return;
        _GetDataAsHeader()->totalWidth = span;
    }
 
    void SetMinimumWidth(Evpu16 width)
    {
        if (!GetInitElement()) return;
        _GetDataAsHeader()->minWidth = width;
    }
 
    void SetReferenceWidth(Evpu16 width)
    {
        if (!GetInitElement()) return;
        _GetDataAsHeader()->allotWidth = width;
    }
 
    bool MoveHorizontalPosition(Evpu16 offset, FCBeatChartElements* pBeatChart);
    
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
        DebugOutInt("Measure Pos: ", GetMeasurePos());
        DebugOutInt("Horizontal Position: ", GetHorizontalPosition());
        DebugOutInt("Minimum position: ", GetMinimumPosition());
        DebugOutInt("Next horizontal position:", GetNextHorizontalPosition());
        DebugOutBool("Init element: ", GetInitElement());
    }
#endif
};
 
 
class FCTempoElement : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTempo _tempo;
 
protected:
    EXTAG Tag() const override { return ot_Tempo; }
    int DataSizeLoad() const override { return sizeof(EDTTempo); }
    void* Allocate() override { return (void*) &_tempo; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_tempo, ((FCTempoElement*)pSource)->_GetTempoElement(), sizeof(_tempo));
        _datablock = &_tempo;
        _loadedsize = sizeof(_tempo);
    }
 
    __FCBaseData* CreateObject() override { return new FCTempoElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    const char* ClassName() const override { return "FCTempoElement"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TEMPOELEMENT; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetTempoElement() { return &_tempo; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCTempoElement() : __FCInciOther()
    {
        memset(&_tempo, 0, sizeof(_tempo));
        _tempo.unit = 1000;
        _datablock = &_tempo;
        _loadedsize = sizeof(_tempo);
    }
 
    void SetMeasurePos(twobyte edupos) { _tempo.eldur = edupos; }
 
    TimeEdu32 GetMeasurePos() const override { return _tempo.eldur; }
 
    bool GetAbsolute() const { return _tempo.flag == TIMEDIAL_ABSOLUTE; }
 
    void SetAbsolute(bool value)
    {
        _tempo.flag = value ? TIMEDIAL_ABSOLUTE : TIMEDIAL_RELATIVE;
    }
 
    fourbyte GetRatio() const { return _tempo.ratio; }
 
    void SetRatio(fourbyte value) { _tempo.ratio = value; }
 
    float CalcValue()
    {
        if (GetAbsolute())
        {            
            float result = _tempo.ratio * _tempo.unit;            
            result /= 65536;            
            /* The value here is relative to 60 BPM == 1024 */
            result *= 60;            
            result /= 1024;            
            /* Round it off to 2 decimals */
            fourbyte fb = (fourbyte) (result * 100);
            result = fb;
            result /= 100;
            return result;
        }
        else
        {
            /* Relative */
            float result = GetRatio();
            result /= 10;
            return result;
        }
    }
 
    void SetAbsoluteValue(float value)
    {
        SetAbsolute(true);
        _tempo.unit = 1000;
        value *= 1024;
        value /= 60;
        value *= 65536;
        value /= 1000;
        _tempo.ratio = (fourbyte) value;
    }
 
    void SetRelativeValue(float value)
    {
        SetAbsolute(false);
        SetRatio((fourbyte) (value * 10));
    }
};
 
 
 
#ifdef PDK_FRAMEWORK_TINYXML
class FCPercussionMapNote : public __FCBase
{
    int _midikey;
    PERC_NOTE_TYPE _notetype;
    FCString _name;
public:
    enum PERCUSSION_NOTE_TYPES {
        PERCNOTETYPE_BASSDRUM = 13,
        PERCNOTETYPE_BELLTREE = 70,
        PERCNOTETYPE_BONGO_HIGH = 32,
        PERCNOTETYPE_BONGO_LOW = 33,
        PERCNOTETYPE_CONGA = 36,
        PERCNOTETYPE_COWBELL = 6,
        PERCNOTETYPE_CASTANETS = 362,
        PERCNOTETYPE_CYMBAL_CHINA = 17,
        PERCNOTETYPE_CYMBAL_CRASH = 4,
        PERCNOTETYPE_CYMBAL_RIDE = 18,
        PERCNOTETYPE_CYMBAL_SIZZLE = 121,
        PERCNOTETYPE_CYMBAL_SPLASH = 21,
        PERCNOTETYPE_CLAVES = 35,
        PERCNOTETYPE_GONG_SMALL = 137,
        PERCNOTETYPE_GONG_MEDIUM = 136,
        PERCNOTETYPE_GONG_LARGE = 135,
        PERCNOTETYPE_HIHAT_CLOSED = 15,
        PERCNOTETYPE_HIHAT_FOOT = 16,
        PERCNOTETYPE_HIHAT_OPEN = 14,
        PERCNOTETYPE_KICKDRUM = 2,
        PERCNOTETYPE_RHYTHMCUES = 235,
        PERCNOTETYPE_ROTOTOM_MID = 321,
        PERCNOTETYPE_SIDEDRUM = 279,
        PERCNOTETYPE_SNAREDRUM = 1,
        PERCNOTETYPE_TAMBOURINE = 7,
        PERCNOTETYPE_TAMTAM = 149,
        PERCNOTETYPE_TOM_HIGH = 24,
        PERCNOTETYPE_TOM_HIGHMID = 25,
        PERCNOTETYPE_TOM_LOW = 27,
        PERCNOTETYPE_TRIANGLE_MUTE = 8,
        PERCNOTETYPE_TRIANGLE_OPEN = 9,
        PERCNOTETYPE_VIBRASLAP = 12,
        PERCNOTETYPE_WINDCHIMES = 460,
        PERCNOTETYPE_WOODBLOCK_HIGH = 10
    };
 
    FCPercussionMapNote(int midikey, int notetype, const char* pszName) : __FCBase()
    {
        _midikey = midikey;
        _notetype = notetype;
        _name.SetCString(pszName);
    }
    const char* ClassName() const override { return "FCPercussionMapNote"; }
 
    PERC_NOTE_TYPE GetRawNoteType() const { return _notetype; }
 
    PERC_NOTE_TYPE GetNoteType() const { return _notetype & 0x0fff; }
 
    twobyte GetOrderID() const
    {
        twobyte returnvalue = _notetype & 0xf000;
        returnvalue /= 0x1000;
        return returnvalue;
    }
 
    int GetMidiNote() const { return _midikey; }
 
    const char* GetName() const { return _name.GetCString(); }
};
 
 
class FCPercussionMapNotes : public __FCCollection
{
    twobyte _percussionid;
public:
 
    FCPercussionMapNotes(twobyte percussionid) : __FCCollection()
    {
       _percussionid = percussionid;
    }
 
    twobyte GetPercussionID() const { return _percussionid; }
 
    const char* ClassName() const override { return "FCPercussionMapNotes"; }
 
    FCPercussionMapNote* GetItemAt(int index) const { return (FCPercussionMapNote*) __FCCollection::GetItemAt(index); }
 
    FCPercussionMapNote* FindRawNoteType(PERC_NOTE_TYPE rawnotetype)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCPercussionMapNote* pItem = GetItemAt(i);
            if (pItem->GetRawNoteType() == rawnotetype) return pItem;
        }
        return NULL;
    }
 
    FCPercussionMapNote* FindMidiNote(twobyte midinote)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCPercussionMapNote* pItem = GetItemAt(i);
            if (pItem->GetMidiNote() == midinote) return pItem;
        }
        return NULL;
    }
};
 
class FCInstrumentDef;
 
class FCPercussionMapNotesLookup : public __FCCollection
{
    public:
        const char* ClassName() const override { return "FCPercussionMapNotesLookup"; }
 
        FCPercussionMapNotesLookup() : __FCCollection() {}
 
        FCPercussionMapNotes* GetPercussionMapNotes(FCInstrumentDef* pInstrumentDef);        
};
 
#endif /*PDK_FRAMEWORK_TINYXML*/
 
 
class FCPercussionLayoutNotes;
class FCPercussionLayoutNote;
 
class FCPercussionLayoutNotesLookup : public __FCCollection
{
public:
    const char* ClassName() const override { return "FCPercussionLayoutNotesLookup"; }
 
    FCPercussionLayoutNotesLookup() : __FCCollection() {}
    
    FCPercussionLayoutNotes* GetPercussionLayoutNotes(FCPercussionStaff* pPercussionStaff);
    
    FCPercussionLayoutNote* FindPercussionLayoutRawNote(FCPercussionStaff* pPercussionStaff, FLAG_16 percussionnote);
 
    FCPercussionLayoutNotes* GetItemAt(int index) const { return (FCPercussionLayoutNotes*) __FCCollection::GetItemAt(index); }
};
 
 
 
class FCInstrumentDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTInstDefinition _instrumentdef;
 
protected:
    EXTAG Tag() const override { return ot_InstDefinition; }
    int DataSizeLoad() const override { return sizeof(EDTInstDefinition); }
    void* Allocate() override { return (void*) &_instrumentdef; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_instrumentdef, ((FCInstrumentDef*)pSource)->_GetInstrumentDef(), sizeof(_instrumentdef));
        _datablock = &_instrumentdef;
        _loadedsize = sizeof(_instrumentdef);
    }
 
    __FCBaseData* CreateObject() override { return new FCInstrumentDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    const char* ClassName() const override { return "FCInstrumentDef"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_INSTRUMENTDEF; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetInstrumentDef() { return &_instrumentdef; }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCInstrumentDef() : __FCNoInciOther() {}
 
    FCString* CreateNameString()
    {
        FCInstrumentDefText text;
        text.Load(GetItemNo());
        return text.CreateString();
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateNameString_GC()
    { return makeLuaSharedPtr(CreateNameString()); }
#endif
 
    twobyte GetVirtualChannel() const { return _instrumentdef.virtChannel; }
 
    twobyte GetPercussionMapID() const { return _instrumentdef.percMapRefID; }
 
    void SetPercussionMapID(twobyte mapID) { _instrumentdef.percMapRefID = mapID; }
 
#ifdef PDK_FRAMEWORK_TINYXML
    FCPercussionMapNotes* CreatePercussionMapNotes();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCPercussionMapNotes> CreatePercussionMapNotes_GC()
    { return makeLuaSharedPtr(CreatePercussionMapNotes()); }
#endif
#endif // PDK_FRAMEWORK_TINYXML
 
        bool GetPercussionMapLocation(void* pFileSpecLocation, FCString* pMapName, EVERSION finpathspecversion);
        
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        this->DebugDataDump();
    }
#endif
 
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
#include "pragma_align_begin.h"
struct __EDTLayerPlayData
{
        ePlaybackRoute playbackRouteNum;        // twobyte
        twobyte velControlLevel;
        FLAG_16 velControlSaveFlags;
        FLAG_16 playFlags;
};
#include "pragma_align_end.h"
 
#include "pragma_align_begin.h"
struct __EDTPlayData2006
{
        __EDTLayerPlayData chordPlayData;
        __EDTLayerPlayData MIDIExpressionsPlayData;
        __EDTLayerPlayData layerPlayData[4];    // Should be MAX_LAYERS
};
#include "pragma_align_end.h"
 
const EXTAG __ot_PlayData2006   = MAKEEXTAG(edOther4Inci,'P','L');
 
// __EDTLayerPlayData.playFlags
const FLAG_16 __PLAY_LAYER_TRACK = 0x0001;
const FLAG_16 __SOLO_LAYER_TRACK = 0x0002;
 
 
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
 
class FCLayerPlaybackData : public __FCBase
{
    __EDTLayerPlayData* _pLayerData;
public:
    FCLayerPlaybackData(__EDTLayerPlayData* pData) : __FCBase()
    {
        _pLayerData = pData;
    }
    const char* ClassName() const override { return "FCLayerPlaybackData"; }
 
    ePlaybackRoute GetInstrumentDefID() const
    {
        /* The value is 0-based!!! To be able to map to FCInstrumentDef, it
         * needs to be 1-based. */
        return _pLayerData->playbackRouteNum + 1;  
    }
 
    bool GetPlay() const
    {
        return GetBitFlag(_pLayerData->playFlags, __PLAY_LAYER_TRACK);
    }
 
    bool GetSolo() const
    {
        return GetBitFlag(_pLayerData->playFlags, __SOLO_LAYER_TRACK);
    }
 
    void SetInstrumentDefID(ePlaybackRoute value)
    {
        /* The value is 0-based!!! (To be able to map to FCInstrumentDef, it
         * needs to be 1-based.) */
        _pLayerData->playbackRouteNum = value - 1;
    }
 
    void SetPlay(bool state)
    {
        return Set16BitFlag(&_pLayerData->playFlags, __PLAY_LAYER_TRACK, state);
    }
 
    void SetSolo(bool state)
    {
        return Set16BitFlag(&_pLayerData->playFlags, __SOLO_LAYER_TRACK, state);
    }
};
 
 
class FCInstrumentPlaybackData : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __EDTPlayData2006 _playbackdata;
 
    std::unique_ptr<FCLayerPlaybackData> _pChordLayer;
    std::unique_ptr<FCLayerPlaybackData> _pExpressionLayer;
    std::vector<std::unique_ptr<FCLayerPlaybackData>> _pNoteLayers;
 
protected:
    EXTAG Tag() const override { return __ot_PlayData2006; }
    int DataSizeLoad() const override { return sizeof(__EDTPlayData2006); }
    void* Allocate() override { return (void*) &_playbackdata; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_playbackdata, ((FCInstrumentPlaybackData*)pSource)->_GetPlaybackData(), sizeof(_playbackdata));
        _datablock = &_playbackdata;
        _loadedsize = sizeof(_playbackdata);
    }
 
    __FCBaseData* CreateObject() override { return new FCInstrumentPlaybackData(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    const char* ClassName() const override { return "FCInstrumentPlaybackData"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_INSTRUMENTPLAYBACKDATA; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetPlaybackData() { return &_playbackdata; }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCInstrumentPlaybackData() : __FCNoInciOther(), _pNoteLayers(DIM(_playbackdata.layerPlayData))
    {}
 
    FCLayerPlaybackData* GetChordLayerData()
    {
        if (!DataIsLoaded()) return NULL;
        if (!_pChordLayer)
            _pChordLayer = std::make_unique<FCLayerPlaybackData>(FCLayerPlaybackData(&_playbackdata.chordPlayData));
        return _pChordLayer.get();
    }
 
    FCLayerPlaybackData* GetMidiExpressionLayerData()
    {        
        if (!DataIsLoaded()) return NULL;
        if (!_pExpressionLayer)
            _pExpressionLayer = std::make_unique<FCLayerPlaybackData>(FCLayerPlaybackData(&_playbackdata.MIDIExpressionsPlayData));
        return _pExpressionLayer.get();
    }
 
    FCLayerPlaybackData* GetNoteLayerData(int layernumber)
    {
        if ((layernumber < 1) || (layernumber > _pNoteLayers.size())) return NULL;
        if (!DataIsLoaded()) return NULL;
        layernumber--;  /* Make a 0-based index */
        if (!_pNoteLayers[layernumber])
            _pNoteLayers[layernumber] = std::make_unique<FCLayerPlaybackData>(FCLayerPlaybackData(&_playbackdata.layerPlayData[layernumber]));
        return _pNoteLayers[layernumber].get();
    }
    
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugDataDump();
    }
#endif
 
};
 
class FCPercussionLayoutNote : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTPercussionNoteDef2010 _percussionnotedef2010;
#if FXT_VERSION >= FINALEVERSION_2012
    EDTPercussionNoteDef2012 _percussionnotedef2012;
#endif
 
    EVERSION _VersionToUse() const;
 
protected:
    EXTAG Tag() const override;    
    
    int DataSizeLoad() const override;
    
    void* Allocate() override;
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(_GetPercussionNoteDef(), ((FCPercussionLayoutNote*)pSource)->_GetPercussionNoteDef(), DataSizeLoad());
        _datablock = _GetPercussionNoteDef();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCPercussionLayoutNote(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    const char* ClassName() const override { return "FCPercussionLayoutNote"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PERCUSSIONLAYOUTNOTE; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetPercussionNoteDef();
    
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCPercussionLayoutNote() : __FCInciOther() {
        memset(Allocate(), 0, DataSizeLoad());
    }
 
    PERC_NOTE_TYPE GetRawNoteType() const;
 
    PERC_NOTE_TYPE GetNoteType() const;
 
    twobyte GetOrderID() const;
 
    twobyte GetStaffPosition() const;
 
    fourbyte GetClosedNotehead() const;
 
    fourbyte GetHalfNotehead() const;
 
    fourbyte GetWholeNotehead() const;
 
    fourbyte GetDoubleWholeNotehead() const;
    
 
 
    void SetNoteType(PERC_NOTE_TYPE value);
 
    void SetOrderID(twobyte value);
 
    void SetStaffPosition(twobyte value);
 
    void SetClosedNotehead(fourbyte value);
 
    void SetHalfNotehead(fourbyte value);
 
    void SetWholeNotehead(fourbyte value);
 
    void SetDoubleWholeNotehead(fourbyte value);
 
#ifdef PDK_FRAMEWORK_TINYXML
    twobyte CalcMidiRawNote(FCPercussionMapNotes* pNotes);
 
    twobyte CalcMidiNote(FCPercussionMapNotes* pNotes);
#endif
 
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCInciOther::DebugDump();
    }
#endif
 
};
 
 
 
/* Previously undocumented stuff */
const EXTAG __ot_CategoryStaffListScore = MAKEEXTAG(edOther, 'C', 's');
const EXTAG __ot_CategoryStaffListParts = MAKEEXTAG(edOther, 'C', 'p');
const EXTAG __ot_CategoryStaffListScoreOverride = MAKEEXTAG(edOther, 'c',
'o');
const EXTAG __ot_CategoryStaffListPartsOverride = MAKEEXTAG(edOther, 'C',
'o');
 
 
const EXTAG __ot_StaffAssignStaffListScore      = MAKEEXTAG(edOther, 'S', 's');
const EXTAG __ot_StaffAssignStaffListParts = MAKEEXTAG(edOther, 's', 'p');
const EXTAG __ot_StaffAssignStaffListScoreOverride = MAKEEXTAG(edOther, 'S',
'o');
const EXTAG __ot_StaffAssignStaffListPartsOverride = MAKEEXTAG(edOther, 's',
'o');
 
 
class FCStaffList : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStaffList* _TypeCast() const { return (EDTStaffList*)_datablock; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return GetCustomTag() ? GetCustomTag() : ot_StaffListDataScore; }
 
    int DataSizeLoad() const override;
    int DataSizeSave() const override;
    void* Allocate() override;
    void Deallocate() override;
    bool IsDynamicSize() override { return true; }
 
    __FCBaseData* CreateObject() override { return new FCStaffList(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    enum STAFFLIST_MODES
    {
        SLMODE_SCORE = 0,
        SLMODE_PARTS,
        SLMODE_FORCESCORE,
        SLMODE_FORCEPARTS,
 
        SLMODE_CATEGORY_SCORE,
        SLMODE_CATEGORY_PARTS,
        SLMODE_CATEGORY_FORCESCORE,
        SLMODE_CATEGORY_FORCEPARTS,
 
        SLMODE_ASSIGNMENT_SCORE,
        SLMODE_ASSIGNMENT_PARTS,
        SLMODE_ASSIGNMENT_FORCESCORE,
        SLMODE_ASSIGNMENT_FORCEPARTS
    };
 
 
    FCStaffList() : __FCNoInciOther()
    {
    }
 
    const char* ClassName() const override { return "FCStaffList"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STAFFLIST; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetStaffListElement() { return _datablock; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
 
    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STAFFLIST_MODES
#else
    int
#endif
    mode
    )
    {
        switch (mode)
        {
            case SLMODE_SCORE:
                SetCustomTag(ot_StaffListDataScore);
                break;
            case SLMODE_PARTS:
                SetCustomTag(ot_StaffListDataParts);
                break;
            case SLMODE_FORCESCORE:
                SetCustomTag(ot_StaffListForceScore);
                break;
            case SLMODE_FORCEPARTS:
                SetCustomTag(ot_StaffListForceParts);
                break;
 
            case SLMODE_CATEGORY_SCORE:
                SetCustomTag(__ot_CategoryStaffListScore);
                break;
            case SLMODE_CATEGORY_PARTS:
                SetCustomTag(__ot_CategoryStaffListParts);
                break;
            case SLMODE_CATEGORY_FORCESCORE:
                SetCustomTag(__ot_CategoryStaffListScoreOverride);
                break;
            case SLMODE_CATEGORY_FORCEPARTS:
                SetCustomTag(__ot_CategoryStaffListPartsOverride);
                break;
 
            case SLMODE_ASSIGNMENT_SCORE:
                SetCustomTag(__ot_StaffAssignStaffListScore);
                break;
            case SLMODE_ASSIGNMENT_PARTS:
                SetCustomTag(__ot_StaffAssignStaffListParts);
                break;
            case SLMODE_ASSIGNMENT_FORCESCORE:
                SetCustomTag(__ot_StaffAssignStaffListScoreOverride);
                break;
            case SLMODE_ASSIGNMENT_FORCEPARTS:
                SetCustomTag(__ot_StaffAssignStaffListPartsOverride);
                break;
        }
    }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
    }
#endif
 
    bool Load(CMPER itemno) override;
 
    bool SaveNew() override { return false; }
 
    bool Save() override;
 
    bool DeleteData() override { return false; }
 
    bool LoadNext() override { return Load(GetItemNo() + 1); }
 
    int GetElementCount() const
    {
        if (!DataIsLoaded()) return 0;
        int maxcount = _loadedsize / sizeof(EDTStaffList);
        /* Reduce list if some elements are 0 at the end */
        while (maxcount > 0)
        {
            if (_TypeCast()[maxcount - 1].staff == 0)
                maxcount --;
            else
                return maxcount;
        }
        return maxcount;
    }
 
    int GetStaffCount() const
    {
        if (!DataIsLoaded()) return 0;
        int maxcount = _loadedsize / sizeof(EDTStaffList);
        int staffcount = 0;
        for (int i = 0; i < maxcount; i++)
        {
            if (_TypeCast()[i].staff > 0) staffcount++;
        }
        return staffcount;
    }
 
    int GetStaff(int index)
    {
        if (index < 0) return 0;
        int maxcount = _loadedsize / sizeof(EDTStaffList);
        int staffcount = 0;
        for (int i = 0; i < maxcount; i++)
        {
            if (_TypeCast()[i].staff > 0)
            {
                if (staffcount == index) return _TypeCast()[index].staff;
                staffcount++;
            }
        }
        return 0;
    }
 
    bool IsElementAvailable(twobyte stafflistelement)
    {
        if (stafflistelement == 0) return false;  /* This value would not be a valid value in a staff list. */
        int maxcount = _loadedsize / sizeof(EDTStaffList);
        for (int i = 0; i < maxcount; i++)
        {
            if (_TypeCast()[i].staff == stafflistelement) return true;
        }
        return false;
    }
 
    bool IncludesTopStaff()
    {
        return IsElementAvailable(SLD_TOPSTAFF);
    }
 
    bool IncludesBottomStaff()
    {
        return IsElementAvailable(SLD_BOTTOMSTAFF);
    }
 
    bool IncludesStaff(twobyte staffnumber)
    {
        return IsElementAvailable(staffnumber);
    }
 
    FCString* CreateNameString();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateNameString_GC()
    { return makeLuaSharedPtr(CreateNameString()); }
#endif
 
    bool SaveNameString(FCString* pString);
 
    bool AddElement(twobyte elementnumber);
 
    bool AddStaff(twobyte staffnumber)
    {
        if (staffnumber < 1) return false;
        return AddElement(staffnumber);
    }
 
     bool AddTopStaff()
     {
         return AddElement(SLD_TOPSTAFF);
     }
 
     bool AddBottomStaff()
     {
         return AddElement(SLD_BOTTOMSTAFF);
     }
 
     bool RemoveElement(twobyte element);
 
     bool RemoveTopStaff()
     {
         return RemoveElement(SLD_TOPSTAFF);
     }
 
     bool RemoveBottomStaff()
     {
         return RemoveElement(SLD_BOTTOMSTAFF);
     }
 
     bool RemoveStaff(twobyte staffnumber)
     {
         if (staffnumber < 1) return false;
         return RemoveElement(staffnumber);
     }
};
 
 
 
class FCFretInstrumentDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTFretInstrument _fretinstrumentold; /* Pre 25.3 */
    
    FIN25_3_CODE( EDTFretInstrument25_3 _fretinstrument25_3; )
    
    /* Decides which of the structs that should be used, based on
     the PDK and running version. Returns true if 25.3 is supported. */
    bool _Use25_3Version() const;
    
    /* Returns a pointer to the 'noOfFrets' member */
    const twobyte* _GetNoOfFretsPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.noOfFrets; )
        return &_fretinstrumentold.noOfFrets;
    }
    
    /* Returns a pointer to the 'noOfStrings' member */
    const twobyte* _GetNoOfStringsPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.noOfStrings; )
        return &_fretinstrumentold.noOfStrings;
    }
    
    /* Returns a pointer to the 'speedyClef' member */
    const eClef* _GetSpeedyClefPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.speedyClef; )
        return &_fretinstrumentold.speedyClef;
    }
    
    /* Returns a pointer to the 'diatonicStepsLo' member */
    const utwobyte* _GetDiatonicStepsLoPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.diatonicStepsLo; )
        return &_fretinstrumentold.diatonicStepsLo;
    }
    
    /* Returns a pointer to the 'diatonicStepsHi' member */
    const utwobyte* _GetDiatonicStepsHiPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.diatonicStepsHi; )
        return &_fretinstrumentold.diatonicStepsHi;
    }
    
    /* Returns a pointer to the 'name' member. On Finale 25.3+, it's an
     eUniChar16 buffer. On earlier Finale versions, it's an ECHAR buffer. */
    const void* _GetNamePtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.name; )
        return &_fretinstrumentold.name;
    }
    
    /* Returns a pointer to the 'stringTuning' member. The meaning of this pointer is a
     bit different in 25.3 PDK versions. */
    const void* _GetStringTuningPtr(int stringno) const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.stringTuning[stringno - 1]; )
        return &_fretinstrumentold.stringTuning[stringno - 1];
    }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override;
    int DataSizeLoad() const override;
    void* Allocate() override;
    EVERSION EnigmaVersion() const override { return _Use25_3Version() ? FINALEVERSION_25_3 : FINALEVERSION_2010; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        int size = DataSizeLoad();
        memcpy(_GetFretInstrumentDef(), ((FCFretInstrumentDef*)pSource)->_GetFretInstrumentDef(), size);
        _datablock = _GetFretInstrumentDef();
        _loadedsize = size;
    }
 
    __FCBaseData* CreateObject() override { return new FCFretInstrumentDef(); }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCFretInstrumentDef"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_FRETINSTRUMENTDEF; }
 
    bool LoadFirst() override { return Load(1); }
 
    bool LoadNext() override 
    {        
        if (!DataIsLoaded()) return false;
        return Load(GetItemNo() + 1);
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetFretInstrumentDef() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCFretInstrumentDef() : __FCNoInciOther()
    {
        /* Don't use virtual methods in the constructor */
        if (_Use25_3Version())
        {
#if FXT_VERSION >= FINALEVERSION_25_3
            memset(&_fretinstrument25_3, 0, sizeof(_fretinstrument25_3));
            _datablock = &_fretinstrument25_3;
            _loadedsize = sizeof(_fretinstrument25_3);
#endif
        }
        else
        {
            memset(&_fretinstrumentold, 0, sizeof(_fretinstrumentold));
            _datablock = &_fretinstrumentold;
            _loadedsize = sizeof(_fretinstrumentold);
        }
    }
 
    twobyte GetFretCount() const
    {
        return *_GetNoOfFretsPtr();
    }
 
    void SetFretCount(twobyte count)
    {
        *(twobyte*)_GetNoOfFretsPtr() = count;
    }
 
    twobyte GetStringCount() const
    {
        return *_GetNoOfStringsPtr();
    }
 
    void SetStringCount(twobyte count)
    {
        if (count < 1) return;
        if (count > 24) return;
        *(twobyte*)_GetNoOfStringsPtr() = count;
    }
 
    eClef GetSpeedyClef() const
    {
        return *_GetSpeedyClefPtr();
    }
 
    void SetSpeedyClef(eClef clef)
    {
        *(eClef*)_GetSpeedyClefPtr() = clef;
    }
 
    bool GetName(FCString* pString)
    {
        if (!pString) return false;
        if (_Use25_3Version())
        {
            /* Unicode version */
            FIN25_3_CODE( pString->SetUnicodeString((eUniChar16*) _GetNamePtr()); )
        }
        else
        {
            /* Old ECHAR version */
            pString->SetCString((ECHAR*) _GetNamePtr());
        }
        
        return true;
    }
 
    bool SetName(FCString* pString)
    {
        if (!pString) return false;
        if (pString->GetLength() > 47) return false;
        if (_Use25_3Version())
        {
            /* Unicode version */
            FIN25_3_CODE( pString->CopyToUnicodeBuffer((eUniChar16*) _GetNamePtr()); )
        }
        else
        {
            /* Old ECHAR version */
            strcpy((ECHAR*) _GetNamePtr(), pString->GetCString());
        }
        return true;
    }
 
    twobyte GetStringTuning(int stringnumber)
    {
        if (stringnumber < 1) return 0;
        if (stringnumber > GetStringCount()) return 0;
        if (stringnumber > 24) return 0;
        
        /* The meaning of the StringTuning array has shifted a bit between PDKs.
         */
#if FXT_VERSION >= FINALEVERSION_25_3
        if (_Use25_3Version())
        {
            return ((EDTStringData*)_GetStringTuningPtr(stringnumber))->pitch;
        }
#endif
        return *(twobyte*)_GetStringTuningPtr(stringnumber);
    }
 
    bool SetStringTuning(int stringnumber, twobyte midinumber)
    {
        if (stringnumber < 1) return false;
        if (stringnumber > GetStringCount()) return false;
        if (stringnumber > 24) return false;
 
        if (_Use25_3Version())
        {
#if FXT_VERSION >= FINALEVERSION_25_3
            ((EDTStringData*)_GetStringTuningPtr(stringnumber))->pitch = midinumber;
#endif
        }
        else
        {
            *(twobyte*)_GetStringTuningPtr(stringnumber) = midinumber;
        }
        return true;
    }
    
    bool IsDiatonic()
    {
        return (MAKELONG(*_GetDiatonicStepsLoPtr(), *_GetDiatonicStepsHiPtr()) != 0);
    }
    
    int GetDiatonicCount()
    {
        if (!IsDiatonic()) return 0;
        ufourbyte fb = MAKELONG(*_GetDiatonicStepsLoPtr(), *_GetDiatonicStepsHiPtr());
        int totalcount = 0;
        while (fb)
        {
            if (fb & 0x01) totalcount ++;
            fb = fb >> 1;
        }
        return totalcount;
    }
    
    bool GetDiatonicInfo(FCNumbers* pNumbers)
    {
        if (!pNumbers) return false;
        pNumbers->ClearAll();
        ufourbyte fb = MAKELONG(*_GetDiatonicStepsLoPtr(), *_GetDiatonicStepsHiPtr());
        int count = 0;
        while (fb != 0)
        {
            count ++;
            if (fb & 0x01)
            {                
                pNumbers->Add(new FCNumber(count));
                count = 0;
            }
            fb = fb >> 1;
        }
        return true;
    }
    
    bool SetDiatonicInfo(FCNumbers* pNumbers)
    {
        if (!pNumbers) return false;
        ufourbyte fb = 0;
        for (int i = pNumbers->GetCount() - 1; i >= 0; i--)
        {
            FCNumber* pNumber = pNumbers->GetItemAt(i);            
            if (pNumber->GetInt() < 1) return false;
            if (pNumber->GetInt() > 5) return false;
            fb = fb << 1;  /* Shift to next number */
            fb |= 0x01;
            for (int bitcount = 0; bitcount < pNumber->GetInt() - 1; bitcount++)
            {
                fb = fb << 1;  /* Shift with extra zeros, if necessary */
            }            
        }
        *(utwobyte*)_GetDiatonicStepsLoPtr() = LOWORD(fb);
        *(utwobyte*)_GetDiatonicStepsHiPtr() = HIWORD(fb);
        return true;
    }
    
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        DebugOutHex("Diatonic bit set: ", MAKELONG(*_GetDiatonicStepsLoPtr(), *_GetDiatonicStepsHiPtr()));
    }
#endif
};
 
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#include "pragma_align_begin.h"
struct __EDTMidClef
{
    twobyte clefindex;
    twobyte edupos;
    twobyte vertadjust;
    twobyte resize;
    twobyte horizadjust;
    FLAG_16 flag;
};
#include "pragma_align_end.h"
 
const EXTAG __ot_MidClef = MAKEEXTAG(edOther, 'C', 'E');
#endif
 
 
class FCCellClefChange : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __EDTMidClef _midclefdata;
    
    FCCellClefChange(const FCCellClefChange &src) : __FCInciOther()
    {
        _midclefdata = src._midclefdata;
        _datablock = &_midclefdata;
        _loadedsize = sizeof(_midclefdata);
    }
 
    friend class FCCellClefChanges;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
    EXTAG Tag() const override { return __ot_MidClef; }
    int DataSizeLoad() const override { return sizeof(__EDTMidClef); }
    void* Allocate() override { return (void*) &_midclefdata; }
    
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_midclefdata, ((FCCellClefChange*)pSource)->_GetCellClefChange(), sizeof(_midclefdata));
        _datablock = &_midclefdata;
        _loadedsize = sizeof(_midclefdata);
    }
 
    __FCBaseData* CreateObject() override { return new FCCellClefChange(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCellClefChange"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CELLCLEFCHANGE; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetCellClefChange() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    FCCellClefChange();
    
    twobyte GetClefIndex() const { return _midclefdata.clefindex; }
    
    TimeEdu32 GetMeasurePos() const override { return _midclefdata.edupos; }
    
    twobyte GetClefPercent() const { return _midclefdata.resize; }
    
    twobyte GetHorizontalOffset() const { return _midclefdata.horizadjust; }
 
    twobyte GetVerticalOffset() const { return _midclefdata.vertadjust; }
    
    twobyte GetClefShow() const;
    
    bool GetAllowVerticalDrag() const { return (_midclefdata.flag & 0x04) != 0; }
 
    bool GetClefAfterBarline() const { return (_midclefdata.flag & 0x0010) != 0; }
 
    void SetClefIndex(twobyte value) { _midclefdata.clefindex = value; }
    
    void SetMeasurePos(twobyte value) { _midclefdata.edupos = value; }
    
    void SetClefPercent(twobyte value) { _midclefdata.resize = value; }
 
    void SetHorizontalOffset(twobyte value) { _midclefdata.horizadjust = value; }
 
    void SetVerticalOffset(twobyte value) { _midclefdata.vertadjust = value; }
 
    void SetClefShow(twobyte showstate);
    
    void SetAllowVerticalDrag(bool state) { Set16BitFlag(&_midclefdata.flag, 0x04, state); }
 
    void SetClefAfterBarline(bool state) { Set16BitFlag(&_midclefdata.flag, 0x0010, state); }
 
    bool IsStartClef() { return (GetMeasurePos() == 0); }
};
 
 
class FCGuide : public __FCBase
{
        Efix32 _position;
    public:
        FCGuide(Efix32 position) : __FCBase()
        {
            _position = position;
        }
        const char* ClassName() const override { return "FCGuide"; }
 
        Efix32 GetPosition() const { return _position; }
 
        void SetPosition(Efix32 value) { _position = value; }
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
const EXTAG __ot_MetatoolExpression = MAKEEXTAG(edOther, '&', 'd');
const EXTAG __ot_MetatoolArticulation =  MAKEEXTAG(edOther, '&', 'a');
const EXTAG __ot_MetatoolRepeat =  MAKEEXTAG(edOther, '&', 'r');
const EXTAG __ot_MetatoolClef = MAKEEXTAG(edOther, '&', 'f');
const EXTAG __ot_MetatoolTuplet = MAKEEXTAG(edOther3Inci, '&', 'u');
const EXTAG __ot_MetatoolStaffStyle = MAKEEXTAG(edOther, '&', 's');
 
#include "pragma_align_begin.h"
struct __EDTMetatool
{
    twobyte item1; /* For most data, this is a cmper */
    twobyte item2; /* For expressions, this is a bool */
    twobyte item3;
    twobyte item4;
    twobyte item5;
    twobyte item6;
};
#include "pragma_align_end.h"
 
#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
 
class FCClefDef;
#ifdef PDK_FRAMEWORK_ENTRIES
class FCTuplet;
#endif
 
class FCMetatoolAssignment : public __FCNoInciOther
{
public:
    enum METATOOL_MODES
    {
        /* Currently unassigned metatool mode. */
        MTOOLMODE_UNKNOWN = 0,
        
        MTOOLMODE_EXPRESSION = 1,
        
        MTOOLMODE_ARTICULATION = 2,
        
        MTOOLMODE_REPEAT = 3,
        
                MTOOLMODE_CLEF = 4,
        
#ifdef PDK_FRAMEWORK_ENTRIES
                MTOOLMODE_TUPLET = 5,
#endif
        
                MTOOLMODE_STAFFSTYLE = 6
        };
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    METATOOL_MODES _mode;  /* The mode of the object. */
    
    __EDTMetatool _metatool;        /* Data for most kind of items */
    EDTTuplet2005 _tupletmetatool;  /* Data for tuplets */
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    EXTAG Tag() const override
    {
        switch (_mode)
        {
            case MTOOLMODE_EXPRESSION:
                return __ot_MetatoolExpression;
            case MTOOLMODE_ARTICULATION:
                return __ot_MetatoolArticulation;
            case MTOOLMODE_REPEAT:
                return __ot_MetatoolRepeat;
                        case MTOOLMODE_CLEF:
                                return __ot_MetatoolClef;
#ifdef PDK_FRAMEWORK_ENTRIES
            case MTOOLMODE_TUPLET:
                return __ot_MetatoolTuplet;
#endif
                        case MTOOLMODE_STAFFSTYLE:
                                return __ot_MetatoolStaffStyle;
            case MTOOLMODE_UNKNOWN:
                return 0;
        }
        return 0;
    }
    int DataSizeLoad() const override
    {
        switch (_mode)
        {
#ifdef PDK_FRAMEWORK_ENTRIES
            case MTOOLMODE_TUPLET:
                return sizeof(_tupletmetatool);
#endif
            case MTOOLMODE_UNKNOWN:
                return 0;
            default:
                return sizeof(__EDTMetatool);
        }
    }
    void* Allocate() override
    {
        switch (_mode)
        {
#ifdef PDK_FRAMEWORK_ENTRIES
            case MTOOLMODE_TUPLET:
                return (void*) &_tupletmetatool;
#endif
            case MTOOLMODE_UNKNOWN:
                return NULL;
            default:
                return (void*) &_metatool;
        }
    }
    
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        if (_mode == MTOOLMODE_UNKNOWN) return;
        memcpy(_GetMetatool(), ((FCMetatoolAssignment*)pSource)->_GetMetatool(), DataSizeLoad());
        _datablock = _GetMetatool();
        _loadedsize = sizeof(DataSizeLoad());
    }
    
    __FCBaseData* CreateObject() override { return new FCMetatoolAssignment(); }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCMetatoolAssignment"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_METATOOLASSIGNMENT; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetMetatool() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
    FCMetatoolAssignment() : __FCNoInciOther()
    {
        _mode = MTOOLMODE_UNKNOWN;
        // _datablock and _loadedsize is initialized in SetMode()
        memset(&_metatool, 0, sizeof(_metatool));
        memset(&_tupletmetatool, 0, sizeof(_tupletmetatool));
    }
    
    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                 METATOOL_MODES
#else
                 int
#endif
                 mode)
    {
        if (_mode != MTOOLMODE_UNKNOWN) return;
        _mode = (METATOOL_MODES) mode;
        _datablock = _GetMetatool();
        _loadedsize = DataSizeLoad();
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    METATOOL_MODES
#else
    int
#endif
    GetMode() const { return (METATOOL_MODES) _mode; }
    
    CMPER GetDefID() const
    {
        switch (_mode)
        {
            case MTOOLMODE_EXPRESSION:
            case MTOOLMODE_ARTICULATION:
            case MTOOLMODE_REPEAT:
                        case MTOOLMODE_CLEF:
                        case MTOOLMODE_STAFFSTYLE:
                return _metatool.item1;
            default:
                return 0;
        }
    }
    
    twobyte GetKeystroke() const;
    
    bool IsShapeExpressionDef() const
    {
        if (_mode != MTOOLMODE_EXPRESSION) return false;
        return (_metatool.item2 == 0);
    }
    
    bool AssignArticulationDef(FCArticulationDef* pDef)
    {
        if (!pDef) return false;
        if (_mode != MTOOLMODE_ARTICULATION) return false;
        _metatool.item1 = pDef->GetItemNo();
        return true;
    }
    
    bool AssignTextExpressionDef(FCTextExpressionDef* pDef)
    {
        if (!pDef) return false;
        if (_mode != MTOOLMODE_EXPRESSION) return false;
        _metatool.item1 = pDef->GetItemNo();
        _metatool.item2 = 1;
        return true;
    }
    
    bool AssignShapeExpressionDef(FCShapeExpressionDef* pDef)
    {
        if (!pDef) return false;
        if (_mode != MTOOLMODE_EXPRESSION) return false;
        _metatool.item1 = pDef->GetItemNo();
        _metatool.item2 = 0;
        return true;
    }
    
    bool AssignRepeatDef(FCTextRepeatDef* pDef)
    {
        if (!pDef) return false;
        if (_mode != MTOOLMODE_REPEAT) return false;
        _metatool.item1 = pDef->GetItemNo();
        return true;
    }
    
        bool AssignClefDef(FCClefDef* pDef);
    
#ifdef PDK_FRAMEWORK_ENTRIES
        bool AssignTuplet(FCTuplet* pTuplet);
#endif
    
        bool AssignStaffStyle(FCStaffStyleDef* pStaffStyle)
        {
                if (!pStaffStyle) return false;
                if (_mode != MTOOLMODE_STAFFSTYLE) return false;
                _metatool.item1 = pStaffStyle->GetItemNo();
                return true;
        }
    
    bool SaveAsKeystroke(twobyte keystrokeslot)
    {
        if (_mode == MTOOLMODE_UNKNOWN) return false;
        if ((keystrokeslot >= 'A' && keystrokeslot <= 'Z') || (keystrokeslot >= '0' && keystrokeslot <= '9'))
        {
            return __FCNoInciOther::SaveAs(keystrokeslot);
        }
        return false;
    }
    
    bool SaveNew() override { return false; }
    
    virtual bool SaveAs([[maybe_unused]]CMPER cmper) override { return false; }
    
    __FCBaseData* CreateLinkedObject();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<__FCBaseData> CreateLinkedObject_GC()
    { return makeLuaSharedPtr(CreateLinkedObject()); }
#endif
    
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        switch (_mode)
        {
#ifdef PDK_FRAMEWORK_ENTRIES
            case MTOOLMODE_TUPLET:
                DebugDataDump();
                break;
#endif
            default:
                DebugOutInt("item1: ", _metatool.item1);
                DebugOutInt("item2: ", _metatool.item2);
                DebugOutInt("item3: ", _metatool.item3);
                DebugOutInt("item4: ", _metatool.item4);
                DebugOutInt("item5: ", _metatool.item5);
                DebugOutInt("item6: ", _metatool.item6);
                break;
        }
    }
#endif
};
 
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
class FCBookmark : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTBookmark2012 _bookmark;
 
protected:
    EXTAG Tag() const override { return ot_Bookmark2012; }
    int DataSizeLoad() const override { return sizeof(_bookmark); }
    void* Allocate() override { return (void*) &_bookmark; }
 
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        memcpy(&_bookmark, ((FCBookmark*)pSource)->_GetBookmark(), DataSizeLoad());
        _datablock = _GetBookmark();
        _loadedsize = DataSizeLoad();
    }
 
    __FCBaseData* CreateObject() override { return new FCBookmark(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    const char* ClassName() const override { return "FCBookmark"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_BOOKMARK; }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void* _GetBookmark() { return &_bookmark; }
 
    bool LoadFirst() override
    {
        SetCmperAndInci(0, 0);
        return LoadNext();
    }
    
    bool Save() override;
    
    bool SaveNew() override;
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
    enum BOOKMARKTYPES
    {
        BOOKMARKTYPE_PAGEVIEW = 0,
 
        BOOKMARKTYPE_SCROLLVIEW = 1
    };
 
    FCBookmark() : __FCNoInciOther()
    {
        memset(_GetBookmark(), 0, DataSizeLoad());
        _datablock = _GetBookmark();
        _loadedsize = DataSizeLoad();
    }
 
    FCString* CreateNameString()
    {
        FCBookmarkText text;
        if (! text.Load(_bookmark.nameRawTextID))
            return nullptr;
        FCString* retval = text.CreateString();
        retval->TrimEnigmaFontTags();
        return retval;
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateNameString_GC()
    { return makeLuaSharedPtr(CreateNameString()); }
#endif
 
    bool SaveNameString(const FCString* pString);
 
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BOOKMARKTYPES
#else
    int
#endif
    GetViewType() const { return (BOOKMARKTYPES)_bookmark.view; }
 
    ePercent GetViewPercent() const { return _bookmark.viewPercent; }
 
    bool GetUseViewPercent() const { return MAKEBOOL(_bookmark.scaleView); }
 
    int GetLocator() const { return _bookmark.page_meas; }
 
    int GetHorizontalPosInst() const { return _bookmark.horizpos_inst; }
 
    bool GetUseHorizontalPosInst() const { return GetBitFlag(_bookmark.flag, BM_SCRL_HORIZINST); }
 
    int GetVerticalPosStaffSet() const
    {
        if (GetViewType() == BOOKMARKTYPE_SCROLLVIEW)
            return static_cast<utwobyte>(_bookmark.vertpos_staffset) - IU_STAFFSET1 + 1;
        return _bookmark.vertpos_staffset;
    }
 
    bool GetUseVerticalPosStaffSet() const { return GetBitFlag(_bookmark.flag, BM_SCRL_VERTSTAFFSET); }
 
    void SetViewType(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    BOOKMARKTYPES
#else
    int
#endif
    value) { _bookmark.view = (twobyte)value; }
 
    void SetViewPercent(ePercent value) {_bookmark.viewPercent = value; }
 
    void SetUseViewPercent(bool state) { _bookmark.scaleView = state; }
 
    void SetLocator(int value) { _bookmark.page_meas = value; }
 
    void SetHorizontalPosInst(int value) { _bookmark.horizpos_inst = value; }
 
    void SetUseHorizontalPosInst(bool state) { Set16BitFlag(&_bookmark.flag, BM_SCRL_HORIZINST, state); }
 
    void SetVerticalPosStaffSet(int value)
    {
        if (GetViewType() == BOOKMARKTYPE_SCROLLVIEW)
            _bookmark.vertpos_staffset = IU_STAFFSET1 + value - 1;
        else
            _bookmark.vertpos_staffset = value;
    }
 
    void SetUseVerticalPosStaffSet(bool state) { Set16BitFlag(&_bookmark.flag, BM_SCRL_VERTSTAFFSET, state); }
    
    bool IsForPageView() const
    { return GetViewType() == BOOKMARKTYPE_PAGEVIEW; }
    
    bool IsForScrollView() const
    { return GetViewType() == BOOKMARKTYPE_SCROLLVIEW; }
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoInciOther::DebugDump();
        this->DebugDataDump();
    }
#endif
 
};
#endif // PDK_FRAMEWORK_ENIGMASTRINGS
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
#include "pragma_align_begin.h"
struct _FCEDTKeyFormat
{
   twobyte     totalSteps;       // number elements in EDTKeyStep array (12 for std key)
   twobyte     numDiatonicSteps; // (7 for std key)
private:
   twobyte     filler[4];
};
#include "pragma_align_end.h"
 
//cmper = key cmper from eKey
//inci = 0
#define __ot_KeyFormat MAKEEXTAG(edOther,'K','F')
 
#include "pragma_align_begin.h"
struct _FCEDTKeyAttributes
{
   twobyte     harmonicRef;
   eMIDIkey    middleKey;
   EFONTID     symbolFont;            //enigma font id of accidental symbols
   twobyte     gotoKeyUnit;
   twobyte     symListID;             //cmper of accidental symbols
   FLAG_16     flags;
    
// flag values:
#define KEYSATTRIB_HAS_CLEFOCTV 0x0001  // indicates that accidental octave placement records exists
};
#include "pragma_align_end.h"
 
//cmper = key cmper from eKey
//inci = 0
#define __ot_KeyAttributes MAKEEXTAG(edOther,'K','A')
 
#include "pragma_align_begin.h"
struct __FCEDTKeyStep
{
   twobyte     diatonicStep;
   FLAG_16     flag;
   
//flag values:
#define KEYSTEP_IS_NEXT_DIATONIC_STEP 0x8000
};
#include "pragma_align_end.h"
 
//multi-inci array of EDTKeyStep (
//cmper = key cmper from eKey
#define __ot_KeyStepMap  MAKEEXTAG(edOther,'K','M')
 
// cmper1 = cmper from _FCEDTKeyAttributes.symListID
// cmper2 = list element (1..7 or -1..-7)
// inci = 0
#define __dt_KeyAcciSymbol  MAKEEXTAG(edDetail,'K','S')
 
// inci array of twobytes
// cmper =  key cmper from eKey
// inci = 0
#define __ot_KeyAcciOrderPositive MAKEEXTAG(edOther,'O','p')   //0..6 (for 1 up to 7)
#define __ot_KeyAcciOrderNegative MAKEEXTAG(edOther,'O','n')   //0..6 (for -1 down to -7)
 
// inci array of twobytes
// cmper =  key cmper from eKey
#define __ot_KeyAcciAmountPositive MAKEEXTAG(edOther,'A','p')   //0..6 (for 1 up to 7)
#define __ot_KeyAcciAmountNegative MAKEEXTAG(edOther,'A','n')   //0..6 (for -1 down to -7)
 
// inci array of twobytes
// cmper =  key cmper from eKey
#define __ot_KeyToneCenterPositive MAKEEXTAG(edOther,'T','p')   //0..7 (for 0 up to 7)
#define __ot_KeyToneCenterNegative MAKEEXTAG(edOther,'T','n')   //0..7 (for 0 down to -7, but 0 not used)
 
// inci array of twobytes
// cmper1 = key cmper from eKey
// cmper2 = clef id
#define __dt_KeyOctavePlacementPositive MAKEEXTAG(edDetail,'C','p')   //0..6 (for 1 up to 7)
#define __dt_KeyOctavePlacementNegative MAKEEXTAG(edDetail,'C','n')   //0..6 (for -1 down to -7)
 
// As far as I know custom key modes are the only Enigma data that use parallel
// positive and negative arrays like this. RGP 3/6/2024
 
template<EXTAG TAGP, EXTAG TAGN, int MAXSIZE, bool CONSTRAIN_VALUES>
class __FCDualArray
{
    static_assert(MAXSIZE == 7 || MAXSIZE == 8, "MAXSIZE must be 7 o 8");
    static constexpr bool IS_DETAIL = HI_UTWOBYTE(TAGP) == edDetail;
 
protected:
    using __FCPositiveArray = std::conditional_t<IS_DETAIL, __FCEnigmaDetailArray<twobyte, TAGP>, __FCEnigmaOtherArray<twobyte, TAGP>>;
    using __FCNegativeArray = std::conditional_t<IS_DETAIL, __FCEnigmaDetailArray<twobyte, TAGN>, __FCEnigmaOtherArray<twobyte, TAGN>>;
 
    __FCPositiveArray _positive;
    __FCNegativeArray _negative;
    
private:
    twobyte __getActualX(twobyte x) const
    {
        twobyte actualX = std::abs(x);
        if constexpr (MAXSIZE == 7)
        {
            if (actualX == 0)
            {
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
                throw std::runtime_error("zero is not a valid index");
#endif
                assert(actualX);
                return 0;
            }
            actualX--;
        }
        if (actualX >= MAXSIZE)
        {
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
            throw std::runtime_error("index out of range: " + std::to_string(x));
#endif
            return actualX % MAXSIZE;
        }
        return actualX;
    }
 
protected:
    __FCDualArray() : _positive(MAXSIZE), _negative(MAXSIZE)
    {
        _positive.Reset();
        _negative.Reset();
    }
    
public:
    twobyte operator[](twobyte x) const
    {
        twobyte actualX = __getActualX(x);
        if (x < 0) return _negative[actualX];
        return _positive[actualX];
    }
    
    twobyte& operator[](twobyte x)
    {
        twobyte actualX = __getActualX(x);
        if (x < 0) return _negative[actualX];
        return _positive[actualX];
    }
    
    int NumPositive() const { return _positive.NumElements(); }
    int NumNegative() const { return _negative.NumElements(); }
 
    __FCDualArray& operator=(const std::map<twobyte, twobyte>& values)
    {
        _positive.Reset();
        _negative.Reset();
        for (auto value : values)
        {
            if (value.first >= 0 && !NumPositive())
                _positive.AllocateFor(MAXSIZE);
            else if (value.first < 0 && !NumNegative())
                _negative.AllocateFor(MAXSIZE);
            if constexpr(CONSTRAIN_VALUES)
            {
                if (value.second < 0 || value.second > 6)
                {
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
                    throw std::runtime_error("value must be between 0 and 6: got " + std::to_string(value.second));
#endif
                    (*this)[value.first] = std::abs(value.second) % 6;
                    return *this;
                }
            }
            (*this)[value.first] = value.second;
        }
        return *this;
    }
    
    operator std::map<twobyte, twobyte>() const
    {
        std::map<twobyte, twobyte> values;
        const twobyte xoff = (MAXSIZE == 7) ? 1 : 0;
        for (twobyte x = 0; x < NumPositive(); x++)
        {
            if (x >= MAXSIZE) break;
            values[x + xoff] = _positive[x];
        }
        const twobyte startneg = (MAXSIZE == 7) ? 0 : 1;
        for (twobyte x = startneg; x < NumNegative(); x++)
        {
            if (x >= MAXSIZE) break;
            values[-x - xoff] = _negative[x];
        }
        return values;
    }
    
    bool Load(CMPER cmper, CMPER cmper2)
    {
        bool retval = false;
        if constexpr(IS_DETAIL)
        {
            if (_positive.Load(cmper, cmper2)) retval = true;
            if (_negative.Load(cmper, cmper2)) retval = true;
        }
        else
        {
            if (_positive.Load(cmper)) retval = true;
            if (_negative.Load(cmper)) retval = true;
        }
        return retval;
    }
    
    bool SaveAs(CMPER cmper, CMPER cmper2)
    {
        if constexpr(IS_DETAIL)
            return _positive.SaveAs(cmper, cmper2) && _negative.SaveAs(cmper, cmper2);
        else
            return _positive.SaveAs(cmper) && _negative.SaveAs(cmper);
    }
    
    bool Delete(CMPER cmper)
    {
        bool deleted = false;
        if (__FCPositiveArray().Delete(cmper)) deleted = true;
        if (__FCNegativeArray().Delete(cmper)) deleted = true;
        return deleted;
    }
};
 
template<EXTAG TAGP, EXTAG TAGN, int MAXSIZE, bool CONSTRAIN_VALUES = true>
class __FCDualOtherArray : public __FCDualArray<TAGP, TAGN, MAXSIZE, CONSTRAIN_VALUES>
{
    using __FCDualOtherArrayBase = __FCDualArray<TAGP, TAGN, MAXSIZE, CONSTRAIN_VALUES>;
    
public:
    __FCDualOtherArray() = default;
    
    using __FCDualOtherArrayBase::operator=;
    using __FCDualOtherArrayBase::operator std::map<twobyte, twobyte>;
    
    bool Load(CMPER cmper)
    { return __FCDualOtherArrayBase::Load(cmper, 0); }
    
    bool SaveAs(CMPER cmper)
    { return __FCDualOtherArrayBase::SaveAs(cmper, 0); }
};
 
template<EXTAG TAGP, EXTAG TAGN, int MAXSIZE, bool CONSTRAIN_VALUES = true>
class __FCDualDetailArray : public __FCDualArray<TAGP, TAGN, MAXSIZE, CONSTRAIN_VALUES>
{
    using __FCDualDetailArrayBase = __FCDualArray<TAGP, TAGN, MAXSIZE, CONSTRAIN_VALUES>;
    
public:
    __FCDualDetailArray() = default;
    using __FCDualDetailArrayBase::operator=;
    using __FCDualDetailArrayBase::operator std::map<twobyte, twobyte>;
};
 
using __FCCustomKeyModeTonalCenters = __FCDualOtherArray<__ot_KeyToneCenterPositive, __ot_KeyToneCenterNegative, 8>;
using __FCCustomKeyModeAcciOrder = __FCDualOtherArray<__ot_KeyAcciOrderPositive, __ot_KeyAcciOrderNegative, 7>;
using __FCCustomKeyModeAcciAmounts = __FCDualOtherArray<__ot_KeyAcciAmountPositive, __ot_KeyAcciAmountNegative, 7, false>;
using __FCCustomKeyClefOctavePlacement = __FCDualDetailArray<__dt_KeyOctavePlacementPositive, __dt_KeyOctavePlacementNegative, 7, false>;
 
class __FCCustomKeyClefOctavePlacements
{
    std::vector<__FCCustomKeyClefOctavePlacement> _placements;
    
public:
    __FCCustomKeyClefOctavePlacements() = default;
    
    __FCCustomKeyClefOctavePlacements& operator=(const std::vector<std::map<twobyte, twobyte>>& values)
    {
        _placements.clear();
        _placements.resize(values.size());
        for (size_t x = 0; x < _placements.size(); x++)
            _placements[x] = values[x];
        return *this;
    }
    
    operator std::vector<std::map<twobyte, twobyte>>() const
    {
        std::vector<std::map<twobyte, twobyte>> retval(_placements.size());
        for (size_t x = 0; x < _placements.size(); x++)
            retval[x] = _placements[x];
        return retval;
    }
    
    bool Load(CMPER cmper);
    
    bool SaveAs(CMPER cmper)
    {
        for (CMPER x = 0; x < _placements.size(); x++)
        {
            if (!_placements[x].SaveAs(cmper, x)) return false;
        }
        return true;
    }
    
    bool Delete(CMPER cmper)
    {
        return __FCCustomKeyClefOctavePlacement().Delete(cmper);
    }
};
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
class FCCustomKeyModeSymbolList : public __FCBase
{
    using symbolMap = std::map<twobyte, std::string>;
    
    CMPER _itemno;
    symbolMap _list; // key: 1..7 for sharps, -1..-7 for flats, 0 for natural; value: utf8-encoded string
    
    FCCustomKeyModeSymbolList(const FCCustomKeyModeSymbolList& src)
        : _itemno(src._itemno), _list(src._list)
    {}
    
public:
    const char* ClassName() const override { return "FCCustomKeyModeSymbolList"; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCCustomKeyModeSymbolList* CreateClone() const
    { return new FCCustomKeyModeSymbolList(*this);  }
#endif
    
    FCCustomKeyModeSymbolList() : _itemno(kNewCmper) {}
    
    bool Load(CMPER itemno);
 
    bool LoadNext();
    
    bool LoadFirst();
 
    bool Save();
 
    bool SaveAs(CMPER itemno)
    {
        _itemno = itemno;
        return Save();
    }
 
    bool DeleteData();
        
    CMPER GetItemNo() const { return _itemno; }
 
    symbolMap GetList() const { return _list; }
 
    void SetList(symbolMap list) { _list = list; }
    
    FCString* CreateListString() const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateListString_GC() const
    { return makeLuaSharedPtr(CreateListString()); }
#endif
    
    static symbolMap GetDefaultList();
    
    bool CalcIsDefaultList() const;
};
 
class FCCustomKeyModeDef : public __FCNoInciOther
{
private:
    _FCEDTKeyFormat _format;
    _FCEDTKeyAttributes _attributes;
    std::vector<eHarmLev> _stepmap;
    __FCCustomKeyModeTonalCenters _tonalcenters;
    __FCCustomKeyModeAcciOrder _acciorder;
    __FCCustomKeyModeAcciAmounts _acciamounts;
    __FCCustomKeyClefOctavePlacements _clefplacements;
    
    bool _LoadChildData();
    bool _SaveChildData();
    bool _DeleteChildData();
    
    bool _LoadStepMap();
    bool _SaveStepMap();
    
    bool SaveNew() override
    {
#if PDK_FRAMEWORK_LUAFRIENDLY
        throw std::runtime_error("SaveNew not implemented for FCCustomKeyModeDef");
#endif
        return false;
    }
 
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EXTAG Tag() const override { return __ot_KeyFormat; }
    int DataSizeLoad() const override { return sizeof(_format); }
    void* Allocate() override { return (void*) &_format; }
    
    void CloneMemoryFrom(__FCBaseData* pSource) override
    {
        FCCustomKeyModeDef* pSourceKeyModeDef = dynamic_cast<FCCustomKeyModeDef*>(pSource);
        assert(pSourceKeyModeDef);
        _format = pSourceKeyModeDef->_format;
        _attributes = pSourceKeyModeDef->_attributes;
        _stepmap = pSourceKeyModeDef->_stepmap;
        _tonalcenters = pSourceKeyModeDef->_tonalcenters;
        _acciorder = pSourceKeyModeDef->_acciorder;
        _acciamounts = pSourceKeyModeDef->_acciamounts;
        _clefplacements = pSourceKeyModeDef->_clefplacements;
        _datablock = Allocate();
        _loadedsize = DataSizeLoad();
    }
    
    __FCBaseData* CreateObject() override { return new FCCustomKeyModeDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCustomKeyModeDef"; }
    const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_KEYMODEDEF; }
    
    FCCustomKeyModeDef() : __FCNoInciOther()
    {
        memset(&_attributes, 0, sizeof(_attributes));
        memset(&_format, 0, sizeof(_format));
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool LoadFirst() override
    {
        if (Load(0)) return true;
        return LoadNext();
    }
    
    bool LoadNext() override
    {
        // Due to Finale bug, calling FX_NextEData with extag of __ot_KeyFormat and null buffer crashes Finale.
        // Therefore we cannot call the base class LoadNext (__FCBaseData::LoadNext).
        _FCEDTKeyFormat format;
        if (!FX_NextEData(Tag(), &_dataid, &format, sizeof(format), EnigmaVersion())) return false;
        return Load(_dataid.other.cmper);
    }
    
    bool Load(CMPER itemno) override
    {
        if (! __FCNoInciOther::Load(itemno)) return false;
        return _LoadChildData();
    }
    
    bool Save() override
    {
        _format.numDiatonicSteps = static_cast<twobyte>(_stepmap.size());
        if (! __FCNoInciOther::Save()) return false;
        return _SaveChildData();
    }
    
    bool DeleteData() override
    {
        if (!_DeleteChildData()) return false;
        return __FCNoInciOther::DeleteData();
    }
#endif // DOXYGEN_SHOULD_IGNORE_THIS
    
    bool SaveNewLinear();
    
    bool SaveNewNonLinear();
 
    static bool DeleteItemNo(CMPER itemno)
    {
        FCCustomKeyModeDef def;
        def.SetCmperAndInci(itemno, 0);
        return def.DeleteData();
    }
    
    eKey GetKeyID(int accidentalnumber = 0) const
    {
        if (IsLinear())
            return ::MakeLinearKey(accidentalnumber, GetItemNo());
        return GetItemNo();
    }
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    static int GetKeyID_CFunc(lua_State *L)
    {
        return _CFunctionOneOptionalParameter<FCCustomKeyModeDef, eKey, int, &FCCustomKeyModeDef::GetKeyID>(L, 0);
    }
#endif
 
    bool IsLinear() const { return ::IsLinearKeyMode(GetItemNo()); }
    
    bool IsNonLinear() const { return !::IsLinearKey(GetItemNo()); }
    
    bool IsPredefined() const { return ::IsPredefinedKeyMode(GetItemNo()); }
 
    twobyte GetHarmonicReference() const { return _attributes.harmonicRef; }
    
    void SetHarmonicReference(twobyte value) { _attributes.harmonicRef = value; }
    
    twobyte GetMiddleKeyNumber() const { return _attributes.middleKey; }
 
    void SetMiddleKeyNumber(twobyte value) { _attributes.middleKey = value; }
        
    twobyte GetGoToKeyUnit() const { return _attributes.gotoKeyUnit; }
    
    void SetGoToKeyUnit(twobyte value) { _attributes.gotoKeyUnit = value; }
    
    twobyte GetSymbolListID() const { return _attributes.symListID; }
    
    void SetSymbolListID(twobyte value) { _attributes.symListID = value; }
 
    bool GetHasClefAccidentalPlacements() const { return GetBitFlag(_attributes.flags, KEYSATTRIB_HAS_CLEFOCTV); }
    
    void SetHasClefAccidentalPlacements(bool state) { Set16BitFlag(&_attributes.flags, KEYSATTRIB_HAS_CLEFOCTV, state); }
 
    EFONTID GetAccidentalFontID() const { return _attributes.symbolFont; }
    
    void SetAccidentalFontID(const EFONTID value) { _attributes.symbolFont = value; }
    
    FCFontInfo* CreateAccidentalFontInfo() const;
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCFontInfo> CreateAccidentalFontInfo_GC() const
    { return makeLuaSharedPtr(CreateAccidentalFontInfo()); }
#endif
 
 
    twobyte GetTotalChromaticSteps() const { return _format.totalSteps; }
    
    void SetTotalChromaticSteps(twobyte value) { _format.totalSteps = value; }
    
    std::vector<eHarmLev> GetDiatonicStepsMap() const { return _stepmap; }
    
    void SetDiatonicStepsMap(const std::vector<eHarmLev>& list) { _stepmap = list; }
    
    std::map<twobyte, twobyte> GetTonalCenters() const { return _tonalcenters; }
    
    void SetTonalCenters(const std::map<twobyte, twobyte>& values) { _tonalcenters = values; }
    
    twobyte GetBaseTonalCenter() const
    {
        if (_tonalcenters.NumPositive() <= 0)
            return GetItemNo() == KEYMODE_MINOR ? 5 : 0;
        return _tonalcenters[0];
    }
    
    void SetBaseTonalCenter(twobyte value)
    {
        if (value < 0 || value > 6)
        {
#ifdef PDK_FRAMEWORK_LUAFRIENDLY
            throw std::runtime_error("value must be between 0 and 6; got " + std::to_string(value));
#endif
            return;
        }
        if (value == 0 || (value == 5 && GetItemNo() == KEYMODE_MINOR))
        {
            // do not create tonal centers if they are not necessary.
            if (_tonalcenters.NumPositive() == 0 && _tonalcenters.NumNegative() == 0)
                return;
        }
        if (IsNonLinear())
        {
            SetTonalCenters({{0, value}, {1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}, {7,0}});
            return;
        }
        auto tonalCenters = GetDefaultTonalCenters();
        if (value > 0)
        {
            for (auto& tonalCenter : tonalCenters)
                tonalCenter.second = (tonalCenter.second + value) % 7;
        }
        SetTonalCenters(tonalCenters);
    }
 
    static std::map<twobyte, twobyte> GetDefaultTonalCenters()
    {
        return {{-7,0}, {-6,4}, {-5,1}, {-4,5}, {-3,2}, {-2,6}, {-1,3}, {0,0}, {1,4}, {2,1}, {3,5}, {4,2}, {5,6}, {6,3}, {7,0}};
    }
    
    static bool CalcIsDefaultTonalCenters(const std::map<twobyte, twobyte>& values)
    {
        return values == GetDefaultTonalCenters();
    }
 
    std::map<twobyte, twobyte> GetAccidentalOrder() const { return _acciorder; }
    
    void SetAccidentalOrder(const std::map<twobyte, twobyte>& values) { _acciorder = values; }
 
    static std::map<twobyte, twobyte> GetDefaultAccidentalOrder()
    {
        return {{-7,3}, {-6,0}, {-5,4}, {-4,1}, {-3,5}, {-2,2}, {-1,6}, {1,3}, {2,0}, {3,4}, {4,1}, {5,5}, {6,2}, {7,6}};
    }
    
    static bool CalcIsDefaultAccidentalOrder(const std::map<twobyte, twobyte>& values)
    {
        return values == GetDefaultAccidentalOrder();
    }
 
    std::map<twobyte, twobyte> GetAccidentalAmounts() const { return _acciamounts; }
    
    void SetAccidentalAmounts(const std::map<twobyte, twobyte>& values) { _acciamounts = values; }
 
    static std::map<twobyte, twobyte> GetDefaultAccidentalAmounts()
    {
        return {{-7,-1}, {-6,-1}, {-5,-1}, {-4,-1}, {-3,-1}, {-2,-1}, {-1,-1}, {1,1}, {2,1}, {3,1}, {4,1}, {5,1}, {6,1}, {7,1}};
    }
    
    static bool CalcIsDefaultAccidentalAmounts(const std::map<twobyte, twobyte>& values)
    {
        return values == GetDefaultAccidentalAmounts();
    }
 
    std::vector<std::map<twobyte, twobyte>> GetClefAccidentalPlacements() const { return _clefplacements; }
 
    void SetClefAccidentalPlacements(const std::vector<std::map<twobyte, twobyte>>& values) { _clefplacements = values; }
 
    static std::vector<std::map<twobyte, twobyte>> GetDefaultClefAccidentalPlacements()
    {
        return
        {
            {{-7,0}, {-6,1}, {-5,0}, {-4,1}, {-3,0}, {-2,1}, {-1,0}, {1,1}, {2,1}, {3,1}, {4,1}, {5,0}, {6,1}, {7,0}},
            {{-7,-1}, {-6,0}, {-5,-1}, {-4,0}, {-3,-1}, {-2,0}, {-1,-1}, {1,0}, {2,0}, {3,0}, {4,0}, {5,-1}, {6,0}, {7,-1}},
            {{-7,-1}, {-6,0}, {-5,-1}, {-4,0}, {-3,-1}, {-2,0}, {-1,-1}, {1,-1}, {2,0}, {3,-1}, {4,0}, {5,-1}, {6,0}, {7,-1}},
            {{-7,-2}, {-6,-1}, {-5,-2}, {-4,-1}, {-3,-2}, {-2,-1}, {-1,-2}, {1,-1}, {2,-1}, {3,-1}, {4,-1}, {5,-2}, {6,-1}, {7,-2}},
            {{-7,0}, {-6,1}, {-5,0}, {-4,1}, {-3,0}, {-2,1}, {-1,0}, {1,1}, {2,1}, {3,1}, {4,1}, {5,0}, {6,1}, {7,0}},
            {{-7,-1}, {-6,0}, {-5,-1}, {-4,0}, {-3,-1}, {-2,0}, {-1,-1}, {1,0}, {2,0}, {3,0}, {4,0}, {5,-1}, {6,0}, {7,-1}},
            {{-7,-3}, {-6,-2}, {-5,-3}, {-4,-2}, {-3,-3}, {-2,-2}, {-1,-3}, {1,-2}, {2,-2}, {3,-2}, {4,-2}, {5,-3}, {6,-2}, {7,-3}},
            {{-7,-1}, {-6,-1}, {-5,-1}, {-4,-1}, {-3,-1}, {-2,-1}, {-1,-1}, {1,-1}, {2,-1}, {3,-1}, {4,-1}, {5,-1}, {6,-1}, {7,-1}},
            {{-7,0}, {-6,1}, {-5,0}, {-4,1}, {-3,0}, {-2,1}, {-1,0}, {1,1}, {2,1}, {3,1}, {4,1}, {5,0}, {6,1}, {7,0}},
            {{-7,-1}, {-6,-1}, {-5,-1}, {-4,-1}, {-3,-1}, {-2,-1}, {-1,-1}, {1,-1}, {2,-1}, {3,-1}, {4,-1}, {5,-1}, {6,-1}, {7,-1}},
            {{-7,0}, {-6,0}, {-5,0}, {-4,0}, {-3,0}, {-2,0}, {-1,0}, {1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}, {7,0}},
            {{-7,0}, {-6,0}, {-5,0}, {-4,0}, {-3,0}, {-2,0}, {-1,0}, {1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}, {7,0}},
            {{-7,0}, {-6,1}, {-5,0}, {-4,1}, {-3,0}, {-2,1}, {-1,0}, {1,1}, {2,1}, {3,1}, {4,1}, {5,0}, {6,1}, {7,0}},
            {{-7,1}, {-6,2}, {-5,1}, {-4,2}, {-3,1}, {-2,2}, {-1,1}, {1,2}, {2,2}, {3,2}, {4,2}, {5,1}, {6,2}, {7,1}},
            {{-7,-1}, {-6,0}, {-5,-1}, {-4,0}, {-3,-1}, {-2,0}, {-1,-1}, {1,0}, {2,0}, {3,0}, {4,0}, {5,-1}, {6,0}, {7,-1}},
            {{-7,0}, {-6,1}, {-5,0}, {-4,1}, {-3,0}, {-2,1}, {-1,0}, {1,1}, {2,1}, {3,1}, {4,1}, {5,0}, {6,1}, {7,0}},
            {{-7,0}, {-6,1}, {-5,0}, {-4,1}, {-3,0}, {-2,1}, {-1,0}, {1,1}, {2,1}, {3,1}, {4,1}, {5,0}, {6,1}, {7,0}},
            {{-7,0}, {-6,1}, {-5,0}, {-4,1}, {-3,0}, {-2,1}, {-1,0}, {1,1}, {2,1}, {3,1}, {4,1}, {5,0}, {6,1}, {7,0}}
        };
    }
    
    static bool CalcIsDefaultClefAccidentalPlacements(const std::vector<std::map<twobyte, twobyte>>& values)
    {
        return values == GetDefaultClefAccidentalPlacements();
    }
    
    FCKeySignature* CreateKeySignature(eHarmAlt alteration = 0) const;
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
private:
    luabridge::RefCountedPtr<FCKeySignature> CreateKeySignature_GC(eHarmAlt alteration)
    { return makeLuaSharedPtr(CreateKeySignature(alteration)); }
public:
    static int CreateKeySignature_CFunc(lua_State *L)
    {
        return _CFunctionOneOptionalParameter<FCCustomKeyModeDef, luabridge::RefCountedPtr<FCKeySignature>, eHarmAlt, &FCCustomKeyModeDef::CreateKeySignature_GC>(L, 0);
    }
#endif
    
};
 
#endif  /* _FF_OTHER_H */