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   if (ly_scm2bool (paper_->c_variable ("part-is-first")))
 385     {
 386       Stencil title = book_title ();
 387       if (!title.is_empty ())
 388         {
 389           SCM props = paper_->lookup_variable (ly_symbol2scm ("book-title-properties"));
 390           Prob *ps = make_paper_system (props);
 391           paper_system_set_stencil (ps, title);
 392
 393           system_specs = scm_cons (ps->self_scm (), system_specs);
 394           ps->unprotect ();
 395         }
 396     }
 397
 398   SCM page_properties
 399     = scm_call_1 (ly_lily_module_constant ("layout-extract-page-properties"),
 400                   paper_->self_scm ());
 401
 402   SCM interpret_markup_list = ly_lily_module_constant ("interpret-markup-list");
 403   SCM header = SCM_EOL;
 404   SCM labels = SCM_EOL;
 405   for (SCM s = scm_reverse (scores_); scm_is_pair (s); s = scm_cdr (s))
 406     {
 407       if (ly_is_module (scm_car (s)))
 408         {
 409           header = scm_car (s);
 410           if (header_0_ == SCM_EOL)
 411             header_0_ = header;
 412         }
 413       else if (Page_marker *page_marker = unsmob_page_marker (scm_car (s)))
 414         {
 415           /* page markers are used to set page breaking/turning permission,
 416              or to place bookmarking labels */
 417           if (scm_is_symbol (page_marker->permission_symbol ()))
 418             {
 419               /* set previous element page break or turn permission */
 420               if (scm_is_pair (system_specs))
 421                 set_page_permission (scm_car (system_specs),
 422                                      page_marker->permission_symbol (),
 423                                      page_marker->permission_value ());
 424             }
 425           if (scm_is_symbol (page_marker->label ()))
 426             {
 427               /* The next element label is to be set */
 428               labels = scm_cons (page_marker->label (), labels);
 429             }
 430         }
 431       else if (Music_output *mop = unsmob_music_output (scm_car (s)))
 432         {
 433           if (Paper_score *pscore = dynamic_cast<Paper_score *> (mop))
 434             {
 435               SCM title = get_score_title (header);
 436
 437               if (scm_is_pair (system_specs))
 438                 set_system_penalty (scm_car (system_specs), header);
 439
 440               if (unsmob_prob (title))
 441                 {
 442                   system_specs = scm_cons (title, system_specs);
 443                   unsmob_prob (title)->unprotect ();
 444                 }
 445
 446               header = SCM_EOL;
 447               system_specs = scm_cons (pscore->self_scm (), system_specs);
 448               if (scm_is_pair (labels))
 449                 {
 450                   set_labels (scm_car (system_specs), labels);
 451                   labels = SCM_EOL;
 452                 }
 453             }
 454           else
 455             {
 456               /*
 457                 Ignore MIDI
 458               */
 459             }
 460         }
 461       else if (Text_interface::is_markup_list (scm_car (s)))
 462         {
 463           SCM texts = scm_call_3 (interpret_markup_list,
 464                                   paper_->self_scm (),
 465                                   page_properties,
 466                                   scm_car (s));
 467           for (SCM list = texts ; scm_is_pair (list) ; list = scm_cdr (list))
 468             {
 469               SCM t = scm_car (list);
 470               // TODO: init props
 471               Prob *ps = make_paper_system (SCM_EOL);
 472               ps->set_property ("page-break-permission", ly_symbol2scm ("allow"));
 473               ps->set_property ("page-turn-permission", ly_symbol2scm ("allow"));
 474
 475               paper_system_set_stencil (ps, *unsmob_stencil (t));
 476               ps->set_property ("is-title", SCM_BOOL_T);
 477               if (scm_is_pair (scm_cdr (list)))
 478                 {
 479                   /* If an other markup is following, set this markup
 480                    * next padding and next space to 0, so that baseline-skip
 481                    * only should be taken into account for lines vertical
 482                    * spacing. */
 483                   ps->set_property ("next-padding", scm_double2num (0.0));
 484                   ps->set_property ("next-space", scm_double2num (0.0));
 485                 }
 486               system_specs = scm_cons (ps->self_scm (), system_specs);
 487               ps->unprotect ();
 488
 489               if (scm_is_pair (labels))
 490                 {
 491                   set_labels (scm_car (system_specs), labels);
 492                   labels = SCM_EOL;
 493                 }
 494               // FIXME: figure out penalty.
 495               //set_system_penalty (ps, scores_[i].header_);
 496             }
 497         }
 498       else
 499         assert (0);
 500     }
 501
 502   system_specs = scm_reverse_x (system_specs, SCM_EOL);
 503   return system_specs;
 504 }
 505
 506 SCM
 507 Paper_book::systems ()
 508 {
 509   if (systems_ != SCM_BOOL_F)
 510     return systems_;
 511
 512   systems_ = SCM_EOL;
 513   if (scm_is_pair (bookparts_))
 514     {
 515       for (SCM p = scm_reverse (bookparts_); scm_is_pair (p); p = scm_cdr (p))
 516         if (Paper_book *pbookpart = unsmob_paper_book (scm_car (p)))
 517           systems_ = scm_append_x (scm_list_2 (systems_, pbookpart->systems ()));
 518     }
 519   else
 520     {
 521       SCM specs = get_system_specs ();
 522       for (SCM s = specs; scm_is_pair (s); s = scm_cdr (s))
 523         {
 524           if (Paper_score *pscore = dynamic_cast<Paper_score*> (unsmob_music_output (scm_car (s))))
 525             {
 526               SCM system_list = scm_vector_to_list (pscore->get_paper_systems ());
 527               system_list = scm_reverse (system_list);
 528               systems_ = scm_append (scm_list_2 (system_list, systems_));
 529             }
 530           else
 531             {
 532               systems_ = scm_cons (scm_car (s), systems_);
 533             }
 534         }
 535       systems_ = scm_reverse (systems_);
 536
 537       /* backwards compatibility for the old page breaker */
 538       int i = 0;
 539       Prob *last = 0;
 540       for (SCM s = systems_; scm_is_pair (s); s = scm_cdr (s))
 541         {
 542           Prob *ps = unsmob_prob (scm_car (s));
 543           ps->set_property ("number", scm_from_int (++i));
 544
 545           if (last
 546               && to_boolean (last->get_property ("is-title"))
 547               && !scm_is_number (ps->get_property ("penalty")))
 548             ps->set_property ("penalty", scm_from_int (10000));
 549           last = ps;
 550
 551           if (scm_is_pair (scm_cdr (s)))
 552             {
 553               SCM perm = ps->get_property ("page-break-permission");
 554               Prob *next = unsmob_prob (scm_cadr (s));
 555               if (perm == SCM_EOL)
 556                 next->set_property ("penalty", scm_from_int (10001));
 557               else if (perm == ly_symbol2scm ("force"))
 558                 next->set_property ("penalty", scm_from_int (-10001));
 559             }
 560         }
 561     }
 562
 563   return systems_;
 564 }
 565
 566 SCM
 567 Paper_book::pages ()
 568 {
 569   if (SCM_BOOL_F != pages_)
 570     return pages_;
 571
 572   pages_ = SCM_EOL;
 573   if (scm_is_pair (bookparts_))
 574     {
 575       for (SCM p = scm_reverse (bookparts_); scm_is_pair (p); p = scm_cdr (p))
 576         if (Paper_book *pbookpart = unsmob_paper_book (scm_car (p)))
 577           pages_ = scm_append_x (scm_list_2 (pages_, pbookpart->pages ()));
 578     }
 579   else
 580     {
 581       SCM proc = paper_->c_variable ("page-breaking-wrapper");
 582       pages_ = scm_apply_0 (proc, scm_list_1 (self_scm ()));
 583
 584       /* set systems_ from the pages */
 585       if (systems_ == SCM_BOOL_F)
 586         {
 587           systems_ = SCM_EOL;
 588           for (SCM p = pages_; scm_is_pair (p); p = scm_cdr (p))
 589             {
 590               Prob *page = unsmob_prob (scm_car (p));
 591               SCM systems = page->get_property ("lines");
 592               systems_ = scm_append (scm_list_2 (systems_, systems));
 593             }
 594         }
 595     }
 596   return pages_;
 597 }
 598
 599 SCM
 600 Paper_book::performances () const
 601 {
 602   return scm_reverse (performances_);
 603 }