lily/score-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 1997--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
   5
   6   LilyPond is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   LilyPond is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "score-engraver.hh"
  21
  22 #include "all-font-metrics.hh"
  23 #include "axis-group-interface.hh"
  24 #include "context-def.hh"
  25 #include "dispatcher.hh"
  26 #include "global-context.hh"
  27 #include "grob-properties.hh"
  28 #include "international.hh"
  29 #include "main.hh"
  30 #include "open-type-font.hh"
  31 #include "output-def.hh"
  32 #include "paper-column-engraver.hh"
  33 #include "paper-column.hh"
  34 #include "paper-score.hh"
  35 #include "system.hh"
  36 #include "warn.hh"
  37
  38 Score_engraver::Score_engraver ()
  39 {
  40   system_ = 0;
  41   pscore_ = 0;
  42 }
  43
  44 void
  45 Score_engraver::derived_mark () const
  46 {
  47   if (pscore_)
  48     scm_gc_mark (pscore_->self_scm ());
  49   Engraver_group::derived_mark ();
  50 }
  51
  52 void
  53 Score_engraver::prepare (SCM)
  54 {
  55   precomputed_recurse_over_translators (context (), START_TRANSLATION_TIMESTEP, DOWN);
  56 }
  57
  58 void
  59 Score_engraver::finish (SCM)
  60 {
  61   recurse_over_translators (context (), &Translator::finalize,
  62                             &Translator_group::finalize,
  63                             UP);
  64 }
  65
  66 #define MUSIC_FONT "emmentaler-20"
  67
  68 /*
  69   use start/finish?
  70 */
  71 void
  72 Score_engraver::initialize ()
  73 {
  74   Font_metric *fm = all_fonts_global->find_otf (MUSIC_FONT);
  75   if (!fm)
  76     {
  77       error (_f ("cannot find `%s'", MUSIC_FONT ".otf")
  78              + "\n"
  79              + _ ("Music font has not been installed properly.")
  80              + "\n"
  81              + _f ("Search path `%s'", global_path.to_string ().c_str ())
  82              + "\n"
  83              + _ ("Aborting"));
  84     }
  85
  86   pscore_ = new Paper_score (dynamic_cast<Output_def *> (context ()->get_output_def ()));
  87   pscore_->unprotect ();
  88   context ()->set_property ("output", pscore_->self_scm ());
  89
  90   SCM props = Grob_property_info (context (), ly_symbol2scm ("System")).updated ();
  91
  92   pscore_->typeset_system (new System (props));
  93
  94   system_ = pscore_->root_system ();
  95   context ()->set_property ("rootSystem", system_->self_scm ());
  96
  97   Engraver_group::initialize ();
  98 }
  99
 100 void
 101 Score_engraver::connect_to_context (Context *c)
 102 {
 103   Engraver_group::connect_to_context (c);
 104
 105   Dispatcher *d = c->get_global_context ()->event_source ();
 106   d->add_listener (GET_LISTENER (Score_engraver, one_time_step), ly_symbol2scm ("OneTimeStep"));
 107   d->add_listener (GET_LISTENER (Score_engraver, prepare), ly_symbol2scm ("Prepare"));
 108   d->add_listener (GET_LISTENER (Score_engraver, finish), ly_symbol2scm ("Finish"));
 109 }
 110
 111 /*
 112   uncovered:
 113
 114   check_removal always returns false for Score contexts, it has been that way
 115 since I joined the project. There is a reason for this: The typeset score is
 116 stored in the Score_engraver, which in turn is accessed through the
 117 Global_context returned by ly:run-translator. So the score-translator must be
 118 connected to the score-context after run-translator finishes.
 119
 120 I plan to change this: we should junk run-translator, and instead keep track
 121 of both context and translator in the SCM code, and access the typeset score
 122 directly via the created global-translator. Then it would be possible to
 123 disconnect score-translators at iteration time. -es
 124  */
 125 void
 126 Score_engraver::disconnect_from_context ()
 127 {
 128   Dispatcher *d = context ()->get_global_context ()->event_source ();
 129   d->remove_listener (GET_LISTENER (Score_engraver, one_time_step), ly_symbol2scm ("OneTimeStep"));
 130   d->remove_listener (GET_LISTENER (Score_engraver, prepare), ly_symbol2scm ("Prepare"));
 131   d->remove_listener (GET_LISTENER (Score_engraver, finish), ly_symbol2scm ("Finish"));
 132
 133   Engraver_group::disconnect_from_context ();
 134 }
 135
 136 void
 137 Score_engraver::finalize ()
 138 {
 139   Engraver_group::finalize ();
 140
 141   typeset_all ();
 142 }
 143
 144 void
 145 Score_engraver::one_time_step (SCM)
 146 {
 147   if (!to_boolean (context ()->get_property ("skipTypesetting")))
 148     {
 149       precomputed_recurse_over_translators (context (), PROCESS_MUSIC, UP);
 150       Engraver_group::do_announces ();
 151     }
 152
 153   precomputed_recurse_over_translators (context (), STOP_TRANSLATION_TIMESTEP, UP);
 154   typeset_all ();
 155 }
 156
 157 void
 158 Score_engraver::announce_grob (Grob_info info, Direction start_end, Context *reroute_context)
 159 {
 160   Engraver_group::announce_grob (info, start_end, reroute_context);
 161   if (start_end == START)
 162     {
 163       pscore_->root_system ()->typeset_grob (info.grob ());
 164       elems_.push_back (info.grob ());
 165     }
 166 }
 167
 168 void
 169 Score_engraver::typeset_all ()
 170 {
 171   for (vsize i = 0; i < elems_.size (); i++)
 172     {
 173       Grob *elem = elems_[i];
 174
 175       if (!elem->get_parent (Y_AXIS))
 176         Axis_group_interface::add_element (system_, elem);
 177     }
 178   elems_.clear ();
 179 }
 180
 181 ADD_TRANSLATOR_GROUP (Score_engraver,
 182                       /* doc */
 183                       "The top-level engraver.  Takes care of generating"
 184                       " columns and the complete system (i.e.,"
 185                       " @code{System}).\n"
 186                       "\n"
 187                       "This engraver decides whether a column is breakable."
 188                       "  The default is that a column is always breakable."
 189                       "  However, every @code{Bar_engraver} that does not have"
 190                       " a bar line at a certain point sets @code{forbidBreaks}"
 191                       " to stop line breaks.  In practice, this means that you"
 192                       " can make a break point by creating a bar line"
 193                       " (assuming that there are no beams or notes that"
 194                       " prevent a break point).",
 195
 196                       /* create */
 197                       "System ",
 198
 199                       /* read */
 200                       "currentMusicalColumn "
 201                       "currentCommandColumn ",
 202
 203                       /* write */
 204                       ""
 205                      );