timeinterface.h

// Name:        timeinterface.h
// Author:      Laurent Pugin
// Created:     2015
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_TIME_INTERFACE_H__
#define __VRV_TIME_INTERFACE_H__
 
#include "atts_shared.h"
#include "interface.h"
#include "vrvdef.h"
 
namespace vrv {
 
class Object;
class LayerElement;
class Measure;
class PrepareStaffCurrentTimeSpanningFunctor;
class PrepareTimePointingFunctor;
class PrepareTimeSpanningFunctor;
class PrepareTimestampsFunctor;
class ResetDataFunctor;
class StaffAlignment;
 
//----------------------------------------------------------------------------
// TimePointInterface
//----------------------------------------------------------------------------
 
class TimePointInterface : public Interface, public AttStaffIdent, public AttStartId, public AttTimestampLog {
public:
    TimePointInterface();
    virtual ~TimePointInterface();
    void Reset() override;
    InterfaceId IsInterface() const override { return INTERFACE_TIME_POINT; }
 
    void SetStart(LayerElement *start);
    LayerElement *GetStart() { return m_start; }
    const LayerElement *GetStart() const { return m_start; }
 
    bool SetStartOnly(LayerElement *start);
 
    void AddStaff(int n);
 
    bool HasStart() const { return (m_start); }
 
    Measure *GetStartMeasure();
    const Measure *GetStartMeasure() const;
 
    bool IsOnStaff(int n) const;
 
    std::vector<const Staff *> GetTstampStaves(const Measure *measure, const Object *object) const;
    std::vector<Staff *> GetTstampStaves(const Measure *measure, const Object *object);
 
    bool VerifyMeasure(const Object *owner) const;
 
    //-----------------//
    // Pseudo functors //
    //-----------------//
 
    FunctorCode InterfacePrepareTimePointing(PrepareTimePointingFunctor &functor, Object *object);
    virtual FunctorCode InterfacePrepareTimestamps(PrepareTimestampsFunctor &functor, Object *object);
    virtual FunctorCode InterfaceResetData(ResetDataFunctor &functor, Object *object);
 
protected:
    void SetIDStr();
 
private:
    //
public:
    //
protected:
    LayerElement *m_start;
    std::string m_startID;
 
private:
};
 
//----------------------------------------------------------------------------
// TimeSpanningInterface
//----------------------------------------------------------------------------
 
class TimeSpanningInterface : public TimePointInterface, public AttStartEndId, public AttTimestamp2Log {
public:
    TimeSpanningInterface();
    virtual ~TimeSpanningInterface();
    void Reset() override;
    InterfaceId IsInterface() const override { return INTERFACE_TIME_SPANNING; }
 
    void SetEnd(LayerElement *end);
    LayerElement *GetEnd() { return m_end; }
    const LayerElement *GetEnd() const { return m_end; }
 
    bool SetStartAndEnd(LayerElement *element);
 
    bool HasStartAndEnd() const { return (m_start && m_end); }
 
    Measure *GetEndMeasure();
    const Measure *GetEndMeasure() const;
 
    bool IsSpanningMeasures() const;
 
    void SetIDStr();
 
    bool IsOrdered() const;
    bool IsOrdered(const LayerElement *start, const LayerElement *end) const;
 
    void GetCrossStaffOverflows(
        StaffAlignment *alignment, curvature_CURVEDIR curveDir, bool &skipAbove, bool &skipBelow);
 
    //-----------------//
    // Pseudo functors //
    //-----------------//
 
    FunctorCode InterfacePrepareTimeSpanning(PrepareTimeSpanningFunctor &functor, Object *object);
    FunctorCode InterfacePrepareTimestamps(PrepareTimestampsFunctor &functor, Object *object) override;
    FunctorCode InterfacePrepareStaffCurrentTimeSpanning(
        PrepareStaffCurrentTimeSpanningFunctor &functor, Object *object);
    FunctorCode InterfaceResetData(ResetDataFunctor &functor, Object *object) override;
 
private:
    //
public:
    //
private:
    LayerElement *m_end;
    std::string m_endID;
};
 
} // namespace vrv
 
#endif