Idealspacing 0
# yydebug
-InitParser 1
-Parser 1
+InitParser 0
+Parser 0
InitDeclarations 0
Declarations 1
# FlexLexer debug
TOPLEVEL_MAJOR_VERSION = 0
TOPLEVEL_MINOR_VERSION = 0
-TOPLEVEL_PATCH_LEVEL = 72
+TOPLEVEL_PATCH_LEVEL = 73
# use to send patches, always empty for released version:
# include separator: ".postfix", "-pl" makes rpm barf
-30/Jun/97 LilyPond 0.0.72 1
+30/Jun/97 LilyPond 0.0.73 1
--- /dev/null
+This file documents bugs which were "re-introduced" in various pl's
+
+pl 70
+ * r^"simile"
+
+ * hairpin pos.
+
+pl69
+ * slurs.ly
+
+pl68:
+ * opening rests wohltemperirt
+
+ * lyrics broken,
+
+ * midi broken
=item *
-The MusixTeX fonts. (I use those found in MusixTeX T.59). Beware, the
-clef symbol has changed position in the Egler version, aka. OpusTeX)
+The MusixTeX fonts (I included those found in MusixTeX T.73). Beware,
+the clef symbol has changed position in the Egler version,
+a.k.a. OpusTeX)
=back
default: do-doc
true
+
do-doc: $(TEXTFILES)
html: $(HTMLFILES)
MAN1FILES = lilypond convert-mudela mi2mu
MAN1GROFF = $(addprefix $(outdir)/, $(addsuffix .1,$(MAN1FILES)))
-bla:
- echo $(MANGROFF)
- echo $(MANFILES)
-
localinstall: $(outdir)/lilypond.1 $(outdir)/mudela.5
$(INSTALL) -d $(mandir)/man5
$(INSTALL) -d $(mandir)/man1
=head1 DOCUMENTATION
+=over 4
+
=item *
<a href=INSTALL.html
=head1 NAME
-Lily literature -- reading on music engraving/typesetting/etc.
+Lily Literature -- reading on music engraving/typesetting/etc.
=head1 DESCRIPTION
[What I do know, I've commented inside brackets. They are just
my personal comments, not to be taken too seriously]
-=head2 References
+=head2 Music engraving
Wanske, Helene. ``Musiknotation --- Von der Syntax des Notenstichs
zum EDV-gesteuerten Notensatz'', Schott-Verlag, Mainz 1988. ISBN
revised edition by Arnold Broido and Daniel Dorff. Music Publisher's
Association of the United States Inc., 1993.
-W.A. Hegazy and J. S. Gourlay. Optimal line breaking in music. In
-``Document Manipulation and Typography'', J.C. van Vliet (ed) 1988.
-
-[This generalizes TeX's breaking algorithm to music]
-
Ross, Ted. ``Teach yourself the art of music engraving and
processing'' (3rd edition). Hansen House, Miami Beach, FL.
(305) 532-5461
[This is about I<engraving> i.e. professional music typesetting, and
-includes some good spacing tables]
+includes some good spacing tables MB]
Read, Gardner. ``Modern Rhythmic Notation.'' Indiana University Press, 1978.
New York.
[This is as close to the ``standard'' reference work for music notation issues
-as one is likely to get.]
+as one is likely to get. MB]
=head2 Related papers
+
+Byrd, Donald. ``Music Notation by Computer''. Diss. Indiana Univ.,
+1985.
+
+Byrd, Donaldn. ``A System for Music Printing by Computer.''
+Computers and the Humanities, 8 (1974), 161-72.
+
+Smith, Leland. ``Editing and Printing Music by Computer.'' Journal
+of Music Theory, 17 (1973), 292-309.
+
+[If I remember correctly, this was concerned more with an input
+language than with the typography. SP.]
+
+Gomberg, David A. ``A Computer-Oriented System for Music Printing.'' Diss.
+Washington Univ. 1975.
+
+Hewlett, Walter B. and Eleanor Selfridge-Field. Directory of Computer
+Assisted Research in Musicology. Menlo Park, CA: Center for Computer
+Assisted Research in the Humanities.
+
+[Annual editions since 1985, many containing surveys of music
+typesetting technology. SP]
+
+
+W.A. Hegazy and J. S. Gourlay. Optimal line breaking in music. In
+``Document Manipulation and Typography'', J.C. van Vliet (ed) 1988.
+
+[This generalizes TeX's breaking algorithm to music]
+
David A. Gomberg; A Computer-oriented System for Music Printing.
Computers and the Humanities, Vol.11, pp 63-80.
[This paper describes a vapourware music setting system and an input
language to go with it. ]
-D. Blostein and L. Haken, The Lime Music Editor: A Diagram Editor
+D. Blostein and L. Haken, The Lime Music Editor: A Diagram Editor
Involving Complex Translations, Software Practice and Experience,
-Vol. 24, No. 3, March 1994, pp. 289-306.
+Vol. 24, No. 3, March 1994, pp. 289-306.
[A description of various conversions, decisions and issues relating
to this interactive editor]
"constraints" (which go unexplained) to automatically position various
elements.]
+Stephen Dowland Page. ``Computer Tools for Music Information
+Retrieval''. Dissertation Univ of Oxford, 1988.
+
+[Don't ask Stephen for a copy. Write to the Bodleian Library, Oxford,
+or to the British Library, instead.]
+
=head2 Further reading
Chlapik, Herbert. ``Die Praxis des Notengraphikers''. Doblinger, 1987.
Tablature: http://wabakimi.carleton.ca/~phacket2/guitar/tabfaq.html
-
-(of varying usefulness):
-
Donato, Anthony. Preparing Music Manuscript. Englewood Cliffs:
Prentice-Hall, 1963.
-Donemus. "Uitgeven van muziek". Donemus Amsterdam, 1900
+Donemus. ``Uitgeven van muziek''. Donemus Amsterdam, 1900
Heussenstamm, George. The Norton Manual of Music Notation. New York:
Norton, 1987.
=head2 other stuff
-Andreas Mahling, J. Herczeg, M. Herczeg and S<H.-D.> B\"ocker, Beyond
-visualization: knowing and understanding. In P.~Gorny, M.~J. Tauber
-(eds.), Visualization in Human-Computer Interaction, Lecture
-Notes in Computer Science, 439, 16--26, Springer-Verlag, 1990.
Peter S. Langston, Unix music tools at Bellcore.
Software --- Practice and Experience, Vol. 20(S1), S1/47--S1/61, 1990.
Miguel Filgueiras, Some Music Typesetting Algorithms. LIACC,
Universidade do Porto, forthcoming.
+
+=head1 AUTHORS
+
+Refs contributed by Han-Wen Nienhuys, Miguel Filgueiras, Mark
+Basinski, Dorothea Blostein, Stephen Page, Jan Nieuwenhuizen.
+
+This should really be redone in BibTeX
=head2 Free packages (with source)
-G Sharp, http://dept-info.labri.u-bordeaux.fr/~strandh/Gsharp
+=item G Sharp, http://dept-info.labri.u-bordeaux.fr/~strandh/Gsharp
An alpha version notation editor for X. Source available on request.
-Rosegarden, http://www.math.bath.ac.uk/~masjpf/rose.html
+=item Rosegarden, http://www.math.bath.ac.uk/~masjpf/rose.html
A Notation editor/Sequencer for X (win95 port underway). Outputs musictex.
-Common Notation, http://www-ccrma.stanford.edu/ccrma/Software/cmn/cmn.html
+=item Common Notation, http://www-ccrma.stanford.edu/ccrma/Software/cmn/cmn.html
-A versatile lisp package. Part of the Common Music system. Input is in Lisp.
+A versatile lisp package. Part of the Common Music system. Input is in
+Lisp. It needs Adobe fonts
-Vivace, http://www.calband.berkeley.edu/~gmeeker/vivace
+=item Vivace, http://www.calband.berkeley.edu/~gmeeker/vivace
A amateurish notation program for TclTk and X.
-MPP, http://www.stack.nl/~hanwen/mpp-english.html
+=item MPP, http://www.stack.nl/~hanwen/mpp-english.html
A preprocessor to MusixTeX by Jan Nieuwenhuizen and Han-Wen Nienhuys.
It is outdated by its successor, LilyPond.
-Music, http://www.cs.nott.ac.uk/Departement/Staff/ef/printing.html
+=item Music, http://www.cs.nott.ac.uk/Departement/Staff/ef/printing.html
A TROFF preprocessor by Eric Foxley
A-R Music Engraving, by A-R Editions, Inc. Professional engraving on
Sun boxen.
-Mup, http://www.arkkra.com/
+=item Mup, http://www.arkkra.com/
A program which creates PS from a script input. Although it comes with
C source code, it is Shareware.
-PMX, http://www.gmd.de/Misc/Music/
+=item PMX, http://www.gmd.de/Misc/Music/
A Preprocessor for MusiXTeX by Don Simons
-Musi*TeX, http://www.gmd.de/Misc/Music/
+=item Musi*TeX, http://www.gmd.de/Misc/Music/
MusixTeX is a macro package for TeX to typeset polyphonic or
instrumental music by Daniel Taupin, Ross Mitchell and Andreas
Egler. It includes a font set with lots symbols
-ABC2MTeX, http://www.gmd.de/Misc/Music/
+=item ABC2MTeX, http://www.gmd.de/Misc/Music/
A preprocessor to MusixTeX by Chris Walshaw for way of transcribing folk
and traditional music.
-SceX http://www.ncc.up.pt/~mig/SceX.html
+=item SceX http://www.ncc.up.pt/~mig/SceX.html
A preprocessor to MusixTeX by Miguel Filgueiras. Source in prolog
available on request. (?)
-MUTEX, http://www.gmd.de/Misc/Music/
+=item MUTEX, http://www.gmd.de/Misc/Music/
A TeX macro package for typesetting single-staff music by Angelika
Schofer & Andrea Steinbach. With some fonts
=head2 Free (zero cents)
-Calliope, http://www.cl.cam.ac.uk/users/wfc/
+=item Calliope, http://www.cl.cam.ac.uk/users/wfc/
-A NeXT package by William F Clocksin. Requires Adobe fonts.
+A NeXT package by William F. Clocksin. Requires Adobe fonts.
=head2 Proprietary
-MusicEase, http://mesa.colorado.edu/~grader/musicez.html
+=item MusicEase, http://mesa.colorado.edu/~grader/musicez.html
Described in Computer vol 29(6). Shareware
-LIME, http://datura.cerl.uiuc.edu/
+=item LIME, http://datura.cerl.uiuc.edu/
-Sibelius, http://www.acorn.co.uk/developers/sibelius
+=item Sibelius, http://www.acorn.co.uk/developers/sibelius
Finale
Personal Composer
-Mozart, http://www.mozart.co.uk/
+
+
+=item Mozart, http://www.mozart.co.uk/
A shareware windows package
=head2 Unknown
-Berlioz, http://www.bsi.fr/~montel/
+=item Berlioz, http://www.bsi.fr/~montel/
-3/Jul/97 LilyPond 0.0.72 1
+7/Jul/97 LilyPond 0.0.73 1
-3/Jul/97 LilyPond 0.0.72 2
+7/Jul/97 LilyPond 0.0.73 2
-3/Jul/97 LilyPond 0.0.72 3
+7/Jul/97 LilyPond 0.0.73 3
+\bo TeX
- +\bo The MusixTeX fonts. (I use those found in MusixTeX
- T.59). Beware, the clef symbol has changed position
- in the Egler version, aka. OpusTeX)
+ +\bo The MusixTeX fonts (I included those found in
+ MusixTeX T.73). Beware, the clef symbol has changed
+ position in the Egler version, a.k.a. OpusTeX)
At this time, GNU LilyPond output looks nice, but is not
of production quality. If you're not discouraged; this is
-3/Jul/97 LilyPond 0.0.72 4
+7/Jul/97 LilyPond 0.0.73 4
-3/Jul/97 LilyPond 0.0.72 5
+7/Jul/97 LilyPond 0.0.73 5
+pl 73pre
+ - some refs doco.
+ - move Input_engraver into Paper_def
+ - junk Interpreter
+ - naming: Request_engraver -> Engraver,
+ - Music_iterator::next() -> process_and_next()
+ - junk Voice_engravers
+ - Span_bar, Span_bar_engraver
+ - Vertical_align_engraver
+
+*******
july 2
pl 72pre
- - paper{} syntax: var = 1.0\pt;, with an Assoc array
+ - \paper{} syntax: var = 1.0\pt;, with an Assoc array
- sketch of MIDI Performer classes.
- bf: memleak in parser
- naming: Acceptor -> Translator
Most of the items are marked in the code as well, with full explanation.
grep for TODO and ugh/ugr
+ * pushgroup/popgroup
+
+ * strict separation between visual and auditive processing.
+
+ * fix depcy/dept stuff in eg. Beam.
+
* whole head on ledger line
* piano staff
tekst staat erg ver van notenbalken af
-Onduidelijk wanneer wel en geen \ voor een woord. Maak liever
-verplichte regels
-
BUGS
* spurious Weird stem size warnings
* lilypond - -> crash
- * scales.ly
-
* standchen triool beam up/down
* (where are the) gcc compile warnings on linux
%
\requestengraver {
- "Score_engraver"
+ "Score_engraver"
\alias "Score";
-% \consists "Score_bar_engraver";
\consists "Bar_align_engraver";
\consists "Clef_align_engraver";
\consists "Key_align_engraver";
\consists "Meter_align_engraver";
\consists "Score_horizontal_align_engraver";
+ \consists "Vertical_align_engraver";
+ \consists "Span_bar_engraver";
\contains\requestengraver {
"Staff_engravers"
\consists "Note_column_engraver";
\consists "Slur_engraver";
\contains \requestengraver {
- "Voice_engravers"
+ "Engraver_group_engraver"
\alias "Voice";
\consists "Note_head_engraver" ;
\consists "Tie_engraver";
"Voice_group_engravers"
\alias "Voice_group";
\contains\requestengraver{
- "Voice_engravers"
+ "Engraver_group_engraver"
\consists "Lyric_engraver";
\consists "Swallow_engraver";
}
+++ /dev/null
-
- [todo]
- * runtime
-
-%{ "french" style: interbeam = intenote;
- "german" style: interbeam = 2/3 * interline
-%}
- as lily's style is currently german, we'll hardcode german style
- */
- // it seems that "interline" means _between_ lines
-// return ball(4).dim.y.length() * 2 / 3;
- return ball(4).dim.y.length() * 2 / 3 + 0.4; //ugh
-}
-\include "table_sixteen.ini"
-
-default_paper = paper {
- linewidth = 15 \cm;
- rule_thickness = 0.4\pt;
- interline = 4\pt;
- notewidth = 4\pt;
- interbeam = 7\pt;
- \symboltables { \table_sixteen }
-}
default_paper = \paper {
linewidth = 15.0 \cm;
rule_thickness = 0.4\pt;
+ bar_size = 16.0 \pt;
interline = 4.\pt;
- notewidth = 4.0\pt;
- wholewidth = 5.\pt;
+ notewidth = 5.0\pt;
+ wholewidth = 4.8\pt;
unitspace = 30.\pt;
%
interbeam = 2.667\pt;
geometric = 1.414;
\symboltables { \table_sixteen }
+ \include "engraver.ini"
}
\version "0.0.61";
-\include "engraver.ini"
\include "dynamic.ini"
-\include "dutch.ini" % do not include init/ path
+\include "dutch.ini"
\include "script.ini"
\include "paper16.ini"
+left = -1
+right = 1
+up = 1
+down = -1
"bars" = \table {
"empty" "\emptybar"
- "|" "\maatstreep" 0.0\pt 0.64\pt -8.0\pt 8.0\pt
- "||" "\doublebar" 0.0\pt 4.0\pt -8.0\pt 8.0\pt
- "|." "\finishbar" -4.0\pt 0.0\pt -8.0\pt 8.0\pt
- ":|" "\repeatbar" -4.0\pt 0.0\pt -8.0\pt 8.0\pt
- "|:" "\startrepeat" 0.0\pt 4.0\pt -8.0\pt 8.0\pt
- ":|:" "\repeatbarstartrepeat" 0.0\pt 16.0\pt -8.0\pt 8.0\pt
+ "|" "\maatstreep{%}" 0.0\pt 0.64\pt .0\pt 16.0\pt
+ "||" "\doublebar{%}" 0.0\pt 4.0\pt .0\pt 16.0\pt
+ "|." "\finishbar{%}" -4.0\pt 0.0\pt .0\pt 16.0\pt
+ ":|" "\repeatbar" -4.0\pt 0.0\pt .0\pt 16.0\pt
+ "|:" "\startrepeat" 0.0\pt 4.0\pt 0.0\pt 16.0\pt
+ ":|:" "\repeatbarstartrepeat" 0.0\pt 16.0\pt 0.0\pt 16.0\pt
}
% declare melody (which will be in *one* staff ) for the lead voice
melodie = \melodic {
% switch Lilypond in note-mode
- \clef\violin;
+ \clef"violin";
\meter 2/4 ;
\octave c'; % set the default octave
% the default note duratino is 4
{ \octave c'; c4 c4
< \multi 1; { c2 c2 } { c'2 c'2 } >
< \multi 2; { \stem -1; c2 c2 } { \stem 1; c'2 c'2 } >
- < \multi 3; { \clef "bass"; c2 c2 } { \bar "||"; \key cis ; c'2 c'2 } >
+ < \multi 3; { \clef "bass"; c2 c2 } { \meter 2/4;\bar "||"; \key fis cis gis; c'2 c'2 } >
c2 c1
}
\score{
\melodic { \IImenuetto }
\paper{
- width= 195.0\mm;
unitspace= 9.0\mm ;% to get lily to use only three lines
geometric= 1.40;
+ linewidth= 195.0\mm;
\output "scsii-menuetto.out";
}
\midi{
{ \id "Lyric" "2"; \tekstII }
\melodic < \melodie \commands >
- \melodic <\begeleiding \commands >
-
+ \melodic < \begeleiding \commands >
>
\paper{
- width= 195.\mm;
+ linewidth= 195.\mm;
% on two pages...
unitspace= 9.\mm;
MAJOR_VERSION = 0
MINOR_VERSION = 0
-PATCH_LEVEL = 72
+PATCH_LEVEL = 73
# use to send patches, always empty for released version:
# include separator: ".postfix", "-pl" makes rpm barf
}
IMPLEMENT_STATIC_NAME(Bar_engraver);
-IMPLEMENT_IS_TYPE_B1(Bar_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Bar_engraver,Engraver);
ADD_THIS_ENGRAVER(Bar_engraver);
Bar::Bar()
{
type_str_ = "|";
+ spanned_i_ = 0;
}
Molecule*
Bar::brew_molecule_p()const
{
- Symbol s = paper()->lookup_l()->bar(type_str_);
+ Paper_def *p = paper();
+ Symbol s = p->lookup_l()->bar( type_str_,
+ p->get_var("bar_size") );
Molecule*output = new Molecule(Atom(s));
return output;
}
TODO
- Less hairy code. Better slope calculations.
- knee: ([\stem 1; c8 \stem -1; c8]
+ Less hairy code. knee: ([\stem 1; c8 \stem -1; c8]
*/
}
IMPLEMENT_STATIC_NAME(Clef_engraver);
-IMPLEMENT_IS_TYPE_B1(Clef_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Clef_engraver,Engraver);
ADD_THIS_ENGRAVER(Clef_engraver);
}
IMPLEMENT_STATIC_NAME(Collision_engraver);
-IMPLEMENT_IS_TYPE_B1(Collision_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Collision_engraver,Engraver);
ADD_THIS_ENGRAVER(Collision_engraver);
}
IMPLEMENT_STATIC_NAME(Dynamic_engraver);
-IMPLEMENT_IS_TYPE_B1(Dynamic_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Dynamic_engraver,Engraver);
ADD_THIS_ENGRAVER(Dynamic_engraver);
Dynamic_engraver::~Dynamic_engraver()
iter_top(grav_list_, i);
while (i.ok()) {
// this construction to ensure clean deletion
- Request_engraver *grav_l = i++;
+ Engraver *grav_l = i++;
grav_l->set_feature(d);
}
}
iter_top(grav_list_, i);
while (i.ok()) {
- Request_engraver *grav_l = i++;
+ Engraver *grav_l = i++;
grav_l->sync_features();
}
}
iter_top(grav_list_, i);
while (i.ok()) {
- Request_engraver *grav_l = i++;
+ Engraver *grav_l = i++;
grav_l->pre_move_processing();
}
}
iter_top(grav_list_, i);
while (i.ok()) {
- Request_engraver *grav_l = i++;
+ Engraver *grav_l = i++;
grav_l->process_requests();
}
}
iter_top(grav_list_, i);
while (i.ok()) {
// this construction to ensure clean deletion
- Request_engraver *grav_l = i++;
+ Engraver *grav_l = i++;
grav_l->post_move_processing();
}
}
bool
-Engraver_group_engraver::contains_b(Request_engraver* grav_l)const
+Engraver_group_engraver::contains_b(Engraver* grav_l)const
{
- bool parent_b = Request_engraver::contains_b(grav_l);
+ bool parent_b = Engraver::contains_b(grav_l);
if (parent_b)
return true;
return hebbes_b ;
}
+bool
+Engraver_group_engraver::try_request(Request* r)
+{
+ return Engraver::try_request(r);
+}
+
void
-Engraver_group_engraver::add(Request_engraver *grav_p)
+Engraver_group_engraver::add(Engraver *grav_p)
{
grav_list_.bottom().add(grav_p);
grav_p->daddy_grav_l_ = this;
}
-Request_engraver *
-Engraver_group_engraver::remove_engraver_p(Request_engraver*grav_l)
+Engraver *
+Engraver_group_engraver::remove_engraver_p(Engraver*grav_l)
{
group_l_arr_.substitute((Engraver_group_engraver*)grav_l,0);
nongroup_l_arr_.substitute(grav_l,0);
}
void
-Engraver_group_engraver::terminate_engraver(Request_engraver*r_l)
+Engraver_group_engraver::terminate_engraver(Engraver*r_l)
{
mtor << "Removing " << r_l->name() << " at " << get_staff_info().when() << "\n";
r_l->do_removal_processing();
- Request_engraver * grav_p =remove_engraver_p(r_l);
+ Engraver * grav_p =remove_engraver_p(r_l);
delete grav_p;
}
-IMPLEMENT_IS_TYPE_B2(Engraver_group_engraver,Request_engraver, Translator);
+IMPLEMENT_IS_TYPE_B2(Engraver_group_engraver,Engraver, Translator);
IMPLEMENT_STATIC_NAME(Engraver_group_engraver);
ADD_THIS_ENGRAVER(Engraver_group_engraver);
Engraver_group_engraver::announce_element(Score_elem_info info)
{
announce_info_arr_.push(info);
- Request_engraver::announce_element(info);
+ Engraver::announce_element(info);
}
void
if (!info.req_l_)
info.req_l_ = &dummy_req;
- for (int i=0; i < nongroup_l_arr_.size(); i++) {
+ for (int i=0; i < nongroup_l_arr_.size(); i++) { // Is this good enough?6
if (nongroup_l_arr_[i] != info.origin_grav_l_arr_[0])
nongroup_l_arr_[i]->acknowledge_element(info);
}
Staff_info
Engraver_group_engraver::get_staff_info()const
{
- Staff_info inf = Request_engraver::get_staff_info();
+ Staff_info inf = Engraver::get_staff_info();
for (int i=0; i < nongroup_l_arr_.size(); i++)
nongroup_l_arr_[i]->fill_staff_info(inf);
Translator*
Engraver_group_engraver::get_default_interpreter()
{
- if ( interpreter_l() )
+ // ?
+ if ( is_bottom_engraver_b() )
return daddy_grav_l_->get_default_interpreter();
Engraver_group_engraver *grav_p= igrav_l_->
get_default_igrav_l()->get_group_engraver_p();
add(grav_p );
- if (grav_p->interpreter_l())
+ if (grav_p->is_bottom_engraver_b())
return grav_p;
else
return grav_p->get_default_interpreter();
}
+
+bool
+Engraver_group_engraver::is_bottom_engraver_b()const
+{
+ return !igrav_l_->get_default_igrav_l();
+}
/*
- engraver.cc -- implement Request_engraver
+ engraver.cc -- implement Engraver
Sourcefile of GNU LilyPond musictypesetter
#include "debug.hh"
void
-Request_engraver::post_move_processing()
+Engraver::post_move_processing()
{
if (status < CREATION_INITED) {
}
bool
-Request_engraver::try_request(Request * r)
+Engraver::try_request(Request * r)
{
if (status < MOVE_INITED)
post_move_processing();
}
void
-Request_engraver::process_requests()
+Engraver::process_requests()
{
if (status < PROCESSED_REQS)
post_move_processing();
}
void
-Request_engraver::pre_move_processing()
+Engraver::pre_move_processing()
{
do_pre_move_processing();
status = CREATION_INITED;
}
void
-Request_engraver::fill_staff_info(Staff_info&)
+Engraver::fill_staff_info(Staff_info&)
{
}
Scalar
-Request_engraver::get_feature(String t)
+Engraver::get_feature(String t)
{
return daddy_grav_l_->get_feature(t);
}
bool
-Request_engraver::do_try_request(Request*)
+Engraver::do_try_request(Request*)
{
return false;
}
-Request_engraver::Request_engraver()
+Engraver::Engraver()
{
status = VIRGIN;
daddy_grav_l_ = 0;
}
void
-Request_engraver::announce_element(Score_elem_info i)
+Engraver::announce_element(Score_elem_info i)
{
i.origin_grav_l_arr_.push(this);
daddy_grav_l_->announce_element(i);
}
void
-Request_engraver::typeset_element(Score_elem*p)
+Engraver::typeset_element(Score_elem*p)
{
daddy_grav_l_->typeset_element(p);
}
Paper_def*
-Request_engraver::paper()const
+Engraver::paper()const
{
return daddy_grav_l_->paper();
}
void
-Request_engraver::typeset_breakable_item(Item * nobreak_p)
+Engraver::typeset_breakable_item(Item * nobreak_p)
{
daddy_grav_l_->typeset_breakable_item(nobreak_p);
}
bool
-Request_engraver::contains_b(Request_engraver *grav_l)const
+Engraver::contains_b(Engraver *grav_l)const
{
return this == grav_l;
}
Staff_info
-Request_engraver::get_staff_info() const
+Engraver::get_staff_info() const
{
return daddy_grav_l_->get_staff_info();
}
void
-Request_engraver::print() const
+Engraver::print() const
{
#ifndef NPRINT
mtor << "\n" << name() << " {";
#endif
}
-IMPLEMENT_STATIC_NAME(Request_engraver);
-IMPLEMENT_IS_TYPE_B(Request_engraver);
+IMPLEMENT_STATIC_NAME(Engraver);
+IMPLEMENT_IS_TYPE_B(Engraver);
void
-Request_engraver::do_print()const
+Engraver::do_print()const
{
}
#include "debug.hh"
#include "engraver.hh"
-struct Request_engraver_table_entry {
+struct Engraver_table_entry {
String name_str_;
Grav_ctor ctor_l_;
- Request_engraver_table_entry(String s, Grav_ctor f) {
+ Engraver_table_entry(String s, Grav_ctor f) {
name_str_ =s;
ctor_l_ = f;
}
- Request_engraver_table_entry()
+ Engraver_table_entry()
{
ctor_l_ =0;
}
};
-static Array<Request_engraver_table_entry> *grav_table=0;
+static Array<Engraver_table_entry> *grav_table=0;
void
-add_request_engraver(String s, Grav_ctor f)
+add_Engraver(String s, Grav_ctor f)
{
if (!grav_table)
- grav_table = new Array<Request_engraver_table_entry>;
+ grav_table = new Array<Engraver_table_entry>;
- grav_table->push(Request_engraver_table_entry(s, f));
+ grav_table->push(Engraver_table_entry(s, f));
}
-Request_engraver*
+Engraver*
get_engraver_p(String s)
{
for (int i=0; i < grav_table->size(); i++) {
}
IMPLEMENT_STATIC_NAME(Note_head_engraver);
-IMPLEMENT_IS_TYPE_B1(Note_head_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Note_head_engraver,Engraver);
ADD_THIS_ENGRAVER(Note_head_engraver);
} \
class Class
+
DEFAULT_PRINT(Script_id, General_script_def, script);
DEFAULT_PRINT(Lookup_id, Lookup, lookup);
DEFAULT_PRINT(Symtables_id, Symtables, symtables);
DEFAULT_PRINT(Score_id, Score, score);
DEFAULT_PRINT(Input_gravs_id, Input_engraver, igravs);
DEFAULT_PRINT(Paper_def_id,Paper_def, paperdef);
+
void
Real_id::do_print() const
{
- Identifier::print();
mtor << *((Real_id*)this)->real(false)<< "\n";
}
+void
+Int_id::do_print() const
+{
+ mtor << *((Int_id*)this)->intid(false)<< "\n";
+}
+
+
#define default_accessor(Idclass, Class, accessor)\
Class*\
Idclass::accessor(bool copy) {\
+implement_id_class(Int_id, int, intid);
implement_id_class(Real_id, Real, real);
implement_id_class(Script_id, General_script_def, script);
implement_id_class(Lookup_id, Lookup, lookup);
assert(false);
}
-
+default_accessor(Int_id, int, intid);
default_accessor(Real_id, Real, real);
virtual_accessor(Script_id, General_script_def, script);
default_accessor(Lookup_id, Lookup, lookup);
#ifndef ACCEPTOR_HH
#define ACCEPTOR_HH
+#error
#include "string.hh"
#include "lily-proto.hh"
/**
generate bars. Either user ("|:"), or default (new measure)
*/
-class Bar_engraver : public Request_engraver {
+class Bar_engraver : public Engraver {
Bar_req * bar_req_l_;
Bar * bar_p_;
public:
class Bar:public Item {
public:
String type_str_;
+ int spanned_i_;
NAME_MEMBERS();
SCORE_ELEM_CLONE(Bar);
#include "engraver.hh"
/// where is c-0 in the staff?
-class Clef_engraver : public Request_engraver {
+class Clef_engraver : public Engraver {
Clef_item *clef_p_;
Clef_change_req * clef_req_l_;
void create_clef();
#include "engraver.hh"
-class Collision_engraver : public Request_engraver {
+class Collision_engraver : public Engraver {
Collision* col_p_;
protected:
#include "engraver.hh"
-class Dynamic_engraver : public Request_engraver {
+class Dynamic_engraver : public Engraver {
int dir_i_;
Text_item * dynamic_p_;
Crescendo * to_end_cresc_p_;
Group a number of engravers. Usually delegates everything to its contents.
Postfix: group
*/
-class Engraver_group_engraver : public Request_engraver, public virtual Translator {
+class Engraver_group_engraver : public Engraver, public virtual Translator {
protected:
- Pointer_list<Request_engraver*> grav_list_;
+ Pointer_list<Engraver*> grav_list_;
Link_array<Engraver_group_engraver> group_l_arr_;
- Link_array<Request_engraver> nongroup_l_arr_;
+ Link_array<Engraver> nongroup_l_arr_;
Array<Score_elem_info> announce_info_arr_;
Engraver_group_engraver();
~Engraver_group_engraver();
+ bool is_bottom_engraver_b() const;
/**
Pre:
#grav_l# is in #grav_list_#
*/
- virtual void terminate_engraver(Request_engraver * grav_l);
+ virtual void terminate_engraver(Engraver * grav_l);
NAME_MEMBERS();
/**
Remove #grav_l# from the list, and return it.
*/
- virtual Request_engraver * remove_engraver_p(Request_engraver*grav_l);
+ virtual Engraver * remove_engraver_p(Engraver*grav_l);
virtual void set_feature(Feature i);
- virtual void sync_features() ;
+ virtual void sync_features();
+
virtual void do_pre_move_processing();
virtual void do_post_move_processing();
-
virtual void do_removal_processing();
virtual bool do_try_request(Request*);
+ virtual bool try_request(Request*);
virtual void do_process_requests();
virtual Staff_info get_staff_info()const;
virtual Engraver_group_engraver * find_engraver_l(String name,String id);
virtual void do_announces();
virtual void announce_element(Score_elem_info);
-
-
- virtual void add(Request_engraver* grav_p);
-
- virtual bool contains_b(Request_engraver*)const;
+ virtual void add(Engraver* grav_p);
+ virtual bool contains_b(Engraver*)const;
virtual Translator* find_get_translator_l(String name, String id);
virtual Translator * get_default_interpreter();
/*
- engraver.hh -- declare Request_engraver
+ engraver.hh -- declare Engraver
source file of the GNU LilyPond music typesetter
*/
-class Request_engraver {
+class Engraver {
friend class Engraver_group_engraver;
/**
- You cannot copy a Request_engraver
+ You cannot copy a Engraver
*/
- Request_engraver(const Request_engraver&){}
+ Engraver(const Engraver&){}
enum {
VIRGIN,
virtual void sync_features() {}
- virtual bool contains_b(Request_engraver*grav_l)const;
+ virtual bool contains_b(Engraver*grav_l)const;
/**
Get information on the staff. Default: ask daddy.
*/
*/
bool try_request(Request*);
+ bool is_bottom_engraver() const;
void post_move_processing();
Engraver_group_engraver * daddy_grav_l_;
- Request_engraver();
- virtual ~Request_engraver(){}
+ Engraver();
+ virtual ~Engraver(){}
NAME_MEMBERS();
void print() const;
};
*/
#define ADD_THIS_ENGRAVER(c) \
struct c ## init { \
- static Request_engraver * globalctor (){ \
+ static Engraver * globalctor (){ \
return new c; \
} \
c ## init () { \
- add_request_engraver(c::static_name(), globalctor); \
+ add_Engraver(c::static_name(), globalctor); \
\
} \
} _ ## c ## init;
-typedef Request_engraver*(*Grav_ctor)(void);
-void add_request_engraver(String s, Grav_ctor f);
+typedef Engraver*(*Grav_ctor)(void);
+void add_Engraver(String s, Grav_ctor f);
#endif // ENGRAVER_HH
/*
- global-acceptor.hh -- declare Global_acceptor
+ global-translator.hh -- declare Global_translator
source file of the GNU LilyPond music typesetter
*/
-#ifndef GLOBAL_ACCEPTOR_HH
-#define GLOBAL_ACCEPTOR_HH
+#ifndef GLOBAL_TRANSLATOR_HH
+#define GLOBAL_TRANSLATOR_HH
-#include "acceptor.hh"
+#include "translator.hh"
#include "pqueue.hh"
class Global_translator : public virtual Translator {
virtual void finish() {}
protected:
+ virtual Global_translator *global_l() { return this; }
virtual int depth_i() const;
virtual Translator *ancestor_l(int);
};
#define HEADGRAV_HH
#include "engraver.hh"
-struct Note_head_engraver : Request_engraver {
+struct Note_head_engraver : Engraver {
Note_head* note_p_;
Rhythmic_req * note_req_l_;
#include "string.hh"
#include "varray.hh"
+struct Input_engraver_list : public Pointer_list<Input_engraver*>
+{
+ Input_engraver_list(Input_engraver_list const &);
+ Input_engraver_list(){}
+};
+
struct Input_engraver : Input {
- Pointer_list<Input_engraver*> contains_igrav_p_list_;
+ Input_engraver_list contains_igrav_p_list_;
Array<String> consists_str_arr_;
Array<String> alias_str_arr_;
- String name_str_;
+ String type_str_;
void add(Input_engraver *);
bool is_name_b(String);
};
-void add_global_input_engraver(Input_engraver* igrav_p);
-Input_engraver*lookup_grav(String);
-Request_engraver*get_engraver_p(String s);
+Engraver*get_engraver_p(String s);
#endif // INPUT_ENGRAVER_HH
+++ /dev/null
-/*
- interpretor.hh -- declare Interpreter
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
-*/
-
-
-#ifndef INTERPRETER_HH
-#define INTERPRETER_HH
-
-#include "lily-proto.hh"
-
-#endif // INTERPRETER_HH
#include "engraver.hh"
#include "key.hh"
-struct Key_engraver : Request_engraver {
+struct Key_engraver : Engraver {
Key key_;
Key_change_req * keyreq_l_;
Key_item * kit_p_;
struct Engraver_group_engraver;
struct Request;
struct Request_column;
-struct Request_engraver;
+struct Engraver;
struct Rest;
struct Rest_collision;
struct Rest_collision_engraver;
struct Vertical_brace;
struct Vertical_spanner;
struct Vertical_group;
-
+struct Vertical_align_spanner;
+struct Vertical_align_engraver;
+struct Vertical_align_element;
struct Voice;
struct Voice_element;
struct Voice_group_engravers;
#include "key.hh"
#include "parray.hh"
-struct Local_key_engraver : Request_engraver {
+struct Local_key_engraver : Engraver {
Key local_key_;
Key const *key_C_;
Array<Note_req* > mel_l_arr_;
Symbol flag(int)const;
Symbol rest(int, bool outside)const;
Symbol clef(String)const;
- Symbol bar(String)const;
+ Symbol bar(String, Real height)const;
+
Symbol dots(int)const;
Symbol slur(int dy, Real &dx, int dir)const;
Symbol half_slur(int dy, Real &dx, int dir, int xpart)const;
#include "lily-proto.hh"
-class Lyric_engraver : public Request_engraver {
+class Lyric_engraver : public Engraver {
Array<Lyric_req*> lreq_arr_;
virtual bool do_try_request(Request*);
virtual void do_process_requests();
/**
generate meters.
*/
-class Meter_engraver : public Request_engraver {
+class Meter_engraver : public Engraver {
public:
Time_description time_;
Rhythmic_grouping default_grouping_;
Music_iterator* get_iterator_p(Music*)const;
void set_translator(Translator*);
Music_iterator();
- virtual void next(Moment until);
+
+ virtual void process_and_next(Moment until);
virtual Moment next_moment()const;
virtual bool ok()const;
virtual ~Music_iterator();
virtual Moment next_moment() const;
virtual void do_print()const;
- virtual void next(Moment);
+ virtual void process_and_next(Moment);
};
class Change_iterator : public Music_iterator {
Change_reg * change_l_;
public:
NAME_MEMBERS();
- virtual void next(Moment);
+ virtual void process_and_next(Moment);
Change_iterator(Change_reg*);
};
protected:
virtual void do_print()const;
virtual void construct_children();
- virtual void next(Moment);
+ virtual void process_and_next(Moment);
virtual Moment next_moment()const;
virtual bool ok()const;
};
virtual void do_print()const;
virtual void construct_children();
~Voice_iterator();
- virtual void next(Moment);
+ virtual void process_and_next(Moment);
virtual Moment next_moment()const;
virtual bool ok()const;
};
#include "engraver.hh"
-class Note_column_engraver :public Request_engraver {
+class Note_column_engraver :public Engraver {
Rest_column * rest_col_l();
Note_column * note_col_l();
Lookup *lookup_p_;
Assoc<String, Real> *real_vars_p_;
+ Input_engraver * igrav_p_;
public:
String outfile_str_;
void reinit();
Paper_def();
void set(Lookup*);
+ void set (Input_engraver * );
+ Global_translator * get_global_translator_p()const;
~Paper_def();
Paper_def(Paper_def const&);
/// The distance between beams
#include "varray.hh"
#include "engraver.hh"
-class Rest_collision_engraver : public Request_engraver {
+class Rest_collision_engraver : public Engraver {
Rest_collision* rest_collision_p_;
Array< Collision *> collision_l_arr_;
protected:
#include "engraver.hh"
-class Score_align_engraver: public Request_engraver
+class Score_align_engraver: public Engraver
{
Horizontal_group_item * align_p_;
public:
Score_elem * elem_l_;
Request*req_l_;
Voice const * voice_l_;
- Array<Request_engraver*> origin_grav_l_arr_;
+ Array<Engraver*> origin_grav_l_arr_;
/* *** */
Score_elem_info(Score_elem*, Request*);
virtual void do_post_processing();
virtual void do_substitute_dependency(Score_elem * , Score_elem *);
+ virtual void do_substitute_dependent(Score_elem *, Score_elem *);
virtual void do_break_processing();
virtual void handle_broken_dependencies();
virtual void handle_prebroken_dependencies();
#ifndef SCORE_HALIGN_GRAV_HH
#define SCORE_HALIGN_GRAV_HH
#include "engraver.hh"
-class Score_horizontal_align_engraver : public Request_engraver {
+class Score_horizontal_align_engraver : public Engraver {
Break_align_item * halign_p_;
public:
#include "colhpos.hh"
#include "spanner-elem-group.hh"
-#include "vertical-align-elem.hh"
/// the columns of a score that form one line.
-class Line_of_score : public Spanner, public Vertical_align_elem {
+class Line_of_score : public Spanner{
public:
Link_array<PCol> cols;
bool error_mark_b_;
/// is #c# contained in #*this#?
bool contains_b(PCol const *c)const;
- bool contains_b(Score_elem const*e) const {
- return Vertical_align_elem::contains_b(e);
- }
Link_array<Line_of_score> get_lines()const;
void set_breaking(Array<Col_hpositions> const&);
protected:
virtual void break_into_pieces();
- virtual void do_substitute_dependency(Score_elem*,Score_elem*);
virtual Interval do_width()const;
virtual void do_print() const;
SCORE_ELEM_CLONE(Line_of_score);
#include "engraver.hh"
-class Script_engraver : public Request_engraver {
+class Script_engraver : public Engraver {
Array<Script *> script_p_arr_;
Array<Script_req *> script_req_l_arr_;
#include "engraver.hh"
-class Slur_engraver :public Request_engraver {
+class Slur_engraver :public Engraver {
Array<Slur_req*> requests_arr_;
Array<Slur_req*> new_slur_req_l_arr_;
Array<Slur *> slur_l_stack_;
--- /dev/null
+/*
+ span-bar-grav.hh -- declare Span_bar_engraver
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+
+#ifndef SPAN_BAR_GRAV_HH
+#define SPAN_BAR_GRAV_HH
+
+#include "engraver.hh"
+
+class Span_bar_engraver : public Engraver
+{
+ Span_bar * spanbar_p_;
+ Array<Bar*> bar_l_arr_;
+ Vertical_align_element * valign_l_;
+public:
+ NAME_MEMBERS();
+ virtual void acknowledge_element(Score_elem_info);
+ virtual void do_pre_move_processing();
+ Span_bar_engraver();
+
+};
+
+#endif // SPAN_BAR_GRAV_HH
--- /dev/null
+/*
+ span-bar.hh -- declare Span_bar
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+
+#ifndef SPAN_BAR_HH
+#define SPAN_BAR_HH
+
+#include "bar.hh"
+
+class Span_bar : public Bar
+{
+ Link_array<Bar> spanning_l_arr_;
+
+public:
+ NAME_MEMBERS();
+ SCORE_ELEM_CLONE(Span_bar);
+ void add(Bar* );
+ void set( Vertical_align_element *);
+ void do_pre_processing();
+ void do_substitute_dependency(Score_elem*,Score_elem*);
+ Molecule * brew_molecule_p()const;
+};
+#endif // SPAN_BAR_HH
#include "lily-proto.hh"
-/// struct to pass staff info along a Request_engraver hierarchy.
+/// struct to pass staff info along a Engraver hierarchy.
struct Staff_info {
int *c0_position_i_l_;
Staff_symbol*staff_sym_l_;
/**
Manage the staff symbol.
*/
-class Staff_sym_engraver : public Request_engraver {
+class Staff_sym_engraver : public Engraver {
Staff_symbol *span_p_;
public:
Staff_sym_engraver();
override default_grouping if setting a n-plet
*/
-class Stem_beam_engraver : public Request_engraver {
+class Stem_beam_engraver : public Engraver {
Stem * stem_p_;
Beam * beam_p_;
Beam_req * beam_req_l_;
This engraver swallows everything given to it silently. The purpose of
this is to prevent spurious "request junked" warnings.
*/
-class Swallow_engraver : public Request_engraver {
+class Swallow_engraver : public Engraver {
protected:
bool acceptable_request_b(Request*) const;
bool do_try_request(Request*) ;
#define TEXTGRAV_HH
#include "engraver.hh"
-class Text_engraver : public Request_engraver{
+class Text_engraver : public Engraver{
Text_item * text_p_;
Text_req * text_req_l_;
int dir_i_;
#include "engraver.hh"
-class Tie_engraver : public Request_engraver {
+class Tie_engraver : public Engraver {
Tie * end_tie_p_;
Tie * tie_p_;
Moment end_mom_;
/*
- acceptor.hh -- declare Translator
+ translator.hh -- declare Translator
source file of the GNU LilyPond music typesetter
*/
-#ifndef ACCEPTOR_HH
-#define ACCEPTOR_HH
+#ifndef TRANSLATOR_HH
+#define TRANSLATOR_HH
#include "string.hh"
#include "lily-proto.hh"
-#include "interpreter.hh"
#include "virtual-methods.hh"
class Translator {
int iterator_count_;
- virtual Interpreter * interpreter_l() { return 0; }
+ virtual Global_translator *global_l() { return 0; }
/// Score_register = 0, Staff_registers = 1, etc)
virtual int depth_i()const=0;
+ virtual bool is_bottom_engraver_b() const { return false; }
+ virtual bool try_request(Request*);
virtual Translator *find_get_translator_l(String name, String id)=0;
virtual Translator *ancestor_l(int l=1)=0;
virtual ~Translator(){}
virtual Translator *get_default_interpreter()=0;
};
-class Interpreter : public virtual Translator {
-public:
- virtual bool interpret_request_b(Request*) { return false;}
-};
-#endif // ACCEPTOR_HH
+#endif // TRANSLATOR_HH
/**
Order elements top to bottom.
*/
-class Vertical_align_elem : virtual public Score_elem {
+class Vertical_align_element : virtual public Score_elem {
Link_array<Score_elem> elem_l_arr_;
public:
void add(Score_elem*);
bool contains_b(Score_elem const*)const;
+ Vertical_align_element();
NAME_MEMBERS();
protected:
virtual void do_substitute_dependency(Score_elem*,Score_elem*);
--- /dev/null
+/*
+ vertical-align-grav.hh -- declare Vertical_align_engraver
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+
+#ifndef VERTICAL_ALIGN_GRAV_HH
+#define VERTICAL_ALIGN_GRAV_HH
+
+#include "engraver.hh"
+
+class Vertical_align_engraver : public Engraver {
+ Vertical_align_spanner * valign_p_;
+
+public:
+ NAME_MEMBERS();
+ Vertical_align_engraver();
+protected:
+ virtual void acknowledge_element(Score_elem_info);
+ virtual void do_creation_processing();
+ virtual void do_removal_processing();
+};
+
+#endif // VERTICAL_ALIGN_GRAV_HH
--- /dev/null
+/*
+ vertical-align-spanner.hh -- declare Vertical_align_spanner
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+
+#ifndef VERTICAL_ALIGN_SPANNER_HH
+#define VERTICAL_ALIGN_SPANNER_HH
+
+#include "spanner.hh"
+#include "vertical-align-elem.hh"
+
+class Vertical_align_spanner : public Vertical_align_element, public Spanner
+{
+public:
+ NAME_MEMBERS();
+ SCORE_ELEM_CLONE(Vertical_align_spanner);
+ virtual void do_print() const { Vertical_align_element::do_print() ; }
+
+};
+#endif // VERTICAL_ALIGN_SPANNER_HH
+++ /dev/null
-/*
- voice-gravs.hh -- declare Voice_engravers
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
-*/
-
-
-#ifndef VOICEGRAVS_HH
-#define VOICEGRAVS_HH
-
-#include "engraver-group.hh"
-#include "interpreter.hh"
-
-class Voice_engravers : public Interpreter, public Engraver_group_engraver {
-public:
- NAME_MEMBERS();
-
-protected:
- virtual bool interpret_request_b(Request*);
- virtual Interpreter* interpreter_l() { return this; }
-};
-
-
-#endif // VOICEGRAVS_HH
bool
Input_engraver::is_name_b(String n)
{
- bool b = (n == name_str_);
- for (int i=0; !b && i < alias_str_arr_.size(); i++)
- b = b || (alias_str_arr_[i] == n);
- return b;
+ for (int i=0; i < alias_str_arr_.size(); i++)
+ if (alias_str_arr_[i] == n)
+ return true;
+ return false;
}
void
Input_engraver::print() const
{
#ifndef NPRINT
- mtor << "name " << name_str_;
+ mtor << "type " << type_str_;
mtor << "Consists of ";
for (int i=0; i< consists_str_arr_.size(); i++)
mtor << consists_str_arr_[i] << ',';
#endif
}
-/*
- UGH. Global.
- */
-Link_array<Input_engraver> igravs_p_arr;
-
-void
-add_global_input_engraver(Input_engraver *grav_p)
-{
- igravs_p_arr.push(grav_p);
-}
-
-Input_engraver *
-lookup_grav(String nm)
-{
- for (int i=0; i < igravs_p_arr.size(); i++)
- if (igravs_p_arr[i]->is_name_b(nm))
- return igravs_p_arr[i];
-
- error("can't find reg `" + nm + "'");
-}
-
Input_engraver *
return this;
Input_engraver * r =0;
- for (iter(contains_igrav_p_list_.top(), i); !r &&i.ok(); i++)
- r = i->recursive_find(nm);
+ iter(contains_igrav_p_list_.top(), i);
+ for (; !r &&i.ok(); i++) {
+ if (i->recursive_find(nm))
+ r = i.ptr();
+ }
return r;
}
+
Input_engraver *
Input_engraver::find_igrav_l(String nm)
{
Input_engraver::get_group_engraver_p()
{
Engraver_group_engraver * grav_p = (Engraver_group_engraver*)
- get_engraver_p(name_str_);
+ get_engraver_p(type_str_);
-
-
for (int i=0; i < consists_str_arr_.size(); i++) {
grav_p->add( get_engraver_p( consists_str_arr_[i]) );
}
Input_engraver*
Input_engraver::get_default_igrav_l()
{
- return contains_igrav_p_list_.top();
+ if ( contains_igrav_p_list_.size() )
+ return contains_igrav_p_list_.top();
+ else
+ return 0;
+}
+
+
+Input_engraver_list::Input_engraver_list(Input_engraver_list const &s)
+{
+ for (PCursor<Input_engraver*> pc(s); pc.ok(); pc++) {
+ Input_engraver *q = pc;
+ Input_engraver *p=new Input_engraver(*q) ;
+ bottom().add(p);
+ }
}
}
IMPLEMENT_STATIC_NAME(Key_engraver);
-IMPLEMENT_IS_TYPE_B1(Key_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Key_engraver,Engraver);
ADD_THIS_ENGRAVER(Key_engraver);
yyterminate(); // can't move this, since it actually rets a YY_NULL
}
}
-<notes,INITIAL,lyrics>
-\\include {
+<notes,INITIAL,lyrics>\\include {
yy_push_state(incl);
}
<incl>\"[^"]*\" { /* got the include file name */
}
IMPLEMENT_STATIC_NAME(Local_key_engraver);
-IMPLEMENT_IS_TYPE_B1(Local_key_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Local_key_engraver,Engraver);
ADD_THIS_ENGRAVER(Local_key_engraver);
Symbol
-Lookup::bar(String s) const
+Lookup::bar(String s, Real h) const
{
- return (*symtables_)("bars")->lookup(s);
+ Array<String> a;
+ a.push(print_dimen( h));
+ Symbol ret=(*symtables_)("bars")->lookup(s);;
+ ret.tex = substitute_args(ret.tex, a);
+ ret.dim.y = Interval( 0, h);
+ return ret;
}
Symbol
IMPLEMENT_STATIC_NAME(Lyric_engraver);
-IMPLEMENT_IS_TYPE_B1(Lyric_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Lyric_engraver,Engraver);
ADD_THIS_ENGRAVER(Lyric_engraver);
IMPLEMENT_STATIC_NAME(Meter_engraver);
ADD_THIS_ENGRAVER(Meter_engraver);
-IMPLEMENT_IS_TYPE_B1(Meter_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Meter_engraver,Engraver);
#include "music-iterator.hh"
#include "translator.hh"
#include "request.hh"
-#include "interpreter.hh"
#include "debug.hh"
IMPLEMENT_STATIC_NAME(Music_iterator);
Music_iterator::get_req_translator_l()
{
assert(report_to_l_);
- if (report_to_l_->interpreter_l() )
+ if (report_to_l_->is_bottom_engraver_b() )
return report_to_l_;
set_translator( report_to_l_->get_default_interpreter() );
}
void
-Music_iterator::next(Moment)
+Music_iterator::process_and_next(Moment)
{
first_b_ = false;
}
}
void
-Chord_iterator::next(Moment until)
+Chord_iterator::process_and_next(Moment until)
{
for (iter(children_p_list_.top(), i); i.ok(); ) {
if (i->next_moment() == until) {
- i->next(until);
+ i->process_and_next(until);
}
if (!i->ok())
delete i.remove_p();
else
i++;
}
- Music_iterator::next(until);
+ Music_iterator::process_and_next(until);
// assert(!ok() || next_moment() > until);
}
IMPLEMENT_IS_TYPE_B1(Voice_iterator,Music_iterator);
void
-Voice_iterator::next(Moment until)
+Voice_iterator::process_and_next(Moment until)
{
while (ok()) {
Moment local_until = until - here_mom_;
Moment here = iter_p_->next_moment();
if (here != local_until)
return;
- iter_p_->next(local_until);
+ iter_p_->process_and_next(local_until);
}
if (!iter_p_)
iter_p_ = Music_iterator::get_iterator_p( ptr() );
else if (!iter_p_->ok() )
next_element();
}
- Music_iterator::next(until);
+ Music_iterator::process_and_next(until);
assert(!ok() || next_moment() > until);
}
}
/* ***************** */
+
void
Request_iterator::do_print()const
{
mtor << req_l_->name() ;
}
+
Request_iterator::Request_iterator(Request const*c)
{
req_l_ = (Request*)c;
}
void
-Request_iterator::next(Moment m)
+Request_iterator::process_and_next(Moment m)
{
- if ( first_b_) {
- bool gotcha = daddy_iter_l_->report_to_l_->
- interpreter_l()->interpret_request_b(req_l_);
+ if ( first_b_ ) {
+ bool gotcha = daddy_iter_l_->report_to_l_->try_request(req_l_);
if (!gotcha)
req_l_->warning("Junking request: " + String(req_l_->name()));
first_b_ = false;
{
return (req_l_->duration() && !last_b_) || first_b_; // ugh
}
+
IMPLEMENT_STATIC_NAME(Request_iterator);
IMPLEMENT_IS_TYPE_B1(Request_iterator, Music_iterator);
TODO: pop/pushgroup
*/
void
-Change_iterator::next(Moment mom)
+Change_iterator::process_and_next(Moment mom)
{
#if 0
Engraver_group_engraver *group_l =
report_to_l_->daddy_grav_l_->remove_engraver_p(report_to_l_);
group_l->add(report_to_l_);
#endif
- Music_iterator::next(mom);
+ Music_iterator::process_and_next(mom);
}
Voice_element_iterator::construct_children()
{
get_req_translator_l();
-/*
- if ( daddy_iter_l_
- && daddy_iter_l_->is_type_b(Voice_iterator::static_name() )) {
- set_translator(daddy_iter_l_-> get_req_translator_l());
- } else if (daddy_iter_l_
- && daddy_iter_l_-> is_type_b( Chord_iterator::static_name() )) {
-
- get_req_translator_l();
- }
- */
Chord_iterator::construct_children();
}
do_post_move_processing();
}
IMPLEMENT_STATIC_NAME(Note_column_engraver);
-IMPLEMENT_IS_TYPE_B1(Note_column_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Note_column_engraver,Engraver);
ADD_THIS_ENGRAVER(Note_column_engraver);
#include "debug.hh"
#include "lookup.hh"
#include "dimen.hh"
-
+#include "input-engraver.hh"
+#include "engraver-group.hh"
+#include "assoc-iter.hh"
void
Paper_def::set_var(String s, Real r)
Paper_def::Paper_def()
{
+ igrav_p_ = 0;
lookup_p_ = 0;
real_vars_p_ = new Assoc<String,Real>;
outfile_str_ = "lelie.tex";
Paper_def::~Paper_def()
{
+ delete igrav_p_;
delete real_vars_p_;
delete lookup_p_;
}
Paper_def::Paper_def(Paper_def const&s)
{
+ igrav_p_ = s.igrav_p_ ? new Input_engraver( *s.igrav_p_):0;
lookup_p_ = s.lookup_p_? new Lookup(*s.lookup_p_) : 0;
lookup_p_->paper_l_ = this;
real_vars_p_ = new Assoc<String,Real> (*s.real_vars_p_);
outfile_str_ = s.outfile_str_;
}
+void
+Paper_def::set(Input_engraver * igrav_p)
+{
+ delete igrav_p_;
+ igrav_p_ = igrav_p;
+}
+
void
Paper_def::set(Lookup*l)
{
mtor << "Paper {";
mtor << "out: " <<outfile_str_;
lookup_p_->print();
+ for (Assoc_iter<String,Real> i(*real_vars_p_); i.ok(); i++) {
+ mtor << i.key() << "= " << i.val() << "\n";
+ }
mtor << "}\n";
#endif
}
+
Lookup const *
Paper_def::lookup_l()
{
assert( lookup_p_ );
return lookup_p_;
}
+
+Global_translator*
+Paper_def::get_global_translator_p() const
+{
+ return igrav_p_->get_group_engraver_p()->global_l();
+}
| mudela error
| mudela check_version { }
| mudela add_notenames { }
- | mudela input_engraver_spec { add_global_input_engraver($2); }
;
check_version:
$$ = new Real_id(*$1, new Real($3), REAL_IDENTIFIER);
delete $1;
}
-
+ | declarable_identifier '=' int {
+ $$ = new Int_id(*$1, new int($3), INT_IDENTIFIER);
+ delete $1;
+ }
| declarable_identifier '=' post_request {
$$ = new Request_id(*$1, $3, POST_REQUEST_IDENTIFIER);
delete $1;
input_engraver_spec_body:
STRING {
$$ = new Input_engraver;
- $$->name_str_ =*$1;
+ $$->type_str_ =*$1;
+ $$->set_spot ( THIS->here_input() );
delete $1;
}
| input_engraver_spec_body ALIAS STRING ';' {
| paper_body STRING '=' REAL ';' {
$$->set_var(*$2, $4);
}
+ | paper_body input_engraver_spec {
+ $$->set( $2 );
+ }
| paper_body error {
}
#include "note-column.hh"
IMPLEMENT_STATIC_NAME(Rest_collision_engraver);
-IMPLEMENT_IS_TYPE_B1(Rest_collision_engraver, Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Rest_collision_engraver, Engraver);
ADD_THIS_ENGRAVER(Rest_collision_engraver);
Rest_collision_engraver::Rest_collision_engraver()
void
Score_align_engraver::acknowledge_element(Score_elem_info inf)
{
- if (inf.elem_l_->name() == type_ch_C_ ) {
+ if (inf.elem_l_->is_type_b(type_ch_C_ )) {
if (! align_p_ ) {
align_p_ = new Horizontal_group_item;
}
IMPLEMENT_STATIC_NAME(Score_align_engraver)
-IMPLEMENT_IS_TYPE_B1(Score_align_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Score_align_engraver,Engraver);
Score_elem::do_substitute_dependency(Score_elem*,Score_elem*)
{
}
+void
+Score_elem::do_substitute_dependent(Score_elem*,Score_elem*)
+{}
IMPLEMENT_STATIC_NAME(Score_elem);
Score_elem::remove_dependency(Score_elem*e)
{
remove_edge_out(e);
+ e->do_substitute_dependent(this, 0);
do_substitute_dependency(e, 0);
}
Spanner * sp = elt->spanner();
Spanner * broken = sp->find_broken_piece(line);
do_substitute_dependency(sp, broken);
+
add_dependency(broken);
} else if (elt->item() && elt->item()->pcol_l_->breakpoint_b()
&& elt->item()->break_status_i() == 0) {
info.origin_grav_l_arr_.push(this);
if (info.elem_l_->name() == Bar::static_name()) {
get_staff_info().command_pcol_l()->set_breakable();
- } else if ( info.elem_l_->is_type_b( Line_of_staff::static_name() ) &&
- !scoreline_l_->contains_b( info.elem_l_) )
-
- scoreline_l_->add(info.elem_l_);
-
+ }
+
announce_info_arr_.push(info);
}
void
for (int i =0; i < nobreak_item_p_arr_.size(); i++) {
ps_l->typeset_item(nobreak_item_p_arr_[i], c, 0);
- scoreline_l_->add(nobreak_item_p_arr_[i]);
+ scoreline_l_->add_dependency(nobreak_item_p_arr_[i]);
}
nobreak_item_p_arr_.set_size(0);
Score_engraver::do_try_request(Request*r)
{
bool gotcha = false;
- for (int i =0; !gotcha && i < nongroup_l_arr_.size() ; i++)
+ for ( int i =0; !gotcha && i < nongroup_l_arr_.size() ; i++)
gotcha = nongroup_l_arr_[i]->try_request(r);
return gotcha;
void
Score_horizontal_align_engraver::acknowledge_element(Score_elem_info i)
{
- Request_engraver* reg = i.origin_grav_l_arr_[0];
+ Engraver* reg = i.origin_grav_l_arr_[0];
if (reg->is_type_b(
Score_align_engraver::static_name()) )
{
}
}
IMPLEMENT_STATIC_NAME(Score_horizontal_align_engraver);
-IMPLEMENT_IS_TYPE_B1(Score_horizontal_align_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Score_horizontal_align_engraver,Engraver);
ADD_THIS_ENGRAVER(Score_horizontal_align_engraver);
(c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
*/
+
#include "tex-stream.hh"
#include "score.hh"
#include "score-column.hh"
#include "midi-output.hh"
#include "midi-def.hh"
#include "p-col.hh"
-#include "score-grav.hh"
#include "music-iterator.hh"
#include "music.hh"
-#include "music-list.hh"
-#include "input-engraver.hh"
+#include "global-translator.hh"
extern String default_out_fn;
}
void
-Score::run_translator(Global_translator * acc_l)
+Score::run_translator(Global_translator * trans_l)
{
- acc_l->set_score (this);
+ trans_l->set_score (this);
Music_iterator * iter = Music_iterator::static_get_iterator_p(music_p_,
- acc_l);
+ trans_l);
iter->construct_children();
- while ( iter->ok() || acc_l->moments_left_i() ) {
+ while ( iter->ok() || trans_l->moments_left_i() ) {
Moment w = INFTY;
if (iter->ok() ) {
w = iter->next_moment();
iter->print();
}
- acc_l->modify_next( w );
- acc_l->prepare(w);
- iter->next( w );
- acc_l->process();
+ trans_l->modify_next( w );
+ trans_l->prepare(w);
+ iter->process_and_next( w );
+ trans_l->process();
}
delete iter;
- acc_l->finish();
+ trans_l->finish();
}
*mlog << "\nCreating elements ..." << flush;
pscore_p_ = new PScore(paper_p_);
- Score_engraver * score_grav=
- (Score_engraver*)lookup_grav("Score_engraver")->get_group_engraver_p();
- run_translator( score_grav );
- delete score_grav;
+ Global_translator * score_trans= paper_p_->get_global_translator_p();
+ run_translator( score_trans );
+ delete score_trans;
if( errorlevel_i_){
// should we? hampers debugging.
IMPLEMENT_STATIC_NAME(Line_of_score);
-IMPLEMENT_IS_TYPE_B2(Line_of_score,Spanner,Vertical_align_elem);
+IMPLEMENT_IS_TYPE_B1(Line_of_score,Spanner);
void
Line_of_score::add(Score_elem*e)
{
- if (e->is_type_b( Line_of_staff::static_name())
- && ! Vertical_align_elem::contains_b( e) )
-
- Vertical_align_elem::add(e);
- else {
- add_dependency(e);
- }
+ add_dependency(e);
}
bool
{
return Spanner::do_width();
}
-
-void
-Line_of_score::do_substitute_dependency(Score_elem*o,Score_elem*n)
-{
- Spanner::do_substitute_dependency(o,n);
- Vertical_align_elem::do_substitute_dependency(o,n);
-}
}
IMPLEMENT_STATIC_NAME(Script_engraver);
-IMPLEMENT_IS_TYPE_B1(Script_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Script_engraver,Engraver);
ADD_THIS_ENGRAVER(Script_engraver);
}
}
IMPLEMENT_STATIC_NAME(Slur_engraver);
-IMPLEMENT_IS_TYPE_B1(Slur_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Slur_engraver,Engraver);
ADD_THIS_ENGRAVER(Slur_engraver);
--- /dev/null
+/*
+ span-bar-grav.cc -- implement Span_bar_engraver
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+#include "span-bar.hh"
+#include "span-bar-grav.hh"
+#include "vertical-align-spanner.hh"
+
+Span_bar_engraver::Span_bar_engraver()
+{
+ spanbar_p_ =0;
+ valign_l_ =0;
+}
+
+void
+Span_bar_engraver::acknowledge_element(Score_elem_info i)
+{
+ if ( i.elem_l_->is_type_b( Bar::static_name() ) ) {
+ bar_l_arr_.push( (Bar*)i.elem_l_->item() );
+
+ if (bar_l_arr_.size() >= 2 && !spanbar_p_) {
+ spanbar_p_ = new Span_bar;
+ announce_element( Score_elem_info(spanbar_p_,0) );
+ }
+ } else if (i.elem_l_->is_type_b( Vertical_align_spanner::static_name() )
+ && i.origin_grav_l_arr_.size() <= 2) {
+ valign_l_ = (Vertical_align_spanner*)i.elem_l_->spanner();
+ }
+}
+
+void
+Span_bar_engraver::do_pre_move_processing()
+{
+ if (spanbar_p_) {
+ for (int i=0; i < bar_l_arr_.size() ; i++)
+ spanbar_p_->add(bar_l_arr_[i]);
+ spanbar_p_->set( valign_l_ );
+ typeset_breakable_item(spanbar_p_);
+ spanbar_p_ =0;
+ }
+ bar_l_arr_.set_size( 0);
+
+}
+
+IMPLEMENT_STATIC_NAME(Span_bar_engraver);
+IMPLEMENT_IS_TYPE_B1(Span_bar_engraver,Engraver);
+ADD_THIS_ENGRAVER(Span_bar_engraver);
--- /dev/null
+/*
+ span-bar.cc -- implement Span_bar
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+
+#include "span-bar.hh"
+#include "lookup.hh"
+#include "symbol.hh"
+#include "paper-def.hh"
+#include "molecule.hh"
+#include "vertical-align-elem.hh"
+
+void
+Span_bar::add(Bar*b)
+{
+ b->spanned_i_ ++;
+ spanning_l_arr_.push(b);
+ add_dependency( b );
+}
+
+
+
+void
+Span_bar::do_substitute_dependency(Score_elem*o, Score_elem*n)
+{
+ Bar * bold = 0;
+ if (o->is_type_b(Bar::static_name() ))
+ bold = (Bar*)o->item();
+ else
+ return;
+
+ bold->spanned_i_ --;
+ Bar * b =0;
+ if (n && n->is_type_b(Bar::static_name() )) {
+ b = (Bar*)n->item();
+ b->spanned_i_ ++;
+ }
+
+ spanning_l_arr_.substitute( bold , b);
+
+}
+
+void
+Span_bar::set(Vertical_align_element *a)
+{
+ add_dependency( a );
+}
+
+
+void
+Span_bar::do_pre_processing()
+{
+ if ( spanning_l_arr_.size () < 1) {
+ transparent_b_ = true;
+ empty_b_ =true;
+ } else {
+ type_str_ = spanning_l_arr_[0]->type_str_;
+ if (type_str_ =="") {
+ transparent_b_=true;
+ empty_b_ = true;
+ }
+ }
+}
+
+Molecule*
+Span_bar::brew_molecule_p()const
+{
+ Interval y;
+ for (int i=0; i < spanning_l_arr_.size(); i++)
+ y.unite( spanning_l_arr_[i]->height() );
+ Symbol s = paper()->lookup_l()->bar(type_str_, y.length());
+ Molecule*output = new Molecule(Atom(s));
+ output->translate_y ( y[-1] );
+
+ return output;
+}
+
+IMPLEMENT_STATIC_NAME(Span_bar);
+IMPLEMENT_IS_TYPE_B1(Span_bar,Bar);
*/
#include "staff-sym.hh"
-#include "voice-group-gravs.hh"
-#include "voice-gravs.hh"
#include "staff-gravs.hh"
#include "command-request.hh"
#include "bar.hh"
#include "debug.hh"
-#include "input-engraver.hh"
-#include "meter-grav.hh"
#include "staffline.hh"
group_staff_elems();
staffline_p_->right_col_l_ = get_staff_info().command_pcol_l();
- Request_engraver::typeset_element(staffline_p_);
+ Engraver::typeset_element(staffline_p_);
staffline_p_ = 0;
}
staffline_p_->left_col_l_ = get_staff_info().command_pcol_l();
// don't broadcast to self.
- Request_engraver::announce_element(Score_elem_info(staffline_p_,0));
+ Engraver::announce_element(Score_elem_info(staffline_p_,0));
Engraver_group_engraver::do_creation_processing();
}
IMPLEMENT_STATIC_NAME(Staff_sym_engraver);
-IMPLEMENT_IS_TYPE_B1(Staff_sym_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Staff_sym_engraver,Engraver);
ADD_THIS_ENGRAVER(Staff_sym_engraver);
}
IMPLEMENT_STATIC_NAME(Stem_beam_engraver);
-IMPLEMENT_IS_TYPE_B1(Stem_beam_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Stem_beam_engraver,Engraver);
ADD_THIS_ENGRAVER(Stem_beam_engraver);
#include "swallow-grav.hh"
IMPLEMENT_STATIC_NAME(Swallow_engraver);
-IMPLEMENT_IS_TYPE_B1(Swallow_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Swallow_engraver,Engraver);
ADD_THIS_ENGRAVER(Swallow_engraver);
#include "plist.tcc"
#include "engraver.hh"
-IPL_instantiate(Request_engraver);
+IPL_instantiate(Engraver);
text_req_l_ = 0;
}
IMPLEMENT_STATIC_NAME(Text_engraver);
-IMPLEMENT_IS_TYPE_B1(Text_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Text_engraver,Engraver);
ADD_THIS_ENGRAVER(Text_engraver);
}
IMPLEMENT_STATIC_NAME(Tie_engraver);
-IMPLEMENT_IS_TYPE_B1(Tie_engraver,Request_engraver);
+IMPLEMENT_IS_TYPE_B1(Tie_engraver,Engraver);
ADD_THIS_ENGRAVER(Tie_engraver);
IMPLEMENT_STATIC_NAME(Translator);
IMPLEMENT_IS_TYPE_B(Translator);
+
+bool
+Translator::try_request(Request*)
+{
+ return false;
+}
#include "interval.hh"
void
-Vertical_align_elem::add(Score_elem*el_l)
+Vertical_align_element::add(Score_elem*el_l)
{
assert( ! contains_b(el_l));
elem_l_arr_.push(el_l);
}
void
-Vertical_align_elem::do_substitute_dependency(Score_elem*o,Score_elem*n)
+Vertical_align_element::do_substitute_dependency(Score_elem*o,Score_elem*n)
{
int i;
while((i = elem_l_arr_.find_i(o))>=0)
elem_l_arr_.del(i);
}
void
-Vertical_align_elem::do_post_processing()
+Vertical_align_element::do_post_processing()
{
Array<Interval> dims;
for (int i=0; i < elem_l_arr_.size(); i++ ) {
}
bool
-Vertical_align_elem::contains_b(Score_elem const *e)const
+Vertical_align_element::contains_b(Score_elem const *e)const
{
return elem_l_arr_.find_l(e);
}
-Vertical_align_elem::Vertical_align_elem()
+Vertical_align_element::Vertical_align_element()
{
transparent_b_ = true;
empty_b_ =true;
}
-IMPLEMENT_STATIC_NAME(Vertical_align_elem);
-IMPLEMENT_IS_TYPE_B1(Vertical_align_elem, Score_elem);
+IMPLEMENT_STATIC_NAME(Vertical_align_element);
+IMPLEMENT_IS_TYPE_B1(Vertical_align_element, Score_elem);
--- /dev/null
+/*
+ vertical-align-grav.cc -- implement Vertical_align_engraver
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+
+#include "vertical-align-grav.hh"
+#include "vertical-align-spanner.hh"
+
+Vertical_align_engraver::Vertical_align_engraver()
+{
+ valign_p_ =0;
+}
+
+void
+Vertical_align_engraver::do_creation_processing()
+{
+ valign_p_ =new Vertical_align_spanner;
+ valign_p_->left_col_l_ = get_staff_info().command_pcol_l() ;
+ announce_element( Score_elem_info( valign_p_ , 0 ));
+}
+
+void
+Vertical_align_engraver::do_removal_processing()
+{
+ valign_p_->right_col_l_ = get_staff_info().command_pcol_l();
+ typeset_element( valign_p_);
+ valign_p_ =0;
+}
+
+void
+Vertical_align_engraver::acknowledge_element(Score_elem_info i)
+{
+ if ( i.origin_grav_l_arr_.size() == 2 &&
+ i.elem_l_->is_type_b(Vertical_group::static_name()) &&
+ !i.elem_l_->y_group_element_i_ &&
+ !valign_p_->contains_b( i.elem_l_) ) {
+
+ valign_p_->add ( i.elem_l_ );
+ }
+}
+
+IMPLEMENT_STATIC_NAME(Vertical_align_engraver);
+IMPLEMENT_IS_TYPE_B1(Vertical_align_engraver, Engraver);
+ADD_THIS_ENGRAVER(Vertical_align_engraver);
--- /dev/null
+/*
+ vertical-align-spanner.cc -- implement Vertical_align_spanner
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
+#include "vertical-align-spanner.hh"
+
+IMPLEMENT_STATIC_NAME(Vertical_align_spanner);
+IMPLEMENT_IS_TYPE_B2(Vertical_align_spanner, Vertical_align_element, Spanner);
+++ /dev/null
-/*
- voice-gravs.cc -- implement Voice_engravers
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
-*/
-
-#include "proto.hh"
-#include "plist.hh"
-#include "command-request.hh"
-#include "musical-request.hh"
-#include "voice-gravs.hh"
-#include "engraver.hh"
-#include "debug.hh"
-
-
-ADD_THIS_ENGRAVER(Voice_engravers);
-IMPLEMENT_IS_TYPE_B1(Voice_engravers, Engraver_group_engraver);
-IMPLEMENT_STATIC_NAME(Voice_engravers);
-
-bool
-Voice_engravers::interpret_request_b(Request*r)
-{
- return try_request(r);
-}
-
(c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
*/
-#include "music-list.hh"
#include "proto.hh"
#include "plist.hh"
#include "musical-request.hh"
-#include "voice-gravs.hh"
#include "voice-group-gravs.hh"
#include "engraver.hh"
#include "command-request.hh"
#include "debug.hh"
-#include "input-engraver.hh"
-#include "time-description.hh"
Voice_group_engravers::Voice_group_engravers()
Begin3
Title: LilyPond
-Version: 0.0.72pre
+Version: 0.0.73pre
Entered-date: 07/03/97
Description: LilyPond is a program which converts a music-script (mudela) into
TeX output, or MIDI to produce multi-staff scores. Features include multiple
jan@digicash.com (Jan Nieuwenhuizen)
Maintained-by: hanwen@stack.nl (Han-Wen Nienhuys)
Primary-site: pcnov095.win.tue.nl /pub/lilypond/
- 300k lilypond-0.0.72pre.tar.gz
+ 300k lilypond-0.0.73pre.tar.gz
Alternate-site:
Original-site:
Platform: unix/win32, GNU C++
Name: lilypond
-Version: 0.0.72pre
+Version: 0.0.73pre
Release: 1
Copyright: GPL
Group: Applications/Publishing
-Source0: pcnov095.win.tue.nl:/pub/lilypond/lilypond-0.0.72pre.tar.gz
+Source0: pcnov095.win.tue.nl:/pub/lilypond/lilypond-0.0.73pre.tar.gz
Summary: A preprocessor to make TeX typeset music.
URL: http://www.stack.nl/~hanwen/lilypond
Packager: Han-Wen Nienhuys <hanwen@stack.nl>
\def\emptybar{}
-\def\thinbar{\vrule height\balkheight width 1.6\staffrulethickness} % TODO parametric.
-\def\thickbar{\vrule height\balkheight width 2\smallspace}
-\def\maatstreep{\thinbar}
-
+\def\thinbar#1{\vrule height #1 width 1.6\staffrulethickness} % TODO parametric.
+\def\thickbar#1{\vrule height #1 width 2\smallspace}
+\def\maatstreep#1{\thinbar{#1}}
+\def\defaultthinbar{\thinbar{\balkheight}}
+\def\defaultthickbar{\thickbar{\balkheight}}
%? what-s wrong with rightalign?
-\def\finishbar{\rightalign{\thinbar\kern\smallspace\thickbar}}
+\def\finishbar#1{\rightalign{\thinbar{#1}\kern\smallspace\thickbar{#1}}}
-\def\repeatstopbar{\hss\rightalign{\repeatcolon\hskip2\smallspace\thinbar\hskip\smallspace\thickbar}}
-\def\repeatstartbar{\hbox{\thickbar\kern\smallspace\thinbar\kern2\smallspace\repeatcolon}}
-\def\repeatstopstart{\hbox{\repeatcolon\kern2\smallspace\thinbar\kern\smallspace\thickbar\kern\smallspace\thickbar\kern\smallspace\thinbar\kern2\smallspace\repeatcolon}}
-\def\doublebar{\hbox{\thinbar\hskip\smallspace\thinbar}}
+\def\repeatstopbar{\hss\rightalign{\repeatcolon\hskip2\smallspace\defaultthinbar\hskip\smallspace\defaultthickbar}}
+\def\repeatstartbar{\hbox{\defaultthickbar\kern\smallspace\defaultthinbar\kern2\smallspace\repeatcolon}}
+\def\repeatstopstart{\hbox{\repeatcolon\kern2\smallspace\defaultthinbar\kern\smallspace\defaultthickbar\kern\smallspace\defaultthickbar\kern\smallspace\defaultthinbar\kern2\smallspace\repeatcolon}}
+\def\doublebar#1{\hbox{\thinbar{#1}\hskip\smallspace\thinbar{#1}}}
%compatibility
\def\repeatbar{\repeatstopbar}
projects / lilypond.git / commitdiff