//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2002-2012 Werner Schweer
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License version 2
//  as published by the Free Software Foundation and appearing in
//  the file LICENCE.GPL
//=============================================================================
 
#ifndef __BEAM_H__
#define __BEAM_H__
 
#include "element.h"
#include "durationtype.h"
 
namespace Ms {
 
class ChordRest;
class MuseScoreView;
class Chord;
class System;
enum class SpannerSegmentType;
 
struct BeamFragment;
 
//---------------------------------------------------------
//   @@ Beam
//---------------------------------------------------------
 
class Beam : public Element {
      Q_GADGET
 
      QVector<ChordRest*> _elements;        // must be sorted by tick
      QVector<QLineF*> beamSegments;
      Direction _direction;
 
      bool _up;
      bool _distribute;                   // equal spacing of elements
      bool _noSlope;
      PropertyFlags noSlopeStyle;
 
      bool _userModified[2];              // 0: auto/down  1: up
      bool _isGrace;
      bool _cross;
 
      qreal _grow1;                       // define "feather" beams
      qreal _grow2;
      qreal _beamDist;
 
      QVector<BeamFragment*> fragments;     // beam splits across systems
 
      mutable int _id;          // used in read()/write()
 
      int minMove;              // set in layout1()
      int maxMove;
      TDuration maxDuration;
      qreal slope { 0.0 };
 
 
      void layout2(std::vector<ChordRest*>, SpannerSegmentType, int frag);
      bool twoBeamedNotes();
      void computeStemLen(const std::vector<ChordRest*>& crl, qreal& py1, int beamLevels);
      bool slopeZero(const std::vector<ChordRest*>& crl);
      bool hasNoSlope();
      void addChordRest(ChordRest* a);
      void removeChordRest(ChordRest* a);
 
   public:
      enum class Mode : signed char {
            AUTO, BEGIN, MID, END, NONE, BEGIN32, BEGIN64, INVALID = -1
            };
      Q_ENUMS(Mode)
 
      Beam(Score* = 0);
      Beam(const Beam&);
      ~Beam();
      virtual Beam* clone() const override         { return new Beam(*this); }
      virtual ElementType type() const override  { return ElementType::BEAM; }
      virtual QPointF pagePos() const override;    ///< position in page coordinates
      virtual QPointF canvasPos() const override;  ///< position in page coordinates
 
      virtual bool isEditable() const override { return true; }
      virtual void startEdit(EditData&) override;
      virtual void endEdit(EditData&) override;
      virtual void editDrag(EditData&) override;
      virtual void updateGrips(EditData&) const override;
 
      virtual int tick() const override;
      virtual int rtick() const override;
 
      virtual void write(XmlWriter& xml) const override;
      virtual void read(XmlReader&) override;
      virtual void spatiumChanged(qreal /*oldValue*/, qreal /*newValue*/) override;
 
      virtual void reset() override;
 
      System* system() const { return (System*)parent(); }
 
      void layout1();
      void layoutGraceNotes();
      void layout();
 
      const QVector<ChordRest*>& elements() { return _elements;  }
      void clear()                        { _elements.clear(); }
      bool empty() const                { return _elements.empty(); }
 
      virtual void add(Element*) override;
      virtual void remove(Element*) override;
 
      virtual void move(const QPointF&) override;
      virtual void draw(QPainter*) const override;
 
      bool up() const                     { return _up; }
      void setUp(bool v)                  { _up = v;    }
      void setId(int i) const             { _id = i;    }
      int id() const                      { return _id; }
      bool noSlope() const                { return _noSlope; }
      void setNoSlope(bool val)           { _noSlope = val; }
 
      void setBeamDirection(Direction d);
      Direction beamDirection() const     { return _direction; }
 
      virtual bool acceptDrop(EditData&) const override;
      virtual Element* drop(EditData&) override;
 
      qreal growLeft() const              { return _grow1; }
      qreal growRight() const             { return _grow2; }
      void setGrowLeft(qreal val)         { _grow1 = val;  }
      void setGrowRight(qreal val)        { _grow2 = val;  }
 
      bool distribute() const             { return _distribute; }
      void setDistribute(bool val)        { _distribute = val;  }
 
      bool userModified() const;
      void setUserModified(bool val);
 
      QPointF beamPos() const;
      void setBeamPos(const QPointF& bp);
 
      qreal beamDist() const              { return _beamDist; }
 
      virtual QVariant getProperty(P_ID propertyId) const override;
      virtual bool setProperty(P_ID propertyId, const QVariant&) override;
      virtual QVariant propertyDefault(P_ID id) const override;
      virtual PropertyFlags propertyFlags(P_ID) const override;
      virtual void resetProperty(P_ID id) override;
      virtual StyleIdx getPropertyStyle(P_ID) const override;
 
      virtual void styleChanged() override;
      bool isGrace() const { return _isGrace; }  // for debugger
      bool cross() const   { return _cross; }
      virtual Shape shape() const override;
      virtual void triggerLayout() const override;
      };
 
 
}     // namespace Ms
 
Q_DECLARE_METATYPE(Ms::Beam::Mode);
 
#endif
 

V690 The 'Beam' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class.