ff_noteframe.h

/*
 * File:   ff_noteframe.h
 * Author: Jari Williamsson
 *
 * Created on den 18 november 2010, 01:20
 */

#ifndef FF_NOTEFRAME_H
#define FF_NOTEFRAME_H

#include "ff_basecollection.h"


#ifdef PDK_FRAMEWORK_ENTRIES
class FCNoteEntry;

class FCNote : public __FCBase
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        bool _shouldbeerased;

    int _index;
    EXNOTE* _pNote;
    FCNoteEntry* _pEntry;

    void _SetNoteFlag(FLAG_32 flag, bool state)
            { Set32BitFlag(&_pNote->flag, flag, state); }

    bool _GetNoteFlag(FLAG_32 flag) const { return GetBitFlag(_pNote->flag, flag); }

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

    public:
        virtual const char* ClassName() { return "FCNote"; }

        FCNote(int index, EXNOTE* pexnote, FCNoteEntry* pParent) : __FCBase()
        {
            _index = index;
            _pNote = pexnote;
            _pEntry = pParent;
            _shouldbeerased = false;
        }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

        ENTNUM _GetEntryNumber();

        EXNOTE* _GetEXNOTE() { return _pNote; }

                void _UpdateEXNOTE(EXNOTE* pNote) { _pNote = pNote;  }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */


        FCNoteEntry* GetEntry() const { return _pEntry; }

        bool GetAccidental() const { return _GetNoteFlag(NF_ACCIBIT); }

        bool GetAccidentalFreeze() const { return _GetNoteFlag(NF_FREEZEACCI); }

        bool GetAccidentalParentheses() const { return _GetNoteFlag(NF_PARENACCI); }

        twobyte GetDisplacement() const 
                { 
#ifdef PDK_FRAMEWORK_DIAGNOSE
                        if ((_pNote->noteID < 0) || (_pNote->noteID > 32))
                        {
                                DebugOutDigit("Illegal Note ID value in FCNote::GetDisplacement(): ", _pNote->noteID);
                        }
#endif
                        return _pNote->tcd; 
                }

        bool GetLegality() const { return _GetNoteFlag(NF_VALID); }

        twobyte GetRaiseLower() const { return _pNote->alteration; }

        bool GetSpacing() const { return !_GetNoteFlag(NF_NOSPACING); }

        bool GetPlayback() const { return !_GetNoteFlag(NF_NOPLAYBACK); }

        bool GetTie() const { return _GetNoteFlag(NF_TIESTART); }

        bool GetTieBackwards() const { return _GetNoteFlag(NF_TIEEND); }

        bool GetCrossStaff() const { return _GetNoteFlag(NF_CROSSBIT); }

        eNoteID GetNoteID() const { return _pNote->noteID; }

#ifdef PDK_FRAMEWORK_PREFS

        void GetString(FCString* pString, FCKeySignature* pKey, bool simplifydoublesharp = false,
                        bool writtenpitch = false);

        bool CalcAccidental() const;

        twobyte CalcOctave(FCKeySignature* pKey, int transposeinterval = 0);
    
        twobyte CalcWrittenOctave(FCKeySignature* pKey, int transposevalue, bool simplifytranspose, bool chromatictranspose);

        bool SetString(FCString* pString, FCKeySignature* pKey, bool writtenpitch);

#endif // #ifdef PDK_FRAMEWORK_PREFS

        void SetAccidental(bool state) { _SetNoteFlag(NF_ACCIBIT, state); }

        void SetAccidentalFreeze(bool state) { _SetNoteFlag(NF_FREEZEACCI, state); }

        void SetAccidentalParentheses(bool state) { _SetNoteFlag(NF_PARENACCI, state); }

        void SetSpacing(bool state) { _SetNoteFlag(NF_NOSPACING, !state); }

        void SetPlayback(bool state) { _SetNoteFlag(NF_NOPLAYBACK, !state); }

        void SetLegality(bool state) { _SetNoteFlag(NF_VALID, state); }

        void SetDisplacement(twobyte disp) { _pNote->tcd = disp; }

        void SetRaiseLower(twobyte amount) { _pNote->alteration = amount; }

        void SetNoteID(eNoteID noteid)
        {
            _pNote->noteID = noteid;
        }

        void SetTie(bool value) { _SetNoteFlag(NF_TIESTART, value); }

        void SetTieBackwards(bool value) { _SetNoteFlag(NF_TIEEND, value); }

        void SetCrossStaff(bool state) { _SetNoteFlag(NF_CROSSBIT, state); }

        bool CalcOnLedgerLine();

        int CalcCrossStaffNumber();

        bool CalcRightsidePlacement();

        twobyte CalcNoteheadWidth();

        twobyte CalcStaffPosition();

        char CalcPitchChar();

        char CalcWrittenPitchChar();

        twobyte CalcPitchRaiseLower(bool writtenpitch);

        twobyte CalcMIDIKey();

#ifdef PDK_FRAMEWORK_PREFS

        void SetMIDIKey(twobyte midikey);
#endif

        bool IsIdenticalPitch(FCNote* pPitchNote);

        bool IsHigherPitchThan(FCNote* pPitchCompareNote);

        bool IsLowerPitchThan(FCNote* pPitchCompareNote);

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

        void _SetNoteDetailEntryFlag(bool state);

        bool _GetNoteDetailEntryFlag();

        void _SetPerformanceDataEntryFlag(bool state);

        bool _GetPerformanceDataEntryFlag();

        void _SetSpecialAltsEntryFlag(bool state);

        bool _GetSpecialAltsEntryFlag();


        void _SetCrossStaffEntryFlag(bool state);

        bool _GetCrossStaffEntryFlag();

        void _SetArticulationEntryFlag(bool state);
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

        void MarkForErase() { _shouldbeerased = true; }

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

        bool _GetShouldEraseState() { return _shouldbeerased; }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */


#ifdef PDK_FRAMEWORK_DEBUG
        virtual void DebugDump()
        {
            __FCBase::DebugDump();
            DebugOutDigit("Note ID: ", GetNoteID());
            DebugOutDigit("Displacement: ", GetDisplacement());
            DebugOutDigit("Alteration: ", GetRaiseLower());
        }
#endif
};
#endif  // #ifdef PDK_FRAMEWORK_ENTRIES

#ifdef PDK_FRAMEWORK_ENTRIES

class FCNotePitch : public FCNote
{
    EXNOTE _exnote;
public:
    virtual const char* ClassName() { return "FCNotePitch"; }

    FCNotePitch() : FCNote(0, &_exnote, NULL) {
        memset(&_exnote, 0, sizeof(_exnote));
    }

    void CopyFrom(FCNote* pNote)
    {
        memcpy(&_exnote , pNote->_GetEXNOTE(), sizeof(EXNOTE));
    }
};

class FCNotePitches : public __FCCollection
{
    int _measureno;
    int _staffno;
    int _layerno;
    bool _gracenote;
    int _gracenoteindex;
    int _frameindex;
    TimeEdu32 _edupos;
    ENTNUM _entnum;
    TimeEdu32 _duration;
    TimeEdu32 _actualduration;
public:
    FCNotePitches() : __FCCollection()
    {
        _measureno = 0;
        _staffno = 0;
        _layerno = 0;
        _gracenote = false;
        _gracenoteindex = 0;
        _frameindex = 0;
        _edupos = 0;
        _entnum = 0;
        _duration = 0;
        _actualduration = 0;
    }

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

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

#ifdef PDK_FRAMEWORK_PREFS

    void AddFromEntry(FCNoteEntry* pEntry);
#endif

    void CloneEntryPositionData(FCNoteEntry* pEntry);

    int GetMeasure() { return _measureno; }

    int GetStaff() { return _staffno; }

    int GetLayerNumber() { return _layerno; }

    bool GetGraceNote() { return _gracenote; }

    int GetGraceNoteIndex() { return _gracenoteindex; }

    TimeEdu32 GetMeasurePos() { return _edupos; }

    ENTNUM GetENTNUM() { return _entnum; }

    TimeEdu32 GetDuration() { return _duration; }

    TimeEdu32 GetActualDuration() { return _actualduration; }

    int GetFrameIndex() { return _frameindex; }

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCCollection::DebugDump();
        DebugOutDigit("Measure: ", _measureno);
        DebugOutDigit("Edu position: ", _edupos);
    }
#endif

};
#endif  // #ifdef PDK_FRAMEWORK_ENTRIES


#ifdef PDK_FRAMEWORK_ENTRIES
class FCArticulations;
class FCNoteEntries;
class FCTuplet;
class FCTuplets;
class FCNoteheadMods;
class FCPerformanceMods;

class FCNoteEntry : public __FCCollection
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS    
    EXENTRY*        _pEntryRef;
    EXTGF2005a*     _pFrameRef;
    twobyte         _framemeasure;
    twobyte         _framestaff;
    FCNoteEntry*    _pPreviousEntry;
    FCNoteEntry*    _pNextEntry;
    FCArticulations* _pArticulationCache;

    void _SetXefFlag(FLAG_16 mask, bool state)
    {
        Set16BitFlag(&_pEntryRef->xef, mask, state);
    }

    void _SetEfFlag(FLAG_32 mask, bool state)
    {
        Set32BitFlag(&_pEntryRef->ef, mask, state);
    }

    bool _GetXefFlag(FLAG_32 mask) const
    {
        return GetBitFlag(_pEntryRef->xef, mask);
    }

    bool _GetEfFlag(FLAG_32 mask) const
    {
        return GetBitFlag(_pEntryRef->ef, mask);
    }

    void _UpdateNoteCollection();

    twobyte _FindUniqueNoteID();

#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
public:
    FCNote* GetItemAt(int index) { return (FCNote*) __FCCollection::GetItemAt(index); }


    enum ENTRY_DURATIONS {
        BREVE = 8192,
        WHOLE_NOTE = 4096,
        NOTE_WHOLE = 4096,
        HALF_NOTE = 2048,
        NOTE_HALF = 2048,
        QUARTER_NOTE = 1024,
        NOTE_QUARTER = 1024,
        EIGHTH_NOTE = 512,
        NOTE_8TH = 512,
        SIXTEENTH_NOTE = 256,
        NOTE_16TH = 256,
        THIRTYSECOND_NOTE = 128,
        NOTE_32ND = 128,
        SIXTYFOURTH_NOTE = 64,
        NOTE_64TH = 64,
        NOTE_128TH = 32
    };


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

    FCNoteEntry(EXENTRY* pEntry, EXTGF2005a* pFrame, FCNoteEntry* pPrevious) : __FCCollection()
    {
        _pArticulationCache = NULL;
        _pEntryRef = pEntry;
        _framemeasure = pFrame->meas;
        _framestaff = FX_SlotToInst(pFrame->staffSlot, pFrame->iuList);
        _pFrameRef = pFrame;
        _pPreviousEntry = pPrevious;
        _pNextEntry = NULL;
        _UpdateNoteCollection();
    }

    virtual ~FCNoteEntry();

#ifndef DOXYGEN_SHOULD_SKIP_THIS

    void _AttachNextEntry(FCNoteEntry* pNext) { _pNextEntry = pNext; }

    void _AttachPreviousEntry(FCNoteEntry* pNext) { _pPreviousEntry = pNext; }

    EXENTRY* _GetEXENTRY() { return _pEntryRef; }

    EXTGF2005a* _GetTGFRef() { return _pFrameRef; }

    /* \brief For internal use only.
     *
     * Calculates the index within the TGF frame. Returns -1 if index
     * wasn't found (SHOULD NEVER HAPPEN).
     *  */
    int _CalcTGFIndex();

    void _TGFUpdate(EXTGF2005a* pTGF, EXENTRY* pEntry)
    {
        _pFrameRef = pTGF;
        _pEntryRef = pEntry;
                /* The TGF info for the entry is now updated. 
                * Update the EXNOTE references for all the note objects as well. */
                for (int i = 0; i < GetCount(); i++)
                {
                        FCNote* pNote = GetItemAt(i);
                        pNote->_UpdateEXNOTE(&pEntry->note[i]);
                }
    }

    FCArticulations* _GetArticulationCache() { return _pArticulationCache; }
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/

    
    FCNote* FindNoteID(twobyte noteID);
    

    void SetRestDisplacement(twobyte value);

    twobyte GetRestDisplacement();


    FCNoteEntry* Previous() { return _pPreviousEntry; }

    FCNoteEntry* PreviousInFrame() 
    {
        if (!_pPreviousEntry) return NULL;
        if (_pPreviousEntry->_GetTGFRef() != _GetTGFRef()) return NULL;
        return _pPreviousEntry;
    }

    FCArticulations* CreateArticulations();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCArticulations* CreateArticulations_GC();
#endif

    FCNoteheadMods* CreateNoteheadMods();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCNoteheadMods* CreateNoteheadMods_GC();
#endif

    FCPerformanceMods* CreatePerformanceMods();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCPerformanceMods* CreatePerformanceMods_GC();
#endif

    FCTuplets* CreateTuplets();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCTuplets* CreateTuplets_GC();
#endif

    
    ENTNUM GetEntryNumber() const { return _pEntryRef ? _pEntryRef->entnum : 0; }

#ifndef DOXYGEN_SHOULD_SKIP_THIS

    void _PackEXENTRYNotes();

    bool _GetTupletDef(twobyte inci, EDTTuplet2005* pTuplet);

#ifdef PDK_FRAMEWORK_PREFS

    bool _CalcRestFlippable();

    bool _CalcRestBeamedGroupEnd();
#endif  /* PDK_FRAMEWORK_PREFS */
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/

    void SetNoteFlag(bool state) { _SetEfFlag(EF_NOTEBIT, state); }

    void SetPlayback(bool state) { _SetXefFlag(XEF_NOPLAYBACK, !state); }

    void SetCombineRests(bool state);

    void SetFlipTie(bool state) { _SetEfFlag(EF_FLIPTIE, state); }

    void SetSpacing(bool state) { _SetXefFlag(XEF_NOSPACING, !state); }

    void SetVisible(bool state)  { _SetEfFlag(EF_IGNOREBIT, !state);  }

    void SetGraceNote(bool state) { _SetEfFlag(EF_GRACENOTE, state); }

    void SetVoice2(bool state) { _SetEfFlag(EF_V2BIT, state); }

    void SetVoice2Launch(bool state) { _SetEfFlag(EF_V1CNTLRBIT, state); }

    void SetGraceNoteSlash(bool state) { _SetXefFlag(XEF_SLASHGRACE, state); }

    void SetCrossStaff(bool state) { _SetEfFlag(EF_CROSSSTAFF, state); }

    void SetBeamBeat(bool state) { _SetEfFlag(EF_BEAMBIT, state); }

    void SetFreezeBeam(bool state) { _SetXefFlag(XEF_FREEZEBEAM, state); }

    void SetFlatBeam(bool state) { _SetXefFlag(XEF_FLATBEAM, state); }

    void SetLedgerLines(bool state) { _SetXefFlag(XEF_NOLEGER, !state); }

    void SetFreezeStem(bool state) { _SetEfFlag(EF_FREEZSTEM, state); }

    void SetCheckAccidentals(bool state);

    void SetLegality(bool state) { _SetEfFlag(EF_VALID, state); }

    void SetManualPosition(Evpu16 pos) { _pEntryRef->orgposi = pos; }

    void SetClefIndex(eClef clef) { _pEntryRef->clef = clef; }

    void SetStemUp(bool state) { _SetEfFlag(EF_UPSTEMBIT, state); }

    void SetDuration(TimeEdu32 duration) { _pEntryRef->dura = duration; }

    void SetFloatingRest(bool state)   { _SetEfFlag(EF_FLOATREST, state); }

    void SetNoteDetailFlag(bool state) { _SetEfFlag(EF_NOTEDTAIL, state); }

    void SetPerformanceDataFlag(bool state) { _SetEfFlag(EF_PRFMDATA, state); }

    void SetSpecialAltsFlag(bool state) { _SetEfFlag(EF_DOTTIEALTS, state); }

    void SetArticulationFlag(bool state) { _SetEfFlag(EF_ARTICDTAIL, state); }

    void SetSmartShapeFlag(bool state) { _SetXefFlag(XEF_SMARTSHAPEDETAIL, state); }

    void SetTupletStartFlag(bool state) { _SetEfFlag(EF_TUPLSTART, state); }

    void SetLyricFlag(bool state) { _SetEfFlag(EF_LYRICDETAIL, state); }

    void SetStemDetailFlag(bool state) { _SetEfFlag(EF_STEMDTAIL, state); }

    void SetSecondaryBeamFlag(bool state) { _SetEfFlag(EF_SECBEAMBIT, state); }

    void SetActualDuration(TimeEdu32 value) { _pEntryRef->actdur = value; }

    void SetMeasurePos(TimeEdu32 value) { _pEntryRef->elldur = value; }

    bool GetBeamBeat() const { return _GetEfFlag(EF_BEAMBIT); }

    bool GetCheckAccidentals() const;

    bool GetLedgerLines() const { return !_GetXefFlag(XEF_NOLEGER); }

    bool GetFreezeStem() const { return _GetEfFlag(EF_FREEZSTEM); }

    bool GetLegality() const { return _GetEfFlag(EF_VALID); }

    bool GetFreezeBeam() const { return _GetXefFlag(XEF_FREEZEBEAM); }

    bool GetFlatBeam() const { return _GetXefFlag(XEF_FLATBEAM); }

    bool GetPlayback() const { return !_GetXefFlag(XEF_NOPLAYBACK); }

    bool GetCombineRests() const;

    bool GetFlipTie() const { return _GetEfFlag(EF_FLIPTIE); }

    bool GetSpacing() const { return !_GetXefFlag(XEF_NOSPACING); }

    bool GetVisible() const { return !_GetEfFlag(EF_IGNOREBIT);  }

    bool GetGraceNote() const { return _GetEfFlag(EF_GRACENOTE); }

    bool GetGraceNoteSlash() const { return _GetXefFlag(XEF_SLASHGRACE); }

    bool GetVoice2() const { return _GetEfFlag(EF_V2BIT); }

    bool GetVoice2Launch() const { return _GetEfFlag(EF_V1CNTLRBIT); }

    bool GetStemUp() const { return _GetEfFlag(EF_UPSTEMBIT); }

    bool GetCrossStaff() const { return _GetEfFlag(EF_CROSSSTAFF); }

    TimeEdu32 GetDuration() const { return _pEntryRef->dura; }

    bool GetFloatingRest() const { return _GetEfFlag(EF_FLOATREST); } 

    TimeEdu32 GetActualDuration() const { return _pEntryRef->actdur; }

    TimeEdu32 CalcNondottedDuration()
    {
        TimeEdu32 duration = GetDuration();
        TimeEdu32 timeedu_try = 8192;
        while (timeedu_try)
        {
            if (timeedu_try & duration) return timeedu_try;
            timeedu_try /= 2;
        }
        return 0;
    }

    twobyte CalcDots()
    {
        return CalcDotsForDuration(GetDuration());
    }

    twobyte GetLayerNumber() const { return _pFrameRef->layer + 1; }
    
    Evpu16 GetManualPosition() const { return _pEntryRef->orgposi; }

    eClef GetClefIndex() const { return _pEntryRef->clef; }
    
    int CalcGraceNoteIndex();

    twobyte CalcHighestStaffPosition();

    twobyte CalcHighestDisplacement();
    
    twobyte CalcDisplacementRange();

    twobyte CalcBeamCount()
    {
        TimeEdu32 duration = CalcNondottedDuration();
        if (duration == 0) return 0;
        if (duration > EIGHTH_NOTE) return 0;
        twobyte retvalue = 1;
        TimeEdu32 tryvalue = EIGHTH_NOTE;
        while (tryvalue)
        {
            if (tryvalue == duration) return retvalue;
            retvalue ++;
            tryvalue /= 2;
        }
        return 0;
    }

    bool CalcMultiLayeredCell();
    
    int CalcDisplacementMatchCount(FCNoteEntry* pCompareEntry);

    FCNote* CalcHighestNote(FCNote* pCeiling = NULL);

    FCNote* CalcLowestNote(FCNote* pFloor = NULL);

    bool CalcHiddenThroughAltNotation();

    FCNote* CalcHighestPercussionNote();

    FCNote* CalcLowestPercussionNote();
    
    bool HasSameNotes(FCNoteEntry* pEntry);

    FCNote* FindDisplacement(twobyte displacement);

    FCNote* FindPitch(FCNote* pPitchNote);

    TimeEdu32 GetMeasurePos() const { return _pEntryRef->elldur; }

    bool GetNoteDetailFlag() const { return _GetEfFlag(EF_NOTEDTAIL); }

    bool GetPerformanceDataFlag() const { return _GetEfFlag(EF_PRFMDATA); }

    bool GetSpecialAltsFlag() const { return _GetEfFlag(EF_DOTTIEALTS); }

    bool GetTupletStartFlag() const { return _GetEfFlag(EF_TUPLSTART); }

    bool GetLyricFlag() const { return _GetEfFlag(EF_LYRICDETAIL); }

    bool GetStemDetailFlag() const { return _GetEfFlag(EF_STEMDTAIL); }

    bool GetSecondaryBeamFlag() const { return _GetEfFlag(EF_SECBEAMBIT); }

    bool GetArticulationFlag() const { return _GetEfFlag(EF_ARTICDTAIL); }

    bool GetSmartShapeFlag() const { return _GetXefFlag(XEF_SMARTSHAPEDETAIL); }

    twobyte GetMeasure() const { return _framemeasure; }

    twobyte GetStaff() const { return _framestaff; }

    FCNoteEntry* Next() { return _pNextEntry; }
    
    bool IsNote() { return _GetEfFlag(EF_NOTEBIT); }

    bool IsRest() { return !_GetEfFlag(EF_NOTEBIT); }

    bool IsDotted();
       
    bool IsStartOfTuplet();

    bool IsStartOfTupletParam(TupletInfo* pInfoStorage = NULL);

    bool IsPartOfTuplet();

    bool IsOverlappedEntry(FCNoteEntry* pTestEntry);

    bool IsPartOfTupletParam(TupletInfo* pInfoStorage = NULL);
    
    bool IsLastInMeasure()
    {
        if (!Next()) return true;
        return (Next()->GetMeasure() != GetMeasure());
    }

    FCNoteEntry* CalcLastTupletEntry(FCTuplet* pTuplet);

#ifdef PDK_FRAMEWORK_PREFS

    bool CalcFlippable();

    bool CalcBeamedGroupEnd();

    bool CalcUnbeamedNote();
#endif

#ifdef PDK_FRAMEWORK_PREFS

    FCNoteEntry* CalcBeamStartEntry();
#endif

#ifdef PDK_FRAMEWORK_PREFS

    bool CalcLargestNoteheadResize(FCNumber* pLargestFontSize, FCNumber* pLargestResize);

    bool CalcSmallestNoteheadResize(FCNumber* pSmallestFontSize, FCNumber* pSmallestResize);
#endif

    twobyte CalcWidestNoteheadWidth();

    bool CalcStemUp();

    twobyte CalcResize();
    
    twobyte CalcStemLength();

    static void MarkEntryMetricsForUpdate()
    {
        FCEntryMetrics::MarkMetricsForRebuild();
        FCCellMetrics::MarkMetricsForRebuild();
    }

    static TimeEdu32 CalcNondottedDurationForDuration(TimeEdu32 duration);

    static int CalcDotsForDuration(TimeEdu32 duration);

    static bool IsValidDuration(TimeEdu32 duration);

    static TimeEdu32 CalcValidDuration(TimeEdu32 duration);

    bool IsTied();

    bool IsTiedBackwards();

    bool IsTiedToPrevious();

    bool IsAllTied();

    bool IsAllTiedBackwards();

    void ClearPitches();

    FCNote* AddNewNote();

    int AddPitches(FCNoteEntry* pSourceEntry, bool unique, bool settie = false);

#ifndef PDK_FRAMEWORK_LUAFRIENDLY

    int AddPitches(FCNotePitches* pPitches, bool unique);
#endif
    
    int AddPitch(FCNote* pNote);

    int AddArticulations(FCNoteEntry* pSourceEntry, bool bNoDuplicates = true);

    void TieAll(bool bTie);

    void SetAccidentals(bool bAccidental);

    void CopyNotes(FCNoteEntry* pFrom);
    
    void CopyNote(FCNote* pFrom);

    void CopyEntry(FCNoteEntry* pFromEntry);

    void CopyEntryDetails(FCNoteEntry* pFromEntry, bool copytuplets);

    void CopyEntryPercussionDetails(FCNoteEntry* pFromEntry);

    bool DeleteNote(FCNote* pNote);

    void CacheArticulations();

    bool IsRestMovable();

    void MakeRest();

    void MakeMovableRest();

    void MakeNote();

    FCNoteEntry* CreateShallowClone();

    FCNotePitches* CreateNotePitches();
    
#ifdef PDK_FRAMEWORK_DEBUG
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void DebugOutLocation()
    {
        FCString location("Location - Staff: ");
        location.AppendInteger(GetStaff());
        location.AppendCString("  Measure: ");
        location.AppendInteger(GetMeasure());
        location.AppendCString("  Duration Pos: ");
        location.AppendInteger(GetMeasurePos());
        DebugOut(location.GetCString());
    }

    virtual void DebugDump()
    {
        __FCCollection::DebugDump();
                DebugOutDigit("Entry Number: ", GetEntryNumber());
        DebugOutDigit("Duration position: ", GetMeasurePos());
        DebugOutDigit("Duration: ", GetDuration());
        DebugOutBool("Is note: ", IsNote());
        DebugOutBool("Beam/Beat: ", GetBeamBeat());
        DebugOutBool("Stem goes up: ", CalcStemUp());
        DebugOutBool("Articulation Flag: ", GetArticulationFlag());
    }

    virtual void DebugDataDump()
    {
        __FCCollection::DebugDataDump();
        DebugOutHex("xef: ", _pEntryRef->xef);
        DebugOutHex("ef: ", _pEntryRef->ef);
    }
#endif  /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
#endif

};

#endif // #ifdef PDK_FRAMEWORK_ENTRIES



#ifdef PDK_FRAMEWORK_ENTRIES

class __FCNoteEntryCollection : public __FCCollection
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    void _ClearTGF(EXTGF2005a* pTgf)
    {
        FX_DeleteEXENTRY( pTgf, 0, pTgf->numEntries );
    }

    void _CopyEntries(EXTGF2005a* pSourceTgf, EXTGF2005a* pDestinationTgf);

#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
   
public:
        FCNoteEntry* FindEntryNumber(ENTNUM entnum)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCNoteEntry* pNoteEntry = (FCNoteEntry*) GetItemAt(i);
                        if (pNoteEntry->GetEntryNumber() == entnum) return pNoteEntry;
        }
        return NULL;
    }

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

};
#endif // #ifdef PDK_FRAMEWORK_ENTRIES


#ifdef PDK_FRAMEWORK_ENTRIES

class FCNoteEntries : public __FCNoteEntryCollection
{
public:
    virtual const char* ClassName() { return "FCNoteEntries"; }
};
#endif // #ifdef PDK_FRAMEWORK_ENTRIES

#ifdef PDK_FRAMEWORK_ENTRIES

class FCNoteEntryCell : public __FCNoteEntryCollection
{
    /* Settings that controls the flow of the 'Find' methods. All defaults to ON. */
    bool _findvisible;
    bool _findhidden;
    bool _findnotes;
    bool _findrests;
    bool _findalternatenotation;
    bool _findcutaway;
    bool _findvoice1;
    bool _findvoice2;
    bool _findvoice2launch;
    
    /* For internal use only. Helper method for all the 'Find' methods. */
    bool _ShouldScanEntry(FCNoteEntry* pNoteEntry);
    
public:
    enum LOADLAYERMODES
    {
        LLM_NONE = -3,
        
        LLM_HIDDENLAYERS = -2,
        
        LLM_EVERYLAYER = -1,
        
        LLM_ALLVISIBILELAYERS = 0
        };
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EXTGF2005a* _frames[20];

    int _measure;
    int _staff;

    int _loadlayermode;
    bool _loadmirrors;

    void _SetupEntries();
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

public:
    virtual const char* ClassName() { return "FCNoteEntryCell"; }

    FCNoteEntryCell(int measure, int staff) : __FCNoteEntryCollection()
    {
        /* Set all settings related to the 'Find methods to ON */
        _findvisible = true;
        _findhidden = true;
        _findnotes = true;
        _findrests = true;
        _findalternatenotation = true;
        _findcutaway = true;
        _findvoice1 = true;
        _findvoice2 = true;
        _findvoice2launch = true;
        
        _loadlayermode = (int) LLM_ALLVISIBILELAYERS;  // Load all visible layers
        _loadmirrors = true;
        _measure = measure;
        _staff = staff;
        for (int i = 0; i < FX_GetMaxLayers(); i++) _frames[i] = NULL;
    }

    virtual ~FCNoteEntryCell()
    {
        ClearFrame();
    }

    FCNoteEntry* AppendEntriesInLayer(int layerno, int noofentries);

    bool MoveEntry(FCNoteEntry* pEntry, FCNoteEntryCell* pSourceEntryCell);

    bool CalcEntriesInMultiLayers()
    {
        if (GetCount() == 0) return false;
        FCNoteEntry* pFirstEntry = GetItemAt(0);
        for (int i = 1; i < GetCount(); i++)
        {
            FCNoteEntry* pCheckEntry = GetItemAt(i);
            if (pFirstEntry->GetLayerNumber() != pCheckEntry->GetLayerNumber()) return true;
        }
        return false;
    }

    bool IsLayerContainingEntries(int layerno)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCNoteEntry* pCheckEntry = GetItemAt(i);
            if (pCheckEntry->GetLayerNumber() == layerno) return true;
        }
        return false;
    }

    TimeEdu32 CalcLayerDuration(int layerno)
    {
        if (!_frames[layerno - 1]) return -1;
        return FX_GetTGFDuration(_frames[layerno - 1]);
    }
    
    void ClearFrame()
    {
        ClearAll();
        for (int i = 0; i < FX_GetMaxLayers(); i++)
        {
            if (_frames[i]) FX_FreeTGF(_frames[i]);
            _frames[i] = NULL;
        }
    }

    FCNoteEntry* FindEntryStartPosition(TimeEdu32 pos, int layerno);

    FCNoteEntry* FindCoveredEntry(TimeEdu32 pos, int layerno);

    FCNoteEntry* FindClosestPos(TimeEdu32 pos);
    
    FCNoteEntry* FindNextEntryPos(TimeEdu32 pos);
    
    FCNoteEntry* FindPreviousEntryPos(TimeEdu32 pos);
    
    bool DeleteAllNullEntries();

    bool DeleteEntry(FCNoteEntry* pEntry);

    bool Load();

    bool Save();
    
    FCNoteEntry* GetRegionItemAt(int index, FCMusicRegion* pRegion);

    
    /***********/
    /* GETTERS */
    /***********/
    
    int GetLoadLayerMode() const {  return _loadlayermode; }
    
    bool GetLoadMirrors() const { return _loadmirrors; }
    
    bool GetFindVisible() const { return _findvisible; }
    
    bool GetFindHidden() const { return _findhidden; }
    
    bool GetFindNotes() const { return _findnotes; }
    
    bool GetFindRests() const { return _findrests; }
    
    bool GetFindAlternateNotation() const { return _findalternatenotation; }
    
    bool GetFindCutaway() const { return _findcutaway; }
    
    bool GetFindVoice1() const { return _findvoice1; }
    
    bool GetFindVoice2() const { return _findvoice2; }
    
    bool GetFindVoice2Launch() const { return _findvoice2launch; }
    
    twobyte GetMeasure() const { return _measure; }
    
    twobyte GetStaff() const { return _staff; }
    
    /***********/
    /* SETTERS */
    /***********/
    
    void SetLoadLayerMode(int mode) { _loadlayermode = mode; }
    
    void SetLoadMirrors(bool state) { _loadmirrors = state; }
    
    void SetFindVisible(bool state) { _findvisible = state; }
    
    void SetFindHidden(bool state) { _findhidden = state; }
    
    void SetFindNotes(bool state) { _findnotes = state; }
    
    void SetFindRests(bool state) { _findrests = state; }
    
    void SetFindAlternateNotation(bool state) { _findalternatenotation = state; }
    
    void SetFindCutaway(bool state) { _findcutaway = state; }
    
    void SetFindVoice1(bool state) { _findvoice1 = state; }
    
    void SetFindVoice2(bool state) { _findvoice2 = state; }
    
    void SetFindVoice2Launch(bool state) { _findvoice2launch = state; }
    

    FCNoteEntry* GetItemAt(int index) { return (FCNoteEntry*) __FCNoteEntryCollection::GetItemAt(index); }
};
#endif // #ifdef PDK_FRAMEWORK_ENTRIES

#ifdef PDK_FRAMEWORK_ENTRIES

class FCNoteEntryLayer : public __FCNoteEntryCollection {
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    twobyte _layerindex;
    twobyte _staff;
    twobyte _startmeasure;
    twobyte _endmeasure;

    bool _loadmirrors;
    bool _usevisiblelayeronly;

    int _tgfcounter;
    EXTGF2005a** _tgfarray;

    void _SetupEntries();

    bool _LoadRedir(twobyte layer_redir,
                            twobyte staff_redir,
                            twobyte startmeasure_redir);


    EXTGF2005a* _SilentTGFUpdate(EXTGF2005a* pOldTGF);


    EXTGF2005a* _GetNextTGFRef(EXTGF2005a* pTGF)
    {
        for (int i = 0; i < _tgfcounter - 1; i++)
        {
            if (_tgfarray[i] == pTGF) return _tgfarray[i + 1];
        }
        return NULL;
    }


#endif /* DOXYGEN_SHOULD_IGNORE_THIS */

public:
    virtual const char* ClassName() { return "FCNoteEntryLayer"; }


    FCNoteEntryLayer(twobyte layer, twobyte staff, twobyte startmeas = 1, twobyte endmeas = -1);

    virtual ~FCNoteEntryLayer() {
        ClearFrames();
    }

    void ClearFrames() {
        ClearAll();
        for (int i = 0; i < _tgfcounter; i++) {
            if (_tgfarray[i]) FX_FreeTGF(_tgfarray[i]);
            _tgfarray[i] = NULL;
        }
        delete [] _tgfarray;
        _tgfarray = NULL;
        _tgfcounter = 0;
    }

    bool DeleteAllNullEntries();

        bool DeleteAllRestFrames();

    void ClearAllEntries()
    {
        for (int i = 0; i < _tgfcounter; i++) {
            if (_tgfarray[i]) _ClearTGF(_tgfarray[i]);
        }
        ClearAll();
    }

    twobyte GetLayerIndex() const { return _layerindex; }

    twobyte GetStaff() const { return _staff; }

    twobyte GetStartMeasure() const { return _startmeasure; }

    twobyte GetEndMeasure() const { return _endmeasure; }

    bool GetLoadMirrors() const { return _loadmirrors; }

    bool GetUseVisibleLayer() const { return _usevisiblelayeronly; }

    void SetUseVisibleLayer(bool value) { _usevisiblelayeronly = value; }

    void SetLayerIndex(twobyte layerno);

    void SetLoadMirrors(bool state) { _loadmirrors = state; }
    
    bool Load();

    bool Save();

    FCNoteEntryLayer* CreateCloneEntries(twobyte layerindex_redir,
                            twobyte staff_redir,
                            twobyte startmeasure_redir);

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCNoteEntryLayer* CreateCloneEntries_GC(twobyte layer_redir,
                            twobyte staff_redir,
                            twobyte startmeasure_redir);
#endif


    FCNoteEntries* CreateRegionEntries(FCMusicRegion* pRegion);


    FCNoteEntry* InsertEntriesBefore(FCNoteEntry* pPositionEntry, int count);

    FCNoteEntry* InsertEntriesAfter(FCNoteEntry* pPositionEntry, int count, bool nextmeasure = false);


    bool CloneTuplets(FCNoteEntryLayer* pSource);


    bool IsInSuccession(FCNoteEntry* pEntry1, FCNoteEntry* pEntry2)
    {
        if (pEntry1->Next() != pEntry2) return false;
        if ((pEntry2->GetMeasure() - pEntry1->GetMeasure()) > 1) return false;
        return true;
    }
    
    TimeEdu32 CalcFrameDuration(int measurenumber);

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

    int CalcRegionCount(FCMusicRegion* pRegion);

    FCNoteEntry* GetRegionItemAt(int index, FCMusicRegion* pRegion);

    int ForEachInRegion(FCIteratorHandler* pIterator, FCMusicRegion* pRegion);

    FCNoteEntry* GetItemAt(int index) { return (FCNoteEntry*) __FCNoteEntryCollection::GetItemAt(index); }
#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCNoteEntryCollection::DebugDump();
        __FCBase::DebugDump();
        DebugOutDigit("Layer: ", GetLayerIndex());
        DebugOutDigit("Staff: ", GetStaff());
        DebugOutDigit("Start measure: ", GetStartMeasure());
        DebugOutDigit("End measure: ", GetEndMeasure());
        DebugOutDigit("TGF Frame counter: ", _tgfcounter);
        for (int i = 0; i < _tgfcounter; i++) {
            if (_tgfarray[i])
            {
                DebugOutDigit("=> TGF No", i);
                DebugOutDigit("===> .frame ", _tgfarray[i]->frame);
                DebugOutDigit("===> .inst ", _tgfarray[i]->inst);
                DebugOutDigit("===> .staffSlot ", _tgfarray[i]->staffSlot);
                DebugOutDigit("===> .meas ", _tgfarray[i]->meas);
            }
        }
    }
#endif
};


class FCNoteEntryLayers : public __FCCollection
{
    int _staffno;
    int _startmeasure;
    int _endmeasure;

    bool _usevisiblelayersonly;
public:

    FCNoteEntryLayers(twobyte staff, twobyte startmeas = 1, twobyte endmeas = -1)
    {
        _staffno = staff;
        _startmeasure = startmeas;
        _endmeasure = endmeas;
        _usevisiblelayersonly = true;
    }

    bool LoadAll()
    {
        bool result = false;
        for (int layer = 0; layer < FX_GetMaxLayers(); layer++)
        {
            FCNoteEntryLayer* pNoteEntryLayer = new FCNoteEntryLayer(layer, _staffno, _startmeasure, _endmeasure);
            pNoteEntryLayer->SetUseVisibleLayer(_usevisiblelayersonly);
            if (pNoteEntryLayer->Load()) result = true;
            Add(pNoteEntryLayer);
        }
        return result;
    }

    bool SaveAll()
    {        
        for (int layeridx = 0; layeridx < GetCount(); layeridx++)
        {
            FCNoteEntryLayer* pLayer = (FCNoteEntryLayer*) GetItemAt(layeridx);
            if (!pLayer->Save()) return false;
        }
        return true;
    }


    void SetUseVisibleLayersOnly(bool value)
    {
        _usevisiblelayersonly = value;
    }

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



#endif // #ifdef PDK_FRAMEWORK_ENTRIES


#endif  /* FF_NOTEFRAME_H */