floatingobject.h

// Name:        floatingobject.h
// Author:      Laurent Pugin
// Created:     2015
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_FLOATING_OBJECT_H__
#define __VRV_FLOATING_OBJECT_H__
 
#include "devicecontextbase.h"
#include "object.h"
 
namespace vrv {
 
class Alignment;
class FloatingPositioner;
class StaffAlignment;
 
//----------------------------------------------------------------------------
// FloatingObject
//----------------------------------------------------------------------------
 
class FloatingObject : public Object {
public:
    FloatingObject();
    FloatingObject(ClassId classId);
    virtual ~FloatingObject();
    void Reset() override;
    void ResetDrawing();
 
    void UpdateContentBBoxX(int x1, int x2) override;
    void UpdateContentBBoxY(int y1, int y2) override;
    void UpdateSelfBBoxX(int x1, int x2) override;
    void UpdateSelfBBoxY(int y1, int y2) override;
 
    int GetDrawingX() const override;
    int GetDrawingY() const override;
 
    void SetCurrentFloatingPositioner(FloatingPositioner *boundingBox);
    FloatingPositioner *GetCurrentFloatingPositioner() { return m_currentPositioner; }
    const FloatingPositioner *GetCurrentFloatingPositioner() const { return m_currentPositioner; }
 
    FloatingPositioner *GetCorrespFloatingPositioner(const FloatingObject *object);
    const FloatingPositioner *GetCorrespFloatingPositioner(const FloatingObject *object) const;
 
    int GetDrawingGrpId() const { return m_drawingGrpId; }
    void SetDrawingGrpId(int drawingGrpId) { m_drawingGrpId = drawingGrpId; }
    int SetDrawingGrpObject(void *drawingGrpObject);
 
    void ResetMaxDrawingYRel() { m_maxDrawingYRel = VRV_UNSET; }
    void SetMaxDrawingYRel(int maxDrawingYRel, data_STAFFREL place);
    int GetMaxDrawingYRel() const { return m_maxDrawingYRel; };
 
    void ResetDrawingObjectIDs();
 
    virtual bool IsExtenderElement() const { return false; }
 
    virtual bool IsCloserToStaffThan(const FloatingObject *, data_STAFFREL) const { return false; }
 
    virtual std::pair<int, bool> GetVerticalContentBoundaryRel(const Doc *doc, const FloatingPositioner *positioner,
        const BoundingBox *horizOverlappingBBox, bool contentTop) const;
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
private:
    //
public:
    //
private:
    FloatingPositioner *m_currentPositioner;
 
    /* Drawing Id to group floating elements horizontally */
    int m_drawingGrpId;
 
    int m_maxDrawingYRel;
 
    //----------------//
    // Static members //
    //----------------//
 
    static thread_local std::vector<void *> s_drawingObjectIds;
};
 
//----------------------------------------------------------------------------
// FloatingPositioner
//----------------------------------------------------------------------------
 
class FloatingPositioner : public BoundingBox {
public:
    // constructors and destructors
    FloatingPositioner(FloatingObject *object, StaffAlignment *alignment, char spanningType);
    virtual ~FloatingPositioner() {}
    ClassId GetClassId() const override { return FLOATING_POSITIONER; }
 
    virtual void ResetPositioner();
 
    int GetDrawingX() const override;
    int GetDrawingY() const override;
 
    void ResetCachedDrawingX() const override;
    void ResetCachedDrawingY() const override;
 
    void SetObjectXY(Object *objectX, Object *objectY);
    Object *GetObjectX() { return m_objectX; }
    const Object *GetObjectX() const { return m_objectX; }
    Object *GetObjectY() { return m_objectY; }
    const Object *GetObjectY() const { return m_objectY; }
 
    FloatingObject *GetObject() { return m_object; }
    const FloatingObject *GetObject() const { return m_object; }
 
    StaffAlignment *GetAlignment() { return m_alignment; }
    const StaffAlignment *GetAlignment() const { return m_alignment; }
 
    char GetSpanningType() const { return m_spanningType; }
 
    data_STAFFREL GetDrawingPlace() const { return m_place; }
 
    int GetDrawingYRel() const { return m_drawingYRel; }
    virtual void SetDrawingYRel(int drawingYRel, bool force = false);
    int GetDrawingXRel() const { return m_drawingXRel; }
    virtual void SetDrawingXRel(int drawingXRel);
 
    int GetDrawingExtenderWidth() const { return m_drawingExtenderWidth; }
    void SetDrawingExtenderWidth(int extenderWidth) { m_drawingExtenderWidth = extenderWidth; }
 
    bool HasHorizontalOverlapWith(const BoundingBox *bbox, int unit) const;
 
    int GetAdmissibleHorizOverlapMargin(const BoundingBox *bbox, int unit) const;
 
    void CalcDrawingYRel(const Doc *doc, const StaffAlignment *staffAlignment, const BoundingBox *horizOverlappingBBox);
 
    void AdjustExtenders();
 
    int GetSpaceBelow(
        const Doc *doc, const StaffAlignment *staffAlignment, const BoundingBox *horizOverlappingBBox) const;
 
    std::pair<int, bool> GetVerticalContentBoundaryRel(
        const Doc *doc, const BoundingBox *horizOverlappingBBox, bool contentTop) const;
    int GetVerticalContentBoundary(const Doc *doc, const BoundingBox *horizOverlappingBBox, bool contentTop) const;
 
    bool HasVerticalContentOverlap(const Doc *doc, const BoundingBox *horizOverlappingBBox, int margin) const;
 
private:
    Object *m_objectX;
    Object *m_objectY;
 
protected:
    int m_drawingXRel;
    int m_drawingYRel;
 
    int m_drawingExtenderWidth;
 
    FloatingObject *m_object;
 
    StaffAlignment *m_alignment;
 
    data_STAFFREL m_place;
 
public:
    char m_spanningType;
};
 
//----------------------------------------------------------------------------
// FloatingCurvePositioner
//----------------------------------------------------------------------------
 
class FloatingCurvePositioner : public FloatingPositioner {
public:
    // constructors and destructors
    FloatingCurvePositioner(FloatingObject *object, StaffAlignment *alignment, char spanningType);
    virtual ~FloatingCurvePositioner();
    ClassId GetClassId() const override { return FLOATING_CURVE_POSITIONER; }
 
    void ResetPositioner() override;
 
    void ResetCurveParams();
 
    void UpdateCurveParams(const Point points[4], int thickness, curvature_CURVEDIR curveDir);
    void UpdatePoints(const BezierCurve &bezier);
 
    void MoveFrontHorizontal(int distance);
    void MoveBackHorizontal(int distance);
    void MoveFrontVertical(int distance);
    void MoveBackVertical(int distance);
 
    int CalcMinMaxY(const Point points[4]) const;
 
    int CalcAdjustment(
        const BoundingBox *boundingBox, bool &discard, int margin = 0, bool horizontalOverlap = true) const;
    int CalcDirectionalAdjustment(const BoundingBox *boundingBox, bool isCurveAbove, bool &discard, int margin = 0,
        bool horizontalOverlap = true) const;
    // Refined version that returns the adjustments on the left and right hand side of the bounding box
    std::pair<int, int> CalcLeftRightAdjustment(
        const BoundingBox *boundingBox, bool &discard, int margin = 0, bool horizontalOverlap = true) const;
    std::pair<int, int> CalcDirectionalLeftRightAdjustment(const BoundingBox *boundingBox, bool isCurveAbove,
        bool &discard, int margin = 0, bool horizontalOverlap = true) const;
 
    void GetPoints(Point points[4]) const;
    int GetThickness() const { return m_thickness; }
    curvature_CURVEDIR GetDir() const { return m_dir; }
 
    bool HasCachedX12() const;
    std::pair<int, int> GetCachedX12() const { return m_cachedX12; }
    void SetCachedX12(const std::pair<int, int> &cachedX12) { m_cachedX12 = cachedX12; }
 
    void ClearSpannedElements();
 
    void AddSpannedElement(CurveSpannedElement *spannedElement) { m_spannedElements.push_back(spannedElement); }
 
    const ArrayOfCurveSpannedElements *GetSpannedElements() { return &m_spannedElements; }
 
    void SetCrossStaff(Staff *crossStaff) { m_crossStaff = crossStaff; }
    Staff *GetCrossStaff() { return m_crossStaff; }
    const Staff *GetCrossStaff() const { return m_crossStaff; }
    bool IsCrossStaff() const { return m_crossStaff != NULL; }
 
    void SetRequestedStaffSpace(int space) { m_requestedStaffSpace = space; }
    int GetRequestedStaffSpace() const { return m_requestedStaffSpace; }
 
    std::pair<int, int> CalcRequestedStaffSpace(const StaffAlignment *alignment) const;
 
private:
    //
public:
    //
private:
    Point m_points[4];
    int m_thickness;
    curvature_CURVEDIR m_dir;
    Staff *m_crossStaff;
 
    ArrayOfCurveSpannedElements m_spannedElements;
 
    mutable int m_cachedMinMaxY;
 
    std::pair<int, int> m_cachedX12;
 
    int m_requestedStaffSpace;
};
 
//----------------------------------------------------------------------------
// CurveSpannedElement
//----------------------------------------------------------------------------
 
class CurveSpannedElement {
public:
    CurveSpannedElement()
    {
        m_boundingBox = NULL;
        m_discarded = false;
        m_isBelow = true;
    }
    virtual ~CurveSpannedElement() {}
 
    Point m_rotatedPoints[4];
    const BoundingBox *m_boundingBox;
    bool m_discarded;
    bool m_isBelow;
};
 
} // namespace vrv
 
#endif