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
    };
 
 
    const char* ClassName() const override { 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 IsEmptyAndNotSinglePos() const
    {
        return IsEmpty() && ! IsSinglePos();
    }
 
    bool IsMeasureIncluded(twobyte measureno);
 
    bool IsAbsoluteEndMeasurePos();
 
    bool IsFullMeasureIncluded(twobyte measureno);
 
    bool IsStaffIncluded(twobyte staffnumber) const;
 
    bool IsSlotIncluded(twobyte slotnumber) const;
 
    bool IsMeasurePosWithin(int measure, TimeEdu32 pos);
 
    bool IsStartPos(const int measure, const TimeEdu32 pos);
 
    bool IsCellPosWithin(const FCCell* pCell, const TimeEdu32 pos);
 
    bool IsIdentical(const __FCBase* pCompareObject) const override;
    
#ifdef PDK_FRAMEWORK_ENTRIES
    bool IsEntryPosWithin(const 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) const { 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 (IsEmptyAndNotSinglePos()) 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_CPP
    luabridge::RefCountedPtr<FCCells> CreateCells_GC()
    { return makeLuaSharedPtr(CreateCells()); }
#endif
 
    bool Playback(bool playtoend = false) const;
    
    bool PlaybackSingleStaff(eStaff staffnum, bool playtoend = false) const
    {
        if (!CalcSlotNumber(staffnum))
            return false;
        FX_Playback(GetStartMeasure(), (playtoend) ? 0 : GetEndMeasure(), staffnum, GetInstrumentList());
        return true;
    }
    
    void FixMeasureWidthsInScore() const;
 
#ifdef PDK_FRAMEWORK_DEBUG
    void DebugDump() override
    {
        __FCBase::DebugDump();
        DebugOutInt("Start measure: ", GetStartMeasure());
        DebugOutInt("Start measure pos: ", GetStartMeasurePos());
        DebugOutInt("End measure: ", GetEndMeasure());
        DebugOutInt("End measure pos: ", GetEndMeasurePos());
        DebugOutInt("Instrument list: ", GetInstrumentList());
        DebugOutInt("Start slot: ", GetStartSlot());
        DebugOutInt("End slot: ", GetEndSlot());
        DebugOutInt("Start staff: ", GetStartStaff());
        DebugOutInt("End staff: ", GetEndStaff());
    }
#endif
};
 
#endif  /* FF_REGION_H */