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