//-------------------------------------------------------------------
void GRTrill::tellPosition( GObject * caller, const NVPoint & np )
{
fType = static_cast<ARTrill *>(mAbstractRepresentation)->getType();
GRSingleNote * ev = dynamic_cast<GRSingleNote *>(caller);
if (ev)
{
const int dir = chooseDirection(ev);
NVPoint newPoint (np);
const bool upward = (dir == dirUP);
if( upward ) // if stemsUp
{
if (newPoint.y >= ev->getStemLength())
newPoint.y = -LSPACE;
else
newPoint.y -= (ev->getStemLength() + LSPACE);
}
else
{
newPoint.y = (newPoint.y > 0)? -LSPACE : newPoint.y - 1.5f*LSPACE;
}
setPosition(newPoint);
// Accidental
NVPoint accidentalPos = NVPoint(newPoint);
accidentalPos.x += GetSymbolExtent(mSymbol)*0.5f + 0.4f*LSPACE;
accidentalPos.y -= 1.5f*LSPACE;
fAccidental->setPosition(accidentalPos);
}
else {
mDraw = false;
fAccidental->setDrawOnOff(false);
}
}
/** \brief Goes through the elements and finds notes and then checkes,
wether the accidentals collide.
*/
void GRSpring::checkAccidentalCollisions()
{
GRAccidentalList * myacclist = 0;
GuidoPos pos = grolst.GetHeadPosition();
while (pos)
{
GRNotationElement * el = grolst.GetNext(pos);
GRSingleNote * note = dynamic_cast<GRSingleNote *>(el);
if (note)
{
GRAccidentalList noteacclist;
note->extractAccidentals( ¬eacclist );
if (myacclist == 0)
myacclist = new GRAccidentalList(0);
myacclist->DumpListAtTail( ¬eacclist );
}
}
if (myacclist && myacclist->GetCount() > 1)
{
// now I have the accidentals at this Spring-location ....
myacclist->sort( &compaccposy );
GuidoPos pos = myacclist->GetHeadPosition();
NVPoint pt;
GRAccidental * prevacc = 0;
while (pos)
{
GRAccidental * acc = myacclist->GetNext(pos);
GCoord cury = acc->getPosition().y;
if (prevacc)
{
if (acc->getGRStaff() != prevacc->getGRStaff()
|| (cury - prevacc->getPosition().y) > (3 * LSPACE))
pt.x = 0;
}
prevacc = acc;
if (!acc->getOffsetSet())
acc->addToOffset(pt);
pt.x -= 2 * (acc->getRightSpace());
}
// now I have to update bounding boxes of notes...
pos = grolst.GetHeadPosition();
while (pos)
{
GRSingleNote *sngnot = dynamic_cast<GRSingleNote *>(grolst.GetNext(pos));
if (sngnot)
sngnot->updateBoundingBox();
}
}
delete myacclist;
}
void GRDiminuendo::getDiminuendoEndingContext(GRDiminuendoContext *ioContext, GRSystemStartEndStruct * sse)
{
GRNotationElement * endElement = sse->endElement;
if(sse->endflag == GRSystemStartEndStruct::OPENRIGHT)
endElement = lastendElement;
GRSingleNote *note = dynamic_cast<GRSingleNote *>(endElement);
if (note)
{
ioContext->rightHead = note->getNoteHead();
ioContext->rightNoteDX = note->getOffset().x;
}
}
void GRDiminuendo::getDiminuendoBeginingContext(GRDiminuendoContext *ioContext, GRSystemStartEndStruct *sse )
{
GRNotationElement * startElement = sse->startElement;
if (sse->startflag == GRSystemStartEndStruct::OPENLEFT)
startElement = flaststartElement;
GRSingleNote *note = dynamic_cast<GRSingleNote *>(startElement);
if (note)
{
ioContext->leftHead = note->getNoteHead();
ioContext->leftNoteDX = note->getOffset().x;
}
}
/** \brief Returns true if there is grace note.
*/
bool GRSpring::hasGraceNote()
{
GuidoPos pos = grolst.GetHeadPosition();
while (pos) {
GRNotationElement *el = grolst.GetNext(pos);
GRSingleNote *note = dynamic_cast<GRSingleNote*>(el);
if (note && note->isGraceNote())
return true;
}
return false;
}
/** \brief Returns the highest and lowest notehead
(with respect to y-position.
this is needed for slurs from and to chords.
*/
int GRGlobalStem::getHighestAndLowestNoteHead(GRStdNoteHead ** highest,
GRStdNoteHead ** lowest) const
{
*highest = *lowest = NULL;
if (mAssociated == 0 ) return 0;
GuidoPos pos = mAssociated->GetHeadPosition();
while (pos)
{
GRSingleNote * sn = dynamic_cast<GRSingleNote *>(mAssociated->GetNext(pos));
if (sn)
{
GRStdNoteHead * tmp = sn->getNoteHead();
if (tmp)
{
if (*highest && *lowest)
{
if ((*highest)->getPosition().y > tmp->getPosition().y)
{
*highest = tmp;
}
if ((*lowest)->getPosition().y < tmp->getPosition().y)
{
*lowest = tmp;
}
}
else
{
*highest = tmp;
*lowest = tmp;
}
}
}
}
if (*highest != NULL)
return 1;
return 0; // is it a stem dir ?
}
// -----------------------------------------------------------------------------
// (JB) It is similar to the beginning one, but has some additionnal code to
// try to get the right stem direction from a global location. Why not
// for the beginning context ?
void
GRBowing::getBowEndingContext( GRBowingContext * ioContext, GRSystemStartEndStruct * sse )
{
GRNotationElement * endElement = sse->endElement;
GRSingleNote * note = dynamic_cast<GRSingleNote *>(endElement);
if( note )
{
ioContext->bottomRightHead = note->getNoteHead();
ioContext->topRightHead = ioContext->bottomRightHead; // the same as bottom head.
ioContext->stemDirRight = note->getThroatDirection();
}
else
{
GRGlobalStem * stem = findGlobalStem( sse, endElement );
if( stem )
{
stem->getHighestAndLowestNoteHead( &ioContext->topRightHead, &ioContext->bottomRightHead );
ioContext->stemDirRight = stem->getStemDir();
}
else // we have not found one ....
{
const NEPointerList * ptlist2 = endElement->getAssociations();
GuidoPos nepos = ptlist2->GetHeadPosition();
while (nepos)
{
GRGlobalLocation * gloc = dynamic_cast<GRGlobalLocation *>(ptlist2->GetNext(nepos));
if (gloc)
{
ioContext->stemDirRight = (GDirection)gloc->getHighestAndLowestNoteHead(
&ioContext->topRightHead, &ioContext->bottomRightHead );
break;
}
}
}
ioContext->rightChordStem = stem;
}
}
// -----------------------------------------------------------------------------
// Figure out if the first element is a part of a chord.
// Find the highest and lowest note heads.
// Get the stem directions (or the possible stem directions)
void
GRBowing::getBowBeginingContext( GRBowingContext * ioContext, GRSystemStartEndStruct * sse )
{
GRNotationElement * startElement = sse->startElement;
GRSingleNote * note = dynamic_cast<GRSingleNote *>(startElement);
if( note )
{
ioContext->bottomLeftHead = note->getNoteHead();
ioContext->topLeftHead = ioContext->bottomLeftHead; // the same as bottom head.
ioContext->stemDirLeft = note->getThroatDirection();
}
else
{
GRGlobalStem * stem = findGlobalStem( sse, startElement );
if( stem )
{
stem->getHighestAndLowestNoteHead( &ioContext->topLeftHead, &ioContext->bottomLeftHead );
ioContext->stemDirLeft = stem->getStemDir();
}
ioContext->leftChordStem = stem;
}
}
// (JB) \bug There is probably a bug somewhere: with map mode
// different than "ISOTROPIC" (proportionnal), beamings polygons between "UP" stems
// draw at an incorrect x position, while "DOWN" beams are always ok.
//
// Too long, needs some code-factorization, if possible.
void GRBeam::tellPosition( GObject * gobj, const NVPoint & p_pos)
{
/* Beams are polygons made of four points:
0 2
------------------
| |
------------------
1 3
*/
// a new test is performed: if it is a systemTag and
// it is not a systemcall (checkpos), than we can just do nothing.
if (error || !mAssociated || ( mAssociated->GetCount() == 0 )
|| ( tagtype == GRTag::SYSTEMTAG && !mIsSystemCall ))
return;
GRNotationElement * el = dynamic_cast<GRNotationElement *>(gobj);
if (!el || !el->getGRStaff())
return;
GRSystemStartEndStruct * sse = getSystemStartEndStruct(el->getGRStaff()->getGRSystem());
assert(sse);
if (el != sse->endElement)
return;
GRBeamSaveStruct * st = (GRBeamSaveStruct *)sse->p;
GuidoPos pos;
GREvent * startEl = GREvent::cast(sse->startElement);
GREvent * endEl = GREvent::cast(sse->endElement);
// this is the staff to which the beam belongs and who draws it.
const GRStaff * beamstaff = sse->startElement->getGRStaff();
PosInfos infos = { dirUP, LSPACE, 1.0f, (endEl == startEl)};
ARBeam * arBeam = getARBeam();
const bool isSpecBeam = arBeam->isGuidoSpecBeam();
if(startEl)
infos.stemdir = startEl->getStemDirection();
else if(endEl)
infos.stemdir = endEl->getStemDirection();
if(level != 0)
return;
NVPoint offset = initp0 (sse, startEl, infos);
initp1 (sse, infos);
offset = initp2 (sse, endEl, infos);
initp3 (sse, infos);
// -----------------------------------------------------------
// Now, we adjust the stemlengths, according to beamslope ...
// we have the start and end-position in st->p
// We have to determine the slope and adjust the slope to minimum and maximum ...
// -----------------------------------------------------------
float stemWidth = st->p[2].x - st->p[0].x;
float slope = (st->p[2].y - st->p[0].y) / stemWidth;
// another hack to control the slope when events are on different staves - DF sept 15 2009
if (startEl && endEl && (startEl->getGRStaff() != endEl->getGRStaff())) {
while ((slope < -0.20) || (slope > 0.20)) {
float shift = (slope < 0) ? -LSPACE/4 : LSPACE/4;
st->p[0].y += shift;
st->p[1].y += shift;
st->p[2].y -= shift;
st->p[3].y -= shift;
slope = (st->p[2].y - st->p[0].y) / stemWidth;
}
}
bool needsadjust = true;
// we have to adjust the slope ONLY if the stemlength
// of the first and last element has not been set automatically!
// and if we are note in the case of a chained feather beam
if ( (startEl && startEl->getStemLengthSet() && endEl && endEl->getStemLengthSet())
|| tagtype == SYSTEMTAG || (arBeam && isSpecBeam) || (isFeathered && startEl && startEl->stemHasBeenChanged()))
{
needsadjust = false;
}
else slopeAdjust (sse, startEl, endEl, slope, infos);
if (arBeam && isSpecBeam)
{
// then we have to set the length ... if it is not set otherwise ...
GRSingleNote * nt = dynamic_cast<GRSingleNote *>(sse->startElement);
if(nt && !nt->getStemLengthSet()) {
const float myval = arBeam->dy1->getValue();
nt->setStemLength( myval);
}
nt = dynamic_cast<GRSingleNote *>(sse->endElement);
if(nt && !nt->getStemLengthSet()) {
float myval;
if (arBeam->dy3 && arBeam->dy3->TagIsSet())
myval = arBeam->dy3->getValue();
else
myval = arBeam->dy1->getValue();
nt->setStemLength( myval);
}
}
float offsetbeam = 0;
// nobeamoffset describes, if no beamoffset is valid: if notes ask for different beam-offsets
// then, there is just no offset .... things must be changed manually then ....
bool nobeamoffset = false;
if(( startEl && startEl->getStemLengthSet()) || ( endEl && endEl->getStemLengthSet()))
nobeamoffset = true;
for (int counter = 0; counter < 2; ++counter )
{
if (counter == 1) {
if ((offsetbeam == 0) || nobeamoffset) break;
else if (!nobeamoffset) {
st->p[0].y -= offsetbeam;
st->p[1].y -= offsetbeam;
st->p[2].y -= offsetbeam;
st->p[3].y -= offsetbeam;
offsetbeam = 0;
}
}
pos = sse->startpos;
while (pos)
{
// now we calculate the stem-end-positions ...
GuidoPos oldpos = pos;
GREvent * sn = GREvent::cast(mAssociated->GetNext(pos));
if (sn)
{
float rx = sn->getStemStartPos().x - st->p[0].x;
if (tagtype == SYSTEMTAG)
rx += sn->getGRStaff()->getPosition().x;
float disty = st->p[2].y - st->p[0].y;
float distx = st->p[2].x - st->p[0].x;
float ly = disty / distx * rx;
ly += st->p[0].y;
float diffy = (float)sn->getStemStartPos().y;
GDirection adjustdir=dirAUTO;
if (sn->getStemDirection() == dirUP)
{
diffy += (float)sn->getStemLength();
adjustdir = dirUP;
}
else if (sn->getStemDirection() == dirDOWN)
{
adjustdir = dirDOWN;
diffy -= (float)sn->getStemLength();
}
ly -= diffy;
if (tagtype == SYSTEMTAG)
ly -= (float)sn->getGRStaff()->getPosition().y;
// if we have a beam between grace notes, we don't want an offbase that whould make the stems too long
GRNote * gnote = dynamic_cast<GRNote*>(startEl);
bool isGrace = gnote ? gnote->isGraceNote() : false;
float offbase = isGrace ? 0 : 3.5f * infos.currentLSPACE;
if (ly < 0)
{
if (needsadjust) {
if (adjustdir == dirDOWN)
{
const float newoffs = ly - offbase;
if (newoffs < offsetbeam)
{
if (offsetbeam > 0)
{
GuidoTrace("WARNING: different beam adjustments!");
nobeamoffset = true;
}
else offsetbeam = newoffs;
}
ly = -offbase;
}
else if (ly > -offbase)
{
const float newoffs = ly + offbase;
if (newoffs > offsetbeam)
{
if (offsetbeam < 0)
{
GuidoTrace("WARNING: different beam adjustments!");
nobeamoffset = true;
}
else offsetbeam = newoffs;
}
}
}
ly = -ly;
}
else if (needsadjust) {
if (adjustdir == dirUP)
{
const float newoffs = ly + offbase;
if (newoffs > offsetbeam)
{
if (offsetbeam < 0)
{
GuidoTrace("WARNING: different beam adjustments!");
nobeamoffset = true;
}
else offsetbeam = newoffs;
}
ly = offbase;
}
else if (ly < offbase)
{
const float newoffs = ly - offbase;
if (newoffs < offsetbeam)
{
if (offsetbeam > 0)
{
GuidoTrace("WARNING: different beam adjustments!");
nobeamoffset = true;
}
else offsetbeam = newoffs;
}
}
}
// sn->changeStemLength( ly );
// adjusted - DF sept 15 2009
sn->changeStemLength( ly - infos.currentLSPACE/20 );
// so that the possible next featherd beam knows that he is chained
// (and musn't change its slope)
sn->setStemChanged();
}
if (oldpos == sse->endpos)
break;
}
//endEl->setStemChanged();
}
if(!smallerBeams.empty())
{
for(std::vector<GRBeam *>::iterator it = smallerBeams.begin(); it < smallerBeams.end(); it++)
{
(*it)->decLevel();
(*it)->tellPosition((*it)->getEndElement(), (*it)->getEndElement()->getPosition());
}
return;
}
// -- Now we need to add the simplebeams as simplebeamgroups ...
NVPoint myp[4];
int dir = st->direction;
if (st->dirset)
{
// then the direction was set explicitly by the user ...
GREvent * sn = GREvent::cast(mAssociated->GetHead());
if (sn)
dir = sn->getStemDirection();
}
else dir = infos.stemdir;
bool first = true;
pos = sse->startpos;
// - These constants define the space and the thickness of additionnal beams.
const float yFact1 = 0.75f * infos.currentLSPACE; // was 0.7f
const float yFact2 = 0.4f * infos.currentLSPACE;
// if we have a feathered beam, we just have to draw the main beam (already done)
// and the other simple beams will only depend on the begining and ending
// points, regardless of the durations of the inner notes.
if(isFeathered)
{
ARFeatheredBeam * ar = static_cast<ARFeatheredBeam *>(getARBeam()->isARFeatheredBeam());
int begin = 0;
int end = 0;
GREvent * stemNoteBegin = GREvent::cast(mAssociated->GetHead());
GDirection localDir = stemNoteBegin->getStemDirection();
float yLocalFact1 = yFact1 * localDir * infos.currentSize;
float yLocalFact2 = yFact2 * localDir * infos.currentSize;
// if the user hasn't set the durations as parameters,
// we will take the first and last notes'durations
if(!ar->isDurationsSet())
{
ar->findDefaultPoints();
}
end = ar->getLastBeaming();
begin = ar->getFirstBeaming();
for(int i=1;i<=begin; i++)
{
myp[0] = st->p[0];
myp[0].y += (i-1) * yLocalFact1;
myp[1].x = myp[0].x;
myp[1].y = myp[0].y + yLocalFact2;
myp[2] = st->p[2];
if(end>i ||(end==i && i!=1)) // no need to draw the main beam again.
myp[2].y += (i-1) * yLocalFact1;
else
myp[2].y += (end-1) * yLocalFact1;
myp[3].x = myp[2].x;
myp[3].y = myp[2].y + yLocalFact2;
GRSimpleBeam * tmpbeam = new GRSimpleBeam(this,myp);
if( st->simpleBeams == 0 )
st->simpleBeams = new SimpleBeamList(1);
st->simpleBeams->AddTail(tmpbeam);
}
// if end > begin
for(int i=begin; i<end; i++)
{
myp[0] = st->p[0];
myp[0].y += (begin-1) * yLocalFact1;
myp[1].x = myp[0].x;
myp[1].y = myp[0].y + yLocalFact2;
myp[2] = st->p[2];
myp[2].y += i * yLocalFact1;
myp[3].x = myp[2].x;
myp[3].y = myp[2].y + yLocalFact2;
GRSimpleBeam * tmpbeam = new GRSimpleBeam(this,myp);
if( st->simpleBeams == 0 )
st->simpleBeams = new SimpleBeamList(1);
st->simpleBeams->AddTail(tmpbeam);
}
// in order to draw the total duration of the beam
if(drawDur)
{
TYPE_TIMEPOSITION begin = ar->getBeginTimePosition();
TYPE_TIMEPOSITION end = ar->getEndTimePosition();
TYPE_DURATION dur = end - begin;
int num = dur.getNumerator();
int den = dur.getDenominator();
stringstream out;
out << num << '/' << den;
st->duration = out.str();
size_t n = st->duration.length();
GREvent * ev = dynamic_cast<GREvent *>(mAssociated->GetHead());
const NVPoint p1 = ev->getStemEndPos();
float xBegin = ev->getPosition().x;
ev = dynamic_cast<GREvent *>(mAssociated->GetTail());
const NVPoint p2 = ev->getStemEndPos();
float xEnd = ev->getPosition().x + ev->getBoundingBox().Width()/2;
int dir = ev->getStemDirection();
float Y1;
float Y2;
if(dir>0)
{
Y1 = min(p1.y, p2.y) - LSPACE;
if(Y1>=getLastPositionOfBarDuration().first && Y1<getLastPositionOfBarDuration().second+LSPACE/2)
Y1 -= LSPACE;
Y2 = Y1 - LSPACE/2;
getLastPositionOfBarDuration().first = Y2;
getLastPositionOfBarDuration().second = Y1;
}
else
{
Y1 = max(p1.y, p2.y) + LSPACE;
if(Y1>=getLastPositionOfBarDuration().first-LSPACE/2 && Y1<getLastPositionOfBarDuration().second)
Y1 += LSPACE;
Y2 = Y1 + LSPACE/2;
getLastPositionOfBarDuration().first = Y1;
getLastPositionOfBarDuration().second = Y2;
}
if (xBegin > xEnd)
{
if (sse->endflag == GRSystemStartEndStruct::OPENRIGHT)
xEnd = sse->endElement->getPosition().x;
if (sse->startflag == GRSystemStartEndStruct::OPENLEFT)
xBegin = sse->startElement->getPosition().x;
}
float x = xBegin + (xEnd - xBegin) / 2;
float X1 = x - (n - 0.5f) / 2 * LSPACE;
float X2 = x + (n - 0.5f) / 2 * LSPACE;
st->DurationLine[0] = NVPoint(xBegin, Y1);
st->DurationLine[1] = NVPoint(xBegin, Y2);
st->DurationLine[2] = NVPoint(X1, Y2);
st->DurationLine[3] = NVPoint(X2, Y2);
st->DurationLine[4] = NVPoint(xEnd, Y2);
st->DurationLine[5] = NVPoint(xEnd, Y1);
}
}
// for beam length adjustment - DF sept 15 2009
const float xadjust = infos.currentLSPACE/10;
GDirection lastLocalDir = dirOFF;
int previousBeamsCount = 0;
while (pos && !isFeathered)
{
GuidoPos oldpos = pos;
GREvent * stemNote = GREvent::cast(mAssociated->GetNext(pos));
if (stemNote)
{
GDirection localDir = stemNote->getStemDirection();
float yLocalFact1 = yFact1 * localDir * infos.currentSize;
float yLocalFact2 = yFact2 * localDir * infos.currentSize;
// now we check the number of beams ...
if (stemNote->getBeamCount() < stemNote->getNumFaehnchen())
{
float beamCount = (float)(stemNote->getBeamCount());
stemNote->incBeamCount();
if (first && (sse->startflag == GRSystemStartEndStruct::OPENLEFT)) {
// the additional beam starts at the startElement (glue), we have more beams to draw
myp[0] = sse->startElement->getPosition();
if (tagtype == SYSTEMTAG)
myp[0] += stemNote->getGRStaff()->getPosition();
myp[1] = myp[0];
// first = false; // never read (according to clang :-)
}
else {
// the additional beam starts at sn. We have more beams to draw
myp[0] = stemNote->getStemStartPos();
if (tagtype == SYSTEMTAG)
myp[0] += stemNote->getGRStaff()->getPosition();
myp[0].y += beamCount * yLocalFact1;
if (localDir != dir)
myp[0].y -= yLocalFact2;
myp[1].x = myp[0].x;
myp[1].y = myp[0].y + yLocalFact2;
}
// now we look for the endposition
GREvent * sn2 = NULL;
GuidoPos tmppos = pos;
// partialbeam is set, if the new SimpleBeam only covers part of the masterBeam.
int partialbeam = 0;
while (tmppos)
{
GuidoPos oldpos2 = tmppos;
GREvent * tmpsn = GREvent::cast(mAssociated->GetNext(tmppos));
if (tmpsn) {
if (tmpsn->getBeamCount() < tmpsn->getNumFaehnchen())
{
sn2 = tmpsn;
sn2->incBeamCount();
continue;
}
else
{
partialbeam = 1;
break;
}
}
if (oldpos2 == sse->endpos)
break;
}
if (sn2)
{
if (!partialbeam && sse->endflag == GRSystemStartEndStruct::OPENRIGHT)
{
// then the position is different ...
myp[2] = sse->endElement->getPosition();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += sn2->getGRStaff()->getPosition();
myp[2].y = myp[0].y;
}
else
{
// we have an End-Position ...
myp[2] = sn2->getStemEndPos();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += sn2->getGRStaff()->getPosition();
myp[2].y += beamCount * yLocalFact1;
}
if (localDir != dir)
myp[2].y -= yLocalFact2;
myp[3].x = myp[2].x;
myp[3].y = myp[2].y + yLocalFact2;
}
else
{
// we do not have an End-Positon single beam ... (meaning a single straight flag)
// but only, if it is not open on the left or the right hand side.
const float slope = (float)(st->p[2].y - st->p[0].y ) / (float)(st->p[2].x - st->p[0].x);
if (sse->startflag == GRSystemStartEndStruct::OPENLEFT)
{
// then we have to deal with the startposition of the glue-element ....
// BUT, you can only set this, if the previous beam had this beamcount at the end ....
// how do I know that? not now.
// sn is the only element .... and we are open on the left ...
if (tagtype == SYSTEMTAG)
myp[0] += stemNote->getGRStaff()->getPosition();
myp[1] = myp[0];
myp[2] = stemNote->getStemEndPos();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += stemNote->getGRStaff()->getPosition();
myp[2].y += beamCount * yLocalFact1;
if (localDir != dir)
myp[2].y -= yLocalFact2;
myp[3] = myp[2];
myp[3].y += yLocalFact2;
}
else if (sse->endflag == GRSystemStartEndStruct::OPENRIGHT)
{
myp[0] = stemNote->getStemEndPos();
if (tagtype == SYSTEMTAG)
myp[0] += stemNote->getGRStaff()->getPosition();
myp[0].y += beamCount * yLocalFact1;
if (localDir != dir)
myp[0].y -= yLocalFact2;
myp[1] = myp[0];
myp[1].y += yLocalFact2;
myp[2] = sse->endElement->getPosition();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += sn2->getGRStaff()->getPosition();
myp[2].y = myp[0].y;
myp[3].x = myp[2].x;
myp[3].y = myp[1].y;
}
/* 26/11/03
Beaming bug: wrong direction for partial beam (beam-bug.gmn)
can be tested but changing this test.
startpos check added to correct problem with partial beam
going outside a group like in [ _/16 c d/8 ]
*/
else if( oldpos == sse->endpos || pos == NULL || ((!stemNote->isSyncopated()) && (oldpos != sse->startpos)))
{
// Partial beams leftward ( using slope)
myp[2] = stemNote->getStemEndPos();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += stemNote->getGRStaff()->getPosition();
if (localDir != dir)
myp[2].y -= yLocalFact2;
myp[2].y += beamCount * yLocalFact1;
myp[3] = myp[2];
myp[3].y += yLocalFact2;
myp[0] = myp[2];
myp[0].x -= infos.currentLSPACE;
myp[0].y -= slope * infos.currentLSPACE;
myp[1] = myp[0];
myp[1].y += yLocalFact2;
// ? We are at the end, there is no valid event at the end ... so what do we do?
// useless tests: the code was the same and is now outside the test (above) - DF sept 15 2009
/*
if (sse->endflag == GRSystemStartEndStruct::OPENRIGHT)
{
}
else
{
}
*/
}
else
{
// Partial beams rightward ( using slope)
myp[2] = myp[0];
myp[2].x += infos.currentLSPACE;
myp[2].y += slope * infos.currentLSPACE;
myp[3] = myp[2];
myp[3].y += yLocalFact2;
}
}
// now we construct a SimpleBeam, we now have to "undo" the systemTag-stuff
if (tagtype == SYSTEMTAG)
{
const NVPoint & offset = beamstaff->getPosition();
myp[0] -= offset;
myp[1] -= offset;
myp[2] -= offset;
myp[3] -= offset;
}
if (sse->startflag == GRSystemStartEndStruct::OPENLEFT)
{
myp[0].y = myp[2].y;
myp[1].y = myp[3].y;
}
GRSimpleBeam * tmpbeam = new GRSimpleBeam(this,myp);
if( st->simpleBeams == 0 )
st->simpleBeams = new SimpleBeamList(1);
st->simpleBeams->AddTail(tmpbeam);
pos = sse->startpos;
oldpos = pos;
first = true;
lastLocalDir = localDir;
previousBeamsCount = stemNote->getBeamCount() - 1;
}
// a new hack, again to catch stems directions change - DF sept 15 2009
else if (localDir != dir) {
// check for stems length
NVPoint stemloc = stemNote->getStemStartPos();
if (tagtype == SYSTEMTAG)
stemloc += stemNote->getGRStaff()->getPosition();
int beamscount = stemNote->getBeamCount() - 1;
if ((beamscount > 0) && (previousBeamsCount > beamscount) && (lastLocalDir != localDir)) {
if (localDir == dirUP)
stemNote->changeStemLength(stemNote->getStemLength() + (yLocalFact1 * beamscount));
else if (localDir == dirDOWN)
stemNote->changeStemLength(stemNote->getStemLength() - (yLocalFact1 * beamscount));
}
}
}
if (oldpos == sse->endpos)
break;
}
GuidoPos stemPos = sse->startpos;
while(stemPos)
{
GREvent * stemNote = GREvent::cast(mAssociated->GetNext(stemPos));
if(stemNote)
{
GuidoPos tagpos = NULL;
if (stemNote->getAssociations())
tagpos = stemNote->getAssociations()->GetHeadPosition();
while(tagpos)
{
GRNotationElement * tag = stemNote->getAssociations()->GetNext(tagpos);
GRTremolo * trem = dynamic_cast<GRTremolo*>(tag);
if(trem)
{
trem->tellPosition(stemNote,stemNote->getPosition());
if(trem->isTwoNotesTremolo()) // in order to force the second pitch (especially the chords) to update
{
GREvent * secondPitch = dynamic_cast<GREvent*>(mAssociated->GetNext(stemPos));
if(secondPitch) trem->tellPosition(secondPitch, secondPitch->getPosition());
}
}
}
}
}
// now we have to make sure, that the original positions
// for the beam are set for the right staff
if (tagtype == SYSTEMTAG)
{
const NVPoint &offset = beamstaff->getPosition();
st->p[0] -= offset;
st->p[1] -= offset;
st->p[2] -= offset;
st->p[3] -= offset;
}
}
// (JB) \bug There is probably a bug somewhere: with map mode
// different than "ISOTROPIC" (proportionnal), beamings polygons between "UP" stems
// draw at an incorrect x position, while "DOWN" beams are always ok.
//
// Too long, needs some code-factorization, if possible.
void GRBeam::tellPosition( GObject * gobj, const NVPoint & p_pos)
{
/* Beams are polygons made of four points:
0 2
------------------
| |
------------------
1 3
*/
// a new test is performed: if it is a systemTag and
// it is not a systemcall (checkpos), than we can just do nothing.
if (error || !mAssociated || ( mAssociated->GetCount() == 0 )
|| ( tagtype == GRTag::SYSTEMTAG && !mIsSystemCall ))
return;
GRNotationElement * el = dynamic_cast<GRNotationElement *>(gobj);
if (!el || !el->getGRStaff())
return;
GRSystemStartEndStruct * sse = getSystemStartEndStruct(el->getGRStaff()->getGRSystem());
assert(sse);
if (el != sse->endElement)
return;
GRBeamSaveStruct * st = (GRBeamSaveStruct *)sse->p;
GuidoPos pos;
GREvent * startEl = GREvent::cast(sse->startElement);
GREvent * endEl = GREvent::cast(sse->endElement);
// this is the staff to which the beam belongs and who draws it.
const GRStaff * beamstaff = sse->startElement->getGRStaff();
PosInfos infos = { dirUP, LSPACE, 1.0f, (endEl == startEl)};
ARBeam * arBeam = getARBeam();
const bool isSpecBeam = arBeam->isGuidoSpecBeam();
NVPoint offset = initp0 (sse, startEl, infos);
initp1 (sse, infos);
offset = initp2 (sse, endEl, infos);
initp3 (sse, infos);
// -----------------------------------------------------------
// Now, we adjust the stemlengths, according to beamslope ...
// we have the start and end-position in st->p
// We have to determine the slope and adjust the slope to minimum and maximum ...
// -----------------------------------------------------------
float stemWidth = st->p[2].x - st->p[0].x;
float slope = (st->p[2].y - st->p[0].y) / stemWidth;
// another hack to control the slope when events are on different staves - DF sept 15 2009
if (startEl && endEl && (startEl->getGRStaff() != endEl->getGRStaff())) {
while ((slope < -0.20) || (slope > 0.20)) {
float shift = (slope < 0) ? -LSPACE/4 : LSPACE/4;
st->p[0].y += shift;
st->p[1].y += shift;
st->p[2].y -= shift;
st->p[3].y -= shift;
slope = (st->p[2].y - st->p[0].y) / stemWidth;
}
}
bool needsadjust = true;
// we have to adjust the slope ONLY, if the stemlength
// of the first and last element has not been set automatically!
if ( (startEl && startEl->getStemLengthSet() && endEl && endEl->getStemLengthSet())
|| tagtype == SYSTEMTAG || (arBeam && isSpecBeam))
{
needsadjust = false;
}
else slopeAdjust (sse, startEl, endEl, slope, infos);
if (arBeam && isSpecBeam)
{
// then we have to set the length ... if it is not set otherwise ...
GRSingleNote * nt = dynamic_cast<GRSingleNote *>(sse->startElement);
if(nt && !nt->getStemLengthSet()) {
const float myval = arBeam->dy1->getValue();
nt->setStemLength( myval);
}
nt = dynamic_cast<GRSingleNote *>(sse->endElement);
if(nt && !nt->getStemLengthSet()) {
float myval;
if (arBeam->dy3 && arBeam->dy3->TagIsSet())
myval = arBeam->dy3->getValue();
else
myval = arBeam->dy1->getValue();
nt->setStemLength( myval);
}
}
float offsetbeam = 0;
// nobeamoffset describes, if no beamoffset is valid: if notes ask for different beam-offsets
// then, there is just no offset .... things must be changed manually then ....
bool nobeamoffset = false;
if(( startEl && startEl->getStemLengthSet()) || ( endEl && endEl->getStemLengthSet()))
nobeamoffset = true;
for (int counter = 0; counter < 2; ++counter )
{
if (counter == 1) {
if ((offsetbeam == 0) || nobeamoffset) break;
else if (!nobeamoffset) {
st->p[0].y -= offsetbeam;
st->p[1].y -= offsetbeam;
st->p[2].y -= offsetbeam;
st->p[3].y -= offsetbeam;
offsetbeam = 0;
}
}
pos = sse->startpos;
while (pos)
{
// now we calculate the stem-end-positions ...
GuidoPos oldpos = pos;
GREvent * sn = GREvent::cast(mAssociated->GetNext(pos));
if (sn)
{
float rx = sn->getStemStartPos().x - st->p[0].x;
if (tagtype == SYSTEMTAG)
rx += sn->getGRStaff()->getPosition().x;
float disty = st->p[2].y - st->p[0].y;
float distx = st->p[2].x - st->p[0].x;
float ly = disty / distx * rx;
ly += st->p[0].y;
float diffy = (float)sn->getStemStartPos().y;
GDirection adjustdir=dirAUTO;
if (sn->getStemDirection() == dirUP)
{
diffy += (float)sn->getStemLength();
adjustdir = dirUP;
}
else if (sn->getStemDirection() == dirDOWN)
{
adjustdir = dirDOWN;
diffy -= (float)sn->getStemLength();
}
ly -= diffy;
if (tagtype == SYSTEMTAG)
ly -= (float)sn->getGRStaff()->getPosition().y;
float offbase = 3.5f * infos.currentLSPACE;
if (ly < 0)
{
if (needsadjust) {
if (adjustdir == dirDOWN)
{
const float newoffs = ly - offbase;
if (newoffs < offsetbeam)
{
if (offsetbeam > 0)
{
GuidoTrace("WARNING: different beam adjustments!");
nobeamoffset = true;
}
else offsetbeam = newoffs;
}
ly = -offbase;
}
else if (ly > -offbase)
{
const float newoffs = ly + offbase;
if (newoffs > offsetbeam)
{
if (offsetbeam < 0)
{
GuidoTrace("WARNING: different beam adjustments!");
nobeamoffset = true;
}
else offsetbeam = newoffs;
}
}
}
ly = -ly;
}
else if (needsadjust) {
if (adjustdir == dirUP)
{
const float newoffs = ly + offbase;
if (newoffs > offsetbeam)
{
if (offsetbeam < 0)
{
GuidoTrace("WARNING: different beam adjustments!");
nobeamoffset = true;
}
else offsetbeam = newoffs;
}
ly = offbase;
}
else if (ly < offbase)
{
const float newoffs = ly - offbase;
if (newoffs < offsetbeam)
{
if (offsetbeam > 0)
{
GuidoTrace("WARNING: different beam adjustments!");
nobeamoffset = true;
}
else offsetbeam = newoffs;
}
}
}
// sn->changeStemLength( ly );
// adjusted - DF sept 15 2009
sn->changeStemLength( ly - infos.currentLSPACE/20 );
}
if (oldpos == sse->endpos)
break;
}
}
// -- Now we need to add the simplebeams as simplebeamgroups ...
NVPoint myp[4];
int dir = st->direction;
if (st->dirset)
{
// then the direction was set explicitly by the user ...
GREvent * sn = GREvent::cast(mAssociated->GetHead());
if (sn)
dir = sn->getStemDirection();
}
else dir = infos.stemdir;
bool first = true;
pos = sse->startpos;
// - These constants defines the space and the thickness of additionnal beams.
const float yFact1 = 0.75f * infos.currentLSPACE; // was 0.7f
const float yFact2 = 0.4f * infos.currentLSPACE;
// for beam length adjustment - DF sept 15 2009
const float xadjust = infos.currentLSPACE/10;
GDirection lastLocalDir = dirOFF;
int previousBeamsCount = 0;
while (pos)
{
GuidoPos oldpos = pos;
GREvent * stemNote = GREvent::cast(mAssociated->GetNext(pos));
if (stemNote)
{
GDirection localDir = stemNote->getStemDirection();
float yLocalFact1 = yFact1 * localDir;
float yLocalFact2 = yFact2 * localDir;
// now we check the number of beams ...
if (stemNote->getBeamCount() < stemNote->getNumFaehnchen())
{
float beamCount = (float)(stemNote->getBeamCount());
stemNote->incBeamCount();
if (first && (sse->startflag == GRSystemStartEndStruct::OPENLEFT)) {
// the additional beam starts at the startElement (glue), we have more beams to draw
myp[0] = sse->startElement->getPosition();
if (tagtype == SYSTEMTAG)
myp[0] += stemNote->getGRStaff()->getPosition();
myp[1] = myp[0];
// first = false; // never read (according to clang :-)
}
else {
// the additional beam starts at sn. We have more beams to draw
myp[0] = stemNote->getStemStartPos();
if (tagtype == SYSTEMTAG)
myp[0] += stemNote->getGRStaff()->getPosition();
myp[0].y += beamCount * yLocalFact1;
if (localDir != dir)
myp[0].y -= yLocalFact2;
myp[1].x = myp[0].x;
myp[1].y = myp[0].y + yLocalFact2;
}
// now we look for the endposition
GREvent * sn2 = NULL;
GuidoPos tmppos = pos;
// partialbeam is set, if the new SimpleBeam only covers part of the masterBeam.
int partialbeam = 0;
while (tmppos)
{
GuidoPos oldpos2 = tmppos;
GREvent * tmpsn = GREvent::cast(mAssociated->GetNext(tmppos));
if (tmpsn) {
if (tmpsn->getBeamCount() < tmpsn->getNumFaehnchen())
{
sn2 = tmpsn;
sn2->incBeamCount();
continue;
}
else
{
partialbeam = 1;
break;
}
}
if (oldpos2 == sse->endpos)
break;
}
if (sn2)
{
if (!partialbeam && sse->endflag == GRSystemStartEndStruct::OPENRIGHT)
{
// then the position is different ...
myp[2] = sse->endElement->getPosition();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += sn2->getGRStaff()->getPosition();
myp[2].y = myp[0].y;
}
else
{
// we have an End-Position ...
myp[2] = sn2->getStemEndPos();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += sn2->getGRStaff()->getPosition();
myp[2].y += beamCount * yLocalFact1;
}
if (localDir != dir)
myp[2].y -= yLocalFact2;
myp[3].x = myp[2].x;
myp[3].y = myp[2].y + yLocalFact2;
}
else
{
// we do not have an End-Positon single beam ... (meaning a single straight flag)
// but only, if it is not open on the left or the right hand side.
const float slope = (float)(st->p[2].y - st->p[0].y ) / (float)(st->p[2].x - st->p[0].x);
if (sse->startflag == GRSystemStartEndStruct::OPENLEFT)
{
// then we have to deal with the startposition of the glue-element ....
// BUT, you can only set this, if the previous beam had this beamcount at the end ....
// how do I know that? not now.
// sn is the only element .... and we are open on the left ...
if (tagtype == SYSTEMTAG)
myp[0] += stemNote->getGRStaff()->getPosition();
myp[1] = myp[0];
myp[2] = stemNote->getStemEndPos();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += stemNote->getGRStaff()->getPosition();
myp[2].y += beamCount * yLocalFact1;
if (localDir != dir)
myp[2].y -= yLocalFact2;
myp[3] = myp[2];
myp[3].y += yLocalFact2;
}
else if (sse->endflag == GRSystemStartEndStruct::OPENRIGHT)
{
myp[0] = stemNote->getStemEndPos();
if (tagtype == SYSTEMTAG)
myp[0] += stemNote->getGRStaff()->getPosition();
myp[0].y += beamCount * yLocalFact1;
if (localDir != dir)
myp[0].y -= yLocalFact2;
myp[1] = myp[0];
myp[1].y += yLocalFact2;
myp[2] = sse->endElement->getPosition();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += sn2->getGRStaff()->getPosition();
myp[2].y = myp[0].y;
myp[3].x = myp[2].x;
myp[3].y = myp[1].y;
}
/* 26/11/03
Beaming bug: wrong direction for partial beam (beam-bug.gmn)
can be tested but changing this test.
startpos check added to correct problem with partial beam
going outside a group like in [ _/16 c d/8 ]
*/
else if( oldpos == sse->endpos || pos == NULL || ((!stemNote->isSyncopated()) && (oldpos != sse->startpos)))
{
// Partial beams leftward ( using slope)
myp[2] = stemNote->getStemEndPos();
myp[2].x += xadjust;
if (tagtype == SYSTEMTAG)
myp[2] += stemNote->getGRStaff()->getPosition();
if (localDir != dir)
myp[2].y -= yLocalFact2;
myp[2].y += beamCount * yLocalFact1;
myp[3] = myp[2];
myp[3].y += yLocalFact2;
myp[0] = myp[2];
myp[0].x -= infos.currentLSPACE;
myp[0].y -= slope * infos.currentLSPACE;
myp[1] = myp[0];
myp[1].y += yLocalFact2;
// ? We are at the end, there is no valid event at the end ... so what do we do?
// useless tests: the code was the same and is now outside the test (above) - DF sept 15 2009
/*
if (sse->endflag == GRSystemStartEndStruct::OPENRIGHT)
{
}
else
{
}
*/
}
else
{
// Partial beams rightward ( using slope)
myp[2] = myp[0];
myp[2].x += infos.currentLSPACE;
myp[2].y += slope * infos.currentLSPACE;
myp[3] = myp[2];
myp[3].y += yLocalFact2;
}
}
// now we construct a SimpleBeam, we now have to "undo" the systemTag-stuff
if (tagtype == SYSTEMTAG)
{
const NVPoint & offset = beamstaff->getPosition();
myp[0] -= offset;
myp[1] -= offset;
myp[2] -= offset;
myp[3] -= offset;
}
if (sse->startflag == GRSystemStartEndStruct::OPENLEFT)
{
myp[0].y = myp[2].y;
myp[1].y = myp[3].y;
}
GRSimpleBeam * tmpbeam = new GRSimpleBeam(this,myp);
if( st->simpleBeams == 0 )
st->simpleBeams = new SimpleBeamList(1);
st->simpleBeams->AddTail(tmpbeam);
pos = sse->startpos;
oldpos = pos;
first = true;
lastLocalDir = localDir;
previousBeamsCount = stemNote->getBeamCount() - 1;
}
// a new hack, again to catch stems directions change - DF sept 15 2009
else if (localDir != dir) {
// check for stems length
NVPoint stemloc = stemNote->getStemStartPos();
if (tagtype == SYSTEMTAG)
stemloc += stemNote->getGRStaff()->getPosition();
int beamscount = stemNote->getBeamCount() - 1;
if ((beamscount > 0) && (previousBeamsCount > beamscount) && (lastLocalDir != localDir)) {
if (localDir == dirUP)
stemNote->changeStemLength(stemNote->getStemLength() + (yLocalFact1 * beamscount));
else if (localDir == dirDOWN)
stemNote->changeStemLength(stemNote->getStemLength() - (yLocalFact1 * beamscount));
}
}
}
if (oldpos == sse->endpos)
break;
}
// now we have to make sure, that the original positions
// for the beam are set for the right staff
if (tagtype == SYSTEMTAG)
{
const NVPoint &offset = beamstaff->getPosition();
st->p[0] -= offset;
st->p[1] -= offset;
st->p[2] -= offset;
st->p[3] -= offset;
}
}
void GRGlobalStem::updateGlobalStem(const GRStaff * inStaff)
{
// now we can adjust the headoffsets for the notes ...
// maybe we should sort the mAssociated list by y-position.
// then we can travers the noteheads an make the
// adjustion (semi-)automatic.
mAssociated->sort( &compnotposy );
const float curLSPACE = inStaff->getStaffLSPACE();
ARTHead::HEADSTATE sugHeadState;
ARTHead::HEADSTATE prevHeadState = ARTHead::NOTSET;
float prevposy = 0; // (JB) warning, was not initialized. I don't know if 0
// is a good init value ! TODO: verify.
// the first element is in most cases the empty-event!?
GRSingleNote * note = dynamic_cast<GRSingleNote *>(mFirstEl);
if (note)
{
note->adjustHeadPosition(ARTHead::NORMAL);
note->updateBoundingBox();
}
if (stemdir == dirDOWN)
{
sugHeadState = ARTHead::RIGHT;
GuidoPos pos = mAssociated->GetHeadPosition();
while (pos)
{
note = dynamic_cast<GRSingleNote *>(mAssociated->GetNext(pos));
if (note)
{
if (prevHeadState != ARTHead::NOTSET)
{
float cury = (float)note->getPosition().y;
if (tagtype == GRTag::SYSTEMTAG)
cury += (float)note->getGRStaff()->getPosition().y;
// y-values are ascending.
if (cury != prevposy && cury - prevposy < curLSPACE)
{
// then I have to reverse the headsuggestion.
if (prevHeadState == ARTHead::RIGHT)
sugHeadState = ARTHead::LEFT;
else
sugHeadState = ARTHead::RIGHT;
}
else if (cury - prevposy >= curLSPACE)
{
if (prevHeadState == ARTHead::LEFT)
sugHeadState = ARTHead::RIGHT;
}
}
ARTHead::HEADSTATE retHeadState = note->adjustHeadPosition(sugHeadState);
// now we have a current headstate ....
prevHeadState = retHeadState;
prevposy = note->getPosition().y;
if (tagtype == GRTag::SYSTEMTAG)
prevposy += note->getGRStaff()->getPosition().y;
note->updateBoundingBox();
}
}
}
else if (stemdir == dirUP || stemdir == dirOFF)
{
sugHeadState = ARTHead::LEFT;
GuidoPos pos = mAssociated->GetTailPosition();
while (pos)
{
note = dynamic_cast<GRSingleNote *>(mAssociated->GetPrev(pos));
if (note)
{
if (prevHeadState != ARTHead::NOTSET)
{
float cury = (float)note->getPosition().y;
if (tagtype == GRTag::SYSTEMTAG)
cury += note->getGRStaff()->getPosition().y;
// y-values are decending.
if (cury != prevposy && prevposy - cury < curLSPACE)
{
// then I have to reverse the headsuggestion.
if (prevHeadState == ARTHead::RIGHT)
sugHeadState = ARTHead::LEFT;
else
sugHeadState = ARTHead::RIGHT;
}
else if (prevposy - cury >= curLSPACE)
{
if (prevHeadState == ARTHead::RIGHT)
sugHeadState = ARTHead::LEFT;
}
}
ARTHead::HEADSTATE retHeadState = note->adjustHeadPosition(sugHeadState);
prevHeadState = retHeadState;
prevposy = note->getPosition().y;
if (tagtype == GRTag::SYSTEMTAG)
prevposy += note->getGRStaff()->getPosition().y;
note->updateBoundingBox();
}
}
}
else
{
assert(false);
}
}
void GRGlobalStem::addAssociation(GRNotationElement * grnot)
{
if (error) return;
GREvent * ev = GREvent::cast(grnot);
if( ev )
{
TYPE_DURATION evdur (ev->getDuration());
TYPE_DURATION durtempl;
GRSingleNote * sngnot = dynamic_cast<GRSingleNote *>(ev);
if (sngnot)
{
durtempl = sngnot->getDurTemplate();
}
// this changes the display-duration
// (nested display-duration-tags!)
if (durtempl>evdur && durtempl> dispdur)
dispdur = durtempl;
// take the length ...
if (evdur > DURATION_0)
{
if (mFirstEl)
{
// then we already have one duration event. In this
// case, the association is added because an other
// voice uses this globalstem because of a \chord<label>-Tag
ev->setGlobalStem(this);
ev->setNeedsSpring(1);
}
else
{
// then our springconstant changes ...
ev->setGlobalStem(this);
if (!mFirstEl)
ev->setNeedsSpring(1);
}
}
else
{
ev->setGlobalStem(this);
if (!mFirstEl)
ev->setNeedsSpring(1);
}
}
// This sets the first element in the range ...
if (mFirstEl == 0)
{
// this associates the first element with
// this tag ....
mFirstEl = grnot;
mFirstEl->addAssociation(this);
return;
// the firstElement is not added to the associated
// ones -> it does not have to told anything!?
}
GRPTagARNotationElement::addAssociation(grnot);
// this is needed, because the share location can
// be used in different staves. Elements that need
// be told of the location can be deleted before this
// tag, therefor we must know, if these elements are
// deleted.
// The recursive cycle with tellPosition is broken,
// because only the first element really sets the
// position. And the first is not included in the
// own mAssociated list.
grnot->addAssociation(this);
}
