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
* jwlua_luabridgeconnect.cpp implementation.)
*
* The following class implementation is for the special FCLuaIterator class in JW Lua. Since
* a limitation of LuaBridge is that the include file can only be included at one place,
* this work-around is used.
*/



class FCLuaIterator : public __FCBase
{
public:

        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:
                _FCLuaIterEntryFilter(LUAITERATOR_ENTRYFILTERS value) : __FCBase() { _entryfilter = value; }

                LUAITERATOR_ENTRYFILTERS GetFilter() { return _entryfilter; }
        };

        class _FCLuaIterEntryFilters : public __FCCollection
        {
        public:
                _FCLuaIterEntryFilters() : __FCCollection() {}


                _FCLuaIterEntryFilter* GetItemAt(int index) { 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:
                _FCLuaIterNoteFilter(LUAITERATOR_NOTEFILTERS value) : __FCBase() { _notefilter = value; }
        
                LUAITERATOR_NOTEFILTERS GetFilter() { return _notefilter; }
        };
    
        class _FCLuaIterNoteFilters : public __FCCollection
        {
        public:
                _FCLuaIterNoteFilters() : __FCCollection() {}
        
        
                _FCLuaIterNoteFilter* GetItemAt(int index) { 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:
                _FCLuaIterAltNotationFilter(__FCStaffBase::ALTERNATE_STAFF value) : __FCBase() { _altnotationfilter = value; }
        
                __FCStaffBase::ALTERNATE_STAFF GetFilter() { return _altnotationfilter; }
        };
    
        class _FCLuaIterAltNotationFilters : public __FCCollection
        {
        public:
                _FCLuaIterAltNotationFilters() : __FCCollection() {}
        
        _FCLuaIterAltNotationFilter* GetItemAt(int index) { 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:
                _FCLuaIterNotationStyleFilter(__FCStaffBase::STAFFNOTATION_STYLE value) : __FCBase() { _notationstylefilter = value; }

                __FCStaffBase::STAFFNOTATION_STYLE GetFilter() { return _notationstylefilter; }
        };

        class _FCLuaIterNotationStyleFilters : public __FCCollection
        {
        public:
                _FCLuaIterNotationStyleFilters() : __FCCollection() {}

                _FCLuaIterNotationStyleFilter* GetItemAt(int index) { 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
                        DebugOutDigit("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
                        DebugOutDigit("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 OutputExceptionError(luabridge::LuaException e)
        {
                FCString errstring;
                errstring.SetCString(e.what());
                LuaRun_AppendLineToOutput(&errstring);
        }

        /* Executes the Lua callback function */
        bool ExecuteCallback(luabridge::LuaRef &lua_callback_function, luabridge::LuaRef &parameter, EProgressDataP *ppProgressBarData)
        {
                bool continueflag = true;
                try
                {
                        luabridge::LuaRef returnvalue = lua_callback_function(parameter);
                        if (returnvalue.type() == LUA_TBOOLEAN) continueflag = returnvalue.cast <bool>();
                        if (continueflag == false)
                        {
                /* Don't roll back changes if callback exits with false */
                                EndProgressBar(ppProgressBarData, false);
                                return false;
                        }
                }
                /* Handle exceptions */
                catch (luabridge::LuaException e)
                {
                        OutputExceptionError(e);
                        EndProgressBar(ppProgressBarData, true);
                        return false;
                }
                return true;
        }

        /* Executes the Lua callback function for the ForEachCell() iterator. */
        bool ExecuteCellCallback(luabridge::LuaRef &lua_callback_function, int measure, int staff, EProgressDataP *ppProgressBarData)
        {
                bool continueflag = true;
                try
                {
                        luabridge::LuaRef returnvalue = lua_callback_function(measure, staff);
                        if (returnvalue.type() == LUA_TBOOLEAN) continueflag = returnvalue.cast <bool>();
                        if (continueflag == false)
                        {
                /* Don't roll back changes if callback exits with false */
                                EndProgressBar(ppProgressBarData, false);
                                return false;
                        }
                }
                /* Handle exceptions */
                catch (luabridge::LuaException e)
                {
                        OutputExceptionError(e);
                        EndProgressBar(ppProgressBarData, true);
                        return false;
                }
                return true;
        }
    
    /* Executes the Lua callback function for the ForEachFile() iterator. */
        bool ExecuteFileCallback(luabridge::LuaRef &lua_callback_function, FCDocument* pDocument, FCString* pFileName, EProgressDataP *ppProgressBarData)
        {
                bool continueflag = true;
                try
                {
                        luabridge::LuaRef returnvalue = lua_callback_function(pDocument, pFileName);
                        if (returnvalue.type() == LUA_TBOOLEAN) continueflag = returnvalue.cast <bool>();
                        if (continueflag == false)
                        {
                /* Don't roll back changes if callback exits with false */
                                EndProgressBar(ppProgressBarData, false);
                                return false;
                        }
                }
                /* Handle exceptions */
                catch (luabridge::LuaException e)
                {
                        OutputExceptionError(e);
                        EndProgressBar(ppProgressBarData, true);
                        return false;
                }
                return true;
        }

        int ProcessRegionEntries(FCMusicRegion* pRegion, luabridge::LuaRef &lua_callback_function, bool shouldsave)
        {
                FCMusicRegion fullregion;
                if (!pRegion || pRegion->IsEmpty())
                {
                        if (!_nullregionequalsall) return 0;
                        if (!fullregion.SetFullDocument()) return 0;
                        pRegion = &fullregion;
                }
                if (!lua_callback_function.isFunction()) return 0;
                if (pRegion->IsEmpty()) 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;
                                                                luabridge::LuaRef parameter(_pGlobal_LuaState, pEntry);
                                                                count++;
                                                                if (!ExecuteCallback(lua_callback_function, parameter, &pProgressBarData))
                                                                {
                                                                        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;
            case FCID_SHAPEDEF:
                pCollectionData = new FCShapeDefs();
                break;
            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->IsEmpty())
                {
                        if (!_nullregionequalsall) return 0;
                        if (!fullregion.SetFullDocument()) return 0;
                        pRegion = &fullregion;
                }
                if (!lua_callback_function.isFunction()) return 0;
                if (pRegion->IsEmpty()) 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;
                                                                                luabridge::LuaRef parameter(_pGlobal_LuaState, pNote);
                                                                                count++;
                                                                                if (!ExecuteCallback(lua_callback_function, parameter, &pProgressBarData))
                                                                                {
                                                                                        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->IsEmpty())
                {
                        if (!_nullregionequalsall) return 0;
                        if (!fullregion.SetFullDocument()) return 0;
                        pRegion = &fullregion;
                }
                if (!lua_callback_function.isFunction()) return 0;
                if (pRegion->IsEmpty()) 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 (!ExecuteCellCallback(lua_callback_function, meas, staff, &pProgressBarData))
                                                {
                                                        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;
                
                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(_pGlobal_LuaState, pPart);
                                count++;
                                bool callbackreturn = ExecuteCallback(lua_callback_function, parameter, &pProgressBarData);
                                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);
        
        luabridge::LuaRef parameter(_pGlobal_LuaState);
                /* 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, parameter, &pProgressBarData))
                                {
                                        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, parameter, &pERData->pProgressBarData))
                                                {
                                                        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, parameter, &pERData->pProgressBarData))
                                                        {
                                                                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, parameter, &pERData->pProgressBarData))
                {
                    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, parameter, &pERData->pProgressBarData))
                {
                    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->IsEmpty())
                {
                        if (!_nullregionequalsall) return 0;
                        if (!fullregion.SetFullDocument()) return 0;
                        pRegion = &fullregion;
                }
                if (!lua_callback_function.isFunction()) return 0;
                if (pRegion->IsEmpty()) 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;
        
                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(_pGlobal_LuaState);
                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;

        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;

                                FCString astring;
                                FCDocument::GetLastUndoString(&astring);
                                pDoc->SwitchTo(&astring, true);
                                luabridge::LuaRef parameter(_pGlobal_LuaState, pDoc);
                                count++;

                                /* User callback */
                                if (!ExecuteCallback(lua_callback_function, parameter, &pProgressBarData))
                                {
                                        pDoc->SwitchBack(true);
                                        return count;
                                }
                                if (shouldsave && (!pDoc->IsUntitled())) pDoc->Save();
                                pDoc->SwitchBack(true);
                                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);

        FCDocument currentdocument;
        currentdocument.SetToCurrent();

        FCString lastundostring;
        FCDocument::GetLastUndoString(&lastundostring);
        
                int filenameidx = 0;
                if (_forwardprocessing)
                        filenameidx = 0;
                else
                        filenameidx = pFileStrings->GetCount() - 1;
                while (filenameidx >= 0 && filenameidx < pFileStrings->GetCount())
        {
                        while (true)
                        {
                                FCString* pString = pFileStrings->GetItemAt(filenameidx);
                                if (!pString) break;
                                if (pString->IsEmpty()) break;
                                FCDocument document;
                                count++;
                                bool executereturn = false;
                                /* 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, &lastundostring))
                                {
                                        /* Document is now in focus */
                                        executereturn = ExecuteFileCallback(lua_callback_function, &document, pString, &pProgressBarData);
                                        if (executereturn && shouldsave) document.Save();
                                        document.SetDirty(false);
                                        if (shouldsave)
                                                document.CloseCurrentDocumentWindow();
                                        else
                                                document.Close();

                                        /* Start new Finale edit block for the current document */
                                        if (currentdocument.SwitchTo(&lastundostring, true))
                                        {
                                                currentdocument._DiscardSwitchBack();
                                        }
                                }
                                else
                                {
                                        /* File couldn't be opened - send nil to the callback */
                                        luabridge::LuaRef parameter(_pGlobal_LuaState, NULL);
                                        executereturn = ExecuteFileCallback(lua_callback_function, &document, NULL, &pProgressBarData);
                                }
                                if (!executereturn) return count;
                                break;
                        } /* while (true) */
                        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);
        
        FCDocument currentdocument;
        currentdocument.SetToCurrent();
        
        FCString lastundostring;
        FCDocument::GetLastUndoString(&lastundostring);
        
        for (int i = integer1; i != integer2; i += incdec)
        {
                        /* Handle the progress bar */
                        if (!UpdateProgressBar(&pProgressBarData, &progressupdatecount)) return count;                  

                        luabridge::LuaRef parameter(_pGlobal_LuaState, i + incdec);
            count ++;
                        bool executereturn = ExecuteCallback(lua_callback_function, parameter, &pProgressBarData);
                        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();
/*          Not yet supported in JW Lua
            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)
        {
                switch (pProcessObject->GetClassID())
                {
            case FCID_ACCIDENTALMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCAccidentalMod*)pProcessObject);
                return true;
            case FCID_ALLOTMENT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCAllotment*)pProcessObject);
                return true;
            case FCID_ARTICULATION:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCArticulation*)pProcessObject);
                return true;
            case FCID_ARTICULATIONDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCArticulationDef*)pProcessObject);
                return true;
            case FCID_BACKWARDREPEAT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCBackwardRepeat*)pProcessObject);
                return true;
            case FCID_BASELINE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCBaseline*)pProcessObject);
                return true;
            case FCID_BEAMMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCBeamMod*)pProcessObject);
                return true;
            case FCID_BEATCHARTELEMENT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCBeatChartElement*)pProcessObject);
                return true;
            case FCID_BROKENBEAMMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCBrokenBeamMod*)pProcessObject);
                return true;
            case FCID_CATEGORYDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCCategoryDef*)pProcessObject);
                return true;
            case FCID_CELLCLEFCHANGE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCCellClefChange*)pProcessObject);
                return true;
            case FCID_CELLFRAMEHOLD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCCellFrameHold*)pProcessObject);
                return true;
            case FCID_CELLGRAPHIC:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCCellGraphic*)pProcessObject);
                return true;
            case FCID_CELLTEXT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCCellText*)pProcessObject);
                return true;
            case FCID_CENTERSMARTSHAPE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCCenterSmartShape*)pProcessObject);
                return true;
            case FCID_CHORD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCChord*)pProcessObject);
                return true;
            case FCID_CHORDSUFFIXELEMENT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCChordSuffixElement*)pProcessObject);
                return true;
            case FCID_CHORUSSYLLABLE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCChorusSyllable*)pProcessObject);
                return true;
            case FCID_CLEFDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCClefDef*)pProcessObject);
                return true;
            case FCID_CROSSSTAFFMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCCrossStaffMod*)pProcessObject);
                return true;
            case FCID_CUSTOMSMARTLINEDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCCustomSmartLineDef*)pProcessObject);
                return true;
            case FCID_CUSTOMSTEMMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCCustomStemMod*)pProcessObject);
                return true;
            case FCID_DOTMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCDotMod*)pProcessObject);
                return true;
            case FCID_ENCLOSURE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCEnclosure*)pProcessObject);
                return true;
            case FCID_ENDINGREPEAT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCEndingRepeat*)pProcessObject);
                return true;
            case FCID_ENTRYALTERMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCEntryAlterMod*)pProcessObject);
                return true;
            case FCID_EXECUTABLESHAPEDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCExecutableShapeDef*)pProcessObject);
                return true;
            case FCID_EXPRESSION:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCExpression*)pProcessObject);
                return true;
            case FCID_FREEZESYSTEM:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCFreezeSystem*)pProcessObject);
                return true;
            case FCID_FRETBOARDSTYLEDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCFretboardStyleDef*)pProcessObject);
                return true;
            case FCID_FRETBOARDGROUPDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCFretboardGroupDef*)pProcessObject);
                return true;
            case FCID_FRETINSTRUMENTDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCFretInstrumentDef*)pProcessObject);
                return true;
            case FCID_GROUP:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCGroup*)pProcessObject);
                return true;
            case FCID_INDEPENDENTCELLDETAIL:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCIndependentCellDetail*)pProcessObject);
                return true;
            case FCID_INSTRUMENTDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCInstrumentDef*)pProcessObject);
                return true;
            case FCID_INSTRUMENTPLAYBACKDATA:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCInstrumentPlaybackData*)pProcessObject);
                return true;
            case FCID_MEASURE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCMeasure*)pProcessObject);
                return true;
            case FCID_MEASURENUMBERREGION:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCMeasureNumberRegion*)pProcessObject);
                return true;
            case FCID_METATOOLASSIGNMENT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCMetatoolAssignment*)pProcessObject);
                return true;
            case FCID_MIDIEXPRESSION:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCMidiExpression*)pProcessObject);
                return true;
            case FCID_MULTIMEASUREREST:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCMultiMeasureRest*)pProcessObject);
                return true;
            case FCID_MULTISTAFFINSTRUMENT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCMultiStaffInstrument*)pProcessObject);
                return true;
            case FCID_NOTEHEADMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCNoteheadMod*)pProcessObject);
                return true;
            case FCID_PERCUSSIONLAYOUTNOTE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCPercussionLayoutNote*)pProcessObject);
                return true;
            case FCID_PERCUSSIONSTAFF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCPercussionStaff*)pProcessObject);
                return true;
            case FCID_PERFORMANCEMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCPerformanceMod*)pProcessObject);
                return true;
            case FCID_PAGE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCPage*)pProcessObject);
                return true;
            case FCID_PAGEGRAPHIC:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCPageGraphic*)pProcessObject);
                return true;
            case FCID_PAGETEXT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCPageText*)pProcessObject);
                return true;
            case FCID_PERCUSSIONNOTEMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCPercussionNoteMod*)pProcessObject);
                return true;
            case FCID_RAWTEXT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCRawText*)pProcessObject);
                return true;
            case FCID_SECONDARYBEAMBREAKMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCSecondaryBeamBreakMod*)pProcessObject);
                return true;
            case FCID_SECTIONSYLLABLE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCSectionSyllable*)pProcessObject);
                return true;
            case FCID_SEPARATEMEASURENUMBER:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCSeparateMeasureNumber*)pProcessObject);
                return true;
            case FCID_SEPARATEPLACEMENT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCSeparatePlacement*)pProcessObject);
                return true;
            case FCID_SHAPEDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCShapeDef*)pProcessObject);
                return true;
            case FCID_SHAPEEXPRESSIONDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCShapeExpressionDef*)pProcessObject);
                return true;
            case FCID_SMARTSHAPE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCSmartShape*)pProcessObject);
                return true;
            case FCID_SMARTSHAPEENTRYMARK:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCSmartShapeEntryMark*)pProcessObject);
                return true;
            case FCID_SMARTSHAPEMEASUREMARK:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCSmartShapeMeasureMark*)pProcessObject);
                return true;
            case FCID_STAFF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCStaff*)pProcessObject);
                return true;
            case FCID_STAFFLIST:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCStaffList*)pProcessObject);
                return true;
            case FCID_STAFFNAMEPOSITION:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCStaffNamePosition*)pProcessObject);
                return true;
            case FCID_STAFFSTYLEASSIGN:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCStaffStyleAssign*)pProcessObject);
                return true;
            case FCID_STAFFSTYLEDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCStaffStyleDef*)pProcessObject);
                return true;
            case FCID_STAFFSYSTEM:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCStaffSystem*)pProcessObject);
                return true;
            case FCID_STEMMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCStemMod*)pProcessObject);
                return true;
            case FCID_SYLLABLEENTRYMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCSyllableEntryMod*)pProcessObject);
                return true;
            case FCID_SYSTEMSTAFF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCSystemStaff*)pProcessObject);
                return true;
            case FCID_TABLATURENOTEMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCTablatureNoteMod*)pProcessObject);
                return true;
            case FCID_TEMPOELEMENT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCTempoElement*)pProcessObject);
                return true;
            case FCID_TEXTBLOCK:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCTextBlock*)pProcessObject);
                return true;
            case FCID_TEXTEXPRESSIONDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCTextExpressionDef*)pProcessObject);
                return true;
            case FCID_TEXTREPEAT:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCTextRepeat*)pProcessObject);
                return true;
            case FCID_TEXTREPEATDEF:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCTextRepeatDef*)pProcessObject);
                return true;
            case FCID_TIEMOD:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCTieMod*)pProcessObject);
                return true;
            case FCID_TUPLET:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCTuplet*)pProcessObject);
                return true;
            case FCID_VERSESYLLABLE:
                parameter = luabridge::LuaRef(_pGlobal_LuaState, (FCVerseSyllable*)pProcessObject);
                return true;
                
                default:
#ifdef PDK_FRAMEWORK_DIAGNOSE
                        DebugOutDigit("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);
        }
};