LoweBowe/MuseScore
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

cleanup ElementFlags interface, use more Placement properties on mxml import/export

Browse source
This commit is contained in:
ws 2018-07-04 12:41:03 +02:00
parent bebc557ebf
commit 175d5aadb3
52 changed files with 171 additions and 214 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
libmscore/accidental.cpp
View file

@ -148,9 +148,8 @@ AccidentalVal sym2accidentalVal(SymId id)
//---------------------------------------------------------
Accidental::Accidental(Score* s)
: Element(s)
: Element(s, ElementFlag::MOVABLE)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
}
//---------------------------------------------------------

3
libmscore/ambitus.cpp
View file

@ -39,7 +39,7 @@ static const qreal LINEOFFSET_DEFAULT = 0.8; // the distance
//---------------------------------------------------------
Ambitus::Ambitus(Score* s)
: Element(s), _topAccid(s), _bottomAccid(s)
: Element(s, ElementFlag::MOVABLE), _topAccid(s), _bottomAccid(s)
{
_noteHeadGroup = NOTEHEADGROUP_DEFAULT;
_noteHeadType = NOTEHEADTYPE_DEFAULT;
@ -52,7 +52,6 @@ Ambitus::Ambitus(Score* s)
_bottomTpc = Tpc::TPC_INVALID;
_topAccid.setParent(this);
_bottomAccid.setParent(this);
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
}
//---------------------------------------------------------

3
libmscore/arpeggio.cpp
View file

@ -28,9 +28,8 @@ namespace Ms {
//---------------------------------------------------------
Arpeggio::Arpeggio(Score* s)
: Element(s)
: Element(s, ElementFlag::MOVABLE)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
_arpeggioType = ArpeggioType::NORMAL;
setHeight(spatium() * 4); // for use in palettes
_span = 1;

3
libmscore/articulation.cpp
View file

@ -30,9 +30,8 @@ namespace Ms {
//---------------------------------------------------------
Articulation::Articulation(Score* s)
: Element(s)
: Element(s, ElementFlag::MOVABLE)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
_symId = SymId::noSym;
_anchor = ArticulationAnchor::TOP_STAFF;
_direction = Direction::AUTO;

2
libmscore/beam.cpp
View file

@ -52,7 +52,7 @@ struct BeamFragment {
//---------------------------------------------------------
Beam::Beam(Score* s)
: Element(s, ElementFlag::SELECTABLE)
: Element(s)
{
initSubStyle(SubStyleId::BEAM);
_direction = Direction::AUTO;

3
libmscore/breath.cpp
View file

@ -36,11 +36,10 @@ const std::vector<BreathType> Breath::breathList {
//---------------------------------------------------------
Breath::Breath(Score* s)
: Element(s)
: Element(s, ElementFlag::MOVABLE)
{
_symId = SymId::breathMarkComma;
_pause = 0.0;
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
}
//---------------------------------------------------------

71
libmscore/bsymbol.cpp
View file

@ -14,6 +14,10 @@
#include "image.h"
#include "xml.h"
#include "staff.h"
#include "segment.h"
#include "page.h"
#include "system.h"
#include "measure.h"
namespace Ms {
@ -21,10 +25,9 @@ namespace Ms {
// BSymbol
//---------------------------------------------------------
BSymbol::BSymbol(Score* s)
: Element(s)
BSymbol::BSymbol(Score* s, ElementFlags f)
: Element(s, f)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
_systemFlag = false;
}
@ -196,6 +199,68 @@ QRectF BSymbol::drag(EditData& ed)
return r;
}
//---------------------------------------------------------
// dragAnchor
//---------------------------------------------------------
QLineF BSymbol::dragAnchor() const
{
if (parent() && parent()->type() == ElementType::SEGMENT) {
System* system = segment()->measure()->system();
qreal y = system->staffCanvasYpage(staffIdx());
// QPointF anchor(segment()->pageX(), y);
QPointF anchor(segment()->canvasPos().x(), y);
return QLineF(canvasPos(), anchor);
}
else {
return QLineF(canvasPos(), parent()->canvasPos());
}
}
//---------------------------------------------------------
// pagePos
//---------------------------------------------------------
QPointF BSymbol::pagePos() const
{
if (parent() && (parent()->type() == ElementType::SEGMENT)) {
QPointF p(pos());
System* system = segment()->measure()->system();
if (system) {
p.ry() += system->staff(staffIdx())->y() + system->y();
}
p.rx() = pageX();
return p;
}
else
return Element::pagePos();
}
//---------------------------------------------------------
// canvasPos
//---------------------------------------------------------
QPointF BSymbol::canvasPos() const
{
if (parent() && (parent()->type() == ElementType::SEGMENT)) {
QPointF p(pos());
Segment* s = toSegment(parent());
System* system = s->measure()->system();
if (system) {
int si = staffIdx();
p.ry() += system->staff(si)->y() + system->y();
Page* page = system->page();
if (page)
p.ry() += page->y();
}
p.rx() = canvasX();
return p;
}
else
return Element::canvasPos();
}
}

2
libmscore/bsymbol.h
View file

@ -28,7 +28,7 @@ class BSymbol : public Element, public ElementLayout {
bool _systemFlag;
public:
BSymbol(Score* s);
BSymbol(Score* s, ElementFlags f = ElementFlag::NOTHING);
BSymbol(const BSymbol&);
BSymbol &operator=(const BSymbol&) = delete;

3
libmscore/chord.cpp
View file

@ -215,7 +215,6 @@ Chord::Chord(Score* s)
_playEventType = PlayEventType::Auto;
_crossMeasure = CrossMeasure::UNKNOWN;
_graceIndex = 0;
setFlags(ElementFlag::MOVABLE | ElementFlag::ON_STAFF);
}
Chord::Chord(const Chord& c, bool link)
@ -494,7 +493,7 @@ void Chord::add(Element* e)
Chord* gc = toChord(e);
Q_ASSERT(gc->noteType() != NoteType::NORMAL);
int idx = gc->graceIndex();
gc->setFlags(ElementFlag::MOVABLE);
gc->setFlag(ElementFlag::MOVABLE, true);
_graceNotes.insert(_graceNotes.begin() + idx, gc);
}
break;

3
libmscore/chordline.cpp
View file

@ -31,9 +31,8 @@ const char* scorelineNames[] = {
//---------------------------------------------------------
ChordLine::ChordLine(Score* s)
: Element(s)
: Element(s, ElementFlag::MOVABLE)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
modified = false;
_chordLineType = ChordLineType::NOTYPE;
_straight = false;

4
libmscore/clef.cpp
View file

@ -90,10 +90,8 @@ ClefType ClefInfo::tag2type(const QString& s)
//---------------------------------------------------------
Clef::Clef(Score* s)
: Element(s)
: Element(s, ElementFlag::ON_STAFF)
{
setFlags(ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
_showCourtesy = true;
_small = false;
_clefTypes._concertClef = ClefType::INVALID;

2
libmscore/duration.h
View file

@ -42,7 +42,7 @@ class DurationElement : public Element {
#endif
public:
DurationElement(Score* = 0, ElementFlags = ElementFlag::NOTHING);
DurationElement(Score* = 0, ElementFlags = ElementFlag::MOVABLE | ElementFlag::ON_STAFF);
DurationElement(const DurationElement& e);
~DurationElement();

5
libmscore/dynamic.cpp
View file

@ -80,13 +80,12 @@ static Dyn dynList[] = {
//---------------------------------------------------------
Dynamic::Dynamic(Score* s)
: TextBase(s)
: TextBase(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(SubStyleId::DYNAMICS);
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
_velocity = -1;
_dynRange = Range::PART;
_dynamicType = Type::OTHER;
_dynamicType = Type::OTHER;
}
Dynamic::Dynamic(const Dynamic& d)

3
libmscore/element.cpp
View file

@ -151,7 +151,7 @@ QString Element::subtypeName() const
Element::Element(Score* s, ElementFlags f)
: ScoreElement(s)
{
_flags = f | ElementFlag::ENABLED | ElementFlag::EMPTY | ElementFlag::AUTOPLACE | ElementFlag::SELECTABLE | ElementFlag::VISIBLE;
_flags = f;
_placement = Placement::BELOW;
_track = -1;
_color = MScore::defaultColor;
@ -170,7 +170,6 @@ Element::Element(const Element& e)
_mag = e._mag;
_pos = e._pos;
_userOff = e._userOff;
// _readPos = e._readPos;
_bbox = e._bbox;
_tag = e._tag;
_z = e._z;

29
libmscore/element.h
View file

@ -56,16 +56,15 @@ enum class Grip {
enum class ElementFlag {
NOTHING = 0x00000000,
DROP_TARGET = 0x00000001,
SELECTABLE = 0x00000002,
NOT_SELECTABLE = 0x00000002,
MOVABLE = 0x00000004,
// SEGMENT = 0x00000008,
COMPOSITION = 0x00000008, // true if element is part of another element
HAS_TAG = 0x00000010, // true if this is a layered element
ON_STAFF = 0x00000020,
SELECTED = 0x00000040,
GENERATED = 0x00000080,
VISIBLE = 0x00000100,
AUTOPLACE = 0x00000200,
INVISIBLE = 0x00000100,
NO_AUTOPLACE = 0x00000200,
SYSTEM = 0x00000400,
// measure flags
@ -147,11 +146,7 @@ class EditData {
class Element : public ScoreElement {
Element* _parent { 0 };
mutable ElementFlags _flags {
ElementFlag::ENABLED | ElementFlag::EMPTY | ElementFlag::AUTOPLACE | ElementFlag::SELECTABLE
| ElementFlag::VISIBLE
}; // used for segments
mutable ElementFlags _flags;
Placement _placement;
int _track; ///< staffIdx * VOICES + voice
qreal _mag; ///< standard magnification (derived value)
@ -184,15 +179,12 @@ class Element : public ScoreElement {
inline void setFlag(ElementFlag f, bool v) { if (v) _flags |= f; else _flags &= ~ElementFlags(f); }
inline void setFlag(ElementFlag f, bool v) const { if (v) _flags |= f; else _flags &= ~ElementFlags(f); }
inline bool flag(ElementFlag f) const { return _flags & f; }
inline void setFlags(ElementFlags f) { _flags |= f; }
inline void clearFlags(ElementFlags f) { _flags &= ~f; }
inline ElementFlags flags() const { return _flags; }
bool selected() const { return flag(ElementFlag::SELECTED); }
virtual void setSelected(bool f) { setFlag(ElementFlag::SELECTED, f); }
bool visible() const { return flag(ElementFlag::VISIBLE); }
virtual void setVisible(bool f) { setFlag(ElementFlag::VISIBLE, f); }
bool visible() const { return !flag(ElementFlag::INVISIBLE); }
virtual void setVisible(bool f) { setFlag(ElementFlag::INVISIBLE, !f); }
Placement placement() const { return _placement; }
void setPlacement(Placement val) { _placement = val; }
@ -391,8 +383,8 @@ class Element : public ScoreElement {
bool trailer() const { return flag(ElementFlag::TRAILER); }
void setTrailer(bool val) { setFlag(ElementFlag::TRAILER, val); }
bool selectable() const { return flag(ElementFlag::SELECTABLE); }
void setSelectable(bool val) { setFlag(ElementFlag::SELECTABLE, val); }
bool selectable() const { return !flag(ElementFlag::NOT_SELECTABLE); }
void setSelectable(bool val) { setFlag(ElementFlag::NOT_SELECTABLE, !val); }
bool dropTarget() const { return flag(ElementFlag::DROP_TARGET); }
void setDropTarget(bool v) const { setFlag(ElementFlag::DROP_TARGET, v); }
@ -401,7 +393,6 @@ class Element : public ScoreElement {
void setComposition(bool v) const { setFlag(ElementFlag::COMPOSITION, v); }
virtual bool isMovable() const { return flag(ElementFlag::MOVABLE); }
// bool isSegmentFlag() const { return flag(ElementFlag::SEGMENT); }
bool enabled() const { return flag(ElementFlag::ENABLED); }
void setEnabled(bool val) { setFlag(ElementFlag::ENABLED, val); }
@ -409,8 +400,8 @@ class Element : public ScoreElement {
uint tag() const { return _tag; }
void setTag(uint val) { _tag = val; }
bool autoplace() const { return flag(ElementFlag::AUTOPLACE); }
void setAutoplace(bool v) { setFlag(ElementFlag::AUTOPLACE, v); }
bool autoplace() const { return !flag(ElementFlag::NO_AUTOPLACE); }
void setAutoplace(bool v) { setFlag(ElementFlag::NO_AUTOPLACE, !v); }
virtual QVariant getProperty(Pid) const override;
virtual bool setProperty(Pid, const QVariant&) override;

4
libmscore/fermata.cpp
View file

@ -30,11 +30,9 @@ namespace Ms {
//---------------------------------------------------------
Fermata::Fermata(Score* s)
: Element(s)
: Element(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
setPlacement(Placement::ABOVE);
_symId = SymId::noSym;
_timeStretch = 1.0;
setPlay(true);

3
libmscore/figuredbass.cpp
View file

@ -956,10 +956,9 @@ bool FiguredBassItem::startsWithParenthesis() const
//---------------------------------------------------------
FiguredBass::FiguredBass(Score* s)
: TextBase(s)
: TextBase(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(SubStyleId::FIGURED_BASS);
setFlag(ElementFlag::ON_STAFF, true);
setOnNote(true);
#if 0 // TODO
TextStyle st(

6
libmscore/fingering.cpp
View file

@ -28,14 +28,14 @@ namespace Ms {
// Element(Score* = 0, ElementFlags = ElementFlag::NOTHING);
//---------------------------------------------------------
Fingering::Fingering(SubStyleId ssid, Score* s, ElementFlag ef)
Fingering::Fingering(SubStyleId ssid, Score* s, ElementFlags ef)
: TextBase(s, ef)
{
initSubStyle(ssid);
}
Fingering::Fingering(Score* s)
: Fingering(SubStyleId::FINGERING, s, ElementFlag::HAS_TAG)
Fingering::Fingering(Score* s, ElementFlags ef)
: Fingering(SubStyleId::FINGERING, s, ef)
{
}

4
libmscore/fingering.h
View file

@ -24,8 +24,8 @@ namespace Ms {
class Fingering final : public TextBase {
public:
Fingering(SubStyleId ssid, Score* s, ElementFlag ef = ElementFlag::HAS_TAG);
Fingering(Score* s);
Fingering(SubStyleId ssid, Score* s, ElementFlags ef = ElementFlag::HAS_TAG);
Fingering(Score* s, ElementFlags ef = ElementFlag::HAS_TAG);
virtual Fingering* clone() const override { return new Fingering(*this); }
virtual ElementType type() const override { return ElementType::FINGERING; }

3
libmscore/fret.cpp
View file

@ -31,9 +31,8 @@ namespace Ms {
//---------------------------------------------------------
FretDiagram::FretDiagram(Score* score)
: Element(score)
: Element(score, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::ON_STAFF | ElementFlag::SELECTABLE);
font.setFamily("FreeSans");
font.setPointSize(4.0 * mag());
initSubStyle(SubStyleId::FRET);

4
libmscore/glissando.cpp
View file

@ -258,7 +258,7 @@ Sid GlissandoSegment::getPropertyStyle(Pid id) const
//=========================================================
Glissando::Glissando(Score* s)
: SLine(s, ElementFlag::MOVABLE | ElementFlag::SELECTABLE)
: SLine(s, ElementFlag::MOVABLE)
{
setAnchor(Spanner::Anchor::NOTE);
setDiagonal(true);
@ -294,7 +294,7 @@ Glissando::Glissando(const Glissando& g)
LineSegment* Glissando::createLineSegment()
{
GlissandoSegment* seg = new GlissandoSegment(score());
seg->setFlag(ElementFlag::ON_STAFF, false);
// seg->setFlag(ElementFlag::ON_STAFF, false);
seg->setTrack(track());
seg->setColor(color());
return seg;

2
libmscore/glissando.h
View file

@ -32,7 +32,7 @@ enum class GlissandoType;
class GlissandoSegment final : public LineSegment {
public:
GlissandoSegment(Score* s) : LineSegment(s) {}
GlissandoSegment(Score* s) : LineSegment(s) {}
Glissando* glissando() const { return toGlissando(spanner()); }
virtual ElementType type() const override { return ElementType::GLISSANDO_SEGMENT; }
virtual GlissandoSegment* clone() const override { return new GlissandoSegment(*this); }

3
libmscore/harmony.cpp
View file

@ -138,7 +138,7 @@ qDebug("ResolveDegreeList: not found in table");
//---------------------------------------------------------
Harmony::Harmony(Score* s)
: TextBase(s)
: TextBase(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(SubStyleId::HARMONY);
_rootTpc = Tpc::TPC_INVALID;
@ -149,7 +149,6 @@ Harmony::Harmony(Score* s)
_parsedForm = 0;
_leftParen = false;
_rightParen = false;
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
}
Harmony::Harmony(const Harmony& h)

3
libmscore/hook.cpp
View file

@ -23,9 +23,8 @@ namespace Ms {
//---------------------------------------------------------
Hook::Hook(Score* s)
: Symbol(s)
: Symbol(s, ElementFlag::NOTHING)
{
setFlag(ElementFlag::MOVABLE, false);
setZ(int(type()) * 100);
}

2
libmscore/image.cpp
View file

@ -32,7 +32,7 @@ static bool defaultSizeIsSpatium = true;
//---------------------------------------------------------
Image::Image(Score* s)
: BSymbol(s)
: BSymbol(s, ElementFlag::NOTHING)
{
imageType = ImageType::NONE;
rasterDoc = 0;

3
libmscore/iname.cpp
View file

@ -23,10 +23,9 @@ namespace Ms {
//---------------------------------------------------------
InstrumentName::InstrumentName(Score* s)
: TextBase(s)
: TextBase(s, ElementFlag::NOTHING | ElementFlag::NOT_SELECTABLE)
{
setInstrumentNameType(InstrumentNameType::SHORT);
setSelectable(false);
}
//---------------------------------------------------------

9
libmscore/instrchange.cpp
View file

@ -28,17 +28,18 @@ namespace Ms {
//---------------------------------------------------------
InstrumentChange::InstrumentChange(Score* s)
: TextBase(s, ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF)
: TextBase(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(SubStyleId::INSTRUMENT_CHANGE);
setPlacement(Placement::ABOVE);
_instrument = new Instrument();
}
InstrumentChange::InstrumentChange(const Instrument& i, Score* s)
: TextBase(s)
: TextBase(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(SubStyleId::INSTRUMENT_CHANGE);
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
setPlacement(Placement::ABOVE);
_instrument = new Instrument(i);
}
@ -117,6 +118,8 @@ QVariant InstrumentChange::getProperty(Pid propertyId) const
QVariant InstrumentChange::propertyDefault(Pid propertyId) const
{
switch (propertyId) {
case Pid::PLACEMENT:
return int(Placement::ABOVE);
case Pid::SUB_STYLE:
return int(SubStyleId::INSTRUMENT_CHANGE);
default:

3
libmscore/jump.cpp
View file

@ -40,10 +40,9 @@ int jumpTypeTableSize()
//---------------------------------------------------------
Jump::Jump(Score* s)
: TextBase(s)
: TextBase(s, ElementFlag::MOVABLE)
{
initSubStyle(SubStyleId::REPEAT_RIGHT);
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
setLayoutToParentWidth(true);
_playRepeats = false;
}

3
libmscore/keysig.cpp
View file

@ -47,9 +47,8 @@ const char* keyNames[] = {
//---------------------------------------------------------
KeySig::KeySig(Score* s)
: Element(s)
: Element(s, ElementFlag::ON_STAFF)
{
setFlags(ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
_showCourtesy = true;
_hideNaturals = false;
}

2
libmscore/line.h
View file

@ -41,7 +41,7 @@ class LineSegment : public SpannerSegment {
virtual void startEditDrag(EditData&) override;
public:
LineSegment(Score* s) : SpannerSegment(s) {}
LineSegment(Score* s, ElementFlags f = ElementFlag::NOTHING) : SpannerSegment(s, f) {}
LineSegment(const LineSegment&);
virtual void draw(QPainter*) const = 0;
SLine* line() const { return (SLine*)spanner(); }

8
libmscore/lyrics.cpp
View file

@ -611,10 +611,8 @@ QVariant Lyrics::propertyDefault(Pid id) const
//=========================================================
LyricsLine::LyricsLine(Score* s)
: SLine(s)
: SLine(s, ElementFlag::NOT_SELECTABLE)
{
setFlags(0);
setGenerated(true); // no need to save it, as it can be re-generated
setDiagonal(false);
setLineWidth(Lyrics::LYRICS_DASH_DEFAULT_LINE_THICKNESS * spatium());
@ -777,10 +775,8 @@ bool LyricsLine::setProperty(Pid propertyId, const QVariant& v)
//=========================================================
LyricsLineSegment::LyricsLineSegment(Score* s)
: LineSegment(s)
: LineSegment(s, ElementFlag::ON_STAFF | ElementFlag::NOT_SELECTABLE)
{
setFlags(ElementFlag::ON_STAFF);
clearFlags(ElementFlag::SELECTABLE | ElementFlag::MOVABLE);
setGenerated(true);
}

6
libmscore/marker.cpp
View file

@ -40,20 +40,18 @@ int markerTypeTableSize()
//---------------------------------------------------------
Marker::Marker(Score* s)
: TextBase(s)
: TextBase(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(SubStyleId::REPEAT_LEFT);
_markerType = Type::FINE;
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
setLayoutToParentWidth(true);
}
Marker::Marker(SubStyleId ssid, Score* s)
: TextBase(s)
: TextBase(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(ssid);
_markerType = Type::FINE;
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
setLayoutToParentWidth(true);
}

3
libmscore/note.cpp
View file

@ -541,9 +541,8 @@ NoteHead::Group NoteHead::headGroup() const
//---------------------------------------------------------
Note::Note(Score* s)
: Element(s)
: Element(s, ElementFlag::MOVABLE)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
_playEvents.append(NoteEvent()); // add default play event
_cachedNoteheadSym = SymId::noSym;
_cachedSymNull = SymId::noSym;

16
libmscore/ottava.cpp
View file

@ -31,22 +31,20 @@ namespace Ms {
struct OttavaDefault {
SymId id;
SymId numbersOnlyId;
QPointF offset;
qreal hookDirection;
Placement place;
int shift;
const char* name;
const char* numbersOnlyName;
};
// order is important, should be the same as OttavaType
static const OttavaDefault ottavaDefault[] = {
{ SymId::ottavaAlta, SymId::ottava, QPointF(0.0, .7), 1.0, Placement::ABOVE, 12, "8va", "8" },
{ SymId::ottavaBassaBa, SymId::ottava, QPointF(0.0, -1.0), -1.0, Placement::BELOW, -12, "8vb", "8" },
{ SymId::quindicesimaAlta, SymId::quindicesima, QPointF(0.0, .7), 1.0, Placement::ABOVE, 24, "15ma", "15" },
{ SymId::quindicesimaBassa, SymId::quindicesima, QPointF(0.0, -1.0), -1.0, Placement::BELOW, -24, "15mb", "15" },
{ SymId::ventiduesimaAlta, SymId::ventiduesima, QPointF(0.0, .7), 1.0, Placement::ABOVE, 36, "22ma", "22" },
{ SymId::ventiduesimaBassa, SymId::ventiduesima, QPointF(0.0, -1.0), -1.0, Placement::BELOW, -36, "22mb", "22" }
{ SymId::ottavaAlta, SymId::ottava, 1.0, Placement::ABOVE, 12, "8va" },
{ SymId::ottavaBassaBa, SymId::ottava, -1.0, Placement::BELOW, -12, "8vb" },
{ SymId::quindicesimaAlta, SymId::quindicesima, 1.0, Placement::ABOVE, 24, "15ma" },
{ SymId::quindicesimaBassa, SymId::quindicesima, -1.0, Placement::BELOW, -24, "15mb" },
{ SymId::ventiduesimaAlta, SymId::ventiduesima, 1.0, Placement::ABOVE, 36, "22ma" },
{ SymId::ventiduesimaBassa, SymId::ventiduesima, -1.0, Placement::BELOW, -36, "22mb" }
};
//---------------------------------------------------------
@ -138,7 +136,7 @@ QVariant OttavaSegment::propertyDefault(Pid id) const
//---------------------------------------------------------
Ottava::Ottava(Score* s)
: TextLineBase(s, ElementFlag::ON_STAFF)
: TextLineBase(s, ElementFlag::ON_STAFF | ElementFlag::MOVABLE)
{
_ottavaType = OttavaType::OTTAVA_8VA;
setBeginTextPlace(PlaceText::LEFT);

4
libmscore/page.cpp
View file

@ -37,10 +37,8 @@ namespace Ms {
//---------------------------------------------------------
Page::Page(Score* s)
: Element(s),
_no(0)
: Element(s, ElementFlag::NOT_SELECTABLE), _no(0)
{
setFlags(0);
bspTreeValid = false;
}

3
libmscore/pedal.cpp
View file

@ -162,6 +162,9 @@ QVariant Pedal::propertyDefault(Pid propertyId) const
case Pid::END_HOOK_TYPE:
return int(HookType::NONE);
case Pid::PLACEMENT:
return int(Placement::BELOW);
default:
return TextLineBase::propertyDefault(propertyId);
}

2
libmscore/rest.cpp
View file

@ -39,7 +39,6 @@ namespace Ms {
Rest::Rest(Score* s)
: ChordRest(s)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
_beamMode = Beam::Mode::NONE;
_sym = SymId::restQuarter;
}
@ -47,7 +46,6 @@ Rest::Rest(Score* s)
Rest::Rest(Score* s, const TDuration& d)
: ChordRest(s)
{
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
_beamMode = Beam::Mode::NONE;
_sym = SymId::restQuarter;
setDurationType(d);

4
libmscore/segment.cpp
View file

@ -110,14 +110,14 @@ void Segment::removeElement(int track)
//---------------------------------------------------------
Segment::Segment(Measure* m)
: Element(m->score())
: Element(m->score(), ElementFlag::EMPTY | ElementFlag::ENABLED | ElementFlag::NOT_SELECTABLE)
{
setParent(m);
init();
}
Segment::Segment(Measure* m, SegmentType st, int t)
: Element(m->score())
: Element(m->score(), ElementFlag::EMPTY | ElementFlag::ENABLED | ElementFlag::NOT_SELECTABLE)
{
setParent(m);
_segmentType = st;

6
libmscore/spanner.cpp
View file

@ -26,11 +26,9 @@ namespace Ms {
// SpannerSegment
//---------------------------------------------------------
SpannerSegment::SpannerSegment(Score* s)
: Element(s)
SpannerSegment::SpannerSegment(Score* s, ElementFlags f)
: Element(s, f)
{
// setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::SEGMENT | ElementFlag::ON_STAFF);
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF);
setSpannerSegmentType(SpannerSegmentType::SINGLE);
_spanner = 0;
}

2
libmscore/spanner.h
View file

@ -56,7 +56,7 @@ class SpannerSegment : public Element {
QPointF _userOff2;
public:
SpannerSegment(Score* s);
SpannerSegment(Score* s, ElementFlags f = ElementFlag::ON_STAFF | ElementFlag::MOVABLE);
SpannerSegment(const SpannerSegment&);
virtual SpannerSegment* clone() const = 0;

7
libmscore/stafftext.cpp
View file

@ -23,12 +23,9 @@ namespace Ms {
// StaffTextBase
//---------------------------------------------------------
// : TextBase(s, ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF)
StaffTextBase::StaffTextBase(Score* s, ElementFlags flags)
: TextBase(s, flags)
{
// initSubStyle(ss);
setPlacement(Placement::ABOVE); // default
setSwingParameters(MScore::division / 2, 60);
}
@ -236,13 +233,13 @@ QVariant StaffTextBase::propertyDefault(Pid id) const
//---------------------------------------------------------
StaffText::StaffText(Score* s)
: StaffTextBase(s, ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF)
: StaffTextBase(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(SubStyleId::STAFF);
}
StaffText::StaffText(SubStyleId ss, Score* s)
: StaffTextBase(s, ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF)
: StaffTextBase(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(ss);
}

6
libmscore/stafftype.cpp
View file

@ -856,9 +856,8 @@ qreal StaffType::physStringToYOffset(int strg) const
//---------------------------------------------------------
TabDurationSymbol::TabDurationSymbol(Score* s)
: Element(s)
: Element(s, ElementFlag::NOT_SELECTABLE)
{
clearFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
setGenerated(true);
_beamGrid = TabBeamGrid::NONE;
_beamLength = 0.0;
@ -867,9 +866,8 @@ TabDurationSymbol::TabDurationSymbol(Score* s)
}
TabDurationSymbol::TabDurationSymbol(Score* s, StaffType* tab, TDuration::DurationType type, int dots)
: Element(s)
: Element(s, ElementFlag::NOT_SELECTABLE)
{
clearFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
setGenerated(true);
_beamGrid = TabBeamGrid::NONE;
_beamLength = 0.0;

2
libmscore/stem.cpp
View file

@ -32,7 +32,7 @@ namespace Ms {
//---------------------------------------------------------
Stem::Stem(Score* s)
: Element(s, ElementFlag::SELECTABLE)
: Element(s)
{
initSubStyle(SubStyleId::STEM);
resetProperty(Pid::USER_LEN);

75
libmscore/symbol.cpp
View file

@ -26,8 +26,8 @@ namespace Ms {
// Symbol
//---------------------------------------------------------
Symbol::Symbol(Score* s)
: BSymbol(s)
Symbol::Symbol(Score* s, ElementFlags f)
: BSymbol(s, f)
{
_sym = SymId::accidentalSharp; // arbitrary valid default
}
@ -48,15 +48,6 @@ QString Symbol::symName() const
return Sym::id2name(_sym);
}
//---------------------------------------------------------
// setAbove
//---------------------------------------------------------
void Symbol::setAbove(bool val)
{
setYoff(val ? -2.0 : 7.0);
}
//---------------------------------------------------------
// layout
// height() and width() should return sensible
@ -151,68 +142,6 @@ void Symbol::read(XmlReader& e)
setPos(pos);
}
//---------------------------------------------------------
// dragAnchor
//---------------------------------------------------------
QLineF BSymbol::dragAnchor() const
{
if (parent() && parent()->type() == ElementType::SEGMENT) {
System* system = segment()->measure()->system();
qreal y = system->staffCanvasYpage(staffIdx());
// QPointF anchor(segment()->pageX(), y);
QPointF anchor(segment()->canvasPos().x(), y);
return QLineF(canvasPos(), anchor);
}
else {
return QLineF(canvasPos(), parent()->canvasPos());
}
}
//---------------------------------------------------------
// pagePos
//---------------------------------------------------------
QPointF BSymbol::pagePos() const
{
if (parent() && (parent()->type() == ElementType::SEGMENT)) {
QPointF p(pos());
System* system = segment()->measure()->system();
if (system) {
p.ry() += system->staff(staffIdx())->y() + system->y();
}
p.rx() = pageX();
return p;
}
else
return Element::pagePos();
}
//---------------------------------------------------------
// canvasPos
//---------------------------------------------------------
QPointF BSymbol::canvasPos() const
{
if (parent() && (parent()->type() == ElementType::SEGMENT)) {
QPointF p(pos());
Segment* s = toSegment(parent());
System* system = s->measure()->system();
if (system) {
int si = staffIdx();
p.ry() += system->staff(si)->y() + system->y();
Page* page = system->page();
if (page)
p.ry() += page->y();
}
p.rx() = canvasX();
return p;
}
else
return Element::canvasPos();
}
//---------------------------------------------------------
// FSymbol
//---------------------------------------------------------

3
libmscore/symbol.h
View file

@ -34,7 +34,7 @@ class Symbol : public BSymbol {
const ScoreFont* _scoreFont = nullptr;
public:
Symbol(Score* s);
Symbol(Score* s, ElementFlags f = ElementFlag::MOVABLE);
Symbol(const Symbol&);
Symbol &operator=(const Symbol&) = delete;
@ -50,7 +50,6 @@ class Symbol : public BSymbol {
virtual void write(XmlWriter& xml) const override;
virtual void read(XmlReader&) override;
virtual void layout() override;
void setAbove(bool);
virtual qreal baseLine() const { return 0.0; }
virtual Segment* segment() const { return (Segment*)parent(); }

1
libmscore/textlinebase.cpp
View file

@ -360,6 +360,7 @@ static constexpr std::array<Pid, 34> pids = { {
Pid::END_FONT_ITALIC,
Pid::END_FONT_UNDERLINE,
Pid::END_TEXT_OFFSET,
Pid::PLACEMENT,
} };
//---------------------------------------------------------

2
libmscore/timesig.cpp
View file

@ -32,7 +32,7 @@ namespace Ms {
//---------------------------------------------------------
TimeSig::TimeSig(Score* s)
: Element(s, ElementFlag::SELECTABLE | ElementFlag::ON_STAFF | ElementFlag::MOVABLE)
: Element(s, ElementFlag::ON_STAFF | ElementFlag::MOVABLE)
{
initSubStyle(SubStyleId::TIMESIG);

5
libmscore/tremolo.cpp
View file

@ -9,6 +9,7 @@
// as published by the Free Software Foundation and appearing in
// the file LICENCE.GPL
//=============================================================================
#include "tremolo.h"
#include "score.h"
#include "style.h"
@ -39,12 +40,11 @@ static const char* tremoloName[] = {
};
Tremolo::Tremolo(Score* score)
: Element(score)
: Element(score, ElementFlag::MOVABLE)
{
setTremoloType(TremoloType::R8);
_chord1 = 0;
_chord2 = 0;
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
}
Tremolo::Tremolo(const Tremolo& t)
@ -53,7 +53,6 @@ Tremolo::Tremolo(const Tremolo& t)
setTremoloType(t.tremoloType());
_chord1 = t.chord1();
_chord2 = t.chord2();
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
}
//---------------------------------------------------------

2
libmscore/tremolobar.cpp
View file

@ -25,7 +25,7 @@ namespace Ms {
//---------------------------------------------------------
TremoloBar::TremoloBar(Score* s)
: Element(s, ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF)
: Element(s, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
initSubStyle(SubStyleId::TREMOLO_BAR);
}

2
libmscore/tuplet.cpp
View file

@ -31,7 +31,7 @@ namespace Ms {
//---------------------------------------------------------
Tuplet::Tuplet(Score* s)
: DurationElement(s, ElementFlag::MOVABLE | ElementFlag::SELECTABLE | ElementFlag::ON_STAFF)
: DurationElement(s)
{
_tick = 0;
_ratio = Fraction(1, 1);

19
mscore/exportxml.cpp
View file

@ -3058,9 +3058,9 @@ static void directionTag(XmlWriter& xml, Attributes& attr, Element const* const
*/
if (pel && pel->type() == ElementType::SYSTEM) {
/*
const System* sys = static_cast<const System*>(pel);
QRectF bb = sys->staff(el->staffIdx())->bbox();
/*
qDebug("directionTag() syst=%p sys x=%g y=%g cpx=%g cpy=%g",
sys, sys->pos().x(), sys->pos().y(),
sys->pagePos().x(),
@ -3077,15 +3077,15 @@ static void directionTag(XmlWriter& xml, Attributes& attr, Element const* const
// for the line type elements the reference point is vertically centered
// actual position info is in the segments
// compare the segment's canvas ypos with the staff's center height
if (seg->pagePos().y() < sys->pagePos().y() + bb.y() + bb.height() / 2)
// if (seg->pagePos().y() < sys->pagePos().y() + bb.y() + bb.height() / 2)
if (el->placement() == Placement::ABOVE)
tagname += " placement=\"above\"";
else
tagname += " placement=\"below\"";
}
else if (el->isDynamic()) {
tagname += " placement=\"";
tagname += el->placement() == Placement::ABOVE
? "above" : "below";
tagname += el->placement() == Placement::ABOVE ? "above" : "below";
tagname += "\"";
}
else {
@ -3094,7 +3094,8 @@ static void directionTag(XmlWriter& xml, Attributes& attr, Element const* const
el->y(), el->height(),
bb.y(), bb.height());
*/
if (el->y() + el->height() / 2 < /*bb.y() +*/ bb.height() / 2)
// if (el->y() + el->height() / 2 < /*bb.y() +*/ bb.height() / 2)
if (el->placement() == Placement::ABOVE)
tagname += " placement=\"above\"";
else
tagname += " placement=\"below\"";
@ -3361,7 +3362,7 @@ void ExportMusicXml::tempoText(TempoText const* const text, int staff)
qDebug("ExportMusicXml::tempoText(TempoText='%s')", qPrintable(text->xmlText()));
*/
attr.doAttr(xml, false);
xml.stag(QString("direction placement=\"%1\"").arg((text->parent()->y()-text->y() < 0.0) ? "below" : "above"));
xml.stag(QString("direction placement=\"%1\"").arg((text->placement() ==Placement::BELOW ) ? "below" : "above"));
wordsMetrome(xml, _score, text);
/*
int offs = text->mxmlOff();
@ -3881,7 +3882,8 @@ static void directionJump(XmlWriter& xml, const Jump* const jp)
else
qDebug("jump type=%d not implemented", int(jtp));
if (sound != "") {
xml.stag("direction placement=\"above\"");
// xml.stag("direction placement=\"above\"");
xml.stag(QString("direction placement=\"%1\"").arg((jp->placement() ==Placement::BELOW ) ? "below" : "above"));
xml.stag("direction-type");
QString positioning = "";
positioning += addPositioningAttributes(jp);
@ -3936,7 +3938,8 @@ static void directionMarker(XmlWriter& xml, const Marker* const m)
else
qDebug("marker type=%d not implemented", int(mtp));
if (sound != "") {
xml.stag("direction placement=\"above\"");
// xml.stag("direction placement=\"above\"");
xml.stag(QString("direction placement=\"%1\"").arg((m->placement() ==Placement::BELOW ) ? "below" : "above"));
xml.stag("direction-type");
QString positioning = "";
positioning += addPositioningAttributes(m);

14
mscore/importmxmlpass2.cpp
View file

@ -801,9 +801,10 @@ static void addElemOffset(Element* el, int track, const QString& placement, Meas
el, track, qPrintable(placement), tick);
*/
#if 0 // ws: use placement for symbols
// move to correct position
// TODO: handle rx, ry
if (el->type() == ElementType::SYMBOL) {
if (el->isSymbol()) {
qreal y = 0;
// calc y offset assuming five line staff and default style
// note that required y offset is element type dependent
@ -821,9 +822,10 @@ static void addElemOffset(Element* el, int track, const QString& placement, Meas
el->setUserOff(QPoint(0, y));
}
else {
el->setPlacement(placement == "above"
? Placement::ABOVE : Placement::BELOW);
el->setPlacement(placement == "above" ? Placement::ABOVE : Placement::BELOW);
}
#endif
el->setPlacement(placement == "above" ? Placement::ABOVE : Placement::BELOW);
el->setTrack(track);
Segment* s = measure->getSegment(SegmentType::ChordRest, tick);
@ -1345,6 +1347,7 @@ static void setSLinePlacement(SLine* sli, const QString placement)
sli, sli->type(), sli->score()->spatium(), qPrintable(placement));
*/
#if 0
// calc y offset assuming five line staff and default style
// note that required y offset is element type dependent
if (sli->type() == ElementType::HAIRPIN) {
@ -1363,9 +1366,10 @@ static void setSLinePlacement(SLine* sli, const QString placement)
}
}
else {
sli->setPlacement(placement == "above"
? Placement::ABOVE : Placement::BELOW);
sli->setPlacement(placement == "above" ? Placement::ABOVE : Placement::BELOW);
}
#endif
sli->setPlacement(placement == "above" ? Placement::ABOVE : Placement::BELOW);
}
//---------------------------------------------------------