X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Frhythmic-column-engraver.cc;h=d8e5751265537b76cd471bf6b0717bc1d12a7124;hb=a97db4ced6286c02dd269c6e985c412fe2c86cb1;hp=2957a3f0cf0fe6b96296f1a122741cce783f2d7a;hpb=af9078fd6d63dea5141e87a1b4d7cb5b0bcba84a;p=lilypond.git diff --git a/lily/rhythmic-column-engraver.cc b/lily/rhythmic-column-engraver.cc index 2957a3f0cf..d8e5751265 100644 --- a/lily/rhythmic-column-engraver.cc +++ b/lily/rhythmic-column-engraver.cc @@ -1,141 +1,153 @@ /* - rhythmic-column-grav.cc -- implement Rhythmic_column_engraver + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 1997--2010 Han-Wen Nienhuys - (c) 1997--2001 Han-Wen Nienhuys -*/ + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . +*/ -#include "slur.hh" #include "engraver.hh" #include "rhythmic-head.hh" #include "stem.hh" #include "note-column.hh" -#include "dot-column.hh" -#include "musical-request.hh" #include "item.hh" +#include "dot-column.hh" +#include "pointer-group-interface.hh" -class Rhythmic_column_engraver :public Engraver +#include "translator.icc" + +/* + this engraver glues together stems, rests and note heads into a NoteColumn + grob. + + It also generates spacing objects. Originally, we have tried to + have the spacing functionality at different levels. + + - by simply using the sequence of Separation-item as + spacing-sequences (at staff level). Unfortunately, this fucks up if + there are different kinds of tuplets in different voices (8th and + 8ths triplets combined made the program believe there were 1/12 th + notes.). + + Doing it in a separate engraver using timing info is generally + complicated (start/end time management), and fucks up if a voice + changes staff. + + Now we do it from here again. This has the problem that voices can + appear and disappear at will, leaving lots of loose ends (the note + spacing engraver don't know where to connect the last note of the + voice on the right with), but we don't complain about those, and let + the default spacing do its work. +*/ + +class Rhythmic_column_engraver : public Engraver { - Link_array rhead_l_arr_; - Grob * stem_l_; - Grob * note_column_; - Grob * dotcol_l_; - - Grob * last_spacing_; - Grob * spacing_; - - TRANSLATOR_DECLARATIONS(Rhythmic_column_engraver); + vector rheads_; + Grob *stem_; + Grob *note_column_; + Grob *dotcol_; + Grob *arpeggio_; + + TRANSLATOR_DECLARATIONS (Rhythmic_column_engraver); protected: - virtual void acknowledge_grob (Grob_info); - virtual void create_grobs (); - virtual void stop_translation_timestep (); - virtual void start_translation_timestep (); + DECLARE_ACKNOWLEDGER (stem); + DECLARE_ACKNOWLEDGER (rhythmic_head); + DECLARE_ACKNOWLEDGER (arpeggio); + void process_acknowledged (); + void stop_translation_timestep (); }; - - Rhythmic_column_engraver::Rhythmic_column_engraver () { - spacing_ =0 ; - last_spacing_ = 0; - - stem_l_ =0; - note_column_=0; - dotcol_l_ =0; + + stem_ = 0; + note_column_ = 0; + arpeggio_ = 0; } void -Rhythmic_column_engraver::create_grobs () +Rhythmic_column_engraver::process_acknowledged () { - if (rhead_l_arr_.size ()) + if (rheads_.size ()) { if (!note_column_) - { - note_column_ = new Item (get_property ("NoteColumn")); - Note_column::set_interface (note_column_); - announce_grob (note_column_, 0); - - spacing_ = new Item (get_property ("NoteSpacing")); - spacing_->set_grob_property ("left-item", note_column_->self_scm ()); - announce_grob (spacing_, 0); - - if (last_spacing_) - { - last_spacing_->set_grob_property ("right-item" , note_column_->self_scm ()); - } - } + note_column_ = make_item ("NoteColumn", rheads_[0]->self_scm ()); - for (int i=0; i < rhead_l_arr_.size (); i++) - { - if (!rhead_l_arr_[i]->get_parent (X_AXIS)) - Note_column::add_head (note_column_, rhead_l_arr_[i]); - } - rhead_l_arr_.set_size (0); + for (vsize i = 0; i < rheads_.size (); i++) + if (!rheads_[i]->get_parent (X_AXIS)) + Note_column::add_head (note_column_, rheads_[i]); + + rheads_.resize (0); } - if (note_column_) { - if (dotcol_l_ - && !dotcol_l_->get_parent (X_AXIS)) + if (stem_ + && !stem_->get_parent (X_AXIS)) { - Note_column::set_dotcol (note_column_, dotcol_l_); - } - - if (stem_l_ - && !stem_l_->get_parent (X_AXIS)) - { - Note_column::set_stem (note_column_, stem_l_); - stem_l_ = 0; + Note_column::set_stem (note_column_, stem_); + stem_ = 0; } + if (arpeggio_) + note_column_->set_object ("arpeggio", arpeggio_->self_scm ()); } } void -Rhythmic_column_engraver::acknowledge_grob (Grob_info i) +Rhythmic_column_engraver::acknowledge_stem (Grob_info i) { - Item * item = dynamic_cast (i.grob_l_); - if (item && Stem::has_interface (item)) - { - stem_l_ = item; - } - else if (item && Rhythmic_head::has_interface (item)) - { - rhead_l_arr_.push (item); - } - else if (item && Dot_column::has_interface (item)) - { - dotcol_l_ = item; - } + stem_ = i.grob (); } void -Rhythmic_column_engraver::stop_translation_timestep () +Rhythmic_column_engraver::acknowledge_rhythmic_head (Grob_info i) { - if (note_column_) - { - typeset_grob (note_column_); - note_column_ =0; - } + rheads_.push_back (i.grob ()); } void -Rhythmic_column_engraver::start_translation_timestep () +Rhythmic_column_engraver::acknowledge_arpeggio (Grob_info i) { - dotcol_l_ =0; - stem_l_ =0; + arpeggio_ = i.grob (); } +void +Rhythmic_column_engraver::stop_translation_timestep () +{ + note_column_ = 0; + stem_ = 0; + arpeggio_ = 0; +} + +ADD_ACKNOWLEDGER (Rhythmic_column_engraver, stem); +ADD_ACKNOWLEDGER (Rhythmic_column_engraver, rhythmic_head); +ADD_ACKNOWLEDGER (Rhythmic_column_engraver, arpeggio); + +ADD_TRANSLATOR (Rhythmic_column_engraver, + /* doc */ + "Generate @code{NoteColumn}, an object that groups stems," + " note heads, and rests.", + + /* create */ + "NoteColumn ", + /* read */ + "", -ENTER_DESCRIPTION(Rhythmic_column_engraver, -/* descr */ "Generates NoteColumn, an objects that groups stems, noteheads and rests.", -/* creats*/ "NoteColumn", -/* acks */ "stem-interface rhythmic-head-interface dot-column-interface", -/* reads */ "", -/* write */ ""); + /* write */ + "" + );