X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpaper-def.cc;h=acf580772b9f03972d3d40ef89ca22169df557e9;hb=da000980e554ce4c2a4095d68c1a2be6bc714f7f;hp=0fcdd18fc7dae0d25dd8026b896b3f4f1bdb76dd;hpb=a78c70be8951804126d19eb74b344ae1858023e5;p=lilypond.git diff --git a/lily/paper-def.cc b/lily/paper-def.cc index 0fcdd18fc7..acf580772b 100644 --- a/lily/paper-def.cc +++ b/lily/paper-def.cc @@ -3,164 +3,179 @@ source file of the GNU LilyPond music typesetter - (c) 1997--2001 Han-Wen Nienhuys + (c) 1997--2004 Han-Wen Nienhuys */ + #include +#include "virtual-font-metric.hh" #include "all-font-metrics.hh" #include "string.hh" #include "misc.hh" #include "paper-def.hh" -#include "debug.hh" +#include "warn.hh" #include "scaled-font-metric.hh" #include "main.hh" -#include "scope.hh" -#include "file-results.hh" // urg? header_global_p +#include "scm-hash.hh" #include "paper-outputter.hh" +#include "ly-module.hh" -Paper_def::Paper_def () -{ -} +/* + This is an almost empty thing. The only substantial thing this class + handles is scaling up and down to real-world dimensions (internally + dimensions are against global staff-space.) + */ -Paper_def::~Paper_def () +Paper_def::Paper_def () { + /* Do not remove this statement, scm_make_hash_table may trigger GC. */ + scaled_fonts_ = SCM_EOL; + scaled_fonts_ = scm_c_make_hash_table (11); } Paper_def::Paper_def (Paper_def const&src) : Music_output_def (src) { + /* Do not remove this statement, scm_make_hash_table may trigger GC. */ + scaled_fonts_ = SCM_EOL; + scaled_fonts_ = scm_c_make_hash_table (11); } - -Real -Paper_def::get_var (String s) const +Paper_def::~Paper_def () { - return get_realvar (ly_symbol2scm (s.ch_C ())); } -SCM -Paper_def::get_scmvar (String s) const +void +Paper_def::derived_mark () { - return scope_p_->scm_elem (ly_symbol2scm (s.ch_C ())); + scm_gc_mark (scaled_fonts_); } Real -Paper_def::get_realvar (SCM s) const +Paper_def::get_dimension (SCM s) const { - SCM val ; - if (!scope_p_->try_retrieve (s, &val)) - { - programming_error ("unknown paper variable: " + ly_symbol2string (s)); - return 0.0; - } - - Real sc = 1.0; - SCM ssc; - if (scope_p_->try_retrieve (ly_symbol2scm ("outputscale"), &ssc)) - { - sc = gh_scm2double (ssc); - } - if (gh_number_p (val)) - { - return gh_scm2double (val) / sc; - } - else - { - programming_error ("not a real variable"); - return 0.0; - } + SCM val = lookup_variable (s); + SCM scale = lookup_variable (ly_symbol2scm ("outputscale")); + + Real sc = ly_scm2double (scale); + return ly_scm2double (val) / sc; } -/* - FIXME. This is broken until we have a generic way of - putting lists inside the \paper block. - */ +/* FIXME. This is broken until we have a generic way of + putting lists inside the \paper block. */ Interval Paper_def::line_dimensions_int (int n) const { - Real lw = get_var ("linewidth"); - Real ind = n? 0.0:get_var ("indent"); + Real lw = get_dimension (ly_symbol2scm ("linewidth")); + Real ind = n? 0.0:get_dimension (ly_symbol2scm ("indent")); return Interval (ind, lw); } - - -int Paper_def::score_count_i_ = 0; - -int -Paper_def::get_next_score_count () const -{ - return score_count_i_ ++; -} - -void -Paper_def::reset_score_count () -{ - score_count_i_ = 0; -} - - Paper_outputter* -Paper_def::paper_outputter_p () +Paper_def::get_paper_outputter (String outname) const { - String outname = outname_str (); progress_indication (_f ("paper output to `%s'...", outname == "-" ? String ("") : outname)); - - target_str_global_array.push (outname); - Paper_outputter * po = new Paper_outputter (outname); - Path p = split_path (outname); - p.ext = ""; - po->basename_ = p.str (); - return po; + return new Paper_outputter (outname); } - -/* - todo: use symbols and hashtable idx? -*/ -Font_metric * -Paper_def::find_font (SCM fn, Real m) +Font_metric* +Paper_def::find_scaled_font (Font_metric *f, Real m, SCM input_enc_name) { - SCM key = gh_cons (fn, gh_double2scm (m)); - SCM met = scm_assoc (key, scaled_fonts_); - - if (gh_pair_p (met)) - return unsmob_metrics (gh_cdr (met)); - - SCM ssc; - if (scope_p_->try_retrieve (ly_symbol2scm ("outputscale"), &ssc)) + SCM sizes = scm_hashq_ref (scaled_fonts_, f->self_scm (), SCM_BOOL_F); + if (sizes != SCM_BOOL_F) { - m /= gh_scm2double (ssc); + SCM met = scm_assoc (scm_make_real (m), sizes); + if (ly_c_pair_p (met)) + return unsmob_metrics (ly_cdr (met)); } + else + sizes = SCM_EOL; - Font_metric* f = all_fonts_global_p->find_font (ly_scm2string (fn)); - SCM val = Scaled_font_metric::make_scaled_font_metric (f, m); - scaled_fonts_ = scm_acons (key, val, scaled_fonts_); + /* Hmm. We're chaining font - metrics. Should consider whether to + merge virtual-font and scaled_font. */ + SCM val = SCM_EOL; + if (Virtual_font_metric * vf = dynamic_cast (f)) + { + /* For fontify_atom (), the magnification and name must be known + at the same time. That's impossible for + + Scaled (Virtual_font (Font1,Font2)) + + so we replace by + + Virtual_font (Scaled (Font1), Scaled (Font2)) */ + SCM lst = SCM_EOL; + SCM *t = &lst; + for (SCM s = vf->get_font_list (); ly_c_pair_p (s); s = ly_cdr (s)) + { + Font_metric *scaled = find_scaled_font (unsmob_metrics (ly_car (s)), + m, input_enc_name); + *t = scm_cons (scaled->self_scm (), SCM_EOL); + t = SCM_CDRLOC(*t); + } + + vf = new Virtual_font_metric (lst); + val = vf->self_scm (); + } + else + { + SCM scale_var = ly_module_lookup (scope_, ly_symbol2scm ("outputscale")); + + if (!ly_c_symbol_p (input_enc_name)) + { + SCM var = ly_module_lookup (scope_, ly_symbol2scm ("inputencoding")); + input_enc_name = scm_variable_ref (var); + } + m /= ly_scm2double (scm_variable_ref (scale_var)); + val = Modified_font_metric::make_scaled_font_metric (input_enc_name, + f, m); + } + sizes = scm_acons (scm_make_real (m), val, sizes); scm_gc_unprotect_object (val); - - return dynamic_cast (unsmob_metrics (val)); + scm_hashq_set_x (scaled_fonts_, f->self_scm (), sizes); + return unsmob_metrics (val); } -/* - Return alist to translate internally used fonts back to real-world - coordinates. */ +/* Return alist to translate internally used fonts back to real-world + coordinates. */ SCM -Paper_def::font_descriptions ()const +Paper_def::font_descriptions () const { + SCM func = ly_scheme_function ("hash-table->alist"); - SCM l = SCM_EOL; - for (SCM s = scaled_fonts_; gh_pair_p (s); s = gh_cdr (s)) + for (SCM s = scm_call_1 (func, scaled_fonts_); ly_c_pair_p (s); s = ly_cdr (s)) { - SCM desc = gh_caar (s); - SCM mdesc = unsmob_metrics (gh_cdar (s))->description_; - - l = gh_cons (gh_cons (mdesc, desc), l); + SCM entry = ly_car (s); + for (SCM t = ly_cdr (entry); ly_c_pair_p (t); t = ly_cdr (t)) + { + Font_metric *fm= unsmob_metrics (ly_cdar (t)); + + if (dynamic_cast (fm)) + l = scm_cons (fm->self_scm (), l); + } } return l; } + +Paper_def* +unsmob_paper (SCM x) +{ + return dynamic_cast (unsmob_music_output_def (x)); +} + + +LY_DEFINE (ly_paper_def_p, "ly:paper-def?", + 1, 0, 0, (SCM def), + "Is @var{def} a paper definition?") +{ + Paper_def *op = dynamic_cast (unsmob_music_output_def (def)); + + bool pap = op; + return ly_bool2scm (pap); +}