//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2002-2011 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 __MEASURE_H__
#define __MEASURE_H__
 
/**
 \file
 Definition of class Measure.
*/
 
#include "measurebase.h"
#include "fraction.h"
#include "segmentlist.h"
 
namespace Ms {
 
class XmlWriter;
class Beam;
class Tuplet;
class Staff;
class Chord;
class Text;
class ChordRest;
class Score;
class MuseScoreView;
class System;
class Note;
class Spacer;
class TieMap;
class AccidentalState;
class Spanner;
class Part;
class RepeatMeasure;
 
class MStaff;
 
//---------------------------------------------------------
//   MeasureNumberMode
//---------------------------------------------------------
 
enum class MeasureNumberMode : char {
      AUTO,       // show measure number depending on style
      SHOW,       // always show measure number
      HIDE        // dont show measure number
      };
 
//---------------------------------------------------------
//   @@ Measure
///    one measure in a system
//
//   @P firstSegment    Segment       the first segment of the measure (read-only)
//   @P lastSegment     Segment       the last segment of the measure (read-only)
//---------------------------------------------------------
 
class Measure : public MeasureBase {
      Q_GADGET
      Q_PROPERTY(Ms::Segment* firstSegment READ first)
      Q_PROPERTY(Ms::Segment* lastSegment  READ last)
 
      std::vector<MStaff*>  _mstaves;
      SegmentList _segments;
      Measure* _mmRest;       // multi measure rest which replaces a measure range
 
      qreal _userStretch;
 
      Fraction _timesig;
      Fraction _len;          ///< actual length of measure
 
      int _mmRestCount;       // > 0 if this is a multi measure rest
                              // 0 if this is the start of a mm rest (_mmRest != 0)
                              // < 0 if this measure is covered by a mm rest
 
      int _playbackCount;     // temp. value used in RepeatList
                              // counts how many times this measure was already played
 
      int _repeatCount;       ///< end repeat marker und repeat count
 
      MeasureNumberMode _noMode;
      bool _breakMultiMeasureRest;
 
      void push_back(Segment* e);
      void push_front(Segment* e);
 
      void fillGap(const Fraction& pos, const Fraction& len, int track, const Fraction& stretch);
      void computeMinWidth(Segment* s, qreal x, bool isSystemHeader);
 
   public:
      Measure(Score* = 0);
      Measure(const Measure&);
      ~Measure();
      virtual Measure* clone() const override     { return new Measure(*this); }
      virtual ElementType type() const override { return ElementType::MEASURE; }
      virtual void setScore(Score* s) override;
      Measure* cloneMeasure(Score*, TieMap*);
 
      void read(XmlReader&, int idx);
      void read(XmlReader& d) { read(d, 0); }
      virtual void write(XmlWriter& xml) const override { Element::write(xml); }
      void write(XmlWriter&, int, bool writeSystemElements, bool forceTimeSig) const;
      void writeBox(XmlWriter&) const;
      void readBox(XmlReader&);
      virtual bool isEditable() const override { return false; }
      void checkMeasure(int idx);
 
      virtual void add(Element*) override;
      virtual void remove(Element*) override;
      virtual void change(Element* o, Element* n) override;
      virtual void spatiumChanged(qreal oldValue, qreal newValue) override;
 
      System* system() const                      { return (System*)parent(); }
      bool hasVoices(int staffIdx) const;
      void setHasVoices(int staffIdx, bool v);
 
      StaffLines* staffLines(int staffIdx);
      Spacer* vspacerDown(int staffIdx) const;
      Spacer* vspacerUp(int staffIdx) const;
      void setStaffVisible(int staffIdx, bool visible);
      void setStaffSlashStyle(int staffIdx, bool slashStyle);
      bool corrupted(int staffIdx) const;
      void setCorrupted(int staffIdx, bool val);
      void setNoText(int staffIdx, Text*);
      Text* noText(int staffIdx) const;
      Shape staffShape(int staffIdx) const;
      Shape& staffShape(int staffIdx);
      void createStaves(int);
 
      MeasureNumberMode measureNumberMode() const     { return _noMode;      }
      void setMeasureNumberMode(MeasureNumberMode v)  { _noMode = v;         }
 
      Fraction timesig() const             { return _timesig;     }
      void setTimesig(const Fraction& f)   { _timesig = f;        }
      Fraction len() const                 { return _len;         }
      Fraction stretchedLen(Staff*) const;
      void setLen(const Fraction& f)       { _len = f;            }
      virtual int ticks() const override;             // actual length of measure in ticks
      bool isIrregular() const             { return _timesig != _len; }
 
      int size() const                          { return _segments.size();        }
      Ms::Segment* first() const                { return _segments.first();       }
      Segment* first(SegmentType t) const     { return _segments.first(t);      }
 
      Ms::Segment* last() const                 { return _segments.last(); }
      SegmentList& segments()                   { return _segments; }
      const SegmentList& segments() const       { return _segments; }
 
      qreal userStretch() const;
      void setUserStretch(qreal v)              { _userStretch = v; }
 
      void stretchMeasure(qreal stretch);
      void layout2();
 
      Chord* findChord(int tick, int track);
      ChordRest* findChordRest(int tick, int track);
      int snap(int tick, const QPointF p) const;
      int snapNote(int tick, const QPointF p, int staff) const;
 
      void insertStaff(Staff*, int staff);
      void insertMStaff(MStaff* staff, int idx);
      void removeMStaff(MStaff* staff, int idx);
 
      virtual void moveTicks(int diff);
 
      void cmdRemoveStaves(int s, int e);
      void cmdAddStaves(int s, int e, bool createRest);
      void removeStaves(int s, int e);
      void insertStaves(int s, int e);
 
      qreal tick2pos(int) const;
      Segment* tick2segment(int tick, SegmentType st = SegmentType::ChordRest);
 
      void sortStaves(QList<int>& dst);
 
      virtual bool acceptDrop(EditData&) const override;
      virtual Element* drop(EditData&) override;
 
      int repeatCount() const         { return _repeatCount; }
      void setRepeatCount(int val)    { _repeatCount = val; }
 
      Segment* undoGetSegment(SegmentType st, int tick);  // deprecated
      Segment* getSegment(SegmentType st, int tick);      // deprecated
      Segment* findSegment(SegmentType st, int tick) const;     // deprecated
 
      Segment* undoGetSegmentR(SegmentType st, int rtick);
      Segment* getSegmentR(SegmentType st, int rtick);
      Segment* findSegmentR(SegmentType st, int rtick) const;
 
      // preferred:
      Segment* undoGetSegment(SegmentType st, const Fraction& f) { return undoGetSegmentR(st, f.ticks()); }
      Segment* getSegment(SegmentType st, const Fraction& f)     { return getSegmentR(st, f.ticks()); }
 
      Segment* findFirst(SegmentType st, int rtick) const;
 
      qreal createEndBarLines(bool);
      void barLinesSetSpan(Segment*);
      void setEndBarLineType(BarLineType val, int track, bool visible = true, QColor color = QColor());
 
      RepeatMeasure* cmdInsertRepeatMeasure(int staffIdx);
 
      virtual void scanElements(void* data, void (*func)(void*, Element*), bool all=true) override;
      void createVoice(int track);
      void adjustToLen(Fraction, bool appendRestsIfNecessary = true);
 
      AccidentalVal findAccidental(Note*) const;
      AccidentalVal findAccidental(Segment* s, int staffIdx, int line, bool &error) const;
      void exchangeVoice(int voice1, int voice2, int staffIdx);
      void checkMultiVoices(int staffIdx);
      bool hasVoice(int track) const;
      bool isMeasureRest(int staffIdx) const;
      bool isFullMeasureRest() const;
      bool isRepeatMeasure(Staff* staff) const;
      bool visible(int staffIdx) const;
      bool slashStyle(int staffIdx) const;
      bool isFinalMeasureOfSection() const;
      bool isAnacrusis() const;
 
      bool breakMultiMeasureRest() const        { return _breakMultiMeasureRest; }
      void setBreakMultiMeasureRest(bool val)   { _breakMultiMeasureRest = val;  }
 
      bool empty() const;
      bool isOnlyRests(int track) const;
      bool isOnlyDeletedRests(int track) const;
 
      int playbackCount() const      { return _playbackCount; }
      void setPlaybackCount(int val) { _playbackCount = val; }
      QRectF staffabbox(int staffIdx) const;
 
      virtual QVariant getProperty(P_ID propertyId) const override;
      virtual bool setProperty(P_ID propertyId, const QVariant&) override;
      virtual QVariant propertyDefault(P_ID) const override;
 
      bool hasMMRest() const        { return _mmRest != 0; }
      bool isMMRest() const         { return _mmRestCount > 0; }
      Measure* mmRest() const       { return _mmRest;      }
      const Measure* mmRest1() const;
      void setMMRest(Measure* m)    { _mmRest = m;         }
      int mmRestCount() const       { return _mmRestCount; }    // number of measures _mmRest spans
      void setMMRestCount(int n)    { _mmRestCount = n;    }
      Measure* mmRestFirst() const;
      Measure* mmRestLast() const;
 
      Element* nextElementStaff(int staff);
      Element* prevElementStaff(int staff);
      virtual QString accessibleInfo() const override;
 
      void addSystemHeader(bool firstSystem);
      void addSystemTrailer(Measure* nm);
      void removeSystemHeader();
      void removeSystemTrailer();
 
      const BarLine* endBarLine() const;
      BarLineType endBarLineType() const;
      bool endBarLineVisible() const;
      virtual void triggerLayout() const override;
      qreal basicStretch() const;
      qreal basicWidth() const;
      virtual void computeMinWidth();
      void checkHeader();
      void checkTrailer();
      void setStretchedWidth(qreal);
      void layoutStaffLines();
      };
 
}     // namespace Ms
#endif
 

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