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