//=============================================================================
//  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 __TUPLET_H__
#define __TUPLET_H__
 
#include "duration.h"
#include "property.h"
 
namespace Ms {
 
class Text;
class Spanner;
 
//------------------------------------------------------------------------
//   @@ Tuplet
//!     Example of 1/8 triplet:
//!       _baseLen     = 1/8
//!       _actualNotes = 3
//!       _normalNotes = 2     (3 notes played in the time of 2/8)
//!
//!    The tuplet has a  len of _baseLen * _normalNotes.
//!    A tuplet note has len of _baseLen * _normalNotes / _actualNotes.
//------------------------------------------------------------------------
 
class Tuplet : public DurationElement {
      Q_GADGET
 
      // the tick position of a tuplet is the tick position of its
      // first element:
      int _tick;
 
   public:
      enum class NumberType : char { SHOW_NUMBER, SHOW_RELATION, NO_TEXT };
      enum class BracketType : char { AUTO_BRACKET, SHOW_BRACKET, SHOW_NO_BRACKET };
 
   private:
      std::vector<DurationElement*> _elements;
 
      Direction _direction;
      NumberType _numberType;
      BracketType _bracketType;
      PropertyFlags directionStyle  { PropertyFlags::STYLED };
      PropertyFlags numberStyle     { PropertyFlags::STYLED };
      PropertyFlags bracketStyle    { PropertyFlags::STYLED };
 
      bool _hasBracket;
 
      Fraction _ratio;
      TDuration _baseLen;      // 1/8 for a triplet of 1/8
 
      bool _isUp;
 
      QPointF p1, p2;
      QPointF _p1, _p2;       // user offset
      mutable int _id;        // used during read/write
 
      Text* _number;
      QPointF bracketL[4];
      QPointF bracketR[3];
 
   public:
      Tuplet(Score*);
      Tuplet(const Tuplet&);
      ~Tuplet();
      virtual Tuplet* clone() const override      { return new Tuplet(*this); }
      virtual ElementType type() const override { return ElementType::TUPLET; }
      virtual void setTrack(int val) override;
 
      virtual void add(Element*) override;
      virtual void remove(Element*) override;
 
      virtual bool isEditable() const override;
      virtual void startEdit(EditData&) override;
      virtual void editDrag(EditData&) override;
      virtual void updateGrips(EditData&) const override;
 
      virtual void setSelected(bool f) override;
 
      virtual Measure* measure() const override { return (Measure*)parent(); }
 
      NumberType numberType() const        { return _numberType;       }
      BracketType bracketType() const      { return _bracketType;      }
      void setNumberType(NumberType val)   { _numberType = val;        }
      void setBracketType(BracketType val) { _bracketType = val;       }
      bool hasBracket() const              { return _hasBracket;       }
      void setHasBracket(bool b)           { _hasBracket = b;          }
 
      Fraction ratio() const               { return _ratio;         }
      void setRatio(const Fraction& r)     { _ratio = r;            }
 
      const std::vector<DurationElement*>& elements() const { return _elements; }
      void clear()                         { _elements.clear(); }
 
      virtual void layout() override;
      virtual void scanElements(void* data, void (*func)(void*, Element*), bool all=true) override;
      Text* number() const { return _number; }
 
      virtual void read(XmlReader&) override;
      virtual void write(XmlWriter&) const override;
      virtual bool readProperties(XmlReader&) override;
 
      virtual void reset() override;
 
      virtual void draw(QPainter*) const override;
      int id() const                       { return _id;          }
      void setId(int i) const              { _id = i;             }
 
      TDuration baseLen() const            { return _baseLen;     }
      void setBaseLen(const TDuration& d)  { _baseLen = d;        }
 
      virtual void dump() const override;
 
      void setDirection(Direction d)       { _direction = d; }
      Direction direction() const          { return _direction; }
      bool isUp() const                    { return _isUp; }
      virtual int tick() const override    { return _tick; }
      void setTick(int val)                { _tick = val; }
      Fraction elementsDuration();
      void sortElements();
 
      virtual void setVisible(bool f) override;
      virtual QVariant getProperty(P_ID propertyId) const override;
      virtual bool setProperty(P_ID propertyId, const QVariant& v) override;
      virtual QVariant propertyDefault(P_ID id) const override;
      virtual PropertyFlags propertyFlags(P_ID) const override;
      virtual void resetProperty(P_ID id) override;
      virtual void styleChanged() override;
      virtual StyleIdx getPropertyStyle(P_ID) const override;
      virtual void setPropertyFlags(P_ID, PropertyFlags);
 
      void sanitizeTuplet();
      };
 
 
}     // namespace Ms
#endif
 

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