ff_celldetails.h

/*
 * File:   ff_celldetails.h
 * Author: Jari Williamsson
 *
 * Created on den 3 december 2010, 23:10
 */

#ifndef FF_CELLDETAILS_H
#define FF_CELLDETAILS_H

#include "ff_cell.h"
#include "ff_region.h"
#include "ff_noteframe.h"


class __FCCellDetail : public __FCBaseData
{
    protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
      FCCell* _pConnectedCell;

      virtual void _SaveMeasureFlag() = 0;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    public:
        virtual const char* ClassName() { return "__FCCellDetail"; }

        __FCCellDetail() : __FCBaseData()
        {
            _pConnectedCell = NULL;
        }


        void ConnectCell(FCCell* pCell) { _pConnectedCell = pCell; }


        FCCell* GetConnectedCell() const { return _pConnectedCell; }

        virtual bool LoadFirst();
    
        virtual bool LoadLast();

        virtual bool LoadNext();
    
        virtual bool LoadPrevious();
    
        virtual TimeEdu32 GetMeasurePos() const { return 0; }

        virtual bool SaveNew();

        virtual eMeas GetMeasure() const
        {
            if (GetConnectedCell())
                return GetConnectedCell()->GetMeasure();
            else
                return _dataid.detail.cmper2;
        }

        virtual twobyte GetStaff() const
        {
            if (GetConnectedCell())
                return GetConnectedCell()->GetStaff();
            else
                return _dataid.detail.cmper1;
        }

#ifdef PDK_FRAMEWORK_DEBUG
        virtual void DebugDump()
        {
            __FCBaseData::DebugDump();
            DebugOutDigit("_dataid.detail.cmper1", _dataid.detail.cmper1);
            DebugOutDigit("_dataid.detail.cmper2", _dataid.detail.cmper2);
            DebugOutDigit("_dataid.detail.inci", _dataid.detail.inci);
            if (_pConnectedCell)
            {
                DebugOutDigit("Cell measure: ", _pConnectedCell->GetMeasure());
                DebugOutDigit("Cell staff: ", _pConnectedCell->GetStaff());
            }
        }

#endif
};

class __FCNoInciCellDetail : public __FCCellDetail
{
    virtual bool LoadFirst() { return __FCCellDetail::LoadFirst(); }
    virtual bool LoadNext() { return false; }
    virtual bool SaveNew() { return false; }
public:
    virtual const char* ClassName() { return "__FCNoInciCellDetail"; }

   __FCNoInciCellDetail() : __FCCellDetail()
        {
        }

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


class __FCCollectionCellDetail : public __FCCollectionDetail
{
public:
    virtual const char* ClassName() { return "__FCCollectionCellDetail"; }

    __FCCollectionCellDetail() : __FCCollectionDetail()
    {
    }

    virtual int LoadAllInCell(FCCell* pCell);

    int LoadAllForRegion(FCMusicRegion* pMusicRegion);

    virtual int LoadAll();
};

class __FCCollectionNoInciCellDetail : public __FCCollectionDetail
{
public:
    virtual const char* ClassName() { return "__FCCollectionNoInciCellDetail"; }

    __FCCollectionNoInciCellDetail() : __FCCollectionDetail()
    {
    }

    int LoadAllInRegion(FCMusicRegion* pMusicRegion);
};


class FCMidiExpression : public __FCCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTMidiExpression _midiexpression;

protected:
    /* No measure flag to set? */
    virtual void _SaveMeasureFlag() {}

    virtual EXTAG Tag() { return dt_MidiExpression; }
    virtual int DataSizeLoad() { return sizeof(EDTMidiExpression); }
    virtual int DataSizeSave() { return sizeof(EDTMidiExpression); }
    virtual void* Allocate() { return (void*) &_midiexpression; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_midiexpression, ((FCMidiExpression*)pSource)->_GetMidiExpr(), sizeof(_midiexpression));
        _datablock = &_midiexpression;
        _loadedsize = sizeof(_midiexpression);
    }

    virtual __FCBaseData* CreateObject() { return new FCMidiExpression(); }
#endif
public:
    enum MIDI_CONTROLLER_NUMBERS
    {
        PEDAL_CONTROLLER = 64
    };

    virtual const char* ClassName() { return "FCMidiExpression"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_MIDIEXPRESSION; }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTMidiExpression* _GetMidiExpr() { return &_midiexpression; }
#endif

    FCMidiExpression() : __FCCellDetail()
    {
        memset(&_midiexpression, 0, sizeof(_midiexpression));
        _loadedsize = sizeof(_midiexpression);
        _datablock = &_midiexpression;
    }

    TimeEdu32 GetMeasurePos() const { return _midiexpression.eldur; }

    bool IsController() const { return (LOBYTE(_midiexpression.status) == MIDIEXP_CONTROLLER); }
      
    twobyte GetControllerNumber() const { return IsController() ? _midiexpression.data1 : 0; }

    twobyte GetControllerValue() const { return IsController() ? _midiexpression.data2 : 0; }

    void SetUseController()
    {
        _midiexpression.status &= 0xff00;
        _midiexpression.status |= MIDIEXP_CONTROLLER;
    }

    void SetControllerNumber(twobyte number)
    {
        if (!IsController()) return;
        _midiexpression.data1 = number;
    }

    void SetControllerValue(twobyte number)
    {
        if (!IsController()) return;
        _midiexpression.data2 = number;
    }

    
    bool IsPressure() const { return (LOBYTE(_midiexpression.status) == MIDIEXP_PRESSURE); }

    void SetPressureValue(twobyte value)
    {
        if (!IsPressure()) return;
        if (value < 0) value = 0;
        if (value > 127) value = 127;
        _midiexpression.data1 = value;
    }

    twobyte GetPressureValue() const
    {
        if (!IsPressure()) return 0;
        return _midiexpression.data1;
    }

    void SetUsePressure()
    {
        _midiexpression.status &= 0xff00;
        _midiexpression.status |= MIDIEXP_PRESSURE;
    }


    bool IsPitchWheel() const { return (LOBYTE(_midiexpression.status) == MIDIEXP_PITCHWHEEL); }

    void SetPitchWheelValue(twobyte value)
    {
        if (!IsPitchWheel()) return;
        if (value > 8192) value = 8192;
        if (value < -8192) value = -8192;
        /* For some unknown reason, data2 & 64 is always true for 0
         * and positive values. */
        bool isnegative = (value < 0);
        _midiexpression.data1 = value & 0x7f;
        value &= ~0x7f;
        value /= 0x80;
        value &= 0x3f;
        _midiexpression.data2 = value;
        if (!isnegative) _midiexpression.data2 |= 0x40;
    }

    twobyte GetPitchWheelValue() const
    {
        if (!IsPitchWheel()) return 0;
        /* For some unknown reason, data2 & 64 is always true for 0
         * and positive values. */
        bool isnegative = (_midiexpression.data2 & 0x20) != 0;
        twobyte result = (_midiexpression.data1 & 0x7f);
        result = result | ((_midiexpression.data2 & 0x3f) * 0x80);
        if (isnegative) 
        {
            result = 0x2000 - result;
            result = -result;
        }        
        return result;
    }

    void SetUsePitchWheel()
    {
        _midiexpression.status &= 0xff00;
        _midiexpression.status |= MIDIEXP_PITCHWHEEL;
    }

    bool IsPatchChange() const { return (LOBYTE(_midiexpression.status) == MIDIEXP_PATCH_CHANGE); }
    
    void SetUsePatchChange()
    {
        _midiexpression.status &= 0xff00;
        _midiexpression.status |= MIDIEXP_PATCH_CHANGE;
    }
    
    void SetPatchChangeMode(twobyte mode)
    {
        if (!IsPatchChange()) return;
        if (mode < 0) return;
        if (mode > 4) return;
        twobyte patchnumber = LOBYTE(_midiexpression.data1);
        _midiexpression.data1 = MAKEWORD(patchnumber, mode);
    }
    
    twobyte GetPatchChangeMode() const
    {
        if (!IsPatchChange()) return 0;
        return HIBYTE(_midiexpression.data1);
    }
    
    void SetPatchChangeNumber(twobyte number)
    {
        if (!IsPatchChange()) return;
        if (number < 0) return;
        if (number > 255) return;
        twobyte patchmode = HIBYTE(_midiexpression.data1);
        _midiexpression.data1 = MAKEWORD(number, patchmode);
    }
    
    twobyte GetPatchChangeNumber() const
    {
        if (!IsPatchChange()) return 0;
        return LOBYTE(_midiexpression.data1);
    }

    
    void SetPatchChangeBankData1(twobyte mode)
    {
        if (!IsPatchChange()) return;
        if (mode < 0) return;
        if (mode > 255) return;
        twobyte patchnumber = LOBYTE(_midiexpression.data2);
        _midiexpression.data2 = MAKEWORD(patchnumber, mode);
    }
    
    twobyte GetPatchChangeBankData1() const
    {
        if (!IsPatchChange()) return 0;
        return HIBYTE(_midiexpression.data2);
    }
    
    void SetPatchChangeBankData2(twobyte number)
    {
        if (!IsPatchChange()) return;
        if (number < 0) return;
        if (number > 255) return;
        twobyte patchmode = HIBYTE(_midiexpression.data2);
        _midiexpression.data2 = MAKEWORD(number, patchmode);
    }
    
    twobyte GetPatchChangeBankData2() const
    {
        if (!IsPatchChange()) return 0;
        return LOBYTE(_midiexpression.data2);
    }

    
    void SetMeasurePos(TimeEdu32 value) { _midiexpression.eldur = value; }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCCellDetail::DebugDump();
        DebugOutDigit("Position: ", GetMeasurePos());
        if (IsController())
        {
            DebugOutBool("Is Controller: ", IsController());
            DebugOutDigit("Controller number: ", GetControllerNumber());
            DebugOutDigit("Controller value: ", GetControllerValue());
        }
        if (IsPitchWheel())
        {
            DebugOutBool("Is Pitch Wheel: ", IsPitchWheel());
            DebugOutDigit("data1: ", _midiexpression.data1);
            DebugOutDigit("data2: ", _midiexpression.data2);
        }
    }
#endif
};



class FCSeparateMeasureNumber : public __FCCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    FCEnclosure _enclosure;

    EDTMeasNumberSeparate _separatemeasurenumberold;
    
    FIN25_4_CODE( EDTMeasNumberSeparate25_4 _separatemeasurenumber25_4; )

    /* Decides which version of the struct that should be used */
    const bool _Use25_4_Version() const;
    
    /* Returns the pointer to the 'flag' struct member */
    const FLAG_16* _GetFlagPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.flag; )
        return &_separatemeasurenumberold.flag;
    }
    
    /* Returns the pointer to the 'region' struct member */
    const twobyte* _GetRegionPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.region; )
        return &_separatemeasurenumberold.region;
    }
    
    /* Returns the pointer to the 'x1add' struct member */
    const twobyte* _GetX1addPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.x1add; )
        return &_separatemeasurenumberold.x1add;
    }
    
    /* Returns the pointer to the 'y1add' struct member */
    const twobyte* _GetY1addPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.y1add; )
        return &_separatemeasurenumberold.y1add;
    }
    
    /* Returns the pointer to the 'encl' struct member (different data type,
     depending on version) */
    const void* _GetEnclPtr() const
    {
        FIN25_4_CODE( if (_Use25_4_Version()) return &_separatemeasurenumber25_4.encl; )
        return &_separatemeasurenumberold.encl;
    }
    
    /* No measure flag? */
    virtual void _SaveMeasureFlag() {}
protected:
    virtual EXTAG Tag();
    virtual int DataSizeLoad();
    virtual int DataSizeSave();
    virtual void* Allocate();

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

    virtual __FCBaseData* CreateObject() { return new FCSeparateMeasureNumber(); }
#endif
public:

    virtual const char* ClassName() { return "FCSeparateMeasureNumber"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SEPARATEMEASURENUMBER; }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void* _GetSeparateMeasNum() { return Allocate(); }
#endif

    FCSeparateMeasureNumber() : __FCCellDetail()
    {
        /* Don't use virtual methods in the constructor */
        if (_Use25_4_Version())
        {
#if FXT_VERSION >= FINALEVERSION_25_4
            memset(&_separatemeasurenumber25_4, 0, sizeof(_separatemeasurenumber25_4));
            _loadedsize = sizeof(_separatemeasurenumber25_4);
            _datablock = &_separatemeasurenumber25_4;
#endif
        }
        else
        {
            memset(&_separatemeasurenumberold, 0, sizeof(_separatemeasurenumberold));
            _loadedsize = sizeof(_separatemeasurenumberold);
            _datablock = &_separatemeasurenumberold;
        }
    }

    twobyte GetRegionNumberID() const { return *_GetRegionPtr(); }

    bool GetShowOverride() const { return GetBitFlag(*_GetFlagPtr(), MEASNUM_FORCE_MNUM); }

    bool GetHideOverride() const { return GetBitFlag(*_GetFlagPtr(), MEASNUM_HIDE_MNUM); }

    bool GetUseEnclosure() const { return GetBitFlag(*_GetFlagPtr(), MEASNUM_USE_ENCL); }

    twobyte GetHorizontalPosition() const { return *_GetX1addPtr(); }

    twobyte GetVerticalPosition() const { return *_GetY1addPtr(); }

    bool AssignMeasureNumberRegion(FCMeasureNumberRegion* pRegion)
    {
        if (!pRegion) return false;
        if (pRegion->GetID() < 1) return false;
        SetRegionNumberID(pRegion->GetID());
        return true;
    }

    FCEnclosure* GetEnclosure() 
    {
        if (!GetUseEnclosure()) return NULL;
        _enclosure._AssignEDTEnclosure((void*) _GetEnclPtr());
        return &_enclosure;
    }

    void SetRegionNumberID(twobyte regionid)
    {
        if (regionid < 1) return;
        *(twobyte*)_GetRegionPtr() = regionid;
    }

    void SetShowOverride(bool state) { Set16BitFlag((FLAG_16*)_GetFlagPtr(), MEASNUM_FORCE_MNUM, state); }

    void SetHideOverride(bool state)  { Set16BitFlag((FLAG_16*)_GetFlagPtr(), MEASNUM_HIDE_MNUM, state); }

    void SetUseEnclosure(bool state) { Set16BitFlag((FLAG_16*) _GetFlagPtr(), MEASNUM_USE_ENCL, state); }

    void SetHorizontalPosition(twobyte value) { *(twobyte*)_GetX1addPtr() = value; }

    void SetVerticalPosition(twobyte value) { *(twobyte*)_GetY1addPtr() = value; }

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

class FCSeparateMeasureNumbers : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCSeparateMeasureNumber(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    
    FCSeparateMeasureNumbers() : __FCCollectionCellDetail() {}

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

    FCSeparateMeasureNumber* GetItemAt(int index) { return (FCSeparateMeasureNumber*) __FCCollection::GetItemAt(index); }
};


class FCCellFrameHold : public __FCNoInciCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTGfhold2004 _tgfhold;

protected:
    /* No measure flag storage */
    virtual void _SaveMeasureFlag() {}


    virtual EXTAG Tag() { return dt_Gfhold; }
    virtual int DataSizeLoad() { return sizeof(EDTGfhold2004); }
    virtual int DataSizeSave() { return sizeof(EDTGfhold2004); }
    virtual void* Allocate() { return (void*) &_tgfhold; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        // Don't use memcpy, since EDTGfhold2004 contains dynamic memory.
        _tgfhold = ((FCCellFrameHold*) pSource)->_GetTGFHold();
        _datablock = &_tgfhold;
        _loadedsize = sizeof(_tgfhold);
    }

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

#endif
public:

    virtual const char* ClassName() { return "FCCellFrameHold"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CELLFRAMEHOLD; }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTGfhold2004& _GetTGFHold() { return _tgfhold; }
#endif

    enum CLEF_SHOW
    {
        SHOWCLEF_NORMAL = 0,
        SHOWCLEF_HIDE,
        SHOWCLEF_ALWAYS
    };


    FCCellFrameHold() : __FCNoInciCellDetail()
    {
        /* Don't reset using memset, since there's a constructor for dynamic
         * memory in _tgfhold. */
        _tgfhold.clef = 0;
        _tgfhold.flag = 0;
        _tgfhold.clefPercent = 100;
        _datablock = &_tgfhold;
        _loadedsize = sizeof(_tgfhold);
    }

    twobyte GetClefIndex() const { return _tgfhold.clef; }

    twobyte GetClefPercent() const { return _tgfhold.clefPercent; }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    CLEF_SHOW
#else
    int
#endif
    GetClefShow() const
    {
        if (GetBitFlag(_tgfhold.flag, GF_HIDECLEF))
            return SHOWCLEF_HIDE;
        if (GetBitFlag(_tgfhold.flag, 0x0020))
            return SHOWCLEF_ALWAYS;
        else
            return SHOWCLEF_NORMAL;
    }

    bool GetIsClefList() const
    {
        return GetBitFlag(_tgfhold.flag, GF_CLEFISLIST);
    }

    bool GetClefAfterBarline() const { return GetBitFlag(_tgfhold.flag, 0x0001); }

    void SetClefIndex(twobyte newclef) 
    {
        if (GetIsClefList()) return;
        _tgfhold.clef = newclef;
    }
    
    void SetClefPercent(twobyte resize) 
    {
        if (GetIsClefList()) return;
        _tgfhold.clefPercent = resize;
    }

    void SetClefShow(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    CLEF_SHOW
#else
    twobyte
#endif
    clef
    )
    {
        if (GetIsClefList()) return;
        switch (clef)
        {
            case SHOWCLEF_HIDE:
                Set16BitFlag(&_tgfhold.flag, GF_HIDECLEF, true);
                Set16BitFlag(&_tgfhold.flag, 0x0020, false);
                break;
            case SHOWCLEF_ALWAYS:
                Set16BitFlag(&_tgfhold.flag, GF_HIDECLEF, false);
                Set16BitFlag(&_tgfhold.flag, 0x0020, true);
                break;
            case SHOWCLEF_NORMAL:
                Set16BitFlag(&_tgfhold.flag, GF_HIDECLEF, false);
                Set16BitFlag(&_tgfhold.flag, 0x0020, false);
                break;
        }        
    }


    void SetClefAfterBarline(bool state) 
    {
        if (GetIsClefList()) return;
        Set16BitFlag(&_tgfhold.flag, 0x0001, state);
    }

    bool CalcClefChange();

    virtual bool SaveNew();


    FCCellClefChanges* CreateCellClefChanges();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCCellClefChanges* CreateCellClefChanges_GC();
#endif


#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoInciCellDetail::DebugDump();
        DebugOutDigit("Clef: ", GetClefIndex());
        DebugOutDigit("Clef Resize: ", GetClefPercent());
        DebugOutDigit("Clef show: ", GetClefShow());
        DebugOutHex("Flag Bits: ", _tgfhold.flag);
    }
#endif
};



class FCChord : public __FCCellDetail
{
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    EDTChord2010 _chord;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    
    virtual void _SaveMeasureFlag();

    virtual int DataSizeLoad() { return sizeof(EDTChord2010); }
    virtual void* Allocate() { return (void*) &_chord; }

    virtual EVERSION EnigmaVersion() { return FINALEVERSION_2010; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_chord, ((FCChord*)pSource)->_GetChord(), sizeof(_chord));
        _datablock = &_chord;
        _loadedsize = sizeof(_chord);
    }

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

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual EXTAG Tag() { return dt_Chord2010; }  /* Some plug-ins need this - needs to be public. */

    virtual const char* ClassName() { return "FCChord"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CHORD; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

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

    enum ALTERNATEBASS_PLACEMENT
    {
        ALTBASSPLACE_AFTERROOT = 0,
        ALTBASSPLACE_UNDERROOT,
        ALTBASSPLACE_SUBTEXT
    };

    FCChord() : __FCCellDetail()
    {
        memset(&_chord, 0, sizeof(_chord));
        _datablock = &_chord;
        _loadedsize = sizeof(_chord);
    }

    bool IsEarlierThan(FCChord* pTestChord)
    {
        if (!pTestChord) return false;
        if (pTestChord->GetMeasure() > GetMeasure()) return true;
        if (pTestChord->GetMeasure() < GetMeasure()) return false;
        return (pTestChord->GetMeasurePos() > GetMeasurePos());
    }

    virtual TimeEdu32 GetMeasurePos() const { return _chord.horzEDU; }

    void SetMeasurePos(TimeEdu32 position) { _chord.horzEDU = position; }

#ifdef PDK_FRAMEWORK_ENTRIES

    bool AnalyzeEntryChord(FCNoteEntry* pEntry)
    {
        tbool suffixfound;
        FCMusicRegion musicregion;
        musicregion.SetInstrumentList(0);
        musicregion.SetStartStaff(pEntry->GetStaff());
        musicregion.SetEndStaff(pEntry->GetStaff());
        musicregion.SetStartMeasure(pEntry->GetMeasure());
        musicregion.SetEndMeasure(pEntry->GetMeasure());
        musicregion.SetStartMeasurePos(pEntry->GetMeasurePos());
        musicregion.SetEndMeasurePosRight();
        EREGION eregion;
        musicregion.GetEnigmaRegion(&eregion);
#if FXT_VERSION >= FINALEVERSION_2014_5
        if (!FX_AnalyzeChord(&eregion, (EDTChord2010*) &_chord, &suffixfound)) return false;
#else
        if (!FX_AnalyzeChord(&eregion, (EDTChord*) &_chord, &suffixfound)) return false;
#endif
        SetMeasurePos(pEntry->GetMeasurePos());
        SetChordVerticalPos(0);
        return true;
    }
#endif

    FCChordSuffixElements* CreateChordSuffixElements();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCChordSuffixElements* CreateChordSuffixElements_GC();
#endif

    /******** CHORD GETTERS ***********/

    twobyte GetChordSuffixID() const { return _chord.suffix; }

    twobyte GetChordHorizontalPos() const { return _chord.posadd; }

    twobyte GetChordVerticalPos()  const { return _chord.lineadd; }

    bool GetChordVisible() const { return !GetBitFlag(_chord.capoData, 0x0080); }

    twobyte GetChordResize() const { return _chord.chPercent; }

    bool GetChordRootVisible() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_SHOWROOT);
    }

    bool GetChordRootPlayback() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_PLAYROOT);
    }

    bool GetChordRootLowercase() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_LOWERCASE);
    }

    bool GetChordSuffixVisible() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_SHOW_SUFFIX);
    }

    bool GetChordSuffixPlayback() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_PLAYCHORD);
    }

    bool GetUseCapo() const
    {
        return GetBitFlag(_chord.capoData, CHORD_USE_LOCAL_CAPO);
    }

    twobyte GetCapo() const
    {
        return (_chord.capoData & CHORD_CAPO_VALUE);
    }

    twobyte GetScaleNumber() const
    {
        return _chord.showPlay & CHORD_SCALENUM;
    }
    
    twobyte GetAlteration() const
    {
        twobyte alteration = _chord.showPlay & CHORD_RLBITS;
        alteration >>= 8;
        if (alteration & 0x08)
        {
            /* Signed */
            alteration |= 0xfff0;
        }
        return alteration;
    }

    bool GetChordAlternateBassVisible() const
    {
        return GetBitFlag(_chord.altbass, CHORD_SHOWALTBASS);
    }

    bool GetChordAlternateBassPlayback() const
    {
        return GetBitFlag(_chord.altbass, CHORD_PLAYALTBASS);
    }

    bool GetChordAlternateBassLowercase() const
    {
        return GetBitFlag(_chord.altbass, CHORD_LOWERCASE);
    }

    twobyte GetAlternateBassScaleNumber() const
    {
        return _chord.altbass & CHORD_SCALENUM;
    }

        twobyte GetAlternateBassAlteration() const
        {
                twobyte alteration = _chord.altbass & CHORD_RLBITS;
                alteration >>= 8;
                if (alteration & 0x08)
                {
                        /* Signed */
                        alteration |= 0xfff0;
                }
                return alteration;
        }

#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ALTERNATEBASS_PLACEMENT 
#else
    int
#endif
    GetChordAlternateBassPlacement() const
    {
        if (GetBitFlag(_chord.altbass, CHORD_DOWNSIDEBIT) == false)
        {
            if (GetBitFlag(_chord.altbass, CHORD_SUBTEXTBIT))
                return ALTBASSPLACE_SUBTEXT;
            else
                return ALTBASSPLACE_AFTERROOT;
        }
        else return ALTBASSPLACE_UNDERROOT;
    }

    /******** FRETBOARD GETTERS ***********/

    twobyte GetFretboardStyleID() const { return _chord.fbStyleID; }

    twobyte GetFretboardHorizontalPos() const { return _chord.fbposadd; }

    twobyte GetFretboardVerticalPos() const { return _chord.fblineadd; }

    /* Use absolute bit mask, since the CHORD_HIDE_FRETBOARD is reversed */
    bool GetFretboardVisible() const { return GetBitFlag(_chord.showPlay, 0x4000); }

    twobyte GetFretboardResize() const { return _chord.fbPercent; }

    bool GetFretboardPlayback() const
    {
        return GetBitFlag(_chord.showPlay, CHORD_PLAYFRETBOARD);
    }

    bool GetFretboardUseFont() const
    {
        return GetBitFlag(_chord.fbData, CHORD_USE_FRET_FONT);
    }

    /******** CHORD SETTERS ***********/

    void SetChordSuffixID(twobyte value) { _chord.suffix = value; }

    void SetChordHorizontalPos(twobyte value) { _chord.posadd = value; }

    void SetChordVerticalPos(twobyte value)  { _chord.lineadd = value; }

    void SetChordVisible(bool state) { Set16BitFlag(&_chord.capoData, 0x0080, !state); }

    void SetChordResize(twobyte value) { _chord.chPercent = value; }

    void SetChordRootVisible(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_SHOWROOT, state);
    }

    void SetChordRootPlayback(bool playback)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_PLAYROOT, playback);
    }

    void SetChordRootLowercase(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_LOWERCASE, state);
    }

    void SetChordSuffixVisible(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_SHOW_SUFFIX, state);
    }

    void SetChordSuffixPlayback(bool playback)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_PLAYCHORD, playback);
    }

    void SetChordAlternateBassVisible(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_SHOWALTBASS, state);
    }

    void SetChordAlternateBassPlayback(bool playback)
    {
        Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_PLAYALTBASS, playback);
    }

    void SetChordAlternateBassLowercase(bool lowercase)
    {
        Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_LOWERCASE, lowercase);
    }

    void SetChordAlternateBassPlacement(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    ALTERNATEBASS_PLACEMENT
#else
    int
#endif
    placement
    )
    {
        switch (placement)
        {
            case ALTBASSPLACE_AFTERROOT:
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_DOWNSIDEBIT, false);
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_SUBTEXTBIT, false);
                break;
            case ALTBASSPLACE_UNDERROOT:
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_DOWNSIDEBIT, true);
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_SUBTEXTBIT, false);
                break;
            case ALTBASSPLACE_SUBTEXT:
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_DOWNSIDEBIT, false);
                Set16BitFlag((FLAG_16*)&_chord.altbass, CHORD_SUBTEXTBIT, true);
                break;
        }
    }

    void SetUseCapo(bool state)
    {
        Set16BitFlag((FLAG_16*)&_chord.capoData, CHORD_USE_LOCAL_CAPO, state);
    }

    void SetCapo(twobyte value)
    {
        _chord.capoData &= ~CHORD_CAPO_VALUE;
        _chord.capoData |= (value & CHORD_CAPO_VALUE);
    }

    void SetScaleNumber(twobyte scalenumber)
    {
        _chord.showPlay &= ~CHORD_SCALENUM;
        _chord.showPlay |= (scalenumber & CHORD_SCALENUM);
    }

    void SetAlteration(twobyte alteration)
    {
        alteration <<= 8;
        alteration &= CHORD_RLBITS;
        _chord.showPlay &= ~CHORD_RLBITS;
        _chord.showPlay |= alteration;        
    }

    void SetAlternateBassScaleNumber(twobyte scalenumber)
    {
        _chord.altbass &= ~CHORD_SCALENUM;
        _chord.altbass |= (scalenumber & CHORD_SCALENUM);
    }

        void SetAlternateBassAlteration(twobyte alteration)
        {
                alteration <<= 8;
                alteration &= CHORD_RLBITS;
                _chord.altbass &= ~CHORD_RLBITS;
                _chord.altbass |= alteration;
        }


    /******** FRETBOARD SETTERS ***********/

    void SetFretboardStyleID(twobyte value) { _chord.fbStyleID = value; }

    void SetFretboardHorizontalPos(twobyte value) { _chord.fbposadd = value; }

    void SetFretboardVerticalPos(twobyte value) { _chord.fblineadd = value; }

    /* Use absolute bit mask, since the CHORD_HIDE_FRETBOARD is reversed */
    void SetFretboardVisible(bool state) { Set16BitFlag((FLAG_16*)&_chord.showPlay, 0x4000, state); }

    void SetFretboardResize(twobyte value) { _chord.fbPercent = value; }

    void SetFretboardPlayback(bool playback)
    {
        Set16BitFlag((FLAG_16*)&_chord.showPlay, CHORD_PLAYFRETBOARD, playback);
    }

    void SetFretboardUseFont(bool state)
    {
        Set16BitFlag(&_chord.fbData, CHORD_USE_FRET_FONT, state);
    }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCCellDetail::DebugDump();
        DebugOutBlock(&_chord, 0, sizeof(_chord));
        DebugOutBool("Chord Visible: ", GetChordVisible());
        DebugOutBool("Fretboard Visible: ", GetFretboardVisible());
    }
#endif
};




class FCCellGraphic : public __FCCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTTGraphic _graphic;

    /* No measure flag? */
    virtual void _SaveMeasureFlag() {}

protected:
    virtual EXTAG Tag() { return dt_MeasGraphic; }
    virtual int DataSizeLoad() { return sizeof(EDTTGraphic); }
    virtual int DataSizeSave() { return sizeof(EDTTGraphic); }
    virtual void* Allocate() { return (void*) &_graphic; }

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

    virtual __FCBaseData* CreateObject() { return new FCCellGraphic(); }
#endif
public:

    virtual const char* ClassName() { return "FCCellGraphic"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CELLGRAPHIC; }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTTGraphic* _GetGraphic() { return &_graphic; }
#endif

    FCCellGraphic() : __FCCellDetail()
    {
        memset(&_graphic, 0, sizeof(_graphic));
        _loadedsize = sizeof(_graphic);
        _datablock = &_graphic;
    }

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

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




class FCCellText : public __FCCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTMeasureText _measuretext;

    virtual void _SaveMeasureFlag();

protected:
    virtual EXTAG Tag() { return dt_MeasureTextBlock; }
    virtual int DataSizeLoad() { return sizeof(EDTMeasureText); }
    virtual int DataSizeSave() { return sizeof(EDTMeasureText); }
    virtual void* Allocate() { return (void*) &_measuretext; }

    virtual void CloneMemoryFrom(__FCBaseData* pSource)
    {
        memcpy(&_measuretext, ((FCCellText*)pSource)->_GetCellText(), sizeof(_measuretext));
        _datablock = &_measuretext;
        _loadedsize = sizeof(_measuretext);
    }

    virtual __FCBaseData* CreateObject() { return new FCCellText(); }
#endif
public:

    virtual const char* ClassName() { return "FCCellText"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CELLTEXT; }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    EDTMeasureText* _GetCellText() { return &_measuretext; }
#endif

    FCCellText() : __FCCellDetail()
    {
        memset(&_measuretext, 0, sizeof(_measuretext));
        _loadedsize = sizeof(_measuretext);
        _datablock = &_measuretext;
    }

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

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCString* CreateTextString_GC();
#endif

    FCTextBlock* CreateTextBlock();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCTextBlock* CreateTextBlock_GC();
#endif

     bool SaveNewTextBlock(FCString* pString);

     bool SaveTextString(FCString* pString);

    twobyte GetTextBlockID() const
    {
        return _measuretext.block;
    }

    CMPER GetStringID() const;

    virtual TimeEdu32 GetMeasurePos() const
    {
        return _measuretext.xdisp;
    }

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

    void SetMeasurePos(TimeEdu32 value)
    {
        _measuretext.xdisp = (Evpu16) value;
    }

    void SetVerticalPos(twobyte value)
    {
        _measuretext.ydisp = value;
    }

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






class FCCellGraphics : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCCellGraphic(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCCellGraphics"; }

    FCCellGraphic* GetItemAt(int index) { return (FCCellGraphic*) __FCCollection::GetItemAt(index); }
};



class FCCellTexts : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCCellText(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCCellTexts() : __FCCollectionCellDetail() {}

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

    FCCellText* GetItemAt(int index) { return (FCCellText*) __FCCollectionCellDetail::GetItemAt(index); }
};




class FCCellFrameHolds : public __FCCollectionNoInciCellDetail
{
    protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCCellFrameHold(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCCellFrameHolds"; }

};



class FCMidiExpressions : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCMidiExpression(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCMidiExpressions"; }

    FCMidiExpression* GetItemAt(int index) { return (FCMidiExpression*) __FCCollectionCellDetail::GetItemAt(index); }
};


class FCChords : public __FCCollectionCellDetail
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCChord(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCChords"; }

    FCChord* FindMeasurePos(TimeEdu32 durationpos)
    {
        for (int i = 0; i < GetCount(); i++ )
        {
            FCChord* pChord = (FCChord*) GetItemAt(i);
            if (pChord->GetMeasurePos() == durationpos) return pChord;
        }
        return NULL;
    }

    FCChord* GetItemAt(int index) { return (FCChord*) __FCCollectionCellDetail::GetItemAt(index); }
};



class FCIndependentCellDetail : public __FCNoInciCellDetail
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#if FXT_VERSION < FINALEVERSION_2014
    EDTMeasureFloat _measurefloat2014; /* Dummy struct */
    EDTMeasureFloat _measurefloat2001;
#else
    EDTMeasureFloat2014 _measurefloat2014;
    EDTMeasureFloat2001 _measurefloat2001;
#endif

    EVERSION _VersionToUse() const;
protected:
    /* Set measure flag? */
    virtual void _SaveMeasureFlag() {}

    virtual EXTAG Tag();
    virtual int DataSizeLoad();
    virtual int DataSizeSave();
    virtual void* Allocate();
    virtual EVERSION EnigmaVersion() { return _VersionToUse(); }

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

    virtual __FCBaseData* CreateObject() { return new FCIndependentCellDetail(); }
#endif
public:

    virtual const char* ClassName() { return "FCIndependentCellDetail"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_INDEPENDENTCELLDETAIL; }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void* _GetDataPtr();
#endif

    FCIndependentCellDetail() : __FCNoInciCellDetail()
    {
        int size = FCIndependentCellDetail::DataSizeLoad();  /* Assure non-virtual call in constructor */
        memset(_GetDataPtr(), 0, size);
        _datablock = _GetDataPtr();
        _loadedsize = size;
    }

    bool GetHasKeySignature();

    bool GetHasTimeSignature();

    eKey GetKeySignatureID();

    twobyte GetTimeSignatureBeats();

    twobyte GetTimeSignatureBeatDuration();

    bool GetTimeSignatureCompositeTop();

    bool GetTimeSignatureCompositeBottom();


        void SetHasKeySignature(bool state);

        void SetHasTimeSignature(bool state);

    void SetKeySignatureID(eKey value);

    void SetTimeSignatureBeats(twobyte beats);

    void SetTimeSignatureBeatDuration(twobyte beatduration);

    void SetTimeSignatureCompositeTop(bool state);

    void SetTimeSignatureCompositeBottom(bool state);

        void SetFullTimeSignature(FCTimeSignature* pTimeSig);

        void SetFullKeySignature(FCKeySignature* pKeySig);

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





#endif  /* FF_CELLDETAILS_H */