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 "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:
    virtual const char* ClassName() { 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

    virtual bool LoadFirst() { return false; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    __FCInciOther() : __FCOther() {}

    virtual bool Load(CMPER itemno, twobyte inci);
    
    virtual twobyte CalcLastInci();

    virtual bool Reload();

    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() { return false; }
    
    virtual TimeEdu32 GetMeasurePos() const { return 0; }
};

class FCOtherInci : public __FCInciOther
{
        twobyte _inciblock[6];

        virtual int DataSizeLoad() { return sizeof(_inciblock); }  /* A standard inci */
        virtual void* Allocate() { return _GetDataPtr(); }
        virtual EXTAG Tag() { return GetCustomTag();  }

        virtual void CloneMemoryFrom(__FCBaseData* pSource)
        {
                memcpy(&_inciblock, ((FCOtherInci*)pSource)->_GetDataPtr(), sizeof(_inciblock));
                _datablock = &_inciblock;
                _loadedsize = sizeof(_inciblock);
        }

        virtual __FCBaseData* CreateObject()
        {
                return new FCOtherInci();
        }
public:

        FCOtherInci() : __FCInciOther()
        {
                memset(&_inciblock, 0, sizeof(_inciblock));
                _datablock = &_inciblock;
                _loadedsize = sizeof(_inciblock);
        }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

        void* _GetDataPtr() { return &_inciblock; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

        virtual const char* ClassName() { return "FCOtherInci"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_OTHERINCI; }
};



class __FCNoInciOther : public __FCOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    int _DataSizeLoadFullCmper(CMPER cmper, ETAG othertag);

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

    __FCNoInciOther() : __FCOther() {}

    virtual bool Load(CMPER itemno);

    virtual bool Reload();

    virtual bool SaveAs(CMPER itemno);

    virtual bool DeepSaveAs(CMPER itemno)
    {
        return SaveAs(itemno);
    }

    virtual bool DeepDeleteData()
    {
        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;
    }

    virtual bool LoadFirst() { return Load(1); }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCOther::DebugDump();
        DebugOutDigit("dataid.other.cmper: ", _dataid.other.cmper);
    }
#endif

};


class __FCCompositeTimeSigTopElement : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTCompositeTimeUpper _compositetimeupperdata;

protected:
    virtual EXTAG Tag() { return ot_CompositeTimeUpper; }
    virtual int DataSizeLoad() { return sizeof(EDTCompositeTimeUpper); }
    virtual void* Allocate() { return (void*) &_compositetimeupperdata; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_compositetimeupperdata, ((__FCCompositeTimeSigTopElement*)pSource)->_GetDataPtr(), sizeof(_compositetimeupperdata));
        _datablock = &_compositetimeupperdata;
        _loadedsize = sizeof(_compositetimeupperdata);
    }

    virtual __FCBaseData* CreateObject()
    {
        return new __FCCompositeTimeSigTopElement();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "__FCCompositeTimeSigTopElement"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
    }
#endif
};



class __FCCompositeTimeSigBottomElement : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTCompositeTimeLower _compositetimelowerdata;

protected:
    virtual EXTAG Tag() { return ot_CompositeTimeLower; }
    virtual int DataSizeLoad() { return sizeof(EDTCompositeTimeLower); }
    virtual void* Allocate() { return (void*) &_compositetimelowerdata; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_compositetimelowerdata, ((__FCCompositeTimeSigBottomElement*)pSource)->_GetDataPtr(), sizeof(_compositetimelowerdata));
        _datablock = &_compositetimelowerdata;
        _loadedsize = sizeof(_compositetimelowerdata);
    }

    virtual __FCBaseData* CreateObject()
    {
        return new __FCCompositeTimeSigBottomElement();
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "__FCCompositeTimeSigBottomElement"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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
    virtual void DebugDump()
    {
        __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)
    {
        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
        virtual __FCBaseData* CreateElement() { 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

        virtual const char* ClassName() { return "FCCompositeTimeSigTop"; }

        FCCompositeTimeSigTop() : __FCCollectionInciOther()
        {
            _pArray = NULL;
            _arraycounter = 0;
        }

        virtual ~FCCompositeTimeSigTop()
        {
            delete [] _pArray;
            _pArray = NULL;
            _arraycounter = 0;
        }

        int GetGroupCount()
        {
            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)
        {
            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)
        {
            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)
        {
            ECompositeTimeUpper* pCompositeTimeUpper = _GetGroupElementPtr(groupindex, subindex);
            if (!pCompositeTimeUpper) return 0;
            return pCompositeTimeUpper->main;
        }

        int GetElementCount()
        {
            return _arraycounter;
        }

        void SetGroupElementBeats(int groupindex, int subindex, twobyte value)
        {
            ECompositeTimeUpper* pCompositeTimeUpper = _GetGroupElementPtr(groupindex, subindex);            
            if (!pCompositeTimeUpper) return;
            pCompositeTimeUpper->main = value;
        }

        virtual bool SaveAll()
        {
            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();
        }

        virtual bool SaveAllForItem(CMPER cmper)
        {
            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)
    {
        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
        virtual __FCBaseData* CreateElement() { 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

        virtual const char* ClassName() { return "FCCompositeTimeSigBottom"; }

        FCCompositeTimeSigBottom() : __FCCollectionInciOther()
        {
            _pArray = NULL;
            _arraycounter = 0;
        }

        virtual ~FCCompositeTimeSigBottom()
        {
            delete [] _pArray;
            _pArray = NULL;
            _arraycounter = 0;
        }

        int GetGroupCount()
        {            
            int groupcount = 0;
            for (int i = 0; i < _arraycounter; i++)
            {
                if (_pArray[i].chainstart) groupcount++;
            }
            return groupcount;
        }

        int GetGroupElementCount(int groupindex)
        {
            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)
        {
            ECompositeTimeLower* pCompositeTimeLower = _GetGroupElementPtr(groupindex, subindex);
            if (!pCompositeTimeLower) return 0;
            return pCompositeTimeLower->main;
        }

        int GetElementCount()
        {
            return _arraycounter;
        }

        int AddGroup()
        {            
            ECompositeTimeLower* pNewArray = new ECompositeTimeLower[_arraycounter + 1];

            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];
            pNewAddedData->chainstart = true;
            pNewAddedData->main = 1024;
            pNewAddedData ++;            

            /* Set new info: */
            _arraycounter ++;
            _pArray = pNewArray;

            return GetGroupCount() - 1;
        }

        bool DeleteGroup(int groupindex)
        {
            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;
        }

        virtual bool SaveAll()
        {
            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();
        }

        virtual bool SaveAllForItem(CMPER cmper)
        {
            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();
    bool _Is2014bFormat();
    
    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();

    void _SetMemory(EDTPathInst* pPathInstruction, void* pPathData, int offset);

    virtual ~FCShapeDefInstruction();

    int GetCount() const { return _size; }
    
    ETAG GetTag() const
    {
        return _tag;
    }
    
    virtual bool IsIdentical(__FCBase* pTestObject)
    {
        FCShapeDefInstruction* pTestInstruction = (FCShapeDefInstruction*) pTestObject;
        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);

        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->GetNameByID());  /* 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
    virtual void DebugDump()
    {
        __FCBase::DebugDump();

        DebugOutDigit("sizeof double: ", sizeof(double));
        DebugOutString("Tag: ", GetTagAsString());
        
        DebugOutDigit("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:
    virtual const char* ClassName() { return "FCShapeDefInstructions"; }

    FCShapeDefInstruction* GetItemAt(int index) { 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:
    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ot_Shape; }

    virtual EVERSION EnigmaVersion();

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        /* Copy the heap: */
        __FCNoInciOther::CloneMemoryFrom(pSource);
        /* Copy the empty shape state */
        _isemptyshape = ((FCShapeDef*) pSource)->_GetIsEmptyShape();
    }

    virtual int DataSizeLoad()
    {
        fourbyte size;
        if (!FX_LoadEData(Tag(), &_dataid, NULL, &size, EnigmaVersion())) return 0;
        
        if (!_Is2014bFormat())
        {
            /* Attempt to workaround for empty shape crashes on earlier Finale versions. */
            SetCustomTag((size == sizeof(EDTShape)) ? __ot_Shape_WORKAROUNDTAG : ot_Shape);
        }
        return size;
    }

    virtual void* Allocate()
    {
        _AllocateMemory(DataSizeLoad());
        return _datablock;
    }

    virtual void Deallocate()
    {
        if (_datablock) delete [] (char*) _datablock;
                _datablock = NULL;
        _loadedsize = 0;
    }

    virtual bool IsDynamicSize() { return true; }

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

    virtual bool LoadFirst()
    {
        return Load(1);
    }

    virtual bool DeleteData()
    {
        if (CalcProtected()) return false;
        return __FCNoInciOther::DeleteData();
    }

    virtual bool LoadNext()
    {
        return Load(GetItemNo() + 1);
    }

    virtual bool Load(CMPER itemno)
    {    
        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

    FCShapeDefInstructions* CreateInstructions_GC();
#endif

    FCStrings* CreateTextStrings();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCStrings* CreateTextStrings_GC();
#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
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Data size: ", (int) _loadedsize);
        DebugOutDigit("Instruction count: ", GetInstructionsCount());
        DebugOutDigit("Data count: ", GetDataCount());
        DebugOutDigit("sizeof EDTShape: ", sizeof(EDTShape));
        DebugOutDigit("sizeof EDTPathInst: ", sizeof(EDTPathInst));
        DebugOutDigit("sizeof EDTPathData2002: ", sizeof(EDTPathData2002));
        

        //FCShapeDefInstructions* pInstructions = CreateInstructions();
        //pInstructions->DebugDump();
        //delete pInstructions;
        
/*        DebugOutDigit("Instruction count: ", GetInstructionsCount());
        for (int i = 0; i < GetInstructionsCount(); i++)
        {
            DebugOutDigit("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:
    virtual EXTAG Tag()
    {
        if (GetCustomTag()) return GetCustomTag();
        FIN25_4_CODE( if (Use25_4Version()) return ot_TextExpEnclosure25_4; )
        return ot_TextExpEnclosure;
    }
    virtual int DataSizeLoad()
    {
        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 */
    virtual void* Allocate()
    {
        FIN25_4_CODE( if (Use25_4Version()) return (void*) _pEnclosure25_4; )
        return (void*) _pEnclosureOld;
    }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        void* pData = _GetEnclosure();
        int size = DataSizeLoad();
        memcpy(pData, ((FCEnclosure*)pSource)->_GetEnclosure(), size);
        _datablock = pData;
        _loadedsize = size;
    }

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

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCEnclosure"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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()
    {
        if (Use25_4Version())
        {
            FIN25_4_CODE( _pEnclosure25_4 = &_enclosuredata25_4; )
        }
        else
        {
            _pEnclosureOld = &_enclosuredataold;
        }
        
    }
    
    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;
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
    }
#endif

};


#ifdef PDK_FRAMEWORK_LAYOUT

class FCPage : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTPageSpec pagespec;
protected:
    virtual EXTAG Tag() { return ot_EDTPageSpec; }
    virtual int DataSizeLoad() { return sizeof(EDTPageSpec); }
    virtual void* Allocate() { return (void*) &pagespec; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&pagespec, ((FCPage*)pSource)->_GetPageSpec(), sizeof(pagespec));
        _datablock = &pagespec;
        _loadedsize = sizeof(pagespec);
    }

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

    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
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("First system: ", GetFirstSystem());
        DebugOutDigit("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:
    virtual EXTAG Tag() { return ot_EDTStaffSystemSpec; }
    virtual int DataSizeLoad() { return sizeof(EDTStaffSystemSpec2005); }
    virtual void* Allocate() { return (void*) &_staffsystem; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_staffsystem, ((FCStaffSystem*)pSource)->_GetStaffSystemSpec(), sizeof(_staffsystem));
        _datablock = &_staffsystem;
        _loadedsize = sizeof(_staffsystem);
    }


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

    FCSystemStaves* CreateSystemStaves_GC();
#endif

    FCFreezeSystem* CreateFreezeSystem(bool force_create = true);

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCFreezeSystem* CreateFreezeSystem_GC(bool force_create);
#endif

    bool CalcRegion(FCMusicRegion* pRegion);

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("First measure: ", GetFirstMeasure());
        DebugOutDigit("Next System Measure: ", GetNextSysMeasure());
        DebugOutDigit("Space Above: ", GetSpaceAbove());
        DebugOutDigit("Top Margin: ", GetTopMargin());
        DebugOutDigit("Bottom Margin: ", GetBottomMargin());
        DebugOutDigit("Staff Height: ", GetStaffHeight());
        DebugOutDigit("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); }

protected:
    virtual EVERSION EnigmaVersion() 
    { 
        return _VersionToUse();
    }
    virtual EXTAG Tag() { return ot_MeasureSpec; }
    virtual int DataSizeLoad() {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014) return sizeof(EDTMeasureSpec2014);
#endif
        return sizeof(EDTMeasureSpec2005);
    }
    
    virtual void* Allocate() 
    {
#if FXT_VERSION >= FINALEVERSION_2014
        if (_VersionToUse() == FINALEVERSION_2014) return (void*) &_measurespec2014;
#endif
        return (void*) &_measurespec2005;
    }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
#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);
    }

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

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

    virtual bool Save();

    virtual bool Load(CMPER itemno);

    FCBeatChartElements* CreateBeatChartElements();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    /* GC version of #CreateBeatChartElements for Lua. */
    FCBeatChartElements* CreateBeatChartElements_GC();
#endif

    FCExpressions* CreateExpressions();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    /* GC version of #CreateExpressions for Lua. */
    FCExpressions* CreateExpressions_GC();
#endif

    FCTempoElements* CreateTempoElements();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY
    /* GC version of #CreateTempoElements for Lua. */
    FCTempoElements* CreateTempoElements_GC();
#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);
    }
};

/* 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 AssignAllMeasures() to set */
    FCMeasures* _pAllMeasures;
    
    /* Used for the _SetTempAllMeasures() etc mechanism. This is where the real value of
     * _pAllMeasures is stored, during a temporary collection assignment. */
    FCMeasures* _pTempAllMeasuresStorage;
    
    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:
    virtual EXTAG Tag() { return ot_MeasNumberRegion; }
    virtual int DataSizeLoad();
    virtual void* Allocate();

    virtual EVERSION EnigmaVersion();

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(_GetData(), ((FCMeasureNumberRegion*)pSource)->_GetData(), DataSizeLoad());
        _datablock = Allocate();
        _loadedsize = DataSizeLoad();
    }

    virtual __FCBaseData* CreateObject() { return new FCMeasureNumberRegion(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    enum NUMBERINGSTYLE
    {
        NUMBERING_DIGITS = 0,

        /* "a, b, c...aa, bb, cc" */
        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
    {
        /* Show in all views */
        NUMBERVIEW_ALL = 0,

        /* Show in Page View only */
        NUMBERVIEW_PAGEONLY,

        /* Show in Scroll/Studio View only */
        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
    };

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

    FCFontInfo* CreateStartFontInfo_GC(bool 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

    FCFontInfo* CreateMultipleFontInfo_GC(bool 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

    FCFontInfo* CreateMultiMeasureFontInfo_GC(bool parts);
#endif

    FCString* CreateDisplayedString(twobyte measure);

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateDisplayedString_GC(twobyte 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 AssignAllMeasures(FCMeasures* pAllMeasures);
    
    void _SetTempAllMeasures(FCMeasures* pAllMeasuresToUse)
    {
        /* Store the "actual" value, restore it with _RestoreTempAllMeasures() */
        _pTempAllMeasuresStorage = _pAllMeasures;
        /* Set temp value */
        _pAllMeasures = pAllMeasuresToUse;
    }
    
    void _RestoreTempAllMeasures()
    {
        /* Restore from temporary storage to the "real" storage */
        _pAllMeasures = _pTempAllMeasuresStorage;
    }
    
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Start measure: ", GetStartMeasure());
        DebugOutDigit("End measure: ", GetEndMeasure());
    }
#endif
};

class FCSystemStaff : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTInstrumentUsed _instrumentused;    
    int _resize;

    virtual bool LoadFirst() { return false; }
protected:
    virtual EXTAG Tag() { return ot_InstrumentUsed; }
    virtual int DataSizeLoad() { return sizeof(EDTInstrumentUsed); }
    virtual void* Allocate() { return (void*) &_instrumentused; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_instrumentused, ((FCSystemStaff*)pSource)->_GetDataPtr(), sizeof(_instrumentused));
        _datablock = &_instrumentused;
        _loadedsize = sizeof(_instrumentused);
        _resize = ((FCSystemStaff*)pSource)->GetResize();
    }

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

    virtual bool Load(CMPER itemno, twobyte inci);

    virtual bool SaveNew(CMPER itemno);

    virtual bool Save();
    

    void SetDistance(Evpu32 distance) { _instrumentused.separ = -distance; }

    void SetStaff(eStaff staffno) { _instrumentused.inst = staffno; }

    Evpu32 GetDistance() const { return -_instrumentused.separ; }

    eStaff GetStaff() const { 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
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
        DebugOutDigit("Distance: ", GetDistance());
    }
#endif
};

class FCPercussionLayoutNotes;

class FCPercussionStaff  : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTDrumStaff2010 _drumstaff;

    virtual bool LoadFirst() { return false; }
protected:
    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ot_DrumStaff2010; } /* Custom tags might be used!!! */
    virtual int DataSizeLoad() { return sizeof(EDTDrumStaff2010); }
    virtual void* Allocate() { return (void*) &_drumstaff; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_drumstaff, ((FCPercussionStaff*)pSource)->_GetDataPtr(), sizeof(_drumstaff));
        _datablock = &_drumstaff;
        _loadedsize = sizeof(_drumstaff);
    }

    virtual __FCBaseData* CreateObject() { return new FCPercussionStaff(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCPercussionStaff"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("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;

    virtual bool LoadFirst() { return false; }
protected:
    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ot_NamePosFull; } /* Custom tags SHOULD be used!!! */
    virtual int DataSizeLoad() { return sizeof(EDTNamePos); }
    virtual void* Allocate() { return (void*) &_namepos; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_namepos, ((FCStaffNamePosition*)pSource)->_GetDataPtr(), sizeof(_namepos));
        _datablock = &_namepos;
        _loadedsize = sizeof(_namepos);
        _fullnamepos = ((FCStaffNamePosition*)pSource)->_GetFullNamePos();
    }

    virtual __FCBaseData* CreateObject() { return new FCStaffNamePosition(_fullnamepos); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCStaffNamePosition"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_STAFFNAMEPOSITION; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    bool _GetFullNamePos() {  return _fullnamepos; }

    void* _GetDataPtr() { return &_namepos; }
#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; }

    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)
    {
        justification &= NAMEPOS_JUSTIBITS;
        _namepos.flag &= ~NAMEPOS_JUSTIBITS;
        _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
{
private:
    mutable FCString _uuid;  /* Used for #GetInstrumentUUID */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    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;
            
    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 = (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:
#if FXT_VERSION >= FINALEVERSION_2012
    
    static const char* FFUUID_BLANKSTAFF;
    static const char* FFUUID_GRANDSTAFF;
    static const char* FFUUID_UNKNOWN;
    
    /* Strings */
    
    static const char* FFUUID_VIOLIN;
    static const char* FFUUID_VIOLA;
    static const char* FFUUID_CELLO;
    static const char* FFUUID_DOUBLEBASS;
    static const char* FFUUID_VIOLINSECTION;
    static const char* FFUUID_VIOLASECTION;
    static const char* FFUUID_CELLOSECTION;
    static const char* FFUUID_VIOLONCELLOSECTION;
    static const char* FFUUID_DOUBLEBASSSECTION;
    static const char* FFUUID_CONTRABASSSECTION;
    static const char* FFUUID_STRINGENSEMBLE;
    static const char* FFUUID_VIOLADAMORE;
    static const char* FFUUID_AJAENG;
    static const char* FFUUID_ARPEGGIONE;
    static const char* FFUUID_BARYTON;
    static const char* FFUUID_BYZANTINELYRA;
    static const char* FFUUID_CRETANLYRA;
    static const char* FFUUID_CRWTH;
    static const char* FFUUID_DAHU;
    static const char* FFUUID_DANGAO;
    static const char* FFUUID_DIHU;
    static const char* FFUUID_ERHU;
    static const char* FFUUID_ERXIAN;
    static const char* FFUUID_FIDDLE;
    static const char* FFUUID_GAOHU;
    static const char* FFUUID_GEHU;
    static const char* FFUUID_HAEGEUM;
    static const char* FFUUID_HARDANGERFIDDLE;
    static const char* FFUUID_HURDYGURDY;
    static const char* FFUUID_IGIL;
    static const char* FFUUID_KAMANCHA;
    static const char* FFUUID_KOKYU;
    static const char* FFUUID_KORA;
    static const char* FFUUID_LARUAN;
    static const char* FFUUID_LEIQIN;
    static const char* FFUUID_LIRONE;
    static const char* FFUUID_MORINKHUUR;
    static const char* FFUUID_NYCKELHARPA;
    static const char* FFUUID_OCTOBASS;
    static const char* FFUUID_REBAB;
    static const char* FFUUID_REBEC;
    static const char* FFUUID_SARANGI;
    static const char* FFUUID_SARANGIDRONE;
    static const char* FFUUID_STROHVIOLIN;
    static const char* FFUUID_TROMBAMARINA;
    static const char* FFUUID_VIELLE;
    static const char* FFUUID_VIOL;
    static const char* FFUUID_VIOLADAGAMBA;
    static const char* FFUUID_VIOLINOPICCOLO;
    static const char* FFUUID_VIOLONCELLOPICCOLO;
    static const char* FFUUID_VIOLOTTA;
    static const char* FFUUID_ZHONGHU;
    
    /* Keyboards */
    
    static const char* FFUUID_PIANO;
    static const char* FFUUID_PIANONONAME;
    static const char* FFUUID_HARPSICHORD;
    static const char* FFUUID_ORGAN;
    static const char* FFUUID_ORGAN2STAFF;
    static const char* FFUUID_CELESTA;
    static const char* FFUUID_ACCORDION;
    static const char* FFUUID_MELODICA;
    static const char* FFUUID_ELECTRICPIANO;
    static const char* FFUUID_CLAVINET;
    static const char* FFUUID_SYNTHPAD;
    static const char* FFUUID_SYNTHLEAD;
    static const char* FFUUID_SYNTHBRASS;
    static const char* FFUUID_SYNTHSOUNDTRACK;
    static const char* FFUUID_SOUNDFX;
    static const char* FFUUID_HARMONIUM;
    static const char* FFUUID_ONDESMARTENOT;
    static const char* FFUUID_THEREMIN;
    static const char* FFUUID_VIRGINAL;
    static const char* FFUUID_CLAVICHORD;
    
    /* Voices */
    
    static const char* FFUUID_SOPRANOVOICE;
    static const char* FFUUID_ALTOVOICE;
    static const char* FFUUID_TENORVOICE;
    static const char* FFUUID_BARITONEVOICE;
    static const char* FFUUID_BASSVOICE;
    static const char* FFUUID_VOCALS;
    static const char* FFUUID_VOICE;
    static const char* FFUUID_VOICENONAME;
    static const char* FFUUID_MEZZOSOPRANOVOICE;
    static const char* FFUUID_CONTRALTOVOICE;
    static const char* FFUUID_COUNTERTENORVOICE;
    static const char* FFUUID_BASSBAROTONEVOICE;
    static const char* FFUUID_CHOIRAAHS;
    static const char* FFUUID_CHOIROOHS;
    static const char* FFUUID_YODEL;
    static const char* FFUUID_BEATBOX;
    static const char* FFUUID_KAZOO;
    static const char* FFUUID_TALKBOX;
    static const char* FFUUID_VOCALPERCUSSION;
    
    /* Woodwinds */
    
    static const char* FFUUID_PICCOLO;
    static const char* FFUUID_FLUTE;
    static const char* FFUUID_ALTOFLUTE;
    static const char* FFUUID_OBOE;
    static const char* FFUUID_OBOEDAMORE;
    static const char* FFUUID_ENGLISHHORN;
    static const char* FFUUID_CLARINETBFLAT;
    static const char* FFUUID_CLARINETA;
    static const char* FFUUID_CLARINETEFLAT;
    static const char* FFUUID_ALTOCLARINET;
    static const char* FFUUID_CONTRALTOCLARINET;
    static const char* FFUUID_BASSCLARINET;
    static const char* FFUUID_CONTRABASSCLARINET;
    static const char* FFUUID_BASSOON;
    static const char* FFUUID_CONTRABASSOON;
    static const char* FFUUID_WINDSECTION;
    static const char* FFUUID_SOPRANOSAX;
    static const char* FFUUID_ALTOSAX;
    static const char* FFUUID_TENORSAX;
    static const char* FFUUID_BARITONESAX;
    static const char* FFUUID_SOPRANORECORDER;
    static const char* FFUUID_SOPRANINORECORDER;
    static const char* FFUUID_ALTORECORDER;
    static const char* FFUUID_TENORRECORDER;
    static const char* FFUUID_BASSRECORDER;
    static const char* FFUUID_DESCANTRECORDER;
    static const char* FFUUID_OCARINA;
    static const char* FFUUID_PENNYWHISTLE;
    static const char* FFUUID_PENNYWHISTLED;
    static const char* FFUUID_PENNYWHISTLEG;
    static const char* FFUUID_LOWIRISHWHISTLE;
    static const char* FFUUID_TINWHISTLEBFLAT;
    static const char* FFUUID_HARMONICA;
    static const char* FFUUID_BASSHARMONICA;
    static const char* FFUUID_CONCERTINA;
    static const char* FFUUID_BANDONEON;
    static const char* FFUUID_HORNF_WWQUINTET;
    static const char* FFUUID_BAGPIPES;
    static const char* FFUUID_UILLEANNPIPES;
    static const char* FFUUID_GAIDAPIPES;
    static const char* FFUUID_CONTRAALTOFLUTE;
    static const char* FFUUID_BASSFLUTE;
    static const char* FFUUID_CONTRABASSFLUTE;
    static const char* FFUUID_DOUBLECONTRABASSFLUTE;
    static const char* FFUUID_HYPERBASSFLUTE;
    static const char* FFUUID_PANPIPES;
    static const char* FFUUID_FIFE;
    static const char* FFUUID_BOTTLEBLOW;
    static const char* FFUUID_JUG;
    static const char* FFUUID_PICCOLOOBOE;
    static const char* FFUUID_PICCOLOHECKELPHONE;
    static const char* FFUUID_HECKELPHONE;
    static const char* FFUUID_BASSOBOE;
    static const char* FFUUID_BASSETCLARINET;
    static const char* FFUUID_BASSETHORN;
    static const char* FFUUID_HORNPIPE;
    static const char* FFUUID_PICCOLOCLARINET;
    static const char* FFUUID_SAXONETTE;
    static const char* FFUUID_SOPRANINOSAX;
    static const char* FFUUID_MEZZOSOPRANOSAX;
    static const char* FFUUID_SOPRILLO;
    static const char* FFUUID_CMELODYSAX;
    static const char* FFUUID_AULOCHROME;
    static const char* FFUUID_XAPHOON;
    static const char* FFUUID_BASSSAX;
    static const char* FFUUID_CONTRABASSSAX;
    static const char* FFUUID_SUBCONTRABASSSAX;
    static const char* FFUUID_TUBAX;
    static const char* FFUUID_BANSURI;
    static const char* FFUUID_DANSO;
    static const char* FFUUID_DIZI;
    static const char* FFUUID_DILLIKAVAL;
    static const char* FFUUID_DIPLE;
    static const char* FFUUID_DOUBLEFLUTE;
    static const char* FFUUID_DVOJNICE;
    static const char* FFUUID_DVOJNICEDRONE;
    static const char* FFUUID_FLAGEOLET;
    static const char* FFUUID_FUJARA;
    static const char* FFUUID_GEMSHORN;
    static const char* FFUUID_HOCCHIKU;
    static const char* FFUUID_HUN;
    static const char* FFUUID_IRISHFLUTE;
    static const char* FFUUID_KAVAL;
    static const char* FFUUID_KHLUI;
    static const char* FFUUID_KNOTWEEDFLUTE;
    static const char* FFUUID_KONCOVKAALTOFLUTE;
    static const char* FFUUID_KOUDI;
    static const char* FFUUID_NEY;
    static const char* FFUUID_NOHKAN;
    static const char* FFUUID_NOSEFLUTE;
    static const char* FFUUID_PALENDAG;
    static const char* FFUUID_QUENA;
    static const char* FFUUID_RYUTEKI;
    static const char* FFUUID_SHAKUHACHI;
    static const char* FFUUID_SHEPHERDSPIPE;
    static const char* FFUUID_SHINOBUE;
    static const char* FFUUID_SHIVAWHISTLE;
    static const char* FFUUID_SHVI;
    static const char* FFUUID_SULING;
    static const char* FFUUID_TARKA;
    static const char* FFUUID_TENOROVERTONEFLUTE;
    static const char* FFUUID_TUMPONG;
    static const char* FFUUID_VENU;
    static const char* FFUUID_XIAO;
    static const char* FFUUID_XUN;
    static const char* FFUUID_ALBOGUE;
    static const char* FFUUID_ALBOKA;
    static const char* FFUUID_ALTOCRUMHORN;
    static const char* FFUUID_ARGHUL;
    static const char* FFUUID_BAWU;
    static const char* FFUUID_CHALUMEAU;
    static const char* FFUUID_CLARINETTEDAMOUR;
    static const char* FFUUID_CORNAMUSE;
    static const char* FFUUID_DIPLICA;
    static const char* FFUUID_DOUBLECLARINET;
    static const char* FFUUID_HECKELCLARINA;
    static const char* FFUUID_HECKELPHONECLARINET;
    static const char* FFUUID_HIRTENSCHALMEI;
    static const char* FFUUID_LAUNEDDAS;
    static const char* FFUUID_MAQRUNAH;
    static const char* FFUUID_MIJWIZ;
    static const char* FFUUID_OCTAVIN;
    static const char* FFUUID_PIBGORN;
    static const char* FFUUID_RAUSCHPFEIFE;
    static const char* FFUUID_SIPSI;
    static const char* FFUUID_MODERNTAROGATO;
    static const char* FFUUID_TENORCRUMHORN;
    static const char* FFUUID_ZHALEIKA;
    static const char* FFUUID_ALGAITA;
    static const char* FFUUID_BIFORA;
    static const char* FFUUID_BOMBARDE;
    static const char* FFUUID_CROMORNE;
    static const char* FFUUID_DUDUK;
    static const char* FFUUID_DULCIAN;
    static const char* FFUUID_DULZAINA;
    static const char* FFUUID_GUAN;
    static const char* FFUUID_GUANZI;
    static const char* FFUUID_HICHIRIKI;
    static const char* FFUUID_HNE;
    static const char* FFUUID_JOGIBAJA;
    static const char* FFUUID_KENBAU;
    static const char* FFUUID_MIZMAR;
    static const char* FFUUID_NADASWARAM;
    static const char* FFUUID_OBOEDACACCIA;
    static const char* FFUUID_PI;
    static const char* FFUUID_PIRI;
    static const char* FFUUID_PUNGISNAKECHARMER;
    static const char* FFUUID_RACKETT;
    static const char* FFUUID_REEDCONTRABASS;
    static const char* FFUUID_RHAITA;
    static const char* FFUUID_ROTHPHONE;
    static const char* FFUUID_SARRUSOPHONE;
    static const char* FFUUID_SHAWM;
    static const char* FFUUID_SHEHNAI;
    static const char* FFUUID_SOPILA;
    static const char* FFUUID_SORNA;
    static const char* FFUUID_SRALAI;
    static const char* FFUUID_SUONA;
    static const char* FFUUID_SURNAY;
    static const char* FFUUID_TAEPYEONGSO;
    static const char* FFUUID_ANCIENTTAROGATO;
    static const char* FFUUID_TROMPETACHINA;
    static const char* FFUUID_ZURLA;
    static const char* FFUUID_ZURNA;
    static const char* FFUUID_KHAENMOUTHORGAN;
    static const char* FFUUID_HULUSI;
    static const char* FFUUID_SHENG;
    
    /* Brass */
    static const char* FFUUID_TRUMPETBFLAT;
    static const char* FFUUID_TRUMPETC;
    static const char* FFUUID_TRUMPETD;
    static const char* FFUUID_CORNET;
    static const char* FFUUID_FLUGELHORN;
    static const char* FFUUID_MELLOPHONE;
    static const char* FFUUID_HORNF;
    static const char* FFUUID_TROMBONE;
    static const char* FFUUID_BASSTROMBONE;
    static const char* FFUUID_EUPHONIUM;
    static const char* FFUUID_BARITONEBC;
    static const char* FFUUID_BARITONETC;
    static const char* FFUUID_TUBA;
    static const char* FFUUID_BASSTUBA;
    static const char* FFUUID_SOUSAPHONE;
    static const char* FFUUID_BRASSSECTION;
    static const char* FFUUID_PICCOLOTRUMPETA;
    static const char* FFUUID_BUGLE;
    static const char* FFUUID_CORNETEFLAT;
    static const char* FFUUID_HORNEFLAT;
    static const char* FFUUID_ALTOTROMBONE;
    static const char* FFUUID_TENORTROMBONE;
    static const char* FFUUID_CONTRABASSTROMBONE;
    static const char* FFUUID_ALPHORN;
    static const char* FFUUID_ALTOHORN;
    static const char* FFUUID_DIDGERIDOO;
    static const char* FFUUID_POSTHORN;
    static const char* FFUUID_VIENNAHORN;
    static const char* FFUUID_WAGNERTUBA;
    static const char* FFUUID_BAROQUETRUMPET;
    static const char* FFUUID_BASSTRUMPET;
    static const char* FFUUID_CORNETTO;
    static const char* FFUUID_FISCORN;
    static const char* FFUUID_KUHLOHORN;
    static const char* FFUUID_POCKETTRUMPET;
    static const char* FFUUID_SAXHORN;
    static const char* FFUUID_SLIDETRUMPET;
    static const char* FFUUID_CIMBASSO;
    static const char* FFUUID_DOUBLEBELLEUPHONIUM;
    static const char* FFUUID_SACKBUT;
    static const char* FFUUID_HELICON;
    static const char* FFUUID_OPHICLEIDE;
    static const char* FFUUID_SERPENT;
    static const char* FFUUID_SUBCONTRABASSTUBA;
    static const char* FFUUID_CONCHSHELL;
    static const char* FFUUID_HORAGAI;
    static const char* FFUUID_SHOFAR;
    static const char* FFUUID_VUVUZELA;
    
    /* Plucked strings */
    static const char* FFUUID_HARP;
    static const char* FFUUID_TROUBADORHARP;
    static const char* FFUUID_GUITAR;
    static const char* FFUUID_GUITAR8VB;
    static const char* FFUUID_ACOUSTICGUITAR;
    static const char* FFUUID_CLASSICALGUITAR;
    static const char* FFUUID_ELECTRICGUITAR;
    static const char* FFUUID_STEELGUITAR;
    static const char* FFUUID_BANJO;
    static const char* FFUUID_TENORBANJO;
    static const char* FFUUID_ACOUSTICBASS;
    static const char* FFUUID_BASSGUITAR;
    static const char* FFUUID_ELECTRICBASS;
    static const char* FFUUID_FRETLESSBASS;
    static const char* FFUUID_STRINGBASS;
    static const char* FFUUID_MANDOLIN;
    static const char* FFUUID_DULCIMER;
    static const char* FFUUID_HAMMEREDDULCIMER;
    static const char* FFUUID_DULCIMER8VB;
    static const char* FFUUID_AUTOHARP;
    static const char* FFUUID_LUTE;
    static const char* FFUUID_UKULELE;
    static const char* FFUUID_TENORUKULELE;
    static const char* FFUUID_SITAR;
    static const char* FFUUID_ZITHER;
    static const char* FFUUID_ARCHLUTE;
    static const char* FFUUID_BAGLAMA;
    static const char* FFUUID_BALALAIKA;
    static const char* FFUUID_BANDURA;
    static const char* FFUUID_BANJOLELE;
    static const char* FFUUID_BARBAT;
    static const char* FFUUID_BEGENA;
    static const char* FFUUID_BIWA;
    static const char* FFUUID_BOLON;
    static const char* FFUUID_BORDONUA;
    static const char* FFUUID_BOUZOUKI;
    static const char* FFUUID_BULGARIANTAMBURA;
    static const char* FFUUID_CHAPMANSTICK;
    static const char* FFUUID_CHARANGO;
    static const char* FFUUID_CHITARRABATTENTE;
    static const char* FFUUID_CHOAZHOUGUZHENG;
    static const char* FFUUID_CIMBALOM;
    static const char* FFUUID_CITTERN;
    static const char* FFUUID_CUATRO;
    static const char* FFUUID_DANBAU;
    static const char* FFUUID_DANNGUYET;
    static const char* FFUUID_DANTAMTHAPLUC;
    static const char* FFUUID_DANTRANH;
    static const char* FFUUID_DANTYBA;
    static const char* FFUUID_DIDDLEYBOW;
    static const char* FFUUID_DOBRO;
    static const char* FFUUID_DOMRA;
    static const char* FFUUID_DUTAR;
    static const char* FFUUID_DUXIANQIN;
    static const char* FFUUID_EKTARA1;
    static const char* FFUUID_FLAMENCOGUITAR;
    static const char* FFUUID_GEOMUNGO;
    static const char* FFUUID_EKTARA2;
    static const char* FFUUID_GOTTUVADHYAM;
    static const char* FFUUID_GUITARRAQUINTAHUAPANGUERA;
    static const char* FFUUID_GUITARRON;
    static const char* FFUUID_GUITJO;
    static const char* FFUUID_GUITJODOUBLENECK;
    static const char* FFUUID_GUQIN;
    static const char* FFUUID_GUZHENG;
    static const char* FFUUID_HARPGUITAR;
    static const char* FFUUID_IRISHBOUZOUKI;
    static const char* FFUUID_JARANAHUASTECA;
    static const char* FFUUID_JARANAJAROCHO;
    static const char* FFUUID_JARANAMOSQUITO;
    static const char* FFUUID_JARANASEGUNDA;
    static const char* FFUUID_JARANATERCERA;
    static const char* FFUUID_KABOSY;
    static const char* FFUUID_KANTELE;
    static const char* FFUUID_KAYAGUM;
    static const char* FFUUID_KHIM;
    static const char* FFUUID_KOBZA;
    static const char* FFUUID_KOMUZ;
    static const char* FFUUID_KOTO;
    static const char* FFUUID_KUTIYAPI;
    static const char* FFUUID_LANGELEIK;
    static const char* FFUUID_LYRE;
    static const char* FFUUID_MANDOBASS;
    static const char* FFUUID_MANDOCELLO;
    static const char* FFUUID_MANDOLA;
    static const char* FFUUID_MANDORA;
    static const char* FFUUID_MANDORE;
    static const char* FFUUID_MANGBETU;
    static const char* FFUUID_MAROVANY;
    static const char* FFUUID_MOHANVEENA;
    static const char* FFUUID_MOODSWINGER;
    static const char* FFUUID_MUSICALBOW;
    static const char* FFUUID_NGONI;
    static const char* FFUUID_OCTAVEMANDOLIN;
    static const char* FFUUID_OUD;
    static const char* FFUUID_PIPA;
    static const char* FFUUID_PORTUGUESEGUITAR;
    static const char* FFUUID_PSALTERY;
    static const char* FFUUID_REQUINTOGUITAR;
    static const char* FFUUID_RUAN;
    static const char* FFUUID_RUDRAVEENA;
    static const char* FFUUID_SALLANEH;
    static const char* FFUUID_SANSHIN;
    static const char* FFUUID_SANTOOR;
    static const char* FFUUID_SANXIAN;
    static const char* FFUUID_SAROD;
    static const char* FFUUID_SAUNG;
    static const char* FFUUID_SAZ;
    static const char* FFUUID_SE;
    static const char* FFUUID_SETAR;
    static const char* FFUUID_SHAMISEN;
    static const char* FFUUID_TAMBURA;
    static const char* FFUUID_TAR_PLUCKED;
    static const char* FFUUID_THEORBO;
    static const char* FFUUID_TIMPLE;
    static const char* FFUUID_TRES;
    static const char* FFUUID_TSYMBALY;
    static const char* FFUUID_VALIHA;
    static const char* FFUUID_VEENA;
    static const char* FFUUID_VICHITRAVEENA;
    static const char* FFUUID_VIHUELAMEXICO;
    static const char* FFUUID_VIHUELASPAIN;
    static const char* FFUUID_WASHTUBBASS;
    static const char* FFUUID_WHAMOLA;
    static const char* FFUUID_XALAM;
    static const char* FFUUID_YANGQIN;
    static const char* FFUUID_YAZHENG;
    static const char* FFUUID_YUEQIN;
    
    /* Tablature */
    static const char* FFUUID_TAB_GUITAR;
    static const char* FFUUID_TAB_GUITARNONAME;
    static const char* FFUUID_TAB_GUITARSTEMS;
    static const char* FFUUID_TAB_GUITAR_D;
    static const char* FFUUID_TAB_GUITAR_DADGAD;
    static const char* FFUUID_TAB_GUITAR_DOUBLED;
    static const char* FFUUID_TAB_GUITAR_DROPD;
    static const char* FFUUID_TAB_GUITAR_G;
    static const char* FFUUID_TAB_GUITAR_7STRING;
    static const char* FFUUID_TAB_BANJO_G;
    static const char* FFUUID_TAB_TENORBANJO;
    static const char* FFUUID_TAB_BANJO_C;
    static const char* FFUUID_TAB_BANJO_D;
    static const char* FFUUID_TAB_BANJO_DOUBLEC;
    static const char* FFUUID_TAB_BANJO_GMODAL;
    static const char* FFUUID_TAB_BANJO_PLECTRUM;
    static const char* FFUUID_TAB_BASSGUITAR_4;
    static const char* FFUUID_TAB_BASSGUITAR_5;
    static const char* FFUUID_TAB_BASSGUITAR_6;
    static const char* FFUUID_TAB_DULCIMER_DAA;
    static const char* FFUUID_TAB_DULCIMER_DAAUNISON;
    static const char* FFUUID_TAB_DULCIMER_DAD;
    static const char* FFUUID_TAB_GAMBA;
    static const char* FFUUID_TAB_LUTEITALIAN;
    static const char* FFUUID_TAB_LUTELETTERS;
    static const char* FFUUID_TAB_MANDOLIN;
    static const char* FFUUID_TAB_REQUINTO;
    static const char* FFUUID_TAB_SITAR_SHANKAR;
    static const char* FFUUID_TAB_SITAR_KHAN;
    static const char* FFUUID_TAB_UKULELE;
    static const char* FFUUID_TAB_VIHUELA;
    
    /* Pitched Percussion */
    static const char* FFUUID_TIMPANI;
    static const char* FFUUID_MALLETS;
    static const char* FFUUID_BELLS;
    static const char* FFUUID_CHIMES;
    static const char* FFUUID_CROTALES;
    static const char* FFUUID_GLOCKENSPIEL;
    static const char* FFUUID_SOPRANOGLOCKENSPIEL;
    static const char* FFUUID_ALTOGLOCKENSPIEL;
    static const char* FFUUID_MARIMBA;
    static const char* FFUUID_BASSMARIMBA;
    static const char* FFUUID_MARIMBASINGLESTAFF;
    static const char* FFUUID_TUBULARBELLS;
    static const char* FFUUID_VIBRAPHONE;
    static const char* FFUUID_XYLOPHONE;
    static const char* FFUUID_SOPRANOXYLOPHONE;
    static const char* FFUUID_ALTOXYLOPHONE;
    static const char* FFUUID_BASSXYLOPHONE;
    static const char* FFUUID_XYLORIMBA;
    static const char* FFUUID_BELL_LYRE;
    static const char* FFUUID_BOOMWHACKERS;
    static const char* FFUUID_CHROMANOTESINSTRUMENTS;
    static const char* FFUUID_CARILLON;
    static const char* FFUUID_CRYSTALGLASSES;
    static const char* FFUUID_FLEXATONE_PITCHED;
    static const char* FFUUID_GLASSHARMONICA;
    static const char* FFUUID_GLASSMARIMBA;
    static const char* FFUUID_HANDBELLS;
    static const char* FFUUID_HANDBELLS_TCLEF;
    static const char* FFUUID_HANDBELLS_BCLEF;
    static const char* FFUUID_HANG_TCLEF;
    static const char* FFUUID_JAWHARP;
    static const char* FFUUID_KALIMBA;
    static const char* FFUUID_SOPRANOMETALLOPHONE;
    static const char* FFUUID_ALTOMETALLOPHONE;
    static const char* FFUUID_BASSMETALLOPHONE;
    static const char* FFUUID_MUSICALSAW;
    static const char* FFUUID_SLIDEWHISTLE;
    static const char* FFUUID_STEELDRUMS_TCLEF;
    static const char* FFUUID_STEELDRUMS_BCLEF;
    static const char* FFUUID_BONANGGAMELAN;
    static const char* FFUUID_GANGSAGAMELAN;
    static const char* FFUUID_GENDERGAMELAN;
    static const char* FFUUID_GIYINGGAMELAN;
    static const char* FFUUID_KANTILGAMELAN;
    static const char* FFUUID_PELOGPANERUSGAMELAN;
    static const char* FFUUID_PEMADEGAMELAN;
    static const char* FFUUID_PENYACAHGAMELAN;
    static const char* FFUUID_SARONBARUNGGAMELAN;
    static const char* FFUUID_SARONDEMONGGAMELAN;
    static const char* FFUUID_SARONPANERUSGAMELAN;
    static const char* FFUUID_SLENDROPANERUSGAMELAN;
    static const char* FFUUID_SLENTHEMSGAMELAN;
    static const char* FFUUID_ALMGLOCKEN;
    static const char* FFUUID_ANGKLUNG;
    static const char* FFUUID_ARRAYMBIRA;
    static const char* FFUUID_BALAFON;
    static const char* FFUUID_BALAPHON;
    static const char* FFUUID_BIANQING;
    static const char* FFUUID_BIANZHONG;
    static const char* FFUUID_FANGXIANG;
    static const char* FFUUID_GANDINGANAKAYO;
    static const char* FFUUID_GYIL;
    static const char* FFUUID_KUBING;
    static const char* FFUUID_KULINTANG;
    static const char* FFUUID_KULINTANGAKAYO;
    static const char* FFUUID_KULINTANGATINIOK;
    static const char* FFUUID_LAMELLAPHONE;
    static const char* FFUUID_LIKEMBE;
    static const char* FFUUID_LUNTANG;
    static const char* FFUUID_MBIRA;
    static const char* FFUUID_MURCHANG;
    static const char* FFUUID_RANATEKLEK;
    static const char* FFUUID_RANATTHUMLEK;
    static const char* FFUUID_SANZA;
    static const char* FFUUID_TAIKODRUMS;
    static const char* FFUUID_TEMPLEBELLS;
    static const char* FFUUID_TIBETANBELLS;
    static const char* FFUUID_TIBETANSINGINGBOWLS;
    
    /* Drums */
    
    static const char* FFUUID_SNAREDRUM;
    static const char* FFUUID_BASSDRUM;
    static const char* FFUUID_DRUMSET;
    static const char* FFUUID_TENORDRUM;
    static const char* FFUUID_QUADTOMS;
    static const char* FFUUID_QUINTTOMS;
    static const char* FFUUID_ROTOTOMS;
    static const char* FFUUID_TENORLINE;
    static const char* FFUUID_SNARELINE;
    static const char* FFUUID_BASSDRUMS_5LINE;
    static const char* FFUUID_DJEMBE;
    static const char* FFUUID_BONGODRUMS;
    static const char* FFUUID_CONGADRUMS;
    static const char* FFUUID_LOGDRUM;
    static const char* FFUUID_TABLAS;
    static const char* FFUUID_TIMBALES;
    static const char* FFUUID_AFRICANLOGDRUM;
    static const char* FFUUID_APENTEMMA;
    static const char* FFUUID_ARABIANFRAMEDRUM;
    static const char* FFUUID_ASHIKO;
    static const char* FFUUID_ATABAQUE;
    static const char* FFUUID_BATA;
    static const char* FFUUID_BENDIR;
    static const char* FFUUID_BODHRAN;
    static const char* FFUUID_BOMBO;
    static const char* FFUUID_BOUGARABOU;
    static const char* FFUUID_BUFFALODRUM;
    static const char* FFUUID_CHENDA;
    static const char* FFUUID_CHUDAIKO;
    static const char* FFUUID_DABAKAN;
    static const char* FFUUID_DAIBYOSI;
    static const char* FFUUID_DAMROO;
    static const char* FFUUID_DARABUKA;
    static const char* FFUUID_DATANGULIONDRUM;
    static const char* FFUUID_DHOL;
    static const char* FFUUID_DHOLAK;
    static const char* FFUUID_DOLLU;
    static const char* FFUUID_DONDO;
    static const char* FFUUID_DOUNDOUNBA;
    static const char* FFUUID_DUFF;
    static const char* FFUUID_DUMBEK;
    static const char* FFUUID_EWEDRUMKAGAN;
    static const char* FFUUID_EWEDRUMKPANLOGO1LARGE;
    static const char* FFUUID_EWEDRUMKPANLOGO2MEDIUM;
    static const char* FFUUID_EWEDRUMKPANLOGO3COMBO;
    static const char* FFUUID_EWEDRUMSOGO;
    static const char* FFUUID_FONTOMFROM;
    static const char* FFUUID_GEDUK;
    static const char* FFUUID_HANDDRUM;
    static const char* FFUUID_HIRADAIKO;
    static const char* FFUUID_IGIHUMURIZO;
    static const char* FFUUID_INGOMA;
    static const char* FFUUID_INYAHURA;
    static const char* FFUUID_JANGGU;
    static const char* FFUUID_KAKKO;
    static const char* FFUUID_KANJIRA;
    static const char* FFUUID_KENDANGGAMELAN;
    static const char* FFUUID_KENKENI;
    static const char* FFUUID_KHOL;
    static const char* FFUUID_KODAIKO;
    static const char* FFUUID_KUDUM;
    static const char* FFUUID_LAMBEGDRUM;
    static const char* FFUUID_MADAL;
    static const char* FFUUID_MADDALE;
    static const char* FFUUID_MOROCCODRUM;
    static const char* FFUUID_MRIDANGAM;
    static const char* FFUUID_NAAL;
    static const char* FFUUID_NAGADODAIKO;
    static const char* FFUUID_NAGARA;
    static const char* FFUUID_NAQARA;
    static const char* FFUUID_NATIVELOGDRUM;
    static const char* FFUUID_NIGERIANLOGDRUM;
    static const char* FFUUID_ODAIKO;
    static const char* FFUUID_OKAWA;
    static const char* FFUUID_OKEDODAIKO;
    static const char* FFUUID_PAHUHULA;
    static const char* FFUUID_PAKHAVAJ;
    static const char* FFUUID_PANDERO;
    static const char* FFUUID_POWWOWDRUM;
    static const char* FFUUID_PUEBLODRUM;
    static const char* FFUUID_REPINIQUE;
    static const char* FFUUID_SABAR;
    static const char* FFUUID_SAKARA;
    static const char* FFUUID_SAMPHO;
    static const char* FFUUID_SANGBAN;
    static const char* FFUUID_SHIMEDAIKO;
    static const char* FFUUID_SURDO;
    static const char* FFUUID_TALKINGDRUM;
    static const char* FFUUID_TAMA;
    static const char* FFUUID_TAMBORITA;
    static const char* FFUUID_TAMTE;
    static const char* FFUUID_TANTAN;
    static const char* FFUUID_TANGKU;
    static const char* FFUUID_TAPHON;
    static const char* FFUUID_TARDRUM;
    static const char* FFUUID_TASHA;
    static const char* FFUUID_THAVIL;
    static const char* FFUUID_TOMBAK;
    static const char* FFUUID_TUMBAK;
    static const char* FFUUID_TSUZUMI;
    static const char* FFUUID_UCHIWADAIKO;
    static const char* FFUUID_UDAKU;
    static const char* FFUUID_ZARB;
    
    /* Percussion */
    
    static const char* FFUUID_PERCUSSIONGENERAL;
    static const char* FFUUID_PERCACCESSORIES;
    static const char* FFUUID_WINDCHIMES;
    static const char* FFUUID_CHIMETREE;
    static const char* FFUUID_BELLTREE;
    static const char* FFUUID_JINGLEBELLS;
    static const char* FFUUID_TAMBOURINE;
    static const char* FFUUID_TRIANGLE;
    static const char* FFUUID_CYMBALS;
    static const char* FFUUID_FINGERCYMBALS;
    static const char* FFUUID_CRASHCYMBAL;
    static const char* FFUUID_HIHATCYMBAL;
    static const char* FFUUID_RIDECYMBAL;
    static const char* FFUUID_SPLASHCYMBAL;
    static const char* FFUUID_TAMTAM;
    static const char* FFUUID_GONG;
    static const char* FFUUID_AGOGOBELLS;
    static const char* FFUUID_AIRHORN;
    static const char* FFUUID_BRAKEDRUM;
    static const char* FFUUID_CABASA;
    static const char* FFUUID_CAJON;
    static const char* FFUUID_CASTANETS;
    static const char* FFUUID_CLAP;
    static const char* FFUUID_CLAPPER;
    static const char* FFUUID_CLAVES;
    static const char* FFUUID_COWBELL;
    static const char* FFUUID_CUICA;
    static const char* FFUUID_GUIRO;
    static const char* FFUUID_MARACAS;
    static const char* FFUUID_POLICEWHISTLE;
    static const char* FFUUID_RAINSTICK;
    static const char* FFUUID_RATCHET;
    static const char* FFUUID_RATTLE;
    static const char* FFUUID_SANDBLOCK;
    static const char* FFUUID_SHAKERS;
    static const char* FFUUID_SPOONS;
    static const char* FFUUID_TEMPLEBLOCKS;
    static const char* FFUUID_VIBRASLAP;
    static const char* FFUUID_WASHBOARD;
    static const char* FFUUID_WHIP;
    static const char* FFUUID_WINDMACHINE;
    static const char* FFUUID_WOODBLOCKS;
    static const char* FFUUID_CENGCENGGAMELAN;
    static const char* FFUUID_GONGAGENGGAMELAN;
    static const char* FFUUID_KEMPULGAMELAN;
    static const char* FFUUID_KEMPYANGGAMELAN;
    static const char* FFUUID_KENONGGAMELAN;
    static const char* FFUUID_KETUKGAMELAN;
    static const char* FFUUID_REYONGGAMELAN;
    static const char* FFUUID_ADODO;
    static const char* FFUUID_AEOLIANHARP;
    static const char* FFUUID_AFOXE;
    static const char* FFUUID_AGOGOBLOCK;
    static const char* FFUUID_AGUNG;
    static const char* FFUUID_AGUNGATAMLANG;
    static const char* FFUUID_AHOKO;
    static const char* FFUUID_BABENDIL;
    static const char* FFUUID_BASICINDIANPERCUSSION;
    static const char* FFUUID_BERIMBAU;
    static const char* FFUUID_BO;
    static const char* FFUUID_BONES;
    static const char* FFUUID_BONGOBELLS;
    static const char* FFUUID_BULLROARER;
    static const char* FFUUID_CAXIXI;
    static const char* FFUUID_CHACHABELLS;
    static const char* FFUUID_CHABARA;
    static const char* FFUUID_CHANCHIKI;
    static const char* FFUUID_CHIMTA;
    static const char* FFUUID_CHINATEMPLEBLOCKS;
    static const char* FFUUID_CHINESECYMBALS;
    static const char* FFUUID_CHINESEGONGS;
    static const char* FFUUID_CHINESEPERCUSSIONENSEMBLE;
    static const char* FFUUID_CHING;
    static const char* FFUUID_CHIPPLI;
    static const char* FFUUID_DAFF;
    static const char* FFUUID_DAFLI;
    static const char* FFUUID_DAWURO;
    static const char* FFUUID_DEF;
    static const char* FFUUID_DOIRA;
    static const char* FFUUID_EWEDRUMATOKE;
    static const char* FFUUID_EWEDRUMAXATSE;
    static const char* FFUUID_EWEDRUMGANGOKUI;
    static const char* FFUUID_FLEXATONE_PERC;
    static const char* FFUUID_GANDINGAN;
    static const char* FFUUID_GANZA;
    static const char* FFUUID_GHATAM;
    static const char* FFUUID_GHUNGROO;
    static const char* FFUUID_GOME;
    static const char* FFUUID_GUBAN;
    static const char* FFUUID_HANDCYMBAL;
    static const char* FFUUID_HANG;
    static const char* FFUUID_HATHELI;
    static const char* FFUUID_HOSHO;
    static const char* FFUUID_HYOUSHIGI;
    static const char* FFUUID_IBO;
    static const char* FFUUID_INDIANGONG;
    static const char* FFUUID_IPU;
    static const char* FFUUID_JAWBONE;
    static const char* FFUUID_KAEKEEKE;
    static const char* FFUUID_KAGUL;
    static const char* FFUUID_KALAAU;
    static const char* FFUUID_KASHIKLAR;
    static const char* FFUUID_KESI;
    static const char* FFUUID_KHARTAL;
    static const char* FFUUID_KKWAENGGWARI;
    static const char* FFUUID_KPOKOKPOKO;
    static const char* FFUUID_KRINSLITDRUM;
    static const char* FFUUID_LAVASTONES;
    static const char* FFUUID_LUOGONG;
    static const char* FFUUID_MANJEERA;
    static const char* FFUUID_PANCLAPPERS;
    static const char* FFUUID_PATSCHEN;
    static const char* FFUUID_RATTLECOG;
    static const char* FFUUID_RIQ;
    static const char* FFUUID_SHEKERE;
    static const char* FFUUID_SISTRE;
    static const char* FFUUID_SISTRUM;
    static const char* FFUUID_SLIDEWHISTLE_PERCCLEF;
    static const char* FFUUID_SLITDRUM;
    static const char* FFUUID_SNAP;
    static const char* FFUUID_STAMP;
    static const char* FFUUID_STIRDRUM;
    static const char* FFUUID_TEBYOSHI;
    static const char* FFUUID_TELEVI;
    static const char* FFUUID_TEPONAXTLI;
    static const char* FFUUID_THAIGONG;
    static const char* FFUUID_TIBETANCYMBALS;
    static const char* FFUUID_TICTOCBLOCK;
    static const char* FFUUID_TIMBALEBELL;
    static const char* FFUUID_TINAJA;
    static const char* FFUUID_TINGSHA;
    static const char* FFUUID_TOERE;
    static const char* FFUUID_TONETANG;
    static const char* FFUUID_TRYCHEL;
    static const char* FFUUID_UDU;
    static const char* FFUUID_ZILLS;
    
#endif

    enum STAFFNOTATION_STYLE
    {
        STAFFNOTATION_NORMAL = 0,
        
        STAFFNOTATION_PERCUSSION = 1,
        
        STAFFNOTATION_TABLATURE = 2
    };
    
    enum ALTERNATE_STAFF {
        
        ALTSTAFF_NORMAL = FXUseNormalNotation,
        
        ALTSTAFF_SLASHBEATS = FXUseSlashBeatsNotation,
        
        ALTSTAFF_RHYTHMIC = FXUseRhythmicNotation,
        
        ALTSTAFF_ONEBARREPEAT = FXUseOneBarRepeatSymbol,
        
        ALTSTAFF_TWOBARREPEAT = FXUseTwoBarRepeatSymbol,
        
        ALTSTAFF_BLANKNOTATIONRESTS = 5,
        
        ALTSTAFF_BLANKNOTATION = FXUseBlankNotation
    };
    
    enum STAFF_HIDEMODES
    {
        STAFFHIDE_NORMAL = 0,
        
        STAFFHIDE_SCORE = 1,
        
        STAFFHIDE_SCORE_AND_PARTS = 2,
        
        STAFFHIDE_CUTAWAY = 3
    };
    
    /***********/
    /* GETTERS */
    /***********/
    
    bool GetIgnoreKeySig() const { return _GetInstFlag(STAFF_NOKEY); }
    
    bool GetIndependentTimeSig() const { return _GetInstFlag(STAFF_FLOATTIME); }
    
    bool GetIndependentKeySig() const { return _GetInstFlag(STAFF_FLOATKEYS); }
    
    bool GetShowMeasureNumbers() const { return !_GetInstFlag(STAFF_NEGMNUMB); }
    
    bool GetShowKeySignatures() const { return !_GetInstFlag(STAFF_NEGKEY); }
    

        bool GetShowTimeSignatures() const
        {
#if FXT_VERSION < FINALEVERSION_25
                return !_GetInstFlag(STAFF_NEGTIME); /* 32-bit PDK */
#else
                return !_GetInstFlag(STAFF_NEGTIME_SCORE);  /* This is just a rename of the old STAFF_NEGTIME constant */
#endif
        }

    bool GetShowScoreTimeSignatures() const 
        { 
                return GetShowTimeSignatures();
        }

    bool GetShowPartTimeSignatures() const
    {
#if FXT_VERSION >= FINALEVERSION_25
        return !_GetMoreFlags3(STAFF_MF3_NEGTIME_PARTS);   /* 64-bit PDK */
#else
        return GetShowScoreTimeSignatures(); /* 32-bit PDK */
#endif
    }


    bool GetShowClefs() const { return !_GetInstFlag(STAFF_NEGCLEF); }
    
    bool GetShowChords() const { return !_GetInstFlag(0x0002 /*STAFF_HIDE_CHORDS*/); }
    
    bool GetShowBarlines() const { return !_GetInstFlag(STAFF_HIDE_BARLINES); }
    
    bool GetShowTextRepeats() const { return !_GetInstFlag(STAFF_NEGREPEAT); }
    
    bool GetShowRepeats() const { return !_GetInstFlag(STAFF_HIDE_RPT_BARS); }
    
    bool GetShowScoreStaffNames() const { return !_GetInstFlag(STAFF_NEGNAME); }
    
        bool GetBreakBarlines() const { return _GetInstFlag(STAFF_BLINEBREAK); }
    
        bool GetBreakRepeatBarlines() const { return _GetInstFlag(STAFF_RBARBREAK); }
    
    bool GetShowAugmentationDots() const { return _GetMoreFlags(STAFF_MF_SHOW_DOTS); }

        bool GetIndependentFont() const { return _GetFlag(STAFF_USESMFONT); }
    
        bool GetShowNoteColors() const { return _GetFlag(STAFF_SHOW_NOTE_COLORS); }
    
        bool GetShowNoteShapes() const { return _GetFlag(STAFF_SF_DOSHAPENOTES); }

    twobyte GetHalfRestPosition() const {
        twobyte result = LOBYTE(*_GetHOtherRestPtr());
        if (result & 0x80)
        {
            /* Make 16-bit signed */
            result |= 0xff00;
        }
        return result;
    };

    twobyte GetOtherRestPosition() const {
        twobyte result = LOBYTE(*_GetHOtherRestPtr());
        if (result & 0x80)
        {
            /* Make 16-bit signed */
            result |= 0xff00;
        }
        return result;
    }
    
    twobyte GetWholeRestPosition() const {
        twobyte result = HIBYTE(*_GetDwWRestPtr());
        if (result & 0x80)
        {
            /* Make 16-bit signed */
            result |= 0xff00;
        }
        return result;
    };

    twobyte GetDoubleWholeRestPosition() const { 
        twobyte result = LOBYTE(*_GetDwWRestPtr());
        if (result & 0x80)
        {
            /* Make 16-bit signed */
            result |= 0xff00;
        }
        return result;
    };
    
    twobyte GetStemReversalPosition() const { return *_GetStemReversalPtr(); }
    
    bool GetShowTopRepeatDot() const
    {
        return !GetBitFlag(*_GetFlagPtr(), STAFF_HIDE_REPEAT_TOP_DOT);
    }
    
    bool GetShowBottomRepeatDot() const
    {
        return !GetBitFlag(*_GetFlagPtr(), STAFF_HIDE_REPEAT_BOTTOM_DOT);
    }
    
    twobyte GetTopRepeatDotPosition() const
    {
        twobyte result = HIBYTE(*_GetRepeatDotsOffPtr());
        if (result & 0x80)
        {
            /* Make 16-bit signed */
            result |= 0xff00;
        }
        return result;
    }
    
    twobyte GetBottomRepeatDotPosition() const
    {
        twobyte result = LOBYTE(*_GetRepeatDotsOffPtr());
        if (result & 0x80)
        {
            /* Make 16-bit signed */
            result |= 0xff00;
        }
        return result;
    }
    
    
    bool GetTransposeChromatic() const { return _GetTranspositionFlag(STAFF_CHROMTRANS); }
    
    bool GetTransposeUseClef() const { return _GetTranspositionFlag(STAFF_SETTOCLEF); }
    
    bool GetShowLyrics() const { return !_GetFlag(0x0010 /*STAFF_HIDE_LYRICS*/); }
    
    bool GetShowRests() const { return _GetMoreFlags(STAFF_MF_SHOW_RESTS); }
    
    bool GetShowPartStaffNames() const { return _GetFlag(0x0008 /*STAFF_SHOWNAME_PARTS*/); }
    
    bool GetShowStems() const { return _GetMoreFlags(STAFF_MF_SHOW_STEMS); }
    
    bool GetShowTies() const { return _GetMoreFlags(STAFF_MF_SHOW_TIES); }
    
    bool GetAltNotationDisplayOtherLayerNotes() const
    {
        return _GetAltFlag(STAFF_ALT_SHOWOTHERNOTES);
    }
    
    bool GetTransposeSimplifyKey() const { return !_GetTranspositionFlag(STAFF_NOKEYOPT); }
    
        bool GetDisplayEmptyRests() const { return !_GetFlag(STAFF_BLANKMEASURE); }
    
        bool GetFlatBeams() const { return _GetFlag(STAFF_FLAT_BEAMS); }
    
    bool GetShowTuplets() const
    {
        return _GetMoreFlags(STAFF_MF_SHOW_TUPLETS);
    }
    
    bool GetShowOnlyFirstMeasureClef() const
    {
        return _GetMoreFlags(STAFF_MF_CLEF_FIRST_MEAS_ONLY);
    }

    bool GetFretLetters() const
    {
        return _GetMoreFlags(STAFF_MF_USE_TAB_LETTERS);
    }
    
    bool GetBreakTablatureLines() const
    {
        return _GetMoreFlags(STAFF_MF_BREAK_LINES_AT_NOTES);
    }
    
    bool GetShowFretboards() const { return !_GetFlag(0x0800 /*STAFF_HIDE_FRETBOARDS*/); }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STAFFNOTATION_STYLE
#else
    int
#endif
    GetNotationStyle() const
    {
        if (_GetFlag(STAFF_DOPERCUSSIONNOTES)) return STAFFNOTATION_PERCUSSION;
        if (_GetFlag(STAFF_TABNOTES)) return STAFFNOTATION_TABLATURE;
        return STAFFNOTATION_NORMAL;
    }
    
        bool GetAllowHiding() const;

    twobyte GetTransposeInterval() const;
    
    bool GetShowStaffLines() const;
    
    twobyte GetLineCount() const;
    
    Efix32 GetLineSpacing() const
    {
        return *_GetLineSpacePtr();
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
        __FCStaffBase::ALTERNATE_STAFF GetAltNotationStyle() { return (__FCStaffBase::ALTERNATE_STAFF) (*_GetAltFlagPtr() & STAFF_ALTNOTATION); }
#else
        FLAG_16 GetAltNotationStyle() const { return *_GetAltFlagPtr() & STAFF_ALTNOTATION; }
#endif
    
    twobyte GetAltNotationLayer() const {
                return ((*_GetAltFlagPtr() & STAFF_ALTLAYER) >> 4) + 1;
        }
    
    bool GetAltShowArticulations() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWARTICS); }
    
    bool GetAltShowLyrics() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWLYRICS); }

    bool GetAltShowSmartShapes() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWSMARTSHAPES); }

    bool GetAltShowExpression() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWEXPRESSIONS); }
    
    bool GetAltShowOtherNotes() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWOTHERNOTES); }

    bool GetAltShowOtherArticulations() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SHOWOTHERARTICS); }

    bool GetAltShowOtherLyrics() const { return GetBitFlag(*_GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHERLYRICS); }

    bool GetAltShowOtherSmartShapes() const { return GetBitFlag(*_GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHERSMARTSHAPES); }

    bool GetAltShowOtherExpressions() const { return GetBitFlag(*_GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHEREXPRESSIONS); }
    
    bool GetAltRhythmStemsUp() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_RHYTHM_STEMS_UP); }

    bool GetAltSlashDots() const { return GetBitFlag(*_GetAltFlagPtr(), STAFF_ALT_SLASH_DOTS); }
    
    twobyte GetTransposeClefIndex() const { return (*_GetClefsPtr() & 0xff00) / 0x100; }
    
    twobyte GetDefaultClef() const { return *_GetClefsPtr() & 0xff; }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STAFF_HIDEMODES
#else
    int
#endif
    GetHideMode() const;
    
        bool GetRedisplayOtherLayerAccidentals() const
    {
                const FLAG_16 *pMoreFlags3 = _GetMoreFlags3Ptr();
                if ( !pMoreFlags3 ) return false;
        return (_GetMoreFlags3(0x0001 /* STAFF_MF3_REDISPLAY_LAYER_ACCIS */));
    }
    
        bool GetNoKeySigShowAccidentals() const
    {
                const FLAG_16 *pMoreFlags2 = _GetMoreFlags2Ptr();
                if ( !pMoreFlags2 ) return false;
        return (_GetMoreFlags2(0x0001 /*STAFF_MF2_HIDE_KEYSIG_SHOW_ACCIS*/));
    }
    
    CMPER GetAbbreviatedNameID() { return *_GetAbbrvNamePtr(); }
    
    CMPER GetFullNameID() { return *_GetFullNamePtr(); }
    
    twobyte GetCapoPosition() const
    {
        return LOBYTE(*_GetCapoLowFretPtr());
    }
    
    twobyte GetLowestFret() const
    {
        return HIBYTE(*_GetCapoLowFretPtr());
    }
    
    Efix32 GetVerticalFretOffset() const
    {
        return *_GetVertTabNumOffPtr();
    }
    
    CMPER GetFretInstrumentDefID() const
    {
        return *_GetFretInstIDPtr();
    }
    
    Evpu16 GetBottomBarlineOffset() const
    {
        return *_GetBottomBarlineOffsetPtr();
    }
    
    Evpu16 GetTopBarlineOffset() const
    {
        return *_GetTopBarlineOffsetPtr();
    }

#if FXT_VERSION >= FINALEVERSION_2012

    const char* GetInstrumentUUID() const
    {
        if (_VersionToUse() < FINALEVERSION_2012) return "";
        _uuid.Clear();
        
        const uonebyte* pInstUUID = _GetInstUUIDPtr();
        for (int i = 0; i < UUID_SIZE_PDK; i++)
        {
            uonebyte abyte = pInstUUID[i];
            int highnibble = (abyte & 0xf0) >> 4;
            int lownibble = (abyte & 0x0f);
            if (highnibble < 10)
                _uuid.AppendCharacter(highnibble + '0');
            else
                _uuid.AppendCharacter(highnibble + 'a' - 10);
            if (lownibble < 10)
                _uuid.AppendCharacter(lownibble + '0');
            else
                _uuid.AppendCharacter(lownibble + 'a' - 10);
            switch (i)
            {
                case 3:
                case 5:
                case 7:
                case 9:
                    _uuid.AppendCharacter('-');
                    break;
            }
        }
        return _uuid.GetCString();
    }
#endif
    
    /***********/
    /* SETTERS */
    /***********/
    
    void SetIgnoreKeySig(bool state) { return _SetInstFlag(STAFF_NOKEY, state); }
    
    void SetIndependentTimeSig(bool state) { _SetInstFlag(STAFF_FLOATTIME, state); }
    
    void SetShowMeasureNumbers(bool value) { _SetInstFlag(STAFF_NEGMNUMB, !value); }
    
    void SetShowKeySignatures(bool value) { _SetInstFlag(STAFF_NEGKEY, !value); }
    
        void SetShowTimeSignatures(bool value) 
        {
                SetShowScoreTimeSignatures(value);
                SetShowPartTimeSignatures(value);
        }

        void SetShowScoreTimeSignatures(bool value) 
        {
#if FXT_VERSION < FINALEVERSION_25
                _SetInstFlag(STAFF_NEGTIME, !value);  /* 32-bit PDK */
#else
                _SetInstFlag(STAFF_NEGTIME_SCORE, !value);   /* 64-bit PDK */
#endif
        }
    
    void SetShowPartTimeSignatures(bool value)
        {
#if FXT_VERSION >= FINALEVERSION_25
                _SetMoreFlags3(STAFF_MF3_NEGTIME_PARTS, !value);
#endif
        }
    
    void SetShowClefs(bool value) { _SetInstFlag(STAFF_NEGCLEF, !value); }
    
    void SetShowChords(bool value) { _SetInstFlag(0x0002 /*STAFF_HIDE_CHORDS*/, !value); }
    
    void SetShowBarlines(bool value) { _SetInstFlag(STAFF_HIDE_BARLINES, !value); }
    
    void SetShowTextRepeats(bool value) { _SetInstFlag(STAFF_NEGREPEAT, !value); }
    
    void SetShowRepeats(bool value) { _SetInstFlag(STAFF_HIDE_RPT_BARS, !value); }
    
    void SetShowScoreStaffNames(bool value) { _SetInstFlag(STAFF_NEGNAME, !value); }
    
        void SetBreakBarlines(bool state) { _SetInstFlag(STAFF_BLINEBREAK, state); }
    
        void SetBreakRepeatBarlines(bool state) { _SetInstFlag(STAFF_RBARBREAK, state); }
    
    void SetShowAugmentationDots(bool value) { _SetMoreFlags(STAFF_MF_SHOW_DOTS, value); }
    
        void SetIndependentFont(bool state) { _SetFlag(STAFF_USESMFONT, state); }
    
        void SetShowNoteColors(bool state) { _SetFlag(STAFF_SHOW_NOTE_COLORS, state); }
    
        void SetShowNoteShapes(bool state) { _SetFlag(STAFF_SF_DOSHAPENOTES, state); }
    
    void SetHalfRestPosition(twobyte position)
    {
        if (position < 0) position |= 0x80;
        position &= 0x00ff;
        BYTE hibyte = HIBYTE(*_GetHOtherRestPtr());
        utwobyte* pRestStorage = (utwobyte*) _GetHOtherRestPtr();
        *pRestStorage = MAKEWORD((BYTE) position, hibyte);
    }
    
    void SetOtherRestPosition(twobyte position)
    {
        if (position < 0) position |= 0x80;
        position &= 0x00ff;
        BYTE lobyte = LOBYTE(*_GetHOtherRestPtr());
        utwobyte* pRestStorage = (utwobyte*) _GetHOtherRestPtr();
        *pRestStorage = MAKEWORD(lobyte, (BYTE) position);
    }
    
    void SetWholeRestPosition(twobyte position)
    {
        if (position < 0) position |= 0x80;
        position &= 0x00ff;
        BYTE lobyte = LOBYTE(*_GetDwWRestPtr());
        utwobyte* pRestStorage = (utwobyte*) _GetDwWRestPtr();
        *pRestStorage = MAKEWORD(lobyte, (BYTE) position);
    }

    void SetDoubleWholeRestPosition(twobyte position)
    {
        if (position < 0) position |= 0x80;
        position &= 0x00ff;
        BYTE hibyte = HIBYTE(*_GetDwWRestPtr());
        utwobyte* pRestStorage = (utwobyte*) _GetDwWRestPtr();
        *pRestStorage = MAKEWORD((BYTE) position, hibyte);
    }
    
    void SetStemReversalPosition(twobyte position)
    {
        twobyte* pStemReversal = (twobyte*) _GetStemReversalPtr();
        *pStemReversal = position;
    }
    
    void SetShowTopRepeatDot(bool state)
    {
        Set16BitFlag((FLAG_16*)_GetFlagPtr(), STAFF_HIDE_REPEAT_TOP_DOT, !state);
    }
    
    void SetShowBottomRepeatDot(bool state)
    {
        Set16BitFlag((FLAG_16*)_GetFlagPtr(), STAFF_HIDE_REPEAT_BOTTOM_DOT, !state);
    }
    
    void SetTopRepeatDotPosition(twobyte position)
    {
        if (position < 0) position |= 0x80;
        position &= 0x00ff;
        BYTE lobyte = LOBYTE(*_GetRepeatDotsOffPtr());
        utwobyte* pDotsOffsetStorage = (utwobyte*) _GetRepeatDotsOffPtr();
        *pDotsOffsetStorage = MAKEWORD(lobyte, (BYTE) position);
    }
    
    void SetBottomRepeatDotPosition(twobyte position)
    {
        if (position < 0) position |= 0x80;
        position &= 0x00ff;
        BYTE hibyte = HIBYTE(*_GetRepeatDotsOffPtr());
        utwobyte* pDotsOffsetStorage = (utwobyte*) _GetRepeatDotsOffPtr();
        *pDotsOffsetStorage = MAKEWORD((BYTE) position, hibyte);
    }
    
    void SetTransposeChromatic(bool state) { _SetTranspositionFlag(STAFF_CHROMTRANS, state); }
    
    void SetTransposeUseClef(bool state) { _SetTranspositionFlag(STAFF_SETTOCLEF, state); }
    
    void SetShowFretboards(bool value) { _SetFlag(0x0800 /*STAFF_HIDE_FRETBOARDS*/, !value); }
    
    void SetShowLyrics(bool value) { _SetFlag(0x0010 /*STAFF_HIDE_LYRICS*/, !value); }
    
    void SetShowRests(bool value) { _SetMoreFlags(STAFF_MF_SHOW_RESTS, value); }
    
    void SetShowPartStaffNames(bool value) { _SetFlag(0x0008 /*STAFF_SHOWNAME_PARTS*/, value); }

    void SetShowStems(bool value) { _SetMoreFlags(STAFF_MF_SHOW_STEMS, value); }
    
    void SetShowTies(bool state) { _SetMoreFlags(STAFF_MF_SHOW_TIES, state); }
    
    void SetAltNotationDisplayOtherLayerNotes(bool state)
    {
        _SetAltFlag(STAFF_ALT_SHOWOTHERNOTES, state);
    }
    
    void SetTransposeSimplifyKey(bool state) { _SetTranspositionFlag(STAFF_NOKEYOPT, !state); }
    
        void SetDisplayEmptyRests(bool state) { _SetFlag(STAFF_BLANKMEASURE, !state); }
    
        void SetFlatBeams(bool state) { _SetFlag(STAFF_FLAT_BEAMS, state); }
    
    void SetShowTuplets(bool state)
    {
        _SetMoreFlags(STAFF_MF_SHOW_TUPLETS, state);
    }
    
    void SetShowOnlyFirstMeasureClef(bool state)
    {
        _SetMoreFlags(STAFF_MF_CLEF_FIRST_MEAS_ONLY, state);
    }
    
    void SetFretLetters(bool state)
    {
        _SetMoreFlags(STAFF_MF_USE_TAB_LETTERS, state);
    }
    
    void SetBreakTablatureLines(bool state)
    {
        _SetMoreFlags(STAFF_MF_BREAK_LINES_AT_NOTES, state);
    }
    
    void SetNotationStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                          STAFFNOTATION_STYLE
#else
                          int
#endif
                          value)
    {
        switch (value)
        {
            case STAFFNOTATION_PERCUSSION:
                _SetFlag(STAFF_DOPERCUSSIONNOTES, true);
                _SetFlag(STAFF_TABNOTES, false);
                break;
            case STAFFNOTATION_TABLATURE:
                _SetFlag(STAFF_DOPERCUSSIONNOTES, false);
                _SetFlag(STAFF_TABNOTES, true);
                break;
            case STAFFNOTATION_NORMAL:
                _SetFlag(STAFF_DOPERCUSSIONNOTES, false);
                _SetFlag(STAFF_TABNOTES, false);
                break;
        }                
    }

    void SetIndependentKeySig(bool state) { _SetInstFlag(STAFF_FLOATKEYS, state); }
    
        void SetAllowHiding(bool state);
    
    twobyte GetTransposeAlteration() const;
    
    void SetTransposeAlteration(twobyte value);
    
    void SetTransposeInterval(twobyte value);
    
    void SetShowStaffLines(bool value);

    void SetLineCount(twobyte value);
    
    void SetLineSpacing(Efix32 distance)
    {
        Efix32* pStorage = (Efix32*) _GetLineSpacePtr();
        *pStorage = (distance / 64) * 64;
    }
        
    void SetAltNotationStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                ALTERNATE_STAFF value
#else
                FLAG_16 value
#endif
    )
        {
                FLAG_16* pAltFlag = (FLAG_16*)_GetAltFlagPtr();
                *pAltFlag &= ~STAFF_ALTNOTATION;
                *pAltFlag |= value;
        }
    
    void SetAltNotationLayer(int value)
        {
                if (value < 1) return;
                if (value > 4) return;
                value--;
                value = value << 4;
                FLAG_16* pAltFlag = (FLAG_16*) _GetAltFlagPtr();
                *pAltFlag &= ~STAFF_ALTLAYER;
                *pAltFlag |= value;
        }
    
    void SetAltShowArticulations(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWARTICS, state); }
    
    void SetAltShowLyrics(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWLYRICS, state); }
    
    void SetAltShowSmartShapes(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWSMARTSHAPES, state); }
    
    void SetAltShowExpression(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWEXPRESSIONS, state); }
    
    void SetAltShowOtherNotes(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWOTHERNOTES, state); }
    
    void SetAltShowOtherArticulations(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SHOWOTHERARTICS, state); }
    
    void SetAltShowOtherLyrics(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHERLYRICS, state); }
    
    void SetAltShowOtherSmartShapes(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHERSMARTSHAPES, state); }
    
    void SetAltShowOtherExpressions(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlag2Ptr(), STAFF_ALT2_SHOWOTHEREXPRESSIONS, state); }
    
    void SetAltRhythmStemsUp(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_RHYTHM_STEMS_UP, state); }
    
    void SetAltSlashDots(bool state) { Set16BitFlag((FLAG_16*) _GetAltFlagPtr(), STAFF_ALT_SLASH_DOTS, state); }
    
    void SetHideMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                     STAFF_HIDEMODES
#else
                     int
#endif
                     value
                     );
    
    void SetTransposeClefIndex(twobyte clefindex)
        {
                clefindex &= 0x00ff;
                clefindex *= 0x100;
                twobyte* pClefs = (twobyte*)_GetClefsPtr();
                *pClefs &= 0x00ff;
                *pClefs |= clefindex;
        }
    
    void SetDefaultClef(twobyte clefindex)
    {
        clefindex &= 0xff;
        twobyte* pClefs = (twobyte*) _GetClefsPtr();
        *pClefs &= ~0xff;
        *pClefs |= clefindex;
    }        
         
        void SetRedisplayOtherLayerAccidentals(bool state)
    {
                const FLAG_16 *pMoreFlags3 = _GetMoreFlags3Ptr();
                if ( !pMoreFlags3 ) return;
                _SetMoreFlags3(0x0001 /*STAFF_MF3_REDISPLAY_LAYER_ACCIS*/,state);
    }
    
        void SetNoKeySigShowAccidentals(bool state)
    {
                const FLAG_16 *pMoreFlags2 = _GetMoreFlags2Ptr();
                if ( !pMoreFlags2 ) return;
                _SetMoreFlags2(0x0001 /*STAFF_MF2_HIDE_KEYSIG_SHOW_ACCIS*/,state);
    }
    
    void SetLowestFret(twobyte value)
    {
        BYTE lobyte = LOBYTE(*_GetCapoLowFretPtr());
        utwobyte* pCapoLowFret = (utwobyte*) _GetCapoLowFretPtr();
        *pCapoLowFret = MAKEWORD(lobyte, value);
    }
    
    void SetCapoPosition(twobyte value)
    {
        BYTE hibyte = HIBYTE(*_GetCapoLowFretPtr());
        utwobyte* pCapoLowFret = (utwobyte*) _GetCapoLowFretPtr();
        *pCapoLowFret = MAKEWORD(value, hibyte);
    }

    void SetVerticalFretOffset(Efix32 value)
    {
        Efix32* pVertTabNumOff = (Efix32*) _GetVertTabNumOffPtr();
        *pVertTabNumOff = value;
    }
    
    void SetFretInstrumentDefID(CMPER newid)
    {
        CMPER* pFretInstID = (CMPER*) _GetFretInstIDPtr();
        *pFretInstID = newid;
    }
    
    void SetBottomBarlineOffset(Evpu16 distance)
    {
        Evpu16* pData = (Evpu16*) _GetBottomBarlineOffsetPtr();
        *pData = distance;
    }
    
    void SetTopBarlineOffset(Evpu16 distance)
    {
        Evpu16* pData = (Evpu16*) _GetTopBarlineOffsetPtr();
        *pData = distance;
    }
    
#if FXT_VERSION >= FINALEVERSION_2012

    void SetInstrumentUUID(const char* pszUUID)
    {
        if (_VersionToUse() < FINALEVERSION_2012) return;
        if (!pszUUID) return;
        if (strlen(pszUUID) != 36) return; /* Wrong string format */
        if (pszUUID[8] != '-') return; /* No first dash */
        if (pszUUID[13] != '-') return; /* No second dash */
        if (pszUUID[18] != '-') return; /* No third dash */
        if (pszUUID[23] != '-') return; /* No fourth dash */
        for (int i = 0; i < 36; i++)
        {
            switch (i)
            {
                case 8:
                case 13:
                case 18:
                case 23:
                    if (pszUUID[i] != '-') return;
                    break;
                default:
                    if ((pszUUID[i] >= 'a') && (pszUUID[i] <= 'f')) break;
                    if ((pszUUID[i] >= '0') && (pszUUID[i] <= '9')) break;
                    return;
            }
        }
        /* UUID validation ok - store the UUID */
        const char* pszCurrent = pszUUID;
        for (int i = 0; i < UUID_SIZE_PDK; i++)
        {
            int result1, result2;
            if (*pszCurrent >= 'a') result1 = *pszCurrent - 'a' + 10;
            else if (*pszCurrent >= 'A') result1 = *pszCurrent - 'A' + 10;
            else result1 = *pszCurrent - '0';
            pszCurrent ++;
            if (*pszCurrent >= 'a') result2 = *pszCurrent - 'a' + 10;
            else if (*pszCurrent >= 'A') result2 = *pszCurrent - 'A' + 10;
            else result2 = *pszCurrent - '0';
            int result = (result1 * 0x10) | result2;
            uonebyte* pInstUUID = (uonebyte*) _GetInstUUIDPtr();
            pInstUUID[i] = result;
            pszCurrent ++;
            if ((i == 3) || (i == 5) || (i == 7) || (i == 9)) pszCurrent ++;
        }
    }
#endif
    
    /****************/
    /* MISC METHODS */
    /****************/
    
    void MakeNormalNotation()
    {
        _SetFlag(STAFF_DOPERCUSSIONNOTES, false);
        _SetFlag(STAFF_TABNOTES, false);
    }
    
    bool IsPercussion()
    {
        return (GetNotationStyle() == STAFFNOTATION_PERCUSSION);
    }
    
    bool IsTablature()
    {
        return (GetNotationStyle() == STAFFNOTATION_TABLATURE);
    }
    
    bool IsNormalNotation()
    {
        return (GetNotationStyle() == STAFFNOTATION_NORMAL);
    }
    
    bool GetTranspose() const
    {
        /* Fix Oct 22, 2012: STAFF_NOKEYOPT might be set even if no transposition
         * is used */
        return ((*_GetTranspositionPtr() & ~STAFF_NOKEYOPT) != 0);
    }
    
    bool SaveFullNameString(FCString* pString);
    
    bool SaveAbbreviatedNameString(FCString* pString);
    
    bool SaveNewFullNameString(FCString* pString);
    
    bool SaveNewAbbreviatedNameString(FCString* pString);
    
    void MakeStandard5LineStaff()
    {
        SetLineCount(5);
        SetLineSpacing(24 * 64);
        SetTopBarlineOffset(0);
        SetBottomBarlineOffset(0);
        SetDoubleWholeRestPosition(-4);
        SetWholeRestPosition(-4);
        SetHalfRestPosition(-4);
        SetOtherRestPosition(-4);
        SetStemReversalPosition(-4);
        SetShowTopRepeatDot(true);
        SetTopRepeatDotPosition(-3);
        SetShowBottomRepeatDot(true);
        SetBottomRepeatDotPosition(-5);
    }

    void Make1LineFullBarlineStaff()
    {
        SetLineCount(1);
        SetLineSpacing(24 * 64);
        SetTopBarlineOffset(48);
        SetBottomBarlineOffset(-48);
        SetDoubleWholeRestPosition(-5);
        SetWholeRestPosition(-6);
        SetHalfRestPosition(-4);
        SetOtherRestPosition(-4);
        SetStemReversalPosition(-4);
        SetShowTopRepeatDot(true);
        SetTopRepeatDotPosition(-3);
        SetShowBottomRepeatDot(true);
        SetBottomRepeatDotPosition(-5);
    }
    
    void Make1LineShortBarlineStaff()
    {
        SetLineCount(1);
        SetLineSpacing(24 * 64);
        SetTopBarlineOffset(24);
        SetBottomBarlineOffset(-24);
        SetDoubleWholeRestPosition(-5);
        SetWholeRestPosition(-6);
        SetHalfRestPosition(-4);
        SetOtherRestPosition(-4);
        SetStemReversalPosition(-4);
        SetShowTopRepeatDot(true);
        SetTopRepeatDotPosition(-3);
        SetShowBottomRepeatDot(true);
        SetBottomRepeatDotPosition(-5);
    }
    
    void Make0LineFullBarlineStaff()
    {
        SetLineCount(0);
        SetLineSpacing(24 * 64);
        SetTopBarlineOffset(0);
        SetBottomBarlineOffset(0);
        SetDoubleWholeRestPosition(-4);
        SetWholeRestPosition(-4);
        SetHalfRestPosition(-4);
        SetOtherRestPosition(-4);
        SetStemReversalPosition(-4);
        SetShowTopRepeatDot(true);
        SetTopRepeatDotPosition(-3);
        SetShowBottomRepeatDot(true);
        SetBottomRepeatDotPosition(-5);
    }
    
    FCString* CreateFullNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateFullNameString_GC();
#endif
    
    FCString* CreateAbbreviatedNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateAbbreviatedNameString_GC();
#endif
    
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS

    FCString* CreateDisplayFullNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateDisplayFullNameString_GC();
#endif
    
    FCString* CreateTrimmedFullNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateTrimmedFullNameString_GC();
#endif
    
    FCString* CreateTrimmedAbbreviatedNameString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateTrimmedAbbreviatedNameString_GC();
#endif
    
#endif /* #ifdef PDK_FRAMEWORK_ENIGMASTRINGS */
    
    
#if FXT_VERSION >= FINALEVERSION_2012

    bool InstrumentMatchesUUID(const char* pszUUID)
    {
        if (_VersionToUse() < FINALEVERSION_2012) return false;
        uonebyte* pInstUUID = (uonebyte*) _GetInstUUIDPtr();
        
        if (strlen(pszUUID) != 36) return false; /* Wrong string format */
        if (pszUUID[8] != '-') return false; /* No first dash */
        if (pszUUID[13] != '-') return false; /* No second dash */
        if (pszUUID[18] != '-') return false; /* No third dash */
        if (pszUUID[23] != '-') return false; /* No fourth dash */
        const char* pszCurrent = pszUUID;
        for (int i = 0; i < UUID_SIZE_PDK; i++)
        {
            int result1, result2;
            if (*pszCurrent >= 'a') result1 = *pszCurrent - 'a' + 10;
            else if (*pszCurrent >= 'A') result1 = *pszCurrent - 'A' + 10;
            else result1 = *pszCurrent - '0';
            pszCurrent ++;
            if (*pszCurrent >= 'a') result2 = *pszCurrent - 'a' + 10;
            else if (*pszCurrent >= 'A') result2 = *pszCurrent - 'A' + 10;
            else result2 = *pszCurrent - '0';
            int result = (result1 * 0x10) | result2;
            if (result != pInstUUID[i]) return false;
            pszCurrent ++;
            if ((i == 3) || (i == 5) || (i == 7) || (i == 9)) pszCurrent ++;
        }
        return true;
    }
#endif
    
#if FXT_VERSION >= FINALEVERSION_2012

    bool HasInstrumentAssigned()
    {
        if (_VersionToUse() < FINALEVERSION_2012) return false;
        uonebyte* pInstUUID = (uonebyte*) _GetInstUUIDPtr();
        bool blockisempty = true;
        for (int i = 0; i < UUID_SIZE_PDK; i++) if (pInstUUID[i]) blockisempty = false;
        if (blockisempty) return false;
        if (InstrumentMatchesUUID(FFUUID_BLANKSTAFF)) return false;
        if (InstrumentMatchesUUID(FFUUID_UNKNOWN)) return false;
        return true;
    }
#endif
    

};


/* Macro to only refer to the EDTStaffSpec2012 on 2012 PDKs and later. */
#if FXT_VERSION >= FINALEVERSION_2012
#define PROTECTED2012STAFFSPEC(code) code
#else
#define PROTECTED2012STAFFSPEC(code)
#endif

/* Macro to only refer to the EDTStaffSpec2014 on 2014 PDKs and later. */
#if FXT_VERSION >= FINALEVERSION_2014
#define PROTECTED2014STAFFSPEC(code) code
#else
#define PROTECTED2014STAFFSPEC(code)
#endif


class FCStaff : public __FCStaffBase
{

private:
#ifdef PDK_FRAMEWORK_PREFS

    FCStaffNamePosition* _pFullNamePosition;
    FCStaffNamePosition* _pAbbreviatedNamePosition;
#endif

protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTStaffSpec2010 _staffspec2010;
    PROTECTED2012STAFFSPEC(EDTStaffSpec2012 _staffspec2012;)
    PROTECTED2014STAFFSPEC(EDTStaffSpec2014 _staffspec2014;)

    virtual EXTAG Tag() { return ot_EDTStaffSpec; }
    virtual int DataSizeLoad() 
    {
        switch (_VersionToUse())
        {
            case FINALEVERSION_2010:
                return sizeof(EDTStaffSpec2010);
            case FINALEVERSION_2012:
                PROTECTED2012STAFFSPEC(return sizeof(EDTStaffSpec2012));
                break;
            default:
                PROTECTED2014STAFFSPEC(return sizeof(EDTStaffSpec2014));
                break;
        }
    }
    virtual void* Allocate() 
    {
        switch (_VersionToUse())
        {            
            case FINALEVERSION_2010:
                return (void*) &_staffspec2010;
#if FXT_VERSION >= FINALEVERSION_2012
            case FINALEVERSION_2012:
                return (void*) &_staffspec2012;
#endif
            default:
                PROTECTED2014STAFFSPEC(return (void*) &_staffspec2014);
                return NULL;
        }
    }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        void* pStaffSpec = NULL;
        fourbyte size = 0;
        switch (_VersionToUse())
        {
            case FINALEVERSION_2010:
                pStaffSpec = &_staffspec2010;
                size = sizeof(_staffspec2010);
                break;
            case FINALEVERSION_2012:
                PROTECTED2012STAFFSPEC(
                pStaffSpec = &_staffspec2012;
                size = sizeof(_staffspec2012);)
                break;
            default:
                PROTECTED2014STAFFSPEC(
                pStaffSpec = &_staffspec2014;
                size = sizeof(_staffspec2014);)
                break;
        }

        memcpy(pStaffSpec, ((FCStaff*)pSource)->_GetStaffSpec(), size);
        _datablock = pStaffSpec;
        _loadedsize = size;
    }

    virtual bool LoadFirst()
    {
        SetCmperAndInci(0, 0);
        return LoadNext();
    }

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


    virtual const uonebyte* _GetInstUUIDPtr() const
    {
        if (_VersionToUse() >= FINALEVERSION_2014)
                return _staffspec2014.instUUID;
        if (_VersionToUse() >= FINALEVERSION_2012)
                return _staffspec2012.instUUID;
        return NULL;
    }
    
    virtual const FLAG_16* _GetInstFlagPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->instflag;
    }
    
    virtual const FLAG_16* _GetFlagPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->flag;
    }
    
        virtual const FLAG_16* _GetAltFlagPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->altFlag;
    }
    
        virtual const FLAG_16* _GetAltFlag2Ptr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->altFlag2;
    }
    
        virtual const twobyte* _GetTranspositionPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->transposition;
    }
    
    virtual const FLAG_16* _GetMoreFlagsPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->moreFlags;
    }
        
    virtual const FLAG_16* _GetMoreFlags2Ptr() const
    {
                if (_VersionToUse() < FINALEVERSION_2014) return NULL;
#if FXT_VERSION < FINALEVERSION_25
                return (const FLAG_16*)&((EDTStaffSpec2014*)_GetStaffSpec())->hideKeySigsShowAccis;
#else
                return &((EDTStaffSpec2014*)_GetStaffSpec())->moreFlags2;
#endif
    }

    virtual const FLAG_16* _GetMoreFlags3Ptr() const
    {
                if (_VersionToUse() < FINALEVERSION_2014) return NULL;
#if FXT_VERSION < FINALEVERSION_25
                return (const FLAG_16*) &((EDTStaffSpec2014*)_GetStaffSpec())->redisplayLayerAccis;
#else
                return &((EDTStaffSpec2014*)_GetStaffSpec())->moreFlags3;
#endif
    }
        
    virtual const twobyte* _GetAbbrvNamePtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->abbrvName;
    }
    
    virtual const twobyte* _GetFullNamePtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->fullName;
    }
    
        virtual const twobyte* _GetClefsPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->clefs;
    }
    
    virtual const Efix32* _GetVertTabNumOffPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->vertTabNumOff;
    }
    
    virtual const CMPER* _GetFretInstIDPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->fretInstID;
    }
    
    virtual const Evpu16* _GetBottomBarlineOffsetPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->botBarlineOffset;
    }
    
    virtual const Evpu16* _GetTopBarlineOffsetPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->topBarlineOffset;
    }
    
    virtual const utwobyte* _GetCapoLowFretPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->capoLowFret;
    }
    
    virtual const FLAG_16* _GetBotLinesPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->botLines;
    }
    
    virtual const FLAG_16* _GetTopLinesPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->topLines;
    }
    
    virtual const Efix32* _GetLineSpacePtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->lineSpace;
    }
    
    virtual const twobyte* _GetDwWRestPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->dw_wRest;
    }

    virtual const twobyte* _GetStemReversalPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->stemReversal;
    }

    virtual const twobyte* _GetRepeatDotsOffPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->repeatDotsOff;
    }
    
    virtual const twobyte* _GetHOtherRestPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->h_otherRest;
    }
       
    
    const ETAG* _GetFullNamePosTagPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->fullNamePosTag;
    }
    
    const twobyte* _GetFullNamePosCmperPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->fullNamePosCmper;
    }
    
    const ETAG* _GetAbbrvNamePosTagPtr() const
    {
        return &((EDTStaffSpec2010*)_GetStaffSpec())->abbrvNamePosTag;
    }
    
    const twobyte* _GetAbbrvNamePosCmperPtr() { return &((EDTStaffSpec2010*)_GetStaffSpec())->abbrvNamePosCmper; }
    
    ETAG _GetFullNamePosTag() { return *_GetFullNamePosTagPtr(); }
    
    twobyte _GetFullNamePosCmper() { return *_GetFullNamePosCmperPtr(); }
    
    ETAG _GetAbbreviatedNamePosTag() { return *_GetAbbrvNamePosTagPtr(); }
    
    twobyte _GetAbbreviatedNamePosCmper() { return *_GetAbbrvNamePosCmperPtr(); }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EVERSION EnigmaVersion()
    {
        return _VersionToUse();
    }
#endif

    virtual const char* ClassName() { return "FCStaff"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_STAFF; }

    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    const void* _GetStaffSpec() const
    {
        switch (_VersionToUse())
        {
            case FINALEVERSION_2010:
                return &_staffspec2010;
            case FINALEVERSION_2012:
                PROTECTED2012STAFFSPEC(return &_staffspec2012);
                return NULL;
            default:
                PROTECTED2014STAFFSPEC(return &_staffspec2014);
                return NULL;
        }
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCStaff() : __FCStaffBase()
    {
#ifdef PDK_FRAMEWORK_PREFS
        _pFullNamePosition = NULL;
        _pAbbreviatedNamePosition = NULL;
#endif

        int size = 0;
        switch (_VersionToUse())
        {
            case FINALEVERSION_2010:
                size = sizeof(_staffspec2010);
                memset(&_staffspec2010, 0, size);
                break;
            case FINALEVERSION_2012:
                PROTECTED2012STAFFSPEC(size = sizeof(_staffspec2012);)
                PROTECTED2012STAFFSPEC(memset(&_staffspec2012, 0, size));
                break;
            default:
                PROTECTED2014STAFFSPEC(size = sizeof(_staffspec2014);)
                PROTECTED2014STAFFSPEC(memset(&_staffspec2014, 0, size));
                break;
        }        
    }

    virtual ~FCStaff()
    {
#ifdef PDK_FRAMEWORK_PREFS
        delete _pFullNamePosition;
        _pFullNamePosition = NULL;

        delete _pAbbreviatedNamePosition;
        _pAbbreviatedNamePosition = NULL;
#endif
    }

    virtual bool Save();
    
    

   
    
    

    FCInstrumentPlaybackData* CreateInstrumentPlaybackData();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCInstrumentPlaybackData* CreateInstrumentPlaybackData_GC();
#endif

    FCFretInstrumentDef* CreateFretInstrumentDef();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCFretInstrumentDef* CreateFretInstrumentDef_GC();
#endif
    

    int CalcPercussionLayoutID();

    
        

#ifdef PDK_FRAMEWORK_PREFS

    FCStaffNamePosition* GetFullNamePosition();

    FCStaffNamePosition* GetAbbreviatedNamePosition();
#endif

    
    FCPercussionStaff* CreatePercussionStaff();
    
    bool SavePercussionLayout(int layoutID, int mapID);
    
    FCInstrumentDef* CreateLayerInstrumentDef(int layer);
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCInstrumentDef* CreateLayerInstrumentDef_GC(int layer);
#endif
    

    
    



    
    
    
   
    
    
    
    
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutBool("Transposition: ", GetTranspose());
        DebugOutBool("Chromatic Transposition:" , GetTransposeChromatic());
        DebugOutBool("Transposition - Set to clef: ", GetTransposeUseClef());
        DebugOutBool("Transposition - Simplify key: ", GetTransposeSimplifyKey());
        DebugOutDigit("Transposition - Alteration: ", GetTransposeAlteration());
        DebugOutDigit("Transposition - Interval: ", GetTransposeInterval());
        DebugOutHex("topLines :", ((EDTStaffSpec2010*)_GetStaffSpec())->topLines);
        DebugOutHex("botLines :", ((EDTStaffSpec2010*)_GetStaffSpec())->botLines);
        DebugOutDigit("drumStaffCmper: ", ((EDTStaffSpec2010*)_GetStaffSpec())->drumStaffCmper);
    }
#endif

};

class FCNoteEntry;
class FCCell;

class FCCurrentStaffSpec : public FCStaff
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual bool Load(CMPER itemno) { return false; }

    virtual bool SaveAs(CMPER itemno) { return false; }

    virtual bool SaveNew() { return false; }

    virtual CMPER GetItemNo() { return 0; }

    virtual EXTAG Tag() { return ot_EDTCurrStaffSpec; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCCurrentStaffSpec"; }

#ifdef PDK_FRAMEWORK_ENTRIES

    bool LoadForEntry(FCNoteEntry* pNoteEntry);
#endif

    bool LoadForCell(FCCell* pCell, TimeEdu32 durationpos);

    int GetConnectedDurationPos() const { return _dataid.staffSpec.eduPos; }

    int GetConnectedMeasure() const { return _dataid.staffSpec.measNum; }

    int GetConnectedStaff() const { return _dataid.staffSpec.staffNum; }
};


class FCArticulation;

class FCArticulationDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTArticulationDefinition _articdefold;

#if FXT_VERSION >= FINALEVERSION_2012
    EDTArticulationDefinition2012 _articdef2012;
#endif

    bool Use2012Version() const;

    mutable EFONTNAME _mainsymbolfontname;      /* For return value only */
    mutable EFONTNAME _flippedsymbolfontname;   /* For return value only */

#if FXT_VERSION >= FINALEVERSION_25
        mutable EnigmaFontName _mainsymbolfontnameUTF16;      /* For return value only */
    mutable EnigmaFontName _flippedsymbolfontnameUTF16;   /* For return value only */
#endif

    const FLAG_16* _GetFlag1Ptr() const;
    const FLAG_16* _GetFlag2Ptr() const;
    const twobyte* _GetMainShapePtr() const;
    const twobyte* _GetFlippedShapePtr() const;
    const twobyte* _GetStartTopNotePtr() const;
    const twobyte* _GetStartBotNotePtr() const;
    const twobyte* _GetDurTopNotePtr() const;
    const twobyte* _GetDurBotNotePtr() const;
    const twobyte* _GetAmpTopNotePtr() const;
    const twobyte* _GetAmpBotNotePtr() const;
    const Evpu16* _GetDefaultVerticalPosPtr() const;
    const Evpu16* _GetMainHandleVerticalOffsetPtr() const;
    const Evpu16* _GetMainHandleHorizontalOffsetPtr() const;
    const Evpu16* _GetFlippedHandleVerticalOffsetPtr() const;
    const Evpu16* _GetFlippedHandleHorizontalOffsetPtr() const;

    bool _GetFlag1State(FLAG_16 state) const { return GetBitFlag(*_GetFlag1Ptr(), state); }
    void _SetFlag1State(FLAG_16 flagbits, bool state)
    {
        FLAG_16* pData = (FLAG_16*) _GetFlag1Ptr();
        Set16BitFlag(pData, flagbits, state);
    }
    bool _GetFlag2State(FLAG_16 state) const { return GetBitFlag(*_GetFlag2Ptr(), state); }
    void _SetFlag2State(FLAG_16 flagbits, bool state)
    {
        FLAG_16* pData = (FLAG_16*) _GetFlag2Ptr();
        Set16BitFlag(pData, flagbits, state);
    }
    
protected:
    virtual EXTAG Tag() { return ot_ArticulationDefinition; }
    virtual int DataSizeLoad();
    virtual void* Allocate();
    
    virtual EVERSION EnigmaVersion()
    {
        if (Use2012Version()) return FINALEVERSION_2012;
        return FINALEVERSION_2010;
    }

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

    virtual __FCBaseData* CreateObject() { return new FCArticulationDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    enum ARTPOSITIONING_SIDES {
        ARTPOS_MANUAL_POSITIONING,
        ARTPOS_AUTO_NOTESTEM,
        ARTPOS_ALWAYS_NOTE_SIDE,
        ARTPOS_ALWAYS_STEM_SIDE,
        ARTPOS_BELOW_ENTRY,
        ARTPOS_ABOVE_ENTRY
    };


    virtual const char* ClassName() { return "FCArticulationDef"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_ARTICULATIONDEF; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetArticDef() { return Allocate(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCArticulationDef() : __FCNoInciOther()
    {
        memset(_GetArticDef(), 0, DataSizeLoad());
        _datablock = _GetArticDef();
        _loadedsize = DataSizeLoad();
    }

    bool GetOnScreenOnly() const { return _GetFlag1State(ARTIC_NOPRINT); }

    FCFontInfo* CreateMainSymbolFontInfo();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCFontInfo* CreateMainSymbolFontInfo_GC();
#endif

    FCFontInfo* CreateFlippedSymbolFontInfo();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCFontInfo* CreateFlippedSymbolFontInfo_GC();
#endif

    eUniChar32 GetAboveSymbolChar() const
    {
        if (GetAboveUsesMain())
            return GetMainSymbolChar();
        else
            return GetFlippedSymbolChar();
    }

    eUniChar32 GetBelowSymbolChar() const
    {
        if (GetBelowUsesMain())
            return GetMainSymbolChar();
        else
            return GetFlippedSymbolChar();
    }


    eUniChar32 GetMainSymbolChar() const;

    twobyte GetMainSymbolShapeID() const { return GetMainSymbolIsShape() ? *_GetMainShapePtr() : 0; }

    eUniChar32 GetFlippedSymbolChar() const;

    twobyte GetFlippedSymbolShapeID() const { return GetFlippedSymbolIsShape() ? *_GetFlippedShapePtr() : 0; }

    const char* GetMainSymbolFont() const;
    
    const EFONTID GetMainSymbolFontID() const;

    const eUniChar16* GetMainSymbolFontUTF16() const;

    const char* GetFlippedSymbolFont() const;
    
    const EFONTID GetFlippedSymbolFontID() const;

    const eUniChar16* GetFlippedSymbolFontUTF16() const;

    twobyte GetMainSymbolSize() const;

    twobyte GetFlippedSymbolSize() const;

    bool GetAboveUsesMain() const { return !_GetFlag1State(ARTIC_ABOVE_SYMBOL); }

    bool GetBelowUsesMain() const { return !_GetFlag1State(ARTIC_BELOW_SYMBOL); }

    bool GetCopyMainSymbol() const { return _GetFlag1State(ARTIC_IMRKITERANT); }

    bool GetCopyMainSymbolHorizontally() const { return _GetFlag1State(ARTIC_HORZITERANT); }

    bool GetPlayback() const { return _GetFlag2State(ARTIC_PLAY); }

    bool GetAttackIsPercent() const { return _GetFlag2State(ARTIC_START_IS_PERCENT); }

    twobyte GetTopAttack() const { return *_GetStartTopNotePtr(); }

    twobyte GetBottomAttack() const { return *_GetStartBotNotePtr(); }

    bool GetDurationIsPercent() const { return _GetFlag2State(ARTIC_DUR_IS_PERCENT); }

    twobyte GetTopDuration() const { return *_GetDurTopNotePtr(); }

    twobyte GetBottomDuration() const { return *_GetDurBotNotePtr(); }

    bool GetVelocityIsPercent() const { return _GetFlag2State(ARTIC_AMP_IS_PERCENT); }

    twobyte GetTopVelocity() const { return *_GetAmpTopNotePtr(); }

    twobyte GetBottomVelocity() const { return *_GetAmpBotNotePtr(); }

    bool GetAvoidStaffLines() const { return _GetFlag2State(ARTIC_AVOID_STAFF_LINES); }

    bool GetAlwaysPlaceOutsideStaff() const { return _GetFlag1State(ARTIC_OUTSIDESTAFF); }

    bool GetCenterHorizontally() const { return _GetFlag1State(ARTIC_AUTOHORZ); }

    bool GetInsideSlurs() const { return _GetFlag1State(ARTIC_INSIDE_SLUR); }

    bool GetAttachToTopNote() const { return _GetFlag1State(ARTIC_USETOPNOTE); }

    Evpu16 GetDefaultVerticalPos() const { return *_GetDefaultVerticalPosPtr(); }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ARTPOSITIONING_SIDES
#else
    int
#endif
    GetAutoPosSide() const;

    Evpu16 GetMainHandleVerticalOffset() const { return *_GetMainHandleVerticalOffsetPtr(); }

    Evpu16 GetMainHandleHorizontalOffset() const { return *_GetMainHandleHorizontalOffsetPtr(); }

    Evpu16 GetFlippedHandleVerticalOffset() const { return *_GetFlippedHandleVerticalOffsetPtr(); }

    Evpu16 GetFlippedHandleHorizontalOffset() const { return *_GetFlippedHandleHorizontalOffsetPtr(); }

    bool GetMainSymbolIsShape() const { return _GetFlag2State(ARTIC_MAIN_IS_SHAPE); }

     bool GetFlippedSymbolIsShape() const { return _GetFlag2State(ARTIC_FLIPPED_IS_SHAPE); }

     bool IsShapeUsed()
     {
        if (GetAboveUsesMain())
        {
            if (GetMainSymbolIsShape()) return true;
        }
        else
        {
            if (GetFlippedSymbolIsShape()) return true;
        }
        if (GetBelowUsesMain())
        {
            if (GetMainSymbolIsShape()) return true;
        }
        else
        {
            if (GetFlippedSymbolIsShape()) return true;
        }
        return false;
     }

    bool IsMainSymbolFont(const char* pszFontName);

    bool IsMainSymbolFontUTF16(const eUniChar16* pszFontName);

    bool IsFlippedSymbolFont(const char* pszFontName);

    bool IsFlippedSymbolFontUTF16(const eUniChar16* pszFontName);

    bool IsIdenticalTo(FCArticulationDef* pDef, bool playbackinfo, bool positioningvalues, bool positioningoptions, bool defaultside);
            
    void GetMainSymbolFontInfo(FCFontInfo* pFontInfo);

    void GetFlippedSymbolFontInfo(FCFontInfo* pFontInfo);

    void SetOnScreenOnly(bool state) { _SetFlag1State(ARTIC_NOPRINT, state); }

    void SetMainSymbolFontInfo(FCFontInfo* pFontInfo);

    void SetFlippedSymbolFontInfo(FCFontInfo* pFontInfo);

    void SetMainSymbolSize(twobyte size);

    void SetFlippedSymbolSize(twobyte size);

    void SetMainSymbolFont(const char* pszFontName);

    void SetFlippedSymbolFont(const char* pszFontName);

    void SetMainSymbolFontUTF16(const eUniChar16* pszFontName);

    void SetFlippedSymbolFontUTF16(const eUniChar16* pszFontName);

    void SetAboveSymbolChar(eUniChar32 symbol)
    {
        if (GetAboveUsesMain())
            SetMainSymbolChar(symbol);
        else
            SetFlippedSymbolChar(symbol);
    }

    void SetBelowSymbolChar(eUniChar32 symbol)
    {
        if (GetBelowUsesMain())
            SetMainSymbolChar(symbol);
        else
            SetFlippedSymbolChar(symbol);
    }


    void SetMainSymbolChar(eUniChar32 symbol)
    {
        if (Use2012Version())
        {
#if FXT_VERSION >= FINALEVERSION_2012
            _articdef2012.charMain = symbol;
#endif            
        }
        else
        {
            _articdefold.efxsymbolMain &= 0xff00;
            _articdefold.efxsymbolMain |= (symbol & 0xff);
        }
    }

    void SetMainSymbolIsShape(bool useshape)
    {
        _SetFlag2State(ARTIC_MAIN_IS_SHAPE, useshape); 
    }

    void SetFlippedSymbolIsShape(bool useshape)
    {
        _SetFlag2State(ARTIC_FLIPPED_IS_SHAPE, useshape);
    }

    void SetMainSymbolShapeID(CMPER shapeID)
    {
        CMPER* pValue = (CMPER*) _GetMainShapePtr();
        *pValue = shapeID;
    }

    void SetFlippedSymbolShapeID(twobyte shapeID)
    {
        CMPER* pValue = (CMPER*) _GetFlippedShapePtr();
        *pValue = shapeID;
    }

    void SetFlippedSymbolChar(eUniChar32 symbol)
    {
        if (Use2012Version())
        {
#if FXT_VERSION >= FINALEVERSION_2012
            _articdef2012.charAlt = symbol;
#endif
        }
        else
        {
            _articdefold.efxsymbolFlipped &= 0xff00;
            _articdefold.efxsymbolFlipped |= (symbol & 0xff);
        }
    }

    void SetAboveUsesMain(bool state) { _SetFlag1State(ARTIC_ABOVE_SYMBOL, !state); }

    void SetBelowUsesMain(bool state) { _SetFlag1State(ARTIC_BELOW_SYMBOL, !state); }

    void SetCopyMainSymbol(bool state) { _SetFlag1State(ARTIC_IMRKITERANT, state); }

    void SetCopyMainSymbolHorizontally(bool state) { _SetFlag1State(ARTIC_HORZITERANT, state); }

    void SetPlayback(bool state) { _SetFlag2State(ARTIC_PLAY, state); }

    void SetAttackIsPercent(bool state) { _SetFlag2State(ARTIC_START_IS_PERCENT, state); }

    void SetTopAttack(twobyte value) 
    {
        twobyte* pValue = (twobyte*) _GetStartTopNotePtr();
        *pValue = value;
    }

    void SetBottomAttack(twobyte value) 
    {
        twobyte* pValue = (twobyte*) _GetStartBotNotePtr();
        *pValue = value;
    }

    void SetAutoPosSide(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                ARTPOSITIONING_SIDES mode
#else
                int mode
#endif
    );

    void SetAlwaysPlaceOutsideStaff(bool state) { _SetFlag1State(ARTIC_OUTSIDESTAFF, state); }

    void SetCenterHorizontally(bool state) { _SetFlag1State(ARTIC_AUTOHORZ, state); }

    void SetAvoidStaffLines(bool state) { _SetFlag2State(ARTIC_AVOID_STAFF_LINES, state); }

    void SetInsideSlurs(bool state) { _SetFlag1State(ARTIC_INSIDE_SLUR, state); }

    void SetAttachToTopNote(bool state) { _SetFlag1State(ARTIC_USETOPNOTE, state); }

    void SetDefaultVerticalPos(Evpu16 value)
    {
        Evpu16* pValue = (Evpu16*) _GetDefaultVerticalPosPtr();
        *pValue = value;
    }

    void SetMainHandleVerticalOffset(Evpu16 value)
    {
        Evpu16* pValue = (Evpu16*) _GetMainHandleVerticalOffsetPtr();
        *pValue = value;
    }

    void SetMainHandleHorizontalOffset(Evpu16 value)
    {
        Evpu16* pValue = (Evpu16*) _GetMainHandleHorizontalOffsetPtr();
        *pValue = value;
    }

    void SetFlippedHandleVerticalOffset(Evpu16 value)
    {
        Evpu16* pValue = (Evpu16*) _GetFlippedHandleVerticalOffsetPtr();
        *pValue = value;
    }

    void SetFlippedHandleHorizontalOffset(Evpu16 value) 
    {
        Evpu16* pValue = (Evpu16*) _GetFlippedHandleHorizontalOffsetPtr();
        *pValue = value;
    }
            
    void SetTopDuration(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetDurTopNotePtr();
        *pValue = value;        
    }

    void SetBottomDuration(twobyte value) 
    {
        twobyte* pValue = (twobyte*) _GetDurBotNotePtr();
        *pValue = value;        
    }

    void SetDurationIsPercent(bool value) { _SetFlag2State(ARTIC_DUR_IS_PERCENT, value); }

    void SetTopVelocity(twobyte value)
    {
        twobyte* pValue = (twobyte*) _GetAmpTopNotePtr();
        *pValue = value;
    }

    void SetBottomVelocity(twobyte value) 
    {
        twobyte* pValue = (twobyte*) _GetAmpBotNotePtr();
        *pValue = value;
    }

    void SetVelocityIsPercent(bool value) { _SetFlag2State(ARTIC_AMP_IS_PERCENT, value); }
    
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Main symbol char: ", GetMainSymbolChar());        
        DebugOutString("Main symbol font name: ", GetMainSymbolFont());
        DebugOutDigit("Main symbol size: ", GetMainSymbolSize());
    }
#endif

};


class FCCategoryDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTMarkingCategory _categorydefold;
    
#if FXT_VERSION >= FINALEVERSION_2012
    EDTMarkingCategory2012 _categorydef2012;
#endif
    
    bool _Use2012Version() const;

    const FLAG_16* _GetFlagPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.categoryFlags;
#endif
        return &_categorydefold.categoryFlags;
    }
    
    const twobyte* _GetCatIDPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.catID;
#endif
        return &_categorydefold.catID;
    }
    
    const twobyte* _GetStaffListPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.staffList;
#endif
        return &_categorydefold.staffList;
    }
    
    const twobyte* _GetVertAlignPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.vertAlign;
#endif
        return &_categorydefold.vertAlign;
    }

    const twobyte* _GetVertOffsetBaseLinePtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.vertOffsetBaseline;
#endif
        return &_categorydefold.vertOffsetBaseline;
    }

    const twobyte* _GetVertOffsetEntryPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.vertOffsetEntry;
#endif
        return &_categorydefold.vertOffsetEntry;
    }
    
    const twobyte* _GetJustificationPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.justification;
#endif
        return &_categorydefold.justification;
    }
    
    const twobyte* _GetHorzAlignPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.horzAlign;
#endif
        return &_categorydefold.horzAlign;
    }
    
    const twobyte* _GetHorzOffsetPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.horzOffset;
#endif
        return &_categorydefold.horzOffset;
    }
    
    const EEnigmaFont* _GetTextFontPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.textFont;
#endif
        return &_categorydefold.textFont;
    }
    
    const EEnigmaFont* _GetMusicFontPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.musicFont;
#endif
        return &_categorydefold.musicFont;
    }

    const EEnigmaFont* _GetNumberFontPtr() const
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_categorydef2012.numberFont;
#endif
        return &_categorydefold.numberFont;
    }
    
    bool _GetFlagState(FLAG_16 state) const
    {
        FLAG_16* pValue = (FLAG_16*) _GetFlagPtr();
        return GetBitFlag(*pValue, state);
    }
    
    void _SetFlagState(FLAG_16 mask, bool state)
    {
        FLAG_16* pValue = (FLAG_16*) _GetFlagPtr();
        return Set16BitFlag(pValue, mask, state);
    }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return ot_MarkingCategory; }
    
    virtual int DataSizeLoad()
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return sizeof(EDTMarkingCategory2012);
#endif
        return sizeof(EDTMarkingCategory);
    }
    
    virtual void* Allocate()
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return (void*) &_categorydef2012;
#endif
        return (void*) &_categorydefold;
    }

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

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

    // Class doesn't yet support Unicode
    virtual EVERSION EnigmaVersion()
    {
        if (_Use2012Version()) return FINALEVERSION_2012;
        return FINALEVERSION_2010;
    }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

        enum CATEGORY_DEFAULTIDS
        {
                DEFAULTCATID_DYNAMICS = 1,

                DEFAULTCATID_TEMPOMARKS = 2,

                DEFAULTCATID_TEMPOALTERATIONS = 3,

                DEFAULTCATID_EXPRESSIVETEXT = 4,

                DEFAULTCATID_TECHNIQUETEXT = 5,

                DEFAULTCATID_REHEARSALMARK = 6
        };


    enum CATEGORY_MODE
    {
        CATEGORYMODE_NONE = 0,

        CATEGORYMODE_TEXT = 1,

        CATEGORYMODE_MUSIC = 2,

        CATEGORYMODE_NUMBER = 3
    };


    virtual const char* ClassName() { return "FCCategoryDef"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CATEGORYDEF; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetCategoryDef() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    enum VERT_ALIGNMENT
    {
        ALIGNVERT_CLICKPOS = 2,

        ALIGNVERT_STAFF_REFERENCE_LINE = 3,

        ALIGNVERT_ABOVE_STAFF_BASELINE = 0,

        ALIGNVERT_BELOW_STAFF_BASELINE = 1,

        ALIGNVERT_TOPNOTE = 4,

        ALIGNVERT_BOTTOMNOTE = 5,

        ALIGNVERT_ABOVEENTRY = 6,

        ALIGNVERT_BELOWENTRY = 7,

        ALIGNVERT_ABOVE_STAFF_BASELINE_OR_ENTRY = 8,

        ALIGNVERT_BELOW_STAFF_BASELINE_OR_ENTRY = 9
    };

    enum HORIZ_ALIGNMENT
    {
        ALIGNHORIZ_CLICKPOS = 3,

        ALIGNHORIZ_LEFTOFALLNOTEHEAD = 9,

        ALIGNHORIZ_LEFTOFPRIMARYNOTEHEAD = 13,

        ALIGNHORIZ_STEM = 10,

        ALIGNHORIZ_CENTERPRIMARYNOTEHEAD = 11,

        ALIGNHORIZ_CENTERALLNOTEHEADS = 12,

        ALIGNHORIZ_RIGHTALLNOTEHEADS = 14,

        ALIGNHORIZ_LEFTBARLINE = 0,

        ALIGNHORIZ_TIMESIGSTART = 1,

        ALIGNHORIZ_AFTERCLEFKEYTIMEREPEAT = 2,

        ALIGNHORIZ_STARTOFMUSIC = 7,

        ALIGNHORIZ_CENTERBETWEENBARLINES = 4,

        ALIGNHORIZ_CENTEROVERUNDERMUSIC = 5,

        ALIGNHORIZ_RIGHTBARLINE = 6,

    };

    enum HORIZ_JUSTIFICATION
    {
        EXPRJUSTIFY_LEFT = 0,       

        EXPRJUSTIFY_CENTER = 1,

        EXPRJUSTIFY_RIGHT  = 2
    };

    FCCategoryDef() : __FCNoInciOther()
    {
        memset(_GetCategoryDef(), 0, DataSizeLoad());
        _datablock = _GetCategoryDef();
        _loadedsize = DataSizeLoad();
    }

    virtual bool IsIdentical(__FCBase* pObject)
    {
        FCCategoryDef* pOtherCategory = (FCCategoryDef*) pObject;
        if (pOtherCategory->GetID() != GetID()) return false;
        if (*pOtherCategory->_GetFlagPtr() != *_GetFlagPtr()) return false;
        FCString thisname, othername;
        pOtherCategory->GetName(&othername);
        GetName(&thisname);
        return othername.IsEqualString(&thisname);
    }

    bool GetBreakMMRest() const
    {
        return _GetFlagState(0x400);
    }

    bool GetOverrideStaffList() const
    {        
        return _GetFlagState(0x0010);
    }

    twobyte GetID() const
    {
        return *_GetCatIDPtr();
    }

    twobyte GetStaffListID() const
    {
        return *_GetStaffListPtr();
    }

    void GetName(FCString* pString)
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version())
        {
            pString->SetUnicodeString(_categorydef2012.name);
            return;
        }
#endif
        pString->SetCString(_categorydefold.name);
    }

    FCString* CreateName() 
    {
        FCString* pString = new FCString();
        GetName(pString);
        return pString;
    }

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateName_GC();
#endif

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    VERT_ALIGNMENT 
#else
    int
#endif
    GetVerticalAlignmentPoint() const { return (VERT_ALIGNMENT) *_GetVertAlignPtr(); }

    twobyte GetVerticalBaselineOffset() const { return *_GetVertOffsetBaseLinePtr(); }

    twobyte GetVerticalEntryOffset() const { return *_GetVertOffsetEntryPtr(); }


#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    HORIZ_JUSTIFICATION
#else
    int
#endif
    GetHorizontalJustification() const
    {
        return (HORIZ_JUSTIFICATION) *_GetJustificationPtr();
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    HORIZ_ALIGNMENT 
#else
    int
#endif
    GetHorizontalAlignmentPoint() const
    {
        return (HORIZ_ALIGNMENT) *_GetHorzAlignPtr();
    }

    twobyte GetHorizontalOffset() const
    {
        return *_GetHorzOffsetPtr();
    }

    bool GetTextFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesTextFont()) return false;
        pInfo->ParseEnigmaFont(_GetTextFontPtr());
        return true;
    }

    bool GetMusicFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesMusicFont()) return false;
        pInfo->ParseEnigmaFont(_GetMusicFontPtr());
        return true;
    }

    bool GetNumberFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesNumberFont()) return false;
        pInfo->ParseEnigmaFont(_GetNumberFontPtr());
        return true;
    }


    bool SetTextFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesTextFont()) return false;
        EEnigmaFont* pFont = (EEnigmaFont*) _GetTextFontPtr();
        pFont->font = pInfo->GetNameByID();
        pFont->efx = pInfo->GetEnigmaStyles();
        pFont->size = pInfo->GetSize();
        return true;
    }

    bool SetMusicFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesMusicFont()) return false;
        EEnigmaFont* pFont = (EEnigmaFont*) _GetMusicFontPtr();
        pFont->font = pInfo->GetNameByID();
        pFont->efx = pInfo->GetEnigmaStyles();
        pFont->size = pInfo->GetSize();
        return true;
    }

    bool SetNumberFontInfo(FCFontInfo* pInfo)
    {
        if (!UsesNumberFont()) return false;
        EEnigmaFont* pFont = (EEnigmaFont*) _GetNumberFontPtr();
        pFont->font = pInfo->GetNameByID();
        pFont->efx = pInfo->GetEnigmaStyles();
        pFont->size = pInfo->GetSize();
        return true;
    }

    void SetStaffListID(twobyte value)
    {
        twobyte* pStaffList = (twobyte*) _GetStaffListPtr();
        *pStaffList = value;
    }

    FCFontInfo* CreateTextFontInfo()
    {
        FCFontInfo* pFontInfo = new FCFontInfo();
        pFontInfo->ParseEnigmaFont(_GetTextFontPtr());
        return pFontInfo;
    }

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCFontInfo* CreateTextFontInfo_GC();
#endif

    bool GetUserCreated() const
    {
        return _GetFlagState(MC_USER_CREATED);
    }

    bool IsDefaultMiscellaneous()
    {
        if (GetUserCreated()) return false;
        return GetID() == 7;
    }

    bool IsDefaultDynamics()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_DYNAMICS;
    }

    bool IsDefaultTempoMarks()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_TEMPOMARKS;
    }

    bool IsDefaultTempoAlterations()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_TEMPOALTERATIONS;
    }

    bool IsDefaultExpressiveText()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_EXPRESSIVETEXT;
    }

    bool IsDefaultTechniqueText()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_TECHNIQUETEXT;
    }

    bool IsDefaultRehearsalMarks()
    {
        if (GetUserCreated()) return false;
                return GetID() == DEFAULTCATID_REHEARSALMARK;
    }

    bool UsesStaffList() { return _GetFlagState(MC_STAFFLIST); }

    bool UsesTextFont() { return _GetFlagState(0x0001); }  /* For some reason MC_OVERRIDE_TEXT_FONT doesn't work*/

    bool UsesMusicFont() { return _GetFlagState(0x0002); } /* For some reason MC_OVERRIDE_MUSIC_FONT doesn't work*/

    bool UsesNumberFont() { return _GetFlagState(0x0004); }  /* For some reason MC_OVERRIDE_NUMBER_FONT doesn't work*/

    void SetName(FCString* pString) 
    {
        if (!pString) return;
        /* Make sure there isn't any overflow of the text */
        FCString tempstring;
        tempstring.SetString(pString);
        tempstring.TruncateAt(63);
        /* Copy the text */
        if (_Use2012Version())
        {
#if FXT_VERSION >= FINALEVERSION_2012
            int len = tempstring.GetLength();
            memcpy(_categorydef2012.name, tempstring._GetUnicodeBuffer(), (len + 1) * sizeof (eUniChar16));
            _categorydef2012.name[len] = 0; /* For safety add a NULL */
#endif
        }
        else
        {
            strcpy(_categorydefold.name, tempstring.GetCString());
        }
    }

    void SetVerticalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    VERT_ALIGNMENT
#else
    twobyte
#endif
    value
    )
    {
        twobyte* pAlign = (twobyte*) _GetVertAlignPtr();
        *pAlign = (twobyte) value;
    }

    void SetUserCreated(bool value) { _SetFlagState(MC_USER_CREATED, value); }

    void SetBreakMMRest(bool state)
    {
        _SetFlagState(0x400, state);
    }

    void SetOverrideStaffList(bool state)
    {
        _SetFlagState(0x0010, state);
    }

        void SetID(twobyte catID)
        {
                twobyte* pData = (twobyte*) _GetCatIDPtr();
                *pData = catID;
        }

    void SetVerticalBaselineOffset(twobyte value)
    {
        twobyte* pVertOffsetBase = (twobyte*) _GetVertOffsetBaseLinePtr();
        *pVertOffsetBase = value;
    }

    void SetVerticalEntryOffset(twobyte value)
    {
        twobyte* pOffset = (twobyte*) _GetVertOffsetEntryPtr();
        *pOffset = value;
    }

    void SetHorizontalJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    HORIZ_JUSTIFICATION
#else
    int
#endif
    value)
    {
        switch (value)
        {
            case EXPRJUSTIFY_LEFT:
            case EXPRJUSTIFY_CENTER:
            case EXPRJUSTIFY_RIGHT:
                break;
            default:
                return;
        }
        twobyte* pJustification = (twobyte*) _GetJustificationPtr();
        *pJustification = value;
    }


    void SetHorizontalOffset(twobyte value)
    {
        twobyte* pHorizontalOffset = (twobyte*) _GetHorzOffsetPtr();
        *pHorizontalOffset = value;
    }

    void SetHorizontalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    HORIZ_ALIGNMENT
#else
    twobyte
#endif
    value
    )
    {
        twobyte* pHorizAlign = (twobyte*) _GetHorzAlignPtr();
        *pHorizAlign = (twobyte) value;
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Category ID: ", GetID());
        DebugOutBool("User created: ", GetUserCreated());
        FCString string;
        GetName(&string);
        DebugOutString("Name: ", string.GetCString());
    }
#endif
};




class FCFreezeSystem : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTFreezeMeasures _freezemeasures;

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return ot_FreezeMeasures; }
    virtual int DataSizeLoad() { return sizeof(EDTFreezeMeasures); }
    virtual void* Allocate() { return (void*) &_freezemeasures; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_freezemeasures, ((FCFreezeSystem*)pSource)->_GetFreezeMeasures(), sizeof(_freezemeasures));
        _datablock = &_freezemeasures;
        _loadedsize = sizeof(_freezemeasures);
    }

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

    // Doesn't support First/Next
    virtual bool LoadFirst() { return false; }

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

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetFreezeMeasures() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCFreezeSystem() : __FCNoInciOther()
    {
        memset(&_freezemeasures, 0, sizeof(_freezemeasures));
        _freezemeasures.mode = 1;
        _datablock = &_freezemeasures;
        _loadedsize = sizeof(_freezemeasures);
    }

    void SetNextSysMeasure(twobyte measure) { _freezemeasures.measure = measure; }

    twobyte GetNextSysMeasure() const { return _freezemeasures.measure; }


#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Next system measure: ", GetNextSysMeasure());
    }
#endif
};


class FCTextExpressionDef : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTextExpression2004 _nullexpression;  /* A data block for when the _datablock is NULL.
                                             This should never be accessed directly. It's only
                                             available to prevent crashes. */
    EDTTextExpression2004* _TypeCast() const
    {
        if (!_datablock) return (EDTTextExpression2004*) &_nullexpression;
        return (EDTTextExpression2004*)_datablock;
    }

    void _AllocateMemory(int size);
protected:
    virtual EXTAG Tag() { return ot_TextExpression; }
    virtual EVERSION EnigmaVersion();

    virtual int DataSizeLoad();
    virtual int DataSizeSave();
    virtual void* Allocate();
    virtual void Deallocate();
    virtual bool IsDynamicSize() { return true; }

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

    virtual bool LoadNext()
    {
        return Load(GetItemNo() + 1); // FX_NextEData can sometimes cause problems!!!
    }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    enum REHEARSALMARK_STYLES
    {
        REHMARKSTYLE_MANUAL = FX_EXPR_REHEARSAL_MANUAL,

        REHMARKSTYLE_LETTER = FX_EXPR_REHERASAL_LETTERS,

        REHMARKSTYLE_LETNUM = FX_EXPR_REHEARSAL_LETNUM,

        REHMARKSTYLE_LETTER_LC = FX_EXPR_REHEARSAL_LETTERS_LC,

        REHMARKSTYLE_LETNUM_LC = FX_EXPR_REHEARSAL_LETNUM_LC,

        REHMARKSTYLE_NUMBER = FX_EXPR_REHEARSAL_NUMBERS,

        REHMARKSTYLE_MEASNUM = FX_EXPR_REHEARSAL_MEASNUM
    };

        enum SMARTMUSIC_MARKER_TYPES
        {
                SMARTMUSICTYPE_NONE = 0,

                SMARTMUSICTYPE_UNKNOWN = -1,

                SMARTMUSICTYPE_INTELLIGENTACC0,

                SMARTMUSICTYPE_INTELLIGENTACC1,

                SMARTMUSICTYPE_INTELLIGENTACC2,

                SMARTMUSICTYPE_INTELLIGENTACC3,

                SMARTMUSICTYPE_INTELLIGENTACC4,

                SMARTMUSICTYPE_INTELLIGENTACC5,

                SMARTMUSICTYPE_INTELLIGENTACC6,

                SMARTMUSICTYPE_INTELLIGENTACC7,

                SMARTMUSICTYPE_INTELLIGENTACC8,

                SMARTMUSICTYPE_INTELLIGENTACC9,

                SMARTMUSICTYPE_INTELLIGENTACC10,

                SMARTMUSICTYPE_WAITFORENDOFNOTE,

                SMARTMUSICTYPE_WAITFORNOTEON,

                SMARTMUSICTYPE_WAITFORFOOTPEDAL,

                SMARTMUSICTYPE_RESUME,

                SMARTMUSICTYPE_RESETTEMPO,

                SMARTMUSICTYPE_OPTIONALOCTAVEUP,

                SMARTMUSICTYPE_OPTIONALOCTAVEDOWN,

                SMARTMUSICTYPE_OPTIONALOCTAVEEND,

                SMARTMUSICTYPE_REHEARSALMARK,

                SMARTMUSICTYPE_REPEATSTART,

                SMARTMUSICTYPE_REPEATEND,

                SMARTMUSICTYPE_REPEAT_ENDING,

                SMARTMUSICTYPE_REPEAT_DS,

                SMARTMUSICTYPE_REPEAT_DC,

                SMARTMUSICTYPE_USEDESCRIPTIONTEXT,

                SMARTMUSICTYPE_SMALLBREATH,

                SMARTMUSICTYPE_LARGEBREATH,

                SMARTMUSICTYPE_BREATHEND,

                SMARTMUSICTYPE_RESETMEASURECOUNTER,

                SMARTMUSICTYPE_ASSESSMENTON,
                
                SMARTMUSICTYPE_ASSESSMENTOFF,

                SMARTMUSICTYPE_SOLOPLAYBACKON,
                
                SMARTMUSICTYPE_SOLOPLAYBACKOFF,

                SMARTMUSICTYPE_SWINGASSESSMENTON,

                SMARTMUSICTYPE_SWINGASSESSMENTOFF
        };
    
    virtual const char* ClassName() { return "FCTextExpressionDef"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TEXTEXPRESSIONDEF; }

    FCTextExpressionDef();

    virtual ~FCTextExpressionDef();

    virtual bool DeepSaveAs(CMPER itemno)
    {
       FCString* pString = CreateTextString();
       SaveNewTextBlock(pString);
       delete pString;

       FCEnclosure* pEnclosure = CreateEnclosure();
       if (pEnclosure)
       {
           pEnclosure->SaveAs(itemno);
           delete pEnclosure;
       }

       return SaveAs(itemno);
    }

    virtual bool DeepDeleteData();
    

    CMPER GetTextBlockID();
    

    bool GetUseExecutableShape() const
    {
        return GetBitFlag(_TypeCast()->flag, EXP_VALUEisEXEC);
    }

    twobyte GetExecutableShapeID() const
    {
        if (!GetUseExecutableShape()) return 0;
        return _TypeCast()->value;
    }

    void SetExecutableShapeID(twobyte shapeID)
    {
        _TypeCast()->value = shapeID;
        SetUseExecutableShape((shapeID != 0) ? true : false);
    }

    void SetUseExecutableShape(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, EXP_VALUEisEXEC, state);
    }
    
    bool GetHideMeasureNumbers() const
    {
        return GetBitFlag(_TypeCast()->flag, 0x8000);
    }
    
    void SetHideMeasureNumbers(bool value)
    {
        Set16BitFlag(&_TypeCast()->flag, 0x8000, value);
    }

    bool GetUseEnclosure() const
    {
        return GetBitFlag(_TypeCast()->flag, TEXT_EXP_NEWENCLOSURE);
    }

    void SetUseEnclosure(bool value)
    {
        Set16BitFlag(&_TypeCast()->flag, TEXT_EXP_NEWENCLOSURE, value);
    }

    twobyte GetCategoryID() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (_TypeCast()->category & 0x3fff);
#else
        return (_TypeCast()->measYadjust & 0x3fff); 
#endif
    }

    twobyte GetTextID() const { return (_TypeCast()->textIDKey); }

    twobyte GetPlaybackTempoValue()
    {
        if (!GetBitFlag(_TypeCast()->flag, EXP_USEauxDATA)) return 0;
        if (!GetBitFlag(_TypeCast()->flag, EXP_TIME)) return 0;
        return _TypeCast()->value;        
    }

    twobyte GetPlaybackTempoDuration()
    {
        if (!GetBitFlag(_TypeCast()->flag, EXP_USEauxDATA)) return 0;
        if (!GetBitFlag(_TypeCast()->flag, EXP_TIME)) return 0;
        return _TypeCast()->auxdata1;
    }

        twobyte GetPlaybackPass() const
        {
                return _TypeCast()->playPass;
        }

        void SetPlaybackPass(twobyte value)
        {
                _TypeCast()->playPass = value;
        }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::VERT_ALIGNMENT 
#else 
    int
#endif
    GetVerticalAlignmentPoint() const
    {
        return (FCCategoryDef::VERT_ALIGNMENT) _TypeCast()->vertMeasExprAlign;
    }

    twobyte GetVerticalBaselineOffset() const { return _TypeCast()->noteYadjustBaseline; }

    twobyte GetVerticalEntryOffset() const { return _TypeCast()->noteYadjustEntry; }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REHEARSALMARK_STYLES
#else 
    int
#endif
    GetRehearsalMarkStyle() const
    {
        return (REHEARSALMARK_STYLES) _TypeCast()->categorySpecific;
    }

    void SetRehearsalMarkStyle(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REHEARSALMARK_STYLES
#else
    int
#endif
    value
    )
    {
        _TypeCast()->categorySpecific = value;
    }

    bool GetBreakMMRest() const
    {
        return GetBitFlag(_TypeCast()->flag, 0x400);
    }

    void SetBreakMMRest(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, 0x400, state);
    }

     void SetCategoryID(twobyte ID)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->category &= 0xc000;
        _TypeCast()->category |= (ID & 0x3fff);
#else
        _TypeCast()->measYadjust &= 0xc000;
        _TypeCast()->measYadjust |= (ID & 0x3fff);
#endif
    }


    void SetUseCategoryFont(bool value);

    void SetUseCategoryPos(bool value);

    void SetPlaybackController(twobyte controllernumber, twobyte value)
    {
        Set16BitFlag(&_TypeCast()->flag, EXP_USEauxDATA, true);
        _TypeCast()->flag &= ~EXP_DYTYPEBITS;
        _TypeCast()->flag |= EXP_MIDI_CONTROLLER;
        _TypeCast()->value = value;
        _TypeCast()->auxdata1 = controllernumber;
    }

    void SetPlaybackTempo(TimeEdu32 eduduration, int tempo)
    {
        Set16BitFlag(&_TypeCast()->flag, EXP_USEauxDATA, true);
        _TypeCast()->flag &= ~EXP_DYTYPEBITS;
        _TypeCast()->flag |= EXP_TIME;
        _TypeCast()->value = tempo;
        _TypeCast()->auxdata1 = eduduration;
    }

    void SetVerticalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::VERT_ALIGNMENT
#else
    int
#endif
    value)
    {
        _TypeCast()->vertMeasExprAlign = (twobyte) value;
    }

    void SetVerticalBaselineOffset(twobyte value) {
        _TypeCast()->noteYadjustBaseline = value;
    }

    void SetVerticalEntryOffset(twobyte value)
    {
        _TypeCast()->noteYadjustEntry = value;
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_JUSTIFICATION
#else
    int
#endif
    GetHorizontalJustification() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (FCCategoryDef::HORIZ_JUSTIFICATION) _TypeCast()->horzExprAlign;
#else
        return (FCCategoryDef::HORIZ_JUSTIFICATION) _TypeCast()->measExprAlign;
#endif
    }

    void SetHorizontalJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_JUSTIFICATION
#else
    int
#endif
    value)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->horzExprAlign = (twobyte) value;
#else
        _TypeCast()->measExprAlign = (twobyte) value;
#endif
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_ALIGNMENT
#else
    int
#endif
    GetHorizontalAlignmentPoint() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (FCCategoryDef::HORIZ_ALIGNMENT) _TypeCast()->horzMeasExprAlign;
#else
        return (FCCategoryDef::HORIZ_ALIGNMENT) _TypeCast()->measAlign;
#endif
    }

    void SetHorizontalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_ALIGNMENT
#else
    int
#endif
    value)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->horzMeasExprAlign = (twobyte) value;
#else
        _TypeCast()->measAlign = (twobyte) value;
#endif
    }


    twobyte GetHorizontalOffset() const
    {
        return _TypeCast()->measXadjust;
    }

    void SetHorizontalOffset(twobyte value)
    {
        _TypeCast()->measXadjust = value;
    }

     FCString* CreateTextString();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

     FCString* CreateTextString_GC();
#endif

     FCEnclosure* CreateEnclosure();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

     FCEnclosure* CreateEnclosure_GC();
#endif

     bool IsPlaybackTempo() const
     {
         return (_TypeCast()->flag & EXP_DYTYPEBITS) == EXP_TIME;
     }

         bool IsSmartMusicMarker() const
         {
                 return (_TypeCast()->flag & EXP_SMARTMUSICMARKER) == EXP_SMARTMUSICMARKER;
         }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
         SMARTMUSIC_MARKER_TYPES 
#else
         int
#endif
                 GetSmartMusicMarkerType() const;

         void SetSmartMusicMarkerType(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                 FCTextExpressionDef::SMARTMUSIC_MARKER_TYPES
#else
                 int
#endif
                 value
                 );

     bool IsAutoRehearsalMark() const
         {
         return (GetRehearsalMarkStyle() != REHMARKSTYLE_MANUAL);
     }

     bool MakeRehearsalMark(FCString* pString, int measure);

     bool SaveTextString(FCString* pString);

     bool SaveNewTextBlock(FCString* pString);

     bool DeleteTextBlock();

     bool AssignToCategory(FCCategoryDef* pDef);
     
     bool GetUseCategoryFont() const;
     
     bool GetUseCategoryPos() const;
     

     void SetDescription(FCString* pDescriptionString);

     void GetDescription(FCString* pDescriptionString);

     FCString* CreateDescription();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY     

     FCString* CreateDescription_GC();
#endif


#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        FCString description;
        GetDescription(&description);
        DebugOutString("Description: ", description.GetCString());
        DebugOutDigit("Category ID: ", GetCategoryID());
        FCString* pString = CreateTextString();
        DebugOutString("Rawstring: ", pString->GetCString());
        delete pString;
    }
#endif
};



class FCShapeExpressionDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    bool _unicode;

    EDTShapeExpression2004* _TypeCast() const { return (EDTShapeExpression2004*)_datablock; }
    
    const char* _TypeCastTextPtr() const
    {
        if (_loadedsize <= 36) return NULL;
        char* pszReturn = (char*) _datablock;
        pszReturn += 36;  /* 3 full incis */
        return pszReturn;
    }
    
    void _AllocateMemory(int size);

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() {
        /* DataSizeLoad() sets the custom tag!!! */
        return GetCustomTag() ? GetCustomTag() : ot_ShapeExpression2004;
    }
    virtual EVERSION EnigmaVersion() { return _unicode ? FINALEVERSION_2012 : FINALEVERSION_2010; }
    
    virtual int DataSizeLoad();
    virtual int DataSizeSave();
    virtual void* Allocate();
    virtual void Deallocate();
    virtual bool IsDynamicSize() { return true; }
  
    
    virtual __FCBaseData* CreateObject() { return new FCShapeExpressionDef(); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:    

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    virtual bool Load(CMPER cmper);

    virtual bool Save();

    virtual bool SaveNew();

    virtual const char* ClassName() { return "FCShapeExpressionDef"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SHAPEEXPRESSIONDEF; }

    void* _GetShapeExpression() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCShapeExpressionDef();

    virtual ~FCShapeExpressionDef();


#ifdef PDK_FRAMEWORK_SHAPES

     virtual bool LoadFirst() { return Load(1); }

    virtual bool LoadNext()
    {
        if (!DataIsLoaded()) return false;
        return Load(GetItemNo() + 1);
    }

    FCShapeDef* CreateShapeDef();
    
    FCShapeDef* CreateShapeDef_GC();
#endif
    
    bool GetUseExecutableShape() const
    {
        return GetBitFlag(_TypeCast()->flag, EXP_VALUEisEXEC);
    }


    bool GetAllowHorizontalStretching() const
    {
        return !GetBitFlag(_TypeCast()->flag, SHAPE_EXP_LOCKDOWN);
    }

    bool GetNoPrint() const
    {
        return GetBitFlag(_TypeCast()->flag, SHAPE_EXP_NOPRINT);
    }

    bool GetBreakMMRest() const
    {
        return GetBitFlag(_TypeCast()->flag, SHAPE_EXP_BREAKMMREST);
    }

    twobyte GetExecutableShapeID()
    {
        if (!GetUseExecutableShape()) return 0;
        return _TypeCast()->value;
    }

    twobyte GetID() const
    {
        return _TypeCast()->shapedef;
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_JUSTIFICATION
#else
    int
#endif
    GetHorizontalJustification() const
    {
        twobyte setting;  /* Shape expr def have another order than text expr defs */
#if FXT_VERSION >= FINALEVERSION_2014
        setting = (FCCategoryDef::HORIZ_JUSTIFICATION) _TypeCast()->horzExprAlign;
#else
        setting = (FCCategoryDef::HORIZ_JUSTIFICATION) _TypeCast()->measExprAlign;
#endif
        switch (setting)
        {
            case 0:
                return FCCategoryDef::EXPRJUSTIFY_LEFT;
            case 1:
                return FCCategoryDef::EXPRJUSTIFY_CENTER;
            default:
                return FCCategoryDef::EXPRJUSTIFY_RIGHT;
        }

    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_ALIGNMENT
#else
    int
#endif
    GetHorizontalAlignmentPoint() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (FCCategoryDef::HORIZ_ALIGNMENT) _TypeCast()->horzMeasExprAlign;
#else
        return (FCCategoryDef::HORIZ_ALIGNMENT) _TypeCast()->measAlign;
#endif
    }

    bool GetUseCategoryPos() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
    return GetBitFlag(_TypeCast()->category, USE_CATEGORY_POS_MASK);
#elif FXT_VERSION >= FINALEVERSION_2012
    return GetBitFlag(_TypeCast()->measYadjust, USE_CATEGORY_POS_MASK);
#else
    return GetBitFlag(_TypeCast()->measYadjust, 0x4000);
#endif
    }

    twobyte GetHorizontalOffset() const
    {
        return _TypeCast()->measXadjust;
    }

    twobyte GetVerticalEntryOffset() const { 
#if FXT_VERSION < FINALEVERSION_2014
        return _TypeCast()->noteYadjustEntry;
#else
        return _TypeCast()->yAdjustEntry;
#endif
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::VERT_ALIGNMENT
#else
    int
#endif
    GetVerticalAlignmentPoint() const
    {
        return (FCCategoryDef::VERT_ALIGNMENT) _TypeCast()->vertMeasExprAlign;
    }

    twobyte GetVerticalBaselineOffset() const {
#if FXT_VERSION < FINALEVERSION_2014
        return _TypeCast()->noteYadjustBaseline;
#else
        return _TypeCast()->yAdjustBaseline;
#endif
    }
    
    void GetDescription(FCString* pName);
    

    void SetID(twobyte shapeID)
    {
        _TypeCast()->shapedef = shapeID;
    }

    void SetExecutableShapeID(twobyte shapeID)
    {
        _TypeCast()->value = shapeID;
        SetUseExecutableShape((shapeID != 0) ? true : false);
    }

    void SetUseExecutableShape(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, EXP_VALUEisEXEC, state);
    }

    void SetAllowHorizontalStretching(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, SHAPE_EXP_LOCKDOWN, !state);
    }

    void SetNoPrint(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, SHAPE_EXP_NOPRINT, state);
    }

    void SetBreakMMRest(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, SHAPE_EXP_BREAKMMREST, state);
    }


    twobyte GetCategoryID() const
    {
#if FXT_VERSION >= FINALEVERSION_2014
        return (_TypeCast()->category & 0x3fff);
#else
        return (_TypeCast()->measYadjust & 0x3fff);
#endif
    }

     void SetCategoryID(twobyte ID)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->category &= 0xc000;
        _TypeCast()->category |= (ID & 0x3fff);
#else
        _TypeCast()->measYadjust &= 0xc000;
        _TypeCast()->measYadjust |= (ID & 0x3fff);
#endif    
     }


    void SetHorizontalJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_JUSTIFICATION
#else
    int
#endif
    value)
    {
        /* Shape expr defs have the flags in another way than text expr defs... */
        twobyte setting = 0;
        switch (value)
        {
            case FCCategoryDef::EXPRJUSTIFY_LEFT:
                setting = 0;
                break;
            case FCCategoryDef::EXPRJUSTIFY_CENTER:
                setting = 1;
                break;
            case FCCategoryDef::EXPRJUSTIFY_RIGHT:
                setting = 2;
                break;
        }        
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->horzExprAlign = (twobyte) setting;
#else
        _TypeCast()->measExprAlign = (twobyte) setting;
#endif
    }

    void SetHorizontalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::HORIZ_ALIGNMENT
#else
    int
#endif
    value)
    {
#if FXT_VERSION >= FINALEVERSION_2014
        _TypeCast()->horzMeasExprAlign = (twobyte) value;
#else
        _TypeCast()->measAlign = (twobyte) value;
#endif
    }

    void SetUseCategoryPos(bool value)
    {
#if FXT_VERSION >= FINALEVERSION_2014    
        Set16BitFlag((FLAG_16*) &_TypeCast()->category, USE_CATEGORY_POS_MASK, value);
#elif FXT_VERSION >= FINALEVERSION_2012    
        Set16BitFlag((FLAG_16*) &_TypeCast()->measYadjust, USE_CATEGORY_POS_MASK, value);
#else
        Set16BitFlag((FLAG_16*) &_TypeCast()->measYadjust, 0x4000, value);
#endif
    }

    void SetHorizontalOffset(twobyte value)
    {
        _TypeCast()->measXadjust = value;
    }

    void SetVerticalEntryOffset(twobyte value)
    {
#if FXT_VERSION < FINALEVERSION_2014
        _TypeCast()->noteYadjustEntry = value;
#else
        _TypeCast()->yAdjustEntry = value;
#endif
    }

    void SetVerticalAlignmentPoint(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCCategoryDef::VERT_ALIGNMENT
#else
    int
#endif
    value)
    {
        _TypeCast()->vertMeasExprAlign = (twobyte) value;
    }

    void SetVerticalBaselineOffset(twobyte value) {
#if FXT_VERSION < FINALEVERSION_2014
        _TypeCast()->noteYadjustBaseline = value;
#else
        _TypeCast()->yAdjustBaseline = value;
#endif
    }

    void SetDescription(FCString* pName);

#ifdef PDK_FRAMEWORK_SHAPES

    bool AssignShapeDef(FCShapeDef* pShapeDef)
    {
        if (!pShapeDef) return false;
        if (pShapeDef->GetItemNo() < 1) return false;
        _TypeCast()->shapedef = pShapeDef->GetItemNo();
        return true;
    }
#endif

    FCString* CreateDescription();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateDescription_GC();
#endif


#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Category ID: ", GetCategoryID());
    }
#endif
};


class FCTextBlock : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTextBlock2004 _textblock2004;    /* Pre 25.4-version of the struct */
#if FXT_VERSION >= FINALEVERSION_25_4
    EDTTextBlock25_4 _textblock25_4;    /* 25.4 and above */
#endif
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
    /* If true, use the 25.4 struct. If false, use the old 2004 struct. */
    bool UseVersion25_4() const;
    
    /* Returns the pointer to the flag member in the struct. */
    const FLAG_16* _GetFlagPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.flag; )
        return &_textblock2004.flag;
    }
    
    /* Returns the pointer to the textID member in the struct. */
    const eText* _GetTextIDPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.textID; )
        return &_textblock2004.textID;
    }
    
    /* Returns the pointer to the shapeID member in the struct. */
    const eShape* _GetShapeIDPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.shapeID; )
        return &_textblock2004.shapeID;
    }
    
    /* Returns the pointer to the lineSpacing member in the struct. */
    const twobyte* _GetLineSpacingPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.lineSpacing; )
        return &_textblock2004.lineSpacing;
    }
    
    /* Returns the pointer to the textTag member in the struct. */
    const ETAG* _GetTextTagPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.textTag; )
        return &_textblock2004.textTag;
    }
    
    /* Returns the pointer to the width member in the struct. */
    const Evpu16* _GetWidthPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.width; )
        return &_textblock2004.width;
    }
    
    /* Returns the pointer to the height member in the struct. */
    const Evpu16* _GetHeightPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.height; )
        return &_textblock2004.height;
    }
    
    /* Returns the pointer to the xadd member in the struct. */
    const Evpu16* _GetXaddPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.xadd; )
        return &_textblock2004.xadd;
    }
    
    /* Returns the pointer to the yadd member in the struct. */
    const Evpu16* _GetYaddPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.yadd; )
        return &_textblock2004.yadd;
    }
    
    /* Returns the pointer to the insethi member in the struct. */
    const EVPUFixedShort* _GetInsetHiPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.insethi; )
        return &_textblock2004.insethi;
    }
    
    /* Returns the pointer to the insetlo member in the struct. */
    const EVPUFixedShort* _GetInsetLoPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.insetlo; )
        return &_textblock2004.insetlo;
    }
    
    /* Returns the pointer to the stdlinelo member in the struct. */
    const EVPUFixedShort* _GetStdLineLoPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.stdlinelo; )
        return &_textblock2004.stdlinelo;
    }
    
    /* Returns the pointer to the stdlinehi member in the struct. */
    const EVPUFixedShort* _GetStdLineHiPtr() const
    {
        FIN25_4_CODE(if (UseVersion25_4()) return &_textblock25_4.stdlinehi; )
        return &_textblock2004.stdlinehi;
    }
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return ot_TextBlock; }
    
    virtual int DataSizeLoad() {
        FIN25_4_CODE(if (UseVersion25_4()) return sizeof(EDTTextBlock25_4);)
        return sizeof(EDTTextBlock2004);
    }
    virtual void* Allocate()
    {
        FIN25_4_CODE( if (UseVersion25_4()) return (void*) &_textblock25_4; )
        return (void*) &_textblock2004;
    }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        void* pTextBlock = Allocate();
        memcpy(pTextBlock, ((FCTextBlock*)pSource)->_GetTextBlock(), DataSizeLoad());
        _datablock = pTextBlock;
        _loadedsize = DataSizeLoad();
    }

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

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    enum TEXTBLOCKJUSTIFY
    {
        TEXTJUSTIFY_LEFT = TEXT_JUSTIFY_LEFT,
        TEXTJUSTIFY_RIGHT = TEXT_JUSTIFY_RIGHT,
        TEXTJUSTIFY_CENTER = TEXT_JUSTIFY_CENTER,
        TEXTJUSTIFY_FULL = TEXT_JUSTIFY_FULL,
        TEXTJUSTIFY_FORCED_FULL = TEXT_JUSTIFY_FORCED_FULL
    };


    virtual const char* ClassName() { return "FCTextBlock"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TEXTBLOCK; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetTextBlock() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCTextBlock() : __FCNoInciOther()
    {
        void* pTextBlock = Allocate();
        int size = DataSizeLoad();
        memset(pTextBlock, 0, size);
        Set16BitFlag( (FLAG_16*)_GetFlagPtr(),
                TEXTBLOCK_NEWPOS | TEXTBLOCK_SHOWMAINSHAPE |
                TEXTBLOCK_WORDWRAP | TEXTBLOCK_LINESPACINGISPERCENT,
                true);
        SetLineSpacing(100);
        SetRawText(0, LO_UTWOBYTE(tx_TextBlock));  /* Default to tx_TextBlock */
       _datablock = pTextBlock;
       _loadedsize = size;
    }

    twobyte GetRawTextID() const { return *_GetTextIDPtr(); }

    void _SetRawTextID(twobyte therawtextid) { *(eText*)_GetTextIDPtr() = therawtextid; }

    EXTAG GetRawTextExtag()
    {
        EXTAG rawtextextag = tx_TextBlock;
        rawtextextag &= 0xffff0000;
        rawtextextag |= *_GetTextTagPtr();
        return rawtextextag;
    }   

    twobyte GetShapeID() const { return *_GetShapeIDPtr(); }

    FCString* CreateRawTextString();

#if PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateRawTextString_GC();
#endif

    bool SaveRawTextString(FCString* pString);

    bool SaveNewRawTextString(FCString* pString);

    void SetShapeID(twobyte shapeID) { *(eShape*)_GetShapeIDPtr() = shapeID; }

    void SetRawText(twobyte theid, ETAG tag = LO_UTWOBYTE(tx_TextBlock))
    {
        *(eText*)_GetTextIDPtr() = theid;
        *(ETAG*)_GetTextTagPtr() = tag;
    }

    void SetJustification(FLAG_16 justification)
    {
        FLAG_16* pFlag = (FLAG_16*) _GetFlagPtr();
        *pFlag &= ~TEXTBLOCK_JUSTIBITS;
        *pFlag |= (justification % TEXTBLOCK_JUSTIBITS);
    }

    virtual bool DeepDeleteData()
    {
        FCRawText rawtext;
        rawtext.SetCustomTag(GetRawTextExtag());
        rawtext.Load(GetRawTextID());                
        rawtext.DeleteData();
        return DeleteData();
    }

    twobyte GetLineSpacing() const { return *_GetLineSpacingPtr(); }
    

    void SetLineSpacing(twobyte linespacing) { *(twobyte*)_GetLineSpacingPtr() = linespacing; }


    FLAG_16 GetJustification() const
    {
        return (*_GetFlagPtr() & TEXTBLOCK_JUSTIBITS);
    }

    bool GetFrameReference() const
    {
        return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_NEWPOS);
    }

    bool GetLineSpacingIsPercent() const
    {
        return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_LINESPACINGISPERCENT);
    }

    bool GetWordWrap() const
    {
        return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_WORDWRAP);
    }

    bool GetExpandSingleWord() const
    {
        return !GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_NOEXPANDSINGLEWORD);
    }
    
    bool GetRoundedCorners() const
    {
        FIN25_4_CODE( if (UseVersion25_4()) return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_ROUND_CORNERS); )
        return false;
    }
    
    Efix32 GetRoundedCornerRadius() const
    {
        FIN25_4_CODE( if (UseVersion25_4()) return _textblock25_4.m_cornerRadius; )
        return 0;
    }
    

    void SetFrameReference(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_NEWPOS, state);
    }

    void SetLineSpacingIsPercent(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_LINESPACINGISPERCENT, state);
    }

    void SetWordWrap(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_WORDWRAP, state);
    }

    void SetExpandSingleWord(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_NOEXPANDSINGLEWORD, !state);
    }

    void SetRoundedCorners(bool state)
    {
        FIN25_4_CODE( if (UseVersion25_4()) Set16BitFlag((FLAG_16*) _GetFlagPtr(), TEXTBLOCK_ROUND_CORNERS, state); )
    }
    
    void SetRoundedCornerRadius(Efix32 radius)
    {
        FIN25_4_CODE( if (UseVersion25_4()) _textblock25_4.m_cornerRadius = radius; )
    }
    
    void SetLineWidth(int value)
    {
        *(EVPUFixedShort*)_GetStdLineLoPtr() = LOWORD(value);
        *(EVPUFixedShort*)_GetStdLineHiPtr() = HIWORD(value);
    }

    void SetLineInset(int value)
    {
        *(EVPUFixedShort*)_GetInsetLoPtr() = LOWORD(value);
        *(EVPUFixedShort*)_GetInsetHiPtr() = HIWORD(value);
    }
    
    void SetHorizontalTextOffset(int value)
    {
        *(Evpu16*) _GetXaddPtr() = value;
    }

    void SetVerticalTextOffset(int value)
    {
        *(Evpu16*) _GetYaddPtr() = value;
    }
    
    void SetShowBorders(bool state)
    {
        Set16BitFlag((FLAG_16*)_GetFlagPtr(), TEXTBLOCK_SHOWMAINSHAPE, state);
    }

    void SetWidth(Evpu16 width)
    {
        *(Evpu16*)_GetWidthPtr() = width;
    }

    void SetHeight(Evpu16 height)
    {
        *(Evpu16*)_GetHeightPtr() = height;
    }

    
    int GetLineWidth() const
    {
        return MAKELONG(*_GetStdLineLoPtr(), *_GetStdLineHiPtr());
    }
    
    int GetLineInset() const
    {
        return MAKELONG(*_GetInsetLoPtr(), *_GetInsetHiPtr());
    }
    
    int GetHorizontalTextOffset() const
    {
        return *_GetXaddPtr();
    }
    
    int GetVerticalTextOffset() const
    {
        return *_GetYaddPtr();
    }
    
    bool GetShowBorders() const
    {
        return GetBitFlag(*_GetFlagPtr(), TEXTBLOCK_SHOWMAINSHAPE);
    }

    Evpu16 GetWidth() const
    {
        return *_GetWidthPtr();
    }

    Evpu16 GetHeight() const
    {
        return *_GetHeightPtr();
    }

    bool GetExpandHorizontally() const
    {
        return (GetWidth() == 0);
    }

    bool GetExpandVertically() const
    {
        return (GetHeight() == 0);
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Raw text ID: ", GetRawTextID());
        DebugOutHex("Text tag (hex): ", *_GetTextTagPtr());
        DebugOutHex("flag (hex): ", *_GetFlagPtr());
    }
#endif
};


class FCPageText  : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTPageText _pagetext;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return ot_PageText; }
    virtual int DataSizeLoad() { return sizeof(EDTPageText); }
    virtual void* Allocate() { return (void*) &_pagetext; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_pagetext, ((FCPageText*)pSource)->_GetPageText(), sizeof(_pagetext));
        _datablock = &_pagetext;
        _loadedsize = sizeof(_pagetext);
    }

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


    virtual bool LoadFirst()
    {
        SetCmperAndInci(0, 0);
        if (Load(0, 0)) return true;
        return LoadNext();
    }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    enum TEXT_HORIZONTAL_ALIGN
    {
        TEXTHORIZALIGN_LEFT = TEXT_HALIGN_LEFT,
        TEXTHORIZALIGN_RIGHT = TEXT_HALIGN_RIGHT,
        TEXTHORIZALIGN_CENTER = TEXT_HALIGN_CENTER
    };

    enum TEXT_VERTICAL_ALIGN
    {
        TEXTVERTALIGN_TOP = TEXT_VALIGN_TOP,
        TEXTVERTALIGN_BOTTOM = TEXT_VALIGN_BOTTOM,
        TEXTVERTALIGN_CENTER = TEXT_VALIGN_CENTER        
    };

    enum TEXT_ASSIGNMENT
    {
        TEXTASSIGN_ALL = PAGETEXT_ASSIGN_ALL,
        TEXTASSIGN_ODD = PAGETEXT_ASSIGN_ODD,
        TEXTASSIGN_EVEN = PAGETEXT_ASSIGN_EVEN
    };

    virtual const char* ClassName() { return "FCPageText"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PAGETEXT; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetPageText() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCPageText() : __FCInciOther()
    {
        memset(&_pagetext, 0, sizeof(_pagetext));
        _datablock = &_pagetext;
        _loadedsize = sizeof(_pagetext);
    }

    FCString* CreateTextString()
    {
        FCTextBlock textblock;
        textblock.Load(GetTextBlockID());
        return textblock.CreateRawTextString();
    }

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateTextString_GC();
#endif

    FCTextBlock* CreateTextBlock();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCTextBlock* CreateTextBlock_GC();
#endif

    twobyte GetFirstPage() const
    {
        return _pagetext.startPage;
    }

    twobyte GetLastPage() const
    {
        return _pagetext.endPage;
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_HORIZONTAL_ALIGN
#else
    int
#endif
    GetHorizontalAlignment() const
    {
        return (TEXT_HORIZONTAL_ALIGN) ((_pagetext.flag & PAGETEXT_HPOS_LP_BITS) >> 2);
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_VERTICAL_ALIGN
#else
    int
#endif
    GetVerticalAlignment() const
    {
        return (TEXT_VERTICAL_ALIGN) ((_pagetext.flag & PAGETEXT_VPOS_BITS) >> 8);
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_HORIZONTAL_ALIGN
#else
    int
#endif
     GetHorizontalAlignmentRightPage() const
     {
         return (TEXT_HORIZONTAL_ALIGN) ((_pagetext.flag & PAGETEXT_HPOS_RP_BITS) >> 4);
     }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_ASSIGNMENT
#else
    int
#endif
    GetPageAssignment() const
    {
         return (TEXT_ASSIGNMENT) (_pagetext.flag & PAGETEXT_OE_BITS);
    }

    bool GetPageEdgeRef() const
    {
        return GetBitFlag(_pagetext.flag, PAGETEXT_HPOS_PAGE_EDGE);
    }

    bool GetFrameEdgeRef() const
    {
        FCTextBlock textblock;
        if (!textblock.Load(GetTextBlockID())) return false;
        return textblock.GetFrameReference();
    }


    twobyte GetHorizontalPos() const
    {
        return _pagetext.xdisp;
    }

    twobyte GetHorizontalPosRightPage() const
    {
        return _pagetext.rightpgxdisp;
    }

    twobyte GetVerticalPos() const
    {
        return _pagetext.ydisp;
    }

    twobyte GetVerticalPosRightPage() const
    {
        return _pagetext.rightpgydisp;
    }

    bool GetVisible() const
    {
        return !GetBitFlag(_pagetext.flag, (PAGETEXT_ANNOTATION));
    }

    bool GetIndependentRightPage() const
    {
        return GetBitFlag(_pagetext.flag, PAGETEXT_INDRP_POS);
    }

    CMPER GetTextBlockID() const
    {
        return _pagetext.block;
    }

    void _SetTextBlockID(CMPER textblockid)
    {
        _pagetext.block = textblockid;
    }

    CMPER GetStringID() const;

     bool SaveNewTextBlock(FCString* pString);

     bool SaveTextString(FCString* pString);

     void SetHorizontalAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_HORIZONTAL_ALIGN
#else
    FLAG_16
#endif
    alignment
     )
     {
         _pagetext.flag &= ~PAGETEXT_HPOS_LP_BITS;
         _pagetext.flag |= ((alignment << 2) & PAGETEXT_HPOS_LP_BITS);
         if (!GetIndependentRightPage()) SetHorizontalAlignmentRightPage(alignment);
     }

     void SetHorizontalAlignmentRightPage(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_HORIZONTAL_ALIGN
#else
    FLAG_16
#endif
     alignment)
     {
         _pagetext.flag &= ~PAGETEXT_HPOS_RP_BITS;
         _pagetext.flag |= ((alignment << 4) & PAGETEXT_HPOS_RP_BITS);
     }

    void SetVerticalAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_VERTICAL_ALIGN
#else
    int
#endif
    alignment
    )
    {
         _pagetext.flag &= ~PAGETEXT_VPOS_BITS;
         _pagetext.flag |= ((alignment << 8) & PAGETEXT_VPOS_BITS);
    }

    void SetPageAssignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    TEXT_ASSIGNMENT
#else
    int
#endif
    assign
    )
    {
        _pagetext.flag &= ~PAGETEXT_OE_BITS;
        _pagetext.flag |= (assign & PAGETEXT_OE_BITS);
    }

     void SetFirstPage(ePage page)
     {
         _pagetext.startPage = page;
     }

    void SetLastPage(ePage page)
    {
        _pagetext.endPage = page;
    }

    void SetHorizontalPos(twobyte value)
    {
        _pagetext.xdisp = value;
        if (!GetIndependentRightPage()) SetHorizontalPosRightPage(value);
    }

    void SetHorizontalPosRightPage(twobyte value)
    {
        _pagetext.rightpgxdisp = value;
    }

    void SetVerticalPos(twobyte value)
    {
        _pagetext.ydisp = value;
        if (!GetIndependentRightPage()) SetVerticalPosRightPage(value);
    }

    void SetVerticalPosRightPage(twobyte value)
    {
        _pagetext.rightpgydisp = value;
    }

    void SetVisible(bool visible)
    {
        Set16BitFlag(&_pagetext.flag, PAGETEXT_ANNOTATION, !visible);
    }

    void SetIndependentRightPage(bool state)
    {
        Set16BitFlag(&_pagetext.flag, PAGETEXT_INDRP_POS, state);
    }

    void SetPageEdgeRef(bool state)
    {
        Set16BitFlag(&_pagetext.flag, PAGETEXT_HPOS_PAGE_EDGE, state);
        Set16BitFlag(&_pagetext.flag, PAGETEXT_VPOS_PAGE_EDGE, state);
    }

    void SetFrameEdgeRef(bool state)
    {
        FCTextBlock textblock;
        if (!textblock.Load(GetTextBlockID())) return;
        textblock.SetFrameReference(state);
    }

    virtual bool DeepDeleteData()
    {
        FCTextBlock textblock;
        textblock.Load(GetTextBlockID());
        textblock.DeepDeleteData();
        return DeleteData();
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
        DebugOutDigit("First page: ", GetFirstPage());
        DebugOutDigit("Last page: ", GetLastPage());
        DebugOutHex("Flag (hex): ", _pagetext.flag);
    }
#endif
};





class FCSeparatePlacement : public __FCInciOther
{    
    private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTSeparatePlacement _separateplacement;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ot_SeparateBackwardRepeatPlacement; }
    virtual int DataSizeLoad() { return sizeof(EDTSeparatePlacement); }
    virtual void* Allocate() { return (void*) &_separateplacement; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_separateplacement, ((FCSeparatePlacement*)pSource)->_GetSeparatePlacement(), sizeof(_separateplacement));
        _datablock = &_separateplacement;
        _loadedsize = sizeof(_separateplacement);
    }

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

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    enum SEPARATEPLACEMENT_MODES
    {        
        SEPARMODE_BACKWARDREPEAT = 0,

        SEPARMODE_TEXTREPEAT = 1,

        SEPARMODE_ENDINGREPEAT = 2,

        SEPARMODE_ENDINGREPEATTEXT = 3
    };

    virtual const char* ClassName() { return "FCSeparatePlacement"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SEPARATEPLACEMENT; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetSeparatePlacement() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCSeparatePlacement() : __FCInciOther()
    {
        memset(&_separateplacement, 0, sizeof(_separateplacement));
        _datablock = &_separateplacement;
        _loadedsize = sizeof(_separateplacement);
    }


    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    SEPARATEPLACEMENT_MODES 
#else
    int
#endif
    mode
    )
    {
        switch (mode)
        {
            case FCSeparatePlacement::SEPARMODE_TEXTREPEAT:
                SetCustomTag(MAKEEXTAG(edOther,'R','I'));
                break;
            case FCSeparatePlacement::SEPARMODE_BACKWARDREPEAT:
                SetCustomTag(ot_SeparateBackwardRepeatPlacement);
                break;
            case FCSeparatePlacement::SEPARMODE_ENDINGREPEAT:
                SetCustomTag(ot_SeparateEndingRepeatPlacement);
                break;
            case FCSeparatePlacement::SEPARMODE_ENDINGREPEATTEXT:
                SetCustomTag(ot_SeparateEndingRepeatTextPlacement);
                break;
        }
    }

    virtual eStaff GetStaff() const { return _separateplacement.instno; }
    
    virtual bool HasStaffValue() { return true; }

    twobyte GetMeasure() const { return _separateplacement.measure; }

        Evpu16 GetHorizontalOffset1() const { return _separateplacement.x1add; }

    Evpu16 GetVerticalOffset1() const { return _separateplacement.y1add; }

        Evpu16 GetHorizontalOffset2() const { return _separateplacement.x2add; }

    Evpu16 GetVerticalOffset2() const { return _separateplacement.y2add; }

    void SetStaff(eStaff staff) { _separateplacement.instno = staff; }

    void SetMeasure(twobyte meas) { _separateplacement.measure = meas; }

    void SetHorizontalOffset1(Evpu16 value) { _separateplacement.x1add = value; }

    void SetVerticalOffset1(Evpu16 value) { _separateplacement.y1add = value; }

    void SetHorizontalOffset2(Evpu16 value) { _separateplacement.x2add = value; }

    void SetVerticalOffset2(Evpu16 value) { _separateplacement.y2add = value; }
};


class FCCell;

class FCExpression : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTScoreExpression2009 _expression;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    virtual int DataSizeLoad() { return sizeof(EDTScoreExpression2009); }
    virtual void* Allocate() { return (void*) &_expression; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_expression, ((FCExpression*)pSource)->_GetExpression(), sizeof(_expression));
        _datablock = &_expression;
        _loadedsize = sizeof(_expression);
    }

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

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

        enum EXPRESSION_PLAYBACK_STARTPOINTS
        {
                EXPRPLAYSTART_POSINMEASURE = 0,
                
                EXPRPLAYSTART_ALIGNMENTPOINT = 1,

                EXPRPLAYSTART_BEGINNINGOFMEASURE = 2
        };


    virtual const char* ClassName() { return "FCExpression"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_EXPRESSION; }

    virtual EXTAG Tag() { return ot_ScoreExpression2009; }  /* Tag is required to be public for some plug-ins */

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetExpression() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCExpression() : __FCInciOther()
    {
        memset(&_expression, 0, sizeof(_expression));
        _datablock = &_expression;
        _loadedsize = sizeof(_expression);
    }


    bool AssignTextExpressionDef(FCTextExpressionDef* pDef);

    bool AssignShapeExpressionDef(FCShapeExpressionDef* pDef);

    bool CalcMetricPos(FCPoint* pPoint);
    
    void ResetPos()
    {
        SetHorizontalPos(0);
        SetVerticalPos(0);
    }

    virtual twobyte GetStaff() const { return _expression.staffAssign; }
    
    virtual bool HasStaffValue() { return true; }

    virtual eMeas GetMeasure() const { return _dataid.other.cmper; }

    twobyte GetLayerAssignment() const { return _expression.flag & 0x7; }

    twobyte GetPlaybackLayerAssignment() const
    {        
        return (_expression.flag & 0x70) >> 4;
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
        EXPRESSION_PLAYBACK_STARTPOINTS
#else
        int 
#endif
        GetPlaybackStart() const
        {
                if (GetBitFlag(_expression.flag, 0x0400)) return EXPRPLAYSTART_POSINMEASURE;
                if (GetBitFlag(_expression.flag, 0x0200)) return EXPRPLAYSTART_ALIGNMENTPOINT;
                return EXPRPLAYSTART_BEGINNINGOFMEASURE;
        }

    bool GetScoreAssignment() const
    {
        return !GetBitFlag(_expression.flag, 0x1000);
    }

    bool GetPartAssignment() const
    {
        return !GetBitFlag(_expression.flag, 0x0800);
    }

    twobyte GetStaffListID() const { return _expression.staffList; }

    twobyte GetStaffGroupID() const { return _expression.staffGroup; }
    
    twobyte GetRehearsalMarkOffset() const { return _expression.rehearsalMarkOffset; }

    bool GetVisible() const { return !GetBitFlag(_expression.flag, 0x4000); }

    bool GetScaleWithEntry() const { return !GetBitFlag(_expression.flag, 0x0100); }

    TimeEdu32 GetMeasurePos() const { return 0x10000 * _expression.horzEDUOffHi + _expression.horzEDUOffLo; }

    twobyte GetHorizontalPos() const { return _expression.horzEVPUOff; }

    twobyte GetVerticalPos() const { return _expression.vertOff; }

    twobyte GetGraceNoteIndex() const { return _expression.graceNoteIndex; }
    
    bool IsVisibleOnStaff(twobyte staff);
   
    FCShapeExpressionDef* CreateShapeExpressionDef();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCShapeExpressionDef* CreateShapeExpressionDef_GC();
#endif

    FCTextExpressionDef* CreateTextExpressionDef();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCTextExpressionDef* CreateTextExpressionDef_GC();
#endif

    bool IsShape() const { return GetBitFlag(_expression.flag, SCOREEXP_SHAPE_OBJECT); }

    bool IsSingleStaffAssigned() { return (GetStaff() > 0); }

    bool GetShape() const { return GetBitFlag(_expression.flag, SCOREEXP_SHAPE_OBJECT); }

    twobyte GetID() const { return _expression.dynumber; }

    bool SaveNewToCell(FCCell* pCell);

    void SetID(twobyte id) { _expression.dynumber = id; }

    void SetLayerAssignment(twobyte layer)
    {
        layer &= 0x07;
        _expression.flag &= ~0x07;
        _expression.flag |= layer;
    }

    void SetScoreAssignment(bool value)
    {
        Set16BitFlag(&_expression.flag, 0x1000, !value);
    }

    void SetPartAssignment(bool value)
    {
        Set16BitFlag(&_expression.flag, 0x0800, !value);
    }

    void SetPlaybackLayerAssignment(twobyte layer)
    {
        layer &= 0x07;
        layer <<= 4;
        _expression.flag &= ~0x70;
        _expression.flag |= layer;       
    }

        void SetPlaybackStart(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                EXPRESSION_PLAYBACK_STARTPOINTS
#else
                int
#endif
                value
                )
        {
                switch (value)
                {
                        case EXPRPLAYSTART_POSINMEASURE:
                                Set16BitFlag(&_expression.flag, 0x0400, true);
                                Set16BitFlag(&_expression.flag, 0x0200, false);
                                break;
                        case EXPRPLAYSTART_ALIGNMENTPOINT:
                                Set16BitFlag(&_expression.flag, 0x0400, false);
                                Set16BitFlag(&_expression.flag, 0x0200, true);
                                break;
                        default: /* EXPRPLAYSTART_BEGINNINGOFMEASURE */
                                Set16BitFlag(&_expression.flag, 0x0400, false);
                                Set16BitFlag(&_expression.flag, 0x0200, false);
                                break;
                }               
        }

    void SetStaff(twobyte staffno) { _expression.staffAssign = staffno; }

    void SetShape(bool isshape) { Set16BitFlag(&_expression.flag, SCOREEXP_SHAPE_OBJECT, isshape); }

    void SetStaffListID(twobyte ID) { _expression.staffList = ID; }

    void SetStaffGroupID(twobyte value) { _expression.staffGroup = value; }

    void SetRehearsalMarkOffset(twobyte value) { _expression.rehearsalMarkOffset = value; }

    void SetVisible(bool state) { Set16BitFlag(&_expression.flag, 0x4000, !state); }

    void SetScaleWithEntry(bool state) { Set16BitFlag(&_expression.flag, 0x0100, !state); }

    void SetMeasurePos(TimeEdu32 value) 
    {        
        _expression.horzEDUOffHi = (value & 0xffff0000) / 0x10000;
        _expression.horzEDUOffLo = value & 0x0000ffff;
    }

    void SetHorizontalPos(twobyte value) { _expression.horzEVPUOff = value; }

    void SetVerticalPos(twobyte value) {  _expression.vertOff = value; }
    
    void SetGraceNoteIndex(twobyte index) {
        if (index < 0) return; /* Negative indexes aren't allowed */
        _expression.graceNoteIndex = index;
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
        DebugOutBlock(&_expression, 0, sizeof(_expression));
        DebugOutHex("Flag bits (hex): ", _expression.flag);
        DebugOutDigit("Attached to Staff: ", GetStaff());
        DebugOutDigit("Staff List ID: ", GetStaffListID());
        DebugOutDigit("Rehearsal Mark Offset: ", GetRehearsalMarkOffset());
        DebugOutDigit("Measure Pos (EDUs): ", GetMeasurePos());
        DebugOutDigit("Horizontal Pos (EVPUs): ", GetHorizontalPos());
        DebugOutDigit("Vertical Pos: ", GetVerticalPos());
    }
#endif
};


/* Macro for accessing same-name fields in different versions
 of the Staff Style Def struct: */
#define __STAFFSTYLEDEF_RETURN_FIELD_PTR(field) \
switch (_VersionToUse()) \
{ \
    case FINALEVERSION_2014: \
        return &_staffstyledef2014.field; \
    case FINALEVERSION_2012: \
        return &_staffstyledef2012.field; \
    default: \
        return &_staffstyledef2010.field; \
} \


class FCStaffStyleDef : public __FCStaffBase
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStaffStyle2010 _staffstyledef2010;
    
#if FXT_VERSION >= FINALEVERSION_2012
    EDTStaffStyle2012 _staffstyledef2012;
#else
    EDTStaffStyle2010 _staffstyledef2012; /* Dummy struct for unsupported PDKs */
#endif
    
#if FXT_VERSION >= FINALEVERSION_2014
    EDTStaffStyle2014 _staffstyledef2014;
#else
    EDTStaffStyle2010 _staffstyledef2014;  /* Dummy struct for unsupported PDKs */
#endif
    
    const uonebyte* _GetInstUUIDPtr() const
    {
        if (_VersionToUse() >= FINALEVERSION_2014)
            return _staffstyledef2014.instUUID;
        if (_VersionToUse() >= FINALEVERSION_2012)
            return _staffstyledef2012.instUUID;
        return NULL;
    }
    
    const FLAG_16* _GetInstFlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(instflag);
    }
    
    const FLAG_16* _GetFlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(flag);
    }
    
        const FLAG_16* _GetAltFlagPtr() const
        {
                __STAFFSTYLEDEF_RETURN_FIELD_PTR(altFlag);
        }
    
        const FLAG_16* _GetAltFlag2Ptr() const
        {
                __STAFFSTYLEDEF_RETURN_FIELD_PTR(altFlag2);
        }
    
        const twobyte* _GetTranspositionPtr() const
        {
                __STAFFSTYLEDEF_RETURN_FIELD_PTR(transposition);
        }
    
    const FLAG_16* _GetMoreFlagsPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(moreFlags);
    }

    const FLAG_16* _GetMoreFlags2Ptr() const
    {
                if (_VersionToUse() < FINALEVERSION_2014) return NULL;
#if FXT_VERSION < FINALEVERSION_25
                return (const FLAG_16*) &_staffstyledef2014.hideKeySigsShowAccis;
#else
                return &_staffstyledef2014.moreFlags2;
#endif
    }

    const FLAG_16* _GetMoreFlags3Ptr() const
    {
                if (_VersionToUse() < FINALEVERSION_2014) return NULL;
#if FXT_VERSION < FINALEVERSION_25
                return (const FLAG_16*) &_staffstyledef2014.redisplayLayerAccis;
#else
                return &_staffstyledef2014.moreFlags3;
#endif          
    }
                
    const FLAG_16* _GetMask1FlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(mask1);
    }

    const FLAG_16* _GetMask2FlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(mask2);
    }

    const FLAG_16* _GetMask3FlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(mask3);
    }

    const FLAG_16* _GetSFFlagPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(sfflag);
    }

    const twobyte* _GetAbbrvNamePtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(abbrvName);
    }
    
    const twobyte* _GetFullNamePtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(fullName);
    }

        const twobyte* _GetClefsPtr() const
        {
                __STAFFSTYLEDEF_RETURN_FIELD_PTR(clefs);
        }
    
    const Efix32* _GetVertTabNumOffPtr() const
        {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(vertTabNumOff);
    }

    const CMPER* _GetFretInstIDPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(fretInstID);
    }

    const Evpu16* _GetBottomBarlineOffsetPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(botBarlineOffset);
    }

    const Evpu16* _GetTopBarlineOffsetPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(topBarlineOffset);
    }
    
    const utwobyte* _GetCapoLowFretPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(capoLowFret);
    }
    
    const FLAG_16* _GetBotLinesPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(botLines);
    }
    
    virtual const FLAG_16* _GetTopLinesPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(topLines);
    }
    
    virtual const Efix32* _GetLineSpacePtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(lineSpace);
    }
    
    virtual const twobyte* _GetDwWRestPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(dw_wRest);
    }
    
    virtual const twobyte* _GetStemReversalPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(stemReversal);
    }
    
    virtual const twobyte* _GetRepeatDotsOffPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(repeatDotsOff);
    }
    
    virtual const twobyte* _GetHOtherRestPtr() const
    {
        __STAFFSTYLEDEF_RETURN_FIELD_PTR(h_otherRest);
    }
        
    
    FLAG_16 GetMask1() const { return *_GetMask1FlagPtr(); }
    
    FLAG_16 GetMask2() const { return *_GetMask2FlagPtr(); }
    
    FLAG_16 GetMask3() const { return *_GetMask3FlagPtr(); }
    
        virtual bool LoadFirst() 
        { 
                /* Since there can be holes in the staff style "chain", there
                need to be a better method to find items. Scanning a gap of 20 items
                should be an ok workaround for most documents. */
                for (int i = 1; i <= 20; i++)
                {
                        if (Load(i)) return true;
                }
                return false; 
        }

        virtual bool LoadNext() 
        { 
                /* Since there can be holes in the staff style "chain", there
                need to be a better method to find items. Scanning a gap of 20 items
                should be an ok workaround for most documents. */
                int itemno = GetItemNo();
                for (int i = 1; i <= 20; i++)
                {
                        if (Load(itemno + i)) return true;
                }               
                return false;
        }
        
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    virtual EXTAG Tag() { return ot_EDTStaffStyle2010; }
    virtual int DataSizeLoad()
    {
        switch (_VersionToUse())
        {
            case FINALEVERSION_2014:
                return sizeof(EDTStaffStyle2014);
            case FINALEVERSION_2012:
                return sizeof(EDTStaffStyle2012);
            default:
                return sizeof(EDTStaffStyle2010);
        }
    }
    virtual void* Allocate()
    {
        switch (_VersionToUse())
        {
            case FINALEVERSION_2014:
                return (void*) &_staffstyledef2014;
            case FINALEVERSION_2012:
                return (void*) &_staffstyledef2012;
            default:
                return (void*) &_staffstyledef2010;
        }
    }
    virtual EVERSION EnigmaVersion() { return _VersionToUse(); }

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

    virtual __FCBaseData* CreateObject() { return new FCStaffStyleDef(); }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCStaffStyleDef"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_STAFFSTYLEDEF; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetStaffStyle() { return Allocate(); }

        virtual bool Load(twobyte itemno);
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCStaffStyleDef() : __FCStaffBase()
    {
        memset(_GetStaffStyle(), 0, DataSizeLoad());
        _datablock = _GetStaffStyle();
        _loadedsize = DataSizeLoad();
    }

    /************************
     *** GETTERS for data ***
     ************************/
    
        bool GetCopyable() const { return GetBitFlag(*_GetSFFlagPtr(), SFFLAG_COPYABLE); }

        bool GetAddToMenu() const { return GetBitFlag(*_GetSFFlagPtr(), SFFLAG_ADDTOMENU); }

    
    /*************************************
     *** GETTERS for Staff Style usage ***
     *************************************/
    
    bool GetUseShowKeySignatures() const { return GetBitFlag(GetMask2(), SFMASK2_NEGKEY); }

        bool GetUseShowMeasureNumbers() const { return GetBitFlag(GetMask1(), SFMASK1_NEGMNUMB); }

        bool GetUseShowTimeSignatures() const { return GetBitFlag(GetMask2(), SFMASK2_NEGTIME); }

        bool GetUseShowClefs() const { return GetBitFlag(GetMask2(), SFMASK2_NEGCLEF); }

        bool GetUseShowChords() const { return GetBitFlag(GetMask3(), SFMASK3_HIDE_CHORDS); }
                
        bool GetUseShowAugmentationDots() const { return GetBitFlag(GetMask2(), SFMASK2_SHOWDOTS); }
                
        bool GetUseShowFretboards() const { return GetBitFlag(GetMask3(), SFMASK3_HIDE_FRETBOARDS); }

        bool GetUseShowLyrics() const { return GetBitFlag(GetMask3(), SFMASK3_HIDE_LYRICS); }

        bool GetUseShowRepeats() const { return GetBitFlag(GetMask2(), SFMASK2_HIDE_RPT_BARS); }

        bool GetUseShowRests() const { return GetBitFlag(GetMask2(), SFMASK2_SHOWRESTS); }

        bool GetUseShowStaffLines() const;

        bool GetUseShowScoreStaffNames() const { return GetBitFlag(GetMask1(), SFMASK1_NEGNAME); }

        bool GetUseShowPartStaffNames() const { return GetBitFlag(GetMask3(), SFMASK3_SHOWNAME_PARTS); }

        bool GetUseShowStems() const { return GetBitFlag(GetMask3(), SFMASK3_SHOWSTEMS); }

        bool GetUseShowTies() const { return GetBitFlag(GetMask2(), SFMASK2_SHOWTIES); }
                
        bool GetUseIndependentFont() const { return GetBitFlag(GetMask1(), SFMASK1_FLOATNOTEHEADFONT); }

        bool GetUseFlatBeams() const { return GetBitFlag(GetMask1(), SFMASK1_FLAT_BEAMS); }

        bool GetUseNotationStyle() const { return GetBitFlag(GetMask1(), SFMASK1_NOTATIONSTYLE); }

        bool GetUseDisplayEmptyRests() const { return GetBitFlag(GetMask1(), SFMASK1_BLANKMEASURE); }

        bool GetUseAllowHiding() const { return GetBitFlag(GetMask1(), SFMASK1_NO_OPTIMIZE); }

        bool GetUseDefaultClef() const { return GetBitFlag(GetMask1(), SFMASK1_DEFAULTCLEF); }

        bool GetUseStafflineAdjustments() const { return GetBitFlag(GetMask1(), SFMASK1_STAFFLINES); }

        bool GetUseTransposition() const { return GetBitFlag(GetMask1(), SFMASK1_TRANSPOSITION); }

        bool GetUseBreakBarlines() const { return GetBitFlag(GetMask1(), SFMASK1_BLINEBREAK); }

        bool GetUseBreakRepeatBarlines() const { return GetBitFlag(GetMask1(), SFMASK1_RBARBREAK); }

        bool GetUseShowTextRepeats() const { return GetBitFlag(GetMask1(), SFMASK1_NEGREPEAT); }

        bool GetUseShowBarlines() const { return GetBitFlag(GetMask1(), SFMASK1_HIDE_BARLINES); }

        bool GetUseFullName() const { return GetBitFlag(GetMask2(), SFMASK2_FULLNAME); }

        bool GetUseAbbreviatedName() const { return GetBitFlag(GetMask2(), SFMASK2_ABBRVNAME); }

        bool GetUseIndependentKeySig() const { return GetBitFlag(GetMask2(), SFMASK2_FLOATKEYS); }

        bool GetUseIndependentTimeSig() const { return GetBitFlag(GetMask2(), SFMASK2_FLOATTIME); }

        bool GetUseHideMode() const { return GetBitFlag(GetMask2(), SFMASK2_HIDESTAFF); }

        bool GetUseIgnoreKeySig() const { return GetBitFlag(GetMask2(), SFMASK2_NOKEY); }

        bool GetUseFullNamePosition() const { return GetBitFlag(GetMask2(), SFMASK2_FULLNAMEPOS); }

        bool GetUseAbbreviatedPosition() const { return GetBitFlag(GetMask2(), SFMASK2_ABBRVNAMEPOS); }

        bool GetUseAltNotationStyle() const { return GetBitFlag(GetMask2(), SFMASK2_ALTNOTATION); }

        bool GetUseShowNoteColors() const { return GetBitFlag(GetMask3(), SFMASK3_SHOW_NOTE_COLORS); }

        bool GetUseShowNoteShapes() const;

        bool GetUseNoKeySigShowAccidentals() const;

        bool GetUseRedisplayOtherLayerAccidentals() const;


    /************************
     *** SETTERS for data ***
     ************************/
    
        void SetCopyable(bool value) { Set16BitFlag((FLAG_16*)_GetSFFlagPtr(), SFFLAG_COPYABLE, value); }

    void SetAddToMenu(bool value) { Set16BitFlag((FLAG_16*) _GetSFFlagPtr(), SFFLAG_ADDTOMENU, value); }
    
    /*************************************
     *** SETTERS for Staff Style usage ***
     *************************************/
    
    void SetUseShowKeySignatures(bool state)
    {
        Set16BitFlag((FLAG_16*) _GetMask2FlagPtr(), SFMASK2_NEGKEY, state);
    }

        void SetUseShowMeasureNumbers(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NEGMNUMB, state);            
        }

        void SetUseShowTimeSignatures(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_NEGTIME, state);
        }

        void SetUseShowClefs(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_NEGCLEF, state);
        }

        void SetUseShowChords(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_HIDE_CHORDS, state);
        }
        
        void SetUseShowAugmentationDots(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_SHOWDOTS, state);
        }
                
        void SetUseShowFretboards(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_HIDE_FRETBOARDS, state);
        }

        void SetUseShowLyrics(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_HIDE_LYRICS, state);
        }

        void SetUseShowRepeats(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_HIDE_RPT_BARS, state);
        }

        void SetUseShowRests(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_SHOWRESTS, state);
        }

        void SetUseShowStaffLines(bool state);

        void SetUseShowScoreStaffNames(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NEGNAME, state);
        }

        void SetUseShowPartStaffNames(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_SHOWNAME_PARTS, state);
        }

        void SetUseShowStems(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_SHOWSTEMS, state);
        }

        void SetUseShowTies(bool state)
        {
                Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_SHOWTIES, state);
        }

        void SetUseIndependentFont(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_FLOATNOTEHEADFONT, state); }

        void SetUseFlatBeams(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_FLAT_BEAMS, state); }

        void SetUseNotationStyle(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NOTATIONSTYLE, state); }

        void SetUseDisplayEmptyRests(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_BLANKMEASURE, state); }

        void SetUseAllowHiding(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NO_OPTIMIZE, state); }

        void SetUseDefaultClef(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_DEFAULTCLEF, state); }

        void SetUseStafflineAdjustments(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_STAFFLINES, state); }

        void SetUseTransposition(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_TRANSPOSITION, state); }

        void SetUseBreakBarlines(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_BLINEBREAK, state); }

        void SetUseBreakRepeatBarlines(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_RBARBREAK, state); }

        void SetUseShowTextRepeats(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_NEGREPEAT, state); }

        void SetUseShowBarlines(bool state) { Set16BitFlag((FLAG_16*)_GetMask1FlagPtr(), SFMASK1_HIDE_BARLINES, state); }

        void SetUseFullName(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_FULLNAME, state); }

        void SetUseAbbreviatedName(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_ABBRVNAME, state); }

        void SetUseIndependentKeySig(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_FLOATKEYS, state); }

        void SetUseIndependentTimeSig(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_FLOATTIME, state); }

        void SetUseHideMode(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_HIDESTAFF, state); }

        void SetUseIgnoreKeySig(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_NOKEY, state); }

        void SetUseFullNamePosition(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_FULLNAMEPOS, state); }

        void SetUseAbbreviatedPosition(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_ABBRVNAMEPOS, state); }

        void SetUseAltNotationStyle(bool state) { Set16BitFlag((FLAG_16*)_GetMask2FlagPtr(), SFMASK2_ALTNOTATION, state); }

        void SetUseShowNoteColors(bool state) { Set16BitFlag((FLAG_16*)_GetMask3FlagPtr(), SFMASK3_SHOW_NOTE_COLORS, state); }

        void SetUseShowNoteShapes(bool state);

        void SetUseNoKeySigShowAccidentals(bool state);

        void SetUseRedisplayOtherLayerAccidentals(bool state);

    /*********************
     *** MISC. METHODS ***
     *********************/
    
    bool IsInstrumentChange();
    
        void GetName(FCString* pString);

    void SetName(FCString* pString);

 
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutBool("Is 2012 Instrument Change: ", IsInstrumentChange());
    }
#endif
};



class FCStaffStyleAssign : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStaffStyleAssign _staffstyleassign;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return ot_EDTStaffStyleAssign; }
    virtual int DataSizeLoad() { return sizeof(EDTStaffStyleAssign); }
    virtual void* Allocate() { return (void*) &_staffstyleassign; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_staffstyleassign, ((FCStaffStyleAssign*)pSource)->_GetStaffStyleAssign(), sizeof(_staffstyleassign));
        _datablock = &_staffstyleassign;
        _loadedsize = sizeof(_staffstyleassign);
    }

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

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

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetStaffStyleAssign() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCStaffStyleAssign() : __FCInciOther()
    {
        memset(&_staffstyleassign, 0, sizeof(_staffstyleassign));
        _datablock = &_staffstyleassign;
        _loadedsize = sizeof(_staffstyleassign);
        _staffstyleassign.range.end.edu = 0x7fffffff;
    }

    twobyte GetStyleID() const { return _staffstyleassign.style; };

    eMeas GetStartMeasure() const { return _staffstyleassign.range.start.meas; };

    TimeEdu32 GetStartMeasurePos() const { return _staffstyleassign.range.start.edu; };

    eMeas GetEndMeasure() const { return _staffstyleassign.range.end.meas; };

    TimeEdu32 GetEndMeasurePos() const { return _staffstyleassign.range.end.edu; };

    void SetStartMeasure(eMeas value) { _staffstyleassign.range.start.meas = value; }

    void SetStartMeasurePos(TimeEdu32 value) { _staffstyleassign.range.start.edu = value; }

    void SetEndMeasure(eMeas value) { _staffstyleassign.range.end.meas = value; }

    void SetEndMeasurePos(TimeEdu32 value) { _staffstyleassign.range.end.edu = value; }

    void SetStyleID(twobyte value) { _staffstyleassign.style = value; }

    eStaff GetStaff() const { return _dataid.other.cmper; };

    void SetEndMeasurePosRight() { SetEndMeasurePos(0x7fffffff); }

    bool IsOverlapping(FCMusicRegion* pRegion)
    {
        if (!pRegion) return false;
        if (GetEndMeasure() < pRegion->GetStartMeasure()) return false;
        if (GetStartMeasure() > pRegion->GetEndMeasure()) return false;
        if (GetEndMeasure() == pRegion->GetStartMeasure())
        {
            if (GetEndMeasurePos() < pRegion->GetStartMeasurePos()) return false;
        }
        if (GetStartMeasure() == pRegion->GetEndMeasure())
        {
            if (GetStartMeasurePos() > pRegion->GetEndMeasurePos()) return false;
        }
        // Horizontally, it's an overlap - check the staff:
        if (pRegion->IsStaffIncluded(GetStaff())) return true;
        return false;
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
        DebugOutDigit("Style ID: ", GetStyleID());
        DebugOutDigit("Start measure: ", GetStartMeasure());
        DebugOutDigit("End measure: ", GetEndMeasure());
    }
#endif
};



class FCMultiMeasureRest : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTMultimeasureRest _mmrest;

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return ot_MultimeasureRest; }
    virtual int DataSizeLoad() { return sizeof(EDTMultimeasureRest); }
    virtual void* Allocate() { return (void*) &_mmrest; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_mmrest, ((FCMultiMeasureRest*)pSource)->_GetMMRest(), sizeof(_mmrest));
        _datablock = &_mmrest;
        _loadedsize = sizeof(_mmrest);
    }

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

    virtual bool LoadFirst()
    {
        Load(0);
        return LoadNext();
    }

    virtual bool SaveNew() { return false; }  // Disabled: Save() has to be used
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCMultiMeasureRest"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_MULTIMEASUREREST; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetMMRest() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCMultiMeasureRest() : __FCNoInciOther()
    {
        memset(&_mmrest, 0, sizeof(_mmrest));
        SetWidth(300);  /* Just to set a width */
        _datablock = &_mmrest;
        _loadedsize = sizeof(_mmrest);
    }

    twobyte GetStartMeasure() const { return _dataid.other.cmper; }

    twobyte GetEndMeasure() const { return _mmrest.stopBefore - 1; }

    twobyte GetWidth() const { return _mmrest.measureWidth; }

    twobyte GetShapeID() const { return _mmrest.shape; }

    bool GetUseSymbols() const
    {
        return GetBitFlag(_mmrest.flag, MMREST_USE_SYMBOLS);
    }

    twobyte GetUseSymbolsLessThan() const
    {
        return _mmrest.symbolMeasures;
    }

    twobyte GetShapeEndAdjust() const { return _mmrest.adjustEndPoint; }

    twobyte GetShapeStartAdjust() const { return _mmrest.adjustStartPoint; }

    twobyte GetSymbolSpace() const { return _mmrest.spaceBetween; }

    twobyte GetStartNumberingAt() const { return _mmrest.startNumbering; }

    twobyte GetNumberHorizontalAdjust() const { return _mmrest.horizNumberAdjust; }

    twobyte GetNumberVerticalAdjust() const { return _mmrest.vertNumberAdjust; }

    twobyte CalcMeasureSpan() { return GetEndMeasure() - GetStartMeasure() + 1; }

    void SetWidth(twobyte value) { _mmrest.measureWidth = value; }

    void SetStartMeasure(twobyte measure) { _dataid.other.cmper = measure; }

    void SetEndMeasure(twobyte measure) { _mmrest.stopBefore = measure + 1; }

    void SetShapeEndAdjust(twobyte value) { _mmrest.adjustEndPoint = value; }

    void SetShapeStartAdjust(twobyte value) { _mmrest.adjustStartPoint = value; }

    void SetShapeID(twobyte shapeID) { _mmrest.shape = shapeID; }


    void SetUseSymbols(bool value)
    {
        Set16BitFlag(&_mmrest.flag, MMREST_USE_SYMBOLS, value);
    }

    void SetUseSymbolsLessThan(twobyte value)
    {
        _mmrest.symbolMeasures = value;
    }

    void SetSymbolSpace(twobyte space) { _mmrest.spaceBetween = space; }

    void SetStartNumberingAt(twobyte value) { _mmrest.startNumbering = value; }

    void SetNumberHorizontalAdjust(twobyte value) { _mmrest.horizNumberAdjust = value; }

    void SetNumberVerticalAdjust(twobyte value) { _mmrest.vertNumberAdjust = value; }

    bool IsMeasureIncluded(int measure)
    {
        if (measure < GetStartMeasure()) return false;
        if (measure > GetEndMeasure()) return false;
        return true;
    }

    bool IsShape()
    {
        if (!GetUseSymbols()) return true;
        if (GetUseSymbolsLessThan() >= CalcMeasureSpan()) return true;
        return false;
    }
    
#ifdef PDK_FRAMEWORK_PREFS

    void PrefsReset();
#endif

    
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Start measure: ", GetStartMeasure());
        DebugOutDigit("End measure: ", GetEndMeasure());
    }
#endif
};

#if FXT_VERSION >= FINALEVERSION_2012

class FCMultiStaffInstrument : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTMultiStaffInstGroup _multistaffinstgroup;

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return otx_MultiStaffInstGroup; }
    virtual int DataSizeLoad() { return sizeof(EDTMultiStaffInstGroup); }
    virtual void* Allocate() { return (void*) &_multistaffinstgroup; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_multistaffinstgroup, ((FCMultiStaffInstrument*)pSource)->_GetMultiStaffInstGroup(), sizeof(_multistaffinstgroup));
        _datablock = &_multistaffinstgroup;
        _loadedsize = sizeof(_multistaffinstgroup);
    }

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

    /*virtual bool LoadFirst()
    {
        Load(0);
        return LoadNext();
    } */
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCMultiStaffInstrument"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_MULTISTAFFINSTRUMENT; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetMultiStaffInstGroup() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCMultiStaffInstrument() : __FCNoInciOther()
    {
        memset(&_multistaffinstgroup, 0, sizeof(_multistaffinstgroup));
    }

    bool ContainsStaff(CMPER staffno)
    {
        if (staffno == 0) return false;
        if (staffno == GetFirstStaff()) return true;
        if (staffno == GetSecondStaff()) return true;
        if (staffno == GetThirdStaff()) return true;
        return false;
    }

    CMPER GetFirstStaff() const { return _multistaffinstgroup.staffNum1; }

    CMPER GetSecondStaff() const { return _multistaffinstgroup.staffNum2; }

    CMPER GetThirdStaff() const { return _multistaffinstgroup.staffNum3; }

    eStaffGroup GetGroupID() const
    {
        return _multistaffinstgroup.staffGroupID;
    }


    void SetFirstStaff(CMPER value) { _multistaffinstgroup.staffNum1 = value; }

    void SetSecondStaff(CMPER value) { _multistaffinstgroup.staffNum2 = value; }

    void SetThirdStaff(CMPER value) { _multistaffinstgroup.staffNum3 = value; }

    void SetGroupID(eStaffGroup value)
    {
        _multistaffinstgroup.staffGroupID = value;
    }
    

    CMPER CalcTopStaff()
    {
        CMPER returnvalue = 0;
        twobyte lowestslot = 10000;
        twobyte slottest = FX_InstToSlot(GetFirstStaff(), 0);
        if (slottest)
        {
            lowestslot = slottest;
            returnvalue = GetFirstStaff();
        }
        slottest = FX_InstToSlot(GetSecondStaff(), 0);
        if ((slottest) && (slottest < lowestslot))
        {
            lowestslot = slottest;
            returnvalue = GetSecondStaff();
        }
        slottest = FX_InstToSlot(GetThirdStaff(), 0);
        if ((slottest) && (slottest < lowestslot))
        {
            returnvalue = GetThirdStaff();
        }
        return returnvalue;
    }

    CMPER CalcBottomStaff()
    {
        CMPER returnvalue = 0;
        twobyte highestslot = -10000;
        twobyte slottest = FX_InstToSlot(GetFirstStaff(), 0);
        if (slottest)
        {
            highestslot = slottest;
            returnvalue = GetFirstStaff();
        }
        slottest = FX_InstToSlot(GetSecondStaff(), 0);
        if ((slottest) && (slottest > highestslot))
        {
            highestslot = slottest;
            returnvalue = GetSecondStaff();
        }
        slottest = FX_InstToSlot(GetThirdStaff(), 0);
        if ((slottest) && (slottest > highestslot))
        {
            returnvalue = GetThirdStaff();
        }
        return returnvalue;
    }


#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("First staff: ", GetFirstStaff());
        DebugOutDigit("Second staff: ", GetSecondStaff());
        DebugOutDigit("Third staff: ", GetThirdStaff());
        DebugOutDigit("Group ID: ", GetGroupID());
    }
#endif
};
#endif // #if FXT_VERSION >= FINALEVERSION_2012


class FCAllotment : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTAllotment _allotment;

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return ot_Allotment; }
    virtual int DataSizeLoad() { return sizeof(EDTAllotment); }
    virtual void* Allocate() { return (void*) &_allotment; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_allotment, ((FCAllotment*)pSource)->_GetAllotment(), sizeof(_allotment));
        _datablock = &_allotment;
        _loadedsize = sizeof(_allotment);
    }

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


    virtual bool LoadFirst()
    {
        CMPER trycmper = 0;   // 0 is used for default allotment
        while (!Load(trycmper))
        {
            if (trycmper > 8192) return false;
            trycmper ++;
        }
        return true;
    }

    virtual bool LoadNext()
    {
        CMPER trycmper = GetItemNo() + 1;
        while (!Load(trycmper))
        {
            if (trycmper > 8192) return false;
            trycmper ++;
        }
        return true;
    }


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

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetAllotment() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCAllotment() : __FCNoInciOther()
    {
        memset(&_allotment, 0, sizeof(_allotment));
        _datablock = &_allotment;
        _loadedsize = sizeof(_allotment);
    }

    void SetWidth(twobyte width)
    {
        _allotment.allotment = width;
    }


    twobyte GetWidth()
    {
        return _allotment.allotment;
    }


#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutDigit("Allotment Width: ", GetWidth());
    }
#endif
};



class FCPageGraphic : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTTGraphic _graphic;

    virtual EXTAG Tag() { return ot_PageGraphic; }
    virtual int DataSizeLoad() { return sizeof(EDTTGraphic); }
    virtual void* Allocate() { return (void*) &_graphic; }

    virtual EVERSION EnigmaVersion() { return FINALEVERSION_2010; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_graphic, ((FCPageGraphic*)pSource)->_GetGraphic(), sizeof(_graphic));
        _datablock = &_graphic;
        _loadedsize = sizeof(_graphic);
    }

    virtual bool LoadFirst()
    {
        SetCmperAndInci(0, 0);
        if (Load(0, 0)) return true; /* 0, 0 is a valid record! */
        return LoadNext();
    }

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

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

public:
    virtual const char* ClassName() { return "FCPageGraphic"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PAGEGRAPHIC; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetGraphic() { return &_graphic; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */


    enum GRAPHIC_HORIZONTAL_ALIGN
    {
        GRAPHICHORIZALIGN_LEFT = 0,
        GRAPHICHORIZALIGN_RIGHT = 1,
        GRAPHICHORIZALIGN_CENTER = 2
    };

    enum GRAPHIC_VERTICAL_ALIGN
    {
        GRAPHICVERTALIGN_TOP = 0,
        GRAPHICVERTALIGN_BOTTOM = 1,
        GRAPHICVERTALIGN_CENTER = 2
    };



    FCPageGraphic() : __FCInciOther()
    {
        memset(&_graphic, 0, sizeof(_graphic));
    }

    bool IsEmbedded()
    {
        return (_graphic.graphicCmper == 0);
    }

    int GetFirstPage() const
    {
        return _graphic.start;
    }

    int GetLastPage() const
    {
        return _graphic.end;
    }
    
    Evpu16 GetHorizontalPos() const
    {
        return _graphic.left;
    }

    Evpu16 GetVerticalPos() const
    {
        return _graphic.bottom;
    }

    Evpu16 GetWidth() const
    {
        return _graphic.width;
    }

    Evpu16 GetHeight() const
    {
        return _graphic.height;
    }

    Evpu16 GetOriginalWidth() const
    {
        return _graphic.origWidth;
    }

    Evpu16 GetOriginalHeight() const
    {
        return _graphic.origHeight;
    }

    bool GetVisible() const { return !GetBitFlag(_graphic.displayFlags, GRAPHIC_DISPLAY_HIDDEN); }

    bool GetPageEdgeRef() const { return GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_PAPER); }
    
    bool GetIndependentRightPage() const { return (_graphic.rightPgAlignFlags != 0); }

    Evpu16 GetHorizontalPosRightPage() const { return _graphic.rightPgLeft; }

    Evpu16 GetVerticalPosRightPage() const { return _graphic.rightPgBottom; }

    bool GetFixedPercent() const { return GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_FIXEDPERC); }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_HORIZONTAL_ALIGN
#else
    int
#endif
    GetHorizontalAlignment() const
    {
        if (GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_LEFT)) return GRAPHICHORIZALIGN_LEFT;
        if (GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_RIGHT)) return GRAPHICHORIZALIGN_RIGHT;
        return GRAPHICHORIZALIGN_CENTER;
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_HORIZONTAL_ALIGN
#else
    int
#endif
    GetHorizontalAlignmentRightPage() const
    {
        if (GetBitFlag(_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_LEFT)) return GRAPHICHORIZALIGN_LEFT;
        if (GetBitFlag(_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_RIGHT)) return GRAPHICHORIZALIGN_RIGHT;
        return GRAPHICHORIZALIGN_CENTER;
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_VERTICAL_ALIGN
#else
    int
#endif
    GetVerticalAlignment() const
    {
        if (GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_TOP)) return GRAPHICVERTALIGN_TOP;
        if (GetBitFlag(_graphic.alignFlags, GRAPHIC_ALIGN_BOTTOM)) return GRAPHICVERTALIGN_BOTTOM;
        return GRAPHICVERTALIGN_CENTER;
    }

    /* SETTERS */
    
    void SetFirstPage(int pageno)
    {
        _graphic.start = pageno;
    }

    void SetLastPage(int pageno)
    {
        _graphic.end = pageno;
    }
    
    void SetHorizontalPos(Evpu16 pos)
    {
        _graphic.left = pos;
        if (!GetIndependentRightPage()) SetHorizontalPosRightPage(pos);
    }

    void SetVerticalPos(Evpu16 pos)
    {
        _graphic.bottom = pos;
        if (!GetIndependentRightPage()) SetVerticalPosRightPage(pos);
    }

    void SetWidth(Evpu16 width)
    {
        _graphic.width = width;
    }
    
    void SetHeight(Evpu16 height)
    {
        _graphic.height = height;
    }

    void SetVisible(bool state)
    {
        Set16BitFlag(&_graphic.displayFlags, GRAPHIC_DISPLAY_HIDDEN, !state);
    }

    void SetPageEdgeRef(bool state)
    {
        Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_MARGINS, !state);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_PAPER, state);
    }
    
    void SetIndependentRightPage(bool state)
    {
        if (GetIndependentRightPage() == state) return;
        /* Copy the alignment */
        if (state)
            _graphic.rightPgAlignFlags = _graphic.alignFlags;
        else
            _graphic.rightPgAlignFlags = 0;
    }

    void SetHorizontalPosRightPage(Evpu16 value)
    {
        _graphic.rightPgLeft = value;
    }

    void SetVerticalPosRightPage(Evpu16 value)
    {
        _graphic.rightPgBottom = value;
    }

    void SetFixedPercent(bool state) { Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_FIXEDPERC, state); }

     void SetHorizontalAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_HORIZONTAL_ALIGN
#else
    FLAG_16
#endif
    alignment
     )
    {
         switch (alignment)
         {
             case GRAPHICHORIZALIGN_LEFT:
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_LEFT, true);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_RIGHT, false);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERH, false);
                 break;
             case GRAPHICHORIZALIGN_RIGHT:
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_LEFT, false);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_RIGHT, true);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERH, false);
                 break;
             default: /* Horizontally centered */
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_LEFT, false);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_RIGHT, false);
                 Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERH, true);
                 break;       
         }
         if (!GetIndependentRightPage()) SetHorizontalAlignmentRightPage(alignment);
    }

     void SetHorizontalAlignmentRightPage(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_HORIZONTAL_ALIGN
#else
    FLAG_16
#endif
     alignment)
    {
         switch (alignment)
         {
             case GRAPHICHORIZALIGN_LEFT:
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_LEFT, true);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_RIGHT, false);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERH, false);
                 break;
             case GRAPHICHORIZALIGN_RIGHT:
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_LEFT, false);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_RIGHT, true);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERH, false);
                 break;
             default: /* Horizontally centered */
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_LEFT, false);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_RIGHT, false);
                 Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERH, true);
                 break;
         }
    }

    void SetVerticalAlignment(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    GRAPHIC_VERTICAL_ALIGN
#else
    int
#endif
    alignment
    )
    {
        /* If GetIndependentRightPage() is ON, copy the vertical alignment
         * there as well (to make sure they are in synch). */
        switch (alignment)
        {
            case GRAPHICVERTALIGN_TOP:
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_TOP, true);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_BOTTOM, false);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERV, false);
                if (GetIndependentRightPage())
                {
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_TOP, true);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_BOTTOM, false);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERV, false);
                }
                break;
            case GRAPHICVERTALIGN_BOTTOM:
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_TOP, false);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_BOTTOM, true);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERV, false);
                if (GetIndependentRightPage())
                {
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_TOP, false);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_BOTTOM, true);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERV, false);
                }
                break;
            default:
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_TOP, false);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_BOTTOM, false);
                Set16BitFlag(&_graphic.alignFlags, GRAPHIC_ALIGN_CENTERV, true);
                if (GetIndependentRightPage())
                {
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_TOP, false);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_BOTTOM, false);
                    Set16BitFlag(&_graphic.rightPgAlignFlags, GRAPHIC_ALIGN_CENTERV, true);
                }
                break;
        }
    }
};



class FCTextRepeatDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTTextRepeatStyle2005 _repeatdef;

protected:
    virtual EXTAG Tag() { return ot_TextRepeatStyle; }
    virtual int DataSizeLoad() { return sizeof(EDTTextRepeatStyle2005); }
    virtual void* Allocate() { return (void*) &_repeatdef; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_repeatdef, ((FCTextRepeatDef*)pSource)->_GetRepeatDef(), sizeof(_repeatdef));
        _datablock = &_repeatdef;
        _loadedsize = sizeof(_repeatdef);
    }


    virtual bool LoadFirst()
    {
        bool returnval = __FCNoInciOther::LoadFirst();
        if (!returnval) return false;
        /* Check that a string exists as well.
         * Otherwise, it might be possible that it returns true
         * even if there are no text repeats at all. */
        FCString* pString = CreateTextString();
        bool stringexists = !pString->IsEmpty();
        delete pString;
        return stringexists;
    }


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

    bool _SaveTextAs(FCString* pString, CMPER itemno);

    bool _DeleteText();

    bool _DeleteEnclosure();
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    enum TEXT_REPEAT_JUSTIFICATION
    {
        TEXTREPJUST_LEFT = TEXT_REPEAT_LEFTJUST,

        TEXTREPJUST_RIGHT = TEXT_REPEAT_RITEJUST,

        TEXTREPJUST_CENTER = TEXT_REPEAT_CENTERED,

        TEXTREPJUST_FULL = TEXT_REPEAT_FULLJUST
    };

    enum REPEAT_REPLACE_MODE
    {
        REPEATREPLACE_TIMESPLAYED = 0,

        REPEATREPLACE_TARGETTEXT,

        REPEATREPLACE_TARGETMEASURE
    };


    virtual const char* ClassName() { return "FCTextRepeatDef"; }
    virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TEXTREPEATDEF; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetRepeatDef() { return &_repeatdef; }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCTextRepeatDef();

    virtual bool DeepSaveAs(CMPER itemno);

    virtual bool DeepDeleteData()
    {
        _DeleteEnclosure();
        _DeleteText();
        return DeleteData();
    }
        
    FCString* CreateTextString();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

     FCString* CreateTextString_GC();
#endif
    
    bool SaveTextString(FCString *pString);

    bool DeepSaveNew(FCString* pString, FCEnclosure* pEnclosure);

    FCEnclosure* CreateEnclosure();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCEnclosure* CreateEnclosure_GC();
#endif

    bool SaveEnclosure(FCEnclosure* pEnclosure);
    
     void GetFontInfo(FCFontInfo* pInfo)
     {
         if (!pInfo) return;
         pInfo->SetNameByID(_repeatdef.font);
         pInfo->SetEnigmaStyles(_repeatdef.efx);
         pInfo->SetSize(_repeatdef.size);
     }

     void SetFontInfo(FCFontInfo* pInfo)
     {         
         if (!pInfo) return;         
         _repeatdef.font = pInfo->GetNameByID();
         _repeatdef.efx = pInfo->GetEnigmaStyles();
         _repeatdef.size = pInfo->GetSize();
     }

     bool GetUseThisFont() const
     {
         return GetBitFlag(_repeatdef.flag, TEXT_REPEAT_USETHISFONT);
     }

     void SetUseThisFont(bool state)
     {
         return Set16BitFlag(&_repeatdef.flag, TEXT_REPEAT_USETHISFONT, state);
     }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     TEXT_REPEAT_JUSTIFICATION
#else
     int 
#endif
     GetJustification() const;

     void SetJustification(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     TEXT_REPEAT_JUSTIFICATION
#else
     int
#endif
     value
     );

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     REPEAT_REPLACE_MODE
#else
     int
#endif
     GetReplaceMode() const;

     
    void SetReplaceMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
     REPEAT_REPLACE_MODE
#else
     int
#endif
    value
    );


#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
    }
#endif

};


class FCSeparatePlacements;

class FCTextRepeat : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTTextRepeat2005 _textrepeat;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return ot_TextRepeat2005; }
    virtual int DataSizeLoad() { return sizeof(EDTTextRepeat2005); }
    virtual void* Allocate() { return (void*) &_textrepeat; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_textrepeat, ((FCTextRepeat*)pSource)->_GetTextRepeat(), sizeof(_textrepeat));
        _datablock = &_textrepeat;
        _loadedsize = sizeof(_textrepeat);
    }

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

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

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetTextRepeat() { return &_textrepeat; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    enum REPSHOWMODES
    {
        REPSHOW_ALL = 0,

        REPSHOW_TOPSTAFF,

        REPSHOW_STAFFLIST
    };

    enum REPTARGETTRIGGERS
    {   
        REPTARGET_UNDEFINED = 0,

        REPTARGET_DEFID = 3,

        REPTARGET_MEASURENUM = 1,

        REPTARGET_BACKWARDS = 2,

        REPTARGET_NEVERSKIPENDING = 5,

        REPTARGET_FORWARDS = 8,

        REPTARGET_NEXTENDING = 9
    };
       

    enum REPACTIONS
     {
        REPACTION_NEVERJUMP = 0,

        REPACTION_ALWAYSJUMP = 1,

        REPACTION_JUMPONPASS = 2,

        REPACTION_PLAYSECTION = 3,

        REPACTION_STOPONPASS = 4
     };

    FCTextRepeat() : __FCInciOther()
    {
        memset(&_textrepeat, 0, sizeof(_textrepeat));
        _datablock = &_textrepeat;
        _loadedsize = sizeof(_textrepeat);
    }

    bool AssignTextRepeatDef(FCTextRepeatDef* pDef);


    FCTextRepeatDef* CreateTextRepeatDef();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCTextRepeatDef* CreateTextRepeatDef_GC();
#endif

    FCSeparatePlacements* CreateSeparatePlacements();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCSeparatePlacements* CreateSeparatePlacements_GC();
#endif

    twobyte GetID() const { return _textrepeat.repnum; }

    void SetID(twobyte id) { _textrepeat.repnum = id; }

    Evpu16 GetHorizontalPos() const { return _textrepeat.horzPos; }

    void SetHorizontalPos(Evpu32 value) { _textrepeat.horzPos = value; }

    Evpu16 GetVerticalPos() const { return _textrepeat.vertPos; }

    void SetVerticalPos(Evpu32 value) { _textrepeat.vertPos = value; }

    int GetTarget() const { return _textrepeat.target; }

    void SetTarget(int value) { _textrepeat.target = value; }

    bool GetAutoUpdateTarget() const { return GetBitFlag(_textrepeat.flag, TXTRPT_AUTOUPDATE); }

    void SetAutoUpdateTarget(bool state) { Set16BitFlag(&_textrepeat.flag, TXTRPT_AUTOUPDATE, state); }

    bool GetIndividualPositioning() const { return GetBitFlag(_textrepeat.flag, TXTRPT_INDIVPLAC); }

    void SetIndividualPositioning(bool state) { Set16BitFlag(&_textrepeat.flag, TXTRPT_INDIVPLAC, state); }


#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPSHOWMODES
#else
    int
#endif
    GetShowMode() const;

    void SetShowMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPSHOWMODES
#else
    int
#endif
    mode);

    twobyte GetStaffListID() const {  return _textrepeat.staffList; }

    void SetStaffListID(twobyte list)
    {
        if (list < 0) return;
        _textrepeat.staffList = list;
        Set16BitFlag(&_textrepeat.flag, TXTRPT_TOPSTAFFONLY, false);
    }

    twobyte GetTotalPasses() const {  return _textrepeat.actuate; }

    void SetTotalPasses(twobyte totalpasses)
    {        
        _textrepeat.actuate = totalpasses;
    }


    bool GetJumpIfIgnore() const { return GetBitFlag(_textrepeat.flag, TXTRPT_JMPIGNORE); }

    void SetJumpIfIgnore(bool state) { Set16BitFlag(&_textrepeat.flag, TXTRPT_JMPIGNORE, state); }


    bool GetResetOnRepeat() const { return GetBitFlag(_textrepeat.flag, TXTRPT_CLRonCHANGE); }

    void SetResetOnRepeat(bool state) { Set16BitFlag(&_textrepeat.flag, TXTRPT_CLRonCHANGE, state); }


#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPTARGETTRIGGERS
#else
    int
#endif
    GetTargetTrigger() const;

    void SetTargetTrigger(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPTARGETTRIGGERS
#else
    int
#endif
    mode);



#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPACTIONS
#else
    int
#endif
    GetAction() const;

    void SetAction(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    REPACTIONS
#else
    int
#endif
    mode);



#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
        DebugOutHex("FCTextRepeat:flag: ", _textrepeat.flag);
    }
#endif
};


class FCExecutableShapeDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTExecutableShapeDef _executableshapedef;

protected:
    virtual EXTAG Tag() { return ot_ExecutableShapeDef; }
    virtual int DataSizeLoad() { return sizeof(EDTExecutableShapeDef); }
    virtual void* Allocate() { return (void*) &_executableshapedef; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_executableshapedef, ((FCExecutableShapeDef*)pSource)->_GetExecutableShapeDef(), sizeof(_executableshapedef));
        _datablock = &_executableshapedef;
        _loadedsize = sizeof(_executableshapedef);
    }

    virtual bool LoadNext()
    {
        EDataID olddataID = _dataid;
        _dataid.other.cmper ++;
        if (LoadDataBlock()) return true;
        _dataid = olddataID;
        return false;
    }

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

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

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetExecutableShapeDef() { return &_executableshapedef; }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCExecutableShapeDef() : __FCNoInciOther() {}

    twobyte GetShapeID() { return _executableshapedef.shapeID; }

    void SetShapeID(twobyte shapeID) { _executableshapedef.shapeID = shapeID; }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
    }
#endif

};


class FCChordSuffixElement : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTChordSuffix _chordsuffixold;
#if FXT_VERSION >= FINALEVERSION_2012
    EDTChordSuffix2012 _chordsuffix2012;
#endif
protected:
    bool _Use2012Version() const;

    virtual EXTAG Tag() { return ot_ChordSuffix; }
    virtual int DataSizeLoad() 
    {        
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return sizeof(EDTChordSuffix2012);
#endif     
        return sizeof(EDTChordSuffix);
    }
    virtual void* Allocate()
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return (void*) &_chordsuffix2012;
#endif
        return (void*) &_chordsuffixold;
    }
    virtual EVERSION EnigmaVersion() 
    {
        if (_Use2012Version()) return FINALEVERSION_2012;
        return FINALEVERSION_2010;
    }

    virtual void CloneMemoryFrom(__FCBaseData* pSource);

    virtual __FCBaseData* CreateObject() { return new FCChordSuffixElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCChordSuffixElement"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CHORDSUFFIXELEMENT; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetDataPtr() 
    {
#if FXT_VERSION >= FINALEVERSION_2012
        if (_Use2012Version()) return &_chordsuffix2012;
#endif
        return &_chordsuffixold;
    }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCChordSuffixElement();

    void GetFontInfo(FCFontInfo* pFontInfo);

    void SetFontInfo(FCFontInfo* pFontInfo);

    eUniChar32 GetSymbol() const;

    void SetSymbol(eUniChar32 symbol);

    bool GetNumberRepresentation() const;

    void SetNumberRepresentation(bool state);

    bool GetPrefixFlat() const;

    void SetPrefixFlat(bool state);

    bool GetPrefixSharp() const;

    void SetPrefixSharp(bool state);

    bool GetPrefixPlus() const;

    void SetPrefixPlus(bool state);

    bool GetPrefixMinus() const;

    void SetPrefixMinus(bool state);

    twobyte GetHorizontalOffset() const;

    void SetHorizontalOffset(twobyte value);

    twobyte GetVerticalOffset() const;

    void SetVerticalOffset(twobyte value);
        
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
    }
#endif
};


#if FXT_VERSION >= FINALEVERSION_2012

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

/* MAKEEXTAG(edOther, 'f','t') doesn't work correctly. */

const EXTAG __ot_FRETSTYLE = MAKEEXTAG(MAKETAG(edMultiInciOther,13), 'f','t');

const int __MAX_FRET_NAME_LEN   = 47;   // Max number of characters of names of
const int __MAX_FRET_NUM_TEXT_LEN = 23;

#include "pragma_align_begin.h"
struct __FCFretStyle    // ot_FRETSTYLE (1 logical incidences, 14 physical incidences (0..13))
                                        // cmper comes from EDTChord2010::fbStyleID
{
        // start of physical incident 0 (0 based)
        tbool           showLastFret;                   // Show the last fret when drawing fretboards
        tbool           rotate;                                 // Rotate the diagram so the nut is on the left
        tbool           fingNumWhite;                   // Draw fingering numbers white.

        // CMPERs of the various shapes that can be drawn on the fretboard diagram. When these
        // are zero, the hardcoded shapes will be used. (Hardcoded shapes are designed to look
        // like the Seville Font.)

        eShape          fingStrShapeID;                 // ID of ot_SHAPEDEF record used for drawing
                                                                                // a fingered (closed) string shape
        eShape          openStrShapeID;                 // ID of ot_SHAPEDEF record used for drawing
                                                                                // an open string shape
        eShape          muteStrShapeID;                 // ID of ot_SHAPEDEF record used for drawing
                                                                                // a muted string shape
        // start of physical incident 1 (0 based)
        eShape          barreShapeID;                   // ID of ot_SHAPEDEF record used for drawing
                                                                                // the fretboard barre shape
        eShape          customShapeID;                  // ID of the ot_SHAPEDEF record used for
                                                                                // drawing the user defined shape
        utwobyte        defNumFrets;                    // The number of frets to show by default in this style

        // Following are the high and low twobyte fields that, together, designate various
        // Efix32 values for the fretboard style.

        twobyte         stringGapHi;                    // High and low twobyte values for
        twobyte         stringGapLo;                    // Efix32 string gap (right edge to right edge)

        twobyte         fretGapHi;                              // High and low twobyte values for
        // start of physical incident 2 (0 based)
        twobyte         fretGapLo;                              // Efix32 fret gap (bottom edge to bottom edge)

        twobyte         stringWidthHi;                  // High and low twobyte values for
        twobyte         stringWidthLo;                  // Efix32 width of strings

        twobyte         fretWidthHi;                    // High and low twobyte values for
        twobyte         fretWidthLo;                    // Efix32 width of frets

        twobyte         nutWidthHi;                             // High and low twobyte values for
        // start of physical incident 3 (0 based)
        twobyte         nutWidthLo;                             // Efix32 width of the nut

        twobyte         vertTextOffHi;                  // High and low twobyte values for
        twobyte         vertTextOffLo;                  // Efix32 vert offset of fret number text

        twobyte         horzTextOffHi;                  // High and low twobyte values for
        twobyte         horzTextOffLo;                  // Efix32 horz offset of fret number text

        twobyte         horzHandleOffHi;                // High and low twobyte values for
        // start of physical incident 4 (0 based)
        twobyte         horzHandleOffLo;                // Efix32 horz offset of the fretboard's handle

        twobyte         vertHandleOffHi;                // High and low twobyte values for
        twobyte         vertHandleOffLo;                // Efix32 vert offset of the fretboard's handle

        twobyte         whiteoutHi;                             // High and low twobyte values for
        twobyte         whiteoutLo;                             // Efix32 whiteout of strings for fingering numbers

        // Font information

        EFONTID         fretNumFontID;                  // Font ID, size and EFX data for the
        // start of physical incident 5 (0 based)
        PsPoint16       fretNumFontSize;                // fret number font. (Designates which
        FLAG_16         fretNumFontEfx;                 // fret is the first shown in the diagram

        EFONTID         fingNumFontID;                  // Font ID, size and EFX data for the
        PsPoint16       fingNumFontSize;                // fingering numbers font used in the.
        FLAG_16         fingNumFontEfx;                 // fretboard diagrams

        // Fingering number offsets
        twobyte         horzFingNumOffHi;               // High and low twobyte values for
        // start of physical incident 6 (0 based)
        twobyte         horzFingNumOffLo;               // Efix32 horizontal finger number offset

        twobyte         vertFingNumOffHi;               // High and low twobyte values for
        twobyte         vertFingNumOffLo;               // Efix32 vertical finger number offset

        twobyte         pad[3];                                 // Unused--padding to make size mult of OTSIZE

        // start of physical incident 7 (0 based)
        ECHAR           name[__MAX_FRET_NAME_LEN + 1];  // The name of the fretboard style

        ECHAR           fretNumText[__MAX_FRET_NUM_TEXT_LEN + 1];
                                                                                                // The text to display after the
                                                                                                // fret number (e.g., 'fr' or 'fret')
        // end of physical incident 13 (0 based)
};
#include "pragma_align_end.h"

#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */


class FCFretboardStyleDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        /* The data storage for the object. */
        __FCFretStyle _fretstyledef;

protected:
        virtual EXTAG Tag() { return __ot_FRETSTYLE; }
        virtual int DataSizeLoad() { return sizeof(__FCFretStyle); }
        virtual void* Allocate() { return (void*)&_fretstyledef; }
        virtual EVERSION EnigmaVersion() { return FINALEVERSION_2010; }

        virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_fretstyledef, ((FCFretboardStyleDef*)pSource)->_GetFretStyleDef(), sizeof(_fretstyledef));
        _datablock = &_fretstyledef;
        _loadedsize = sizeof(_fretstyledef);
    }

        virtual bool LoadNext()
        {
                EDataID olddataID = _dataid;
                _dataid.other.cmper++;
                if (LoadDataBlock()) return true;
                _dataid = olddataID;
                return false;
        }

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

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

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

        void* _GetFretStyleDef() { return &_fretstyledef; }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

        FCFretboardStyleDef() : __FCNoInciOther()
    {
        memset(&_fretstyledef, 0, sizeof(_fretstyledef));
        _datablock = &_fretstyledef;
        _loadedsize = sizeof(_fretstyledef);
    }
        
    // *******
    // GETTERS
    // *******
    
        void GetName(FCString* pString)
    {
        if (!pString) return;
        pString->SetCString(_fretstyledef.name);
    }

        Efix32 GetStringSpacing() const { return MAKELONG(_fretstyledef.stringGapLo, _fretstyledef.stringGapHi); }

        Efix32 GetStringThickness() const { return MAKELONG(_fretstyledef.stringWidthLo, _fretstyledef.stringWidthHi); }

        Efix32 GetFretSpacing() const { return MAKELONG(_fretstyledef.fretGapLo, _fretstyledef.fretGapHi); }

        Efix32 GetFretThickness() const { return MAKELONG(_fretstyledef.fretWidthLo, _fretstyledef.fretWidthHi); }

        Efix32 GetNutThickness() const { return MAKELONG(_fretstyledef.nutWidthLo, _fretstyledef.nutWidthHi); }

        Efix32 GetHorizontalFingeringOffset() const { return MAKELONG(_fretstyledef.horzFingNumOffLo, _fretstyledef.horzFingNumOffHi); }

        Efix32 GetVerticalFingeringOffset() const { return MAKELONG(_fretstyledef.vertFingNumOffLo, _fretstyledef.vertFingNumOffHi); }

        Efix32 GetFingeringWhiteout() const { return MAKELONG(_fretstyledef.whiteoutLo, _fretstyledef.whiteoutHi); }

        Efix32 GetHorizontalHandleOffset() const { return MAKELONG(_fretstyledef.horzHandleOffLo, _fretstyledef.horzHandleOffHi); }

        Efix32 GetVerticalHandleOffset() const { return MAKELONG(_fretstyledef.vertHandleOffLo, _fretstyledef.vertHandleOffHi); }

        void GetFretNumberText(FCString* pString) 
        {
                if (!pString) return;
                pString->SetCString(_fretstyledef.fretNumText);
        }

        Efix32 GetHorizontalFretNumberOffset() const { return MAKELONG(_fretstyledef.horzTextOffLo, _fretstyledef.horzTextOffHi); }

        Efix32 GetVerticalFretNumberOffset() const { return MAKELONG(_fretstyledef.vertTextOffLo, _fretstyledef.vertTextOffHi); }

        int GetFretCountDefault() const { return _fretstyledef.defNumFrets; }

        bool GetShowLastFret() const { return _fretstyledef.showLastFret != 0; }
        
        bool GetRotate() const { return _fretstyledef.rotate != 0;  }   

        bool GetDrawFingeringWhite() const { return _fretstyledef.fingNumWhite != 0; }

    twobyte GetFingeredShapeID() const
    {
        return _fretstyledef.fingStrShapeID;
    }

    twobyte GetOpenStringShapeID() const
    {
        return _fretstyledef.openStrShapeID;
    }

    twobyte GetMuteStringShapeID() const
    {
        return _fretstyledef.muteStrShapeID;
    }

    twobyte GetBarreShapeID() const
    {
        return _fretstyledef.barreShapeID;
    }

    twobyte GetCustomShapeID() const
    {
        return _fretstyledef.customShapeID;
    }

        void GetFingeringFontInfo(FCFontInfo* pFontInfo)
        {
                if (!pFontInfo) return;
                pFontInfo->SetNameByID(_fretstyledef.fingNumFontID);
                pFontInfo->SetSize(_fretstyledef.fingNumFontSize);
                pFontInfo->SetEnigmaStyles(_fretstyledef.fingNumFontEfx);
        }

        void GetFretNumberFontInfo(FCFontInfo* pFontInfo)
        {
                if (!pFontInfo) return;
                pFontInfo->SetNameByID(_fretstyledef.fretNumFontID);
                pFontInfo->SetSize(_fretstyledef.fretNumFontSize);
                pFontInfo->SetEnigmaStyles(_fretstyledef.fretNumFontEfx);
        }

    // *******
    // SETTERS
    // *******
    
        void SetName(FCString* pString)
    {
        if (!pString) return;
        memset(&_fretstyledef.name, 0, __MAX_FRET_NAME_LEN + 1);
        strncpy(_fretstyledef.name, pString->GetCString(), __MAX_FRET_NAME_LEN);
    }
    
        void SetStringSpacing(Efix32 value)
    {
        _fretstyledef.stringGapLo = LOWORD(value);
        _fretstyledef.stringGapHi = HIWORD(value);
    }
    
        void SetStringThickness(Efix32 value)
    {
        _fretstyledef.stringWidthLo = LOWORD(value);
        _fretstyledef.stringWidthHi = HIWORD(value);
    }
    
        void SetFretSpacing(Efix32 value)
    {
        _fretstyledef.fretGapLo = LOWORD(value);
        _fretstyledef.fretGapHi = HIWORD(value);
    }
    
        void SetFretThickness(Efix32 value)
    {
        _fretstyledef.fretWidthLo = LOWORD(value);
        _fretstyledef.fretWidthHi = HIWORD(value);
    }
    
        void SetNutThickness(Efix32 value)
    {
        _fretstyledef.nutWidthLo = LOWORD(value);
        _fretstyledef.nutWidthHi = HIWORD(value);
    }
    
        void SetHorizontalFingeringOffset(Efix32 value)
    {
        _fretstyledef.horzFingNumOffLo = LOWORD(value);
        _fretstyledef.horzFingNumOffHi = HIWORD(value);
    }
    
        void SetVerticalFingeringOffset(Efix32 value)
    {
        _fretstyledef.vertFingNumOffLo = LOWORD(value);
        _fretstyledef.vertFingNumOffHi = HIWORD(value);
    }
    
        void SetFingeringWhiteout(Efix32 value)
    {
        _fretstyledef.whiteoutLo = LOWORD(value);
        _fretstyledef.whiteoutHi = HIWORD(value);
    }
    
        void SetHorizontalHandleOffset(Efix32 value)
    {
        _fretstyledef.horzHandleOffLo = LOWORD(value);
        _fretstyledef.horzHandleOffHi = HIWORD(value);
    }
    
        void SetVerticalHandleOffset(Efix32 value)
    {
        _fretstyledef.vertHandleOffLo = LOWORD(value);
        _fretstyledef.vertHandleOffHi = HIWORD(value);
    }
    
        void SetFretNumberText(FCString* pString)
        {
                if (!pString) return;
        memset(&_fretstyledef.fretNumText, 0, __MAX_FRET_NUM_TEXT_LEN + 1);
        strncpy(_fretstyledef.fretNumText, pString->GetCString(), __MAX_FRET_NUM_TEXT_LEN);
        }
    
        void SetHorizontalFretNumberOffset(Efix32 value)
    {
        _fretstyledef.horzTextOffLo = LOWORD(value);
        _fretstyledef.horzTextOffHi = HIWORD(value);
    }
    
        void SetVerticalFretNumberOffset(Efix32 value)
    {
        _fretstyledef.vertTextOffLo = LOWORD(value);
        _fretstyledef.vertTextOffHi = HIWORD(value);
    }
    
        void SetFretCountDefault(int value) { _fretstyledef.defNumFrets = value; }
    
        void SetShowLastFret(bool state) { _fretstyledef.showLastFret = state; }
        
        void SetRotate(bool state) { _fretstyledef.rotate = state;  }
    
        void SetDrawFingeringWhite(bool state) { _fretstyledef.fingNumWhite = state; }

    void SetFingeredShapeID(twobyte value)
    {
        _fretstyledef.fingStrShapeID = value;
    }

    void SetOpenStringShapeID(twobyte value)
    {
        _fretstyledef.openStrShapeID = value;
    }

    void SetMuteStringShapeID(twobyte value)
    {
        _fretstyledef.muteStrShapeID = value;
    }

    void SetBarreShapeID(twobyte value)
    {
        _fretstyledef.barreShapeID = value;
    }

    void SetCustomShapeID(twobyte value)
    {
        _fretstyledef.customShapeID = value;
    }

        void SetFingeringFontInfo(FCFontInfo* pFontInfo)
        {
                if (!pFontInfo) return;
                _fretstyledef.fingNumFontID = pFontInfo->GetNameByID();
                _fretstyledef.fingNumFontSize = pFontInfo->GetSize();
                _fretstyledef.fingNumFontEfx = pFontInfo->GetEnigmaStyles();
        }
    
        void SetFretNumberFontInfo(FCFontInfo* pFontInfo)
        {
                if (!pFontInfo) return;
                _fretstyledef.fretNumFontID = pFontInfo->GetNameByID();
                _fretstyledef.fretNumFontSize = pFontInfo->GetSize();
                _fretstyledef.fretNumFontEfx = pFontInfo->GetEnigmaStyles();
        }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
    }
#endif

};

#endif


#if FXT_VERSION >= FINALEVERSION_2012

class FCFretboardGroupDef : public __FCInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    private:
    EDTFretGroup2012 _fretgroup;

protected:
    virtual EXTAG Tag() { return otx_FretGroup; }
    virtual int DataSizeLoad() { return sizeof(EDTFretGroup2012); }
    virtual void* Allocate() { return (void*) &_fretgroup; }
    virtual EVERSION EnigmaVersion() { return FINALEVERSION_2012; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_fretgroup, ((FCFretboardGroupDef*)pSource)->_GetDataPtr(), sizeof(_fretgroup));
        _datablock = &_fretgroup;
        _loadedsize = sizeof(_fretgroup);
    }

    virtual __FCBaseData* CreateObject() { return new FCFretboardGroupDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCFretboardGroupDef"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_FRETBOARDGROUPDEF; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetDataPtr() { return &_fretgroup; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCFretboardGroupDef() : __FCInciOther() {}

    virtual bool LoadFirst()
    {
        return Load(1, 0);
    }

    twobyte _GetInci() { return _dataid.other.inci; }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
    }
#endif
};

#endif



class FCEndingRepeat : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    /* Data is dynamically stored! */

protected:
    virtual EXTAG Tag() { return ot_EndingRepeat; }

    void _AllocateMemory(int size);

    virtual int DataSizeLoad();
    virtual int DataSizeSave();
    virtual void* Allocate();
    virtual void Deallocate();
    virtual bool IsDynamicSize() { return true; }
    
    virtual __FCBaseData* CreateObject() { return new FCEndingRepeat(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    virtual const char* ClassName() { return "FCEndingRepeat"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_ENDINGREPEAT; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTEndingRepeat2005* _TypeCast() const { return (EDTEndingRepeat2005*) _datablock; }     
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCEndingRepeat() : __FCNoInciOther()
    {
        _AllocateMemory(sizeof(EDTEndingRepeat2005));
    }

    virtual bool DeepDeleteData();

    virtual bool DeepSaveAs(CMPER itemno);
    
    twobyte GetStaffListID() const {  return _TypeCast()->staffList; }

    bool GetSkipOnIgnore() const
    {
        return GetBitFlag(_TypeCast()->flag, EndRepeat_JMPIGNORE);
    }

    eMeas GetTargetMeasure() const
    {
        return _TypeCast()->nextend;
    }

    bool GetIndividualPositioning() const
    {
        return GetBitFlag(_TypeCast()->flag, EndRepeat_INDIVPLAC);
    }

    Evpu16 GetVerticalTopBracketPosition() const
    {
        return _TypeCast()->line2;
    }

    Evpu16 GetHorizontalLeftBracketPosition() const
    {
        return _TypeCast()->pos;
    }
    
    Evpu16 GetVerticalLeftBracketPosition() const
    {
        return _TypeCast()->line;
    }

    Evpu16 GetHorizontalRightBracketPosition() const
    {
        return _TypeCast()->pos2;
    }
    
    Evpu16 GetVerticalRightBracketPosition() const
    {
        return _TypeCast()->endline;
    }
    
    Evpu16 GetHorizontalTextPosition() const
    {
        return _TypeCast()->textpos;
    }

    Evpu16 GetVerticalTextPosition() const
    {
        return _TypeCast()->textline;
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPSHOWMODES
#else
    int
#endif
    GetShowMode() const;
    
    int GetPassNumbersCount() const { return _TypeCast()->numTotalPasses; }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
FCTextRepeat::REPTARGETTRIGGERS
#else
int
#endif
    GetTargetTrigger() const
    {
        switch (_TypeCast()->flag & EndRepeat_ACTION_BITS)
        {
            case 0:
                return FCTextRepeat::REPTARGET_NEXTENDING;
            case 0x10:
                return FCTextRepeat::REPTARGET_MEASURENUM;
            case 0x20:
                return FCTextRepeat::REPTARGET_FORWARDS;
            case 0x50:
                return FCTextRepeat::REPTARGET_NEVERSKIPENDING;
            default:
                return FCTextRepeat::REPTARGET_UNDEFINED;
        }
    }

    void SetStaffListID(twobyte list)
    {
        if (list < 0) return;
        _TypeCast()->staffList = list;
        Set16BitFlag(&_TypeCast()->flag, EndRepeat_TOPSTAFFONLY, false);
    }
    
    void SetSkipOnIgnore(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, EndRepeat_JMPIGNORE, state);
    }

    void SetTargetMeasure(eMeas measure)
    {
        _TypeCast()->nextend = measure;
    }

    void SetIndividualPositioning(bool state)
    {
        Set16BitFlag(&_TypeCast()->flag, EndRepeat_INDIVPLAC, state);
    }

    void SetVerticalTopBracketPosition(Evpu16 position)
    {
        _TypeCast()->line2 = position;
    }

    void SetHorizontalLeftBracketPosition(Evpu16 position)
    {
        _TypeCast()->pos = position;
    }
    
    void SetVerticalLeftBracketPosition(Evpu16 position)
    {
        _TypeCast()->line = position;
    }

    void SetHorizontalRightBracketPosition(Evpu16 position)
    {
        _TypeCast()->pos2 = position;
    }
    
    void SetVerticalRightBracketPosition(Evpu16 position)
    {
        _TypeCast()->endline = position;
    }

    void SetHorizontalTextPosition(Evpu16 position)
    {
        _TypeCast()->textpos = position;
    }
    
    void SetVerticalTextPosition(Evpu16 position)
    {
        _TypeCast()->textline = position;
    }

   
    void SetShowMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPSHOWMODES
#else
    int
#endif
    mode);
    
    
    FCString* CreateTextString();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateTextString_GC();
#endif
    
    bool SaveTextString(FCString* pString);

    bool GetPassNumbers(FCNumbers* pNumbers);

    bool SetPassNumbers(FCNumbers* pNumbers);

    void SetTargetTrigger(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
FCTextRepeat::REPTARGETTRIGGERS
#else
int
#endif
    value
    )
    {
        switch (value)
        {
            case FCTextRepeat::REPTARGET_MEASURENUM:
                _TypeCast()->flag &= ~EndRepeat_ACTION_BITS;
                _TypeCast()->flag |= 0x10;
                break;
            case FCTextRepeat::REPTARGET_FORWARDS:
                _TypeCast()->flag &= ~EndRepeat_ACTION_BITS;
                _TypeCast()->flag |= 0x20;
                break;
            case FCTextRepeat::REPTARGET_NEVERSKIPENDING:
                _TypeCast()->flag &= ~EndRepeat_ACTION_BITS;
                _TypeCast()->flag |= 0x50;
                break;
            case FCTextRepeat::REPTARGET_NEXTENDING:
                _TypeCast()->flag &= ~EndRepeat_ACTION_BITS;
                break;
                        case FCTextRepeat::REPTARGET_UNDEFINED:
                        case FCTextRepeat::REPTARGET_DEFID:
                        case FCTextRepeat::REPTARGET_BACKWARDS:
                                break;
       }
    }


    FCSeparatePlacements* CreateSeparatePlacements();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCSeparatePlacements* CreateSeparatePlacements_GC();
#endif

    FCSeparatePlacements* CreateTextSeparatePlacements();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCSeparatePlacements* CreateTextSeparatePlacements_GC();
#endif
};


class FCBackwardRepeat : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS     

    EDTBackwardRepeat2005 _backwardrepeat;

protected:
    virtual EXTAG Tag() { return ot_BackwardRepeat; }
    virtual int DataSizeLoad() { return sizeof(EDTBackwardRepeat2005); }
    virtual void* Allocate() { return (void*) &_backwardrepeat; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_backwardrepeat, ((FCBackwardRepeat*)pSource)->_GetBackwardRepeat(), sizeof(_backwardrepeat));
        _datablock = &_backwardrepeat;
        _loadedsize = sizeof(_backwardrepeat);
    }

    virtual __FCBaseData* CreateObject() { return new FCBackwardRepeat(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    virtual const char* ClassName() { return "FCBackwardRepeat"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_BACKWARDREPEAT; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetBackwardRepeat() { return &_backwardrepeat; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCBackwardRepeat() : __FCNoInciOther()
    {
        memset(&_backwardrepeat, 0, sizeof(_backwardrepeat));
        _datablock = &_backwardrepeat;
        _loadedsize = sizeof(_backwardrepeat);
    }


    eMeas GetTargetMeasure() const
    {
        return _backwardrepeat.target;
    }

    bool GetIndividualPositioning() const
    {
        return GetBitFlag(_backwardrepeat.flag, BackRepeat_INDIVPLAC);
    }

    twobyte GetTotalPasses() const
    {
        return _backwardrepeat.actuate;
    }

    Evpu16 GetTopBracketPosition() const
    {
        return _backwardrepeat.line2;
    }

    Evpu16 GetBottomBracketPosition() const
    {
        return _backwardrepeat.line1;
    }

    Evpu16 GetRightBracketPosition() const
    {
        return _backwardrepeat.pos1;
    }

    Evpu16 GetLeftBracketPosition() const
    {
        return _backwardrepeat.pos2;
    }

    twobyte GetStaffListID() const
    {
        return _backwardrepeat.staffList;
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPSHOWMODES
#else
    int
#endif
    GetShowMode() const
    {
        if (GetBitFlag(_backwardrepeat.flag, BackRepeat_TOPSTAFFONLY)) return FCTextRepeat::REPSHOW_TOPSTAFF;
        if (_backwardrepeat.staffList) return FCTextRepeat::REPSHOW_STAFFLIST;
        return FCTextRepeat::REPSHOW_ALL;
    }

    void SetShowMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPSHOWMODES
#else
    int
#endif
    mode)
    {
        switch (mode)
        {
            case FCTextRepeat::REPSHOW_TOPSTAFF:
                Set16BitFlag(&_backwardrepeat.flag, BackRepeat_TOPSTAFFONLY, true);
                _backwardrepeat.staffList = 0;
                break;
            case FCTextRepeat::REPSHOW_STAFFLIST:
                Set16BitFlag(&_backwardrepeat.flag, BackRepeat_TOPSTAFFONLY, false);
                if (!_backwardrepeat.staffList) _backwardrepeat.staffList = 1;
                break;
            case FCTextRepeat::REPSHOW_ALL:
                Set16BitFlag(&_backwardrepeat.flag, BackRepeat_TOPSTAFFONLY, false);
                _backwardrepeat.staffList = 0;
                break;
        }
    }


    void SetTargetMeasure(eMeas measure)
    {
        _backwardrepeat.target = measure;
    }

    void SetIndividualPositioning(bool state)
    {
        return Set16BitFlag(&_backwardrepeat.flag, BackRepeat_INDIVPLAC, state);
    }

    void SetTotalPasses(twobyte passes)
    {
        _backwardrepeat.actuate = passes;
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
FCTextRepeat::REPTARGETTRIGGERS
#else
int
#endif
    GetTargetTrigger() const
    {        
        switch (_backwardrepeat.flag & BackRepeat_ACTION_BITS)
        {
            case 0:
                return FCTextRepeat::REPTARGET_NEXTENDING;
            case 0x10:
                return FCTextRepeat::REPTARGET_MEASURENUM;
            case 0x20:
                return FCTextRepeat::REPTARGET_FORWARDS;
            default:
                return FCTextRepeat::REPTARGET_UNDEFINED;
        }
    }

    bool GetResetOnRepeatAction() const
    {
        return GetBitFlag(_backwardrepeat.flag, BackRepeat_CLRonCHANGE);
    }

    void SetTopBracketPosition(Evpu16 position)
    {
        _backwardrepeat.line2 = position;
    }

    void SetBottomBracketPosition(Evpu16 position)
    {
        _backwardrepeat.line1 = position;
    }

    void SetRightBracketPosition(Evpu16 position)
    {
        _backwardrepeat.pos1 = position;
    }

    void SetLeftBracketPosition(Evpu16 position)
    {
        _backwardrepeat.pos2 = position;
    }

    void SetStaffListID(twobyte stafflistid)
    {
        _backwardrepeat.staffList = stafflistid;
    }

    void SetTargetTrigger(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
FCTextRepeat::REPTARGETTRIGGERS
#else
int
#endif
    value
    )
    {
        switch (value)
        {
            case FCTextRepeat::REPTARGET_MEASURENUM:
                _backwardrepeat.flag &= ~BackRepeat_ACTION_BITS;
                _backwardrepeat.flag |= 0x10;
                break;
            case FCTextRepeat::REPTARGET_FORWARDS:
                _backwardrepeat.flag &= ~BackRepeat_ACTION_BITS;
                _backwardrepeat.flag |= 0x20;
                break;            
            case FCTextRepeat::REPTARGET_NEXTENDING:
                _backwardrepeat.flag &= ~BackRepeat_ACTION_BITS;
                break;
                        case FCTextRepeat::REPTARGET_UNDEFINED:
                        case FCTextRepeat::REPTARGET_DEFID:
                        case FCTextRepeat::REPTARGET_BACKWARDS:
                        case FCTextRepeat::REPTARGET_NEVERSKIPENDING:
                                break;
        }
    }

    void SetResetOnRepeatAction(bool state)
    {
        Set16BitFlag(&_backwardrepeat.flag, BackRepeat_CLRonCHANGE, state);
    }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPACTIONS
#else
    int
#endif
    GetAction() const
    {
        switch (_backwardrepeat.flag & 0xc00)
        {
            case 0x00:
                return FCTextRepeat::REPACTION_ALWAYSJUMP;
            case 0x400:
                return FCTextRepeat::REPACTION_JUMPONPASS;
            case 0x800:
                return FCTextRepeat::REPACTION_PLAYSECTION;
            default:
                break;
        }
    
#ifdef PDK_FRAMEWORK_DEBUG
    DebugOutHex("Undefined flag state for FCBackwardRepeat:GetAction: ", _backwardrepeat.flag);
#endif
        return FCTextRepeat::REPACTION_ALWAYSJUMP;
    }

    void SetAction(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCTextRepeat::REPACTIONS
#else
    int
#endif
    mode)
    {
        switch (mode)
        {
            case FCTextRepeat::REPACTION_ALWAYSJUMP:
                /* 0x0c40 bits should all be off */
                Set16BitFlag(&_backwardrepeat.flag, 0x0c00, false);
                break;

            case FCTextRepeat::REPACTION_JUMPONPASS:
                /* 0x0400 (in the 0x0c40 bit set) represents the "jump on pass" */
                Set16BitFlag(&_backwardrepeat.flag, 0x0c00, false);
                Set16BitFlag(&_backwardrepeat.flag, 0x0400, true);                
                break;

            case FCTextRepeat::REPACTION_PLAYSECTION:
                /* 0x0800 (in the 0x0c40 bit set) represents the "play section" */
                Set16BitFlag(&_backwardrepeat.flag, 0x0c00, false);
                Set16BitFlag(&_backwardrepeat.flag, 0x0800, true);                
                break;
        
            case FCTextRepeat::REPACTION_NEVERJUMP:
            case FCTextRepeat::REPACTION_STOPONPASS:
                                break;
        }
    }

    FCSeparatePlacements* CreateSeparatePlacements();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCSeparatePlacements* CreateSeparatePlacements_GC();
#endif

};


class FCBeatChartElement : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTBeatChartElement _beatchartelement;

protected:
    virtual EXTAG Tag() { return ot_BeatChartElement; }
    virtual int DataSizeLoad() { return sizeof(EDTBeatChartElement); }
    virtual void* Allocate() { return (void*) &_beatchartelement; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_beatchartelement, ((FCBeatChartElement*)pSource)->_GetBeatChartElement(), sizeof(_beatchartelement));
        _datablock = &_beatchartelement;
        _loadedsize = sizeof(_beatchartelement);
    }

    virtual __FCBaseData* CreateObject() { return new FCBeatChartElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    virtual const char* ClassName() { return "FCBeatChartElement"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_BEATCHARTELEMENT; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetBeatChartElement() { return &_beatchartelement; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCBeatChartElement() : __FCInciOther()
    {
        memset(&_beatchartelement, 0, sizeof(_beatchartelement));
        _datablock = &_beatchartelement;
        _loadedsize = sizeof(_beatchartelement);
    }

    TimeEdu32 GetMeasurePos() const { return _beatchartelement.dura; }

    Evpu16 GetHorizontalPosition() const { return _beatchartelement.posi; }

    Evpu16 GetFullSpan() const
    {
        if (!GetInitElement()) return 0;
        return _beatchartelement.posi;
    }

    Evpu16 GetReferenceWidth() const
    {
        if (!GetInitElement()) return 0;
        return _beatchartelement.minpos;
    }

    Evpu16 GetMinimumPosition() const { return _beatchartelement.minpos; }

    Evpu16 GetNextHorizontalPosition() const
    {
        if (GetInitElement()) return 0;
        return _beatchartelement.nextposi;
    }

    bool GetInitElement() const { return _beatchartelement.incizero != 0; }

    Evpu16 CalcWidth()
    {
        if (GetInitElement()) return 0;
        return (GetNextHorizontalPosition() - GetHorizontalPosition());
    }
    
    void SetMeasurePos(TimeEdu32 edupos) { _beatchartelement.dura = edupos; }

    void SetWidth(Evpu16 width) 
    {
        if (GetInitElement()) return;
        _beatchartelement.nextposi = width + _beatchartelement.posi;
    }

    void SetHorizontalPosition(Evpu16 position)
    {
        if (GetInitElement()) return;
        _beatchartelement.posi = position;
    }

    void SetNextHorizontalPosition(Evpu16 value)
    {
        if (GetInitElement()) return;
        _beatchartelement.nextposi = value;
    }

    void SetFullSpan(Evpu16 span)
    {
        if (!GetInitElement()) return;
        _beatchartelement.posi = span;
    }

    void SetReferenceWidth(Evpu16 width)
    {
        if (!GetInitElement()) return;
        _beatchartelement.minpos = width;
    }

    void SetMinimumPosition(Evpu16 value) { _beatchartelement.minpos = value; }

    bool MoveHorizontalPosition(Evpu16 offset, FCBeatChartElements* pBeatChart);
    

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
        DebugOutDigit("Measure Pos: ", GetMeasurePos());
        DebugOutDigit("Horizontal Position: ", GetHorizontalPosition());
        DebugOutDigit("Minimum position: ", GetMinimumPosition());
        DebugOutDigit("Next horizontal position:", GetNextHorizontalPosition());
        DebugOutBool("Init element: ", GetInitElement());
    }
#endif
};


class FCTempoElement : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTTempo _tempo;

protected:
    virtual EXTAG Tag() { return ot_Tempo; }
    virtual int DataSizeLoad() { return sizeof(EDTTempo); }
    virtual void* Allocate() { return (void*) &_tempo; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_tempo, ((FCTempoElement*)pSource)->_GetTempoElement(), sizeof(_tempo));
        _datablock = &_tempo;
        _loadedsize = sizeof(_tempo);
    }

    virtual __FCBaseData* CreateObject() { return new FCTempoElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    virtual const char* ClassName() { return "FCTempoElement"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TEMPOELEMENT; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetTempoElement() { return &_tempo; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCTempoElement() : __FCInciOther()
    {
        memset(&_tempo, 0, sizeof(_tempo));
        _tempo.unit = 1000;
        _datablock = &_tempo;
        _loadedsize = sizeof(_tempo);
    }

    void SetMeasurePos(twobyte edupos) { _tempo.eldur = edupos; }

    virtual TimeEdu32 GetMeasurePos() const { return _tempo.eldur; }

    bool GetAbsolute() const { return _tempo.flag == TIMEDIAL_ABSOLUTE; }

    void SetAbsolute(bool value)
    {
        _tempo.flag = value ? TIMEDIAL_ABSOLUTE : TIMEDIAL_RELATIVE;
    }

    fourbyte GetRatio() const { return _tempo.ratio; }

    void SetRatio(fourbyte value) { _tempo.ratio = value; }

    float CalcValue()
    {
        if (GetAbsolute())
        {            
            float result = _tempo.ratio * _tempo.unit;            
            result /= 65536;            
            /* The value here is relative to 60 BPM == 1024 */
            result *= 60;            
            result /= 1024;            
            /* Round it off to 2 decimals */
            fourbyte fb = (fourbyte) (result * 100);
            result = fb;
            result /= 100;
            return result;
        }
        else
        {
            /* Relative */
            float result = GetRatio();
            result /= 10;
            return result;
        }
    }

    void SetAbsoluteValue(float value)
    {
        SetAbsolute(true);
        _tempo.unit = 1000;
        value *= 1024;
        value /= 60;
        value *= 65536;
        value /= 1000;
        _tempo.ratio = (fourbyte) value;
    }

    void SetRelativeValue(float value)
    {
        SetAbsolute(false);
        SetRatio((fourbyte) (value * 10));
    }
};



#ifdef PDK_FRAMEWORK_TINYXML

class FCPercussionMapNote : public __FCBase
{
    int _midikey;
    PERC_NOTE_TYPE _notetype;
    FCString _name;
public:
    enum PERCUSSION_NOTE_TYPES {
        PERCNOTETYPE_BASSDRUM = 13,
        PERCNOTETYPE_BELLTREE = 70,
        PERCNOTETYPE_BONGO_HIGH = 32,
        PERCNOTETYPE_BONGO_LOW = 33,
        PERCNOTETYPE_CONGA = 36,
        PERCNOTETYPE_COWBELL = 6,
        PERCNOTETYPE_CASTANETS = 362,
        PERCNOTETYPE_CYMBAL_CHINA = 17,
        PERCNOTETYPE_CYMBAL_CRASH = 4,
        PERCNOTETYPE_CYMBAL_RIDE = 18,
        PERCNOTETYPE_CYMBAL_SIZZLE = 121,
        PERCNOTETYPE_CYMBAL_SPLASH = 21,
        PERCNOTETYPE_CLAVES = 35,
        PERCNOTETYPE_GONG_SMALL = 137,
        PERCNOTETYPE_GONG_MEDIUM = 136,
        PERCNOTETYPE_GONG_LARGE = 135,
        PERCNOTETYPE_HIHAT_CLOSED = 15,
        PERCNOTETYPE_HIHAT_FOOT = 16,
        PERCNOTETYPE_HIHAT_OPEN = 14,
        PERCNOTETYPE_KICKDRUM = 2,
        PERCNOTETYPE_RHYTHMCUES = 235,
        PERCNOTETYPE_ROTOTOM_MID = 321,
        PERCNOTETYPE_SIDEDRUM = 279,
        PERCNOTETYPE_SNAREDRUM = 1,
        PERCNOTETYPE_TAMBOURINE = 7,
        PERCNOTETYPE_TAMTAM = 149,
        PERCNOTETYPE_TOM_HIGH = 24,
        PERCNOTETYPE_TOM_HIGHMID = 25,
        PERCNOTETYPE_TOM_LOW = 27,
        PERCNOTETYPE_TRIANGLE_MUTE = 8,
        PERCNOTETYPE_TRIANGLE_OPEN = 9,
        PERCNOTETYPE_VIBRASLAP = 12,
        PERCNOTETYPE_WINDCHIMES = 460,
        PERCNOTETYPE_WOODBLOCK_HIGH = 10
    };

    FCPercussionMapNote(int midikey, int notetype, const char* pszName) : __FCBase()
    {
        _midikey = midikey;
        _notetype = notetype;
        _name.SetCString(pszName);
    }

    PERC_NOTE_TYPE GetRawNoteType() const { return _notetype; }

    PERC_NOTE_TYPE GetNoteType() const { return _notetype & 0x0fff; }

    twobyte GetOrderID() const
    {
        twobyte returnvalue = _notetype & 0xf000;
        returnvalue /= 0x1000;
        return returnvalue;
    }

    int GetMidiNote() const { return _midikey; }

    const char* GetName() const { return _name.GetCString(); }
};


class FCPercussionMapNotes : public __FCCollection
{
    twobyte _percussionid;
public:

    FCPercussionMapNotes(twobyte percussionid) : __FCCollection()
    {
       _percussionid = percussionid;
    }

    twobyte GetPercussionID() const { return _percussionid; }

    virtual const char* ClassName() { return "FCPercussionMapNotes"; }

    FCPercussionMapNote* GetItemAt(int index) { return (FCPercussionMapNote*) __FCCollection::GetItemAt(index); }

    FCPercussionMapNote* FindRawNoteType(PERC_NOTE_TYPE rawnotetype)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCPercussionMapNote* pItem = GetItemAt(i);
            if (pItem->GetRawNoteType() == rawnotetype) return pItem;
        }
        return NULL;
    }

    FCPercussionMapNote* FindMidiNote(twobyte midinote)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCPercussionMapNote* pItem = GetItemAt(i);
            if (pItem->GetMidiNote() == midinote) return pItem;
        }
        return NULL;
    }
};

class FCInstrumentDef;

class FCPercussionMapNotesLookup : public __FCCollection
{
    public:
        virtual const char* ClassName() { return "FCPercussionMapNotesLookup"; }

        FCPercussionMapNotesLookup() : __FCCollection() {}

        FCPercussionMapNotes* GetPercussionMapNotes(FCInstrumentDef* pInstrumentDef);        
};

#endif /*PDK_FRAMEWORK_TINYXML*/


class FCPercussionLayoutNotes;
class FCPercussionLayoutNote;

class FCPercussionLayoutNotesLookup : public __FCCollection
{
public:
    virtual const char* ClassName() { return "FCPercussionLayoutNotesLookup"; }

    FCPercussionLayoutNotesLookup() : __FCCollection() {}
    
    FCPercussionLayoutNotes* GetPercussionLayoutNotes(FCPercussionStaff* pPercussionStaff);
    
    FCPercussionLayoutNote* FindPercussionLayoutRawNote(FCPercussionStaff* pPercussionStaff, FLAG_16 percussionnote);

    FCPercussionLayoutNotes* GetItemAt(int index) { return (FCPercussionLayoutNotes*) __FCCollection::GetItemAt(index); }
};



class FCInstrumentDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTInstDefinition _instrumentdef;

protected:
    virtual EXTAG Tag() { return ot_InstDefinition; }
    virtual int DataSizeLoad() { return sizeof(EDTInstDefinition); }
    virtual void* Allocate() { return (void*) &_instrumentdef; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_instrumentdef, ((FCInstrumentDef*)pSource)->_GetInstrumentDef(), sizeof(_instrumentdef));
        _datablock = &_instrumentdef;
        _loadedsize = sizeof(_instrumentdef);
    }

    virtual __FCBaseData* CreateObject() { return new FCInstrumentDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    virtual const char* ClassName() { return "FCInstrumentDef"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_INSTRUMENTDEF; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetInstrumentDef() { return &_instrumentdef; }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCInstrumentDef() : __FCNoInciOther() {}

    FCString* CreateNameString()
    {
        FCInstrumentDefText text;
        text.Load(GetItemNo());
        return text.CreateString();
    }

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateNameString_GC();
#endif

    twobyte GetVirtualChannel() const { return _instrumentdef.virtChannel; }

    twobyte GetPercussionMapID() const { return _instrumentdef.percMapRefID; }

    void SetPercussionMapID(twobyte mapID) { _instrumentdef.percMapRefID = mapID; }

#ifdef PDK_FRAMEWORK_TINYXML

    FCPercussionMapNotes* CreatePercussionMapNotes();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCPercussionMapNotes* CreatePercussionMapNotes_GC();
#endif
#endif

        bool GetPercussionMapLocation(void* pFileSpecLocation, FCString* pMapName, EVERSION finpathspecversion);
        
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        this->DebugDataDump();
    }
#endif

};

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

#include "pragma_align_begin.h"
struct __EDTLayerPlayData
{
        ePlaybackRoute playbackRouteNum;        // twobyte
        twobyte velControlLevel;
        FLAG_16 velControlSaveFlags;
        FLAG_16 playFlags;
};
#include "pragma_align_end.h"

#include "pragma_align_begin.h"
struct __EDTPlayData2006
{
        __EDTLayerPlayData chordPlayData;
        __EDTLayerPlayData MIDIExpressionsPlayData;
        __EDTLayerPlayData layerPlayData[4];    // Should be MAX_LAYERS
};
#include "pragma_align_end.h"

const EXTAG __ot_PlayData2006   = MAKEEXTAG(edOther4Inci,'P','L');

// __EDTLayerPlayData.playFlags
const FLAG_16 __PLAY_LAYER_TRACK = 0x0001;
const FLAG_16 __SOLO_LAYER_TRACK = 0x0002;


#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */


class FCLayerPlaybackData : public __FCBase
{
    __EDTLayerPlayData* _pLayerData;
public:
    FCLayerPlaybackData(__EDTLayerPlayData* pData) : __FCBase()
    {
        _pLayerData = pData;
    }

    ePlaybackRoute GetInstrumentDefID() const
    {
        /* The value is 0-based!!! To be able to map to FCInstrumentDef, it
         * needs to be 1-based. */
        return _pLayerData->playbackRouteNum + 1;  
    }

    bool GetPlay() const
    {
        return GetBitFlag(_pLayerData->playFlags, __PLAY_LAYER_TRACK);
    }

    bool GetSolo() const
    {
        return GetBitFlag(_pLayerData->playFlags, __SOLO_LAYER_TRACK);
    }

    void SetInstrumentDefID(ePlaybackRoute value)
    {
        /* The value is 0-based!!! (To be able to map to FCInstrumentDef, it
         * needs to be 1-based.) */
        _pLayerData->playbackRouteNum = value - 1;
    }

    void SetPlay(bool state)
    {
        return Set16BitFlag(&_pLayerData->playFlags, __PLAY_LAYER_TRACK, state);
    }

    void SetSolo(bool state)
    {
        return Set16BitFlag(&_pLayerData->playFlags, __SOLO_LAYER_TRACK, state);
    }
};


class FCInstrumentPlaybackData : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    __EDTPlayData2006 _playbackdata;

    FCLayerPlaybackData* _pChordLayer;
    FCLayerPlaybackData* _pExpressionLayer;
    FCLayerPlaybackData* _pNoteLayers[4];

protected:
    virtual EXTAG Tag() { return __ot_PlayData2006; }
    virtual int DataSizeLoad() { return sizeof(__EDTPlayData2006); }
    virtual void* Allocate() { return (void*) &_playbackdata; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_playbackdata, ((FCInstrumentPlaybackData*)pSource)->_GetPlaybackData(), sizeof(_playbackdata));
        _datablock = &_playbackdata;
        _loadedsize = sizeof(_playbackdata);
    }

    virtual __FCBaseData* CreateObject() { return new FCInstrumentPlaybackData(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    virtual const char* ClassName() { return "FCInstrumentPlaybackData"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_INSTRUMENTPLAYBACKDATA; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetPlaybackData() { return &_playbackdata; }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCInstrumentPlaybackData() : __FCNoInciOther()
    {
        _pChordLayer = NULL;
        _pExpressionLayer = NULL;
        for (int i = 0; i < 4; i++) _pNoteLayers[i] = NULL;
    }

    virtual ~FCInstrumentPlaybackData()
    {
        delete _pChordLayer;
        delete _pExpressionLayer;
        for (int i = 0; i < 4; i++) delete _pNoteLayers[i];
    }

    FCLayerPlaybackData* GetChordLayerData()
    {
        if (!DataIsLoaded()) return NULL;
        if (_pChordLayer) return _pChordLayer;        
        _pChordLayer = new FCLayerPlaybackData(&_playbackdata.chordPlayData);
        return _pChordLayer;
    }

    FCLayerPlaybackData* GetMidiExpressionLayerData()
    {        
        if (!DataIsLoaded()) return NULL;
        if (_pExpressionLayer) return _pExpressionLayer;
        _pExpressionLayer = new FCLayerPlaybackData(&_playbackdata.MIDIExpressionsPlayData);
        return _pExpressionLayer;
    }


    FCLayerPlaybackData* GetNoteLayerData(int layernumber)
    {
        if ((layernumber < 1) || (layernumber > 4)) return NULL;
        if (!DataIsLoaded()) return NULL;
        layernumber--;  /* Make a 0-based index */
        if (_pNoteLayers[layernumber]) return _pNoteLayers[layernumber];        
        _pNoteLayers[layernumber] = new FCLayerPlaybackData(&_playbackdata.layerPlayData[layernumber]);
        return _pNoteLayers[layernumber];
    }
    
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugDataDump();
    }
#endif

};

class FCPercussionLayoutNote : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EDTPercussionNoteDef2010 _percussionnotedef2010;
#if FXT_VERSION >= FINALEVERSION_2012
    EDTPercussionNoteDef2012 _percussionnotedef2012;
#endif

    EVERSION _VersionToUse() const;

protected:
    virtual EXTAG Tag();    
    
    virtual int DataSizeLoad();
    
    virtual void* Allocate();

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

    virtual __FCBaseData* CreateObject() { return new FCPercussionLayoutNote(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    virtual const char* ClassName() { return "FCPercussionLayoutNote"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PERCUSSIONLAYOUTNOTE; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetPercussionNoteDef();
    

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCPercussionLayoutNote() : __FCInciOther() {
        memset(Allocate(), 0, DataSizeLoad());
    }

    PERC_NOTE_TYPE GetRawNoteType() const;

    PERC_NOTE_TYPE GetNoteType() const;

    twobyte GetOrderID() const;

    twobyte GetStaffPosition() const;

    fourbyte GetClosedNotehead() const;

    fourbyte GetHalfNotehead() const;

    fourbyte GetWholeNotehead() const;

    fourbyte GetDoubleWholeNotehead() const;
    


    void SetNoteType(PERC_NOTE_TYPE value);

    void SetOrderID(twobyte value);

    void SetStaffPosition(twobyte value);

    void SetClosedNotehead(fourbyte value);

    void SetHalfNotehead(fourbyte value);

    void SetWholeNotehead(fourbyte value);

    void SetDoubleWholeNotehead(fourbyte value);

#ifdef PDK_FRAMEWORK_TINYXML

    twobyte CalcMidiRawNote(FCPercussionMapNotes* pNotes);

    twobyte CalcMidiNote(FCPercussionMapNotes* pNotes);
#endif


#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCInciOther::DebugDump();
    }
#endif

};



/* Previously undocumented stuff */
const EXTAG __ot_CategoryStaffListScore = MAKEEXTAG(edOther, 'C', 's');
const EXTAG __ot_CategoryStaffListParts = MAKEEXTAG(edOther, 'C', 'p');
const EXTAG __ot_CategoryStaffListScoreOverride = MAKEEXTAG(edOther, 'c',
'o');
const EXTAG __ot_CategoryStaffListPartsOverride = MAKEEXTAG(edOther, 'C',
'o');


const EXTAG __ot_StaffAssignStaffListScore      = MAKEEXTAG(edOther, 'S', 's');
const EXTAG __ot_StaffAssignStaffListParts = MAKEEXTAG(edOther, 's', 'p');
const EXTAG __ot_StaffAssignStaffListScoreOverride = MAKEEXTAG(edOther, 'S',
'o');
const EXTAG __ot_StaffAssignStaffListPartsOverride = MAKEEXTAG(edOther, 's',
'o');


class FCStaffList : public __FCNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTStaffList* _TypeCast() const { return (EDTStaffList*)_datablock; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ot_StaffListDataScore; }

    virtual int DataSizeLoad();
    virtual int DataSizeSave();
    virtual void* Allocate();
    virtual void Deallocate();
    virtual bool IsDynamicSize() { return true; }

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

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    enum STAFFLIST_MODES
    {
        SLMODE_SCORE = 0,
        SLMODE_PARTS,
        SLMODE_FORCESCORE,
        SLMODE_FORCEPARTS,

        SLMODE_CATEGORY_SCORE,
        SLMODE_CATEGORY_PARTS,
        SLMODE_CATEGORY_FORCESCORE,
        SLMODE_CATEGORY_FORCEPARTS,

        SLMODE_ASSIGNMENT_SCORE,
        SLMODE_ASSIGNMENT_PARTS,
        SLMODE_ASSIGNMENT_FORCESCORE,
        SLMODE_ASSIGNMENT_FORCEPARTS
    };


    FCStaffList() : __FCNoInciOther()
    {
    }

    virtual const char* ClassName() { return "FCStaffList"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_STAFFLIST; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetStaffListElement() { return _datablock; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */


    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    STAFFLIST_MODES
#else
    int
#endif
    mode
    )
    {
        switch (mode)
        {
            case SLMODE_SCORE:
                SetCustomTag(ot_StaffListDataScore);
                break;
            case SLMODE_PARTS:
                SetCustomTag(ot_StaffListDataParts);
                break;
            case SLMODE_FORCESCORE:
                SetCustomTag(ot_StaffListForceScore);
                break;
            case SLMODE_FORCEPARTS:
                SetCustomTag(ot_StaffListForceParts);
                break;

            case SLMODE_CATEGORY_SCORE:
                SetCustomTag(__ot_CategoryStaffListScore);
                break;
            case SLMODE_CATEGORY_PARTS:
                SetCustomTag(__ot_CategoryStaffListParts);
                break;
            case SLMODE_CATEGORY_FORCESCORE:
                SetCustomTag(__ot_CategoryStaffListScoreOverride);
                break;
            case SLMODE_CATEGORY_FORCEPARTS:
                SetCustomTag(__ot_CategoryStaffListPartsOverride);
                break;

            case SLMODE_ASSIGNMENT_SCORE:
                SetCustomTag(__ot_StaffAssignStaffListScore);
                break;
            case SLMODE_ASSIGNMENT_PARTS:
                SetCustomTag(__ot_StaffAssignStaffListParts);
                break;
            case SLMODE_ASSIGNMENT_FORCESCORE:
                SetCustomTag(__ot_StaffAssignStaffListScoreOverride);
                break;
            case SLMODE_ASSIGNMENT_FORCEPARTS:
                SetCustomTag(__ot_StaffAssignStaffListPartsOverride);
                break;
        }
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
    }
#endif

    virtual bool Load(CMPER itemno);

    virtual bool SaveNew() { return false; }

    virtual bool Save();

    virtual bool DeleteData() { return false; }

    virtual bool LoadNext() { return Load(GetItemNo() + 1); }

    int GetElementCount() const
    {
        if (!DataIsLoaded()) return 0;
        int maxcount = _loadedsize / sizeof(EDTStaffList);
        /* Reduce list if some elements are 0 at the end */
        while (maxcount > 0)
        {
            if (_TypeCast()[maxcount - 1].staff == 0)
                maxcount --;
            else
                return maxcount;
        }
        return maxcount;
    }

    int GetStaffCount() const
    {
        if (!DataIsLoaded()) return 0;
        int maxcount = _loadedsize / sizeof(EDTStaffList);
        int staffcount = 0;
        for (int i = 0; i < maxcount; i++)
        {
            if (_TypeCast()[i].staff > 0) staffcount++;
        }
        return staffcount;
    }

    int GetStaff(int index)
    {
        if (index < 0) return 0;
        int maxcount = _loadedsize / sizeof(EDTStaffList);
        int staffcount = 0;
        for (int i = 0; i < maxcount; i++)
        {
            if (_TypeCast()[i].staff > 0)
            {
                if (staffcount == index) return _TypeCast()[index].staff;
                staffcount++;
            }
        }
        return 0;
    }

    bool IsElementAvailable(twobyte stafflistelement)
    {
        if (stafflistelement == 0) return false;  /* This value would not be a valid value in a staff list. */
        int maxcount = _loadedsize / sizeof(EDTStaffList);
        for (int i = 0; i < maxcount; i++)
        {
            if (_TypeCast()[i].staff == stafflistelement) return true;
        }
        return false;
    }

    bool IncludesTopStaff()
    {
        return IsElementAvailable(SLD_TOPSTAFF);
    }

    bool IncludesBottomStaff()
    {
        return IsElementAvailable(SLD_BOTTOMSTAFF);
    }

    bool IncludesStaff(twobyte staffnumber)
    {
        return IsElementAvailable(staffnumber);
    }

    FCString* CreateNameString();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateNameString_GC();
#endif

    bool SaveNameString(FCString* pString);

    bool AddElement(twobyte elementnumber);

    bool AddStaff(twobyte staffnumber)
    {
        if (staffnumber < 1) return false;
        return AddElement(staffnumber);
    }

     bool AddTopStaff()
     {
         return AddElement(SLD_TOPSTAFF);
     }

     bool AddBottomStaff()
     {
         return AddElement(SLD_BOTTOMSTAFF);
     }

     bool RemoveElement(twobyte element);

     bool RemoveTopStaff()
     {
         return RemoveElement(SLD_TOPSTAFF);
     }

     bool RemoveBottomStaff()
     {
         return RemoveElement(SLD_BOTTOMSTAFF);
     }

     bool RemoveStaff(twobyte staffnumber)
     {
         if (staffnumber < 1) return false;
         return RemoveElement(staffnumber);
     }
};



class FCFretInstrumentDef : public __FCNoInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTFretInstrument _fretinstrumentold; /* Pre 25.3 */
    
    FIN25_3_CODE( EDTFretInstrument25_3 _fretinstrument25_3; )
    
    /* Decides which of the structs that should be used, based on
     the PDK and running version. Returns true if 25.3 is supported. */
    bool _Use25_3Version() const;
    
    /* Returns a pointer to the 'noOfFrets' member */
    const twobyte* _GetNoOfFretsPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.noOfFrets; )
        return &_fretinstrumentold.noOfFrets;
    }
    
    /* Returns a pointer to the 'noOfStrings' member */
    const twobyte* _GetNoOfStringsPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.noOfStrings; )
        return &_fretinstrumentold.noOfStrings;
    }
    
    /* Returns a pointer to the 'speedyClef' member */
    const eClef* _GetSpeedyClefPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.speedyClef; )
        return &_fretinstrumentold.speedyClef;
    }
    
    /* Returns a pointer to the 'diatonicStepsLo' member */
    const utwobyte* _GetDiatonicStepsLoPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.diatonicStepsLo; )
        return &_fretinstrumentold.diatonicStepsLo;
    }
    
    /* Returns a pointer to the 'diatonicStepsHi' member */
    const utwobyte* _GetDiatonicStepsHiPtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.diatonicStepsHi; )
        return &_fretinstrumentold.diatonicStepsHi;
    }
    
    /* Returns a pointer to the 'name' member. On Finale 25.3+, it's an
     eUniChar16 buffer. On earlier Finale versions, it's an ECHAR buffer. */
    const void* _GetNamePtr() const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.name; )
        return &_fretinstrumentold.name;
    }
    
    /* Returns a pointer to the 'stringTuning' member. The meaning of this pointer is a
     bit different in 25.3 PDK versions. */
    const void* _GetStringTuningPtr(int stringno) const
    {
        FIN25_3_CODE( if (_Use25_3Version()) return &_fretinstrument25_3.stringTuning[stringno - 1]; )
        return &_fretinstrumentold.stringTuning[stringno - 1];
    }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag();
    virtual int DataSizeLoad();
    virtual void* Allocate();
    virtual EVERSION EnigmaVersion() { return _Use25_3Version() ? FINALEVERSION_25_3 : FINALEVERSION_2010; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        int size = DataSizeLoad();
        memcpy(_GetFretInstrumentDef(), ((FCFretInstrumentDef*)pSource)->_GetFretInstrumentDef(), size);
        _datablock = _GetFretInstrumentDef();
        _loadedsize = size;
    }

    virtual __FCBaseData* CreateObject() { return new FCFretInstrumentDef(); }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCFretInstrumentDef"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_FRETINSTRUMENTDEF; }

    virtual bool LoadFirst() { return Load(1); }

    virtual bool LoadNext() 
    {        
        if (!DataIsLoaded()) return false;
        return Load(GetItemNo() + 1);
    }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetFretInstrumentDef() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCFretInstrumentDef() : __FCNoInciOther()
    {
        /* Don't use virtual methods in the constructor */
        if (_Use25_3Version())
        {
#if FXT_VERSION >= FINALEVERSION_25_3
            memset(&_fretinstrument25_3, 0, sizeof(_fretinstrument25_3));
            _datablock = &_fretinstrument25_3;
            _loadedsize = sizeof(_fretinstrument25_3);
#endif
        }
        else
        {
            memset(&_fretinstrumentold, 0, sizeof(_fretinstrumentold));
            _datablock = &_fretinstrumentold;
            _loadedsize = sizeof(_fretinstrumentold);
        }
    }

    twobyte GetFretCount() const
    {
        return *_GetNoOfFretsPtr();
    }

    void SetFretCount(twobyte count)
    {
        *(twobyte*)_GetNoOfFretsPtr() = count;
    }

    twobyte GetStringCount() const
    {
        return *_GetNoOfStringsPtr();
    }

    void SetStringCount(twobyte count)
    {
        if (count < 1) return;
        if (count > 24) return;
        *(twobyte*)_GetNoOfStringsPtr() = count;
    }

    eClef GetSpeedyClef() const
    {
        return *_GetSpeedyClefPtr();
    }

    void SetSpeedyClef(eClef clef)
    {
        *(eClef*)_GetSpeedyClefPtr() = clef;
    }

    bool GetName(FCString* pString)
    {
        if (!pString) return false;
        if (_Use25_3Version())
        {
            /* Unicode version */
            FIN25_3_CODE( pString->SetUnicodeString((eUniChar16*) _GetNamePtr()); )
        }
        else
        {
            /* Old ECHAR version */
            pString->SetCString((ECHAR*) _GetNamePtr());
        }
        
        return true;
    }

    bool SetName(FCString* pString)
    {
        if (!pString) return false;
        if (pString->GetLength() > 47) return false;
        if (_Use25_3Version())
        {
            /* Unicode version */
            FIN25_3_CODE( pString->CopyToUnicodeBuffer((eUniChar16*) _GetNamePtr()); )
        }
        else
        {
            /* Old ECHAR version */
            strcpy((ECHAR*) _GetNamePtr(), pString->GetCString());
        }
        return true;
    }

    twobyte GetStringTuning(int stringnumber)
    {
        if (stringnumber < 1) return 0;
        if (stringnumber > GetStringCount()) return 0;
        if (stringnumber > 24) return 0;
        
        /* The meaning of the StringTuning array has shifted a bit between PDKs.
         */
#if FXT_VERSION >= FINALEVERSION_25_3
        if (_Use25_3Version())
        {
            return ((EDTStringData*)_GetStringTuningPtr(stringnumber))->pitch;
        }
#endif
        return *(twobyte*)_GetStringTuningPtr(stringnumber);
    }

    bool SetStringTuning(int stringnumber, twobyte midinumber)
    {
        if (stringnumber < 1) return false;
        if (stringnumber > GetStringCount()) return false;
        if (stringnumber > 24) return false;

        if (_Use25_3Version())
        {
#if FXT_VERSION >= FINALEVERSION_25_3
            ((EDTStringData*)_GetStringTuningPtr(stringnumber))->pitch = midinumber;
#endif
        }
        else
        {
            *(twobyte*)_GetStringTuningPtr(stringnumber) = midinumber;
        }
        return true;
    }
    
    bool IsDiatonic()
    {
        return (MAKELONG(*_GetDiatonicStepsLoPtr(), *_GetDiatonicStepsHiPtr()) != 0);
    }
    
    int GetDiatonicCount()
    {
        if (!IsDiatonic()) return 0;
        ufourbyte fb = MAKELONG(*_GetDiatonicStepsLoPtr(), *_GetDiatonicStepsHiPtr());
        int totalcount = 0;
        while (fb)
        {
            if (fb & 0x01) totalcount ++;
            fb = fb >> 1;
        }
        return totalcount;
    }
    
    bool GetDiatonicInfo(FCNumbers* pNumbers)
    {
        if (!pNumbers) return false;
        pNumbers->ClearAll();
        ufourbyte fb = MAKELONG(*_GetDiatonicStepsLoPtr(), *_GetDiatonicStepsHiPtr());
        int count = 0;
        while (fb != 0)
        {
            count ++;
            if (fb & 0x01)
            {                
                pNumbers->Add(new FCNumber(count));
                count = 0;
            }
            fb = fb >> 1;
        }
        return true;
    }
    
    bool SetDiatonicInfo(FCNumbers* pNumbers)
    {
        if (!pNumbers) return false;
        ufourbyte fb = 0;
        for (int i = pNumbers->GetCount() - 1; i >= 0; i--)
        {
            FCNumber* pNumber = pNumbers->GetItemAt(i);            
            if (pNumber->GetInt() < 1) return false;
            if (pNumber->GetInt() > 5) return false;
            fb = fb << 1;  /* Shift to next number */
            fb |= 0x01;
            for (int bitcount = 0; bitcount < pNumber->GetInt() - 1; bitcount++)
            {
                fb = fb << 1;  /* Shift with extra zeros, if necessary */
            }            
        }
        *(utwobyte*)_GetDiatonicStepsLoPtr() = LOWORD(fb);
        *(utwobyte*)_GetDiatonicStepsHiPtr() = HIWORD(fb);
        return true;
    }
    

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        DebugOutHex("Diatonic bit set: ", MAKELONG(*_GetDiatonicStepsLoPtr(), *_GetDiatonicStepsHiPtr()));
    }
#endif
};


#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#include "pragma_align_begin.h"
struct __EDTMidClef
{
    twobyte clefindex;
    twobyte edupos;
    twobyte vertadjust;
    twobyte resize;
    twobyte horizadjust;
    FLAG_16 flag;
};
#include "pragma_align_end.h"

const EXTAG __ot_MidClef = MAKEEXTAG(edOther, 'C', 'E');
#endif


class FCCellClefChange : public __FCInciOther
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __EDTMidClef _midclefdata;

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    virtual EXTAG Tag() { return __ot_MidClef; }
    virtual int DataSizeLoad() { return sizeof(__EDTMidClef); }
    virtual void* Allocate() { return (void*) &_midclefdata; }
    
    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_midclefdata, ((FCCellClefChange*)pSource)->_GetCellClefChange(), sizeof(_midclefdata));
        _datablock = &_midclefdata;
        _loadedsize = sizeof(_midclefdata);
    }

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

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

    void* _GetCellClefChange() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    FCCellClefChange() : __FCInciOther()
    {
        memset(&_midclefdata, 0, sizeof(_midclefdata));
        _midclefdata.resize = 75;
        _datablock = &_midclefdata;
        _loadedsize = sizeof(_midclefdata);
    }
    
    twobyte GetClefIndex() const { return _midclefdata.clefindex; }
    
    virtual TimeEdu32 GetMeasurePos() const { return _midclefdata.edupos; }
    
    twobyte GetClefPercent() const { return _midclefdata.resize; }
    
    twobyte GetHorizontalOffset() const { return _midclefdata.horizadjust; }

    twobyte GetVerticalOffset() const { return _midclefdata.vertadjust; }
    
    twobyte GetClefShow() const;
    
    bool GetAllowVerticalDrag() const { return (_midclefdata.flag & 0x04) != 0; }

    bool GetClefAfterBarline() const { return (_midclefdata.flag & 0x0010) != 0; }

    void SetClefIndex(twobyte value) { _midclefdata.clefindex = value; }
    
    void SetMeasurePos(twobyte value) { _midclefdata.edupos = value; }
    
    void SetClefPercent(twobyte value) { _midclefdata.resize = value; }

    void SetHorizontalOffset(twobyte value) { _midclefdata.horizadjust = value; }

    void SetVerticalOffset(twobyte value) { _midclefdata.vertadjust = value; }

    void SetClefShow(twobyte showstate);
    
    void SetAllowVerticalDrag(bool state) { Set16BitFlag(&_midclefdata.flag, 0x04, state); }

    void SetClefAfterBarline(bool state) { Set16BitFlag(&_midclefdata.flag, 0x0010, state); }

    bool IsStartClef() { return (GetMeasurePos() == 0); }
};


class FCGuide : public __FCBase
{
        Efix32 _position;
    public:
        FCGuide(Efix32 position) : __FCBase()
        {
            _position = position;
        }

        Efix32 GetPosition() const { return _position; }

        void SetPosition(Efix32 value) { _position = value; }
};

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

const EXTAG __ot_MetatoolExpression = MAKEEXTAG(edOther, '&', 'd');
const EXTAG __ot_MetatoolArticulation =  MAKEEXTAG(edOther, '&', 'a');
const EXTAG __ot_MetatoolRepeat =  MAKEEXTAG(edOther, '&', 'r');
const EXTAG __ot_MetatoolClef = MAKEEXTAG(edOther, '&', 'f');
const EXTAG __ot_MetatoolTuplet = MAKEEXTAG(edOther3Inci, '&', 'u');
const EXTAG __ot_MetatoolStaffStyle = MAKEEXTAG(edOther, '&', 's');

#include "pragma_align_begin.h"
struct __EDTMetatool
{
    twobyte item1; /* For most data, this is a cmper */
    twobyte item2; /* For expressions, this is a bool */
    twobyte item3;
    twobyte item4;
    twobyte item5;
    twobyte item6;
};
#include "pragma_align_end.h"

#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */

class FCClefDef;
#ifdef PDK_FRAMEWORK_ENTRIES
class FCTuplet;
#endif

class FCMetatoolAssignment : public __FCNoInciOther
{
public:
    enum METATOOL_MODES
    {
        /* Currently unassigned metatool mode. */
        MTOOLMODE_UNKNOWN = 0,
        
        MTOOLMODE_EXPRESSION = 1,
        
        MTOOLMODE_ARTICULATION = 2,
        
        MTOOLMODE_REPEAT = 3,
        
                MTOOLMODE_CLEF = 4,
        
#ifdef PDK_FRAMEWORK_ENTRIES

                MTOOLMODE_TUPLET = 5,
#endif
        
                MTOOLMODE_STAFFSTYLE = 6
        };
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    METATOOL_MODES _mode;  /* The mode of the object. */
    
    __EDTMetatool _metatool;        /* Data for most kind of items */
    EDTTuplet2005 _tupletmetatool;  /* Data for tuplets */
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    virtual EXTAG Tag()
    {
        switch (_mode)
        {
            case MTOOLMODE_EXPRESSION:
                return __ot_MetatoolExpression;
            case MTOOLMODE_ARTICULATION:
                return __ot_MetatoolArticulation;
            case MTOOLMODE_REPEAT:
                return __ot_MetatoolRepeat;
                        case MTOOLMODE_CLEF:
                                return __ot_MetatoolClef;
#ifdef PDK_FRAMEWORK_ENTRIES
            case MTOOLMODE_TUPLET:
                return __ot_MetatoolTuplet;
#endif
                        case MTOOLMODE_STAFFSTYLE:
                                return __ot_MetatoolStaffStyle;
            case MTOOLMODE_UNKNOWN:
                return 0;
        }
        return 0;
    }
    virtual int DataSizeLoad()
    {
        switch (_mode)
        {
#ifdef PDK_FRAMEWORK_ENTRIES
            case MTOOLMODE_TUPLET:
                return sizeof(_tupletmetatool);
#endif
            case MTOOLMODE_UNKNOWN:
                return 0;
            default:
                return sizeof(__EDTMetatool);
        }
    }
    virtual void* Allocate()
    {
        switch (_mode)
        {
#ifdef PDK_FRAMEWORK_ENTRIES
            case MTOOLMODE_TUPLET:
                return (void*) &_tupletmetatool;
#endif
            case MTOOLMODE_UNKNOWN:
                return NULL;
            default:
                return (void*) &_metatool;
        }
    }
    
    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        if (_mode == MTOOLMODE_UNKNOWN) return;
        memcpy(_GetMetatool(), ((FCMetatoolAssignment*)pSource)->_GetMetatool(), DataSizeLoad());
        _datablock = _GetMetatool();
        _loadedsize = sizeof(DataSizeLoad());
    }
    
    virtual __FCBaseData* CreateObject() { return new FCMetatoolAssignment(); }
    
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCMetatoolAssignment"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_METATOOLASSIGNMENT; }
    
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void* _GetMetatool() { return Allocate(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
    FCMetatoolAssignment() : __FCNoInciOther()
    {
        _mode = MTOOLMODE_UNKNOWN;
        // _datablock and _loadedsize is initialized in SetMode()
        memset(&_metatool, 0, sizeof(_metatool));
        memset(&_tupletmetatool, 0, sizeof(_tupletmetatool));
    }
    
    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                 METATOOL_MODES
#else
                 int
#endif
                 mode)
    {
        if (_mode != MTOOLMODE_UNKNOWN) return;
        _mode = (METATOOL_MODES) mode;
        _datablock = _GetMetatool();
        _loadedsize = DataSizeLoad();
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    METATOOL_MODES
#else
    int
#endif
    GetMode() const { return (METATOOL_MODES) _mode; }
    
    CMPER GetDefID() const
    {
        switch (_mode)
        {
            case MTOOLMODE_EXPRESSION:
            case MTOOLMODE_ARTICULATION:
            case MTOOLMODE_REPEAT:
                        case MTOOLMODE_CLEF:
                        case MTOOLMODE_STAFFSTYLE:
                return _metatool.item1;
            default:
                return 0;
        }
    }
    
    twobyte GetKeystroke() const;
    
    bool IsShapeExpressionDef() const
    {
        if (_mode != MTOOLMODE_EXPRESSION) return false;
        return (_metatool.item2 == 0);
    }
    
    bool AssignArticulationDef(FCArticulationDef* pDef)
    {
        if (!pDef) return false;
        if (_mode != MTOOLMODE_ARTICULATION) return false;
        _metatool.item1 = pDef->GetItemNo();
        return true;
    }
    
    bool AssignTextExpressionDef(FCTextExpressionDef* pDef)
    {
        if (!pDef) return false;
        if (_mode != MTOOLMODE_EXPRESSION) return false;
        _metatool.item1 = pDef->GetItemNo();
        _metatool.item2 = 1;
        return true;
    }
    
    bool AssignShapeExpressionDef(FCShapeExpressionDef* pDef)
    {
        if (!pDef) return false;
        if (_mode != MTOOLMODE_EXPRESSION) return false;
        _metatool.item1 = pDef->GetItemNo();
        _metatool.item2 = 0;
        return true;
    }
    
    bool AssignRepeatDef(FCTextRepeatDef* pDef)
    {
        if (!pDef) return false;
        if (_mode != MTOOLMODE_REPEAT) return false;
        _metatool.item1 = pDef->GetItemNo();
        return true;
    }
    
        bool AssignClefDef(FCClefDef* pDef);
    
#ifdef PDK_FRAMEWORK_ENTRIES

        bool AssignTuplet(FCTuplet* pTuplet);
#endif
    
        bool AssignStaffStyle(FCStaffStyleDef* pStaffStyle)
        {
                if (!pStaffStyle) return false;
                if (_mode != MTOOLMODE_STAFFSTYLE) return false;
                _metatool.item1 = pStaffStyle->GetItemNo();
                return true;
        }
    
    bool SaveAsKeystroke(twobyte keystrokeslot)
    {
        if (_mode == MTOOLMODE_UNKNOWN) return false;
        if ((keystrokeslot >= 'A' && keystrokeslot <= 'Z') || (keystrokeslot >= '0' && keystrokeslot <= '9'))
        {
            return __FCNoInciOther::SaveAs(keystrokeslot);
        }
        return false;
    }
    
    virtual bool SaveNew() { return false; }
    
    virtual bool SaveAs(CMPER cmper) { return false; }
    
    __FCBaseData* CreateLinkedObject();
    
#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    __FCBaseData* CreateLinkedObject_GC();
#endif
    
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciOther::DebugDump();
        switch (_mode)
        {
#ifdef PDK_FRAMEWORK_ENTRIES
            case MTOOLMODE_TUPLET:
                DebugDataDump();
                break;
#endif
            default:
                DebugOutDigit("item1: ", _metatool.item1);
                DebugOutDigit("item2: ", _metatool.item2);
                DebugOutDigit("item3: ", _metatool.item3);
                DebugOutDigit("item4: ", _metatool.item4);
                DebugOutDigit("item5: ", _metatool.item5);
                DebugOutDigit("item6: ", _metatool.item6);
                break;
        }
    }
#endif
};


#endif  /* _FF_OTHER_H */