replaced QString to String. Step 2
This commit is contained in:
parent
8a3bf7cd5a
commit
b4d15fcf9a
96 changed files with 1032 additions and 912 deletions
|
@ -44,12 +44,12 @@ void PageFormat::read206(XmlReader& e)
|
|||
{
|
||||
qreal _oddRightMargin = 0.0;
|
||||
qreal _evenRightMargin = 0.0;
|
||||
QString type;
|
||||
AsciiStringView type;
|
||||
|
||||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "page-margins") {
|
||||
type = e.attribute("type", "both");
|
||||
type = e.asciiAttribute("type", "both");
|
||||
qreal lm = 0.0, rm = 0.0, tm = 0.0, bm = 0.0;
|
||||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView t(e.name());
|
||||
|
|
|
@ -472,9 +472,9 @@ ByteArray MscReader::XmlFileReader::fileData(const QString& fileName) const
|
|||
continue;
|
||||
}
|
||||
|
||||
QString cdata = xml.readElementText();
|
||||
QByteArray ba = cdata.trimmed().toUtf8();
|
||||
return ByteArray(reinterpret_cast<const uint8_t*>(ba.constData()), ba.size());
|
||||
String cdata = xml.readText();
|
||||
ByteArray ba = cdata.trimmed().toUtf8();
|
||||
return ba;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -265,9 +265,9 @@ void Accidental::read(XmlReader& e)
|
|||
_bracket = AccidentalBracket(i);
|
||||
}
|
||||
} else if (tag == "subtype") {
|
||||
setSubtype(e.readElementAsciiText());
|
||||
setSubtype(e.readAsciiText());
|
||||
} else if (tag == "role") {
|
||||
_role = TConv::fromXml(e.readElementAsciiText(), AccidentalRole::AUTO);
|
||||
_role = TConv::fromXml(e.readAsciiText(), AccidentalRole::AUTO);
|
||||
} else if (tag == "small") {
|
||||
m_isSmall = e.readInt();
|
||||
} else if (EngravingItem::readProperties(e)) {
|
||||
|
|
|
@ -90,7 +90,7 @@ void ActionIcon::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "action") {
|
||||
m_actionCode = e.readElementText().toStdString();
|
||||
m_actionCode = e.readText().toStdString();
|
||||
} else if (tag == "subtype") {
|
||||
m_actionType = static_cast<ActionIconType>(e.readInt());
|
||||
} else {
|
||||
|
|
|
@ -139,7 +139,7 @@ bool Articulation::readProperties(XmlReader& e)
|
|||
const AsciiStringView tag(e.name());
|
||||
|
||||
if (tag == "subtype") {
|
||||
AsciiStringView s = e.readElementAsciiText();
|
||||
AsciiStringView s = e.readAsciiText();
|
||||
SymId id = SymNames::symIdByName(s);
|
||||
if (id == SymId::noSym) {
|
||||
id = compat::Read206::articulationNames2SymId206(s); // compatibility hack for "old" 3.0 scores
|
||||
|
@ -451,7 +451,7 @@ Articulation::AnchorGroup Articulation::anchorGroup(SymId symId)
|
|||
// symId2ArticulationName
|
||||
//---------------------------------------------------------
|
||||
|
||||
const char* Articulation::symId2ArticulationName(SymId symId)
|
||||
String Articulation::symId2ArticulationName(SymId symId)
|
||||
{
|
||||
switch (symId) {
|
||||
case SymId::articStaccatissimoAbove:
|
||||
|
@ -460,58 +460,58 @@ const char* Articulation::symId2ArticulationName(SymId symId)
|
|||
case SymId::articStaccatissimoStrokeBelow:
|
||||
case SymId::articStaccatissimoWedgeAbove:
|
||||
case SymId::articStaccatissimoWedgeBelow:
|
||||
return "staccatissimo";
|
||||
return u"staccatissimo";
|
||||
|
||||
case SymId::articStaccatoAbove:
|
||||
case SymId::articStaccatoBelow:
|
||||
return "staccato";
|
||||
return u"staccato";
|
||||
|
||||
case SymId::articAccentStaccatoAbove:
|
||||
case SymId::articAccentStaccatoBelow:
|
||||
return "sforzatoStaccato";
|
||||
return u"sforzatoStaccato";
|
||||
|
||||
case SymId::articMarcatoStaccatoAbove:
|
||||
case SymId::articMarcatoStaccatoBelow:
|
||||
return "marcatoStaccato";
|
||||
return u"marcatoStaccato";
|
||||
|
||||
case SymId::articTenutoStaccatoAbove:
|
||||
case SymId::articTenutoStaccatoBelow:
|
||||
return "portato";
|
||||
return u"portato";
|
||||
|
||||
case SymId::articTenutoAccentAbove:
|
||||
case SymId::articTenutoAccentBelow:
|
||||
return "sforzatoTenuto";
|
||||
return u"sforzatoTenuto";
|
||||
|
||||
case SymId::articMarcatoTenutoAbove:
|
||||
case SymId::articMarcatoTenutoBelow:
|
||||
return "marcatoTenuto";
|
||||
return u"marcatoTenuto";
|
||||
|
||||
case SymId::articTenutoAbove:
|
||||
case SymId::articTenutoBelow:
|
||||
return "tenuto";
|
||||
return u"tenuto";
|
||||
|
||||
case SymId::articMarcatoAbove:
|
||||
case SymId::articMarcatoBelow:
|
||||
return "marcato";
|
||||
return u"marcato";
|
||||
|
||||
case SymId::articAccentAbove:
|
||||
case SymId::articAccentBelow:
|
||||
return "sforzato";
|
||||
return u"sforzato";
|
||||
|
||||
case SymId::brassMuteOpen:
|
||||
return "open";
|
||||
return u"open";
|
||||
|
||||
case SymId::brassMuteClosed:
|
||||
return "closed";
|
||||
return u"closed";
|
||||
|
||||
case SymId::stringsHarmonic:
|
||||
return "harmonic";
|
||||
return u"harmonic";
|
||||
|
||||
case SymId::ornamentMordent:
|
||||
return "mordent";
|
||||
return u"mordent";
|
||||
|
||||
default:
|
||||
return "---";
|
||||
return u"---";
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -531,7 +531,7 @@ Pid Articulation::propertyId(const QStringRef& xmlName) const
|
|||
// articulationName
|
||||
//---------------------------------------------------------
|
||||
|
||||
const char* Articulation::articulationName() const
|
||||
String Articulation::articulationName() const
|
||||
{
|
||||
return symId2ArticulationName(_symId);
|
||||
}
|
||||
|
|
|
@ -118,8 +118,8 @@ public:
|
|||
void setSymId(SymId id);
|
||||
int subtype() const override;
|
||||
QString typeUserName() const override;
|
||||
const char* articulationName() const; // type-name of articulation; used for midi rendering
|
||||
static const char* symId2ArticulationName(SymId symId);
|
||||
String articulationName() const; // type-name of articulation; used for midi rendering
|
||||
static String symId2ArticulationName(SymId symId);
|
||||
|
||||
void layout() override;
|
||||
bool layoutCloseToNote() const;
|
||||
|
|
|
@ -42,7 +42,7 @@ void Audio::read(XmlReader& e)
|
|||
{
|
||||
while (e.readNextStartElement()) {
|
||||
if (e.name() == "path") {
|
||||
_path = e.readElementText();
|
||||
_path = e.readText();
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
|
|
@ -20,11 +20,11 @@
|
|||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef __AUDIO_H__
|
||||
#define __AUDIO_H__
|
||||
#ifndef MU_ENGRAVING_AUDIO_H
|
||||
#define MU_ENGRAVING_AUDIO_H
|
||||
|
||||
#include <QString>
|
||||
#include "types/bytearray.h"
|
||||
#include "types/string.h"
|
||||
|
||||
namespace mu::engraving {
|
||||
class XmlWriter;
|
||||
|
@ -36,19 +36,19 @@ class XmlReader;
|
|||
|
||||
class Audio
|
||||
{
|
||||
QString _path;
|
||||
mu::ByteArray _data;
|
||||
String _path;
|
||||
ByteArray _data;
|
||||
|
||||
public:
|
||||
Audio();
|
||||
const QString& path() const { return _path; }
|
||||
void setPath(const QString& s) { _path = s; }
|
||||
const mu::ByteArray& data() const { return _data; }
|
||||
mu::ByteArray data() { return _data; }
|
||||
void setData(const mu::ByteArray& ba) { _data = ba; }
|
||||
const String& path() const { return _path; }
|
||||
void setPath(const String& s) { _path = s; }
|
||||
const ByteArray& data() const { return _data; }
|
||||
ByteArray data() { return _data; }
|
||||
void setData(const ByteArray& ba) { _data = ba; }
|
||||
|
||||
void read(XmlReader&);
|
||||
void write(XmlWriter&) const;
|
||||
};
|
||||
} // namespace mu::engraving
|
||||
#endif
|
||||
#endif // MU_ENGRAVING_AUDIO_H
|
||||
|
|
|
@ -811,7 +811,7 @@ void BarLine::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
setBarLineType(TConv::fromXml(e.readElementAsciiText(), BarLineType::NORMAL));
|
||||
setBarLineType(TConv::fromXml(e.readAsciiText(), BarLineType::NORMAL));
|
||||
} else if (tag == "span") {
|
||||
_spanStaff = e.readBool();
|
||||
} else if (tag == "spanFromOffset") {
|
||||
|
|
|
@ -25,6 +25,7 @@
|
|||
#include "draw/brush.h"
|
||||
#include "style/style.h"
|
||||
#include "rw/xml.h"
|
||||
#include "types/typesconv.h"
|
||||
|
||||
#include "factory.h"
|
||||
#include "utils.h"
|
||||
|
@ -560,27 +561,6 @@ void Bracket::setSelected(bool f)
|
|||
EngravingItem::setSelected(f);
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Bracket::bracketTypeName
|
||||
//---------------------------------------------------------
|
||||
|
||||
const char* Bracket::bracketTypeName(BracketType type)
|
||||
{
|
||||
switch (type) {
|
||||
case BracketType::BRACE:
|
||||
return "Brace";
|
||||
case BracketType::NORMAL:
|
||||
return "Normal";
|
||||
case BracketType::SQUARE:
|
||||
return "Square";
|
||||
case BracketType::LINE:
|
||||
return "Line";
|
||||
case BracketType::NO_BRACKET:
|
||||
return "NoBracket";
|
||||
}
|
||||
Q_UNREACHABLE();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Bracket::write
|
||||
// used only for palettes
|
||||
|
@ -594,8 +574,7 @@ void Bracket::write(XmlWriter& xml) const
|
|||
case BracketType::SQUARE:
|
||||
case BracketType::LINE:
|
||||
{
|
||||
const char* type = bracketTypeName(_bi->bracketType());
|
||||
xml.startElement(this, { { "type", type } });
|
||||
xml.startElement(this, { { "type", TConv::toXml(_bi->bracketType()) } });
|
||||
isStartTag = true;
|
||||
}
|
||||
break;
|
||||
|
@ -625,22 +604,8 @@ void Bracket::write(XmlWriter& xml) const
|
|||
|
||||
void Bracket::read(XmlReader& e)
|
||||
{
|
||||
QString t(e.attribute("type", "Normal"));
|
||||
_bi = Factory::createBracketItem(score()->dummy());
|
||||
|
||||
if (t == "Normal") {
|
||||
_bi->setBracketType(BracketType::NORMAL);
|
||||
} else if (t == "Akkolade") { //compatibility, not used anymore
|
||||
_bi->setBracketType(BracketType::BRACE);
|
||||
} else if (t == "Brace") {
|
||||
_bi->setBracketType(BracketType::BRACE);
|
||||
} else if (t == "Square") {
|
||||
_bi->setBracketType(BracketType::SQUARE);
|
||||
} else if (t == "Line") {
|
||||
_bi->setBracketType(BracketType::LINE);
|
||||
} else {
|
||||
LOGD("unknown brace type <%s>", qPrintable(t));
|
||||
}
|
||||
_bi->setBracketType(TConv::fromXml(e.asciiAttribute("type"), BracketType::NORMAL));
|
||||
|
||||
while (e.readNextStartElement()) {
|
||||
if (e.name() == "level") {
|
||||
|
|
|
@ -67,7 +67,6 @@ public:
|
|||
BracketItem* bracketItem() const { return _bi; }
|
||||
|
||||
BracketType bracketType() const { return _bi->bracketType(); }
|
||||
static const char* bracketTypeName(BracketType type);
|
||||
|
||||
size_t firstStaff() const { return _firstStaff; }
|
||||
size_t lastStaff() const { return _lastStaff; }
|
||||
|
|
|
@ -131,7 +131,7 @@ void Breath::read(XmlReader& e)
|
|||
break;
|
||||
}
|
||||
} else if (tag == "symbol") {
|
||||
_symId = SymNames::symIdByName(e.readElementAsciiText());
|
||||
_symId = SymNames::symIdByName(e.readAsciiText());
|
||||
} else if (tag == "pause") {
|
||||
_pause = e.readDouble();
|
||||
} else if (!EngravingItem::readProperties(e)) {
|
||||
|
|
|
@ -334,10 +334,10 @@ void HChord::add(const std::vector<HDegree>& degreeList)
|
|||
// readRenderList
|
||||
//---------------------------------------------------------
|
||||
|
||||
static void readRenderList(QString val, std::list<RenderAction>& renderList)
|
||||
static void readRenderList(String val, std::list<RenderAction>& renderList)
|
||||
{
|
||||
renderList.clear();
|
||||
QStringList sl = val.split(" ", Qt::SkipEmptyParts);
|
||||
QStringList sl = val.toQString().split(" ", Qt::SkipEmptyParts);
|
||||
for (const QString& s : qAsConst(sl)) {
|
||||
if (s.startsWith("m:")) {
|
||||
QStringList ssl = s.split(":", Qt::SkipEmptyParts);
|
||||
|
@ -422,9 +422,9 @@ void ChordToken::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "name") {
|
||||
names += e.readElementText();
|
||||
names << e.readText().toQString();
|
||||
} else if (tag == "render") {
|
||||
readRenderList(e.readElementText(), renderList);
|
||||
readRenderList(e.readText().toQString(), renderList);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1603,17 +1603,17 @@ void ChordDescription::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "name") {
|
||||
QString n = e.readElementText();
|
||||
String n = e.readText();
|
||||
// stack names for this file on top of the list
|
||||
names.insert(ni++, n);
|
||||
names.insert(ni++, n.toQString());
|
||||
} else if (tag == "xml") {
|
||||
xmlKind = e.readElementText();
|
||||
xmlKind = e.readText().toQString();
|
||||
} else if (tag == "degree") {
|
||||
xmlDegrees.append(e.readElementText());
|
||||
xmlDegrees.append(e.readText().toQString());
|
||||
} else if (tag == "voicing") {
|
||||
chord = HChord(e.readElementText());
|
||||
chord = HChord(e.readText().toQString());
|
||||
} else if (tag == "render") {
|
||||
readRenderList(e.readElementText(), renderList);
|
||||
readRenderList(e.readText(), renderList);
|
||||
renderListGenerated = false;
|
||||
} else {
|
||||
e.unknown();
|
||||
|
@ -1677,9 +1677,9 @@ void ChordList::read(XmlReader& e)
|
|||
const AsciiStringView tag(e.name());
|
||||
if (tag == "font") {
|
||||
ChordFont f;
|
||||
f.family = e.attribute("family", "default");
|
||||
if (f.family == "MuseJazz") {
|
||||
f.family = "MuseJazz Text";
|
||||
f.family = e.attribute("family", u"default");
|
||||
if (f.family == u"MuseJazz") {
|
||||
f.family = u"MuseJazz Text";
|
||||
}
|
||||
f.mag = 1.0;
|
||||
f.fontClass = e.attribute("class");
|
||||
|
@ -1762,11 +1762,11 @@ void ChordList::read(XmlReader& e)
|
|||
// add to list
|
||||
insert({ id, cd });
|
||||
} else if (tag == "renderRoot") {
|
||||
readRenderList(e.readElementText(), renderListRoot);
|
||||
readRenderList(e.readText(), renderListRoot);
|
||||
} else if (tag == "renderFunction") {
|
||||
readRenderList(e.readElementText(), renderListFunction);
|
||||
readRenderList(e.readText(), renderListFunction);
|
||||
} else if (tag == "renderBase") {
|
||||
readRenderList(e.readElementText(), renderListBase);
|
||||
readRenderList(e.readText(), renderListBase);
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
|
|
@ -251,8 +251,8 @@ struct ChordSymbol {
|
|||
//---------------------------------------------------------
|
||||
|
||||
struct ChordFont {
|
||||
QString family;
|
||||
QString fontClass;
|
||||
String family;
|
||||
String fontClass;
|
||||
qreal mag;
|
||||
};
|
||||
|
||||
|
|
|
@ -209,7 +209,7 @@ bool ChordRest::readProperties(XmlReader& e)
|
|||
const AsciiStringView tag(e.name());
|
||||
|
||||
if (tag == "durationType") {
|
||||
setDurationType(TConv::fromXml(e.readElementAsciiText(), DurationType::V_QUARTER));
|
||||
setDurationType(TConv::fromXml(e.readAsciiText(), DurationType::V_QUARTER));
|
||||
if (actualDurationType().type() != DurationType::V_MEASURE) {
|
||||
if (score()->mscVersion() < 112 && (type() == ElementType::REST)
|
||||
&& // for backward compatibility, convert V_WHOLE rests to V_MEASURE
|
||||
|
@ -234,7 +234,7 @@ bool ChordRest::readProperties(XmlReader& e)
|
|||
}
|
||||
}
|
||||
} else if (tag == "BeamMode") {
|
||||
_beamMode = TConv::fromXml(e.readElementAsciiText(), BeamMode::AUTO);
|
||||
_beamMode = TConv::fromXml(e.readAsciiText(), BeamMode::AUTO);
|
||||
} else if (tag == "Articulation") {
|
||||
Articulation* atr = Factory::createArticulation(this);
|
||||
atr->setTrack(track());
|
||||
|
|
|
@ -299,9 +299,9 @@ void Clef::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "concertClefType") {
|
||||
_clefTypes._concertClef = TConv::fromXml(e.readElementAsciiText(), ClefType::G);
|
||||
_clefTypes._concertClef = TConv::fromXml(e.readAsciiText(), ClefType::G);
|
||||
} else if (tag == "transposingClefType") {
|
||||
_clefTypes._transposingClef = TConv::fromXml(e.readElementAsciiText(), ClefType::G);
|
||||
_clefTypes._transposingClef = TConv::fromXml(e.readAsciiText(), ClefType::G);
|
||||
} else if (tag == "showCourtesyClef") {
|
||||
_showCourtesy = e.readInt();
|
||||
} else if (tag == "forInstrumentChange") {
|
||||
|
|
|
@ -89,11 +89,11 @@ void Drumset::save(XmlWriter& xml) const
|
|||
xml.startElement("variants");
|
||||
for (const auto& v : qAsConst(vs)) {
|
||||
xml.startElement("variant", { { "pitch", v.pitch } });
|
||||
if (!v.articulationName.isEmpty()) {
|
||||
if (!v.articulationName.empty()) {
|
||||
xml.tag("articulation", v.articulationName);
|
||||
}
|
||||
if (v.tremolo != TremoloType::INVALID_TREMOLO) {
|
||||
xml.tag("tremolo", Tremolo::type2name(v.tremolo));
|
||||
xml.tag("tremolo", TConv::toXml(v.tremolo));
|
||||
}
|
||||
xml.endElement();
|
||||
}
|
||||
|
@ -111,7 +111,7 @@ bool Drumset::readProperties(XmlReader& e, int pitch)
|
|||
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "head") {
|
||||
_drum[pitch].notehead = TConv::fromXml(e.readElementAsciiText(), NoteHeadGroup::HEAD_NORMAL);
|
||||
_drum[pitch].notehead = TConv::fromXml(e.readAsciiText(), NoteHeadGroup::HEAD_NORMAL);
|
||||
} else if (tag == "noteheads") {
|
||||
_drum[pitch].notehead = NoteHeadGroup::HEAD_CUSTOM;
|
||||
while (e.readNextStartElement()) {
|
||||
|
@ -121,21 +121,21 @@ bool Drumset::readProperties(XmlReader& e, int pitch)
|
|||
return false;
|
||||
}
|
||||
|
||||
_drum[pitch].noteheads[noteType] = SymNames::symIdByName(e.readElementAsciiText());
|
||||
_drum[pitch].noteheads[noteType] = SymNames::symIdByName(e.readAsciiText());
|
||||
}
|
||||
} else if (tag == "line") {
|
||||
_drum[pitch].line = e.readInt();
|
||||
} else if (tag == "voice") {
|
||||
_drum[pitch].voice = e.readInt();
|
||||
} else if (tag == "name") {
|
||||
_drum[pitch].name = e.readElementText();
|
||||
_drum[pitch].name = e.readText();
|
||||
} else if (tag == "stem") {
|
||||
_drum[pitch].stemDirection = DirectionV(e.readInt());
|
||||
} else if (tag == "shortcut") {
|
||||
bool isNum;
|
||||
QString val(e.readElementText());
|
||||
AsciiStringView val = e.readAsciiText();
|
||||
int i = val.toInt(&isNum);
|
||||
_drum[pitch].shortcut = isNum ? i : toupper(val[0].toLatin1());
|
||||
_drum[pitch].shortcut = isNum ? i : val.at(0).toUpper();
|
||||
} else if (tag == "variants") {
|
||||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tagv(e.name());
|
||||
|
@ -145,9 +145,9 @@ bool Drumset::readProperties(XmlReader& e, int pitch)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView taga(e.name());
|
||||
if (taga == "articulation") {
|
||||
div.articulationName = e.readElementText();
|
||||
div.articulationName = e.readText();
|
||||
} else if (taga == "tremolo") {
|
||||
div.tremolo = Tremolo::name2Type(e.readElementText());
|
||||
div.tremolo = TConv::fromXml(e.readAsciiText(), TremoloType::INVALID_TREMOLO);
|
||||
}
|
||||
}
|
||||
_drum[pitch].addVariant(div);
|
||||
|
@ -241,7 +241,7 @@ DrumInstrumentVariant Drumset::findVariant(int p, const std::vector<Articulation
|
|||
auto vs = variants(p);
|
||||
for (const auto& v : vs) {
|
||||
bool matchTremolo = (!tremolo && v.tremolo == TremoloType::INVALID_TREMOLO) || (tremolo && v.tremolo == tremolo->tremoloType());
|
||||
bool matchArticulation = v.articulationName.isEmpty() && articulations.empty();
|
||||
bool matchArticulation = v.articulationName.empty() && articulations.empty();
|
||||
for (auto a : articulations) {
|
||||
matchArticulation = a->articulationName() == v.articulationName;
|
||||
if (!matchArticulation) {
|
||||
|
|
|
@ -31,15 +31,9 @@ namespace mu::engraving {
|
|||
class XmlWriter;
|
||||
|
||||
struct DrumInstrumentVariant {
|
||||
int pitch;
|
||||
QString articulationName;
|
||||
TremoloType tremolo;
|
||||
DrumInstrumentVariant()
|
||||
{
|
||||
pitch = INVALID_PITCH;
|
||||
tremolo = TremoloType::INVALID_TREMOLO;
|
||||
articulationName = "";
|
||||
}
|
||||
int pitch = INVALID_PITCH;
|
||||
TremoloType tremolo = TremoloType::INVALID_TREMOLO;
|
||||
String articulationName;
|
||||
};
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
@ -47,7 +41,7 @@ struct DrumInstrumentVariant {
|
|||
//---------------------------------------------------------
|
||||
|
||||
struct DrumInstrument {
|
||||
QString name;
|
||||
String name;
|
||||
|
||||
// if notehead = HEAD_CUSTOM, custom, use noteheads
|
||||
NoteHeadGroup notehead = NoteHeadGroup::HEAD_INVALID; ///< notehead symbol set
|
||||
|
@ -81,13 +75,13 @@ class Drumset
|
|||
DrumInstrument _drum[DRUM_INSTRUMENTS];
|
||||
|
||||
public:
|
||||
bool isValid(int pitch) const { return !_drum[pitch].name.isEmpty(); }
|
||||
bool isValid(int pitch) const { return !_drum[pitch].name.empty(); }
|
||||
NoteHeadGroup noteHead(int pitch) const { return _drum[pitch].notehead; }
|
||||
SymId noteHeads(int pitch, NoteHeadType t) const { return _drum[pitch].noteheads[int(t)]; }
|
||||
int line(int pitch) const { return _drum[pitch].line; }
|
||||
int voice(int pitch) const { return _drum[pitch].voice; }
|
||||
DirectionV stemDirection(int pitch) const { return _drum[pitch].stemDirection; }
|
||||
const QString& name(int pitch) const { return _drum[pitch].name; }
|
||||
const String& name(int pitch) const { return _drum[pitch].name; }
|
||||
int shortcut(int pitch) const { return _drum[pitch].shortcut; }
|
||||
std::list<DrumInstrumentVariant> variants(int pitch) const { return _drum[pitch].variants; }
|
||||
|
||||
|
|
|
@ -257,15 +257,15 @@ void Dynamic::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag = e.name();
|
||||
if (tag == "subtype") {
|
||||
setDynamicType(e.readElementText());
|
||||
setDynamicType(e.readText().toQString());
|
||||
} else if (tag == "velocity") {
|
||||
_velocity = e.readInt();
|
||||
} else if (tag == "dynType") {
|
||||
_dynRange = TConv::fromXml(e.readElementAsciiText(), DynamicRange::STAFF);
|
||||
_dynRange = TConv::fromXml(e.readAsciiText(), DynamicRange::STAFF);
|
||||
} else if (tag == "veloChange") {
|
||||
_changeInVelocity = e.readInt();
|
||||
} else if (tag == "veloChangeSpeed") {
|
||||
_velChangeSpeed = TConv::fromXml(e.readElementAsciiText(), DynamicSpeed::NORMAL);
|
||||
_velChangeSpeed = TConv::fromXml(e.readAsciiText(), DynamicSpeed::NORMAL);
|
||||
} else if (!TextBase::readProperties(e)) {
|
||||
e.unknown();
|
||||
}
|
||||
|
|
|
@ -996,7 +996,7 @@ bool EngravingItem::readProperties(XmlReader& e)
|
|||
const AsciiStringView ntag(e.name());
|
||||
|
||||
if (ntag == "score") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
if (val == "same") {
|
||||
linkedIsMaster = score()->isMaster();
|
||||
}
|
||||
|
@ -1064,7 +1064,7 @@ bool EngravingItem::readProperties(XmlReader& e)
|
|||
} else if (tag == "voice") {
|
||||
setVoice(e.readInt());
|
||||
} else if (tag == "tag") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
for (int i = 1; i < MAX_TAGS; i++) {
|
||||
if (score()->layerTags()[i] == val) {
|
||||
_tag = 1 << i;
|
||||
|
|
|
@ -215,7 +215,7 @@ void Excerpt::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag = e.name();
|
||||
if (tag == "name" || tag == "title") {
|
||||
m_name = e.readElementText().trimmed();
|
||||
m_name = e.readText().trimmed();
|
||||
} else if (tag == "part") {
|
||||
size_t partIdx = static_cast<size_t>(e.readInt());
|
||||
if (partIdx >= pl.size()) {
|
||||
|
@ -305,12 +305,12 @@ void Excerpt::createExcerpt(Excerpt* excerpt)
|
|||
|
||||
VBox* titleFramePart = toVBox(measure);
|
||||
titleFramePart->copyValues(titleFrameScore);
|
||||
QString partLabel = excerpt->name();
|
||||
if (!partLabel.isEmpty()) {
|
||||
String partLabel = excerpt->name();
|
||||
if (!partLabel.empty()) {
|
||||
Text* txt = Factory::createText(measure, TextStyleType::INSTRUMENT_EXCERPT);
|
||||
txt->setPlainText(partLabel);
|
||||
measure->add(txt);
|
||||
score->setMetaTag("partName", partLabel);
|
||||
score->setMetaTag("partName", partLabel.toQString());
|
||||
}
|
||||
|
||||
// initial layout of score
|
||||
|
@ -1450,12 +1450,13 @@ QString Excerpt::formatName(const QString& partName, const std::vector<Excerpt*>
|
|||
|
||||
for (Excerpt* e : excerptList) {
|
||||
// if <partName> already exists, change <partName> to <partName 1>
|
||||
if (e->name().compare(name) == 0) {
|
||||
e->setName(e->name() + " 1");
|
||||
QString excName = e->name().toQString();
|
||||
if (excName.compare(name) == 0) {
|
||||
e->setName(excName + " 1");
|
||||
}
|
||||
|
||||
QRegularExpression regex("^(.+)\\s\\d+$");
|
||||
QRegularExpressionMatch match = regex.match(e->name());
|
||||
QRegularExpressionMatch match = regex.match(excName);
|
||||
if (match.hasMatch() && match.capturedTexts()[1] == name) {
|
||||
count++;
|
||||
}
|
||||
|
|
|
@ -27,6 +27,7 @@
|
|||
|
||||
#include "types/fraction.h"
|
||||
#include "types/types.h"
|
||||
#include "types/string.h"
|
||||
#include "mscore.h"
|
||||
|
||||
namespace mu::engraving {
|
||||
|
@ -49,7 +50,7 @@ public:
|
|||
Score* excerptScore() const { return m_excerptScore; }
|
||||
void setExcerptScore(Score* s);
|
||||
|
||||
QString name() const { return m_name; }
|
||||
String name() const { return m_name; }
|
||||
void setName(const QString& title) { m_name = title; }
|
||||
|
||||
std::vector<Part*>& parts() { return m_parts; }
|
||||
|
@ -90,7 +91,7 @@ private:
|
|||
|
||||
MasterScore* m_masterScore = nullptr;
|
||||
Score* m_excerptScore = nullptr;
|
||||
QString m_name;
|
||||
String m_name;
|
||||
std::vector<Part*> m_parts;
|
||||
TracksMap m_tracksMapping;
|
||||
};
|
||||
|
|
|
@ -85,7 +85,7 @@ bool Fermata::readProperties(XmlReader& e)
|
|||
const AsciiStringView tag(e.name());
|
||||
|
||||
if (tag == "subtype") {
|
||||
AsciiStringView s = e.readElementAsciiText();
|
||||
AsciiStringView s = e.readAsciiText();
|
||||
SymId id = SymNames::symIdByName(s);
|
||||
setSymId(id);
|
||||
} else if (tag == "play") {
|
||||
|
|
|
@ -514,7 +514,7 @@ void FiguredBassItem::layout()
|
|||
f.setPointSizeF(m);
|
||||
mu::draw::FontMetrics fm(f);
|
||||
|
||||
QString str;
|
||||
String str;
|
||||
x = symWidth(SymId::noteheadBlack) * .5;
|
||||
x1 = x2 = 0.0;
|
||||
|
||||
|
@ -556,7 +556,7 @@ void FiguredBassItem::layout()
|
|||
}
|
||||
// if several digits or no shape combination, convert _digit to font styled chars
|
||||
else {
|
||||
QString digits = QString();
|
||||
String digits;
|
||||
int digit = _digit;
|
||||
while (true) {
|
||||
digits.prepend(g_FBFonts.at(font).displayDigit[style][(digit % 10)][0]);
|
||||
|
@ -681,7 +681,7 @@ void FiguredBassItem::draw(mu::draw::Painter* painter) const
|
|||
if (parenth[4] != Parenthesis::NONE) {
|
||||
int x = lineEndX > 0.0 ? lineEndX : textWidth;
|
||||
painter->drawText(RectF(x, 0, bbox().width(), bbox().height()), Qt::AlignLeft | Qt::AlignTop,
|
||||
g_FBFonts.at(font).displayParenthesis[int(parenth[4])]);
|
||||
QChar(g_FBFonts.at(font).displayParenthesis[int(parenth[4])].unicode()));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1586,37 +1586,37 @@ bool FiguredBassFont::read(XmlReader& e)
|
|||
const AsciiStringView tag(e.name());
|
||||
|
||||
if (tag == "family") {
|
||||
family = e.readElementText();
|
||||
family = e.readText();
|
||||
} else if (tag == "displayName") {
|
||||
displayName = e.readElementText();
|
||||
displayName = e.readText();
|
||||
} else if (tag == "defaultPitch") {
|
||||
defPitch = e.readDouble();
|
||||
} else if (tag == "defaultLineHeight") {
|
||||
defLineHeight = e.readDouble();
|
||||
} else if (tag == "parenthesisRoundOpen") {
|
||||
displayParenthesis[1] = e.readElementText()[0];
|
||||
displayParenthesis[1] = e.readText().at(0);
|
||||
} else if (tag == "parenthesisRoundClosed") {
|
||||
displayParenthesis[2] = e.readElementText()[0];
|
||||
displayParenthesis[2] = e.readText().at(0);
|
||||
} else if (tag == "parenthesisSquareOpen") {
|
||||
displayParenthesis[3] = e.readElementText()[0];
|
||||
displayParenthesis[3] = e.readText().at(0);
|
||||
} else if (tag == "parenthesisSquareClosed") {
|
||||
displayParenthesis[4] = e.readElementText()[0];
|
||||
displayParenthesis[4] = e.readText().at(0);
|
||||
} else if (tag == "doubleflat") {
|
||||
displayAccidental[int(FiguredBassItem::Modifier::DOUBLEFLAT)]= e.readElementText()[0];
|
||||
displayAccidental[int(FiguredBassItem::Modifier::DOUBLEFLAT)]= e.readText().at(0);
|
||||
} else if (tag == "flat") {
|
||||
displayAccidental[int(FiguredBassItem::Modifier::FLAT)] = e.readElementText()[0];
|
||||
displayAccidental[int(FiguredBassItem::Modifier::FLAT)] = e.readText().at(0);
|
||||
} else if (tag == "natural") {
|
||||
displayAccidental[int(FiguredBassItem::Modifier::NATURAL)] = e.readElementText()[0];
|
||||
displayAccidental[int(FiguredBassItem::Modifier::NATURAL)] = e.readText().at(0);
|
||||
} else if (tag == "sharp") {
|
||||
displayAccidental[int(FiguredBassItem::Modifier::SHARP)] = e.readElementText()[0];
|
||||
displayAccidental[int(FiguredBassItem::Modifier::SHARP)] = e.readText().at(0);
|
||||
} else if (tag == "doublesharp") {
|
||||
displayAccidental[int(FiguredBassItem::Modifier::DOUBLESHARP)]= e.readElementText()[0];
|
||||
displayAccidental[int(FiguredBassItem::Modifier::DOUBLESHARP)]= e.readText().at(0);
|
||||
} else if (tag == "cross") {
|
||||
displayAccidental[int(FiguredBassItem::Modifier::CROSS)] = e.readElementText()[0];
|
||||
displayAccidental[int(FiguredBassItem::Modifier::CROSS)] = e.readText().at(0);
|
||||
} else if (tag == "backslash") {
|
||||
displayAccidental[int(FiguredBassItem::Modifier::BACKSLASH)] = e.readElementText()[0];
|
||||
displayAccidental[int(FiguredBassItem::Modifier::BACKSLASH)] = e.readText().at(0);
|
||||
} else if (tag == "slash") {
|
||||
displayAccidental[int(FiguredBassItem::Modifier::SLASH)] = e.readElementText()[0];
|
||||
displayAccidental[int(FiguredBassItem::Modifier::SLASH)] = e.readText().at(0);
|
||||
} else if (tag == "digit") {
|
||||
int digit = e.intAttribute("value");
|
||||
if (digit < 0 || digit > 9) {
|
||||
|
@ -1626,28 +1626,28 @@ bool FiguredBassFont::read(XmlReader& e)
|
|||
const AsciiStringView t(e.name());
|
||||
if (t == "simple") {
|
||||
displayDigit[int(FiguredBassItem::Style::MODERN)] [digit][int(FiguredBassItem::Combination::SIMPLE)]
|
||||
= e.readElementText()[0];
|
||||
= e.readText().at(0);
|
||||
} else if (t == "crossed") {
|
||||
displayDigit[int(FiguredBassItem::Style::MODERN)] [digit][int(FiguredBassItem::Combination::CROSSED)]
|
||||
= e.readElementText()[0];
|
||||
= e.readText().at(0);
|
||||
} else if (t == "backslashed") {
|
||||
displayDigit[int(FiguredBassItem::Style::MODERN)] [digit][int(FiguredBassItem::Combination::BACKSLASHED)]
|
||||
= e.readElementText()[0];
|
||||
= e.readText().at(0);
|
||||
} else if (t == "slashed") {
|
||||
displayDigit[int(FiguredBassItem::Style::MODERN)] [digit][int(FiguredBassItem::Combination::SLASHED)]
|
||||
= e.readElementText()[0];
|
||||
= e.readText().at(0);
|
||||
} else if (t == "simpleHistoric") {
|
||||
displayDigit[int(FiguredBassItem::Style::HISTORIC)][digit][int(FiguredBassItem::Combination::SIMPLE)]
|
||||
= e.readElementText()[0];
|
||||
= e.readText().at(0);
|
||||
} else if (t == "crossedHistoric") {
|
||||
displayDigit[int(FiguredBassItem::Style::HISTORIC)][digit][int(FiguredBassItem::Combination::CROSSED)]
|
||||
= e.readElementText()[0];
|
||||
= e.readText().at(0);
|
||||
} else if (t == "backslashedHistoric") {
|
||||
displayDigit[int(FiguredBassItem::Style::HISTORIC)][digit][int(FiguredBassItem::Combination::BACKSLASHED)]
|
||||
= e.readElementText()[0];
|
||||
= e.readText().at(0);
|
||||
} else if (t == "slashedHistoric") {
|
||||
displayDigit[int(FiguredBassItem::Style::HISTORIC)][digit][int(FiguredBassItem::Combination::SLASHED)]
|
||||
= e.readElementText()[0];
|
||||
= e.readText().at(0);
|
||||
} else {
|
||||
e.unknown();
|
||||
return false;
|
||||
|
|
|
@ -224,13 +224,13 @@ public:
|
|||
//---------------------------------------------------------
|
||||
|
||||
struct FiguredBassFont {
|
||||
QString family;
|
||||
QString displayName;
|
||||
String family;
|
||||
String displayName;
|
||||
qreal defPitch;
|
||||
qreal defLineHeight;
|
||||
QChar displayAccidental[int(FiguredBassItem::Modifier::NUMOF)];
|
||||
QChar displayParenthesis[int(FiguredBassItem::Parenthesis::NUMOF)];
|
||||
QChar displayDigit[int(FiguredBassItem::Style::NUMOF)][10][int(FiguredBassItem::Combination::NUMOF)];
|
||||
Char displayAccidental[int(FiguredBassItem::Modifier::NUMOF)];
|
||||
Char displayParenthesis[int(FiguredBassItem::Parenthesis::NUMOF)];
|
||||
Char displayDigit[int(FiguredBassItem::Style::NUMOF)][10][int(FiguredBassItem::Combination::NUMOF)];
|
||||
|
||||
bool read(XmlReader&);
|
||||
};
|
||||
|
|
|
@ -863,13 +863,13 @@ void FretDiagram::readNew(XmlReader& e)
|
|||
const AsciiStringView t(e.name());
|
||||
if (t == "dot") {
|
||||
int fret = e.intAttribute("fret", 0);
|
||||
FretDotType dtype = FretItem::nameToDotType(e.readElementText());
|
||||
FretDotType dtype = FretItem::nameToDotType(e.readText());
|
||||
setDot(no, fret, true, dtype);
|
||||
} else if (t == "marker") {
|
||||
FretMarkerType mtype = FretItem::nameToMarkerType(e.readElementText());
|
||||
FretMarkerType mtype = FretItem::nameToMarkerType(e.readText());
|
||||
setMarker(no, mtype);
|
||||
} else if (t == "fingering") {
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
/*setFingering(no, e.readInt()); NOTE:JT todo */
|
||||
} else {
|
||||
e.unknown();
|
||||
|
|
|
@ -734,7 +734,7 @@ void Hairpin::read(XmlReader& e)
|
|||
} else if (tag == "veloChange") {
|
||||
_veloChange = e.readInt();
|
||||
} else if (tag == "dynType") {
|
||||
_dynRange = TConv::fromXml(e.readElementAsciiText(), DynamicRange::STAFF);
|
||||
_dynRange = TConv::fromXml(e.readAsciiText(), DynamicRange::STAFF);
|
||||
} else if (tag == "useTextLine") { // obsolete
|
||||
e.readInt();
|
||||
if (hairpinType() == HairpinType::CRESC_HAIRPIN) {
|
||||
|
@ -745,7 +745,7 @@ void Hairpin::read(XmlReader& e)
|
|||
} else if (tag == "singleNoteDynamics") {
|
||||
_singleNoteDynamics = e.readBool();
|
||||
} else if (tag == "veloChangeMethod") {
|
||||
_veloChangeMethod = TConv::fromXml(e.readElementAsciiText(), ChangeMethod::NORMAL);
|
||||
_veloChangeMethod = TConv::fromXml(e.readAsciiText(), ChangeMethod::NORMAL);
|
||||
} else if (!TextLineBase::readProperties(e)) {
|
||||
e.unknown();
|
||||
}
|
||||
|
|
|
@ -362,13 +362,13 @@ void Harmony::read(XmlReader& e)
|
|||
} else if (tag == "extension") {
|
||||
setId(e.readInt());
|
||||
} else if (tag == "name") {
|
||||
_textName = e.readElementText();
|
||||
_textName = e.readText();
|
||||
} else if (tag == "root") {
|
||||
setRootTpc(e.readInt());
|
||||
} else if (tag == "rootCase") {
|
||||
_rootCase = static_cast<NoteCaseType>(e.readInt());
|
||||
} else if (tag == "function") {
|
||||
_function = e.readElementText();
|
||||
_function = e.readText();
|
||||
} else if (tag == "degree") {
|
||||
int degreeValue = 0;
|
||||
int degreeAlter = 0;
|
||||
|
@ -380,7 +380,7 @@ void Harmony::read(XmlReader& e)
|
|||
} else if (t == "degree-alter") {
|
||||
degreeAlter = e.readInt();
|
||||
} else if (t == "degree-type") {
|
||||
degreeType = e.readElementText();
|
||||
degreeType = e.readText();
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
|
|
@ -365,9 +365,9 @@ void Image::read(XmlReader& e)
|
|||
// sp if size is spatium
|
||||
_sizeIsSpatium = e.readBool();
|
||||
} else if (tag == "path") {
|
||||
_storePath = e.readElementText();
|
||||
_storePath = e.readText();
|
||||
} else if (tag == "linkPath") {
|
||||
_linkPath = e.readElementText();
|
||||
_linkPath = e.readText();
|
||||
} else if (tag == "subtype") { // obsolete
|
||||
e.skipCurrentElement();
|
||||
} else if (!BSymbol::readProperties(e)) {
|
||||
|
|
|
@ -81,7 +81,7 @@ static InstrumentGenre* searchInstrumentGenre(const QString& genre)
|
|||
// searchInstrumentFamily
|
||||
//---------------------------------------------------------
|
||||
|
||||
static InstrumentFamily* searchInstrumentFamily(const QString& name)
|
||||
static InstrumentFamily* searchInstrumentFamily(const String& name)
|
||||
{
|
||||
for (InstrumentFamily* fam : instrumentFamilies) {
|
||||
if (fam->id == name) {
|
||||
|
@ -153,7 +153,7 @@ static TraitType traitTypeFromString(const QString& str)
|
|||
void InstrumentGroup::read(XmlReader& e)
|
||||
{
|
||||
id = e.attribute("id");
|
||||
name = qtrc("InstrumentsXML", e.attribute("name").toUtf8().data());
|
||||
name = qtrc("InstrumentsXML", e.attribute("name"));
|
||||
extended = e.intAttribute("extended", 0);
|
||||
|
||||
while (e.readNextStartElement()) {
|
||||
|
@ -170,7 +170,7 @@ void InstrumentGroup::read(XmlReader& e)
|
|||
}
|
||||
t->read(e);
|
||||
} else if (tag == "ref") {
|
||||
InstrumentTemplate* ttt = searchTemplate(e.readElementText());
|
||||
InstrumentTemplate* ttt = searchTemplate(e.readText());
|
||||
if (ttt) {
|
||||
InstrumentTemplate* t = new InstrumentTemplate(*ttt);
|
||||
instrumentTemplates.push_back(t);
|
||||
|
@ -178,7 +178,7 @@ void InstrumentGroup::read(XmlReader& e)
|
|||
LOGD("instrument reference not found <%s>", e.text().toUtf8().data());
|
||||
}
|
||||
} else if (tag == "name") {
|
||||
name = qtrc("InstrumentsXML", e.readElementText().toUtf8().data());
|
||||
name = qtrc("InstrumentsXML", e.readAsciiText().ascii());
|
||||
} else if (tag == "extended") {
|
||||
extended = e.readInt();
|
||||
} else {
|
||||
|
@ -435,10 +435,10 @@ void InstrumentTemplate::write1(XmlWriter& xml) const
|
|||
// read
|
||||
//---------------------------------------------------------
|
||||
|
||||
static QString translateInstrumentName(const QString& instrumentId, const QString& nameType, const QString& text)
|
||||
static QString translateInstrumentName(const String& instrumentId, const String& nameType, const String& text)
|
||||
{
|
||||
QString disambiguation = instrumentId + '|' + nameType;
|
||||
return qtrc("InstrumentsXML", text.toUtf8().data(), disambiguation.toUtf8().data());
|
||||
String disambiguation = instrumentId + u'|' + nameType;
|
||||
return qtrc("InstrumentsXML", text, disambiguation);
|
||||
}
|
||||
|
||||
void InstrumentTemplate::read(XmlReader& e)
|
||||
|
@ -456,7 +456,7 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
break;
|
||||
}
|
||||
}
|
||||
longNames.push_back(StaffName(translateInstrumentName(id, "longName", e.readElementText()), pos));
|
||||
longNames.push_back(StaffName(translateInstrumentName(id, u"longName", e.readText()), pos));
|
||||
} else if (tag == "shortName" || tag == "short-name") { // "short-name" is obsolete
|
||||
int pos = e.intAttribute("pos", 0);
|
||||
for (std::list<StaffName>::iterator i = shortNames.begin(); i != shortNames.end(); ++i) {
|
||||
|
@ -465,11 +465,11 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
break;
|
||||
}
|
||||
}
|
||||
shortNames.push_back(StaffName(translateInstrumentName(id, "shortName", e.readElementText()), pos));
|
||||
shortNames.push_back(StaffName(translateInstrumentName(id, u"shortName", e.readText()), pos));
|
||||
} else if (tag == "trackName") {
|
||||
trackName = translateInstrumentName(id, "trackName", e.readElementText());
|
||||
trackName = translateInstrumentName(id, u"trackName", e.readText());
|
||||
} else if (tag == "description") {
|
||||
description = translateInstrumentName(id, "description", e.readElementText());
|
||||
description = translateInstrumentName(id, u"description", e.readText());
|
||||
} else if (tag == "extended") {
|
||||
extended = e.readInt();
|
||||
} else if (tag == "staves") {
|
||||
|
@ -479,15 +479,15 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
// barlineSpan[i] = true;
|
||||
} else if (tag == "clef") { // sets both transposing and concert clef
|
||||
int idx = readStaffIdx(e);
|
||||
ClefType ct = TConv::fromXml(e.readElementAsciiText(), ClefType::G);
|
||||
ClefType ct = TConv::fromXml(e.readAsciiText(), ClefType::G);
|
||||
clefTypes[idx]._concertClef = ct;
|
||||
clefTypes[idx]._transposingClef = ct;
|
||||
} else if (tag == "concertClef") {
|
||||
int idx = readStaffIdx(e);
|
||||
clefTypes[idx]._concertClef = TConv::fromXml(e.readElementAsciiText(), ClefType::G);
|
||||
clefTypes[idx]._concertClef = TConv::fromXml(e.readAsciiText(), ClefType::G);
|
||||
} else if (tag == "transposingClef") {
|
||||
int idx = readStaffIdx(e);
|
||||
clefTypes[idx]._transposingClef = TConv::fromXml(e.readElementAsciiText(), ClefType::G);
|
||||
clefTypes[idx]._transposingClef = TConv::fromXml(e.readAsciiText(), ClefType::G);
|
||||
} else if (tag == "stafflines") {
|
||||
int idx = readStaffIdx(e);
|
||||
staffLines[idx] = e.readInt();
|
||||
|
@ -507,9 +507,9 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
barlineSpan[idx + i] = true;
|
||||
}
|
||||
} else if (tag == "aPitchRange") {
|
||||
setPitchRange(e.readElementText(), &minPitchA, &maxPitchA);
|
||||
setPitchRange(e.readText(), &minPitchA, &maxPitchA);
|
||||
} else if (tag == "pPitchRange") {
|
||||
setPitchRange(e.readElementText(), &minPitchP, &maxPitchP);
|
||||
setPitchRange(e.readText(), &minPitchP, &maxPitchP);
|
||||
} else if (tag == "transposition") { // obsolete
|
||||
int i = e.readInt();
|
||||
transpose.chromatic = i;
|
||||
|
@ -520,7 +520,7 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
transpose.diatonic = e.readInt();
|
||||
} else if (tag == "traitName") {
|
||||
trait.type = traitTypeFromString(e.attribute("type"));
|
||||
QString traitName = translateInstrumentName(id, "traitName", e.readElementText());
|
||||
QString traitName = translateInstrumentName(id, u"traitName", e.readText());
|
||||
trait.isDefault = traitName.contains("*");
|
||||
trait.isHiddenOnScore = traitName.contains("(") && traitName.contains(")");
|
||||
trait.name = traitName.remove("*").remove("(").remove(")");
|
||||
|
@ -560,8 +560,8 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
}
|
||||
} else if (tag == "stafftype") {
|
||||
int staffIdx = readStaffIdx(e);
|
||||
QString xmlPresetName = e.attribute("staffTypePreset", "");
|
||||
QString stfGroup = e.readElementText();
|
||||
QString xmlPresetName = e.attribute("staffTypePreset");
|
||||
QString stfGroup = e.readText();
|
||||
if (stfGroup == "percussion") {
|
||||
staffGroup = StaffGroup::PERCUSSION;
|
||||
} else if (stfGroup == "tablature") {
|
||||
|
@ -580,7 +580,7 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
staffLines[staffIdx] = staffTypePreset->lines();
|
||||
}
|
||||
} else if (tag == "init") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
InstrumentTemplate* ttt = searchTemplate(val);
|
||||
if (ttt) {
|
||||
init(*ttt);
|
||||
|
@ -588,11 +588,11 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
LOGD("InstrumentTemplate:: init instrument <%s> not found", qPrintable(val));
|
||||
}
|
||||
} else if (tag == "musicXMLid") {
|
||||
musicXMLid = e.readElementText();
|
||||
musicXMLid = e.readText();
|
||||
} else if (tag == "family") {
|
||||
family = searchInstrumentFamily(e.readElementText());
|
||||
family = searchInstrumentFamily(e.readText());
|
||||
} else if (tag == "genre") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
linkGenre(val);
|
||||
} else if (tag == "singleNoteDynamics") {
|
||||
singleNoteDynamics = e.readBool();
|
||||
|
@ -618,7 +618,7 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
if (description.isEmpty() && !longNames.empty()) {
|
||||
description = longNames.front().name();
|
||||
}
|
||||
if (id.isEmpty()) {
|
||||
if (id.empty()) {
|
||||
id = trackName.toLower().replace(" ", "-");
|
||||
}
|
||||
|
||||
|
@ -631,16 +631,16 @@ void InstrumentTemplate::read(XmlReader& e)
|
|||
// setPitchRange
|
||||
//---------------------------------------------------------
|
||||
|
||||
void InstrumentTemplate::setPitchRange(const QString& s, char* a, char* b) const
|
||||
void InstrumentTemplate::setPitchRange(const String& s, char* a, char* b) const
|
||||
{
|
||||
QStringList sl = s.split("-");
|
||||
StringList sl = s.split(u'-');
|
||||
if (sl.size() != 2) {
|
||||
*a = 0;
|
||||
*b = 127;
|
||||
return;
|
||||
}
|
||||
*a = sl[0].toInt();
|
||||
*b = sl[1].toInt();
|
||||
*a = sl.at(0).toInt();
|
||||
*b = sl.at(1).toInt();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
@ -727,7 +727,7 @@ bool loadInstrumentTemplates(const QString& instrTemplates)
|
|||
// searchTemplate
|
||||
//---------------------------------------------------------
|
||||
|
||||
InstrumentTemplate* searchTemplate(const QString& name)
|
||||
InstrumentTemplate* searchTemplate(const String& name)
|
||||
{
|
||||
for (InstrumentGroup* g : instrumentGroups) {
|
||||
for (InstrumentTemplate* it : g->instrumentTemplates) {
|
||||
|
@ -817,11 +817,11 @@ InstrumentTemplate* guessTemplateByNameData(const std::list<QString>& nameDataLi
|
|||
|
||||
for (const QString& name : nameDataList) {
|
||||
if (name.contains("drum", Qt::CaseInsensitive)) {
|
||||
return searchTemplate("drumset");
|
||||
return searchTemplate(u"drumset");
|
||||
}
|
||||
|
||||
if (name.contains("piano", Qt::CaseInsensitive)) {
|
||||
return searchTemplate("piano");
|
||||
return searchTemplate(u"piano");
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -852,7 +852,7 @@ InstrumentIndex searchTemplateIndexForTrackName(const QString& trackName)
|
|||
// searchTemplateIndexForId
|
||||
//---------------------------------------------------------
|
||||
|
||||
InstrumentIndex searchTemplateIndexForId(const QString& id)
|
||||
InstrumentIndex searchTemplateIndexForId(const String& id)
|
||||
{
|
||||
int instIndex = 0;
|
||||
int grpIndex = 0;
|
||||
|
@ -901,7 +901,7 @@ void InstrumentGenre::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "name") {
|
||||
name = qtrc("InstrumentsXML", e.readElementText().toUtf8().data());
|
||||
name = qtrc("InstrumentsXML", e.readText());
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -926,7 +926,7 @@ void InstrumentFamily::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "name") {
|
||||
name = qtrc("InstrumentsXML", e.readElementText().toUtf8().data());
|
||||
name = qtrc("InstrumentsXML", e.readText());
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -945,9 +945,9 @@ ClefTypeList InstrumentTemplate::clefType(staff_idx_t staffIdx) const
|
|||
return clefTypes[0];
|
||||
}
|
||||
|
||||
QString InstrumentTemplate::familyId() const
|
||||
String InstrumentTemplate::familyId() const
|
||||
{
|
||||
return family ? family->id : QString();
|
||||
return family ? family->id : String();
|
||||
}
|
||||
|
||||
bool InstrumentTemplate::containsGenre(const QString& genreId) const
|
||||
|
|
|
@ -61,8 +61,8 @@ public:
|
|||
class InstrumentFamily
|
||||
{
|
||||
public:
|
||||
QString id;
|
||||
QString name;
|
||||
String id;
|
||||
String name;
|
||||
|
||||
InstrumentFamily() {}
|
||||
void write(XmlWriter& xml) const;
|
||||
|
@ -82,7 +82,7 @@ public:
|
|||
~InstrumentTemplate();
|
||||
InstrumentTemplate& operator=(const InstrumentTemplate&);
|
||||
|
||||
QString id;
|
||||
String id;
|
||||
QString trackName;
|
||||
StaffNameList longNames; ///< shown on first system
|
||||
StaffNameList shortNames; ///< shown on followup systems
|
||||
|
@ -130,12 +130,12 @@ public:
|
|||
void write1(XmlWriter& xml) const;
|
||||
void read(XmlReader&);
|
||||
ClefTypeList clefType(staff_idx_t staffIdx) const;
|
||||
QString familyId() const;
|
||||
String familyId() const;
|
||||
bool containsGenre(const QString& genreId) const;
|
||||
|
||||
private:
|
||||
void init(const InstrumentTemplate&);
|
||||
void setPitchRange(const QString& s, char* a, char* b) const;
|
||||
void setPitchRange(const String& s, char* a, char* b) const;
|
||||
void linkGenre(const QString&);
|
||||
};
|
||||
|
||||
|
@ -174,9 +174,9 @@ extern std::vector<InstrumentGroup*> instrumentGroups;
|
|||
extern std::vector<ScoreOrder> instrumentOrders;
|
||||
extern void clearInstrumentTemplates();
|
||||
extern bool loadInstrumentTemplates(const QString& instrTemplates);
|
||||
extern InstrumentTemplate* searchTemplate(const QString& name);
|
||||
extern InstrumentTemplate* searchTemplate(const String& name);
|
||||
extern InstrumentIndex searchTemplateIndexForTrackName(const QString& trackName);
|
||||
extern InstrumentIndex searchTemplateIndexForId(const QString& id);
|
||||
extern InstrumentIndex searchTemplateIndexForId(const String& id);
|
||||
extern InstrumentTemplate* searchTemplateForMusicXmlId(const QString& mxmlId);
|
||||
extern InstrumentTemplate* searchTemplateForInstrNameList(const std::list<QString>& nameList);
|
||||
extern InstrumentTemplate* searchTemplateForMidiProgram(int midiProgram, const bool useDrumKit = false);
|
||||
|
|
|
@ -96,7 +96,7 @@ static void midi_event_write(const MidiCoreEvent& e, XmlWriter& xml)
|
|||
void NamedEventList::write(XmlWriter& xml, const AsciiStringView& n) const
|
||||
{
|
||||
xml.startElement(n, { { "name", name } });
|
||||
if (!descr.isEmpty()) {
|
||||
if (!descr.empty()) {
|
||||
xml.tag("descr", descr);
|
||||
}
|
||||
for (const MidiCoreEvent& e : events) {
|
||||
|
@ -126,7 +126,7 @@ void NamedEventList::read(XmlReader& e)
|
|||
events.push_back(ev);
|
||||
e.skipCurrentElement();
|
||||
} else if (tag == "descr") {
|
||||
descr = e.readElementText();
|
||||
descr = e.readText();
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -480,7 +480,7 @@ bool Instrument::readProperties(XmlReader& e, Part* part, bool* customDrumset)
|
|||
name.read(e);
|
||||
_shortNames.push_back(name);
|
||||
} else if (tag == "trackName") {
|
||||
_trackName = e.readElementText();
|
||||
_trackName = e.readText();
|
||||
} else if (tag == "minPitch") { // obsolete
|
||||
_minPitchP = _minPitchA = e.readInt();
|
||||
} else if (tag == "maxPitch") { // obsolete
|
||||
|
@ -501,7 +501,7 @@ bool Instrument::readProperties(XmlReader& e, Part* part, bool* customDrumset)
|
|||
} else if (tag == "transposeDiatonic") {
|
||||
_transpose.diatonic = e.readInt();
|
||||
} else if (tag == "instrumentId") {
|
||||
_instrumentId = e.readElementText();
|
||||
_instrumentId = e.readText();
|
||||
} else if (tag == "useDrumset") {
|
||||
_useDrumset = e.readInt();
|
||||
if (_useDrumset) {
|
||||
|
@ -537,14 +537,14 @@ bool Instrument::readProperties(XmlReader& e, Part* part, bool* customDrumset)
|
|||
_channel.push_back(a);
|
||||
} else if (tag == "clef") { // sets both transposing and concert clef
|
||||
int idx = e.intAttribute("staff", 1) - 1;
|
||||
ClefType ct = TConv::fromXml(e.readElementAsciiText(), ClefType::G);
|
||||
ClefType ct = TConv::fromXml(e.readAsciiText(), ClefType::G);
|
||||
setClefType(idx, ClefTypeList(ct, ct));
|
||||
} else if (tag == "concertClef") {
|
||||
int idx = e.intAttribute("staff", 1) - 1;
|
||||
setClefType(idx, ClefTypeList(TConv::fromXml(e.readElementAsciiText(), ClefType::G), clefType(idx)._transposingClef));
|
||||
setClefType(idx, ClefTypeList(TConv::fromXml(e.readAsciiText(), ClefType::G), clefType(idx)._transposingClef));
|
||||
} else if (tag == "transposingClef") {
|
||||
int idx = e.intAttribute("staff", 1) - 1;
|
||||
setClefType(idx, ClefTypeList(clefType(idx)._concertClef, TConv::fromXml(e.readElementAsciiText(), ClefType::G)));
|
||||
setClefType(idx, ClefTypeList(clefType(idx)._concertClef, TConv::fromXml(e.readAsciiText(), ClefType::G)));
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
@ -938,9 +938,9 @@ void InstrChannel::read(XmlReader& e, Part* part)
|
|||
a.read(e);
|
||||
midiActions.push_back(a);
|
||||
} else if (tag == "synti") {
|
||||
_synti = e.readElementText();
|
||||
_synti = e.readText();
|
||||
} else if (tag == "descr") {
|
||||
_descr = e.readElementText();
|
||||
_descr = e.readText();
|
||||
} else if (tag == "color") {
|
||||
_color = e.readInt();
|
||||
} else if (tag == "mute") {
|
||||
|
@ -1259,19 +1259,19 @@ void MidiArticulation::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "velocity") {
|
||||
QString text(e.readElementText());
|
||||
QString text(e.readText());
|
||||
if (text.endsWith("%")) {
|
||||
text = text.left(text.size() - 1);
|
||||
}
|
||||
velocity = text.toInt();
|
||||
} else if (tag == "gateTime") {
|
||||
QString text(e.readElementText());
|
||||
QString text(e.readText());
|
||||
if (text.endsWith("%")) {
|
||||
text = text.left(text.size() - 1);
|
||||
}
|
||||
gateTime = text.toInt();
|
||||
} else if (tag == "descr") {
|
||||
descr = e.readElementText();
|
||||
descr = e.readText();
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -1791,7 +1791,7 @@ void Instrument::updateInstrumentId()
|
|||
if (bestMatchStrength == perfectMatchStrength) {
|
||||
break; // stop looking for matches
|
||||
}
|
||||
} else if ((matchStrength == bestMatchStrength) && (it->id.length() < fallback.length())) {
|
||||
} else if ((matchStrength == bestMatchStrength) && (it->id.size() < fallback.size())) {
|
||||
// Update fallback ID because we've found a shorter one that is equally good.
|
||||
// Shorter IDs tend to correspond to more generic instruments (e.g. "piano"
|
||||
// vs. "grand-piano") so it's better to use a shorter one if unsure.
|
||||
|
|
|
@ -84,8 +84,8 @@ public:
|
|||
//---------------------------------------------------------
|
||||
|
||||
struct NamedEventList {
|
||||
QString name;
|
||||
QString descr;
|
||||
String name;
|
||||
String descr;
|
||||
std::vector<MidiCoreEvent> events;
|
||||
|
||||
void write(XmlWriter&, const AsciiStringView& name) const;
|
||||
|
|
|
@ -91,10 +91,10 @@ void Jump::setJumpType(Type t)
|
|||
{
|
||||
for (const JumpTypeTableItem& p : jumpTypeTable) {
|
||||
if (p.type == t) {
|
||||
setXmlText(p.text);
|
||||
setJumpTo(p.jumpTo);
|
||||
setPlayUntil(p.playUntil);
|
||||
setContinueAt(p.continueAt);
|
||||
setXmlText(p.text.ascii());
|
||||
setJumpTo(p.jumpTo.ascii());
|
||||
setPlayUntil(p.playUntil.ascii());
|
||||
setContinueAt(p.continueAt.ascii());
|
||||
initTextStyleType(TextStyleType::REPEAT_RIGHT);
|
||||
break;
|
||||
}
|
||||
|
@ -143,11 +143,11 @@ void Jump::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "jumpTo") {
|
||||
_jumpTo = e.readElementText();
|
||||
_jumpTo = e.readText();
|
||||
} else if (tag == "playUntil") {
|
||||
_playUntil = e.readElementText();
|
||||
_playUntil = e.readText();
|
||||
} else if (tag == "continueAt") {
|
||||
_continueAt = e.readElementText();
|
||||
_continueAt = e.readText();
|
||||
} else if (tag == "playRepeats") {
|
||||
_playRepeats = e.readBool();
|
||||
} else if (!TextBase::readProperties(e)) {
|
||||
|
|
|
@ -39,9 +39,9 @@ namespace mu::engraving {
|
|||
|
||||
class Jump final : public TextBase
|
||||
{
|
||||
QString _jumpTo;
|
||||
QString _playUntil;
|
||||
QString _continueAt;
|
||||
String _jumpTo;
|
||||
String _playUntil;
|
||||
String _continueAt;
|
||||
bool _playRepeats;
|
||||
|
||||
public:
|
||||
|
@ -103,10 +103,10 @@ public:
|
|||
|
||||
struct JumpTypeTableItem {
|
||||
Jump::Type type;
|
||||
const char* text;
|
||||
const char* jumpTo;
|
||||
const char* playUntil;
|
||||
const char* continueAt;
|
||||
AsciiStringView text;
|
||||
AsciiStringView jumpTo;
|
||||
AsciiStringView playUntil;
|
||||
AsciiStringView continueAt;
|
||||
QString userText;
|
||||
};
|
||||
|
||||
|
|
|
@ -493,7 +493,7 @@ void KeySig::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView t(e.name());
|
||||
if (t == "sym") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
bool valid;
|
||||
SymId id = SymId(val.toInt(&valid));
|
||||
if (!valid) {
|
||||
|
@ -548,7 +548,7 @@ void KeySig::read(XmlReader& e)
|
|||
e.readInt();
|
||||
_sig.setCustom(true);
|
||||
} else if (tag == "mode") {
|
||||
QString m(e.readElementText());
|
||||
QString m(e.readText());
|
||||
if (m == "none") {
|
||||
_sig.setMode(KeyMode::NONE);
|
||||
} else if (m == "major") {
|
||||
|
|
|
@ -140,7 +140,7 @@ bool Lyrics::readProperties(XmlReader& e)
|
|||
if (tag == "no") {
|
||||
_no = e.readInt();
|
||||
} else if (tag == "syllabic") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
if (val == "single") {
|
||||
_syllabic = Syllabic::SINGLE;
|
||||
} else if (val == "begin") {
|
||||
|
|
|
@ -210,7 +210,7 @@ void Marker::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "label") {
|
||||
QString s(e.readElementText());
|
||||
QString s(e.readText());
|
||||
setLabel(s);
|
||||
mt = markerType(s);
|
||||
} else if (!TextBase::readProperties(e)) {
|
||||
|
|
|
@ -135,15 +135,6 @@ static constexpr int VISUAL_INVALID_STRING_INDEX = -100;
|
|||
|
||||
static constexpr ID INVALID_ID = 0;
|
||||
|
||||
//---------------------------------------------------------
|
||||
// BracketType
|
||||
// System Brackets
|
||||
//---------------------------------------------------------
|
||||
|
||||
enum class BracketType : signed char {
|
||||
NORMAL, BRACE, SQUARE, LINE, NO_BRACKET = -1
|
||||
};
|
||||
|
||||
//---------------------------------------------------------
|
||||
// TransposeDirection
|
||||
//---------------------------------------------------------
|
||||
|
|
|
@ -3274,7 +3274,7 @@ QString Note::accessibleInfo() const
|
|||
if (fixed() && headGroup() == NoteHeadGroup::HEAD_SLASH) {
|
||||
pitchName = chord()->noStem() ? QObject::tr("Beat slash") : QObject::tr("Rhythm slash");
|
||||
} else if (staff()->isDrumStaff(tick()) && drumset) {
|
||||
pitchName = qtrc("drumset", drumset->name(pitch()).toUtf8().constData());
|
||||
pitchName = qtrc("drumset", drumset->name(pitch()));
|
||||
} else if (staff()->isTabStaff(tick())) {
|
||||
pitchName
|
||||
= QObject::tr("%1; String: %2; Fret: %3").arg(tpcUserName(false), QString::number(string() + 1), QString::number(fret()));
|
||||
|
@ -3301,7 +3301,7 @@ QString Note::screenReaderInfo() const
|
|||
if (fixed() && headGroup() == NoteHeadGroup::HEAD_SLASH) {
|
||||
pitchName = chord()->noStem() ? QObject::tr("Beat Slash") : QObject::tr("Rhythm Slash");
|
||||
} else if (staff()->isDrumStaff(tick()) && drumset) {
|
||||
pitchName = qtrc("drumset", drumset->name(pitch()).toUtf8().constData());
|
||||
pitchName = qtrc("drumset", drumset->name(pitch()));
|
||||
} else if (staff()->isTabStaff(tick())) {
|
||||
pitchName = QObject::tr("%1; String: %2; Fret: %3").arg(tpcUserName(true), QString::number(string() + 1), QString::number(fret()));
|
||||
} else {
|
||||
|
|
|
@ -94,9 +94,9 @@ void NoteDot::read(XmlReader& e)
|
|||
{
|
||||
while (e.readNextStartElement()) {
|
||||
if (e.name() == "name") { // obsolete
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (e.name() == "subtype") { // obsolete
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (!EngravingItem::readProperties(e)) {
|
||||
e.unknown();
|
||||
}
|
||||
|
|
|
@ -322,7 +322,7 @@ bool Ottava::readProperties(XmlReader& e)
|
|||
{
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
bool ok;
|
||||
int idx = s.toInt(&ok);
|
||||
if (!ok) {
|
||||
|
|
|
@ -106,7 +106,7 @@ QString Part::familyId() const
|
|||
}
|
||||
|
||||
InstrumentIndex ii = searchTemplateIndexForId(instrumentId());
|
||||
return ii.instrTemplate && ii.instrTemplate->family ? ii.instrTemplate->family->id : QString();
|
||||
return ii.instrTemplate && ii.instrTemplate->family ? ii.instrTemplate->family->id : String();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
@ -163,20 +163,20 @@ bool Part::readProperties(XmlReader& e)
|
|||
instr->read(e, this);
|
||||
setInstrument(instr, Fraction(-1, 1));
|
||||
} else if (tag == "name") {
|
||||
instrument()->setLongName(e.readElementText());
|
||||
instrument()->setLongName(e.readText());
|
||||
} else if (tag == "color") {
|
||||
_color = e.readInt();
|
||||
} else if (tag == "shortName") {
|
||||
instrument()->setShortName(e.readElementText());
|
||||
instrument()->setShortName(e.readText());
|
||||
} else if (tag == "trackName") {
|
||||
_partName = e.readElementText();
|
||||
_partName = e.readText();
|
||||
} else if (tag == "show") {
|
||||
_show = e.readInt();
|
||||
} else if (tag == "soloist") {
|
||||
_soloist = e.readInt();
|
||||
} else if (tag == "preferSharpFlat") {
|
||||
_preferSharpFlat
|
||||
=e.readElementText() == "sharps" ? PreferSharpFlat::SHARPS : PreferSharpFlat::FLATS;
|
||||
=e.readText() == "sharps" ? PreferSharpFlat::SHARPS : PreferSharpFlat::FLATS;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
|
|
@ -125,7 +125,7 @@ bool Score::pasteStaff(XmlReader& e, Segment* dst, staff_idx_t dstStaff, Fractio
|
|||
e.unknown();
|
||||
break;
|
||||
}
|
||||
QString version = e.attribute("version", "NONE");
|
||||
QString version = e.attribute("version", u"NONE");
|
||||
if (!MScore::testMode) {
|
||||
if (version != MSC_VERSION) {
|
||||
LOGD("pasteStaff: bad version");
|
||||
|
@ -157,7 +157,7 @@ bool Score::pasteStaff(XmlReader& e, Segment* dst, staff_idx_t dstStaff, Fractio
|
|||
e.context()->setTransposeChromatic(0);
|
||||
e.context()->setTransposeDiatonic(0);
|
||||
|
||||
int srcStaffIdx = e.attribute("id", "0").toInt();
|
||||
int srcStaffIdx = e.intAttribute("id", 0);
|
||||
e.context()->setTrack(srcStaffIdx * static_cast<int>(VOICES));
|
||||
e.context()->setTrackOffset(static_cast<int>((dstStaff - staffStart) * VOICES));
|
||||
size_t dstStaffIdx = e.context()->track() / VOICES;
|
||||
|
@ -182,7 +182,7 @@ bool Score::pasteStaff(XmlReader& e, Segment* dst, staff_idx_t dstStaff, Fractio
|
|||
if (e.name() != "voice") {
|
||||
e.unknown();
|
||||
}
|
||||
voice_idx_t voiceId = static_cast<voice_idx_t>(e.attribute("id", "-1").toInt());
|
||||
voice_idx_t voiceId = static_cast<voice_idx_t>(e.intAttribute("id", -1));
|
||||
Q_ASSERT(voiceId < VOICES);
|
||||
voiceOffset[voiceId] = e.readInt();
|
||||
}
|
||||
|
@ -800,7 +800,7 @@ void Score::pasteSymbols(XmlReader& e, ChordRest* dst)
|
|||
e.unknown();
|
||||
break;
|
||||
}
|
||||
QString version = e.attribute("version", "NONE");
|
||||
QString version = e.attribute("version", u"NONE");
|
||||
if (version != MSC_VERSION) {
|
||||
break;
|
||||
}
|
||||
|
@ -1089,7 +1089,7 @@ static bool canPasteStaff(XmlReader& reader, const Fraction& scale)
|
|||
return false;
|
||||
}
|
||||
if (tag == "durationType") {
|
||||
if (!TDuration(TDuration(TConv::fromXml(reader.readElementAsciiText(),
|
||||
if (!TDuration(TDuration(TConv::fromXml(reader.readAsciiText(),
|
||||
DurationType::V_INVALID)).fraction() * scale).isValid()) {
|
||||
return false;
|
||||
}
|
||||
|
|
|
@ -503,11 +503,11 @@ PropertyValue readProperty(Pid id, XmlReader& e)
|
|||
return PropertyValue::fromValue(e.readFraction());
|
||||
|
||||
case P_TYPE::SYMID:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), SymId::noSym));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), SymId::noSym));
|
||||
case P_TYPE::COLOR:
|
||||
return PropertyValue::fromValue(e.readColor());
|
||||
case P_TYPE::ORNAMENT_STYLE:
|
||||
return PropertyValue::fromValue(TConv::fromXml(e.readElementAsciiText(), OrnamentStyle::DEFAULT));
|
||||
return PropertyValue::fromValue(TConv::fromXml(e.readAsciiText(), OrnamentStyle::DEFAULT));
|
||||
case P_TYPE::POINT:
|
||||
return PropertyValue::fromValue(e.readPoint());
|
||||
case P_TYPE::SCALE:
|
||||
|
@ -515,56 +515,56 @@ PropertyValue readProperty(Pid id, XmlReader& e)
|
|||
case P_TYPE::SIZE:
|
||||
return PropertyValue::fromValue(e.readSize());
|
||||
case P_TYPE::STRING:
|
||||
return PropertyValue(e.readElementText());
|
||||
return PropertyValue(e.readText());
|
||||
|
||||
case P_TYPE::ALIGN:
|
||||
return PropertyValue(TConv::fromXml(e.readElementText(), Align()));
|
||||
return PropertyValue(TConv::fromXml(e.readText(), Align()));
|
||||
case P_TYPE::PLACEMENT_V:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), PlacementV::ABOVE));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), PlacementV::ABOVE));
|
||||
case P_TYPE::PLACEMENT_H:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), PlacementH::LEFT));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), PlacementH::LEFT));
|
||||
case P_TYPE::TEXT_PLACE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), TextPlace::AUTO));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), TextPlace::AUTO));
|
||||
case P_TYPE::DIRECTION_V:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), DirectionV::AUTO));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), DirectionV::AUTO));
|
||||
case P_TYPE::DIRECTION_H:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), DirectionH::AUTO));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), DirectionH::AUTO));
|
||||
case P_TYPE::ORIENTATION:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), Orientation::VERTICAL));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), Orientation::VERTICAL));
|
||||
|
||||
case P_TYPE::LAYOUTBREAK_TYPE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), LayoutBreakType::NOBREAK));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), LayoutBreakType::NOBREAK));
|
||||
case P_TYPE::VELO_TYPE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), VeloType::OFFSET_VAL));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), VeloType::OFFSET_VAL));
|
||||
case P_TYPE::GLISS_STYLE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), GlissandoStyle::CHROMATIC));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), GlissandoStyle::CHROMATIC));
|
||||
case P_TYPE::BARLINE_TYPE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), BarLineType::NORMAL));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), BarLineType::NORMAL));
|
||||
|
||||
case P_TYPE::NOTEHEAD_TYPE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), NoteHeadType::HEAD_AUTO));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), NoteHeadType::HEAD_AUTO));
|
||||
case P_TYPE::NOTEHEAD_SCHEME:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), NoteHeadScheme::HEAD_AUTO));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), NoteHeadScheme::HEAD_AUTO));
|
||||
case P_TYPE::NOTEHEAD_GROUP:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), NoteHeadGroup::HEAD_NORMAL));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), NoteHeadGroup::HEAD_NORMAL));
|
||||
|
||||
case P_TYPE::CLEF_TYPE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), ClefType::G));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), ClefType::G));
|
||||
|
||||
case P_TYPE::DYNAMIC_TYPE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), DynamicType::OTHER));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), DynamicType::OTHER));
|
||||
|
||||
case P_TYPE::HOOK_TYPE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), HookType::NONE));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), HookType::NONE));
|
||||
|
||||
case P_TYPE::KEY_MODE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), KeyMode::NONE));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), KeyMode::NONE));
|
||||
|
||||
case P_TYPE::TEXT_STYLE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), TextStyleType::DEFAULT));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), TextStyleType::DEFAULT));
|
||||
|
||||
case P_TYPE::CHANGE_METHOD:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), ChangeMethod::NORMAL));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), ChangeMethod::NORMAL));
|
||||
|
||||
case P_TYPE::BEAM_MODE:
|
||||
return PropertyValue(int(0));
|
||||
|
@ -578,9 +578,9 @@ PropertyValue readProperty(Pid id, XmlReader& e)
|
|||
return PropertyValue();
|
||||
|
||||
case P_TYPE::PLAYTECH_TYPE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), PlayingTechniqueType::Natural));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), PlayingTechniqueType::Natural));
|
||||
case P_TYPE::TEMPOCHANGE_TYPE:
|
||||
return PropertyValue(TConv::fromXml(e.readElementAsciiText(), GradualTempoChangeType::Undefined));
|
||||
return PropertyValue(TConv::fromXml(e.readAsciiText(), GradualTempoChangeType::Undefined));
|
||||
default:
|
||||
ASSERT_X("unhandled PID type");
|
||||
break;
|
||||
|
@ -601,13 +601,13 @@ QString propertyToString(Pid id, const PropertyValue& value, bool mscx)
|
|||
|
||||
switch (id) {
|
||||
case Pid::SYSTEM_BRACKET: // system bracket type
|
||||
return Bracket::bracketTypeName(BracketType(value.toInt()));
|
||||
return TConv::toXml(BracketType(value.toInt())).toQLatin1String();
|
||||
case Pid::ACCIDENTAL_TYPE:
|
||||
return Accidental::subtype2name(AccidentalType(value.toInt())).toQLatin1String();
|
||||
case Pid::OTTAVA_TYPE:
|
||||
return Ottava::ottavaTypeName(OttavaType(value.toInt()));
|
||||
case Pid::TREMOLO_TYPE:
|
||||
return Tremolo::type2name(TremoloType(value.toInt()));
|
||||
return TConv::toXml(TremoloType(value.toInt())).toQLatin1String();
|
||||
case Pid::TRILL_TYPE:
|
||||
return Trill::type2name(Trill::Type(value.toInt()));
|
||||
case Pid::VIBRATO_TYPE:
|
||||
|
|
|
@ -59,11 +59,11 @@ void Revision::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "id") {
|
||||
_id = e.readElementText();
|
||||
_id = e.readText();
|
||||
} else if (tag == "diff") {
|
||||
_diff = e.readElementText();
|
||||
_diff = e.readText();
|
||||
} else if (tag == "date") {
|
||||
_dateTime = QDateTime::fromString(e.readElementText());
|
||||
_dateTime = QDateTime::fromString(e.readText());
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
|
|
@ -5194,7 +5194,7 @@ QString Score::getTextStyleUserName(TextStyleType tid)
|
|||
|
||||
QString Score::name() const
|
||||
{
|
||||
return _excerpt ? _excerpt->name() : QString();
|
||||
return _excerpt ? _excerpt->name() : String();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
|
|
@ -115,7 +115,7 @@ void ScoreOrder::readInstrument(XmlReader& reader)
|
|||
if (reader.name() == "family") {
|
||||
InstrumentOverwrite io;
|
||||
io.id = reader.attribute("id");
|
||||
io.name = qtrc("OrderXML", reader.readElementText().toUtf8().data());
|
||||
io.name = qtrc("OrderXML", reader.readText());
|
||||
instrumentMap.insert({ instrumentId, io });
|
||||
} else {
|
||||
reader.unknown();
|
||||
|
@ -151,7 +151,7 @@ void ScoreOrder::readSection(XmlReader& reader)
|
|||
while (reader.readNextStartElement()) {
|
||||
if (reader.name() == "family") {
|
||||
ScoreGroup sg;
|
||||
sg.family = reader.readElementText().toUtf8().data();
|
||||
sg.family = reader.readText();
|
||||
sg.section = sectionId;
|
||||
sg.bracket = true;
|
||||
sg.barLineSpan = barLineSpan;
|
||||
|
@ -200,7 +200,7 @@ bool ScoreOrder::hasGroup(const QString& familyId, const QString& group) const
|
|||
|
||||
bool ScoreOrder::isValid() const
|
||||
{
|
||||
return !id.isEmpty();
|
||||
return !id.empty();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
@ -209,16 +209,16 @@ bool ScoreOrder::isValid() const
|
|||
|
||||
bool ScoreOrder::isCustom() const
|
||||
{
|
||||
return id == QString("custom");
|
||||
return id == String(u"custom");
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// getName
|
||||
//---------------------------------------------------------
|
||||
|
||||
QString ScoreOrder::getName() const
|
||||
String ScoreOrder::getName() const
|
||||
{
|
||||
return customized ? qtrc("OrderXML", "%1 (Customized)").arg(name) : name;
|
||||
return customized ? String::fromQString(qtrc("OrderXML", "%1 (Customized)").arg(name)) : name;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
@ -292,7 +292,7 @@ ScoreGroup ScoreOrder::getGroup(const QString family, const QString instrumentGr
|
|||
// instrumentSortingIndex
|
||||
//---------------------------------------------------------
|
||||
|
||||
int ScoreOrder::instrumentSortingIndex(const QString& instrumentId, bool isSoloist) const
|
||||
int ScoreOrder::instrumentSortingIndex(const String& instrumentId, bool isSoloist) const
|
||||
{
|
||||
static const QString SoloistsGroup("<soloists>");
|
||||
static const QString UnsortedGroup("<unsorted>");
|
||||
|
@ -310,7 +310,7 @@ int ScoreOrder::instrumentSortingIndex(const QString& instrumentId, bool isSoloi
|
|||
return 0;
|
||||
}
|
||||
|
||||
QString family = mu::contains(instrumentMap, instrumentId) ? instrumentMap.at(instrumentId).id : ii.instrTemplate->familyId();
|
||||
String family = mu::contains(instrumentMap, instrumentId) ? instrumentMap.at(instrumentId).id : ii.instrTemplate->familyId();
|
||||
|
||||
size_t index = groups.size();
|
||||
|
||||
|
@ -479,14 +479,14 @@ void ScoreOrder::read(XmlReader& reader)
|
|||
const QString sectionId { "" };
|
||||
while (reader.readNextStartElement()) {
|
||||
if (reader.name() == "name") {
|
||||
name = qtrc("OrderXML", reader.readElementText().toUtf8().data());
|
||||
name = qtrc("OrderXML", reader.readText());
|
||||
} else if (reader.name() == "section") {
|
||||
readSection(reader);
|
||||
} else if (reader.name() == "instrument") {
|
||||
readInstrument(reader);
|
||||
} else if (reader.name() == "family") {
|
||||
ScoreGroup sg;
|
||||
sg.family = reader.readElementText().toUtf8().data();
|
||||
sg.family = reader.readText();
|
||||
sg.section = sectionId;
|
||||
sg.bracket = false;
|
||||
sg.barLineSpan = false;
|
||||
|
|
|
@ -50,8 +50,8 @@ struct ScoreGroup
|
|||
|
||||
struct InstrumentOverwrite
|
||||
{
|
||||
QString id;
|
||||
QString name;
|
||||
String id;
|
||||
String name;
|
||||
};
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
@ -60,9 +60,9 @@ struct InstrumentOverwrite
|
|||
|
||||
struct ScoreOrder
|
||||
{
|
||||
QString id { QString() };
|
||||
QString name { QString() };
|
||||
std::map<QString, InstrumentOverwrite> instrumentMap;
|
||||
String id;
|
||||
String name;
|
||||
std::map<String, InstrumentOverwrite> instrumentMap;
|
||||
std::vector<ScoreGroup> groups;
|
||||
bool customized = false;
|
||||
|
||||
|
@ -80,11 +80,11 @@ struct ScoreOrder
|
|||
|
||||
bool isValid() const;
|
||||
bool isCustom() const;
|
||||
QString getName() const;
|
||||
String getName() const;
|
||||
QString getFamilyName(const InstrumentTemplate* instrTemplate, bool soloist) const;
|
||||
ScoreGroup newUnsortedGroup(const QString group, const QString section) const;
|
||||
ScoreGroup getGroup(const QString family, const QString instrumentGroup) const;
|
||||
int instrumentSortingIndex(const QString& instrumentId, bool isSoloist) const;
|
||||
int instrumentSortingIndex(const String& instrumentId, bool isSoloist) const;
|
||||
bool isScoreOrder(const std::list<int>& indices) const;
|
||||
bool isScoreOrder(const Score* score) const;
|
||||
|
||||
|
|
|
@ -863,12 +863,12 @@ bool Staff::readProperties(XmlReader& e)
|
|||
st.read(e);
|
||||
setStaffType(Fraction(0, 1), st);
|
||||
} else if (tag == "defaultClef") { // sets both default transposing and concert clef
|
||||
ClefType ct = TConv::fromXml(e.readElementAsciiText(), ClefType::G);
|
||||
ClefType ct = TConv::fromXml(e.readAsciiText(), ClefType::G);
|
||||
setDefaultClefType(ClefTypeList(ct, ct));
|
||||
} else if (tag == "defaultConcertClef") {
|
||||
setDefaultClefType(ClefTypeList(TConv::fromXml(e.readElementAsciiText(), ClefType::G), defaultClefType()._transposingClef));
|
||||
setDefaultClefType(ClefTypeList(TConv::fromXml(e.readAsciiText(), ClefType::G), defaultClefType()._transposingClef));
|
||||
} else if (tag == "defaultTransposingClef") {
|
||||
setDefaultClefType(ClefTypeList(defaultClefType()._concertClef, TConv::fromXml(e.readElementAsciiText(), ClefType::G)));
|
||||
setDefaultClefType(ClefTypeList(defaultClefType()._concertClef, TConv::fromXml(e.readAsciiText(), ClefType::G)));
|
||||
} else if (tag == "small") { // obsolete
|
||||
staffType(Fraction(0, 1))->setSmall(e.readInt());
|
||||
} else if (tag == "invisible") {
|
||||
|
|
|
@ -368,7 +368,7 @@ void StaffType::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "name") {
|
||||
setXmlName(e.readElementText());
|
||||
setXmlName(e.readText());
|
||||
} else if (tag == "lines") {
|
||||
setLines(e.readInt());
|
||||
} else if (tag == "lineDistance") {
|
||||
|
@ -393,7 +393,7 @@ void StaffType::read(XmlReader& e)
|
|||
} else if (tag == "timesig") {
|
||||
setGenTimesig(e.readInt());
|
||||
} else if (tag == "noteheadScheme") {
|
||||
setNoteHeadScheme(TConv::fromXml(e.readElementAsciiText(), NoteHeadScheme::HEAD_NORMAL));
|
||||
setNoteHeadScheme(TConv::fromXml(e.readAsciiText(), NoteHeadScheme::HEAD_NORMAL));
|
||||
} else if (tag == "keysig") {
|
||||
_genKeysig = e.readInt();
|
||||
} else if (tag == "ledgerlines") {
|
||||
|
@ -405,13 +405,13 @@ void StaffType::read(XmlReader& e)
|
|||
} else if (tag == "durations") {
|
||||
setGenDurations(e.readBool());
|
||||
} else if (tag == "durationFontName") {
|
||||
setDurationFontName(e.readElementText());
|
||||
setDurationFontName(e.readText());
|
||||
} else if (tag == "durationFontSize") {
|
||||
setDurationFontSize(e.readDouble());
|
||||
} else if (tag == "durationFontY") {
|
||||
setDurationFontUserY(e.readDouble());
|
||||
} else if (tag == "fretFontName") {
|
||||
setFretFontName(e.readElementText());
|
||||
setFretFontName(e.readText());
|
||||
} else if (tag == "fretFontSize") {
|
||||
setFretFontSize(e.readDouble());
|
||||
} else if (tag == "fretFontY") {
|
||||
|
@ -1082,9 +1082,9 @@ bool TablatureFretFont::read(XmlReader& e)
|
|||
int val = e.intAttribute("value");
|
||||
|
||||
if (tag == "family") {
|
||||
family = e.readElementText();
|
||||
family = e.readText();
|
||||
} else if (tag == "displayName") {
|
||||
displayName = e.readElementText();
|
||||
displayName = e.readText();
|
||||
} else if (tag == "defaultPitch") {
|
||||
defPitch = e.readDouble();
|
||||
} else if (tag == "defaultYOffset") {
|
||||
|
@ -1092,7 +1092,7 @@ bool TablatureFretFont::read(XmlReader& e)
|
|||
} else if (tag == "mark") {
|
||||
QString sval = e.attribute("value");
|
||||
int num = e.intAttribute("number", 1);
|
||||
QString txt(e.readElementText());
|
||||
QString txt(e.readText());
|
||||
if (sval.size() < 1) {
|
||||
return false;
|
||||
}
|
||||
|
@ -1112,7 +1112,7 @@ bool TablatureFretFont::read(XmlReader& e)
|
|||
}
|
||||
} else if (tag == "fret") {
|
||||
bool bLetter = e.intAttribute("letter");
|
||||
QString txt(e.readElementText());
|
||||
QString txt(e.readText());
|
||||
if (bLetter) {
|
||||
if (val >= 0 && val < NUM_OF_LETTERFRETS) {
|
||||
displayLetter[val] = txt[0];
|
||||
|
@ -1136,9 +1136,9 @@ bool TablatureDurationFont::read(XmlReader& e)
|
|||
const AsciiStringView tag(e.name());
|
||||
|
||||
if (tag == "family") {
|
||||
family = e.readElementText();
|
||||
family = e.readText();
|
||||
} else if (tag == "displayName") {
|
||||
displayName = e.readElementText();
|
||||
displayName = e.readText();
|
||||
} else if (tag == "defaultPitch") {
|
||||
defPitch = e.readDouble();
|
||||
} else if (tag == "defaultYOffset") {
|
||||
|
@ -1150,7 +1150,7 @@ bool TablatureDurationFont::read(XmlReader& e)
|
|||
} else if (tag == "stemWidth") {
|
||||
gridStemWidth = e.readDouble();
|
||||
} else if (tag == "zeroBeamValue") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
if (val == "longa") {
|
||||
zeroBeamLevel = DurationType::V_LONG;
|
||||
} else if (val == "brevis") {
|
||||
|
@ -1182,7 +1182,7 @@ bool TablatureDurationFont::read(XmlReader& e)
|
|||
}
|
||||
} else if (tag == "duration") {
|
||||
QString val = e.attribute("value");
|
||||
QString txt(e.readElementText());
|
||||
QString txt(e.readText());
|
||||
QChar chr = txt[0];
|
||||
if (val == "longa") {
|
||||
displayValue[int(TabVal::VAL_LONGA)] = chr;
|
||||
|
|
|
@ -151,7 +151,7 @@ void Symbol::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "name") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
SymId symId = SymNames::symIdByName(val);
|
||||
if (val != "noSym" && symId == SymId::noSym) {
|
||||
// if symbol name not found, fall back to user names
|
||||
|
@ -165,7 +165,7 @@ void Symbol::read(XmlReader& e)
|
|||
}
|
||||
setSym(symId);
|
||||
} else if (tag == "font") {
|
||||
_scoreFont = ScoreFont::fontByName(e.readElementText());
|
||||
_scoreFont = ScoreFont::fontByName(e.readText());
|
||||
} else if (tag == "Symbol") {
|
||||
Symbol* s = new Symbol(this);
|
||||
s->read(e);
|
||||
|
@ -278,7 +278,7 @@ void FSymbol::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "font") {
|
||||
_font.setFamily(e.readElementText());
|
||||
_font.setFamily(e.readText());
|
||||
} else if (tag == "fontsize") {
|
||||
_font.setPointSizeF(e.readDouble());
|
||||
} else if (tag == "code") {
|
||||
|
|
|
@ -66,7 +66,7 @@ void SynthesizerState::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
if (e.name() == "val") {
|
||||
int id = e.intAttribute("id");
|
||||
group.push_back(IdValue(id, e.readElementText()));
|
||||
group.push_back(IdValue(id, e.readText()));
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
|
|
@ -97,7 +97,7 @@ void TempoText::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "tempo") {
|
||||
setTempo(TConv::fromXml(e.readElementAsciiText(), Constants::defaultTempo));
|
||||
setTempo(TConv::fromXml(e.readAsciiText(), Constants::defaultTempo));
|
||||
} else if (tag == "followText") {
|
||||
_followText = e.readInt();
|
||||
} else if (!TextBase::readProperties(e)) {
|
||||
|
|
|
@ -56,7 +56,7 @@ void Text::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "style") {
|
||||
TextStyleType s = TConv::fromXml(e.readElementAsciiText(), TextStyleType::DEFAULT);
|
||||
TextStyleType s = TConv::fromXml(e.readAsciiText(), TextStyleType::DEFAULT);
|
||||
if (TextStyleType::TUPLET == s) { // ugly hack for compatibility
|
||||
continue;
|
||||
}
|
||||
|
|
|
@ -221,9 +221,9 @@ void TimeSig::read(XmlReader& e)
|
|||
} else if (tag == "stretchD") {
|
||||
_stretch.setDenominator(e.readInt());
|
||||
} else if (tag == "textN") {
|
||||
setNumeratorString(e.readElementText());
|
||||
setNumeratorString(e.readText());
|
||||
} else if (tag == "textD") {
|
||||
setDenominatorString(e.readElementText());
|
||||
setDenominatorString(e.readText());
|
||||
} else if (tag == "Groups") {
|
||||
_groups.read(e);
|
||||
} else if (readStyledProperty(e, tag)) {
|
||||
|
|
|
@ -28,6 +28,7 @@
|
|||
#include "draw/brush.h"
|
||||
#include "style/style.h"
|
||||
#include "rw/xml.h"
|
||||
#include "types/typesconv.h"
|
||||
|
||||
#include "layout/layouttremolo.h"
|
||||
|
||||
|
@ -573,7 +574,7 @@ void Tremolo::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
setTremoloType(e.readElementText());
|
||||
setTremoloType(TConv::fromXml(e.readAsciiText(), TremoloType::INVALID_TREMOLO));
|
||||
}
|
||||
// Style needs special handling other than readStyledProperty()
|
||||
// to avoid calling customStyleApplicable() in setProperty(),
|
||||
|
@ -588,75 +589,6 @@ void Tremolo::read(XmlReader& e)
|
|||
}
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// tremoloTypeName
|
||||
//---------------------------------------------------------
|
||||
|
||||
QString Tremolo::tremoloTypeName() const
|
||||
{
|
||||
return type2name(tremoloType());
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// setTremoloType
|
||||
//---------------------------------------------------------
|
||||
|
||||
void Tremolo::setTremoloType(const QString& s)
|
||||
{
|
||||
setTremoloType(name2Type(s));
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// type2Name
|
||||
//---------------------------------------------------------
|
||||
|
||||
QString Tremolo::type2name(TremoloType t)
|
||||
{
|
||||
switch (t) {
|
||||
case TremoloType::R8: return QString("r8");
|
||||
case TremoloType::R16: return QString("r16");
|
||||
case TremoloType::R32: return QString("r32");
|
||||
case TremoloType::R64: return QString("r64");
|
||||
case TremoloType::C8: return QString("c8");
|
||||
case TremoloType::C16: return QString("c16");
|
||||
case TremoloType::C32: return QString("c32");
|
||||
case TremoloType::C64: return QString("c64");
|
||||
case TremoloType::BUZZ_ROLL: return QString("buzzroll");
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return QString("??");
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// nameToType
|
||||
//---------------------------------------------------------
|
||||
|
||||
TremoloType Tremolo::name2Type(const QString& s)
|
||||
{
|
||||
TremoloType t = TremoloType::INVALID_TREMOLO;
|
||||
if (s == "r8") {
|
||||
t = TremoloType::R8;
|
||||
} else if (s == "r16") {
|
||||
t = TremoloType::R16;
|
||||
} else if (s == "r32") {
|
||||
t = TremoloType::R32;
|
||||
} else if (s == "r64") {
|
||||
t = TremoloType::R64;
|
||||
} else if (s == "c8") {
|
||||
t = TremoloType::C8;
|
||||
} else if (s == "c16") {
|
||||
t = TremoloType::C16;
|
||||
} else if (s == "c32") {
|
||||
t = TremoloType::C32;
|
||||
} else if (s == "c64") {
|
||||
t = TremoloType::C64;
|
||||
} else if (s == "buzzroll") {
|
||||
t = TremoloType::BUZZ_ROLL;
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// tremoloLen
|
||||
//---------------------------------------------------------
|
||||
|
|
|
@ -26,17 +26,11 @@
|
|||
#include "durationtype.h"
|
||||
#include "symbol.h"
|
||||
#include "infrastructure/draw/painterpath.h"
|
||||
#include "types/types.h"
|
||||
|
||||
namespace mu::engraving {
|
||||
class Chord;
|
||||
|
||||
// Tremolo subtypes:
|
||||
enum class TremoloType : signed char {
|
||||
INVALID_TREMOLO = -1,
|
||||
R8 = 0, R16, R32, R64, BUZZ_ROLL, // one note tremolo (repeat)
|
||||
C8, C16, C32, C64 // two note tremolo (change)
|
||||
};
|
||||
|
||||
// only applicable to minim two-note tremolo in non-TAB staves
|
||||
enum class TremoloStyle : signed char {
|
||||
DEFAULT = 0, TRADITIONAL, TRADITIONAL_ALTERNATE
|
||||
|
@ -79,11 +73,6 @@ public:
|
|||
|
||||
void scanElements(void* data, void (* func)(void*, EngravingItem*), bool all=true) override;
|
||||
|
||||
QString tremoloTypeName() const;
|
||||
void setTremoloType(const QString& s);
|
||||
static TremoloType name2Type(const QString& s);
|
||||
static QString type2name(TremoloType t);
|
||||
|
||||
void setTremoloType(TremoloType t);
|
||||
TremoloType tremoloType() const { return _tremoloType; }
|
||||
|
||||
|
|
|
@ -409,7 +409,7 @@ void Trill::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
setTrillType(e.readElementText());
|
||||
setTrillType(e.readText());
|
||||
} else if (tag == "Accidental") {
|
||||
_accidental = Factory::createAccidental(this);
|
||||
_accidental->read(e);
|
||||
|
|
|
@ -927,7 +927,7 @@ bool Tuplet::readProperties(XmlReader& e)
|
|||
} else if (tag == "p2") {
|
||||
_p2 = e.readPoint() * score()->spatium();
|
||||
} else if (tag == "baseNote") {
|
||||
_baseLen = TDuration(TConv::fromXml(e.readElementAsciiText(), DurationType::V_INVALID));
|
||||
_baseLen = TDuration(TConv::fromXml(e.readAsciiText(), DurationType::V_INVALID));
|
||||
} else if (tag == "baseDots") {
|
||||
_baseLen.setDots(e.readInt());
|
||||
} else if (tag == "Number") {
|
||||
|
|
|
@ -264,7 +264,7 @@ void Vibrato::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
setVibratoType(e.readElementText());
|
||||
setVibratoType(e.readText());
|
||||
} else if (tag == "play") {
|
||||
setPlayArticulation(e.readBool());
|
||||
} else if (!SLine::readProperties(e)) {
|
||||
|
|
|
@ -160,7 +160,7 @@ void Volta::read(XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "endings") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
_endings = TConv::fromXml(s, std::vector<int>());
|
||||
} else if (readStyledProperty(e, tag)) {
|
||||
} else if (!readProperties(e)) {
|
||||
|
|
|
@ -392,22 +392,22 @@ static bool readTextProperties(XmlReader& e, TextBase* t, EngravingItem*)
|
|||
t->setPropertyFlags(Pid::FRAME_TYPE, PropertyFlags::UNSTYLED);
|
||||
} else if (tag == "halign") {
|
||||
Align align = t->align();
|
||||
align.horizontal = TConv::fromXml(e.readElementAsciiText(), AlignH::LEFT);
|
||||
align.horizontal = TConv::fromXml(e.readAsciiText(), AlignH::LEFT);
|
||||
t->setAlign(align);
|
||||
t->setPropertyFlags(Pid::ALIGN, PropertyFlags::UNSTYLED);
|
||||
} else if (tag == "valign") {
|
||||
Align align = t->align();
|
||||
align.vertical = TConv::fromXml(e.readElementAsciiText(), AlignV::TOP);
|
||||
align.vertical = TConv::fromXml(e.readAsciiText(), AlignV::TOP);
|
||||
t->setAlign(align);
|
||||
t->setPropertyFlags(Pid::ALIGN, PropertyFlags::UNSTYLED);
|
||||
} else if (tag == "rxoffset") {
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (tag == "ryoffset") {
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (tag == "yoffset") {
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (tag == "systemFlag") {
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (!t->readProperties(e)) {
|
||||
return false;
|
||||
}
|
||||
|
@ -443,7 +443,7 @@ static void readAccidental(Accidental* a, XmlReader& e)
|
|||
a->setBracket(AccidentalBracket(i));
|
||||
}
|
||||
} else if (tag == "subtype") {
|
||||
QString text(e.readElementText());
|
||||
QString text(e.readText());
|
||||
bool isInt;
|
||||
int i = text.toInt(&isInt);
|
||||
if (isInt) {
|
||||
|
@ -604,7 +604,7 @@ static void readFingering114(XmlReader& e, Fingering* fing)
|
|||
htmlDdata.replace(" ", "");
|
||||
fing->setPlainText(htmlDdata);
|
||||
} else if (tag == "subtype") {
|
||||
auto subtype = e.readElementText();
|
||||
auto subtype = e.readText();
|
||||
if (subtype == "StringNumber") {
|
||||
isStringNumber = true;
|
||||
fing->setProperty(Pid::TEXT_STYLE, TextStyleType::STRING_NUMBER);
|
||||
|
@ -676,13 +676,13 @@ static void readNote(Note* note, XmlReader& e, ReadContext& ctx)
|
|||
readFingering114(e, f);
|
||||
note->add(f);
|
||||
} else if (tag == "onTimeType") {
|
||||
if (e.readElementText() == "offset") {
|
||||
if (e.readText() == "offset") {
|
||||
note->setOnTimeType(2);
|
||||
} else {
|
||||
note->setOnTimeType(1);
|
||||
}
|
||||
} else if (tag == "offTimeType") {
|
||||
if (e.readElementText() == "offset") {
|
||||
if (e.readText() == "offset") {
|
||||
note->setOffTimeType(2);
|
||||
} else {
|
||||
note->setOffTimeType(1);
|
||||
|
@ -700,7 +700,7 @@ static void readNote(Note* note, XmlReader& e, ReadContext& ctx)
|
|||
note->setOffTimeOffset(1000 + (e.readInt() * 10));
|
||||
}
|
||||
} else if (tag == "userAccidental") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
bool ok;
|
||||
int k = val.toInt(&ok);
|
||||
if (ok) {
|
||||
|
@ -882,12 +882,9 @@ static void readNote(Note* note, XmlReader& e, ReadContext& ctx)
|
|||
// readClefType
|
||||
//---------------------------------------------------------
|
||||
|
||||
static ClefType readClefType(const QString& s)
|
||||
static ClefType readClefType(int i)
|
||||
{
|
||||
ClefType ct = ClefType::G;
|
||||
bool ok;
|
||||
int i = s.toInt(&ok);
|
||||
if (ok) {
|
||||
// convert obsolete old coding
|
||||
switch (i) {
|
||||
default:
|
||||
|
@ -934,7 +931,7 @@ static ClefType readClefType(const QString& s)
|
|||
case 20: ct = ClefType::TAB_SERIF;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return ct;
|
||||
}
|
||||
|
||||
|
@ -947,7 +944,7 @@ static void readClef(Clef* clef, XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
clef->setClefType(readClefType(e.readElementText()));
|
||||
clef->setClefType(readClefType(e.readInt()));
|
||||
} else if (!clef->readProperties(e)) {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -1013,7 +1010,7 @@ static void readTremolo(Tremolo* tremolo, XmlReader& e)
|
|||
};
|
||||
while (e.readNextStartElement()) {
|
||||
if (e.name() == "subtype") {
|
||||
OldTremoloType sti = OldTremoloType(e.readElementText().toInt());
|
||||
OldTremoloType sti = OldTremoloType(e.readText().toInt());
|
||||
TremoloType st;
|
||||
switch (sti) {
|
||||
default:
|
||||
|
@ -1207,7 +1204,7 @@ static void readVolta114(XmlReader& e, const ReadContext& ctx, Volta* volta)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "endings") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
QStringList sl = s.split(",", Qt::SkipEmptyParts);
|
||||
volta->endings().clear();
|
||||
for (const QString& l : qAsConst(sl)) {
|
||||
|
@ -1236,7 +1233,7 @@ static void readOttava114(XmlReader& e, const ReadContext& ctx, Ottava* ottava)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
bool ok;
|
||||
int idx = s.toInt(&ok);
|
||||
if (!ok) {
|
||||
|
@ -1313,19 +1310,19 @@ static void readTextLine114(XmlReader& e, const ReadContext& ctx, TextLine* text
|
|||
} else if (tag == "hookUp") { // obsolete
|
||||
textLine->setEndHookHeight(Spatium(qreal(-1.0)));
|
||||
} else if (tag == "beginSymbol" || tag == "symbol") { // "symbol" is obsolete
|
||||
QString text(e.readElementText());
|
||||
QString text(e.readText());
|
||||
textLine->setBeginText(QString("<sym>%1</sym>").arg(
|
||||
text[0].isNumber()
|
||||
? resolveSymCompatibility(SymId(text.toInt()), ctx.mscoreVersion())
|
||||
: text));
|
||||
} else if (tag == "continueSymbol") {
|
||||
QString text(e.readElementText());
|
||||
QString text(e.readText());
|
||||
textLine->setContinueText(QString("<sym>%1</sym>").arg(
|
||||
text[0].isNumber()
|
||||
? resolveSymCompatibility(SymId(text.toInt()), ctx.mscoreVersion())
|
||||
: text));
|
||||
} else if (tag == "endSymbol") {
|
||||
QString text(e.readElementText());
|
||||
QString text(e.readText());
|
||||
textLine->setEndText(QString("<sym>%1</sym>").arg(
|
||||
text[0].isNumber()
|
||||
? resolveSymCompatibility(SymId(text.toInt()), ctx.mscoreVersion())
|
||||
|
@ -1337,11 +1334,11 @@ static void readTextLine114(XmlReader& e, const ReadContext& ctx, TextLine* text
|
|||
} else if (tag == "endSymbolOffset") { // obsolete
|
||||
e.readPoint();
|
||||
} else if (tag == "beginTextPlace") {
|
||||
textLine->setBeginTextPlace(TConv::fromXml(e.readElementAsciiText(), TextPlace::AUTO));
|
||||
textLine->setBeginTextPlace(TConv::fromXml(e.readAsciiText(), TextPlace::AUTO));
|
||||
} else if (tag == "continueTextPlace") {
|
||||
textLine->setContinueTextPlace(TConv::fromXml(e.readElementAsciiText(), TextPlace::AUTO));
|
||||
textLine->setContinueTextPlace(TConv::fromXml(e.readAsciiText(), TextPlace::AUTO));
|
||||
} else if (tag == "endTextPlace") {
|
||||
textLine->setEndTextPlace(TConv::fromXml(e.readElementAsciiText(), TextPlace::AUTO));
|
||||
textLine->setEndTextPlace(TConv::fromXml(e.readAsciiText(), TextPlace::AUTO));
|
||||
} else if (!readTextLineProperties114(e, ctx, textLine)) {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -1368,19 +1365,19 @@ static void readPedal114(XmlReader& e, const ReadContext& ctx, Pedal* pedal)
|
|||
pedal->setLineStyle(mu::draw::PenStyle(e.readInt()));
|
||||
pedal->setPropertyFlags(Pid::LINE_STYLE, PropertyFlags::UNSTYLED);
|
||||
} else if (tag == "beginSymbol" || tag == "symbol") { // "symbol" is obsolete
|
||||
QString text(e.readElementText());
|
||||
QString text(e.readText());
|
||||
pedal->setBeginText(QString("<sym>%1</sym>").arg(
|
||||
text[0].isNumber()
|
||||
? resolveSymCompatibility(SymId(text.toInt()), ctx.mscoreVersion())
|
||||
: text));
|
||||
} else if (tag == "continueSymbol") {
|
||||
QString text(e.readElementText());
|
||||
QString text(e.readText());
|
||||
pedal->setContinueText(QString("<sym>%1</sym>").arg(
|
||||
text[0].isNumber()
|
||||
? resolveSymCompatibility(SymId(text.toInt()), ctx.mscoreVersion())
|
||||
: text));
|
||||
} else if (tag == "endSymbol") {
|
||||
QString text(e.readElementText());
|
||||
QString text(e.readText());
|
||||
pedal->setEndText(QString("<sym>%1</sym>").arg(
|
||||
text[0].isNumber()
|
||||
? resolveSymCompatibility(SymId(text.toInt()), ctx.mscoreVersion())
|
||||
|
@ -1421,7 +1418,7 @@ static void readHarmony114(XmlReader& e, const ReadContext& ctx, Harmony* h)
|
|||
} else if (tag == "extension") {
|
||||
h->setId(e.readInt());
|
||||
} else if (tag == "name") {
|
||||
h->setTextName(e.readElementText());
|
||||
h->setTextName(e.readText());
|
||||
} else if (tag == "root") {
|
||||
if (ctx.mscVersion() >= 106) {
|
||||
h->setRootTpc(e.readInt());
|
||||
|
@ -1441,7 +1438,7 @@ static void readHarmony114(XmlReader& e, const ReadContext& ctx, Harmony* h)
|
|||
} else if (t == "degree-alter") {
|
||||
degreeAlter = e.readInt();
|
||||
} else if (t == "degree-type") {
|
||||
degreeType = e.readElementText();
|
||||
degreeType = e.readText();
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -1534,7 +1531,7 @@ static void readMeasure(Measure* m, int staffIdx, XmlReader& e, ReadContext& ctx
|
|||
}
|
||||
|
||||
if (e.hasAttribute("len")) {
|
||||
QStringList sl = e.attribute("len").split('/');
|
||||
StringList sl = e.attribute("len").split('/');
|
||||
if (sl.size() == 2) {
|
||||
m->setTicks(Fraction(sl[0].toInt(), sl[1].toInt()));
|
||||
} else {
|
||||
|
@ -1904,7 +1901,7 @@ static void readMeasure(Measure* m, int staffIdx, XmlReader& e, ReadContext& ctx
|
|||
if (t == "no") {
|
||||
l->setNo(e.readInt());
|
||||
} else if (t == "syllabic") {
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
if (val == "single") {
|
||||
l->setSyllabic(Lyrics::Syllabic::SINGLE);
|
||||
} else if (val == "begin") {
|
||||
|
@ -2011,11 +2008,11 @@ static void readMeasure(Measure* m, int staffIdx, XmlReader& e, ReadContext& ctx
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView t(e.name());
|
||||
if (t == "jumpTo") {
|
||||
j->setJumpTo(e.readElementText());
|
||||
j->setJumpTo(e.readText());
|
||||
} else if (t == "playUntil") {
|
||||
j->setPlayUntil(e.readElementText());
|
||||
j->setPlayUntil(e.readText());
|
||||
} else if (t == "continueAt") {
|
||||
j->setContinueAt(e.readElementText());
|
||||
j->setContinueAt(e.readText());
|
||||
} else if (t == "playRepeats") {
|
||||
j->setPlayRepeats(e.readBool());
|
||||
} else if (t == "subtype") {
|
||||
|
@ -2033,7 +2030,7 @@ static void readMeasure(Measure* m, int staffIdx, XmlReader& e, ReadContext& ctx
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView t(e.name());
|
||||
if (t == "subtype") {
|
||||
QString s(e.readElementText());
|
||||
QString s(e.readText());
|
||||
a->setLabel(s);
|
||||
mt = a->markerType(s);
|
||||
} else if (!a->TextBase::readProperties(e)) {
|
||||
|
@ -2077,7 +2074,7 @@ static void readMeasure(Measure* m, int staffIdx, XmlReader& e, ReadContext& ctx
|
|||
segment = m->getSegment(SegmentType::BeginBarLine, m->tick());
|
||||
BarLine* barLine = Factory::createBarLine(segment);
|
||||
barLine->setTrack(ctx.track());
|
||||
barLine->setBarLineType(TConv::fromXml(e.readElementAsciiText(), BarLineType::NORMAL));
|
||||
barLine->setBarLineType(TConv::fromXml(e.readAsciiText(), BarLineType::NORMAL));
|
||||
segment->add(barLine);
|
||||
} else if (tag == "Tuplet") {
|
||||
Tuplet* tuplet = Factory::createTuplet(m);
|
||||
|
@ -2386,7 +2383,7 @@ static void readStaff(Staff* staff, XmlReader& e, const ReadContext& ctx)
|
|||
while (e.readNextStartElement()) {
|
||||
if (e.name() == "clef") {
|
||||
int tick = e.intAttribute("tick", 0);
|
||||
ClefType ct = readClefType(e.attribute("idx", "0"));
|
||||
ClefType ct = readClefType(e.intAttribute("idx", 0));
|
||||
staff->clefList().insert(std::pair<int, ClefType>(ctx.fileDivision(tick), ct));
|
||||
e.readNext();
|
||||
} else {
|
||||
|
@ -2575,7 +2572,7 @@ static void readPart(Part* part, XmlReader& e, ReadContext& ctx)
|
|||
part->instrument()->setShortName(t->xmlText());
|
||||
delete t;
|
||||
} else if (tag == "trackName") {
|
||||
part->setPartName(e.readElementText());
|
||||
part->setPartName(e.readText());
|
||||
} else if (tag == "show") {
|
||||
part->setShow(e.readInt());
|
||||
} else {
|
||||
|
@ -2622,14 +2619,14 @@ static void readPageFormat(PageFormat* pf, XmlReader& e)
|
|||
qreal _oddRightMargin = 0.0;
|
||||
qreal _evenRightMargin = 0.0;
|
||||
bool landscape = false;
|
||||
QString type;
|
||||
AsciiStringView type;
|
||||
|
||||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "landscape") {
|
||||
landscape = e.readInt();
|
||||
} else if (tag == "page-margins") {
|
||||
type = e.attribute("type", "both");
|
||||
type = e.asciiAttribute("type", "both");
|
||||
qreal lm = 0.0, rm = 0.0, tm = 0.0, bm = 0.0;
|
||||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView t(e.name());
|
||||
|
@ -2664,7 +2661,7 @@ static void readPageFormat(PageFormat* pf, XmlReader& e)
|
|||
} else if (tag == "page-width") {
|
||||
pf->setSize(SizeF(e.readDouble() * 0.5 / PPI, pf->size().height()));
|
||||
} else if (tag == "pageFormat") {
|
||||
const PaperSize* s = getPaperSize114(e.readElementText());
|
||||
const PaperSize* s = getPaperSize114(e.readText());
|
||||
pf->setSize(SizeF(s->w, s->h));
|
||||
} else if (tag == "page-offset") {
|
||||
e.readInt();
|
||||
|
@ -2712,7 +2709,7 @@ static void readStyle(MStyle* style, XmlReader& e, ReadChordListHook& readChordL
|
|||
} else if (tag == "systemDistance") { // obsolete
|
||||
style->set(Sid::minSystemDistance, e.readDouble());
|
||||
} else if (tag == "stemDir") {
|
||||
int voice = e.attribute("voice", "1").toInt() - 1;
|
||||
int voice = e.intAttribute("voice", 1) - 1;
|
||||
switch (voice) {
|
||||
case 0: tag = "StemDir1";
|
||||
break;
|
||||
|
@ -2762,7 +2759,7 @@ Score::FileError Read114::read114(MasterScore* masterScore, XmlReader& e, ReadCo
|
|||
} else if (tag == "siglist") {
|
||||
masterScore->_sigmap->read(e, ctx.fileDivision());
|
||||
} else if (tag == "programVersion") {
|
||||
masterScore->setMscoreVersion(e.readElementText());
|
||||
masterScore->setMscoreVersion(e.readText());
|
||||
} else if (tag == "programRevision") {
|
||||
masterScore->setMscoreRevision(e.readInt());
|
||||
} else if (tag == "Mag"
|
||||
|
@ -2774,12 +2771,12 @@ Score::FileError Read114::read114(MasterScore* masterScore, XmlReader& e, ReadCo
|
|||
e.skipCurrentElement(); // obsolete
|
||||
} else if (tag == "tempolist") {
|
||||
// store the tempo list to create invisible tempo text later
|
||||
qreal tempo = e.attribute("fix", "2.0").toDouble();
|
||||
qreal tempo = e.doubleAttribute("fix", 2.0);
|
||||
tm.setRelTempo(tempo);
|
||||
while (e.readNextStartElement()) {
|
||||
if (e.name() == "tempo") {
|
||||
int tick = e.attribute("tick").toInt();
|
||||
double tmp = e.readElementText().toDouble();
|
||||
double tmp = e.readText().toDouble();
|
||||
tick = ctx.fileDivision(tick);
|
||||
auto pos = tm.find(tick);
|
||||
if (pos != tm.end()) {
|
||||
|
@ -2787,7 +2784,7 @@ Score::FileError Read114::read114(MasterScore* masterScore, XmlReader& e, ReadCo
|
|||
}
|
||||
tm.setTempo(tick, tmp);
|
||||
} else if (e.name() == "relTempo") {
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -2832,18 +2829,18 @@ Score::FileError Read114::read114(MasterScore* masterScore, XmlReader& e, ReadCo
|
|||
masterScore->setMetaTag("copyright", text->plainText());
|
||||
delete text;
|
||||
} else if (tag == "movement-number") {
|
||||
masterScore->setMetaTag("movementNumber", e.readElementText());
|
||||
masterScore->setMetaTag("movementNumber", e.readText());
|
||||
} else if (tag == "movement-title") {
|
||||
masterScore->setMetaTag("movementTitle", e.readElementText());
|
||||
masterScore->setMetaTag("movementTitle", e.readText());
|
||||
} else if (tag == "work-number") {
|
||||
masterScore->setMetaTag("workNumber", e.readElementText());
|
||||
masterScore->setMetaTag("workNumber", e.readText());
|
||||
} else if (tag == "work-title") {
|
||||
masterScore->setMetaTag("workTitle", e.readElementText());
|
||||
masterScore->setMetaTag("workTitle", e.readText());
|
||||
} else if (tag == "source") {
|
||||
masterScore->setMetaTag("source", e.readElementText());
|
||||
masterScore->setMetaTag("source", e.readText());
|
||||
} else if (tag == "metaTag") {
|
||||
QString name = e.attribute("name");
|
||||
masterScore->setMetaTag(name, e.readElementText());
|
||||
masterScore->setMetaTag(name, e.readText());
|
||||
} else if (tag == "Part") {
|
||||
Part* part = new Part(masterScore);
|
||||
readPart(part, e, ctx);
|
||||
|
|
|
@ -140,9 +140,9 @@ void Read206::readTextStyle206(MStyle* style, XmlReader& e, std::map<QString, st
|
|||
const AsciiStringView tag(e.name());
|
||||
|
||||
if (tag == "name") {
|
||||
name = e.readElementText();
|
||||
name = e.readText();
|
||||
} else if (tag == "family") {
|
||||
family = e.readElementText();
|
||||
family = e.readText();
|
||||
} else if (tag == "size") {
|
||||
size = e.readDouble();
|
||||
} else if (tag == "bold") {
|
||||
|
@ -168,9 +168,9 @@ void Read206::readTextStyle206(MStyle* style, XmlReader& e, std::map<QString, st
|
|||
} else if (tag == "anchor") { // obsolete
|
||||
e.skipCurrentElement();
|
||||
} else if (tag == "halign") {
|
||||
align.horizontal = TConv::fromXml(e.readElementAsciiText(), AlignH::LEFT);
|
||||
align.horizontal = TConv::fromXml(e.readAsciiText(), AlignH::LEFT);
|
||||
} else if (tag == "valign") {
|
||||
align.vertical = TConv::fromXml(e.readElementAsciiText(), AlignV::TOP);
|
||||
align.vertical = TConv::fromXml(e.readAsciiText(), AlignV::TOP);
|
||||
} else if (tag == "xoffset") {
|
||||
qreal xo = e.readDouble();
|
||||
if (offsetType == OffsetType::ABS) {
|
||||
|
@ -186,7 +186,7 @@ void Read206::readTextStyle206(MStyle* style, XmlReader& e, std::map<QString, st
|
|||
} else if (tag == "rxoffset" || tag == "ryoffset") { // obsolete
|
||||
e.readDouble();
|
||||
} else if (tag == "offsetType") {
|
||||
const QString& val(e.readElementText());
|
||||
const QString& val(e.readText());
|
||||
OffsetType ot = OffsetType::ABS;
|
||||
if (val == "spatium" || val == "1") {
|
||||
ot = OffsetType::SPATIUM;
|
||||
|
@ -227,7 +227,7 @@ void Read206::readTextStyle206(MStyle* style, XmlReader& e, std::map<QString, st
|
|||
} else if (tag == "systemFlag") {
|
||||
systemFlag = e.readInt();
|
||||
} else if (tag == "placement") {
|
||||
QString value(e.readElementText());
|
||||
QString value(e.readText());
|
||||
if (value == "above") {
|
||||
placement = PlacementV::ABOVE;
|
||||
} else if (value == "below") {
|
||||
|
@ -424,7 +424,7 @@ void Read206::readAccidental206(Accidental* a, XmlReader& e)
|
|||
a->setBracket(AccidentalBracket(i));
|
||||
}
|
||||
} else if (tag == "subtype") {
|
||||
QString text = e.readElementText();
|
||||
QString text = e.readText();
|
||||
const static std::map<QString, AccidentalType> accMap = {
|
||||
{ "none", AccidentalType::NONE },
|
||||
{ "sharp", AccidentalType::SHARP },
|
||||
|
@ -630,11 +630,11 @@ static void readDrumset206(Drumset* ds, XmlReader& e)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView taga(e.name());
|
||||
if (taga == "articulation") {
|
||||
AsciiStringView oldArticulationName = e.readElementAsciiText();
|
||||
AsciiStringView oldArticulationName = e.readAsciiText();
|
||||
SymId oldId = Read206::articulationNames2SymId206(oldArticulationName);
|
||||
div.articulationName = Articulation::symId2ArticulationName(oldId);
|
||||
} else if (taga == "tremolo") {
|
||||
div.tremolo = Tremolo::name2Type(e.readElementText());
|
||||
div.tremolo = TConv::fromXml(e.readAsciiText(), TremoloType::INVALID_TREMOLO);
|
||||
}
|
||||
}
|
||||
ds->drum(pitch).addVariant(div);
|
||||
|
@ -1229,12 +1229,12 @@ static bool readTextProperties206(XmlReader& e, const ReadContext& ctx, TextBase
|
|||
t->readProperty(e, Pid::FRAME_BG_COLOR);
|
||||
} else if (tag == "halign") {
|
||||
Align align = t->align();
|
||||
align.horizontal = TConv::fromXml(e.readElementAsciiText(), AlignH::LEFT);
|
||||
align.horizontal = TConv::fromXml(e.readAsciiText(), AlignH::LEFT);
|
||||
t->setAlign(align);
|
||||
t->setPropertyFlags(Pid::ALIGN, PropertyFlags::UNSTYLED);
|
||||
} else if (tag == "valign") {
|
||||
Align align = t->align();
|
||||
align.vertical = TConv::fromXml(e.readElementAsciiText(), AlignV::TOP);
|
||||
align.vertical = TConv::fromXml(e.readAsciiText(), AlignV::TOP);
|
||||
t->setAlign(align);
|
||||
t->setPropertyFlags(Pid::ALIGN, PropertyFlags::UNSTYLED);
|
||||
} else if (tag == "pos") {
|
||||
|
@ -1378,7 +1378,7 @@ static void readMarker(Marker* m, XmlReader& e, const ReadContext& ctx)
|
|||
while (tctx.reader().readNextStartElement()) {
|
||||
const AsciiStringView tag(tctx.reader().name());
|
||||
if (tag == "label") {
|
||||
QString s(tctx.reader().readElementText());
|
||||
QString s(tctx.reader().readText());
|
||||
m->setLabel(s);
|
||||
mt = m->markerType(s);
|
||||
} else if (!readTextProperties206(tctx.reader(), ctx, m)) {
|
||||
|
@ -1399,11 +1399,11 @@ static void readDynamic(Dynamic* d, XmlReader& e, const ReadContext& ctx)
|
|||
while (tctx.reader().readNextStartElement()) {
|
||||
const AsciiStringView tag = tctx.reader().name();
|
||||
if (tag == "subtype") {
|
||||
d->setDynamicType(tctx.reader().readElementText());
|
||||
d->setDynamicType(tctx.reader().readText());
|
||||
} else if (tag == "velocity") {
|
||||
d->setVelocity(tctx.reader().readInt());
|
||||
} else if (tag == "dynType") {
|
||||
d->setDynRange(TConv::fromXml(tctx.reader().readElementAsciiText(), DynamicRange::STAFF));
|
||||
d->setDynRange(TConv::fromXml(tctx.reader().readAsciiText(), DynamicRange::STAFF));
|
||||
} else if (!readTextProperties206(tctx.reader(), ctx, d)) {
|
||||
tctx.reader().unknown();
|
||||
}
|
||||
|
@ -1462,7 +1462,7 @@ static void readLyrics(Lyrics* lyrics, XmlReader& e, const ReadContext& ctx)
|
|||
readText206(e, ctx, _verseNumber, lyrics);
|
||||
_verseNumber->setParent(lyrics);
|
||||
} else if (tag == "style") {
|
||||
e.readElementText(); // ignore style
|
||||
e.readText(); // ignore style
|
||||
} else if (!lyrics->readProperties(e)) {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -1524,7 +1524,7 @@ bool Read206::readTupletProperties206(XmlReader& e, const ReadContext& ctx, Tupl
|
|||
} else if (tag == "p2") {
|
||||
de->setProperty(Pid::P2, PropertyValue::fromValue(e.readPoint() * ctx.spatium()));
|
||||
} else if (tag == "baseNote") {
|
||||
de->setBaseLen(TDuration(TConv::fromXml(e.readElementAsciiText(), DurationType::V_INVALID)));
|
||||
de->setBaseLen(TDuration(TConv::fromXml(e.readAsciiText(), DurationType::V_INVALID)));
|
||||
} else if (tag == "Number") {
|
||||
Text* _number = Factory::createText(de);
|
||||
de->setNumber(_number);
|
||||
|
@ -1553,7 +1553,7 @@ bool Read206::readChordRestProperties206(XmlReader& e, ReadContext& ctx, ChordRe
|
|||
const AsciiStringView tag(e.name());
|
||||
|
||||
if (tag == "durationType") {
|
||||
ch->setDurationType(TConv::fromXml(e.readElementAsciiText(), DurationType::V_QUARTER));
|
||||
ch->setDurationType(TConv::fromXml(e.readAsciiText(), DurationType::V_QUARTER));
|
||||
if (ch->actualDurationType().type() != DurationType::V_MEASURE) {
|
||||
if (ctx.mscVersion() < 112 && (ch->type() == ElementType::REST)
|
||||
&& // for backward compatibility, convert V_WHOLE rests to V_MEASURE
|
||||
|
@ -1578,7 +1578,7 @@ bool Read206::readChordRestProperties206(XmlReader& e, ReadContext& ctx, ChordRe
|
|||
}
|
||||
}
|
||||
} else if (tag == "BeamMode") {
|
||||
BeamMode bm = TConv::fromXml(e.readElementAsciiText(), BeamMode::AUTO);
|
||||
BeamMode bm = TConv::fromXml(e.readAsciiText(), BeamMode::AUTO);
|
||||
ch->setBeamMode(bm);
|
||||
} else if (tag == "Articulation") {
|
||||
EngravingItem* el = readArticulation(ch, e, ctx);
|
||||
|
@ -2009,7 +2009,7 @@ static void readVolta206(XmlReader& e, const ReadContext& ctx, Volta* volta)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "endings") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
QStringList sl = s.split(",", Qt::SkipEmptyParts);
|
||||
volta->endings().clear();
|
||||
for (const QString& l : qAsConst(sl)) {
|
||||
|
@ -2048,7 +2048,7 @@ static void readOttava(XmlReader& e, const ReadContext& ctx, Ottava* ottava)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
bool ok;
|
||||
int idx = s.toInt(&ok);
|
||||
if (!ok) {
|
||||
|
@ -2120,7 +2120,7 @@ void Read206::readTrill206(XmlReader& e, Trill* t)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
t->setTrillType(e.readElementText());
|
||||
t->setTrillType(e.readText());
|
||||
} else if (tag == "Accidental") {
|
||||
Accidental* _accidental = Factory::createAccidental(t);
|
||||
readAccidental206(_accidental, e);
|
||||
|
@ -2192,7 +2192,7 @@ EngravingItem* Read206::readArticulation(EngravingItem* parent, XmlReader& e, co
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "subtype") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
if (s[0].isDigit()) {
|
||||
int oldType = s.toInt();
|
||||
sym = articulationNames[oldType].id;
|
||||
|
@ -2281,7 +2281,7 @@ EngravingItem* Read206::readArticulation(EngravingItem* parent, XmlReader& e, co
|
|||
} else if (tag == "direction") {
|
||||
useDefaultPlacement = false;
|
||||
if (!el || el->isFermata()) {
|
||||
direction = TConv::fromXml(e.readElementAsciiText(), DirectionV::AUTO);
|
||||
direction = TConv::fromXml(e.readAsciiText(), DirectionV::AUTO);
|
||||
} else {
|
||||
el->readProperties(e);
|
||||
}
|
||||
|
@ -2402,9 +2402,9 @@ static void readMeasure206(Measure* m, int staffIdx, XmlReader& e, ReadContext&
|
|||
|
||||
bool irregular;
|
||||
if (e.hasAttribute("len")) {
|
||||
QStringList sl = e.attribute("len").split('/');
|
||||
StringList sl = e.attribute("len").split(u'/');
|
||||
if (sl.size() == 2) {
|
||||
m->setTicks(Fraction(sl[0].toInt(), sl[1].toInt()));
|
||||
m->setTicks(Fraction(sl.at(0).toInt(), sl.at(1).toInt()));
|
||||
} else {
|
||||
LOGD("illegal measure size <%s>", qPrintable(e.attribute("len")));
|
||||
}
|
||||
|
@ -2439,7 +2439,7 @@ static void readMeasure206(Measure* m, int staffIdx, XmlReader& e, ReadContext&
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView t(e.name());
|
||||
if (t == "subtype") {
|
||||
bl->setBarLineType(TConv::fromXml(e.readElementAsciiText(), BarLineType::NORMAL));
|
||||
bl->setBarLineType(TConv::fromXml(e.readAsciiText(), BarLineType::NORMAL));
|
||||
} else if (t == "customSubtype") { // obsolete
|
||||
e.readInt();
|
||||
} else if (t == "span") {
|
||||
|
@ -2873,7 +2873,7 @@ static void readMeasure206(Measure* m, int staffIdx, XmlReader& e, ReadContext&
|
|||
segment = m->getSegment(SegmentType::BeginBarLine, m->tick());
|
||||
BarLine* barLine = Factory::createBarLine(segment);
|
||||
barLine->setTrack(ctx.track());
|
||||
barLine->setBarLineType(TConv::fromXml(e.readElementAsciiText(), BarLineType::NORMAL));
|
||||
barLine->setBarLineType(TConv::fromXml(e.readAsciiText(), BarLineType::NORMAL));
|
||||
segment->add(barLine);
|
||||
} else if (tag == "Tuplet") {
|
||||
Tuplet* tuplet = Factory::createTuplet(m);
|
||||
|
@ -3203,7 +3203,7 @@ bool Read206::readScore206(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
} else if (tag == "LayerTag") {
|
||||
int id = e.intAttribute("id");
|
||||
const QString& t = e.attribute("tag");
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
if (id >= 0 && id < 32) {
|
||||
score->layerTags()[id] = t;
|
||||
score->layerTagComments()[id] = val;
|
||||
|
@ -3211,7 +3211,7 @@ bool Read206::readScore206(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
} else if (tag == "Layer") {
|
||||
Layer layer;
|
||||
layer.name = e.attribute("name");
|
||||
layer.tags = e.attribute("mask").toUInt();
|
||||
layer.tags = static_cast<uint>(e.intAttribute("mask"));
|
||||
score->layer().push_back(layer);
|
||||
e.readNext();
|
||||
} else if (tag == "currentLayer") {
|
||||
|
@ -3250,18 +3250,18 @@ bool Read206::readScore206(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
score->setMetaTag("copyright", text->xmlText());
|
||||
delete text;
|
||||
} else if (tag == "movement-number") {
|
||||
score->setMetaTag("movementNumber", e.readElementText());
|
||||
score->setMetaTag("movementNumber", e.readText());
|
||||
} else if (tag == "movement-title") {
|
||||
score->setMetaTag("movementTitle", e.readElementText());
|
||||
score->setMetaTag("movementTitle", e.readText());
|
||||
} else if (tag == "work-number") {
|
||||
score->setMetaTag("workNumber", e.readElementText());
|
||||
score->setMetaTag("workNumber", e.readText());
|
||||
} else if (tag == "work-title") {
|
||||
score->setMetaTag("workTitle", e.readElementText());
|
||||
score->setMetaTag("workTitle", e.readText());
|
||||
} else if (tag == "source") {
|
||||
score->setMetaTag("source", e.readElementText());
|
||||
score->setMetaTag("source", e.readText());
|
||||
} else if (tag == "metaTag") {
|
||||
QString name = e.attribute("name");
|
||||
score->setMetaTag(name, e.readElementText());
|
||||
score->setMetaTag(name, e.readText());
|
||||
} else if (tag == "Part") {
|
||||
Part* part = new Part(score);
|
||||
Read206::readPart206(part, e, ctx);
|
||||
|
@ -3326,12 +3326,12 @@ bool Read206::readScore206(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
} else if (tag == "PageList") {
|
||||
e.skipCurrentElement();
|
||||
} else if (tag == "name") {
|
||||
QString n = e.readElementText();
|
||||
QString n = e.readText();
|
||||
if (!score->isMaster()) { //ignore the name if it's not a child score
|
||||
score->excerpt()->setName(n);
|
||||
}
|
||||
} else if (tag == "layoutMode") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
if (s == "line") {
|
||||
score->setLayoutMode(LayoutMode::LINE);
|
||||
} else if (s == "system") {
|
||||
|
@ -3376,9 +3376,9 @@ Score::FileError Read206::read206(mu::engraving::MasterScore* masterScore, XmlRe
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "programVersion") {
|
||||
masterScore->setMscoreVersion(e.readElementText());
|
||||
masterScore->setMscoreVersion(e.readText());
|
||||
} else if (tag == "programRevision") {
|
||||
masterScore->setMscoreRevision(e.readIntHex());
|
||||
masterScore->setMscoreRevision(e.readInt(nullptr, 16));
|
||||
} else if (tag == "Score") {
|
||||
if (!readScore206(masterScore, e, ctx)) {
|
||||
return Score::FileError::FILE_BAD_FORMAT;
|
||||
|
|
|
@ -83,7 +83,7 @@ bool Read302::readScore302(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
} else if (tag == "LayerTag") {
|
||||
int id = e.intAttribute("id");
|
||||
const QString& t = e.attribute("tag");
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
if (id >= 0 && id < 32) {
|
||||
score->_layerTags[id] = t;
|
||||
score->_layerTagComments[id] = val;
|
||||
|
@ -91,7 +91,7 @@ bool Read302::readScore302(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
} else if (tag == "Layer") {
|
||||
Layer layer;
|
||||
layer.name = e.attribute("name");
|
||||
layer.tags = e.attribute("mask").toUInt();
|
||||
layer.tags = static_cast<uint>(e.intAttribute("mask"));
|
||||
score->_layer.push_back(layer);
|
||||
e.readNext();
|
||||
} else if (tag == "currentLayer") {
|
||||
|
@ -127,18 +127,18 @@ bool Read302::readScore302(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
} else if (tag == "copyright" || tag == "rights") {
|
||||
score->setMetaTag("copyright", Text::readXmlText(e, score));
|
||||
} else if (tag == "movement-number") {
|
||||
score->setMetaTag("movementNumber", e.readElementText());
|
||||
score->setMetaTag("movementNumber", e.readText());
|
||||
} else if (tag == "movement-title") {
|
||||
score->setMetaTag("movementTitle", e.readElementText());
|
||||
score->setMetaTag("movementTitle", e.readText());
|
||||
} else if (tag == "work-number") {
|
||||
score->setMetaTag("workNumber", e.readElementText());
|
||||
score->setMetaTag("workNumber", e.readText());
|
||||
} else if (tag == "work-title") {
|
||||
score->setMetaTag("workTitle", e.readElementText());
|
||||
score->setMetaTag("workTitle", e.readText());
|
||||
} else if (tag == "source") {
|
||||
score->setMetaTag("source", e.readElementText());
|
||||
score->setMetaTag("source", e.readText());
|
||||
} else if (tag == "metaTag") {
|
||||
QString name = e.attribute("name");
|
||||
score->setMetaTag(name, e.readElementText());
|
||||
score->setMetaTag(name, e.readText());
|
||||
} else if (tag == "Order") {
|
||||
ScoreOrder order;
|
||||
order.read(e);
|
||||
|
@ -206,12 +206,12 @@ bool Read302::readScore302(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
m->addExcerpt(ex);
|
||||
}
|
||||
} else if (tag == "name") {
|
||||
QString n = e.readElementText();
|
||||
QString n = e.readText();
|
||||
if (!score->isMaster()) { //ignore the name if it's not a child score
|
||||
score->excerpt()->setName(n);
|
||||
}
|
||||
} else if (tag == "layoutMode") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
if (s == "line") {
|
||||
score->setLayoutMode(LayoutMode::LINE);
|
||||
} else if (s == "system") {
|
||||
|
@ -270,9 +270,9 @@ Score::FileError Read302::read302(MasterScore* masterScore, XmlReader& e, ReadCo
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "programVersion") {
|
||||
masterScore->setMscoreVersion(e.readElementText());
|
||||
masterScore->setMscoreVersion(e.readText());
|
||||
} else if (tag == "programRevision") {
|
||||
masterScore->setMscoreRevision(e.readIntHex());
|
||||
masterScore->setMscoreRevision(e.readInt(nullptr, 16));
|
||||
} else if (tag == "Score") {
|
||||
if (!readScore302(masterScore, e, ctx)) {
|
||||
if (e.error() == XmlStreamReader::CustomError) {
|
||||
|
|
|
@ -78,9 +78,9 @@ void MeasureRW::readMeasure(Measure* measure, XmlReader& e, ReadContext& ctx, in
|
|||
|
||||
bool irregular;
|
||||
if (e.hasAttribute("len")) {
|
||||
QStringList sl = e.attribute("len").split('/');
|
||||
StringList sl = e.attribute("len").split(u'/');
|
||||
if (sl.size() == 2) {
|
||||
measure->_len = Fraction(sl[0].toInt(), sl[1].toInt());
|
||||
measure->_len = Fraction(sl.at(0).toInt(), sl.at(1).toInt());
|
||||
} else {
|
||||
LOGD("illegal measure size <%s>", qPrintable(e.attribute("len")));
|
||||
}
|
||||
|
|
|
@ -104,7 +104,7 @@ bool Read400::readScore400(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
} else if (tag == "LayerTag") {
|
||||
int id = e.intAttribute("id");
|
||||
const QString& t = e.attribute("tag");
|
||||
QString val(e.readElementText());
|
||||
QString val(e.readText());
|
||||
if (id >= 0 && id < 32) {
|
||||
score->_layerTags[id] = t;
|
||||
score->_layerTagComments[id] = val;
|
||||
|
@ -112,7 +112,7 @@ bool Read400::readScore400(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
} else if (tag == "Layer") {
|
||||
Layer layer;
|
||||
layer.name = e.attribute("name");
|
||||
layer.tags = e.attribute("mask").toUInt();
|
||||
layer.tags = static_cast<uint>(e.intAttribute("mask"));
|
||||
score->_layer.push_back(layer);
|
||||
e.readNext();
|
||||
} else if (tag == "currentLayer") {
|
||||
|
@ -141,18 +141,18 @@ bool Read400::readScore400(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
} else if (tag == "copyright" || tag == "rights") {
|
||||
score->setMetaTag("copyright", Text::readXmlText(e, score));
|
||||
} else if (tag == "movement-number") {
|
||||
score->setMetaTag("movementNumber", e.readElementText());
|
||||
score->setMetaTag("movementNumber", e.readText());
|
||||
} else if (tag == "movement-title") {
|
||||
score->setMetaTag("movementTitle", e.readElementText());
|
||||
score->setMetaTag("movementTitle", e.readText());
|
||||
} else if (tag == "work-number") {
|
||||
score->setMetaTag("workNumber", e.readElementText());
|
||||
score->setMetaTag("workNumber", e.readText());
|
||||
} else if (tag == "work-title") {
|
||||
score->setMetaTag("workTitle", e.readElementText());
|
||||
score->setMetaTag("workTitle", e.readText());
|
||||
} else if (tag == "source") {
|
||||
score->setMetaTag("source", e.readElementText());
|
||||
score->setMetaTag("source", e.readText());
|
||||
} else if (tag == "metaTag") {
|
||||
QString name = e.attribute("name");
|
||||
score->setMetaTag(name, e.readElementText());
|
||||
score->setMetaTag(name, e.readText());
|
||||
} else if (tag == "Order") {
|
||||
ScoreOrder order;
|
||||
order.read(e);
|
||||
|
@ -202,12 +202,12 @@ bool Read400::readScore400(Score* score, XmlReader& e, ReadContext& ctx)
|
|||
// Since version 400, the Excerpts is stored in a separate file
|
||||
e.skipCurrentElement();
|
||||
} else if (tag == "name") {
|
||||
QString n = e.readElementText();
|
||||
QString n = e.readText();
|
||||
if (!score->isMaster()) { //ignore the name if it's not a child score
|
||||
score->excerpt()->setName(n);
|
||||
}
|
||||
} else if (tag == "layoutMode") {
|
||||
QString s = e.readElementText();
|
||||
QString s = e.readText();
|
||||
if (s == "line") {
|
||||
score->setLayoutMode(LayoutMode::LINE);
|
||||
} else if (s == "system") {
|
||||
|
|
|
@ -212,9 +212,9 @@ Err ScoreReader::doRead(MasterScore* score, XmlReader& e, ReadContext& ctx)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "programVersion") {
|
||||
score->setMscoreVersion(e.readElementText());
|
||||
score->setMscoreVersion(e.readText());
|
||||
} else if (tag == "programRevision") {
|
||||
score->setMscoreRevision(e.readIntHex());
|
||||
score->setMscoreRevision(e.readInt(nullptr, 16));
|
||||
} else if (tag == "Score") {
|
||||
if (!Read400::readScore400(score, e, ctx)) {
|
||||
if (e.error() == XmlStreamReader::CustomError) {
|
||||
|
|
|
@ -36,10 +36,6 @@
|
|||
using namespace mu;
|
||||
|
||||
namespace mu::engraving {
|
||||
//---------------------------------------------------------
|
||||
// ~XmlReader
|
||||
//---------------------------------------------------------
|
||||
|
||||
XmlReader::~XmlReader()
|
||||
{
|
||||
if (m_selfContext) {
|
||||
|
@ -47,68 +43,6 @@ XmlReader::~XmlReader()
|
|||
}
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// intAttribute
|
||||
//---------------------------------------------------------
|
||||
|
||||
int XmlReader::intAttribute(const char* s, int _default) const
|
||||
{
|
||||
if (hasAttribute(s)) {
|
||||
return attribute(s).toInt();
|
||||
} else {
|
||||
return _default;
|
||||
}
|
||||
}
|
||||
|
||||
int XmlReader::intAttribute(const char* s) const
|
||||
{
|
||||
return attribute(s).toInt();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// doubleAttribute
|
||||
//---------------------------------------------------------
|
||||
|
||||
double XmlReader::doubleAttribute(const char* s) const
|
||||
{
|
||||
return attribute(s).toDouble();
|
||||
}
|
||||
|
||||
double XmlReader::doubleAttribute(const char* s, double _default) const
|
||||
{
|
||||
if (hasAttribute(s)) {
|
||||
return attribute(s).toDouble();
|
||||
} else {
|
||||
return _default;
|
||||
}
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// attribute
|
||||
//---------------------------------------------------------
|
||||
|
||||
QString XmlReader::attribute(const char* s, const QString& _default) const
|
||||
{
|
||||
if (hasAttribute(s)) {
|
||||
return attribute(s);
|
||||
} else {
|
||||
return _default;
|
||||
}
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// hasAttribute
|
||||
//---------------------------------------------------------
|
||||
|
||||
bool XmlReader::hasAttribute(const char* s) const
|
||||
{
|
||||
return mu::XmlStreamReader::hasAttribute(s);
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// readPoint
|
||||
//---------------------------------------------------------
|
||||
|
||||
PointF XmlReader::readPoint()
|
||||
{
|
||||
Q_ASSERT(tokenType() == XmlStreamReader::StartElement);
|
||||
|
@ -135,7 +69,7 @@ PointF XmlReader::readPoint()
|
|||
mu::draw::Color XmlReader::readColor()
|
||||
{
|
||||
Q_ASSERT(tokenType() == XmlStreamReader::StartElement);
|
||||
mu::draw::Color c;
|
||||
draw::Color c;
|
||||
c.setRed(intAttribute("r"));
|
||||
c.setGreen(intAttribute("g"));
|
||||
c.setBlue(intAttribute("b"));
|
||||
|
@ -194,9 +128,9 @@ RectF XmlReader::readRect()
|
|||
Fraction XmlReader::readFraction()
|
||||
{
|
||||
Q_ASSERT(tokenType() == XmlStreamReader::StartElement);
|
||||
int z = attribute("z", "0").toInt();
|
||||
int n = attribute("n", "1").toInt();
|
||||
const QString& s(readElementText());
|
||||
int z = intAttribute("z", 0);
|
||||
int n = intAttribute("n", 1);
|
||||
const QString& s(readText());
|
||||
if (!s.isEmpty()) {
|
||||
int i = s.indexOf('/');
|
||||
if (i == -1) {
|
||||
|
@ -227,13 +161,9 @@ void XmlReader::unknown()
|
|||
skipCurrentElement();
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// readDouble
|
||||
//---------------------------------------------------------
|
||||
|
||||
double XmlReader::readDouble(double min, double max)
|
||||
{
|
||||
double val = readElementText().toDouble();
|
||||
double val = readDouble();
|
||||
if (val < min) {
|
||||
val = min;
|
||||
} else if (val > max) {
|
||||
|
@ -242,34 +172,17 @@ double XmlReader::readDouble(double min, double max)
|
|||
return val;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// readBool
|
||||
//---------------------------------------------------------
|
||||
|
||||
bool XmlReader::readBool()
|
||||
{
|
||||
bool val;
|
||||
XmlStreamReader::TokenType tt = readNext();
|
||||
if (tt == XmlStreamReader::Characters) {
|
||||
val = text().toInt() != 0;
|
||||
readNext();
|
||||
} else {
|
||||
val = true;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
// htmlToString
|
||||
//---------------------------------------------------------
|
||||
|
||||
void XmlReader::htmlToString(int level, QString* s)
|
||||
void XmlReader::htmlToString(int level, String* s)
|
||||
{
|
||||
*s += QString("<%1").arg(name().toQLatin1String());
|
||||
*s += u'<' + String::fromAscii(name().ascii());
|
||||
for (const Attribute& a : attributes()) {
|
||||
*s += QString(" %1=\"%2\"").arg(a.name.ascii(), a.value.toQString());
|
||||
*s += u' ' + String::fromAscii(a.name.ascii()) + u"=\"" + a.value + u'\"';
|
||||
}
|
||||
*s += ">";
|
||||
*s += u'>';
|
||||
++level;
|
||||
for (;;) {
|
||||
XmlStreamReader::TokenType t = readNext();
|
||||
|
@ -278,12 +191,12 @@ void XmlReader::htmlToString(int level, QString* s)
|
|||
htmlToString(level, s);
|
||||
break;
|
||||
case XmlStreamReader::EndElement:
|
||||
*s += QString("</%1>").arg(name().toQLatin1String());
|
||||
*s += u"</" + String::fromAscii(name().ascii()) + u'>';
|
||||
--level;
|
||||
return;
|
||||
case XmlStreamReader::Characters:
|
||||
if (!s->isEmpty() || !isWhitespace()) {
|
||||
*s += text().toHtmlEscaped();
|
||||
if (!s->empty() || !isWhitespace()) {
|
||||
*s += text().toXmlEscaped();
|
||||
} else {
|
||||
LOGD() << "ignoring whitespace";
|
||||
}
|
||||
|
@ -303,9 +216,15 @@ void XmlReader::htmlToString(int level, QString* s)
|
|||
// read verbatim until end tag of current level is reached
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
QString XmlReader::readXml()
|
||||
String XmlReader::readXml()
|
||||
{
|
||||
QString s;
|
||||
static int count = 0;
|
||||
++count;
|
||||
if (count == 6) {
|
||||
int k = -1;
|
||||
}
|
||||
|
||||
String s;
|
||||
int level = 1;
|
||||
for (XmlStreamReader::TokenType t = readNext(); t != XmlStreamReader::EndElement; t = readNext()) {
|
||||
switch (t) {
|
||||
|
@ -316,7 +235,7 @@ QString XmlReader::readXml()
|
|||
break;
|
||||
case XmlStreamReader::Characters:
|
||||
if (!isWhitespace()) {
|
||||
s += text().toHtmlEscaped();
|
||||
s += text().toXmlEscaped();
|
||||
}
|
||||
break;
|
||||
case XmlStreamReader::Comment:
|
||||
|
@ -327,6 +246,7 @@ QString XmlReader::readXml()
|
|||
return s;
|
||||
}
|
||||
}
|
||||
LOGI() << count << "| " << s;
|
||||
return s;
|
||||
}
|
||||
|
||||
|
|
|
@ -54,31 +54,17 @@ public:
|
|||
|
||||
void unknown();
|
||||
|
||||
// attribute helper routines:
|
||||
QString attribute(const char* s) const { return mu::XmlStreamReader::attribute(s).toQString(); }
|
||||
QString attribute(const char* s, const QString&) const;
|
||||
int intAttribute(const char* s) const;
|
||||
int intAttribute(const char* s, int _default) const;
|
||||
double doubleAttribute(const char* s) const;
|
||||
double doubleAttribute(const char* s, double _default) const;
|
||||
bool hasAttribute(const char* s) const;
|
||||
|
||||
// helper routines based on readElementText():
|
||||
int readInt() { return readElementText().toInt(); }
|
||||
int readInt(bool* ok) { return readElementText().toInt(ok); }
|
||||
int readIntHex() { return readElementText().toInt(0, 16); }
|
||||
double readDouble() { return readElementText().toDouble(); }
|
||||
qlonglong readLongLong() { return readElementText().toLongLong(); }
|
||||
|
||||
bool readBool() { return XmlStreamReader::readInt(); }
|
||||
double readDouble(bool* ok = nullptr) { return XmlStreamReader::readDouble(ok); }
|
||||
double readDouble(double min, double max);
|
||||
bool readBool();
|
||||
|
||||
mu::PointF readPoint();
|
||||
mu::SizeF readSize();
|
||||
mu::ScaleF readScale();
|
||||
mu::RectF readRect();
|
||||
mu::draw::Color readColor();
|
||||
Fraction readFraction();
|
||||
QString readXml();
|
||||
String readXml();
|
||||
|
||||
void setDocName(const QString& s) { docName = s; }
|
||||
QString getDocName() const { return docName; }
|
||||
|
@ -90,12 +76,11 @@ public:
|
|||
void setContext(ReadContext* context);
|
||||
|
||||
private:
|
||||
|
||||
void htmlToString(int level, String*);
|
||||
|
||||
QString docName; // used for error reporting
|
||||
|
||||
qint64 _offsetLines = 0;
|
||||
|
||||
void htmlToString(int level, QString*);
|
||||
|
||||
mutable ReadContext* m_context = nullptr;
|
||||
mutable bool m_selfContext = false;
|
||||
};
|
||||
|
|
|
@ -113,35 +113,35 @@ bool MStyle::readProperties(XmlReader& e)
|
|||
if (t.name() == tag) {
|
||||
P_TYPE type = t.valueType();
|
||||
if (P_TYPE::SPATIUM == type) {
|
||||
set(idx, Spatium(e.readElementText().toDouble()));
|
||||
set(idx, Spatium(e.readDouble()));
|
||||
} else if (P_TYPE::REAL == type) {
|
||||
set(idx, e.readElementText().toDouble());
|
||||
set(idx, e.readDouble());
|
||||
} else if (P_TYPE::BOOL == type) {
|
||||
set(idx, bool(e.readElementText().toInt()));
|
||||
set(idx, bool(e.readInt()));
|
||||
} else if (P_TYPE::INT == type) {
|
||||
set(idx, e.readElementText().toInt());
|
||||
set(idx, e.readInt());
|
||||
} else if (P_TYPE::DIRECTION_V == type) {
|
||||
set(idx, DirectionV(e.readElementText().toInt()));
|
||||
set(idx, DirectionV(e.readInt()));
|
||||
} else if (P_TYPE::STRING == type) {
|
||||
set(idx, e.readElementText());
|
||||
set(idx, e.readText().toQString());
|
||||
} else if (P_TYPE::ALIGN == type) {
|
||||
Align align = TConv::fromXml(e.readElementText(), Align());
|
||||
Align align = TConv::fromXml(e.readText(), Align());
|
||||
set(idx, align);
|
||||
} else if (P_TYPE::POINT == type) {
|
||||
qreal x = e.doubleAttribute("x", 0.0);
|
||||
qreal y = e.doubleAttribute("y", 0.0);
|
||||
set(idx, PointF(x, y));
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (P_TYPE::SIZE == type) {
|
||||
qreal x = e.doubleAttribute("w", 0.0);
|
||||
qreal y = e.doubleAttribute("h", 0.0);
|
||||
set(idx, SizeF(x, y));
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (P_TYPE::SCALE == type) {
|
||||
qreal sx = e.doubleAttribute("w", 0.0);
|
||||
qreal sy = e.doubleAttribute("h", 0.0);
|
||||
set(idx, ScaleF(sx, sy));
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (P_TYPE::COLOR == type) {
|
||||
mu::draw::Color c;
|
||||
c.setRed(e.intAttribute("r"));
|
||||
|
@ -149,13 +149,13 @@ bool MStyle::readProperties(XmlReader& e)
|
|||
c.setBlue(e.intAttribute("b"));
|
||||
c.setAlpha(e.intAttribute("a", 255));
|
||||
set(idx, c);
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (P_TYPE::PLACEMENT_V == type) {
|
||||
set(idx, PlacementV(e.readElementText().toInt()));
|
||||
set(idx, PlacementV(e.readText().toInt()));
|
||||
} else if (P_TYPE::PLACEMENT_H == type) {
|
||||
set(idx, PlacementH(e.readElementText().toInt()));
|
||||
set(idx, PlacementH(e.readText().toInt()));
|
||||
} else if (P_TYPE::HOOK_TYPE == type) {
|
||||
set(idx, HookType(e.readElementText().toInt()));
|
||||
set(idx, HookType(e.readText().toInt()));
|
||||
} else {
|
||||
ASSERT_X("unhandled type " + QString::number(int(type)));
|
||||
}
|
||||
|
@ -183,7 +183,7 @@ bool MStyle::readStyleValCompat(XmlReader& e)
|
|||
const PointF val(x, y);
|
||||
set(Sid::tempoPosAbove, val);
|
||||
set(Sid::tempoPosBelow, val);
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
return true;
|
||||
}
|
||||
if (readTextStyleValCompat(e)) {
|
||||
|
@ -229,7 +229,7 @@ bool MStyle::readTextStyleValCompat(XmlReader& e)
|
|||
return false;
|
||||
}
|
||||
|
||||
const bool readVal = bool(e.readElementText().toInt());
|
||||
const bool readVal = bool(e.readText().toInt());
|
||||
const PropertyValue& val = value(sid);
|
||||
FontStyle newFontStyle = val.isValid() ? FontStyle(val.toInt()) : FontStyle::Normal;
|
||||
if (readVal) {
|
||||
|
@ -289,7 +289,7 @@ void MStyle::read(XmlReader& e, compat::ReadChordListHook* readChordListHook)
|
|||
|
||||
if (tag == "TextStyle") {
|
||||
//readTextStyle206(this, e); // obsolete
|
||||
e.readElementText();
|
||||
e.readText();
|
||||
} else if (tag == "ottavaHook") { // obsolete, for 3.0dev bw. compatibility, should be removed in final release
|
||||
qreal y = qAbs(e.readDouble());
|
||||
set(Sid::ottavaHookAbove, y);
|
||||
|
|
|
@ -615,6 +615,17 @@ struct InstrumentTrackId {
|
|||
}
|
||||
};
|
||||
|
||||
// Tremolo subtypes:
|
||||
enum class TremoloType : signed char {
|
||||
INVALID_TREMOLO = -1,
|
||||
R8 = 0, R16, R32, R64, BUZZ_ROLL, // one note tremolo (repeat)
|
||||
C8, C16, C32, C64 // two note tremolo (change)
|
||||
};
|
||||
|
||||
enum class BracketType : signed char {
|
||||
NORMAL, BRACE, SQUARE, LINE, NO_BRACKET = -1
|
||||
};
|
||||
|
||||
using InstrumentTrackIdSet = std::unordered_set<InstrumentTrackId>;
|
||||
|
||||
using staff_idx_t = size_t;
|
||||
|
|
|
@ -1339,3 +1339,56 @@ BarLineType TConv::fromXml(const AsciiStringView& tag, BarLineType def)
|
|||
|
||||
return def;
|
||||
}
|
||||
|
||||
static const std::vector<Item<TremoloType> > TREMOLO_TYPES = {
|
||||
{ TremoloType::R8, "r8" },
|
||||
{ TremoloType::R16, "r16" },
|
||||
{ TremoloType::R32, "r32" },
|
||||
{ TremoloType::R64, "r64" },
|
||||
{ TremoloType::C8, "c8" },
|
||||
{ TremoloType::C16, "c16" },
|
||||
{ TremoloType::C32, "c32" },
|
||||
{ TremoloType::C64, "c64" },
|
||||
{ TremoloType::BUZZ_ROLL, "buzzroll" },
|
||||
};
|
||||
|
||||
AsciiStringView TConv::toXml(TremoloType v)
|
||||
{
|
||||
return findXmlTagByType<TremoloType>(TREMOLO_TYPES, v);
|
||||
}
|
||||
|
||||
TremoloType TConv::fromXml(const AsciiStringView& tag, TremoloType def)
|
||||
{
|
||||
return findTypeByXmlTag<TremoloType>(TREMOLO_TYPES, tag, def);
|
||||
}
|
||||
|
||||
static const std::vector<Item<BracketType> > BRACKET_TYPES = {
|
||||
{ BracketType::NORMAL, "Normal" },
|
||||
{ BracketType::BRACE, "Brace" },
|
||||
{ BracketType::SQUARE, "Square" },
|
||||
{ BracketType::LINE, "Line" },
|
||||
{ BracketType::NO_BRACKET, "NoBracket" }
|
||||
};
|
||||
|
||||
AsciiStringView TConv::toXml(BracketType v)
|
||||
{
|
||||
return findXmlTagByType<BracketType>(BRACKET_TYPES, v);
|
||||
}
|
||||
|
||||
BracketType TConv::fromXml(const AsciiStringView& tag, BracketType def)
|
||||
{
|
||||
auto it = std::find_if(BRACKET_TYPES.cbegin(), BRACKET_TYPES.cend(), [tag](const Item<BracketType>& i) {
|
||||
return i.xml == tag;
|
||||
});
|
||||
|
||||
if (it != BRACKET_TYPES.cend()) {
|
||||
return it->type;
|
||||
}
|
||||
|
||||
// compatibility
|
||||
if (tag == "Akkolade") {
|
||||
return BracketType::BRACE;
|
||||
}
|
||||
|
||||
return def;
|
||||
}
|
||||
|
|
|
@ -144,6 +144,12 @@ public:
|
|||
|
||||
static AsciiStringView toXml(BarLineType v);
|
||||
static BarLineType fromXml(const AsciiStringView& str, BarLineType def);
|
||||
|
||||
static AsciiStringView toXml(TremoloType v);
|
||||
static TremoloType fromXml(const AsciiStringView& str, TremoloType def);
|
||||
|
||||
static AsciiStringView toXml(BracketType v);
|
||||
static BracketType fromXml(const AsciiStringView& str, BracketType def);
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
@ -35,7 +35,7 @@ struct XmlStreamReader::Xml {
|
|||
XMLDocument doc;
|
||||
XMLNode* node = nullptr;
|
||||
XMLError err;
|
||||
QString customErr;
|
||||
String customErr;
|
||||
};
|
||||
|
||||
XmlStreamReader::XmlStreamReader()
|
||||
|
@ -183,7 +183,7 @@ void XmlStreamReader::tryParseEntity(Xml* xml)
|
|||
if (list.size() == 3) {
|
||||
String name = list.at(1);
|
||||
String val = list.at(2);
|
||||
m_entities[u"&" + name + u";"] = val.mid(1, val.size() - 2);
|
||||
m_entities[u'&' + name + u';'] = val.mid(1, val.size() - 2);
|
||||
} else {
|
||||
LOGW() << "unknown ENTITY: " << val;
|
||||
}
|
||||
|
@ -245,6 +245,19 @@ AsciiStringView XmlStreamReader::name() const
|
|||
return (m_xml->node && m_xml->node->ToElement()) ? m_xml->node->Value() : AsciiStringView();
|
||||
}
|
||||
|
||||
bool XmlStreamReader::hasAttribute(const char* name) const
|
||||
{
|
||||
if (m_token != TokenType::StartElement) {
|
||||
return false;
|
||||
}
|
||||
|
||||
XMLElement* e = m_xml->node->ToElement();
|
||||
if (!e) {
|
||||
return false;
|
||||
}
|
||||
return e->FindAttribute(name) != nullptr;
|
||||
}
|
||||
|
||||
String XmlStreamReader::attribute(const char* name) const
|
||||
{
|
||||
if (m_token != TokenType::StartElement) {
|
||||
|
@ -258,6 +271,11 @@ String XmlStreamReader::attribute(const char* name) const
|
|||
return String(e->Attribute(name));
|
||||
}
|
||||
|
||||
String XmlStreamReader::attribute(const char* name, const String& def) const
|
||||
{
|
||||
return hasAttribute(name) ? attribute(name) : def;
|
||||
}
|
||||
|
||||
AsciiStringView XmlStreamReader::asciiAttribute(const char* name) const
|
||||
{
|
||||
if (m_token != TokenType::StartElement) {
|
||||
|
@ -271,17 +289,29 @@ AsciiStringView XmlStreamReader::asciiAttribute(const char* name) const
|
|||
return e->Attribute(name);
|
||||
}
|
||||
|
||||
bool XmlStreamReader::hasAttribute(const char* name) const
|
||||
AsciiStringView XmlStreamReader::asciiAttribute(const char* name, const AsciiStringView& def) const
|
||||
{
|
||||
if (m_token != TokenType::StartElement) {
|
||||
return false;
|
||||
}
|
||||
return hasAttribute(name) ? asciiAttribute(name) : def;
|
||||
}
|
||||
|
||||
XMLElement* e = m_xml->node->ToElement();
|
||||
if (!e) {
|
||||
return false;
|
||||
}
|
||||
return e->FindAttribute(name) != nullptr;
|
||||
int XmlStreamReader::intAttribute(const char* name) const
|
||||
{
|
||||
return asciiAttribute(name).toInt();
|
||||
}
|
||||
|
||||
int XmlStreamReader::intAttribute(const char* name, int def) const
|
||||
{
|
||||
return hasAttribute(name) ? intAttribute(name) : def;
|
||||
}
|
||||
|
||||
double XmlStreamReader::doubleAttribute(const char* name) const
|
||||
{
|
||||
return asciiAttribute(name).toDouble();
|
||||
}
|
||||
|
||||
double XmlStreamReader::doubleAttribute(const char* name, double def) const
|
||||
{
|
||||
return hasAttribute(name) ? doubleAttribute(name) : def;
|
||||
}
|
||||
|
||||
std::vector<XmlStreamReader::Attribute> XmlStreamReader::attributes() const
|
||||
|
@ -305,7 +335,23 @@ std::vector<XmlStreamReader::Attribute> XmlStreamReader::attributes() const
|
|||
return attrs;
|
||||
}
|
||||
|
||||
QString XmlStreamReader::readElementText()
|
||||
String XmlStreamReader::text() const
|
||||
{
|
||||
if (m_xml->node && (m_xml->node->ToText() || m_xml->node->ToComment())) {
|
||||
return nodeValue(m_xml);
|
||||
}
|
||||
return String();
|
||||
}
|
||||
|
||||
AsciiStringView XmlStreamReader::asciiText() const
|
||||
{
|
||||
if (m_xml->node && (m_xml->node->ToText() || m_xml->node->ToComment())) {
|
||||
return m_xml->node->Value();
|
||||
}
|
||||
return AsciiStringView();
|
||||
}
|
||||
|
||||
String XmlStreamReader::readText()
|
||||
{
|
||||
if (isStartElement()) {
|
||||
String result;
|
||||
|
@ -315,7 +361,7 @@ QString XmlStreamReader::readElementText()
|
|||
result = nodeValue(m_xml);
|
||||
break;
|
||||
case EndElement:
|
||||
return result.toQString();
|
||||
return result;
|
||||
case Comment:
|
||||
break;
|
||||
case StartElement:
|
||||
|
@ -325,18 +371,10 @@ QString XmlStreamReader::readElementText()
|
|||
}
|
||||
}
|
||||
}
|
||||
return QString();
|
||||
return String();
|
||||
}
|
||||
|
||||
QString XmlStreamReader::text() const
|
||||
{
|
||||
if (m_xml->node && (m_xml->node->ToText() || m_xml->node->ToComment())) {
|
||||
return nodeValue(m_xml).toQString();
|
||||
}
|
||||
return QString();
|
||||
}
|
||||
|
||||
AsciiStringView XmlStreamReader::readElementAsciiText()
|
||||
AsciiStringView XmlStreamReader::readAsciiText()
|
||||
{
|
||||
if (isStartElement()) {
|
||||
AsciiStringView result;
|
||||
|
@ -359,12 +397,16 @@ AsciiStringView XmlStreamReader::readElementAsciiText()
|
|||
return AsciiStringView();
|
||||
}
|
||||
|
||||
AsciiStringView XmlStreamReader::asciiText() const
|
||||
int XmlStreamReader::readInt(bool* ok, int base)
|
||||
{
|
||||
if (m_xml->node && (m_xml->node->ToText() || m_xml->node->ToComment())) {
|
||||
return m_xml->node->Value();
|
||||
}
|
||||
return AsciiStringView();
|
||||
AsciiStringView s = readAsciiText();
|
||||
return s.toInt(ok, base);
|
||||
}
|
||||
|
||||
double XmlStreamReader::readDouble(bool* ok)
|
||||
{
|
||||
AsciiStringView s = readAsciiText();
|
||||
return s.toDouble(ok);
|
||||
}
|
||||
|
||||
int64_t XmlStreamReader::lineNumber() const
|
||||
|
@ -396,15 +438,15 @@ bool XmlStreamReader::isError() const
|
|||
return error() != NoError;
|
||||
}
|
||||
|
||||
QString XmlStreamReader::errorString() const
|
||||
String XmlStreamReader::errorString() const
|
||||
{
|
||||
if (!m_xml->customErr.isEmpty()) {
|
||||
if (!m_xml->customErr.empty()) {
|
||||
return m_xml->customErr;
|
||||
}
|
||||
return m_xml->doc.ErrorStr();
|
||||
return String::fromUtf8(m_xml->doc.ErrorStr());
|
||||
}
|
||||
|
||||
void XmlStreamReader::raiseError(const QString& message)
|
||||
void XmlStreamReader::raiseError(const String& message)
|
||||
{
|
||||
m_xml->customErr = !message.isEmpty() ? message : "CustomError";
|
||||
m_xml->customErr = message;
|
||||
}
|
||||
|
|
|
@ -90,23 +90,30 @@ public:
|
|||
|
||||
AsciiStringView name() const;
|
||||
|
||||
String attribute(const char* name) const;
|
||||
AsciiStringView asciiAttribute(const char* name) const;
|
||||
bool hasAttribute(const char* name) const;
|
||||
String attribute(const char* name) const;
|
||||
String attribute(const char* name, const String& def) const;
|
||||
AsciiStringView asciiAttribute(const char* name) const;
|
||||
AsciiStringView asciiAttribute(const char* name, const AsciiStringView& def) const;
|
||||
int intAttribute(const char* name) const;
|
||||
int intAttribute(const char* name, int def) const;
|
||||
double doubleAttribute(const char* name) const;
|
||||
double doubleAttribute(const char* name, double def) const;
|
||||
std::vector<Attribute> attributes() const;
|
||||
|
||||
QString readElementText();
|
||||
QString text() const;
|
||||
|
||||
AsciiStringView readElementAsciiText();
|
||||
String text() const;
|
||||
AsciiStringView asciiText() const;
|
||||
String readText();
|
||||
AsciiStringView readAsciiText();
|
||||
int readInt(bool* ok = nullptr, int base = 10);
|
||||
double readDouble(bool* ok = nullptr);
|
||||
|
||||
int64_t lineNumber() const;
|
||||
int64_t columnNumber() const;
|
||||
Error error() const;
|
||||
bool isError() const;
|
||||
QString errorString() const;
|
||||
void raiseError(const QString& message = QString());
|
||||
String errorString() const;
|
||||
void raiseError(const String& message);
|
||||
|
||||
private:
|
||||
struct Xml;
|
||||
|
|
|
@ -78,47 +78,19 @@ void XmlStreamWriter::writeDoctype(const QString& type)
|
|||
m_impl->stream << "<!DOCTYPE " << type << '>' << '\n';
|
||||
}
|
||||
|
||||
QString XmlStreamWriter::escapeSymbol(ushort c)
|
||||
String XmlStreamWriter::escapeSymbol(char16_t c)
|
||||
{
|
||||
switch (c) {
|
||||
case '<':
|
||||
return QLatin1String("<");
|
||||
case '>':
|
||||
return QLatin1String(">");
|
||||
case '&':
|
||||
return QLatin1String("&");
|
||||
case '\"':
|
||||
return QLatin1String(""");
|
||||
default:
|
||||
// ignore invalid characters in xml 1.0
|
||||
if ((c < 0x20 && c != 0x09 && c != 0x0A && c != 0x0D)) {
|
||||
return QString();
|
||||
}
|
||||
return QString(QChar(c));
|
||||
}
|
||||
}
|
||||
|
||||
QString XmlStreamWriter::escapeString(const QString& s)
|
||||
{
|
||||
QString escaped;
|
||||
escaped.reserve(s.size());
|
||||
for (int i = 0; i < s.size(); ++i) {
|
||||
ushort c = s.at(i).unicode();
|
||||
escaped += escapeSymbol(c);
|
||||
}
|
||||
return escaped;
|
||||
return String::toXmlEscaped(c);
|
||||
}
|
||||
|
||||
String XmlStreamWriter::escapeString(const String& s)
|
||||
{
|
||||
//! TODO
|
||||
return String::fromQString(escapeString(s.toQString()));
|
||||
return String::toXmlEscaped(s);
|
||||
}
|
||||
|
||||
String XmlStreamWriter::escapeString(const AsciiStringView& s)
|
||||
{
|
||||
//! TODO
|
||||
return String::fromQString(escapeString(QString(s.ascii())));
|
||||
return String::toXmlEscaped(String::fromUtf8(s.ascii()));
|
||||
}
|
||||
|
||||
void XmlStreamWriter::writeValue(const Value& v)
|
||||
|
|
|
@ -61,10 +61,9 @@ public:
|
|||
|
||||
void comment(const String& text);
|
||||
|
||||
static QString escapeSymbol(ushort c);
|
||||
static String escapeSymbol(char16_t c);
|
||||
static String escapeString(const AsciiStringView& s);
|
||||
static String escapeString(const String& s);
|
||||
static QString escapeString(const QString& s);
|
||||
|
||||
protected:
|
||||
void startElementRaw(const QString& name);
|
||||
|
|
|
@ -107,6 +107,17 @@ TEST_F(Global_Types_StringTests, String_Convert)
|
|||
//! CHECK
|
||||
EXPECT_EQ(sstr, sstr_origin);
|
||||
}
|
||||
|
||||
{
|
||||
//! GIVEN Some ASCII string
|
||||
AsciiStringView ascii = "123abc";
|
||||
//! DO
|
||||
String str = String::fromAscii(ascii.ascii());
|
||||
//! CHECK
|
||||
EXPECT_EQ(str.size(), 6);
|
||||
EXPECT_EQ(str.at(0), u'1');
|
||||
EXPECT_EQ(str.at(3), u'a');
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(Global_Types_StringTests, String_Compare)
|
||||
|
@ -239,6 +250,36 @@ TEST_F(Global_Types_StringTests, String_SubStr)
|
|||
}
|
||||
}
|
||||
|
||||
TEST_F(Global_Types_StringTests, String_Trimmed)
|
||||
{
|
||||
{
|
||||
//! GIVEN Some String
|
||||
String str = u" 123abc";
|
||||
//! DO
|
||||
String newStr = str.trimmed();
|
||||
//! CHECK
|
||||
EXPECT_EQ(newStr, u"123abc");
|
||||
}
|
||||
|
||||
{
|
||||
//! GIVEN Some String
|
||||
String str = u"123abc ";
|
||||
//! DO
|
||||
String newStr = str.trimmed();
|
||||
//! CHECK
|
||||
EXPECT_EQ(newStr, u"123abc");
|
||||
}
|
||||
|
||||
{
|
||||
//! GIVEN Some String
|
||||
String str = u" 123abc ";
|
||||
//! DO
|
||||
String newStr = str.trimmed();
|
||||
//! CHECK
|
||||
EXPECT_EQ(newStr, u"123abc");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(Global_Types_StringTests, String_Split)
|
||||
{
|
||||
{
|
||||
|
|
|
@ -33,3 +33,16 @@ QString mu::qtrc(const char* context, const char* key, const char* disambiguatio
|
|||
{
|
||||
return QCoreApplication::translate(context, key, disambiguation, n);
|
||||
}
|
||||
|
||||
QString mu::qtrc(const char* context, const String& key, const char* disambiguation, int n)
|
||||
{
|
||||
ByteArray utf8 = key.toUtf8();
|
||||
return QCoreApplication::translate(context, utf8.constChar(), disambiguation, n);
|
||||
}
|
||||
|
||||
QString mu::qtrc(const char* context, const String& key, const String& disambiguation, int n)
|
||||
{
|
||||
ByteArray keyutf8 = key.toUtf8();
|
||||
ByteArray disutf8 = disambiguation.toUtf8();
|
||||
return QCoreApplication::translate(context, keyutf8.constChar(), disutf8.empty() ? nullptr : disutf8.constChar(), n);
|
||||
}
|
||||
|
|
|
@ -23,10 +23,14 @@
|
|||
#define MU_FRAMEWORK_TRANSLATION_H
|
||||
|
||||
#include <QString>
|
||||
#include "types/string.h"
|
||||
|
||||
namespace mu {
|
||||
std::string trc(const char* context, const char* key, const char* disambiguation = nullptr, int n = -1);
|
||||
|
||||
QString qtrc(const char* context, const char* key, const char* disambiguation = nullptr, int n = -1);
|
||||
QString qtrc(const char* context, const String& key, const char* disambiguation = nullptr, int n = -1);
|
||||
QString qtrc(const char* context, const String& key, const String& disambiguation, int n = -1);
|
||||
}
|
||||
|
||||
#endif // MU_FRAMEWORK_TRANSLATION_H
|
||||
|
|
|
@ -31,12 +31,66 @@
|
|||
|
||||
using namespace mu;
|
||||
|
||||
// Helpers
|
||||
|
||||
static int toInt_helper(const char* str, bool* ok, int base)
|
||||
{
|
||||
if (!str) {
|
||||
return 0;
|
||||
}
|
||||
const char* currentLoc = setlocale(LC_NUMERIC, "C");
|
||||
char* end = nullptr;
|
||||
long int v = static_cast<int>(std::strtol(str, &end, base));
|
||||
setlocale(LC_NUMERIC, currentLoc);
|
||||
if (ok) {
|
||||
size_t sz = std::strlen(end);
|
||||
*ok = sz != std::strlen(str);
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
static double toDouble_helper(const char* str, bool* ok)
|
||||
{
|
||||
if (!str) {
|
||||
return 0.0;
|
||||
}
|
||||
const char* currentLoc = setlocale(LC_NUMERIC, "C");
|
||||
char* end = nullptr;
|
||||
double v = std::strtod(str, &end);
|
||||
setlocale(LC_NUMERIC, currentLoc);
|
||||
if (ok) {
|
||||
size_t sz = std::strlen(end);
|
||||
*ok = sz != std::strlen(str);
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
static void ltrim_helper(std::u16string& s)
|
||||
{
|
||||
s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](char16_t ch) {
|
||||
return !std::isspace(ch);
|
||||
}));
|
||||
}
|
||||
|
||||
static void rtrim_helper(std::u16string& s)
|
||||
{
|
||||
s.erase(std::find_if(s.rbegin(), s.rend(), [](char16_t ch) {
|
||||
return !std::isspace(ch);
|
||||
}).base(), s.end());
|
||||
}
|
||||
|
||||
static void trim_helper(std::u16string& s)
|
||||
{
|
||||
ltrim_helper(s);
|
||||
rtrim_helper(s);
|
||||
}
|
||||
|
||||
// ============================
|
||||
// Char
|
||||
// ============================
|
||||
char Char::ascii(bool* ok) const
|
||||
char Char::toAscii(char16_t c, bool* ok)
|
||||
{
|
||||
if (m_ch > 0xff) {
|
||||
if (c > 0xff) {
|
||||
if (ok) {
|
||||
*ok = false;
|
||||
}
|
||||
|
@ -45,10 +99,20 @@ char Char::ascii(bool* ok) const
|
|||
if (ok) {
|
||||
*ok = true;
|
||||
}
|
||||
return static_cast<char>(m_ch);
|
||||
return static_cast<char>(c);
|
||||
}
|
||||
}
|
||||
|
||||
char16_t Char::fromAscii(char c)
|
||||
{
|
||||
return static_cast<char16_t>(c);
|
||||
}
|
||||
|
||||
char Char::toAscii(bool* ok) const
|
||||
{
|
||||
return toAscii(m_ch);
|
||||
}
|
||||
|
||||
// ============================
|
||||
// UtfCodec
|
||||
// ============================
|
||||
|
@ -76,6 +140,12 @@ String::String(const char16_t* str)
|
|||
m_data = std::make_shared<std::u16string>(str);
|
||||
}
|
||||
|
||||
String::String(const Char& ch)
|
||||
{
|
||||
m_data = std::make_shared<std::u16string>();
|
||||
*m_data.get() += ch.unicode();
|
||||
}
|
||||
|
||||
const std::u16string& String::constStr() const
|
||||
{
|
||||
return *m_data.get();
|
||||
|
@ -87,6 +157,25 @@ std::u16string& String::mutStr()
|
|||
return *m_data.get();
|
||||
}
|
||||
|
||||
void String::reserve(size_t i)
|
||||
{
|
||||
mutStr().reserve(i);
|
||||
}
|
||||
|
||||
bool String::operator ==(const AsciiStringView& s) const
|
||||
{
|
||||
if (size() != s.size()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < s.size(); ++i) {
|
||||
if (at(i).toAscii() != s.at(i).ascii()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void String::detach()
|
||||
{
|
||||
if (!m_data) {
|
||||
|
@ -106,15 +195,33 @@ String& String::operator=(const char16_t* str)
|
|||
return *this;
|
||||
}
|
||||
|
||||
String& String::operator +=(const String& s)
|
||||
String& String::operator +=(const char16_t* s)
|
||||
{
|
||||
mutStr() += s;
|
||||
return *this;
|
||||
}
|
||||
|
||||
String& String::append(Char ch)
|
||||
{
|
||||
mutStr() += ch.unicode();
|
||||
return *this;
|
||||
}
|
||||
|
||||
String& String::append(const String& s)
|
||||
{
|
||||
mutStr() += s.constStr();
|
||||
return *this;
|
||||
}
|
||||
|
||||
String& String::operator +=(const char16_t* s)
|
||||
String& String::prepend(Char ch)
|
||||
{
|
||||
mutStr() += s;
|
||||
mutStr() = ch.unicode() + constStr();
|
||||
return *this;
|
||||
}
|
||||
|
||||
String& String::prepend(const String& s)
|
||||
{
|
||||
mutStr() = s.constStr() + constStr();
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
@ -132,6 +239,18 @@ ByteArray String::toUtf8() const
|
|||
return ByteArray(reinterpret_cast<const uint8_t*>(str.c_str()), str.size());
|
||||
}
|
||||
|
||||
String String::fromAscii(const char* str)
|
||||
{
|
||||
size_t sz = std::strlen(str);
|
||||
String s;
|
||||
s.m_data->resize(sz);
|
||||
std::u16string& data = *s.m_data.get();
|
||||
for (size_t i = 0; i < sz; ++i) {
|
||||
data[i] = Char::fromAscii(str[i]);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
ByteArray String::toAscii(bool* ok) const
|
||||
{
|
||||
ByteArray ba;
|
||||
|
@ -143,7 +262,7 @@ ByteArray String::toAscii(bool* ok) const
|
|||
|
||||
for (size_t i = 0; i < size(); ++i) {
|
||||
bool cok = false;
|
||||
char ch = Char(m_data->at(i)).ascii(&cok);
|
||||
char ch = Char::toAscii(m_data->at(i), &cok);
|
||||
if (!cok && ok) {
|
||||
*ok = false;
|
||||
}
|
||||
|
@ -194,6 +313,11 @@ bool String::empty() const
|
|||
return m_data->empty();
|
||||
}
|
||||
|
||||
void String::clear()
|
||||
{
|
||||
m_data->clear();
|
||||
}
|
||||
|
||||
Char String::at(size_t i) const
|
||||
{
|
||||
IF_ASSERT_FAILED(i < size()) {
|
||||
|
@ -214,12 +338,12 @@ bool String::startsWith(const AsciiStringView& str, CaseSensitivity cs) const
|
|||
}
|
||||
|
||||
for (size_t i = 0; i < str.size(); ++i) {
|
||||
if (Char(m_data->at(i)).ascii() == str.at(i).ascii()) {
|
||||
if (Char(m_data->at(i)).toAscii() == str.at(i).ascii()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (cs == CaseInsensitive) {
|
||||
if (AsciiChar::toLower(Char(m_data->at(i)).ascii()) == AsciiChar::toLower(str.at(i).ascii())) {
|
||||
if (AsciiChar::toLower(Char(m_data->at(i)).toAscii()) == AsciiChar::toLower(str.at(i).ascii())) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
@ -238,12 +362,12 @@ bool String::endsWith(const AsciiStringView& str, CaseSensitivity cs) const
|
|||
|
||||
size_t start = size() - str.size();
|
||||
for (size_t i = 0; i < str.size(); ++i) {
|
||||
if (Char(m_data->at(start + i)).ascii() == str.at(i).ascii()) {
|
||||
if (Char(m_data->at(start + i)).toAscii() == str.at(i).ascii()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (cs == CaseInsensitive) {
|
||||
if (AsciiChar::toLower(Char(m_data->at(start + i)).ascii()) == AsciiChar::toLower(str.at(i).ascii())) {
|
||||
if (AsciiChar::toLower(Char(m_data->at(start + i)).toAscii()) == AsciiChar::toLower(str.at(i).ascii())) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
@ -288,6 +412,61 @@ String String::mid(size_t pos, size_t count) const
|
|||
return s;
|
||||
}
|
||||
|
||||
String String::trimmed() const
|
||||
{
|
||||
String s = *this;
|
||||
trim_helper(s.mutStr());
|
||||
return s;
|
||||
}
|
||||
|
||||
String String::toXmlEscaped(char16_t c)
|
||||
{
|
||||
switch (c) {
|
||||
case u'<':
|
||||
return String(u"<");
|
||||
case u'>':
|
||||
return String(u">");
|
||||
case u'&':
|
||||
return String(u"&");
|
||||
case u'\"':
|
||||
return String(u""");
|
||||
default:
|
||||
// ignore invalid characters in xml 1.0
|
||||
if ((c < 0x0020 && c != 0x0009 && c != 0x000A && c != 0x000D)) {
|
||||
return String();
|
||||
}
|
||||
return String(Char(c));
|
||||
}
|
||||
}
|
||||
|
||||
String String::toXmlEscaped(const String& s)
|
||||
{
|
||||
String escaped;
|
||||
escaped.reserve(s.size());
|
||||
for (size_t i = 0; i < s.size(); ++i) {
|
||||
char16_t c = s.at(i).unicode();
|
||||
escaped += toXmlEscaped(c);
|
||||
}
|
||||
return escaped;
|
||||
}
|
||||
|
||||
String String::toXmlEscaped() const
|
||||
{
|
||||
return toXmlEscaped(*this);
|
||||
}
|
||||
|
||||
int String::toInt(bool* ok, int base) const
|
||||
{
|
||||
ByteArray ba = toUtf8();
|
||||
return toInt_helper(ba.constChar(), ok, base);
|
||||
}
|
||||
|
||||
double String::toDouble(bool* ok) const
|
||||
{
|
||||
ByteArray ba = toUtf8();
|
||||
return toDouble_helper(ba.constChar(), ok);
|
||||
}
|
||||
|
||||
// ============================
|
||||
// AsciiStringView
|
||||
// ============================
|
||||
|
@ -338,28 +517,12 @@ bool AsciiStringView::contains(char ch) const
|
|||
return false;
|
||||
}
|
||||
|
||||
int AsciiStringView::toInt(bool* ok) const
|
||||
int AsciiStringView::toInt(bool* ok, int base) const
|
||||
{
|
||||
const char* currentLoc = setlocale(LC_NUMERIC, "C");
|
||||
char* end = nullptr;
|
||||
long int v = static_cast<int>(std::strtol(m_data, &end, 10));
|
||||
setlocale(LC_NUMERIC, currentLoc);
|
||||
if (ok) {
|
||||
size_t sz = std::strlen(end);
|
||||
*ok = sz != m_size;
|
||||
}
|
||||
return v;
|
||||
return toInt_helper(m_data, ok, base);
|
||||
}
|
||||
|
||||
double AsciiStringView::toDouble(bool* ok) const
|
||||
{
|
||||
const char* currentLoc = setlocale(LC_NUMERIC, "C");
|
||||
char* end = nullptr;
|
||||
double v = std::strtod(m_data, &end);
|
||||
setlocale(LC_NUMERIC, currentLoc);
|
||||
if (ok) {
|
||||
size_t sz = std::strlen(end);
|
||||
*ok = sz != m_size;
|
||||
}
|
||||
return v;
|
||||
return toDouble_helper(m_data, ok);
|
||||
}
|
||||
|
|
|
@ -45,16 +45,18 @@ struct AsciiChar
|
|||
public:
|
||||
AsciiChar() = default;
|
||||
explicit AsciiChar(char c)
|
||||
: ch(c) {}
|
||||
: m_ch(c) {}
|
||||
|
||||
inline char ascii() const noexcept { return ch; }
|
||||
inline char16_t unicode() const noexcept { return char16_t(ch); }
|
||||
inline char ascii() const noexcept { return m_ch; }
|
||||
inline char16_t unicode() const noexcept { return char16_t(m_ch); }
|
||||
inline char toLower() const { return toLower(m_ch); }
|
||||
inline char toUpper() const { return toUpper(m_ch); }
|
||||
|
||||
static char toLower(char ch);
|
||||
static char toUpper(char ch);
|
||||
|
||||
private:
|
||||
char ch = 0;
|
||||
char m_ch = 0;
|
||||
};
|
||||
|
||||
// ============================
|
||||
|
@ -78,7 +80,10 @@ public:
|
|||
inline bool operator !=(AsciiChar c) const { return !operator ==(c); }
|
||||
|
||||
inline char16_t unicode() const { return m_ch; }
|
||||
inline char ascii(bool* ok = nullptr) const;
|
||||
inline char toAscii(bool* ok = nullptr) const;
|
||||
|
||||
static char toAscii(char16_t c, bool* ok = nullptr);
|
||||
static char16_t fromAscii(char c);
|
||||
|
||||
private:
|
||||
char16_t m_ch = 0;
|
||||
|
@ -106,19 +111,40 @@ public:
|
|||
static const size_t npos = static_cast<size_t>(-1);
|
||||
|
||||
String();
|
||||
|
||||
String(const char16_t* str);
|
||||
String(const Char& ch);
|
||||
|
||||
String& operator=(const char16_t* str);
|
||||
void reserve(size_t i);
|
||||
|
||||
operator QString() const {
|
||||
return this->toQString();
|
||||
}
|
||||
|
||||
inline bool operator ==(const String& s) const { return constStr() == s.constStr(); }
|
||||
inline bool operator !=(const String& s) const { return !operator ==(s); }
|
||||
bool operator ==(const AsciiStringView& s) const;
|
||||
inline bool operator !=(const AsciiStringView& s) const { return !operator ==(s); }
|
||||
|
||||
inline bool operator <(const String& s) const { return constStr() < s.constStr(); }
|
||||
|
||||
String& operator +=(const String& s);
|
||||
inline String& operator +=(const String& s) { return append(s); }
|
||||
String& operator +=(const char16_t* s);
|
||||
inline String& operator +=(char16_t s) { return append(s); }
|
||||
|
||||
inline String operator+(const mu::String& s) const { mu::String t(*this); t += s; return t; }
|
||||
inline String operator+(const char16_t* s) const { mu::String t(*this); t += s; return t; }
|
||||
inline String operator+(char16_t s) const { mu::String t(*this); t += s; return t; }
|
||||
|
||||
String& append(Char ch);
|
||||
String& append(const String& s);
|
||||
String& prepend(Char ch);
|
||||
String& prepend(const String& s);
|
||||
|
||||
static String fromUtf8(const char* str);
|
||||
ByteArray toUtf8() const;
|
||||
|
||||
static String fromAscii(const char* str);
|
||||
ByteArray toAscii(bool* ok = nullptr) const;
|
||||
|
||||
static String fromStdString(const std::string& str);
|
||||
|
@ -133,6 +159,8 @@ public:
|
|||
|
||||
size_t size() const;
|
||||
bool empty() const;
|
||||
inline bool isEmpty() const { return empty(); }
|
||||
void clear();
|
||||
Char at(size_t i) const;
|
||||
bool contains(const Char& ch) const;
|
||||
|
||||
|
@ -144,6 +172,13 @@ public:
|
|||
String& replace(const String& before, const String& after);
|
||||
|
||||
String mid(size_t pos, size_t count = npos) const;
|
||||
String trimmed() const;
|
||||
String toXmlEscaped() const;
|
||||
static String toXmlEscaped(const String& str);
|
||||
static String toXmlEscaped(char16_t c);
|
||||
|
||||
int toInt(bool* ok = nullptr, int base = 10) const;
|
||||
double toDouble(bool* ok = nullptr) const;
|
||||
|
||||
private:
|
||||
const std::u16string& constStr() const;
|
||||
|
@ -205,13 +240,16 @@ public:
|
|||
AsciiChar at(size_t i) const;
|
||||
bool contains(char ch) const;
|
||||
|
||||
int toInt(bool* ok = nullptr) const;
|
||||
int toInt(bool* ok = nullptr, int base = 10) const;
|
||||
double toDouble(bool* ok = nullptr) const;
|
||||
|
||||
private:
|
||||
size_t m_size = 0;
|
||||
const char* m_data = nullptr;
|
||||
};
|
||||
|
||||
inline String operator+(char16_t s1, const String& s2) { String t(s1); t += s2; return t; }
|
||||
inline String operator+(const char16_t* s1, const String& s2) { String t(s1); t += s2; return t; }
|
||||
}
|
||||
|
||||
// ============================
|
||||
|
@ -219,9 +257,6 @@ private:
|
|||
// ============================
|
||||
inline bool operator ==(const char16_t* s1, const mu::String& s2) { return s2 == s1; }
|
||||
inline bool operator !=(const char16_t* s1, const mu::String& s2) { return s2 != s1; }
|
||||
inline const mu::String operator+(const mu::String& s1, const mu::String& s2) { mu::String t(s1); t += s2; return t; }
|
||||
inline const mu::String operator+(const mu::String& s1, const char16_t* s2) { mu::String t(s1); t += s2; return t; }
|
||||
inline const mu::String operator+(const char16_t* s1, const mu::String& s2) { mu::String t(s1); t += s2; return t; }
|
||||
|
||||
inline mu::logger::Stream& operator<<(mu::logger::Stream& s, const mu::String& str)
|
||||
{
|
||||
|
|
|
@ -63,7 +63,7 @@ static QFont capxReadFont(XmlReader& e)
|
|||
} else {
|
||||
f.setWeight(QFont::Bold);
|
||||
}
|
||||
f.setItalic(e.attribute("italic", "false") == "true");
|
||||
f.setItalic(e.asciiAttribute("italic", "false") == "true");
|
||||
// LOGD("capxReadFont family '%s' ps %g w %d it '%s'", qPrintable(family), pointSize, weight, qPrintable(italic));
|
||||
e.readNext();
|
||||
return f;
|
||||
|
@ -160,13 +160,13 @@ void BasicDurationalObj::readCapx(XmlReader& e, unsigned int& fullm)
|
|||
}
|
||||
}
|
||||
nDots = e.intAttribute("dots", 0);
|
||||
noDuration = e.attribute("noDuration", "false") == "true";
|
||||
noDuration = e.asciiAttribute("noDuration", "false") == "true";
|
||||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag(e.name());
|
||||
if (tag == "tuplet") {
|
||||
count = e.attribute("count").toInt();
|
||||
tripartite = e.attribute("tripartite", "false") == "true";
|
||||
isProlonging = e.attribute("prolong", "false") == "true";
|
||||
tripartite = e.asciiAttribute("tripartite", "false") == "true";
|
||||
isProlonging = e.asciiAttribute("prolong", "false") == "true";
|
||||
e.readNext();
|
||||
} else {
|
||||
e.unknown();
|
||||
|
@ -192,7 +192,7 @@ void BasicDurationalObj::readCapxObjectArray(XmlReader& e)
|
|||
|
||||
void CapExplicitBarline::readCapx(XmlReader& e)
|
||||
{
|
||||
QString type = e.attribute("type", "single");
|
||||
AsciiStringView type = e.asciiAttribute("type", "single");
|
||||
if (type == "single") {
|
||||
_type = BarLineType::NORMAL;
|
||||
} else if (type == "double") {
|
||||
|
@ -470,7 +470,7 @@ void ChordObj::readCapxLyrics(XmlReader& e)
|
|||
v.hyphen = e.attribute("hyphen") == "true";
|
||||
v.num = e.intAttribute("i", 0);
|
||||
v.verseNumber = e.attribute("verseNumber"); // not used by capella.cpp
|
||||
v.text = e.readElementText();
|
||||
v.text = e.readText();
|
||||
verse.append(v);
|
||||
} else {
|
||||
e.unknown();
|
||||
|
@ -556,7 +556,7 @@ void SimpleTextObj::readCapx(XmlReader& e)
|
|||
{
|
||||
double x = e.doubleAttribute("x");
|
||||
double y = e.doubleAttribute("y");
|
||||
QString stralign = e.attribute("align", "left");
|
||||
AsciiStringView stralign = e.asciiAttribute("align", "left");
|
||||
align = 0;
|
||||
if (stralign == "center") {
|
||||
align = 1;
|
||||
|
@ -571,7 +571,7 @@ void SimpleTextObj::readCapx(XmlReader& e)
|
|||
if (tag == "font") {
|
||||
_font = capxReadFont(e);
|
||||
} else if (tag == "content") {
|
||||
_text = e.readElementText();
|
||||
_text = e.readText();
|
||||
// LOGD("SimpleTextObj::readCapx: found content '%s'", qPrintable(_text));
|
||||
} else {
|
||||
e.unknown();
|
||||
|
@ -585,7 +585,7 @@ void SimpleTextObj::readCapx(XmlReader& e)
|
|||
|
||||
void TransposableObj::readCapx(XmlReader& e)
|
||||
{
|
||||
QString enharmonicNote = e.attribute("base");
|
||||
String enharmonicNote = e.attribute("base");
|
||||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView tag1(e.name());
|
||||
if (tag1 == "drawObj") {
|
||||
|
@ -619,10 +619,10 @@ void SlurObj::readCapx(XmlReader& e)
|
|||
|
||||
void VoltaObj::readCapx(XmlReader& e)
|
||||
{
|
||||
bLeft = e.attribute("leftBent", "true") == "true";
|
||||
bRight = e.attribute("rightBent", "true") == "true";
|
||||
bDotted = e.attribute("dotted", "false") == "true";
|
||||
allNumbers = e.attribute("allNumbers", "false") == "true";
|
||||
bLeft = e.asciiAttribute("leftBent", "true") == "true";
|
||||
bRight = e.asciiAttribute("rightBent", "true") == "true";
|
||||
bDotted = e.asciiAttribute("dotted", "false") == "true";
|
||||
allNumbers = e.asciiAttribute("allNumbers", "false") == "true";
|
||||
int firstNumber = e.intAttribute("firstNumber", 0);
|
||||
int lastNumber = e.intAttribute("lastNumber", 0);
|
||||
if (firstNumber == 0) {
|
||||
|
@ -649,7 +649,7 @@ void TrillObj::readCapx(XmlReader& e)
|
|||
double x0d = e.doubleAttribute("x1", 0.0);
|
||||
double x1d = e.doubleAttribute("x2", 0.0);
|
||||
double yd = e.doubleAttribute("y", 0.0);
|
||||
trillSign = e.attribute("tr", "true") == "true";
|
||||
trillSign = e.asciiAttribute("tr", "true") == "true";
|
||||
x0 = (int)round(x0d * 32.0);
|
||||
x1 = (int)round(x1d * 32.0);
|
||||
y = (int)round(yd * 32.0);
|
||||
|
@ -665,7 +665,7 @@ void TrillObj::readCapx(XmlReader& e)
|
|||
void WedgeObj::readCapx(XmlReader& e)
|
||||
{
|
||||
// TODO: read LineObj properties
|
||||
decresc = e.attribute("decrescendo", "false") == "true";
|
||||
decresc = e.asciiAttribute("decrescendo", "false") == "true";
|
||||
double dheight = e.doubleAttribute("span", 1.0);
|
||||
height = (int)round(dheight * 32.0);
|
||||
e.readNext();
|
||||
|
@ -979,7 +979,7 @@ static void capxNotation(XmlReader& e, uchar& barlineMode, uchar& barlineFrom, u
|
|||
{
|
||||
while (e.readNextStartElement()) {
|
||||
if (e.name() == "barlines") {
|
||||
QString mode = e.attribute("mode", "full");
|
||||
AsciiStringView mode = e.asciiAttribute("mode", "full");
|
||||
if (mode == "full") {
|
||||
barlineMode = 3;
|
||||
} else if (mode == "none") {
|
||||
|
@ -1068,9 +1068,9 @@ void Capella::readCapxStaveLayout(XmlReader& e, CapStaffLayout* sl, int /*idx*/)
|
|||
while (e.readNextStartElement()) {
|
||||
const AsciiStringView t(e.name());
|
||||
if (t == "name") {
|
||||
sl->name = e.readElementText();
|
||||
sl->name = e.readText();
|
||||
} else if (t == "abbrev") {
|
||||
sl->abbrev = e.readElementText();
|
||||
sl->abbrev = e.readText();
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
@ -1317,8 +1317,8 @@ Score::FileError importCapXml(MasterScore* score, const QString& name)
|
|||
|
||||
while (e.readNextStartElement()) {
|
||||
if (e.name() == "score") {
|
||||
const QString& xmlns = e.attribute("xmlns", "<none>"); // doesn't work ???
|
||||
LOGD("importCapXml: found score, namespace '%s'", qPrintable(xmlns));
|
||||
String xmlns = e.attribute("xmlns", u"<none>"); // doesn't work ???
|
||||
LOGD("importCapXml: found score, namespace '%s'", xmlns.toUtf8().constChar());
|
||||
cf.readCapx(e);
|
||||
} else {
|
||||
e.unknown();
|
||||
|
|
|
@ -150,7 +150,7 @@ std::set<int> findAllPitches(const MTrack& track)
|
|||
void findNotEmptyDrumPitches(std::set<int>& drumPitches, const InstrumentTemplate* templ)
|
||||
{
|
||||
for (int i = 0; i != DRUM_INSTRUMENTS; ++i) {
|
||||
if (!templ->drumset->name(i).isEmpty()) {
|
||||
if (!templ->drumset->name(i).empty()) {
|
||||
drumPitches.insert(i);
|
||||
}
|
||||
}
|
||||
|
@ -169,7 +169,7 @@ bool hasNotDefinedDrumPitch(const std::set<int>& trackPitches, const std::set<in
|
|||
return hasNotDefinedPitch;
|
||||
}
|
||||
|
||||
const InstrumentTemplate* findInstrument(const QString& groupId, const QString& instrId)
|
||||
static const InstrumentTemplate* findInstrument(const String& groupId, const String& instrId)
|
||||
{
|
||||
const InstrumentTemplate* instr = nullptr;
|
||||
|
||||
|
@ -260,27 +260,27 @@ std::vector<const InstrumentTemplate*> findInstrumentsForProgram(const MTrack& t
|
|||
// so we will find the most matching instrument
|
||||
|
||||
if (program == 55) { // GM "Orchestra Hit" sound
|
||||
auto instr = findInstrument("electronic-instruments", "brass-synthesizer");
|
||||
auto instr = findInstrument(u"electronic-instruments", u"brass-synthesizer");
|
||||
if (instr) {
|
||||
suitableTemplates.push_back(instr);
|
||||
}
|
||||
} else if (program == 110) { // GM "Fiddle" sound
|
||||
auto instr = findInstrument("strings", "violin");
|
||||
auto instr = findInstrument(u"strings", u"violin");
|
||||
if (instr) {
|
||||
suitableTemplates.push_back(instr);
|
||||
}
|
||||
} else if (program >= 80 && program <= 103) {
|
||||
const InstrumentTemplate* instr = nullptr;
|
||||
if (track.mtrack->drumTrack()) {
|
||||
instr = findInstrument("electronic-instruments", "percussion-synthesizer");
|
||||
instr = findInstrument(u"electronic-instruments", u"percussion-synthesizer");
|
||||
} else {
|
||||
instr = findInstrument("electronic-instruments", "effect-synth");
|
||||
instr = findInstrument(u"electronic-instruments", u"effect-synth");
|
||||
}
|
||||
if (instr) {
|
||||
suitableTemplates.push_back(instr); // generic synth
|
||||
}
|
||||
} else if (program >= 112 && program <= 127) {
|
||||
auto instr = findInstrument("unpitched-percussion", "snare-drum");
|
||||
auto instr = findInstrument(u"unpitched-percussion", u"snare-drum");
|
||||
if (instr) {
|
||||
suitableTemplates.push_back(instr); // 1-line percussion staff
|
||||
}
|
||||
|
@ -288,11 +288,11 @@ std::vector<const InstrumentTemplate*> findInstrumentsForProgram(const MTrack& t
|
|||
// slightly improve slap bass match:
|
||||
// match to the instruments with program 33
|
||||
// instead of 35 according to the algorithm below
|
||||
auto instr = findInstrument("plucked-strings", "electric-bass");
|
||||
auto instr = findInstrument(u"plucked-strings", u"electric-bass");
|
||||
if (instr) {
|
||||
suitableTemplates.push_back(instr);
|
||||
}
|
||||
instr = findInstrument("plucked-strings", "5-string-electric-bass");
|
||||
instr = findInstrument(u"plucked-strings", u"5-string-electric-bass");
|
||||
if (instr) {
|
||||
suitableTemplates.push_back(instr);
|
||||
}
|
||||
|
|
|
@ -170,7 +170,7 @@ void InstrumentListModel::init(const QString& genreId, const QString& groupId)
|
|||
loadInstruments();
|
||||
}
|
||||
|
||||
QString InstrumentListModel::resolveInstrumentGroupId(const QString& instrumentId) const
|
||||
QString InstrumentListModel::resolveInstrumentGroupId(const String& instrumentId) const
|
||||
{
|
||||
for (const InstrumentTemplate* templ : repository()->instrumentTemplates()) {
|
||||
if (templ->id == instrumentId) {
|
||||
|
@ -181,7 +181,7 @@ QString InstrumentListModel::resolveInstrumentGroupId(const QString& instrumentI
|
|||
return NONE_GROUP_ID;
|
||||
}
|
||||
|
||||
void InstrumentListModel::focusOnInstrument(const QString& instrumentId)
|
||||
void InstrumentListModel::focusOnInstrument(const String& instrumentId)
|
||||
{
|
||||
TRACEFUNC;
|
||||
|
||||
|
|
|
@ -111,8 +111,8 @@ private:
|
|||
|
||||
void init(const QString& genreId, const QString& groupId);
|
||||
|
||||
QString resolveInstrumentGroupId(const QString& instrumentId) const;
|
||||
void focusOnInstrument(const QString& instrumentId);
|
||||
QString resolveInstrumentGroupId(const String& instrumentId) const;
|
||||
void focusOnInstrument(const String& instrumentId);
|
||||
|
||||
void loadGenres();
|
||||
void loadGroups();
|
||||
|
|
|
@ -188,7 +188,7 @@ void InstrumentsOnScoreListModel::loadOrders()
|
|||
}
|
||||
}
|
||||
|
||||
int InstrumentsOnScoreListModel::resolveInstrumentSequenceNumber(const QString& instrumentId) const
|
||||
int InstrumentsOnScoreListModel::resolveInstrumentSequenceNumber(const String& instrumentId) const
|
||||
{
|
||||
const InstrumentTemplateList& templates = repository()->instrumentTemplates();
|
||||
for (const InstrumentTemplate* templ : templates) {
|
||||
|
|
|
@ -72,7 +72,7 @@ private:
|
|||
|
||||
void loadOrders();
|
||||
|
||||
int resolveInstrumentSequenceNumber(const QString& instrumentId) const;
|
||||
int resolveInstrumentSequenceNumber(const String& instrumentId) const;
|
||||
void updateInstrumentsOrder();
|
||||
void sortInstruments(ItemList& instruments);
|
||||
void insertInstrument(ItemList& instruments, InstrumentItem* newInstrument);
|
||||
|
|
|
@ -132,7 +132,7 @@ void InstrumentsPanelContextMenuModel::setInstrumentsOrder(const actions::Action
|
|||
return;
|
||||
}
|
||||
|
||||
QString newOrderId = args.arg<QString>(0);
|
||||
String newOrderId = String::fromQString(args.arg<QString>(0));
|
||||
|
||||
for (const ScoreOrder& order : m_orders) {
|
||||
if (order.id == newOrderId) {
|
||||
|
|
|
@ -31,7 +31,7 @@ using namespace mu::notation;
|
|||
ExcerptNotation::ExcerptNotation(mu::engraving::Excerpt* excerpt)
|
||||
: Notation(), m_excerpt(excerpt)
|
||||
{
|
||||
m_name = excerpt ? excerpt->name() : QString();
|
||||
m_name = excerpt ? excerpt->name().toQString() : QString();
|
||||
}
|
||||
|
||||
ExcerptNotation::~ExcerptNotation()
|
||||
|
@ -103,7 +103,7 @@ bool ExcerptNotation::isEmpty() const
|
|||
|
||||
QString ExcerptNotation::name() const
|
||||
{
|
||||
return m_excerpt ? m_excerpt->name() : m_name;
|
||||
return m_excerpt ? m_excerpt->name().toQString() : m_name;
|
||||
}
|
||||
|
||||
void ExcerptNotation::setName(const QString& name)
|
||||
|
|
|
@ -456,22 +456,22 @@ void StaffTextPropertiesDialog::channelItemChanged(QTreeWidgetItem* item, QTreeW
|
|||
for (const NamedEventList& e : part->instrument(tick)->midiActions()) {
|
||||
QTreeWidgetItem* ti = new QTreeWidgetItem(actionList);
|
||||
QString name = e.name;
|
||||
if (e.name.isEmpty()) {
|
||||
if (e.name.empty()) {
|
||||
name = InstrChannel::DEFAULT_NAME;
|
||||
}
|
||||
ti->setText(0, qApp->translate("InstrumentsXML", name.toUtf8().data()));
|
||||
ti->setText(0, qtrc("InstrumentsXML", name));
|
||||
ti->setData(0, Qt::UserRole, name);
|
||||
ti->setText(1, qApp->translate("InstrumentsXML", e.descr.toUtf8().data()));
|
||||
ti->setText(1, qtrc("InstrumentsXML", e.descr));
|
||||
}
|
||||
for (const NamedEventList& e : channel->midiActions) {
|
||||
QTreeWidgetItem* ti = new QTreeWidgetItem(actionList);
|
||||
QString name = e.name;
|
||||
if (e.name.isEmpty()) {
|
||||
if (e.name.empty()) {
|
||||
name = InstrChannel::DEFAULT_NAME;
|
||||
}
|
||||
ti->setText(0, qApp->translate("InstrumentsXML", name.toUtf8().data()));
|
||||
ti->setText(0, qtrc("InstrumentsXML", name));
|
||||
ti->setData(0, Qt::UserRole, name);
|
||||
ti->setText(1, qApp->translate("InstrumentsXML", e.descr.toUtf8().data()));
|
||||
ti->setText(1, qtrc("InstrumentsXML", e.descr));
|
||||
}
|
||||
for (const ChannelActions& ca : m_staffText->channelActions()) {
|
||||
if (ca.channel == channelIdx) {
|
||||
|
|
|
@ -262,9 +262,9 @@ bool Palette::read(XmlReader& e)
|
|||
} else if (tag == "drumPalette") { // obsolete
|
||||
e.skipCurrentElement();
|
||||
} else if (tag == "type") {
|
||||
QByteArray ba = e.readElementText().toLatin1();
|
||||
ByteArray ba = e.readText().toAscii();
|
||||
bool ok = true;
|
||||
const int t = QMetaEnum::fromType<Type>().keyToValue(ba.constData(), &ok);
|
||||
const int t = QMetaEnum::fromType<Type>().keyToValue(ba.constChar(), &ok);
|
||||
if (ok) {
|
||||
m_type = Type(t);
|
||||
}
|
||||
|
@ -386,7 +386,7 @@ bool Palette::readFromFile(const QString& p)
|
|||
}
|
||||
e.readNext();
|
||||
} else if (tag == "file") {
|
||||
images.append(e.readElementText());
|
||||
images.append(e.readText());
|
||||
} else {
|
||||
e.unknown();
|
||||
}
|
||||
|
|
|
@ -194,7 +194,7 @@ bool PaletteCell::read(XmlReader& e)
|
|||
} else if (s == "mag") {
|
||||
mag = e.readDouble();
|
||||
} else if (s == "tag") {
|
||||
tag = e.readElementText();
|
||||
tag = e.readText();
|
||||
}
|
||||
// added on palettes rework
|
||||
// TODO: remove or leave to switch from using attributes later?
|
||||
|
|
|
@ -143,7 +143,7 @@ void DrumsetPalette::updateDrumset()
|
|||
int shortcutCode = m_drumset->shortcut(pitch);
|
||||
QString shortcut = shortcutCode != 0 ? QChar(shortcutCode) : QString();
|
||||
|
||||
m_drumPalette->appendElement(chord, mu::qtrc("drumset", m_drumset->name(pitch).toUtf8().data()), 1.0, shortcut);
|
||||
m_drumPalette->appendElement(chord, mu::qtrc("drumset", m_drumset->name(pitch)), 1.0, shortcut);
|
||||
}
|
||||
|
||||
noteInput->setDrumNote(selectedDrumNote());
|
||||
|
|
|
@ -314,7 +314,7 @@ void EditDrumsetDialog::updatePitchesList()
|
|||
QString s(QChar(m_editedDrumset.shortcut(i)));
|
||||
item->setText(Column::SHORTCUT, s);
|
||||
}
|
||||
item->setText(Column::NAME, mu::qtrc("drumset", m_editedDrumset.name(i).toUtf8().constData()));
|
||||
item->setText(Column::NAME, mu::qtrc("drumset", m_editedDrumset.name(i)));
|
||||
item->setData(Column::PITCH, Qt::UserRole, i);
|
||||
}
|
||||
pitchList->sortItems(3, Qt::SortOrder::DescendingOrder);
|
||||
|
@ -334,7 +334,7 @@ void EditDrumsetDialog::refreshPitchesList()
|
|||
QString s(QChar(m_editedDrumset.shortcut(pitch)));
|
||||
item->setText(Column::SHORTCUT, s);
|
||||
}
|
||||
item->setText(Column::NAME, mu::qtrc("drumset", m_editedDrumset.name(pitch).toUtf8().constData()));
|
||||
item->setText(Column::NAME, mu::qtrc("drumset", m_editedDrumset.name(pitch)));
|
||||
item->setData(0, Qt::UserRole, pitch);
|
||||
}
|
||||
}
|
||||
|
@ -508,7 +508,7 @@ void EditDrumsetDialog::itemChanged(QTreeWidgetItem* current, QTreeWidgetItem* p
|
|||
m_editedDrumset.drum(pitch).shortcut = "ABCDEFG"[shortcut->currentIndex()];
|
||||
}
|
||||
m_editedDrumset.drum(pitch).stemDirection = DirectionV(stemDirection->currentIndex());
|
||||
previous->setText(Column::NAME, mu::qtrc("drumset", m_editedDrumset.name(pitch).toUtf8().constData()));
|
||||
previous->setText(Column::NAME, mu::qtrc("drumset", m_editedDrumset.name(pitch)));
|
||||
}
|
||||
if (current == 0) {
|
||||
return;
|
||||
|
@ -520,7 +520,7 @@ void EditDrumsetDialog::itemChanged(QTreeWidgetItem* current, QTreeWidgetItem* p
|
|||
noteHead->blockSignals(true);
|
||||
|
||||
int pitch = current->data(0, Qt::UserRole).toInt();
|
||||
name->setText(mu::qtrc("drumset", m_editedDrumset.name(pitch).toUtf8().constData()));
|
||||
name->setText(mu::qtrc("drumset", m_editedDrumset.name(pitch)));
|
||||
staffLine->setValue(m_editedDrumset.line(pitch));
|
||||
voice->setCurrentIndex(m_editedDrumset.voice(pitch));
|
||||
stemDirection->setCurrentIndex(int(m_editedDrumset.stemDirection(pitch)));
|
||||
|
@ -627,7 +627,7 @@ void EditDrumsetDialog::updateExample()
|
|||
Stem* stem = Factory::createStem(chord.get());
|
||||
stem->setBaseLength(Millimetre((up ? -3.0 : 3.0) * gpaletteScore->spatium()));
|
||||
chord->add(stem);
|
||||
drumNote->appendElement(chord, mu::qtrc("drumset", m_editedDrumset.name(pitch).toUtf8().constData()));
|
||||
drumNote->appendElement(chord, mu::qtrc("drumset", m_editedDrumset.name(pitch)));
|
||||
}
|
||||
|
||||
//---------------------------------------------------------
|
||||
|
|
Loading…
Reference in a new issue