void Doc::LayOut( )
{
this->SetCurrentScoreDef();
Page *contentPage = this->SetDrawingPage( 0 );
assert( contentPage );
contentPage->LayOutHorizontally();
System *contentSystem = dynamic_cast<System*>(contentPage->DetachChild( 0 ));
assert( contentSystem );
System *currentSystem = new System();
contentPage->AddSystem( currentSystem );
int shift = 0;
int systemFullWidth = this->m_drawingPageWidth - this->m_drawingPageLeftMar - this->m_drawingPageRightMar
- currentSystem->m_systemLeftMar - currentSystem->m_systemRightMar;
ArrayPtrVoid params;
params.push_back( contentSystem );
params.push_back( contentPage );
params.push_back( ¤tSystem );
params.push_back( &shift );
params.push_back( &systemFullWidth );
Functor castOffSystems( &Object::CastOffSystems );
contentSystem->Process( &castOffSystems, params );
delete contentSystem;
LogDebug("Layout: %d systems", contentPage->GetSystemCount());
// Reset the scoreDef at the beginning of each system
this->SetCurrentScoreDef( true );
contentPage->LayOutVertically( );
// Detach the contentPage
this->DetachChild( 0 );
assert( contentPage && !contentPage->m_parent );
Page *currentPage = new Page();
this->AddPage( currentPage );
shift = 0;
int pageFullHeight = this->m_drawingPageHeight - this->m_drawingPageTopMar; // obviously we need a bottom margin
params.clear();
params.push_back( contentPage );
params.push_back( this );
params.push_back( ¤tPage );
params.push_back( &shift );
params.push_back( &pageFullHeight );
Functor castOffPages( &Object::CastOffPages );
contentPage->Process( &castOffPages, params );
delete contentPage;
LogDebug("Layout: %d pages", this->GetChildCount());
// We need to reset the drawing page to NULL
// because idx will still be 0 but contentPage is dead!
this->ResetDrawingPage( );
this->SetCurrentScoreDef( true );
}
float View::CalcInitialSlur(
FloatingCurvePositioner *curve, Slur *slur, Staff *staff, int layerN, curvature_CURVEDIR curveDir, Point points[4])
{
// For readability makes them p1 and p2
Point p1 = points[0];
Point p2 = points[3];
/************** height **************/
// the 'height' of the bezier
int height;
if (slur->HasBulge()) {
height = m_doc->GetDrawingUnit(staff->m_drawingStaffSize) * slur->GetBulge();
}
else {
int dist = abs(p2.x - p1.x);
height = std::max(int(m_options->m_slurMinHeight.GetValue() * m_doc->GetDrawingUnit(staff->m_drawingStaffSize)),
dist / m_options->m_slurHeightFactor.GetValue());
height = std::min(
int(m_options->m_slurMaxHeight.GetValue() * m_doc->GetDrawingUnit(staff->m_drawingStaffSize)), height);
}
// the height of the control points
height = height * 4 / 3;
/************** content **************/
System *system = dynamic_cast<System *>(staff->GetFirstParent(SYSTEM));
assert(system);
FindSpannedLayerElementsParams findSpannedLayerElementsParams(slur, slur);
findSpannedLayerElementsParams.m_minPos = p1.x;
findSpannedLayerElementsParams.m_maxPos = p2.x;
findSpannedLayerElementsParams.m_classIds
= { ACCID, ARTIC_PART, ARTIC, CHORD, FLAG, NOTE, STEM, TIE, TUPLET_BRACKET, TUPLET_NUM };
ArrayOfComparisons filters;
// Create ad comparison object for each type / @n
// For now we only look at one layer (assumed layer1 == layer2)
AttNIntegerComparison matchStaff(STAFF, staff->GetN());
AttNIntegerComparison matchLayer(LAYER, layerN);
filters.push_back(&matchStaff);
filters.push_back(&matchLayer);
Functor findSpannedLayerElements(&Object::FindSpannedLayerElements);
system->Process(&findSpannedLayerElements, &findSpannedLayerElementsParams, NULL, &filters);
curve->ClearSpannedElements();
for (auto &element : findSpannedLayerElementsParams.m_elements) {
Point pRotated;
Point pLeft;
pLeft.x = element->GetSelfLeft();
// if ((pLeft.x > p1->x) && (pLeft.x < p2->x)) {
// pLeft.y = (curveDir == curvature_CURVEDIR_above) ? element->GetSelfTop() : element->GetSelfBottom();
// spannedElements->push_back(spannedElement);
//}
Point pRight;
pRight.x = element->GetSelfRight();
// if ((pRight.x > p1->x) && (pRight.x < p2->x)) {
// pRight.y = (curveDir == curvature_CURVEDIR_above) ? element->GetSelfTop() : element->GetSelfBottom();
// spannedElements->push_back(spannedElement);
//}
if (((pLeft.x > p1.x) && (pLeft.x < p2.x)) || ((pRight.x > p1.x) && (pRight.x < p2.x))) {
CurveSpannedElement *spannedElement = new CurveSpannedElement;
spannedElement->m_boundingBox = element;
curve->AddSpannedElement(spannedElement);
}
}
for (auto &positioner : findSpannedLayerElementsParams.m_ties) {
CurveSpannedElement *spannedElement = new CurveSpannedElement;
spannedElement->m_boundingBox = positioner;
curve->AddSpannedElement(spannedElement);
}
/************** angle **************/
const ArrayOfCurveSpannedElements *spannedElements = curve->GetSpannedElements();
float slurAngle = slur->GetAdjustedSlurAngle(m_doc, p1, p2, curveDir, (spannedElements->size() > 0));
Point rotatedP2 = BoundingBox::CalcPositionAfterRotation(p2, -slurAngle, p1);
/************** control points **************/
Point rotatedC1, rotatedC2;
slur->GetControlPoints(m_doc, p1, rotatedP2, rotatedC1, rotatedC2, curveDir, height, staff->m_drawingStaffSize);
points[0] = p1;
points[1] = BoundingBox::CalcPositionAfterRotation(rotatedC1, slurAngle, p1);
points[2] = BoundingBox::CalcPositionAfterRotation(rotatedC2, slurAngle, p1);
points[3] = BoundingBox::CalcPositionAfterRotation(rotatedP2, slurAngle, p1);
return slurAngle;
}
