+2004-05-04 Han-Wen Nienhuys <hanwen@xs4all.nl>
+
+ * cygwin/lily-wins.py: update for the lily-wins.py script.
+
+2004-05-03 Han-Wen Nienhuys <hanwen@xs4all.nl>
+
+ * lily/score-engraver.cc (typeset_all): switch off unbound spanner
+ code. This will obviate typeset_grob () in the future. The effect
+ of this is that improperly written spanner handling will result in
+ invalid spanner bounds.
+ (announce_grob): add to elems_ from here
+ (typeset_grob): comment out.
+
+ * lily/include/engraver.hh (make_spanner): new calling interface
+ for make_{item,spanner}. This obviates most calls to
+ announce_grob().
+
+ * scm/music-functions.scm (set-accidental-style): use GrandStaff
+ iso. PianoStaff for piano styles.
+
2004-05-03 Heikki Junes <hjunes@cc.hut.fi>
* Documentation/user/music-glossary.tely: add segno after d.s.
Automatically kneed cross-staff beams cannot be used together with
hidden staves.
+Beams do not avoid collisions with symbols around the notes, such as
+texts and accidentals.
Stephen Pollei
Bertalan Fodor
Thomas Scharlowski
-
+Yuval Harel
+Martin Norbäck
Release 2.2
***********
#!@PYTHON@
# lily-wins.py -- LilyPond command for .ly on Windows
+import getopt
import os
import re
import sys
+import time
+
+do_debug = 0
def usage ():
print 'Usage [-h,--help] lily-wins LY-FILE'
# print debugging stuff for now
def debug (s):
- print s
+ if do_debug:
+ print s
def read_pipe (command):
debug ('command:' + command)
return re.sub ("(\s|[`'\"\\\\])", r'\\\1',x)
# return re.sub (r'''([^\\])([`'"\\\s])''', r'\1\\\2', x)
# help emacs'" broken python mode
+
+def usage ():
+ print '''lily-wins [options] file
+
+Options supported:
+
+ -h, --help this help screen
+ -d, --debug print debugging information
+
+'''
debug (`sys.argv`)
-if len (sys.argv) != 2 \
- or sys.argv[1] == '-h' or sys.argv[1] == '--help':
+########
+# main
+(opts, files)=getopt.getopt (sys.argv[1:],'dh', ['help', 'debug'])
+
+for (o,a) in opts:
+ if o == '-d' or o == '--debug':
+ do_debug = 1
+ elif o == '-h' or o == '--help':
+ usage ()
+ sys.exit (0)
+
+if files == []:
usage ()
- sys.exit (0)
-
-native_file = sys.argv[1]
+ sys.exit (1)
+native_file = files[0]
+print 'Processing %s ...' % native_file
file = read_pipe ('/usr/bin/cygpath -au %s' % escape_shell (native_file))
if not file:
file = native_file
dir = '.'
base = os.path.basename (file)
stem = strip_extension (base, '.ly')
-print `vars ()`
+debug ( `vars ()`)
native_base = '%(dir)s/%(stem)s' % vars ()
native_base = read_pipe ('/usr/bin/cygpath -aw %s' % escape_shell (native_base))
pdfview = 'xpdf'
os.chdir (dir)
+pdffile = '%(stem)s.pdf' % vars ()
+if os.path.exists (pdffile):
+ os.unlink (pdffile)
+
+
+script = '/usr/bin/lilypond'
+
if os.path.exists ('/usr/bin/ly2dvi'):
- system ('/usr/bin/ly2dvi -p %s > %s.log 2>&1' % (escape_shell (base),
- escape_shell (stem)))
-else:
- system ('/usr/bin/lilypond %s > %s.log 2>&1' % (escape_shell (base),
- escape_shell (stem)))
-if not os.path.exists ('%(stem)s.pdf' % vars ()):
+ script = '/usr/bin/ly2dvi'
+
+stat = system ('%s -p %s > %s.log 2>&1' % (script, escape_shell (base),
+ escape_shell (stem)))
+
+if not os.path.exists (pdffile):
# message box?
- sys.stderr.write ('pdf output not found\n')
+ sys.stderr.write ('PDF output not found. Error log: \n')
-system ('%s %s.pdf' % (escape_shell (pdfview), escape_shell (native_base)))
+ map (sys.stderr.write, open (stem + '.log').readlines ()[-20:])
+ sys.stderr.write ('A full log is in the file %s.log\n' % stem)
+ sys.stderr.write ('\n\nPress enter to close window\n')
+ sys.stdin.readline ()
+else:
+
+ # run even if failed, to make sure that error
+ system ('%s %s.pdf' % (escape_shell (pdfview), escape_shell (native_base)))
level, so that we get the property settings for
Accidental from the respective Voice.
*/
- Grob * a = make_item_from_properties (origin,
- ly_symbol2scm ("Accidental"));
+ Grob * a = make_item_from_properties (origin->implementation (),
+ ly_symbol2scm ("Accidental"),
+ note->self_scm ()
+ );
a->set_parent (support, Y_AXIS);
if (!accidental_placement_)
{
- accidental_placement_ = make_item ("AccidentalPlacement");
- announce_grob (accidental_placement_, a->self_scm ());
+ accidental_placement_ = make_item ("AccidentalPlacement", a->self_scm ());
}
Accidental_placement::add_accidental (accidental_placement_, a);
- announce_grob (a, SCM_EOL);
SCM accs = scm_cons (scm_int2num (pitch->get_alteration ()), SCM_EOL);
void
Ambitus_engraver::create_ambitus ()
{
- ambitus_ = make_item ("Ambitus");
+ ambitus_ = make_item ("Ambitus",SCM_EOL);
is_typeset = false;
- announce_grob (ambitus_, SCM_EOL);
}
void
{
if (arpeggio_req_)
{
- arpeggio_ = make_item ("Arpeggio");
- announce_grob (arpeggio_, arpeggio_req_->self_scm ());
+ arpeggio_ = make_item ("Arpeggio",arpeggio_req_->self_scm ());
}
}
Grob * it = unsmob_grob (get_property ("currentCommandColumn"));
staffline_->set_bound (LEFT,it);
-
- announce_grob (staffline_, SCM_EOL);
}
}
Spanner*
Axis_group_engraver::get_spanner ()
{
- return make_spanner ("VerticalAxisGroup");
+ return make_spanner ("VerticalAxisGroup", SCM_EOL);
}
/*
Spanner*
Hara_kiri_engraver::get_spanner ()
{
- Spanner * sp = make_spanner ("RemoveEmptyVerticalGroup");
+ Spanner * sp = make_spanner ("RemoveEmptyVerticalGroup", SCM_EOL);
return sp;
}
{
if (!bar_)
{
- bar_ = make_item ("BarLine");
+ bar_ = make_item ("BarLine", SCM_EOL);
SCM gl = get_property ("whichBar");
if (scm_equal_p (gl, bar_->get_property ("glyph")) != SCM_BOOL_T)
bar_->set_property ("glyph", gl);
-
- announce_grob (bar_, SCM_EOL);
}
}
if (text_)
return;
- text_ = make_item ("BarNumber");
+ text_ = make_item ("BarNumber", SCM_EOL);
Side_position_interface::set_axis (text_,Y_AXIS);
-
- announce_grob (text_, SCM_EOL);
}
ENTER_DESCRIPTION (Bar_number_engraver,
set_melisma (true);
prev_start_ev_ = start_ev_;
- beam_ = make_spanner ("Beam");
+ beam_ = make_spanner ("Beam", start_ev_->self_scm ());
SCM smp = get_property ("measurePosition");
Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
beam_info_ = new Beaming_info_list;
/* urg, must copy to Auto_beam_engraver too */
- announce_grob (beam_, start_ev_->self_scm ());
}
}
#include "item.hh"
#include "align-interface.hh"
#include "axis-group-interface.hh"
-
+#include "context.hh"
+#include "translator-group.hh"
class Break_align_engraver : public Engraver
{
if (!align_)
{
- align_ = make_item ("BreakAlignment");
+ align_ = make_item ("BreakAlignment", SCM_EOL);
- announce_grob (align_, SCM_EOL);
+
Context*origin = inf.origin_contexts (this)[0];
- left_edge_ = make_item_from_properties (origin,
- ly_symbol2scm ("LeftEdge"));
+ left_edge_ = make_item_from_properties (origin->implementation (),
+ ly_symbol2scm ("LeftEdge"),
+ SCM_EOL
+ );
add_to_group (left_edge_->get_property ("break-align-symbol"),
left_edge_);
- announce_grob (left_edge_, SCM_EOL);
}
add_to_group (align_name, item);
}
else
{
- group = make_item ("BreakAlignGroup");
+ group = make_item ("BreakAlignGroup", item->self_scm () );
group->set_property ("break-align-symbol", align_name);
group->set_parent (align_, Y_AXIS);
- announce_grob (group, item->self_scm ());
column_alist_ = scm_assoc_set_x (column_alist_, align_name, group->self_scm ());
{
if (breathing_sign_req_ && ! breathing_sign_)
{
- breathing_sign_ = make_item ("BreathingSign");
-
- announce_grob (breathing_sign_, breathing_sign_req_->self_scm ());
+ breathing_sign_ = make_item ("BreathingSign", breathing_sign_req_->self_scm ());
breathing_sign_req_ = 0;
}
}
*/
SCM chord_as_scm = scm_cons (pitches, scm_cons (bass, inversion));
- chord_name_ = make_item ("ChordName");
+ chord_name_ = make_item ("ChordName",notes_[0]->self_scm ());
chord_name_->set_property ("text", markup);
- announce_grob (chord_name_, notes_[0]->self_scm ());
+
SCM s = get_property ("chordChanges");
if (to_boolean (s) && ly_c_pair_p (last_chord_)
&& ly_c_equal_p (chord_as_scm, last_chord_))
Chord_tremolo_engraver::process_music ()
{
if (repeat_ && sequential_body_b_ && !beam_)
- {
- beam_ = make_spanner ("Beam");
- beam_->set_property ("chord-tremolo", SCM_BOOL_T);
-
- SCM smp = get_property ("measurePosition");
- Moment mp
- = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
- beam_start_location_ = mp;
- announce_grob (beam_, repeat_->self_scm ());
- }
+ {
+ beam_ = make_spanner ("Beam", repeat_->self_scm ());
+ beam_->set_property ("chord-tremolo", SCM_BOOL_T);
+
+ SCM smp = get_property ("measurePosition");
+ Moment mp
+ = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
+ beam_start_location_ = mp;
+ }
}
void
else if (repeat_ &&
flags_ && !sequential_body_b_ && Stem::has_interface (info.grob_))
{
- stem_tremolo_ = make_item ("StemTremolo");
- announce_grob (stem_tremolo_, repeat_->self_scm ());
+ stem_tremolo_ = make_item ("StemTremolo", repeat_->self_scm ());
stem_tremolo_->set_property ("flag-count",
scm_int2num (flags_));
stem_tremolo_->set_property ("stem",
{
if (!clef_)
{
- Item *c= make_item ("Clef");
- announce_grob (c, SCM_EOL);
+ Item *c = make_item ("Clef", SCM_EOL);
+
clef_ = c;
SCM cpos = get_property ("clefPosition");
SCM oct = get_property ("clefOctavation");
if (ly_c_number_p (oct) && ly_scm2int (oct))
{
- Item * g = make_item ("OctavateEight");
+ Item * g = make_item ("OctavateEight", SCM_EOL);
int abs_oct = ly_scm2int (oct) ;
int dir = sign (abs_oct);
g->set_parent (clef_, X_AXIS);
g->set_property ("direction", scm_int2num (dir));
octavate_ = g;
- announce_grob (octavate_, SCM_EOL);
+
}
}
}
pmin = pmin <? p;
}
- beacon_ = make_item ("ClusterSpannerBeacon");
+ beacon_ = make_item ("ClusterSpannerBeacon", cluster_notes_[0]->self_scm ());
beacon_->set_property ("positions",
scm_cons (scm_int2num (pmin),
scm_int2num (pmax)));
- announce_grob (beacon_, cluster_notes_[0]->self_scm ());
}
if (beacon_ && !spanner_)
{
- spanner_ = make_spanner ("ClusterSpanner");
- announce_grob (spanner_, cluster_notes_[0]->self_scm ());
+ spanner_ = make_spanner ("ClusterSpanner", cluster_notes_[0]->self_scm () );
}
if (beacon_ && spanner_)
return ;
if (!col_)
{
- col_ = make_item ("NoteCollision");
- announce_grob (col_, SCM_EOL);
+ col_ = make_item ("NoteCollision", SCM_EOL);
+
}
for (int i=0; i< note_columns_.size (); i++)
for (int i = 0;
left_to_do_ && i < note_reqs_.size (); i++)
{
- Item *note = make_item ("NoteHead");
Music * req = note_reqs_[i];
+ Item *note = make_item ("NoteHead", req->self_scm ());
if (scratch_note_reqs_.size ())
{
req = scratch_note_reqs_[i];
int dots= note_dur.dot_count ();
if (dots)
{
- Item * d = make_item ("Dots");
+ Item * d = make_item ("Dots", SCM_EOL);
Rhythmic_head::set_dots (note, d);
/*
d->set_property ("dot-count", scm_int2num (dots));
d->set_parent (note, Y_AXIS);
- announce_grob (d, SCM_EOL);
dots_.push (d);
}
pos += ly_scm2int (c0);
note->set_property ("staff-position", scm_int2num (pos));
- announce_grob (note,req->self_scm ());
notes_.push (note);
}
{
for (int i= 0; i < notes_.size (); i++)
{
- Grob * p = make_spanner ("Tie");
+ Grob * p = make_spanner ("Tie", SCM_EOL);
Tie::set_interface (p); // cannot remove yet!
Tie::set_head (p, LEFT, prev_notes_[i]);
Tie::set_head (p, RIGHT, notes_[i]);
ties_.push (p);
- announce_grob (p, SCM_EOL);
+
}
}
Item*
Custos_engraver::create_custos ()
{
- Item* custos = make_item ("Custos");
+ Item* custos = make_item ("Custos", SCM_EOL);
+
- announce_grob (custos, SCM_EOL);
custodes_.push (custos);
return custos;
{
if (!dotcol_)
{
- dotcol_ = make_item ("DotColumn");
- announce_grob (dotcol_, SCM_EOL);
+ dotcol_ = make_item ("DotColumn", SCM_EOL);
+
}
Dot_column::add_head (dotcol_, info.grob_);
if (!tab)
tab = get_property ("drumStyleTable");
- Item *note = make_item ("NoteHead");
Music * ev = events_[i];
+ Item *note = make_item ("NoteHead", ev->self_scm ());
Duration dur = *unsmob_duration (ev->get_property ("duration"));
if (dur.dot_count ())
{
- Item * d = make_item ("Dots");
+ Item * d = make_item ("Dots", ev->self_scm ());
Rhythmic_head::set_dots (note, d);
if (dur.dot_count ()
d->set_property ("dot-count", scm_int2num (dur.dot_count ()));
d->set_parent (note, Y_AXIS);
- announce_grob (d, SCM_EOL);
+
dots_.push (d);
}
if (ly_c_string_p (script))
{
- Item *p = make_item ("Script");
+ Item *p = make_item ("Script", ev->self_scm ());
SCM desc = SCM_EOL;
make_script_from_event (p, &desc,
context (), script,
if (p->get_property ("follow-into-staff"))
p->set_property ("staff-padding", SCM_EOL);
- announce_grob (p, ev->self_scm ());
p->set_parent (note, Y_AXIS);
Side_position_interface::add_support (p, note);
}
}
-
-
- announce_grob (note,ev->self_scm ());
notes_.push (note);
}
}
{
if (!line_spanner_)
{
- line_spanner_ = make_spanner ("DynamicLineSpanner");
-
Music * rq = accepted_spanreqs_drul_[START];
+ line_spanner_ = make_spanner ("DynamicLineSpanner", rq ? rq->self_scm (): SCM_EOL );
+
if (script_ev_)
- rq = script_ev_ ;
- announce_grob (line_spanner_, rq ? rq->self_scm (): SCM_EOL);
+ rq = script_ev_;
}
}
*/
if (script_ev_)
{
- script_ = make_item ("DynamicText");
+ script_ = make_item ("DynamicText", script_ev_->self_scm ());
script_->set_property ("text",
script_ev_->get_property ("text"));
Axis_group_interface::add_element (line_spanner_, script_);
- announce_grob (script_, script_ev_->self_scm ());
}
Music *stop_ev = accepted_spanreqs_drul_ [STOP] ?
SCM s = get_property ((start_type + "Spanner").to_str0 ());
if (!ly_c_symbol_p (s) || s == ly_symbol2scm ("hairpin"))
{
- cresc_ = make_spanner ("Hairpin");
+ cresc_ = make_spanner ("Hairpin", accepted_spanreqs_drul_[START]->self_scm ());
cresc_->set_property ("grow-direction",
scm_int2num ((start_type == "crescendo")
? BIGGER : SMALLER));
*/
else
{
- cresc_ = make_spanner ("TextSpanner");
+ cresc_ = make_spanner ("TextSpanner", accepted_spanreqs_drul_[START]->self_scm ());
cresc_->set_property ("style", s);
context ()->set_property ((start_type
+ "Spanner").to_str0 (), SCM_EOL);
add_bound_item (line_spanner_, cresc_->get_bound (LEFT));
- announce_grob (cresc_, accepted_spanreqs_drul_[START]->self_scm ());
}
}
}
{
if (ev_)
{
- extender_ = make_spanner ("LyricExtender");
- announce_grob (extender_, ev_->self_scm ());
+ extender_ = make_spanner ("LyricExtender", ev_->self_scm ());
}
}
{
if (rest_req_)
{
- figure_ = make_item ("BassFigure");
- announce_grob (figure_, rest_req_->self_scm ()); // todo
+ figure_ = make_item ("BassFigure", rest_req_->self_scm ());
figure_->set_property ("text" , scm_makfrom0str ("-"));
}
else if (figures_.size ())
*t = scm_cons (figures_[i]->self_scm (), SCM_EOL);
t = SCM_CDRLOC (*t);
}
- figure_ = make_item ("BassFigure");
+ figure_ = make_item ("BassFigure", figures_[0]->self_scm ());
scm_call_3 (proc, l, context ()->self_scm (),
figure_->self_scm ());
- announce_grob (figure_, figures_[0]->self_scm ()); // todo
}
}
}
void
Fingering_engraver::make_script (Direction d, Music *r, int i)
{
- Item *fingering = make_item ("Fingering");
+ Item *fingering = make_item ("Fingering", r->self_scm ());
Axis a = Y_AXIS;
Axis other = other_axis (a);
SCM dig = r->get_property ("digit");
fingering->set_property ("text", scm_number_to_string (dig, scm_int2num (10)));
- announce_grob (fingering, r->self_scm ());
fingerings_.push (fingering);
}
{
if (event_)
{
- line_ = make_spanner ("Glissando");
- announce_grob (line_, event_->self_scm ());
+ line_ = make_spanner ("Glissando", event_->self_scm ());
}
}
{
for (int k = 0; k < push_count_; k++)
{
- Spanner * sp = make_spanner ("HorizontalBracket");
+ Spanner * sp = make_spanner ("HorizontalBracket", events_[k]->self_scm ());
- announce_grob (sp, events_[k]->self_scm ());
for (int i = 0; i < bracket_stack_.size (); i++)
{
/*
{
if (ev_)
{
- hyphen_ = make_spanner ("LyricHyphen");
- announce_grob (hyphen_, ev_->self_scm ());
+ hyphen_ = make_spanner ("LyricHyphen", ev_->self_scm ()
+);
}
}
*/
virtual void process_acknowledged_grobs () {}
- /**
- Announce element. Default: pass on to daddy. Utility
- */
- virtual void announce_grob (Grob*, SCM cause);
+
virtual void announce_grob (Grob_info);
Engraver_group_engraver*get_daddy_engraver () const;
public:
+ /**
+ Announce element. Default: pass on to daddy. Utility
+ */
+ void announce_grob (Grob*, SCM cause);
+
Score_engraver * get_score_engraver () const;
/**
override other ctor
TRANSLATOR_DECLARATIONS(Engraver);
};
-#define make_item(x) make_item_from_properties (context (), ly_symbol2scm (x))
-#define make_spanner(x) make_spanner_from_properties (context (), ly_symbol2scm (x))
-Item* make_item_from_properties (Context * tg, SCM x);
-Spanner* make_spanner_from_properties (Context * tg, SCM x);
+#define make_item(x,cause) make_item_from_properties (this, ly_symbol2scm (x), cause)
+#define make_spanner(x,cause) make_spanner_from_properties (this, ly_symbol2scm (x), cause)
+Item* make_item_from_properties (Translator * tg, SCM x, SCM cause);
+Spanner* make_spanner_from_properties (Translator * tg, SCM x, SCM cause);
return ;
- text_ = make_item ("InstrumentName");
+ text_ = make_item ("InstrumentName", SCM_EOL);
if (text_->get_property ("text") != txt)
text_->set_property ("text", txt);
- announce_grob (text_, SCM_EOL);
+
}
void
if (txt == SCM_EOL)
return ;
- text_ = make_item ("VocalName");
+ text_ = make_item ("VocalName", SCM_EOL);
if (text_->get_property ("text") != txt)
text_->set_property ("text", txt);
- announce_grob (text_, SCM_EOL);
+
}
if (!dynamic_cast<Item*> (me))
me->programming_error ("only items can be breakable.");
- Item * i =dynamic_cast<Item*> (me->get_parent (X_AXIS));
- return (i) ? Item::is_breakable (i) : to_boolean (me->get_property ("breakable"));
+ Item * i = dynamic_cast<Item*> (me->get_parent (X_AXIS));
+ return (i) ? Item::is_breakable (i) : to_boolean (me->get_property ("breakable"));
}
Paper_column *
{
if (!item_)
{
- item_ = make_item ("KeySignature");
+ item_ = make_item ("KeySignature", key_ev_ ? key_ev_->self_scm () : SCM_EOL);
item_->set_property ("c0-position",
get_property ("middleCPosition"));
item_->set_property ("old-accidentals", get_property ("lastKeySignature"));
item_->set_property ("new-accidentals", get_property ("keySignature"));
- announce_grob (item_, key_ev_ ? key_ev_->self_scm () : SCM_EOL);
}
if (!def)
Spanner *
Ligature_bracket_engraver::create_ligature_spanner ()
{
- return make_spanner ("LigatureBracket");
+ return make_spanner ("LigatureBracket", SCM_EOL);
}
void
}
ligature_start_mom_ = now_mom ();
-
- announce_grob (ligature_, reqs_drul_[START]->self_scm ());
+
+ // TODO: dump cause into make_item/spanner.
+ // announce_grob (ligature_, reqs_drul_[START]->self_scm ());
override_stencil_callback ();
}
}
{
if (event_)
{
- text_= make_item ("LyricText");
+ text_= make_item ("LyricText",event_->self_scm ());
text_->set_property ("text", event_->get_property ("text"));
- announce_grob (text_, event_->self_scm ());
}
}
if (text_)
return;
- text_ = make_item ("RehearsalMark");
- announce_grob (text_, ev->self_scm ());
+ text_ = make_item ("RehearsalMark", ev->self_scm ());
}
continue;
}
- grouping_ = make_spanner ("MeasureGrouping");
+ grouping_ = make_spanner ("MeasureGrouping", SCM_EOL);
grouping_->set_bound (LEFT, unsmob_grob (get_property ("currentMusicalColumn")));
- announce_grob (grouping_, SCM_EOL);
+
stop_grouping_mom_ = now.main_part_ + Rational (grouplen - 1) * bl ;
Spanner *
Mensural_ligature_engraver::create_ligature_spanner ()
{
- return make_spanner ("MensuralLigature");
+ return make_spanner ("MensuralLigature", SCM_EOL);
}
/*
if (text_)
return;
- text_ = make_item ("MetronomeMark");
+ text_ = make_item ("MetronomeMark", rq->self_scm () );
- announce_grob (text_, rq->self_scm ());
}
if (rest_ev_ && !mmrest_
&& stop_moment_ > now_mom ())
{
- mmrest_ = make_spanner ("MultiMeasureRest");
+ mmrest_ = make_spanner ("MultiMeasureRest", rest_ev_->self_scm ());
if (text_events_.size ())
{
for (int i = 0; i < text_events_.size (); i++)
{
- Spanner *sp
- = make_spanner ("MultiMeasureRestText");
Music* e = text_events_[i];
+ Spanner *sp
+ = make_spanner ("MultiMeasureRestText", e->self_scm () );
SCM t = e->get_property ("text");
SCM dir = e->get_property ("direction");
sp->set_property ("text",t);
sp->set_property ("direction",dir);
numbers_.push (sp);
- announce_grob (sp, e->self_scm ());
}
/*
else
{
Spanner *sp
- = make_spanner ("MultiMeasureRestNumber");
+ = make_spanner ("MultiMeasureRestNumber", rest_ev_->self_scm () );
numbers_.push (sp);
- announce_grob (sp, rest_ev_->self_scm ());
}
for (int i =0 ; i < numbers_.size (); i++)
numbers_[i]->set_parent (mmrest_, Y_AXIS);
}
- announce_grob (mmrest_, rest_ev_->self_scm ());
start_measure_
= ly_scm2int (get_property ("currentBarNumber"));
}
{
Finger_tuple ft ;
- Grob * g= make_item ("Script");
+ Grob * g= make_item ("Script", event->self_scm () );
make_script_from_event (g, &ft.description_, context (),
event->get_property ("articulation-type"), 0);
if (g)
ft.script_ =g ;
articulations_.push (ft);
- announce_grob (g, event->self_scm ());
ft.script_->set_parent (head, X_AXIS);
}
{
Finger_tuple ft;
- ft.script_ = make_item ("Fingering");
- announce_grob (ft.script_, event->self_scm ());
+ ft.script_ = make_item ("Fingering", event->self_scm () );
Side_position_interface::add_support (ft.script_, head);
Should probably store follow_ in line_, and suicide at some
later point */
if (follow_)
- line_ = make_spanner ("VoiceFollower");
+ line_ = make_spanner ("VoiceFollower", head_->self_scm ());
line_->set_bound (LEFT, last_head_);
line_->set_bound (RIGHT, head_);
- announce_grob (line_, head_->self_scm ());
follow_ = false;
}
{
for (int i=0; i < note_reqs_.size (); i++)
{
- Item *note = make_item ("NoteHead");
Music * req = note_reqs_[i];
+ Item *note = make_item ("NoteHead", req->self_scm ());
Duration dur = *unsmob_duration (req->get_property ("duration"));
note->set_property ("duration-log", scm_int2num (dur.duration_log ()));
if (dur.dot_count ())
{
- Item * d = make_item ("Dots");
+ Item * d = make_item ("Dots", note->self_scm ());
Rhythmic_head::set_dots (note, d);
if (dur.dot_count ()
d->set_property ("dot-count", scm_int2num (dur.dot_count ()));
d->set_parent (note, Y_AXIS);
- announce_grob (d, SCM_EOL);
+
dots_.push (d);
}
pos += ly_scm2int (c0);
note->set_property ("staff-position", scm_int2num (pos));
- announce_grob (note,req->self_scm ());
notes_.push (note);
}
}
}
if (s.length ())
{
- Item * t = make_item ("NoteName");
+ Item * t = make_item ("NoteName", events_[0]->self_scm () );
t->set_property ("text", scm_makfrom0str (s.to_str0 ()));
- announce_grob (t, events_[0]->self_scm ());
texts_.push (t);
}
}
span_ = 0;
if (ly_c_string_p (ott))
{
- span_ = make_spanner ("OttavaBracket");
+ span_ = make_spanner ("OttavaBracket", SCM_EOL);
span_->set_property ("text", ott);
- announce_grob (span_, SCM_EOL);
+
SCM c0 (get_property ("middleCPosition"));
SCM oc0 (get_property ("originalCentralCPosition"));
if (Text_item::markup_p (text))
{
- text_ = make_item ("CombineTextScript");
+ text_ = make_item ("CombineTextScript", event_->self_scm () );
text_->set_property ("text", text);
- announce_grob (text_, event_->self_scm ());
}
}
}
{
finished_perc_ = perc_;
typeset_perc ();
- perc_ = make_spanner ("PercentRepeat");
+ perc_ = make_spanner ("PercentRepeat", repeat_->self_scm ());
SCM col =get_property ("currentCommandColumn");
perc_->set_bound (LEFT, unsmob_grob (col));
- announce_grob (perc_, repeat_->self_scm ());
}
else if (repeat_sign_type_ == DOUBLE_MEASURE)
{
- double_percent_ = make_item ("DoublePercentRepeat");
- announce_grob (double_percent_, repeat_->self_scm ());
-
+ double_percent_ = make_item ("DoublePercentRepeat", repeat_->self_scm ());
/*
forbid breaks on a % line. Should forbid all breaks, really.
*/
{
audio_staffs_.push (s);
}
- else if (Audio_column *c = dynamic_cast<Audio_column*> (p))
- {
- c->performance_ = this;
- }
audio_elem_p_list_ = new Killing_cons<Audio_element> (p, audio_elem_p_list_);
}
{
// push a new phrasing_slur onto stack.
// (use temp. array to wait for all phrasing_slur STOPs)
- Grob* phrasing_slur = make_spanner ("PhrasingSlur");
+ Grob* phrasing_slur = make_spanner ("PhrasingSlur", phrasing_slur_ev->self_scm ());
Slur::set_interface (phrasing_slur); // can't remove.
start_phrasing_slurs.push (phrasing_slur);
eventses_.push (phrasing_slur_ev);
- announce_grob (phrasing_slur, phrasing_slur_ev->self_scm ());
}
}
for (int i=0; i < start_phrasing_slurs.size (); i++)
if (!p->line_spanner_)
{
String name = String (p->name_) + "PedalLineSpanner";
- p->line_spanner_ = make_spanner (name.to_str0 ());
-
Music * rq = (p->event_drul_[START] ? p->event_drul_[START] : p->event_drul_[STOP]);
+ p->line_spanner_ = make_spanner (name.to_str0 (), rq->self_scm ());
+
- announce_grob (p->line_spanner_, rq->self_scm ());
}
/* Choose the appropriate grobs to add to the line spanner
{
String propname = String (p->name_) + "Pedal";
- p->item_ = make_item (propname.to_str0 ());
- p->item_->set_property ("text", s);
- Axis_group_interface::add_element (p->line_spanner_, p->item_);
-
- announce_grob (p->item_,
- (p->event_drul_[START]
- ? p->event_drul_[START]
- : p->event_drul_[STOP])->self_scm ());
+ p->item_ = make_item (propname.to_str0 (), (p->event_drul_[START]
+ ? p->event_drul_[START]
+ : p->event_drul_[STOP])->self_scm ());
}
-
+ p->item_->set_property ("text", s);
+ Axis_group_interface::add_element (p->line_spanner_, p->item_);
+
if (!mixed)
{
p->event_drul_[START] = 0;
p->start_ev_ = p->event_drul_[START];
p->current_bracket_ev_ = p->event_drul_[START];
- p->bracket_ = make_spanner ("PianoPedalBracket");
+ p->bracket_ = make_spanner ("PianoPedalBracket", p->event_drul_[START]->self_scm ());
/*
Set properties so that the stencil-creating function will
*/
Axis_group_interface::add_element (p->line_spanner_, p->bracket_);
- announce_grob (p->bracket_, p->event_drul_[START]->self_scm ());
if (!p->event_drul_[STOP])
{
&& rest_count_ < 2))
return;
- rest_collision_ = make_item ("RestCollision");
+ rest_collision_ = make_item ("RestCollision", SCM_EOL);
- announce_grob (rest_collision_, SCM_EOL);
+
for (int i=0; i < note_columns_.size (); i++)
Rest_collision::add_column (rest_collision_,note_columns_[i]);
}
{
if (rest_req_ && !rest_)
{
- rest_ = make_item ("Rest");
+ rest_ = make_item ("Rest", rest_req_->self_scm ());
int durlog = unsmob_duration (rest_req_->get_property ("duration"))-> duration_log ();
if (dots)
{
- dot_ = make_item ("Dots");
+ dot_ = make_item ("Dots", SCM_EOL);
Rhythmic_head::set_dots (rest_, dot_);
dot_->set_parent (rest_, Y_AXIS);
dot_->set_property ("dot-count", scm_int2num (dots));
- announce_grob (dot_, SCM_EOL);
+
}
Pitch *p = unsmob_pitch (rest_req_->get_property ("pitch"));
rest_->set_property ("staff-position", scm_int2num (pos));
}
- announce_grob (rest_, rest_req_->self_scm ());
}
}
{
if (!note_column_)
{
- note_column_ = make_item ("NoteColumn");
- announce_grob (note_column_, rheads_[0]->self_scm ());
+ note_column_ = make_item ("NoteColumn",rheads_[0]->self_scm ());
- spacing_ = make_item ("NoteSpacing");
+ spacing_ = make_item ("NoteSpacing", SCM_EOL);
spacing_->set_property ("left-items", scm_cons (note_column_->self_scm (), SCM_EOL));
- announce_grob (spacing_, SCM_EOL);
+
if (last_spacing_)
{
{
announce_infos_.push (info);
pscore_->system_->typeset_grob (info.grob_);
+ elems_.push (info.grob_);
}
void
Score_engraver::typeset_grob (Grob *elem)
{
- if (!elem)
- programming_error ("Score_engraver: empty elt\n");
- else
- elems_.push (elem);
+ // elems_.push (elem);
}
void
for (int i =0; i < elems_.size (); i++)
{
Grob * elem = elems_[i];
-
+
+#if 0
if (Spanner *s = dynamic_cast <Spanner *> (elem))
{
/*
if (dynamic_cast<Item*> (s->get_parent (Y_AXIS)))
programming_error ("Spanner Y-parent is an item.");
}
- else
+#endif
+
+ if (dynamic_cast<Item*> (elem))
{
- if (!elem->get_parent (X_AXIS))
+ if (!elem->get_parent (X_AXIS)
+ && elem != command_column_
+ && elem != musical_column_
+ )
{
bool br = to_boolean (elem->get_property ("breakable"));
Axis_group_interface::add_element (br ? command_column_ : musical_column_, elem);
{
if (!scol_ && scripts_.size () > 1)
{
- scol_ = make_item ("ScriptColumn");
- announce_grob (scol_, SCM_EOL);
+ scol_ = make_item ("ScriptColumn", SCM_EOL);
+
}
if (scol_)
{
Music* l=scripts_[i].event_;
- Grob * p = make_item ("Script");
+ Grob * p = make_item ("Script", l->self_scm ());
make_script_from_event (p, &scripts_[i].description_, context (),
l->get_property ("articulation-type"),
SCM force_dir = l->get_property ("direction");
if (is_direction (force_dir) && to_dir (force_dir))
p->set_property ("direction", force_dir);
-
- if (p)
- announce_grob (p, l->self_scm ());
}
}
if (!sep_span_)
{
- sep_span_ = make_spanner ("SeparatingGroupSpanner");
+ sep_span_ = make_spanner ("SeparatingGroupSpanner", SCM_EOL);
- announce_grob (sep_span_, SCM_EOL);
+
sep_span_->set_bound (LEFT, unsmob_grob (get_property ("currentCommandColumn")));
}
}
if (!p_ref_)
{
- p_ref_ = make_item ("SeparationItem");
+ p_ref_ = make_item ("SeparationItem", SCM_EOL);
if (ib)
{
p_ref_->set_property ("breakable", SCM_BOOL_T);
context ()->set_property ("breakableSeparationItem", p_ref_->self_scm ());
}
- announce_grob (p_ref_, SCM_EOL);
+
if (to_boolean (get_property ("createSpacing"))
&& p_ref_ == break_item_)
{
- Item *it = make_item ("StaffSpacing");
+ Item *it = make_item ("StaffSpacing", SCM_EOL);
current_spacings_.staff_spacing_ = it;
it->set_property ("left-items", scm_cons (break_item_->self_scm (), SCM_EOL));
- announce_grob (it, SCM_EOL);
+
if (int i = last_spacings_.note_spacings_.size ())
{
{
if (repeat_ && now_mom () == next_moment_)
{
- beat_slash_ = make_item ("RepeatSlash");
- announce_grob (beat_slash_, repeat_->self_scm ());
+ beat_slash_ = make_item ("RepeatSlash", repeat_->self_scm ());
next_moment_ = next_moment_ + body_length_;
get_global_context ()->add_moment_to_process (next_moment_);
{
// push a new slur onto stack.
// (use temp. array to wait for all slur STOPs)
- Grob* slur = make_spanner ("Slur");
+ Grob* slur = make_spanner ("Slur", slur_ev->self_scm ());
Slur::set_interface (slur); // cannot remove yet!
start_slurs.push (slur);
events_.push (slur_ev);
- announce_grob (slur, slur_ev->self_scm ());
}
}
{
if (!spacing_)
{
- spacing_ = make_spanner ("SpacingSpanner");
+ spacing_ = make_spanner ("SpacingSpanner", SCM_EOL);
spacing_->set_bound (LEFT, unsmob_grob (get_property ("currentCommandColumn")));
- announce_grob (spacing_, SCM_EOL);
+
}
}
if (!span_arpeggio_ && arpeggios_.size () > 1
&& to_boolean (get_property ("connectArpeggios")))
{
- span_arpeggio_ = make_item ("Arpeggio");
- announce_grob (span_arpeggio_, SCM_EOL);
+ span_arpeggio_ = make_item ("Arpeggio", SCM_EOL);
+
}
}
if (bars_.size () >= 2 && !spanbar_)
{
- spanbar_ = make_item ("SpanBar");
+ spanbar_ = make_item ("SpanBar", SCM_EOL);
spanbar_->set_parent (bars_[0], X_AXIS);
- announce_grob (spanbar_, SCM_EOL);
+
}
}
}
{
if (!span_)
{
- span_ = make_spanner ("StaffSymbol");
+ span_ = make_spanner ("StaffSymbol", SCM_EOL);
span_->set_bound (LEFT, unsmob_grob (get_property ("currentCommandColumn")));
- announce_grob (span_, SCM_EOL);
+
}
}
{
last_stanza_ = stanza;
- text_ = make_item ("StanzaNumber");
+ text_ = make_item ("StanzaNumber", SCM_EOL);
text_->set_property ("text", stanza);
- announce_grob (text_, SCM_EOL);
+
}
}
if (!stem_)
{
- stem_ = make_item ("Stem");
+ /*
+ We announce the cause of the head as cause of the stem.
+ The stem needs a rhythmic structure to fit it into a beam. */
+ stem_ = make_item ("Stem",i.music_cause ()->self_scm ());
stem_->set_property ("duration-log", scm_int2num (duration_log));
if (tremolo_flags)
{
- tremolo_ = make_item ("StemTremolo");
- announce_grob (tremolo_, tremolo_ev_->self_scm ());
+ tremolo_ = make_item ("StemTremolo", tremolo_ev_->self_scm ());
/*
The number of tremolo flags is the number of flags of
}
}
- /*
- We announce the cause of the head as cause of the stem.
- The stem needs a rhythmic structure to fit it into a beam. */
- announce_grob (stem_, i.music_cause ()->self_scm ());
}
if (Stem::duration_log (stem_) != duration_log)
if (!delim_)
{
SCM delim_name =get_property ("systemStartDelimiter");
- delim_ = make_spanner_from_properties (context (), delim_name);
+ delim_ = make_spanner_from_properties (this, delim_name, SCM_EOL);
delim_->set_bound (LEFT, unsmob_grob (get_property ("currentCommandColumn")));
- announce_grob (delim_, SCM_EOL);
+
}
}
void
{
if (elem->pscore_)
programming_error ("Adding element twice.");
-
- elem->pscore_ = pscore_;
- Pointer_group_interface::add_grob (this, ly_symbol2scm ("all-elements"), elem);
- scm_gc_unprotect_object (elem->self_scm ());
+ else
+ {
+ elem->pscore_ = pscore_;
+ Pointer_group_interface::add_grob (this, ly_symbol2scm ("all-elements"), elem);
+ scm_gc_unprotect_object (elem->self_scm ());
+ }
}
// todo: use map.
int number_of_strings = ((int) ly_length (stringTunings));
bool high_string_one = to_boolean (get_property ("highStringOne"));
- Item * note = make_item ("TabNoteHead");
Music * event = note_events_[i];
+ Item * note = make_item ("TabNoteHead", event->self_scm ());
Music * tabstring_event=0;
if (dur.dot_count ())
{
- Item * d = make_item ("Dots");
+ Item * d = make_item ("Dots", event->self_scm ());
Rhythmic_head::set_dots (note, d);
if (dur.dot_count ()
d->set_property ("dot-count", scm_int2num (dur.dot_count ()));
d->set_parent (note, Y_AXIS);
- announce_grob (d, SCM_EOL);
+
dots_.push (d);
}
note->set_property ("text", text);
note->set_property ("staff-position", scm_int2num (pos));
- announce_grob (note, event->self_scm ());
notes_.push (note);
}
}
Music * r = evs_[i];
// URG: Text vs TextScript
- Item *text = make_item ("TextScript");
+ Item *text = make_item ("TextScript", r->self_scm ());
Axis ax = Y_AXIS;
SCM mark = r->get_property ("text");
text->set_property ("text", mark);
- announce_grob (text, r->self_scm ());
texts_.push (text);
}
}
else
{
current_req_ = req_drul_[START];
- span_ = make_spanner ("TextSpanner");
+ span_ = make_spanner ("TextSpanner", req_drul_[START]->self_scm ());
Side_position_interface::set_axis (span_, Y_AXIS);
- announce_grob (span_, req_drul_[START]->self_scm ());
req_drul_[START] = 0;
}
}
&& ly_c_equal_p (right_mus->get_property ("pitch"),
left_mus->get_property ("pitch")))
{
- Grob * p = make_spanner ("Tie");
+ Grob * p = make_spanner ("Tie", last_event_->self_scm ());
Tie::set_interface (p); // cannot remove yet!
Tie::set_head (p, LEFT, th);
Tie::set_head (p, RIGHT, h);
ties_.push (p);
- announce_grob (p, last_event_->self_scm ());
}
}
if (ties_.size () && ! tie_column_)
{
- tie_column_ = make_spanner ("TieColumn");
- announce_grob (tie_column_, SCM_EOL);
+ tie_column_ = make_spanner ("TieColumn", SCM_EOL);
+
}
if (tie_column_)
last_time_fraction_ = fr;
- time_signature_ = make_item ("TimeSignature");
+ time_signature_ = make_item ("TimeSignature",SCM_EOL);
time_signature_->set_property ("fraction",fr);
-
- if (time_signature_)
- announce_grob (time_signature_, SCM_EOL);
}
}
#include "warn.hh"
#include "item.hh"
#include "spanner.hh"
+#include "engraver.hh"
/*
Grob descriptions (ie. alists with layout properties) are
}
Item*
-make_item_from_properties (Context * tg, SCM x)
+make_item_from_properties (Translator *tr, SCM x, SCM cause)
{
+ Context *tg = tr->context ();
+
SCM props = updated_grob_properties (tg, x);
- return new Item (props);
+ Item *it= new Item (props);
+
+ dynamic_cast<Engraver*>(tr)->announce_grob (it, cause);
+
+ return it;
}
Spanner*
-make_spanner_from_properties (Context *tg, SCM x)
+make_spanner_from_properties (Translator *tr, SCM x, SCM cause)
{
+ Context *tg = tr->context ();
+
SCM props = updated_grob_properties (tg, x);
- return new Spanner (props);
-}
+ Spanner *it= new Spanner (props);
+ dynamic_cast<Engraver*>(tr)->announce_grob (it, cause);
+
+ return it;
+}
if (i < started_spanners_.size () && started_spanners_[i])
continue;
- Spanner* glep = make_spanner ("TupletBracket");
+ Spanner* glep = make_spanner ("TupletBracket", time_scaled_musics_ [i]->self_scm ());
if (i >= started_spanners_.size ())
started_spanners_.push (glep);
glep->set_property ("text", t);
}
- announce_grob (glep, time_scaled_musics_ [i]->self_scm ());
}
}
Spanner *
Vaticana_ligature_engraver::create_ligature_spanner ()
{
- return make_spanner ("VaticanaLigature");
+ return make_spanner ("VaticanaLigature", SCM_EOL);
}
bool
{
if (!valign_)
{
- valign_ =make_spanner ("VerticalAlignment");
+ valign_ =make_spanner ("VerticalAlignment", SCM_EOL);
valign_->set_bound (LEFT,unsmob_grob (get_property ("currentCommandColumn")));
- announce_grob (valign_ , SCM_EOL);
+
}
}
{
started_mom_ = now_mom () ;
- volta_span_ = make_spanner ("VoltaBracket");
+ volta_span_ = make_spanner ("VoltaBracket", SCM_EOL);
- announce_grob (volta_span_, SCM_EOL);
+
volta_span_->set_property ("text", start_string_);
}
}
(define-public (set-accidental-style style . rest)
"Set accidental style to STYLE. Optionally takes a context argument,
e.g. 'Staff or 'Voice. The context defaults to Voice, except for piano styles, which
-use PianoStaff as a context. "
+use GrandStaff as a context. "
(let ((context (if (pair? rest)
(car rest) 'Staff))
(pcontext (if (pair? rest)
- (car rest) 'PianoStaff)))
+ (car rest) 'GrandStaff)))
(ly:export
(cond
;; accidentals as they were common in the 18th century.
((equal? style 'piano)
(set-accidentals-properties #f
'( Staff (same-octave . 0) (any-octave . 0) (same-octave . 1)
- PianoStaff (any-octave . 0) (same-octave . 1))
+ GrandStaff (any-octave . 0) (same-octave . 1))
'()
pcontext))
((equal? style 'piano-cautionary)
(set-accidentals-properties #f
'(Staff (same-octave . 0))
'(Staff (any-octave . 0) (same-octave . 1)
- PianoStaff (any-octave . 0) (same-octave . 1))
+ GrandStaff (any-octave . 0) (same-octave . 1))
pcontext))
;; do not set localKeySignature when a note alterated differently from
;; localKeySignature is found.
projects / lilypond.git / commitdiff