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
|
//=============================================================================
// 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 __CLEF_H__
#define __CLEF_H__
/**
\file
Definition of classes Clef
*/
#include "element.h"
#include "mscore.h"
namespace Ms {
class XmlWriter;
class MuseScoreView;
class Segment;
static const int NO_CLEF = -1000;
//---------------------------------------------------------
// ClefType
//---------------------------------------------------------
enum class ClefType : signed char {
INVALID = -1,
G = 0,
G15_MB,
G8_VB,
G8_VA,
G15_MA,
G8_VB_O,
G8_VB_P,
G_1,
C1,
C2,
C3,
C4,
C5,
C_19C,
C3_F18C,
C4_F18C,
C3_F20C,
C4_F20C,
F,
F15_MB,
F8_VB,
F_8VA,
F_15MA,
F_B,
F_C,
F_F18C,
F_19C,
PERC,
PERC2,
TAB,
TAB4,
TAB_SERIF,
TAB4_SERIF,
MAX
};
//---------------------------------------------------------
// ClefTypeList
//---------------------------------------------------------
struct ClefTypeList {
ClefType _concertClef = ClefType::G;
ClefType _transposingClef = ClefType::G;
ClefTypeList() {}
ClefTypeList(ClefType a, ClefType b) : _concertClef(a), _transposingClef(b) {}
ClefTypeList(ClefType a) : _concertClef(a), _transposingClef(a) {}
bool operator==(const ClefTypeList& t) const;
bool operator!=(const ClefTypeList& t) const;
};
//---------------------------------------------------------
// ClefInfo
/// Info about a clef.
//---------------------------------------------------------
class ClefInfo {
public:
static const ClefInfo clefTable[];
const char* _tag; ///< comprehensive name for instruments.xml
const char* _sign; ///< Name for musicXml.
int _line; ///< Line for musicXml and for positioning on the staff
int _octChng; ///< Octave change for musicXml.
int _pitchOffset; ///< Pitch offset for line 0.
signed char _lines[14];
SymId _symId;
const char* _name;
StaffGroup _staffGroup;
public:
static const char* tag(ClefType t) { return clefTable[int(t)]._tag; }
static const char* sign(ClefType t) { return clefTable[int(t)]._sign; }
static int line(ClefType t) { return clefTable[int(t)]._line; }
static int octChng(ClefType t) { return clefTable[int(t)]._octChng; }
static int pitchOffset(ClefType t) { return clefTable[int(t)]._pitchOffset; }
static SymId symId(ClefType t) { return clefTable[int(t)]._symId; }
static const signed char* lines(ClefType t) { return clefTable[int(t)]._lines; }
static const char* name(ClefType t) { return clefTable[int(t)]._name; }
static StaffGroup staffGroup(ClefType t) { return clefTable[int(t)]._staffGroup; }
static ClefType tag2type(const QString&);
};
//---------------------------------------------------------
// @@ Clef
/// Graphic representation of a clef.
//
// @P showCourtesy bool show/hide courtesy clef when applicable
// @P small bool small, mid-staff clef (read only, set by layout)
//---------------------------------------------------------
class Clef final : public Element {
SymId symId;
bool _showCourtesy = true;
bool _small = false;
ClefTypeList _clefTypes { ClefType::INVALID };
public:
Clef(Score*);
virtual Clef* clone() const { return new Clef(*this); }
virtual ElementType type() const { return ElementType::CLEF; }
virtual qreal mag() const;
Segment* segment() const { return (Segment*)parent(); }
Measure* measure() const { return (Measure*)parent()->parent(); }
virtual bool acceptDrop(EditData&) const override;
virtual Element* drop(EditData&);
virtual void layout();
virtual void draw(QPainter*) const;
virtual void read(XmlReader&);
virtual void write(XmlWriter&) const;
virtual bool isEditable() const { return false; }
bool small() const { return _small; }
void setSmall(bool val);
bool showCourtesy() const { return _showCourtesy; }
void setShowCourtesy(bool v) { _showCourtesy = v; }
void undoSetShowCourtesy(bool v);
Clef* otherClef();
static ClefType clefType(const QString& s);
const char* clefTypeName();
ClefType clefType() const;
void setClefType(ClefType i);
void setClefType(const QString& s);
ClefTypeList clefTypeList() const { return _clefTypes; }
ClefType concertClef() const { return _clefTypes._concertClef; }
ClefType transposingClef() const { return _clefTypes._transposingClef; }
void setConcertClef(ClefType val);
void setTransposingClef(ClefType val);
void setClefType(const ClefTypeList& ctl) { _clefTypes = ctl; }
virtual void spatiumChanged(qreal oldValue, qreal newValue) override;
QVariant getProperty(Pid propertyId) const;
bool setProperty(Pid propertyId, const QVariant&);
QVariant propertyDefault(Pid id) const;
virtual Element* nextSegmentElement() override;
virtual Element* prevSegmentElement() override;
QString accessibleInfo() const override;
void clear();
};
} // namespace Ms
#endif
|
