//=============================================================================
//  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 __MEASUREBASE_H__
#define __MEASUREBASE_H__
 
/**
 \file
 Definition of MeasureBase class.
*/
 
#include "element.h"
#include "layoutbreak.h"
 
namespace Ms {
 
class Score;
class System;
class Measure;
 
//---------------------------------------------------------
//   Repeat
//---------------------------------------------------------
 
enum class Repeat : char {
      NONE    = 0,
      END     = 1,
      START   = 2,
      MEASURE = 4,
      JUMP    = 8
      };
 
constexpr Repeat operator| (Repeat t1, Repeat t2) {
      return static_cast<Repeat>(static_cast<int>(t1) | static_cast<int>(t2));
      }
constexpr bool operator& (Repeat t1, Repeat t2) {
      return static_cast<int>(t1) & static_cast<int>(t2);
      }
 
//---------------------------------------------------------
//   @@ MeasureBase
///    Virtual base class for Measure, HBox and VBox
//
//   @P lineBreak       bool        true if a system break is positioned on this measure
//   @P nextMeasure     Measure     the next Measure (read-only)
//   @P nextMeasureMM   Measure     the next multi-measure rest Measure (read-only)
//   @P pageBreak       bool        true if a page break is positioned on this measure
//   @P prevMeasure     Measure     the previous Measure (read-only)
//   @P prevMeasureMM   Measure     the previous multi-measure rest Measure (read-only)
//---------------------------------------------------------
 
class MeasureBase : public Element {
      Q_GADGET
 
      Q_PROPERTY(bool         lineBreak         READ lineBreak   WRITE undoSetLineBreak)
      Q_PROPERTY(Ms::Measure* nextMeasure       READ nextMeasure)
      Q_PROPERTY(Ms::Measure* nextMeasureMM     READ nextMeasureMM)
      Q_PROPERTY(bool         pageBreak         READ pageBreak   WRITE undoSetPageBreak)
      Q_PROPERTY(Ms::Measure* prevMeasure       READ prevMeasure)
      Q_PROPERTY(Ms::Measure* prevMeasureMM     READ prevMeasureMM)
 
      MeasureBase* _next    { 0 };
      MeasureBase* _prev    { 0 };
 
      ElementList _el;                    ///< Measure(/tick) relative -elements: with defined start time
                                          ///< but outside the staff
      int _tick              { 0 };
      int _no                { 0 };       ///< Measure number, counting from zero
      int _noOffset          { 0 };       ///< Offset to measure number
 
   protected:
      void cleanupLayoutBreaks(bool undo);
 
   public:
      MeasureBase(Score* score = 0);
      ~MeasureBase();
      MeasureBase(const MeasureBase&);
 
      virtual MeasureBase* clone() const = 0;
      virtual ElementType type() const = 0;
 
      virtual void setScore(Score* s) override;
 
      MeasureBase* next() const              { return _next;   }
      MeasureBase* nextMM() const;
      void setNext(MeasureBase* e)           { _next = e;      }
      MeasureBase* prev() const              { return _prev;   }
      void setPrev(MeasureBase* e)           { _prev = e;      }
 
      Ms::Measure* nextMeasure() const;
      Ms::Measure* prevMeasure() const;
      Ms::Measure* nextMeasureMM() const;
      Ms::Measure* prevMeasureMM() const;
 
      virtual void write(XmlWriter&) const override = 0;
      virtual void write(XmlWriter&, int, bool, bool) const = 0;
 
      virtual void layout();
 
      virtual void scanElements(void* data, void (*func)(void*, Element*), bool all=true);
      ElementList& el()                      { return _el; }
      const ElementList& el() const          { return _el; }
      System* system() const                 { return (System*)parent(); }
      void setSystem(System* s)              { setParent((Element*)s);   }
 
      LayoutBreak* sectionBreakElement() const;
 
      void undoSetBreak(bool v, LayoutBreak::Type type);
      void undoSetLineBreak(bool v)          {  undoSetBreak(v, LayoutBreak::LINE);}
      void undoSetPageBreak(bool v)          {  undoSetBreak(v, LayoutBreak::PAGE);}
      void undoSetSectionBreak(bool v)       {  undoSetBreak(v, LayoutBreak::SECTION);}
      void undoSetNoBreak(bool v)            {  undoSetBreak(v, LayoutBreak::NOBREAK);}
 
      virtual void moveTicks(int diff)       { setTick(tick() + diff); }
 
      virtual void add(Element*) override;
      virtual void remove(Element*) override;
      virtual void writeProperties(XmlWriter&) const override;
      virtual bool readProperties(XmlReader&) override;
 
      virtual int tick() const override      { return _tick;  }
      virtual int ticks() const              { return 0;      }
      int endTick() const                    { return tick() + ticks();  }
      void setTick(int t)                    { _tick = t;     }
 
      qreal pause() const;
 
      virtual QVariant getProperty(P_ID) const override;
      virtual bool setProperty(P_ID, const QVariant&) override;
      virtual QVariant propertyDefault(P_ID) const override;
 
      void clearElements();
      ElementList takeElements();
 
      int no() const                   { return _no;                     }
      void setNo(int n)                { _no = n;                        }
      int noOffset() const             { return _noOffset;               }
      void setNoOffset(int n)          { _noOffset = n;                  }
 
      bool repeatEnd() const           { return flag(ElementFlag::REPEAT_END);    }
      void setRepeatEnd(bool v)        { setFlag(ElementFlag::REPEAT_END, v);     }
 
      bool repeatStart() const         { return flag(ElementFlag::REPEAT_START);  }
      void setRepeatStart(bool v)      { setFlag(ElementFlag::REPEAT_START, v);   }
 
      bool repeatJump() const          { return flag(ElementFlag::REPEAT_JUMP);   }
      void setRepeatJump(bool v)       { setFlag(ElementFlag::REPEAT_JUMP, v);    }
 
      bool irregular() const           { return flag(ElementFlag::IRREGULAR);     }
      void setIrregular(bool v)        { setFlag(ElementFlag::IRREGULAR, v);      }
 
      bool lineBreak() const           { return flag(ElementFlag::LINE_BREAK);    }
      void setLineBreak(bool v)        { setFlag(ElementFlag::LINE_BREAK, v);     }
 
      bool pageBreak() const           { return flag(ElementFlag::PAGE_BREAK);    }
      void setPageBreak(bool v)        { setFlag(ElementFlag::PAGE_BREAK, v);     }
 
      bool sectionBreak() const        { return flag(ElementFlag::SECTION_BREAK); }
      void setSectionBreak(bool v)     { setFlag(ElementFlag::SECTION_BREAK, v);  }
 
      bool noBreak() const             { return flag(ElementFlag::NO_BREAK);      }
      void setNoBreak(bool v)          { setFlag(ElementFlag::NO_BREAK, v);       }
 
      bool hasCourtesyKeySig() const   { return flag(ElementFlag::KEYSIG);        }
      void setHasCourtesyKeySig(int v) { setFlag(ElementFlag::KEYSIG, v);         }
 
      virtual void computeMinWidth() { };
 
      int index() const;
      };
 
 
}     // namespace Ms
#endif
 

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