lily/book-paper-def.cc

   1 /*
   2   book-paper-def.cc --  implement Book_output_def
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 2004 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7
   8 */
   9
  10 #include "ly-module.hh"
  11 #include "output-def.hh"
  12 #include "dimensions.hh"
  13 #include "book-paper-def.hh"
  14 #include "ly-smobs.icc"
  15 #include "font-metric.hh"
  16 #include "virtual-font-metric.hh"
  17 #include "scaled-font-metric.hh"
  18
  19 Book_output_def::Book_output_def ()
  20 {
  21   output_scale_ = 1.0;
  22   scaled_fonts_ = SCM_EOL;
  23   scaled_fonts_ = scm_c_make_hash_table (11);
  24 }
  25
  26 Real
  27 Book_output_def::output_scale () const
  28 {
  29   return output_scale_;
  30 }
  31
  32 Book_output_def::Book_output_def (Book_output_def const & src)
  33   : Output_def (src)
  34 {
  35   output_scale_ = src.output_scale_;
  36   scaled_fonts_ = SCM_EOL;
  37   scaled_fonts_ = scm_c_make_hash_table (11); // copying is not done with live defs. hopefully.
  38 }
  39
  40 void
  41 Book_output_def::derived_mark ()
  42 {
  43   scm_gc_mark (scaled_fonts_);
  44 }
  45
  46
  47
  48 Font_metric*
  49 Book_output_def::find_scaled_font (Font_metric *f, Real m, SCM input_enc_name)
  50 {
  51   Real lookup_mag = m;
  52   if (!dynamic_cast<Virtual_font_metric*> (f))
  53     lookup_mag /= output_scale ();
  54
  55   SCM sizes = scm_hashq_ref (scaled_fonts_, f->self_scm (), SCM_BOOL_F);
  56   if (sizes != SCM_BOOL_F)
  57     {
  58       SCM met = scm_assoc (scm_make_real (lookup_mag), sizes);
  59       if (ly_c_pair_p (met))
  60         return unsmob_metrics (ly_cdr (met));
  61     }
  62   else
  63     sizes = SCM_EOL;
  64
  65   /* Hmm. We're chaining font - metrics.  Should consider whether to
  66      merge virtual-font and scaled_font.  */
  67   SCM val = SCM_EOL;
  68   if (Virtual_font_metric * vf = dynamic_cast<Virtual_font_metric*> (f))
  69     {
  70       /*
  71         For fontify_atom (), the magnification and name must be known
  72         at the same time. That's impossible for
  73
  74           Scaled (Virtual_font (Font1,Font2))
  75
  76         so we replace by
  77
  78           Virtual_font (Scaled (Font1), Scaled (Font2))
  79
  80       */
  81
  82       SCM lst = SCM_EOL;
  83       SCM *t = &lst;
  84       for (SCM s = vf->get_font_list (); ly_c_pair_p (s); s = ly_cdr (s))
  85         {
  86           Font_metric *scaled = find_scaled_font (unsmob_metrics (ly_car (s)),
  87                                                   m, input_enc_name);
  88           *t = scm_cons (scaled->self_scm (), SCM_EOL);
  89           t = SCM_CDRLOC (*t);
  90         }
  91
  92       vf = new Virtual_font_metric (lst);
  93       val = vf->self_scm ();
  94     }
  95   else
  96     {
  97       if (!ly_c_symbol_p (input_enc_name))
  98         {
  99           SCM var = ly_module_lookup (scope_, ly_symbol2scm ("inputencoding"));
 100           if (var != SCM_BOOL_F)
 101             input_enc_name = scm_variable_ref (var);
 102           if (!ly_c_symbol_p (input_enc_name))
 103             input_enc_name = ly_symbol2scm ("latin1");
 104         }
 105
 106       val = Modified_font_metric::make_scaled_font_metric (input_enc_name,
 107                                                            f, lookup_mag);
 108     }
 109
 110   sizes = scm_acons (scm_make_real (lookup_mag), val, sizes);
 111   scm_gc_unprotect_object (val);
 112   scm_hashq_set_x (scaled_fonts_, f->self_scm (), sizes);
 113   return unsmob_metrics (val);
 114 }
 115
 116 Output_def*
 117 Book_output_def::scale_paper (Output_def *pd) const
 118 {
 119   SCM proc = ly_scheme_function ("scale-paper");
 120   SCM new_pap = scm_call_2 (proc, pd->self_scm (), self_scm ());
 121
 122   scm_gc_protect_object (new_pap);
 123
 124   Output_def *p = unsmob_output_def (new_pap);
 125
 126   p->parent_ = (Output_def*) this;
 127   return p;
 128 }
 129
 130 LY_DEFINE (ly_make_bookpaper, "ly:make-bookpaper",
 131            1, 0, 0,
 132            (SCM size),
 133            "Make a paperbook, for staff space SIZE, which is in INTERNAL_UNIT.")
 134 {
 135   Book_output_def *bp = new Book_output_def ;
 136
 137   SCM_ASSERT_TYPE (ly_c_number_p (size), size,
 138                    SCM_ARG1, __FUNCTION__, "number");
 139
 140   bp->output_scale_ = (ly_scm2double (size)) MM;
 141
 142   return scm_gc_unprotect_object (bp->self_scm ());
 143 }
 144
 145 Book_output_def *
 146 unsmob_book_output_def (SCM bp)
 147 {
 148   return dynamic_cast<Book_output_def*> (unsmob_output_def (bp));
 149 }
 150
 151 LY_DEFINE (ly_bookpaper_fonts, "ly:bookpaper-fonts",
 152            1, 0, 0,
 153            (SCM bp),
 154            "Return fonts scaled up BP")
 155 {
 156   Book_output_def *b = unsmob_book_output_def (bp);
 157
 158   SCM_ASSERT_TYPE (b, bp, SCM_ARG1, __FUNCTION__, "bookpaper");
 159
 160   SCM func = ly_scheme_function ("hash-table->alist");
 161
 162   SCM ell = SCM_EOL;
 163   for (SCM s = scm_call_1 (func, b->scaled_fonts_); ly_c_pair_p (s);
 164        s = ly_cdr (s))
 165     {
 166       SCM entry = ly_car (s);
 167       for (SCM t = ly_cdr (entry); ly_c_pair_p (t); t  = ly_cdr (t))
 168         {
 169           Font_metric *fm = unsmob_metrics (ly_cdar (t));
 170
 171           if (dynamic_cast<Modified_font_metric*> (fm))
 172             ell = scm_cons (fm->self_scm (), ell);
 173         }
 174     }
 175   return ell;
 176 }
 177
 178
 179 LY_DEFINE (ly_bookpaper_outputscale, "ly:bookpaper-outputscale",
 180           1, 0, 0,
 181           (SCM bp),
 182           "Get outputscale for BP.")
 183 {
 184   Book_output_def *b = unsmob_book_output_def (bp);
 185   SCM_ASSERT_TYPE (b, bp, SCM_ARG1, __FUNCTION__, "bookpaper");
 186   return scm_make_real (b->output_scale_);
 187 }
 188
 189
 190
 191 LY_DEFINE (ly_book_output_def_scope, "ly:bookpaper-def-scope",
 192            1, 0,0, (SCM def),
 193            "Get the variable scope inside @var{def}.")
 194 {
 195   Book_output_def *op = unsmob_book_output_def (def);
 196   SCM_ASSERT_TYPE (op, def, SCM_ARG1, __FUNCTION__, "Output definition");
 197   return op->scope_;
 198 }