1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
|
//=============================================================================
// 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 __SEGMENT_H__
#define __SEGMENT_H__
#include "element.h"
#include "shape.h"
#include "mscore.h"
namespace Ms {
class Measure;
class Segment;
class ChordRest;
class Spanner;
class System;
//------------------------------------------------------------------------
// @@ Segment
// A segment holds all vertical aligned staff elements.
// Segments are typed and contain only Elements of the same type.
//
// All Elements in a segment start at the same tick. The Segment can store one Element for
// each voice in each staff in the score.
// Some elements (Clef, KeySig, TimeSig etc.) are assumed to always have voice zero
// and can be found in _elist[staffIdx * VOICES];
// Segments are children of Measures and store Clefs, KeySigs, TimeSigs,
// BarLines and ChordRests.
//
// @P annotations array[Element] the list of annotations (read only)
// @P next Segment the next segment in the whole score; null at last score segment (read-only)
// @P nextInMeasure Segment the next segment in measure; null at last measure segment (read-only)
// @P prev Segment the previous segment in the whole score; null at first score segment (read-only)
// @P prevInMeasure Segment the previous segment in measure; null at first measure segment (read-only)
// @P segmentType enum (Segment.All, .Ambitus, .BarLine, .Breath, .ChordRest, .Clef, .EndBarLine, .Invalid, .KeySig, .KeySigAnnounce, .StartRepeatBarLine, .TimeSig, .TimeSigAnnounce)
// @P tick int midi tick position (read only)
//------------------------------------------------------------------------
class Segment final : public Element {
SegmentType _segmentType { SegmentType::Invalid };
Fraction _tick; // { Fraction(0, 1) };
Fraction _ticks; // { Fraction(0, 1) };
Spatium _extraLeadingSpace;
qreal _stretch;
Segment* _next; // linked list of segments inside a measure
Segment* _prev;
std::vector<Element*> _annotations;
std::vector<Element*> _elist; // Element storage, size = staves * VOICES.
std::vector<Shape> _shapes; // size = staves
std::vector<qreal> _dotPosX; // size = staves
void init();
void checkEmpty() const;
void checkElement(Element*, int track);
void setEmpty(bool val) const { setFlag(ElementFlag::EMPTY, val); }
protected:
Element* getElement(int staff); //??
public:
Segment(Measure* m = 0);
Segment(Measure*, SegmentType, const Fraction&);
Segment(const Segment&);
~Segment();
virtual Segment* clone() const { return new Segment(*this); }
virtual ElementType type() const { return ElementType::SEGMENT; }
virtual void setScore(Score*) override;
Segment* next() const { return _next; }
Segment* next(SegmentType) const;
Segment* nextActive() const;
Segment* nextEnabled() const;
void setNext(Segment* e) { _next = e; }
Segment* prev() const { return _prev; }
Segment* prev(SegmentType) const;
Segment* prevActive() const;
Segment* prevEnabled() const;
void setPrev(Segment* e) { _prev = e; }
// don’t stop at measure boundary:
Segment* next1() const;
Segment* next1enabled() const;
Segment* next1MM() const;
Segment* next1MMenabled() const;
Segment* next1(SegmentType) const;
Segment* next1MM(SegmentType) const;
Segment* prev1() const;
Segment* prev1enabled() const;
Segment* prev1MM() const;
Segment* prev1MMenabled() const;
Segment* prev1(SegmentType) const;
Segment* prev1MM(SegmentType) const;
Segment* nextCR(int track = -1, bool sameStaff = false) const;
ChordRest* nextChordRest(int track, bool backwards = false) const;
Element* element(int track) const { return _elist[track]; }
// a variant of the above function, specifically designed to be called from QML
//@ returns the element at track 'track' (null if none)
Ms::Element* elementAt(int track) const;
const std::vector<Element*>& elist() const { return _elist; }
std::vector<Element*>& elist() { return _elist; }
void removeElement(int track);
void setElement(int track, Element* el);
virtual void scanElements(void* data, void (*func)(void*, Element*), bool all=true);
Measure* measure() const { return toMeasure(parent()); }
System* system() const { return toSystem(parent()->parent()); }
qreal x() const { return ipos().x(); }
void setX(qreal v) { rxpos() = v; }
void insertStaff(int staff);
void removeStaff(int staff);
virtual void add(Element*);
virtual void remove(Element*);
void swapElements(int i1, int i2);
void sortStaves(QList<int>& dst);
const char* subTypeName() const;
static const char* subTypeName(SegmentType);
static SegmentType segmentType(ElementType type);
SegmentType segmentType() const { return _segmentType; }
void setSegmentType(SegmentType t);
bool empty() const { return flag(ElementFlag::EMPTY); }
bool written() const { return flag(ElementFlag::WRITTEN); }
void setWritten(bool val) const { setFlag(ElementFlag::WRITTEN, val); }
void fixStaffIdx();
qreal stretch() const { return _stretch; }
void setStretch(qreal v) { _stretch = v; }
virtual Fraction rtick() const override { return _tick; }
void setRtick(const Fraction& v) { Q_ASSERT(v >= Fraction(0,1)); _tick = v; }
virtual Fraction tick() const override;
Fraction ticks() const { return _ticks; }
void setTicks(const Fraction& v) { _ticks = v; }
bool splitsTuplet() const;
const std::vector<Element*>& annotations() const { return _annotations; }
void clearAnnotations();
void removeAnnotation(Element* e);
bool hasAnnotationOrElement(ElementType type, int minTrack, int maxTrack) const;
Element* findAnnotation(ElementType type, int minTrack, int maxTrack);
std::vector<Element*> findAnnotations(ElementType type, int minTrack, int maxTrack);
bool hasElements() const;
qreal dotPosX(int staffIdx) const { return _dotPosX[staffIdx]; }
void setDotPosX(int staffIdx, qreal val) { _dotPosX[staffIdx] = val; }
Spatium extraLeadingSpace() const { return _extraLeadingSpace; }
void setExtraLeadingSpace(Spatium v) { _extraLeadingSpace = v; }
virtual void write(XmlWriter&) const;
virtual void read(XmlReader&);
virtual QVariant getProperty(Pid propertyId) const;
virtual bool setProperty(Pid propertyId, const QVariant&);
virtual QVariant propertyDefault(Pid) const;
bool operator<(const Segment&) const;
bool operator>(const Segment&) const;
virtual QString accessibleExtraInfo() const override;
Element* firstInNextSegments(int activeStaff); //<
Element* lastInPrevSegments(int activeStaff); //<
Element* firstElement(int staff); //< These methods are used for navigation
Element* lastElement(int staff); //< for next-element and prev-element
Element* firstElementOfSegment(Segment* s, int activeStaff);
Element* nextElementOfSegment(Segment* s, Element* e, int activeStaff);
Element* prevElementOfSegment(Segment* s, Element* e, int activeStaff);
Element* lastElementOfSegment(Segment* s, int activeStaff);
Element* nextAnnotation(Element* e);
Element* prevAnnotation(Element* e);
Element* firstAnnotation(Segment* s, int activeStaff);
Element* lastAnnotation(Segment* s, int activeStaff);
Spanner* firstSpanner(int activeStaff);
Spanner* lastSpanner(int activeStaff);
bool notChordRestType(Segment* s);
using Element::nextElement;
Element* nextElement(int activeStaff);
using Element::prevElement;
Element* prevElement(int activeStaff);
std::vector<Shape> shapes() { return _shapes; }
const std::vector<Shape>& shapes() const { return _shapes; }
const Shape& staffShape(int staffIdx) const { return _shapes[staffIdx]; }
Shape& staffShape(int staffIdx) { return _shapes[staffIdx]; }
void createShapes();
void createShape(int staffIdx);
qreal minRight() const;
qreal minLeft(const Shape&) const;
qreal minLeft() const;
qreal minHorizontalDistance(Segment*, bool isSystemGap) const;
qreal minHorizontalCollidingDistance(Segment* ns) const;
// some helper function
ChordRest* cr(int track) const { return toChordRest(_elist[track]); }
bool isType(const SegmentType t) const{ return int(_segmentType) & int(t); }
bool isBeginBarLineType() const { return _segmentType == SegmentType::BeginBarLine; }
bool isClefType() const { return _segmentType == SegmentType::Clef; }
bool isHeaderClefType() const { return _segmentType == SegmentType::HeaderClef; }
bool isKeySigType() const { return _segmentType == SegmentType::KeySig; }
bool isAmbitusType() const { return _segmentType == SegmentType::Ambitus; }
bool isTimeSigType() const { return _segmentType == SegmentType::TimeSig; }
bool isStartRepeatBarLineType() const { return _segmentType == SegmentType::StartRepeatBarLine; }
bool isBarLineType() const { return _segmentType == SegmentType::BarLine; }
bool isBreathType() const { return _segmentType == SegmentType::Breath; }
bool isChordRestType() const { return _segmentType == SegmentType::ChordRest; }
bool isEndBarLineType() const { return _segmentType == SegmentType::EndBarLine; }
bool isKeySigAnnounceType() const { return _segmentType == SegmentType::KeySigAnnounce; }
bool isTimeSigAnnounceType() const { return _segmentType == SegmentType::TimeSigAnnounce; }
};
//---------------------------------------------------------
// nextActive
//---------------------------------------------------------
inline Segment* Segment::nextActive() const
{
Segment* ns = next();
while (ns && !(ns->enabled() && ns->visible()))
ns = ns->next();
return ns;
}
//---------------------------------------------------------
// nextEnabled
//---------------------------------------------------------
inline Segment* Segment::nextEnabled() const
{
Segment* ns = next();
while (ns && !ns->enabled())
ns = ns->next();
return ns;
}
//---------------------------------------------------------
// prevActive
//---------------------------------------------------------
inline Segment* Segment::prevActive() const
{
Segment* ps = prev();
while (ps && !(ps->enabled() && ps->visible()))
ps = ps->prev();
return ps;
}
//---------------------------------------------------------
// prevEnabled
//---------------------------------------------------------
inline Segment* Segment::prevEnabled() const
{
Segment* ps = prev();
while (ps && !ps->enabled())
ps = ps->prev();
return ps;
}
} // namespace Ms
Q_DECLARE_METATYPE(Ms::SegmentType);
#endif
|
