OLD | NEW |
1 /* | 1 /* |
2 This file is part of LilyPond, the GNU music typesetter. | 2 This file is part of LilyPond, the GNU music typesetter. |
3 | 3 |
4 Copyright (C) 1996--2020 Han-Wen Nienhuys <hanwen@xs4all.nl> | 4 Copyright (C) 1996--2020 Han-Wen Nienhuys <hanwen@xs4all.nl> |
5 | 5 |
6 LilyPond is free software: you can redistribute it and/or modify | 6 LilyPond is free software: you can redistribute it and/or modify |
7 it under the terms of the GNU General Public License as published by | 7 it under the terms of the GNU General Public License as published by |
8 the Free Software Foundation, either version 3 of the License, or | 8 the Free Software Foundation, either version 3 of the License, or |
9 (at your option) any later version. | 9 (at your option) any later version. |
10 | 10 |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
85 return dynamic_cast<const Spanner *> (g); | 85 return dynamic_cast<const Spanner *> (g); |
86 } | 86 } |
87 | 87 |
88 vsize | 88 vsize |
89 System::spanner_count () const | 89 System::spanner_count () const |
90 { | 90 { |
91 const vector<Grob *> &grobs = all_elements_->array (); | 91 const vector<Grob *> &grobs = all_elements_->array (); |
92 return std::count_if (grobs.begin (), grobs.end (), is_spanner); | 92 return std::count_if (grobs.begin (), grobs.end (), is_spanner); |
93 } | 93 } |
94 | 94 |
| 95 static uintptr_t |
| 96 break_dir_to_system (Direction dir) |
| 97 { |
| 98 return 16 + 8 * dir; |
| 99 } |
| 100 |
| 101 Grob * |
| 102 System::get_break_substitution (Grob *orig, Direction dir, Grob *system) const |
| 103 { |
| 104 Break_substitution_key k; |
| 105 k.orig_ = orig; |
| 106 k.system_ |
| 107 = dir ? break_dir_to_system (dir) : reinterpret_cast<uintptr_t> (system); |
| 108 |
| 109 auto it = break_mapping_.find (k); |
| 110 return it == break_mapping_.end () ? NULL : it->second; |
| 111 } |
| 112 |
| 113 void |
| 114 System::record_break_substitution (Grob *orig, Direction dir, Grob *system, |
| 115 Grob *grob) |
| 116 { |
| 117 assert (dir || system); |
| 118 assert (!dir || !system); |
| 119 if (original_) |
| 120 { |
| 121 dynamic_cast<System *> (original_)->record_break_substitution ( |
| 122 orig, dir, system, grob); |
| 123 } |
| 124 |
| 125 Break_substitution_key key; |
| 126 key.orig_ = orig; |
| 127 |
| 128 if (dir) |
| 129 { |
| 130 // This is kind of gross. |
| 131 key.system_ = break_dir_to_system (dir); |
| 132 } |
| 133 else |
| 134 { |
| 135 key.system_ = reinterpret_cast<uintptr_t> (system); |
| 136 } |
| 137 |
| 138 break_mapping_[key] = grob; |
| 139 } |
| 140 |
95 void | 141 void |
96 System::typeset_grob (Grob *elem) | 142 System::typeset_grob (Grob *elem) |
97 { | 143 { |
98 if (elem->layout_) | 144 if (elem->layout_) |
99 programming_error ("adding element twice"); | |
100 else | |
101 { | 145 { |
102 elem->layout_ = pscore_->layout (); | 146 programming_error ("adding element twice"); |
103 all_elements_->add (elem); | 147 return; |
104 elem->unprotect (); | 148 } |
| 149 |
| 150 elem->layout_ = pscore_->layout (); |
| 151 all_elements_->add (elem); |
| 152 elem->unprotect (); |
| 153 |
| 154 if (elem->original_) |
| 155 { |
| 156 if (Item *it = dynamic_cast<Item *> (elem)) |
| 157 record_break_substitution (elem->original_, it->break_status_dir (), |
| 158 NULL, elem); |
| 159 else if (Spanner *sp = dynamic_cast<Spanner *> (elem)) |
| 160 record_break_substitution (elem->original_, CENTER, this, sp); |
105 } | 161 } |
106 } | 162 } |
107 | 163 |
108 void | 164 void |
109 System::derived_mark () const | 165 System::derived_mark () const |
110 { | 166 { |
111 const vector <Grob *> &arr = all_elements_->array (); | 167 const vector <Grob *> &arr = all_elements_->array (); |
112 for (vsize i = arr.size (); i--;) | 168 for (vsize i = arr.size (); i--;) |
113 scm_gc_mark (arr[i]->self_scm ()); | 169 scm_gc_mark (arr[i]->self_scm ()); |
114 | 170 |
115 if (pscore_) | 171 if (pscore_) |
116 scm_gc_mark (pscore_->self_scm ()); | 172 scm_gc_mark (pscore_->self_scm ()); |
117 | 173 |
118 Spanner::derived_mark (); | 174 Spanner::derived_mark (); |
119 } | 175 } |
120 | 176 |
121 static void | 177 static void |
122 fixup_refpoints (vector<Grob *> const &grobs) | 178 fixup_refpoints (vector<Grob *> const &grobs) |
123 { | 179 { |
124 for (vsize i = grobs.size (); i--;) | 180 for (vsize i = grobs.size (); i--;) |
125 grobs[i]->fixup_refpoint (); | 181 grobs[i]->fixup_refpoint (); |
126 } | 182 } |
127 | 183 |
128 void | 184 void |
129 System::do_break_substitution_and_fixup_refpoints () | 185 System::do_break_substitution_and_fixup_refpoints () |
130 { | 186 { |
131 for (vsize i = 0; i < all_elements_->size (); i++) | 187 for (Grob *g : all_elements_->array ()) |
132 { | 188 { |
133 Grob *g = all_elements_->grob (i); | |
134 if (g->internal_has_interface (ly_symbol2scm ("only-prebreak-interface"))) | 189 if (g->internal_has_interface (ly_symbol2scm ("only-prebreak-interface"))) |
135 { | 190 { |
136 /* | 191 /* |
137 Kill no longer needed grobs. | 192 Kill no longer needed grobs. |
138 */ | 193 */ |
139 Item *it = dynamic_cast<Item *> (g); | 194 Item *it = dynamic_cast<Item *> (g); |
140 if (it && Item::is_non_musical (it)) | 195 if (it && Item::is_non_musical (it)) |
141 { | 196 { |
142 it->find_prebroken_piece (LEFT)->suicide (); | 197 it->find_prebroken_piece (LEFT)->suicide (); |
143 it->find_prebroken_piece (RIGHT)->suicide (); | 198 it->find_prebroken_piece (RIGHT)->suicide (); |
144 } | 199 } |
145 g->suicide (); | 200 g->suicide (); |
146 } | 201 } |
147 else | 202 else |
148 g->do_break_processing (); | 203 g->do_break_processing (this); |
149 } | 204 } |
150 | 205 |
151 /* | 206 /* |
152 fixups must be done in broken line_of_scores, because new elements | 207 fixups must be done in broken line_of_scores, because new elements |
153 are put over there. */ | 208 are put over there. */ |
154 vsize count = 0; | 209 for (Grob *se : broken_intos_) |
155 for (vsize i = 0; i < broken_intos_.size (); i++) | |
156 { | 210 { |
157 Grob *se = broken_intos_[i]; | |
158 | |
159 extract_grob_set (se, "all-elements", all_elts); | 211 extract_grob_set (se, "all-elements", all_elts); |
160 for (vsize j = 0; j < all_elts.size (); j++) | 212 for (vsize j = 0; j < all_elts.size (); j++) |
161 { | 213 { |
162 Grob *g = all_elts[j]; | 214 Grob *g = all_elts[j]; |
163 g->fixup_refpoint (); | 215 g->fixup_refpoint (); |
164 } | 216 } |
165 | |
166 count += all_elts.size (); | |
167 } | 217 } |
168 | 218 |
169 /* | 219 /* |
170 needed for doing items. | 220 needed for doing items. |
171 */ | 221 */ |
172 fixup_refpoints (all_elements_->array ()); | 222 fixup_refpoints (all_elements_->array ()); |
173 | 223 |
174 for (vsize i = 0; i < all_elements_->size (); i++) | 224 for (Grob *g : all_elements_->array ()) |
175 all_elements_->grob (i)->handle_broken_dependencies (); | 225 g->handle_broken_dependencies (this); |
176 | 226 |
177 handle_broken_dependencies (); | 227 handle_broken_dependencies (this); |
178 | 228 |
179 /* Because the get_property (all-elements) contains items in 3 | 229 /* Because the get_property (all-elements) contains items in 3 |
180 versions, handle_broken_dependencies () will leave duplicated | 230 versions, handle_broken_dependencies () will leave duplicated |
181 items in all-elements. Strictly speaking this is harmless, but | 231 items in all-elements. Strictly speaking this is harmless, but |
182 it leads to duplicated symbols in the output. uniq makes sure | 232 it leads to duplicated symbols in the output. uniq makes sure |
183 that no duplicates are in the list.i */ | 233 that no duplicates are in the list. */ |
184 for (vsize i = 0; i < broken_intos_.size (); i++) | 234 vsize count = 0; |
| 235 for (Grob *grob_child : broken_intos_) |
185 { | 236 { |
186 System *child = dynamic_cast<System *> (broken_intos_[i]); | 237 System *child = dynamic_cast<System *> (grob_child); |
187 child->all_elements_->remove_duplicates (); | 238 child->all_elements_->remove_duplicates (); |
188 | 239 |
189 for (vsize j = 0; j < child->all_elements_->size (); j++) | 240 count += child->all_elements_->size (); |
| 241 for (Grob *g : child->all_elements_->array ()) |
190 { | 242 { |
191 Grob *g = child->all_elements_->grob (j); | |
192 | |
193 (void) get_property (g, "after-line-breaking"); | 243 (void) get_property (g, "after-line-breaking"); |
194 } | 244 } |
195 } | 245 } |
| 246 count += element_count (); |
196 | 247 |
197 debug_output (_f ("Element count %zu", count + element_count ()) + "\n"); | 248 debug_output ("Break-mapping size %zu\n", break_mapping_.size ()); |
| 249 // No longer needed: |
| 250 break_mapping_.clear (); |
| 251 debug_output (_f ("Element count %zu", count) + "\n"); |
198 } | 252 } |
199 | 253 |
200 bool | 254 bool |
201 System::accepts_as_bound_item (const Item *) const | 255 System::accepts_as_bound_item (const Item *) const |
202 { | 256 { |
203 return false; | 257 return false; |
204 } | 258 } |
205 | 259 |
206 bool | 260 bool |
207 System::accepts_as_bound_paper_column (const Paper_column *) const | 261 System::accepts_as_bound_paper_column (const Paper_column *) const |
208 { | 262 { |
209 return true; | 263 return true; |
210 } | 264 } |
211 | 265 |
212 SCM | 266 SCM |
213 System::get_broken_system_grobs () | 267 System::get_broken_system_grobs () |
214 { | 268 { |
215 SCM ret = SCM_EOL; | 269 SCM ret = SCM_EOL; |
216 for (vsize i = 0; i < broken_intos_.size (); i++) | 270 for (Grob *g : broken_intos_) |
217 ret = scm_cons (broken_intos_[i]->self_scm (), ret); | 271 ret = scm_cons (g->self_scm (), ret); |
218 return scm_reverse_x (ret, SCM_EOL); | 272 return scm_reverse_x (ret, SCM_EOL); |
219 } | 273 } |
220 | 274 |
221 SCM | 275 SCM |
222 System::get_paper_systems () | 276 System::get_paper_systems () |
223 { | 277 { |
224 SCM lines = scm_c_make_vector (broken_intos_.size (), SCM_EOL); | 278 SCM lines = scm_c_make_vector (broken_intos_.size (), SCM_EOL); |
225 for (vsize i = 0; i < broken_intos_.size (); i++) | 279 for (vsize i = 0; i < broken_intos_.size (); i++) |
226 { | 280 { |
227 debug_output ("[", false); | 281 debug_output ("[", false); |
228 | |
229 System *system = dynamic_cast<System *> (broken_intos_[i]); | 282 System *system = dynamic_cast<System *> (broken_intos_[i]); |
230 | 283 |
231 scm_c_vector_set_x (lines, i, system->get_paper_system ()); | 284 scm_c_vector_set_x (lines, i, system->get_paper_system ()); |
232 | 285 |
233 debug_output (std::to_string (i) + "]", false); | 286 debug_output (std::to_string (i) + "]", false); |
234 } | 287 } |
235 return lines; | 288 return lines; |
236 } | 289 } |
237 | 290 |
238 vector<Grob *> | 291 vector<Grob *> |
239 System::get_footnote_grobs_in_range (vsize start, vsize end) | 292 System::get_footnote_grobs_in_range (vsize start, vsize end) |
240 { | 293 { |
241 vector<Grob *> out; | 294 vector<Grob *> out; |
242 extract_grob_set (this, "footnotes-before-line-breaking", footnote_grobs); | 295 extract_grob_set (this, "footnotes-before-line-breaking", footnote_grobs); |
243 for (vsize i = 0; i < footnote_grobs.size (); i++) | 296 for (Grob *at_bat : footnote_grobs) |
244 { | 297 { |
245 Grob *at_bat = footnote_grobs[i]; | |
246 int pos = at_bat->spanned_rank_interval ()[LEFT]; | 298 int pos = at_bat->spanned_rank_interval ()[LEFT]; |
247 bool end_of_line_visible = true; | 299 bool end_of_line_visible = true; |
248 if (Spanner *s = dynamic_cast<Spanner *>(at_bat)) | 300 if (Spanner *s = dynamic_cast<Spanner *>(at_bat)) |
249 { | 301 { |
250 Direction spanner_placement = robust_scm2dir (get_property (s, "spanne
r-placement"), LEFT); | 302 Direction spanner_placement = robust_scm2dir (get_property (s, "spanne
r-placement"), LEFT); |
251 if (spanner_placement == CENTER) | 303 if (spanner_placement == CENTER) |
252 spanner_placement = LEFT; | 304 spanner_placement = LEFT; |
253 | 305 |
254 pos = s->spanned_rank_interval ()[spanner_placement]; | 306 pos = s->spanned_rank_interval ()[spanner_placement]; |
255 if (Spanner *orig = s->original ()) | 307 if (Spanner *orig = s->original ()) |
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
381 } | 433 } |
382 | 434 |
383 MAKE_SCHEME_CALLBACK (System, footnotes_before_line_breaking, 1); | 435 MAKE_SCHEME_CALLBACK (System, footnotes_before_line_breaking, 1); |
384 SCM | 436 SCM |
385 System::footnotes_before_line_breaking (SCM smob) | 437 System::footnotes_before_line_breaking (SCM smob) |
386 { | 438 { |
387 Grob *me = unsmob<Grob> (smob); | 439 Grob *me = unsmob<Grob> (smob); |
388 vector<Grob *> footnotes; | 440 vector<Grob *> footnotes; |
389 SCM grobs_scm = Grob_array::make_array (); | 441 SCM grobs_scm = Grob_array::make_array (); |
390 extract_grob_set (me, "all-elements", elts); | 442 extract_grob_set (me, "all-elements", elts); |
391 for (vsize i = 0; i < elts.size (); i++) | 443 for (Grob *e : elts) |
392 if (elts[i]->internal_has_interface (ly_symbol2scm ("footnote-interface"))) | 444 if (e->internal_has_interface (ly_symbol2scm ("footnote-interface"))) |
393 footnotes.push_back (elts[i]); | 445 footnotes.push_back (e); |
394 | 446 |
395 unsmob<Grob_array> (grobs_scm)->set_array (footnotes); | 447 unsmob<Grob_array> (grobs_scm)->set_array (footnotes); |
396 return grobs_scm; | 448 return grobs_scm; |
397 } | 449 } |
398 | 450 |
399 MAKE_SCHEME_CALLBACK (System, footnotes_after_line_breaking, 1); | 451 MAKE_SCHEME_CALLBACK (System, footnotes_after_line_breaking, 1); |
400 SCM | 452 SCM |
401 System::footnotes_after_line_breaking (SCM smob) | 453 System::footnotes_after_line_breaking (SCM smob) |
402 { | 454 { |
403 Spanner *sys_span = unsmob<Spanner> (smob); | 455 Spanner *sys_span = unsmob<Spanner> (smob); |
404 System *sys = dynamic_cast<System *> (sys_span); | 456 System *sys = dynamic_cast<System *> (sys_span); |
405 Interval_t<int> sri = sys->spanned_rank_interval (); | 457 Interval_t<int> sri = sys->spanned_rank_interval (); |
406 vector<Grob *> footnote_grobs = sys->get_footnote_grobs_in_range (sri[LEFT], s
ri[RIGHT]); | 458 vector<Grob *> footnote_grobs = sys->get_footnote_grobs_in_range (sri[LEFT], s
ri[RIGHT]); |
407 vector_sort (footnote_grobs, grob_2D_less); | 459 vector_sort (footnote_grobs, grob_2D_less); |
408 | 460 |
409 SCM grobs_scm = Grob_array::make_array (); | 461 SCM grobs_scm = Grob_array::make_array (); |
410 unsmob<Grob_array> (grobs_scm)->set_array (footnote_grobs); | 462 unsmob<Grob_array> (grobs_scm)->set_array (footnote_grobs); |
411 return grobs_scm; | 463 return grobs_scm; |
412 } | 464 } |
413 | 465 |
414 MAKE_SCHEME_CALLBACK (System, vertical_skyline_elements, 1); | 466 MAKE_SCHEME_CALLBACK (System, vertical_skyline_elements, 1); |
415 SCM | 467 SCM |
416 System::vertical_skyline_elements (SCM smob) | 468 System::vertical_skyline_elements (SCM smob) |
417 { | 469 { |
418 Grob *me_grob = unsmob<Grob> (smob); | 470 Grob *me_grob = unsmob<Grob> (smob); |
419 vector<Grob *> vertical_skyline_grobs; | 471 vector<Grob *> vertical_skyline_grobs; |
420 extract_grob_set (me_grob, "elements", my_elts); | 472 extract_grob_set (me_grob, "elements", my_elts); |
421 for (vsize i = 0; i < my_elts.size (); i++) | 473 for (Grob *e : my_elts) |
422 if (has_interface<System_start_delimiter> (my_elts[i])) | 474 if (has_interface<System_start_delimiter> (e)) |
423 vertical_skyline_grobs.push_back (my_elts[i]); | 475 vertical_skyline_grobs.push_back (e); |
424 | 476 |
425 System *me = dynamic_cast<System *> (me_grob); | 477 System *me = dynamic_cast<System *> (me_grob); |
426 Grob *align = unsmob<Grob> (get_object (me, "vertical-alignment")); | 478 Grob *align = unsmob<Grob> (get_object (me, "vertical-alignment")); |
427 if (!align) | 479 if (!align) |
428 { | 480 { |
429 SCM grobs_scm = Grob_array::make_array (); | 481 SCM grobs_scm = Grob_array::make_array (); |
430 unsmob<Grob_array> (grobs_scm)->set_array (vertical_skyline_grobs); | 482 unsmob<Grob_array> (grobs_scm)->set_array (vertical_skyline_grobs); |
431 return grobs_scm; | 483 return grobs_scm; |
432 } | 484 } |
433 | 485 |
434 extract_grob_set (align, "elements", elts); | 486 extract_grob_set (align, "elements", elts); |
435 | 487 |
436 for (vsize i = 0; i < elts.size (); i++) | 488 for (Grob *e : elts) |
437 if (has_interface<Hara_kiri_group_spanner> (elts[i])) | 489 if (has_interface<Hara_kiri_group_spanner> (e)) |
438 vertical_skyline_grobs.push_back (elts[i]); | 490 vertical_skyline_grobs.push_back (e); |
439 | 491 |
440 SCM grobs_scm = Grob_array::make_array (); | 492 SCM grobs_scm = Grob_array::make_array (); |
441 unsmob<Grob_array> (grobs_scm)->set_array (vertical_skyline_grobs); | 493 unsmob<Grob_array> (grobs_scm)->set_array (vertical_skyline_grobs); |
442 return grobs_scm; | 494 return grobs_scm; |
443 } | 495 } |
444 | 496 |
445 void | 497 void |
446 System::break_into_pieces (vector<Column_x_positions> const &breaking) | 498 System::break_into_pieces (vector<Column_x_positions> const &breaking) |
447 { | 499 { |
448 for (vsize i = 0; i < breaking.size (); i++) | 500 for (vsize i = 0; i < breaking.size (); i++) |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
512 | 564 |
513 p->set_rank (ga->size ()); | 565 p->set_rank (ga->size ()); |
514 | 566 |
515 ga->add (p); | 567 ga->add (p); |
516 Axis_group_interface::add_element (this, p); | 568 Axis_group_interface::add_element (this, p); |
517 } | 569 } |
518 | 570 |
519 void | 571 void |
520 System::pre_processing () | 572 System::pre_processing () |
521 { | 573 { |
| 574 /* Empirically, the break mapping is about 1.5x the number of elements. */ |
| 575 break_mapping_.reserve (element_count () * 2); |
| 576 |
522 /* | 577 /* |
523 Each breakable Item calls back to this System to append two clones of | 578 Each breakable Item calls back to this System to append two clones of |
524 itself (for before and after a break) to the vector. We stop after | 579 itself (for before and after a break) to the vector. We stop after |
525 breaking the originals and don't invite the clones to break themselves. | 580 breaking the originals and don't invite the clones to break themselves. |
526 */ | 581 */ |
527 vsize num_original_grobs = all_elements_->size (); | 582 vsize num_original_grobs = all_elements_->size (); |
528 for (vsize i = 0; i < num_original_grobs; i++) | 583 for (vsize i = 0; i < num_original_grobs; i++) |
529 all_elements_->grob (i)->break_breakable_item (this); | 584 all_elements_->grob (i)->break_breakable_item (this); |
530 | 585 |
531 debug_output (_f ("Grob count %zu", element_count ())); | 586 debug_output (_f ("Grob count %zu", element_count ())); |
532 | 587 |
533 /* | 588 /* |
534 order is significant: broken grobs are added to the end of the | 589 order is significant: broken grobs are added to the end of the |
535 array, and should be processed before the original is potentially | 590 array, and should be processed before the original is potentially |
536 killed. | 591 killed. |
537 */ | 592 */ |
538 for (vsize i = all_elements_->size (); i--;) | 593 for (vsize i = all_elements_->size (); i--;) |
539 all_elements_->grob (i)->handle_prebroken_dependencies (); | 594 all_elements_->grob (i)->handle_prebroken_dependencies (this); |
540 | 595 |
541 fixup_refpoints (all_elements_->array ()); | 596 fixup_refpoints (all_elements_->array ()); |
542 | 597 |
543 for (vsize i = 0; i < all_elements_->size (); i++) | 598 for (Grob *g : all_elements_->array ()) |
544 { | 599 { |
545 Grob *g = all_elements_->grob (i); | |
546 (void) get_property (g, "before-line-breaking"); | 600 (void) get_property (g, "before-line-breaking"); |
547 } | 601 } |
548 | 602 |
549 for (vsize i = 0; i < all_elements_->size (); i++) | 603 for (Grob *g : all_elements_->array ()) |
550 { | 604 { |
551 Grob *e = all_elements_->grob (i); | 605 (void) get_property (g, "springs-and-rods"); |
552 (void) get_property (e, "springs-and-rods"); | |
553 } | 606 } |
554 } | 607 } |
555 | 608 |
556 void | 609 void |
557 System::post_processing () | 610 System::post_processing () |
558 { | 611 { |
559 Interval iv (extent (this, Y_AXIS)); | 612 Interval iv (extent (this, Y_AXIS)); |
560 if (iv.is_empty ()) | 613 if (iv.is_empty ()) |
561 programming_error ("system with empty extent"); | 614 programming_error ("system with empty extent"); |
562 else | 615 else |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
594 */ | 647 */ |
595 SCM | 648 SCM |
596 System::get_paper_system () | 649 System::get_paper_system () |
597 { | 650 { |
598 SCM exprs = SCM_EOL; | 651 SCM exprs = SCM_EOL; |
599 SCM *tail = &exprs; | 652 SCM *tail = &exprs; |
600 | 653 |
601 post_processing (); | 654 post_processing (); |
602 | 655 |
603 vector<Layer_entry> entries; | 656 vector<Layer_entry> entries; |
604 for (vsize j = 0; j < all_elements_->size (); j++) | 657 for (Grob *g : all_elements_->array ()) |
605 { | 658 { |
606 Layer_entry e; | 659 Layer_entry e; |
607 e.grob_ = all_elements_->grob (j); | 660 e.grob_ = g; |
| 661 ; |
608 e.layer_ = robust_scm2int (get_property (e.grob_, "layer"), 1); | 662 e.layer_ = robust_scm2int (get_property (e.grob_, "layer"), 1); |
609 | |
610 entries.push_back (e); | 663 entries.push_back (e); |
611 } | 664 } |
612 | 665 |
613 vector_sort (entries, std::less<Layer_entry> ()); | 666 vector_sort (entries, std::less<Layer_entry> ()); |
614 for (vsize j = 0; j < entries.size (); j++) | 667 for (vsize j = 0; j < entries.size (); j++) |
615 { | 668 { |
616 Grob *g = entries[j].grob_; | 669 Grob *g = entries[j].grob_; |
617 Stencil st = g->get_print_stencil (); | 670 Stencil st = g->get_print_stencil (); |
618 | 671 |
619 if (scm_is_null (st.expr ())) | 672 if (scm_is_null (st.expr ())) |
(...skipping 427 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1047 "footnotes-after-line-breaking " | 1100 "footnotes-after-line-breaking " |
1048 "in-note-direction " | 1101 "in-note-direction " |
1049 "in-note-padding " | 1102 "in-note-padding " |
1050 "in-note-stencil " | 1103 "in-note-stencil " |
1051 "labels " | 1104 "labels " |
1052 "page-number " | 1105 "page-number " |
1053 "pure-Y-extent " | 1106 "pure-Y-extent " |
1054 "rank-on-page " | 1107 "rank-on-page " |
1055 "vertical-alignment " | 1108 "vertical-alignment " |
1056 ); | 1109 ); |
OLD | NEW |