ff_region.h

/*
 * File:   ff_region.h
 * Author: Jari Williamsson
 *
 * Created on den 7 november 2010, 13:52
 */

#ifndef FF_REGION_H
#define FF_REGION_H


class FCCell;
class FCCells;

class FCMusicRegion : public __FCBase
{
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
        EREGION _region;
        EDOCID _documentid;

        ECLIPFILETOKEN _clipfiletoken;
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
public:



    enum REBARSTOPS
    {
        REBARSTOP_NONE = REBAR_NO_STOP,

        REBARSTOP_KEY = REBAR_STOP_KEYCHANGE,

        REBARSTOP_TIME = REBAR_STOP_TIMECHANGE,

        REBARSTOP_REGIONEND = REBAR_STOP_ENDOFREGION,

        REBARSTOP_SPECIALBARLINE = REBAR_STOP_SPECIALBARLINE,

        REBARSTOP_EMPTYFRAME = REBAR_STOP_EMPTYFRAME,

        REBARSTOP_EMPTYFRAMEAFTERREGION = REBAR_STOP_EMPTYFRAMEAFTERREGION
    };


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

#ifndef DOXYGEN_SHOULD_IGNORE_THIS

    EREGION* _GetEREGION() { return &_region; }

    EDOCID _GetDocumentID() { return _documentid; }
#endif


    FCMusicRegion(EREGION* pRegion = NULL);

    virtual ~FCMusicRegion();


    void AssureSortedStaves();

    void Clear() { _region.ClearEnigmaRegion(); }

    bool IsEmpty() const
    {
        /* The EREGION approach doesn't cover all cases,
         since an empty region can be defined as startmeas=endmeas
         and measstartpos=measendpos.
         I have to do some additional checking to be safe.
         Don't use getters here, since it will result in an endless
         recursive chain.
         */
        if (_region.start.meas > _region.end.meas) return true;
        if (_region.start.meas == _region.end.meas)
        {
            if (_region.start.duraPos >= _region.end.duraPos) return true;
        }
        return (_region.IsEnigmaRegionEmpty() != 0);
    }
    
    bool IsSinglePos() const
    {
        if (_region.start.meas < 1) return false;
        if (_region.start.meas != _region.end.meas) return false;
        if (_region.start.duraPos != _region.end.duraPos) return false;
        return true;
    }

    bool IsMeasureIncluded(twobyte measureno);

    bool IsAbsoluteEndMeasurePos();

    bool IsFullMeasureIncluded(twobyte measureno);

    bool IsStaffIncluded(twobyte staffnumber);

    bool IsSlotIncluded(twobyte slotnumber);

    bool IsMeasurePosWithin(int measure, TimeEdu32 pos);

    bool IsStartPos(int measure, TimeEdu32 pos);

    bool IsCellPosWithin(FCCell* pCell, TimeEdu32 pos);

    virtual bool IsIdentical(FCMusicRegion* pMusicRegion);
    
#ifdef PDK_FRAMEWORK_ENTRIES

    bool IsEntryPosWithin(FCNoteEntry* pEntry);
#endif // #ifdef PDK_FRAMEWORK_ENTRIES

    bool IsPartial();

        bool IsMeasurePartial(eMeas measure);

    bool IsOverlapping(FCMusicRegion* pRegion);

    bool IsFullDocumentSpan();

    bool IsLastEndMeasure();

    bool SetFullDocument();

    bool SetCurrentSelection();

    void SetEnigmaRegion(EREGION* pRegion);

    void SetRegion(FCMusicRegion* pSourceRegion);

    void GetEnigmaRegion(EREGION* pRegion);

    void SetStartMeasure(twobyte measure) { _region.start.meas = measure; }

    void SetStartMeasurePos(TimeEdu32 pos) { _region.start.duraPos = pos; }

    void SetStartMeasurePosLeft() { SetStartMeasurePos(0); }

     void SetEndMeasure(twobyte measure) { _region.end.meas = measure; }

     void SetEndMeasurePos(TimeEdu32 pos) { _region.end.duraPos = pos; }

     void SetEndMeasurePosRight() { SetEndMeasurePos(0x7fffffff); }

     bool SetFullMeasureStack();

        void SetInstrumentList(twobyte list) { _region.start.IUlist = _region.end.IUlist = list; }

        void SetStartStaff(twobyte staff) { _region.start.IUslot = FX_InstToSlot(staff, _region.start.IUlist); }

    void SetStartSlot(twobyte slot) { _region.start.IUslot = slot; }

        void SetEndStaff(twobyte staff) { _region.end.IUslot = FX_InstToSlot(staff, _region.end.IUlist); }

    void SetEndSlot(twobyte slot) { _region.end.IUslot = slot; }

    twobyte GetStartMeasure() const { return _region.start.meas; }

    twobyte GetEndMeasure() const { return _region.end.meas; }

    twobyte GetInstrumentList() const { return _region.start.IUlist; }

    twobyte GetStartSlot() const { return _region.start.IUslot; }

    twobyte GetEndSlot() const { return _region.end.IUslot; }

    twobyte GetStartStaff() const { return FX_SlotToInst(_region.start.IUslot, _region.start.IUlist); }

    twobyte GetEndStaff() const { return FX_SlotToInst(_region.end.IUslot, _region.end.IUlist); }

    TimeEdu32 GetStartMeasurePos() const { return _region.start.duraPos; }

    TimeEdu32 GetEndMeasurePos() const { return _region.end.duraPos; }

    int CalcMeasureSpan() {
        if (IsSinglePos()) return 1;
        if (IsEmpty()) return 0;
        return GetEndMeasure() - GetStartMeasure() + 1;
    }

    int CalcStaffSpan() { return GetEndSlot() - GetStartSlot() + 1; }

    twobyte CalcStaffNumber(twobyte slot) { return FX_SlotToInst(slot, GetInstrumentList()); }

    twobyte CalcSlotNumber(twobyte staff) { return FX_InstToSlot(staff, GetInstrumentList()); }

    TimeEdu32 CalcDuration();

    bool SetDurationOffsetLeft(TimeEdu32 durationoffset);

    bool SetDurationOffsetRight(TimeEdu32 durationoffset);

    bool IsCurrentDocument();

    void SetInDocument();

    void ConvertToGlobalInstrumentList();

    int ForEachStaff(FCIteratorHandler* pHandler);

    bool CopyMusic();

    bool CutMusic();

    bool CutDeleteMusic();

    bool PasteMusic();

    bool ReleaseMusic();

    void Redraw();

    void RebeamMusic();

    void RebarMusic(int stopflags, bool rebeam, bool padwithrests);
    
    bool MusicMassMoverFrom(FCMusicRegion* pSourceRegion);
    
    bool AddMeasureOffset(int offset)
    {
        if (IsEmpty() && (!IsSinglePos())) return false;
        int newstart = GetStartMeasure() + offset;
        int newend = GetEndMeasure() + offset;
        if (newstart < 1) return false;
        if (newend > 32767) return false;
        SetStartMeasure(newstart);
        SetEndMeasure(newend);
        return true;
    }

    FCCells* CreateCells();

#ifdef PDK_FRAMEWORK_LUAFRIENDLY

    FCCells* CreateCells_GC();
#endif

#ifdef PDK_FRAMEWORK_DEBUG
    virtual void DebugDump()
    {
        __FCBase::DebugDump();
        DebugOutDigit("Start measure: ", GetStartMeasure());
        DebugOutDigit("Start measure pos: ", GetStartMeasurePos());
        DebugOutDigit("End measure: ", GetEndMeasure());
        DebugOutDigit("End measure pos: ", GetEndMeasurePos());
        DebugOutDigit("Instrument list: ", GetInstrumentList());
        DebugOutDigit("Start slot: ", GetStartSlot());
        DebugOutDigit("End slot: ", GetEndSlot());
        DebugOutDigit("Start staff: ", GetStartStaff());
        DebugOutDigit("End staff: ", GetEndStaff());
    }
#endif
};

#endif  /* FF_REGION_H */