void TestBarline::barline02()
{
char msg[256];
Score* score = readScore(DIR + "barline02.mscx");
QVERIFY(score);
Measure* msr = score->firstMeasure()->nextMeasure();
TimeSig* ts = new TimeSig(score);
ts->setSig(Fraction(3, 4), TimeSigType::NORMAL);
score->cmdAddTimeSig(msr, 0, ts, false);
score->doLayout();
msr = score->firstMeasure();
int msrNo = 1;
while ((msr = msr->nextMeasure())) {
++msrNo;
Segment* seg = msr->findSegment(SegmentType::EndBarLine, msr->tick()+msr->ticks());
sprintf(msg, "No SegEndBarLine in measure %d.", msrNo);
QVERIFY2(seg != nullptr, msg);
BarLine* bar = static_cast<BarLine*>(seg->element(0));
sprintf(msg, "No barline in measure %d.", msrNo);
QVERIFY2(bar != nullptr, msg);
// bar line should be generated if NORMAL, except the END one at the end
sprintf(msg, "Barline in measure %d changed into 'non-generated'.", msrNo);
// ws: end barline is also generated
// bool test = (bar->barLineType() == BarLineType::NORMAL) ? bar->generated() : !bar->generated();
bool test = bar->generated();
QVERIFY2(test, msg);
}
// QVERIFY(saveCompareScore(score, "barline02.mscx", DIR + "barline02-ref.mscx"));
delete score;
}
Palette* MuseScore::newBarLinePalette()
{
Palette* sp = new Palette;
sp->setName(qApp->translate("barlines", "Barlines"));
sp->setMag(0.8);
sp->setGrid(42, 38);
struct {
BarLineType type;
const char* name;
} t[] = {
{ NORMAL_BAR, QT_TR_NOOP("Normal") },
{ BROKEN_BAR, QT_TR_NOOP("Dashed") },
{ END_BAR, QT_TR_NOOP("End Bar") },
{ DOUBLE_BAR, QT_TR_NOOP("Double Bar") },
{ START_REPEAT, QT_TR_NOOP("Start Repeat") },
{ END_REPEAT, QT_TR_NOOP("End Repeat") },
{ END_START_REPEAT, QT_TR_NOOP("End-Start Repeat") },
};
for (unsigned i = 0; i < sizeof(t)/sizeof(*t); ++i) {
BarLine* b = new BarLine(gscore);
b->setSubtype(t[i].type);
sp->append(b, qApp->translate("barlines", t[i].name));
}
return sp;
}
void MuseScore::barMenu()
{
if (barPalette == 0) {
Palette* sp = new Palette();
sp->resize(300, 200);
barPalette = new PaletteScrollArea(sp, 0);
barPalette->setRestrictHeight(false);
barPalette->setWindowTitle(tr("MuseScore: Barlines"));
sp->setGrid(42, 38);
struct {
BarLineType type;
const char* name;
} t[] = {
{ NORMAL_BAR, QT_TR_NOOP("Normal") },
{ BROKEN_BAR, QT_TR_NOOP("Dashed") },
{ END_BAR, QT_TR_NOOP("End Bar") },
{ DOUBLE_BAR, QT_TR_NOOP("Double Bar") },
{ START_REPEAT, QT_TR_NOOP("Start Repeat") },
{ END_REPEAT, QT_TR_NOOP("End Repeat") },
{ END_START_REPEAT, QT_TR_NOOP("End-Start Repeat") },
};
for (unsigned i = 0; i < sizeof(t)/sizeof(*t); ++i) {
BarLine* b = new BarLine(gscore);
b->setHeight(4 * gscore->spatium());
b->setSubtype(t[i].type);
sp->append(b, tr(t[i].name));
}
}
barPalette->show();
barPalette->raise();
}
void InspectorBarLine::setElement()
{
InspectorElementBase::setElement();
BarLine* bl = toBarLine(inspector->element());
// enable / disable individual type combo items according to score and selected bar line status
bool bMultiStaff = bl->score()->nstaves() > 1;
BarLineType blt = bl->barLineType();
bool isRepeat = blt & (BarLineType::START_REPEAT | BarLineType::END_REPEAT | BarLineType::END_START_REPEAT);
const QStandardItemModel* model = qobject_cast<const QStandardItemModel*>(b.type->model());
int i = 0;
for (auto& k : BarLine::barLineTable) {
QStandardItem* item = model->item(i);
// if combo item is repeat type, should be disabled for multi-staff scores
if (k.type & (BarLineType::START_REPEAT | BarLineType::END_REPEAT | BarLineType::END_START_REPEAT)) {
// disable / enable
item->setFlags(bMultiStaff ?
item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled) :
item->flags() | (Qt::ItemFlags)(Qt::ItemIsSelectable|Qt::ItemIsEnabled) );
}
// if combo item is NOT repeat type, should be disabled if selected bar line is a repeat
else {
item->setFlags(isRepeat ?
item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled) :
item->flags() | (Qt::ItemFlags)(Qt::ItemIsSelectable|Qt::ItemIsEnabled) );
}
++i;
}
#if 0
blockSpanDataSignals(true);
manageSpanData();
blockSpanDataSignals(false);
#endif
}
void TestBarline::barline04()
{
Score* score = readScore(DIR + "barline04.mscx");
QVERIFY(score);
score->doLayout();
// 'go' to 5th measure
Measure* msr = score->firstMeasure();
for (int i=0; i < 4; i++)
msr = msr->nextMeasure();
// check span data of measure-initial start-repeat bar line
Segment* seg = msr->findSegment(SegmentType::StartRepeatBarLine, msr->tick());
QVERIFY2(seg != nullptr, "No SegStartRepeatBarLine segment in measure 5.");
BarLine* bar = static_cast<BarLine*>(seg->element(0));
QVERIFY2(bar != nullptr, "No start-repeat bar line in measure 5.");
score->undoChangeSingleBarLineSpan(bar, 2, 2, 6);
score->doLayout();
QVERIFY2(bar->span() == 2 && bar->spanFrom() == 2 && bar->spanTo() == 6,
"Wrong span data in start-repeat bar line of measure 5.");
// check start-repeat bar ine in second staff is gone
QVERIFY2(seg->element(1) == nullptr, "Extra start-repeat bar line in 2nd staff of measure 5.");
// QVERIFY(saveCompareScore(score, "barline04.mscx", DIR + "barline04-ref.mscx"));
delete score;
}
Element* BarLine::drop(const DropData& data)
{
Element* e = data.element;
int type = e->type();
if (type == BAR_LINE) {
BarLine* bl = static_cast<BarLine*>(e);
BarLineType st = bl->subtype();
if (st == subtype()) {
delete e;
return 0;
}
Measure* m = segment()->measure();
if (st == START_REPEAT) {
m = m->nextMeasure();
if (m == 0) {
delete e;
return 0;
}
}
m->drop(data);
}
else if (type == ARTICULATION) {
Articulation* atr = static_cast<Articulation*>(e);
atr->setParent(this);
atr->setTrack(track());
score()->select(atr, SELECT_SINGLE, 0);
score()->undoAddElement(atr);
}
return 0;
}
void dropNormalBarline(Element* e)
{
EditData dropData(0);
BarLine* barLine = new BarLine(e->score());
barLine->setBarLineType(BarLineType::NORMAL);
dropData.dropElement = barLine;
e->score()->startCmd();
e->drop(dropData);
e->score()->endCmd();
}
void InspectorBarLine::presetDefaultClicked()
{
BarLine* bl = toBarLine(inspector->element());
Score* score = bl->score();
score->startCmd();
bl->undoResetProperty(P_ID::BARLINE_SPAN);
bl->undoResetProperty(P_ID::BARLINE_SPAN_FROM);
bl->undoResetProperty(P_ID::BARLINE_SPAN_TO);
score->endCmd();
}
void InspectorBarLine::presetTick2Clicked()
{
BarLine* bl = toBarLine(inspector->element());
Score* score = bl->score();
score->startCmd();
bl->undoChangeProperty(P_ID::BARLINE_SPAN, false);
bl->undoChangeProperty(P_ID::BARLINE_SPAN_FROM, BARLINE_SPAN_TICK2_FROM);
bl->undoChangeProperty(P_ID::BARLINE_SPAN_TO, BARLINE_SPAN_TICK2_TO);
score->endCmd();
}
void InspectorBarLine::presetDefaultClicked()
{
Score* score = inspector->element()->score();
score->startCmd();
BarLine* bl;
for (Element* e : *inspector->el()) {
if (e->isBarLine()) {
bl = toBarLine(e);
bl->undoResetProperty(Pid::BARLINE_SPAN);
bl->undoResetProperty(Pid::BARLINE_SPAN_FROM);
bl->undoResetProperty(Pid::BARLINE_SPAN_TO);
}
}
score->endCmd();
}
void InspectorBarLine::presetTick2Clicked()
{
Score* score = inspector->element()->score();
score->startCmd();
BarLine* bl;
for (Element* e : *inspector->el()) {
if (e->isBarLine()) {
bl = toBarLine(e);
bl->undoChangeProperty(Pid::BARLINE_SPAN, false);
bl->undoChangeProperty(Pid::BARLINE_SPAN_FROM, BARLINE_SPAN_TICK2_FROM);
bl->undoChangeProperty(Pid::BARLINE_SPAN_TO, BARLINE_SPAN_TICK2_TO);
}
}
score->endCmd();
}
void TestBarline::barline06()
{
char msg[256];
Score* score = readScore(DIR + "barline06.mscx");
QVERIFY(score);
score->doLayout();
// scan each measure
Measure* msr = score->firstMeasure();
int msrNo = 1;
for (int i=0; i < 3; i++) {
// check measure endbarline type
sprintf(msg, "EndBarLineType not NORMAL in measure %d.", msrNo);
//TODO QVERIFY2(msr->endBarLineType() == BarLineType::NORMAL, msg);
// locate end-measure bar line segment
Segment* seg = msr->findSegment(SegmentType::EndBarLine, msr->tick()+msr->ticks());
sprintf(msg, "No SegEndBarLine in measure %d.", msr->no());
QVERIFY2(seg != nullptr, msg);
// check only i-th staff has custom bar line type
for (int j=0; j < 3; j++) {
BarLine* bar = static_cast<BarLine*>(seg->element(j*VOICES));
// if not the i-th staff, bar should be normal and not custom
if (j != i) {
sprintf(msg, "barline type NOT NORMAL or CUSTOM TYPE in staff %d of measure %d.", j+1, msrNo);
QVERIFY2(bar->barLineType() == BarLineType::NORMAL, msg);
// QVERIFY2(bar->customSubtype() == false, msg);
}
// in the i-th staff, the bar line should be of type DOUBLE and custom type should be true
else {
sprintf(msg, "No barline for staff %d in measure %d", j+1, msrNo);
QVERIFY2(bar != nullptr, msg);
sprintf(msg, "barline type NOT DOUBLE or NOT CUSTOM TYPE in staff %d of measure %d.", j+1, msrNo);
QVERIFY2(bar->barLineType() == BarLineType::DOUBLE, msg);
// QVERIFY2(bar->customSubtype() == true, msg);
}
}
msr = msr->nextMeasure();
msrNo++;
}
// QVERIFY(saveCompareScore(score, "barline06.mscx", DIR + "barline06-ref.mscx"));
delete score;
}
void InspectorBarLine::presetShort2Clicked()
{
BarLine* bl = toBarLine(inspector->element());
Score* score = bl->score();
score->startCmd();
bl->undoChangeProperty(P_ID::BARLINE_SPAN, false);
bl->undoChangeProperty(P_ID::BARLINE_SPAN_FROM, BARLINE_SPAN_SHORT2_FROM);
int shortDelta = bl->staff() ? (bl->staff()->lines(bl->tick()) - 5) * 2 : 0;
bl->undoChangeProperty(P_ID::BARLINE_SPAN_TO, BARLINE_SPAN_SHORT2_TO + shortDelta);
score->endCmd();
}
void InspectorBarLine::setAsStaffDefault()
{
BarLine* bl = toBarLine(inspector->element());
Staff* staff = bl->staff();
Score* score = bl->score();
score->startCmd();
staff->undoChangeProperty(Pid::STAFF_BARLINE_SPAN, bl->getProperty(Pid::BARLINE_SPAN));
staff->undoChangeProperty(Pid::STAFF_BARLINE_SPAN_FROM, bl->getProperty(Pid::BARLINE_SPAN_FROM));
staff->undoChangeProperty(Pid::STAFF_BARLINE_SPAN_TO, bl->getProperty(Pid::BARLINE_SPAN_TO));
if (bl->barLineType() == BarLineType::NORMAL)
bl->setGenerated(true);
score->endCmd();
}
void TestBarline::barline05()
{
Score* score = readScore(DIR + "barline05.mscx");
QVERIFY(score);
score->doLayout();
// 'go' to 4th measure
Measure* msr = score->firstMeasure();
for (int i=0; i < 3; i++)
msr = msr->nextMeasure();
// create and add a LineBreak element
LayoutBreak* lb = new LayoutBreak(score);
lb->setLayoutBreakType(LayoutBreak::Type::LINE);
lb->setTrack(-1); // system-level element
lb->setParent(msr);
score->undoAddElement(lb);
score->doLayout();
// check an end-repeat bar line has been created at the end of this measure and it is generated
Segment* seg = msr->findSegment(SegmentType::EndBarLine, msr->tick()+msr->ticks());
QVERIFY2(seg != nullptr, "No SegEndBarLine segment in measure 4.");
BarLine* bar = static_cast<BarLine*>(seg->element(0));
QVERIFY2(bar != nullptr, "No end-repeat barline in measure 4.");
QVERIFY2(bar->barLineType() == BarLineType::END_REPEAT, "Barline at measure 4 is not END-REPEAT");
QVERIFY2(bar->generated(), "End-repeat barline in measure 4 is non-generated.");
// // check an end-repeat bar line has been created at the beginning of the next measure and it is not generated
// check an end-repeat bar line has been created at the beginning of the next measure and it is generated
msr = msr->nextMeasure();
seg = msr->findSegment(SegmentType::StartRepeatBarLine, msr->tick());
QVERIFY2(seg != nullptr, "No SegStartRepeatBarLine segment in measure 5.");
bar = static_cast<BarLine*>(seg->element(0));
QVERIFY2(bar != nullptr, "No start-repeat barline in measure 5.");
QVERIFY2(bar->generated(), "Start-reapeat barline in measure 5 is not generated.");
// QVERIFY(saveCompareScore(score, "barline05.mscx", DIR + "barline05-ref.mscx"));
delete score;
}
void InspectorBarLine::presetShort2Clicked()
{
Score* score = inspector->element()->score();
score->startCmd();
BarLine* bl;
for (Element* e : *inspector->el()) {
if (e->isBarLine()) {
bl = toBarLine(e);
bl->undoChangeProperty(Pid::BARLINE_SPAN, false);
bl->undoChangeProperty(Pid::BARLINE_SPAN_FROM, BARLINE_SPAN_SHORT2_FROM);
int shortDelta = bl->staff() ? (bl->staff()->lines(bl->tick()) - 5) * 2 : 0;
bl->undoChangeProperty(Pid::BARLINE_SPAN_TO, BARLINE_SPAN_SHORT2_TO + shortDelta);
}
}
score->endCmd();
}
Palette* MuseScore::newBarLinePalette()
{
Palette* sp = new Palette;
sp->setName(qApp->translate("barlines", "Barlines"));
sp->setMag(0.8);
sp->setGrid(42, 38);
// bar line styles
struct {
BarLineType type;
const char* name;
} t[] = {
{ NORMAL_BAR, QT_TR_NOOP("Normal") },
{ BROKEN_BAR, QT_TR_NOOP("Dashed") },
{ DOTTED_BAR, QT_TR_NOOP("Dotted") },
{ END_BAR, QT_TR_NOOP("End Bar") },
{ DOUBLE_BAR, QT_TR_NOOP("Double Bar") },
{ START_REPEAT, QT_TR_NOOP("Start Repeat") },
{ END_REPEAT, QT_TR_NOOP("End Repeat") },
{ END_START_REPEAT, QT_TR_NOOP("End-Start Repeat") },
};
for (unsigned i = 0; i < sizeof(t)/sizeof(*t); ++i) {
BarLine* b = new BarLine(gscore);
b->setSubtype(t[i].type);
sp->append(b, qApp->translate("barlines", t[i].name));
}
// bar line spans
struct {
int from, to;
const char* name;
} span[] = {
{ -1, 1, QT_TR_NOOP("Tick 1") },
{ -2, 2, QT_TR_NOOP("Tick 2") },
{ 2, 6, QT_TR_NOOP("Short 1") },
{ 1, 7, QT_TR_NOOP("Short 2") },
};
for (unsigned i = 0; i < sizeof(span)/sizeof(*span); ++i) {
BarLine* b = new BarLine(gscore);
b->setSubtype(NORMAL_BAR);
b->setSpanFrom(span[i].from);
b->setSpanTo(span[i].to);
sp->append(b, qApp->translate("barlines", span[i].name));
}
return sp;
}
Palette* MuseScore::newBarLinePalette()
{
Palette* sp = new Palette;
sp->setName(QT_TRANSLATE_NOOP("Palette", "Barlines"));
sp->setMag(0.8);
sp->setGrid(42, 38);
// bar line styles
struct {
BarLineType type;
const char* name;
} t[] = {
{ BarLineType::NORMAL, QT_TRANSLATE_NOOP("Palette", "Normal") },
{ BarLineType::BROKEN, QT_TRANSLATE_NOOP("Palette", "Dashed") },
{ BarLineType::DOTTED, QT_TRANSLATE_NOOP("Palette", "Dotted") },
{ BarLineType::END, QT_TRANSLATE_NOOP("Palette", "End Bar") },
{ BarLineType::DOUBLE, QT_TRANSLATE_NOOP("Palette", "Double Bar") },
{ BarLineType::START_REPEAT, QT_TRANSLATE_NOOP("Palette", "Start Repeat") },
{ BarLineType::END_REPEAT, QT_TRANSLATE_NOOP("Palette", "End Repeat") },
{ BarLineType::END_START_REPEAT, QT_TRANSLATE_NOOP("Palette", "End-Start Repeat") },
};
for (unsigned i = 0; i < sizeof(t)/sizeof(*t); ++i) {
BarLine* b = new BarLine(gscore);
b->setBarLineType(t[i].type);
sp->append(b, t[i].name);
}
// bar line spans
struct {
int from, to;
const char* name;
} span[] = {
{ -1, 1, QT_TRANSLATE_NOOP("Palette", "Tick 1") },
{ -2, 2, QT_TRANSLATE_NOOP("Palette", "Tick 2") },
{ 2, 6, QT_TRANSLATE_NOOP("Palette", "Short 1") },
{ 1, 7, QT_TRANSLATE_NOOP("Palette", "Short 2") },
};
for (unsigned i = 0; i < sizeof(span)/sizeof(*span); ++i) {
BarLine* b = new BarLine(gscore);
b->setBarLineType(BarLineType::NORMAL);
b->setSpanFrom(span[i].from);
b->setSpanTo(span[i].to);
sp->append(b, span[i].name);
}
return sp;
}
bool BarLine::acceptDrop(const DropData& data) const
{
Element::Type type = data.element->type();
if (type == Element::Type::BAR_LINE) {
if (parent() && parent()->type() == Element::Type::SEGMENT)
return true;
if (parent() && parent()->type() == Element::Type::SYSTEM) {
BarLine* b = static_cast<BarLine*>(data.element);
return (b->barLineType() == BarLineType::BROKEN || b->barLineType() == BarLineType::DOTTED
|| b->barLineType() == BarLineType::NORMAL || b->barLineType() == BarLineType::DOUBLE
|| b->spanFrom() != 0 || b->spanTo() != DEFAULT_BARLINE_TO);
}
}
else {
return (type == Element::Type::ARTICULATION
&& parent()
&& parent()->type() == Element::Type::SEGMENT
&& static_cast<Segment*>(parent())->segmentType() == Segment::Type::EndBarLine);
}
return false;
}
bool BarLine::acceptDrop(MuseScoreView*, const QPointF&, Element* e) const
{
int type = e->type();
if (type == BAR_LINE) {
if (parent() && parent()->type() == SEGMENT)
return true;
if (parent() && parent()->type() == SYSTEM) {
BarLine* b = static_cast<BarLine*>(e);
return (b->barLineType() == BROKEN_BAR || b->barLineType() == DOTTED_BAR
|| b->barLineType() == NORMAL_BAR || b->barLineType() == DOUBLE_BAR
|| b->spanFrom() != 0 || b->spanTo() != DEFAULT_BARLINE_TO);
}
}
else {
return (type == ARTICULATION
&& parent()
&& parent()->type() == SEGMENT
&& static_cast<Segment*>(parent())->segmentType() == Segment::SegEndBarLine);
}
return false;
}
Palette* MuseScore::newBarLinePalette(bool basic)
{
Palette* sp = new Palette;
sp->setName(QT_TRANSLATE_NOOP("Palette", "Barlines"));
sp->setMag(0.8);
sp->setGrid(42, 38);
// bar line styles
for (unsigned i = 0; i < BarLine::barLineTableSize(); ++i) {
BarLine* b = new BarLine(gscore);
BarLineTableItem bti = BarLine::barLineTableItem(i);
b->setBarLineType(bti.type);
sp->append(b, qApp->translate("Palette", bti.name));
}
if (!basic) {
// bar line spans
struct {
int from, to;
const char* name;
} span[] = {
{ BARLINE_SPAN_TICK1_FROM, BARLINE_SPAN_TICK1_TO, QT_TRANSLATE_NOOP("Palette", "Tick 1 span") },
{ BARLINE_SPAN_TICK2_FROM, BARLINE_SPAN_TICK2_TO, QT_TRANSLATE_NOOP("Palette", "Tick 2 span") },
{ BARLINE_SPAN_SHORT1_FROM,BARLINE_SPAN_SHORT1_TO,QT_TRANSLATE_NOOP("Palette", "Short 1 span") },
{ BARLINE_SPAN_SHORT2_FROM,BARLINE_SPAN_SHORT2_TO,QT_TRANSLATE_NOOP("Palette", "Short 2 span") },
};
for (unsigned i = 0; i < sizeof(span)/sizeof(*span); ++i) {
BarLine* b = new BarLine(gscore);
b->setBarLineType(BarLineType::NORMAL);
b->setSpanFrom(span[i].from);
b->setSpanTo(span[i].to);
sp->append(b, qApp->translate("Palette", span[i].name));
}
}
return sp;
}
Staff* CScribeToNeoScribeXML::Scribe2MEIXMLStaff(const CScribeReaderVisitable& scribe_data, const scribe_part& partit, StaffGrp* staffgrp, const int i)
{
std::string staffnum("s");
staffnum += std::to_string(i); //autogenerate staff ids
//finish score definitions
//add staff definition for current part
//NB. look to alternatively embedding these in staffs
StaffDef* staffdef = new StaffDef;
//define staff from data
staffgrp->addChild(staffdef);
staffdef->addAttribute("id", staffnum);
staffdef->addAttribute("lines", std::to_string(partit.initial_staff_data.staff_lines));
staffdef->addAttribute("label", CScribeCodes::voice_labels[partit.voice_type].c_str());
//define clef from data
Clef* clef = new Clef;
staffdef->addChild(clef);
scribe_clef loc_clef;
loc_clef.clef_line = partit.initial_staff_data.clef_line;
loc_clef.clef = partit.initial_staff_data.clef;
//convert scribe-based clef position to mei
//int mei_clef_line = ((loc_clef.clef_line + 1)/2) - 1; = incorrect
int mei_clef_line = 1 + (loc_clef.clef_line-3)/2;
//4-line staves are numbered 3, 5, 7, 9 in scribe
//if (partit->staff_lines<=4) mei_clef_line -= (5 - partit->staff_lines);
clef->addAttribute("line", std::to_string(mei_clef_line)); //these need to be set for each staff/part
clef->addAttribute("shape", std::string(&(partit.initial_staff_data.clef),1).c_str()); //the first event in stored memory should be the initial clef
Staff* staff = new Staff;
staff->addAttribute("id", staffnum);
staff->addAttribute("source", partit.abbrev_ms);
//folio on which part appears
Pb* pb = new Pb; //new ELEMENT?
staff->addChild(pb);
pb->addAttribute("n", partit.folios);
//first staff on which part appears
Sb* sb = new Sb;
sb->addAttribute("n", "0"); //set to "0" since this isn't encoded in scribe; data will need to be enhanced later
staff->addChild(sb);
coloration_type current_color = coloration_type::full_black; // this needs to be better handled with a default coloration in a part
for (std::vector<scribe_row>::const_iterator rowit = partit.rows.begin(); rowit!=partit.rows.end(); rowit++)
{
if (rowit->is_comment) {
//check it this is the correct way to handle a comment
MeiCommentNode* comment = new MeiCommentNode;
comment->setValue(rowit->comment);
staff->addChild(comment);
//NB. syl can have a type (eg. initial) attribute and also encode color as <rend> child element
} else {
//syllable container (holds syllables, notes, neumes, and ligatures)
Syllable* syllable = new Syllable; //neumes.h
staff->addChild(syllable);
//add actual syllable if present
if (!rowit->syllable.empty()) {
Syl* syl = new Syl;
syl->setValue(rowit->syllable);
syllable->addChild(syl);
}
//extract events - notes, rests ligatures, uneumes and/or ligatures
for (std::vector<scribe_event>::const_iterator eventit = rowit->events.begin(); eventit!=rowit->events.end(); eventit++ )
{
current_color = eventit->local_coloration;
//use temp TiXML pointer which is either syllable, uneume/ineume or ligature - add notes to this, but make sure that uneume/inueme/ligature pointer is preinserted into syllable
//handle events for each row
code_t event_type = scribe_data.GetCodes()->get_code_type(eventit->code);//codes->get_code_type(eventit->code);
//foster parent will change roles according to child elements that need to be added
MeiElement* foster = syllable;
switch (event_type)
{
case code_t::ineume:
{
#ifdef IGNOREGAPS
Ineume* ineume = new Ineume;
//ineume->addAttribute("name", scribe_data.GetCodes()->code_to_name(eventit->code));
foster->addChild(ineume);
foster = ineume;
#else //this needs work, hence excluded
if (!eventit->preceding_gap || foster->getChildren().empty())
{
Ineume* ineume = new Ineume;
//ineume->addAttribute("name", scribe_data.GetCodes()->code_to_name(eventit->code));
foster->addChild(ineume);
foster = ineume;
}
else
{
MeiElement* lastNeume = foster->getChildren().back();
if (lastNeume->getName() == "ineume")
{
Ineume* newNeume = new Ineume(*dynamic_cast<Ineume*>(lastNeume));
/*for (std::vector<MeiElement*>::const_iterator child = lastNeume->getChildren().begin(); child!=lastNeume->getChildren().end(); child++ ) {
MeiElement* clone = new MeiElement(**child);
newNeume->addChild(clone);
}*/
foster->removeChild(lastNeume);
foster->addChild(newNeume);
//delete lastNeume;
foster = newNeume;
}
else
foster = lastNeume;
}
#endif
goto do_note;
break;
}
case code_t::uneume:
{
Uneume* uneume = new Uneume;
uneume->addAttribute("name", scribe_data.GetCodes()->code_to_name(eventit->code));
foster->addChild(uneume);
foster = uneume;
goto do_note;
break;
}
case code_t::ligature:
{
Ligature* ligature = new Ligature; //mensural.h
ligature->addAttribute("name", scribe_data.GetCodes()->code_to_name(eventit->code));
foster->addChild(ligature);
foster = ligature;
if (current_color!=coloration_type::full_black)
{
switch (current_color) {
case full_red:
ligature->addAttribute("color", "red");
break;
case void_red:
ligature->addAttribute("color", "red");
ligature->addAttribute("void", "true"); //this seems a sensible solution for this problem and a suitable additional attribute to the MEI description
break;
case void_black:
ligature->addAttribute("void", "true"); //**
break;
case full_blue:
ligature->addAttribute("color", "blue");
break;
default:
break;
}
}
//goto do_note;
//break;
}
case code_t::note:
do_note:
{
for (auto i = eventit->pitch_num.begin(); i!=eventit->pitch_num.end(); i++)
{
int note_count = 1;
MeiElement* temp_foster = foster;
//handle note attributes according to type
if ( foster->getName()=="ineume" )
{
Uneume* temp_uneume = new Uneume; //handle ineumes
//find uneume names
temp_uneume->addAttribute("name", CScribeReaderVisitable::get_ineume_part(eventit->code, i - eventit->pitch_num.begin(), note_count));
foster->addChild(temp_uneume);
temp_foster = temp_uneume; //allow notes to be children of uneume
} else if ((eventit->code=="B" || eventit->code=="V" || eventit->code=="L") && eventit->pitch_num.size()>1 && scribe_data.GetType()==chant && i!=eventit->pitch_num.begin()) //codes like virga and punctum may be followed by several pitch numbers, indicating a sequence of simple neumes
{
Uneume* temp_uneume = new Uneume;
temp_uneume->addAttribute("name", scribe_data.GetCodes()->code_to_name(eventit->code));
foster->getParent()->addChild(temp_uneume); //link to syllable element, not uneume!
temp_foster = temp_uneume;
}
//also handle ligatures
auto j = 0;
//insert note or notes for unneumes in ineumes
for (; j < note_count ; j++)
{
//convert note location to pitch name
// need to handle dots as element rather than attribute?
char pitch_name = loc_clef.get_pitch_name(*i);
int octave = loc_clef.get_octave(*i);
Note* note = new Note;
if (foster->getName()=="syllable")
{
note->addAttribute("dur", scribe_data.GetCodes()->code_to_name(eventit->code));
}
else if (foster->getName()=="ligature")
{
note->addAttribute("dur", scribe_data.get_ligature_part(eventit->code, j));
}
note->addAttribute("pname", std::string(&pitch_name,1));
note->addAttribute("oct", std::to_string(octave));
int note_loc = *i - 3; //3 is bottom line in Scribe, 0 in MEI
note->addAttribute("loc", std::to_string( note_loc ));
if (current_color!=coloration_type::full_black)
{
switch (current_color) {
case full_red:
note->addAttribute("color", "red");
break;
case void_red:
note->addAttribute("color", "red");
note->addAttribute("void", "true"); //this seems a sensible solution for this problem and a suitable additional attribute to the MEI description
break;
case void_black:
note->addAttribute("void", "true"); //**
break;
case full_blue:
note->addAttribute("color", "blue");
break;
default:
break;
}
}
temp_foster->addChild(note);
}
i+=j-1;
}
}
break;
//dot needs to be handled as a unique element in our extended definition
/*Stinson, 7 July 2013: Further notes on DOT
The code has two arguments: the first is the substantive position on the staff; the second refines that position up or down and is capable of five variants: 0 = exactly on the line or exactly in the middle of the space between the lines; -1 = 0.1 of the space between the lines below (or for +, above) the space or line; -2= 0.2 of the space below the normal position for that line or space; -3 = 0.3 below the normal position; -4 = 0.4 below the normal position.
Only values between 0 and 4 are permitted as the second argument as 5 would be the equivalent of having the dot on the next numbered line or space, e.g. '7 -5', if it were permitted, would be the same as '6 0'.*/
case code_t::dot:
{
Dot* dot = new Dot;
char pitch_name = loc_clef.get_pitch_name(eventit->pitch_num[0]);
int octave = loc_clef.get_octave(eventit->pitch_num[0]);
dot->addAttribute("ploc", std::string(&pitch_name,1));
dot->addAttribute("oloc", std::to_string(octave));
/*vo: records the vertical adjustment of a feature's programmatically-determined location in terms of staff interline distance; that is, in units of 1/2 the distance between adjacent staff lines. (MEI2013)*/
//only set for non-defult positions
if (eventit->pitch_num[1]!=0)
{
float v_pos = eventit->pitch_num[1]/10.0*2;
dot->addAttribute("vo", to_string_with_precision(v_pos,1));
}
foster->addChild(dot);
}
break;
case code_t::rest:
{
Rest* rest = new Rest;
foster->addChild(rest);
switch (*(eventit->code.c_str())) {
//rests of type 'R' has two associated pitch numbers from which we might infer the type
case generic_rest:
{
int end = eventit->pitch_num[0];
int start = eventit->pitch_num[1];
int rest_type = start-end;
switch (rest_type) {
case minim_rest:
rest->addAttribute("type", "minima");
break;
case semibreve_rest:
rest->addAttribute("type", "semibrevis");
break;
case breve_rest:
rest->addAttribute("type", "brevis");
break;
case long_rest:
rest->addAttribute("type", "longa imperfecta");
break;
case perf_long_rest:
rest->addAttribute("type", "long perfecta");
break;
default:
break;
}
char ploc = loc_clef.get_pitch_name(start);
rest->addAttribute("ploc", std::string(&ploc,1));
rest->addAttribute("oloc", std::to_string(loc_clef.get_octave(start)));
break;
//also process 'RSM', semiminim rest
}
//case semiminim_rest:
//rest->SetAttribute("type", "semiminim");
// break;
default:
rest->addAttribute("type", scribe_data.GetCodes()->code_to_name(eventit->code));
if (!eventit->pitch_num.empty()) {
char pitch_name = loc_clef.get_pitch_name(eventit->pitch_num[0]);
int octave = loc_clef.get_octave(eventit->pitch_num[0]);
rest->addAttribute("ploc", std::string(&pitch_name,1));
rest->addAttribute("oloc", std::to_string(octave));
}
break;
}
}
break;
// non-standard mensuration signs
case code_t::mensuration:
{
Mensur* mensuration_sign = new Mensur;
foster->addChild(mensuration_sign);
if (eventit->code == "MO" || eventit->code == "MC" || eventit->code == "MO." || eventit->code == "MC.")
{
char the_sign = eventit->code[1];
mensuration_sign->addAttribute("sign", std::string(&the_sign,1));
if (eventit->code.size()==3 && eventit->code[2]=='.') {
mensuration_sign->addAttribute("dot", "true");
}
//also able to set attribute 'orient' to reversed for reversed signs; and slash attribute for cut signs
}
if (eventit->code == ".D." || eventit->code == ".Q." || eventit->code == ".SI." || eventit->code == ".P." || eventit->code == ".N." || eventit->code == ".O." || eventit->code == ".I.") //also .SG.?
{
//these are wholly new to the MEI schema; the whole dot-letter-dot sign is encoded
mensuration_sign->addAttribute("sign", eventit->code);
}
break;
}
case code_t::barline:
{
BarLine* barline = new BarLine;
foster->addChild(barline);
if (eventit->code == "QBAR") {
barline->addAttribute("rend", "quarter"); //non-standard data type for rend.
}
if (eventit->code == "HBAR") {
barline->addAttribute("rend", "half");
}
if (eventit->code == "WBAR") {
barline->addAttribute("rend", "single");
}
if (eventit->code == "DBAR") {
barline->addAttribute("rend", "dbl");
}
//modern bar editorial - ignore?
if (eventit->code == "MBAR") {
barline->addAttribute("barplace", "takt");
barline->addAttribute("taktplace", std::string(9,1));
}
//also able to see rend attribute
break;
}
case code_t::clef:
{
//NB. old clefchange element superceded; clefGrp used for simultaneous clefs
loc_clef.clef_line = *(eventit->pitch_num.begin());
loc_clef.clef = *(eventit->code.c_str());
Clef* clef = new Clef;
clef->addAttribute("line", std::to_string( ((loc_clef.clef_line + 1)/2) - 1));
clef->addAttribute("shape", std::string(&(loc_clef.clef),1).c_str());
foster->addChild(clef);
break;
}
//The MEI accidental names are not used: diesis, b-rotundum and b-quadratum are. Other variants may be added. All ms accidentials in Scribe (as they should be in NeoScribe) are independent elements
case code_t::accidental:
{
Accid* accid = new Accid;
accid->addAttribute("accidental", scribe_data.GetCodes()->code_to_name(eventit->code));
if (!eventit->pitch_num.empty()) {
char ploc = loc_clef.get_pitch_name(eventit->pitch_num[0]);
int oloc = loc_clef.get_octave(eventit->pitch_num[0]);
accid->addAttribute("ploc", std::string(&ploc,1));
accid->addAttribute("oloc", std::to_string(oloc));
}
foster->addChild(accid);
break;
}
case code_t::other:
//lucunae
default:
break;
}
}
}
}
return staff;
}
Element* BarLine::drop(const DropData& data)
{
Element* e = data.element;
int type = e->type();
if (type == BAR_LINE) {
BarLine* bl = static_cast<BarLine*>(e);
BarLineType st = bl->barLineType();
// if no change in subtype or no change in span, do nothing
if (st == barLineType() && bl->spanFrom() == 0 && bl->spanTo() == DEFAULT_BARLINE_TO) {
delete e;
return 0;
}
// system left-side bar line
if (parent()->type() == SYSTEM) {
BarLine* b = static_cast<System*>(parent())->barLine();
score()->undoChangeProperty(b, P_SUBTYPE, int(bl->barLineType()));
delete e;
return 0;
}
// check if the new property can apply to this single bar line
bool oldRepeat = (barLineType() == START_REPEAT || barLineType() == END_REPEAT
|| barLineType() == END_START_REPEAT);
bool newRepeat = (bl->barLineType() == START_REPEAT || bl->barLineType() == END_REPEAT
|| bl->barLineType() == END_START_REPEAT);
// if repeats are not involved or drop refers to span rather than subtype =>
// single bar line drop
if( (!oldRepeat && !newRepeat) || (bl->spanFrom() != 0 || bl->spanTo() != DEFAULT_BARLINE_TO) ) {
// if drop refers to span, update this bar line span
if(bl->spanFrom() != 0 || bl->spanTo() != DEFAULT_BARLINE_TO) {
// if dropped spanFrom or spanTo are below the middle of standard staff (5 lines)
// adjust to the number of syaff lines
int bottomSpan = (staff()->lines()-1) * 2;
int spanFrom = bl->spanFrom() > 4 ? bottomSpan - (8 - bl->spanFrom()) : bl->spanFrom();
int spanTo = bl->spanTo() > 4 ? bottomSpan - (8 - bl->spanTo()) : bl->spanTo();
score()->undoChangeSingleBarLineSpan(this, 1, spanFrom, spanTo);
}
// if drop refer to subtype, update this bar line subtype
else {
score()->undoChangeProperty(this, P_SUBTYPE, int(bl->barLineType()));
// setCustomSubtype(true);
}
delete e;
return 0;
}
// drop applies to all bar lines of the measure
Measure* m = static_cast<Segment*>(parent())->measure();
if (st == START_REPEAT) {
m = m->nextMeasure();
if (m == 0) {
delete e;
return 0;
}
}
m->drop(data);
}
else if (type == ARTICULATION) {
Articulation* atr = static_cast<Articulation*>(e);
atr->setParent(this);
atr->setTrack(track());
score()->undoAddElement(atr);
return atr;
}
return 0;
}
void ContinuousPanel::draw(QPainter& painter, const QList<Element*>& el) {
painter.save();
painter.setRenderHint(QPainter::Antialiasing, preferences.antialiasedDrawing);
painter.setRenderHint(QPainter::TextAntialiasing, true);
// Draw colored rectangle
painter.setClipping(false);
QPointF pos(_offsetPanel, 0);
painter.translate(pos);
QPen pen;
pen.setWidthF(0.0);
pen.setStyle(Qt::NoPen);
painter.setPen(pen);
painter.setBrush(preferences.fgColor);
QRectF bg(_rect);
bg.setWidth(_widthClef + _widthKeySig + _widthTimeSig + _leftMarginTotal + _panelRightPadding);
QPixmap* fgPixmap = _sv->fgPixmap();
if (fgPixmap == 0 || fgPixmap->isNull())
painter.fillRect(bg, preferences.fgColor);
else {
painter.setMatrixEnabled(false);
painter.drawTiledPixmap(bg, *fgPixmap, bg.topLeft()
- QPoint(lrint(_sv->matrix().dx()), lrint(_sv->matrix().dy())));
painter.setMatrixEnabled(true);
}
painter.setClipRect(_rect);
painter.setClipping(true);
QColor color(MScore::layoutBreakColor);
// Draw measure text number
QString text = _mmRestCount ? QString("#%1-%2").arg(_currentMeasureNo+1).arg(_currentMeasureNo+_mmRestCount) : QString("#%1").arg(_currentMeasureNo+1);
Text* newElement = new Text(_score);
newElement->setTextStyleType(TextStyleType::DEFAULT);
newElement->setFlag(ElementFlag::MOVABLE, false);
newElement->setXmlText(text);
newElement->textStyle().setFamily("FreeSans");
newElement->textStyle().setSizeIsSpatiumDependent(true);
newElement->setColor(color);
newElement->sameLayout();
pos = QPointF(_score->styleP(StyleIdx::clefLeftMargin) + _widthClef, _y + newElement->height());
painter.translate(pos);
newElement->draw(&painter);
pos += QPointF(_offsetPanel, 0);
painter.translate(-pos);
delete newElement;
// This second pass draws the elements spaced evently using the width of the largest element
for (const Element* e : el) {
e->itemDiscovered = 0;
if (!e->visible()) {
if (_score->printing() || !_score->showInvisible())
continue;
}
if (e->type() == Element::Type::STAFF_LINES) {
Staff* currentStaff = _score->staff(e->staffIdx());
Segment* parent = _score->tick2segmentMM(_currentMeasureTick);
pos = QPointF (_offsetPanel, e->pagePos().y());
painter.translate(pos);
// Draw staff lines
StaffLines* newStaffLines = static_cast<StaffLines*>(e->clone());
newStaffLines->setWidth(bg.width());
newStaffLines->setParent(parent);
newStaffLines->setTrack(e->track());
newStaffLines->layout();
newStaffLines->setColor(color);
newStaffLines->draw(&painter);
delete newStaffLines;
// Draw barline
BarLine* newBarLine = new BarLine(_score);
newBarLine->setBarLineType(BarLineType::NORMAL);
newBarLine->setParent(parent);
newBarLine->setTrack(e->track());
newBarLine->setSpan(currentStaff->barLineSpan());
newBarLine->setSpanFrom(currentStaff->barLineFrom());
newBarLine->setSpanTo(currentStaff->barLineTo());
newBarLine->layout();
newBarLine->setColor(color);
newBarLine->draw(&painter);
delete newBarLine;
// Draw the current staff name
QList<StaffName>& staffNamesLong = currentStaff->part()->instrument()->longNames();
QString staffName = staffNamesLong.isEmpty() ? " " : staffNamesLong[0].name();
if (staffName == "") {
QList<StaffName>& staffNamesShort = currentStaff->part()->instrument()->shortNames();
staffName = staffNamesShort.isEmpty() ? "" : staffNamesShort[0].name();
}
Text* newName = new Text(_score);
newName->setXmlText(staffName);
newName->setParent(parent);
newName->setTrack(e->track());
newName->setColor(color);
newName->textStyle().setFamily("FreeSans");
newName->textStyle().setSizeIsSpatiumDependent(true);
newName->layout();
newName->setPlainText(newName->plainText());
newName->layout();
if (currentStaff->part()->staff(0) == currentStaff) {
double _spatium = _score->spatium();
pos = QPointF (_score->styleP(StyleIdx::clefLeftMargin) + _widthClef, 0 - _spatium * 2);
painter.translate(pos);
newName->draw(&painter);
painter.translate(-pos);
}
delete newName;
// Draw the current Clef
Clef* newClef = new Clef(_score);
ClefType currentClef = currentStaff->clef(_currentMeasureTick);
newClef->setClefType(currentClef);
newClef->setParent(parent);
newClef->setTrack(e->track());
newClef->setColor(color);
newClef->layout();
pos = QPointF(_score->styleP(StyleIdx::clefLeftMargin), 0);
painter.translate(pos);
newClef->draw(&painter);
pos = QPointF(_widthClef,0);
painter.translate(pos);
delete newClef;
// Draw the current KeySignature
KeySig* newKs = new KeySig(_score);
KeySigEvent currentKeySigEvent = currentStaff->keySigEvent(_currentMeasureTick);
newKs->setKeySigEvent(currentKeySigEvent);
// The Parent and the track must be set to have the key signature layout adjusted to different clefs
// This also adds naturals to the key signature (if set in the score style)
newKs->setParent(parent);
newKs->setTrack(e->track());
newKs->setColor(color);
newKs->setHideNaturals(true);
pos = QPointF(_score->styleP(StyleIdx::keysigLeftMargin),0);
painter.translate(pos);
newKs->layout();
newKs->draw(&painter);
delete newKs;
pos = QPointF(_widthKeySig + _xPosTimeSig, 0);
painter.translate(pos);
// Draw the current TimeSignature
TimeSig* newTs = new TimeSig(_score);
// Try to get local time signature, if not, get the current measure one
TimeSig* currentTimeSig = currentStaff->timeSig(_currentMeasureTick);
if (currentTimeSig) {
newTs->setFrom(currentTimeSig);
newTs->setParent(parent);
newTs->setTrack(e->track());
newTs->setColor(color);
newTs->layout();
pos = QPointF(_score->styleP(StyleIdx::timesigLeftMargin),0);
painter.translate(pos);
newTs->draw(&painter);
delete newTs;
}
pos = QPointF(_offsetPanel + _widthClef + _widthKeySig + _xPosTimeSig + _leftMarginTotal, e->pagePos().y());
painter.translate(-pos);
}
}
painter.restore();
}
void System::layout(qreal xo1)
{
if (isVbox()) // ignore vbox
return;
static const Spatium instrumentNameOffset(1.0);
int nstaves = _staves.size();
if (nstaves != score()->nstaves())
qDebug("System::layout: nstaves %d != %d", nstaves, score()->nstaves());
//---------------------------------------------------
// find x position of staves
// create brackets
//---------------------------------------------------
qreal xoff2 = 0.0; // x offset for instrument name
int bracketLevels = 0;
for (int idx = 0; idx < nstaves; ++idx)
bracketLevels = qMax(bracketLevels, score()->staff(idx)->bracketLevels());
qreal bracketWidth[bracketLevels];
for (int i = 0; i < bracketLevels; ++i)
bracketWidth[i] = 0.0;
QList<Bracket*> bl = _brackets;
_brackets.clear();
for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) {
Staff* s = score()->staff(staffIdx);
for (int i = 0; i < bracketLevels; ++i) {
if (s->bracket(i) == BracketType::NO_BRACKET)
continue;
int firstStaff = staffIdx;
int lastStaff = staffIdx + s->bracketSpan(i) - 1;
if (lastStaff >= nstaves)
lastStaff = nstaves - 1;
for (; firstStaff <= lastStaff; ++firstStaff) {
if (score()->staff(firstStaff)->show())
break;
}
for (; lastStaff >= firstStaff; --lastStaff) {
if (score()->staff(lastStaff)->show())
break;
}
int span = lastStaff - firstStaff + 1;
//
// do not show bracket if it only spans one
// system due to some invisible staves
//
if ((span > 1) || (s->bracketSpan(i) == span)) {
//
// this bracket is visible
//
Bracket* b = 0;
int track = staffIdx * VOICES;
for (int k = 0; k < bl.size(); ++k) {
if (bl[k]->track() == track && bl[k]->level() == i) {
b = bl.takeAt(k);
break;
}
}
if (b == 0) {
b = new Bracket(score());
b->setGenerated(true);
b->setParent(this);
b->setTrack(track);
b->setLevel(i);
b->setBracketType(s->bracket(i));
b->setSpan(s->bracketSpan(i));
score()->undoAddElement(b);
}
else
_brackets.append(b);
b->setFirstStaff(firstStaff);
b->setLastStaff(lastStaff);
bracketWidth[i] = qMax(bracketWidth[i], b->width());
}
}
if (!s->show())
continue;
for (InstrumentName* t : _staves[staffIdx]->instrumentNames) {
t->layout();
qreal w = t->width() + point(instrumentNameOffset);
if (w > xoff2)
xoff2 = w;
}
}
for (Bracket* b : bl)
score()->undoRemoveElement(b);
//---------------------------------------------------
// layout SysStaff and StaffLines
//---------------------------------------------------
// xoff2 += xo1;
_leftMargin = xoff2;
qreal bd = point(score()->styleS(StyleIdx::bracketDistance));
if ( _brackets.size() > 0) {
for (int i = 0; i < bracketLevels; ++i)
_leftMargin += bracketWidth[i] + bd;
}
for (int staffIdx = 0; staffIdx < nstaves; ++staffIdx) {
SysStaff* s = _staves[staffIdx];
Staff* staff = score()->staff(staffIdx);
if (!staff->show() || !s->show()) {
s->setbbox(QRectF());
continue;
}
qreal staffMag = staff->mag();
qreal h;
if (staff->lines() == 1)
h = 2;
else
h = (staff->lines()-1) * staff->lineDistance();
h = h * staffMag * spatium();
s->bbox().setRect(_leftMargin + xo1, 0.0, 0.0, h);
}
if ((nstaves > 1 && score()->styleB(StyleIdx::startBarlineMultiple)) || (nstaves <= 1 && score()->styleB(StyleIdx::startBarlineSingle))) {
if (_barLine == 0) {
BarLine* bl = new BarLine(score());
bl->setParent(this);
bl->setTrack(0);
bl->setGenerated(true);
score()->undoAddElement(bl);
}
}
else if (_barLine)
score()->undoRemoveElement(_barLine);
if (_barLine)
_barLine->rxpos() = _leftMargin + xo1;
//---------------------------------------------------
// layout brackets
//---------------------------------------------------
for (Bracket* b : _brackets) {
qreal xo = -xo1;
for (const Bracket* b2 : _brackets) {
if (b->level() > b2->level() &&
((b->firstStaff() >= b2->firstStaff() && b->firstStaff() <= b2->lastStaff()) ||
(b->lastStaff() >= b2->firstStaff() && b->lastStaff() <= b2->lastStaff())))
xo += b2->width() + bd;
}
b->rxpos() = _leftMargin - xo - b->width();
}
//---------------------------------------------------
// layout instrument names x position
//---------------------------------------------------
int idx = 0;
for (const Part* p : score()->parts()) {
SysStaff* s = staff(idx);
if (s->show() && p->show()) {
for (InstrumentName* t : s->instrumentNames) {
switch (t->textStyle().align() & AlignmentFlags::HMASK) {
case int(AlignmentFlags::LEFT):
t->rxpos() = 0;
break;
case int(AlignmentFlags::HCENTER):
t->rxpos() = (xoff2 - point(instrumentNameOffset) + xo1) * .5;
break;
case int(AlignmentFlags::RIGHT):
default:
t->rxpos() = xoff2 - point(instrumentNameOffset) + xo1;
break;
}
t->rxpos() += t->textStyle().offset(t->spatium()).x();
}
}
idx += p->nstaves();
}
}
Element* ChordRest::drop(const DropData& data)
{
Element* e = data.element;
Measure* m = measure();
switch (e->type()) {
case Element::Type::BREATH:
{
Breath* b = static_cast<Breath*>(e);
b->setTrack(staffIdx() * VOICES);
// TODO: insert automatically in all staves?
Segment* seg = m->undoGetSegment(Segment::Type::Breath, tick());
b->setParent(seg);
score()->undoAddElement(b);
}
return e;
case Element::Type::BAR_LINE:
{
BarLine* bl = static_cast<BarLine*>(e);
bl->setTrack(staffIdx() * VOICES);
if (tick() == m->tick())
return m->drop(data);
Segment* seg = m->undoGetSegment(Segment::Type::BarLine, tick());
bl->setParent(seg);
score()->undoAddElement(bl);
}
return e;
case Element::Type::CLEF:
score()->cmdInsertClef(static_cast<Clef*>(e), this);
break;
case Element::Type::TEMPO_TEXT:
{
TempoText* tt = static_cast<TempoText*>(e);
tt->setParent(segment());
TextStyleType st = tt->textStyleType();
tt->setTextStyleType(st);
score()->undoAddElement(tt);
}
return e;
case Element::Type::DYNAMIC:
{
Dynamic* d = static_cast<Dynamic*>(e);
d->setTrack(track());
TextStyleType st = d->textStyleType();
d->setTextStyleType(st);
d->setParent(segment());
score()->undoAddElement(d);
}
return e;
case Element::Type::FRET_DIAGRAM:
case Element::Type::SYMBOL:
e->setTrack(track());
e->setParent(segment());
score()->undoAddElement(e);
return e;
case Element::Type::NOTE:
{
Note* note = static_cast<Note*>(e);
NoteVal nval;
nval.pitch = note->pitch();
nval.headGroup = note->headGroup();
nval.fret = note->fret();
nval.string = note->string();
score()->setNoteRest(segment(), track(), nval, data.duration, MScore::Direction::AUTO);
delete e;
}
break;
case Element::Type::HARMONY:
static_cast<Harmony*>(e)->render();
// fall through
case Element::Type::TEXT:
case Element::Type::STAFF_TEXT:
case Element::Type::STAFF_STATE:
case Element::Type::INSTRUMENT_CHANGE:
case Element::Type::REHEARSAL_MARK:
e->setParent(segment());
e->setTrack((track() / VOICES) * VOICES);
{
Text* f = static_cast<Text*>(e);
TextStyleType st = f->textStyleType();
if (st >= TextStyleType::DEFAULT)
f->setTextStyleType(st);
}
score()->undoAddElement(e);
return e;
case Element::Type::FIGURED_BASS:
{
bool bNew;
FiguredBass * fb = static_cast<FiguredBass *>(e);
fb->setParent( segment() );
fb->setTrack( (track() / VOICES) * VOICES );
fb->setTicks( duration().ticks() );
fb->setOnNote(true);
FiguredBass::addFiguredBassToSegment(segment(),
fb->track(), fb->ticks(), &bNew);
if (bNew)
score()->undoAddElement(e);
return e;
}
case Element::Type::IMAGE:
e->setParent(segment());
score()->undoAddElement(e);
return e;
case Element::Type::ICON:
{
switch(static_cast<Icon*>(e)->iconType()) {
case IconType::SBEAM:
score()->undoChangeProperty(this, P_ID::BEAM_MODE, int(Beam::Mode::BEGIN));
break;
case IconType::MBEAM:
score()->undoChangeProperty(this, P_ID::BEAM_MODE, int(Beam::Mode::MID));
break;
case IconType::NBEAM:
score()->undoChangeProperty(this, P_ID::BEAM_MODE, int(Beam::Mode::NONE));
break;
case IconType::BEAM32:
score()->undoChangeProperty(this, P_ID::BEAM_MODE, int(Beam::Mode::BEGIN32));
break;
case IconType::BEAM64:
score()->undoChangeProperty(this, P_ID::BEAM_MODE, int(Beam::Mode::BEGIN64));
break;
case IconType::AUTOBEAM:
score()->undoChangeProperty(this, P_ID::BEAM_MODE, int(Beam::Mode::AUTO));
break;
default:
break;
}
}
delete e;
break;
default:
qDebug("cannot drop %s", e->name());
delete e;
return 0;
}
return 0;
}
void MuseScore::populatePalette()
{
//-----------------------------------
// notes
//-----------------------------------
Palette* notePalette = new Palette;
notePalette->setName(tr("Grace Notes"));
notePalette->setGrid(32, 40);
notePalette->setDrawGrid(true);
static const IconAction gna[] = {
{ ICON_ACCIACCATURA, "acciaccatura" },
{ ICON_APPOGGIATURA, "appoggiatura" },
{ ICON_GRACE4, "grace4" },
{ ICON_GRACE16, "grace16" },
{ ICON_GRACE32, "grace32" },
{ -1, "" }
};
populateIconPalette(notePalette, gna);
paletteBox->addPalette(notePalette);
//-----------------------------------
// clefs
//-----------------------------------
Palette* sp = new Palette;
sp->setName(tr("Clefs"));
sp->setMag(0.8);
sp->setGrid(33, 60);
sp->setYOffset(1.0);
static const ClefType clefs[21] = {
CLEF_G, CLEF_G1, CLEF_G2, CLEF_G3, CLEF_G4,
CLEF_C1, CLEF_C2, CLEF_C3, CLEF_C4, CLEF_C5,
CLEF_F, CLEF_F_8VA, CLEF_F_15MA, CLEF_F8, CLEF_F15, CLEF_F_B, CLEF_F_C,
CLEF_PERC, CLEF_TAB, CLEF_TAB2, CLEF_PERC2
};
for (int i = 0; i < 20; ++i) {
ClefType j = clefs[i];
Clef* k = new ::Clef(gscore);
k->setClefType(ClefTypeList(j, j));
sp->append(k, qApp->translate("clefTable", clefTable[j].name));
}
paletteBox->addPalette(sp);
//-----------------------------------
// key signatures
//-----------------------------------
sp = newKeySigPalette();
paletteBox->addPalette(sp);
//-----------------------------------
// Time
//-----------------------------------
sp = new Palette;
sp->setName(tr("Time Signatures"));
sp->setMag(.8);
sp->setGrid(42, 38);
TimeSig* ts;
ts = new TimeSig(gscore);
ts->setSig(2, 2);
sp->append(ts, "2/2");
sp->append(new TimeSig(gscore, 2, 4), "2/4");
sp->append(new TimeSig(gscore, 3, 4), "3/4");
sp->append(new TimeSig(gscore, 4, 4), "4/4");
sp->append(new TimeSig(gscore, 5, 4), "5/4");
sp->append(new TimeSig(gscore, 6, 4), "6/4");
sp->append(new TimeSig(gscore, 3, 8), "3/8");
sp->append(new TimeSig(gscore, 6, 8), "6/8");
sp->append(new TimeSig(gscore, 9, 8), "9/8");
sp->append(new TimeSig(gscore, 12, 8), "12/8");
sp->append(new TimeSig(gscore, TSIG_FOUR_FOUR), tr("4/4 common time"));
sp->append(new TimeSig(gscore, TSIG_ALLA_BREVE), tr("2/2 alla breve"));
paletteBox->addPalette(sp);
//-----------------------------------
// Bar Lines
//-----------------------------------
sp = new Palette;
sp->setName(tr("Barlines"));
sp->setMag(0.8);
sp->setGrid(42, 38);
struct {
BarLineType type;
const char* name;
} t[] = {
{ NORMAL_BAR, QT_TR_NOOP("Normal") },
{ BROKEN_BAR, QT_TR_NOOP("Dashed") },
{ END_BAR, QT_TR_NOOP("End Bar") },
{ DOUBLE_BAR, QT_TR_NOOP("Double Bar") },
{ START_REPEAT, QT_TR_NOOP("Start Repeat") },
{ END_REPEAT, QT_TR_NOOP("End Repeat") },
{ END_START_REPEAT, QT_TR_NOOP("End-Start Repeat") },
};
for (unsigned i = 0; i < sizeof(t)/sizeof(*t); ++i) {
BarLine* b = new BarLine(gscore);
b->setSubtype(t[i].type);
sp->append(b, tr(t[i].name));
}
paletteBox->addPalette(sp);
//-----------------------------------
// Lines
//-----------------------------------
sp = new Palette;
sp->setName(tr("Lines"));
sp->setMag(.8);
sp->setGrid(82, 23);
Slur* slur = new Slur(gscore);
slur->setId(0);
sp->append(slur, tr("Slur"));
Hairpin* gabel0 = new Hairpin(gscore);
gabel0->setSubtype(0);
sp->append(gabel0, tr("Crescendo"));
Hairpin* gabel1 = new Hairpin(gscore);
gabel1->setSubtype(1);
sp->append(gabel1, tr("Diminuendo"));
Volta* volta = new Volta(gscore);
volta->setSubtype(VOLTA_CLOSED);
volta->setText("1.");
QList<int> il;
il.append(1);
volta->setEndings(il);
sp->append(volta, tr("Prima volta"));
volta = new Volta(gscore);
volta->setSubtype(VOLTA_CLOSED);
volta->setText("2.");
il.clear();
il.append(2);
volta->setEndings(il);
sp->append(volta, tr("Seconda volta"));
volta = new Volta(gscore);
volta->setSubtype(VOLTA_CLOSED);
volta->setText("3.");
il.clear();
il.append(3);
volta->setEndings(il);
sp->append(volta, tr("Terza volta"));
volta = new Volta(gscore);
volta->setSubtype(VOLTA_OPEN);
volta->setText("2.");
il.clear();
il.append(2);
volta->setEndings(il);
sp->append(volta, tr("Seconda volta 2"));
Ottava* ottava = new Ottava(gscore);
ottava->setSubtype(0);
sp->append(ottava, tr("8va"));
ottava = new Ottava(gscore);
ottava->setSubtype(1);
sp->append(ottava, tr("15ma"));
ottava = new Ottava(gscore);
ottava->setSubtype(2);
sp->append(ottava, tr("8vb"));
ottava = new Ottava(gscore);
ottava->setSubtype(3);
sp->append(ottava, tr("15mb"));
Pedal* pedal = new Pedal(gscore);
//pedal->setLen(l);
sp->append(pedal, tr("Pedal"));
pedal = new Pedal(gscore);
//pedal->setLen(l);
pedal->setEndHookType(HOOK_45);
sp->append(pedal, tr("Pedal"));
pedal = new Pedal(gscore);
//pedal->setLen(l);
pedal->setBeginSymbol(-1);
pedal->setBeginHook(true);
pedal->setBeginHookType(HOOK_45);
pedal->setEndHookType(HOOK_45);
sp->append(pedal, tr("Pedal"));
pedal = new Pedal(gscore);
//pedal->setLen(l);
pedal->setBeginSymbol(-1);
pedal->setBeginHook(true);
pedal->setBeginHookType(HOOK_45);
sp->append(pedal, tr("Pedal"));
Trill* trill = new Trill(gscore);
sp->append(trill, tr("Trill line"));
trill = new Trill(gscore);
trill->setSubtype("upprall");
sp->append(trill, tr("Upprall line"));
trill = new Trill(gscore);
trill->setSubtype("downprall");
sp->append(trill, tr("Downprall line"));
trill = new Trill(gscore);
trill->setSubtype("prallprall");
sp->append(trill, tr("Prallprall line"));
TextLine* textLine = new TextLine(gscore);
textLine->setBeginText("VII");
textLine->setEndHook(true);
sp->append(textLine, tr("Text line"));
TextLine* line = new TextLine(gscore);
line->setDiagonal(true);
sp->append(line, tr("Line"));
paletteBox->addPalette(sp);
//-----------------------------------
// Arpeggio && Glissando
//-----------------------------------
sp = new Palette();
sp->setName(tr("Arpeggio && Glissando"));
sp->setGrid(27, 60);
for (int i = 0; i < 4; ++i) {
Arpeggio* a = new Arpeggio(gscore);
a->setSubtype(ArpeggioType(i));
sp->append(a, tr("Arpeggio"));
}
for (int i = 0; i < 2; ++i) {
Glissando* a = new Glissando(gscore);
a->setSubtype(i);
sp->append(a, tr("Glissando"));
}
paletteBox->addPalette(sp);
//-----------------------------------
// Symbols: Breath
//-----------------------------------
sp = new Palette();
sp->setName(tr("Breath && Pauses"));
sp->setGrid(42, 40);
for (int i = 0; i < 4; ++i) {
Breath* a = new Breath(gscore);
a->setSubtype(i);
if (i < 2)
sp->append(a, tr("Breath"));
else
sp->append(a, tr("Caesura"));
}
paletteBox->addPalette(sp);
//-----------------------------------
// Brackets
//-----------------------------------
sp = new Palette;
sp->setName(tr("Brackets"));
sp->setMag(0.7);
sp->setGrid(42, 60);
Bracket* b1 = new Bracket(gscore);
b1->setSubtype(BRACKET_NORMAL);
Bracket* b2 = new Bracket(gscore);
b2->setSubtype(BRACKET_AKKOLADE);
// b1->setHeight(_spatium * 7);
// b2->setHeight(_spatium * 7);
sp->append(b1, tr("Square bracket"));
sp->append(b2, tr("Curly bracket"));
paletteBox->addPalette(sp);
//-----------------------------------
// Attributes, Ornaments
//-----------------------------------
sp = new Palette;
sp->setName(tr("Articulations && Ornaments"));
sp->setGrid(42, 25);
for (int i = 0; i < ARTICULATIONS; ++i) {
Articulation* s = new Articulation(gscore);
s->setSubtype(ArticulationType(i));
sp->append(s, qApp->translate("articulation", qPrintable(s->subtypeUserName())));
}
Bend* bend = new Bend(gscore);
bend->points().append(PitchValue(0, 0, false));
bend->points().append(PitchValue(15, 100, false));
bend->points().append(PitchValue(60, 100, false));
sp->append(bend, qApp->translate("articulation", "Bend"));
TremoloBar* tb = new TremoloBar(gscore);
tb->points().append(PitchValue(0, 0, false)); // "Dip"
tb->points().append(PitchValue(30, -100, false));
tb->points().append(PitchValue(60, 0, false));
sp->append(tb, qApp->translate("articulation", "Tremolo Bar"));
paletteBox->addPalette(sp);
//-----------------------------------
// Accidentals
//-----------------------------------
sp = newAccidentalsPalette();
paletteBox->addPalette(sp);
//-----------------------------------
// Dynamics
//-----------------------------------
sp = new Palette;
sp->setName(tr("Dynamics"));
sp->setMag(.8);
sp->setGrid(42, 28);
static const char* dynS[] = {
"ppp", "pp", "p", "mp", "mf", "f", "ff", "fff"
};
for (unsigned i = 0; i < sizeof(dynS)/sizeof(*dynS); ++i) {
Dynamic* dynamic = new Dynamic(gscore);
dynamic->setSubtype(dynS[i]);
sp->append(dynamic, dynamic->subtypeName());
}
paletteBox->addPalette(sp);
//-----------------------------------
// Fingering
//-----------------------------------
sp = new Palette;
sp->setName(tr("Fingering"));
sp->setMag(1.5);
sp->setGrid(28, 30);
sp->setDrawGrid(true);
const char finger[] = "012345pimac";
for (unsigned i = 0; i < strlen(finger); ++i) {
Fingering* f = new Fingering(gscore);
f->setText(QString(finger[i]));
sp->append(f, tr("Fingering %1").arg(finger[i]));
}
const char stringnumber[] = "0123456";
for (unsigned i = 0; i < strlen(stringnumber); ++i) {
Fingering* f = new Fingering(gscore);
f->setTextStyle(TEXT_STYLE_STRING_NUMBER);
f->setText(QString(stringnumber[i]));
sp->append(f, tr("String number %1").arg(stringnumber[i]));
}
Symbol* symbol = new Symbol(gscore, thumbSym);
sp->append(symbol, tr("Thumb"));
paletteBox->addPalette(sp);
//-----------------------------------
// Noteheads
//-----------------------------------
sp = new Palette;
sp->setName(tr("Note Heads"));
sp->setMag(1.3);
sp->setGrid(33, 36);
sp->setDrawGrid(true);
for (int i = 0; i < HEAD_GROUPS; ++i) {
int sym = noteHeads[0][i][1];
if (i == HEAD_BREVIS_ALT)
sym = noteHeads[0][i][3];
NoteHead* nh = new NoteHead(gscore);
nh->setSym(sym);
sp->append(nh, qApp->translate("symbol", symbols[0][sym].name()));
}
paletteBox->addPalette(sp);
//-----------------------------------
// Tremolo
//-----------------------------------
sp = new Palette;
sp->setName(tr("Tremolo"));
sp->setGrid(27, 40);
sp->setDrawGrid(true);
const char* tremoloName[] = {
QT_TR_NOOP("1/8 through stem"),
QT_TR_NOOP("1/16 through stem"),
QT_TR_NOOP("1/32 through stem"),
QT_TR_NOOP("1/64 through stem"),
QT_TR_NOOP("1/8 between notes"),
QT_TR_NOOP("1/16 between notes"),
QT_TR_NOOP("1/32 between notes"),
QT_TR_NOOP("1/64 between notes")
};
for (int i = TREMOLO_R8; i <= TREMOLO_C64; ++i) {
Tremolo* tremolo = new Tremolo(gscore);
tremolo->setSubtype(TremoloType(i));
sp->append(tremolo, tr(tremoloName[i - TREMOLO_R8]));
}
paletteBox->addPalette(sp);
//-----------------------------------
// Fall, Doit
//-----------------------------------
sp = new Palette;
sp->setName(tr("Fall/Doit"));
sp->setGrid(27, 40);
sp->setDrawGrid(true);
const char* scorelineNames[] = {
QT_TR_NOOP("fall"),
QT_TR_NOOP("doit"),
};
ChordLine* cl = new ChordLine(gscore);
cl->setSubtype(1);
sp->append(cl, tr(scorelineNames[0]));
cl = new ChordLine(gscore);
cl->setSubtype(2);
sp->append(cl, tr(scorelineNames[1]));
paletteBox->addPalette(sp);
//-----------------------------------
// Repeats
//-----------------------------------
sp = new Palette;
sp->setName(tr("Repeats"));
sp->setMag(0.65);
sp->setGrid(84, 28);
sp->setDrawGrid(true);
RepeatMeasure* rm = new RepeatMeasure(gscore);
sp->append(rm, tr("Repeat measure sign"));
Marker* mk = new Marker(gscore);
mk->setMarkerType(MARKER_SEGNO);
sp->append(mk, tr("Segno"));
mk = new Marker(gscore);
mk->setMarkerType(MARKER_VARSEGNO);
sp->append(mk, tr("Segno Variation"));
mk = new Marker(gscore);
mk->setMarkerType(MARKER_CODA);
sp->append(mk, tr("Coda"));
mk = new Marker(gscore);
mk->setMarkerType(MARKER_VARCODA);
sp->append(mk, tr("Varied coda"));
mk = new Marker(gscore);
mk->setMarkerType(MARKER_CODETTA);
sp->append(mk, tr("Codetta"));
mk = new Marker(gscore);
mk->setMarkerType(MARKER_FINE);
sp->append(mk, tr("Fine"));
Jump* jp = new Jump(gscore);
jp->setJumpType(JUMP_DC);
sp->append(jp, tr("Da Capo"));
jp = new Jump(gscore);
jp->setJumpType(JUMP_DC_AL_FINE);
sp->append(jp, tr("Da Capo al Fine"));
jp = new Jump(gscore);
jp->setJumpType(JUMP_DC_AL_CODA);
sp->append(jp, tr("Da Capo al Coda"));
jp = new Jump(gscore);
jp->setJumpType(JUMP_DS_AL_CODA);
sp->append(jp, tr("D.S al Coda"));
jp = new Jump(gscore);
jp->setJumpType(JUMP_DS_AL_FINE);
sp->append(jp, tr("D.S al Fine"));
jp = new Jump(gscore);
jp->setJumpType(JUMP_DS);
sp->append(jp, tr("D.S"));
mk = new Marker(gscore);
mk->setMarkerType(MARKER_TOCODA);
sp->append(mk, tr("To Coda"));
paletteBox->addPalette(sp);
//-----------------------------------
// Text
//-----------------------------------
sp = new Palette;
sp->setName(tr("Text"));
sp->setMag(0.65);
sp->setGrid(84, 28);
sp->setDrawGrid(true);
StaffText* st = new StaffText(gscore);
st->setSystemFlag(false);
st->setTextStyle(TEXT_STYLE_STAFF);
//TODO st->setSubtype(TEXT_STAFF);
st->setText(tr("staff-text"));
sp->append(st, tr("Staff Text"));
st = new StaffText(gscore);
st->setSystemFlag(true);
st->setTextStyle(TEXT_STYLE_SYSTEM);
// st->setSubtype(TEXT_SYSTEM);
st->setText(tr("system-text"));
sp->append(st, tr("System Text"));
RehearsalMark* rhm = new RehearsalMark(gscore);
rhm->setTrack(0);
rhm->setText("B1");
sp->append(rhm, tr("RRehearsal Mark"));
InstrumentChange* is = new InstrumentChange(gscore);
is->setText(tr("Instrument"));
sp->append(is, tr("Instrument Change"));
Text* text = new Text(gscore);
text->setTrack(0);
text->setTextStyle(TEXT_STYLE_LYRICS_VERSE_NUMBER);
text->setText(tr("1."));
text->setSystemFlag(true);
sp->append(text, tr("Lyrics Verse Number"));
static const TempoPattern tp[] = {
TempoPattern(QString("%1%2 = 80"). arg(QChar(0xd834)).arg(QChar(0xdd5f)), 80.0/60.0), // 1/4
TempoPattern(QString("%1%2 = 80"). arg(QChar(0xd834)).arg(QChar(0xdd5e)), 80.0/30.0), // 1/2
TempoPattern(QString("%1%2 = 80"). arg(QChar(0xd834)).arg(QChar(0xdd60)), 80.0/120.0), // 1/8
TempoPattern(QString("%1%2%3%4 = 80").arg(QChar(0xd834)).arg(QChar(0xdd5f)).arg(QChar(0xd834)).arg(QChar(0xdd6d)), 120.0/60.0), // dotted 1/4
TempoPattern(QString("%1%2%3%4 = 80").arg(QChar(0xd834)).arg(QChar(0xdd5e)).arg(QChar(0xd834)).arg(QChar(0xdd6d)), 120/30.0), // dotted 1/2
TempoPattern(QString("%1%2%3%4 = 80").arg(QChar(0xd834)).arg(QChar(0xdd60)).arg(QChar(0xd834)).arg(QChar(0xdd6d)), 120/120.0) // dotted 1/8
};
for (unsigned i = 0; i < sizeof(tp)/sizeof(*tp); ++i) {
TempoText* tt = new TempoText(gscore);
tt->setFollowText(true);
tt->setTrack(0);
tt->setTempo(tp[i].f);
tt->setText(tp[i].pattern);
sp->append(tt, tr("Tempo Text"), QString(), 1.5);
}
Harmony* harmony = new Harmony(gscore);
harmony->setText("c7");
sp->append(harmony, tr("Chord Name"));
paletteBox->addPalette(sp);
//-----------------------------------
// breaks
//-----------------------------------
qreal _spatium = gscore->spatium();
sp = new Palette;
sp->setName(tr("Breaks && Spacer"));
sp->setMag(.7);
sp->setGrid(42, 36);
sp->setDrawGrid(true);
LayoutBreak* lb = new LayoutBreak(gscore);
lb->setSubtype(LAYOUT_BREAK_LINE);
sp->append(lb, tr("Line break"));
lb = new LayoutBreak(gscore);
lb->setSubtype(LAYOUT_BREAK_PAGE);
sp->append(lb, tr("Page break"));
lb = new LayoutBreak(gscore);
lb->setSubtype(LAYOUT_BREAK_SECTION);
sp->append(lb, tr("Section break"));
Spacer* spacer = new Spacer(gscore);
spacer->setGap(3 * _spatium);
spacer->setSubtype(SPACER_DOWN);
sp->append(spacer, tr("Staff spacer down"));
spacer = new Spacer(gscore);
spacer->setGap(3 * _spatium);
spacer->setSubtype(SPACER_UP);
sp->append(spacer, tr("Staff spacer up"));
paletteBox->addPalette(sp);
//-----------------------------------
// staff state changes
//-----------------------------------
#if 0
sp = new Palette;
sp->setName(tr("Staff Changes"));
sp->setMag(.7);
sp->setGrid(42, 36);
sp->setDrawGrid(true);
StaffState* st = new StaffState(gscore);
st->setSubtype(STAFF_STATE_VISIBLE);
sp->append(st, tr("set visible"));
st = new StaffState(gscore);
st->setSubtype(STAFF_STATE_INVISIBLE);
sp->append(st, tr("set invisible"));
st = new StaffState(gscore);
st->setSubtype(STAFF_STATE_TYPE);
sp->append(st, tr("change staff type"));
st = new StaffState(gscore);
st->setSubtype(STAFF_STATE_INSTRUMENT);
sp->append(st, tr("change instrument"));
paletteBox->addPalette(sp);
#endif
//-----------------------------------
// beam properties
//-----------------------------------
sp = new Palette;
sp->setName(tr("Beam Properties"));
sp->setGrid(27, 40);
sp->setDrawGrid(true);
static const IconAction bpa[] = {
{ ICON_SBEAM, "beam-start" },
{ ICON_MBEAM, "beam-mid" },
{ ICON_NBEAM, "no-beam" },
{ ICON_BEAM32, "beam32" },
{ ICON_BEAM64, "beam64" },
{ ICON_AUTOBEAM, "auto-beam" },
{ ICON_FBEAM1, "fbeam1" },
{ ICON_FBEAM2, "fbeam2" },
{ -1, ""}
};
populateIconPalette(sp, bpa);
paletteBox->addPalette(sp);
//-----------------------------------
// Symbols
//-----------------------------------
sp = new Palette;
sp->setName(tr("Symbols"));
sp->setGrid(42, 45);
sp->setDrawGrid(true);
sp->append(accDiscantSym);
sp->append(accDotSym);
sp->append(accFreebaseSym);
sp->append(accStdbaseSym);
sp->append(accBayanbaseSym);
sp->append(accOldEESym);
sp->append(accpushSym);
sp->append(accpullSym);
FretDiagram* fret = new FretDiagram(gscore);
fret->setDot(5, 1);
fret->setDot(2, 2);
fret->setDot(1, 3);
fret->setMarker(0, 'X');
fret->setMarker(3, 'O');
fret->setMarker(4, 'O');
sp->append(fret, tr("Fret Diagram"));
paletteBox->addPalette(sp);
}
void InspectorBarLine::manageSpanData()
{
#if 0
BarLine* bl = toBarLine(inspector->element());
// determine MIN and MAX for SPANFROM and SPANTO
Staff* staffFrom = bl->staff();
Staff* staffTo = bl->score()->staff(bl->staffIdx() + bl->span() - 1);
int staffFromLines= (staffFrom ? staffFrom->lines(bl->tick()) : 5);
int staffToLines = (staffTo ? staffTo->lines(bl->tick()) : 5);
// From: min = minimum possible according to number of staff lines
// max = if same as To, at least 1sp (2 units) above To; if not, max possible according to num.of lines
int min = staffFromLines == 1 ? BARLINE_SPAN_1LINESTAFF_FROM : MIN_BARLINE_SPAN_FROMTO;
int max = bl->span() < 2 ? bl->spanTo() - MIN_BARLINE_FROMTO_DIST
: (staffFromLines == 1 ? BARLINE_SPAN_1LINESTAFF_TO : (staffFromLines-1) * 2 + 2);
b.spanFrom->setMinimum(min);
b.spanFrom->setMaximum(max);
// To: min = if same as From, at least 1sp (2 units) below From; if not, min possible according to num.of lines
// max = max possible according to number of staff lines
min = bl->span() < 2 ? bl->spanFrom() + MIN_BARLINE_FROMTO_DIST
: (staffToLines == 1 ? BARLINE_SPAN_1LINESTAFF_FROM : MIN_BARLINE_SPAN_FROMTO);
max = staffToLines == 1 ? BARLINE_SPAN_1LINESTAFF_TO : (staffToLines-1) * 2 + 2;
b.spanTo->setMinimum(min);
b.spanTo->setMaximum(max);
// determine MAX for SPAN
max = bl->score()->nstaves() - bl->staffIdx();
b.span->setMaximum(max);
#endif
}