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
        virtual __FCBaseData* CreateElement() { return new FCOtherInci(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
        virtual const char* ClassName() { return "FCOtherIncis"; }

        int GetMemoryBlockSize();

        twobyte* CreateMemoryBlock();

        void MakeMemoryBlockCollection(twobyte* pBuffer, int size, CMPER cmper);

        void ExpandToFitRecords(int noofrecords, int recordsize, CMPER cmper);

        FCOtherInci* GetItemAt(int index) { return (FCOtherInci*)__FCCollectionInciOther::GetItemAt(index); }
};



#ifdef PDK_FRAMEWORK_LAYOUT

class FCPages : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCPage(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCPages() : __FCCollectionNoInciOther()
    {        
    }

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

    FCPage* GetItemAt(int index) { return (FCPage*) __FCCollection::GetItemAt(index); }
    
    static bool AppendBlank(bool updatelayout);
    
    static bool InsertBlank(int beforepageno, bool updatelayout);
};
#endif // PDK_FRAMEWORK_LAYOUT


#ifdef PDK_FRAMEWORK_LAYOUT

class FCStaffSystems : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCStaffSystem(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCStaffSystems() : __FCCollectionNoInciOther()
    {
    }

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

    FCStaffSystem* GetItemAt(int index) { 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
        virtual __FCBaseData* CreateElement() { return new FCMeasure(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCMeasures() : __FCCollectionNoInciOther()
    {}

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

    FCMeasure* GetItemAt(int index) { 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
        virtual __FCBaseData* CreateElement() { return new FCStaff(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCStaves() : __FCCollectionNoInciOther() {}

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

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

    static CMPER Append();
    
    static bool Delete(CMPER staffid);
};



class FCMeasureNumberRegions : public __FCCollectionNoInciOther
{
    /* Reference table for the "Include measure in numbering" option. Assign
     with AssignAllMeasures(). */
    FCMeasures* _pAllMeasures;
    
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCMeasureNumberRegion(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    FCMeasureNumberRegions() : __FCCollectionNoInciOther()
    {
        _pAllMeasures = NULL;
    }

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

    FCMeasureNumberRegion* FindMeasure(int measure);
    
    FCMeasureNumberRegion* FindByID(int theID);

    int CalcStringFromNumber(int measure, FCString* pString);

        int CalcNumberFromString(FCString* pString);
    
    bool IsMeasureIncluded(int measure);
    
    bool IsStringUnique(FCString* pString);
    
    int CountRegionsForMeasure(int measure);

    FCMeasureNumberRegion* GetItemAt(int index) { return (FCMeasureNumberRegion*) __FCCollectionNoInciOther::GetItemAt(index); }
    
    bool AssignAllMeasures(FCMeasures* pAllMeasures);
};


class FCArticulationDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCArticulationDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCArticulationDefs"; }

    FCArticulationDefs() :  __FCCollectionNoInciOther()
    {
    }
    
    FCArticulationDef* GetItemAt(int index) { return (FCArticulationDef*) __FCCollection::GetItemAt(index); }
};



class FCSystemStaves : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCSystemStaff(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCSystemStaves() : __FCCollectionInciOther() { }

    FCSystemStaff* GetItemAt(int index) { return (FCSystemStaff*) __FCCollectionInciOther::GetItemAt(index); }

    virtual const char* ClassName() { 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 LoadStaffSet(int staffsetnumber)
    {
        return LoadAllForItem(IU_STAFFSET1 + staffsetnumber - 1);
    }

    int LoadAllForRegion(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 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;
    }
};


class FCCategoryDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCCategoryDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCCategoryDefs() : __FCCollectionNoInciOther()
    {
    }

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

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

    FCCategoryDef* FindName(FCString* pString)
    {
        FCString astring;
        for (int idx = 0; idx < GetCount(); idx++)
        {
            FCCategoryDef* pCategory = GetItemAt(idx);
            pCategory->GetName(&astring);
            if (astring.IsEqualString(pString)) 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
        virtual __FCBaseData* CreateElement() { return new FCTextExpressionDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTextExpressionDefs() : __FCCollectionNoInciOther() {}

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

    FCTextExpressionDef* GetItemAt(int index) { return (FCTextExpressionDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};

class FCShapeExpressionDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCShapeExpressionDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCShapeExpressionDefs() : __FCCollectionNoInciOther() {}

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

    FCShapeExpressionDef* GetItemAt(int index) { return (FCShapeExpressionDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};



class FCExpressions : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCExpression(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCExpressions() : __FCCollectionInciOther() {}

    FCExpression* GetItemAt(int index) { return (FCExpression*) __FCCollectionInciOther::GetItemAt(index); }

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

    virtual 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
        virtual __FCBaseData* CreateElement() { return new FCPageText(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCPageTexts() : __FCCollectionInciOther() {}

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

    FCPageText* GetItemAt(int index) { return (FCPageText*) __FCCollectionInciOther::GetItemAt(index); }
};


class FCTextBlocks : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCTextBlock(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTextBlocks() : __FCCollectionNoInciOther() {}

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

    FCTextBlock* GetItemAt(int index) { 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:
        virtual __FCBaseData* CreateElement() { 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

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

    void SetMode(
#ifndef PDK_FRAMEWORK_LUAFRIENDLY
    FCSeparatePlacement::SEPARATEPLACEMENT_MODES
#else
    int
#endif
    mode)
    {
        switch (mode)
        {
            case FCSeparatePlacement::SEPARMODE_TEXTREPEAT:
                SetCustomTag(MAKEEXTAG(edOther,'R','I'));
                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) { 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 __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCStaffStyleDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCStaffStyleDefs"; }

        FCStaffStyleDef* GetItemAt(int index) { return (FCStaffStyleDef*)__FCCollectionInciOther::GetItemAt(index); }
};
#endif

class FCStaffStyleAssigns : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCStaffStyleAssign(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCStaffStyleAssigns"; }

    FCStaffStyleAssign* GetItemAt(int index) { return (FCStaffStyleAssign*) __FCCollectionInciOther::GetItemAt(index); }
};


class FCMultiMeasureRests : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCMultiMeasureRest(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCMultiMeasureRests() : __FCCollectionNoInciOther() {}

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

    FCMultiMeasureRest* GetItemAt(int index) { return (FCMultiMeasureRest*) __FCCollectionNoInciOther::GetItemAt(index); }
};


class FCFreezeSystems : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCFreezeSystem(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCFreezeSystems"; }
};




#if FXT_VERSION >= FINALEVERSION_2012

class FCMultiStaffInstruments : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCMultiStaffInstrument(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCMultiStaffInstruments() : __FCCollectionNoInciOther()
    {
    }

    virtual const char* ClassName() { return "FCMultiStaffInstruments"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { 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) { return (FCMultiStaffInstrument*) __FCCollectionNoInciOther::GetItemAt(index); }
};
#endif  // #if FXT_VERSION >= FINALEVERSION_2012


class FCAllotments : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCAllotment(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCAllotment"; }
};


class FCPageGraphics : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCPageGraphic(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCPageGraphics() : __FCCollectionInciOther()
    {
    }

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

    FCPageGraphic* GetItemAt(int index) { return (FCPageGraphic*) __FCCollectionInciOther::GetItemAt(index); }
};


class FCTextRepeatDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCTextRepeatDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTextRepeatDefs() : __FCCollectionNoInciOther() {}

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

    FCTextRepeatDef* GetItemAt(int index) { return (FCTextRepeatDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};


class FCFretInstrumentDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCFretInstrumentDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCFretInstrumentDefs() : __FCCollectionNoInciOther() {}

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

    FCFretInstrumentDef* GetItemAt(int index) { return (FCFretInstrumentDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};


class FCTextRepeats : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCTextRepeat(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTextRepeats() : __FCCollectionInciOther() {}
    
    virtual const char* ClassName() { return "FCTextRepeats"; }
    
    FCTextRepeat* GetItemAt(int index) { return (FCTextRepeat*) __FCCollectionInciOther::GetItemAt(index); }
};


class FCExecutableShapeDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCExecutableShapeDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCExecutableShapeDefs"; }
};


#ifdef PDK_FRAMEWORK_SHAPES

class FCShapeDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCShapeDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCShapeDefs() : __FCCollectionNoInciOther() {}

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

    FCShapeDef* GetItemAt(int index) { return (FCShapeDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};
#endif /* PDK_FRAMEWORK_SHAPES */

class FCChordSuffixElements : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCChordSuffixElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCChordSuffixElements"; }

    FCChordSuffixElement* GetItemAt(int index) { return (FCChordSuffixElement*) __FCCollectionInciOther::GetItemAt(index); }
};


#if FXT_VERSION >= FINALEVERSION_2012

class FCFretboardStyleDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCFretboardStyleDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCFretboardStyleDefs"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_FRETBOARDSTYLEDEFS; }

        FCFretboardStyleDef* GetItemAt(int index) { return (FCFretboardStyleDef*)__FCCollectionNoInciOther::GetItemAt(index); }
};
#endif


#if FXT_VERSION >= FINALEVERSION_2012

class FCFretboardGroupDefs : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCFretboardGroupDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
        FCFretboardGroupDefs() : __FCCollectionInciOther() {}

    virtual const char* ClassName() { return "FCFretboardGroupDefs"; }
        virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_FRETBOARDGROUPDEFS; }

        FCFretboardGroupDef* GetItemAt(int index) { return (FCFretboardGroupDef*)__FCCollectionInciOther::GetItemAt(index); }
};
#endif


class FCBeatChartElements : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCBeatChartElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCBeatChartElements() : __FCCollectionInciOther()
    {}


    virtual const char* ClassName() { 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;
    }

    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();
    
    virtual bool SaveAll()
    {
        if (!IsValid()) return false;
        return __FCCollectionInciOther::SaveAll();
    }

    FCBeatChartElement* GetItemAt(int index) { return (FCBeatChartElement*) __FCCollectionInciOther::GetItemAt(index); }
};

class FCTempoElements : public __FCCollectionInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCTempoElement(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCTempoElements() : __FCCollectionInciOther()
    {
    }

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

    FCTempoElement* GetItemAt(int index) { return (FCTempoElement*) __FCCollectionInciOther::GetItemAt(index); }

    void AssureSorted();
};



class FCPercussionLayoutNotes : public __FCCollectionInciOther
{
    CMPER _percLibID;
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCPercussionLayoutNote(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    
    FCPercussionLayoutNotes() : __FCCollectionInciOther()
    {
        _percLibID = 0;
    }

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

    CMPER GetPercussionLibraryID() { return _percLibID; }

    virtual int LoadAllForItem(CMPER cmper)
    {
        _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

    FCString* CreateNameString_GC();
#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) { return (FCPercussionLayoutNote*) __FCCollectionInciOther::GetItemAt(index); }
};



class FCInstrumentDefs : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCInstrumentDef(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:

    FCInstrumentDefs() : __FCCollectionNoInciOther()
    {
    }


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

    FCInstrumentDef* GetItemAt(int index) { return (FCInstrumentDef*) __FCCollectionNoInciOther::GetItemAt(index); }
};


class FCStaffLists : public __FCCollectionNoInciOther
{
protected:
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        virtual __FCBaseData* CreateElement() { return new FCStaffList(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    /* \brief The constructor
     *
     * Lua-supported.
     *  */
    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;
        }
    }

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

    FCStaffList* GetItemAt(int index) { return (FCStaffList*) __FCCollectionNoInciOther::GetItemAt(index); }
};


class FCStaffListLookup : public __FCCollection
{
    FCStaffList _scoredisplay, _partsdisplay, _scoreforced, _partsforced;
    bool _loaded;
public:
    FCStaffListLookup() : __FCCollection()
    {
        _loaded = false;
    }

    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() {}

    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
        virtual __FCBaseData* CreateElement() { return new FCCellClefChange(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    virtual const char* ClassName() { return "FCCellClefChanges"; }

    FCCellClefChanges() : __FCCollectionInciOther()
    {
    }

    FCCellClefChange* GetItemAt(int index) { return (FCCellClefChange*)__FCCollectionInciOther::GetItemAt(index); }
};


class FCGuides : public __FCCollection
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        bool _vertical; /* True - vertical guides, False - horizontal guides */
#endif
    public:

#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        /* \brief The constructor.
         *
         * For internal use only.
         */
        FCGuides(bool isvertical) : __FCCollection()
        {
            _vertical = isvertical;
        }

        bool _Load(int count);

        bool _Save();
#endif

    FCGuide* GetItemAt(int index) { 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);
        Add(pGuide);
        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
    virtual __FCBaseData* CreateElement() { return new FCMetatoolAssignment(); }
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:
    FCMetatoolAssignments() : __FCCollectionNoInciOther()
    {}
    
    virtual const char* ClassName() { return "FCMetatoolAssignments"; }
    
    FCMetatoolAssignment* GetItemAt(int index) { 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; }
    
    virtual int LoadAll();
    
    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);
};


#endif  /* FF_OTHERCOLLECTION_H */