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 Jan Nieuwenhuizen <janneke@gnu.org>
   7 */
   8
   9 #include "paper-book.hh"
  10
  11 #include "ly-module.hh"
  12 #include "main.hh"
  13 #include "output-def.hh"
  14 #include "paper-outputter.hh"
  15 #include "paper-score.hh"
  16 #include "paper-system.hh"
  17 #include "warn.hh"
  18
  19 #include "ly-smobs.icc"
  20
  21 Paper_book::Paper_book ()
  22 {
  23   pages_ = SCM_BOOL_F;
  24   systems_ = SCM_BOOL_F;
  25   header_ = SCM_EOL;
  26
  27   paper_ = 0;
  28   smobify_self ();
  29 }
  30
  31 Paper_book::~Paper_book ()
  32 {
  33 }
  34
  35 IMPLEMENT_DEFAULT_EQUAL_P (Paper_book);
  36 IMPLEMENT_SMOBS (Paper_book)
  37 IMPLEMENT_TYPE_P (Paper_book, "ly:paper-book?")
  38
  39 SCM
  40 Paper_book::mark_smob (SCM smob)
  41 {
  42   Paper_book *b = (Paper_book*) SCM_CELL_WORD_1 (smob);
  43   for (int i = 0; i < b->score_systems_.size (); i++)
  44     b->score_systems_[i].gc_mark ();
  45
  46   if (b->paper_)
  47     scm_gc_mark (b->paper_->self_scm ());
  48   scm_gc_mark (b->header_);
  49   scm_gc_mark (b->pages_);
  50   return b->systems_;
  51 }
  52
  53 int
  54 Paper_book::print_smob (SCM smob, SCM port, scm_print_state*)
  55 {
  56   Paper_book *b = (Paper_book*) SCM_CELL_WORD_1 (smob);
  57
  58   scm_puts ("#<", port);
  59   scm_puts (classname (b), port);
  60   scm_puts (" ", port);
  61   //scm_puts (b->, port);
  62   scm_puts (">", port);
  63   return 1;
  64 }
  65
  66 SCM
  67 dump_fields ()
  68 {
  69   SCM fields = SCM_EOL;
  70   for (int i = dump_header_fieldnames_global.size (); i--; )
  71     fields
  72       = scm_cons (ly_symbol2scm (dump_header_fieldnames_global[i].to_str0 ()),
  73                   fields);
  74   return fields;
  75 }
  76
  77 void
  78 Paper_book::output (String outname)
  79 {
  80   if (!score_systems_.size ())
  81     return;
  82
  83   /* Generate all stencils to trigger font loads.  */
  84   pages ();
  85
  86   SCM scopes = SCM_EOL;
  87   if (ly_c_module_p (header_))
  88     scopes = scm_cons (header_, scopes);
  89
  90   String mod_nm = "scm framework-" + output_backend_global;
  91
  92   SCM mod = scm_c_resolve_module (mod_nm.to_str0 ());
  93   if (make_pages)
  94     {
  95       SCM func = scm_c_module_lookup (mod, "output-framework");
  96
  97       func = scm_variable_ref (func);
  98       scm_apply_0 (func, scm_list_n (scm_makfrom0str (outname.to_str0 ()),
  99                                      self_scm (),
 100                                      scopes,
 101                                      dump_fields (),
 102                                      SCM_UNDEFINED));
 103     }
 104
 105   if (make_preview)
 106     {
 107       SCM func = scm_c_module_lookup (mod, "output-preview-framework");
 108       func = scm_variable_ref (func);
 109       scm_apply_0 (func, scm_list_n (scm_makfrom0str (outname.to_str0 ()),
 110                                      self_scm (),
 111                                      scopes,
 112                                      dump_fields (),
 113                                      SCM_UNDEFINED));
 114     }
 115   progress_indication ("\n");
 116 }
 117
 118 void
 119 Paper_book::classic_output (String outname)
 120 {
 121   /* Generate all stencils to trigger font loads.  */
 122   systems ();
 123
 124   // ugh code dup
 125   SCM scopes = SCM_EOL;
 126   if (ly_c_module_p (header_))
 127     scopes = scm_cons (header_, scopes);
 128
 129   if (ly_c_module_p (score_systems_[0].header_))
 130     scopes = scm_cons (score_systems_[0].header_, scopes);
 131   //end ugh
 132
 133   String format = output_backend_global;
 134   String mod_nm = "scm framework-" + format;
 135
 136   SCM mod = scm_c_resolve_module (mod_nm.to_str0 ());
 137   SCM func = scm_c_module_lookup (mod, "output-classic-framework");
 138
 139   func = scm_variable_ref (func);
 140
 141   scm_apply_0 (func, scm_list_n (scm_makfrom0str (outname.to_str0 ()),
 142                                  self_scm (),
 143                                  scopes,
 144                                  dump_fields (),
 145                                  SCM_UNDEFINED));
 146
 147   progress_indication ("\n");
 148 }
 149
 150 LY_DEFINE (ly_paper_book_pages, "ly:paper-book-pages",
 151           1, 0, 0, (SCM pb),
 152           "Return pages in book PB.")
 153 {
 154   return unsmob_paper_book(pb)->pages ();
 155 }
 156
 157 LY_DEFINE (ly_paper_book_scopes, "ly:paper-book-scopes",
 158           1, 0, 0, (SCM book),
 159           "Return pages in layout book @var{book}.")
 160 {
 161   Paper_book *pb = unsmob_paper_book(book);
 162   SCM_ASSERT_TYPE(pb, book, SCM_ARG1, __FUNCTION__, "Paper_book");
 163
 164   SCM scopes = SCM_EOL;
 165   if (ly_c_module_p (pb->header_))
 166     scopes = scm_cons (pb->header_, scopes);
 167
 168   return scopes;
 169 }
 170
 171 LY_DEFINE (ly_paper_book_systems, "ly:paper-book-systems",
 172            1, 0, 0, (SCM pb),
 173            "Return systems in book PB.")
 174 {
 175   return unsmob_paper_book (pb)->systems ();
 176 }
 177
 178 LY_DEFINE (ly_paper_book_paper, "ly:paper-book-paper",
 179           1, 0, 0, (SCM pb),
 180           "Return pages in book PB.")
 181 {
 182   return unsmob_paper_book (pb)->paper_->self_scm ();
 183 }
 184
 185 /* TODO: resurrect more complex user-tweaks for titling?  */
 186 Stencil
 187 Paper_book::book_title ()
 188 {
 189   SCM title_func = paper_->lookup_variable (ly_symbol2scm ("book-title"));
 190   Stencil title;
 191
 192   SCM scopes = SCM_EOL;
 193   if (ly_c_module_p (header_))
 194     scopes = scm_cons (header_, scopes);
 195
 196
 197   SCM tit = SCM_EOL;
 198   if (ly_c_procedure_p (title_func))
 199     tit = scm_call_2 (title_func,
 200                      paper_->self_scm (),
 201                      scopes);
 202
 203   if (unsmob_stencil (tit))
 204     title = *unsmob_stencil (tit);
 205
 206   if (!title.is_empty ())
 207     title.align_to (Y_AXIS, UP);
 208
 209   return title;
 210 }
 211
 212 Stencil
 213 Paper_book::score_title (int i)
 214 {
 215   SCM title_func = paper_->lookup_variable (ly_symbol2scm ("score-title"));
 216
 217   Stencil title;
 218
 219   // ugh code dup
 220   SCM scopes = SCM_EOL;
 221   if (ly_c_module_p (header_))
 222     scopes = scm_cons (header_, scopes);
 223
 224   if (ly_c_module_p (score_systems_[i].header_))
 225     scopes = scm_cons (score_systems_[i].header_, scopes);
 226   //end ugh
 227
 228   SCM tit = SCM_EOL;
 229   if (ly_c_procedure_p (title_func))
 230     tit = scm_call_2 (title_func,
 231                      paper_->self_scm (),
 232                      scopes);
 233
 234   if (unsmob_stencil (tit))
 235     title = *unsmob_stencil (tit);
 236
 237   if (!title.is_empty ())
 238     title.align_to (Y_AXIS, UP);
 239
 240   return title;
 241 }
 242
 243 void
 244 set_system_penalty (Paper_system * ps, SCM header)
 245 {
 246   if (ly_c_module_p (header))
 247     {
 248       SCM force = ly_module_lookup (header, ly_symbol2scm ("breakbefore"));
 249       if (SCM_VARIABLEP(force)
 250           && scm_is_bool (SCM_VARIABLE_REF(force)))
 251         {
 252           ps->break_before_penalty_ = to_boolean (SCM_VARIABLE_REF(force))
 253             ? -10000
 254             : 10000;
 255         }
 256     }
 257 }
 258
 259 SCM
 260 Paper_book::systems ()
 261 {
 262   if (systems_ != SCM_BOOL_F)
 263     return systems_;
 264
 265   systems_ = SCM_EOL;
 266   Stencil title = book_title ();
 267
 268   if (!title.is_empty ())
 269     {
 270       Paper_system *ps = new Paper_system (title, true);
 271       set_system_penalty (ps, header_);
 272
 273       systems_ = scm_cons (ps->self_scm (), systems_);
 274       scm_gc_unprotect_object (ps->self_scm ());
 275     }
 276
 277   int score_count = score_systems_.size ();
 278   for (int i = 0; i < score_count; i++)
 279     {
 280       Stencil title = score_title (i);
 281       if (!title.is_empty ())
 282         {
 283           Paper_system *ps = new Paper_system (title, true);
 284           systems_ = scm_cons (ps->self_scm (), systems_);
 285           scm_gc_unprotect_object (ps->self_scm ());
 286
 287           set_system_penalty (ps, score_systems_[i].header_);
 288
 289         }
 290
 291       if (scm_vector_p (score_systems_[i].systems_) == SCM_BOOL_T)
 292         {
 293           // guh.
 294           SCM system_list = scm_vector_to_list (score_systems_[i].systems_);
 295
 296           system_list = scm_reverse (system_list);
 297           systems_ = scm_append (scm_list_2 (system_list, systems_));
 298         }
 299     }
 300
 301   systems_ = scm_reverse (systems_);
 302
 303   int i = 0;
 304   Paper_system *last = 0;
 305   for (SCM s = systems_; s != SCM_EOL; s = scm_cdr (s))
 306     {
 307       Paper_system *ps = unsmob_paper_system (scm_car (s));
 308       ps->number_ = ++i;
 309
 310       if (last
 311           && last->is_title ()
 312           && !ps->break_before_penalty_)
 313         ps->break_before_penalty_ = 10000;
 314       last = ps;
 315     }
 316
 317   return systems_;
 318 }
 319
 320 SCM
 321 Paper_book::pages ()
 322 {
 323   if (SCM_BOOL_F != pages_)
 324     return pages_;
 325
 326   pages_ = SCM_EOL;
 327   SCM proc = paper_->c_variable ("page-breaking");
 328   pages_ = scm_apply_0 (proc, scm_list_2 (systems (), self_scm ()));
 329   return pages_;
 330 }
 331
 332
 333 /****************************************************************/
 334
 335 Score_systems::Score_systems ()
 336 {
 337   systems_ = SCM_EOL;
 338   header_ = SCM_EOL;
 339 }
 340
 341 void
 342 Score_systems::gc_mark ()
 343 {
 344   scm_gc_mark (systems_);
 345   scm_gc_mark (header_);
 346 }
 347