void GRPositionTag::removeAssociation(GRNotationElement * grnot)
{
// now we test, if the endElement or startElement
// is effected ...
const GRStaff * staff = grnot->getGRStaff();
if( staff )
{
GRSystemStartEndStruct * sse = getSystemStartEndStruct(staff->getGRSystem());
if (sse)
{
if (sse->startElement == grnot)
{
sse->startElement = NULL;
sse->startflag = GRSystemStartEndStruct::NOTKNOWN;
sse->startpos = NULL;
}
if (sse->endElement == grnot)
{
sse->endElement = NULL;
sse->endflag = GRSystemStartEndStruct::NOTKNOWN;
sse->endpos = NULL;
}
}
}
}
/** \brief Deletes the Staff from the sse (if it is found) and returns 1, if no more
staffs remain, that is sse is empty. Then the positiontag can be deleted.
*/
bool GRPositionTag::DeleteStaff(GRStaff * grstaff)
{
// if (error) return 1;
GRSystemStartEndStruct * sse = getSystemStartEndStruct(grstaff->getGRSystem());
if (!sse)
{
// assert(false);
return (mStartEndList.GetCount() == 0);
}
// also deletes it ...
// remove the associations ...
GRNotationElement * el = dynamic_cast<GRNotationElement *>(this);
if (el)
{
if (sse->startElement) sse->startElement->removeAssociation(el);
// here we have a real problem: there are some case where the endElement has been freed before this call and of course it crashes :-(
// since memory management is quite complex (and a bit messy), the only workaround I've found is to look at the associated fields
// with the hope that the memory is not reused in between (that's currently the case)
// a real solution would be to have automatic memory management using smart pointers...
// it'll have to be done sooner or later [D.F. 2012 march 6]
if (sse->endElement && sse->endElement->associated()) sse->endElement->removeAssociation(el);
}
// mStartEndList.setOwnership(0);
mStartEndList.RemoveElement(sse);
// mStartEndList.setOwnership(1);
// this really deletes the sse ...
// deleteSSE(sse);
return (mStartEndList.GetCount() == 0);
}
void GRPositionTag::setEndElement(const GRStaff * grstaff,
GRNotationElement * n_element)
{
GRSystemStartEndStruct * sse =
getSystemStartEndStruct(grstaff->getGRSystem());
assert(sse);
GRNotationElement * el = dynamic_cast<GRNotationElement *>(this);
assert(el);
if (sse->endElement)
{
sse->endElement->removeAssociation(el);
}
if (!error)
{
sse->endElement = n_element;
if (sse->endElement)
{
sse->endElement->addAssociation(el);
}
}
else
sse->endElement = NULL;
}
void GRPositionTag::RangeEnd(GRStaff * grstaff)
{
if (grstaff == 0) return;
GRSystemStartEndStruct * sse = getSystemStartEndStruct(grstaff->getGRSystem());
assert(sse);
if (error)
{
setStartElement(grstaff,NULL);
setEndElement(grstaff,NULL);
return;
}
NEPointerList * associated = NULL;
GRNotationElement * el = dynamic_cast<GRNotationElement *>(this);
if (el)
associated = el->getAssociations();
if (associated == 0) return;
if (sse->startflag == GRSystemStartEndStruct::LEFTMOST
&& sse->startElement == NULL)
{
setStartElement(grstaff,associated->GetHead());
sse->startpos = associated->GetHeadPosition();
}
setEndElement(grstaff,associated->GetTail());
sse->endflag = GRSystemStartEndStruct::RIGHTMOST;
sse->endpos = associated->GetTailPosition();
}
void GRDiminuendo::tellPosition(GObject *caller, const NVPoint & newPosition)
{
GRNotationElement * grel = dynamic_cast<GRNotationElement *>(caller);
if (grel == 0)
return;
GRStaff * staff = grel->getGRStaff();
if (staff == 0)
return;
GRSystemStartEndStruct * sse = getSystemStartEndStruct(staff->getGRSystem());
if (sse == 0)
return;
const GRNotationElement * const endElement = sse->endElement;
if (grel == endElement)
updateDiminuendo(staff);
}
void GRPositionTag::addAssociation(GRNotationElement * grnot)
{
if (error) return;
const GRStaff * pstaff = grnot->getGRStaff();
assert(pstaff);
GRSystemStartEndStruct * sse= getSystemStartEndStruct(pstaff->getGRSystem());
NEPointerList * associated = NULL;
GRNotationElement * el = dynamic_cast<GRNotationElement *>(this);
if (el)
associated = el->getAssociations();
if (!associated) return;
if (sse && sse->startflag == GRSystemStartEndStruct::OPENLEFT
&& sse->startpos == NULL)
sse->startpos = associated->GetTailPosition();
}
void GRPositionTag::StaffFinished(GRStaff * grstaff)
{
if (!grstaff) return;
GRSystemStartEndStruct * sse = getSystemStartEndStruct(grstaff->getGRSystem());
assert(sse);
if (error)
{
setStartElement(grstaff,NULL);
setEndElement(grstaff,NULL);
lastendElement = NULL;
return;
}
NEPointerList * associated = NULL;
GRNotationElement * el = dynamic_cast<GRNotationElement *>(this);
if (el)
associated = el->getAssociations();
if (associated == 0) return;
if (sse->startflag == GRSystemStartEndStruct::LEFTMOST
&& sse->startElement == NULL)
{
setStartElement(grstaff,associated->GetHead());
sse->startpos = associated->GetHeadPosition();
}
lastendflag = sse->endflag;
lastendElement = sse->endElement;
lastendpos = sse->endpos;
// there is no old lastendelement in this case
assert(lastendElement == NULL);
setEndElement(grstaff, /*ynamic_cast<GRNotationElement *>*/(grstaff->getEndGlue()));
sse->endflag = GRSystemStartEndStruct::OPENRIGHT;
sse->endpos = associated->GetTailPosition();
}
void GRCrescendo::OnDraw( VGDevice & hdc) const
{
if (!mDraw)
return;
if (fCrescInfos->points[0].x == fCrescInfos->points[1].x)
return;
assert(gCurSystem);
GRSystemStartEndStruct * sse = getSystemStartEndStruct(gCurSystem);
if (sse == 0)
return;
const VGColor prevTextColor = hdc.GetFontColor();
if (mColRef) {
hdc.PushPenColor(VGColor(mColRef));
hdc.PushFillColor(VGColor(mColRef));
hdc.SetFontColor(VGColor(mColRef));
}
hdc.PushPenWidth(fCrescInfos->thickness);
hdc.Line(fCrescInfos->points[0].x , fCrescInfos->points[0].y, fCrescInfos->points[1].x , fCrescInfos->points[1].y);
hdc.Line(fCrescInfos->points[0].x , fCrescInfos->points[0].y, fCrescInfos->points[2].x , fCrescInfos->points[2].y);
const float xMarkingOffset = fCrescInfos->points[1].x + 30;
const float yMarkingOffset = fCrescInfos->points[0].y - 277 + (mTagSize - 1) * 25;
if (fCrescInfos->fMarkingSymbol != 0)
OnDrawSymbol(hdc, fCrescInfos->fMarkingSymbol, xMarkingOffset, yMarkingOffset, mTagSize);
hdc.PopPenWidth();
if (mColRef) {
hdc.SetFontColor(prevTextColor);
hdc.PopFillColor();
hdc.PopPenColor();
}
}
void GRDiminuendo::updateDiminuendo(GRStaff * inStaff)
{
GRSystemStartEndStruct *sse = getSystemStartEndStruct(inStaff->getGRSystem());
if (sse == 0)
return;
// Collects informations about the context
fDimContext.staff = inStaff;
getDiminuendoBeginingContext(&fDimContext, sse);
getDiminuendoEndingContext(&fDimContext, sse);
ARDiminuendo *arDim = static_cast<ARDiminuendo *>(getAbstractRepresentation());
const float staffLSpace = inStaff->getStaffLSPACE();
assert(arDim);
/**** information gathering of parameters from the AR ****/
const char* dynamicMarking = arDim->getDynamicMarking().c_str();
if (!strcmp(dynamicMarking,"p"))
fDimInfos->fMarkingSymbol = kIntensPSymbol;
else if (!strcmp(dynamicMarking,"f"))
fDimInfos->fMarkingSymbol = kIntensFSymbol;
else if (!strcmp(dynamicMarking,"ff"))
fDimInfos->fMarkingSymbol = kIntensFFSymbol;
else if (!strcmp(dynamicMarking,"fff"))
fDimInfos->fMarkingSymbol = kIntensFFFSymbol;
else if (!strcmp(dynamicMarking,"ffff"))
fDimInfos->fMarkingSymbol = kIntensFFFFSymbol;
else if (!strcmp(dynamicMarking,"mf"))
fDimInfos->fMarkingSymbol = kIntensMFSymbol;
else if (!strcmp(dynamicMarking,"mp"))
fDimInfos->fMarkingSymbol = kIntensMPSymbol;
else if (!strcmp(dynamicMarking,"sf"))
fDimInfos->fMarkingSymbol = kIntensSFSymbol;
else if (!strcmp(dynamicMarking,"pp"))
fDimInfos->fMarkingSymbol = kIntensPPSymbol;
else if (!strcmp(dynamicMarking,"ppp"))
fDimInfos->fMarkingSymbol = kIntensPPPSymbol;
else if (!strcmp(dynamicMarking,"pppp"))
fDimInfos->fMarkingSymbol = kIntensPPPPSymbol;
else
fDimInfos->fMarkingSymbol = 0;
float dx1 = arDim->getDx1();
float dx2 = arDim->getDx2();
float dy = arDim->getDy();
float deltaY = arDim->getDeltaY();
float XLeft = 0;
float XRight = 0;
if (fDimContext.leftHead)
XLeft = fDimContext.leftHead->getPosition().x + fDimContext.leftNoteDX;
else
XLeft = sse->startElement->getPosition().x;
if (fDimContext.rightHead)
XRight = fDimContext.rightHead->getPosition().x + fDimContext.rightNoteDX;
else
XRight = sse->endElement->getPosition().x;
fDimInfos->points[0].x = fDimInfos->points[2].x = XLeft + dx1;
fDimInfos->points[1].x = XRight + dx2;
if (fDimInfos->points[0].x > fDimInfos->points[1].x)
{
fDimInfos->points[0].x = fDimInfos->points[2].x = XLeft;
fDimInfos->points[1].x = XRight;
}
mPosition.y = (GCoord)(6 * staffLSpace);
fDimInfos->points[0].y = mPosition.y + dy + deltaY / 2;
fDimInfos->points[1].y = mPosition.y + dy;
fDimInfos->points[2].y = mPosition.y + dy - deltaY / 2;
fDimInfos->thickness = arDim->getThickness();
}
/** \brief Called to break a tag at a previously saved PBreak-Location.
It sets the sse-Positions ...
(It is somewhat equivalent to StaffFinished,
with the difference, that assocpos is used). assocpos is the tail-position
of the associated list at the time of the pbreak-situation.
Now, this routine is called when a tag needs to be broken
because the optimum line break algorithm has determined the breaklocation.
*/
void GRPositionTag::BreakTag(GRStaff * grstaff, GuidoPos & assocpos)
{
if (grstaff == 0) return;
GRSystemStartEndStruct * sse = getSystemStartEndStruct(grstaff->getGRSystem());
assert(sse);
if (error)
{
setStartElement(grstaff,NULL);
setEndElement(grstaff,NULL);
lastendElement = NULL;
return;
}
// now we do something .....
NEPointerList * associated = 0;
GRNotationElement * el = dynamic_cast<GRNotationElement *>(this);
if (el)
associated = el->getAssociations();
if (!associated) return;
// only, if the startElement is not set and
// we do not have an OPENLEFT, the very first
// element from the association is made the
// startElement.
if (sse->startflag == GRSystemStartEndStruct::LEFTMOST
&& sse->startElement == NULL)
{
setStartElement(grstaff,associated->GetHead());
sse->startpos = associated->GetHeadPosition();
}
// now, we remeber the last end-setting ...
lastendElement = sse->endElement;
lastendflag = sse->endflag;
lastendpos = sse->endpos;
// now, we set the new OPENRIGHT and get the
// endglue ...
// the old association of the end-element MUST
// be maintained! ->
sse->endElement = NULL;
setEndElement(grstaff,grstaff->getEndGlue());
sse->endflag = GRSystemStartEndStruct::OPENRIGHT;
// this uses assocpos!
sse->endpos = assocpos;
sse->grsystem = grstaff->getGRSystem();
// now, we increment the assocpos, so that
// we can save this position for
// the NEW Segment build with ResumeTag
if (associated && assocpos)
associated->GetNext(assocpos);
// I now have to add a new sse-that handles the next system ?
}
void GRGlobalStem::RangeEnd( GRStaff * inStaff)
{
if (error || mFirstEl == 0) return;
GRPTagARNotationElement::RangeEnd(inStaff);
if (inStaff == 0) return;
GRSystemStartEndStruct * sse = getSystemStartEndStruct(inStaff->getGRSystem());
// this checks, wether all associated elements are
// on the same staff. If not, we build a new
// GRSystemTag that gets added to the system
// so that an update on all positions can be made ....
// (this is taken from GRBeam)
GuidoPos syststpos = sse->startpos;
if (tagtype != GRTag::SYSTEMTAG && syststpos)
{
// this is all done so that I really get a correct first staff to
// test my stuff ...
while (syststpos && !/*ynamic_cast<GRNotationElement *>*/(mAssociated->GetAt(syststpos)))
{
mAssociated->GetNext(syststpos);
}
// const GRStaff *tststaff = mAssociated->GetNext(syststpos)->getGRStaff();
int tststaffnum = mAssociated->GetNext(syststpos)->getStaffNumber();
while (syststpos)
{
GRNotationElement * el = mAssociated->GetNext(syststpos);
if (el)
{
if (el->getStaffNumber() != tststaffnum) // el->getGRStaff() != tststaff)
{
tagtype = GRTag::SYSTEMTAG;
GRSystemTag * mysystag = new GRSystemTag(this);
// sse->grsystem->addSystemTag(mysystag);
el->getGRSystemSlice()->addSystemTag(mysystag);
break;
}
}
}
}
if (tagtype != GRTag::SYSTEMTAG)
{
// check, whether firstel is on the same staff?
if (mFirstEl && mAssociated && mAssociated->GetHead())
{
if (mFirstEl->getStaffNumber() != mAssociated->GetHead()->getStaffNumber() ) // getGRStaff() != mAssociated->GetHead()->getGRStaff())
{
tagtype = GRTag::SYSTEMTAG;
GRSystemTag * mysystag = new GRSystemTag(this);
// sse->grsystem->addSystemTag(mysystag);
mFirstEl->getGRSystemSlice()->addSystemTag(mysystag);
}
}
}
GRNotationElement * el = /*dynamic cast<GRNotationElement *>*/(this);
const NEPointerList * associated = el ? el->getAssociations() : 0;
if (associated == 0)
return;
// now I have the associations ...
// I have to build the stem ....
delete theStem;
theStem = new GRStem(this);
if (mColRef)
theStem->setColRef( mColRef );
// the Vertical position of the Notes that share a stem
// must be already set ....
// mHighestY = mLowestY = -32767;
int highestlowestset = 0;
// only if the stemdir has not been set ....
if (stemdir == dirOFF)
{
stemdir = dirUP;
if (stemstate)
{
if (stemstate->getStemState() == ARTStem::UP)
{
// we have to determine the direction ourselves.
stemdir = dirUP;
}
else if (stemstate->getStemState() == ARTStem::DOWN)
{
// we have to determine the direction ourselves.
stemdir = dirDOWN;
}
else if (stemstate->getStemState() == ARTStem::OFF)
{
// we have to determine the direction ourselves.
stemdir = dirOFF;
}
}
if ( ( stemstate && stemstate->getStemState() == ARTStem::AUTO )
|| !stemstate)
{
// we have to determine the direction ourselves.
// this needs to be done with
// the direction of notes ...
GCoord middle = 0;
int count = 0;
// determine the lowest and highest position ...
el = associated->GetTail();
if (el)
{
middle = el->getPosition().y;
if (tagtype == GRTag::SYSTEMTAG && el->getGRStaff())
{
middle += (GCoord)el->getGRStaff()->getPosition().y;
}
mHighestY = middle;
mLowestY = middle;
++ count;
}
GuidoPos pos = associated->GetHeadPosition();
while (pos && pos != associated->GetTailPosition())
{
GRNotationElement * el = associated->GetNext(pos);
if (el && !dynamic_cast<GREmpty *>(el))
{
GCoord ypos = el->getPosition().y;
if (el->getGRStaff() && tagtype == GRTag::SYSTEMTAG)
ypos += el->getGRStaff()->getPosition().y;
middle += ypos;
++count ;
if (mLowestY > ypos) mLowestY = ypos;
if (mHighestY < ypos) mHighestY = ypos;
}
}
highestlowestset = 1;
if (count > 0)
middle /= count;
const float curLSPACE = (float)(inStaff->getStaffLSPACE());
const float mylowesty = 2 * curLSPACE - mLowestY;
const float myhighesty = mHighestY - 2 * curLSPACE;
if (mylowesty > myhighesty)
{
stemdir = dirDOWN;
}
else if (myhighesty > mylowesty)
stemdir = dirUP;
else
{
if (middle >= curLSPACE * 2)
{
stemdir = dirUP;
}
else if (middle < curLSPACE * 2)
{
stemdir = dirDOWN;
}
}
}
}
if (dispdur >= DURATION_1)
{
stemdir = dirOFF;
}
theStem->setStemDir(stemdir);
// otherwise it has been set because of auto-stem.
if (!highestlowestset)
{
// determine the lowest and highest position ...
el = associated->GetTail();
if (el)
{
mLowestY = el->getPosition().y;
if (tagtype == GRTag::SYSTEMTAG && el->getGRStaff())
{
mLowestY += el->getGRStaff()->getPosition().y;
}
mHighestY = mLowestY;
}
GuidoPos pos = associated->GetHeadPosition();
while (pos)
{
GRNotationElement * el = associated->GetNext(pos);
if (el && !dynamic_cast<GREmpty *>(el))
{
NVPoint elpos (el->getPosition());
if (tagtype == GRTag::SYSTEMTAG && el->getGRStaff())
{
elpos += el->getGRStaff()->getPosition();
}
if (mLowestY > elpos.y) mLowestY = elpos.y;
if (mHighestY < elpos.y) mHighestY = elpos.y;
}
}
}
// now we have the position of the lowest or highest note ...
if (stemdir == dirUP)
{
theStem->setPosition(NVPoint(0, (GCoord)mHighestY));
}
else if (stemdir == dirDOWN)
{
theStem->setPosition(NVPoint(0, (GCoord)mLowestY));
}
// now we have to deal with the length...
const TagParameterFloat * taglength = 0;
if (stemstate)
taglength = stemstate->getLength();
if (stemstate && taglength && taglength->TagIsSet())
{
// we have a length, that was definitly set...
theStem->setStemLength((float)(stemstate->getLength()->getValue()));
stemlengthset = true;
}
else
{
// length was not set ....
float length = (float)(mHighestY - mLowestY + inStaff->getStaffLSPACE() * 3.5f * mTagSize);
theStem->setStemLength( length );
}
delete theFlag;
// here we have to add the flags ...
theFlag = new GRFlag(this, dispdur,stemdir,theStem->getStemLength());
if (mColRef)
theFlag->setColRef(mColRef);
if (!mFlagOnOff)
theFlag->setFlagOnOff(mFlagOnOff);
if (stemdir == dirUP)
{
theFlag->setPosition(NVPoint(0, (GCoord)mHighestY));
}
else if (stemdir == dirDOWN)
{
theFlag->setPosition(NVPoint(0, (GCoord)mLowestY));
}
if (tagtype != GRTag::SYSTEMTAG)
updateGlobalStem(inStaff);
}