void View::DrawSlurInitial(FloatingCurvePositioner *curve, Slur *slur, int x1, int x2, Staff *staff, char spanningType)
{
Beam *parentBeam = NULL;
Chord *startParentChord = NULL;
Chord *endParentChord = NULL;
Note *startNote = NULL;
Note *endNote = NULL;
Chord *startChord = NULL;
Chord *endChord = NULL;
curvature_CURVEDIR drawingCurveDir = curvature_CURVEDIR_above;
data_STEMDIRECTION startStemDir = STEMDIRECTION_NONE;
data_STEMDIRECTION endStemDir = STEMDIRECTION_NONE;
data_STEMDIRECTION stemDir = STEMDIRECTION_NONE;
bool isGraceToNoteSlur = false;
int y1 = staff->GetDrawingY();
int y2 = staff->GetDrawingY();
/************** parent layers **************/
LayerElement *start = dynamic_cast<LayerElement *>(slur->GetStart());
LayerElement *end = dynamic_cast<LayerElement *>(slur->GetEnd());
if (!start || !end) {
// no start and end, obviously nothing to do...
return;
}
if (start->Is(TIMESTAMP_ATTR) && end->Is(TIMESTAMP_ATTR)) {
// for now ignore slur using 2 tstamps
return;
}
if (start->Is(NOTE)) {
startNote = dynamic_cast<Note *>(start);
assert(startNote);
startParentChord = startNote->IsChordTone();
startStemDir = startNote->GetDrawingStemDir();
}
else if (start->Is(CHORD)) {
startChord = dynamic_cast<Chord *>(start);
assert(startChord);
startStemDir = startChord->GetDrawingStemDir();
}
if (end->Is(NOTE)) {
endNote = dynamic_cast<Note *>(end);
assert(endNote);
endParentChord = endNote->IsChordTone();
endStemDir = endNote->GetDrawingStemDir();
}
else if (end->Is(CHORD)) {
endChord = dynamic_cast<Chord *>(end);
assert(endChord);
endStemDir = endChord->GetDrawingStemDir();
}
if (startNote && endNote && startNote->IsGraceNote() && !endNote->IsGraceNote()) {
isGraceToNoteSlur = true;
}
Layer *layer = NULL;
LayerElement *layerElement = NULL;
// For now, with timestamps, get the first layer. We should eventually look at the @layerident (not implemented)
if (!start->Is(TIMESTAMP_ATTR)) {
layer = dynamic_cast<Layer *>(start->GetFirstParent(LAYER));
layerElement = start;
}
else {
layer = dynamic_cast<Layer *>(end->GetFirstParent(LAYER));
layerElement = end;
}
assert(layer);
if (!start->Is(TIMESTAMP_ATTR) && !end->Is(TIMESTAMP_ATTR) && (spanningType == SPANNING_START_END)) {
System *system = dynamic_cast<System *>(staff->GetFirstParent(SYSTEM));
assert(system);
// If we have a start to end situation, then store the curvedir in the slur for mixed drawing stem dir
// situations
if (system->HasMixedDrawingStemDir(start, end)) {
slur->SetDrawingCurvedir(curvature_CURVEDIR_above);
}
}
/************** calculate the radius for adjusting the x position **************/
int startRadius = 0;
if (!start->Is(TIMESTAMP_ATTR)) {
startRadius = start->GetDrawingRadius(m_doc);
}
int endRadius = 0;
if (!end->Is(TIMESTAMP_ATTR)) {
endRadius = end->GetDrawingRadius(m_doc);
}
/************** note stem dir **************/
if (spanningType == SPANNING_START_END) {
stemDir = startStemDir;
}
// This is the case when the tie is split over two system of two pages.
// In this case, we are now drawing its beginning to the end of the measure (i.e., the last aligner)
else if (spanningType == SPANNING_START) {
stemDir = startStemDir;
}
// Now this is the case when the tie is split but we are drawing the end of it
else if (spanningType == SPANNING_END) {
stemDir = endStemDir;
}
// Finally, slur accross an entire system; use the staff position and up (see below)
else {
stemDir = STEMDIRECTION_down;
}
/************** direction **************/
data_STEMDIRECTION layerStemDir;
// first should be the tie @curvedir
if (slur->HasCurvedir()) {
drawingCurveDir
= (slur->GetCurvedir() == curvature_CURVEDIR_above) ? curvature_CURVEDIR_above : curvature_CURVEDIR_below;
}
// grace notes - always below unless we have a drawing stem direction on the layer
else if (isGraceToNoteSlur && (layer->GetDrawingStemDir(layerElement) == STEMDIRECTION_NONE)) {
drawingCurveDir = curvature_CURVEDIR_below;
}
// the normal case
else if (slur->HasDrawingCurvedir()) {
drawingCurveDir = slur->GetDrawingCurvedir();
}
// then layer direction trumps note direction
else if (layer && ((layerStemDir = layer->GetDrawingStemDir(layerElement)) != STEMDIRECTION_NONE)) {
drawingCurveDir = (layerStemDir == STEMDIRECTION_up) ? curvature_CURVEDIR_above : curvature_CURVEDIR_below;
}
// look if in a chord
else if (startParentChord) {
if (startParentChord->PositionInChord(startNote) < 0) {
drawingCurveDir = curvature_CURVEDIR_below;
}
else if (startParentChord->PositionInChord(startNote) > 0) {
drawingCurveDir = curvature_CURVEDIR_above;
}
// away from the stem if odd number (center note)
else {
drawingCurveDir = (stemDir != STEMDIRECTION_up) ? curvature_CURVEDIR_above : curvature_CURVEDIR_below;
}
}
else if (stemDir == STEMDIRECTION_up) {
drawingCurveDir = curvature_CURVEDIR_below;
}
else if (stemDir == STEMDIRECTION_NONE) {
// no information from the note stem directions, look at the position in the notes
int center = staff->GetDrawingY() - m_doc->GetDrawingDoubleUnit(staff->m_drawingStaffSize) * 2;
drawingCurveDir = (start->GetDrawingY() > center) ? curvature_CURVEDIR_above : curvature_CURVEDIR_below;
}
/************** adjusting y position **************/
bool isShortSlur = false;
if (x2 - x1 < 1 * m_doc->GetDrawingDoubleUnit(staff->m_drawingStaffSize)) isShortSlur = true;
int yChordMax, yChordMin;
if ((spanningType == SPANNING_START_END) || (spanningType == SPANNING_START)) {
// first get the min max of the chord (if any)
if (startParentChord) {
startParentChord->GetYExtremes(yChordMax, yChordMin);
}
else if (startChord) {
startChord->GetYExtremes(yChordMax, yChordMin);
}
// slur is up
if (drawingCurveDir == curvature_CURVEDIR_above) {
// P(^)
if (startStemDir == STEMDIRECTION_down) y1 = start->GetDrawingTop(m_doc, staff->m_drawingStaffSize);
// d(^)d
else if (isShortSlur) {
y1 = start->GetDrawingTop(m_doc, staff->m_drawingStaffSize);
}
// same but in beam - adjust the x too
else if ((parentBeam = start->IsInBeam()) && !parentBeam->IsLastInBeam(start)) {
y1 = start->GetDrawingTop(m_doc, staff->m_drawingStaffSize);
x1 += startRadius - m_doc->GetDrawingStemWidth(staff->m_drawingStaffSize);
}
// d(^)
else {
// put it on the side, move it left, but not if we have a @stamp
if (!start->Is(TIMESTAMP_ATTR)) x1 += m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 4 / 2;
if (startChord || startParentChord)
y1 = yChordMin + m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 3;
else
y1 = start->GetDrawingY() + m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 3;
}
}
// slur is down
else {
// d(_)
if (startStemDir == STEMDIRECTION_up) y1 = start->GetDrawingBottom(m_doc, staff->m_drawingStaffSize);
// P(_)P
else if (isShortSlur) {
y1 = start->GetDrawingBottom(m_doc, staff->m_drawingStaffSize);
}
// same but in beam
else if ((parentBeam = start->IsInBeam()) && !parentBeam->IsLastInBeam(start)) {
y1 = start->GetDrawingBottom(m_doc, staff->m_drawingStaffSize);
x1 -= startRadius - m_doc->GetDrawingStemWidth(staff->m_drawingStaffSize);
}
// P(_)
else {
// put it on the side, but no need to move it left
if (startChord || startParentChord)
y1 = yChordMin - m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 3;
else
y1 = start->GetDrawingY() - m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 3;
}
}
}
if ((spanningType == SPANNING_START_END) || (spanningType == SPANNING_END)) {
// get the min max of the chord if any
if (endParentChord) {
endParentChord->GetYExtremes(yChordMax, yChordMin);
}
else if (endChord) {
endChord->GetYExtremes(yChordMax, yChordMin);
}
// get the stem direction of the end
// slur is up
if (drawingCurveDir == curvature_CURVEDIR_above) {
// (^)P
if (endStemDir == STEMDIRECTION_down) y2 = end->GetDrawingTop(m_doc, staff->m_drawingStaffSize);
// d(^)d
else if (isShortSlur) {
y2 = end->GetDrawingTop(m_doc, staff->m_drawingStaffSize);
}
// same but in beam - adjust the x too
else if ((parentBeam = end->IsInBeam()) && !parentBeam->IsFirstInBeam(end)) {
y2 = end->GetDrawingTop(m_doc, staff->m_drawingStaffSize);
x2 += endRadius - m_doc->GetDrawingStemWidth(staff->m_drawingStaffSize);
}
// (^)d
else {
// put it on the side, no need to move it right
if (endChord || endParentChord)
y2 = yChordMin + m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 3;
else
y2 = end->GetDrawingY() + m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 3;
}
}
else {
if (isGraceToNoteSlur) {
if (endNote) {
y2 = endNote->GetDrawingY();
x2 -= m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 2;
isShortSlur = true;
}
else {
y2 = y1;
}
}
// (_)d
else if (endStemDir == STEMDIRECTION_up)
y2 = end->GetDrawingBottom(m_doc, staff->m_drawingStaffSize);
// P(_)P
else if (isShortSlur) {
y2 = end->GetDrawingBottom(m_doc, staff->m_drawingStaffSize);
}
// same but in beam
else if ((parentBeam = end->IsInBeam()) && !parentBeam->IsFirstInBeam(end)) {
y2 = end->GetDrawingBottom(m_doc, staff->m_drawingStaffSize);
//
x2 -= endRadius - m_doc->GetDrawingStemWidth(staff->m_drawingStaffSize);
}
// (_)P
else {
// put it on the side, move it right, but not if we have a @stamp2
if (!end->Is(TIMESTAMP_ATTR)) x2 -= m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 2;
if (endChord || endParentChord)
y2 = yChordMin - m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 3;
else
y2 = end->GetDrawingY() - m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * 3;
}
}
}
// Positions not attached to a note
if (spanningType == SPANNING_START) {
if (drawingCurveDir == curvature_CURVEDIR_above)
y2 = std::max(staff->GetDrawingY(), y1);
else
y2 = std::min(staff->GetDrawingY() - m_doc->GetDrawingStaffSize(staff->m_drawingStaffSize), y1);
}
if (end->Is(TIMESTAMP_ATTR)) {
if (drawingCurveDir == curvature_CURVEDIR_above)
y2 = std::max(staff->GetDrawingY(), y1);
else
y2 = std::min(staff->GetDrawingY() - m_doc->GetDrawingStaffSize(staff->m_drawingStaffSize), y1);
}
if (spanningType == SPANNING_END) {
if (drawingCurveDir == curvature_CURVEDIR_above)
y1 = std::max(staff->GetDrawingY(), y2);
else
y1 = std::min(staff->GetDrawingY() - m_doc->GetDrawingStaffSize(staff->m_drawingStaffSize), y2);
}
if (start->Is(TIMESTAMP_ATTR)) {
if (drawingCurveDir == curvature_CURVEDIR_above)
y1 = std::max(staff->GetDrawingY(), y2);
else
y1 = std::min(staff->GetDrawingY() - m_doc->GetDrawingStaffSize(staff->m_drawingStaffSize), y2);
}
// slur accross an entire system; use the staff position
else if (spanningType == SPANNING_MIDDLE) {
// To be adjusted
if (drawingCurveDir == curvature_CURVEDIR_above)
y1 = staff->GetDrawingY();
else
y1 = staff->GetDrawingY() - m_doc->GetDrawingStaffSize(staff->m_drawingStaffSize);
y2 = y1;
}
/************** y position **************/
if (drawingCurveDir == curvature_CURVEDIR_above) {
y1 += 1 * m_doc->GetDrawingUnit(staff->m_drawingStaffSize);
y2 += 1 * m_doc->GetDrawingUnit(staff->m_drawingStaffSize);
}
else {
y1 -= 1 * m_doc->GetDrawingUnit(staff->m_drawingStaffSize);
y2 -= 1 * m_doc->GetDrawingUnit(staff->m_drawingStaffSize);
}
Point points[4];
points[0] = Point(x1, y1);
points[3] = Point(x2, y2);
float angle = CalcInitialSlur(curve, slur, staff, layer->GetN(), drawingCurveDir, points);
int thickness = m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * m_options->m_slurThickness.GetValue();
curve->UpdateCurveParams(points, angle, thickness, drawingCurveDir);
/************** articulation **************/
// First get all artic children
ClassIdComparison matchType(ARTIC);
ArrayOfObjects artics;
ArrayOfObjects::iterator articIter;
// the normal case or start
if ((spanningType == SPANNING_START_END) || (spanningType == SPANNING_START)) {
start->FindAllChildByComparison(&artics, &matchType);
// Then the @n of each first staffDef
for (articIter = artics.begin(); articIter != artics.end(); ++articIter) {
Artic *artic = dynamic_cast<Artic *>(*articIter);
assert(artic);
ArticPart *outsidePart = artic->GetOutsidePart();
if (outsidePart) {
if ((outsidePart->GetPlace().GetBasic() == STAFFREL_basic_above)
&& (drawingCurveDir == curvature_CURVEDIR_above)) {
outsidePart->AddSlurPositioner(curve, true);
}
else if ((outsidePart->GetPlace().GetBasic() == STAFFREL_basic_below)
&& (drawingCurveDir == curvature_CURVEDIR_below)) {
outsidePart->AddSlurPositioner(curve, true);
}
}
}
}
// normal case or end
if ((spanningType == SPANNING_START_END) || (spanningType == SPANNING_END)) {
end->FindAllChildByComparison(&artics, &matchType);
// Then the @n of each first staffDef
for (articIter = artics.begin(); articIter != artics.end(); ++articIter) {
Artic *artic = dynamic_cast<Artic *>(*articIter);
assert(artic);
ArticPart *outsidePart = artic->GetOutsidePart();
if (outsidePart) {
if ((outsidePart->GetPlace().GetBasic() == STAFFREL_basic_above)
&& (drawingCurveDir == curvature_CURVEDIR_above)) {
outsidePart->AddSlurPositioner(curve, false);
}
else if ((outsidePart->GetPlace().GetBasic() == STAFFREL_basic_below)
&& (drawingCurveDir == curvature_CURVEDIR_below)) {
outsidePart->AddSlurPositioner(curve, false);
}
}
}
}
return;
}
Score::FileError Score::read114(XmlReader& e)
{
if (parentScore())
setMscVersion(parentScore()->mscVersion());
for (unsigned int i = 0; i < sizeof(style114)/sizeof(*style114); ++i)
style()->set(style114[i].idx, style114[i].val);
// old text style defaults
TextStyle ts = style()->textStyle("Chord Symbol");
ts.setYoff(-4.0);
style()->setTextStyle(ts);
TempoMap tm;
while (e.readNextStartElement()) {
e.setTrack(-1);
const QStringRef& tag(e.name());
if (tag == "Staff")
readStaff(e);
else if (tag == "KeySig") { // not supported
KeySig* ks = new KeySig(this);
ks->read(e);
// customKeysigs.append(ks);
delete ks;
}
else if (tag == "siglist")
_sigmap->read(e, _fileDivision);
else if (tag == "programVersion") {
_mscoreVersion = e.readElementText();
parseVersion(_mscoreVersion);
}
else if (tag == "programRevision")
_mscoreRevision = e.readInt();
else if (tag == "Mag"
|| tag == "MagIdx"
|| tag == "xoff"
|| tag == "Symbols"
|| tag == "cursorTrack"
|| tag == "yoff")
e.skipCurrentElement(); // obsolete
else if (tag == "tempolist") {
// store the tempo list to create invisible tempo text later
qreal tempo = e.attribute("fix","2.0").toDouble();
tm.setRelTempo(tempo);
while (e.readNextStartElement()) {
if (e.name() == "tempo") {
int tick = e.attribute("tick").toInt();
double tmp = e.readElementText().toDouble();
tick = (tick * MScore::division + _fileDivision/2) / _fileDivision;
auto pos = tm.find(tick);
if (pos != tm.end())
tm.erase(pos);
tm.setTempo(tick, tmp);
}
else if (e.name() == "relTempo")
e.readElementText();
else
e.unknown();
}
}
else if (tag == "playMode")
_playMode = PlayMode(e.readInt());
else if (tag == "SyntiSettings")
_synthesizerState.read(e);
else if (tag == "Spatium")
_style.setSpatium (e.readDouble() * MScore::DPMM);
else if (tag == "Division")
_fileDivision = e.readInt();
else if (tag == "showInvisible")
_showInvisible = e.readInt();
else if (tag == "showFrames")
_showFrames = e.readInt();
else if (tag == "showMargins")
_showPageborders = e.readInt();
else if (tag == "Style") {
qreal sp = _style.spatium();
_style.load(e);
// adjust this now so chords render properly on read
// other style adjustments can wait until reading is finished
if (style(StyleIdx::useGermanNoteNames).toBool())
style()->set(StyleIdx::useStandardNoteNames, false);
if (_layoutMode == LayoutMode::FLOAT) {
// style should not change spatium in
// float mode
_style.setSpatium(sp);
}
}
else if (tag == "TextStyle") {
TextStyle s;
s.read(e);
qreal spMM = _style.spatium() / MScore::DPMM;
if (s.frameWidthMM() != 0.0)
s.setFrameWidth(Spatium(s.frameWidthMM() / spMM));
if (s.paddingWidthMM() != 0.0)
s.setPaddingWidth(Spatium(s.paddingWidthMM() / spMM));
\
// convert 1.2 text styles
s.setName(convertOldTextStyleNames(s.name()));
if (s.name() == "Lyrics Odd Lines" || s.name() == "Lyrics Even Lines")
s.setAlign((s.align() & ~ Align(AlignmentFlags::VMASK)) | AlignmentFlags::BASELINE);
_style.setTextStyle(s);
}
else if (tag == "page-layout") {
if (_layoutMode != LayoutMode::FLOAT && _layoutMode != LayoutMode::SYSTEM) {
PageFormat pf;
pf.copy(*pageFormat());
pf.read(e, this);
setPageFormat(pf);
}
else
e.skipCurrentElement();
}
else if (tag == "copyright" || tag == "rights") {
Text* text = new Text(this);
text->read(e);
text->layout();
setMetaTag("copyright", text->plainText());
delete text;
}
else if (tag == "movement-number")
setMetaTag("movementNumber", e.readElementText());
else if (tag == "movement-title")
setMetaTag("movementTitle", e.readElementText());
else if (tag == "work-number")
setMetaTag("workNumber", e.readElementText());
else if (tag == "work-title")
setMetaTag("workTitle", e.readElementText());
else if (tag == "source")
setMetaTag("source", e.readElementText());
else if (tag == "metaTag") {
QString name = e.attribute("name");
setMetaTag(name, e.readElementText());
}
else if (tag == "Part") {
Part* part = new Part(this);
part->read114(e);
_parts.push_back(part);
}
else if (tag == "Slur") {
Slur* slur = new Slur(this);
slur->read(e);
addSpanner(slur);
}
else if ((tag == "HairPin")
|| (tag == "Ottava")
|| (tag == "TextLine")
|| (tag == "Volta")
|| (tag == "Trill")
|| (tag == "Pedal")) {
Spanner* s = static_cast<Spanner*>(Element::name2Element(tag, this));
s->read(e);
if (s->track() == -1)
s->setTrack(e.track());
else
e.setTrack(s->track()); // update current track
if (s->tick() == -1)
s->setTick(e.tick());
else
e.initTick(s->tick()); // update current tick
if (s->track2() == -1)
s->setTrack2(s->track());
if (s->ticks() == 0) {
delete s;
qDebug("zero spanner %s ticks: %d", s->name(), s->ticks());
}
else {
addSpanner(s);
}
}
else if (tag == "Excerpt") {
if (MScore::noExcerpts)
e.skipCurrentElement();
else {
Excerpt* ex = new Excerpt(this);
ex->read(e);
_excerpts.append(ex);
}
}
else if (tag == "Beam") {
Beam* beam = new Beam(this);
beam->read(e);
beam->setParent(0);
// _beams.append(beam);
}
else if (tag == "name")
setName(e.readElementText());
else
e.unknown();
}
if (e.error() != XmlStreamReader::NoError)
return FileError::FILE_BAD_FORMAT;
int n = nstaves();
for (int idx = 0; idx < n; ++idx) {
Staff* s = _staves[idx];
int track = idx * VOICES;
// check barLineSpan
if (s->barLineSpan() > (n - idx)) {
qDebug("read114: invalid bar line span %d (max %d)",
s->barLineSpan(), n - idx);
s->setBarLineSpan(n - idx);
}
for (auto i : e.clefs(idx)) {
int tick = i.first;
ClefType clefId = i.second;
Measure* m = tick2measure(tick);
if (!m)
continue;
if ((tick == m->tick()) && m->prevMeasure())
m = m->prevMeasure();
Segment* seg = m->getSegment(Segment::Type::Clef, tick);
if (seg->element(track))
static_cast<Clef*>(seg->element(track))->setGenerated(false);
else {
Clef* clef = new Clef(this);
clef->setClefType(clefId);
clef->setTrack(track);
clef->setParent(seg);
clef->setGenerated(false);
seg->add(clef);
}
}
// create missing KeySig
KeyList* km = s->keyList();
for (auto i = km->begin(); i != km->end(); ++i) {
int tick = i->first;
if (tick < 0) {
qDebug("read114: Key tick %d", tick);
continue;
}
if (tick == 0 && i->second.key() == Key::C)
continue;
Measure* m = tick2measure(tick);
if (!m) //empty score
break;
Segment* seg = m->getSegment(Segment::Type::KeySig, tick);
if (seg->element(track))
static_cast<KeySig*>(seg->element(track))->setGenerated(false);
else {
KeySigEvent ke = i->second;
KeySig* ks = new KeySig(this);
ks->setKeySigEvent(ke);
ks->setParent(seg);
ks->setTrack(track);
ks->setGenerated(false);
seg->add(ks);
}
}
}
for (std::pair<int,Spanner*> p : spanner()) {
Spanner* s = p.second;
if (s->type() != Element::Type::SLUR) {
if (s->type() == Element::Type::VOLTA) {
Volta* volta = static_cast<Volta*>(s);
volta->setAnchor(Spanner::Anchor::MEASURE);
}
}
if (s->type() == Element::Type::OTTAVA
|| s->type() == Element::Type::PEDAL
|| s->type() == Element::Type::TRILL
|| s->type() == Element::Type::TEXTLINE) {
qreal yo = 0;
if (s->type() == Element::Type::OTTAVA) {
// fix ottava position
yo = styleS(StyleIdx::ottavaY).val() * spatium();
if (s->placement() == Element::Placement::BELOW)
yo = -yo + s->staff()->height();
}
else if (s->type() == Element::Type::PEDAL) {
yo = styleS(StyleIdx::pedalY).val() * spatium();
}
else if (s->type() == Element::Type::TRILL) {
yo = styleS(StyleIdx::trillY).val() * spatium();
}
else if (s->type() == Element::Type::TEXTLINE) {
yo = -5.0 * spatium();
}
if (!s->spannerSegments().isEmpty()) {
for (SpannerSegment* seg : s->spannerSegments()) {
if (!seg->userOff().isNull())
seg->setUserYoffset(seg->userOff().y() - yo);
}
}
else {
s->setUserYoffset(-yo);
}
}
}
connectTies();
//
// remove "middle beam" flags from first ChordRest in
// measure
//
for (Measure* m = firstMeasure(); m; m = m->nextMeasure()) {
int tracks = nstaves() * VOICES;
bool first = true;
for (int track = 0; track < tracks; ++track) {
for (Segment* s = m->first(); s; s = s->next()) {
if (s->segmentType() != Segment::Type::ChordRest)
continue;
ChordRest* cr = static_cast<ChordRest*>(s->element(track));
if (cr) {
if(cr->type() == Element::Type::REST) {
Rest* r = static_cast<Rest*>(cr);
if (!r->userOff().isNull()) {
int lineOffset = r->computeLineOffset();
qreal lineDist = r->staff() ? r->staff()->staffType()->lineDistance().val() : 1.0;
r->rUserYoffset() -= (lineOffset * .5 * lineDist * r->spatium());
}
}
if(!first) {
switch(cr->beamMode()) {
case Beam::Mode::AUTO:
case Beam::Mode::BEGIN:
case Beam::Mode::END:
case Beam::Mode::NONE:
break;
case Beam::Mode::MID:
case Beam::Mode::BEGIN32:
case Beam::Mode::BEGIN64:
cr->setBeamMode(Beam::Mode::BEGIN);
break;
case Beam::Mode::INVALID:
if (cr->type() == Element::Type::CHORD)
cr->setBeamMode(Beam::Mode::AUTO);
else
cr->setBeamMode(Beam::Mode::NONE);
break;
}
first = false;
}
}
}
}
}
for (MeasureBase* mb = _measures.first(); mb; mb = mb->next()) {
if (mb->type() == Element::Type::VBOX) {
Box* b = static_cast<Box*>(mb);
qreal y = point(styleS(StyleIdx::staffUpperBorder));
b->setBottomGap(y);
}
}
_fileDivision = MScore::division;
//
// sanity check for barLineSpan and update ottavas
//
foreach(Staff* staff, _staves) {
int barLineSpan = staff->barLineSpan();
int idx = staffIdx(staff);
int n = nstaves();
if (idx + barLineSpan > n) {
qDebug("bad span: idx %d span %d staves %d", idx, barLineSpan, n);
staff->setBarLineSpan(n - idx);
}
staff->updateOttava();
}
int GameScript::useOnlineAPIDirectly(OnlineAPIParams_t params)
{
#ifdef USE_CURL
struct curlMemoryStruct chunk;
chunk.memory = (char *)malloc(1); /* will be grown as needed by the realloc above */
chunk.size = 0; /* no data at this point */
// construct post fields
struct curl_httppost *formpost=NULL;
struct curl_httppost *lastptr=NULL;
curl_global_init(CURL_GLOBAL_ALL);
std::map<String, AngelScript::CScriptDictionary::valueStruct>::const_iterator it;
for (it = params.dict->dict.begin(); it != params.dict->dict.end(); it++)
{
int typeId = it->second.typeId;
if (typeId == mse->getEngine()->GetTypeIdByDecl("string"))
{
// its a String
String *str = (String *)it->second.valueObj;
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, it->first.c_str(), CURLFORM_COPYCONTENTS, str->c_str(), CURLFORM_END);
}
else if (typeId == AngelScript::asTYPEID_INT8 \
|| typeId == AngelScript::asTYPEID_INT16 \
|| typeId == AngelScript::asTYPEID_INT32 \
|| typeId == AngelScript::asTYPEID_INT64)
{
// its an integer
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, it->first.c_str(), CURLFORM_COPYCONTENTS, TOSTRING((int)it->second.valueInt).c_str(), CURLFORM_END);
}
else if (typeId == AngelScript::asTYPEID_UINT8 \
|| typeId == AngelScript::asTYPEID_UINT16 \
|| typeId == AngelScript::asTYPEID_UINT32 \
|| typeId == AngelScript::asTYPEID_UINT64)
{
// its an unsigned integer
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, it->first.c_str(), CURLFORM_COPYCONTENTS, TOSTRING((unsigned int)it->second.valueInt).c_str(), CURLFORM_END);
}
else if (typeId == AngelScript::asTYPEID_FLOAT || typeId == AngelScript::asTYPEID_DOUBLE)
{
// its a float or double
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, it->first.c_str(), CURLFORM_COPYCONTENTS, TOSTRING((float)it->second.valueFlt).c_str(), CURLFORM_END);
}
}
// add some hard coded values
//curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "terrain_Name", CURLFORM_COPYCONTENTS, gEnv->frameListener->terrainName.c_str(), CURLFORM_END);
//curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "terrain_FileName", CURLFORM_COPYCONTENTS, gEnv->frameListener->terrainFileName.c_str(), CURLFORM_END);
//curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "terrain_FileHash", CURLFORM_COPYCONTENTS, gEnv->frameListener->terrainFileHash.c_str(), CURLFORM_END);
//curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "terrain_ModHash", CURLFORM_COPYCONTENTS, gEnv->frameListener->terrainModHash.c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "terrain_ScriptName", CURLFORM_COPYCONTENTS, mse->getScriptName().c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "terrain_ScriptHash", CURLFORM_COPYCONTENTS, mse->getScriptHash().c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "User_NickName", CURLFORM_COPYCONTENTS, SSETTING("Nickname", "Anonymous").c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "User_Language", CURLFORM_COPYCONTENTS, SSETTING("Language", "English").c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "User_Token", CURLFORM_COPYCONTENTS, SSETTING("User Token Hash", "-").c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "RoR_VersionString", CURLFORM_COPYCONTENTS, ROR_VERSION_STRING, CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "RoR_ProtocolVersion", CURLFORM_COPYCONTENTS, RORNET_VERSION, CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "RoR_BinaryHash", CURLFORM_COPYCONTENTS, SSETTING("BinaryHash", "-").c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "RoR_GUID", CURLFORM_COPYCONTENTS, SSETTING("GUID", "-").c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "MP_ServerName", CURLFORM_COPYCONTENTS, SSETTING("Server name", "-").c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "MP_ServerPort", CURLFORM_COPYCONTENTS, SSETTING("Server port", "-").c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "MP_NetworkEnabled", CURLFORM_COPYCONTENTS, SSETTING("Network enable", "No").c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "APIProtocolVersion", CURLFORM_COPYCONTENTS, "2", CURLFORM_END);
if (BeamFactory::getSingleton().getCurrentTruck())
{
Beam *truck = BeamFactory::getSingleton().getCurrentTruck();
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "Truck_Name", CURLFORM_COPYCONTENTS, truck->getTruckName().c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "Truck_FileName", CURLFORM_COPYCONTENTS, truck->getTruckFileName().c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "Truck_Hash", CURLFORM_COPYCONTENTS, truck->getTruckHash().c_str(), CURLFORM_END);
// look for any locked trucks
int i = 0;
for (std::vector<hook_t>::iterator it = truck->hooks.begin(); it != truck->hooks.end(); it++, i++)
{
Beam *trailer = it->lockTruck;
if (trailer && trailer->getTruckName() != trailer->getTruckName())
{
String name = "Trailer_" + TOSTRING(i) + "_Name";
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, name.c_str(), CURLFORM_COPYCONTENTS, trailer->getTruckName().c_str(), CURLFORM_END);
String filename = "Trailer_" + TOSTRING(i) + "_FileName";
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, filename.c_str(), CURLFORM_COPYCONTENTS, trailer->getTruckFileName().c_str(), CURLFORM_END);
String hash = "Trailer_" + TOSTRING(i) + "_Hash";
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, hash.c_str(), CURLFORM_COPYCONTENTS, trailer->getTruckHash().c_str(), CURLFORM_END);
}
}
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "Trailer_Count", CURLFORM_COPYCONTENTS, TOSTRING(i).c_str(), CURLFORM_END);
}
const RenderTarget::FrameStats& stats = RoR::Application::GetOgreSubsystem()->GetRenderWindow()->getStatistics();
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "AVG_FPS", CURLFORM_COPYCONTENTS, TOSTRING(stats.avgFPS).c_str(), CURLFORM_END);
CURLcode res;
CURL *curl = curl_easy_init();
if (!curl)
{
LOG("ERROR: failed to init curl");
return 1;
}
char *curl_err_str[CURL_ERROR_SIZE];
memset(curl_err_str, 0, CURL_ERROR_SIZE);
String url = "http://" + String(REPO_SERVER) + params.apiquery;
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlWriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
// set post options
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
// logging stuff
//curl_easy_setopt(curl, CURLOPT_STDERR, LogManager::getsin InstallerLog::getSingleton()->getLogFilePtr());
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_err_str[0]);
// http related settings
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1); // follow redirects
curl_easy_setopt(curl, CURLOPT_AUTOREFERER, 1); // set the Referrer: field in requests where it follows a Location: redirect.
curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 20);
curl_easy_setopt(curl, CURLOPT_USERAGENT, "RoR");
curl_easy_setopt(curl, CURLOPT_FILETIME, 1);
// TO BE DONE: ADD SSL
// see: http://curl.haxx.se/libcurl/c/simplessl.html
// curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,1L);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
//printf("%lu bytes retrieved\n", (long)chunk.size);
curl_formfree(formpost);
String result;
if (chunk.memory)
{
// convert memory into String now
result = String(chunk.memory);
// then free
free(chunk.memory);
}
/* we're done with libcurl, so clean it up */
curl_global_cleanup();
if (res != CURLE_OK)
{
const char *errstr = curl_easy_strerror(res);
result = "ERROR: " + String(errstr);
}
LOG("online API result: " + result);
#ifdef USE_MYGUI
Console *con = RoR::Application::GetConsole();
if (con)
{
con->putMessage(Console::CONSOLE_MSGTYPE_HIGHSCORE, Console::CONSOLE_SYSTEM_NOTICE, ANSI_TO_UTF(result));
RoR::Application::GetGuiManager()->PushNotification("Script:", ANSI_TO_UTF(result));
}
#endif // USE_MYGUI
#endif //USE_CURL
return 0;
}
