system.h

// Name:        system.h
// Author:      Laurent Pugin
// Created:     2011
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_SYSTEM_H__
#define __VRV_SYSTEM_H__
 
#include "drawinginterface.h"
#include "editorial.h"
#include "object.h"
#include "verticalaligner.h"
#include "vrvdef.h"
 
namespace vrv {
 
class SystemMilestoneEnd;
class DeviceContext;
class Ending;
class Measure;
class ScoreDef;
class Slur;
class Staff;
 
//----------------------------------------------------------------------------
// System
//----------------------------------------------------------------------------
 
class System : public Object, public DrawingListInterface, public AttTyped {
public:
    System();
    virtual ~System();
    void Reset() override;
    std::string GetClassName() const override { return "system"; }
 
    bool IsSupportedChild(ClassId classId) override;
 
    int GetDrawingX() const override;
    int GetDrawingY() const override;
 
    int GetDrawingXRel() const { return m_drawingXRel; }
    virtual void SetDrawingXRel(int drawingXRel);
    int GetDrawingYRel() const { return m_drawingYRel; }
    virtual void SetDrawingYRel(int drawingYRel);
 
    int GetDrawingLabelsWidth() const;
    void SetDrawingLabelsWidth(int width);
    int GetDrawingAbbrLabelsWidth() const { return m_drawingAbbrLabelsWidth; }
    void SetDrawingAbbrLabelsWidth(int width);
    void ResetDrawingAbbrLabelsWidth() { m_drawingAbbrLabelsWidth = 0; }
 
    int GetHeight() const;
 
    int GetMinimumSystemSpacing(const Doc *doc) const;
 
    int GetSystemIdx() const { return Object::GetIdx(); }
 
    bool SetCurrentFloatingPositioner(
        int staffN, FloatingObject *object, Object *objectX, Object *objectY, char spanningType = SPANNING_START_END);
 
    ScoreDef *GetDrawingScoreDef() { return m_drawingScoreDef; }
    const ScoreDef *GetDrawingScoreDef() const { return m_drawingScoreDef; }
    void SetDrawingScoreDef(ScoreDef *drawingScoreDef);
    void ResetDrawingScoreDef();
 
    bool HasMixedDrawingStemDir(const LayerElement *start, const LayerElement *end) const;
 
    curvature_CURVEDIR GetPreferredCurveDirection(
        const LayerElement *start, const LayerElement *end, const Slur *slur) const;
 
    bool IsDrawingOptimized() const { return m_drawingIsOptimized; }
    void IsDrawingOptimized(bool drawingIsOptimized) { m_drawingIsOptimized = drawingIsOptimized; }
 
    void AddToDrawingListIfNecessary(Object *object);
 
    bool IsFirstInPage() const;
    bool IsLastInPage() const;
    bool IsFirstOfMdiv() const;
    bool IsLastOfMdiv() const;
    bool IsFirstOfSelection() const;
    bool IsLastOfSelection() const;
 
    double EstimateJustificationRatio(const Doc *doc) const;
 
    void ConvertToUnCastOffMensuralSystem();
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
public:
    SystemAligner m_systemAligner;
 
public:
    int m_systemLeftMar;
    int m_systemRightMar;
    int m_drawingFacsY;
    int m_drawingFacsX;
    int m_drawingAbbrLabelsWidth;
    int m_drawingTotalWidth;
    int m_drawingJustifiableWidth;
 
    int m_castOffTotalWidth;
    int m_castOffJustifiableWidth;
 
protected:
    int m_drawingXRel;
    int m_drawingYRel;
 
private:
    ScoreDef *m_drawingScoreDef;
 
    bool m_drawingIsOptimized;
};
 
} // namespace vrv
 
#endif