---- ../lilypond-1.3.65/CHANGES Mon Jun 26 23:22:49 2000
-++ b/CHANGES Wed Jun 28 23:25:56 2000
-@@ -1,3 +1,9 @@
1.3.65.mb1
==========
* Corrected text sizes in paper*.ly
- 1.3.64.uu1
- ==========
- 1.3.65.jcn2
+1.3.65.uu1
+==========
+
+* Dots, Collision, Rest_collision removed as separate Score_element type.
+
+* Stem and Note_column accept only one rest.
+
+* Use offset callback in Stem to resolve rest/beam collisions.
+
+* Put the value of new local key signature (accidentals) back into a property.
+
+* Set molecule-callback for notename item.
+
+1.3.65.jcn2
===========
* Added some comments to new slur code.
* Removed some ugly interstaff slur code, interstaff slurs at line-break
are still broken.
-1.3.65.jcn1
-===========
-
-* Bugfix: 16th beams are also beams.
+* Slur bugfix: 16th beams are also beams.
-* Patches from hw
-1.3.64.uu1
-==========
+1.3.65
+======
* Bugfix: translate volta spanner at start of line.
generic-property.scm. Similar fixes for Stem, Tie, etc.
* Added a Text_engraver to GraceContext. Maybe it was removed on
- purpose: scripst on grace notes seem broken, they appear on the
+ purpose: scripts on grace notes seem broken, they appear on the
main note.
* Bugfix: volume effect of (de)crescendi was sometimes wrong way round.
* Fixed dimensions (more x-y interchanges) of brace, bracket and
volta-spanner.
-* Bit half-baken fix in to get similar vertical placement of orphaned vs.
+* Half-assed fix to get similar vertical placement of orphaned vs.
line-spanned dynamic elements.
* Added property bracketCollapseHeight: the minimal size of a staff bracket
===========
* Lily now also performs crescendi and decrescendi in MIDI output:
- Span_dynamic_performer (bit scrappy).
+ Span_dynamic_performer in a slightly crappy way.
* Added preliminary support for crescendi/decrescendi other than `hairpins',
eg: `cresc. poco `a poco -- -- --'
<a href="@TOP@Documentation/out-www/index.html"><b>Documentation</b></a>
</td></tr>
<tr><td><font size=-1>
- <a href="@TOP@Documentation/out-www/CHANGES.html">NEWS</a><br>
+ <a href="@TOP@Documentation/out-www/NEWS.html">NEWS</a><br>
+ <a href="@TOP@Documentation/out-www/CHANGES.html">Change Log</a><br>
<a href="@TOP@Documentation/out-www/faq.html">FAQ</a><br>
<a href="@TOP@Documentation/user/out-www/lilypond.html">User manual</a><br>
<a href="@TOP@Documentation/out-www/regression-test.html">Features</a><br>
@mudelafile{dots.ly}
+Accidentals worki: the second note does not get a sharp. The third and
+fourth show forced and courtesy accidentals
+
+@mudelafile{accidental.ly}
+
Multiple measure rests do not collide with barlines and clefs. They
are not expanded when you set @code{Score.skipBars}. Although the
multi-measure-rest is a Spanner, minimum distances are set to keep it
colliding from barlines.
+
@mudelafile{multi-measure-rest.ly}
If @code{Score.skipBars} is set,
@mudelafile{grace.ly}
-
@section Beams, slurs and other spanners
Beaming is generated automatically. Beams may cross bar lines. In that
-[todo]
+* Improved design and implementation: Complete rewrite of the
+internals: LilyPond is smaller, cleaner, more flexible, etc.
+ - More pervasive GUILE integration resulting in
+
+ - Improved speed, with comparable memory footprint
+
+ - Improved robustness: Lily almost never crashes.
+
+* Piano pedal support
+
+* MIDI: dynamics, tempo changes
+
+* Typography: More elegant slurs, aligned dynamics, text crescendos,
+
+* Chordnames are now configurable in every respect
+
+* Included extensive glossary
+
+* Many bugfixes.
+
+* Finished ouverture Coriolan as full orchestral score example.
+
+* AsciiScript [check if broken, decide wether to keep]
PACKAGE_NAME=LilyPond
MAJOR_VERSION=1
MINOR_VERSION=3
-PATCH_LEVEL=65
-MY_PATCH_LEVEL=mb1
+PATCH_LEVEL=66
+MY_PATCH_LEVEL=
# use the above to send patches: MY_PATCH_LEVEL is always empty for a
# released version.
--- /dev/null
+
+foo = \notes\relative c'' { cis4 cis cis! cis? }
+\score {
+
+ <\foo
+ \context NoteNames \foo
+>
+}
\score {
- \context Voice \notes\relative c {
+ \context Voice \notes\relative c'' {
\time 6/8;
- d''4. b <b4. c d e> <f g a b>
+ d4. g,,
+ <b''4. c d e> <f g a b>
<g b d> <c, g' d' a'>
}
\paper { }
\midi { }
-}
\ No newline at end of file
+}
\property Voice . noteHeadStyle = #'cross
f4^"4"
g4^"5"
- \property Voice . noteHeadStyle = ""
+ \property Voice . noteHeadStyle = ##f
% Music to the Martians!
< bes4^"6" e_"7" c_"8" >
a^"0"_"9"
%{
This file tests as much features of lily as possible. If there are any
-basic faults in , this file will not run correctly.
+basic faults in lily, this file will not run correctly.
TODO:
-* add tuplets
-
* repeats.
* tremolo
/*
- afm2.cc -- implement Adobe_font_metric
+ afm.cc -- implement Adobe_font_metric
source file of the Flower Library
*/
#include "engraver-group-engraver.hh"
-#include "beam-engraver.hh"
+#include "engraver.hh"
#include "musical-request.hh"
#include "beam.hh"
#include "stem.hh"
#include "warn.hh"
#include "beaming.hh"
#include "score-engraver.hh"
+#include "rest.hh"
+#include "drul-array.hh"
+
+class Beam_engraver : public Engraver
+{
+ Drul_array<Span_req*> reqs_drul_;
+
+ Beam *finished_beam_p_;
+ Beam *beam_p_;
+ Span_req * prev_start_req_;
+
+ Beaming_info_list * beam_info_p_;
+ Beaming_info_list * finished_beam_info_p_;
+
+ /// location within measure where beam started.
+ Moment beam_start_location_;
+
+ /// moment (global time) where beam started.
+ Moment beam_start_mom_;
+
+ void typeset_beam ();
+protected:
+ virtual void do_pre_move_processing ();
+ virtual void do_post_move_processing ();
+ virtual void do_removal_processing ();
+ virtual void acknowledge_element (Score_element_info);
+ virtual bool do_try_music (Music*);
+ virtual void do_process_music ();
+public:
+ Beam_engraver ();
+ VIRTUAL_COPY_CONS (Translator);
+};
+
Beam_engraver::Beam_engraver ()
{
{
if (beam_p_)
{
- Stem* stem_l = dynamic_cast<Stem *> (info.elem_l_);
- if (!stem_l || stem_l->beam_l ())
- return;
+ if (Rest* r = dynamic_cast<Rest* > (info.elem_l_))
+ {
+ r->add_offset_callback (Beam::rest_collision_callback, Y_AXIS);
+ }
+ else if (Stem* stem_l = dynamic_cast<Stem *> (info.elem_l_))
+ {
+ if (stem_l->beam_l ())
+ return;
- bool stem_grace = stem_l->get_elt_property ("grace") == SCM_BOOL_T;
+ bool stem_grace = stem_l->get_elt_property ("grace") == SCM_BOOL_T;
- SCM wg =get_property ("weAreGraceContext");
- bool wgb= to_boolean (wg);
+ SCM wg =get_property ("weAreGraceContext");
+ bool wgb= to_boolean (wg);
- if (wgb!= stem_grace)
- return;
+ if (wgb!= stem_grace)
+ return;
- Rhythmic_req *rhythmic_req = dynamic_cast <Rhythmic_req *> (info.req_l_);
- if (!rhythmic_req)
- {
- String s = _ ("stem must have Rhythmic structure");
- if (info.req_l_)
- info.req_l_->warning (s);
- else
- ::warning (s);
+ Rhythmic_req *rhythmic_req = dynamic_cast <Rhythmic_req *> (info.req_l_);
+ if (!rhythmic_req)
+ {
+ String s = _ ("stem must have Rhythmic structure");
+ if (info.req_l_)
+ info.req_l_->warning (s);
+ else
+ ::warning (s);
- return;
+ return;
+ }
+
+ if (rhythmic_req->duration_.durlog_i_<= 2)
+ {
+ rhythmic_req->warning (_ ("stem doesn't fit in beam"));
+ prev_start_req_->warning (_ ("beam was started here"));
+ /*
+ don't return, since
+
+ [r4 c8] can just as well be modern notation.
+ */
+ }
+
+ stem_l->set_elt_property ("duration-log",
+ gh_int2scm (rhythmic_req->duration_.durlog_i_));
+ Moment stem_location = now_mom () - beam_start_mom_ + beam_start_location_;
+ beam_info_p_->add_stem (stem_location,
+ (rhythmic_req->duration_.durlog_i_ - 2) >? 1);
+ beam_p_->add_stem (stem_l);
}
-
- if (rhythmic_req->duration_.durlog_i_<= 2)
- {
- rhythmic_req->warning (_ ("stem doesn't fit in beam"));
- prev_start_req_->warning (_ ("beam was started here"));
- /*
- don't return, since
-
- [r4 c8] can just as well be modern notation.
- */
- }
-
- stem_l->set_elt_property ("duration-log",
- gh_int2scm (rhythmic_req->duration_.durlog_i_));
- Moment stem_location = now_mom () - beam_start_mom_ + beam_start_location_;
- beam_info_p_->add_stem (stem_location,
- (rhythmic_req->duration_.durlog_i_ - 2) >? 1);
- beam_p_->add_stem (stem_l);
}
}
}
return 0;
}
+
+
+/*
+ [TODO]
+ handle rest under beam (do_post: beams are calculated now)
+ what about combination of collisions and rest under beam.
+
+ Should lookup
+
+ rest -> stem -> beam -> interpolate_y_position ()
+*/
+Real
+Beam::rest_collision_callback (Score_element const *rest, Axis a )
+{
+ assert (a == Y_AXIS);
+
+ Score_element * st = unsmob_element (rest->get_elt_pointer ("stem"));
+ Stem * stem = dynamic_cast<Stem*> (st);
+ if (!stem)
+ return 0.0;
+ Beam * beam = dynamic_cast<Beam*> (unsmob_element (stem->get_elt_pointer ("beam")));
+ if (!beam || !beam->visible_stem_count ())
+ return 0.0;
+
+ // make callback for rest from this.
+ Real beam_dy = 0;
+ Real beam_y = 0;
+
+
+ // todo: make sure this calced already.
+ SCM s = beam->get_elt_property ("height");
+ if (gh_number_p (s))
+ beam_dy = gh_scm2double (s);
+
+ s = beam->get_elt_property ("y-position");
+ if (gh_number_p (s))
+ beam_y = gh_scm2double (s);
+
+ Real x0 = beam->first_visible_stem ()->relative_coordinate (0, X_AXIS);
+ Real dx = beam->last_visible_stem ()->relative_coordinate (0, X_AXIS) - x0;
+ Real dydx = beam_dy && dx ? beam_dy/dx : 0;
+
+ Direction d = stem->get_direction ();
+ Real beamy = (stem->relative_coordinate (0, X_AXIS) - x0) * dydx + beam_y;
+
+ Staff_symbol_referencer_interface si (rest);
+
+ Real staff_space = si.staff_space ();
+ Real rest_dim = rest->extent (Y_AXIS)[d]*2.0 / staff_space ;
+
+ Real minimum_dist
+ = gh_scm2double (rest->get_elt_property ("minimum-beam-collision-distance"));
+ Real dist =
+ minimum_dist + -d * (beamy - rest_dim) >? 0;
+
+ int stafflines = si.line_count ();
+
+ // move discretely by half spaces.
+ int discrete_dist = int (ceil (dist));
+
+ // move by whole spaces inside the staff.
+ if (discrete_dist < stafflines+1)
+ discrete_dist = int (ceil (discrete_dist / 2.0)* 2.0);
+
+ return (-d * discrete_dist);
+}
#include "collision.hh"
#include "dimension-cache.hh"
#include "engraver.hh"
+#include "axis-group-interface.hh"
/*
collect Note_column, and as soon as there are 2 or more, put them in
a collision object. */
class Collision_engraver : public Engraver {
- Collision* col_p_;
+ Item * col_p_;
Link_array<Note_column> note_column_l_arr_;
protected:
return ;
if (!col_p_)
{
- col_p_ = new Collision (get_property ("basicCollisionProperties"));
+ col_p_ = new Item (get_property ("basicCollisionProperties"));
+ Axis_group_interface (col_p_).set_interface ();
+ Axis_group_interface (col_p_).set_axes (X_AXIS, Y_AXIS);
+
announce_element (Score_element_info (col_p_,0));
}
+
for (int i=0; i< note_column_l_arr_.size (); i++)
- col_p_->add_column (note_column_l_arr_[i]);
+ Collision (col_p_).add_column (note_column_l_arr_[i]);
}
void
#include "note-head.hh"
#include "paper-def.hh"
#include "axis-group-interface.hh"
-
-
-Collision::Collision(SCM s )
- : Item (s)
-{
- Axis_group_interface (this).set_interface ();
- Axis_group_interface (this).set_axes (X_AXIS, Y_AXIS);
-}
+#include "item.hh"
void
Collision::add_column (Note_column* ncol_l)
{
- Axis_group_interface (this).add_element (ncol_l);
- add_dependency (ncol_l);
+ ncol_l->add_offset_callback (force_shift_callback, X_AXIS);
+ Axis_group_interface (elt_l_).add_element (ncol_l);
+ elt_l_->add_dependency (ncol_l);
}
-GLUE_SCORE_ELEMENT(Collision,before_line_breaking);
-SCM
-Collision::member_before_line_breaking ()
+Real
+Collision::force_shift_callback (Score_element const * c, Axis a)
{
- do_shifts();
- return SCM_UNDEFINED;
+ assert (a == X_AXIS);
+
+ Score_element * me = c->parent_l (a);
+ /*
+ ugh. the way DONE is done is not clean
+ */
+ if (!unsmob_element (me->get_elt_pointer ("done")))
+ {
+ me->set_elt_pointer ("done", me->self_scm_);
+ do_shifts (me);
+ }
+
+ return 0.0;
}
/*
TODO: make callback of this.
*/
void
-Collision::do_shifts()
+Collision::do_shifts(Score_element* me)
{
- SCM autos (automatic_shift ());
- SCM hand (forced_shift ());
+ SCM autos (automatic_shift (me));
+ SCM hand (forced_shift (me));
+
Link_array<Score_element> done;
- Real wid = paper_l ()->get_var ("collision_note_width");
+ Real wid = me->paper_l ()->get_var ("collision_note_width"); // elt prop
for (; gh_pair_p (hand); hand =gh_cdr (hand))
{
Score_element * s = unsmob_element (gh_caar (hand));
This should be put into Scheme.
*/
SCM
-Collision::automatic_shift ()
+Collision::automatic_shift (Score_element *me)
{
Drul_array<Link_array<Note_column> > clash_groups;
Drul_array<Array<int> > shifts;
SCM tups = SCM_EOL;
- SCM s = get_elt_pointer ("elements");
+ SCM s = me->get_elt_pointer ("elements");
for (; gh_pair_p (s); s = gh_cdr (s))
{
SCM car = gh_car (s);
{
for (int i=0; i < clash_groups[d].size (); i++)
{
- Slice s(clash_groups[d][i]->head_positions_interval ());
+ Slice s(Note_column::head_positions_interval (clash_groups[d][i]));
s[LEFT] --;
s[RIGHT]++;
extents[d].push (s);
Note_head * nu_l= cu_l->first_head();
Note_head * nd_l = cd_l->first_head();
- int downpos = cd_l->head_positions_interval ()[BIGGER];
- int uppos = cu_l->head_positions_interval ()[SMALLER];
+ int downpos = Note_column::head_positions_interval (cd_l)[BIGGER];
+ int uppos = Note_column::head_positions_interval (cu_l)[SMALLER];
bool merge =
downpos == uppos
&& nu_l->balltype_i () == nd_l->balltype_i ();
- if (!to_boolean (get_elt_property ("merge-differently-dotted")))
+ if (!to_boolean (me->get_elt_property ("merge-differently-dotted")))
merge = merge && nu_l->dot_count () == nd_l->dot_count ();
/*
SCM
-Collision::forced_shift ()
+Collision::forced_shift (Score_element *me)
{
SCM tups = SCM_EOL;
- SCM s = get_elt_pointer ("elements");
+ SCM s = me->get_elt_pointer ("elements");
for (; gh_pair_p (s); s = gh_cdr (s))
{
Score_element * se = unsmob_element (gh_car (s));
+Collision::Collision (Score_element* c)
+{
+ elt_l_ = c;
+}
// todo: dots and elements duplicate each other.
void
-Dot_column::add_dots (Dots *d)
+Dot_column::add_dots (Item *d)
{
Pointer_group_interface gi (this, "dots");
gi.add_element (d);
int
-Dot_column::compare (Dots * const &d1, Dots * const &d2)
+Dot_column::compare (Item * const &d1, Item * const &d2)
{
Staff_symbol_referencer_interface s1(d1);
Staff_symbol_referencer_interface s2(d2);
SCM
Dot_column::member_after_line_breaking ()
{
- Link_array<Dots> dots = Pointer_group_interface__extract_elements (this, (Dots*)0 , "dots");
+ Link_array<Item> dots = Pointer_group_interface__extract_elements (this, (Item*)0 , "dots");
dots.sort (Dot_column::compare);
if (dots.size () < 2)
*/
#include "dots.hh"
+#include "item.hh"
#include "molecule.hh"
#include "paper-def.hh"
#include "lookup.hh"
#include "staff-symbol-referencer.hh"
#include "directional-element-interface.hh"
-Dots::Dots (SCM s)
- : Item (s)
-{
-}
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Dots,after_line_breaking);
-GLUE_SCORE_ELEMENT(Dots,after_line_breaking);
SCM
-Dots::member_after_line_breaking ()
+Dots::after_line_breaking (SCM smob)
{
- SCM d= get_elt_property ("dot-count");
+ Item * p = dynamic_cast<Item*> (unsmob_element (smob));
+
+ SCM d= p->get_elt_property ("dot-count");
if (gh_number_p (d) && gh_scm2int (d))
{
- if (!Directional_element_interface (this).get ())
- Directional_element_interface (this).set (UP);
+ if (!Directional_element_interface (p).get ())
+ Directional_element_interface (p).set (UP);
- Staff_symbol_referencer_interface si (this);
- int p = int (si.position_f ());
- if (!(p % 2))
- si.set_position (p + Directional_element_interface (this).get ());
+ Staff_symbol_referencer_interface si (p);
+ int pos = int (si.position_f ());
+ if (!(pos % 2))
+ si.set_position (pos + Directional_element_interface (p).get ());
}
- return SCM_UNDEFINED;
-
+ return SCM_UNDEFINED;
}
MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Dots,brew_molecule);
i.origin_trans_l_ = this;
daddy_grav_l()->announce_element (i);
}
-
+
void
Engraver::typeset_element (Score_element*p)
{
Hara_kiri_group_spanner::member_after_line_breaking ()
{
SCM worth = get_elt_pointer ("items-worth-living");
- /*
- worth == self_scm is a stupid way to signal that we're done.
- */
if (gh_pair_p (worth))
return SCM_UNDEFINED;
+++ /dev/null
-/*
- beam-engraver.hh -- declare Beam_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1998--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-
- */
-
-#ifndef BEAM_ENGRAVER_HH
-#define BEAM_ENGRAVER_HH
-
-#include "engraver.hh"
-#include "drul-array.hh"
-
-class Beam_engraver : public Engraver {
- Drul_array<Span_req*> reqs_drul_;
-
- Beam *finished_beam_p_;
- Beam *beam_p_;
- Span_req * prev_start_req_;
-
- Beaming_info_list * beam_info_p_;
- Beaming_info_list * finished_beam_info_p_;
-
- /// location within measure where beam started.
- Moment beam_start_location_;
-
- /// moment (global time) where beam started.
- Moment beam_start_mom_;
-
- void typeset_beam ();
-protected:
- virtual void do_pre_move_processing ();
- virtual void do_post_move_processing ();
- virtual void do_removal_processing ();
- virtual void acknowledge_element (Score_element_info);
- virtual bool do_try_music (Music*);
- virtual void do_process_music ();
-public:
- Beam_engraver ();
- VIRTUAL_COPY_CONS (Translator);
-};
-
-#endif /* BEAM_ENGRAVER_HH */
-
int visible_stem_count () const;
Stem* first_visible_stem () const;
Stem* last_visible_stem () const;
-
+ static Real rest_collision_callback (Score_element const*,Axis);
Beam (SCM);
void add_stem (Stem*);
void set_grouping (Rhythmic_grouping def, Rhythmic_grouping current);
#ifndef COLLISION_HH
#define COLLISION_HH
+
#include "lily-proto.hh"
-#include "item.hh"
+#include "lily-guile.hh"
/**
Read and removed from elements.
*/
-class Collision : public Item
+class Collision // interface
{
public:
- SCM automatic_shift ();
- SCM forced_shift ();
- void do_shifts ();
- SCM member_before_line_breaking ();
- static SCM before_line_breaking (SCM);
+ Score_element* elt_l_;
+ static SCM automatic_shift (Score_element*);
+ static SCM forced_shift (Score_element*);
+ static Real force_shift_callback (Score_element const*, Axis);
+ static void do_shifts (Score_element*);
-
void add_column (Note_column*ncol_l);
- Collision(SCM);
+ Collision(Score_element*);
};
#endif // COLLISION_HH
*/
class Dot_column : public Item
{
- static int compare (Dots * const&,Dots * const&);
- void add_dots (Dots*);
+ static int compare (Item * const&,Item * const&);
+ void add_dots (Item*);
public:
VIRTUAL_COPY_CONS (Score_element);
void add_head (Rhythmic_head*);
#ifndef DOTS_HH
#define DOTS_HH
-#include "item.hh"
+#include "lily-proto.hh"
+#include "lily-guile.hh"
/**
*/
-class Dots : public Item
+class Dots // interface
{
public:
- SCM member_brew_molecule () const;
- SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
static SCM brew_molecule (SCM);
-
- Dots (SCM);
};
#endif // DOTS_HH
#include "array.hh"
#include "request.hh"
#include "score-element-info.hh"
-#include "staff-info.hh"
#include "translator.hh"
/**
a struct which processes requests, and creates the #Score_element#s.
- It may use derived classes. Hungarian postfix: grav
-
+ It may use derived classes.
*/
class Engraver : public virtual Translator {
/** a struct for treating a group of noteheads (noteheads, stem
(chord) and scripts) as a single entity.
+
+ UGR. Junkme. refpoint should be the notehead, dir should come from stem.
+
*/
class Note_column : public Item
{
public:
- SCM member_after_line_breaking ();
- static SCM after_line_breaking (SCM);
static int shift_compare (Note_column *const &, Note_column*const&);
/** The relative position of the "voice" containing this
Direction dir () const;
- Interval_t<int> head_positions_interval() const;
-
+ static Slice head_positions_interval(Score_element* me) ;
+ static Direction static_dir (Score_element*);
void translate_rests(int dy);
Note_head * first_head ()const;
Interval rest_dim ()const ;
Note_column (SCM);
- void set_stem (Stem*);
- void set_dotcol (Dot_column*);
- void add_head (Rhythmic_head*);
+ void set_stem (Score_element*);
+ void set_dotcol (Score_element*);
+ void add_head (Score_element*);
bool rest_b () const;
Stem *stem_l()const;
*/
class Note_heads_engraver : public Engraver {
Link_array<Note_head> note_p_arr_;
- Link_array<Dots> dot_p_arr_;
+ Link_array<Item> dot_p_arr_;
Link_array<Note_req> note_req_l_arr_;
Moment note_end_mom_;
public:
#include "array.hh"
#include "request.hh"
#include "score-element-info.hh"
-#include "staff-info.hh"
#include "translator.hh"
/**
+++ /dev/null
-/*
- rest-collision-engraver.hh -- declare Rest_collision_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-*/
-
-
-#ifndef REST_COLLISION_GRAV_HH
-#define REST_COLLISION_GRAV_HH
-
-#include "array.hh"
-#include "engraver.hh"
-
-class Rest_collision_engraver : public Engraver {
- Rest_collision* rest_collision_p_;
-
- Link_array<Note_column> note_column_l_arr_;
-protected:
- virtual void acknowledge_element (Score_element_info);
- virtual void process_acknowledged ();
- virtual void do_pre_move_processing();
-public:
- VIRTUAL_COPY_CONS(Translator);
- Rest_collision_engraver();
-
-};
-#endif // REST_COLLISION_GRAV_HH
#define REST_COLLISION_HH
#include "lily-proto.hh"
-#include "item.hh"
+#include "lily-guile.hh"
-class Rest_collision : public Item {
+class Rest_collision // interface
+{
public:
+ Score_element *elt_l_;
+
void add_column (Note_column*);
- Interval rest_dim () const;
-
- Rest_collision(SCM);
+ Rest_collision(Score_element*);
+ void set_interface ();
- SCM member_after_line_breaking ();
- static SCM after_line_breaking (SCM);
+ static Real force_shift_callback (Score_element const*, Axis);
+ static SCM do_shift (Score_element*,SCM);
};
#endif // REST_COLLISION_HH
class Rest_engraver : public Engraver
{
Rest_req *rest_req_l_;
- Dots * dot_p_;
+ Item * dot_p_;
Rest * rest_p_;
protected:
virtual bool do_try_music (Music *);
+++ /dev/null
-/*
- rhythmic-column-engraver.hh -- declare Rhythmic_column_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-*/
-
-
-#ifndef RHYTHMIC_COLUMN_GRAV_HH
-#define RHYTHMIC_COLUMN_GRAV_HH
-
-#include "engraver.hh"
-#include "parray.hh"
-
-class Rhythmic_column_engraver :public Engraver {
- Link_array<Rhythmic_head> rhead_l_arr_;
- Link_array<Slur> grace_slur_endings_;
- Stem * stem_l_;
- Note_column *ncol_p_;
- Dot_column *dotcol_l_;
-
-protected:
- VIRTUAL_COPY_CONS(Translator);
- virtual void acknowledge_element (Score_element_info);
- virtual void process_acknowledged ();
- virtual void do_pre_move_processing();
- virtual void do_post_move_processing();
-public:
- Rhythmic_column_engraver();
-
-};
-#endif // RHYTHMIC_COLUMN_GRAV_HH
-
-
-
VIRTUAL_COPY_CONS(Rhythmic_head);
int balltype_i () const;
- void add_dots (Dots *);
+ void add_dots (Item *);
Stem * stem_l () const;
- Dots * dots_l () const;
+ Item * dots_l () const;
int dot_count () const;
SCM member_after_line_breaking ();
}
}
+
+
+ daddy_trans_l_->set_property ("localKeySignature", localsig);
/*
UGH !
*/
#include <math.h> // ceil
#include "axis-group-interface.hh"
-#include "dot-column.hh"
#include "note-column.hh"
-#include "beam.hh"
-#include "note-head.hh"
#include "stem.hh"
-#include "rest.hh"
#include "debug.hh"
#include "paper-def.hh"
#include "group-interface.hh"
bool
Note_column::rest_b () const
{
- SCM r = get_elt_pointer ("rests");
-
- return gh_pair_p (r);
+ return unsmob_element (get_elt_pointer ("rest"));
}
int
Note_column::Note_column( SCM s)
: Item (s)
{
- set_elt_pointer ("rests", SCM_EOL);
set_elt_pointer ("note-heads", SCM_EOL);
Axis_group_interface (this).set_interface ();
Axis_group_interface (this).set_axes (X_AXIS, Y_AXIS);
{
SCM s = get_elt_pointer ("stem");
return dynamic_cast<Stem*> (unsmob_element (s));
-
}
Slice
-Note_column::head_positions_interval() const
+Note_column::head_positions_interval(Score_element *me)
{
Slice iv;
iv.set_empty ();
- SCM h = get_elt_pointer ("note-heads");
+ SCM h = me->get_elt_pointer ("note-heads");
for (; gh_pair_p (h); h = gh_cdr (h))
{
Score_element *se = unsmob_element (gh_car (h));
}
Direction
-Note_column::dir () const
+Note_column::static_dir (Score_element* me)
{
- if (stem_l ())
- return stem_l ()->get_direction ();
- else if (gh_pair_p (get_elt_pointer ("note-heads")))
- return (Direction)sign (head_positions_interval().center ());
+ Score_element *stem = unsmob_element (me->get_elt_pointer ("stem"));
+ if (dynamic_cast<Stem*> (stem))
+ return dynamic_cast<Stem*> (stem)->get_direction ();
+ else if (gh_pair_p (me->get_elt_pointer ("note-heads")))
+ return (Direction)sign (head_positions_interval (me).center ());
programming_error ("Note column without heads and stem!");
return CENTER;
}
+Direction
+Note_column::dir () const
+{
+ return static_dir ((Score_element*) this);
+}
+
void
-Note_column::set_stem (Stem * stem_l)
+Note_column::set_stem (Score_element * stem_l)
{
set_elt_pointer ("stem", stem_l->self_scm_);
Axis_group_interface (this).add_element (stem_l);
}
-
-
void
-Note_column::add_head (Rhythmic_head *h)
+Note_column::add_head (Score_element *h)
{
- if (Rest*r=dynamic_cast<Rest *> (h))
+ if (to_boolean (h->get_elt_property ("rest-interface")))
{
- Pointer_group_interface gi (this, "rests");
- gi.add_element (h);
+ this->set_elt_pointer ("rest", h->self_scm_);
}
- if (Note_head *nh=dynamic_cast<Note_head *> (h))
+ else if (to_boolean (h->get_elt_property ("note-head-interface")))
{
Pointer_group_interface gi (this, "note-heads");
- gi.add_element (nh);
+ gi.add_element (h);
}
Axis_group_interface (this).add_element (h);
}
void
Note_column::translate_rests (int dy_i)
{
- SCM s = get_elt_pointer ("rests");
- for (; gh_pair_p (s); s = gh_cdr (s))
+ Score_element * r = unsmob_element (get_elt_pointer ("rest"));
+ if (r)
{
- Score_element * se = unsmob_element (gh_car (s));
- Staff_symbol_referencer_interface si (se);
-
- se->translate_axis (dy_i * si.staff_space ()/2.0, Y_AXIS);
+ Staff_symbol_referencer_interface si (r);
+ r->translate_axis (dy_i * si.staff_space ()/2.0, Y_AXIS);
}
}
void
-Note_column::set_dotcol (Dot_column *d)
+Note_column::set_dotcol (Score_element *d)
{
Axis_group_interface (this).add_element (d);
}
-/*
- [TODO]
- handle rest under beam (do_post: beams are calculated now)
- what about combination of collisions and rest under beam.
-
- Should lookup
-
- rest -> stem -> beam -> interpolate_y_position ()
-*/
-
-GLUE_SCORE_ELEMENT(Note_column,after_line_breaking);
-SCM
-Note_column::member_after_line_breaking ()
-{
- if (!stem_l () || !rest_b ())
- return SCM_UNDEFINED;
-
- Beam * b = stem_l ()->beam_l ();
- if (!b || !b->visible_stem_count ())
- return SCM_UNDEFINED;
-
- /* ugh. Should be done by beam.
- (what? should be done --jcn)
- scary too?: height is calculated during post_processing
- */
- Real beam_dy = 0;
- Real beam_y = 0;
-
- SCM s = b->get_elt_property ("height");
- if (gh_number_p (s))
- beam_dy = gh_scm2double (s);
-
- s = b->get_elt_property ("y-position");
- if (gh_number_p (s))
- beam_y = gh_scm2double (s);
-
-
- Real x0 = b->first_visible_stem ()->relative_coordinate (0, X_AXIS);
- Real dx = b->last_visible_stem ()->relative_coordinate (0, X_AXIS) - x0;
- Real dydx = beam_dy && dx ? beam_dy/dx : 0;
-
- Direction d = stem_l ()->get_direction ();
- Real beamy = (stem_l ()->relative_coordinate (0, X_AXIS) - x0) * dydx + beam_y;
-
- s = get_elt_pointer ("rests");
- Score_element * se = unsmob_element (gh_car (s));
- Staff_symbol_referencer_interface si (se);
-
- Real staff_space = si.staff_space ();
- Real rest_dim = extent (Y_AXIS)[d]*2.0 /staff_space ;
-
- Real minimum_dist
- = paper_l ()->get_var ("restcollision_minimum_beamdist") ;
- Real dist =
- minimum_dist + -d * (beamy - rest_dim) >? 0;
-
- int stafflines = si.line_count ();
-
- // move discretely by half spaces.
- int discrete_dist = int (ceil (dist ));
-
- // move by whole spaces inside the staff.
- if (discrete_dist < stafflines+1)
- discrete_dist = int (ceil (discrete_dist / 2.0)* 2.0);
-
- translate_rests (-d * discrete_dist);
-
- return SCM_UNDEFINED;
-}
Interval
Note_column::rest_dim () const
{
- Interval restdim;
- SCM s = get_elt_pointer ("rests");
- for (; gh_pair_p (s); s = gh_cdr (s))
- {
- Score_element * sc = unsmob_element ( gh_car (s));
- restdim.unite (sc->extent (Y_AXIS));
- }
-
- return restdim;
+ Score_element * r = unsmob_element (get_elt_pointer ("rest"));
+ return r->extent (Y_AXIS);
}
Note_head*
if (balltype_i () > 2)
set_elt_property ("duration-log", gh_int2scm (2));
- if (Dots *d = dots_l ())
+ if (Item *d = dots_l ())
{ // move into Rhythmic_head?
Staff_symbol_referencer_interface si (d);
Staff_symbol_referencer_interface me (this);
if (note_req_l->duration_.dots_i_)
{
- Dots * d = new Dots (get_property ("basicDotsProperties"));
+ Item * d = new Item (get_property ("basicDotsProperties"));
Staff_symbol_referencer_interface sd (d);
sd.set_interface ();
}
if (s.length_i())
{
- Item * t = new Item (SCM_EOL);
+ Item * t = new Item (get_property ("basicNoteNameProperties"));
t->set_elt_property ("text", ly_str02scm ( s.ch_C()));
announce_element (Score_element_info (t, req_l_arr_[0]));
texts_.push (t);
#include "debug.hh"
#include "rest-collision.hh"
-#include "rest-collision-engraver.hh"
+#include "engraver.hh"
#include "collision.hh"
#include "note-column.hh"
+class Rest_collision_engraver : public Engraver
+{
+ Item* rest_collision_p_;
+
+ Link_array<Note_column> note_column_l_arr_;
+protected:
+ virtual void acknowledge_element (Score_element_info);
+ virtual void process_acknowledged ();
+ virtual void do_pre_move_processing();
+public:
+ VIRTUAL_COPY_CONS(Translator);
+ Rest_collision_engraver();
+
+};
ADD_THIS_TRANSLATOR(Rest_collision_engraver);
if (rest_collision_p_ || note_column_l_arr_.size () < 2)
return;
- rest_collision_p_ = new Rest_collision (get_property ("basicRestCollisionProperties"));
-
+ rest_collision_p_ = new Item (get_property ("basicRestCollisionProperties"));
+ Rest_collision (rest_collision_p_).set_interface();
announce_element (Score_element_info (rest_collision_p_, 0));
for (int i=0; i< note_column_l_arr_.size (); i++)
- rest_collision_p_->add_column (note_column_l_arr_[i]);
+ Rest_collision (rest_collision_p_).add_column (note_column_l_arr_[i]);
}
void
*/
#include <math.h> // ceil.
-#include "beam.hh"
#include "debug.hh"
#include "rest-collision.hh"
#include "note-column.hh"
#include "stem.hh"
#include "note-head.hh"
-#include "collision.hh"
#include "paper-def.hh"
#include "rest.hh"
#include "group-interface.hh"
#include "staff-symbol-referencer.hh"
#include "duration.hh"
-void
-Rest_collision::add_column (Note_column *nc_l)
+Real
+Rest_collision::force_shift_callback (Score_element const*them, Axis a)
{
- add_dependency (nc_l);
- Pointer_group_interface gi (this);
- if (nc_l->rest_b ())
- gi.name_ = "rests";
- else
- gi.name_ = "notes";
+ assert (a == Y_AXIS);
+
+ Score_element * rc = unsmob_element (them->get_elt_pointer ("rest-collision"));
+
+ if (rc)
+ {
+ /*
+ Done: destruct pointers, so we do the shift only once.
+ */
+ SCM elts = rc->get_elt_pointer ("elements");
+ rc->set_elt_pointer ("elements", SCM_EOL);
+
+ do_shift (rc, elts);
+ }
- gi.add_element (nc_l);
+ return 0.0;
}
+void
+Rest_collision::add_column (Note_column *p)
+{
+ elt_l_->add_dependency (p);
+ Pointer_group_interface gi (elt_l_);
+ gi.add_element (p);
+
+ p->add_offset_callback (&Rest_collision::force_shift_callback, Y_AXIS);
+ p->set_elt_pointer ("rest-collision", elt_l_->self_scm_);
+}
+
+/*
+ these 3 have to go, because they're unnecessary complications.
+ */
static Duration
to_duration (int type, int dots)
{
return d;
}
+/*
+ UGH
+
+ elt_l_ should be "duration" independent
+ */
static Moment
rhythmic_head2mom (Rhythmic_head* r)
{
ugh
*/
static Rhythmic_head*
-col2rhythmic_head (Note_column* c)
+col2rhythmic_head (Score_element* c)
{
- SCM s = c->get_elt_pointer ("rests");
- assert (gh_pair_p (s));
- Score_element* e = unsmob_element (gh_car (s));
- return dynamic_cast<Rhythmic_head*> (e);
+ return dynamic_cast<Rhythmic_head*> (unsmob_element (c->get_elt_pointer ("rest")));
}
-GLUE_SCORE_ELEMENT(Rest_collision,after_line_breaking);
+/*
+ TODO: fixme, fucks up if called twice on the same set of rests.
+ */
SCM
-Rest_collision::member_after_line_breaking ()
+Rest_collision::do_shift (Score_element *me, SCM elts)
{
- Link_array<Note_column> rest_l_arr =
- Pointer_group_interface__extract_elements (this, (Note_column*) 0, "rests");
- Link_array<Note_column> ncol_l_arr =
- Pointer_group_interface__extract_elements (this, (Note_column*) 0, "notes");
+ /*
+ ugh. -> score elt type
+ */
+ Link_array<Note_column> rests;
+ Link_array<Note_column> notes;
+
+ for (SCM s = elts; gh_pair_p (s); s = gh_cdr (s))
+ {
+ Score_element * e = unsmob_element (gh_car (s));
+ if (e && unsmob_element (e->get_elt_pointer ("rest")))
+ rests.push (dynamic_cast<Note_column*> (e));
+ else
+ notes.push (dynamic_cast<Note_column*> (e));
+ }
/*
*/
// no rests to collide
- if (!rest_l_arr.size())
+ if (!rests.size())
return SCM_UNDEFINED;
// no partners to collide with
- if (rest_l_arr.size() + ncol_l_arr.size () < 2)
+ if (rests.size() + notes.size () < 2)
return SCM_UNDEFINED;
// meisjes met meisjes
- if (!ncol_l_arr.size())
+ if (!notes.size())
{
- Moment m = rhythmic_head2mom (col2rhythmic_head (rest_l_arr[0]));
+ Moment m = rhythmic_head2mom (col2rhythmic_head (rests[0]));
int i = 1;
- for (; i < rest_l_arr.size (); i++)
+ for (; i < rests.size (); i++)
{
- Moment me = rhythmic_head2mom (col2rhythmic_head (rest_l_arr[i]));
+ Moment me = rhythmic_head2mom (col2rhythmic_head (rests[i]));
if (me != m)
break;
}
(urg: all 3 of them, currently).
*/
int display_count;
- SCM s = get_elt_property ("maximum-rest-count");
- if (i == rest_l_arr.size ()
- && gh_number_p (s) && gh_scm2int (s) < rest_l_arr.size ())
+ SCM s = me->get_elt_property ("maximum-rest-count");
+ if (i == rests.size ()
+ && gh_number_p (s) && gh_scm2int (s) < rests.size ())
{
display_count = gh_scm2int (s);
for (; i > display_count; i--)
- col2rhythmic_head (rest_l_arr[i-1])
+ col2rhythmic_head (rests[i-1])
->set_elt_property ("molecule-callback", SCM_BOOL_T);
}
else
- display_count = rest_l_arr.size ();
+ display_count = rests.size ();
/*
UGH. Should get dims from table. Should have minimum dist.
int dy = display_count > 2 ? 6 : 4;
if (display_count > 1)
{
- rest_l_arr[0]->translate_rests (dy);
- rest_l_arr[1]->translate_rests (-dy);
+ rests[0]->translate_rests (dy);
+ rests[1]->translate_rests (-dy);
}
}
// meisjes met jongetjes
else
{
- if (rest_l_arr.size () > 1)
+ if (rests.size () > 1)
{
warning (_("too many colliding rests"));
}
- if (ncol_l_arr.size () > 1)
+ if (notes.size () > 1)
{
warning (_("too many notes for rest collision"));
}
- Note_column * rcol = rest_l_arr[0];
+ Note_column * rcol = rests[0];
// try to be opposite of noteheads.
- Direction dir = - ncol_l_arr[0]->dir();
+ Direction dir = - notes[0]->dir();
Interval restdim = rcol->rest_dim ();
if (restdim.empty_b ())
return SCM_UNDEFINED;
// staff ref'd?
- Real staff_space = paper_l()->get_var ("interline");
+ Real staff_space = me->paper_l()->get_var ("interline");
/* FIXME
- staff_space = rcol->rest_l_arr[0]->staff_space ();
+ staff_space = rcol->rests[0]->staff_space ();
*/
- Real half_staff_space_f = staff_space/2;
- Real minimum_dist = paper_l ()->get_var ("restcollision_minimum_dist")
- * half_staff_space_f;
+ Real minimum_dist = gh_scm2double (me->get_elt_property ("minimum-distance")) * staff_space;
/*
assumption: ref points are the same.
*/
Interval notedim;
- for (int i = 0; i < ncol_l_arr.size(); i++)
+ for (int i = 0; i < notes.size(); i++)
{
- notedim.unite (ncol_l_arr[i]->extent (Y_AXIS));
+ notedim.unite (notes[i]->extent (Y_AXIS));
}
Interval inter (notedim);
// FIXME
- //int stafflines = 5; // rcol->rest_l_arr[0]->line_count;
- int stafflines = Staff_symbol_referencer_interface (this).line_count ();
+ //int stafflines = 5; // rcol->rests[0]->line_count;
+ int stafflines = Staff_symbol_referencer_interface (me).line_count ();
// hurg?
stafflines = stafflines != 0 ? stafflines : 5;
return SCM_UNDEFINED;
}
-
-Rest_collision::Rest_collision(SCM s)
- : Item (s)
+void
+Rest_collision::set_interface ()
{
- set_elt_pointer ("rests", SCM_EOL);
- set_elt_pointer ("notes", SCM_EOL);
- set_extent_callback (0, X_AXIS);
- set_extent_callback (0, Y_AXIS);
+ elt_l_->set_extent_callback (0, X_AXIS);
+ elt_l_->set_extent_callback (0, Y_AXIS);
+ elt_l_->set_elt_pointer ("elements", SCM_EOL);
}
+Rest_collision::Rest_collision (Score_element* c)
+{
+ elt_l_ = c;
+}
if (rest_req_l_->duration_.dots_i_)
{
- dot_p_ = new Dots (get_property ("basicDotsProperties"));
+ dot_p_ = new Item (get_property ("basicDotsProperties"));
Staff_symbol_referencer_interface si (dot_p_);
si.set_interface ();
Staff_symbol_referencer_interface si (this);
si.set_position (si.position_f () + 2);
}
-
- Dots * d = dots_l ();
+ Item * d = dots_l ();
if (d && balltype_i () > 4) // UGH.
{
/*
#include "dimension-cache.hh"
#include "slur.hh"
-#include "rhythmic-column-engraver.hh"
+#include "engraver.hh"
#include "note-head.hh"
#include "stem.hh"
#include "note-column.hh"
#include "dot-column.hh"
#include "musical-request.hh"
+class Rhythmic_column_engraver :public Engraver
+{
+ Link_array<Rhythmic_head> rhead_l_arr_;
+ Link_array<Slur> grace_slur_endings_;
+ Stem * stem_l_;
+ Note_column *ncol_p_;
+ Dot_column *dotcol_l_;
+
+protected:
+ VIRTUAL_COPY_CONS(Translator);
+ virtual void acknowledge_element (Score_element_info);
+ virtual void process_acknowledged ();
+ virtual void do_pre_move_processing();
+ virtual void do_post_move_processing();
+public:
+ Rhythmic_column_engraver();
+
+};
+
+
+
Rhythmic_column_engraver::Rhythmic_column_engraver()
{
stem_l_ =0;
#include "staff-symbol-referencer.hh"
-Dots*
+Item*
Rhythmic_head::dots_l () const
{
SCM s = get_elt_pointer ("dot");
- return dynamic_cast<Dots*> (unsmob_element (s));
+ return dynamic_cast<Item*> (unsmob_element (s));
}
int
SCM
Rhythmic_head::member_after_line_breaking ()
{
- if (Dots *d = dots_l ())
+ if (Item *d = dots_l ())
{
Staff_symbol_referencer_interface si (d);
Staff_symbol_referencer_interface me (d);
void
-Rhythmic_head::add_dots (Dots *dot_l)
+Rhythmic_head::add_dots (Item *dot_l)
{
set_elt_pointer ("dot", dot_l->self_scm_);
dot_l->add_dependency (this);
Rhythmic_tuple::time_compare (Rhythmic_tuple const &h1,
Rhythmic_tuple const &h2)
{
-
return (h1.end_ - h2.end_ ).sign ();
}
if (left == right)
{
- /*
- FIXME: this is broken.
- */
/*
If we have a spanner spanning one column, we must break it
anyway because it might provide a parent for another item. */
do
{
Item* bound = left->find_prebroken_piece (d);
- if (bound->line_l ())
+ if (!bound)
+ programming_error ("no broken bound");
+ else if (bound->line_l ())
{
Spanner * span_p = dynamic_cast<Spanner*>( clone ());
span_p->set_bound (LEFT, bound);
#include "musical-request.hh"
#include "misc.hh"
#include "stem-tremolo.hh"
-#include "staff-info.hh"
+
#include "translator-group.hh"
#include "engraver.hh"
n->set_elt_pointer ("stem", this->self_scm_);
n->add_dependency (this);
- Pointer_group_interface gi (this);
if (Note_head *nh = dynamic_cast<Note_head *> (n))
- gi.name_ = "heads";
- else
- gi.name_ = "rests";
+ {
+ Pointer_group_interface gi (this);
+ gi.name_ = "heads";
- gi.add_element (n);
+ gi.add_element (n);
+ }
+ else
+ {
+ n->set_elt_pointer ("rest", n->self_scm_);
+ }
}
Stem::Stem (SCM s)
: Item (s)
{
set_elt_pointer ("heads", SCM_EOL);
- set_elt_pointer ("rests", SCM_EOL);
add_offset_callback ( &Stem::off_callback, X_AXIS);
}
)
basicCollisionProperties = #`(
(axes 0 1)
- (before-line-breaking-callback . ,Collision::before_line_breaking)
)
basicCrescendoProperties = #`(
(molecule-callback . ,Crescendo::brew_molecule)
basicDotsProperties = #`(
(molecule-callback . ,Dots::brew_molecule)
(after-line-breaking-callback . ,Dots::after_line_breaking)
- (dot-count . 1)
+ (dot-count . 1)
+ (dots-interface . #t)
)
basicDynamicLineSpannerProperties = #`(
(dynamic-interface . #t)
(axes 0 1)
)
basicNoteHeadProperties = #`(
+ (note-head-interface . #t)
(molecule-callback . ,Note_head::brew_molecule)
(before-line-breaking-callback . ,Note_head::before_line_breaking)
(after-line-breaking-callback . ,Rhythmic_head::after_line_breaking)
)
+ basicNoteNameProperties = #`(
+ (molecule-callback . ,Text_item::brew_molecule)
+ )
basicOctavateEightProperties = #`(
(self-alignment-X . 0)
(text . "8")
)
basicTextProperties = #`( )
- basicRestProperties = #`(
+ basicRestProperties = #`(
+ (rest-interface . #t)
(molecule-callback . ,Rest::brew_molecule)
(after-line-breaking-callback . ,Rhythmic_head::after_line_breaking)
+ (minimum-beam-collision-distance . 1.5)
)
basicRestCollisionProperties = #`(
- (after-line-breaking-callback . ,Rest_collision::after_line_breaking)
+ (minimum-distance . 0.75)
)
basicScriptProperties = #`(
(molecule-callback . ,Script::brew_molecule)
crescendo_dash = 4.0*\staffspace;
% in internote.
-restcollision_minimum_dist = 3.0;
-restcollision_minimum_beamdist = 1.5;
% unit for note collision resolving
Begin3
Title: LilyPond
-Version: 1.3.65
-Entered-date: 26JUN00
+Version: 1.3.66
+Entered-date: 29JUN00
Description:
Keywords: music notation typesetting midi fonts engraving
Author: hanwen@cs.uu.nl (Han-Wen Nienhuys)
janneke@gnu.org (Jan Nieuwenhuizen)
Maintained-by: hanwen@stack.nl (Han-Wen Nienhuys)
Primary-site: sunsite.unc.edu /pub/Linux/apps/sound/convert
- 1000k lilypond-1.3.65.tar.gz
+ 1000k lilypond-1.3.66.tar.gz
Original-site: ftp.cs.uu.nl /pub/GNU/LilyPond/development/
- 1000k lilypond-1.3.65.tar.gz
+ 1000k lilypond-1.3.66.tar.gz
Copying-policy: GPL
End
Name: lilypond
-Version: 1.3.65
+Version: 1.3.66
Release: 1
Copyright: GPL
Group: Applications/Publishing
-Source0: ftp.cs.uu.nl:/pub/GNU/LilyPond/development/lilypond-1.3.65.tar.gz
+Source0: ftp.cs.uu.nl:/pub/GNU/LilyPond/development/lilypond-1.3.66.tar.gz
Summary: A program for printing sheet music.
URL: http://www.cs.uu.nl/~hanwen/lilypond
# Icon: lilypond-icon.gif
+; BROKEN as of 1.3.55, FIXME
+;
+
+
;
; Format:
; (cons 'Type name
projects / lilypond.git / commitdiff