fflua_luaiterator.h

/*
 * File: fflua_luaiterator.h
 *
 *  Created by Jari Williamsson on 2015-11-04.
 *
 * ******* IMPORTANT!!! ******
 * Although this file is available in the PDK Framework folder, it should NOT be used in
 * the PDK Framework umbrella. This file is placed in the framework folder purely ONLY to
 * provide online documentation for the FCLuaIterator class!
 *
 * (The file will ONLY make sense in the context of the specific
 * LuaBridge connection implementation.)
 *
 * The following class implementation is for the special FCLuaIterator class in JW and RGP Lua. Since
 * a limitation of LuaBridge is that the include file can only be included at one place,
 * this work-around is used.
 *
 * If you include this header you must provide a LuaRun_ExceptionAbort function that prints the error
 * in the Lua output stream, disconnects and disposes of the Lua state, and displays the message to the user.
 * You can use lua_getstack to determine if LuaRun_ExceptionAbort is running under Lua and should throw the exception
 * up the chain rather than taking other actions.
 */
 
#ifndef jwlua_fflua_luaiterator_h
#define jwlua_fflua_luaiterator_h
 
class FCLuaIterator : public __FCBase
{
public:
    const char* ClassName() const override { return "FCLuaIterator"; }
 
        enum LUAITERATOR_ENTRYFILTERS
        {
                LIEFILTER_NOTE = 0,
 
                LIEFILTER_REST,
 
                LIEFILTER_CHORD,
 
                LIEFILTER_SINGLENOTE,
 
                LIEFILTER_ARTICULATIONFLAG,
 
                LIEFILTER_SMARTSHAPEFLAG,
 
                LIEFILTER_NOTEDETAILFLAG,
 
                LIEFILTER_PERFORMANCEDATAFLAG,
 
                LIEFILTER_SPECIALALTSFLAG,
 
                LIEFILTER_TUPLETSTARTFLAG,
 
                LIEFILTER_LYRICFLAG,
 
                LIEFILTER_STEMDETAILFLAG,
 
                LIEFILTER_SECONDARYBEAMFLAG,
 
                LIEFILTER_GRACENOTE,
                
                LIEFILTER_DOTTED,
                        
                LIEFILTER_DURWHOLE,
        
                LIEFILTER_DURHALF,
        
                LIEFILTER_DURQUARTER,
        
                LIEFILTER_DUR8TH,
 
                LIEFILTER_DUR16TH,
        
                LIEFILTER_DUR32ND,
        
                LIEFILTER_DUR64TH
        };
    
    enum LUAITERATOR_NOTEFILTERS
    {
        LINFILTER_TIE,
        
        LINFILTER_ACCIDENTAL,
        
        LINFILTER_ACCIDENTALPARENTHESES,
        
        LINFILTER_ACCIDENTALFREEZE
    };
 
    
        enum LUAITERATOR_LOGICMETHOD
        {
                LILOGIC_AND = 0,
 
                LILOGIC_OR = 1,
 
                LILOGIC_NOT = 2
        };
        
private:
    enum CLASS_APPROACHES
    {
        CLASSAPPROACH_NONE = 0,
        CLASSAPPROACH_ENTRYDETAILS,     /* Entry-attached data */
        CLASSAPPROACH_NOTEDETAILS,      /* Note-attached data */
        CLASSAPPROACH_MEASUREDETAILS,   /* Measure-attached data*/
        CLASSAPPROACH_CELLDETAILS       /* Cell-attached data */
    };
 
    
    
    /*********************************************/
        /* Classes for adding/removing entry filters */
    /*********************************************/
    
        class _FCLuaIterEntryFilter : public __FCBase
        {
                LUAITERATOR_ENTRYFILTERS _entryfilter;
        public:
        const char* ClassName() const override { return "_FCLuaIterEntryFilter"; }
 
        _FCLuaIterEntryFilter(LUAITERATOR_ENTRYFILTERS value) : __FCBase() { _entryfilter = value; }
 
                LUAITERATOR_ENTRYFILTERS GetFilter() { return _entryfilter; }
        };
 
        class _FCLuaIterEntryFilters : public __FCCollection
        {
        public:
        const char* ClassName() const override { return "_FCLuaIterEntryFilters"; }
 
        _FCLuaIterEntryFilters() : __FCCollection() {}
 
 
                _FCLuaIterEntryFilter* GetItemAt(int index) const { return (_FCLuaIterEntryFilter*)__FCCollection::GetItemAt(index); }
 
                _FCLuaIterEntryFilter* Find(LUAITERATOR_ENTRYFILTERS filter)
                {
                        for (int i = 0; i < GetCount(); i++)
                        {
                                _FCLuaIterEntryFilter* pItem = GetItemAt(i);
                                if (pItem->GetFilter() == filter) return pItem;
                        }
                        return NULL;
                }
 
                bool AddFilter(LUAITERATOR_ENTRYFILTERS filter)
                {
                        if (Find(filter)) return false;
                        Add(new _FCLuaIterEntryFilter(filter));
                        return true;
                }
 
                bool RemoveFilter(LUAITERATOR_ENTRYFILTERS filter)
                {
                        _FCLuaIterEntryFilter* pItem = Find(filter);
                        if (!pItem) return false;
                        int index = GetIndexOf(pItem);
                        if (index == -1) return false;  /* Should never occur, but to be safe... */
                        ClearItemAt(index);
            return true;
                }
        };
 
    /********************************************/
        /* Classes for adding/removing note filters */
    /********************************************/
    
        class _FCLuaIterNoteFilter : public __FCBase
        {
                LUAITERATOR_NOTEFILTERS _notefilter;
        public:
        const char* ClassName() const override { return "_FCLuaIterNoteFilter"; }
 
        _FCLuaIterNoteFilter(LUAITERATOR_NOTEFILTERS value) : __FCBase() { _notefilter = value; }
        
                LUAITERATOR_NOTEFILTERS GetFilter() { return _notefilter; }
        };
    
        class _FCLuaIterNoteFilters : public __FCCollection
        {
        public:
        const char* ClassName() const override { return "_FCLuaIterNoteFilters"; }
 
        _FCLuaIterNoteFilters() : __FCCollection() {}
        
        
                _FCLuaIterNoteFilter* GetItemAt(int index) const { return (_FCLuaIterNoteFilter*)__FCCollection::GetItemAt(index); }
        
                _FCLuaIterNoteFilter* Find(LUAITERATOR_NOTEFILTERS filter)
                {
                        for (int i = 0; i < GetCount(); i++)
                        {
                                _FCLuaIterNoteFilter* pItem = GetItemAt(i);
                                if (pItem->GetFilter() == filter) return pItem;
                        }
                        return NULL;
                }
        
                bool AddFilter(LUAITERATOR_NOTEFILTERS filter)
                {
                        if (Find(filter)) return false;
                        Add(new _FCLuaIterNoteFilter(filter));
                        return true;
                }
        
                bool RemoveFilter(LUAITERATOR_NOTEFILTERS filter)
                {
                        _FCLuaIterNoteFilter* pItem = Find(filter);
                        if (!pItem) return false;
                        int index = GetIndexOf(pItem);
                        if (index == -1) return false;  /* Should never occur, but to be safe... */
                        ClearItemAt(index);
            return true;
                }
        };
 
    
    /**********************************************************/
        /* Classes for adding/removing alternate notation filters */
    /**********************************************************/
        class _FCLuaIterAltNotationFilter : public __FCBase
        {
                __FCStaffBase::ALTERNATE_STAFF _altnotationfilter;
        public:
        const char* ClassName() const override { return "_FCLuaIterAltNotationFilter"; }
 
        _FCLuaIterAltNotationFilter(__FCStaffBase::ALTERNATE_STAFF value) : __FCBase() { _altnotationfilter = value; }
        
                __FCStaffBase::ALTERNATE_STAFF GetFilter() { return _altnotationfilter; }
        };
    
        class _FCLuaIterAltNotationFilters : public __FCCollection
        {
        public:
        const char* ClassName() const override { return "_FCLuaIterAltNotationFilters"; }
 
        _FCLuaIterAltNotationFilters() : __FCCollection() {}
        
        _FCLuaIterAltNotationFilter* GetItemAt(int index) const { return (_FCLuaIterAltNotationFilter*)__FCCollection::GetItemAt(index); }
        
                _FCLuaIterAltNotationFilter* Find(__FCStaffBase::ALTERNATE_STAFF filter)
                {
                        for (int i = 0; i < GetCount(); i++)
                        {
                                _FCLuaIterAltNotationFilter* pItem = GetItemAt(i);
                                if (pItem->GetFilter() == filter) return pItem;
                        }
                        return NULL;
                }
        
                bool AddFilter(__FCStaffBase::ALTERNATE_STAFF filter)
                {
                        if (Find(filter)) return false;
                        Add(new _FCLuaIterAltNotationFilter(filter));
                        return true;
                }
        
                bool RemoveFilter(__FCStaffBase::ALTERNATE_STAFF filter)
                {
                        _FCLuaIterAltNotationFilter* pItem = Find(filter);
                        if (!pItem) return false;
                        int index = GetIndexOf(pItem);
                        if (index == -1) return false;  /* Should never occur, but to be safe... */
                        ClearItemAt(index);
            return true;
                }
    };
 
        /******************************************************/
        /* Classes for adding/removing notation style filters */
        /******************************************************/
        class _FCLuaIterNotationStyleFilter : public __FCBase
        {
                __FCStaffBase::STAFFNOTATION_STYLE _notationstylefilter;
        public:
        const char* ClassName() const override { return "_FCLuaIterNotationStyleFilter"; }
 
        _FCLuaIterNotationStyleFilter(__FCStaffBase::STAFFNOTATION_STYLE value) : __FCBase() { _notationstylefilter = value; }
 
                __FCStaffBase::STAFFNOTATION_STYLE GetFilter() { return _notationstylefilter; }
        };
 
        class _FCLuaIterNotationStyleFilters : public __FCCollection
        {
        public:
        const char* ClassName() const override { return "_FCLuaIterNotationStyleFilters"; }
 
        _FCLuaIterNotationStyleFilters() : __FCCollection() {}
 
                _FCLuaIterNotationStyleFilter* GetItemAt(int index) const { return (_FCLuaIterNotationStyleFilter*)__FCCollection::GetItemAt(index); }
 
                _FCLuaIterNotationStyleFilter* Find(__FCStaffBase::STAFFNOTATION_STYLE filter)
                {
                        for (int i = 0; i < GetCount(); i++)
                        {
                                _FCLuaIterNotationStyleFilter* pItem = GetItemAt(i);
                                if (pItem->GetFilter() == filter) return pItem;
                        }
                        return NULL;
                }
 
                bool AddFilter(__FCStaffBase::STAFFNOTATION_STYLE filter)
                {
                        if (Find(filter)) return false;
                        Add(new _FCLuaIterNotationStyleFilter(filter));
                        return true;
                }
 
                bool RemoveFilter(__FCStaffBase::STAFFNOTATION_STYLE filter)
                {
                        _FCLuaIterNotationStyleFilter* pItem = Find(filter);
                        if (!pItem) return false;
                        int index = GetIndexOf(pItem);
                        if (index == -1) return false;  /* Should never occur, but to be safe... */
                        ClearItemAt(index);
                        return true;
                }
        };
 
        _FCLuaIterEntryFilters _entryfilters_AND;
        _FCLuaIterEntryFilters _entryfilters_OR;
        _FCLuaIterEntryFilters _entryfilters_NOT;
            
    _FCLuaIterNoteFilters _notefilters_AND;
        _FCLuaIterNoteFilters _notefilters_OR;
        _FCLuaIterNoteFilters _notefilters_NOT;
            
    _FCLuaIterAltNotationFilters _altnotationfilters_AND;
        _FCLuaIterAltNotationFilters _altnotationfilters_OR;
        _FCLuaIterAltNotationFilters _altnotationfilters_NOT;
            
        _FCLuaIterNotationStyleFilters _notationstylefilters_AND;
        _FCLuaIterNotationStyleFilters _notationstylefilters_OR;
        _FCLuaIterNotationStyleFilters _notationstylefilters_NOT;
 
        bool _nullregionequalsall;
 
        bool _forwardprocessing;
        bool _downwardprocessing;
        bool _partialmeasureselections;
 
        double _timingstart, _timingend;
        bool _useprogressbar;
        bool _abortableprogressbar;     
        bool _progressbar_useraborted;
        int _progressfrequency;  /* How often the meter should update. */
        int _loadlayermode;
    bool _processscorepart;
    bool _processcurrentpart;
    bool _processcurrentdoc;
        
    /************************/
        /* Check entry filters. */
        /************************/
    
        bool EntryFilterCheck(FCNoteEntry* pEntry, LUAITERATOR_ENTRYFILTERS filter)
        {               
                switch (filter)
                {
                case LIEFILTER_NOTE:
                        return pEntry->IsNote();                        
                case LIEFILTER_REST:
                        return pEntry->IsRest();                        
                case LIEFILTER_CHORD:
                        return (pEntry->IsNote() && (pEntry->GetCount() >= 2));                 
                case LIEFILTER_SINGLENOTE:
                        return (pEntry->IsNote() && (pEntry->GetCount() == 1));                 
                case LIEFILTER_ARTICULATIONFLAG:
                        return pEntry->GetArticulationFlag();                   
                case LIEFILTER_SMARTSHAPEFLAG:
                        return pEntry->GetSmartShapeFlag();                     
                case LIEFILTER_NOTEDETAILFLAG:
                        return pEntry->GetNoteDetailFlag();                     
                case LIEFILTER_PERFORMANCEDATAFLAG:
                        return pEntry->GetPerformanceDataFlag();                        
                case LIEFILTER_SPECIALALTSFLAG:
                        return pEntry->GetSpecialAltsFlag();                    
                case LIEFILTER_TUPLETSTARTFLAG:
                        return pEntry->GetTupletStartFlag();                    
                case LIEFILTER_LYRICFLAG:
                        return pEntry->GetLyricFlag();                  
                case LIEFILTER_STEMDETAILFLAG:
                        return pEntry->GetStemDetailFlag();                     
                case LIEFILTER_SECONDARYBEAMFLAG:
                        return pEntry->GetSecondaryBeamFlag();  
                case LIEFILTER_GRACENOTE:
                        return pEntry->GetGraceNote();          
                case LIEFILTER_DOTTED:
                        return pEntry->IsDotted();                                      
                case LIEFILTER_DURWHOLE:
                        return (pEntry->CalcNondottedDuration() == FCNoteEntry::WHOLE_NOTE);                    
                case LIEFILTER_DURHALF:
                        return (pEntry->CalcNondottedDuration() == FCNoteEntry::HALF_NOTE);                     
                case LIEFILTER_DURQUARTER:
                        return (pEntry->CalcNondottedDuration() == FCNoteEntry::QUARTER_NOTE);                  
                case LIEFILTER_DUR8TH:
                        return (pEntry->CalcNondottedDuration() == FCNoteEntry::EIGHTH_NOTE);                   
                case LIEFILTER_DUR16TH:
                        return (pEntry->CalcNondottedDuration() == FCNoteEntry::SIXTEENTH_NOTE);                        
                case LIEFILTER_DUR32ND:
                        return (pEntry->CalcNondottedDuration() == FCNoteEntry::THIRTYSECOND_NOTE);                     
                case LIEFILTER_DUR64TH:
                        return (pEntry->CalcNondottedDuration() == FCNoteEntry::SIXTYFOURTH_NOTE);                      
                default:
#ifdef PDK_FRAMEWORK_DIAGNOSE
                        DebugOutInt("Error: Unknown '_entryfiltermode' in FCLuaIterator:EntryMatchesFilter(): ", (int)filter);
#endif
                        return false;
                }
                return false;
        }
 
        bool EntryMatchesANDFilters(FCNoteEntry* pEntry)
        {
                if (_entryfilters_AND.GetCount() == 0) return true;
                for (int i = 0; i < _entryfilters_AND.GetCount(); i++)
                {
                        LUAITERATOR_ENTRYFILTERS filter = _entryfilters_AND.GetItemAt(i)->GetFilter();
                        if (!EntryFilterCheck(pEntry, filter)) return false;
                }
                return true;
        }
 
        bool EntryMatchesORFilters(FCNoteEntry* pEntry)
        {
                if (_entryfilters_OR.GetCount() == 0) return true;
                for (int i = 0; i < _entryfilters_OR.GetCount(); i++)
                {
                        LUAITERATOR_ENTRYFILTERS filter = _entryfilters_OR.GetItemAt(i)->GetFilter();
                        if (EntryFilterCheck(pEntry, filter)) return true;
                }
                return false;
        }
 
        bool EntryMatchesNOTFilters(FCNoteEntry* pEntry)
        {
                if (_entryfilters_NOT.GetCount() == 0) return true;
                for (int i = 0; i < _entryfilters_NOT.GetCount(); i++)
                {
                        LUAITERATOR_ENTRYFILTERS filter = _entryfilters_NOT.GetItemAt(i)->GetFilter();
                        if (EntryFilterCheck(pEntry, filter)) return false;
                }
                return true;
        }
 
        bool EntryMatchesFilters(FCNoteEntry* pEntry)
        {
                if (!EntryMatchesANDFilters(pEntry)) return false;
                if (!EntryMatchesORFilters(pEntry)) return false;
                if (!EntryMatchesNOTFilters(pEntry)) return false;
                return true;
        }
 
        /*********************************/
        /* Check notation style filters. */
        /*********************************/
 
        bool NotationStyleFilterCheck(FCCurrentStaffSpec* pStaffSpec, __FCStaffBase::STAFFNOTATION_STYLE filter)
        {
                return (pStaffSpec->GetNotationStyle() == filter);
        }
        
        bool NotationStyleMatchesANDFilters(FCCurrentStaffSpec* pStaffSpec)
        {
                if (_notationstylefilters_AND.GetCount() == 0) return true;             
                for (int i = 0; i < _notationstylefilters_AND.GetCount(); i++)
                {
                        __FCStaffBase::STAFFNOTATION_STYLE filter = _notationstylefilters_AND.GetItemAt(i)->GetFilter();
                        if (!NotationStyleFilterCheck(pStaffSpec, filter)) return false;
                }
                return true;
        }
 
        bool NotationStyleMatchesORFilters(FCCurrentStaffSpec* pStaffSpec)
        {
                if (_notationstylefilters_OR.GetCount() == 0) return true;              
                for (int i = 0; i < _notationstylefilters_OR.GetCount(); i++)
                {
                        __FCStaffBase::STAFFNOTATION_STYLE filter = _notationstylefilters_OR.GetItemAt(i)->GetFilter();
                        if (NotationStyleFilterCheck(pStaffSpec, filter)) return true;
                }
                return false;
        }
 
        bool NotationStyleMatchesNOTFilters(FCCurrentStaffSpec* pStaffSpec)
        {
                if (_notationstylefilters_NOT.GetCount() == 0) return true;             
                for (int i = 0; i < _notationstylefilters_NOT.GetCount(); i++)
                {
                        __FCStaffBase::STAFFNOTATION_STYLE filter = _notationstylefilters_NOT.GetItemAt(i)->GetFilter();
                        if (NotationStyleFilterCheck(pStaffSpec, filter)) return false;
                }
                return true;
        }
 
        /* Entry method version to check notation style */
        bool NotationStyleMatchesFilters(FCNoteEntry* pEntry)
        {
                if ((_notationstylefilters_AND.GetCount() == 0) &&
                        (_notationstylefilters_OR.GetCount() == 0) &&
                        (_notationstylefilters_NOT.GetCount() == 0))
                        return true;
                FCCurrentStaffSpec staffspec;
                if (!staffspec.LoadForEntry(pEntry)) return false;
                if (!NotationStyleMatchesANDFilters(&staffspec)) return false;
                if (!NotationStyleMatchesORFilters(&staffspec)) return false;
                if (!NotationStyleMatchesNOTFilters(&staffspec)) return false;
                return true;
        }
 
        /* Cell method version to check notation style */
        bool NotationStyleMatchesFilters(eMeas measure, eStaff staff, TimeEdu32 measurepos)
        {
                if ((_notationstylefilters_AND.GetCount() == 0) &&
                        (_notationstylefilters_OR.GetCount() == 0) &&
                        (_notationstylefilters_NOT.GetCount() == 0))
                        return true;
                FCCurrentStaffSpec staffspec;
                FCCell cell(measure, staff);
                if (!staffspec.LoadForCell(&cell, measurepos)) return false;
                if (!NotationStyleMatchesANDFilters(&staffspec)) return false;
                if (!NotationStyleMatchesORFilters(&staffspec)) return false;
                if (!NotationStyleMatchesNOTFilters(&staffspec)) return false;
                return true;
        }
 
        /************************************/
        /* Check alternate notation filters */
        /************************************/
    
        bool AltNotationFilterCheck(FCCurrentStaffSpec* pStaffSpec, __FCStaffBase::ALTERNATE_STAFF filter)
        {
                return (pStaffSpec->GetAltNotationStyle() == filter);
        }
 
        bool AltNotationMatchesANDFilters(FCCurrentStaffSpec* pStaffSpec)
        {
                if (_altnotationfilters_AND.GetCount() == 0) return true;               
                for (int i = 0; i < _altnotationfilters_AND.GetCount(); i++)
                {
                        __FCStaffBase::ALTERNATE_STAFF filter = _altnotationfilters_AND.GetItemAt(i)->GetFilter();
                        if (!AltNotationFilterCheck(pStaffSpec, filter)) return false;
                }
                return true;
        }
 
        bool AltNotationMatchesORFilters(FCCurrentStaffSpec* pStaffSpec)
        {
                if (_altnotationfilters_OR.GetCount() == 0) return true;                
                for (int i = 0; i < _altnotationfilters_OR.GetCount(); i++)
                {
                        __FCStaffBase::ALTERNATE_STAFF filter = _altnotationfilters_OR.GetItemAt(i)->GetFilter();
                        if (AltNotationFilterCheck(pStaffSpec, filter)) return true;
                }
                return false;
        }
 
        bool AltNotationMatchesNOTFilters(FCCurrentStaffSpec* pStaffSpec)
        {
                if (_altnotationfilters_NOT.GetCount() == 0) return true;               
                for (int i = 0; i < _altnotationfilters_NOT.GetCount(); i++)
                {
                        __FCStaffBase::ALTERNATE_STAFF filter = _altnotationfilters_NOT.GetItemAt(i)->GetFilter();
                        if (AltNotationFilterCheck(pStaffSpec, filter)) return false;
                }
                return true;
        }
 
        /* Entry method version to check alternate notation */
    bool AlternateNotationMatchesFilters(FCNoteEntry* pEntry)
    {
        if ((_altnotationfilters_AND.GetCount() == 0) && 
                        (_altnotationfilters_OR.GetCount() == 0) &&
                        (_altnotationfilters_NOT.GetCount() == 0))
                        return true;
                FCCurrentStaffSpec staffspec;
                if (!staffspec.LoadForEntry(pEntry)) return false;
                if (!AltNotationMatchesANDFilters(&staffspec)) return false;
                if (!AltNotationMatchesORFilters(&staffspec)) return false;
                if (!AltNotationMatchesNOTFilters(&staffspec)) return false;
                return true;
    }
    
    /* Cell method version to check alternate notation */
    bool AlternateNotationMatchesFilters(eMeas measure, eStaff staff, TimeEdu32 measurepos)
    {
                if ((_altnotationfilters_AND.GetCount() == 0) &&
                        (_altnotationfilters_OR.GetCount() == 0) &&
                        (_altnotationfilters_NOT.GetCount() == 0))
                        return true;        
                FCCurrentStaffSpec staffspec;
        FCCell cell(measure, staff);
                if (!staffspec.LoadForCell(&cell, measurepos)) return false;
                if (!AltNotationMatchesANDFilters(&staffspec)) return false;
                if (!AltNotationMatchesORFilters(&staffspec)) return false;
                if (!AltNotationMatchesNOTFilters(&staffspec)) return false;
                return true;
    }
 
 
        /**********************/
        /* Check note filters */
        /**********************/
 
        bool NoteFilterCheck(FCNote* pNote, LUAITERATOR_NOTEFILTERS filter)
        {                       
                switch (filter)
                {
                case LINFILTER_TIE:
                        return pNote->GetTie();                 
                case LINFILTER_ACCIDENTAL:
                        return pNote->CalcAccidental();                 
                case LINFILTER_ACCIDENTALPARENTHESES:
                        return pNote->GetAccidentalParentheses();                       
                case LINFILTER_ACCIDENTALFREEZE:
                        return pNote->GetAccidentalFreeze();                    
                default:
#ifdef PDK_FRAMEWORK_DIAGNOSE
                        DebugOutInt("Error: Unknown '_notfiltermode' in FCLuaIterator:NoteMatchesFilter(): ", (int)filter);
#endif
                        return false;
                }
        }
 
        bool NoteMatchesANDFilters(FCNote* pNote)
        {
                if (_notefilters_AND.GetCount() == 0) return true;
                for (int i = 0; i < _notefilters_AND.GetCount(); i++)
                {
                        LUAITERATOR_NOTEFILTERS filter = _notefilters_AND.GetItemAt(i)->GetFilter();
                        if (!NoteFilterCheck(pNote, filter)) return false;
                }
                return true;
        }
 
        bool NoteMatchesORFilters(FCNote* pNote)
        {
                if (_notefilters_OR.GetCount() == 0) return true;
                for (int i = 0; i < _notefilters_OR.GetCount(); i++)
                {
                        LUAITERATOR_NOTEFILTERS filter = _notefilters_OR.GetItemAt(i)->GetFilter();
                        if (NoteFilterCheck(pNote, filter)) return true;
                }
                return false;
        }
 
        bool NoteMatchesNOTFilters(FCNote* pNote)
        {
                if (_notefilters_NOT.GetCount() == 0) return true;
                for (int i = 0; i < _notefilters_NOT.GetCount(); i++)
                {
                        LUAITERATOR_NOTEFILTERS filter = _notefilters_NOT.GetItemAt(i)->GetFilter();
                        if (NoteFilterCheck(pNote, filter)) return false;
                }
                return true;
        }
 
        bool NoteMatchesFilters(FCNote* pNote)
        {        
                if (!NoteMatchesANDFilters(pNote)) return false;
                if (!NoteMatchesORFilters(pNote)) return false;
                if (!NoteMatchesNOTFilters(pNote)) return false;
                return true;
        }
 
 
 
        /* Sends an Lua exception error to the console output. 
        Called from _ProcessObjectCallback. */
        void HandleExceptionError(luabridge::LuaException &e, EProgressDataP *ppProgressBarData)
        {
        EndProgressBar(ppProgressBarData, true);
        LuaRun_ExceptionAbort(e);
        }
    
    /* Executes the Lua callback function for a ForEach...() iterator. */
    template <typename... Args>
    bool ExecuteCallback(luabridge::LuaRef& lua_callback_function, EProgressDataP *ppProgressBarData, Args&&... args)
    {
        bool continueflag = true;
        try
        {
    #if LUABRIDGE_MAJOR_VERSION >= 3
            luabridge::LuaResult returnvalue = lua_callback_function.callWithHandler(LuaRun_ErrorFunction, std::forward<Args>(args)...);
            if (!returnvalue) returnvalue.raiseException();
            if (returnvalue.size() > 0 && returnvalue[0].isValid() && returnvalue[0].isBool())
                continueflag = returnvalue[0];
    #else
            luabridge::LuaRef returnvalue = lua_callback_function(std::forward<Args>(args)...);
            if (returnvalue.type() == LUA_TBOOLEAN) continueflag = returnvalue.cast<bool>();
    #endif
            if (!continueflag)
            {
                // Don't roll back changes if callback exits with false
                EndProgressBar(ppProgressBarData, false);
                return false;
            }
        }
        catch (luabridge::LuaException e)
        {
            HandleExceptionError(e, ppProgressBarData);
            return false;
        }
        return true;
    }
 
        int ProcessRegionEntries(FCMusicRegion* pRegion, luabridge::LuaRef &lua_callback_function, bool shouldsave)
        {
                FCMusicRegion fullregion;
                if (!pRegion || pRegion->IsEmptyAndNotSinglePos())
                {
                        if (!_nullregionequalsall) return 0;
                        if (!fullregion.SetFullDocument()) return 0;
                        pRegion = &fullregion;
                }
                if (!lua_callback_function.isFunction()) return 0;
                if (pRegion->IsEmptyAndNotSinglePos()) return 0;
                int count = 0;
                int progressupdatecount;
                EProgressDataP pProgressBarData;
 
                StartProgressBar(&pProgressBarData, pRegion->CalcMeasureSpan() * pRegion->CalcStaffSpan(), &progressupdatecount);
 
                int meas = 0;
                if (_forwardprocessing)
                        meas = pRegion->GetStartMeasure();
                else
                        meas = pRegion->GetEndMeasure();
 
                while (meas >= pRegion->GetStartMeasure() && meas <= pRegion->GetEndMeasure())
                {
                        while (true)
                        {
                                if ((!_partialmeasureselections) && pRegion->IsMeasurePartial(meas)) break;
                                int slot = 0;
                                if (_downwardprocessing)
                                        slot = pRegion->GetStartSlot();
                                else
                                        slot = pRegion->GetEndSlot();
                                while (slot >= pRegion->GetStartSlot() && slot <= pRegion->GetEndSlot())
                                {
                                        while (true)
                                        {
                                                /* Handle the progress bar */
                                                if (!UpdateProgressBar(&pProgressBarData, &progressupdatecount))
                                                {
                                                        return count;
                                                }
 
                                                FCNoteEntryCell entrycell(meas, pRegion->CalcStaffNumber(slot));
                                                entrycell.SetLoadLayerMode(_loadlayermode);
                                                entrycell.Load();
 
                                                bool entriesprocessed = false;
                                                /* Process the entries in the FCNoteEntryCell collection */
                                                int entryidx = 0;
                                                if (_forwardprocessing)
                                                        entryidx = 0;
                                                else
                                                        entryidx = entrycell.GetCount() - 1;
                                                while (entryidx >= 0 && entryidx < entrycell.GetCount())
                                                {
                                                        while (true)
                                                        {
                                                                FCNoteEntry* pEntry = entrycell.GetItemAt(entryidx);
                                                                if (!pRegion->IsEntryPosWithin(pEntry)) break;
                                                                if (!EntryMatchesFilters(pEntry)) break;
                                                                if (!NotationStyleMatchesFilters(pEntry)) break;
                                                                if (!AlternateNotationMatchesFilters(pEntry)) break;
                                                                /* Send entry to Lua callback */
                                                                entriesprocessed = true;
                                                                count++;
                                                                if (!ExecuteCallback(lua_callback_function, &pProgressBarData, pEntry))
                                                                {
                                                                        return count;
                                                                }
                                                                break;
                                                        } /* while (true) */
                                                        if (_forwardprocessing) entryidx++; else entryidx--;
                                                }
                                                /* Save back */
                                                if (shouldsave && entriesprocessed) entrycell.Save();
                                                break;
                                        } /* while (true) */
                                        if (_downwardprocessing) slot++; else slot--;
                                }
                                break;
                        } /* while (true) */
                        if (_forwardprocessing) meas++; else meas--;
                }
                EndProgressBar(&pProgressBarData, false);
                return count;
        }
 
    __FCCollectionData* LoadCollectionForClassID(PDKFRAMEWORK_CLASSID classID)
    {
        __FCCollectionData* pCollectionData = NULL;
        switch (classID)
        {
            case FCID_ARTICULATIONDEF:
                pCollectionData = new FCArticulationDefs();
                break;
            case FCID_CATEGORYDEF:
                pCollectionData = new FCCategoryDefs();
                break;
            case FCID_CHORD:
                pCollectionData = new FCChords();
                break;
            case FCID_CLEFDEF:
                pCollectionData = new FCClefDefs();
                break;
            case FCID_CUSTOMSMARTLINEDEF:
                pCollectionData = new FCCustomSmartLineDefs();
                break;
            case FCID_EXECUTABLESHAPEDEF:
                pCollectionData = new FCExecutableShapeDefs();
                break;
            case FCID_FRETBOARDSTYLEDEF:
                pCollectionData = new FCFretboardStyleDefs();
                break;
            case FCID_FRETBOARDGROUPDEF:
                pCollectionData = new FCFretboardGroupDefs();
                break;
            case FCID_FRETINSTRUMENTDEF:
                pCollectionData = new FCFretInstrumentDefs();
                break;
            case FCID_GROUP:
                pCollectionData = new FCGroups();
                break;
            case FCID_INSTRUMENTDEF:
                pCollectionData = new FCInstrumentDefs();
                break;
            case FCID_MEASURE:
                pCollectionData = new FCMeasures();
                break;
            case FCID_MEASURENUMBERREGION:
                pCollectionData = new FCMeasureNumberRegions();
                break;
            case FCID_MULTIMEASUREREST:
                pCollectionData = new FCMultiMeasureRests();
                break;
            case FCID_MULTISTAFFINSTRUMENT:
                pCollectionData = new FCMultiStaffInstruments();
                break;
            case FCID_PAGE:
                pCollectionData = new FCPages();
                break;
            case FCID_PAGEGRAPHIC:
                pCollectionData = new FCPageGraphics();
                break;
            case FCID_PAGETEXT:
                pCollectionData = new FCPageTexts();
                break;
#ifdef PDK_FRAMEWORK_SHAPES
            case FCID_SHAPEDEF:
                pCollectionData = new FCShapeDefs();
                break;
#endif
            case FCID_SHAPEEXPRESSIONDEF:
                pCollectionData = new FCShapeExpressionDefs();
                break;
            case FCID_SMARTSHAPE:
                pCollectionData = new FCSmartShapes();
                break;
            case FCID_STAFF:
                pCollectionData = new FCStaves();
                break;
            case FCID_STAFFSTYLEDEF:
                pCollectionData = new FCStaffStyleDefs();
                break;
            case FCID_STAFFSYSTEM:
                pCollectionData = new FCStaffSystems();
                break;
            case FCID_TEXTEXPRESSIONDEF:
                pCollectionData = new FCTextExpressionDefs();
                break;
            case FCID_TEXTREPEATDEF:
                pCollectionData = new FCTextRepeatDefs();
                break;
            default:
                break;
        }
        if (!pCollectionData) return NULL;
        pCollectionData->LoadAll();
        return pCollectionData;
    }
    
        int ProcessRegionNotes(FCMusicRegion* pRegion, luabridge::LuaRef &lua_callback_function, bool shouldsave)
        {
                FCMusicRegion fullregion;
                if (!pRegion || pRegion->IsEmptyAndNotSinglePos())
                {
                        if (!_nullregionequalsall) return 0;
                        if (!fullregion.SetFullDocument()) return 0;
                        pRegion = &fullregion;
                }
                if (!lua_callback_function.isFunction()) return 0;
                if (pRegion->IsEmptyAndNotSinglePos()) return 0;
                int count = 0;
                int progressupdatecount;
                EProgressDataP pProgressBarData;
 
                StartProgressBar(&pProgressBarData, pRegion->CalcMeasureSpan() * pRegion->CalcStaffSpan(), &progressupdatecount);
 
                int meas = 0;
                if (_forwardprocessing)
                        meas = pRegion->GetStartMeasure();
                else
                        meas = pRegion->GetEndMeasure();
        
                while (meas >= pRegion->GetStartMeasure() && meas <= pRegion->GetEndMeasure())
                {
                        while (true)
                        {
                                if ((!_partialmeasureselections) && pRegion->IsMeasurePartial(meas)) break;
                                int slot = 0;
                                if (_downwardprocessing)
                                        slot = pRegion->GetStartSlot();
                                else
                                        slot = pRegion->GetEndSlot();
 
                                while (slot >= pRegion->GetStartSlot() && slot <= pRegion->GetEndSlot())
                                {
                                        while (true)
                                        {
                                                /* Handle the progress bar */
                                                if (!UpdateProgressBar(&pProgressBarData, &progressupdatecount))
                                                {
                                                        return count;
                                                }
 
                                                FCNoteEntryCell entrycell(meas, pRegion->CalcStaffNumber(slot));
                                                entrycell.SetLoadLayerMode(_loadlayermode);
                                                entrycell.Load();
 
                                                bool entriesprocessed = false;
 
                                                int entryidx = 0;
                                                if (_forwardprocessing)
                                                        entryidx = 0;
                                                else
                                                        entryidx = entrycell.GetCount() - 1;
                                                /* Process the entries in the FCNoteEntryCell collection */
                                                while (entryidx >= 0 && entryidx < entrycell.GetCount())
                                                {
                                                        while (true)
                                                        {
                                                                FCNoteEntry* pEntry = entrycell.GetItemAt(entryidx);
                                                                if (pEntry->IsRest()) break;
                                                                if (!pRegion->IsEntryPosWithin(pEntry)) break;
                                                                if (!EntryMatchesFilters(pEntry)) break;
                                                                if (!NotationStyleMatchesFilters(pEntry)) break;
                                                                if (!AlternateNotationMatchesFilters(pEntry)) break;
 
                                                                int noteidx = 0;
                                                                if (_forwardprocessing)
                                                                        noteidx = 0;
                                                                else
                                                                        noteidx = pEntry->GetCount() - 1;
                                                                /* Browse throúgh the notes in the chord */
                                                                while (noteidx >= 0 && noteidx < pEntry->GetCount())                                                            
                                                                {
                                                                        while (true)
                                                                        {
                                                                                FCNote* pNote = pEntry->GetItemAt(noteidx);
                                                                                if (!NoteMatchesFilters(pNote)) break;
                                                                                /* Send entry to Lua callback */
                                                                                entriesprocessed = true;
                                                                                count++;
                                        if (!ExecuteCallback(lua_callback_function, &pProgressBarData, pNote))
                                                                                {
                                                                                        return count;
                                                                                }
                                                                                break;
                                                                        } /* while (true) */
                                                                        if (_forwardprocessing) noteidx++; else noteidx--;
                                                                }
                                                                break;
                                                        } /* while (true) */
                                                        if (_forwardprocessing) entryidx ++; else entryidx --;
                                                }
                                                /* Save back */
                                                if (shouldsave && entriesprocessed) entrycell.Save();
                                                break;
                                        } /* while (true) */
                                        if (_downwardprocessing) slot++; else slot--;
                                } /* while (slot ... */
                                break;
                        } /* while (true) */
                        if (_forwardprocessing) meas++; else meas--;
                }
                EndProgressBar(&pProgressBarData, false);
                return count;
        }
 
        /* The main processing method for ForEachCell(). */
        int ProcessForEachCell(FCMusicRegion* pRegion, luabridge::LuaRef& lua_callback_function)
        {
                FCMusicRegion fullregion;
                if (!pRegion || pRegion->IsEmptyAndNotSinglePos())
                {
                        if (!_nullregionequalsall) return 0;
                        if (!fullregion.SetFullDocument()) return 0;
                        pRegion = &fullregion;
                }
                if (!lua_callback_function.isFunction()) return 0;
                if (pRegion->IsEmptyAndNotSinglePos()) return 0;
                int count = 0;
                int progressupdatecount;
                EProgressDataP pProgressBarData;
                
                StartProgressBar(&pProgressBarData, pRegion->CalcMeasureSpan() * pRegion->CalcStaffSpan(), &progressupdatecount);
 
                int meas = 0;
                if (_forwardprocessing)
                        meas = pRegion->GetStartMeasure();
                else
                        meas = pRegion->GetEndMeasure();
 
                while (meas >= pRegion->GetStartMeasure() && meas <= pRegion->GetEndMeasure())
                {
                        while (true)
                        {
                                if ((!_partialmeasureselections) && pRegion->IsMeasurePartial(meas)) break;
                                int slot = 0;
                                if (_downwardprocessing)
                                        slot = pRegion->GetStartSlot();
                                else
                                        slot = pRegion->GetEndSlot();
                                while (slot >= pRegion->GetStartSlot() && slot <= pRegion->GetEndSlot())
                                {
                                        while (true)
                                        {
                                                /* Handle the progress bar */
                                                if (!UpdateProgressBar(&pProgressBarData, &progressupdatecount))
                                                {
                                                        return count;
                                                }
                                                eStaff staff = pRegion->CalcStaffNumber(slot);
                                                if (!NotationStyleMatchesFilters(meas, staff, 0)) break;
                                                if (!AlternateNotationMatchesFilters(meas, staff, 0)) break;
                                                count++;
                                                /* User callback */
                                                if (!ExecuteCallback(lua_callback_function, &pProgressBarData, meas, staff))
                                                {
                                                        return count;
                                                }
                                                break;
                                        }
                                        if (_downwardprocessing) slot++; else slot--;
                                }
                                break;
                        }
                        if (_forwardprocessing) meas++; else meas--;
                }
                EndProgressBar(&pProgressBarData, false);               
                return count;
        }
 
        /* The main processing method for ForEachPart(). */
        int ProcessForEachPart(luabridge::LuaRef& lua_callback_function)
        {
                if (!lua_callback_function.isFunction()) return 0;
                int count = 0;
                int progressupdatecount;
                EProgressDataP pProgressBarData;
        
        lua_State * pLuaState = lua_callback_function.state();
 
                FCParts allparts;
                allparts.LoadAll();
                StartProgressBar(&pProgressBarData, allparts.GetCount(), &progressupdatecount);
 
                int partidx = 0;
                if (_forwardprocessing)
                        partidx = 0;
                else
                        partidx = allparts.GetCount() - 1;
                while (partidx >= 0 && partidx < allparts.GetCount())
                {
                        while (true)
                        {
                                /* Handle the progress bar */
                                if (!UpdateProgressBar(&pProgressBarData, &progressupdatecount)) return count;
 
                                /* Get the part and switch focus */
                                FCPart* pPart = allparts.GetItemAt(partidx);
                                if (!_processscorepart && pPart->IsScore()) break;
                                if (!_processcurrentpart && pPart->IsCurrent()) break;
 
                                /* User callback */
                                pPart->SwitchTo();
                                luabridge::LuaRef parameter(pLuaState, pPart);
                                count++;
                                bool callbackreturn = ExecuteCallback(lua_callback_function, &pProgressBarData, parameter);
                                pPart->SwitchBack();
 
                                if (!callbackreturn) return count;
                                break;
                        }
                        if (_forwardprocessing)
                                partidx++;
                        else
                                partidx--;
                }
 
                EndProgressBar(&pProgressBarData, false);               
                return count;
        }
    
    /* The main method for "ForEach()". The start/stop of the timer are handled
     * outside of this method. */
    int ProcessForEach(__FCCollectionData* pCollection, luabridge::LuaRef& lua_callback_function, bool shouldsave)
    {
        if (!pCollection) return 0;
                if (pCollection->GetCount() == 0) return 0;
                if (!lua_callback_function.isFunction()) return 0;
                int count = 0;
                int progressupdatecount;
                EProgressDataP pProgressBarData;
        
                StartProgressBar(&pProgressBarData, pCollection->GetCount(), &progressupdatecount);
                
        lua_State * pLuaState = lua_callback_function.state();
        
        luabridge::LuaRef parameter(pLuaState);
                /* Ideally, a base object should be created once as a LuaRef and data cloned, since
         * that would be much faster. However, there are too many issues with linked objects
         * to be safe. */
        
                int i = 0;
                if (_forwardprocessing)
                        i = 0;
                else
                        i = pCollection->GetCount() - 1;
 
                while (i >= 0 && i < pCollection->GetCount())
                {                       
                        while (true)
                        {
                                /* Handle the progress bar */
                                if (!UpdateProgressBar(&pProgressBarData, &progressupdatecount))
                                {
                                        return count;
                                }
 
                                /* Get the item data to process */
                                __FCBaseData* pObject = (__FCBaseData*)pCollection->GetItemAt(i);
                                if (!pObject) break;
                if (!SetupCorrectCppClass(pObject, parameter))
                {
                    EndProgressBar(&pProgressBarData, false);
                    return count;
                }
 
                                /* Execute the callback */
                                count++;
                                if (!ExecuteCallback(lua_callback_function, &pProgressBarData, parameter))
                                {
                                        return count;
                                }
                                if (shouldsave) pObject->Save();
                                break;
                        } /* while (true) */
                        if (_forwardprocessing) i++; else i--;
                }
                EndProgressBar(&pProgressBarData, false);
                return count;
 
                if (_forwardprocessing) i++; else i--;          
    }
        
    struct EACH_REGION_OBJECT_DATA
    {
        FCMusicRegion* pRegion;
        int count;
        __FCBaseData* pObject;
        EProgressDataP pProgressBarData;
        CLASS_APPROACHES classapproach;
        bool shouldsave;
        int progressupdatecount;
    };
    
    /* Handles the Lua callback to note entry details for ForEachRegionObject
     and ForEachRegionObjectSaved.
     
     Objects must be based on __FCEntryDetail.
     */
    bool ProcessEntryDetailsCell(eMeas meas, eStaff staff, luabridge::LuaRef& lua_callback_function, luabridge::LuaRef &parameter, EACH_REGION_OBJECT_DATA* pERData)
    {
        __FCEntryDetail* pEntryObject = (__FCEntryDetail*) pERData->pObject;
        FCNoteEntryCell entrycell(meas, staff);
        entrycell.SetLoadLayerMode(_loadlayermode);
        entrycell.Load();
                int entryidx = 0;
                if (_forwardprocessing)
                        entryidx = 0;
                else
                        entryidx = entrycell.GetCount() - 1;
        while (entryidx >= 0 && entryidx < entrycell.GetCount())
                {
                        while (true)
                        {
                                FCNoteEntry* pEntry = entrycell.GetItemAt(entryidx);
                                if (!pERData->pRegion->IsEntryPosWithin(pEntry)) break;
                                if (!EntryMatchesFilters(pEntry)) break;
                                if (!NotationStyleMatchesFilters(pEntry)) break;
                if (!AlternateNotationMatchesFilters(pEntry)) break;
                                pEntryObject->SetNoteEntry(pEntry);
                                if (_forwardprocessing)
                                {
                                        twobyte currentinci = 0;
                                        while (pEntryObject->Load(pEntry->GetEntryNumber(), currentinci))
                                        {
                                                /* Call the Lua callback function */
                                                pERData->count++;
                                                if (!ExecuteCallback(lua_callback_function, &pERData->pProgressBarData, parameter))
                                                {
                                                        return false;
                                                }
                                                if (pERData->shouldsave) pEntryObject->Save();
                                                currentinci++;
                                        }
                                }
                                else
                                {
                                        /* Parse backwards - Find last inci. */
                                        twobyte lastinci = pEntryObject->CalcLastInci();
                                        if (lastinci == kNewInci) break;
                                        while (lastinci >= 0)
                                        {
                                                if (pEntryObject->Load(pEntry->GetEntryNumber(), lastinci))
                                                {
                                                        /* Call the Lua callback function */
                                                        pERData->count++;
                                                        if (!ExecuteCallback(lua_callback_function, &pERData->pProgressBarData, parameter))
                                                        {
                                                                return false;
                                                        }
                                                        if (pERData->shouldsave) pEntryObject->Save();
                                                }
                                                lastinci--;
                                        }
                                }
                                break;
                        } /* while (true) ... */
                        if (_forwardprocessing) entryidx++; else entryidx--;
        }
        return true;
    }
    
    /* Handles the Lua callback to measure-attached details for ForEachRegionObject
     and ForEachRegionObjectSaved.
     
     The object must be based on a __FCInciOther child class, and the "other" value
     must be the measure. And the virtual methods GetMeasure()/GetMeasurePos()/GetStaff() must
     be implemented in the class.
     */
    bool ProcessMeasureDetailsCell(eMeas meas, eStaff staff, luabridge::LuaRef& lua_callback_function, luabridge::LuaRef &parameter, EACH_REGION_OBJECT_DATA* pERData)
    {
        __FCInciOther* pMeasureObject = (__FCInciOther*) pERData->pObject;
    
        twobyte inci = 0;
        twobyte incdec = 1;
        if (!_forwardprocessing) inci = pMeasureObject->CalcLastInci();
        if (inci == kNewInci) return true;
        while (pMeasureObject->Load(meas, inci))
        {
            while (true)
            {
            /* Check if the object is in range */
                if (pMeasureObject->HasStaffValue() && (staff != pMeasureObject->GetStaff())) break;
                if (meas != pMeasureObject->GetMeasure()) break;
                FCCell cell(meas, staff);
                if (!pERData->pRegion->IsCellPosWithin(&cell, pMeasureObject->GetMeasurePos())) break;
                /* Check filter matches */
                if (!NotationStyleMatchesFilters(meas, staff, pMeasureObject->GetMeasurePos())) break;
                if (!AlternateNotationMatchesFilters(meas, staff, pMeasureObject->GetMeasurePos())) break;
            
                /* Call the Lua callback function */
                pERData->count++;
                if (!ExecuteCallback(lua_callback_function, &pERData->pProgressBarData, parameter))
                {
                    return false;
                }
                if (pERData->shouldsave) pMeasureObject->Save();
                break;
            }  /* while (true) */
            inci += incdec;
            /* Check for incis < 0 separately. Don't know if it's necessary, but it's a bit nicer. */
            if (inci < 0) return true;
        }
        return true;
    }
    
    /* Handles the Lua callback to cell-attached details for ForEachRegionObject
     and ForEachRegionObjectSaved.
     
     The object must be based on a __FCCellDetail child class, and requires an
     implemented GetMeasurePos() method.
     */
    bool ProcessCellDetailsCell(eMeas meas, eStaff staff, luabridge::LuaRef& lua_callback_function, luabridge::LuaRef &parameter, EACH_REGION_OBJECT_DATA* pERData)
    {
        __FCCellDetail* pCellObject = (__FCCellDetail*) pERData->pObject;
        
        FCCell cell(meas, staff);
        pCellObject->ConnectCell(&cell);
        
        bool success = _forwardprocessing ? pCellObject->LoadFirst() : pCellObject->LoadLast();
        while (success)
        {
            while (true)
            {
                /* Check if the object is in range */
                if (!pERData->pRegion->IsCellPosWithin(&cell, pCellObject->GetMeasurePos())) break;
                /* Check filter matches */
                if (!NotationStyleMatchesFilters(meas, staff, pCellObject->GetMeasurePos())) break;
                if (!AlternateNotationMatchesFilters(meas, staff, pCellObject->GetMeasurePos())) break;
                
                /* Call the Lua callback function */
                pERData->count++;
                if (!ExecuteCallback(lua_callback_function, &pERData->pProgressBarData, parameter))
                {
                    return false;
                }
                if (pERData->shouldsave) pCellObject->Save();
                break;
            }  /* while (true) */
            success = _forwardprocessing ? pCellObject->LoadNext() : pCellObject->LoadPrevious();
        }
        return true;
    }
    
    /* Main processing method for ForEachRegionObject and ForEachRegionObjectSave.
     *
     * It parses through the cells and redirects the call to the poper method.
     */
    int ProcessForEachRegionObject(FCMusicRegion* pRegion, int classID, luabridge::LuaRef lua_callback_function, bool shouldsave)
    {
                FCMusicRegion fullregion;
                if (!pRegion || pRegion->IsEmptyAndNotSinglePos())
                {
                        if (!_nullregionequalsall) return 0;
                        if (!fullregion.SetFullDocument()) return 0;
                        pRegion = &fullregion;
                }
                if (!lua_callback_function.isFunction()) return 0;
                if (pRegion->IsEmptyAndNotSinglePos()) return 0;
        
        /* Set up struct info */
        EACH_REGION_OBJECT_DATA erdata;
        erdata.pRegion = pRegion;
        erdata.progressupdatecount = 0;
        erdata.shouldsave = shouldsave;
        erdata.pObject = MapRegionClassApproach((PDKFRAMEWORK_CLASSID) classID, &erdata.classapproach);
        if (erdata.classapproach == CLASSAPPROACH_NONE) return 0;
                erdata.count = 0;
        
        lua_State * pLuaState = lua_callback_function.state();
 
                StartProgressBar(&erdata.pProgressBarData, pRegion->CalcMeasureSpan() * pRegion->CalcStaffSpan(), &erdata.progressupdatecount);
        
        /* Set up parameter that will contain the object that is sent to the Lua callback
         * function. Keeping a single parameter LuaRef object like this will be 
         * considerably faster! */
        luabridge::LuaRef parameter(pLuaState);
                if (!SetupCorrectCppClass(erdata.pObject, parameter))
                {
            EndProgressBar(&erdata.pProgressBarData, false);
            return 0;
        }
        
        /* Browse through all cells in the selection */         
                int meas = 0;
                if (_forwardprocessing)
                        meas = pRegion->GetStartMeasure();
                else
                        meas = pRegion->GetEndMeasure();
                while (meas >= pRegion->GetStartMeasure() && meas <= pRegion->GetEndMeasure())
                {
                        while (true)
                        {
                                if ((!_partialmeasureselections) && pRegion->IsMeasurePartial(meas)) break;
                                int slot = 0;
                                if (_downwardprocessing)
                                        slot = pRegion->GetStartSlot();
                                else
                                        slot = pRegion->GetEndSlot();
                                while (slot >= pRegion->GetStartSlot() && slot <= pRegion->GetEndSlot())
                                {
                                        while (true)
                                        {
                                                /* Handle the progress bar */
                                                if (!UpdateProgressBar(&erdata.pProgressBarData, &erdata.progressupdatecount))
                                                {
                                                        delete erdata.pObject;
                                                        return erdata.count;
                                                }
                                                eStaff staff = pRegion->CalcStaffNumber(slot);
                        
                        /* Don't check for notation styles here, since the
                         position check is different depending on entry-based
                         or measure-based, etc.
                         Make the check in each individual object parser instead. */
                                                
                                                /* User callback */
                                                bool continueflag = false;
                                                switch (erdata.classapproach)
                                                {
                                                case CLASSAPPROACH_ENTRYDETAILS:
                        case CLASSAPPROACH_NOTEDETAILS:
                                                        /* **********************/
                                                        /* Handle entry details */
                                                        /* **********************/
                                                        continueflag = ProcessEntryDetailsCell(meas, staff, lua_callback_function, parameter, &erdata);
                            break;
                        case CLASSAPPROACH_MEASUREDETAILS:
                            /* ************************/
                            /* Handle measure details */
                            /* ************************/
                            continueflag = ProcessMeasureDetailsCell(meas, staff, lua_callback_function, parameter, &erdata);
                                break;
                        case CLASSAPPROACH_CELLDETAILS:
                            /* *********************/
                            /* Handle cell details */
                            /* *********************/
                            continueflag = ProcessCellDetailsCell(meas, staff, lua_callback_function, parameter, &erdata);
                                break;
                                                default:
                                                        break;
                                                }
                                                if (!continueflag)
                                                {
                                                        delete erdata.pObject;
                                                        return erdata.count;
                                                }
                                                break;
                                        } /* while (true) */
                                        if (_downwardprocessing) slot++; else slot--;
                                }
                                break;
                        } /* while (true) */
                        if (_forwardprocessing) meas++; else meas--;
                }
        delete erdata.pObject;
                EndProgressBar(&erdata.pProgressBarData, false);
                return erdata.count;
    }
    
    /* Main method for ForEachDocument() and ForEachDocumentSaved().
     For ForEachDocumentSaved(), documents are only saved if a file
     name exists.
     */
    int ProcessForEachDocument(luabridge::LuaRef lua_callback_function, bool shouldsave)
    {
        if (!lua_callback_function.isFunction()) return 0;
                int count = 0;
                int progressupdatecount;
                EProgressDataP pProgressBarData;
        
        FCDocuments alldocs;
        alldocs.LoadAll();
                StartProgressBar(&pProgressBarData, alldocs.GetCount(), &progressupdatecount);
        
                int docidx = 0;
                if (_forwardprocessing)
                        docidx = 0; 
                else 
                        docidx = alldocs.GetCount() - 1;
        
        lua_State * pLuaState = lua_callback_function.state();
 
        FCUndoController& undo = FCUndoController::GetUndoController(lua_callback_function.state());
 
        while (docidx >= 0 && docidx < alldocs.GetCount())
                {
                        while (true)
                        {
                                /* Handle the progress bar */
                                if (!UpdateProgressBar(&pProgressBarData, &progressupdatecount))
                                {
                                        return count;
                                }
 
                                /* Get the document and switch focus */
                                FCDocument* pDoc = alldocs.GetItemAt(docidx);
                                if (!_processcurrentdoc && pDoc->IsCurrent()) break;
 
                                pDoc->SwitchTo(nullptr, true, lua_callback_function.state());
                                luabridge::LuaRef parameter(pLuaState, pDoc);
                                count++;
 
                                /* User callback */
                                if (!ExecuteCallback(lua_callback_function, &pProgressBarData, parameter))
                                {
                                        pDoc->SwitchBack(true, pLuaState);
                                        return count;
                                }
                                if (shouldsave && (!pDoc->IsUntitled()) && !undo.GetSandboxMode())
                {
                    undo.EndUndo(true);
                    pDoc->Save();
                }
                                pDoc->SwitchBack(true, pLuaState);
                                break;
                        }
                        if (_forwardprocessing)
                                docidx++;
                        else
                                docidx--;
                }
        
        EndProgressBar(&pProgressBarData, false);
                return count;
    }
    
    /* Processing method for ForEachFile and ForEachFileSaved. */
    int ProcessForEachFile(FCStrings* pFileStrings, luabridge::LuaRef lua_callback_function, bool shouldsave)
    {
        if (!pFileStrings) return 0;
                if (pFileStrings->GetCount() == 0) return 0;
        int count = 0;
 
                int progressupdatecount;
                EProgressDataP pProgressBarData;
                StartProgressBar(&pProgressBarData, pFileStrings->GetCount(), &progressupdatecount);
 
        lua_State * pLuaState = lua_callback_function.state();
 
        FCUndoController& undo = FCUndoController::GetUndoController(pLuaState);
        
                int filenameidx = 0;
                if (_forwardprocessing)
                        filenameidx = 0;
                else
                        filenameidx = pFileStrings->GetCount() - 1;
                while (filenameidx >= 0 && filenameidx < pFileStrings->GetCount())
        {
            bool executereturn = true;
                        while (true)
                        {
                                FCString* pString = pFileStrings->GetItemAt(filenameidx);
                                if (!pString) break;
                                if (pString->IsEmpty()) break;
                                FCDocument document; // initializes to current document
                                count++;
                                /* There seems to be an issue with saving documents without
                                * a window, so if save should be made, a document window is opened as well. */
                                if (document.Open(pString, shouldsave, nullptr, true, false, true, pLuaState)) // true: save any current edits (replicates previous behavior before refactoring)
                                {
                                        /* Document is now in focus */
                                        executereturn = ExecuteCallback(lua_callback_function, &pProgressBarData, &document, pString);
                                        if (executereturn && shouldsave && !undo.GetSandboxMode())
                    {
                        undo.EndUndo(true); // this replicates previous calls to FX_EndFinaleEdit in Close and CloseCurrentDocumentAndWindow.
                        document.Save();
                    }
                                        document.SetDirty(false);
                                        if (shouldsave)
                                                document.CloseCurrentDocumentAndWindow(pLuaState);
                                        else
                                                document.Close(pLuaState);
                                }
                                else
                                {
                                        /* File couldn't be opened - send nil to the callback */
                                        luabridge::LuaRef parameter(pLuaState, NULL);
                                        executereturn = ExecuteCallback(lua_callback_function, &pProgressBarData, &document, nullptr);
                                }
                document.SwitchBack(true, pLuaState);
                                break;
                        } /* while (true) */
            if (!executereturn) break;
                        if (_forwardprocessing) filenameidx++; else filenameidx--;
        }
                EndProgressBar(&pProgressBarData, false);
        return count;
    }
 
    /* Processing method for ForEachInteger. */
    int ProcessForEachInteger(int integer1, int integer2, luabridge::LuaRef lua_callback_function)
    {
        int count = 0;
        int incdec = 1;
        
        if (integer1 > integer2) incdec = -1;
        
        integer1 -= incdec;
        
                int progressupdatecount;
                EProgressDataP pProgressBarData;
        
        /* Multiplying difference with incdec to assure positive difference. */
                StartProgressBar(&pProgressBarData, (integer2 - integer1) * incdec + 1, &progressupdatecount);
        
        for (int i = integer1; i != integer2; i += incdec)
        {
                        /* Handle the progress bar */
                        if (!UpdateProgressBar(&pProgressBarData, &progressupdatecount)) return count;                  
 
            count ++;
                        bool executereturn = ExecuteCallback(lua_callback_function, &pProgressBarData, i + incdec);
                        if (!executereturn) return count;
        }
                EndProgressBar(&pProgressBarData, false);
        return count;
    }
    
    
    /* Preparation method for ForEachRegionObject(Saved). Creates a data object of the
     correct class, and defines the approach to use for the class. */
    __FCBaseData* MapRegionClassApproach(PDKFRAMEWORK_CLASSID classID, CLASS_APPROACHES* pClassApproach)
    {
        switch (classID)
        {
            case FCID_ACCIDENTALMOD:
                *pClassApproach = CLASSAPPROACH_NOTEDETAILS;
                return new FCAccidentalMod();
            case FCID_ARTICULATION:
                *pClassApproach = CLASSAPPROACH_ENTRYDETAILS;
                return new FCArticulation();
            case FCID_BEATCHARTELEMENT:
                *pClassApproach = CLASSAPPROACH_MEASUREDETAILS;
                return new FCBeatChartElement();
            case FCID_BROKENBEAMMOD:
                *pClassApproach = CLASSAPPROACH_ENTRYDETAILS;
                return new FCBrokenBeamMod();
            case FCID_CELLGRAPHIC:
                 *pClassApproach = CLASSAPPROACH_CELLDETAILS;
                 return new FCCellGraphic();
            case FCID_CELLTEXT:
                *pClassApproach = CLASSAPPROACH_CELLDETAILS;
                return new FCCellText();
            case FCID_CHORD:
                *pClassApproach = CLASSAPPROACH_CELLDETAILS;
                return new FCChord();
            case FCID_CROSSSTAFFMOD:
                *pClassApproach = CLASSAPPROACH_NOTEDETAILS;
                return new FCCrossStaffMod();
            case FCID_CUSTOMSTEMMOD:
                *pClassApproach = CLASSAPPROACH_ENTRYDETAILS;
                return new FCCustomStemMod();
            case FCID_DOTMOD:
                *pClassApproach = CLASSAPPROACH_NOTEDETAILS;
                return new FCDotMod();
            case FCID_ENTRYALTERMOD:
                *pClassApproach = CLASSAPPROACH_ENTRYDETAILS;
                return new FCEntryAlterMod();
            case FCID_EXPRESSION:
                *pClassApproach = CLASSAPPROACH_MEASUREDETAILS;
                return new FCExpression();
            case FCID_MIDIEXPRESSION:
                *pClassApproach = CLASSAPPROACH_CELLDETAILS;
                return new FCMidiExpression();
            case FCID_NOTEHEADMOD:
                *pClassApproach = CLASSAPPROACH_NOTEDETAILS;
                return new FCNoteheadMod();
            case FCID_PERCUSSIONNOTEMOD:
                *pClassApproach = CLASSAPPROACH_NOTEDETAILS;
                return new FCPercussionNoteMod();
            case FCID_PERFORMANCEMOD:
                *pClassApproach = CLASSAPPROACH_NOTEDETAILS;
                return new FCPerformanceMod();
            case FCID_SECONDARYBEAMBREAKMOD:
                *pClassApproach = CLASSAPPROACH_ENTRYDETAILS;
                return new FCSecondaryBeamBreakMod();
            case FCID_SEPARATEMEASURENUMBER:
                *pClassApproach = CLASSAPPROACH_CELLDETAILS;
                return new FCSeparateMeasureNumber();
            case FCID_SEPARATEPLACEMENT:
                *pClassApproach = CLASSAPPROACH_MEASUREDETAILS;
                return new FCSeparatePlacement();
            case FCID_SMARTSHAPEENTRYMARK:
                *pClassApproach = CLASSAPPROACH_ENTRYDETAILS;
                return new FCSmartShapeEntryMark();
            case FCID_STEMMOD:
                *pClassApproach = CLASSAPPROACH_ENTRYDETAILS;
                return new FCStemMod();
            case FCID_SYLLABLEENTRYMOD:
                *pClassApproach = CLASSAPPROACH_ENTRYDETAILS;
                return new FCSyllableEntryMod();
            case FCID_TABLATURENOTEMOD:
                *pClassApproach = CLASSAPPROACH_NOTEDETAILS;
                return new FCTablatureNoteMod();
            case FCID_TUPLET:
                *pClassApproach = CLASSAPPROACH_ENTRYDETAILS;
                return new FCTuplet();
            default:
                *pClassApproach = CLASSAPPROACH_NONE;
                return NULL;
        }
    }
    
    
        void StartTiming()
        {
                _timingstart = 0;
                _timingend = 0;         
                _timingstart = FCUI::GetHiResTimer();
        }
 
        void EndTiming()
        {               
                _timingend = FCUI::GetHiResTimer();
        }
 
        /* Initializes Finale's progress bar.
        * 
        * The progress bar info is not stored in the class data, to make sure that stacked iterators should be able to run
        * from the same iterator.
        */
        void StartProgressBar(EProgressDataP *ppProgressBarData, int count, int* pProgressUpdateCount)
        {
                _progressbar_useraborted = false;
                *pProgressUpdateCount = 0;
                if (!_useprogressbar) return;
                *ppProgressBarData = FX_StartMassEdit(NULL, count);
        }
 
        /* Updates Finale's progress bar and checks for user iterrupts.
        *
        * The progress bar info is not stored in the class data, to make sure
    * that stacked iterators should be able to run
        * from the same iterator.
    *
    * Returns false if user aborts the progressbar
        */
        bool UpdateProgressBar(EProgressDataP *ppProgressBarData, int* pProgressUpdateCount)
        {
                if (!_useprogressbar) return true;
                if (!*ppProgressBarData) return true;
                (*pProgressUpdateCount)++;
                if (*pProgressUpdateCount < _progressfrequency) return true;
 
                bool continueflag = (FX_MassEditProgress(*ppProgressBarData, _progressfrequency, 0, 0, 0) != 0);
                if ((!continueflag) && _abortableprogressbar)
                {
                        _progressbar_useraborted = true;
                        FX_EndMassEdit(*ppProgressBarData, true);
                        return false;
                }
                return true;
        }
 
        /* Destroys Finale's progress bar.
        *
        * The progress bar info is not stored in the class data, to make sure that stacked iterators should be able to run
        * from the same iterator.
        */
        void EndProgressBar(EProgressDataP *ppProgressBarData, bool abortprogress)
        {
                if (!_useprogressbar) return;
                if (!*ppProgressBarData) return;
                FX_EndMassEdit(*ppProgressBarData, abortprogress);
                *ppProgressBarData = NULL;
        }
 
        /* Set up the LuaRef for the correct object type */
        bool SetupCorrectCppClass(__FCBaseData* pProcessObject, luabridge::LuaRef &parameter)
        {
        lua_State * pLuaState = parameter.state();
        
        switch (pProcessObject->GetClassID())
                {
            case FCID_ACCIDENTALMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCAccidentalMod*)pProcessObject);
                return true;
            case FCID_ALLOTMENT:
                parameter = luabridge::LuaRef(pLuaState, (FCAllotment*)pProcessObject);
                return true;
            case FCID_ARTICULATION:
                parameter = luabridge::LuaRef(pLuaState, (FCArticulation*)pProcessObject);
                return true;
            case FCID_ARTICULATIONDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCArticulationDef*)pProcessObject);
                return true;
            case FCID_BACKWARDREPEAT:
                parameter = luabridge::LuaRef(pLuaState, (FCBackwardRepeat*)pProcessObject);
                return true;
            case FCID_BASELINE:
                parameter = luabridge::LuaRef(pLuaState, (FCBaseline*)pProcessObject);
                return true;
            case FCID_BEAMMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCBeamMod*)pProcessObject);
                return true;
            case FCID_BEATCHARTELEMENT:
                parameter = luabridge::LuaRef(pLuaState, (FCBeatChartElement*)pProcessObject);
                return true;
            case FCID_BROKENBEAMMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCBrokenBeamMod*)pProcessObject);
                return true;
            case FCID_CATEGORYDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCCategoryDef*)pProcessObject);
                return true;
            case FCID_CELLCLEFCHANGE:
                parameter = luabridge::LuaRef(pLuaState, (FCCellClefChange*)pProcessObject);
                return true;
            case FCID_CELLFRAMEHOLD:
                parameter = luabridge::LuaRef(pLuaState, (FCCellFrameHold*)pProcessObject);
                return true;
            case FCID_CELLGRAPHIC:
                parameter = luabridge::LuaRef(pLuaState, (FCCellGraphic*)pProcessObject);
                return true;
            case FCID_CELLTEXT:
                parameter = luabridge::LuaRef(pLuaState, (FCCellText*)pProcessObject);
                return true;
            case FCID_CENTERSMARTSHAPE:
                parameter = luabridge::LuaRef(pLuaState, (FCCenterSmartShape*)pProcessObject);
                return true;
            case FCID_CHORD:
                parameter = luabridge::LuaRef(pLuaState, (FCChord*)pProcessObject);
                return true;
            case FCID_CHORDSUFFIXELEMENT:
                parameter = luabridge::LuaRef(pLuaState, (FCChordSuffixElement*)pProcessObject);
                return true;
            case FCID_CHORUSSYLLABLE:
                parameter = luabridge::LuaRef(pLuaState, (FCChorusSyllable*)pProcessObject);
                return true;
            case FCID_CLEFDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCClefDef*)pProcessObject);
                return true;
            case FCID_CROSSSTAFFMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCCrossStaffMod*)pProcessObject);
                return true;
            case FCID_CUSTOMSMARTLINEDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCCustomSmartLineDef*)pProcessObject);
                return true;
            case FCID_CUSTOMSTEMMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCCustomStemMod*)pProcessObject);
                return true;
            case FCID_DOTMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCDotMod*)pProcessObject);
                return true;
            case FCID_ENCLOSURE:
                parameter = luabridge::LuaRef(pLuaState, (FCEnclosure*)pProcessObject);
                return true;
            case FCID_ENDINGREPEAT:
                parameter = luabridge::LuaRef(pLuaState, (FCEndingRepeat*)pProcessObject);
                return true;
            case FCID_ENTRYALTERMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCEntryAlterMod*)pProcessObject);
                return true;
            case FCID_EXECUTABLESHAPEDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCExecutableShapeDef*)pProcessObject);
                return true;
            case FCID_EXPRESSION:
                parameter = luabridge::LuaRef(pLuaState, (FCExpression*)pProcessObject);
                return true;
            case FCID_FREEZESYSTEM:
                parameter = luabridge::LuaRef(pLuaState, (FCFreezeSystem*)pProcessObject);
                return true;
            case FCID_FRETBOARDSTYLEDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCFretboardStyleDef*)pProcessObject);
                return true;
            case FCID_FRETBOARDGROUPDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCFretboardGroupDef*)pProcessObject);
                return true;
            case FCID_FRETINSTRUMENTDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCFretInstrumentDef*)pProcessObject);
                return true;
            case FCID_GROUP:
                parameter = luabridge::LuaRef(pLuaState, (FCGroup*)pProcessObject);
                return true;
            case FCID_INDEPENDENTCELLDETAIL:
                parameter = luabridge::LuaRef(pLuaState, (FCIndependentCellDetail*)pProcessObject);
                return true;
            case FCID_INSTRUMENTDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCInstrumentDef*)pProcessObject);
                return true;
            case FCID_INSTRUMENTPLAYBACKDATA:
                parameter = luabridge::LuaRef(pLuaState, (FCInstrumentPlaybackData*)pProcessObject);
                return true;
            case FCID_MEASURE:
                parameter = luabridge::LuaRef(pLuaState, (FCMeasure*)pProcessObject);
                return true;
            case FCID_MEASURENUMBERREGION:
                parameter = luabridge::LuaRef(pLuaState, (FCMeasureNumberRegion*)pProcessObject);
                return true;
            case FCID_METATOOLASSIGNMENT:
                parameter = luabridge::LuaRef(pLuaState, (FCMetatoolAssignment*)pProcessObject);
                return true;
            case FCID_MIDIEXPRESSION:
                parameter = luabridge::LuaRef(pLuaState, (FCMidiExpression*)pProcessObject);
                return true;
            case FCID_MULTIMEASUREREST:
                parameter = luabridge::LuaRef(pLuaState, (FCMultiMeasureRest*)pProcessObject);
                return true;
            case FCID_MULTISTAFFINSTRUMENT:
                parameter = luabridge::LuaRef(pLuaState, (FCMultiStaffInstrument*)pProcessObject);
                return true;
            case FCID_NOTEHEADMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCNoteheadMod*)pProcessObject);
                return true;
            case FCID_PERCUSSIONLAYOUTNOTE:
                parameter = luabridge::LuaRef(pLuaState, (FCPercussionLayoutNote*)pProcessObject);
                return true;
            case FCID_PERCUSSIONSTAFF:
                parameter = luabridge::LuaRef(pLuaState, (FCPercussionStaff*)pProcessObject);
                return true;
            case FCID_PERFORMANCEMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCPerformanceMod*)pProcessObject);
                return true;
            case FCID_PAGE:
                parameter = luabridge::LuaRef(pLuaState, (FCPage*)pProcessObject);
                return true;
            case FCID_PAGEGRAPHIC:
                parameter = luabridge::LuaRef(pLuaState, (FCPageGraphic*)pProcessObject);
                return true;
            case FCID_PAGETEXT:
                parameter = luabridge::LuaRef(pLuaState, (FCPageText*)pProcessObject);
                return true;
            case FCID_PERCUSSIONNOTEMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCPercussionNoteMod*)pProcessObject);
                return true;
            case FCID_RAWTEXT:
                parameter = luabridge::LuaRef(pLuaState, (FCRawText*)pProcessObject);
                return true;
            case FCID_SECONDARYBEAMBREAKMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCSecondaryBeamBreakMod*)pProcessObject);
                return true;
            case FCID_SECTIONSYLLABLE:
                parameter = luabridge::LuaRef(pLuaState, (FCSectionSyllable*)pProcessObject);
                return true;
            case FCID_SEPARATEMEASURENUMBER:
                parameter = luabridge::LuaRef(pLuaState, (FCSeparateMeasureNumber*)pProcessObject);
                return true;
            case FCID_SEPARATEPLACEMENT:
                parameter = luabridge::LuaRef(pLuaState, (FCSeparatePlacement*)pProcessObject);
                return true;
#ifdef PDK_FRAMEWORK_SHAPES
            case FCID_SHAPEDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCShapeDef*)pProcessObject);
                return true;
#endif
            case FCID_SHAPEEXPRESSIONDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCShapeExpressionDef*)pProcessObject);
                return true;
            case FCID_SMARTSHAPE:
                parameter = luabridge::LuaRef(pLuaState, (FCSmartShape*)pProcessObject);
                return true;
            case FCID_SMARTSHAPEENTRYMARK:
                parameter = luabridge::LuaRef(pLuaState, (FCSmartShapeEntryMark*)pProcessObject);
                return true;
            case FCID_SMARTSHAPEMEASUREMARK:
                parameter = luabridge::LuaRef(pLuaState, (FCSmartShapeMeasureMark*)pProcessObject);
                return true;
            case FCID_STAFF:
                parameter = luabridge::LuaRef(pLuaState, (FCStaff*)pProcessObject);
                return true;
            case FCID_STAFFLIST:
                parameter = luabridge::LuaRef(pLuaState, (FCStaffList*)pProcessObject);
                return true;
            case FCID_STAFFNAMEPOSITION:
                parameter = luabridge::LuaRef(pLuaState, (FCStaffNamePosition*)pProcessObject);
                return true;
            case FCID_STAFFSTYLEASSIGN:
                parameter = luabridge::LuaRef(pLuaState, (FCStaffStyleAssign*)pProcessObject);
                return true;
            case FCID_STAFFSTYLEDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCStaffStyleDef*)pProcessObject);
                return true;
            case FCID_STAFFSYSTEM:
                parameter = luabridge::LuaRef(pLuaState, (FCStaffSystem*)pProcessObject);
                return true;
            case FCID_STEMMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCStemMod*)pProcessObject);
                return true;
            case FCID_SYLLABLEENTRYMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCSyllableEntryMod*)pProcessObject);
                return true;
            case FCID_SYSTEMSTAFF:
                parameter = luabridge::LuaRef(pLuaState, (FCSystemStaff*)pProcessObject);
                return true;
            case FCID_TABLATURENOTEMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCTablatureNoteMod*)pProcessObject);
                return true;
            case FCID_TEMPOELEMENT:
                parameter = luabridge::LuaRef(pLuaState, (FCTempoElement*)pProcessObject);
                return true;
            case FCID_TEXTBLOCK:
                parameter = luabridge::LuaRef(pLuaState, (FCTextBlock*)pProcessObject);
                return true;
            case FCID_TEXTEXPRESSIONDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCTextExpressionDef*)pProcessObject);
                return true;
            case FCID_TEXTREPEAT:
                parameter = luabridge::LuaRef(pLuaState, (FCTextRepeat*)pProcessObject);
                return true;
            case FCID_TEXTREPEATDEF:
                parameter = luabridge::LuaRef(pLuaState, (FCTextRepeatDef*)pProcessObject);
                return true;
            case FCID_TIEMOD:
                parameter = luabridge::LuaRef(pLuaState, (FCTieMod*)pProcessObject);
                return true;
            case FCID_TUPLET:
                parameter = luabridge::LuaRef(pLuaState, (FCTuplet*)pProcessObject);
                return true;
            case FCID_VERSESYLLABLE:
                parameter = luabridge::LuaRef(pLuaState, (FCVerseSyllable*)pProcessObject);
                return true;
                
                default:
#ifdef PDK_FRAMEWORK_DIAGNOSE
                        DebugOutInt("Error in FCLuaIterator - unhandled class: ", pProcessObject->GetClassID());
#endif
                        return false;
                }
        }
public:
        FCLuaIterator() : __FCBase()
        {               
                _progressfrequency = 20;                        
                _timingstart = _timingend = 0;
                _forwardprocessing = true;
                _downwardprocessing = true;
                _partialmeasureselections = true;
                _nullregionequalsall = false;
                _useprogressbar = false;
                _abortableprogressbar = false;
                _progressbar_useraborted = false;
                _loadlayermode = 0;
        _processscorepart = true;
        _processcurrentpart = true;
        _processcurrentdoc = true;
        }
    
        int ForEach(__FCCollectionData* pCollection, luabridge::LuaRef lua_callback_function)
        {
        StartTiming();
        int count = ProcessForEach(pCollection, lua_callback_function, false);
        EndTiming();
        return count;
    }
    
        int ForEachSaved(__FCCollectionData* pCollection, luabridge::LuaRef lua_callback_function)
        {
        StartTiming();
        int count = ProcessForEach(pCollection, lua_callback_function, true);
        EndTiming();
        return count;
    }
               
        int ForEachEntry(FCMusicRegion* pRegion, luabridge::LuaRef lua_callback_function)
        {
        StartTiming();
                int count = ProcessRegionEntries(pRegion, lua_callback_function, false);
        EndTiming();
        return count;
        }
 
        int ForEachEntrySaved(FCMusicRegion* pRegion, luabridge::LuaRef lua_callback_function)
        {
        StartTiming();
                int count = ProcessRegionEntries(pRegion, lua_callback_function, true);
        EndTiming();
        return count;
        }
 
        int ForEachNote(FCMusicRegion* pRegion, luabridge::LuaRef lua_callback_function)
        {
        StartTiming();
                int count = ProcessRegionNotes(pRegion, lua_callback_function, false);
        EndTiming();
        return count;
        }
 
        int ForEachNoteSaved(FCMusicRegion* pRegion, luabridge::LuaRef lua_callback_function)
        {
        StartTiming();
                int count = ProcessRegionNotes(pRegion, lua_callback_function, true);
        EndTiming();
        return count;
        }
 
        int ForEachCell(FCMusicRegion* pRegion, luabridge::LuaRef lua_callback_function)
        {
                StartTiming();
                int count = ProcessForEachCell(pRegion, lua_callback_function);
                EndTiming();
                return count;
        }
    
    int ForEachPart(luabridge::LuaRef lua_callback_function)
    {           
                StartTiming();
                int count = ProcessForEachPart(lua_callback_function);
                EndTiming();
                return count;           
    }
    
    int ForEachObject(int classID, luabridge::LuaRef lua_callback_function)
    {
        if (!lua_callback_function.isFunction()) return 0;
        StartTiming();
        __FCCollectionData* pCollection = LoadCollectionForClassID((PDKFRAMEWORK_CLASSID) classID);
        if (!pCollection)
        {
            EndTiming();
            return 0;
        }
        int count = ProcessForEach(pCollection, lua_callback_function, false);
        delete pCollection;
        EndTiming();
        return count;
    }
    
    int ForEachObjectSaved(int classID, luabridge::LuaRef lua_callback_function)
    {
        if (!lua_callback_function.isFunction()) return 0;
        StartTiming();
        __FCCollectionData* pCollection = LoadCollectionForClassID((PDKFRAMEWORK_CLASSID) classID);
        if (!pCollection)
        {
            EndTiming();
            return 0;
        }
        int count = ProcessForEach(pCollection, lua_callback_function, true);
        delete pCollection;
        EndTiming();
        return count;
    }
    
    int ForEachRegionObject(FCMusicRegion* pRegion, int classID, luabridge::LuaRef lua_callback_function)
    {
        StartTiming();
        int count = ProcessForEachRegionObject(pRegion, classID, lua_callback_function, false);
        EndTiming();
        return count;
    }
    
    int ForEachRegionObjectSaved(FCMusicRegion* pRegion, int classID, luabridge::LuaRef lua_callback_function)
    {
        StartTiming();
        int count = ProcessForEachRegionObject(pRegion, classID, lua_callback_function, true);
        EndTiming();
        return count;
    }
 
    int ForEachDocument(luabridge::LuaRef lua_callback_function)
    {
        StartTiming();
        int count = ProcessForEachDocument(lua_callback_function, false);
        EndTiming();
        return count;
    }
    
    int ForEachDocumentSaved(luabridge::LuaRef lua_callback_function)
    {
        StartTiming();
        int count = ProcessForEachDocument(lua_callback_function, true);
        EndTiming();
        return count;
    }
    
    int ForEachFile(FCStrings* pFileStrings, luabridge::LuaRef lua_callback_function)
    {
        StartTiming();
        int count = ProcessForEachFile(pFileStrings, lua_callback_function, false);
        EndTiming();
        return count;
    }
    
    int ForEachFileSaved(FCStrings* pFileStrings, luabridge::LuaRef lua_callback_function)
    {
        StartTiming();
        int count = ProcessForEachFile(pFileStrings, lua_callback_function, true);
        EndTiming();
        return count;
    }
    
    int ForEachInteger(int integer1, int integer2, luabridge::LuaRef lua_callback_function)
    {
        StartTiming();
        int count = ProcessForEachInteger(integer1, integer2, lua_callback_function);
        EndTiming();
        return count;
    }
 
        bool GetUseProgressBar() const { return _useprogressbar; }
 
        int GetProgressUpdateFrequency() const
        {
                return _progressfrequency;
        }
 
        bool GetAbortableProgressBar() const
        {
                return _abortableprogressbar;
        }
 
        bool GetProgressBarUserAborted() const { return _progressbar_useraborted; }
 
        int GetLoadLayerMode() const
        {
                return _loadlayermode;
        }
                            
    bool GetProcessScorePart() const { return _processscorepart; }
    
    bool GetProcessCurrentPart() const { return _processcurrentpart; }
 
    bool GetProcessCurrentDocument() const { return _processcurrentdoc; }
 
        bool GetNullRegionEqualsAll() const { return _nullregionequalsall; }
 
        bool GetForwardProcessing() const { return _forwardprocessing; }
 
        bool GetDownwardProcessing() const { return _downwardprocessing; }
 
        bool GetPartialMeasureSelections() const { return _partialmeasureselections; }
    
        void SetUseProgressBar(bool use) { _useprogressbar = use; }
 
        void SetProgressUpdateFrequency(int freq)
        {
                if (freq < 1) return;
                _progressfrequency = freq;
        }
 
        void SetAbortableProgressBar(bool state) { _abortableprogressbar = state; }
    
    void SetLoadLayerMode(int loadlayermode) { _loadlayermode = loadlayermode; }
                
    void SetProcessScorePart(bool state) { _processscorepart = state; }
 
    void SetProcessCurrentPart(bool state) { _processcurrentpart = state; }
 
    void SetProcessCurrentDocument(bool state) { _processcurrentdoc = state; }
 
        void SetNullRegionEqualsAll(bool state) { _nullregionequalsall = state; }
 
        void SetForwardProcessing(bool forward) { _forwardprocessing = forward; }
 
        void SetDownwardProcessing(bool downward) { _downwardprocessing = downward; }
 
        void SetPartialMeasureSelections(bool partialselections) { _partialmeasureselections = partialselections; }
    
    bool AddEntryFilter(int filter, int logicmode)
    {        
                switch (logicmode)
                {
                        case LILOGIC_AND:
                                return _entryfilters_AND.AddFilter((LUAITERATOR_ENTRYFILTERS)filter);                           
                        case LILOGIC_OR:
                                return _entryfilters_OR.AddFilter((LUAITERATOR_ENTRYFILTERS)filter);                            
                        case LILOGIC_NOT:
                                return _entryfilters_NOT.AddFilter((LUAITERATOR_ENTRYFILTERS)filter);
                }
                return false;
    }
 
        bool RemoveEntryFilter(int filter, int logicmode)
        {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return _entryfilters_AND.RemoveFilter((LUAITERATOR_ENTRYFILTERS)filter);
                case LILOGIC_OR:
                        return _entryfilters_OR.RemoveFilter((LUAITERATOR_ENTRYFILTERS)filter);
                case LILOGIC_NOT:
                        return _entryfilters_NOT.RemoveFilter((LUAITERATOR_ENTRYFILTERS)filter);
                }
                return false;           
        }
    
    void ClearAllEntryFilters() 
        { 
                _entryfilters_AND.ClearAll();
                _entryfilters_OR.ClearAll();
                _entryfilters_NOT.ClearAll();
        }
 
        bool IsEntryFilterAdded(int filter, int logicmode)
        {               
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return (_entryfilters_AND.Find((LUAITERATOR_ENTRYFILTERS)filter) != NULL);                      
                case LILOGIC_OR:
                        return (_entryfilters_OR.Find((LUAITERATOR_ENTRYFILTERS)filter) != NULL);                       
                case LILOGIC_NOT:
                        return (_entryfilters_NOT.Find((LUAITERATOR_ENTRYFILTERS)filter) != NULL);
                }
                return false;           
        }
    
        bool AddNoteFilter(int filter, int logicmode)
    {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return _notefilters_AND.AddFilter((LUAITERATOR_NOTEFILTERS)filter);
                case LILOGIC_OR:
                        return _notefilters_OR.AddFilter((LUAITERATOR_NOTEFILTERS)filter);
                case LILOGIC_NOT:
                        return _notefilters_NOT.AddFilter((LUAITERATOR_NOTEFILTERS)filter);
                }
                return false;
    }
    
        bool RemoveNoteFilter(int filter, int logicmode)
        {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return _notefilters_AND.RemoveFilter((LUAITERATOR_NOTEFILTERS)filter);
                case LILOGIC_OR:
                        return _notefilters_OR.RemoveFilter((LUAITERATOR_NOTEFILTERS)filter);
                case LILOGIC_NOT:
                        return _notefilters_NOT.RemoveFilter((LUAITERATOR_NOTEFILTERS)filter);
                }
                return false;           
        }
    
    void ClearAllNoteFilters() 
        {
                _notefilters_AND.ClearAll();
                _notefilters_OR.ClearAll();
                _notefilters_NOT.ClearAll();
        }
    
        bool IsNoteFilterAdded(int filter, int logicmode)
        {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return (_notefilters_AND.Find((LUAITERATOR_NOTEFILTERS)filter) != NULL);
                case LILOGIC_OR:
                        return (_notefilters_OR.Find((LUAITERATOR_NOTEFILTERS)filter) != NULL);
                case LILOGIC_NOT:
                        return (_notefilters_NOT.Find((LUAITERATOR_NOTEFILTERS)filter) != NULL);
                }
                return false;           
        }
    
        bool AddAltNotationFilter(int filter, int logicmode)
    {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return _altnotationfilters_AND.AddFilter((__FCStaffBase::ALTERNATE_STAFF)filter);
                case LILOGIC_OR:
                        return _altnotationfilters_OR.AddFilter((__FCStaffBase::ALTERNATE_STAFF)filter);
                case LILOGIC_NOT:
                        return _altnotationfilters_NOT.AddFilter((__FCStaffBase::ALTERNATE_STAFF)filter);
                }
                return false;   
    }
    
        bool RemoveAltNotationFilter(int filter, int logicmode)
        {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return _altnotationfilters_AND.RemoveFilter((__FCStaffBase::ALTERNATE_STAFF)filter);
                case LILOGIC_OR:
                        return _altnotationfilters_OR.RemoveFilter((__FCStaffBase::ALTERNATE_STAFF)filter);
                case LILOGIC_NOT:
                        return _altnotationfilters_NOT.RemoveFilter((__FCStaffBase::ALTERNATE_STAFF)filter);
                }
                return false;
        }
    
    void ClearAllAltNotationFilters() 
        { 
                _altnotationfilters_AND.ClearAll(); 
                _altnotationfilters_OR.ClearAll();
                _altnotationfilters_NOT.ClearAll();
        }
    
        bool IsAltNotationFilterAdded(int filter, int logicmode)
        {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return (_altnotationfilters_AND.Find((__FCStaffBase::ALTERNATE_STAFF)filter) != NULL);
                case LILOGIC_OR:
                        return (_altnotationfilters_OR.Find((__FCStaffBase::ALTERNATE_STAFF)filter) != NULL);
                case LILOGIC_NOT:
                        return (_altnotationfilters_NOT.Find((__FCStaffBase::ALTERNATE_STAFF)filter) != NULL);
                }
                return false;           
        }
 
        bool AddNotationStyleFilter(int filter, int logicmode)
        {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return _notationstylefilters_AND.AddFilter((__FCStaffBase::STAFFNOTATION_STYLE)filter);
                case LILOGIC_OR:
                        return _notationstylefilters_OR.AddFilter((__FCStaffBase::STAFFNOTATION_STYLE)filter);
                case LILOGIC_NOT:
                        return _notationstylefilters_NOT.AddFilter((__FCStaffBase::STAFFNOTATION_STYLE)filter);
                }
                return false;
        }
 
        bool RemoveNotationStyleFilter(int filter, int logicmode)
        {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return _notationstylefilters_AND.RemoveFilter((__FCStaffBase::STAFFNOTATION_STYLE)filter);
                case LILOGIC_OR:
                        return _notationstylefilters_OR.RemoveFilter((__FCStaffBase::STAFFNOTATION_STYLE)filter);
                case LILOGIC_NOT:
                        return _notationstylefilters_NOT.RemoveFilter((__FCStaffBase::STAFFNOTATION_STYLE)filter);
                }
                return false;
        }
 
        void ClearAllNotationStyleFilters()
        {
                _notationstylefilters_AND.ClearAll();
                _notationstylefilters_OR.ClearAll();
                _notationstylefilters_NOT.ClearAll();
        }
 
        bool IsNotationStyleFilterAdded(int filter, int logicmode)
        {
                switch (logicmode)
                {
                case LILOGIC_AND:
                        return (_notationstylefilters_AND.Find((__FCStaffBase::STAFFNOTATION_STYLE)filter) != NULL);
                case LILOGIC_OR:
                        return (_notationstylefilters_OR.Find((__FCStaffBase::STAFFNOTATION_STYLE)filter) != NULL);
                case LILOGIC_NOT:
                        return (_notationstylefilters_NOT.Find((__FCStaffBase::STAFFNOTATION_STYLE)filter) != NULL);
                }
                return false;
        }
    
        double CalcLastDuration()
        {
        if (_timingend == 0) return 0;
                return (_timingend - _timingstart);
        }
};
 
#endif // jwlua_fflua_luaiterator_h