lily/paper-book.cc

   1 /*
   2   paper-book.cc -- implement Paper_book
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 2004--2008 Jan Nieuwenhuizen <janneke@gnu.org>
   7 */
   8
   9 #include "paper-book.hh"
  10
  11 #include "grob.hh"
  12 #include "main.hh"
  13 #include "output-def.hh"
  14 #include "paper-column.hh"
  15 #include "paper-score.hh"
  16 #include "paper-system.hh"
  17 #include "text-interface.hh"
  18 #include "warn.hh"
  19 #include "program-option.hh"
  20 #include "page-marker.hh"
  21
  22 #include "ly-smobs.icc"
  23
  24 Paper_book::Paper_book ()
  25 {
  26   header_ = SCM_EOL;
  27   header_0_ = SCM_EOL;
  28   pages_ = SCM_BOOL_F;
  29   scores_ = SCM_EOL;
  30   bookparts_ = SCM_EOL;
  31   performances_ = SCM_EOL;
  32   systems_ = SCM_BOOL_F;
  33
  34   paper_ = 0;
  35   parent_ = 0;
  36   smobify_self ();
  37 }
  38
  39 Paper_book::~Paper_book ()
  40 {
  41 }
  42
  43 IMPLEMENT_DEFAULT_EQUAL_P (Paper_book);
  44 IMPLEMENT_SMOBS (Paper_book);
  45 IMPLEMENT_TYPE_P (Paper_book, "ly:paper-book?");
  46
  47 SCM
  48 Paper_book::mark_smob (SCM smob)
  49 {
  50   Paper_book *b = (Paper_book *) SCM_CELL_WORD_1 (smob);
  51   if (b->paper_)
  52     scm_gc_mark (b->paper_->self_scm ());
  53   if (b->parent_)
  54     scm_gc_mark (b->parent_->self_scm ());
  55   scm_gc_mark (b->header_);
  56   scm_gc_mark (b->header_0_);
  57   scm_gc_mark (b->pages_);
  58   scm_gc_mark (b->performances_);
  59   scm_gc_mark (b->scores_);
  60   scm_gc_mark (b->bookparts_);
  61   return b->systems_;
  62 }
  63
  64 int
  65 Paper_book::print_smob (SCM smob, SCM port, scm_print_state*)
  66 {
  67   Paper_book *b = (Paper_book *) SCM_CELL_WORD_1 (smob);
  68   (void)b;
  69   scm_puts ("#<Paper_book>", port);
  70   return 1;
  71 }
  72
  73 Output_def *
  74 Paper_book::top_paper ()
  75 {
  76   Output_def *paper = paper_;
  77   while (paper->parent_)
  78     paper = paper->parent_;
  79   return paper;
  80 }
  81
  82 SCM
  83 dump_fields ()
  84 {
  85   SCM fields = SCM_EOL;
  86   for (vsize i = dump_header_fieldnames_global.size (); i--;)
  87     fields
  88       = scm_cons (ly_symbol2scm (dump_header_fieldnames_global[i].c_str ()),
  89                   fields);
  90   return fields;
  91 }
  92
  93 void
  94 Paper_book::add_score (SCM s)
  95 {
  96   scores_ = scm_cons (s, scores_);
  97 }
  98
  99 void
 100 Paper_book::add_bookpart (SCM p)
 101 {
 102   bookparts_ = scm_cons (p, bookparts_);
 103 }
 104
 105 void
 106 Paper_book::add_performance (SCM s)
 107 {
 108   performances_ = scm_cons (s, performances_);
 109 }
 110
 111 void
 112 Paper_book::output_aux (SCM output_channel,
 113                         bool is_last,
 114                         int *first_page_number,
 115                         int *first_performance_number)
 116 {
 117   if (scm_is_pair (performances_))
 118     {
 119       SCM proc = ly_lily_module_constant ("write-performances-midis");
 120
 121       scm_call_3 (proc,
 122                   performances (),
 123                   output_channel,
 124                   scm_long2num (*first_performance_number));
 125       *first_performance_number += scm_ilength (performances_);
 126     }
 127
 128   if (scm_is_pair (bookparts_))
 129     {
 130       for (SCM p = scm_reverse (bookparts_); scm_is_pair (p); p = scm_cdr (p))
 131         if (Paper_book *pbookpart = unsmob_paper_book (scm_car (p)))
 132           {
 133             bool is_last_part = (is_last && !scm_is_pair (scm_cdr (p)));
 134             pbookpart->output_aux (output_channel,
 135                                    is_last_part,
 136                                    first_page_number,
 137                                    first_performance_number);
 138           }
 139     }
 140   else
 141     {
 142       if (scores_ == SCM_EOL)
 143         return;
 144       paper_->set_variable (ly_symbol2scm ("first-page-number"),
 145                             scm_long2num (*first_page_number));
 146       paper_->set_variable (ly_symbol2scm ("is-last-bookpart"),
 147                             ly_bool2scm (is_last));
 148       /* Generate all stencils to trigger font loads.  */
 149       *first_page_number += scm_ilength (pages ());
 150     }
 151 }
 152
 153 void
 154 Paper_book::output (SCM output_channel)
 155 {
 156   int first_page_number = robust_scm2int (paper_->c_variable ("first-page-number"), 1);
 157   int first_performance_number = 0;
 158   output_aux (output_channel,
 159               true,
 160               &first_page_number,
 161               &first_performance_number);
 162
 163   SCM scopes = SCM_EOL;
 164   if (ly_is_module (header_))
 165     scopes = scm_cons (header_, scopes);
 166
 167   string mod_nm = "scm framework-" + get_output_backend_name ();
 168
 169   SCM mod = scm_c_resolve_module (mod_nm.c_str ());
 170
 171   if (get_program_option ("print-pages"))
 172     {
 173       SCM func = scm_c_module_lookup (mod, "output-framework");
 174
 175       func = scm_variable_ref (func);
 176       scm_apply_0 (func, scm_list_n (output_channel,
 177                                      self_scm (),
 178                                      scopes,
 179                                      dump_fields (),
 180                                      SCM_UNDEFINED));
 181     }
 182
 183   if (get_program_option ("preview"))
 184     {
 185       SCM func = scm_c_module_lookup (mod, "output-preview-framework");
 186       func = scm_variable_ref (func);
 187       scm_apply_0 (func, scm_list_n (output_channel,
 188                                      self_scm (),
 189                                      scopes,
 190                                      dump_fields (),
 191                                      SCM_UNDEFINED));
 192     }
 193 }
 194
 195 void
 196 Paper_book::classic_output_aux (SCM output,
 197                                 int *first_performance_number)
 198 {
 199   if (scm_is_pair (performances_))
 200     {
 201       SCM proc = ly_lily_module_constant ("write-performances-midis");
 202       scm_call_3 (proc,
 203                   performances (),
 204                   output,
 205                   scm_long2num (*first_performance_number));
 206       *first_performance_number += scm_ilength (performances_);
 207     }
 208
 209   /* Generate all stencils to trigger font loads.  */
 210   systems ();
 211 }
 212
 213 void
 214 Paper_book::classic_output (SCM output)
 215 {
 216   int first_performance_number = 0;
 217   classic_output_aux (output, &first_performance_number);
 218
 219   SCM scopes = SCM_EOL;
 220   if (ly_is_module (header_))
 221     scopes = scm_cons (header_, scopes);
 222
 223   if (ly_is_module (header_0_))
 224     scopes = scm_cons (header_0_, scopes);
 225
 226   string format = get_output_backend_name ();
 227   string mod_nm = "scm framework-" + format;
 228
 229   SCM mod = scm_c_resolve_module (mod_nm.c_str ());
 230   SCM func = scm_c_module_lookup (mod, "output-classic-framework");
 231
 232   func = scm_variable_ref (func);
 233   scm_apply_0 (func, scm_list_n (output,
 234                                  self_scm (),
 235                                  scopes,
 236                                  dump_fields (),
 237                                  SCM_UNDEFINED));
 238
 239   progress_indication ("\n");
 240 }
 241
 242 /* TODO: resurrect more complex user-tweaks for titling?  */
 243 Stencil
 244 Paper_book::book_title ()
 245 {
 246   SCM title_func = paper_->lookup_variable (ly_symbol2scm ("book-title"));
 247   Stencil title;
 248
 249   SCM scopes = SCM_EOL;
 250   if (ly_is_module (header_))
 251     scopes = scm_cons (header_, scopes);
 252
 253   SCM tit = SCM_EOL;
 254   if (ly_is_procedure (title_func))
 255     tit = scm_call_2 (title_func,
 256                       paper_->self_scm (),
 257                       scopes);
 258
 259   if (unsmob_stencil (tit))
 260     title = *unsmob_stencil (tit);
 261
 262   if (!title.is_empty ())
 263     title.align_to (Y_AXIS, UP);
 264
 265   return title;
 266 }
 267
 268 Stencil
 269 Paper_book::score_title (SCM header)
 270 {
 271   SCM title_func = paper_->lookup_variable (ly_symbol2scm ("score-title"));
 272
 273   Stencil title;
 274
 275   SCM scopes = SCM_EOL;
 276   if (ly_is_module (header_))
 277     scopes = scm_cons (header_, scopes);
 278
 279   if (ly_is_module (header))
 280     scopes = scm_cons (header, scopes);
 281
 282   SCM tit = SCM_EOL;
 283   if (ly_is_procedure (title_func))
 284     tit = scm_call_2 (title_func,
 285                       paper_->self_scm (),
 286                       scopes);
 287
 288   if (unsmob_stencil (tit))
 289     title = *unsmob_stencil (tit);
 290
 291   if (!title.is_empty ())
 292     title.align_to (Y_AXIS, UP);
 293
 294   return title;
 295 }
 296
 297 void
 298 set_page_permission (SCM sys, SCM symbol, SCM permission)
 299 {
 300   if (Paper_score *ps = dynamic_cast<Paper_score*> (unsmob_music_output (sys)))
 301     {
 302       vector<Grob*> cols = ps->get_columns ();
 303       if (cols.size ())
 304         {
 305           Paper_column *col = dynamic_cast<Paper_column*> (cols.back ());
 306           col->set_property (symbol, permission);
 307           col->find_prebroken_piece (LEFT)->set_property (symbol, permission);
 308         }
 309     }
 310   else if (Prob *pb = unsmob_prob (sys))
 311     pb->set_property (symbol, permission);
 312 }
 313
 314 /* read the breakbefore property of a score block and set up the preceding
 315    system-spec to honour it. That is, SYS should be the system spec that
 316    immediately precedes the score (from which HEADER is taken)
 317    in the get_system_specs () list */
 318 void
 319 set_system_penalty (SCM sys, SCM header)
 320 {
 321   if (ly_is_module (header))
 322     {
 323       SCM force = ly_module_lookup (header, ly_symbol2scm ("breakbefore"));
 324       if (SCM_VARIABLEP (force)
 325           && scm_is_bool (SCM_VARIABLE_REF (force)))
 326         {
 327           if (to_boolean (SCM_VARIABLE_REF (force)))
 328             {
 329               set_page_permission (sys, ly_symbol2scm ("page-break-permission"),
 330                                    ly_symbol2scm ("force"));
 331               set_page_permission (sys, ly_symbol2scm ("line-break-permission"),
 332                                    ly_symbol2scm ("force"));
 333             }
 334           else
 335             set_page_permission (sys, ly_symbol2scm ("page-break-permission"), SCM_EOL);
 336         }
 337     }
 338 }
 339
 340 void
 341 set_labels (SCM sys, SCM labels)
 342 {
 343   if (Paper_score *ps = dynamic_cast<Paper_score*> (unsmob_music_output (sys)))
 344     {
 345       vector<Grob*> cols = ps->get_columns ();
 346       if (cols.size ())
 347         {
 348           Paper_column *col = dynamic_cast<Paper_column*> (cols[0]);
 349           col->set_property ("labels",
 350                              scm_append_x (scm_list_2 (col->get_property ("labels"),
 351                                                        labels)));
 352           Paper_column *col_right = dynamic_cast<Paper_column*> (col->find_prebroken_piece (RIGHT));
 353           col_right->set_property ("labels",
 354                                    scm_append_x (scm_list_2 (col_right->get_property ("labels"),
 355                                                              labels)));
 356         }
 357     }
 358   else if (Prob *pb = unsmob_prob (sys))
 359     pb->set_property ("labels",
 360                       scm_append_x (scm_list_2 (pb->get_property ("labels"),
 361                                                 labels)));
 362 }
 363
 364 SCM
 365 Paper_book::get_score_title (SCM header)
 366 {
 367   Stencil title = score_title (header);
 368   if (title.is_empty ())
 369     title = score_title (header_);
 370   if (!title.is_empty ())
 371     {
 372       /*
 373         TODO: this should come from the \layout {} block, which should
 374         override settings from \paper {}
 375       */
 376       SCM props = paper_->lookup_variable (ly_symbol2scm ("score-title-properties"));
 377       Prob *ps = make_paper_system (props);
 378       paper_system_set_stencil (ps, title);
 379
 380       return ps->self_scm ();
 381     }
 382
 383   return SCM_BOOL_F;
 384 }
 385
 386
 387 SCM
 388 Paper_book::get_system_specs ()
 389 {
 390   SCM system_specs = SCM_EOL;
 391
 392   Stencil title = book_title ();
 393   if (!title.is_empty ())
 394     {
 395       SCM props = paper_->lookup_variable (ly_symbol2scm ("book-title-properties"));
 396       Prob *ps = make_paper_system (props);
 397       paper_system_set_stencil (ps, title);
 398
 399       system_specs = scm_cons (ps->self_scm (), system_specs);
 400       ps->unprotect ();
 401     }
 402
 403   SCM page_properties
 404     = scm_call_1 (ly_lily_module_constant ("layout-extract-page-properties"),
 405                   paper_->self_scm ());
 406
 407   SCM interpret_markup_list = ly_lily_module_constant ("interpret-markup-list");
 408   SCM header = SCM_EOL;
 409   SCM labels = SCM_EOL;
 410   for (SCM s = scm_reverse (scores_); scm_is_pair (s); s = scm_cdr (s))
 411     {
 412       if (ly_is_module (scm_car (s)))
 413         {
 414           header = scm_car (s);
 415           if (header_0_ == SCM_EOL)
 416             header_0_ = header;
 417         }
 418       else if (Page_marker *page_marker = unsmob_page_marker (scm_car (s)))
 419         {
 420           /* page markers are used to set page breaking/turning permission,
 421              or to place bookmarking labels */
 422           if (scm_is_symbol (page_marker->permission_symbol ()))
 423             {
 424               /* set previous element page break or turn permission */
 425               if (scm_is_pair (system_specs))
 426                 set_page_permission (scm_car (system_specs),
 427                                      page_marker->permission_symbol (),
 428                                      page_marker->permission_value ());
 429             }
 430           if (scm_is_symbol (page_marker->label ()))
 431             {
 432               /* The next element label is to be set */
 433               labels = scm_cons (page_marker->label (), labels);
 434             }
 435         }
 436       else if (Music_output *mop = unsmob_music_output (scm_car (s)))
 437         {
 438           if (Paper_score *pscore = dynamic_cast<Paper_score *> (mop))
 439             {
 440               SCM title = get_score_title (header);
 441
 442               if (scm_is_pair (system_specs))
 443                 set_system_penalty (scm_car (system_specs), header);
 444
 445               if (unsmob_prob (title))
 446                 {
 447                   system_specs = scm_cons (title, system_specs);
 448                   unsmob_prob (title)->unprotect ();
 449                 }
 450
 451               header = SCM_EOL;
 452               system_specs = scm_cons (pscore->self_scm (), system_specs);
 453               if (scm_is_pair (labels))
 454                 {
 455                   set_labels (scm_car (system_specs), labels);
 456                   labels = SCM_EOL;
 457                 }
 458             }
 459           else
 460             {
 461               /*
 462                 Ignore MIDI
 463               */
 464             }
 465         }
 466       else if (Text_interface::is_markup_list (scm_car (s)))
 467         {
 468           SCM texts = scm_call_3 (interpret_markup_list,
 469                                   paper_->self_scm (),
 470                                   page_properties,
 471                                   scm_car (s));
 472           for (SCM list = texts ; scm_is_pair (list) ; list = scm_cdr (list))
 473             {
 474               SCM t = scm_car (list);
 475               // TODO: init props
 476               Prob *ps = make_paper_system (SCM_EOL);
 477               ps->set_property ("page-break-permission", ly_symbol2scm ("allow"));
 478               ps->set_property ("page-turn-permission", ly_symbol2scm ("allow"));
 479
 480               paper_system_set_stencil (ps, *unsmob_stencil (t));
 481               ps->set_property ("is-title", SCM_BOOL_T);
 482               if (scm_is_pair (scm_cdr (list)))
 483                 {
 484                   /* If an other markup is following, set this markup
 485                    * next padding and next space to 0, so that baseline-skip
 486                    * only should be taken into account for lines vertical
 487                    * spacing. */
 488                   ps->set_property ("next-padding", scm_double2num (0.0));
 489                   ps->set_property ("next-space", scm_double2num (0.0));
 490                 }
 491               system_specs = scm_cons (ps->self_scm (), system_specs);
 492               ps->unprotect ();
 493
 494               if (scm_is_pair (labels))
 495                 {
 496                   set_labels (scm_car (system_specs), labels);
 497                   labels = SCM_EOL;
 498                 }
 499               // FIXME: figure out penalty.
 500               //set_system_penalty (ps, scores_[i].header_);
 501             }
 502         }
 503       else
 504         assert (0);
 505     }
 506
 507   system_specs = scm_reverse_x (system_specs, SCM_EOL);
 508   return system_specs;
 509 }
 510
 511 SCM
 512 Paper_book::systems ()
 513 {
 514   if (systems_ != SCM_BOOL_F)
 515     return systems_;
 516
 517   systems_ = SCM_EOL;
 518   if (scm_is_pair (bookparts_))
 519     {
 520       for (SCM p = scm_reverse (bookparts_); scm_is_pair (p); p = scm_cdr (p))
 521         if (Paper_book *pbookpart = unsmob_paper_book (scm_car (p)))
 522           systems_ = scm_append_x (scm_list_2 (systems_, pbookpart->systems ()));
 523     }
 524   else
 525     {
 526       SCM specs = get_system_specs ();
 527       for (SCM s = specs; scm_is_pair (s); s = scm_cdr (s))
 528         {
 529           if (Paper_score *pscore = dynamic_cast<Paper_score*> (unsmob_music_output (scm_car (s))))
 530             {
 531               SCM system_list = scm_vector_to_list (pscore->get_paper_systems ());
 532               system_list = scm_reverse (system_list);
 533               systems_ = scm_append (scm_list_2 (system_list, systems_));
 534             }
 535           else
 536             {
 537               systems_ = scm_cons (scm_car (s), systems_);
 538             }
 539         }
 540       systems_ = scm_reverse (systems_);
 541
 542       /* backwards compatibility for the old page breaker */
 543       int i = 0;
 544       Prob *last = 0;
 545       for (SCM s = systems_; scm_is_pair (s); s = scm_cdr (s))
 546         {
 547           Prob *ps = unsmob_prob (scm_car (s));
 548           ps->set_property ("number", scm_from_int (++i));
 549
 550           if (last
 551               && to_boolean (last->get_property ("is-title"))
 552               && !scm_is_number (ps->get_property ("penalty")))
 553             ps->set_property ("penalty", scm_from_int (10000));
 554           last = ps;
 555
 556           if (scm_is_pair (scm_cdr (s)))
 557             {
 558               SCM perm = ps->get_property ("page-break-permission");
 559               Prob *next = unsmob_prob (scm_cadr (s));
 560               if (perm == SCM_EOL)
 561                 next->set_property ("penalty", scm_from_int (10001));
 562               else if (perm == ly_symbol2scm ("force"))
 563                 next->set_property ("penalty", scm_from_int (-10001));
 564             }
 565         }
 566     }
 567
 568   return systems_;
 569 }
 570
 571 SCM
 572 Paper_book::pages ()
 573 {
 574   if (SCM_BOOL_F != pages_)
 575     return pages_;
 576
 577   pages_ = SCM_EOL;
 578   if (scm_is_pair (bookparts_))
 579     {
 580       for (SCM p = scm_reverse (bookparts_); scm_is_pair (p); p = scm_cdr (p))
 581         if (Paper_book *pbookpart = unsmob_paper_book (scm_car (p)))
 582           pages_ = scm_append_x (scm_list_2 (pages_, pbookpart->pages ()));
 583     }
 584   else
 585     {
 586       SCM proc = paper_->c_variable ("page-breaking-wrapper");
 587       pages_ = scm_apply_0 (proc, scm_list_1 (self_scm ()));
 588
 589       /* set systems_ from the pages */
 590       if (systems_ == SCM_BOOL_F)
 591         {
 592           systems_ = SCM_EOL;
 593           for (SCM p = pages_; scm_is_pair (p); p = scm_cdr (p))
 594             {
 595               Prob *page = unsmob_prob (scm_car (p));
 596               SCM systems = page->get_property ("lines");
 597               systems_ = scm_append (scm_list_2 (systems_, systems));
 598             }
 599         }
 600     }
 601   return pages_;
 602 }
 603
 604 SCM
 605 Paper_book::performances () const
 606 {
 607   return scm_reverse (performances_);
 608 }