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 FCTransposer;
 
class FCNote : public __FCBase
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        bool _shouldbeerased;
 
    int _index;
    EXNOTE* _pNote;
    FCNoteEntry* _pEntry;
    std::unique_ptr<FCTransposer> _pTransposer;
 
    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:
        const char* ClassName() const override { 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))
                        {
                                DebugOutInt("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); }
 
        bool GetDownstem2nd() const { return _GetNoteFlag(NF_DWSECBIT); }
 
        bool GetUpstem2nd() const { return _GetNoteFlag(NF_UPSECBIT); }
 
        bool GetUpstemSplit() const { return _GetNoteFlag(NF_UPSPBIT); }
 
        eNoteID GetNoteID() const { return _pNote->noteID; }
    
        int GetNoteIndex() const { return _index; }
 
#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
    
        FCTransposer* GetTransposer();
    
        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); }
 
        void SetUpstemSplit(bool state) { _SetNoteFlag(NF_UPSPBIT, state); }
    
        int CalcNumberOfLedgerLines();
 
        bool CalcOnLedgerLine();
 
        int CalcCrossStaffNumber();
 
        bool CalcRightsidePlacement();
 
        twobyte CalcNoteheadWidth();
 
        twobyte CalcStaffPosition();
 
        char CalcPitchChar();
 
        char CalcWrittenPitchChar();
 
        twobyte CalcPitchRaiseLower(bool writtenpitch);
 
        twobyte CalcMIDIKey();
    
        bool CalcVisibleInPart() const;
    
        bool CalcIsTopNote() const;
    
        bool CalcIsBottomNote() const;
 
#ifdef PDK_FRAMEWORK_PREFS
        void SetMIDIKey(twobyte midikey);
#endif
 
        bool IsIdenticalPitch(FCNote* pPitchNote);
 
        bool IsHigherPitchThan(FCNote* pPitchCompareNote);
 
        bool IsLowerPitchThan(FCNote* pPitchCompareNote);
    
        bool IsUpper2nd() const;
    
        bool IsLower2nd() const;
    
        bool IsNonAligned2nd() const;
    
        bool MatchSpellingToScore();
 
#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
        void DebugDump() override
        {
            __FCBase::DebugDump();
            DebugOutInt("Note ID: ", GetNoteID());
            DebugOutInt("Displacement: ", GetDisplacement());
            DebugOutInt("Alteration: ", GetRaiseLower());
        }
#endif
};
#endif  // #ifdef PDK_FRAMEWORK_ENTRIES
 
#ifdef PDK_FRAMEWORK_ENTRIES
class FCNotePitch : public FCNote
{
    EXNOTE _exnote;
public:
    const char* ClassName() const override { 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) const { return (FCNotePitch*) __FCCollection::GetItemAt(index); }
 
    const char* ClassName() const override { return "FCNotePitches"; }
 
#ifdef PDK_FRAMEWORK_PREFS
    void AddFromEntry(FCNoteEntry* pEntry);
 
        void AddFromCellEntry(FCNoteEntry* pEntry, FCNoteEntryCell* pNoteEntryCell);
#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
    void DebugDump() override
    {
        __FCCollection::DebugDump();
        DebugOutInt("Measure: ", _measureno);
        DebugOutInt("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)
    {
        if (_pEntryRef)
            Set16BitFlag(&_pEntryRef->xef, mask, state);
    }
 
    void _SetEfFlag(FLAG_32 mask, bool state)
    {
        if (_pEntryRef)
            Set32BitFlag(&_pEntryRef->ef, mask, state);
    }
 
    bool _GetXefFlag(FLAG_32 mask) const
    {
        return (_pEntryRef) ? GetBitFlag(_pEntryRef->xef, mask) : false;
    }
 
    bool _GetEfFlag(FLAG_32 mask) const
    {
        return (_pEntryRef) ? GetBitFlag(_pEntryRef->ef, mask) : false;
    }
 
    void _UpdateNoteCollection();
 
    twobyte _FindUniqueNoteID();
    
    bool _CanBeBeamed() const;
    
    template<FCNoteEntry* (FCNoteEntry::*ITERATOR)()>
    FCNoteEntry* _IteratePotentialEntryInBeam();
    
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#ifdef PDK_FRAMEWORK_PREFS
    template<FCNoteEntry* (FCNoteEntry::*ITERATOR)()>
    std::optional<int> _IterateFindRestsInSecondaryBeam(FCNoteEntry* pNextOrPrevInBeam);
#endif // PDK_FRAMEWORK_PREFS
#endif // DOXYGEN_SHOULD_SKIP_THIS
    
    FCNoteEntry* _NextPotentialInBeam()
    {
        FCNoteEntry* pNext = _IteratePotentialEntryInBeam<&FCNoteEntry::NextSameVInFrame>();
        if (pNext && pNext->GetBeamBeat()) return nullptr;
        return pNext;
    }
    
    FCNoteEntry* _PreviousPotentialInBeam()
    {
        if (GetBeamBeat()) return nullptr;
        return _IteratePotentialEntryInBeam<&FCNoteEntry::PreviousSameVInFrame>();
    }
    
#ifdef PDK_FRAMEWORK_PREFS
    template<FCNoteEntry* (FCNoteEntry::*ITERATOR)(), FCNoteEntry* (FCNoteEntry::*REVERSE_ITERATOR)()>
    FCNoteEntry* _IterateBeamGroup();
#endif
    
    
#if PDK_FRAMEWORK_PREFS
    twobyte _CalcVisibleBeams();
#endif
    
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
 
public:
    FCNote* GetItemAt(int index) const { 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
    };
 
 
    const char* ClassName() const override { 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;
    }
    
    FCNoteEntry* PreviousSameVInFrame();
    
#ifdef PDK_FRAMEWORK_PREFS
    FCNoteEntry* NextInBeamedGroup()
    { return _IterateBeamGroup<&FCNoteEntry::_NextPotentialInBeam, &FCNoteEntry::_PreviousPotentialInBeam>(); }
#endif
    
#ifdef PDK_FRAMEWORK_PREFS
    FCNoteEntry* PreviousInBeamedGroup()
    { return _IterateBeamGroup<&FCNoteEntry::_PreviousPotentialInBeam, &FCNoteEntry::_NextPotentialInBeam>(); }
#endif
    
    FCArticulations* CreateArticulations();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCArticulations> CreateArticulations_GC()
    { return makeLuaSharedPtr(CreateArticulations()); }
#endif
 
    FCNoteheadMods* CreateNoteheadMods();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCNoteheadMods> CreateNoteheadMods_GC()
    { return makeLuaSharedPtr(CreateNoteheadMods()); }
#endif
 
    FCPerformanceMods* CreatePerformanceMods();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCPerformanceMods> CreatePerformanceMods_GC()
    { return makeLuaSharedPtr(CreatePerformanceMods()); }
#endif
 
    FCTuplets* CreateTuplets();
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCTuplets> CreateTuplets_GC()
    { return makeLuaSharedPtr(CreateTuplets()); }
#endif
 
    
    ENTNUM GetEntryNumber() const { return _pEntryRef ? _pEntryRef->entnum : 0; }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void _PackEXENTRYNotes();
 
    bool _GetTupletDef(twobyte inci, EDTTuplet2005* pTuplet);
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
    
    bool RelinkToCurrentView();
    
    bool RelinkToScore();
 
    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 SetSplitRest(bool state) { _SetEfFlag(EF_SPLITREST, 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 SetReverseUpStem(bool state) { _SetEfFlag(EF_REVUPSTEMBIT, state); }
 
    void SetReverseDownStem(bool state) { _SetEfFlag(EF_REVDWSTEMBIT, state); }
 
    void SetSplitStem(bool state) { _SetEfFlag(EF_SPLITSTEM, 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)
    {
        // When the TGF is saved, Finale apparently does some cleanup that removes
        // any orphanded EXNOTE values, so setting this to `true` is sufficient,
        // provided the entry is already a rest.
        _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 SetBeamExtensionFlag(bool state) { _SetEfFlag(EF_BMEXTDTAIL, 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 GetReverseUpStem() const { return _GetEfFlag(EF_REVUPSTEMBIT); }
 
    bool GetReverseDownStem() const { return _GetEfFlag(EF_REVDWSTEMBIT); }
 
    bool GetSplitStem() const { return _GetEfFlag(EF_SPLITSTEM); }
 
    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 GetSplitRest() const { return _GetEfFlag(EF_SPLITREST); }
 
    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());
    }
 
#ifdef PDK_FRAMEWORK_PREFS
        bool CalcUniquePitchString(FCString* pString);
#endif
 
    twobyte GetLayerNumber() const { return _pFrameRef->layer + 1; }
    
    Evpu16 GetManualPosition() const { return _pEntryRef->orgposi; }
 
    eClef GetClefIndex() const { return _pEntryRef->clef; }
    
    int CalcGraceNoteIndex();
    
    int CalcNumberOfVisibleNotes() const;
    
    bool CalcDisplaysAsRest() const
    {
        return (IsRest() || CalcNumberOfVisibleNotes() == 0);
    }
 
    twobyte CalcHighestStaffPosition();
    
    twobyte CalcLowestStaffPosition();
 
    twobyte CalcHighestDisplacement();
 
        twobyte CalcLowestDisplacement();
    
    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 GetBeamExtensionFlag() const { return _GetEfFlag(EF_BMEXTDTAIL); }
 
    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; }
 
    FCNoteEntry* NextInFrame()
    {
        if (!_pNextEntry) return NULL;
        if (_pNextEntry->_GetTGFRef() != _GetTGFRef()) return NULL;
        return _pNextEntry;
    }
    
    FCNoteEntry* NextSameVInFrame();
 
    bool IsNote() { return _GetEfFlag(EF_NOTEBIT); }
 
    bool IsRest() const { return !_GetEfFlag(EF_NOTEBIT); }
 
    bool IsDotted();
       
    bool IsStartOfTuplet();
 
        bool IsSameMeasurePosAs(FCNoteEntry* pCompareEntry);
 
    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
    int CalcLowestBeamStart();
#endif
 
#ifdef PDK_FRAMEWORK_PREFS
    int CalcLowestBeamEnd();
#endif
 
#ifdef PDK_FRAMEWORK_PREFS
    int CalcLowestBeamStub();
#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());
    }
 
    void DebugDump() override
    {
        __FCCollection::DebugDump();
                DebugOutInt("Entry Number: ", GetEntryNumber());
        DebugOutInt("Duration position: ", GetMeasurePos());
        DebugOutInt("Duration: ", GetDuration());
        DebugOutBool("Is note: ", IsNote());
        DebugOutBool("Beam/Beat: ", GetBeamBeat());
        DebugOutBool("Stem goes up: ", CalcStemUp());
        DebugOutBool("Articulation Flag: ", GetArticulationFlag());
    }
 
    void DebugDataDump() override
    {
        __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:
    const char* ClassName() const override { return "__FCNoteEntryCollection"; }
    
        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) const { return (FCNoteEntry*) __FCCollection::GetItemAt(index); }
 
};
#endif // #ifdef PDK_FRAMEWORK_ENTRIES
 
 
#ifdef PDK_FRAMEWORK_ENTRIES
class FCNoteEntries : public __FCNoteEntryCollection
{
public:
    const char* ClassName() const override { 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);
        
        /* The note entry (and cell metrics) metrics for the full cell. */
        bool _loadedmetrics;
        FCNoteEntryCellMetrics _noteentrycellmetrics;
 
        /* For internal use only. Makes sure that the metrics for the whole TGF is loaded. */
        void _AssureLoadedEntryCellMetrics();
 
public:
    enum LOADLAYERMODES
    {
        LLM_NONE = -3,
        
        LLM_HIDDENLAYERS = -2,
        
        LLM_EVERYLAYER = -1,
        
        LLM_ALLVISIBILELAYERS = 0
        };
private:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    std::vector<EXTGF2005a*> _frames;
 
    int _measure;
    int _staff;
 
    int _loadlayermode;
    bool _loadmirrors;
 
    void _SetupEntries();
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
public:
    const char* ClassName() const override { return "FCNoteEntryCell"; }
 
    FCNoteEntryCell(int measure, int staff) : __FCNoteEntryCollection(), _frames(FX_GetMaxLayers())
    {
                /* Force metrics to load */
                _loadedmetrics = false;
 
        /* 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;
    }
 
    virtual ~FCNoteEntryCell()
    {
        ClearFrame();
    }
 
    FCNoteEntry* AppendEntriesInLayer(int layerno, int noofentries);
 
    bool MoveEntry(FCNoteEntry* pEntry, FCNoteEntryCell* pSourceEntryCell);
 
        bool CalcAccidental(FCNoteEntry* pEntry, FCNote* pNote);        
 
    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);
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        /* Only for internal use! */
        EXTGF2005a* _GetEXTGF(int index) { return _frames[index]; }
        
        /* Old (unoptimized) code */
        bool _DeleteAllNullEntriesOld();
#endif // DOXYGEN_SHOULD_IGNORE_THIS
   
    bool DeleteAllNullEntries();
 
    bool DeleteEntry(FCNoteEntry* pEntry);
 
    bool Load();
 
    bool Save();
    
    FCNoteEntry* GetRegionItemAt(int index, FCMusicRegion* pRegion);
 
    bool ReduceEntries()
    {
        for (auto frame : _frames)
        {
            if (frame && !frame->isMirror)
                FX_ReduceEntries(frame);
        }
        _SetupEntries();
        return Save();
    }
    
    /***********/
    /* 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) const { 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;
    }
 
        /* Utility method for _DeleteAllRestFramesMethod() */
        bool _RestsHasAttachedData(FCNoteEntry* pEntry);
 
        /* Utility method for #DeleteAllRestFrames and #DeleteAllNonconnectedRestFrames */
        bool _DeleteAllRestFramesMethod(bool keepentryattachedrestframes);
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 
public:
    const char* ClassName() const override { return "FCNoteEntryLayer"; }
 
 
    FCNoteEntryLayer(twobyte layerindex, 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();
 
        bool DeleteAllNonconnectedRestFrames();
 
    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_CPP
    luabridge::RefCountedPtr<FCNoteEntryLayer> CreateCloneEntries_GC(twobyte layer_redir,
                            twobyte staff_redir,
                            twobyte startmeasure_redir)
    { return makeLuaSharedPtr(CreateCloneEntries(layer_redir, staff_redir, 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) const { return (FCNoteEntry*) __FCNoteEntryCollection::GetItemAt(index); }
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCNoteEntryCollection::DebugDump();
        __FCBase::DebugDump();
        DebugOutInt("Layer: ", GetLayerIndex());
        DebugOutInt("Staff: ", GetStaff());
        DebugOutInt("Start measure: ", GetStartMeasure());
        DebugOutInt("End measure: ", GetEndMeasure());
        DebugOutInt("TGF Frame counter: ", _tgfcounter);
        for (int i = 0; i < _tgfcounter; i++) {
            if (_tgfarray[i])
            {
                DebugOutInt("=> TGF No", i);
                DebugOutInt("===> .frame ", _tgfarray[i]->frame);
                DebugOutInt("===> .inst ", _tgfarray[i]->inst);
                DebugOutInt("===> .staffSlot ", _tgfarray[i]->staffSlot);
                DebugOutInt("===> .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) const
    {
        return (FCNoteEntryLayer*) __FCCollection::GetItemAt(index);
    }
};
 
 
 
#endif // #ifdef PDK_FRAMEWORK_ENTRIES
 
 
#endif  /* FF_NOTEFRAME_H */