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

Revision of translated strings

Browse source
This commit is contained in:
Igor Korsukov 2022-07-11 19:22:39 +02:00
parent bb4b7fd910
commit 7e44a94eed
47 changed files with 6048 additions and 6467 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10109
share/locale/musescore_en.ts
View file

File diff suppressed because it is too large Load diff

2
src/appshell/qml/Main.wasm.qml
View file

@ -33,7 +33,7 @@ ApplicationWindow {
height: 480
visible: true
title: qsTr("MuseScore")
title: qsTrc("appshell", "MuseScore")
header: ToolBar {
contentHeight: 40

4
src/appshell/view/dockwindow/dockpanelview.cpp
View file

@ -59,7 +59,7 @@ public:
items << makeSeparator();
}
MenuItem* closeDockItem = makeMenuItem(SET_DOCK_OPEN_ACTION_CODE, mu::qtrc("dock", "Close"));
MenuItem* closeDockItem = makeMenuItem(SET_DOCK_OPEN_ACTION_CODE, mu::qtrc("appshell/dock", "Close"));
closeDockItem->setArgs(ActionData::make_arg2<QString, bool>(m_panel->objectName(), false));
items << closeDockItem;
@ -112,7 +112,7 @@ private:
QString toggleFloatingActionTitle() const
{
return m_panel->floating() ? mu::qtrc("dock", "Dock") : mu::qtrc("dock", "Undock");
return m_panel->floating() ? mu::qtrc("appshell/dock", "Dock") : mu::qtrc("appshell/dock", "Undock");
}
void listenFloatingChanged()

2
src/cloud/qml/MuseScore/Cloud/internal/AuthorizationPage.qml
View file

@ -72,7 +72,7 @@ FocusScope {
anchors.topMargin: privateProperties.sideMargin
anchors.leftMargin: privateProperties.sideMargin
text: qsTrc("scores", "Account")
text: qsTrc("cloud", "Account")
font: ui.theme.titleBoldFont
}

2
src/engraving/libmscore/barline.cpp
View file

@ -272,7 +272,7 @@ String BarLine::userTypeName(BarLineType t)
{
for (const auto& i : barLineTable) {
if (i.type == t) {
return mtrc("symUserNames", i.userName);
return mtrc("engraving/sym", i.userName);
}
}
return String();

16
src/engraving/libmscore/check.cpp
View file

@ -139,11 +139,9 @@ bool Score::sanityCheck()
}
}
if (voices[0] != mLen) {
String msg
= mtrc("engraving", "Measure %1, staff %2 incomplete. Expected: %3; Found: %4")
.arg(mNumber).arg(staffIdx + 1).arg(mLen.toString(), voices[0].toString());
LOGE() << msg;
error += String(u"%1\n").arg(msg);
LOGE() << String(u"Measure %1, staff %2 incomplete. Expected: %3; Found: %4")
.arg(mNumber).arg(staffIdx + 1).arg(mLen.toString(), voices[0].toString());
#ifndef NDEBUG
m->setCorrupted(staffIdx, true);
#endif
@ -159,10 +157,9 @@ bool Score::sanityCheck()
}
for (voice_idx_t v = 1; v < VOICES; ++v) {
if (voices[v] > mLen) {
String msg = mtrc("engraving", "Measure %1, staff %2, voice %3 too long. Expected: %4; Found: %5")
.arg(mNumber).arg(staffIdx + 1).arg(v + 1).arg(mLen.toString(), voices[v].toString());
LOGE() << msg;
error += String(u"%1\n").arg(msg);
LOGE() << String(u"Measure %1, staff %2, voice %3 too long. Expected: %4; Found: %5")
.arg(mNumber).arg(staffIdx + 1).arg(v + 1).arg(mLen.toString(), voices[v].toString());
#ifndef NDEBUG
m->setCorrupted(staffIdx, true);
#endif
@ -173,7 +170,6 @@ bool Score::sanityCheck()
mNumber++;
}
MScore::lastError = error;
return result;
}

5
src/engraving/libmscore/chordlist.cpp
View file

@ -1843,8 +1843,7 @@ bool ChordList::read(const String& name)
}
File f(path);
if (!f.open(IODevice::ReadOnly)) {
MScore::lastError = mtrc("engraving", "Cannot open chord description:\n%1").arg(f.filePath().toString());
LOGD() << "read failed: " << path;
LOGE() << "Cannot open chord description: " << f.filePath();
return false;
}
@ -1884,7 +1883,7 @@ bool ChordList::write(const String& name) const
File f(info.filePath());
if (!f.open(IODevice::WriteOnly)) {
MScore::lastError = mtrc("engraving", "Failed open chord description: %1").arg(f.filePath().toString());
LOGE() << "Failed open chord description: " << f.filePath();
return false;
}

50
src/engraving/libmscore/drumset.cpp
View file

@ -271,34 +271,34 @@ void initDrumset()
smDrumset->drum(i).voice = 0;
smDrumset->drum(i).stemDirection = DirectionV::UP;
}
smDrumset->drum(35) = DrumInstrument(TConv::userName(DrumPitch(35)), NoteHeadGroup::HEAD_NORMAL, 7, DirectionV::DOWN, 1);
smDrumset->drum(36) = DrumInstrument(TConv::userName(DrumPitch(36)), NoteHeadGroup::HEAD_NORMAL, 7, DirectionV::DOWN, 1, Key_B);
smDrumset->drum(37) = DrumInstrument(TConv::userName(DrumPitch(37)), NoteHeadGroup::HEAD_CROSS, 3, DirectionV::UP);
smDrumset->drum(38) = DrumInstrument(TConv::userName(DrumPitch(38)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP, 0, Key_A);
smDrumset->drum(35) = DrumInstrument(TConv::userName(DrumNum(35)), NoteHeadGroup::HEAD_NORMAL, 7, DirectionV::DOWN, 1);
smDrumset->drum(36) = DrumInstrument(TConv::userName(DrumNum(36)), NoteHeadGroup::HEAD_NORMAL, 7, DirectionV::DOWN, 1, Key_B);
smDrumset->drum(37) = DrumInstrument(TConv::userName(DrumNum(37)), NoteHeadGroup::HEAD_CROSS, 3, DirectionV::UP);
smDrumset->drum(38) = DrumInstrument(TConv::userName(DrumNum(38)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP, 0, Key_A);
smDrumset->drum(40) = DrumInstrument(TConv::userName(DrumPitch(40)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
smDrumset->drum(41) = DrumInstrument(TConv::userName(DrumPitch(41)), NoteHeadGroup::HEAD_NORMAL, 5, DirectionV::UP);
smDrumset->drum(42) = DrumInstrument(TConv::userName(DrumPitch(42)), NoteHeadGroup::HEAD_CROSS, -1, DirectionV::UP, 0, Key_G);
smDrumset->drum(43) = DrumInstrument(TConv::userName(DrumPitch(43)), NoteHeadGroup::HEAD_NORMAL, 5, DirectionV::DOWN, 1);
smDrumset->drum(44) = DrumInstrument(TConv::userName(DrumPitch(44)), NoteHeadGroup::HEAD_CROSS, 9, DirectionV::DOWN, 1, Key_F);
smDrumset->drum(45) = DrumInstrument(TConv::userName(DrumPitch(45)), NoteHeadGroup::HEAD_NORMAL, 2, DirectionV::UP);
smDrumset->drum(46) = DrumInstrument(TConv::userName(DrumPitch(46)), NoteHeadGroup::HEAD_CROSS, 1, DirectionV::UP);
smDrumset->drum(47) = DrumInstrument(TConv::userName(DrumPitch(47)), NoteHeadGroup::HEAD_NORMAL, 1, DirectionV::UP);
smDrumset->drum(48) = DrumInstrument(TConv::userName(DrumPitch(48)), NoteHeadGroup::HEAD_NORMAL, 0, DirectionV::UP);
smDrumset->drum(49) = DrumInstrument(TConv::userName(DrumPitch(49)), NoteHeadGroup::HEAD_CROSS, -2, DirectionV::UP, 0, Key_C);
smDrumset->drum(40) = DrumInstrument(TConv::userName(DrumNum(40)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
smDrumset->drum(41) = DrumInstrument(TConv::userName(DrumNum(41)), NoteHeadGroup::HEAD_NORMAL, 5, DirectionV::UP);
smDrumset->drum(42) = DrumInstrument(TConv::userName(DrumNum(42)), NoteHeadGroup::HEAD_CROSS, -1, DirectionV::UP, 0, Key_G);
smDrumset->drum(43) = DrumInstrument(TConv::userName(DrumNum(43)), NoteHeadGroup::HEAD_NORMAL, 5, DirectionV::DOWN, 1);
smDrumset->drum(44) = DrumInstrument(TConv::userName(DrumNum(44)), NoteHeadGroup::HEAD_CROSS, 9, DirectionV::DOWN, 1, Key_F);
smDrumset->drum(45) = DrumInstrument(TConv::userName(DrumNum(45)), NoteHeadGroup::HEAD_NORMAL, 2, DirectionV::UP);
smDrumset->drum(46) = DrumInstrument(TConv::userName(DrumNum(46)), NoteHeadGroup::HEAD_CROSS, 1, DirectionV::UP);
smDrumset->drum(47) = DrumInstrument(TConv::userName(DrumNum(47)), NoteHeadGroup::HEAD_NORMAL, 1, DirectionV::UP);
smDrumset->drum(48) = DrumInstrument(TConv::userName(DrumNum(48)), NoteHeadGroup::HEAD_NORMAL, 0, DirectionV::UP);
smDrumset->drum(49) = DrumInstrument(TConv::userName(DrumNum(49)), NoteHeadGroup::HEAD_CROSS, -2, DirectionV::UP, 0, Key_C);
smDrumset->drum(50) = DrumInstrument(TConv::userName(DrumPitch(50)), NoteHeadGroup::HEAD_NORMAL, 0, DirectionV::UP, 0, Key_E);
smDrumset->drum(51) = DrumInstrument(TConv::userName(DrumPitch(51)), NoteHeadGroup::HEAD_CROSS, 0, DirectionV::UP, 0, Key_D);
smDrumset->drum(52) = DrumInstrument(TConv::userName(DrumPitch(52)), NoteHeadGroup::HEAD_CROSS, -3, DirectionV::UP);
smDrumset->drum(53) = DrumInstrument(TConv::userName(DrumPitch(53)), NoteHeadGroup::HEAD_DIAMOND, 0, DirectionV::UP);
smDrumset->drum(54) = DrumInstrument(TConv::userName(DrumPitch(54)), NoteHeadGroup::HEAD_DIAMOND, 2, DirectionV::UP);
smDrumset->drum(55) = DrumInstrument(TConv::userName(DrumPitch(55)), NoteHeadGroup::HEAD_CROSS, -3, DirectionV::UP);
smDrumset->drum(56) = DrumInstrument(TConv::userName(DrumPitch(56)), NoteHeadGroup::HEAD_TRIANGLE_DOWN, 1, DirectionV::UP);
smDrumset->drum(57) = DrumInstrument(TConv::userName(DrumPitch(57)), NoteHeadGroup::HEAD_CROSS, -3, DirectionV::UP);
smDrumset->drum(50) = DrumInstrument(TConv::userName(DrumNum(50)), NoteHeadGroup::HEAD_NORMAL, 0, DirectionV::UP, 0, Key_E);
smDrumset->drum(51) = DrumInstrument(TConv::userName(DrumNum(51)), NoteHeadGroup::HEAD_CROSS, 0, DirectionV::UP, 0, Key_D);
smDrumset->drum(52) = DrumInstrument(TConv::userName(DrumNum(52)), NoteHeadGroup::HEAD_CROSS, -3, DirectionV::UP);
smDrumset->drum(53) = DrumInstrument(TConv::userName(DrumNum(53)), NoteHeadGroup::HEAD_DIAMOND, 0, DirectionV::UP);
smDrumset->drum(54) = DrumInstrument(TConv::userName(DrumNum(54)), NoteHeadGroup::HEAD_DIAMOND, 2, DirectionV::UP);
smDrumset->drum(55) = DrumInstrument(TConv::userName(DrumNum(55)), NoteHeadGroup::HEAD_CROSS, -3, DirectionV::UP);
smDrumset->drum(56) = DrumInstrument(TConv::userName(DrumNum(56)), NoteHeadGroup::HEAD_TRIANGLE_DOWN, 1, DirectionV::UP);
smDrumset->drum(57) = DrumInstrument(TConv::userName(DrumNum(57)), NoteHeadGroup::HEAD_CROSS, -3, DirectionV::UP);
smDrumset->drum(59) = DrumInstrument(TConv::userName(DrumPitch(59)), NoteHeadGroup::HEAD_CROSS, 2, DirectionV::UP);
smDrumset->drum(59) = DrumInstrument(TConv::userName(DrumNum(59)), NoteHeadGroup::HEAD_CROSS, 2, DirectionV::UP);
smDrumset->drum(63) = DrumInstrument(TConv::userName(DrumPitch(63)), NoteHeadGroup::HEAD_CROSS, 4, DirectionV::UP);
smDrumset->drum(64) = DrumInstrument(TConv::userName(DrumPitch(64)), NoteHeadGroup::HEAD_CROSS, 6, DirectionV::UP);
smDrumset->drum(63) = DrumInstrument(TConv::userName(DrumNum(63)), NoteHeadGroup::HEAD_CROSS, 4, DirectionV::UP);
smDrumset->drum(64) = DrumInstrument(TConv::userName(DrumNum(64)), NoteHeadGroup::HEAD_CROSS, 6, DirectionV::UP);
}
}

3
src/engraving/libmscore/figuredbass.cpp
View file

@ -1683,8 +1683,7 @@ bool FiguredBass::readConfigFile(const String& fileName)
File fi(path);
if (!fi.open(IODevice::ReadOnly)) {
MScore::lastError = mtrc("engraving", "Cannot open figured bass description:\n%1").arg(fi.filePath().toString());
LOGD("FiguredBass::read failed: <%s>", muPrintable(path));
LOGE() << "Cannot open figured bass description: " << fi.filePath();
return false;
}
XmlReader e(&fi);

3
src/engraving/libmscore/mscore.cpp
View file

@ -102,7 +102,6 @@ double MScore::nudgeStep10;
double MScore::nudgeStep50;
int MScore::defaultPlayDuration;
String MScore::lastError;
int MScore::sampleRate = 44100;
int MScore::mtcType;
@ -134,8 +133,6 @@ void MScore::init()
playRepeats = true;
playbackSpeedIncrement = 5;
lastError = u"";
//
// initialize styles
//

1
src/engraving/libmscore/mscore.h
View file

@ -271,7 +271,6 @@ public:
static double nudgeStep10;
static double nudgeStep50;
static int defaultPlayDuration;
static String lastError;
// #ifndef NDEBUG
static bool noHorizontalStretch;

8
src/engraving/libmscore/scorefile.cpp
View file

@ -329,11 +329,11 @@ bool Score::loadStyle(const String& fn, bool ign, const bool overlap)
undo(new ChangeStyle(this, st, overlap));
return true;
} else {
MScore::lastError = mtrc("engraving", "The style file is not compatible with this version of MuseScore.");
LOGE() << "The style file is not compatible with this version of MuseScore.";
return false;
}
}
MScore::lastError = String::fromUtf8(strerror(errno));
return false;
}
@ -351,13 +351,13 @@ bool Score::saveStyle(const String& name)
}
File f(info.filePath());
if (!f.open(IODevice::WriteOnly)) {
MScore::lastError = mtrc("engraving", "Failed open style file: %1 ").arg(info.filePath());
LOGE() << "Failed open style file: " << info.filePath();
return false;
}
bool ok = style().write(&f);
if (!ok) {
MScore::lastError = mtrc("engraving", "Failed write style file: %1").arg(info.filePath());
LOGE() << "Failed write style file: " << info.filePath();
return false;
}

3
src/engraving/libmscore/stafftype.cpp
View file

@ -1270,8 +1270,7 @@ bool StaffType::readConfigFile(const String& fileName)
File f(path);
if (!f.exists() || !f.open(IODevice::ReadOnly)) {
MScore::lastError = mtrc("engraving", "Cannot open tablature font description:\n%1").arg(f.filePath().toString());
LOGD() << "readConfigFile failed: " << path;
LOGE() << "Cannot open tablature font description: " << f.filePath();
return false;
}

8
src/engraving/libmscore/timesig.cpp
View file

@ -564,16 +564,16 @@ String TimeSig::accessibleInfo() const
String timeSigString;
switch (timeSigType()) {
case TimeSigType::FOUR_FOUR:
timeSigString = mtrc("symUserNames", "Common time");
timeSigString = mtrc("engraving", "Common time");
break;
case TimeSigType::ALLA_BREVE:
timeSigString = mtrc("symUserNames", "Cut time");
timeSigString = mtrc("engraving", "Cut time");
break;
case TimeSigType::CUT_BACH:
timeSigString = mtrc("symUserNames", "Cut time (Bach)");
timeSigString = mtrc("engraving", "Cut time (Bach)");
break;
case TimeSigType::CUT_TRIPLE:
timeSigString = mtrc("symUserNames", "Cut triple time (9/8)");
timeSigString = mtrc("engraving", "Cut triple time (9/8)");
break;
default:
timeSigString = mtrc("engraving", "%1/%2 time").arg(numerator(), denominator());

6
src/engraving/rw/compat/read206.cpp
View file

@ -3342,10 +3342,8 @@ bool Read206::readScore206(Score* score, XmlReader& e, ReadContext& ctx)
}
}
if (e.error() != XmlStreamReader::NoError) {
LOGD("%s: xml read error at line %lld col %lld: %s",
muPrintable(e.docName()), e.lineNumber(), e.columnNumber(), e.name().ascii());
MScore::lastError = mtrc("engraving", "XML read error at line %1, column %2: %3").arg(e.lineNumber()).arg(e.columnNumber()).arg(
String::fromAscii(e.name().ascii()));
LOGE() << String(u"XML read error at line %1, column %2: %3").arg(e.lineNumber()).arg(e.columnNumber())
.arg(String::fromAscii(e.name().ascii()));
return false;
}

8
src/engraving/rw/compat/read302.cpp
View file

@ -225,13 +225,11 @@ bool Read302::readScore302(Score* score, XmlReader& e, ReadContext& ctx)
}
e.context()->reconnectBrokenConnectors();
if (e.error() != XmlStreamReader::NoError) {
LOGD("%s: xml read error at line %lld col %lld: %s",
muPrintable(e.docName()), e.lineNumber(), e.columnNumber(), e.name().ascii());
if (e.error() == XmlStreamReader::CustomError) {
MScore::lastError = e.errorString();
LOGE() << e.errorString();
} else {
MScore::lastError = mtrc("engraving", "XML read error at line %1, column %2: %3").arg(e.lineNumber(), e.columnNumber()).arg(
String::fromAscii(e.name().ascii()));
LOGE() << String(u"XML read error at line %1, column %2: %3").arg(e.lineNumber(), e.columnNumber())
.arg(String::fromAscii(e.name().ascii()));
}
return false;
}

8
src/engraving/rw/read400.cpp
View file

@ -226,13 +226,11 @@ bool Read400::readScore400(Score* score, XmlReader& e, ReadContext& ctx)
}
ctx.reconnectBrokenConnectors();
if (e.error() != XmlStreamReader::NoError) {
LOGD("%s: xml read error at line %lld col %lld: %s",
muPrintable(e.docName()), e.lineNumber(), e.columnNumber(), e.name().ascii());
if (e.error() == XmlStreamReader::CustomError) {
MScore::lastError = e.errorString();
LOGE() << e.errorString();
} else {
MScore::lastError = mtrc("engraving", "XML read error at line %1, column %2: %3").arg(e.lineNumber(), e.columnNumber()).arg(
String::fromAscii(e.name().ascii()));
LOGE() << String(u"XML read error at line %1, column %2: %3").arg(e.lineNumber(), e.columnNumber())
.arg(String::fromAscii(e.name().ascii()));
}
return false;
}

734
src/engraving/types/symnames.cpp
View file

File diff suppressed because it is too large Load diff

2
src/engraving/types/types.h
View file

@ -796,7 +796,7 @@ using InstrumentTrackIdSet = std::unordered_set<InstrumentTrackId>;
enum EmbellishmentType {};
enum DrumPitch {};
enum DrumNum {};
enum class GlissandoType {
STRAIGHT, WAVY

128
src/engraving/types/typesconv.cpp
View file

@ -1341,11 +1341,16 @@ TextPlace TConv::fromXml(const AsciiStringView& tag, TextPlace def)
return oldit->type;
}
static const std::vector<Item<DirectionV> > DIRECTIONV_TYPES = {
{ DirectionV::AUTO, "auto" },
{ DirectionV::UP, "up" },
{ DirectionV::DOWN, "down" }
};
static const std::array<Item<DirectionV>, 3 > DIRECTIONV_TYPES = { {
{ DirectionV::AUTO, "auto", QT_TRANSLATE_NOOP("engraving", "Auto") },
{ DirectionV::UP, "up", QT_TRANSLATE_NOOP("engraving", "Up") },
{ DirectionV::DOWN, "down", QT_TRANSLATE_NOOP("engraving", "Down") },
} };
String TConv::translatedUserName(DirectionV v)
{
return mtrc("engraving", findUserNameByType<DirectionV>(DIRECTIONV_TYPES, v));
}
AsciiStringView TConv::toXml(DirectionV v)
{
@ -1373,11 +1378,16 @@ DirectionV TConv::fromXml(const AsciiStringView& tag, DirectionV def)
}
static const std::vector<Item<DirectionH> > DIRECTIONH_TYPES = {
{ DirectionH::AUTO, "auto" },
{ DirectionH::RIGHT, "right" },
{ DirectionH::LEFT, "left" }
{ DirectionH::AUTO, "auto", QT_TRANSLATE_NOOP("engraving", "Auto") },
{ DirectionH::RIGHT, "right", QT_TRANSLATE_NOOP("engraving", "Right") },
{ DirectionH::LEFT, "left", QT_TRANSLATE_NOOP("engraving", "Left") },
};
String TConv::translatedUserName(DirectionH v)
{
return mtrc("engraving", findUserNameByType<DirectionH>(DIRECTIONH_TYPES, v));
}
AsciiStringView TConv::toXml(DirectionH v)
{
return findXmlTagByType<DirectionH>(DIRECTIONH_TYPES, v);
@ -1983,46 +1993,92 @@ ChordLineType TConv::fromXml(const AsciiStringView& tag, ChordLineType def)
}
struct DrumPitchItem {
DrumPitch pitch;
DrumNum num = DrumNum(0);
const char* userName = nullptr;
};
static const std::vector<DrumPitchItem> DRUMPITCHS = {
{ DrumPitch(35), QT_TRANSLATE_NOOP("engraving", "Acoustic Bass Drum") },
{ DrumPitch(36), QT_TRANSLATE_NOOP("engraving", "Bass Drum 1") },
{ DrumPitch(37), QT_TRANSLATE_NOOP("engraving", "Side Stick") },
{ DrumPitch(38), QT_TRANSLATE_NOOP("engraving", "Acoustic Snare") },
{ DrumNum(27), QT_TRANSLATE_NOOP("engraving", "High Q") },
{ DrumNum(28), QT_TRANSLATE_NOOP("engraving", "Slap") },
{ DrumNum(29), QT_TRANSLATE_NOOP("engraving", "Scratch Push") },
{ DrumPitch(40), QT_TRANSLATE_NOOP("engraving", "Electric Snare") },
{ DrumPitch(41), QT_TRANSLATE_NOOP("engraving", "Low Floor Tom") },
{ DrumPitch(42), QT_TRANSLATE_NOOP("engraving", "Closed Hi-Hat") },
{ DrumPitch(43), QT_TRANSLATE_NOOP("engraving", "High Floor Tom") },
{ DrumPitch(44), QT_TRANSLATE_NOOP("engraving", "Pedal Hi-Hat") },
{ DrumPitch(45), QT_TRANSLATE_NOOP("engraving", "Low Tom") },
{ DrumPitch(46), QT_TRANSLATE_NOOP("engraving", "Open Hi-Hat") },
{ DrumPitch(47), QT_TRANSLATE_NOOP("engraving", "Low-Mid Tom") },
{ DrumPitch(48), QT_TRANSLATE_NOOP("engraving", "Hi-Mid Tom") },
{ DrumPitch(49), QT_TRANSLATE_NOOP("engraving", "Crash Cymbal 1") },
{ DrumNum(30), QT_TRANSLATE_NOOP("engraving", "Scratch Pull") },
{ DrumNum(31), QT_TRANSLATE_NOOP("engraving", "Sticks") },
{ DrumNum(32), QT_TRANSLATE_NOOP("engraving", "Square Click") },
{ DrumNum(33), QT_TRANSLATE_NOOP("engraving", "Metronome Click") },
{ DrumNum(34), QT_TRANSLATE_NOOP("engraving", "Metronome Bell") },
{ DrumNum(35), QT_TRANSLATE_NOOP("engraving", "Acoustic Bass Drum") },
{ DrumNum(36), QT_TRANSLATE_NOOP("engraving", "Bass Drum 1") },
{ DrumNum(37), QT_TRANSLATE_NOOP("engraving", "Side Stick") },
{ DrumNum(38), QT_TRANSLATE_NOOP("engraving", "Acoustic Snare") },
{ DrumNum(39), QT_TRANSLATE_NOOP("engraving", "Hand Clap") },
{ DrumPitch(50), QT_TRANSLATE_NOOP("engraving", "High Tom") },
{ DrumPitch(51), QT_TRANSLATE_NOOP("engraving", "Ride Cymbal 1") },
{ DrumPitch(52), QT_TRANSLATE_NOOP("engraving", "Chinese Cymbal") },
{ DrumPitch(53), QT_TRANSLATE_NOOP("engraving", "Ride Bell") },
{ DrumPitch(54), QT_TRANSLATE_NOOP("engraving", "Tambourine") },
{ DrumPitch(55), QT_TRANSLATE_NOOP("engraving", "Splash Cymbal") },
{ DrumPitch(56), QT_TRANSLATE_NOOP("engraving", "Cowbell") },
{ DrumPitch(57), QT_TRANSLATE_NOOP("engraving", "Crash Cymbal 2") },
{ DrumNum(40), QT_TRANSLATE_NOOP("engraving", "Electric Snare") },
{ DrumNum(41), QT_TRANSLATE_NOOP("engraving", "Low Floor Tom") },
{ DrumNum(42), QT_TRANSLATE_NOOP("engraving", "Closed Hi-Hat") },
{ DrumNum(43), QT_TRANSLATE_NOOP("engraving", "High Floor Tom") },
{ DrumNum(44), QT_TRANSLATE_NOOP("engraving", "Pedal Hi-Hat") },
{ DrumNum(45), QT_TRANSLATE_NOOP("engraving", "Low Tom") },
{ DrumNum(46), QT_TRANSLATE_NOOP("engraving", "Open Hi-Hat") },
{ DrumNum(47), QT_TRANSLATE_NOOP("engraving", "Low-Mid Tom") },
{ DrumNum(48), QT_TRANSLATE_NOOP("engraving", "Hi-Mid Tom") },
{ DrumNum(49), QT_TRANSLATE_NOOP("engraving", "Crash Cymbal 1") },
{ DrumPitch(59), QT_TRANSLATE_NOOP("engraving", "Ride Cymbal 2") },
{ DrumNum(50), QT_TRANSLATE_NOOP("engraving", "High Tom") },
{ DrumNum(51), QT_TRANSLATE_NOOP("engraving", "Ride Cymbal 1") },
{ DrumNum(52), QT_TRANSLATE_NOOP("engraving", "Chinese Cymbal") },
{ DrumNum(53), QT_TRANSLATE_NOOP("engraving", "Ride Bell") },
{ DrumNum(54), QT_TRANSLATE_NOOP("engraving", "Tambourine") },
{ DrumNum(55), QT_TRANSLATE_NOOP("engraving", "Splash Cymbal") },
{ DrumNum(56), QT_TRANSLATE_NOOP("engraving", "Cowbell") },
{ DrumNum(57), QT_TRANSLATE_NOOP("engraving", "Crash Cymbal 2") },
{ DrumNum(58), QT_TRANSLATE_NOOP("engraving", "Vibraslap") },
{ DrumNum(59), QT_TRANSLATE_NOOP("engraving", "Ride Cymbal 2") },
{ DrumPitch(63), QT_TRANSLATE_NOOP("engraving", "Open Hi Conga") },
{ DrumPitch(64), QT_TRANSLATE_NOOP("engraving", "Low Conga") },
{ DrumNum(60), QT_TRANSLATE_NOOP("engraving", "Hi Bongo") },
{ DrumNum(61), QT_TRANSLATE_NOOP("engraving", "Low Bongo") },
{ DrumNum(62), QT_TRANSLATE_NOOP("engraving", "Mute Hi Conga") },
{ DrumNum(63), QT_TRANSLATE_NOOP("engraving", "Open Hi Conga") },
{ DrumNum(64), QT_TRANSLATE_NOOP("engraving", "Low Conga") },
{ DrumNum(65), QT_TRANSLATE_NOOP("engraving", "High Timbale") },
{ DrumNum(66), QT_TRANSLATE_NOOP("engraving", "Low Timbale") },
{ DrumNum(67), QT_TRANSLATE_NOOP("engraving", "High Agogo") },
{ DrumNum(68), QT_TRANSLATE_NOOP("engraving", "Low Agogo") },
{ DrumNum(69), QT_TRANSLATE_NOOP("engraving", "Cabasa") },
{ DrumNum(70), QT_TRANSLATE_NOOP("engraving", "Maracas") },
{ DrumNum(71), QT_TRANSLATE_NOOP("engraving", "Short Whistle") },
{ DrumNum(72), QT_TRANSLATE_NOOP("engraving", "Long Whistle") },
{ DrumNum(73), QT_TRANSLATE_NOOP("engraving", "Short Güiro") },
{ DrumNum(74), QT_TRANSLATE_NOOP("engraving", "Long Güiro") },
{ DrumNum(75), QT_TRANSLATE_NOOP("engraving", "Claves") },
{ DrumNum(76), QT_TRANSLATE_NOOP("engraving", "Hi Wood Block") },
{ DrumNum(77), QT_TRANSLATE_NOOP("engraving", "Low Wood Block") },
{ DrumNum(78), QT_TRANSLATE_NOOP("engraving", "Mute Cuica") },
{ DrumNum(79), QT_TRANSLATE_NOOP("engraving", "Open Cuica") },
{ DrumNum(80), QT_TRANSLATE_NOOP("engraving", "Mute Triangle") },
{ DrumNum(81), QT_TRANSLATE_NOOP("engraving", "Open Triangle") },
{ DrumNum(82), QT_TRANSLATE_NOOP("engraving", "Shaker") },
{ DrumNum(83), QT_TRANSLATE_NOOP("engraving", "Sleigh Bell") },
{ DrumNum(84), QT_TRANSLATE_NOOP("engraving", "Mark Tree") },
{ DrumNum(85), QT_TRANSLATE_NOOP("engraving", "Castanets") },
{ DrumNum(86), QT_TRANSLATE_NOOP("engraving", "Mute Surdo") },
{ DrumNum(87), QT_TRANSLATE_NOOP("engraving", "Open Surdo") },
{ DrumNum(91), QT_TRANSLATE_NOOP("engraving", "Snare (Rim shot)") },
{ DrumNum(93), QT_TRANSLATE_NOOP("engraving", "Ride (Edge)") },
{ DrumNum(99), QT_TRANSLATE_NOOP("engraving", "Cowbell Low") },
{ DrumNum(102), QT_TRANSLATE_NOOP("engraving", "Cowbell High") },
};
const char* TConv::userName(DrumPitch v)
const char* TConv::userName(DrumNum v)
{
auto it = std::find_if(DRUMPITCHS.cbegin(), DRUMPITCHS.cend(), [v](const DrumPitchItem& i) {
return i.pitch == v;
return i.num == v;
});
IF_ASSERT_FAILED(it != DRUMPITCHS.cend()) {

4
src/engraving/types/typesconv.h
View file

@ -131,8 +131,10 @@ public:
static AsciiStringView toXml(TextPlace v);
static TextPlace fromXml(const AsciiStringView& str, TextPlace def);
static String translatedUserName(DirectionV v);
static AsciiStringView toXml(DirectionV v);
static DirectionV fromXml(const AsciiStringView& str, DirectionV def);
static String translatedUserName(DirectionH v);
static AsciiStringView toXml(DirectionH v);
static DirectionH fromXml(const AsciiStringView& str, DirectionH def);
@ -175,7 +177,7 @@ public:
static AsciiStringView toXml(ChordLineType v);
static ChordLineType fromXml(const AsciiStringView& tag, ChordLineType def);
static const char* userName(DrumPitch v);
static const char* userName(DrumNum v);
static const char* userName(GlissandoType v);
static String translatedUserName(GlissandoType v);

149
src/importexport/guitarpro/internal/importgtp.cpp
View file

@ -28,11 +28,12 @@
#include "importptb.h"
#include "rw/xml.h"
#include "translation.h"
#include "interactive/messagebox.h"
#include "rw/xml.h"
#include "types/typesconv.h"
#include <libmscore/factory.h>
#include <libmscore/measurebase.h>
#include <libmscore/text.h>
@ -323,77 +324,81 @@ void GuitarPro::initGuitarProDrumset()
gpDrumset->drum(i).stemDirection = DirectionV::UP;
}
// new drumset determined via guitar pro (third argument specifies position on staff, 10 = C3, 9 = D3, 8 = E3,...)
gpDrumset->drum(27) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Q"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(28) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Slap"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(29) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Scratch Push"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(30) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Scratch Pull"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(31) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Sticks"), NoteHeadGroup::HEAD_CROSS, 3, DirectionV::UP);
gpDrumset->drum(32) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Square Click"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(33) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Metronome Click"), NoteHeadGroup::HEAD_CROSS, 3, DirectionV::UP);
gpDrumset->drum(34) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Metronome Bell"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(35)
= DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Acoustic Bass Drum"), NoteHeadGroup::HEAD_NORMAL, 7, DirectionV::UP);
gpDrumset->drum(36) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Bass Drum 1"), NoteHeadGroup::HEAD_NORMAL, 7, DirectionV::UP);
gpDrumset->drum(37) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Side Stick"), NoteHeadGroup::HEAD_CROSS, 3, DirectionV::UP);
gpDrumset->drum(38) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Acoustic Snare"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(39) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Hand Clap"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(40) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Electric Snare"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(41) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Floor Tom"), NoteHeadGroup::HEAD_NORMAL, 6, DirectionV::UP);
gpDrumset->drum(42) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Closed Hi-Hat"), NoteHeadGroup::HEAD_CROSS, -1, DirectionV::UP);
gpDrumset->drum(43) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Floor Tom"), NoteHeadGroup::HEAD_NORMAL, 6, DirectionV::UP);
gpDrumset->drum(44) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Pedal Hi-Hat"), NoteHeadGroup::HEAD_CROSS, 9, DirectionV::UP);
gpDrumset->drum(45) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Tom"), NoteHeadGroup::HEAD_NORMAL, 5, DirectionV::UP);
gpDrumset->drum(46) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Hi-Hat"), NoteHeadGroup::HEAD_XCIRCLE, -1, DirectionV::UP);
gpDrumset->drum(47) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low-Mid Tom"), NoteHeadGroup::HEAD_NORMAL, 4, DirectionV::UP);
gpDrumset->drum(48) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Hi-Mid Tom"), NoteHeadGroup::HEAD_NORMAL, 2, DirectionV::UP);
gpDrumset->drum(49) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Crash Cymbal 1"), NoteHeadGroup::HEAD_CROSS, -2, DirectionV::UP);
gpDrumset->drum(50) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Tom"), NoteHeadGroup::HEAD_NORMAL, 1, DirectionV::UP);
gpDrumset->drum(51) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Ride Cymbal 1"), NoteHeadGroup::HEAD_CROSS, 0, DirectionV::UP);
gpDrumset->drum(52) = DrumInstrument(QT_TRANSLATE_NOOP("drumset",
"Chinese Cymbal"), NoteHeadGroup::HEAD_HEAVY_CROSS_HAT, -3, DirectionV::UP);
gpDrumset->drum(53) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Ride Bell"), NoteHeadGroup::HEAD_DIAMOND, 0, DirectionV::UP);
gpDrumset->drum(54) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Tambourine"), NoteHeadGroup::HEAD_CROSS, 2, DirectionV::UP);
gpDrumset->drum(55) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Splash Cymbal"), NoteHeadGroup::HEAD_CROSS, -2, DirectionV::UP);
gpDrumset->drum(56) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Cowbell Medium"), NoteHeadGroup::HEAD_NORMAL, 0, DirectionV::UP);
gpDrumset->drum(57) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Crash Cymbal 2"), NoteHeadGroup::HEAD_CROSS, -1, DirectionV::UP);
gpDrumset->drum(58) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Vibraslap"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(59) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Ride Cymbal 2"), NoteHeadGroup::HEAD_CROSS, 2, DirectionV::UP);
gpDrumset->drum(60) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Hi Bongo"), NoteHeadGroup::HEAD_NORMAL, 8, DirectionV::UP);
gpDrumset->drum(61) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Bongo"), NoteHeadGroup::HEAD_NORMAL, 9, DirectionV::UP);
gpDrumset->drum(62) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Mute Hi Conga"), NoteHeadGroup::HEAD_CROSS, 5, DirectionV::UP);
gpDrumset->drum(63) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Hi Conga"), NoteHeadGroup::HEAD_CROSS, 4, DirectionV::UP);
gpDrumset->drum(64) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Conga"), NoteHeadGroup::HEAD_CROSS, 6, DirectionV::UP);
gpDrumset->drum(65) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Timbale"), NoteHeadGroup::HEAD_CROSS, 8, DirectionV::UP);
gpDrumset->drum(66) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Timbale"), NoteHeadGroup::HEAD_CROSS, 9, DirectionV::UP);
gpDrumset->drum(67) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "High Agogo"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(68) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Agogo"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(69) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Cabasa"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(70) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Maracas"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(71) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Short Whistle"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(72) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Long Whistle"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(73) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Short Güiro"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(74) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Long Güiro"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(75) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Claves"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(76) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Hi Wood Block"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(77) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Low Wood Block"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(78) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Mute Cuica"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(79) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Cuica"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(80) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Mute Triangle"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(81) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Triangle"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(82) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Shaker"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(83) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Sleigh Bell"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(84) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Mark Tree"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(85) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Castanets"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(86) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Mute Surdo"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(87) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Open Surdo"), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(91) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Snare (Rim shot)"), NoteHeadGroup::HEAD_DIAMOND, 3, DirectionV::UP);
gpDrumset->drum(93) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Ride (Edge)"), NoteHeadGroup::HEAD_CROSS, 0, DirectionV::UP);
gpDrumset->drum(27) = DrumInstrument(TConv::userName(DrumNum(27)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(28) = DrumInstrument(TConv::userName(DrumNum(28)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(29) = DrumInstrument(TConv::userName(DrumNum(29)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(30) = DrumInstrument(TConv::userName(DrumNum(30)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(31) = DrumInstrument(TConv::userName(DrumNum(31)), NoteHeadGroup::HEAD_CROSS, 3, DirectionV::UP);
gpDrumset->drum(32) = DrumInstrument(TConv::userName(DrumNum(32)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(33) = DrumInstrument(TConv::userName(DrumNum(33)), NoteHeadGroup::HEAD_CROSS, 3, DirectionV::UP);
gpDrumset->drum(34) = DrumInstrument(TConv::userName(DrumNum(34)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(35) = DrumInstrument(TConv::userName(DrumNum(35)), NoteHeadGroup::HEAD_NORMAL, 7, DirectionV::UP);
gpDrumset->drum(36) = DrumInstrument(TConv::userName(DrumNum(36)), NoteHeadGroup::HEAD_NORMAL, 7, DirectionV::UP);
gpDrumset->drum(37) = DrumInstrument(TConv::userName(DrumNum(37)), NoteHeadGroup::HEAD_CROSS, 3, DirectionV::UP);
gpDrumset->drum(38) = DrumInstrument(TConv::userName(DrumNum(38)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(39) = DrumInstrument(TConv::userName(DrumNum(39)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(40) = DrumInstrument(TConv::userName(DrumNum(40)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(41) = DrumInstrument(TConv::userName(DrumNum(41)), NoteHeadGroup::HEAD_NORMAL, 6, DirectionV::UP);
gpDrumset->drum(42) = DrumInstrument(TConv::userName(DrumNum(42)), NoteHeadGroup::HEAD_CROSS, -1, DirectionV::UP);
gpDrumset->drum(43) = DrumInstrument(TConv::userName(DrumNum(43)), NoteHeadGroup::HEAD_NORMAL, 6, DirectionV::UP);
gpDrumset->drum(44) = DrumInstrument(TConv::userName(DrumNum(44)), NoteHeadGroup::HEAD_CROSS, 9, DirectionV::UP);
gpDrumset->drum(45) = DrumInstrument(TConv::userName(DrumNum(45)), NoteHeadGroup::HEAD_NORMAL, 5, DirectionV::UP);
gpDrumset->drum(46) = DrumInstrument(TConv::userName(DrumNum(46)), NoteHeadGroup::HEAD_XCIRCLE, -1, DirectionV::UP);
gpDrumset->drum(47) = DrumInstrument(TConv::userName(DrumNum(47)), NoteHeadGroup::HEAD_NORMAL, 4, DirectionV::UP);
gpDrumset->drum(48) = DrumInstrument(TConv::userName(DrumNum(48)), NoteHeadGroup::HEAD_NORMAL, 2, DirectionV::UP);
gpDrumset->drum(49) = DrumInstrument(TConv::userName(DrumNum(49)), NoteHeadGroup::HEAD_CROSS, -2, DirectionV::UP);
gpDrumset->drum(50) = DrumInstrument(TConv::userName(DrumNum(50)), NoteHeadGroup::HEAD_NORMAL, 1, DirectionV::UP);
gpDrumset->drum(51) = DrumInstrument(TConv::userName(DrumNum(51)), NoteHeadGroup::HEAD_CROSS, 0, DirectionV::UP);
gpDrumset->drum(52) = DrumInstrument(TConv::userName(DrumNum(52)), NoteHeadGroup::HEAD_HEAVY_CROSS_HAT, -3, DirectionV::UP);
gpDrumset->drum(53) = DrumInstrument(TConv::userName(DrumNum(53)), NoteHeadGroup::HEAD_DIAMOND, 0, DirectionV::UP);
gpDrumset->drum(54) = DrumInstrument(TConv::userName(DrumNum(54)), NoteHeadGroup::HEAD_CROSS, 2, DirectionV::UP);
gpDrumset->drum(55) = DrumInstrument(TConv::userName(DrumNum(55)), NoteHeadGroup::HEAD_CROSS, -2, DirectionV::UP);
gpDrumset->drum(56) = DrumInstrument(TConv::userName(DrumNum(56)), NoteHeadGroup::HEAD_NORMAL, 0, DirectionV::UP);
gpDrumset->drum(57) = DrumInstrument(TConv::userName(DrumNum(57)), NoteHeadGroup::HEAD_CROSS, -1, DirectionV::UP);
gpDrumset->drum(58) = DrumInstrument(TConv::userName(DrumNum(58)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(59) = DrumInstrument(TConv::userName(DrumNum(59)), NoteHeadGroup::HEAD_CROSS, 2, DirectionV::UP);
gpDrumset->drum(60) = DrumInstrument(TConv::userName(DrumNum(60)), NoteHeadGroup::HEAD_NORMAL, 8, DirectionV::UP);
gpDrumset->drum(61) = DrumInstrument(TConv::userName(DrumNum(61)), NoteHeadGroup::HEAD_NORMAL, 9, DirectionV::UP);
gpDrumset->drum(62) = DrumInstrument(TConv::userName(DrumNum(62)), NoteHeadGroup::HEAD_CROSS, 5, DirectionV::UP);
gpDrumset->drum(63) = DrumInstrument(TConv::userName(DrumNum(63)), NoteHeadGroup::HEAD_CROSS, 4, DirectionV::UP);
gpDrumset->drum(64) = DrumInstrument(TConv::userName(DrumNum(64)), NoteHeadGroup::HEAD_CROSS, 6, DirectionV::UP);
gpDrumset->drum(65) = DrumInstrument(TConv::userName(DrumNum(65)), NoteHeadGroup::HEAD_CROSS, 8, DirectionV::UP);
gpDrumset->drum(66) = DrumInstrument(TConv::userName(DrumNum(66)), NoteHeadGroup::HEAD_CROSS, 9, DirectionV::UP);
gpDrumset->drum(67) = DrumInstrument(TConv::userName(DrumNum(67)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(68) = DrumInstrument(TConv::userName(DrumNum(68)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(69) = DrumInstrument(TConv::userName(DrumNum(69)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(70) = DrumInstrument(TConv::userName(DrumNum(70)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(71) = DrumInstrument(TConv::userName(DrumNum(71)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(72) = DrumInstrument(TConv::userName(DrumNum(72)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(73) = DrumInstrument(TConv::userName(DrumNum(73)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(74) = DrumInstrument(TConv::userName(DrumNum(74)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(75) = DrumInstrument(TConv::userName(DrumNum(75)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(76) = DrumInstrument(TConv::userName(DrumNum(76)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(77) = DrumInstrument(TConv::userName(DrumNum(77)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(78) = DrumInstrument(TConv::userName(DrumNum(78)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(79) = DrumInstrument(TConv::userName(DrumNum(79)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(80) = DrumInstrument(TConv::userName(DrumNum(80)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(81) = DrumInstrument(TConv::userName(DrumNum(81)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(82) = DrumInstrument(TConv::userName(DrumNum(82)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(83) = DrumInstrument(TConv::userName(DrumNum(83)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(84) = DrumInstrument(TConv::userName(DrumNum(84)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(85) = DrumInstrument(TConv::userName(DrumNum(85)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(86) = DrumInstrument(TConv::userName(DrumNum(86)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(87) = DrumInstrument(TConv::userName(DrumNum(87)), NoteHeadGroup::HEAD_NORMAL, 3, DirectionV::UP);
gpDrumset->drum(91) = DrumInstrument(TConv::userName(DrumNum(91)), NoteHeadGroup::HEAD_DIAMOND, 3, DirectionV::UP);
gpDrumset->drum(93) = DrumInstrument(TConv::userName(DrumNum(93)), NoteHeadGroup::HEAD_CROSS, 0, DirectionV::UP);
//Additional clutch presets (midi by default can't play this)
gpDrumset->drum(99) = DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Cowbell Low"), NoteHeadGroup::HEAD_TRIANGLE_UP, 1, DirectionV::UP);
gpDrumset->drum(102)
= DrumInstrument(QT_TRANSLATE_NOOP("drumset", "Cowbell High"), NoteHeadGroup::HEAD_TRIANGLE_UP, -1, DirectionV::UP);
gpDrumset->drum(99) = DrumInstrument(TConv::userName(DrumNum(99)), NoteHeadGroup::HEAD_TRIANGLE_UP, 1, DirectionV::UP);
gpDrumset->drum(102)= DrumInstrument(TConv::userName(DrumNum(102)), NoteHeadGroup::HEAD_TRIANGLE_UP, -1, DirectionV::UP);
}
//---------------------------------------------------------
@ -3053,10 +3058,6 @@ static Score::FileError importScore(MasterScore* score, mu::io::IODevice* io)
return Score::FileError::FILE_NO_ERROR;
}
if (!mu::engraving::MScore::lastError.isEmpty()) {
LOGE() << mu::engraving::MScore::lastError;
}
addMetaInfo(score, gp);
int idx = 0;

130
src/importexport/midi/internal/midiimport/importmidi_model.cpp
View file

@ -21,7 +21,7 @@
*/
#include "importmidi_model.h"
#include <QCoreApplication>
#include "translation.h"
#include "importmidi_inner.h"
#include "importmidi_clef.h"
@ -86,8 +86,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Import");
return qtrc("iex_midi", "Import");
}
QVariant value(int trackIndex) const override
@ -109,8 +108,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
: Column(opers) {}
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Channel");
return qtrc("iex_midi", "Channel");
}
bool isEditable(int /*trackIndex*/) const override { return false; }
@ -142,8 +140,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
int width() const override { return 180; }
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Staff name");
return qtrc("iex_midi", "Staff name");
}
bool isEditable(int /*trackIndex*/) const override { return false; }
@ -174,8 +171,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
int width() const override { return 130; }
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Sound");
return qtrc("iex_midi", "Sound");
}
bool isEditable(int /*trackIndex*/) const override { return false; }
@ -207,8 +203,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
int width() const override { return 220; }
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "MuseScore instrument");
return qtrc("iex_midi", "MuseScore instrument");
}
bool isEditable(int trackIndex) const override
@ -271,8 +266,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
int width() const override { return 185; }
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Lyrics");
return qtrc("iex_midi", "Lyrics");
}
QVariant value(int trackIndex) const override
@ -317,18 +311,17 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QuantValue(MidiOperations::Opers& opers)
: Column(opers)
{
_values.push_back(QCoreApplication::translate("MIDI import operations", "Quarter"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "Eighth"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "16th"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "32nd"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "64th"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "128th"));
_values.push_back(qtrc("iex_midi", "Quarter"));
_values.push_back(qtrc("iex_midi", "Eighth"));
_values.push_back(qtrc("iex_midi", "16th"));
_values.push_back(qtrc("iex_midi", "32nd"));
_values.push_back(qtrc("iex_midi", "64th"));
_values.push_back(qtrc("iex_midi", "128th"));
}
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Max. quantization");
return qtrc("iex_midi", "Max. quantization");
}
QVariant value(int trackIndex) const override
@ -356,8 +349,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Max. voices");
return qtrc("iex_midi", "Max. voices");
}
QVariant value(int trackIndex) const override
@ -385,19 +377,18 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
Tuplets(MidiOperations::Opers& opers, int trackCount)
: Column(opers), _trackCount(trackCount)
{
_values.push_back(QCoreApplication::translate("MIDI import operations", "2-plets"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "3-plets"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "4-plets"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "5-plets"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "7-plets"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "9-plets"));
_values.push_back(qtrc("iex_midi", "2-plets"));
_values.push_back(qtrc("iex_midi", "3-plets"));
_values.push_back(qtrc("iex_midi", "4-plets"));
_values.push_back(qtrc("iex_midi", "5-plets"));
_values.push_back(qtrc("iex_midi", "7-plets"));
_values.push_back(qtrc("iex_midi", "9-plets"));
}
int width() const override { return 140; }
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Tuplets");
return qtrc("iex_midi", "Tuplets");
}
QVariant value(int trackIndex) const override
@ -541,29 +532,28 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
TimeSig(MidiOperations::Opers& opers)
: Column(opers)
{
_values.push_back(QCoreApplication::translate("MIDI import operations", "2"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "3"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "4"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "5"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "6"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "7"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "9"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "12"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "15"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "21"));
_values.push_back(qtrc("iex_midi", "2"));
_values.push_back(qtrc("iex_midi", "3"));
_values.push_back(qtrc("iex_midi", "4"));
_values.push_back(qtrc("iex_midi", "5"));
_values.push_back(qtrc("iex_midi", "6"));
_values.push_back(qtrc("iex_midi", "7"));
_values.push_back(qtrc("iex_midi", "9"));
_values.push_back(qtrc("iex_midi", "12"));
_values.push_back(qtrc("iex_midi", "15"));
_values.push_back(qtrc("iex_midi", "21"));
_numeratorCount = _values.size();
_values.push_back(QCoreApplication::translate("MIDI import operations", "2"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "4"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "8"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "16"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "32"));
_values.push_back(qtrc("iex_midi", "2"));
_values.push_back(qtrc("iex_midi", "4"));
_values.push_back(qtrc("iex_midi", "8"));
_values.push_back(qtrc("iex_midi", "16"));
_values.push_back(qtrc("iex_midi", "32"));
}
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Time signature");
return qtrc("iex_midi", "Time signature");
}
bool isForAllTracksOnly() const override { return true; }
@ -623,8 +613,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Halving the\nmeasure count");
return qtrc("iex_midi", "Halving the\nmeasure count");
}
bool isForAllTracksOnly() const override { return true; }
@ -650,8 +639,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Is human\nperformance");
return qtrc("iex_midi", "Is human\nperformance");
}
bool isForAllTracksOnly() const override { return true; }
@ -676,8 +664,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Split staff");
return qtrc("iex_midi", "Split staff");
}
QVariant value(int trackIndex) const override
@ -701,8 +688,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Clef\nchanges");
return qtrc("iex_midi", "Clef\nchanges");
}
bool isEditable(int trackIndex) const override
@ -746,8 +732,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Simplify\ndurations");
return qtrc("iex_midi", "Simplify\ndurations");
}
QVariant value(int trackIndex) const override
@ -771,8 +756,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Show\nstaccato");
return qtrc("iex_midi", "Show\nstaccato");
}
QVariant value(int trackIndex) const override
@ -796,8 +780,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Dotted\nnotes");
return qtrc("iex_midi", "Dotted\nnotes");
}
QVariant value(int trackIndex) const override
@ -822,8 +805,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Show\ntempo text");
return qtrc("iex_midi", "Show\ntempo text");
}
bool isForAllTracksOnly() const override { return true; }
@ -850,8 +832,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Show\nchord symbols");
return qtrc("iex_midi", "Show\nchord symbols");
}
bool isForAllTracksOnly() const override { return true; }
@ -877,8 +858,7 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Recognize\npickup measure");
return qtrc("iex_midi", "Recognize\npickup measure");
}
bool isForAllTracksOnly() const override { return true; }
@ -899,15 +879,14 @@ void TracksModel::reset(const MidiOperations::Opers& opers,
Swing(MidiOperations::Opers& opers)
: Column(opers)
{
_values.push_back(QCoreApplication::translate("MIDI import operations", "None (1:1)"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "Swing (2:1)"));
_values.push_back(QCoreApplication::translate("MIDI import operations", "Shuffle (3:1)"));
_values.push_back(qtrc("iex_midi", "None (1:1)"));
_values.push_back(qtrc("iex_midi", "Swing (2:1)"));
_values.push_back(qtrc("iex_midi", "Shuffle (3:1)"));
}
QString headerName() const override
{
return QCoreApplication::translate(
"MIDI import operations", "Detect swing");
return qtrc("iex_midi", "Detect swing");
}
int width() const override { return 130; }
@ -1234,13 +1213,12 @@ QVariant TracksModel::headerData(int section, Qt::Orientation orientation, int r
if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
if (!_columns.empty()) {
return QCoreApplication::translate("MIDI import: tracks model",
_columns[section]->headerName().toUtf8().constData());
return _columns[section]->headerName();
}
} else if (orientation == Qt::Vertical && role == Qt::DisplayRole) {
if (_trackCount > 1) {
if (section == 0) {
return QCoreApplication::translate("MIDI import: tracks model", "All");
return qtrc("iex_midi", "All");
}
return section;
}

6
src/importexport/musicxml/internal/musicxml/importmxml.cpp
View file

@ -22,6 +22,8 @@
#include <QMessageBox>
#include "translation.h"
#include "importmxml.h"
#include "importmxmllogger.h"
#include "importmxmlpass1.h"
@ -41,7 +43,7 @@ static int musicXMLImportErrorDialog(QString text, QString detailedText)
QMessageBox errorDialog;
errorDialog.setIcon(QMessageBox::Question);
errorDialog.setText(text);
errorDialog.setInformativeText(QObject::tr("Do you want to try to load this file anyway?"));
errorDialog.setInformativeText(qtrc("musicxml", "Do you want to try to load this file anyway?"));
errorDialog.setDetailedText(detailedText);
errorDialog.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
errorDialog.setDefaultButton(QMessageBox::No);
@ -79,7 +81,7 @@ Score::FileError importMusicXMLfromBuffer(Score* score, const QString& /*name*/,
const auto pass2_errors = pass2.errors();
if (!(pass1_errors.isEmpty() && pass2_errors.isEmpty())) {
if (!MScore::noGui) {
const QString text { QObject::tr("Error(s) found, import may be incomplete.") };
const QString text = qtrc("musicxml", "Error(s) found, import may be incomplete.");
if (musicXMLImportErrorDialog(text, pass1.errors() + pass2.errors()) != QMessageBox::Yes) {
res = Score::FileError::FILE_USER_ABORT;
}

27
src/importexport/musicxml/internal/musicxml/importxml.cpp
View file

@ -29,6 +29,7 @@
#include <QXmlSchemaValidator>
#include <QBuffer>
#include "translation.h"
#include "serialization/internal/qzipreader_p.h"
#include "importmxml.h"
@ -74,8 +75,7 @@ static bool initMusicXmlSchema(QXmlSchema& schema)
// read the MusicXML schema from the application resources
QFile schemaFile(":/schema/musicxml.xsd");
if (!schemaFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
LOGD("initMusicXmlSchema() could not open resource musicxml.xsd");
MScore::lastError = QObject::tr("Internal error: Could not open resource musicxml.xsd\n");
LOGE("initMusicXmlSchema() could not open resource musicxml.xsd");
return false;
}
@ -96,8 +96,7 @@ static bool initMusicXmlSchema(QXmlSchema& schema)
// load and validate the schema
schema.load(schemaBa);
if (!schema.isValid()) {
LOGD("initMusicXmlSchema() internal error: MusicXML schema is invalid");
MScore::lastError = QObject::tr("Internal error: MusicXML schema is invalid\n");
LOGE("initMusicXmlSchema() internal error: MusicXML schema is invalid");
return false;
}
@ -119,7 +118,7 @@ static int musicXMLValidationErrorDialog(QString text, QString detailedText)
QMessageBox errorDialog;
errorDialog.setIcon(QMessageBox::Question);
errorDialog.setText(text);
errorDialog.setInformativeText(QObject::tr("Do you want to try to load this file anyway?"));
errorDialog.setInformativeText(qtrc("musicxml", "Do you want to try to load this file anyway?"));
errorDialog.setDetailedText(detailedText);
errorDialog.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
errorDialog.setDefaultButton(QMessageBox::No);
@ -143,7 +142,7 @@ static bool extractRootfile(QFile* qf, QByteArray& data)
int line, column;
QString err;
if (!container.setContent(data, false, &err, &line, &column)) {
MScore::lastError = QObject::tr("Error reading container.xml at line %1 column %2: %3\n").arg(line).arg(column).arg(err);
LOGE() << QString("Error reading container.xml at line %1 column %2: %3\n").arg(line).arg(column).arg(err);
return false;
}
@ -172,8 +171,7 @@ static bool extractRootfile(QFile* qf, QByteArray& data)
}
if (rootfile == "") {
LOGD("can't find rootfile in: %s", qPrintable(qf->fileName()));
MScore::lastError = QObject::tr("Can't find rootfile\n%1").arg(qf->fileName());
LOGE("can't find rootfile in: %s", qPrintable(qf->fileName()));
return false;
}
@ -209,11 +207,11 @@ static Score::FileError doValidate(const QString& name, QIODevice* dev)
if (!valid) {
LOGD("importMusicXml() file '%s' is not a valid MusicXML file", qPrintable(name));
MScore::lastError = QObject::tr("File '%1' is not a valid MusicXML file").arg(name);
QString strErr = qtrc("musicxml", "File '%1' is not a valid MusicXML file").arg(name);
if (MScore::noGui) {
return Score::FileError::FILE_NO_ERROR; // might as well try anyhow in converter mode
}
if (musicXMLValidationErrorDialog(MScore::lastError, messageHandler.getErrors()) != QMessageBox::Yes) {
if (musicXMLValidationErrorDialog(strErr, messageHandler.getErrors()) != QMessageBox::Yes) {
return Score::FileError::FILE_USER_ABORT;
}
}
@ -262,8 +260,7 @@ Score::FileError importMusicXml(MasterScore* score, QIODevice* dev, const QStrin
ScoreLoad sl; // suppress warnings for undo push/pop
if (!dev->open(QIODevice::ReadOnly)) {
LOGD("importMusicXml() could not open MusicXML file '%s'", qPrintable(name));
MScore::lastError = QObject::tr("Could not open MusicXML file\n%1").arg(name);
LOGE("importMusicXml() could not open MusicXML file '%s'", qPrintable(name));
return Score::FileError::FILE_OPEN_ERROR;
}
@ -283,8 +280,7 @@ Score::FileError importMusicXml(MasterScore* score, const QString& name)
return Score::FileError::FILE_NOT_FOUND;
}
if (!xmlFile.open(QIODevice::ReadOnly)) {
LOGD("importMusicXml() could not open MusicXML file '%s'", qPrintable(name));
MScore::lastError = QObject::tr("Could not open MusicXML file\n%1").arg(name);
LOGE("importMusicXml() could not open MusicXML file '%s'", qPrintable(name));
return Score::FileError::FILE_OPEN_ERROR;
}
@ -311,8 +307,7 @@ Score::FileError importCompressedMusicXml(MasterScore* score, const QString& nam
return Score::FileError::FILE_NOT_FOUND;
}
if (!mxlFile.open(QIODevice::ReadOnly)) {
LOGD("importCompressedMusicXml() could not open compressed MusicXML file '%s'", qPrintable(name));
MScore::lastError = QObject::tr("Could not open compressed MusicXML file\n%1").arg(name);
LOGE("importCompressedMusicXml() could not open compressed MusicXML file '%s'", qPrintable(name));
return Score::FileError::FILE_OPEN_ERROR;
}

17
src/importexport/musicxml/internal/musicxml/musicxmlsupport.cpp
View file

@ -24,6 +24,7 @@
MusicXML support.
*/
#include "translation.h"
#include "libmscore/accidental.h"
#include "libmscore/articulation.h"
#include "libmscore/chord.h"
@ -188,19 +189,19 @@ void ValidatorMessageHandler::handleMessage(QtMsgType type, const QString& descr
QString strType;
switch (type) {
case 0: strType = tr("Debug");
case 0: strType = qtrc("musicxml", "Debug");
break;
case 1: strType = tr("Warning");
case 1: strType = qtrc("musicxml", "Warning");
break;
case 2: strType = tr("Critical");
case 2: strType = qtrc("musicxml", "Critical");
break;
case 3: strType = tr("Fatal");
case 3: strType = qtrc("musicxml", "Fatal");
break;
default: strType = tr("Unknown");
default: strType = qtrc("musicxml", "Unknown");
break;
}
QString errorStr = QString(tr("%1 error: line %2 column %3 %4"))
QString errorStr = qtrc("musicxml", "%1 error: line %2 column %3 %4")
.arg(strType)
.arg(sourceLocation.line())
.arg(sourceLocation.column())
@ -283,7 +284,7 @@ void domNotImplemented(const QDomElement& e)
QString xmlReaderLocation(const QXmlStreamReader& e)
{
return QObject::tr("line %1 column %2").arg(e.lineNumber()).arg(e.columnNumber());
return qtrc("musicxml", "line %1 column %2").arg(e.lineNumber()).arg(e.columnNumber());
}
//---------------------------------------------------------
@ -296,7 +297,7 @@ QString checkAtEndElement(const QXmlStreamReader& e, const QString& expName)
return "";
}
QString res = QObject::tr("expected token type and name 'EndElement %1', actual '%2 %3'")
QString res = qtrc("musicxml", "expected token type and name 'EndElement %1', actual '%2 %3'")
.arg(expName)
.arg(e.tokenString())
.arg(e.name().toString());

22
src/inspector/view/qml/MuseScore/Inspector/notation/barlines/BarlineSettings.qml
View file

@ -57,17 +57,17 @@ Column {
navigationRowStart: root.navigationRowStart
model: [
{ text: qsTrc("symUserNames", "Single barline"), value: BarlineTypes.TYPE_NORMAL },
{ text: qsTrc("symUserNames", "Double barline"), value: BarlineTypes.TYPE_DOUBLE },
{ text: qsTrc("symUserNames", "Left (start) repeat sign"), value: BarlineTypes.TYPE_START_REPEAT },
{ text: qsTrc("symUserNames", "Right (end) repeat sign"), value: BarlineTypes.TYPE_END_REPEAT },
{ text: qsTrc("symUserNames", "Right and left repeat sign"), value: BarlineTypes.TYPE_END_START_REPEAT },
{ text: qsTrc("symUserNames", "Dashed barline"), value: BarlineTypes.TYPE_DASHED },
{ text: qsTrc("symUserNames", "Final barline"), value: BarlineTypes.TYPE_FINAL },
{ text: qsTrc("symUserNames", "Dotted barline"), value: BarlineTypes.TYPE_DOTTED },
{ text: qsTrc("symUserNames", "Reverse final barline"), value: BarlineTypes.TYPE_REVERSE_END },
{ text: qsTrc("symUserNames", "Heavy barline"), value: BarlineTypes.TYPE_HEAVY },
{ text: qsTrc("symUserNames", "Heavy double barline"), value: BarlineTypes.TYPE_DOUBLE_HEAVY },
{ text: qsTrc("inspector", "Single barline"), value: BarlineTypes.TYPE_NORMAL },
{ text: qsTrc("inspector", "Double barline"), value: BarlineTypes.TYPE_DOUBLE },
{ text: qsTrc("inspector", "Left (start) repeat sign"), value: BarlineTypes.TYPE_START_REPEAT },
{ text: qsTrc("inspector", "Right (end) repeat sign"), value: BarlineTypes.TYPE_END_REPEAT },
{ text: qsTrc("inspector", "Right and left repeat sign"), value: BarlineTypes.TYPE_END_START_REPEAT },
{ text: qsTrc("inspector", "Dashed barline"), value: BarlineTypes.TYPE_DASHED },
{ text: qsTrc("inspector", "Final barline"), value: BarlineTypes.TYPE_FINAL },
{ text: qsTrc("inspector", "Dotted barline"), value: BarlineTypes.TYPE_DOTTED },
{ text: qsTrc("inspector", "Reverse final barline"), value: BarlineTypes.TYPE_REVERSE_END },
{ text: qsTrc("inspector", "Heavy barline"), value: BarlineTypes.TYPE_HEAVY },
{ text: qsTrc("inspector", "Heavy double barline"), value: BarlineTypes.TYPE_DOUBLE_HEAVY },
]
}

2
src/multiinstances/internal/multiinstancesuiactions.cpp
View file

@ -30,7 +30,7 @@ using namespace mu::mi;
const UiActionList MultiInstancesUiActions::m_actions = {
UiAction("multiinstances-dev-show-info",
mu::context::UiCtxAny,
QT_TRANSLATE_NOOP("mi", "Multiinstances")
"Multiinstances"
)
};

2
src/notation/internal/notationactioncontroller.cpp
View file

@ -1436,7 +1436,7 @@ void NotationActionController::saveStyle()
if (!path.empty()) {
if (!currentNotationStyle()->saveStyle(path)) {
interactive()->error(trc("notation", "The style file could not be saved."),
mu::engraving::MScore::lastError.toStdString(), { IInteractive::Button::Ok },
trc("notation", "There was some error"), { IInteractive::Button::Ok },
IInteractive::Button::Ok, IInteractive::Option::WithIcon);
}
}

4
src/notation/view/widgets/colorlabel.cpp
View file

@ -25,6 +25,8 @@
#include <QColorDialog>
#include <QPainter>
#include "translation.h"
namespace Awl {
//---------------------------------------------------------
// ColorLabel
@ -102,7 +104,7 @@ void ColorLabel::colorButtonClicked(bool)
return;
}
QColor c = QColorDialog::getColor(_color, this,
tr("Select Color"),
qtrc("notation", "Select Color"),
QColorDialog::ShowAlphaChannel
);
if (c.isValid()) {

28
src/notation/view/widgets/editstaff.cpp
View file

@ -22,6 +22,12 @@
#include "editstaff.h"
#include "translation.h"
#include "global/utils.h"
#include "ui/view/widgetstatestore.h"
#include "ui/view/widgetutils.h"
#include "editpitch.h"
#include "editstafftype.h"
#include "editstringdata.h"
@ -37,11 +43,6 @@
#include "libmscore/instrumentname.h"
#include "libmscore/system.h"
#include "translation.h"
#include "ui/view/widgetstatestore.h"
#include "ui/view/widgetutils.h"
#include "log.h"
using namespace mu::notation;
@ -638,24 +639,9 @@ void EditStaff::editStringDataClicked()
}
}
static const char* s_es_noteNames[] = {
QT_TRANSLATE_NOOP("editstaff", "C"),
QT_TRANSLATE_NOOP("editstaff", "C♯"),
QT_TRANSLATE_NOOP("editstaff", "D"),
QT_TRANSLATE_NOOP("editstaff", "E♭"),
QT_TRANSLATE_NOOP("editstaff", "E"),
QT_TRANSLATE_NOOP("editstaff", "F"),
QT_TRANSLATE_NOOP("editstaff", "F♯"),
QT_TRANSLATE_NOOP("editstaff", "G"),
QT_TRANSLATE_NOOP("editstaff", "A♭"),
QT_TRANSLATE_NOOP("editstaff", "A"),
QT_TRANSLATE_NOOP("editstaff", "B♭"),
QT_TRANSLATE_NOOP("editstaff", "B")
};
QString EditStaff::midiCodeToStr(int midiCode)
{
return QString("%1 %2").arg(qtrc("editstaff", s_es_noteNames[midiCode % 12])).arg(midiCode / 12 - 1);
return QString("%1 %2").arg(QString::fromStdString(mu::pitchToString(midiCode))).arg(midiCode / 12 - 1);
}
void EditStaff::showStaffTypeDialog()

28
src/notation/view/widgets/editstringdata.cpp
View file

@ -25,6 +25,7 @@
#include <QKeyEvent>
#include "translation.h"
#include "global/utils.h"
#include "ui/view/widgetstatestore.h"
#include "ui/view/widgetnavigationfix.h"
#include "editpitch.h"
@ -48,7 +49,7 @@ EditStringData::EditStringData(QWidget* parent, std::vector<mu::engraving::instr
_strings = strings;
QStringList hdrLabels;
int numOfStrings = static_cast<int>(_strings->size());
hdrLabels << tr("Open", "string data") << tr("Pitch", "string data");
hdrLabels << qtrc("notation", "Open", "string data") << qtrc("notation", "Pitch", "string data");
stringList->setHorizontalHeaderLabels(hdrLabels);
stringList->setRowCount(numOfStrings);
// if any string, insert into string list control and select the first one
@ -138,7 +139,9 @@ bool EditStringData::eventFilter(QObject* obj, QEvent* event)
QString EditStringData::openColumnAccessibleText(const QTableWidgetItem* item) const
{
QString accessibleText = item->data(OPEN_ACCESSIBLE_TITLE_ROLE).toString() + ": "
+ (item->checkState() == Qt::Checked ? tr("checked") : tr("unchecked"));
+ (item->checkState() == Qt::Checked
? qtrc("notation", "checked")
: qtrc("notation", "unchecked"));
return accessibleText;
}
@ -263,26 +266,7 @@ void EditStringData::accept()
}
}
//---------------------------------------------------------
// midiCodeToStr
// Converts a MIDI numeric pitch code to human-readable note name
//---------------------------------------------------------
static const char* s_esd_noteNames[] = {
QT_TRANSLATE_NOOP("editstringdata", "C"),
QT_TRANSLATE_NOOP("editstringdata", "C♯"),
QT_TRANSLATE_NOOP("editstringdata", "D"),
QT_TRANSLATE_NOOP("editstringdata", "E♭"),
QT_TRANSLATE_NOOP("editstringdata", "E"),
QT_TRANSLATE_NOOP("editstringdata", "F"),
QT_TRANSLATE_NOOP("editstringdata", "F♯"),
QT_TRANSLATE_NOOP("editstringdata", "G"),
QT_TRANSLATE_NOOP("editstringdata", "A♭"),
QT_TRANSLATE_NOOP("editstringdata", "A"),
QT_TRANSLATE_NOOP("editstringdata", "B♭"),
QT_TRANSLATE_NOOP("editstringdata", "B")
};
QString EditStringData::midiCodeToStr(int midiCode)
{
return QString("%1 %2").arg(qApp->translate("editstringdata", s_esd_noteNames[midiCode % 12])).arg(midiCode / 12 - 1);
return QString("%1 %2").arg(QString::fromStdString(mu::pitchToString(midiCode))).arg(midiCode / 12 - 1);
}

196
src/notation/view/widgets/editstyle.cpp
View file

@ -178,23 +178,12 @@ static constexpr const char* lineStyles[] = {
QT_TRANSLATE_NOOP("notation", "Dotted"),
};
static QString toUserString(DirectionV val)
{
switch (val) {
case DirectionV::AUTO: return qtrc("Direction", "Auto");
case DirectionV::UP: return qtrc("Direction", "Up");
case DirectionV::DOWN: return qtrc("Direction", "Down");
}
return QString();
}
static void fillDirectionComboBox(QComboBox* comboBox)
{
comboBox->clear();
comboBox->addItem(toUserString(DirectionV::AUTO), static_cast<int>(DirectionV::AUTO));
comboBox->addItem(toUserString(DirectionV::UP), static_cast<int>(DirectionV::UP));
comboBox->addItem(toUserString(DirectionV::DOWN), static_cast<int>(DirectionV::DOWN));
comboBox->addItem(TConv::translatedUserName(DirectionV::AUTO), static_cast<int>(DirectionV::AUTO));
comboBox->addItem(TConv::translatedUserName(DirectionV::UP), static_cast<int>(DirectionV::UP));
comboBox->addItem(TConv::translatedUserName(DirectionV::DOWN), static_cast<int>(DirectionV::DOWN));
}
//---------------------------------------------------------
@ -209,7 +198,7 @@ EditStyle::EditStyle(QWidget* parent)
setWindowFlag(Qt::WindowContextHelpButtonHint, false);
setModal(true);
buttonApplyToAllParts = buttonBox->addButton(tr("Apply to all Parts"), QDialogButtonBox::ApplyRole);
buttonApplyToAllParts = buttonBox->addButton(qtrc("notation/editstyle", "Apply to all Parts"), QDialogButtonBox::ApplyRole);
WidgetUtils::setWidgetIcon(buttonTogglePagelist, IconCode::Code::ARROW_RIGHT);
// ====================================================
@ -667,8 +656,8 @@ EditStyle::EditStyle(QWidget* parent)
for (QComboBox* cb : verticalPlacementComboBoxes) {
cb->clear();
cb->addItem(tr("Above"), int(mu::engraving::PlacementV::ABOVE));
cb->addItem(tr("Below"), int(mu::engraving::PlacementV::BELOW));
cb->addItem(qtrc("notation/editstyle", "Above"), int(mu::engraving::PlacementV::ABOVE));
cb->addItem(qtrc("notation/editstyle", "Below"), int(mu::engraving::PlacementV::BELOW));
}
horizontalPlacementComboBoxes = {
@ -678,30 +667,30 @@ EditStyle::EditStyle(QWidget* parent)
for (QComboBox* cb : horizontalPlacementComboBoxes) {
cb->clear();
cb->addItem(tr("Left"), int(mu::engraving::PlacementH::LEFT));
cb->addItem(tr("Center"), int(mu::engraving::PlacementH::CENTER));
cb->addItem(tr("Right"), int(mu::engraving::PlacementH::RIGHT));
cb->addItem(qtrc("notation/editstyle", "Left"), int(mu::engraving::PlacementH::LEFT));
cb->addItem(qtrc("notation/editstyle", "Center"), int(mu::engraving::PlacementH::CENTER));
cb->addItem(qtrc("notation/editstyle", "Right"), int(mu::engraving::PlacementH::RIGHT));
}
mmRestRangeBracketType->clear();
mmRestRangeBracketType->addItem(tr("None"), int(mu::engraving::MMRestRangeBracketType::NONE));
mmRestRangeBracketType->addItem(tr("Brackets"), int(mu::engraving::MMRestRangeBracketType::BRACKETS));
mmRestRangeBracketType->addItem(tr("Parentheses"), int(mu::engraving::MMRestRangeBracketType::PARENTHESES));
mmRestRangeBracketType->addItem(qtrc("notation/editstyle", "None"), int(mu::engraving::MMRestRangeBracketType::NONE));
mmRestRangeBracketType->addItem(qtrc("notation/editstyle", "Brackets"), int(mu::engraving::MMRestRangeBracketType::BRACKETS));
mmRestRangeBracketType->addItem(qtrc("notation/editstyle", "Parentheses"), int(mu::engraving::MMRestRangeBracketType::PARENTHESES));
autoplaceVerticalAlignRange->clear();
autoplaceVerticalAlignRange->addItem(tr("Segment"), int(mu::engraving::VerticalAlignRange::SEGMENT));
autoplaceVerticalAlignRange->addItem(tr("Measure"), int(mu::engraving::VerticalAlignRange::MEASURE));
autoplaceVerticalAlignRange->addItem(tr("System"), int(mu::engraving::VerticalAlignRange::SYSTEM));
autoplaceVerticalAlignRange->addItem(qtrc("notation/editstyle", "Segment"), int(mu::engraving::VerticalAlignRange::SEGMENT));
autoplaceVerticalAlignRange->addItem(qtrc("notation/editstyle", "Measure"), int(mu::engraving::VerticalAlignRange::MEASURE));
autoplaceVerticalAlignRange->addItem(qtrc("notation/editstyle", "System"), int(mu::engraving::VerticalAlignRange::SYSTEM));
tupletNumberType->clear();
tupletNumberType->addItem(tr("Number"), int(TupletNumberType::SHOW_NUMBER));
tupletNumberType->addItem(tr("Ratio"), int(TupletNumberType::SHOW_RELATION));
tupletNumberType->addItem(tr("None", "no tuplet number type"), int(TupletNumberType::NO_TEXT));
tupletNumberType->addItem(qtrc("notation/editstyle", "Number"), int(TupletNumberType::SHOW_NUMBER));
tupletNumberType->addItem(qtrc("notation/editstyle", "Ratio"), int(TupletNumberType::SHOW_RELATION));
tupletNumberType->addItem(qtrc("notation/editstyle", "None", "no tuplet number type"), int(TupletNumberType::NO_TEXT));
tupletBracketType->clear();
tupletBracketType->addItem(tr("Automatic"), int(TupletBracketType::AUTO_BRACKET));
tupletBracketType->addItem(tr("Bracket"), int(TupletBracketType::SHOW_BRACKET));
tupletBracketType->addItem(tr("None", "no tuplet bracket type"), int(TupletBracketType::SHOW_NO_BRACKET));
tupletBracketType->addItem(qtrc("notation/editstyle", "Automatic"), int(TupletBracketType::AUTO_BRACKET));
tupletBracketType->addItem(qtrc("notation/editstyle", "Bracket"), int(TupletBracketType::SHOW_BRACKET));
tupletBracketType->addItem(qtrc("notation/editstyle", "None", "no tuplet bracket type"), int(TupletBracketType::SHOW_NO_BRACKET));
musicalSymbolFont->clear();
int idx = 0;
@ -763,22 +752,25 @@ EditStyle::EditStyle(QWidget* parent)
harmonyPlay->setChecked(true);
voicingSelectWidget->interpretBox->clear();
voicingSelectWidget->interpretBox->addItem(tr("Jazz"), int(0)); // two-item combobox for boolean style variant
voicingSelectWidget->interpretBox->addItem(tr("Literal"), int(1)); // true = literal
voicingSelectWidget->interpretBox->addItem(qtrc("notation/editstyle", "Jazz"), int(0)); // two-item combobox for boolean style variant
voicingSelectWidget->interpretBox->addItem(qtrc("notation/editstyle", "Literal"), int(1)); // true = literal
voicingSelectWidget->voicingBox->clear();
voicingSelectWidget->voicingBox->addItem(tr("Automatic"), int(mu::engraving::Voicing::AUTO));
voicingSelectWidget->voicingBox->addItem(tr("Root Only"), int(mu::engraving::Voicing::ROOT_ONLY));
voicingSelectWidget->voicingBox->addItem(tr("Close"), int(mu::engraving::Voicing::CLOSE));
voicingSelectWidget->voicingBox->addItem(tr("Drop Two"), int(mu::engraving::Voicing::DROP_2));
voicingSelectWidget->voicingBox->addItem(tr("Six Note"), int(mu::engraving::Voicing::SIX_NOTE));
voicingSelectWidget->voicingBox->addItem(tr("Four Note"), int(mu::engraving::Voicing::FOUR_NOTE));
voicingSelectWidget->voicingBox->addItem(tr("Three Note"), int(mu::engraving::Voicing::THREE_NOTE));
voicingSelectWidget->voicingBox->addItem(qtrc("notation/editstyle", "Automatic"), int(mu::engraving::Voicing::AUTO));
voicingSelectWidget->voicingBox->addItem(qtrc("notation/editstyle", "Root Only"), int(mu::engraving::Voicing::ROOT_ONLY));
voicingSelectWidget->voicingBox->addItem(qtrc("notation/editstyle", "Close"), int(mu::engraving::Voicing::CLOSE));
voicingSelectWidget->voicingBox->addItem(qtrc("notation/editstyle", "Drop Two"), int(mu::engraving::Voicing::DROP_2));
voicingSelectWidget->voicingBox->addItem(qtrc("notation/editstyle", "Six Note"), int(mu::engraving::Voicing::SIX_NOTE));
voicingSelectWidget->voicingBox->addItem(qtrc("notation/editstyle", "Four Note"), int(mu::engraving::Voicing::FOUR_NOTE));
voicingSelectWidget->voicingBox->addItem(qtrc("notation/editstyle", "Three Note"), int(mu::engraving::Voicing::THREE_NOTE));
voicingSelectWidget->durationBox->clear();
voicingSelectWidget->durationBox->addItem(tr("Until Next Chord Symbol"), int(mu::engraving::HDuration::UNTIL_NEXT_CHORD_SYMBOL));
voicingSelectWidget->durationBox->addItem(tr("Until End of Measure"), int(mu::engraving::HDuration::STOP_AT_MEASURE_END));
voicingSelectWidget->durationBox->addItem(tr("Chord/Rest Duration"), int(mu::engraving::HDuration::SEGMENT_DURATION));
voicingSelectWidget->durationBox->addItem(qtrc("notation/editstyle", "Until Next Chord Symbol"),
int(mu::engraving::HDuration::UNTIL_NEXT_CHORD_SYMBOL));
voicingSelectWidget->durationBox->addItem(qtrc("notation/editstyle", "Until End of Measure"),
int(mu::engraving::HDuration::STOP_AT_MEASURE_END));
voicingSelectWidget->durationBox->addItem(qtrc("notation/editstyle", "Chord/Rest Duration"),
int(mu::engraving::HDuration::SEGMENT_DURATION));
// ====================================================
// Miscellaneous
@ -877,9 +869,9 @@ EditStyle::EditStyle(QWidget* parent)
}
textStyleFrameType->clear();
textStyleFrameType->addItem(tr("None", "no frame for text"), int(mu::engraving::FrameType::NO_FRAME));
textStyleFrameType->addItem(tr("Rectangle"), int(mu::engraving::FrameType::SQUARE));
textStyleFrameType->addItem(tr("Circle"), int(mu::engraving::FrameType::CIRCLE));
textStyleFrameType->addItem(qtrc("notation/editstyle", "None", "no frame for text"), int(mu::engraving::FrameType::NO_FRAME));
textStyleFrameType->addItem(qtrc("notation/editstyle", "Rectangle"), int(mu::engraving::FrameType::SQUARE));
textStyleFrameType->addItem(qtrc("notation/editstyle", "Circle"), int(mu::engraving::FrameType::CIRCLE));
WidgetUtils::setWidgetIcon(resetTextStyleName, IconCode::Code::UNDO);
connect(resetTextStyleName, &QToolButton::clicked, this, &EditStyle::resetUserStyleName);
@ -1068,7 +1060,7 @@ void EditStyle::retranslate()
{
retranslateUi(this);
buttonApplyToAllParts->setText(tr("Apply to all Parts"));
buttonApplyToAllParts->setText(qtrc("notation/editstyle", "Apply to all Parts"));
for (const LineStyleSelect* lineStyleSelect : m_lineStyleSelects) {
int idx = 0;
@ -1079,46 +1071,46 @@ void EditStyle::retranslate()
}
for (QComboBox* cb : verticalPlacementComboBoxes) {
cb->setItemText(0, tr("Above"));
cb->setItemText(1, tr("Below"));
cb->setItemText(0, qtrc("notation/editstyle", "Above"));
cb->setItemText(1, qtrc("notation/editstyle", "Below"));
}
for (QComboBox* cb : horizontalPlacementComboBoxes) {
cb->setItemText(0, tr("Left"));
cb->setItemText(1, tr("Center"));
cb->setItemText(2, tr("Right"));
cb->setItemText(0, qtrc("notation/editstyle", "Left"));
cb->setItemText(1, qtrc("notation/editstyle", "Center"));
cb->setItemText(2, qtrc("notation/editstyle", "Right"));
}
mmRestRangeBracketType->setItemText(0, tr("None"));
mmRestRangeBracketType->setItemText(1, tr("Brackets"));
mmRestRangeBracketType->setItemText(2, tr("Parentheses"));
mmRestRangeBracketType->setItemText(0, qtrc("notation/editstyle", "None"));
mmRestRangeBracketType->setItemText(1, qtrc("notation/editstyle", "Brackets"));
mmRestRangeBracketType->setItemText(2, qtrc("notation/editstyle", "Parentheses"));
autoplaceVerticalAlignRange->setItemText(0, tr("Segment"));
autoplaceVerticalAlignRange->setItemText(1, tr("Measure"));
autoplaceVerticalAlignRange->setItemText(2, tr("System"));
autoplaceVerticalAlignRange->setItemText(0, qtrc("notation/editstyle", "Segment"));
autoplaceVerticalAlignRange->setItemText(1, qtrc("notation/editstyle", "Measure"));
autoplaceVerticalAlignRange->setItemText(2, qtrc("notation/editstyle", "System"));
tupletNumberType->setItemText(0, tr("Number"));
tupletNumberType->setItemText(1, tr("Ratio"));
tupletNumberType->setItemText(2, tr("None", "no tuplet number type"));
tupletNumberType->setItemText(0, qtrc("notation/editstyle", "Number"));
tupletNumberType->setItemText(1, qtrc("notation/editstyle", "Ratio"));
tupletNumberType->setItemText(2, qtrc("notation/editstyle", "None", "no tuplet number type"));
tupletBracketType->setItemText(0, tr("Automatic"));
tupletBracketType->setItemText(1, tr("Bracket"));
tupletBracketType->setItemText(2, tr("None", "no tuplet bracket type"));
tupletBracketType->setItemText(0, qtrc("notation/editstyle", "Automatic"));
tupletBracketType->setItemText(1, qtrc("notation/editstyle", "Bracket"));
tupletBracketType->setItemText(2, qtrc("notation/editstyle", "None", "no tuplet bracket type"));
voicingSelectWidget->interpretBox->setItemText(0, tr("Jazz"));
voicingSelectWidget->interpretBox->setItemText(1, tr("Literal"));
voicingSelectWidget->interpretBox->setItemText(0, qtrc("notation/editstyle", "Jazz"));
voicingSelectWidget->interpretBox->setItemText(1, qtrc("notation/editstyle", "Literal"));
voicingSelectWidget->voicingBox->setItemText(0, tr("Automatic"));
voicingSelectWidget->voicingBox->setItemText(1, tr("Root Only"));
voicingSelectWidget->voicingBox->setItemText(2, tr("Close"));
voicingSelectWidget->voicingBox->setItemText(3, tr("Drop Two"));
voicingSelectWidget->voicingBox->setItemText(4, tr("Six Note"));
voicingSelectWidget->voicingBox->setItemText(5, tr("Four Note"));
voicingSelectWidget->voicingBox->setItemText(6, tr("Three Note"));
voicingSelectWidget->voicingBox->setItemText(0, qtrc("notation/editstyle", "Automatic"));
voicingSelectWidget->voicingBox->setItemText(1, qtrc("notation/editstyle", "Root Only"));
voicingSelectWidget->voicingBox->setItemText(2, qtrc("notation/editstyle", "Close"));
voicingSelectWidget->voicingBox->setItemText(3, qtrc("notation/editstyle", "Drop Two"));
voicingSelectWidget->voicingBox->setItemText(4, qtrc("notation/editstyle", "Six Note"));
voicingSelectWidget->voicingBox->setItemText(5, qtrc("notation/editstyle", "Four Note"));
voicingSelectWidget->voicingBox->setItemText(6, qtrc("notation/editstyle", "Three Note"));
voicingSelectWidget->durationBox->setItemText(0, tr("Until Next Chord Symbol"));
voicingSelectWidget->durationBox->setItemText(1, tr("Until End of Measure"));
voicingSelectWidget->durationBox->setItemText(2, tr("Chord/Rest Duration"));
voicingSelectWidget->durationBox->setItemText(0, qtrc("notation/editstyle", "Until Next Chord Symbol"));
voicingSelectWidget->durationBox->setItemText(1, qtrc("notation/editstyle", "Until End of Measure"));
voicingSelectWidget->durationBox->setItemText(2, qtrc("notation/editstyle", "Chord/Rest Duration"));
setHeaderFooterToolTip();
@ -1129,9 +1121,9 @@ void EditStyle::retranslate()
++idx;
}
textStyleFrameType->setItemText(0, tr("None", "no frame for text"));
textStyleFrameType->setItemText(1, tr("Rectangle"));
textStyleFrameType->setItemText(2, tr("Circle"));
textStyleFrameType->setItemText(0, qtrc("notation/editstyle", "None", "no frame for text"));
textStyleFrameType->setItemText(1, qtrc("notation/editstyle", "Rectangle"));
textStyleFrameType->setItemText(2, qtrc("notation/editstyle", "Circle"));
}
//---------------------------------------------------------
@ -1144,48 +1136,48 @@ void EditStyle::setHeaderFooterToolTip()
// jumping thru hoops here to make the job of translators easier, yet have a nice display
QString toolTipHeaderFooter
= QString("<html><head></head><body><p><b>")
+ tr("Special symbols in header/footer")
+ qtrc("notation/editstyle", "Special symbols in header/footer")
+ QString("</b></p>")
+ QString("<table><tr><td>$p</td><td>-</td><td><i>")
+ tr("Page number, except on first page")
+ qtrc("notation/editstyle", "Page number, except on first page")
+ QString("</i></td></tr><tr><td>$N</td><td>-</td><td><i>")
+ tr("Page number, if there is more than one page")
+ qtrc("notation/editstyle", "Page number, if there is more than one page")
+ QString("</i></td></tr><tr><td>$P</td><td>-</td><td><i>")
+ tr("Page number, on all pages")
+ qtrc("notation/editstyle", "Page number, on all pages")
+ QString("</i></td></tr><tr><td>$n</td><td>-</td><td><i>")
+ tr("Number of pages")
+ qtrc("notation/editstyle", "Number of pages")
+ QString("</i></td></tr><tr><td>$f</td><td>-</td><td><i>")
+ tr("File name")
+ qtrc("notation/editstyle", "File name")
+ QString("</i></td></tr><tr><td>$F</td><td>-</td><td><i>")
+ tr("File path+name")
+ qtrc("notation/editstyle", "File path+name")
+ QString("</i></td></tr><tr><td>$i</td><td>-</td><td><i>")
+ tr("Part name, except on first page")
+ qtrc("notation/editstyle", "Part name, except on first page")
+ QString("</i></td></tr><tr><td>$I</td><td>-</td><td><i>")
+ tr("Part name, on all pages")
+ qtrc("notation/editstyle", "Part name, on all pages")
+ QString("</i></td></tr><tr><td>$d</td><td>-</td><td><i>")
+ tr("Current date")
+ qtrc("notation/editstyle", "Current date")
+ QString("</i></td></tr><tr><td>$D</td><td>-</td><td><i>")
+ tr("Creation date")
+ qtrc("notation/editstyle", "Creation date")
+ QString("</i></td></tr><tr><td>$m</td><td>-</td><td><i>")
+ tr("Last modification time")
+ qtrc("notation/editstyle", "Last modification time")
+ QString("</i></td></tr><tr><td>$M</td><td>-</td><td><i>")
+ tr("Last modification date")
+ qtrc("notation/editstyle", "Last modification date")
+ QString("</i></td></tr><tr><td>$C</td><td>-</td><td><i>")
+ tr("Copyright, on first page only")
+ qtrc("notation/editstyle", "Copyright, on first page only")
+ QString("</i></td></tr><tr><td>$c</td><td>-</td><td><i>")
+ tr("Copyright, on all pages")
+ qtrc("notation/editstyle", "Copyright, on all pages")
+ QString("</i></td></tr><tr><td>$v</td><td>-</td><td><i>")
+ tr("MuseScore version this score was last saved with")
+ qtrc("notation/editstyle", "MuseScore version this score was last saved with")
+ QString("</i></td></tr><tr><td>$r</td><td>-</td><td><i>")
+ tr("MuseScore revision this score was last saved with")
+ qtrc("notation/editstyle", "MuseScore revision this score was last saved with")
+ QString("</i></td></tr><tr><td>$$</td><td>-</td><td><i>")
+ tr("The $ sign itself")
+ qtrc("notation/editstyle", "The $ sign itself")
+ QString("</i></td></tr><tr><td>$:tag:</td><td>-</td><td><i>")
+ tr("Metadata tag, see below")
+ qtrc("notation/editstyle", "Metadata tag, see below")
+ QString("</i></td></tr></table><p>")
+ tr("Available metadata tags and their current values")
+ qtrc("notation/editstyle", "Available metadata tags and their current values")
+ QString("<br />")
+ tr("(in File > Score Properties…):")
+ qtrc("notation/editstyle", "(in File > Score Properties…):")
+ QString("</p><table>");
// show all tags for current score/part, see also Score::init()
@ -2143,7 +2135,7 @@ void EditStyle::textStyleChanged(int row)
PropertyValue val = styleValue(a.sid);
textStyleSpatiumDependent->setChecked(val.toBool());
resetTextStyleSpatiumDependent->setEnabled(val != defaultStyleValue(a.sid));
textStyleOffset->setSuffix(val.toBool() ? tr("sp") : tr("mm"));
textStyleOffset->setSuffix(val.toBool() ? qtrc("notation/editstyle", "sp") : qtrc("notation/editstyle", "mm"));
}
break;

6
src/notation/view/widgets/measureproperties.cpp
View file

@ -24,6 +24,8 @@
#include <QKeyEvent>
#include "translation.h"
#include "engraving/libmscore/masterscore.h"
#include "engraving/libmscore/measure.h"
#include "engraving/libmscore/measurerepeat.h"
@ -179,7 +181,7 @@ void MeasurePropertiesDialog::setMeasure(mu::engraving::Measure* measure)
nextButton->setEnabled(m_measure->nextMeasure() != 0);
previousButton->setEnabled(m_measure->prevMeasure() != 0);
setWindowTitle(tr("Measure Properties for Measure %1").arg(m_measure->no() + 1));
setWindowTitle(qtrc("notation", "Measure Properties for Measure %1").arg(m_measure->no() + 1));
m_notation->interaction()->clearSelection();
m_notation->interaction()->select({ m_measure }, mu::engraving::SelectType::ADD, 0);
@ -211,7 +213,7 @@ void MeasurePropertiesDialog::setMeasure(mu::engraving::Measure* measure)
auto itemAccessibleText = [](const QTableWidgetItem* item){
QString accessibleText = item->data(ITEM_ACCESSIBLE_TITLE_ROLE).toString() + ": "
+ (item->checkState() == Qt::Checked ? tr("checked") : tr("unchecked"));
+ (item->checkState() == Qt::Checked ? qtrc("notation", "checked") : qtrc("notation", "unchecked"));
return accessibleText;
};

4
src/notation/view/widgets/selectnotedialog.cpp
View file

@ -27,6 +27,8 @@
#include "selectnotedialog.h"
#include "translation.h"
#include "engraving/types/typesconv.h"
#include "engraving/libmscore/chord.h"
#include "engraving/libmscore/engravingitem.h"
@ -67,7 +69,7 @@ SelectNoteDialog::SelectNoteDialog(QWidget* parent)
type->setText(m_note->noteTypeUserName());
sameType->setAccessibleName(sameType->text() + type->text());
durationType->setText(tr("%1 Note").arg(TConv::translatedUserName(m_note->chord()->durationType().type())));
durationType->setText(qtrc("notation", "%1 Note").arg(TConv::translatedUserName(m_note->chord()->durationType().type())));
sameDurationType->setAccessibleName(sameDurationType->text() + durationType->text());
durationTicks->setText(m_note->chord()->durationUserName());

6
src/notation/view/widgets/stafftextpropertiesdialog.cpp
View file

@ -24,6 +24,8 @@
#include <QSignalMapper>
#include <QToolButton>
#include "translation.h"
#include "engraving/libmscore/score.h"
#include "engraving/libmscore/stafftext.h"
#include "engraving/libmscore/system.h"
@ -77,13 +79,13 @@ StaffTextPropertiesDialog::StaffTextPropertiesDialog(QWidget* parent)
m_originStaffText = st;
if (st->systemFlag()) {
setWindowTitle(tr("System Text Properties"));
setWindowTitle(qtrc("notation", "System Text Properties"));
tabWidget->removeTab(tabWidget->indexOf(tabAeolusStops)); // Aeolus settings for staff text only
//if (!enableExperimental) tabWidget->removeTab(tabWidget->indexOf(tabMIDIAction));
tabWidget->removeTab(tabWidget->indexOf(tabChangeChannel)); // Channel switching for staff text only
tabWidget->removeTab(tabWidget->indexOf(tabCapoSettings)); // Capos for staff text only
} else {
setWindowTitle(tr("Staff Text Properties"));
setWindowTitle(qtrc("notation", "Staff Text Properties"));
//tabWidget->removeTab(tabWidget->indexOf(tabSwingSettings)); // Swing settings for system text only, could be disabled here, if desired
#ifndef AEOLUS
tabWidget->removeTab(tabWidget->indexOf(tabAeolusStops));

88
src/notation/view/widgets/timeline.cpp
View file

@ -28,6 +28,8 @@
#include <QTextDocument>
#include <QMouseEvent>
#include "translation.h"
#include "engraving/types/typesconv.h"
#include "libmscore/barline.h"
#include "libmscore/chord.h"
@ -583,25 +585,25 @@ void TRowLabels::mouseOver(QPointF scenePt)
QString tooltip;
switch (mouseOverArrow) {
case MouseOverValue::COLLAPSE_DOWN_ARROW:
tooltip = tr("Expand meta rows");
tooltip = qtrc("notation/timeline", "Expand meta rows");
break;
case MouseOverValue::COLLAPSE_UP_ARROW:
tooltip = tr("Collapse meta rows");
tooltip = qtrc("notation/timeline", "Collapse meta rows");
break;
case MouseOverValue::MOVE_DOWN_ARROW:
tooltip = tr("Move meta row down one");
tooltip = qtrc("notation/timeline", "Move meta row down one");
break;
case MouseOverValue::MOVE_UP_ARROW:
tooltip = tr("Move meta row up one");
tooltip = qtrc("notation/timeline", "Move meta row up one");
break;
case MouseOverValue::MOVE_UP_DOWN_ARROW:
tooltip = tr("Move meta row up/down one");
tooltip = qtrc("notation/timeline", "Move meta row up/down one");
break;
case MouseOverValue::OPEN_EYE:
tooltip = tr("Hide instrument in score");
tooltip = qtrc("notation/timeline", "Hide instrument in score");
break;
case MouseOverValue::CLOSED_EYE:
tooltip = tr("Show instrument in score");
tooltip = qtrc("notation/timeline", "Show instrument in score");
break;
default:
tooltip = "";
@ -763,13 +765,13 @@ Timeline::Timeline(QSplitter* splitter)
connect(_rowNames, &TRowLabels::swapMeta, this, &Timeline::swapMeta);
connect(this, &Timeline::moved, _rowNames, &TRowLabels::mouseOver);
_metas.push_back({ tr("Tempo"), &Timeline::tempoMeta, true });
_metas.push_back({ tr("Time Signature"), &Timeline::timeMeta, true });
_metas.push_back({ tr("Rehearsal Mark"), &Timeline::rehearsalMeta, true });
_metas.push_back({ tr("Key Signature"), &Timeline::keyMeta, true });
_metas.push_back({ tr("Barlines"), &Timeline::barlineMeta, true });
_metas.push_back({ tr("Jumps and Markers"), &Timeline::jumpMarkerMeta, true });
_metas.push_back({ tr("Measures"), &Timeline::measureMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Tempo"), &Timeline::tempoMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Time Signature"), &Timeline::timeMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Rehearsal Mark"), &Timeline::rehearsalMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Key Signature"), &Timeline::keyMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Barlines"), &Timeline::barlineMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Jumps and Markers"), &Timeline::jumpMarkerMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Measures"), &Timeline::measureMeta, true });
std::tuple<QGraphicsItem*, int, QColor> ohi(nullptr, -1, QColor());
_oldHoverInfo = ohi;
@ -1020,7 +1022,7 @@ void Timeline::drawGrid(int globalRows, int globalCols, int startMeasure, int en
setMetaData(graphicsRectItem, row, ElementType::INVALID, currMeasure, false, 0);
QString translateMeasure = tr("Measure");
QString translateMeasure = qtrc("notation/timeline", "Measure");
QChar initialLetter = translateMeasure[0];
QTextDocument doc;
QString partName = "";
@ -1104,11 +1106,11 @@ void Timeline::drawGrid(int globalRows, int globalCols, int startMeasure, int en
// If no initial key signature is found, add key signature
if (cm == score()->firstMeasure() && noKey
&& (currSeg->isTimeSigType() || currSeg->isChordRestType())) {
if (getMetaRow(tr("Key Signature")) != numMetas) {
if (getMetaRow(qtrc("notation/timeline", "Key Signature")) != numMetas) {
if (_collapsedMeta) {
keyMeta(0, &stagger, xPos);
} else {
keyMeta(0, &staggerArr[getMetaRow(tr("Key Signature"))], xPos);
keyMeta(0, &staggerArr[getMetaRow(qtrc("notation/timeline", "Key Signature"))], xPos);
}
}
noKey = false;
@ -1129,7 +1131,7 @@ void Timeline::drawGrid(int globalRows, int globalCols, int startMeasure, int en
}
}
// Handle all jumps here
if (getMetaRow(tr("Jumps and Markers")) != numMetas) {
if (getMetaRow(qtrc("notation/timeline", "Jumps and Markers")) != numMetas) {
ElementList measureElementsList = cm->el();
for (EngravingItem* element : measureElementsList) {
std::get<3>(_repeatInfo) = element;
@ -1169,7 +1171,7 @@ void Timeline::drawGrid(int globalRows, int globalCols, int startMeasure, int en
void Timeline::tempoMeta(Segment* seg, int* stagger, int pos)
{
// Find position of tempoMeta in metas
int row = getMetaRow(tr("Tempo"));
int row = getMetaRow(qtrc("notation/timeline", "Tempo"));
// Add all tempo texts in this segment
const std::vector<EngravingItem*> annotations = seg->annotations();
@ -1200,7 +1202,7 @@ void Timeline::timeMeta(Segment* seg, int* stagger, int pos)
int x = pos + (*stagger) * _spacing;
// Find position of timeMeta in metas
int row = getMetaRow(tr("Time Signature"));
int row = getMetaRow(qtrc("notation/timeline", "Time Signature"));
TimeSig* originalTimeSig = toTimeSig(seg->element(0));
if (!originalTimeSig) {
@ -1239,7 +1241,7 @@ void Timeline::timeMeta(Segment* seg, int* stagger, int pos)
void Timeline::rehearsalMeta(Segment* seg, int* stagger, int pos)
{
int row = getMetaRow(tr("Rehearsal Mark"));
int row = getMetaRow(qtrc("notation/timeline", "Rehearsal Mark"));
for (EngravingItem* element : seg->annotations()) {
int x = pos + (*stagger) * _spacing;
@ -1270,7 +1272,7 @@ void Timeline::keyMeta(Segment* seg, int* stagger, int pos)
TRACEFUNC;
int row = getMetaRow(tr("Key Signature"));
int row = getMetaRow(qtrc("notation/timeline", "Key Signature"));
std::map<Key, int> keyFrequencies;
const std::vector<Staff*>& staves = score()->staves();
@ -1343,7 +1345,7 @@ void Timeline::keyMeta(Segment* seg, int* stagger, int pos)
tooltip = TConv::translatedUserName(Key::INVALID, true);
} else if (newKey == Key::NUM_OF) {
keyText = "?";
tooltip = tr("Custom Key Signature");
tooltip = qtrc("notation/timeline", "Custom Key Signature");
} else if (int(newKey) == 0) {
keyText = "\u266E";
tooltip = TConv::translatedUserName(Key::C);
@ -1376,7 +1378,7 @@ void Timeline::barlineMeta(Segment* seg, int* stagger, int pos)
TRACEFUNC;
// Find position of repeat_meta in metas
int row = getMetaRow(tr("Barlines"));
int row = getMetaRow(qtrc("notation/timeline", "Barlines"));
QString repeatText = "";
BarLine* barline = toBarLine(seg->element(0));
@ -1432,7 +1434,7 @@ void Timeline::jumpMarkerMeta(Segment* seg, int* stagger, int pos)
TRACEFUNC;
// Find position of repeat_meta in metas
int row = getMetaRow(tr("Jumps and Markers"));
int row = getMetaRow(qtrc("notation/timeline", "Jumps and Markers"));
QString text = "";
EngravingItem* element = nullptr;
@ -1513,7 +1515,7 @@ void Timeline::measureMeta(Segment*, int*, int pos)
}
// Find position of measureMeta in metas
int row = getMetaRow(tr("Measures"));
int row = getMetaRow(qtrc("notation/timeline", "Measures"));
// Adjust number
Measure* currMeasure;
@ -1555,7 +1557,7 @@ void Timeline::measureMeta(Segment*, int*, int pos)
unsigned Timeline::getMetaRow(QString targetText)
{
if (_collapsedMeta) {
if (targetText == tr("Measures")) {
if (targetText == qtrc("notation/timeline", "Measures")) {
return 1;
} else {
return 0;
@ -2530,13 +2532,13 @@ void Timeline::changeEvent(QEvent* event)
QGraphicsView::changeEvent(event);
if (event->type() == QEvent::LanguageChange) {
_metas.clear();
_metas.push_back({ tr("Tempo"), &Timeline::tempoMeta, true });
_metas.push_back({ tr("Time Signature"), &Timeline::timeMeta, true });
_metas.push_back({ tr("Rehearsal Mark"), &Timeline::rehearsalMeta, true });
_metas.push_back({ tr("Key Signature"), &Timeline::keyMeta, true });
_metas.push_back({ tr("Barlines"), &Timeline::barlineMeta, true });
_metas.push_back({ tr("Jumps and Markers"), &Timeline::jumpMarkerMeta, true });
_metas.push_back({ tr("Measures"), &Timeline::measureMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Tempo"), &Timeline::tempoMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Time Signature"), &Timeline::timeMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Rehearsal Mark"), &Timeline::rehearsalMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Key Signature"), &Timeline::keyMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Barlines"), &Timeline::barlineMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Jumps and Markers"), &Timeline::jumpMarkerMeta, true });
_metas.push_back({ qtrc("notation/timeline", "Measures"), &Timeline::measureMeta, true });
updateGridFull();
}
@ -2795,7 +2797,7 @@ std::vector<std::pair<QString, bool> > Timeline::getLabels()
std::vector<std::pair<QString, bool> > rowLabels;
if (_collapsedMeta) {
std::pair<QString, bool> first = std::make_pair("", true);
std::pair<QString, bool> second = std::make_pair(tr("Measures"), true);
std::pair<QString, bool> second = std::make_pair(qtrc("notation/timeline", "Measures"), true);
rowLabels.push_back(first);
rowLabels.push_back(second);
} else {
@ -3046,9 +3048,9 @@ void Timeline::toggleShow(int staff)
void Timeline::contextMenuEvent(QContextMenuEvent* event)
{
QMenu* contextMenu = new QMenu(tr("Context menu"), this);
QMenu* contextMenu = new QMenu(qtrc("notation/timeline", "Context menu"), this);
if (_rowNames->cursorIsOn() == "instrument") {
QAction* edit_instruments = new QAction(tr("Edit Instruments"), this);
QAction* edit_instruments = new QAction(qtrc("notation/timeline", "Edit Instruments"), this);
connect(edit_instruments, &QAction::triggered, this, &Timeline::requestInstrumentDialog);
contextMenu->addAction(edit_instruments);
contextMenu->exec(QCursor::pos());
@ -3056,7 +3058,7 @@ void Timeline::contextMenuEvent(QContextMenuEvent* event)
for (auto it = _metas.begin(); it != _metas.end(); ++it) {
std::tuple<QString, void (Timeline::*)(Segment*, int*, int), bool> meta = *it;
QString row_name = std::get<0>(meta);
if (row_name != tr("Measures")) {
if (row_name != qtrc("notation/timeline", "Measures")) {
QAction* action = new QAction(row_name, this);
action->setCheckable(true);
action->setChecked(std::get<2>(meta));
@ -3065,10 +3067,10 @@ void Timeline::contextMenuEvent(QContextMenuEvent* event)
}
}
contextMenu->addSeparator();
QAction* hide_all = new QAction(tr("Hide all"), this);
QAction* hide_all = new QAction(qtrc("notation/timeline", "Hide all"), this);
connect(hide_all, &QAction::triggered, this, &Timeline::toggleMetaRow);
contextMenu->addAction(hide_all);
QAction* show_all = new QAction(tr("Show all"), this);
QAction* show_all = new QAction(qtrc("notation/timeline", "Show all"), this);
connect(show_all, &QAction::triggered, this, &Timeline::toggleMetaRow);
contextMenu->addAction(show_all);
contextMenu->exec(QCursor::pos());
@ -3088,16 +3090,16 @@ void Timeline::toggleMetaRow()
QString targetText = action->text();
if (targetText == tr("Hide all")) {
if (targetText == qtrc("notation/timeline", "Hide all")) {
for (auto it = _metas.begin(); it != _metas.end(); ++it) {
QString metaText = std::get<0>(*it);
if (metaText != tr("Measures")) {
if (metaText != qtrc("notation/timeline", "Measures")) {
std::get<2>(*it) = false;
}
}
updateGrid();
return;
} else if (targetText == tr("Show all")) {
} else if (targetText == qtrc("notation/timeline", "Show all")) {
for (auto it = _metas.begin(); it != _metas.end(); ++it) {
std::get<2>(*it) = true;
}

2
src/palette/internal/palettecell.cpp
View file

@ -100,7 +100,7 @@ const char* PaletteCell::translationContext() const
case ElementType::FERMATA:
case ElementType::SYMBOL:
// libmscore/sym.cpp, Sym::symUserNames
return "symUserNames";
return "engraving/sym";
case ElementType::CLEF:
// libmscore/clef.cpp, ClefInfo::clefTable[]
return "clefTable";

26
src/palette/internal/palettecreator.cpp
View file

@ -351,9 +351,9 @@ PalettePtr PaletteCreator::newBarLinePalette(bool defaultPalette)
const char* userName;
} spans[] = {
{ BARLINE_SPAN_TICK1_FROM, BARLINE_SPAN_TICK1_TO, SymNames::userNameForSymId(SymId::barlineDashed) },
{ BARLINE_SPAN_TICK2_FROM, BARLINE_SPAN_TICK2_TO, QT_TRANSLATE_NOOP("symUserNames", "Tick barline 2") }, // Not in SMuFL
{ BARLINE_SPAN_TICK2_FROM, BARLINE_SPAN_TICK2_TO, QT_TRANSLATE_NOOP("engraving/sym", "Tick barline 2") }, // Not in SMuFL
{ BARLINE_SPAN_SHORT1_FROM, BARLINE_SPAN_SHORT1_TO, SymNames::userNameForSymId(SymId::barlineShort) },
{ BARLINE_SPAN_SHORT2_FROM, BARLINE_SPAN_SHORT2_TO, QT_TRANSLATE_NOOP("symUserNames", "Short barline 2") }, // Not in SMuFL
{ BARLINE_SPAN_SHORT2_FROM, BARLINE_SPAN_SHORT2_TO, QT_TRANSLATE_NOOP("engraving/sym", "Short barline 2") }, // Not in SMuFL
};
for (auto span : spans) {
auto b = Factory::makeBarLine(gpaletteScore->dummy()->segment());
@ -394,7 +394,7 @@ PalettePtr PaletteCreator::newRepeatsPalette(bool defaultPalette)
auto rm = makeElement<MeasureRepeat>(gpaletteScore);
rm->setSymId(repeat.id);
rm->setNumMeasures(repeat.measuresCount);
sp->appendElement(rm, mu::qtrc("symUserNames", SymNames::userNameForSymId(repeat.id)));
sp->appendElement(rm, mu::qtrc("engraving/sym", SymNames::userNameForSymId(repeat.id)));
}
const std::vector<MarkerType> defaultMarkers = {
@ -1020,22 +1020,22 @@ PalettePtr PaletteCreator::newArpeggioPalette()
cl = Factory::makeChordLine(gpaletteScore->dummy()->chord());
cl->setChordLineType(ChordLineType::FALL);
cl->setStraight(true);
sp->appendElement(cl, QT_TRANSLATE_NOOP("Ms", "Slide out down"));
sp->appendElement(cl, QT_TRANSLATE_NOOP("palette", "Slide out down"));
cl = Factory::makeChordLine(gpaletteScore->dummy()->chord());
cl->setChordLineType(ChordLineType::DOIT);
cl->setStraight(true);
sp->appendElement(cl, QT_TRANSLATE_NOOP("Ms", "Slide out up"));
sp->appendElement(cl, QT_TRANSLATE_NOOP("palette", "Slide out up"));
cl = Factory::makeChordLine(gpaletteScore->dummy()->chord());
cl->setChordLineType(ChordLineType::PLOP);
cl->setStraight(true);
sp->appendElement(cl, QT_TRANSLATE_NOOP("Ms", "Slide in above"));
sp->appendElement(cl, QT_TRANSLATE_NOOP("palette", "Slide in above"));
cl = Factory::makeChordLine(gpaletteScore->dummy()->chord());
cl->setChordLineType(ChordLineType::SCOOP);
cl->setStraight(true);
sp->appendElement(cl, QT_TRANSLATE_NOOP("Ms", "Slide in below"));
sp->appendElement(cl, QT_TRANSLATE_NOOP("palette", "Slide in below"));
return sp;
}
@ -1689,8 +1689,8 @@ PalettePtr PaletteCreator::newTimePalette(bool defaultPalette)
{ 7, 8, TimeSigType::NORMAL, "7/8" },
{ 9, 8, TimeSigType::NORMAL, "9/8" },
{ 12, 8, TimeSigType::NORMAL, "12/8" },
{ 4, 4, TimeSigType::FOUR_FOUR, QT_TRANSLATE_NOOP("symUserNames", "Common time") },
{ 2, 2, TimeSigType::ALLA_BREVE, QT_TRANSLATE_NOOP("symUserNames", "Cut time") },
{ 4, 4, TimeSigType::FOUR_FOUR, QT_TRANSLATE_NOOP("engraving/sym", "Common time") },
{ 2, 2, TimeSigType::ALLA_BREVE, QT_TRANSLATE_NOOP("engraving/sym", "Cut time") },
{ 2, 2, TimeSigType::NORMAL, "2/2" },
{ 3, 2, TimeSigType::NORMAL, "3/2" }
};
@ -1708,13 +1708,13 @@ PalettePtr PaletteCreator::newTimePalette(bool defaultPalette)
{ 7, 8, TimeSigType::NORMAL, "7/8" },
{ 9, 8, TimeSigType::NORMAL, "9/8" },
{ 12, 8, TimeSigType::NORMAL, "12/8" },
{ 4, 4, TimeSigType::FOUR_FOUR, QT_TRANSLATE_NOOP("symUserNames", "Common time") },
{ 2, 2, TimeSigType::ALLA_BREVE, QT_TRANSLATE_NOOP("symUserNames", "Cut time") },
{ 4, 4, TimeSigType::FOUR_FOUR, QT_TRANSLATE_NOOP("engraving/sym", "Common time") },
{ 2, 2, TimeSigType::ALLA_BREVE, QT_TRANSLATE_NOOP("engraving/sym", "Cut time") },
{ 2, 2, TimeSigType::NORMAL, "2/2" },
{ 3, 2, TimeSigType::NORMAL, "3/2" },
{ 4, 2, TimeSigType::NORMAL, "4/2" },
{ 2, 2, TimeSigType::CUT_BACH, QT_TRANSLATE_NOOP("symUserNames", "Cut time (Bach)") },
{ 9, 8, TimeSigType::CUT_TRIPLE, QT_TRANSLATE_NOOP("symUserNames", "Cut triple time (9/8)") }
{ 2, 2, TimeSigType::CUT_BACH, QT_TRANSLATE_NOOP("engraving/sym", "Cut time (Bach)") },
{ 9, 8, TimeSigType::CUT_TRIPLE, QT_TRANSLATE_NOOP("engraving/sym", "Cut triple time (9/8)") }
};
for (TS timeSignatureType : defaultPalette ? defaultTimeSignatureList : masterTimeSignatureList) {

608
src/palette/view/widgets/specialcharactersdialog.cpp
View file

@ -97,309 +97,309 @@ struct UnicodeRange {
const char* name;
};
static constexpr UnicodeRange unicodeRanges[] = {
{ 0x0020, 0x007F, QT_TRANSLATE_NOOP("textpalette", "Basic Latin") }, // leaving out the first 32 non-printable characters
{ 0x0080, 0x00FF, QT_TRANSLATE_NOOP("textpalette", "Latin-1 Supplement") },
{ 0x0100, 0x017F, QT_TRANSLATE_NOOP("textpalette", "Latin Extended-A") },
{ 0x0180, 0x024F, QT_TRANSLATE_NOOP("textpalette", "Latin Extended-B") },
{ 0x0250, 0x02AF, QT_TRANSLATE_NOOP("textpalette", "IPA Extensions") },
{ 0x02B0, 0x02FF, QT_TRANSLATE_NOOP("textpalette", "Spacing Modifier Letters") },
{ 0x0300, 0x036F, QT_TRANSLATE_NOOP("textpalette", "Combining Diacritical Marks") },
{ 0x0370, 0x03FF, QT_TRANSLATE_NOOP("textpalette", "Greek and Coptic") },
{ 0x0400, 0x04FF, QT_TRANSLATE_NOOP("textpalette", "Cyrillic") },
{ 0x0500, 0x052F, QT_TRANSLATE_NOOP("textpalette", "Cyrillic Supplement") },
{ 0x0530, 0x058F, QT_TRANSLATE_NOOP("textpalette", "Armenian") },
{ 0x0590, 0x05FF, QT_TRANSLATE_NOOP("textpalette", "Hebrew") },
{ 0x0600, 0x06FF, QT_TRANSLATE_NOOP("textpalette", "Arabic") },
{ 0x0700, 0x074F, QT_TRANSLATE_NOOP("textpalette", "Syriac") },
{ 0x0750, 0x077F, QT_TRANSLATE_NOOP("textpalette", "Arabic Supplement") },
{ 0x0780, 0x07BF, QT_TRANSLATE_NOOP("textpalette", "Thaana") },
{ 0x07C0, 0x07FF, QT_TRANSLATE_NOOP("textpalette", "NKo") },
{ 0x0800, 0x083F, QT_TRANSLATE_NOOP("textpalette", "Samaritan") },
{ 0x0840, 0x085F, QT_TRANSLATE_NOOP("textpalette", "Mandaic") },
{ 0x0860, 0x086F, QT_TRANSLATE_NOOP("textpalette", "Syriac Supplement") },
{ 0x08A0, 0x08FF, QT_TRANSLATE_NOOP("textpalette", "Arabic Extended-A") },
{ 0x0900, 0x097F, QT_TRANSLATE_NOOP("textpalette", "Devanagari") },
{ 0x0980, 0x09FF, QT_TRANSLATE_NOOP("textpalette", "Bengali") },
{ 0x0A00, 0x0A7F, QT_TRANSLATE_NOOP("textpalette", "Gurmukhi") },
{ 0x0A80, 0x0AFF, QT_TRANSLATE_NOOP("textpalette", "Gujarati") },
{ 0x0B00, 0x0B7F, QT_TRANSLATE_NOOP("textpalette", "Oriya") },
{ 0x0B80, 0x0BFF, QT_TRANSLATE_NOOP("textpalette", "Tamil") },
{ 0x0C00, 0x0C7F, QT_TRANSLATE_NOOP("textpalette", "Telugu") },
{ 0x0C80, 0x0CFF, QT_TRANSLATE_NOOP("textpalette", "Kannada") },
{ 0x0D00, 0x0D7F, QT_TRANSLATE_NOOP("textpalette", "Malayalam") },
{ 0x0D80, 0x0DFF, QT_TRANSLATE_NOOP("textpalette", "Sinhala") },
{ 0x0E00, 0x0E7F, QT_TRANSLATE_NOOP("textpalette", "Thai") },
{ 0x0E80, 0x0EFF, QT_TRANSLATE_NOOP("textpalette", "Lao") },
{ 0x0F00, 0x0FFF, QT_TRANSLATE_NOOP("textpalette", "Tibetan") },
{ 0x1000, 0x109F, QT_TRANSLATE_NOOP("textpalette", "Myanmar") },
{ 0x10A0, 0x10FF, QT_TRANSLATE_NOOP("textpalette", "Georgian") },
{ 0x1100, 0x11FF, QT_TRANSLATE_NOOP("textpalette", "Hangul Jamo") },
{ 0x1200, 0x137F, QT_TRANSLATE_NOOP("textpalette", "Ethiopic") },
{ 0x1380, 0x139F, QT_TRANSLATE_NOOP("textpalette", "Ethiopic Supplement") },
{ 0x13A0, 0x13FF, QT_TRANSLATE_NOOP("textpalette", "Cherokee") },
{ 0x1400, 0x167F, QT_TRANSLATE_NOOP("textpalette", "Unified Canadian Aboriginal Syllabics") },
{ 0x1680, 0x169F, QT_TRANSLATE_NOOP("textpalette", "Ogham") },
{ 0x16A0, 0x16FF, QT_TRANSLATE_NOOP("textpalette", "Runic") },
{ 0x1700, 0x171F, QT_TRANSLATE_NOOP("textpalette", "Tagalog") },
{ 0x1720, 0x173F, QT_TRANSLATE_NOOP("textpalette", "Hanunoo") },
{ 0x1740, 0x175F, QT_TRANSLATE_NOOP("textpalette", "Buhid") },
{ 0x1760, 0x177F, QT_TRANSLATE_NOOP("textpalette", "Tagbanwa") },
{ 0x1780, 0x17FF, QT_TRANSLATE_NOOP("textpalette", "Khmer") },
{ 0x1800, 0x18AF, QT_TRANSLATE_NOOP("textpalette", "Mongolian") },
{ 0x18B0, 0x18FF, QT_TRANSLATE_NOOP("textpalette", "Unified Canadian Aboriginal Syllabics Extended") },
{ 0x1900, 0x194F, QT_TRANSLATE_NOOP("textpalette", "Limbu") },
{ 0x1950, 0x197F, QT_TRANSLATE_NOOP("textpalette", "Tai Le") },
{ 0x1980, 0x19DF, QT_TRANSLATE_NOOP("textpalette", "New Tai Lue") },
{ 0x19E0, 0x19FF, QT_TRANSLATE_NOOP("textpalette", "Khmer Symbols") },
{ 0x1A00, 0x1A1F, QT_TRANSLATE_NOOP("textpalette", "Buginese") },
{ 0x1A20, 0x1AAF, QT_TRANSLATE_NOOP("textpalette", "Tai Tham") },
{ 0x1AB0, 0x1AFF, QT_TRANSLATE_NOOP("textpalette", "Combining Diacritical Marks Extended") },
{ 0x1B00, 0x1B7F, QT_TRANSLATE_NOOP("textpalette", "Balinese") },
{ 0x1B80, 0x1BBF, QT_TRANSLATE_NOOP("textpalette", "Sundanese") },
{ 0x1BC0, 0x1BFF, QT_TRANSLATE_NOOP("textpalette", "Batak") },
{ 0x1C00, 0x1C4F, QT_TRANSLATE_NOOP("textpalette", "Lepcha") },
{ 0x1C50, 0x1C7F, QT_TRANSLATE_NOOP("textpalette", "Ol Chiki") },
{ 0x1C80, 0x1C8F, QT_TRANSLATE_NOOP("textpalette", "Cyrillic Extended-C") },
{ 0x1C90, 0x1CBF, QT_TRANSLATE_NOOP("textpalette", "Georgian Extended") },
{ 0x1CC0, 0x1CCF, QT_TRANSLATE_NOOP("textpalette", "Sundanese Supplement") },
{ 0x1CD0, 0x1CFF, QT_TRANSLATE_NOOP("textpalette", "Vedic Extensions") },
{ 0x1D00, 0x1D7F, QT_TRANSLATE_NOOP("textpalette", "Phonetic Extensions") },
{ 0x1D80, 0x1DBF, QT_TRANSLATE_NOOP("textpalette", "Phonetic Extensions Supplement") },
{ 0x1DC0, 0x1DFF, QT_TRANSLATE_NOOP("textpalette", "Combining Diacritical Marks Supplement") },
{ 0x1E00, 0x1EFF, QT_TRANSLATE_NOOP("textpalette", "Latin Extended Additional") },
{ 0x1F00, 0x1FFF, QT_TRANSLATE_NOOP("textpalette", "Greek Extended") },
{ 0x2000, 0x206F, QT_TRANSLATE_NOOP("textpalette", "General Punctuation") },
{ 0x2070, 0x209F, QT_TRANSLATE_NOOP("textpalette", "Superscripts and Subscripts") },
{ 0x20A0, 0x20CF, QT_TRANSLATE_NOOP("textpalette", "Currency Symbols") },
{ 0x20D0, 0x20FF, QT_TRANSLATE_NOOP("textpalette", "Combining Diacritical Marks for Symbols") },
{ 0x2100, 0x214F, QT_TRANSLATE_NOOP("textpalette", "Letterlike Symbols") },
{ 0x2150, 0x218F, QT_TRANSLATE_NOOP("textpalette", "Number Forms") },
{ 0x2190, 0x21FF, QT_TRANSLATE_NOOP("textpalette", "Arrows") },
{ 0x2200, 0x22FF, QT_TRANSLATE_NOOP("textpalette", "Mathematical Operators") },
{ 0x2300, 0x23FF, QT_TRANSLATE_NOOP("textpalette", "Miscellaneous Technical") },
{ 0x2400, 0x243F, QT_TRANSLATE_NOOP("textpalette", "Control Pictures") },
{ 0x2440, 0x245F, QT_TRANSLATE_NOOP("textpalette", "Optical Character Recognition") },
{ 0x2460, 0x24FF, QT_TRANSLATE_NOOP("textpalette", "Enclosed Alphanumerics") },
{ 0x2500, 0x257F, QT_TRANSLATE_NOOP("textpalette", "Box Drawing") },
{ 0x2580, 0x259F, QT_TRANSLATE_NOOP("textpalette", "Block Elements") },
{ 0x25A0, 0x25FF, QT_TRANSLATE_NOOP("textpalette", "Geometric Shapes") },
{ 0x2600, 0x26FF, QT_TRANSLATE_NOOP("textpalette", "Miscellaneous Symbols") },
{ 0x2700, 0x27BF, QT_TRANSLATE_NOOP("textpalette", "Dingbats") },
{ 0x27C0, 0x27EF, QT_TRANSLATE_NOOP("textpalette", "Miscellaneous Mathematical Symbols-A") },
{ 0x27F0, 0x27FF, QT_TRANSLATE_NOOP("textpalette", "Supplemental Arrows-A") },
{ 0x2800, 0x28FF, QT_TRANSLATE_NOOP("textpalette", "Braille Patterns") },
{ 0x2900, 0x297F, QT_TRANSLATE_NOOP("textpalette", "Supplemental Arrows-B") },
{ 0x2980, 0x29FF, QT_TRANSLATE_NOOP("textpalette", "Miscellaneous Mathematical Symbols-B") },
{ 0x2A00, 0x2AFF, QT_TRANSLATE_NOOP("textpalette", "Supplemental Mathematical Operators") },
{ 0x2B00, 0x2BFF, QT_TRANSLATE_NOOP("textpalette", "Miscellaneous Symbols and Arrows") },
{ 0x2C00, 0x2C5F, QT_TRANSLATE_NOOP("textpalette", "Glagolitic") },
{ 0x2C60, 0x2C7F, QT_TRANSLATE_NOOP("textpalette", "Latin Extended-C") },
{ 0x2C80, 0x2CFF, QT_TRANSLATE_NOOP("textpalette", "Coptic") },
{ 0x2D00, 0x2D2F, QT_TRANSLATE_NOOP("textpalette", "Georgian Supplement") },
{ 0x2D30, 0x2D7F, QT_TRANSLATE_NOOP("textpalette", "Tifinagh") },
{ 0x2D80, 0x2DDF, QT_TRANSLATE_NOOP("textpalette", "Ethiopic Extended") },
{ 0x2DE0, 0x2DFF, QT_TRANSLATE_NOOP("textpalette", "Cyrillic Extended-A") },
{ 0x2E00, 0x2E7F, QT_TRANSLATE_NOOP("textpalette", "Supplemental Punctuation") },
{ 0x2E80, 0x2EFF, QT_TRANSLATE_NOOP("textpalette", "CJK Radicals Supplement") },
{ 0x2F00, 0x2FDF, QT_TRANSLATE_NOOP("textpalette", "Kangxi Radicals") },
{ 0x2FF0, 0x2FFF, QT_TRANSLATE_NOOP("textpalette", "Ideographic Description Characters") },
{ 0x3000, 0x303F, QT_TRANSLATE_NOOP("textpalette", "CJK Symbols and Punctuation") },
{ 0x3040, 0x309F, QT_TRANSLATE_NOOP("textpalette", "Hiragana") },
{ 0x30A0, 0x30FF, QT_TRANSLATE_NOOP("textpalette", "Katakana") },
{ 0x3100, 0x312F, QT_TRANSLATE_NOOP("textpalette", "Bopomofo") },
{ 0x3130, 0x318F, QT_TRANSLATE_NOOP("textpalette", "Hangul Compatibility Jamo") },
{ 0x3190, 0x319F, QT_TRANSLATE_NOOP("textpalette", "Kanbun") },
{ 0x31A0, 0x31BF, QT_TRANSLATE_NOOP("textpalette", "Bopomofo Extended") },
{ 0x31C0, 0x31EF, QT_TRANSLATE_NOOP("textpalette", "CJK Strokes") },
{ 0x31F0, 0x31FF, QT_TRANSLATE_NOOP("textpalette", "Katakana Phonetic Extensions") },
{ 0x3200, 0x32FF, QT_TRANSLATE_NOOP("textpalette", "Enclosed CJK Letters and Months") },
{ 0x3300, 0x33FF, QT_TRANSLATE_NOOP("textpalette", "CJK Compatibility") },
{ 0x3400, 0x4DB5, QT_TRANSLATE_NOOP("textpalette", "CJK Unified Ideographs Extension A") },
{ 0x4DC0, 0x4DFF, QT_TRANSLATE_NOOP("textpalette", "Yijing Hexagram Symbols") },
{ 0x4E00, 0x9FCC, QT_TRANSLATE_NOOP("textpalette", "CJK Unified Ideographs") },
{ 0xA000, 0xA48F, QT_TRANSLATE_NOOP("textpalette", "Yi Syllables") },
{ 0xA490, 0xA4CF, QT_TRANSLATE_NOOP("textpalette", "Yi Radicals") },
{ 0xA4D0, 0xA4FF, QT_TRANSLATE_NOOP("textpalette", "Lisu") },
{ 0xA500, 0xA63F, QT_TRANSLATE_NOOP("textpalette", "Vai") },
{ 0xA640, 0xA69F, QT_TRANSLATE_NOOP("textpalette", "Cyrillic Extended-B") },
{ 0xA6A0, 0xA6FF, QT_TRANSLATE_NOOP("textpalette", "Bamum") },
{ 0xA700, 0xA71F, QT_TRANSLATE_NOOP("textpalette", "Modifier Tone Letters") },
{ 0xA720, 0xA7FF, QT_TRANSLATE_NOOP("textpalette", "Latin Extended-D") },
{ 0xA800, 0xA82F, QT_TRANSLATE_NOOP("textpalette", "Syloti Nagri") },
{ 0xA830, 0xA83F, QT_TRANSLATE_NOOP("textpalette", "Common Indic Number Forms") },
{ 0xA840, 0xA87F, QT_TRANSLATE_NOOP("textpalette", "Phags-pa") },
{ 0xA880, 0xA8DF, QT_TRANSLATE_NOOP("textpalette", "Saurashtra") },
{ 0xA8E0, 0xA8FF, QT_TRANSLATE_NOOP("textpalette", "Devanagari Extended") },
{ 0xA900, 0xA92F, QT_TRANSLATE_NOOP("textpalette", "Kayah Li") },
{ 0xA930, 0xA95F, QT_TRANSLATE_NOOP("textpalette", "Rejang") },
{ 0xA960, 0xA97F, QT_TRANSLATE_NOOP("textpalette", "Hangul Jamo Extended-A") },
{ 0xA980, 0xA9DF, QT_TRANSLATE_NOOP("textpalette", "Javanese") },
{ 0xA9E0, 0xA9FF, QT_TRANSLATE_NOOP("textpalette", "Myanmar Extended-B") },
{ 0xAA00, 0xAA5F, QT_TRANSLATE_NOOP("textpalette", "Cham") },
{ 0xAA60, 0xAA7F, QT_TRANSLATE_NOOP("textpalette", "Myanmar Extended-A") },
{ 0xAA80, 0xAADF, QT_TRANSLATE_NOOP("textpalette", "Tai Viet") },
{ 0xAAE0, 0xAAFF, QT_TRANSLATE_NOOP("textpalette", "Meetei Mayek Extensions") },
{ 0xAB00, 0xAB2F, QT_TRANSLATE_NOOP("textpalette", "Ethiopic Extended-A") },
{ 0xAB30, 0xAB6F, QT_TRANSLATE_NOOP("textpalette", "Latin Extended-E") },
{ 0xAB70, 0xABBF, QT_TRANSLATE_NOOP("textpalette", "Cherokee Supplement") },
{ 0xABC0, 0xABFF, QT_TRANSLATE_NOOP("textpalette", "Meetei Mayek") },
{ 0xAC00, 0xD7A3, QT_TRANSLATE_NOOP("textpalette", "Hangul Syllables") },
{ 0xD7B0, 0xD7FF, QT_TRANSLATE_NOOP("textpalette", "Hangul Jamo Extended-B") },
{ 0xD800, 0xDB7F, QT_TRANSLATE_NOOP("textpalette", "High Surrogates") },
{ 0xDB80, 0xDBFF, QT_TRANSLATE_NOOP("textpalette", "High Private Use Surrogates") },
{ 0xDC00, 0xDFFF, QT_TRANSLATE_NOOP("textpalette", "Low Surrogates") },
{ 0xE000, 0xF8FF, QT_TRANSLATE_NOOP("textpalette", "Private Use Area"), },
{ 0xF900, 0xFAFF, QT_TRANSLATE_NOOP("textpalette", "CJK Compatibility Ideographs"), },
{ 0xFB00, 0xFB4F, QT_TRANSLATE_NOOP("textpalette", "Alphabetic Presentation Forms"), },
{ 0xFB50, 0xFDFF, QT_TRANSLATE_NOOP("textpalette", "Arabic Presentation Forms-A"), },
{ 0xFE00, 0xFE0F, QT_TRANSLATE_NOOP("textpalette", "Variation Selectors"), },
{ 0xFE10, 0xFE1F, QT_TRANSLATE_NOOP("textpalette", "Vertical Forms"), },
{ 0xFE20, 0xFE2F, QT_TRANSLATE_NOOP("textpalette", "Combining Half Marks"), },
{ 0xFE30, 0xFE4F, QT_TRANSLATE_NOOP("textpalette", "CJK Compatibility Forms"), },
{ 0xFE50, 0xFE6F, QT_TRANSLATE_NOOP("textpalette", "Small Form Variants"), },
{ 0xFE70, 0xFEFF, QT_TRANSLATE_NOOP("textpalette", "Arabic Presentation Forms-B"), },
{ 0xFF00, 0xFFEF, QT_TRANSLATE_NOOP("textpalette", "Halfwidth and Fullwidth Forms"), },
{ 0xFFF0, 0xFFFF, QT_TRANSLATE_NOOP("textpalette", "Specials"), },
{ 0x10000, 0x1007F, QT_TRANSLATE_NOOP("textpalette", "Linear B Syllabary") },
{ 0x10080, 0x100FF, QT_TRANSLATE_NOOP("textpalette", "Linear B Ideograms") },
{ 0x10100, 0x1013F, QT_TRANSLATE_NOOP("textpalette", "Aegean Numbers") },
{ 0x10140, 0x1018F, QT_TRANSLATE_NOOP("textpalette", "Ancient Greek Numbers") },
{ 0x10190, 0x101CF, QT_TRANSLATE_NOOP("textpalette", "Ancient Symbols") },
{ 0x101D0, 0x101FF, QT_TRANSLATE_NOOP("textpalette", "Phaistos Disc") },
{ 0x10280, 0x1029F, QT_TRANSLATE_NOOP("textpalette", "Lycian") },
{ 0x102A0, 0x102DF, QT_TRANSLATE_NOOP("textpalette", "Carian") },
{ 0x102E0, 0x102FF, QT_TRANSLATE_NOOP("textpalette", "Coptic Epact Numbers") },
{ 0x10300, 0x1032F, QT_TRANSLATE_NOOP("textpalette", "Old Italic") },
{ 0x10330, 0x1034F, QT_TRANSLATE_NOOP("textpalette", "Gothic") },
{ 0x10350, 0x1037F, QT_TRANSLATE_NOOP("textpalette", "Old Permic") },
{ 0x10380, 0x1039F, QT_TRANSLATE_NOOP("textpalette", "Ugaritic") },
{ 0x103A0, 0x103DF, QT_TRANSLATE_NOOP("textpalette", "Old Persian") },
{ 0x10400, 0x1044F, QT_TRANSLATE_NOOP("textpalette", "Deseret") },
{ 0x10450, 0x1047F, QT_TRANSLATE_NOOP("textpalette", "Shavian") },
{ 0x10480, 0x104AF, QT_TRANSLATE_NOOP("textpalette", "Osmanya") },
{ 0x104B0, 0x104FF, QT_TRANSLATE_NOOP("textpalette", "Osage") },
{ 0x10500, 0x1052F, QT_TRANSLATE_NOOP("textpalette", "Elbasan") },
{ 0x10530, 0x1056F, QT_TRANSLATE_NOOP("textpalette", "Caucasian Albanian") },
{ 0x10600, 0x1077F, QT_TRANSLATE_NOOP("textpalette", "Linear A") },
{ 0x10800, 0x1083F, QT_TRANSLATE_NOOP("textpalette", "Cypriot Syllabary") },
{ 0x10840, 0x1085F, QT_TRANSLATE_NOOP("textpalette", "Imperial Aramaic") },
{ 0x10860, 0x1087F, QT_TRANSLATE_NOOP("textpalette", "Palmyrene") },
{ 0x10880, 0x108AF, QT_TRANSLATE_NOOP("textpalette", "Nabataean") },
{ 0x108E0, 0x108EF, QT_TRANSLATE_NOOP("textpalette", "Hatran") },
{ 0x10900, 0x1091F, QT_TRANSLATE_NOOP("textpalette", "Phoenician") },
{ 0x10920, 0x1093F, QT_TRANSLATE_NOOP("textpalette", "Lydian") },
{ 0x10980, 0x1099F, QT_TRANSLATE_NOOP("textpalette", "Meroitic Hieroglyphs") },
{ 0x109A0, 0x109FF, QT_TRANSLATE_NOOP("textpalette", "Meroitic Cursive") },
{ 0x10A00, 0x10A5F, QT_TRANSLATE_NOOP("textpalette", "Kharoshthi") },
{ 0x10A60, 0x10A7F, QT_TRANSLATE_NOOP("textpalette", "Old South Arabian") },
{ 0x10A80, 0x10A9F, QT_TRANSLATE_NOOP("textpalette", "Old North Arabian") },
{ 0x10AC0, 0x10AFF, QT_TRANSLATE_NOOP("textpalette", "Manichaean") },
{ 0x10B00, 0x10B3F, QT_TRANSLATE_NOOP("textpalette", "Avestan") },
{ 0x10B40, 0x10B5F, QT_TRANSLATE_NOOP("textpalette", "Inscriptional Parthian") },
{ 0x10B60, 0x10B7F, QT_TRANSLATE_NOOP("textpalette", "Inscriptional Pahlavi") },
{ 0x10B80, 0x10BAF, QT_TRANSLATE_NOOP("textpalette", "Psalter Pahlavi") },
{ 0x10C00, 0x10C4F, QT_TRANSLATE_NOOP("textpalette", "Old Turkic") },
{ 0x10C80, 0x10CFF, QT_TRANSLATE_NOOP("textpalette", "Old Hungarian") },
{ 0x10D00, 0x10D3F, QT_TRANSLATE_NOOP("textpalette", "Hanifi Rohingya") },
{ 0x10E60, 0x10E7F, QT_TRANSLATE_NOOP("textpalette", "Rumi Numeral Symbols") },
{ 0x10E80, 0x10EBF, QT_TRANSLATE_NOOP("textpalette", "Yezidi") },
{ 0x10F00, 0x10F2F, QT_TRANSLATE_NOOP("textpalette", "Old Sogdian") },
{ 0x10F30, 0x10F6F, QT_TRANSLATE_NOOP("textpalette", "Sogdian") },
{ 0x10FB0, 0x10FDF, QT_TRANSLATE_NOOP("textpalette", "Chorasmian") },
{ 0x10FE0, 0x10FFF, QT_TRANSLATE_NOOP("textpalette", "Elymaic") },
{ 0x11000, 0x1107F, QT_TRANSLATE_NOOP("textpalette", "Brahmi") },
{ 0x11080, 0x110CF, QT_TRANSLATE_NOOP("textpalette", "Kaithi") },
{ 0x110D0, 0x110FF, QT_TRANSLATE_NOOP("textpalette", "Sora Sompeng") },
{ 0x11100, 0x1114F, QT_TRANSLATE_NOOP("textpalette", "Chakma") },
{ 0x11150, 0x1117F, QT_TRANSLATE_NOOP("textpalette", "Mahajani") },
{ 0x11180, 0x111DF, QT_TRANSLATE_NOOP("textpalette", "Sharada") },
{ 0x111E0, 0x111FF, QT_TRANSLATE_NOOP("textpalette", "Sinhala Archaic Numbers") },
{ 0x11200, 0x1124F, QT_TRANSLATE_NOOP("textpalette", "Khojki") },
{ 0x11280, 0x112AF, QT_TRANSLATE_NOOP("textpalette", "Multani") },
{ 0x112B0, 0x112FF, QT_TRANSLATE_NOOP("textpalette", "Khudawadi") },
{ 0x11300, 0x1137F, QT_TRANSLATE_NOOP("textpalette", "Grantha") },
{ 0x11400, 0x1147F, QT_TRANSLATE_NOOP("textpalette", "Newa") },
{ 0x11480, 0x114DF, QT_TRANSLATE_NOOP("textpalette", "Tirhuta") },
{ 0x11580, 0x115FF, QT_TRANSLATE_NOOP("textpalette", "Siddham") },
{ 0x11600, 0x1165F, QT_TRANSLATE_NOOP("textpalette", "Modi") },
{ 0x11660, 0x1167F, QT_TRANSLATE_NOOP("textpalette", "Mongolian Supplement") },
{ 0x11680, 0x116CF, QT_TRANSLATE_NOOP("textpalette", "Takri") },
{ 0x11700, 0x1173F, QT_TRANSLATE_NOOP("textpalette", "Ahom") },
{ 0x11800, 0x1184F, QT_TRANSLATE_NOOP("textpalette", "Dogra") },
{ 0x118A0, 0x118FF, QT_TRANSLATE_NOOP("textpalette", "Warang Citi") },
{ 0x11900, 0x1195F, QT_TRANSLATE_NOOP("textpalette", "Dives Akuru") },
{ 0x116A0, 0x119FF, QT_TRANSLATE_NOOP("textpalette", "Nandinagari") },
{ 0x11A00, 0x11A4F, QT_TRANSLATE_NOOP("textpalette", "Zanabazer Square") },
{ 0x11A50, 0x11AAF, QT_TRANSLATE_NOOP("textpalette", "Soyombo") },
{ 0x11AC0, 0x11AFF, QT_TRANSLATE_NOOP("textpalette", "Pau Cin Hau") },
{ 0x11C00, 0x11C6F, QT_TRANSLATE_NOOP("textpalette", "Bhaiksuki") },
{ 0x11C70, 0x11CBF, QT_TRANSLATE_NOOP("textpalette", "Marchen") },
{ 0x11D00, 0x11D5F, QT_TRANSLATE_NOOP("textpalette", "Masaram Gondi") },
{ 0x11D60, 0x11DAF, QT_TRANSLATE_NOOP("textpalette", "Gunjala Gondi") },
{ 0x11EE0, 0x11EFF, QT_TRANSLATE_NOOP("textpalette", "Makasar") },
{ 0x11FB0, 0x11FBF, QT_TRANSLATE_NOOP("textpalette", "Lisu Supplement") },
{ 0x11FC0, 0x11FFF, QT_TRANSLATE_NOOP("textpalette", "Tamil Supplement") },
{ 0x12000, 0x123FF, QT_TRANSLATE_NOOP("textpalette", "Cuneiform") },
{ 0x12400, 0x1247F, QT_TRANSLATE_NOOP("textpalette", "Cuneiform Numbers and Punctuation") },
{ 0x12480, 0x1254F, QT_TRANSLATE_NOOP("textpalette", "Early Dynastic Cuneiform") },
{ 0x13000, 0x1342F, QT_TRANSLATE_NOOP("textpalette", "Egyptian Hieroglyphs") },
{ 0x13430, 0x1343F, QT_TRANSLATE_NOOP("textpalette", "Egyptian Hieroglyph Format Controls") },
{ 0x14400, 0x1467F, QT_TRANSLATE_NOOP("textpalette", "Anatolian Hieroglyphs") },
{ 0x16800, 0x16A3F, QT_TRANSLATE_NOOP("textpalette", "Bamum Supplement") },
{ 0x16A40, 0x16A6F, QT_TRANSLATE_NOOP("textpalette", "Mro") },
{ 0x16AD0, 0x16AFF, QT_TRANSLATE_NOOP("textpalette", "Bassa Vah") },
{ 0x16B00, 0x16B8F, QT_TRANSLATE_NOOP("textpalette", "Pahawh Hmong") },
{ 0x16E40, 0x16E9F, QT_TRANSLATE_NOOP("textpalette", "Medefaidrin") },
{ 0x16F00, 0x16F9F, QT_TRANSLATE_NOOP("textpalette", "Miao") },
{ 0x16FE0, 0x16FFF, QT_TRANSLATE_NOOP("textpalette", "Ideographic Symbols and Punctuation") },
{ 0x18800, 0x18AFF, QT_TRANSLATE_NOOP("textpalette", "Tangut Components") },
{ 0x18B00, 0x16CFF, QT_TRANSLATE_NOOP("textpalette", "Khitan Small Script") },
{ 0x18D00, 0x16D8F, QT_TRANSLATE_NOOP("textpalette", "Tangut Supplement") },
{ 0x1B000, 0x1B0FF, QT_TRANSLATE_NOOP("textpalette", "Kana Supplement") },
{ 0x1B100, 0x1B12F, QT_TRANSLATE_NOOP("textpalette", "Kana Extended-A") },
{ 0x1B130, 0x1B16F, QT_TRANSLATE_NOOP("textpalette", "Small Kana Extension") },
{ 0x1B170, 0x1B2FF, QT_TRANSLATE_NOOP("textpalette", "Nushu") },
{ 0x1BC00, 0x1BC9F, QT_TRANSLATE_NOOP("textpalette", "Duployan") },
{ 0x1BCA0, 0x1BCAF, QT_TRANSLATE_NOOP("textpalette", "Shorthand Format Controls") },
{ 0x1D000, 0x1D0FF, QT_TRANSLATE_NOOP("textpalette", "Byzantine Musical Symbols") },
{ 0x1D100, 0x1D1FF, QT_TRANSLATE_NOOP("textpalette", "Musical Symbols") },
{ 0x1D200, 0x1D24F, QT_TRANSLATE_NOOP("textpalette", "Ancient Greek Musical Notation") },
{ 0x1D300, 0x1D35F, QT_TRANSLATE_NOOP("textpalette", "Tai Xuan Jing Symbols") },
{ 0x1D360, 0x1D37F, QT_TRANSLATE_NOOP("textpalette", "Counting Rod Numerals") },
{ 0x1D400, 0x1D7FF, QT_TRANSLATE_NOOP("textpalette", "Mathematical Alphanumeric Symbols") },
{ 0x1D800, 0x1DAAF, QT_TRANSLATE_NOOP("textpalette", "Sutton SignWriting") },
{ 0x1E000, 0x1E02F, QT_TRANSLATE_NOOP("textpalette", "Glagolitic Supplement") },
{ 0x1E100, 0x1E14F, QT_TRANSLATE_NOOP("textpalette", "Nyiakeng Puachue Hmong") },
{ 0x1E2C0, 0x1E2FF, QT_TRANSLATE_NOOP("textpalette", "Wancho") },
{ 0x1E800, 0x1E8DF, QT_TRANSLATE_NOOP("textpalette", "Mende Kikakui") },
{ 0x1E900, 0x1E95F, QT_TRANSLATE_NOOP("textpalette", "Adlam") },
{ 0x1EC70, 0x1ECBF, QT_TRANSLATE_NOOP("textpalette", "Indic Siyaq Numbers") },
{ 0x1ED00, 0x1ED4F, QT_TRANSLATE_NOOP("textpalette", "Ottoman Siyaq Numbers") },
{ 0x1EE00, 0x1EEFF, QT_TRANSLATE_NOOP("textpalette", "Arabic Mathematical Alphabetic Symbols") },
{ 0x1F000, 0x1F02F, QT_TRANSLATE_NOOP("textpalette", "Mahjong Tiles") },
{ 0x1F030, 0x1F09F, QT_TRANSLATE_NOOP("textpalette", "Domino Tiles") },
{ 0x1F0A0, 0x1F0FF, QT_TRANSLATE_NOOP("textpalette", "Playing Cards") },
{ 0x1F100, 0x1F1FF, QT_TRANSLATE_NOOP("textpalette", "Enclosed Alphanumeric Supplement") },
{ 0x1F200, 0x1F2FF, QT_TRANSLATE_NOOP("textpalette", "Enclosed Ideographic Supplement") },
{ 0x1F300, 0x1F5FF, QT_TRANSLATE_NOOP("textpalette", "Miscellaneous Symbols and Pictographs") },
{ 0x1F600, 0x1F64F, QT_TRANSLATE_NOOP("textpalette", "Emoticons (Emoji)") },
{ 0x1F650, 0x1F67F, QT_TRANSLATE_NOOP("textpalette", "Ornamental Dingbats") },
{ 0x1F680, 0x1F6FF, QT_TRANSLATE_NOOP("textpalette", "Transport and Map Symbols") },
{ 0x1F700, 0x1F77F, QT_TRANSLATE_NOOP("textpalette", "Alchemical Symbols") },
{ 0x1F780, 0x1F7FF, QT_TRANSLATE_NOOP("textpalette", "Geometric Shapes Extended") },
{ 0x1F800, 0x1F8FF, QT_TRANSLATE_NOOP("textpalette", "Supplemental Arrows-C") },
{ 0x1F900, 0x1F9FF, QT_TRANSLATE_NOOP("textpalette", "Supplemental Symbols and Pictographs") },
{ 0x1FA00, 0x1FA6F, QT_TRANSLATE_NOOP("textpalette", "Chess Symbols") },
{ 0x1FA70, 0x1FAFF, QT_TRANSLATE_NOOP("textpalette", "Symbols and Pictographs Extended-A") },
{ 0x1FB00, 0x1FBFF, QT_TRANSLATE_NOOP("textpalette", "Symbols for Legacy Computing") },
{ 0x20000, 0x2A6D6, QT_TRANSLATE_NOOP("textpalette", "CJK Unified Ideographs Extension B") },
{ 0x2A700, 0x2B734, QT_TRANSLATE_NOOP("textpalette", "CJK Unified Ideographs Extension C") },
{ 0x2B740, 0x2B81D, QT_TRANSLATE_NOOP("textpalette", "CJK Unified Ideographs Extension D") },
{ 0x2F800, 0x2F81D, QT_TRANSLATE_NOOP("textpalette", "CJK Compatibility Ideographs Supplement") },
{ 0xE0001, 0xE007F, QT_TRANSLATE_NOOP("textpalette", "Tags") },
{ 0xE0100, 0xE01EF, QT_TRANSLATE_NOOP("textpalette", "Variation Selectors Supplement") },
{ 0xF0000, 0xFFFFD, QT_TRANSLATE_NOOP("textpalette", "Supplementary Private Use Area-A") },
{ 0x100000, 0x10FFFD, QT_TRANSLATE_NOOP("textpalette", "Supplementary Private Use Area-B") }
{ 0x0020, 0x007F, QT_TRANSLATE_NOOP("palette/uni", "Basic Latin") }, // leaving out the first 32 non-printable characters
{ 0x0080, 0x00FF, QT_TRANSLATE_NOOP("palette/uni", "Latin-1 Supplement") },
{ 0x0100, 0x017F, QT_TRANSLATE_NOOP("palette/uni", "Latin Extended-A") },
{ 0x0180, 0x024F, QT_TRANSLATE_NOOP("palette/uni", "Latin Extended-B") },
{ 0x0250, 0x02AF, QT_TRANSLATE_NOOP("palette/uni", "IPA Extensions") },
{ 0x02B0, 0x02FF, QT_TRANSLATE_NOOP("palette/uni", "Spacing Modifier Letters") },
{ 0x0300, 0x036F, QT_TRANSLATE_NOOP("palette/uni", "Combining Diacritical Marks") },
{ 0x0370, 0x03FF, QT_TRANSLATE_NOOP("palette/uni", "Greek and Coptic") },
{ 0x0400, 0x04FF, QT_TRANSLATE_NOOP("palette/uni", "Cyrillic") },
{ 0x0500, 0x052F, QT_TRANSLATE_NOOP("palette/uni", "Cyrillic Supplement") },
{ 0x0530, 0x058F, QT_TRANSLATE_NOOP("palette/uni", "Armenian") },
{ 0x0590, 0x05FF, QT_TRANSLATE_NOOP("palette/uni", "Hebrew") },
{ 0x0600, 0x06FF, QT_TRANSLATE_NOOP("palette/uni", "Arabic") },
{ 0x0700, 0x074F, QT_TRANSLATE_NOOP("palette/uni", "Syriac") },
{ 0x0750, 0x077F, QT_TRANSLATE_NOOP("palette/uni", "Arabic Supplement") },
{ 0x0780, 0x07BF, QT_TRANSLATE_NOOP("palette/uni", "Thaana") },
{ 0x07C0, 0x07FF, QT_TRANSLATE_NOOP("palette/uni", "NKo") },
{ 0x0800, 0x083F, QT_TRANSLATE_NOOP("palette/uni", "Samaritan") },
{ 0x0840, 0x085F, QT_TRANSLATE_NOOP("palette/uni", "Mandaic") },
{ 0x0860, 0x086F, QT_TRANSLATE_NOOP("palette/uni", "Syriac Supplement") },
{ 0x08A0, 0x08FF, QT_TRANSLATE_NOOP("palette/uni", "Arabic Extended-A") },
{ 0x0900, 0x097F, QT_TRANSLATE_NOOP("palette/uni", "Devanagari") },
{ 0x0980, 0x09FF, QT_TRANSLATE_NOOP("palette/uni", "Bengali") },
{ 0x0A00, 0x0A7F, QT_TRANSLATE_NOOP("palette/uni", "Gurmukhi") },
{ 0x0A80, 0x0AFF, QT_TRANSLATE_NOOP("palette/uni", "Gujarati") },
{ 0x0B00, 0x0B7F, QT_TRANSLATE_NOOP("palette/uni", "Oriya") },
{ 0x0B80, 0x0BFF, QT_TRANSLATE_NOOP("palette/uni", "Tamil") },
{ 0x0C00, 0x0C7F, QT_TRANSLATE_NOOP("palette/uni", "Telugu") },
{ 0x0C80, 0x0CFF, QT_TRANSLATE_NOOP("palette/uni", "Kannada") },
{ 0x0D00, 0x0D7F, QT_TRANSLATE_NOOP("palette/uni", "Malayalam") },
{ 0x0D80, 0x0DFF, QT_TRANSLATE_NOOP("palette/uni", "Sinhala") },
{ 0x0E00, 0x0E7F, QT_TRANSLATE_NOOP("palette/uni", "Thai") },
{ 0x0E80, 0x0EFF, QT_TRANSLATE_NOOP("palette/uni", "Lao") },
{ 0x0F00, 0x0FFF, QT_TRANSLATE_NOOP("palette/uni", "Tibetan") },
{ 0x1000, 0x109F, QT_TRANSLATE_NOOP("palette/uni", "Myanmar") },
{ 0x10A0, 0x10FF, QT_TRANSLATE_NOOP("palette/uni", "Georgian") },
{ 0x1100, 0x11FF, QT_TRANSLATE_NOOP("palette/uni", "Hangul Jamo") },
{ 0x1200, 0x137F, QT_TRANSLATE_NOOP("palette/uni", "Ethiopic") },
{ 0x1380, 0x139F, QT_TRANSLATE_NOOP("palette/uni", "Ethiopic Supplement") },
{ 0x13A0, 0x13FF, QT_TRANSLATE_NOOP("palette/uni", "Cherokee") },
{ 0x1400, 0x167F, QT_TRANSLATE_NOOP("palette/uni", "Unified Canadian Aboriginal Syllabics") },
{ 0x1680, 0x169F, QT_TRANSLATE_NOOP("palette/uni", "Ogham") },
{ 0x16A0, 0x16FF, QT_TRANSLATE_NOOP("palette/uni", "Runic") },
{ 0x1700, 0x171F, QT_TRANSLATE_NOOP("palette/uni", "Tagalog") },
{ 0x1720, 0x173F, QT_TRANSLATE_NOOP("palette/uni", "Hanunoo") },
{ 0x1740, 0x175F, QT_TRANSLATE_NOOP("palette/uni", "Buhid") },
{ 0x1760, 0x177F, QT_TRANSLATE_NOOP("palette/uni", "Tagbanwa") },
{ 0x1780, 0x17FF, QT_TRANSLATE_NOOP("palette/uni", "Khmer") },
{ 0x1800, 0x18AF, QT_TRANSLATE_NOOP("palette/uni", "Mongolian") },
{ 0x18B0, 0x18FF, QT_TRANSLATE_NOOP("palette/uni", "Unified Canadian Aboriginal Syllabics Extended") },
{ 0x1900, 0x194F, QT_TRANSLATE_NOOP("palette/uni", "Limbu") },
{ 0x1950, 0x197F, QT_TRANSLATE_NOOP("palette/uni", "Tai Le") },
{ 0x1980, 0x19DF, QT_TRANSLATE_NOOP("palette/uni", "New Tai Lue") },
{ 0x19E0, 0x19FF, QT_TRANSLATE_NOOP("palette/uni", "Khmer Symbols") },
{ 0x1A00, 0x1A1F, QT_TRANSLATE_NOOP("palette/uni", "Buginese") },
{ 0x1A20, 0x1AAF, QT_TRANSLATE_NOOP("palette/uni", "Tai Tham") },
{ 0x1AB0, 0x1AFF, QT_TRANSLATE_NOOP("palette/uni", "Combining Diacritical Marks Extended") },
{ 0x1B00, 0x1B7F, QT_TRANSLATE_NOOP("palette/uni", "Balinese") },
{ 0x1B80, 0x1BBF, QT_TRANSLATE_NOOP("palette/uni", "Sundanese") },
{ 0x1BC0, 0x1BFF, QT_TRANSLATE_NOOP("palette/uni", "Batak") },
{ 0x1C00, 0x1C4F, QT_TRANSLATE_NOOP("palette/uni", "Lepcha") },
{ 0x1C50, 0x1C7F, QT_TRANSLATE_NOOP("palette/uni", "Ol Chiki") },
{ 0x1C80, 0x1C8F, QT_TRANSLATE_NOOP("palette/uni", "Cyrillic Extended-C") },
{ 0x1C90, 0x1CBF, QT_TRANSLATE_NOOP("palette/uni", "Georgian Extended") },
{ 0x1CC0, 0x1CCF, QT_TRANSLATE_NOOP("palette/uni", "Sundanese Supplement") },
{ 0x1CD0, 0x1CFF, QT_TRANSLATE_NOOP("palette/uni", "Vedic Extensions") },
{ 0x1D00, 0x1D7F, QT_TRANSLATE_NOOP("palette/uni", "Phonetic Extensions") },
{ 0x1D80, 0x1DBF, QT_TRANSLATE_NOOP("palette/uni", "Phonetic Extensions Supplement") },
{ 0x1DC0, 0x1DFF, QT_TRANSLATE_NOOP("palette/uni", "Combining Diacritical Marks Supplement") },
{ 0x1E00, 0x1EFF, QT_TRANSLATE_NOOP("palette/uni", "Latin Extended Additional") },
{ 0x1F00, 0x1FFF, QT_TRANSLATE_NOOP("palette/uni", "Greek Extended") },
{ 0x2000, 0x206F, QT_TRANSLATE_NOOP("palette/uni", "General Punctuation") },
{ 0x2070, 0x209F, QT_TRANSLATE_NOOP("palette/uni", "Superscripts and Subscripts") },
{ 0x20A0, 0x20CF, QT_TRANSLATE_NOOP("palette/uni", "Currency Symbols") },
{ 0x20D0, 0x20FF, QT_TRANSLATE_NOOP("palette/uni", "Combining Diacritical Marks for Symbols") },
{ 0x2100, 0x214F, QT_TRANSLATE_NOOP("palette/uni", "Letterlike Symbols") },
{ 0x2150, 0x218F, QT_TRANSLATE_NOOP("palette/uni", "Number Forms") },
{ 0x2190, 0x21FF, QT_TRANSLATE_NOOP("palette/uni", "Arrows") },
{ 0x2200, 0x22FF, QT_TRANSLATE_NOOP("palette/uni", "Mathematical Operators") },
{ 0x2300, 0x23FF, QT_TRANSLATE_NOOP("palette/uni", "Miscellaneous Technical") },
{ 0x2400, 0x243F, QT_TRANSLATE_NOOP("palette/uni", "Control Pictures") },
{ 0x2440, 0x245F, QT_TRANSLATE_NOOP("palette/uni", "Optical Character Recognition") },
{ 0x2460, 0x24FF, QT_TRANSLATE_NOOP("palette/uni", "Enclosed Alphanumerics") },
{ 0x2500, 0x257F, QT_TRANSLATE_NOOP("palette/uni", "Box Drawing") },
{ 0x2580, 0x259F, QT_TRANSLATE_NOOP("palette/uni", "Block Elements") },
{ 0x25A0, 0x25FF, QT_TRANSLATE_NOOP("palette/uni", "Geometric Shapes") },
{ 0x2600, 0x26FF, QT_TRANSLATE_NOOP("palette/uni", "Miscellaneous Symbols") },
{ 0x2700, 0x27BF, QT_TRANSLATE_NOOP("palette/uni", "Dingbats") },
{ 0x27C0, 0x27EF, QT_TRANSLATE_NOOP("palette/uni", "Miscellaneous Mathematical Symbols-A") },
{ 0x27F0, 0x27FF, QT_TRANSLATE_NOOP("palette/uni", "Supplemental Arrows-A") },
{ 0x2800, 0x28FF, QT_TRANSLATE_NOOP("palette/uni", "Braille Patterns") },
{ 0x2900, 0x297F, QT_TRANSLATE_NOOP("palette/uni", "Supplemental Arrows-B") },
{ 0x2980, 0x29FF, QT_TRANSLATE_NOOP("palette/uni", "Miscellaneous Mathematical Symbols-B") },
{ 0x2A00, 0x2AFF, QT_TRANSLATE_NOOP("palette/uni", "Supplemental Mathematical Operators") },
{ 0x2B00, 0x2BFF, QT_TRANSLATE_NOOP("palette/uni", "Miscellaneous Symbols and Arrows") },
{ 0x2C00, 0x2C5F, QT_TRANSLATE_NOOP("palette/uni", "Glagolitic") },
{ 0x2C60, 0x2C7F, QT_TRANSLATE_NOOP("palette/uni", "Latin Extended-C") },
{ 0x2C80, 0x2CFF, QT_TRANSLATE_NOOP("palette/uni", "Coptic") },
{ 0x2D00, 0x2D2F, QT_TRANSLATE_NOOP("palette/uni", "Georgian Supplement") },
{ 0x2D30, 0x2D7F, QT_TRANSLATE_NOOP("palette/uni", "Tifinagh") },
{ 0x2D80, 0x2DDF, QT_TRANSLATE_NOOP("palette/uni", "Ethiopic Extended") },
{ 0x2DE0, 0x2DFF, QT_TRANSLATE_NOOP("palette/uni", "Cyrillic Extended-A") },
{ 0x2E00, 0x2E7F, QT_TRANSLATE_NOOP("palette/uni", "Supplemental Punctuation") },
{ 0x2E80, 0x2EFF, QT_TRANSLATE_NOOP("palette/uni", "CJK Radicals Supplement") },
{ 0x2F00, 0x2FDF, QT_TRANSLATE_NOOP("palette/uni", "Kangxi Radicals") },
{ 0x2FF0, 0x2FFF, QT_TRANSLATE_NOOP("palette/uni", "Ideographic Description Characters") },
{ 0x3000, 0x303F, QT_TRANSLATE_NOOP("palette/uni", "CJK Symbols and Punctuation") },
{ 0x3040, 0x309F, QT_TRANSLATE_NOOP("palette/uni", "Hiragana") },
{ 0x30A0, 0x30FF, QT_TRANSLATE_NOOP("palette/uni", "Katakana") },
{ 0x3100, 0x312F, QT_TRANSLATE_NOOP("palette/uni", "Bopomofo") },
{ 0x3130, 0x318F, QT_TRANSLATE_NOOP("palette/uni", "Hangul Compatibility Jamo") },
{ 0x3190, 0x319F, QT_TRANSLATE_NOOP("palette/uni", "Kanbun") },
{ 0x31A0, 0x31BF, QT_TRANSLATE_NOOP("palette/uni", "Bopomofo Extended") },
{ 0x31C0, 0x31EF, QT_TRANSLATE_NOOP("palette/uni", "CJK Strokes") },
{ 0x31F0, 0x31FF, QT_TRANSLATE_NOOP("palette/uni", "Katakana Phonetic Extensions") },
{ 0x3200, 0x32FF, QT_TRANSLATE_NOOP("palette/uni", "Enclosed CJK Letters and Months") },
{ 0x3300, 0x33FF, QT_TRANSLATE_NOOP("palette/uni", "CJK Compatibility") },
{ 0x3400, 0x4DB5, QT_TRANSLATE_NOOP("palette/uni", "CJK Unified Ideographs Extension A") },
{ 0x4DC0, 0x4DFF, QT_TRANSLATE_NOOP("palette/uni", "Yijing Hexagram Symbols") },
{ 0x4E00, 0x9FCC, QT_TRANSLATE_NOOP("palette/uni", "CJK Unified Ideographs") },
{ 0xA000, 0xA48F, QT_TRANSLATE_NOOP("palette/uni", "Yi Syllables") },
{ 0xA490, 0xA4CF, QT_TRANSLATE_NOOP("palette/uni", "Yi Radicals") },
{ 0xA4D0, 0xA4FF, QT_TRANSLATE_NOOP("palette/uni", "Lisu") },
{ 0xA500, 0xA63F, QT_TRANSLATE_NOOP("palette/uni", "Vai") },
{ 0xA640, 0xA69F, QT_TRANSLATE_NOOP("palette/uni", "Cyrillic Extended-B") },
{ 0xA6A0, 0xA6FF, QT_TRANSLATE_NOOP("palette/uni", "Bamum") },
{ 0xA700, 0xA71F, QT_TRANSLATE_NOOP("palette/uni", "Modifier Tone Letters") },
{ 0xA720, 0xA7FF, QT_TRANSLATE_NOOP("palette/uni", "Latin Extended-D") },
{ 0xA800, 0xA82F, QT_TRANSLATE_NOOP("palette/uni", "Syloti Nagri") },
{ 0xA830, 0xA83F, QT_TRANSLATE_NOOP("palette/uni", "Common Indic Number Forms") },
{ 0xA840, 0xA87F, QT_TRANSLATE_NOOP("palette/uni", "Phags-pa") },
{ 0xA880, 0xA8DF, QT_TRANSLATE_NOOP("palette/uni", "Saurashtra") },
{ 0xA8E0, 0xA8FF, QT_TRANSLATE_NOOP("palette/uni", "Devanagari Extended") },
{ 0xA900, 0xA92F, QT_TRANSLATE_NOOP("palette/uni", "Kayah Li") },
{ 0xA930, 0xA95F, QT_TRANSLATE_NOOP("palette/uni", "Rejang") },
{ 0xA960, 0xA97F, QT_TRANSLATE_NOOP("palette/uni", "Hangul Jamo Extended-A") },
{ 0xA980, 0xA9DF, QT_TRANSLATE_NOOP("palette/uni", "Javanese") },
{ 0xA9E0, 0xA9FF, QT_TRANSLATE_NOOP("palette/uni", "Myanmar Extended-B") },
{ 0xAA00, 0xAA5F, QT_TRANSLATE_NOOP("palette/uni", "Cham") },
{ 0xAA60, 0xAA7F, QT_TRANSLATE_NOOP("palette/uni", "Myanmar Extended-A") },
{ 0xAA80, 0xAADF, QT_TRANSLATE_NOOP("palette/uni", "Tai Viet") },
{ 0xAAE0, 0xAAFF, QT_TRANSLATE_NOOP("palette/uni", "Meetei Mayek Extensions") },
{ 0xAB00, 0xAB2F, QT_TRANSLATE_NOOP("palette/uni", "Ethiopic Extended-A") },
{ 0xAB30, 0xAB6F, QT_TRANSLATE_NOOP("palette/uni", "Latin Extended-E") },
{ 0xAB70, 0xABBF, QT_TRANSLATE_NOOP("palette/uni", "Cherokee Supplement") },
{ 0xABC0, 0xABFF, QT_TRANSLATE_NOOP("palette/uni", "Meetei Mayek") },
{ 0xAC00, 0xD7A3, QT_TRANSLATE_NOOP("palette/uni", "Hangul Syllables") },
{ 0xD7B0, 0xD7FF, QT_TRANSLATE_NOOP("palette/uni", "Hangul Jamo Extended-B") },
{ 0xD800, 0xDB7F, QT_TRANSLATE_NOOP("palette/uni", "High Surrogates") },
{ 0xDB80, 0xDBFF, QT_TRANSLATE_NOOP("palette/uni", "High Private Use Surrogates") },
{ 0xDC00, 0xDFFF, QT_TRANSLATE_NOOP("palette/uni", "Low Surrogates") },
{ 0xE000, 0xF8FF, QT_TRANSLATE_NOOP("palette/uni", "Private Use Area"), },
{ 0xF900, 0xFAFF, QT_TRANSLATE_NOOP("palette/uni", "CJK Compatibility Ideographs"), },
{ 0xFB00, 0xFB4F, QT_TRANSLATE_NOOP("palette/uni", "Alphabetic Presentation Forms"), },
{ 0xFB50, 0xFDFF, QT_TRANSLATE_NOOP("palette/uni", "Arabic Presentation Forms-A"), },
{ 0xFE00, 0xFE0F, QT_TRANSLATE_NOOP("palette/uni", "Variation Selectors"), },
{ 0xFE10, 0xFE1F, QT_TRANSLATE_NOOP("palette/uni", "Vertical Forms"), },
{ 0xFE20, 0xFE2F, QT_TRANSLATE_NOOP("palette/uni", "Combining Half Marks"), },
{ 0xFE30, 0xFE4F, QT_TRANSLATE_NOOP("palette/uni", "CJK Compatibility Forms"), },
{ 0xFE50, 0xFE6F, QT_TRANSLATE_NOOP("palette/uni", "Small Form Variants"), },
{ 0xFE70, 0xFEFF, QT_TRANSLATE_NOOP("palette/uni", "Arabic Presentation Forms-B"), },
{ 0xFF00, 0xFFEF, QT_TRANSLATE_NOOP("palette/uni", "Halfwidth and Fullwidth Forms"), },
{ 0xFFF0, 0xFFFF, QT_TRANSLATE_NOOP("palette/uni", "Specials"), },
{ 0x10000, 0x1007F, QT_TRANSLATE_NOOP("palette/uni", "Linear B Syllabary") },
{ 0x10080, 0x100FF, QT_TRANSLATE_NOOP("palette/uni", "Linear B Ideograms") },
{ 0x10100, 0x1013F, QT_TRANSLATE_NOOP("palette/uni", "Aegean Numbers") },
{ 0x10140, 0x1018F, QT_TRANSLATE_NOOP("palette/uni", "Ancient Greek Numbers") },
{ 0x10190, 0x101CF, QT_TRANSLATE_NOOP("palette/uni", "Ancient Symbols") },
{ 0x101D0, 0x101FF, QT_TRANSLATE_NOOP("palette/uni", "Phaistos Disc") },
{ 0x10280, 0x1029F, QT_TRANSLATE_NOOP("palette/uni", "Lycian") },
{ 0x102A0, 0x102DF, QT_TRANSLATE_NOOP("palette/uni", "Carian") },
{ 0x102E0, 0x102FF, QT_TRANSLATE_NOOP("palette/uni", "Coptic Epact Numbers") },
{ 0x10300, 0x1032F, QT_TRANSLATE_NOOP("palette/uni", "Old Italic") },
{ 0x10330, 0x1034F, QT_TRANSLATE_NOOP("palette/uni", "Gothic") },
{ 0x10350, 0x1037F, QT_TRANSLATE_NOOP("palette/uni", "Old Permic") },
{ 0x10380, 0x1039F, QT_TRANSLATE_NOOP("palette/uni", "Ugaritic") },
{ 0x103A0, 0x103DF, QT_TRANSLATE_NOOP("palette/uni", "Old Persian") },
{ 0x10400, 0x1044F, QT_TRANSLATE_NOOP("palette/uni", "Deseret") },
{ 0x10450, 0x1047F, QT_TRANSLATE_NOOP("palette/uni", "Shavian") },
{ 0x10480, 0x104AF, QT_TRANSLATE_NOOP("palette/uni", "Osmanya") },
{ 0x104B0, 0x104FF, QT_TRANSLATE_NOOP("palette/uni", "Osage") },
{ 0x10500, 0x1052F, QT_TRANSLATE_NOOP("palette/uni", "Elbasan") },
{ 0x10530, 0x1056F, QT_TRANSLATE_NOOP("palette/uni", "Caucasian Albanian") },
{ 0x10600, 0x1077F, QT_TRANSLATE_NOOP("palette/uni", "Linear A") },
{ 0x10800, 0x1083F, QT_TRANSLATE_NOOP("palette/uni", "Cypriot Syllabary") },
{ 0x10840, 0x1085F, QT_TRANSLATE_NOOP("palette/uni", "Imperial Aramaic") },
{ 0x10860, 0x1087F, QT_TRANSLATE_NOOP("palette/uni", "Palmyrene") },
{ 0x10880, 0x108AF, QT_TRANSLATE_NOOP("palette/uni", "Nabataean") },
{ 0x108E0, 0x108EF, QT_TRANSLATE_NOOP("palette/uni", "Hatran") },
{ 0x10900, 0x1091F, QT_TRANSLATE_NOOP("palette/uni", "Phoenician") },
{ 0x10920, 0x1093F, QT_TRANSLATE_NOOP("palette/uni", "Lydian") },
{ 0x10980, 0x1099F, QT_TRANSLATE_NOOP("palette/uni", "Meroitic Hieroglyphs") },
{ 0x109A0, 0x109FF, QT_TRANSLATE_NOOP("palette/uni", "Meroitic Cursive") },
{ 0x10A00, 0x10A5F, QT_TRANSLATE_NOOP("palette/uni", "Kharoshthi") },
{ 0x10A60, 0x10A7F, QT_TRANSLATE_NOOP("palette/uni", "Old South Arabian") },
{ 0x10A80, 0x10A9F, QT_TRANSLATE_NOOP("palette/uni", "Old North Arabian") },
{ 0x10AC0, 0x10AFF, QT_TRANSLATE_NOOP("palette/uni", "Manichaean") },
{ 0x10B00, 0x10B3F, QT_TRANSLATE_NOOP("palette/uni", "Avestan") },
{ 0x10B40, 0x10B5F, QT_TRANSLATE_NOOP("palette/uni", "Inscriptional Parthian") },
{ 0x10B60, 0x10B7F, QT_TRANSLATE_NOOP("palette/uni", "Inscriptional Pahlavi") },
{ 0x10B80, 0x10BAF, QT_TRANSLATE_NOOP("palette/uni", "Psalter Pahlavi") },
{ 0x10C00, 0x10C4F, QT_TRANSLATE_NOOP("palette/uni", "Old Turkic") },
{ 0x10C80, 0x10CFF, QT_TRANSLATE_NOOP("palette/uni", "Old Hungarian") },
{ 0x10D00, 0x10D3F, QT_TRANSLATE_NOOP("palette/uni", "Hanifi Rohingya") },
{ 0x10E60, 0x10E7F, QT_TRANSLATE_NOOP("palette/uni", "Rumi Numeral Symbols") },
{ 0x10E80, 0x10EBF, QT_TRANSLATE_NOOP("palette/uni", "Yezidi") },
{ 0x10F00, 0x10F2F, QT_TRANSLATE_NOOP("palette/uni", "Old Sogdian") },
{ 0x10F30, 0x10F6F, QT_TRANSLATE_NOOP("palette/uni", "Sogdian") },
{ 0x10FB0, 0x10FDF, QT_TRANSLATE_NOOP("palette/uni", "Chorasmian") },
{ 0x10FE0, 0x10FFF, QT_TRANSLATE_NOOP("palette/uni", "Elymaic") },
{ 0x11000, 0x1107F, QT_TRANSLATE_NOOP("palette/uni", "Brahmi") },
{ 0x11080, 0x110CF, QT_TRANSLATE_NOOP("palette/uni", "Kaithi") },
{ 0x110D0, 0x110FF, QT_TRANSLATE_NOOP("palette/uni", "Sora Sompeng") },
{ 0x11100, 0x1114F, QT_TRANSLATE_NOOP("palette/uni", "Chakma") },
{ 0x11150, 0x1117F, QT_TRANSLATE_NOOP("palette/uni", "Mahajani") },
{ 0x11180, 0x111DF, QT_TRANSLATE_NOOP("palette/uni", "Sharada") },
{ 0x111E0, 0x111FF, QT_TRANSLATE_NOOP("palette/uni", "Sinhala Archaic Numbers") },
{ 0x11200, 0x1124F, QT_TRANSLATE_NOOP("palette/uni", "Khojki") },
{ 0x11280, 0x112AF, QT_TRANSLATE_NOOP("palette/uni", "Multani") },
{ 0x112B0, 0x112FF, QT_TRANSLATE_NOOP("palette/uni", "Khudawadi") },
{ 0x11300, 0x1137F, QT_TRANSLATE_NOOP("palette/uni", "Grantha") },
{ 0x11400, 0x1147F, QT_TRANSLATE_NOOP("palette/uni", "Newa") },
{ 0x11480, 0x114DF, QT_TRANSLATE_NOOP("palette/uni", "Tirhuta") },
{ 0x11580, 0x115FF, QT_TRANSLATE_NOOP("palette/uni", "Siddham") },
{ 0x11600, 0x1165F, QT_TRANSLATE_NOOP("palette/uni", "Modi") },
{ 0x11660, 0x1167F, QT_TRANSLATE_NOOP("palette/uni", "Mongolian Supplement") },
{ 0x11680, 0x116CF, QT_TRANSLATE_NOOP("palette/uni", "Takri") },
{ 0x11700, 0x1173F, QT_TRANSLATE_NOOP("palette/uni", "Ahom") },
{ 0x11800, 0x1184F, QT_TRANSLATE_NOOP("palette/uni", "Dogra") },
{ 0x118A0, 0x118FF, QT_TRANSLATE_NOOP("palette/uni", "Warang Citi") },
{ 0x11900, 0x1195F, QT_TRANSLATE_NOOP("palette/uni", "Dives Akuru") },
{ 0x116A0, 0x119FF, QT_TRANSLATE_NOOP("palette/uni", "Nandinagari") },
{ 0x11A00, 0x11A4F, QT_TRANSLATE_NOOP("palette/uni", "Zanabazer Square") },
{ 0x11A50, 0x11AAF, QT_TRANSLATE_NOOP("palette/uni", "Soyombo") },
{ 0x11AC0, 0x11AFF, QT_TRANSLATE_NOOP("palette/uni", "Pau Cin Hau") },
{ 0x11C00, 0x11C6F, QT_TRANSLATE_NOOP("palette/uni", "Bhaiksuki") },
{ 0x11C70, 0x11CBF, QT_TRANSLATE_NOOP("palette/uni", "Marchen") },
{ 0x11D00, 0x11D5F, QT_TRANSLATE_NOOP("palette/uni", "Masaram Gondi") },
{ 0x11D60, 0x11DAF, QT_TRANSLATE_NOOP("palette/uni", "Gunjala Gondi") },
{ 0x11EE0, 0x11EFF, QT_TRANSLATE_NOOP("palette/uni", "Makasar") },
{ 0x11FB0, 0x11FBF, QT_TRANSLATE_NOOP("palette/uni", "Lisu Supplement") },
{ 0x11FC0, 0x11FFF, QT_TRANSLATE_NOOP("palette/uni", "Tamil Supplement") },
{ 0x12000, 0x123FF, QT_TRANSLATE_NOOP("palette/uni", "Cuneiform") },
{ 0x12400, 0x1247F, QT_TRANSLATE_NOOP("palette/uni", "Cuneiform Numbers and Punctuation") },
{ 0x12480, 0x1254F, QT_TRANSLATE_NOOP("palette/uni", "Early Dynastic Cuneiform") },
{ 0x13000, 0x1342F, QT_TRANSLATE_NOOP("palette/uni", "Egyptian Hieroglyphs") },
{ 0x13430, 0x1343F, QT_TRANSLATE_NOOP("palette/uni", "Egyptian Hieroglyph Format Controls") },
{ 0x14400, 0x1467F, QT_TRANSLATE_NOOP("palette/uni", "Anatolian Hieroglyphs") },
{ 0x16800, 0x16A3F, QT_TRANSLATE_NOOP("palette/uni", "Bamum Supplement") },
{ 0x16A40, 0x16A6F, QT_TRANSLATE_NOOP("palette/uni", "Mro") },
{ 0x16AD0, 0x16AFF, QT_TRANSLATE_NOOP("palette/uni", "Bassa Vah") },
{ 0x16B00, 0x16B8F, QT_TRANSLATE_NOOP("palette/uni", "Pahawh Hmong") },
{ 0x16E40, 0x16E9F, QT_TRANSLATE_NOOP("palette/uni", "Medefaidrin") },
{ 0x16F00, 0x16F9F, QT_TRANSLATE_NOOP("palette/uni", "Miao") },
{ 0x16FE0, 0x16FFF, QT_TRANSLATE_NOOP("palette/uni", "Ideographic Symbols and Punctuation") },
{ 0x18800, 0x18AFF, QT_TRANSLATE_NOOP("palette/uni", "Tangut Components") },
{ 0x18B00, 0x16CFF, QT_TRANSLATE_NOOP("palette/uni", "Khitan Small Script") },
{ 0x18D00, 0x16D8F, QT_TRANSLATE_NOOP("palette/uni", "Tangut Supplement") },
{ 0x1B000, 0x1B0FF, QT_TRANSLATE_NOOP("palette/uni", "Kana Supplement") },
{ 0x1B100, 0x1B12F, QT_TRANSLATE_NOOP("palette/uni", "Kana Extended-A") },
{ 0x1B130, 0x1B16F, QT_TRANSLATE_NOOP("palette/uni", "Small Kana Extension") },
{ 0x1B170, 0x1B2FF, QT_TRANSLATE_NOOP("palette/uni", "Nushu") },
{ 0x1BC00, 0x1BC9F, QT_TRANSLATE_NOOP("palette/uni", "Duployan") },
{ 0x1BCA0, 0x1BCAF, QT_TRANSLATE_NOOP("palette/uni", "Shorthand Format Controls") },
{ 0x1D000, 0x1D0FF, QT_TRANSLATE_NOOP("palette/uni", "Byzantine Musical Symbols") },
{ 0x1D100, 0x1D1FF, QT_TRANSLATE_NOOP("palette/uni", "Musical Symbols") },
{ 0x1D200, 0x1D24F, QT_TRANSLATE_NOOP("palette/uni", "Ancient Greek Musical Notation") },
{ 0x1D300, 0x1D35F, QT_TRANSLATE_NOOP("palette/uni", "Tai Xuan Jing Symbols") },
{ 0x1D360, 0x1D37F, QT_TRANSLATE_NOOP("palette/uni", "Counting Rod Numerals") },
{ 0x1D400, 0x1D7FF, QT_TRANSLATE_NOOP("palette/uni", "Mathematical Alphanumeric Symbols") },
{ 0x1D800, 0x1DAAF, QT_TRANSLATE_NOOP("palette/uni", "Sutton SignWriting") },
{ 0x1E000, 0x1E02F, QT_TRANSLATE_NOOP("palette/uni", "Glagolitic Supplement") },
{ 0x1E100, 0x1E14F, QT_TRANSLATE_NOOP("palette/uni", "Nyiakeng Puachue Hmong") },
{ 0x1E2C0, 0x1E2FF, QT_TRANSLATE_NOOP("palette/uni", "Wancho") },
{ 0x1E800, 0x1E8DF, QT_TRANSLATE_NOOP("palette/uni", "Mende Kikakui") },
{ 0x1E900, 0x1E95F, QT_TRANSLATE_NOOP("palette/uni", "Adlam") },
{ 0x1EC70, 0x1ECBF, QT_TRANSLATE_NOOP("palette/uni", "Indic Siyaq Numbers") },
{ 0x1ED00, 0x1ED4F, QT_TRANSLATE_NOOP("palette/uni", "Ottoman Siyaq Numbers") },
{ 0x1EE00, 0x1EEFF, QT_TRANSLATE_NOOP("palette/uni", "Arabic Mathematical Alphabetic Symbols") },
{ 0x1F000, 0x1F02F, QT_TRANSLATE_NOOP("palette/uni", "Mahjong Tiles") },
{ 0x1F030, 0x1F09F, QT_TRANSLATE_NOOP("palette/uni", "Domino Tiles") },
{ 0x1F0A0, 0x1F0FF, QT_TRANSLATE_NOOP("palette/uni", "Playing Cards") },
{ 0x1F100, 0x1F1FF, QT_TRANSLATE_NOOP("palette/uni", "Enclosed Alphanumeric Supplement") },
{ 0x1F200, 0x1F2FF, QT_TRANSLATE_NOOP("palette/uni", "Enclosed Ideographic Supplement") },
{ 0x1F300, 0x1F5FF, QT_TRANSLATE_NOOP("palette/uni", "Miscellaneous Symbols and Pictographs") },
{ 0x1F600, 0x1F64F, QT_TRANSLATE_NOOP("palette/uni", "Emoticons (Emoji)") },
{ 0x1F650, 0x1F67F, QT_TRANSLATE_NOOP("palette/uni", "Ornamental Dingbats") },
{ 0x1F680, 0x1F6FF, QT_TRANSLATE_NOOP("palette/uni", "Transport and Map Symbols") },
{ 0x1F700, 0x1F77F, QT_TRANSLATE_NOOP("palette/uni", "Alchemical Symbols") },
{ 0x1F780, 0x1F7FF, QT_TRANSLATE_NOOP("palette/uni", "Geometric Shapes Extended") },
{ 0x1F800, 0x1F8FF, QT_TRANSLATE_NOOP("palette/uni", "Supplemental Arrows-C") },
{ 0x1F900, 0x1F9FF, QT_TRANSLATE_NOOP("palette/uni", "Supplemental Symbols and Pictographs") },
{ 0x1FA00, 0x1FA6F, QT_TRANSLATE_NOOP("palette/uni", "Chess Symbols") },
{ 0x1FA70, 0x1FAFF, QT_TRANSLATE_NOOP("palette/uni", "Symbols and Pictographs Extended-A") },
{ 0x1FB00, 0x1FBFF, QT_TRANSLATE_NOOP("palette/uni", "Symbols for Legacy Computing") },
{ 0x20000, 0x2A6D6, QT_TRANSLATE_NOOP("palette/uni", "CJK Unified Ideographs Extension B") },
{ 0x2A700, 0x2B734, QT_TRANSLATE_NOOP("palette/uni", "CJK Unified Ideographs Extension C") },
{ 0x2B740, 0x2B81D, QT_TRANSLATE_NOOP("palette/uni", "CJK Unified Ideographs Extension D") },
{ 0x2F800, 0x2F81D, QT_TRANSLATE_NOOP("palette/uni", "CJK Compatibility Ideographs Supplement") },
{ 0xE0001, 0xE007F, QT_TRANSLATE_NOOP("palette/uni", "Tags") },
{ 0xE0100, 0xE01EF, QT_TRANSLATE_NOOP("palette/uni", "Variation Selectors Supplement") },
{ 0xF0000, 0xFFFFD, QT_TRANSLATE_NOOP("palette/uni", "Supplementary Private Use Area-A") },
{ 0x100000, 0x10FFFD, QT_TRANSLATE_NOOP("palette/uni", "Supplementary Private Use Area-B") }
};
//---------------------------------------------------------
@ -463,7 +463,7 @@ SpecialCharactersDialog::SpecialCharactersDialog(QWidget* parent)
int index = 0;
for (const UnicodeRange& range : unicodeRanges) {
QListWidgetItem* newItem = new QListWidgetItem(mu::qtrc("textpalette", range.name));
QListWidgetItem* newItem = new QListWidgetItem(mu::qtrc("palette/uni", range.name));
newItem->setData(Qt::UserRole, index);
m_lwu->addItem(newItem);
if (index == 0) {

2
src/playback/qml/MuseScore/Playback/internal/MixerMuteAndSoloSection.qml
View file

@ -80,7 +80,7 @@ MixerPanelSection {
navigation.name: "SoloButton"
navigation.panel: channelItem.panel
navigation.row: root.navigationRowStart + 1
navigation.accessible.name: content.accessibleName + " " + qsTrc("payback", "Solo")
navigation.accessible.name: content.accessibleName + " " + qsTrc("playback", "Solo")
navigation.onActiveChanged: {
if (navigation.active) {
root.navigateControlIndexChanged({row: navigation.row, column: navigation.column})

6
src/plugins/internal/pluginsservice.cpp
View file

@ -78,9 +78,9 @@ Notification PluginsService::pluginsChanged() const
PluginsService::CategoryInfoMap PluginsService::categories() const
{
return {
{ "composing-arranging-tools", trc("plugin", "Composing/arranging tools") },
{ "color-notes", trc("plugin", "Colour notes") },
{ "playback", trc("plugin", "Playback") }
{ "composing-arranging-tools", trc("plugins", "Composing/arranging tools") },
{ "color-notes", trc("plugins", "Colour notes") },
{ "playback", trc("plugins", "Playback") }
};
}

10
src/project/internal/notationproject.cpp
View file

@ -210,9 +210,6 @@ mu::Ret NotationProject::doLoad(engraving::MscReader& reader, const io::path_t&
// Load style if present
if (!stylePath.empty()) {
m_engravingProject->masterScore()->loadStyle(stylePath.toQString());
if (!mu::engraving::MScore::lastError.isEmpty()) {
LOGE() << mu::engraving::MScore::lastError;
}
}
// Load other stuff from the project file
@ -258,10 +255,6 @@ mu::Ret NotationProject::doImport(const io::path_t& path, const io::path_t& styl
return ret;
}
if (!mu::engraving::MScore::lastError.isEmpty()) {
LOGE() << mu::engraving::MScore::lastError;
}
// Setup master score
engraving::Err err = m_engravingProject->setupMasterScore(forceMode);
if (err != engraving::Err::NoError) {
@ -271,9 +264,6 @@ mu::Ret NotationProject::doImport(const io::path_t& path, const io::path_t& styl
// Load style if present
if (!stylePath.empty()) {
score->loadStyle(stylePath.toQString());
if (!mu::engraving::MScore::lastError.isEmpty()) {
LOGE() << mu::engraving::MScore::lastError;
}
}
// Setup other stuff

28
src/project/internal/projectactionscontroller.cpp
View file

@ -597,20 +597,20 @@ io::path_t ProjectActionsController::selectScoreOpeningFile()
"*.ove *.scw *.bmw *.bww *.gtp *.gp3 *.gp4 *.gp5 *.gpx *.gp *.ptb *.mscx *.mscs *.mscz~";
QStringList filter;
filter << QObject::tr("All Supported Files") + " (" + allExt + ")"
<< QObject::tr("MuseScore File") + " (*.mscz)"
<< QObject::tr("MusicXML Files") + " (*.mxl *.musicxml *.xml)"
<< QObject::tr("MIDI Files") + " (*.mid *.midi *.kar)"
<< QObject::tr("MuseData Files") + " (*.md)"
<< QObject::tr("Capella Files") + " (*.cap *.capx)"
<< QObject::tr("BB Files (experimental)") + " (*.mgu *.sgu)"
<< QObject::tr("Overture / Score Writer Files (experimental)") + " (*.ove *.scw)"
<< QObject::tr("Bagpipe Music Writer Files (experimental)") + " (*.bmw *.bww)"
<< QObject::tr("Guitar Pro Files") + " (*.gtp *.gp3 *.gp4 *.gp5 *.gpx *.gp)"
<< QObject::tr("Power Tab Editor Files (experimental)") + " (*.ptb)"
<< QObject::tr("MuseScore Unpack Files") + " (*.mscx)"
<< QObject::tr("MuseScore Dev Files") + " (*.mscs)"
<< QObject::tr("MuseScore Backup Files") + " (*.mscz~)";
filter << qtrc("project", "All Supported Files") + " (" + allExt + ")"
<< qtrc("project", "MuseScore File") + " (*.mscz)"
<< qtrc("project", "MusicXML Files") + " (*.mxl *.musicxml *.xml)"
<< qtrc("project", "MIDI Files") + " (*.mid *.midi *.kar)"
<< qtrc("project", "MuseData Files") + " (*.md)"
<< qtrc("project", "Capella Files") + " (*.cap *.capx)"
<< qtrc("project", "BB Files (experimental)") + " (*.mgu *.sgu)"
<< qtrc("project", "Overture / Score Writer Files (experimental)") + " (*.ove *.scw)"
<< qtrc("project", "Bagpipe Music Writer Files (experimental)") + " (*.bmw *.bww)"
<< qtrc("project", "Guitar Pro Files") + " (*.gtp *.gp3 *.gp4 *.gp5 *.gpx *.gp)"
<< qtrc("project", "Power Tab Editor Files (experimental)") + " (*.ptb)"
<< qtrc("project", "MuseScore Unpack Files") + " (*.mscx)"
<< qtrc("project", "MuseScore Dev Files") + " (*.mscs)"
<< qtrc("project", "MuseScore Backup Files") + " (*.mscz~)";
io::path_t defaultDir = configuration()->lastOpenedProjectsPath();

4
src/project/view/additionalinfomodel.cpp
View file

@ -182,9 +182,9 @@ QString AdditionalInfoModel::timeSignatureAccessibleName(int timeSignatureType,
case Fraction:
return qtrc("project", "%1/%2").arg(QString::number(numerator), QString::number(denominator));
case Common:
return qtrc("symUserNames", "Common time");
return qtrc("project", "Common time");
case Cut:
return qtrc("symUserNames", "Cut time");
return qtrc("project", "Cut time");
}
return QString();

6
src/workspace/view/newworkspacemodel.cpp
View file

@ -37,7 +37,7 @@ void NewWorkspaceModel::load(const QString& workspaceNames)
{
m_workspaceNames = workspaceNames.split(',');
setWorkspaceName(qtrc("workspaces", "My new workspace"));
setWorkspaceName(qtrc("workspace", "My new workspace"));
setUseUiPreferences(true);
setUseUiArrangement(true);
setUsePalettes(true);
@ -95,14 +95,14 @@ void NewWorkspaceModel::validateWorkspaceName()
m_errorMessage.clear();
if (m_workspaceNames.contains(m_workspaceName)) {
m_errorMessage = qtrc("workspaces", "A workspace with the name '%1' already exists. Please choose a different name.")
m_errorMessage = qtrc("workspace", "A workspace with the name '%1' already exists. Please choose a different name.")
.arg(m_workspaceName);
return;
}
//! NOTE A file will be created with this name, so let's check if the name is valid for the file name
if (!io::isAllowedFileName(io::path_t(m_workspaceName))) {
m_errorMessage = qtrc("workspaces", "'%1' cannot be used as a workspace name. Please choose a different name.")
m_errorMessage = qtrc("workspace", "'%1' cannot be used as a workspace name. Please choose a different name.")
.arg(m_workspaceName);
return;
}

2
tools/fonttools/smufl2sym-cmd-symUserNames.jq
View file

@ -1,6 +1,6 @@
to_entries[] | [
" ",
if (.key | in($tr[0])) then "QT_TRANSLATE_NOOP(\"symUserNames\", \"" else "\"" end,
if (.key | in($tr[0])) then "QT_TRANSLATE_NOOP(\"engraving/sym\", \"" else "\"" end,
(.value.description | gsub("\""; "\\\"")),
if (.key | startswith("accidentalWyschnegradsky")) then " (Wyschnegradsky)" else "" end,
if (.key | in($tr[0])) then "\")," else "\"," end