ff_othercollection.h

/*
 * File:   ff_collection.h
 * Author: Jari Williamsson
 *
 * Created on den 7 november 2010, 13:51
 */
 
#ifndef FF_OTHERCOLLECTION_H
#define FF_OTHERCOLLECTION_H
 
#include "ff_region.h"
#include "ff_other.h"
#include "ff_browser.h"
#include "ff_parts.h"
 
 
class FCOtherIncis : public __FCCollectionInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCOtherInci(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
        const char* ClassName() const override { return "FCOtherIncis"; }
    
    FCOtherIncis(EXTAG customTag = 0)
    { if (customTag) SetCustomTag(customTag); }
 
        int GetMemoryBlockSize();
 
        twobyte* CreateMemoryBlock();
 
        void MakeMemoryBlockCollection(twobyte* pBuffer, int size, CMPER cmper);
 
        void ExpandToFitRecords(int noofrecords, int recordsize, CMPER cmper);
 
        FCOtherInci* GetItemAt(int index) const { return (FCOtherInci*)__FCCollectionInciOther::GetItemAt(index); }
};
 
 
 
#ifdef PDK_FRAMEWORK_LAYOUT
class FCPages : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __FCBaseData* CreateElement() override { return new FCPage(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCPages() : __FCCollectionNoInciOther()
    {
    }
    
    const char* ClassName() const override { return "FCPages"; }
    
    FCPage* GetItemAt(int index) const { return (FCPage*) __FCCollection::GetItemAt(index); }
    
    static bool AppendBlank(bool updatelayout);
    
    static bool InsertBlank(int beforepageno, bool updatelayout);
 
    FCPage* FindSystemNumber(eSsys systemnumber);
 
    FCPage* FindMeasureNumber(eMeas measurenumber);
};
#endif // PDK_FRAMEWORK_LAYOUT
 
 
#ifdef PDK_FRAMEWORK_LAYOUT
class FCStaffSystems : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCStaffSystem(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCStaffSystems() : __FCCollectionNoInciOther()
    {
    }
 
    const char* ClassName() const override { return "FCStaffSystems"; }
 
    FCStaffSystem* GetItemAt(int index) const { return (FCStaffSystem*) __FCCollection::GetItemAt(index); }
 
    static void UpdateFullLayout();
 
    bool NeedUpdateLayout();
 
    FCStaffSystem* FindMeasureNumber(eMeas measurenumber);
};
#endif // PDK_FRAMEWORK_LAYOUT
 
 
class FCMeasures : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCMeasure(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCMeasures() : __FCCollectionNoInciOther()
    {}
 
    const char* ClassName() const override { return "FCMeasures"; }
 
    FCMeasure* GetItemAt(int index) const { return (FCMeasure*) __FCCollection::GetItemAt(index); }
 
    void LoadRegion(FCMusicRegion* pRegion);
 
    static bool Delete(int measureno, int count)
    {
        if (count < 1) return false;
        return ::FX_DeleteMeasures(measureno, count, true) != 0;
    }
 
    static bool Append(int count, bool updatelayout)
    {
        if (count < 1) return false;
        FCBrowserMeasures measures;
        int lastmeasure = measures.GetCount();
        return ::FX_InsertMeasures(lastmeasure + 1, count, updatelayout) != 0;
    }
 
    static bool Insert(int measureno, int count, bool updatelayout)
    {
        if (count < 1) return false;        
                tbool param = updatelayout;
        return (::FX_InsertMeasures(measureno, count, param) != 0);
    }
};
 
class FCStaves : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCStaff(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCStaves() : __FCCollectionNoInciOther() {}
 
    const char* ClassName() const override { return "FCStaves"; }
 
    FCStaff* GetItemAt(int index) const { return (FCStaff*) __FCCollection::GetItemAt(index); }
 
    static CMPER Append();
    
    static bool Delete(CMPER staffid);
};
 
 
 
class FCMeasureNumberRegions : public __FCCollectionNoInciOther
{    
        FCNumbers _nonNumberIncludedMeasures;           /* Collection with the measures that aren't
                                                                                                * included in measure numbering, as a buffer for optimization. */
        bool _nonincludedmeasuresloaded;                        /* Flag, that is set when the measures included in measure numbering has been set. */
 
        void AssureLoadedNonIncludedMeasures();
 
 
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCMeasureNumberRegion(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    FCMeasureNumberRegions() : __FCCollectionNoInciOther()
    {
                _nonincludedmeasuresloaded = false;
    }
 
    const char* ClassName() const override { return "FCMeasureNumberRegions"; }
 
    FCMeasureNumberRegion* FindMeasure(int measure);
    
    FCMeasureNumberRegion* FindByID(int theID);
 
    int CalcStringFromNumber(int measure, FCString* pString);
 
        int CalcNumberFromString(const FCString& value);
    
    bool IsMeasureIncluded(int measure);
    
    bool IsStringUnique(const FCString& value);
    
    int CountRegionsForMeasure(int measure);
 
    FCMeasureNumberRegion* GetItemAt(int index) const { return (FCMeasureNumberRegion*) __FCCollectionNoInciOther::GetItemAt(index); }
        
};
 
 
class FCArticulationDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCArticulationDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCArticulationDefs"; }
 
    FCArticulationDefs() :  __FCCollectionNoInciOther()
    {
    }
    
    FCArticulationDef* GetItemAt(int index) const { return (FCArticulationDef*) __FCCollection::GetItemAt(index); }
};
 
 
 
class FCSystemStaves : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCSystemStaff(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCSystemStaves() : __FCCollectionInciOther() { }
 
    FCSystemStaff* GetItemAt(int index) const { return (FCSystemStaff*) __FCCollectionInciOther::GetItemAt(index); }
 
    const char* ClassName() const override { return "FCSystemStaves"; }
 
    FCSystemStaff* FindStaff(twobyte staffno)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCSystemStaff* pSystemStaff = (FCSystemStaff*) GetItemAt(i);
            if (pSystemStaff->GetStaff() == staffno) return pSystemStaff;
        }
        return NULL;
    }
 
    FCSystemStaff* FindTempoTapStaff() { return FindStaff(32767); }
 
 
    twobyte GetStartStaff()
    {
       if (GetCount() == 0) return -1;       
       return GetItemAt(0)->GetStaff();
    }
 
    twobyte GetEndStaff()
    {
       if (GetCount() == 0) return -1;
       FCSystemStaff* pSystemStaff = (FCSystemStaff*) GetItemAt(GetCount() - 1);
       return pSystemStaff->GetStaff();
    }
 
    int LoadScrollView()
    {
        return LoadAllForItem(0);
    }
 
    int LoadStudioView()
    {
        return LoadAllForItem(65400);
    }
 
    int LoadTemporaryInstrumentList()
    {
        return LoadAllForItem(IU_TEMP);
    }
 
    int LoadStaffSet(int staffsetnumber)
    {
        return LoadAllForItem(IU_STAFFSET1 + staffsetnumber - 1);
    }
 
    int LoadAllForRegion(const FCMusicRegion* pRegion)
    {
        ClearAll();
        LoadAllForItem(pRegion->GetInstrumentList());
        /* Remove all staves that aren't part of the selection. */
        for (int listidx = GetCount() - 1; listidx >= 0; listidx --)
        {
            FCSystemStaff* pSystemStaff = (FCSystemStaff*) GetItemAt(listidx);
            if (!pRegion->IsStaffIncluded(pSystemStaff->GetStaff())) ClearItemAt(listidx);
        }
        return GetCount();
    }
    
    bool SaveToTemporaryInstrumentList()
    {
        return SaveAllForItem(IU_TEMP);
    }
 
    bool IsSharingStaffWith(FCSystemStaves* pOtherSystemStaves)
    {
        for (int idx = 0; idx < GetCount(); idx++)
        {
            FCSystemStaff* pSystemStaff = (FCSystemStaff*) GetItemAt(idx);
            if (pOtherSystemStaves->FindStaff(pSystemStaff->GetStaff()) != NULL) return true;
        }
        return false;
    }
    
    FCMusicRegion* CreateMusicRegion(bool forwholedocument = false)
    {
        assert(GetCount() >= 0);
        if (!GetCount()) return nullptr;
        FCMusicRegion* retval = new FCMusicRegion();
        if (forwholedocument || !retval->SetCurrentSelection())
            retval->SetFullDocument();
        retval->SetInstrumentList(GetItemAt(0)->GetItemCmper());
        retval->SetStartStaff(GetItemAt(0)->GetStaff());
        retval->SetEndStaff(GetItemAt(GetCount()-1)->GetStaff());
        return retval;
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCMusicRegion> CreateMusicRegion_GC(bool forwholedocument = false)
    { return makeLuaSharedPtr(CreateMusicRegion(forwholedocument)); }
#endif
 
};
 
 
class FCCategoryDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCCategoryDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCCategoryDefs() : __FCCollectionNoInciOther()
    {
    }
 
    const char* ClassName() const override { return "FCCategoryDefs"; }
 
    FCCategoryDef* GetItemAt(int index) const { return (FCCategoryDef*) __FCCollection::GetItemAt(index); }
 
    FCCategoryDef* FindName(const FCString& value)
    {
        FCString astring;
        for (int idx = 0; idx < GetCount(); idx++)
        {
            FCCategoryDef* pCategory = GetItemAt(idx);
            pCategory->GetName(&astring);
            if (astring.IsEqualString(value)) return pCategory;
        }
        return NULL;
    }
 
    FCCategoryDef* FindID(twobyte catID)
    {        
        for (int idx = 0; idx < GetCount(); idx++)
        {
            FCCategoryDef* pCategory = GetItemAt(idx);            
            if (pCategory->GetID() == catID) return pCategory;
        }
        return NULL;
    }
};
 
 
class FCTextExpressionDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCTextExpressionDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTextExpressionDefs() : __FCCollectionNoInciOther() {}
 
    const char* ClassName() const override { return "FCTextExpressionDefs"; }
 
    FCTextExpressionDef* GetItemAt(int index) const { return (FCTextExpressionDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
class FCShapeExpressionDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCShapeExpressionDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCShapeExpressionDefs() : __FCCollectionNoInciOther() {}
 
    const char* ClassName() const override { return "FCShapeExpressionDefs"; }
 
    FCShapeExpressionDef* GetItemAt(int index) const { return (FCShapeExpressionDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
 
 
class FCExpressions : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCExpression(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCExpressions() : __FCCollectionInciOther() {}
 
    FCExpression* GetItemAt(int index) const { return (FCExpression*) __FCCollectionInciOther::GetItemAt(index); }
 
    const char* ClassName() const override { return "FCExpressions"; }
 
    int LoadAllInCell(FCCell* pCell);
 
#ifdef PDK_FRAMEWORK_LAYOUT
    int LoadAllInCellLayout(FCCell* pCell, FCStaffSystems* pStaffSystems);
#endif
 
    int LoadAllForRegion(FCMusicRegion* pRegion);
};
 
 
 
class FCPageTexts : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCPageText(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCPageTexts() : __FCCollectionInciOther() {}
 
    const char* ClassName() const override { return "FCPageTexts"; }
 
    FCPageText* GetItemAt(int index) const { return (FCPageText*) __FCCollectionInciOther::GetItemAt(index); }
};
 
 
class FCTextBlocks : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCTextBlock(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTextBlocks() : __FCCollectionNoInciOther() {}
 
    const char* ClassName() const override { return "FCTextBlocks"; }
 
    FCTextBlock* GetItemAt(int index) const { return (FCTextBlock*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
 
class FCSeparatePlacements : public __FCCollectionInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
private:
    CMPER _cmpersave;  /* The "location" for the collection. It's where created
                        * elements for AssureCellPlacement() should be saved. */
    int   _expectedmeasure;     
protected:
        __FCBaseData* CreateElement() override { return new FCSeparatePlacement(); }
 
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCSeparatePlacements() : __FCCollectionInciOther()
    {
        _cmpersave = 0;
        _expectedmeasure = 0;
    }
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    void _SetCmperSave(CMPER cmper) { _cmpersave = cmper; }
 
    void _SetExpectedMeasure(int measure) { _expectedmeasure = measure; }
#endif
 
    const char* ClassName() const override { return "FCSeparatePlacements"; }
 
    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCSeparatePlacement::SEPARATEPLACEMENT_MODES
#else
    int
#endif
    mode)
    {
        switch (mode)
        {
            case FCSeparatePlacement::SEPARMODE_TEXTREPEAT:
                SetCustomTag(ot_SeparateTextRepeatPlacement);
                break;
            case FCSeparatePlacement::SEPARMODE_BACKWARDREPEAT:
                SetCustomTag(ot_SeparateBackwardRepeatPlacement);
                break;
            case FCSeparatePlacement::SEPARMODE_ENDINGREPEAT:
                SetCustomTag(ot_SeparateEndingRepeatPlacement);
                break;
            case FCSeparatePlacement::SEPARMODE_ENDINGREPEATTEXT:
                SetCustomTag(ot_SeparateEndingRepeatTextPlacement);
                break;
        }
    }
 
    FCSeparatePlacement* GetItemAt(int index) const { return (FCSeparatePlacement*) __FCCollectionInciOther::GetItemAt(index); }
    
    FCSeparatePlacement* AssureStaffPlacement(eStaff staff);
 
    void KeepOnlyMeasure(eMeas meas)
    {
        for (int i = GetCount() - 1; i >= 0; i--)
        {
            FCSeparatePlacement* pItem = GetItemAt(i);
            if (pItem->GetMeasure() != meas) ClearItemAt(i);
        }
    }
};
 
#if FXT_VERSION >= FINALEVERSION_2012
// Only 2012-style staff style definitions are supported right now, implement later...
 
class FCStaffStyleDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCStaffStyleDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCStaffStyleDefs"; }
 
        FCStaffStyleDef* GetItemAt(int index) const { return (FCStaffStyleDef*)__FCCollectionNoInciOther::GetItemAt(index); }
};
#endif
 
class FCStaffStyleAssigns : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCStaffStyleAssign(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCStaffStyleAssigns"; }
 
    FCStaffStyleAssign* GetItemAt(int index) const { return (FCStaffStyleAssign*) __FCCollectionInciOther::GetItemAt(index); }
};
 
 
class FCMultiMeasureRests : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCMultiMeasureRest(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCMultiMeasureRests() : __FCCollectionNoInciOther() {}
 
    const char* ClassName() const override { return "FCMultiMeasureRests"; }
 
    FCMultiMeasureRest* GetItemAt(int index) const { return (FCMultiMeasureRest*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
 
class FCFreezeSystems : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCFreezeSystem(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCFreezeSystems"; }
};
 
#if FXT_VERSION >= FINALEVERSION_2012
class FCMultiStaffInstruments : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCMultiStaffInstrument(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCMultiStaffInstruments() : __FCCollectionNoInciOther()
    {
    }
 
    const char* ClassName() const override { return "FCMultiStaffInstruments"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MULTISTAFFINSTRUMENTS; }
 
    FCMultiStaffInstrument* FindStaff(CMPER staffno)
    {
        if (staffno == 0) return NULL;
        for (int i = 0; i < GetCount(); i++)
        {
            FCMultiStaffInstrument* pObject = (FCMultiStaffInstrument*) GetItemAt(i);
            if (pObject->ContainsStaff(staffno)) return pObject;
        }
        return NULL;
    }
 
    FCMultiStaffInstrument* GetItemAt(int index) const { return (FCMultiStaffInstrument*) __FCCollectionNoInciOther::GetItemAt(index); }
};
#endif  // #if FXT_VERSION >= FINALEVERSION_2012
 
 
class FCAllotments : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCAllotment(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCAllotments"; }
 
    FCAllotment* GetItemAt(int index) const { return (FCAllotment*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
 
class FCPageGraphics : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCPageGraphic(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCPageGraphics() : __FCCollectionInciOther()
    {
    }
 
    const char* ClassName() const override { return "FCPageGraphics"; }
 
    FCPageGraphic* GetItemAt(int index) const { return (FCPageGraphic*) __FCCollectionInciOther::GetItemAt(index); }
};
 
 
class FCTextRepeatDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCTextRepeatDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTextRepeatDefs() : __FCCollectionNoInciOther() {}
 
    const char* ClassName() const override { return "FCTextRepeatDefs"; }
 
    FCTextRepeatDef* GetItemAt(int index) const { return (FCTextRepeatDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
 
class FCFretInstrumentDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCFretInstrumentDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCFretInstrumentDefs() : __FCCollectionNoInciOther() {}
 
    const char* ClassName() const override { return "FCFretInstrumentDefs"; }
 
    FCFretInstrumentDef* GetItemAt(int index) const { return (FCFretInstrumentDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
 
class FCTextRepeats : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCTextRepeat(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTextRepeats() : __FCCollectionInciOther() {}
    
    const char* ClassName() const override { return "FCTextRepeats"; }
    
    FCTextRepeat* GetItemAt(int index) const { return (FCTextRepeat*) __FCCollectionInciOther::GetItemAt(index); }
};
 
 
class FCExecutableShapeDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCExecutableShapeDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCExecutableShapeDefs"; }
};
 
 
#ifdef PDK_FRAMEWORK_SHAPES
class FCShapeDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCShapeDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCShapeDefs() : __FCCollectionNoInciOther() {}
 
    const char* ClassName() const override { return "FCShapeDefs"; }
 
    FCShapeDef* GetItemAt(int index) const { return (FCShapeDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};
#endif /* PDK_FRAMEWORK_SHAPES */
 
class FCChordSuffixElements : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCChordSuffixElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCChordSuffixElements"; }
 
    FCChordSuffixElement* GetItemAt(int index) const { return (FCChordSuffixElement*) __FCCollectionInciOther::GetItemAt(index); }
};
 
 
#if FXT_VERSION >= FINALEVERSION_2012
class FCFretboardStyleDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCFretboardStyleDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCFretboardStyleDefs"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_FRETBOARDSTYLEDEFS; }
 
        FCFretboardStyleDef* GetItemAt(int index) const { return (FCFretboardStyleDef*)__FCCollectionNoInciOther::GetItemAt(index); }
};
#endif
 
#if FXT_VERSION >= FINALEVERSION_2012
class FCFretboardGroupDefs : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCFretboardGroupDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
        FCFretboardGroupDefs() : __FCCollectionInciOther() {}
 
    const char* ClassName() const override { return "FCFretboardGroupDefs"; }
        const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_FRETBOARDGROUPDEFS; }
 
        FCFretboardGroupDef* GetItemAt(int index) const { return (FCFretboardGroupDef*)__FCCollectionInciOther::GetItemAt(index); }
};
#endif
 
 
class FCBeatChartElements : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCBeatChartElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCBeatChartElements() : __FCCollectionInciOther()
    {}
 
    const char* ClassName() const override { return "FCBeatChartElements"; }
 
    FCBeatChartElement* FindMeasurePos(TimeEdu32 durationpos)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCBeatChartElement* pElement = (FCBeatChartElement*) GetItemAt(i);
            if (pElement->GetInitElement()) continue;
            if (pElement->GetMeasurePos() == durationpos) return pElement;
        }
        return NULL;
    }
    
    Evpu16 CalcElementWidth(int index)
    {
        if (GetCount() <= 0 || index <= 0 || index > GetCount()) return 0;
        FCBeatChartElement *elt = GetItemAt(index);
        const Evpu16 nextMinPos = (index < (GetCount()-1)) ? GetItemAt(index+1)->GetMinimumPosition() : GetItemAt(0)->GetMinimumWidth();
        return (std::max<Evpu16>)(elt->CalcWidth(), nextMinPos - elt->GetMinimumPosition());
    }
    
    bool CalcIsManual()
    {
        if (GetCount() <= 0) return false;
        return GetItemAt(0)->GetMinimumWidth() <= 1;
    }
    
    void TransitionToManual()
    {
        if (GetCount() <= 1 || CalcIsManual()) return;
        Evpu16 accumulatedWidth = GetItemAt(1)->GetMinimumPosition();
        for (int x = 1; x < GetCount(); x++)
        {
            Evpu16 eltWidth = CalcElementWidth(x);
            FCBeatChartElement* elt = GetItemAt(x);
            elt->SetHorizontalPosition(accumulatedWidth);
            accumulatedWidth += eltWidth;
            elt->SetNextHorizontalPosition(accumulatedWidth);
            elt->SetMinimumPosition((std::min)(x-1, 1));
        }
        FCBeatChartElement* header = GetItemAt(0);
        header->SetFullSpan(accumulatedWidth);
        header->SetMinimumWidth(1);
    }
 
    bool RebuildAfter(int index, bool updateinitrecord = false)
    {
        if (GetCount() < 2) return false;
        if (index < 1) return false;
        if (index >= (GetCount())) return false;
        
        FCBeatChartElement* pThisItem = (FCBeatChartElement*) GetItemAt(index);
        int currentpos = pThisItem->GetHorizontalPosition() + pThisItem->CalcWidth();
        for (int i = index + 1; i < GetCount(); i++)
        {
            FCBeatChartElement* pElement = (FCBeatChartElement*) GetItemAt(i);
            int elementwidth = pElement->CalcWidth();
            pElement->SetHorizontalPosition(currentpos);
            currentpos += elementwidth;
            pElement->SetWidth(elementwidth);            
        }
        if (updateinitrecord)
        {
            FCBeatChartElement* pInitElement = (FCBeatChartElement*) GetItemAt(0);
            pInitElement->SetFullSpan(currentpos);
        }
        RebuildNextHorizontalPositions();
        return true;
    }
 
    void RebuildNextHorizontalPositions()
    {
        FCBeatChartElement* pNextElement = NULL;
        for (int idx = GetCount() - 1; idx >= 1; idx--)
        {
            FCBeatChartElement* pElement = (FCBeatChartElement*) GetItemAt(idx);
            if (pNextElement) pElement->SetNextHorizontalPosition(pNextElement->GetHorizontalPosition());
            pNextElement = pElement;
        }
    }
    
    bool IsValid();
    
    bool SaveAll() override
    {
        if (!IsValid()) return false;
        return __FCCollectionInciOther::SaveAll();
    }
 
    FCBeatChartElement* GetItemAt(int index) const { return (FCBeatChartElement*) __FCCollectionInciOther::GetItemAt(index); }
};
 
class FCTempoElements : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCTempoElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTempoElements() : __FCCollectionInciOther()
    {
    }
 
    const char* ClassName() const override { return "FCTempoElements"; }
 
    FCTempoElement* GetItemAt(int index) const { return (FCTempoElement*) __FCCollectionInciOther::GetItemAt(index); }
 
    void AssureSorted();
};
 
 
 
class FCPercussionLayoutNotes : public __FCCollectionInciOther
{
    CMPER _percLibID;
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCPercussionLayoutNote(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    
    FCPercussionLayoutNotes() : __FCCollectionInciOther()
    {
        _percLibID = 0;
    }
 
    const char* ClassName() const override { return "FCPercussionLayoutNotes"; }
 
    CMPER GetPercussionLibraryID() { return _percLibID; }
 
    int LoadAllForItem(CMPER cmper) override
    {
        _percLibID = cmper;
        return __FCCollectionInciOther::LoadAllForItem(cmper);
    }
    
    FCString* CreateNameString()
    {
        if (!_percLibID) return NULL;
        FCPercussionLayoutNotesText text;
        text.Load(_percLibID);
        FCString* pString = text.CreateString();
        return pString;
    }
 
#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
    luabridge::RefCountedPtr<FCString> CreateNameString_GC()
    { return makeLuaSharedPtr(CreateNameString()); }
#endif
 
    FCPercussionLayoutNote* FindRawNoteType(PERC_NOTE_TYPE notetype)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCPercussionLayoutNote* pObject = GetItemAt(i);
            if (pObject->GetRawNoteType() == notetype) return pObject;
        }
        return NULL;
    }
 
    FCPercussionLayoutNote* FindNoteType(PERC_NOTE_TYPE notetype)
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCPercussionLayoutNote* pObject = GetItemAt(i);
            if (pObject->GetNoteType() == notetype) return pObject;
        }
        return NULL;
    }
 
#ifdef PDK_FRAMEWORK_TINYXML
    FCPercussionLayoutNote* FindMidiNote(twobyte midinote, FCPercussionMapNotes* pMapNotes)
    {
        if (!pMapNotes) return NULL;
        for (int i = 0; i < GetCount(); i++)
        {
            FCPercussionLayoutNote* pObject = GetItemAt(i);
            if (pObject->CalcMidiRawNote(pMapNotes)== midinote) return pObject;
        }
        for (int i = 0; i < GetCount(); i++)
        {
            FCPercussionLayoutNote* pObject = GetItemAt(i);
            if (pObject->CalcMidiNote(pMapNotes)== midinote) return pObject;
        }
        return NULL;
    }
#endif
 
    FCPercussionLayoutNote* GetItemAt(int index) const { return (FCPercussionLayoutNote*) __FCCollectionInciOther::GetItemAt(index); }
};
 
 
 
class FCInstrumentDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCInstrumentDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    FCInstrumentDefs() : __FCCollectionNoInciOther()
    {
    }
 
 
    const char* ClassName() const override { return "FCInstrumentDefs"; }
 
    FCInstrumentDef* GetItemAt(int index) const { return (FCInstrumentDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
 
class FCStaffLists : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCStaffList(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCStaffLists() : __FCCollectionNoInciOther()
    {}
 
    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCStaffList::STAFFLIST_MODES
#else
    int
#endif
    mode
    )
    {
        switch (mode)
        {
            case FCStaffList::SLMODE_SCORE:
                SetCustomTag(ot_StaffListDataScore);
                break;
            case FCStaffList::SLMODE_PARTS:
                SetCustomTag(ot_StaffListDataParts);
                break;
            case FCStaffList::SLMODE_FORCESCORE:
                SetCustomTag(ot_StaffListForceScore);
                break;
            case FCStaffList::SLMODE_FORCEPARTS:
                SetCustomTag(ot_StaffListForceParts);
                break;
 
            case FCStaffList::SLMODE_CATEGORY_SCORE:
                SetCustomTag(__ot_CategoryStaffListScore);
                break;
            case FCStaffList::SLMODE_CATEGORY_PARTS:
                SetCustomTag(__ot_CategoryStaffListParts);
                break;
            case FCStaffList::SLMODE_CATEGORY_FORCESCORE:
                SetCustomTag(__ot_CategoryStaffListScoreOverride);
                break;
            case FCStaffList::SLMODE_CATEGORY_FORCEPARTS:
                SetCustomTag(__ot_CategoryStaffListPartsOverride);
                break;
 
 
            case FCStaffList::SLMODE_ASSIGNMENT_SCORE:
                SetCustomTag(__ot_StaffAssignStaffListScore);
                break;
            case FCStaffList::SLMODE_ASSIGNMENT_PARTS:
                SetCustomTag(__ot_StaffAssignStaffListParts);
                break;
            case FCStaffList::SLMODE_ASSIGNMENT_FORCESCORE:
                SetCustomTag(__ot_StaffAssignStaffListScoreOverride);
                break;
            case FCStaffList::SLMODE_ASSIGNMENT_FORCEPARTS:
                SetCustomTag(__ot_StaffAssignStaffListPartsOverride);
                break;
        }
    }
 
    const char* ClassName() const override { return "FCStaffLists"; }
 
    FCStaffList* GetItemAt(int index) const { return (FCStaffList*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
 
class FCStaffListLookup : public __FCCollection
{
    FCStaffList _scoredisplay, _partsdisplay, _scoreforced, _partsforced;
    bool _loaded;
public:
    FCStaffListLookup() : __FCCollection()
    {
        _loaded = false;
    }
    const char* ClassName() const override { return "FCStaffListLookup"; }
 
    bool LoadStandardList(twobyte number)
    {
        _loaded = false;
        _scoredisplay.SetMode(FCStaffList::SLMODE_SCORE);
        if (!_scoredisplay.Load(number)) return false;
        _partsdisplay.SetMode(FCStaffList::SLMODE_PARTS);
        if (!_partsdisplay.Load(number)) return false;
        _scoreforced.SetMode(FCStaffList::SLMODE_FORCESCORE);
        if (!_scoreforced.Load(number)) return false;
        _partsforced.SetMode(FCStaffList::SLMODE_FORCEPARTS);
        if (!_partsforced.Load(number)) return false;
        _loaded = true;
        return true;
    }
 
    bool LoadCategoryList(twobyte number)
    {
        _loaded = false;
        _scoredisplay.SetMode(FCStaffList::SLMODE_CATEGORY_SCORE);
        if (!_scoredisplay.Load(number)) return false;
        _partsdisplay.SetMode(FCStaffList::SLMODE_CATEGORY_PARTS);
        if (!_partsdisplay.Load(number)) return false;
        /* Forced state isn't used - the other selections should ideally be cleared! */
        _loaded = true;
        return true;
    }
 
    bool LoadAssignmentList(twobyte number)
    {
        _loaded = false;
        _scoredisplay.SetMode(FCStaffList::SLMODE_ASSIGNMENT_SCORE);
        if (!_scoredisplay.Load(number)) return false;
        _partsdisplay.SetMode(FCStaffList::SLMODE_ASSIGNMENT_PARTS);
        if (!_partsdisplay.Load(number)) return false;
        /* Forced state isn't used - the other selections should ideally be cleared! */
        _loaded = true;
        return true;
    }
 
    bool IsLoaded() { return _loaded; }
 
 
    bool IsStaffElementDisplayed(eStaff staffno, bool score, FCSystemStaves* pSystemStaves)
    {
       if (!IsLoaded()) return false;
       if (staffno == 0) return false;
       if (score)
       {
           if (_scoredisplay.IncludesStaff(staffno)) return true;
           if (pSystemStaves)
           {
               if (staffno == pSystemStaves->GetStartStaff())
               {
                   if (_scoredisplay.IncludesStaff(SLD_TOPSTAFF)) return true;
               }
               else if (staffno == pSystemStaves->GetEndStaff())
               {
                    if (_scoredisplay.IncludesStaff(SLD_BOTTOMSTAFF)) return true;
               }
           }
       }
       else
       {
           if (_partsdisplay.IncludesStaff(staffno)) return true;
           if (pSystemStaves)
           {
               if (staffno == pSystemStaves->GetStartStaff())
               {
                   if (_partsdisplay.IncludesStaff(SLD_TOPSTAFF)) return true;
               }
               else if (staffno == pSystemStaves->GetEndStaff())
               {
                    if (_partsdisplay.IncludesStaff(SLD_BOTTOMSTAFF)) return true;
               }
           }
       }
       return false;
    }
};
 
#ifdef PDK_FRAMEWORK_LAYOUT
class FCStaffSystemsLookup : __FCBase
{
    /* _partstaffsystems and _partids should match in pairs */
    __FCCollection _partstaffsystems; /* Collection of FCStaffSystems objects. */
    FCNumbers _partids;     /* Collection of FCNumber objects. */
public:
    FCStaffSystemsLookup() : __FCBase() {}
    const char* ClassName() const override { return "FCStaffSystemsLookup"; }
 
    FCStaffSystems* GetCurrentPartStaffSystems()
    {
        FCPart currentpart(FCPart::PARTID_CURRENT);
 
        /* Try to find the part ID in the number collection. */
        FCNumber* pNumber = _partids.FindInt(currentpart.GetID());
        if (pNumber)
        {
            /* Return the existing layout */
            int index = _partids.GetIndexOf(pNumber);
            return (FCStaffSystems*) _partstaffsystems.GetItemAt(index);
        }
        /* Create a new layout and make sure that the layout is updated. */        
        FCStaffSystems* pStaffSystems = new FCStaffSystems();
        pStaffSystems->LoadAll();
        if (pStaffSystems->NeedUpdateLayout())
        {
            FCStaffSystems::UpdateFullLayout();
            pStaffSystems->LoadAll();
        }
        _partstaffsystems.Add(pStaffSystems);
        _partids.Add(new FCNumber(currentpart.GetID()));
        return pStaffSystems;
    }
};
#endif  /* #ifdef PDK_FRAMEWORK_LAYOUT */
 
 
 
 
class FCCellClefChanges : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCCellClefChange(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    const char* ClassName() const override { return "FCCellClefChanges"; }
 
    FCCellClefChanges() : __FCCollectionInciOther()
    {
    }
    
    void InsertCellClefChange(FCCellClefChange * pClefInfo);
 
    FCCellClefChange* GetItemAt(int index) const { return (FCCellClefChange*)__FCCollectionInciOther::GetItemAt(index); }
};
 
 
class FCGuides : public __FCCollection
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    CMPER _cmper; /* the cmper to use with ot_Guide */
#endif
    public:
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCGuides(bool isvertical);
 
    bool _Load(int count);
 
    bool _Save();
#endif
 
    const char* ClassName() const override { return "FCGuides"; }
    
    bool SaveAll();
 
    FCGuide* GetItemAt(int index) const { return (FCGuide*)__FCCollection::GetItemAt(index); }
 
    FCGuide* FindClosest(Efix32 testposition, Efix32 gravityzonesize)
    {
        Efix32 smallestfound = gravityzonesize + 1;
        FCGuide* pFound = NULL;
        for (int i = 0; i < GetCount(); i++)
        {
            FCGuide* pGuide = GetItemAt(i);
            Efix32 testdiff = pGuide->GetPosition() - testposition;
            if (testdiff < 0) testdiff = -testdiff;  /* Force positive diff */
            if (testdiff > gravityzonesize) continue;
            testdiff = -testdiff;   /* Negative diff */
            if (testdiff < -gravityzonesize) continue;
            /* The gravity zone size matches the guide, check to see if it's the smallest diff */
            testdiff = -testdiff;  /* Positive again */
            if (testdiff < smallestfound)
            {
                smallestfound = testdiff;
                pFound = pGuide;
            }
        }
        return pFound;
    }
 
 
    FCGuide* AddGuide(Efix32 position)
    {
        FCGuide* pGuide = new FCGuide(position);
        int index = 0;
        for (index = 0; index < GetCount(); index++)
            if (GetItemAt(index)->GetPosition() >= position)
                break;
        InsertItemAt(pGuide, index);
        return pGuide;
    }
};
 
class FCMetatoolAssignments : public __FCCollectionNoInciOther
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    FCMetatoolAssignment::METATOOL_MODES _mode;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
    
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
    __FCBaseData* CreateElement() override { return new FCMetatoolAssignment(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCMetatoolAssignments() : __FCCollectionNoInciOther()
    {}
    
    const char* ClassName() const override { return "FCMetatoolAssignments"; }
    
    FCMetatoolAssignment* GetItemAt(int index) const { return (FCMetatoolAssignment*) __FCCollection::GetItemAt(index); }
    
    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                 FCMetatoolAssignment::METATOOL_MODES
#else
                 int
#endif
                 mode)
    {
        if (GetCount() != 0) return;
        _mode = (FCMetatoolAssignment::METATOOL_MODES) mode;
    }
    
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCMetatoolAssignment::METATOOL_MODES
#else
    int
#endif
    GetMode() const { return (FCMetatoolAssignment::METATOOL_MODES) _mode; }
    
    int LoadAll() override;
    
    int LoadAllForMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
                       FCMetatoolAssignment::METATOOL_MODES
#else
                       int
#endif
                       mode
                       )
    {
        if (mode == FCMetatoolAssignment::MTOOLMODE_UNKNOWN) return 0;
        _mode = (FCMetatoolAssignment::METATOOL_MODES) mode;
        return LoadAll();
    }
    
        FCMetatoolAssignment* FindKeystroke(twobyte keystrokeslot)
        {
                if (keystrokeslot == 0) return NULL;
                for (int i = 0; i < GetCount(); i++)
                {
                        FCMetatoolAssignment* pAssignment = GetItemAt(i);
                        if (pAssignment->GetKeystroke() == keystrokeslot) return pAssignment;
                }
                return NULL;
        }
    
        FCMetatoolAssignment* FindDefID(CMPER defID)
        {
                if ((_mode != FCMetatoolAssignment::MTOOLMODE_CLEF) && (defID == 0)) return NULL;
                for (int i = 0; i < GetCount(); i++)
                {
                        FCMetatoolAssignment* pAssignment = GetItemAt(i);
                        if (pAssignment->GetDefID() == defID) return pAssignment;
                }
                return NULL;
        }
    
        FCMetatoolAssignment* FindShapeExpressionDef(FCShapeExpressionDef* pDef)
        {
                if (!pDef) return NULL;
                if (_mode != FCMetatoolAssignment::MTOOLMODE_EXPRESSION) return NULL;
                for (int i = 0; i < GetCount(); i++)
                {
                        FCMetatoolAssignment* pAssignment = GetItemAt(i);
                        if (!pAssignment->IsShapeExpressionDef()) continue;
                        if (pAssignment->GetDefID() == pDef->GetItemNo()) return pAssignment;
                }
                return NULL;
        }
    
        FCMetatoolAssignment* FindTextExpressionDef(FCTextExpressionDef* pDef)
        {
                if (!pDef) return NULL;
                if (_mode != FCMetatoolAssignment::MTOOLMODE_EXPRESSION) return NULL;
                for (int i = 0; i < GetCount(); i++)
                {
                        FCMetatoolAssignment* pAssignment = GetItemAt(i);
                        if (pAssignment->IsShapeExpressionDef()) continue;
                        if (pAssignment->GetDefID() == pDef->GetItemNo()) return pAssignment;
                }
                return NULL;
        }
        
        FCMetatoolAssignment* FindArticulationDef(FCArticulationDef* pDef)
        {
                if (!pDef) return NULL;
                if (_mode != FCMetatoolAssignment::MTOOLMODE_ARTICULATION) return NULL;
                for (int i = 0; i < GetCount(); i++)
                {
                        FCMetatoolAssignment* pAssignment = GetItemAt(i);
                        if (pAssignment->GetDefID() == pDef->GetItemNo()) return pAssignment;
                }
                return NULL;
        }
    
        FCMetatoolAssignment* FindRepeatDef(FCTextRepeatDef* pDef)
        {
                if (!pDef) return NULL;
                if (_mode != FCMetatoolAssignment::MTOOLMODE_REPEAT) return NULL;
                for (int i = 0; i < GetCount(); i++)
                {
                        FCMetatoolAssignment* pAssignment = GetItemAt(i);
                        if (pAssignment->GetDefID() == pDef->GetItemNo()) return pAssignment;
                }
                return NULL;
        }
    
        FCMetatoolAssignment* FindClefDef(FCClefDef* pDef);
        
#ifdef PDK_FRAMEWORK_ENTRIES
        FCMetatoolAssignment* FindTuplet(FCTuplet* pTuplet);
#endif
    
        FCMetatoolAssignment* FindStaffStyleDef(FCStaffStyleDef* pDef);
};
 
 
#ifdef PDK_FRAMEWORK_ENIGMASTRINGS
class FCBookmarks : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCBookmark(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    FCBookmarks() : __FCCollectionNoInciOther()
    {
    }
 
    const char* ClassName() const override { return "FCBookmarks"; }
 
    FCBookmark* GetItemAt(int index) const { return (FCBookmark*) __FCCollectionNoInciOther::GetItemAt(index); }
};
#endif // PDK_FRAMEWORK_ENIGMASTRINGS
 
class FCCustomKeyModeSymbolLists : public __FCCollection
{
public:
    FCCustomKeyModeSymbolLists() : __FCCollection() { }
 
    const char* ClassName() const override { return "FCCustomKeyModeSymbolLists"; }
 
    FCCustomKeyModeSymbolList* GetItemAt(int index) const { return (FCCustomKeyModeSymbolList*) __FCCollection::GetItemAt(index); }
 
    int LoadAll()
    {
        ClearAll();
        FCCustomKeyModeSymbolList* pObject = new FCCustomKeyModeSymbolList;
        if (pObject->LoadFirst())
        {
            Add(pObject->CreateClone());
            while (pObject->LoadNext()) Add(pObject->CreateClone());
        }
        delete pObject;
        return GetCount();
    }
};
 
class FCCustomKeyModeDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        __FCBaseData* CreateElement() override { return new FCCustomKeyModeDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
 
    FCCustomKeyModeDefs() : __FCCollectionNoInciOther() { }
 
    const char* ClassName() const override { return "FCCustomKeyModeDefs"; }
    
    int LoadAllLinear()
    {
        LoadAll();
        for (int i = GetCount() - 1; i >= 0; i--)
        {
            if (! GetItemAt(i)->IsLinear()) ClearItemAt(i);
        }
        return GetCount();
    }
    
    int LoadAllNonLinear()
    {
        LoadAll();
        for (int i = GetCount() - 1; i >= 0; i--)
        {
            if (! GetItemAt(i)->IsNonLinear()) ClearItemAt(i);
        }
        return GetCount();
    }
 
    int FindIndexForKeySignature(const FCKeySignature& keysig) const
    {
        for (int i = 0; i < GetCount(); i++)
            if (GetItemAt(i)->GetItemNo() == keysig.GetKeyMode())
                return i;
        return -1;
    }
    
    FCCustomKeyModeDef* FindKeySignature(const FCKeySignature& keysig) const
    {
        for (int i = 0; i < GetCount(); i++)
        {
            FCCustomKeyModeDef* pNext = GetItemAt(i);
            if (pNext->GetItemNo() == keysig.GetKeyMode())
                return pNext;
        }
        return nullptr;
    }
 
    FCCustomKeyModeDef* GetItemAt(int index) const { return (FCCustomKeyModeDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};
 
 
#endif  /* FF_OTHERCOLLECTION_H */