X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fmusic-output-def.cc;h=95ca70953327a714f47d2958b458d80a15d09be2;hb=ed011726ca0dbc44d5394dad366842b1454b1709;hp=e7b012e203a352b04c3f5a828fc1c13b031ecbd6;hpb=499ad01807f1f52e36707a89d7686f04f7e1c3f9;p=lilypond.git diff --git a/lily/music-output-def.cc b/lily/music-output-def.cc index e7b012e203..95ca709533 100644 --- a/lily/music-output-def.cc +++ b/lily/music-output-def.cc @@ -1,162 +1,226 @@ /* - music-output-def.cc -- implement Music_output_def + music-output-def.cc -- implement Output_def source file of the GNU LilyPond music typesetter - (c) 1997--2003 Han-Wen Nienhuys + (c) 1997--2004 Han-Wen Nienhuys */ -#include "scm-hash.hh" - -#include "warn.hh" -#include "music-output-def.hh" -#include "global-translator.hh" -#include "translator-def.hh" -#include "main.hh" +#include "book-paper-def.hh" +#include "context-def.hh" #include "file-path.hh" +#include "global-context.hh" #include "lily-guile.hh" -#include "ly-modules.hh" +#include "ly-module.hh" +#include "main.hh" +#include "output-def.hh" +#include "output-def.hh" +#include "scm-hash.hh" +#include "warn.hh" #include "ly-smobs.icc" -Music_output_def::Music_output_def () +Output_def::Output_def () { - scaled_fonts_ = SCM_EOL; - translator_tab_ = new Scheme_hash_table; scope_ = SCM_EOL; + parent_ = 0; smobify_self (); - scm_gc_unprotect_object (translator_tab_->self_scm ()); - scope_ = ly_make_anonymous_module(); + scope_ = ly_make_anonymous_module (false); } - - -Music_output_def::~Music_output_def () +Output_def::~Output_def () { } -Music_output_def::Music_output_def (Music_output_def const &s) +Output_def::Output_def (Output_def const &s) { scope_ = SCM_EOL; - translator_tab_ = new Scheme_hash_table (*s.translator_tab_); - - scaled_fonts_ = SCM_EOL; - + parent_ = 0; smobify_self (); - scm_gc_unprotect_object (translator_tab_->self_scm ()); - - scaled_fonts_ = scm_list_copy (s.scaled_fonts_); - scope_= ly_make_anonymous_module (); - if (ly_module_p (s.scope_)) - ly_copy_module_variables (scope_, s.scope_); + scope_= ly_make_anonymous_module (false); + if (is_module (s.scope_)) + ly_import_module (scope_, s.scope_); } -IMPLEMENT_SMOBS (Music_output_def); -IMPLEMENT_DEFAULT_EQUAL_P (Music_output_def); +IMPLEMENT_SMOBS (Output_def); +IMPLEMENT_DEFAULT_EQUAL_P (Output_def); + SCM -Music_output_def::mark_smob (SCM m) +Output_def::mark_smob (SCM m) { - Music_output_def * mo = (Music_output_def*) SCM_CELL_WORD_1 (m); - scm_gc_mark (mo->translator_tab_->self_scm ()); - scm_gc_mark (mo->scope_); + Output_def * mo = (Output_def*) SCM_CELL_WORD_1 (m); + + /* + FIXME: why is this necessary? + all bookpaper_ should be protected by themselves. + */ + if (mo->parent_) + scm_gc_mark (mo->parent_->self_scm ()); + - return mo->scaled_fonts_; + mo->derived_mark (); + return mo->scope_; } void -Music_output_def::assign_translator (SCM transdef) +Output_def::derived_mark () {} + +void +assign_context_def (Output_def * m, SCM transdef) { - Translator_def *tp = unsmob_translator_def (transdef); + Context_def *tp = unsmob_context_def (transdef); assert (tp); - translator_tab_->set (tp->type_name_, transdef); - - String nm = ly_symbol2string (tp->type_name_) + "Context"; - - - scm_module_define (scope_, ly_symbol2scm (nm.to_str0()), transdef); + if (tp) + { + SCM sym = tp->get_context_name (); + scm_module_define (m->scope_, sym, transdef); + } } /* find the translator for NAME. NAME must be a symbol. - */ +*/ SCM -Music_output_def::find_translator (SCM name) const +find_context_def (Output_def const *m, SCM name) { - SCM val =SCM_EOL; - translator_tab_->try_retrieve (name, &val); - return val; + Context_def *cd = unsmob_context_def (m->lookup_variable (name)); + return cd ? cd->self_scm () : SCM_EOL; } +int +Output_def::print_smob (SCM s, SCM p, scm_print_state *) +{ + Output_def * def = unsmob_output_def (s); + scm_puts ("#< ", p); + scm_puts (classname (def), p); + + (void)def; + scm_puts (">", p); + return 1; +} -Global_translator * -Music_output_def::get_global_translator () +Real +Output_def::get_dimension (SCM s) const { - SCM key = ly_symbol2scm ("Score"); - Translator_def * t = unsmob_translator_def (find_translator (key)); + SCM val = lookup_variable (s); + return ly_scm2double (val); +} - if (!t) - error (_f ("can't find `%s' context", "Score")); - Translator_group * tg = t->instantiate (this); +SCM +Output_def::lookup_variable (SCM sym) const +{ + SCM var = ly_module_lookup (scope_, sym); + if (SCM_VARIABLEP (var)) + return SCM_VARIABLE_REF (var); - tg->initialize (); + if (parent_) + return parent_->lookup_variable (sym); - return dynamic_cast (tg); + return SCM_EOL; } -int -Music_output_def::print_smob (SCM s, SCM p, scm_print_state *) +SCM +Output_def::c_variable (String s) const { - Music_output_def * def = unsmob_music_output_def (s); - scm_puts ("#", p); - return 1; + return lookup_variable (ly_symbol2scm (s.to_str0 ())); } +void +Output_def::set_variable (SCM sym, SCM val) +{ + scm_module_define (scope_, sym, val); +} -SCM -Music_output_def::get_scmvar (String s) const +LY_DEFINE (ly_paper_lookup, "ly:output-def-lookup", + 2, 0, 0, (SCM pap, SCM sym), + "Lookup @var{sym} in @var{pap}. " + "Return the value or @code{'()} if undefined.") { - return lookup_variable (ly_symbol2scm (s.to_str0 ())); + Output_def *op = unsmob_output_def (pap); + SCM_ASSERT_TYPE (op, pap, SCM_ARG1, __FUNCTION__, "Output_def"); + SCM_ASSERT_TYPE (ly_c_symbol_p (sym), sym, SCM_ARG2, __FUNCTION__, "symbol"); + + return op->lookup_variable (sym); +} + +LY_DEFINE (ly_output_def_scope, "ly:output-def-scope", + 1, 0,0, (SCM def), + "Get the variable scope inside @var{def}.") +{ + Output_def *op = unsmob_output_def (def); + SCM_ASSERT_TYPE (op, def, SCM_ARG1, __FUNCTION__, "Output definition"); + return op->scope_; } -void -Music_output_def::set_variable (SCM sym, SCM val) +LY_DEFINE (ly_output_def_parent, "ly:output-def-parent", + 1, 0, 0, (SCM def), + "Get the parent output-def of @var{def}.") { - scm_module_define (scope_, sym, val); + Output_def *op = unsmob_output_def (def); + SCM_ASSERT_TYPE (op, def, SCM_ARG1, __FUNCTION__, "Output definition"); + return op->parent_ ? op->parent_->self_scm () : SCM_EOL; } -SCM -Music_output_def::lookup_variable (SCM sym) const + +LY_DEFINE (ly_output_def_clone, "ly:output-def-clone", + 1, 0, 0, (SCM def), + "Clone @var{def}.") { - SCM var = ly_module_lookup (scope_, sym); + Output_def *op = unsmob_output_def (def); + SCM_ASSERT_TYPE (op, def, SCM_ARG1, __FUNCTION__, "Output definition"); + SCM s = op->clone ()->self_scm (); + scm_gc_unprotect_object (s); + return s; +} - return scm_variable_ref (var); +LY_DEFINE(ly_output_description, "ly:output-description", + 1,0,0, + (SCM output_def), + "Return the description of translators in @var{output-def}.") +{ + Output_def *id = unsmob_output_def (output_def); + + SCM al =ly_module_to_alist (id->scope_); + + SCM l = SCM_EOL; + for (SCM s = al ; ly_c_pair_p (s); s = ly_cdr (s)) + { + Context_def * td = unsmob_context_def (ly_cdar (s)); + SCM key = ly_caar (s); + if (td && key == td->get_context_name ()) + { + + l = scm_cons (scm_cons (key, td->to_alist ()), l); + } + } + return l; } + + -LY_DEFINE(ly_paper_lookup, - "ly:paper-lookup", - 2, 0,0, - (SCM pap, SCM sym), - "Lookup @var{sym} in @var{pap}. Return the value " - " or '() if undefined. " - ) +#include "interval.hh" + +/* FIXME. This is broken until we have a generic way of + putting lists inside the \paper block. */ +Interval +line_dimensions_int (Output_def *def, int n) { - Music_output_def *op = unsmob_music_output_def (pap); - SCM_ASSERT_TYPE (op, pap, SCM_ARG1, __FUNCTION__, "Paper"); - SCM_ASSERT_TYPE (gh_symbol_p (sym), sym, SCM_ARG2, __FUNCTION__, "symbol"); + Real lw = def->get_dimension (ly_symbol2scm ("linewidth")); + Real ind = n ? 0.0 : def->get_dimension (ly_symbol2scm ("indent")); - SCM v = op->lookup_variable (sym); + return Interval (ind, lw); +} - if (SCM_VARIABLEP(v)) - return SCM_VARIABLE_REF(v); - else - return SCM_EOL; +LY_DEFINE (ly_paper_def_p, "ly:paper-def?", + 1, 0, 0, (SCM def), + "Is @var{def} a paper definition?") +{ + return ly_bool2scm (unsmob_output_def (def)); }