Theoretically, yes but it is easier to do with TeX:
@example
-\def\foo{\hbox{\vrule width 15.0cm height 0.5pt depth 0.0pt}
+\def\foo@{\hbox@{\vrule width 15.0cm height 0.5pt depth 0.0pt@}
\nointerlineskip
-\vskip 5pt\nointerlineskip}
-\def\musicline{\vbox {
+\vskip 5pt\nointerlineskip@}
+\def\musicline@{\vbox @{
\foo\foo\foo\foo\foo
-}\par}
+@}\par@}
\musicline
\musicline
associated element. Setting the property to 'if-no-beam will make it
print only if there is no beam associated with this tuplet bracket.
-[fixme examples]
+@mudelafile[verbatim]{tuplet.ly}
@item @code{tupletInvisible}@indexcode{tupletInvisible} @propertytype{boolean}
F.Schubert/
Hymns/
J.S.Bach/
- L.Mozart/
- N.W.Gade/
- W.A.Mozart/
intl/ library for gettext
po/ translations
ps/ postscript library files
/* define if you have isinf */
#define HAVE_ISINF 0
-/* define if you have isinf */
-#define HAVE_ISINF 0
-
/* define if explicit instantiation is needed */
#undef NEED_EXPLICIT_INSTANTIATION
};
+/*
+ DEPRECATED. Use either SCM (preferred) or STL
+ */
template<class V>
class Dictionary : public Hash_table<String, V>
{
A hash table of prime size.
We use quadratic probing.
- */
+
+ DEPRECATED. Use either SCM (preferred) or STL
+*/
template<class K, class V>
class Fixed_size_hash_table
{
#ifndef TUPLET_HH
#define TUPLET_HH
+#error
template<class T, class U>
--- /dev/null
+
+ \score {
+ \notes \relative c' {
+ c2( c \break c c c c \break c
+}}
\score{
\context Staff \notes\relative c'{
-c\sustaindown d e f\sustainup g\sustaindown b c
-c,\sustainup\sustaindown d e f \sustainup g\sustaindown b c
+c4\sustaindown d e f\sustainup g\sustaindown b c
+c, [d16 \sustainup \sustaindown c c c] [e e \sustainup \sustaindown e e ] f4 \sustainup g\sustaindown b c
\property Staff.stopStartSustain = #"-P"
\property Staff.startSustain = #"P"
c,\sustainup\sustaindown d e f \sustainup g\sustaindown b c
+\version "1.3.47"
+
\score {
- \context Voice \notes\relative c {
- \property Voice.textEmptyDimension = 1
- \property Voice.textScriptPadding = 10
- \property Voice.tupletVisibility = 0
- \times2/3{c'4^"tupletVisibility = 0" d e} \times2/3{[f8 g a]}
- \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 1
- \times2/3{c,4^"tupletVisibility = 1" d e} \times2/3{[f8 g a]}
- \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 2
- \times2/3{c,4^"tupletVisibility = 2" d e} \times2/3{[f8 g a]}
- \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 3
- \times2/3{c,4^"tupletVisibility = 3" d e} \times2/3{[f8 g a]}
- \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 4
- \times2/3{c,4^"tupletVisibility = 4" d e} \times2/3{[f8 g a]}
- \times2/3{b16 c d} c8 | \break
-
- \property Voice.tupletDirection = \down
- \property Voice.tupletVisibility = 0
- \times2/3{c,4^"tupletDirection = down" d e}
- \times2/3{[[f8 g a]]} \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 1
- \times2/3{c,4 d e} \times2/3{[f8 g a]} \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 2
- \times2/3{c,4 d e} \times2/3{[f8 g a]} \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 3
- \times2/3{c,4 d e} \times2/3{[f8 g a]} \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 4
- \times2/3{c,4 d e} \times2/3{[f8 g a]} \times2/3{b16 c d} c8 |\break
-
- \property Voice.tupletDirection = \up
- \property Voice.tupletVisibility = 0
- \times2/3{c,4^"tupletDirection = up" d e}
- \times2/3{[[f8 g a]]} \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 1
- \times2/3{c,4 d e} \times2/3{[f8 g a]} \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 2
- \times2/3{c,4 d e} \times2/3{[f8 g a]} \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 3
- \times2/3{c,4 d e} \times2/3{[f8 g a]} \times2/3{b16 c d} c8 |
- \property Voice.tupletVisibility = 4
- \times2/3{c,4 d e} \times2/3{[f8 g a]} \times2/3{b16 c d} c8 |
-
- }
- \paper { }
- \midi { }
-}
\ No newline at end of file
+ \context Voice \notes\relative c'' {
+
+ \times 2/3 { [c8 c c] }
+ \times 2/3 { c8 [c c] }
+
+ \property Voice .tupletBracketVisibility = #'if-no-beam
+ \times 2/3 { [c8 c c] }
+ \property Voice .tupletDirection = #1
+ \property Voice .tupletNumberVisibility = ##f
+ \times 2/3 { c8 [c c] }
+}
+}
* less hairy code
* move paper vars to scm
-
remove *-hs variables.
-
*/
-#include <math.h> // tanh.
+#include <math.h> // tanh.
#include "directional-element-interface.hh"
#include "beaming.hh"
#include "dimensions.hh"
void
flip (Array<Offset>* arr_p, Axis a)
{
- // huh?
- // for (int i = c.size (); i--;)
for (int i = 0; i < arr_p->size (); i++)
(*arr_p)[i][a] = - (*arr_p)[i][a];
}
TODO: --> see breathing-sign-engraver.cc
*/
+
#include "staff-symbol-referencer.hh"
#include "directional-element-interface.hh"
-
#include "breathing-sign.hh"
#include "string.hh"
#include "molecule.hh"
Staff_symbol_referencer_interface si (this);
Real space = si.staff_space();
+
+ // todo: cfg'able.
Interval i1(0, space / 6), i2(-space / 2, space / 2);
Box b(i1, i2);
"text"
("style" . "text")
*/
+
+/*
+ UGH. remove Dictionary< > and use Scheme_hash_table
+ */
Molecule
Chord_name::ly_word2molecule (SCM word) const
{
- Dictionary<SCM> option_dict;
+ Dictionary<SCM> option_dict; // junkme
if (gh_pair_p (word))
{
SCM options = gh_cdr (word);
#include "clef-item.hh"
#include "string.hh"
#include "molecule.hh"
-#include "paper-def.hh"
-#include "lookup.hh"
#include "text-item.hh"
-#include "paper-score.hh"
-#include "dimension-cache.hh"
-#include "side-position-interface.hh"
-#include "warn.hh"
-#include "line-of-score.hh"
void
Clef_item::before_line_breaking ()
*/
#include "note-column.hh"
-#include "collision-engraver.hh"
#include "collision.hh"
#include "dimension-cache.hh"
+#include "engraver.hh"
+
+class Collision_engraver : public Engraver {
+ Collision* col_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);
+ Collision_engraver();
+};
+
void
Collision_engraver::process_acknowledged ()
{
-
if (col_p_ || note_column_l_arr_.size () < 2)
- return ;
+ return ;
if (!col_p_)
{
col_p_ = new Collision;
add_dependency (ncol_l);
}
-/*
- UGH. junk Shift_tup .
- */
-
void
Collision::before_line_breaking ()
{
- Array<Shift_tup> autos (automatic_shift ());
- Array<Shift_tup> hand (forced_shift ());
+ SCM autos (automatic_shift ());
+ SCM hand (forced_shift ());
Link_array<Score_element> done;
Real wid = paper_l ()->get_var ("collision_note_width");
- for (int i=0; i < hand.size (); i++)
+ for (; gh_pair_p (hand); hand =gh_cdr (hand))
{
- hand[i].e1_->translate_axis (hand[i].e2_ *wid, X_AXIS);
- done.push (hand[i].e1_);
+ Score_element * s = unsmob_element (gh_caar (hand));
+ Real amount = gh_scm2double (gh_cdar (hand));
+
+ s->translate_axis (amount *wid, X_AXIS);
+ done.push (s);
}
-
- for (int i=0; i < autos.size (); i++)
+ for (; gh_pair_p (autos); autos =gh_cdr (autos))
{
- if (!done.find_l (autos[i].e1_))
- autos[i].e1_->translate_axis (autos[i].e2_ * wid, X_AXIS);
+ Score_element * s = unsmob_element (gh_caar (autos));
+ Real amount = gh_scm2double (gh_cdar (autos));
+
+ if (!done.find_l (s))
+ s->translate_axis (amount * wid, X_AXIS);
}
}
This should be done better, probably.
*/
-Array< Shift_tup >
+SCM
Collision::automatic_shift ()
{
Drul_array<Link_array<Note_column> > clash_groups;
Drul_array<Array<int> > shifts;
- Array<Shift_tup> tups;
-
+ SCM tups = SCM_EOL;
SCM s = get_elt_property ("elements");
for (; gh_pair_p (s); s = gh_cdr (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 = cd_l->head_positions_interval ()[BIGGER];
+ int uppos = cu_l->head_positions_interval ()[SMALLER];
bool merge =
downpos == uppos
do
{
for (int i=0; i < clash_groups[d].size (); i++)
- tups.push (Shift_tup (clash_groups[d][i], offsets[d][i]));
+ tups = gh_cons (gh_cons (clash_groups[d][i]->self_scm_, gh_double2scm (offsets[d][i])),
+ tups);
}
while (flip (&d) != UP);
return tups;
}
-Array <Shift_tup>
+SCM
Collision::forced_shift ()
{
- Array<Shift_tup> tups;
+ SCM tups = SCM_EOL;
SCM s = get_elt_property ("elements");
for (; gh_pair_p (s); s = gh_cdr (s))
SCM force = se->remove_elt_property ("force-hshift");
if (gh_number_p (force))
{
- tups. push (Shift_tup (se, gh_scm2double (force)));
+ tups = gh_cons (gh_cons (se->self_scm_, force),
+ tups);
}
}
return tups;
#define COLLISION_HH
#include "lily-proto.hh"
#include "item.hh"
-#include "tuple.hh"
-//junkme, use SCM conses.
-typedef Tuple<Score_element*, Real> Shift_tup;
/**
Resolve conflicts between various Note_columns (chords).
class Collision : public Item
{
protected:
- Array<Shift_tup> automatic_shift ();
- Array<Shift_tup> forced_shift ();
+ SCM automatic_shift ();
+ SCM forced_shift ();
virtual void before_line_breaking ();
public:
}\
-
+/*
+ should include equal_p ?
+ */
#define IMPLEMENT_SMOBS(CL)\
long CL::smob_tag_;\
static scm_smobfuns CL ## _funs = { \
--- /dev/null
+/*
+ score-element-callback.hh -- declare Score_element callbacks
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#ifndef SCORE_ELEMENT_CALLBACK_HH
+#define SCORE_ELEMENT_CALLBACK_HH
+
+#include "lily-proto.hh"
+#include "lily-guile.hh"
+
+typedef SCM (* Score_element_callback) (Score_element * , SCM extra_params);
+SCM smobify_callback (Score_element_callback cb);
+
+
+#endif /* SCORE_ELEMENT_CALLBACK_HH */
+
*/
void calculate_dependencies (int final, int busy, Score_element_method_pointer funcptr);
+
static SCM handle_broken_smobs (SCM, SCM criterion);
void recurse_into_smobs (SCM s, void (Score_element::*meth_ptr)());
bool used_b_;
char const * name () const;
- /**
- Set empty in direction A.
- JUNKME
- */
- void set_empty (Axis a);
+
bool empty_b (Axis a) const;
Interval extent (Axis) const;
--- /dev/null
+/*
+ sustain-pedal.hh -- declare
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#ifndef SUSTAIN_PEDAL_HH
+#define SUSTAIN_PEDAL_HH
+
+#include "item.hh"
+
+
+/*
+ Urg.
+ This is almost text
+ Problem is:
+ * we have no kerning
+ * symbols are at wrong place in font
+
+
+
+ Properties:
+
+ glyph -- text string (TODO: make one large glyph of the Ped symbol, removes need for do_brew_molecule ())
+
+*/
+
+class Sustain_pedal : public Item
+{
+public:
+ VIRTUAL_COPY_CONS (Score_element);
+
+protected:
+ virtual Molecule do_brew_molecule () const;
+ virtual void after_line_breaking ();
+};
+
+
+#endif /* SUSTAIN_PEDAL_HH */
+
set_elt_property ("note-heads", SCM_EOL);
Axis_group_interface (this).set_interface ();
Axis_group_interface (this).set_axes (X_AXIS, Y_AXIS);
+ Group_interface (this, "interfaces").add_thing (ly_symbol2scm ("Note_column"));
}
Stem *
#include "stem.hh"
#include "side-position-interface.hh"
#include "staff-symbol-referencer.hh"
-#include "dictionary.hh"
-#include "dictionary-iter.hh"
#include "text-item.hh"
-
-/*
- Urg.
- This is almost text
- Problem is:
- * we have no kerning
- * symbols are at wrong place in font
-*/
-
-class Sustain_pedal : public Item
-{
-public:
- VIRTUAL_COPY_CONS (Score_element);
-
-protected:
- virtual Molecule do_brew_molecule () const;
- virtual void after_line_breaking ();
-};
-
-void
-Sustain_pedal::after_line_breaking ()
-{
- Side_position_interface i (this);
- Direction d = i.get_direction ();
- i.set_direction (d);
-}
-
-Molecule
-Sustain_pedal::do_brew_molecule () const
-{
- Molecule mol;
- SCM glyph = get_elt_property ("glyph");
- if (glyph == SCM_UNDEFINED)
- return mol;
- String text = ly_scm2string (glyph);
-
- for (int i = 0; i < text.length_i (); i++)
- {
- // leuke koor dump door tiepo, snapnie helemaal:
- //String idx = ("pedal-") + text[i];
- // urg, Byte* ??
- // braak: waarom vindt String het zo moeilijk om
- // String + char te doen?
- //String idx = "pedal-" + String (&text.byte_C ()[i], 1);
- String idx = String ("pedal-") + String (&text.byte_C ()[i], 1);
- Molecule m = lookup_l ()->afm_find (idx);
- if (m.empty_b ())
- continue;
- Real kern = 0;
- if (i)
- {
- SCM s = scm_eval (gh_list (ly_symbol2scm ("pedal-kerning"),
- ly_str02scm (String (&text.byte_C ()[i - 1], 1).ch_C ()),
- ly_str02scm (String (&text.byte_C ()[i], 1).ch_C ()),
- SCM_UNDEFINED));
- if (gh_number_p (s))
- {
- Staff_symbol_referencer_interface st (this);
- Real staff_space = st.staff_space ();
- kern = gh_scm2double (s) * staff_space;
- }
- }
- mol.add_at_edge (X_AXIS, RIGHT, m, kern);
- }
-
- return mol;
-}
-
-
+#include "sustain-pedal.hh"
/*
TODO:
- * it would be real cool if an engraver could be initialised with a
+ * it would be really cool if an engraver could be initialised with a
string, ie:
Piano_pedal_engraver::"sostenuto"
Piano_pedal_engraver::"sustain"
Piano_pedal_engraver::"una-chorda"
+
*/
+/*
+ Would it? The semantics are unclear, and real benefits are muddy
+ too. --hwn
+*/
+
+
+
/**
- engrave Piano pedals
+ engrave Piano pedals symbols.
*/
class Piano_pedal_engraver : public Engraver
{
- struct Pedal_info
- {
- Span_req* start_req_l_;
- Drul_array<Span_req*> req_l_drul_;
- Item* item_p_;
- };
-
public:
VIRTUAL_COPY_CONS (Translator);
Piano_pedal_engraver ();
-
+ ~Piano_pedal_engraver ();
protected:
+ virtual void do_creation_processing ();
virtual bool do_try_music (Music*);
virtual void do_process_music ();
virtual void do_pre_move_processing ();
virtual void acknowledge_element (Score_element_info);
private:
- Dictionary<Pedal_info> info_dict_;
+ struct Pedal_info
+ {
+ char const * name_;
+ Span_req* start_req_l_;
+ Drul_array<Span_req*> req_l_drul_;
+ Item* item_p_;
+ };
+
+
+ Pedal_info *info_list_;
};
ADD_THIS_TRANSLATOR (Piano_pedal_engraver);
Piano_pedal_engraver::Piano_pedal_engraver ()
{
- (void)info_dict_["Sostenuto"];
- (void)info_dict_["Sustain"];
- (void)info_dict_["UnaChorda"];
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ info_list_ = 0;
+}
+void
+Piano_pedal_engraver::do_creation_processing()
+{
+ info_list_ = new Pedal_info[4];
+ Pedal_info *p = info_list_;
+
+
+ char * names [] = { "Sostenuto", "Sustain", "UnaChorda", 0 };
+ char **np = names ;
+ do
{
- Pedal_info& p = i.val_ref ();
- p.item_p_ = 0;
- p.req_l_drul_[START] = 0;
- p.req_l_drul_[STOP] = 0;
- p.start_req_l_ = 0;
+ p->name_ = *np;
+ p->item_p_ = 0;
+ p->req_l_drul_[START] = 0;
+ p->req_l_drul_[STOP] = 0;
+ p->start_req_l_ = 0;
+
+ p++;
}
+ while (*(np ++));
+}
+
+Piano_pedal_engraver::~Piano_pedal_engraver()
+{
+ delete[] info_list_;
}
/*
void
Piano_pedal_engraver::acknowledge_element (Score_element_info info)
{
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ for (Pedal_info*p = info_list_; p->name_; p ++)
{
- Pedal_info& p = i.val_ref ();
- if (p.item_p_)
+ if (p->item_p_)
{
if (Note_head* n = dynamic_cast<Note_head*> (info.elem_l_))
{
- Side_position_interface st (p.item_p_);
+ Side_position_interface st (p->item_p_);
st.add_support (n);
if (st.get_axis( ) == X_AXIS
- && !p.item_p_->parent_l (Y_AXIS))
- p.item_p_->set_parent (n, Y_AXIS);
+ && !p->item_p_->parent_l (Y_AXIS))
+ p->item_p_->set_parent (n, Y_AXIS);
}
if (Stem* s = dynamic_cast<Stem*> (info.elem_l_))
{
- Side_position_interface st (p.item_p_);
+ Side_position_interface st (p->item_p_);
st.add_support (s);
}
}
bool
Piano_pedal_engraver::do_try_music (Music *m)
{
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ if (Span_req * s = dynamic_cast<Span_req*>(m))
{
- Pedal_info& p = i.val_ref ();
- if (Span_req * s = dynamic_cast<Span_req*>(m))
+ for (Pedal_info*p = info_list_; p->name_; p ++)
{
- if (s->span_type_str_ == i.key ())
+ if (s->span_type_str_ == p->name_)
{
- p.req_l_drul_[s->span_dir_] = s;
+ p->req_l_drul_[s->span_dir_] = s;
return true;
}
}
void
Piano_pedal_engraver::do_process_music ()
{
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ for (Pedal_info*p = info_list_; p->name_; p ++)
{
- Pedal_info& p = i.val_ref ();
SCM s = SCM_UNDEFINED;
- if (p.req_l_drul_[STOP] && p.req_l_drul_[START])
+ if (p->req_l_drul_[STOP] && p->req_l_drul_[START])
{
- if (!p.start_req_l_)
+ if (!p->start_req_l_)
{
- p.req_l_drul_[STOP]->warning (_f ("can't find start of piano pedal: %s", i.key ()));
+ p->req_l_drul_[STOP]->warning (_f ("can't find start of piano pedal: %s", p->name_ ));
}
else
{
- s = get_property ("stopStart" + i.key ());
+ s = get_property ("stopStart" + String (p->name_ ));
}
- p.start_req_l_ = p.req_l_drul_[START];
+ p->start_req_l_ = p->req_l_drul_[START];
}
- else if (p.req_l_drul_[STOP])
+ else if (p->req_l_drul_[STOP])
{
- if (!p.start_req_l_)
+ if (!p->start_req_l_)
{
- p.req_l_drul_[STOP]->warning (_f ("can't find start of piano pedal: %s", i.key ()));
+ p->req_l_drul_[STOP]->warning (_f ("can't find start of piano pedal: %s", p->name_ ));
}
else
{
- s = get_property ("stop" + i.key ());
+ s = get_property ("stop" + String (p->name_ ));
}
- p.start_req_l_ = 0;
+ p->start_req_l_ = 0;
}
- else if (p.req_l_drul_[START])
+ else if (p->req_l_drul_[START])
{
- p.start_req_l_ = p.req_l_drul_[START];
- s = get_property ("start" + i.key ());
+ p->start_req_l_ = p->req_l_drul_[START];
+ s = get_property ("start" + String (p->name_ ));
}
if (s != SCM_UNDEFINED)
{
- if (i.key () == "Sustain")
+ if (p->name_ == String ("Sustain"))
{
- p.item_p_ = new Sustain_pedal;
- p.item_p_->set_elt_property ("glyph", s);
+ p->item_p_ = new Sustain_pedal;
+ p->item_p_->set_elt_property ("text", s);
}
else
{
- p.item_p_ = new Text_item;
- p.item_p_->set_elt_property ("text", s);
+ p->item_p_ = new Text_item;
+ p->item_p_->set_elt_property ("text", s);
// guh
- p.item_p_->set_elt_property ("style", ly_str02scm ("italic"));
+ p->item_p_->set_elt_property ("style", ly_str02scm ("italic"));
}
- Side_position_interface si (p.item_p_);
+ Side_position_interface si (p->item_p_);
si.set_axis (Y_AXIS);
- /* Hmm,
- If set to empty, it can't be centred
- Howto centre non-fat text?
- p.item_p_->set_empty (X_AXIS);
- */
- p.item_p_->set_elt_property ("self-alignment-X", gh_int2scm (0));
- p.item_p_->add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS);
- p.item_p_->add_offset_callback (Side_position_interface::centered_on_parent, X_AXIS);
- announce_element (Score_element_info (p.item_p_,
- p.req_l_drul_[START]
- ? p.req_l_drul_[START]
- : p.req_l_drul_[STOP]));
+ p->item_p_->set_elt_property ("no-spacing-rods" , SCM_BOOL_T);
+ p->item_p_->set_elt_property ("self-alignment-X", gh_int2scm (0));
+ p->item_p_->add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS);
+ p->item_p_->add_offset_callback (Side_position_interface::centered_on_parent, X_AXIS);
+ announce_element (Score_element_info (p->item_p_,
+ p->req_l_drul_[START]
+ ? p->req_l_drul_[START]
+ : p->req_l_drul_[STOP]));
}
}
}
void
Piano_pedal_engraver::do_pre_move_processing ()
{
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ Item * sustain = 0;
+ for (Pedal_info*p = info_list_; p->name_; p ++)
+ {
+ if (p->name_ == String ("Sustain"))
+ sustain = p->item_p_;
+ }
+
+ for (Pedal_info*p = info_list_; p->name_; p ++)
{
- Pedal_info& p = i.val_ref ();
- if (p.item_p_)
+ if (p->item_p_)
{
- side_position (p.item_p_).add_staff_support ();
+ side_position (p->item_p_).add_staff_support ();
/*
Hmm.
*/
- if (i.key () != "Sustain")
+ if (p->name_ != String ("Sustain"))
{
- if (Item* sustain = info_dict_["Sustain"].item_p_)
+ if (sustain)
{
- Side_position_interface st (p.item_p_);
+ Side_position_interface st (p->item_p_);
st.add_support (sustain);
}
}
- typeset_element (p.item_p_);
+ typeset_element (p->item_p_);
}
- p.item_p_ = 0;
+ p->item_p_ = 0;
}
}
void
Piano_pedal_engraver::do_post_move_processing ()
{
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ for (Pedal_info*p = info_list_; p->name_; p ++)
{
- Pedal_info& p = i.val_ref ();
- p.req_l_drul_[STOP] = 0;
- p.req_l_drul_[START] = 0;
+ p->req_l_drul_[STOP] = 0;
+ p->req_l_drul_[START] = 0;
}
}
{
struct Pedal_info
{
+ char const *name_;
Span_req* start_req_l_;
Drul_array<Span_req*> req_l_drul_;
};
public:
VIRTUAL_COPY_CONS (Translator);
-
Piano_pedal_performer ();
-
+ ~Piano_pedal_performer ();
+
protected:
+ virtual void do_creation_processing ();
virtual bool do_try_music (Music*);
virtual void do_process_music ();
virtual void do_pre_move_processing ();
private:
Link_array<Audio_piano_pedal> audio_p_arr_;
- Dictionary<Pedal_info> info_dict_;
+ Pedal_info * info_alist_;
};
ADD_THIS_TRANSLATOR (Piano_pedal_performer);
Piano_pedal_performer::Piano_pedal_performer ()
{
- (void)info_dict_["Sostenuto"];
- (void)info_dict_["Sustain"];
- (void)info_dict_["UnaChorda"];
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ info_alist_ = 0;
+}
+
+Piano_pedal_performer::~Piano_pedal_performer()
+{
+ delete[] info_alist_;
+}
+
+void
+Piano_pedal_performer::do_creation_processing ()
+{
+ info_alist_ = new Pedal_info[4];
+ Pedal_info *p = info_alist_;
+
+ char * names [] = { "Sostenuto", "Sustain", "UnaChorda", 0 };
+ char **np = names ;
+ do
{
- Pedal_info& p = i.val_ref ();
- p.req_l_drul_[START] = 0;
- p.req_l_drul_[STOP] = 0;
- p.start_req_l_ = 0;
+ p->name_ = *np;
+ p->req_l_drul_[START] = 0;
+ p->req_l_drul_[STOP] = 0;
+ p->start_req_l_ = 0;
+
+ p++;
}
+ while (*(np ++));
}
void
Piano_pedal_performer::do_process_music ()
{
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ for (Pedal_info*p = info_alist_; p->name_; p ++)
+
{
- Pedal_info& p = i.val_ref ();
- if (p.req_l_drul_[STOP])
+ if (p->req_l_drul_[STOP])
{
- if (!p.start_req_l_)
+ if (!p->start_req_l_)
{
- p.req_l_drul_[STOP]->warning (_f ("can't find start of piano pedal: %s", i.key ()));
+ p->req_l_drul_[STOP]->warning (_f ("can't find start of piano pedal: %s", String (p->name_)));
}
else
{
Audio_piano_pedal* a = new Audio_piano_pedal;
- a->type_str_ = i.key ();
+ a->type_str_ = String (p->name_);
a->dir_ = STOP;
audio_p_arr_.push (a);
}
- p.start_req_l_ = 0;
+ p->start_req_l_ = 0;
}
- if (p.req_l_drul_[START])
+ if (p->req_l_drul_[START])
{
- p.start_req_l_ = p.req_l_drul_[START];
+ p->start_req_l_ = p->req_l_drul_[START];
Audio_piano_pedal* a = new Audio_piano_pedal;
- a->type_str_ = i.key ();
+ a->type_str_ = String (p->name_);
a->dir_ = START;
audio_p_arr_.push (a);
}
void
Piano_pedal_performer::do_pre_move_processing ()
{
- for (int i=0; i < audio_p_arr_.size (); i++)
+ for (int i=0; i< audio_p_arr_.size (); i++)
play_element (audio_p_arr_[i]);
audio_p_arr_.clear ();
}
void
Piano_pedal_performer::do_post_move_processing ()
{
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ for (Pedal_info*p = info_alist_; p->name_; p ++)
{
- Pedal_info& p = i.val_ref ();
- p.req_l_drul_[STOP] = 0;
- p.req_l_drul_[START] = 0;
+ p->req_l_drul_[STOP] = 0;
+ p->req_l_drul_[START] = 0;
}
}
bool
Piano_pedal_performer::do_try_music (Music* r)
{
- for (Dictionary_iter <Pedal_info> i (info_dict_); i.ok (); i++)
+ if (Span_req * s = dynamic_cast<Span_req*>(r))
{
- Pedal_info& p = i.val_ref ();
- if (Span_req * s = dynamic_cast<Span_req*>(r))
+ for (Pedal_info*p = info_alist_; p->name_; p ++)
{
- if (s->span_type_str_ == i.key ())
+ if (s->span_type_str_ == String (p->name_))
{
- p.req_l_drul_[s->span_dir_] = s;
+ p->req_l_drul_[s->span_dir_] = s;
return true;
}
}
#include "protected-scm.hh"
#include "dictionary.hh"
#include "score-element.hh"
+#include "scm-hash.hh"
class Property_engraver : public Engraver
{
- Dictionary<Protected_scm> prop_dict_;
+ /*
+ UGH. Junk Dictionary
+ */
+ Scheme_hash_table prop_dict_; // junkme
void apply_properties (SCM, Score_element*);
protected:
Property_engraver::do_creation_processing ()
{
SCM plist = get_property ("Generic_property_list");
- for (; SCM_NIMP (plist); plist = gh_cdr (plist))
+ for (; gh_pair_p (plist); plist = gh_cdr (plist))
{
SCM elt_props = gh_car (plist);
- prop_dict_[ly_scm2string (gh_car (elt_props))] = gh_cdr (elt_props);
+ prop_dict_.set (gh_car (elt_props), gh_cdr (elt_props));
}
}
void
Property_engraver::acknowledge_element (Score_element_info i)
{
- if (prop_dict_.elem_b (i.elem_l_->name()))
- {
- SCM p = prop_dict_[i.elem_l_->name()];
- apply_properties (p,i.elem_l_);
+ SCM ifs = i.elem_l_->get_elt_property ("interfaces");
+ SCM props;
+ for (; gh_pair_p (ifs); ifs = gh_cdr (ifs))
+ {
+ if (prop_dict_.try_retrieve (gh_car (ifs), &props))
+ {
+ apply_properties (props,i.elem_l_);
+ }
}
- if (prop_dict_.elem_b ("all"))
+
+ if (prop_dict_.try_retrieve (ly_symbol2scm ("all"), &props))
{
- apply_properties (prop_dict_["all"], i.elem_l_);
+ apply_properties (props, i.elem_l_);
}
}
== SCM_BOOL_T) // defined and right type: do it
e->set_elt_property (ly_symbol2string (elt_prop_sym), val);
else
- /*
+
+ /*
we don't print a warning if VAL == #f, because we would
get lots of warnings when we restore stuff to default, eg.
should not cause "type error: slurDash expects number not
boolean"
- */
+ */
if (val != SCM_BOOL_F)
- { // not the right type: error message.
- SCM errport = scm_current_error_port ();
- warning (_("Wrong type for property"));
- scm_display (prop_sym, errport);
- scm_puts (", type predicate: ", errport);
- scm_display (type_p, errport);
- scm_puts (", value found: ", errport);
- scm_display (val, errport);
- scm_puts (" type: ", errport);
- scm_display (ly_type (val), errport);
- scm_puts ("\n", errport);
- }
+ { // not the right type: error message.
+ SCM errport = scm_current_error_port ();
+ warning (_("Wrong type for property"));
+ scm_display (prop_sym, errport);
+ scm_puts (", type predicate: ", errport);
+ scm_display (type_p, errport);
+ scm_puts (", value found: ", errport);
+ scm_display (val, errport);
+ scm_puts (" type: ", errport);
+ scm_display (ly_type (val), errport);
+ scm_puts ("\n", errport);
+ }
}
}
repeats_i_ = s.repeats_i_;
fold_b_ = s.fold_b_;
volta_fold_b_ = s.volta_fold_b_;
-
+ type_ = s.type_;
repeat_body_p_ = s.repeat_body_p_ ? s.repeat_body_p_->clone () : 0;
alternatives_p_ = s.alternatives_p_
? dynamic_cast<Music_sequence*> (s.alternatives_p_->clone ()):0;
--- /dev/null
+/*
+ score-element-callback.cc -- implement Callback smob.
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#include "score-element-callback.hh"
+
+
+static long callback_tag;
+
+static
+SCM mark_smob (SCM)
+{
+ return SCM_EOL;
+}
+
+static int
+print_smob (SCM, SCM port, scm_print_state *)
+{
+ scm_puts ("#<Callback>", port);
+ return 1;
+}
+
+static
+scm_sizet free_smob (SCM)
+{
+ return 0;
+}
+
+static scm_smobfuns callback_funs = {
+ mark_smob, free_smob,
+ print_smob, 0,
+};
+
+static
+void start_callback_smobs()
+{
+ callback_tag = scm_newsmob (&callback_funs);
+}
+
+
+SCM
+smobify_callback (Score_element_callback cb )
+{
+ SCM z;
+
+ SCM_NEWCELL(z);
+ SCM_SETCDR(z, cb);
+ SCM_SETCAR(z, callback_tag);
+
+ return z;
+}
+
+ADD_SCM_INIT_FUNC(callback, start_callback_smobs);
return;
status_i_ ++;
-#if 0
- /*
- UGH. UGH. UGH.
- */
- if (get_elt_property ("self-alignment-X") != SCM_UNDEFINED
- && !dim_cache_[X_AXIS]->off_callback_l_)
- {
- add_offset_callback (Side_position_interface::aligned_on_self,X_AXIS);
- }
-
- if (get_elt_property ("self-alignment-Y") != SCM_UNDEFINED
- && !dim_cache_[X_AXIS]->off_callback_l_)
-
- {
- add_offset_callback (Side_position_interface::aligned_on_self, Y_AXIS);
- }
-#endif
-
do_add_processing();
}
continue; /*UGH UGH*/
}
+ if (to_boolean (il->get_elt_property ("no-spacing-rods")))
+ {
+ continue;
+ }
+
Interval iv (il->extent (X_AXIS));
if (!iv.empty_b ())
{
set_elt_property ("note-columns", SCM_EOL);
set_elt_property ("control-points", SCM_EOL);
-
-#if 0
- /*
- I still don't understand the merits of this Group_interface.
- */
- Group_interface c (this, "control-points");
- c.set_interface ();
-#endif
}
void
warning (_ ("Putting slur over rest. Ignoring."));
else
{
- Group_interface gi (this, "note-columns");
- gi.add_element (n);
+ Group_interface (this, "note-columns").add_element (n);
add_dependency (n);
}
}
spanbar_p_->set_parent (bar_l_arr_[0], Y_AXIS);
spanbar_p_->set_parent (bar_l_arr_[0], X_AXIS);
- /*
- UGH. UGH UUHGK GUHG G
- */
- String visnam = String(name()) + "-visibility";
-
- spanbar_p_->set_elt_property ("visibility-lambda",
- scm_eval (ly_symbol2scm (visnam.ch_C())));
+ SCM v = bar_l_arr_[0]->get_elt_property ("visibility-lambda");
+ if (gh_procedure_p (v))
+ spanbar_p_->set_elt_property ("visibility-lambda",v);
spanbar_p_->set_parent (bar_l_arr_[0], X_AXIS);
announce_element (Score_element_info (spanbar_p_,0));
--- /dev/null
+/*
+ sustain-pedal.cc -- implement Sustain_pedal
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#include "sustain-pedal.hh"
+#include "side-position-interface.hh"
+#include "molecule.hh"
+#include "lookup.hh"
+#include "staff-symbol-referencer.hh"
+
+void
+Sustain_pedal::after_line_breaking ()
+{
+ /*
+ UGH. Should work automatically via offset callback.
+ */
+ Side_position_interface i (this);
+ Direction d = i.get_direction ();
+ i.set_direction (d);
+}
+
+Molecule
+Sustain_pedal::do_brew_molecule () const
+{
+ Molecule mol;
+ SCM glyph = get_elt_property ("text");
+ if (glyph == SCM_UNDEFINED)
+ return mol;
+ String text = ly_scm2string (glyph);
+
+ for (int i = 0; i < text.length_i (); i++)
+ {
+ String idx = String ("pedal-") + String (&text.byte_C ()[i], 1);
+ Molecule m = lookup_l ()->afm_find (idx);
+ if (m.empty_b ())
+ continue;
+ Real kern = 0;
+ if (i)
+ {
+ SCM s = scm_eval (gh_list (ly_symbol2scm ("pedal-kerning"),
+ ly_str02scm (String (&text.byte_C ()[i - 1], 1).ch_C ()),
+ ly_str02scm (String (&text.byte_C ()[i], 1).ch_C ()),
+ SCM_UNDEFINED));
+ if (gh_number_p (s))
+ {
+ Staff_symbol_referencer_interface st (this);
+ Real staff_space = st.staff_space ();
+ kern = gh_scm2double (s) * staff_space;
+ }
+ }
+ mol.add_at_edge (X_AXIS, RIGHT, m, kern);
+ }
+
+ return mol;
+}
+
+
SCM empty = get_property ("textNonEmpty");
if (!to_boolean (empty))
- text->set_extent_callback (0, X_AXIS);
-
+ {
+ text->set_elt_property ("no-spacing-rods" , SCM_BOOL_T);
+ text->set_extent_callback (0, X_AXIS);
+ }
announce_element (Score_element_info (text, r));
texts_.push (text);
}
should delete these after exit.
*/
+/*
+ UGH. Dictionary is deprecated
+ */
Dictionary<Translator*> *global_translator_dict_p=0;
void
;
; Format:
-; (cons "Type name"
+; (cons 'Type name
; (list PROPERTYDESCRIPTIONS))
;
; where
(define generic-beam-properties
- (cons "Beam"
+ (cons 'Beam
(list
(list 'beamSlopeDamping number? 'damping)
(list 'autoKneeGap number? 'auto-knee-gap)
(define generic-stem-properties
- (cons "Stem"
+ (cons 'Stem
(list
(list 'stemVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
)
(define generic-dot-properties
- (cons "Dots" (list
+ (cons 'Dots
+ (list
(list 'dotDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
)
))
(define generic-script-properties
- (cons "Script" (list
+ (cons 'Script (list
(list 'articulationScriptVerticalDirection dir? 'direction)
(list 'articulationScriptPadding number? 'padding)
(define generic-text-properties
- (cons "Text_item" (list
+ (cons 'Text_item (list
(list 'textStyle string? 'style)
(list 'textScriptPadding number? 'padding)
(list 'textVerticalAlignment dir? 'self-alignment-Y)
))
(define generic-sustain-pedal-properties
- (cons "Sustain_pedal" (list
+ (cons 'Sustain_pedal (list
(list 'textScriptPadding number? 'padding)
(list 'sustainPedalPadding number? 'padding))))
(define generic-chord-name-properties
- (cons "Chord_name" (list
+ (cons 'Chord_name (list
(list 'textScriptWordSpace number? 'word-space)
(list 'chordNameWordSpace number? 'word-space)
(list 'chordNameStyle string? 'style))))
(define generic-crescendo-properties
- (cons "Crescendo" (list
+ (cons 'Crescendo (list
(list 'dynamicDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
(list 'dynamicPadding number? 'padding)
)))
(define generic-dynamic-line-spanner-properties
- (cons "Dynamic_line_spanner" (list
+ (cons 'Dynamic_line_spanner (list
(list 'dynamicDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
(list 'dynamicPadding number? 'padding)
)))
(define generic-volta-spanner-properties
- (cons "Volta_spanner" (list
+ (cons 'Volta_spanner (list
(list 'voltaVerticalDirection dir? 'direction)
(list 'voltaPadding number? 'padding)
(list 'voltaMinimumSpace number? 'minimum-space)
)))
(define generic-bar-properties
- (cons "Staff_bar" (list
+ (cons 'Staff_bar (list
(list 'barSize number? 'bar-size))
)
)
; don't do this yet. Depends on whennn the staff is really announced
(define generic-staff-symbol-properties
- (cons "Staff_symbol" (list
+ (cons 'Staff_symbol (list
)
)
)
(define generic-breathing-sign-properties
- (cons "Breathing_sign"
+ (cons 'Breathing_sign
(list
(list 'breathingSignVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
)))
(define generic-clef-properties
- (cons "Clef_item"
+ (cons 'Clef_item
(list
(list 'clefStyle string? 'style))
)
)
(define generic-All-properties
- (cons "all" (list (list 'fontSize number? 'fontsize))))
+ (cons 'all (list (list 'fontSize number? 'fontsize))))
(define generic-notehead-properties
- (cons "Note_head" (list (list 'noteHeadStyle symbol? 'style))))
+ (cons 'Note_head
+ (list (list 'noteHeadStyle symbol? 'style))))
(define generic-rest-properties
- (cons "Rest" (list (list 'restStyle string? 'reststyle))))
+ (cons 'Rest
+ (list (list 'restStyle string? 'reststyle))))
(define generic-rest-collision-properties
- (cons "Rest_collision" (list (list 'maximumRestCount number? 'maximum-rest-count))))
+ (cons 'Rest_collision
+ (list (list 'maximumRestCount number? 'maximum-rest-count))))
(define generic-tie-properties
- (cons "Tie" (list
+ (cons 'Tie (list
(list 'tieVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
(list 'tieDash number? 'dashed)
)))
(define generic-tie-column-properties
- (cons "Tie_column" (list
+ (cons 'Tie_column (list
(list 'tieVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
)))
(define generic-note-column-properties
- (cons "Note_column"
+ (cons 'Note_column
(list
(list 'horizontalNoteShift number? 'horizontal-shift)
(list 'forceHorizontalShift number? 'force-hshift)
)))
(define generic-collision-properties
- (cons "Collision"
+ (cons 'Collision
(list
(list 'collisionMergeDotted boolean? 'merge-differently-dotted)
)
)
(define generic-slur-properties
- (cons "Slur"
+ (cons 'Slur
(list
(list 'slurVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
(list 'slurDash number? 'dashed))))
(define generic-timesig-properties
- (cons "Time_signature"
+ (cons 'Time_signature
(list
(list 'timeSignatureStyle string? 'style))))
(or (boolean? s) (symbol? s)))
(define generic-tuplet-spanner-properties
- (cons "Tuplet_spanner"
+ (cons 'Tuplet_spanner
(list
+ (list 'tupletDirection dir? 'direction)
(list 'tupletNumberVisibility symbol-or-boolean? 'tuplet-number-visibility)
(list 'tupletBracketVisibility symbol-or-boolean? 'tuplet-bracket-visibility)
))
;
; This file contains various routines in Scheme that are easier to
-; do here than in C++. At present it is a unorganised mess. Sorry.
+; do here than in C++. At present it is an unorganised mess. Sorry.
;
(define (end-of-line-invisible d) (if (= d -1) '(#t . #t) '(#f . #f)))
-;; Score_span_bars are only visible at start of line
-;; i.e. if break_dir == RIGHT == 1
-(define Span_bar_engraver-visibility begin-of-line-invisible)
(define mark-visibility end-of-line-invisible)
;; Spacing constants for prefatory matter.
(define (scm-as-output)
(eval (as-scm 'all-definitions)))
-
-; Russ McManus, <mcmanus@IDT.NET>
-;
-; I use the following, which should definitely be provided somewhere
-; in guile, but isn't, AFAIK:
-;
-;
-
-(define (hash-table-for-each fn ht)
- (do ((i 0 (+ 1 i)))
- ((= i (vector-length ht)))
- (do ((alist (vector-ref ht i) (cdr alist)))
- ((null? alist) #t)
- (fn (car (car alist)) (cdr (car alist))))))
-
-(define (hash-table-map fn ht)
- (do ((i 0 (+ 1 i))
- (ret-ls '()))
- ((= i (vector-length ht)) (reverse ret-ls))
- (do ((alist (vector-ref ht i) (cdr alist)))
- ((null? alist) #t)
- (set! ret-ls (cons (fn (car (car alist)) (cdr (car alist))) ret-ls)))))
-
-
-
+
(define (index-cell cell dir)
(if (equal? dir 1)
(cdr cell)
)
)
-
-(define (slur-ugly ind ht)
- (if (and
-; (< ht 4.0)
- (< ht (* 4 ind))
- (> ht (* 0.4 ind))
- (> ht (+ (* 2 ind) -4))
- (< ht (+ (* -2 ind) 8)))
- #f
- (cons ind ht)
- ))
# BUG: does not handle \verb|\begin{verbatim}\end{verbatim}| correctly.
# Should make a joint RE for \verb and \begin, \end{verbatim}
+
+# TODO: add an option to read the .ly files from a previous run and dump
+# the .tex file, so you can do
+#
+# * mudela-book file.tex
+# * convert-mudela *.ly
+# * mudela-book --read-lys *.ly
#
default_music_fontsize = 16
projects / lilypond.git / commitdiff