#!@PYTHON@
+
+# (urg! wat een pokkeformaat (pokkenformaat?))
+
import string
+import sys
+import re
+
+fn = sys.argv[1]
-ls = open ('barsant.pmx').readlines ()
+ls = open (fn).readlines ()
def stripcomment (l):
- return re.sub ('^%.*$', '', l)
+ return re.sub ('[ \t]*%.*$\n', '', l)
+
+def stripwhite (l):
+ return re.sub ('[ \n\t]+', ' ', l)
+
+def stripeols (l):
+ return re.sub ('^ ', '', re.sub (' $', '', l))
ls = map (stripcomment, ls)
+ls = map (stripwhite, ls)
+ls = map (stripeols, ls)
+
+
ls = filter (lambda x: x <> '', ls)
opening = ls[0]
ls = ls[1:]
+
opening = map (string.atoi, re.split ('[\t ]+', opening))
-(nv,noinst,mtrnuml,mtrdenl,mtrnump,mtrdenp,xmtrnum0,isig) = tuple (opening)
+
+(no_staffs, no_instruments, timesig_num,timesig_den, ptimesig_num,
+ ptimesig_den, pickup_beats,keysig_number) = tuple (opening)
opening = ls[0]
ls = ls[1:]
-opening = map (string.atoi, re.split ('[\t ]+', opening))
-(npages,nsyst,musicsize,fracindent) = tuple (opening)
-for l in ls:
- pass
+# ignore this.
+# opening = map (string.atoi, re.split ('[\t ]+', opening))
+# (no_pages,no_systems, musicsize, fracindent) = tuple (opening)
+
+instruments = []
+while len (instruments) < no_instruments:
+ instruments.append (ls[0])
+ ls = ls[1:]
+
+class Staff:
+ def __init__ (self):
+ self.voices = ([],[])
+ self.clef = None
+ self.instrument = 0
+l = ls[0]
+ls = ls[1:]
+
+staffs = map (lambda x: Staff (), range(0, no_staffs))
+staff_idx = 0
+
+for s in staffs:
+ s.clef = l[0]
+ l = l[1:]
+
+# dump path
+ls = ls[1:]
+
+# dump more ?
+ls = ls[2:]
+
+actab = {-2: 'eses', -1: 'es', 0 : '', 1: 'is', 2:'isis'}
+
+def pitch_to_lily_string (tup):
+ (o,n,a) = tup
+
+ nm = chr((n + 2) % 7 + ord ('a'))
+ nm = nm + actab[a]
+ if o > 0:
+ nm = nm + "'" * o
+ elif o < 0:
+ nm = nm + "," * -o
+ return nm
+
+class Chord:
+ def __init__ (self):
+ self.pitches = []
+ self.dots = 0
+ self.basic_duration = 0
+
+ def dump (self):
+ str = ''
+
+ for p in self.pitches:
+ if str:
+ str = str + ' '
+ str = str + pitch_to_lily_string (p)
+
+ if len (self.pitches) > 1:
+ str = '<%s>' % str
+ elif len (self.pitches) == 0:
+ str = 'r'
+
+
+ sd = ''
+ if self.basic_duration == 0.5:
+ sd = '\\breve'
+ else:
+ sd = '%d' % self.basic_duration
+
+ str = str + sd + '.' * self.dots
+ return str
+
+
+input_left = string.join (ls, ' ')
+
+
+input_left = re.sub ('[ \t\n]+', ' ', input_left)
+
+SPACE=' \t\n'
+DIGITS ='0123456789'
+basicdur_table = {
+ 9: 0.5,
+ 0: 0 ,
+ 2: 2 ,
+ 4: 4 ,
+ 8: 8 ,
+ 1: 16,
+ 3: 32,
+ 6: 64
+ }
+
+class Parser:
+ def __init__ (self):
+ self.chords = []
+ self.forced_duration = None
+ self.last_octave = 4
+
+ def parse_note (self, str):
+ ch = Chord ()
+
+ name = None
+ if str[0] <> 'r':
+ name = (ord (str[0]) - ord('a') + 5) % 7
+ str = str[1:]
+
+ forced_duration = 0
+ alteration = 0
+ dots = 0
+ oct = None
+ durdigit = None
+ multibar = 0
+ while str[0] in 'dsfmnul0123456789.,':
+ c = str[0]
+ str = str[1:]
+ if c == 'f':
+ alteration = alteration -1
+ elif c == 'n':
+ alteration = 0
+ elif c == 'm':
+ multibar = 1
+ elif c == 's':
+ alteration = alteration +1
+ elif c == 'd':
+ dots = dots + 1
+ elif c in DIGITS and durdigit == None:
+ durdigit = string.atoi (c)
+ elif c in DIGITS:
+ oct = string.atoi (c) - 4
+ elif c == '.':
+ dots = dots+ 1
+ forced_duration = 2
+ elif c == ',':
+ forced_duration = 2
+
+
+ if durdigit:
+ ch.basic_duration = basicdur_table[durdigit]
+ self.last_basic_duration = ch.basic_duration
+ else:
+ ch.basic_duration = self.last_basic_duration
+
+ if name:
+ if oct:
+ self.last_octave =oct
+ else:
+ oct = self.last_octave
+
+ if name:
+ ch.pitches.append ((oct, name, alteration))
+
+ ch.dots = dots
+
+
+ if forced_duration:
+ self.forced_duration = ch.basic_duration / forced_duration
+
+
+ self.chords.append (ch)
+ while str[0] in SPACE:
+ str = str [1:]
+ return str
+
+
+parser = Parser()
+while input_left:
+ while input_left[0] in 'abcdefgr':
+ input_left = parser.parse_note (input_left)
+ print input_left[0]
+
+ sys.stderr.write ("\nHuh? Unknown directive %s" %input_left[0:1])
+ input_left = input_left[1:]
+
+
+
+for c in parser.chords:
+ print c.dump ()
template<class T>
Cons<T> * last_cons (Cons<T> * head)
{
- while (head->next_)
+ while (head && head->next_)
{
head = head->next_;
}
if (isdir_b (al))
{
Direction d = to_dir (al);
- Directional_element_interface (align_item_p_).set (d);
+ Directional_element_interface::set (align_item_p_,d);
}
typeset_element (align_item_p_);
warning (_ ("beam has less than two stems"));
}
- if (!Directional_element_interface (me).get ())
- Directional_element_interface (me).set (get_default_dir (me));
+ if (!Directional_element_interface::get (me))
+ Directional_element_interface::set (me, get_default_dir (me));
auto_knees (me);
set_stem_directions (me);
for (int i=0; i <stems.size (); i++)
do { // HUH -- waar slaat dit op?
Score_element *s = stems[i];
- Direction sd = Directional_element_interface (s).get ();
+ Direction sd = Directional_element_interface::get (s);
int current = sd ? (1 + d * sd)/2
: Stem::get_center_distance (s, (Direction)-d);
{
Link_array<Item> stems
=Pointer_group_interface__extract_elements (me, (Item*) 0, "stems");
- Direction d = Directional_element_interface (me).get ();
+ Direction d = Directional_element_interface::get (me);
for (int i=0; i <stems.size (); i++)
{
Score_element *s = stems[i];
SCM force = s->remove_elt_property ("dir-forced");
if (!gh_boolean_p (force) || !gh_scm2bool (force))
- Directional_element_interface (s).set (d);
+ Directional_element_interface ::set (s,d);
}
}
bool knee_b = false;
int knee_y = 0;
SCM gap = me->get_elt_property (gap_str.ch_C());
-
- Direction d = Directional_element_interface (me).get ();
+
+ Direction d = Directional_element_interface::get (me);
Link_array<Item> stems=
Pointer_group_interface__extract_elements (me, (Item*)0, "stems");
int y = (int)(Stem::head_positions(s)[d])
+ (int)calc_interstaff_dist (s, dynamic_cast<Spanner*> (me));
- Directional_element_interface (s).set (y < knee_y ? UP : DOWN);
+ Directional_element_interface::set (s,y < knee_y ? UP : DOWN);
s->set_elt_property ("dir-forced", SCM_BOOL_T);
}
}
/*
until here, we used only stem_info, which acts as if dir=up
*/
- y *= Directional_element_interface (me).get ();
- dy *= Directional_element_interface (me).get ();
+ y *= Directional_element_interface::get (me);
+ dy *= Directional_element_interface::get (me);
Real half_space = Staff_symbol_referencer::staff_space (me) / 2;
*/
int quant_dir = 0;
if (abs (y_shift) > half_space / 2)
- quant_dir = sign (y_shift) * Directional_element_interface (me).get ();
+ quant_dir = sign (y_shift) * Directional_element_interface::get (me);
y = quantise_y_f (me, y, dy, quant_dir);
}
}
Real stem_y = (dy && dx ? (s->relative_coordinate (0, X_AXIS) - x0) / dx * dy : 0) + y;
/* knee */
- Direction dir = Directional_element_interface(me).get ();
- Direction sdir = Directional_element_interface (s).get ();
+ Direction dir = Directional_element_interface::get (me);
+ Direction sdir = Directional_element_interface::get (s);
/* knee */
if (dir!= sdir)
// huh, why not for first visible?
if (Staff_symbol_referencer::staff_symbol_l (s)
!= Staff_symbol_referencer::staff_symbol_l (last_visible_stem (me)))
- stem_y += Directional_element_interface (me).get ()
+ stem_y += Directional_element_interface::get (me)
* (beam_multiplicity - stem_multiplicity) * interbeam_f;
}
{
Real shorten = 0;
Real lengthen = 0;
- Direction dir = Directional_element_interface (me).get ();
+ Direction dir = Directional_element_interface::get (me);
Link_array<Item> stems=
Pointer_group_interface__extract_elements (me, (Item*)0, "stems");
if (a.size () <= 1)
return y;
- Real up_y = Directional_element_interface (me).get () * y;
+ Real up_y = Directional_element_interface::get (me) * y;
Interval iv = quantise_iv (a, up_y/staff_space) * staff_space;
Real q = up_y - iv[SMALLER] <= iv[BIGGER] - up_y
if (quant_dir)
q = iv[(Direction)quant_dir];
- return q * Directional_element_interface (me).get ();
+ return q * Directional_element_interface::get (me);
}
void
nw_f = me->paper_l ()->get_var ("quartwidth");
- Direction dir = Directional_element_interface (me).get ();
+ Direction dir = Directional_element_interface::get (me);
/* half beams extending to the left. */
if (prev)
Score_element * me = (Score_element*)b;
Real space = Staff_symbol_referencer::staff_space (b);
- Direction d = Directional_element_interface (b). get ();
+ Direction d = Directional_element_interface::get (b);
if (!d)
{
d = UP;
- Directional_element_interface (me).set (d);
+ Directional_element_interface::set (me, d);
}
return 2.0 * space * d;
It's amazing Mike:
Stem:: type_i () ->first_head ()->get_direction () ->
- Directional_element_interface (me).set (d);
+ Directional_element_interface::set (me, d);
don't understand this comment.
#include "musical-request.hh"
-bool
-Bar_req::do_equal_b (Request const *r) const
-{
- Bar_req const* b = dynamic_cast <Bar_req const *> (r);
- return b && type_str_ == b->type_str_;
-}
-
-void
-Bar_req::do_print () const
-{
-#ifndef NPRINT
- DEBUG_OUT << type_str_;
-#endif
-}
-
Bar_req::Bar_req (String s)
{
- type_str_ = s;
+ set_mus_property ("type", ly_str02scm (s.ch_C()));
}
bool
#include "directional-element-interface.hh"
-Directional_element_interface::Directional_element_interface (Score_element const *s)
+static SCM Directional_element_interface::direction_sym;
+
+static void
+init_functions ()
{
- elt_l_ = (Score_element*)s;
+ Directional_element_interface::direction_sym = scm_permanent_object (ly_symbol2scm ("direction"));
}
+ADD_SCM_INIT_FUNC(Directional, init_functions);
+
bool
-Directional_element_interface::has_interface () const
+Directional_element_interface::has_interface (Score_element*me)
{
- return isdir_b (elt_l_->get_elt_property ("direction"));
+ return isdir_b (me->get_elt_property (direction_sym));
}
-
-
-
Direction
-Directional_element_interface::get () const
+Directional_element_interface::get (Score_element*me)
{
// return dir_;
- SCM d= elt_l_->get_elt_property ("direction");
+ SCM d= me->get_elt_property (direction_sym);
if (!isdir_b(d))
return CENTER;
}
void
-Directional_element_interface::set (Direction d)
+Directional_element_interface::set (Score_element*me, Direction d)
{
- elt_l_->set_elt_property ("direction", gh_int2scm (d));
+ SCM sd = gh_int2scm (d);
+
+ if (me->get_elt_property (direction_sym) != sd)
+ me->set_elt_property (direction_sym, sd);
}
Dot_column::set_interface (Score_element* me)
{
me->set_elt_property ("dots", SCM_EOL);
- Directional_element_interface (me).set (RIGHT);
+ Directional_element_interface::set (me, RIGHT);
Axis_group_interface::set_interface (me);
Axis_group_interface::set_axes (me, X_AXIS,X_AXIS);
SCM d= me->get_elt_property ("dot-count");
if (gh_number_p (d) && gh_scm2int (d))
{
- if (!Directional_element_interface (me).get ())
- Directional_element_interface (me).set (UP);
+ if (!Directional_element_interface::get (me))
+ Directional_element_interface::set (me, UP);
int pos = int (Staff_symbol_referencer::position_f (me));
if (!(pos % 2))
- return Staff_symbol_referencer::staff_space (me) / 2.0 * Directional_element_interface (me).get ();
+ return Staff_symbol_referencer::staff_space (me) / 2.0 * Directional_element_interface::get (me);
}
return 0.0;
text_p_ = new Item (get_property ("basicDynamicTextProperties"));
text_p_->set_elt_property ("text", ly_str02scm (loud.ch_C ()));
if (Direction d=text_req_l_->get_direction ())
- Directional_element_interface (line_spanner_).set (d);
+ Directional_element_interface::set (line_spanner_, d);
Axis_group_interface::add_element (line_spanner_, text_p_);
{
accepted_spanreqs_drul_[START]->origin ()->warning
(current_cresc_req_->span_dir_ == 1
- ?
- _ ("already have a crescendo")
+ ? _ ("already have a crescendo")
: _ ("already have a decrescendo"));
}
else
void
Engraver::announce_element (Score_element* e, Music *m)
{
- if (e->get_elt_property ("interfaces") == SCM_EOL)
- Group_interface (e, "interfaces").add_thing (ly_symbol2scm (e->name()));
-
if (m && m->origin ()->location_str ().length_i ())
{
e->set_elt_property ("origin", m->get_mus_property ("origin"));
private:
+ void typeset_bar ();
void create_bar ();
Item * bar_p_;
class Mark_req : public Request {
public:
- SCM mark_label ();
-
-
virtual bool do_equal_b (Request const*) const;
+ SCM mark_label ();
VIRTUAL_COPY_CONS(Music);
};
the latter should only happen at the start of a measure. */
class Bar_req : public Request {
public:
- String type_str_;
+
Bar_req (String);
protected:
- virtual bool do_equal_b (Request const*) const;
- virtual void do_print () const;
-
VIRTUAL_COPY_CONS(Music);
};
struct Directional_element_interface
{
-
public:
- Score_element *elt_l_;
-
- Directional_element_interface (Score_element const *);
- void set (Direction d);
- Direction get () const;
- bool has_interface () const;
- // bool set_interface ();
+ static SCM direction_sym ;
+ static void set (Score_element*,Direction d);
+ static Direction get (Score_element*) ;
+ static bool has_interface (Score_element*) ;
};
@see Music_sequence
+
+ TODO: make a equalp function for general music.
*/
class Music {
public:
0 means ORPHAN,
*/
char status_i_;
- char const * name () const;
+ String name () const;
/*
IDEA: make this a global variable. This is the same for all
{
public:
VIRTUAL_COPY_CONS(Translator);
- Time_signature_change_req * time_signature_req_l () const;
Timing_translator ();
Link_array<Timing_req> timing_req_l_arr_;
virtual void do_post_move_processing();
public:
-
Moment measure_position () const;
Moment measure_length () const;
void set_time_signature (int, int);
-
};
#endif // TIMING_TRANSLATOR_HH
VIRTUAL_COPY_CONS(Translator);
Translator_group(Translator_group const &);
Translator_group();
- void add_simple_translator (Translator *trans_p);
void add_group_translator (Translator *trans_p);
void terminate_translator (Translator*r_l);
Translator *remove_translator_p (Translator*trans_l);
void check_removal ();
- Translator *get_simple_translator (String) const;
+ // Translator *get_simple_translator (String) const;
Translator_group *find_existing_translator_l (String n, String id);
Translator_group *find_create_translator_l (String n, String id);
Link_array<Translator_group> path_to_acceptable_translator (String alias, Music_output_def*) const;
happens at the begin of the alt. The :| bar event at the ending.
*/
- for (SCM s = repeated_music_l_->alternatives ()->music_list ();
- gh_pair_p (s); s = gh_cdr (s))
- {
- Music *mus =unsmob_music (gh_car (s));
+ for (SCM s = repeated_music_l_->alternatives ()->music_list ();
+ gh_pair_p (s); s = gh_cdr (s))
+ {
+ Music *mus =unsmob_music (gh_car (s));
/*
some idiot might typeset a repeat not starting on a
becel.append (c);
last_number = volta_number;
volta_number ++;
- SCM l (get_property ("voltaSpannerDuration"));
- if (unsmob_moment(l))
+ SCM l (get_property ("voltaSpannerDuration"));
+ if (unsmob_moment(l))
{
Moment vSD_mom = *unsmob_moment (l);
if ( vSD_mom < mus->length_mom() ) // terminate volta early ?
}
}
- Cons<Bar_create_event> *&tail = create_barmoments_queue_
- ? last_cons (create_barmoments_queue_)->next_
- : create_barmoments_queue_;
+ /*
+ ugh, should merge :| and |: here.
+ */
+ Cons<Bar_create_event> * last = last_cons (create_barmoments_queue_);
+ Cons<Bar_create_event> **tail = last? & last->next_
+ : & create_barmoments_queue_;
- tail = becel.head_ ;
+ *tail = becel.head_ ;
+
becel.head_ = 0;
}
}
- Cons<Bar_create_event> * head = create_barmoments_queue_;
+ Cons<Bar_create_event> * head = create_barmoments_queue_;
if (!head)
return;
- Bar_engraver* bar_engraver_l = dynamic_cast <Bar_engraver*>
- (daddy_grav_l ()->get_simple_translator ("Bar_engraver")); // UGH
-
/*
Do all the events that need to be done now.
*/
{
create_barmoments_queue_ = create_barmoments_queue_->next_;
head->next_ =0;
- if (bar_engraver_l)
+ String t = head->car_->type_;
+ if (head->car_->bar_b_)
{
- String t = head->car_->type_;
- if (head->car_->bar_b_)
+ if (t == "stop" || t == ":|")
{
- if (t == "stop" || t == ":|")
- {
- end_volta_span_p_ = volta_span_p_;
- volta_span_p_ =0;
- }
-
- if (t != "stop")
- bar_engraver_l->request_bar (t);
- else
- bar_engraver_l->request_bar ("");
+ end_volta_span_p_ = volta_span_p_;
+ volta_span_p_ =0;
}
- else
+
+ SCM whsym = ly_symbol2scm ("whichBar");
+ Translator_group* where = daddy_trans_l_->where_defined (whsym);
+ SCM which = where->get_property (whsym);
+
+ /*
+ Should use symbols for bar glyphs.
+ */
+ if (t == "stop" && which == SCM_UNDEFINED)
+ which = ly_str02scm ("");
+ else if (t != "stop")
{
- assert (!volta_span_p_);
- volta_span_p_ = new Spanner (get_property ("basicVoltaSpannerProperties"));
- Volta_spanner::set_interface (volta_span_p_);
- announce_element (volta_span_p_,0);
- volta_span_p_->set_elt_property ("text",
- ly_str02scm (t.ch_C()));
- volta_span_p_->set_elt_property ("last-volta",
- gh_bool2scm (head->car_->last_b_));
- // voltaSpannerDuration stuff here.
- // other property stuff here.
+ SCM l = ly_str02scm (":|");
+ SCM r = ly_str02scm ("|:");
+
+ if ( (t == "|:" && scm_equal_p (which, l) == SCM_BOOL_T)
+ || (t == ":|" && scm_equal_p (which, r)== SCM_BOOL_T))
+ t = ":|:";
+
+ if (t != "" || !gh_string_p (which))
+ which = ly_str02scm (t.ch_C());
}
-
+ where->set_property (whsym, which);
}
else
{
- warning (_ ("No bar engraver found. Ignoring repeats."));
+ assert (!volta_span_p_);
+ volta_span_p_ = new Spanner (get_property ("basicVoltaSpannerProperties"));
+ Volta_spanner::set_interface (volta_span_p_);
+ announce_element (volta_span_p_,0);
+ volta_span_p_->set_elt_property ("text",
+ ly_str02scm (t.ch_C()));
+ volta_span_p_->set_elt_property ("last-volta",
+ gh_bool2scm (head->car_->last_b_));
+ // voltaSpannerDuration stuff here.
+ // other property stuff here.
}
+
delete head->car_;
delete head;
return common;
}
-char const *
+String
Score_element::name () const
{
- return classname (this);
+ SCM nm = get_elt_property ("name");
+
+ return nm == SCM_EOL ? classname (this) :ly_scm2string (nm) ;
}
void
Score_element *sc = (Score_element *) gh_cdr (s);
scm_puts ("#<Score_element ", port);
- scm_puts ((char *)sc->name (), port);
+ scm_puts ((char *)sc->name ().ch_C(), port);
/*
don't try to print properties, that is too much hassle.
if (!s->get_bound (d))
{
s->set_bound(d, command_column_l_);
- ::warning (_f ("unbound spanner `%s'", classname(s)));
+ ::warning (_f ("unbound spanner `%s'", s->name().ch_C()));
}
} while (flip(&d) != LEFT);
}
void
Separating_group_spanner::set_interface (Score_element*me)
{
- me->set_elt_property ("elements", SCM_EOL);
+
}
void
Slur::set_extremities (Score_element*me)
{
- if (!Directional_element_interface (me).get ())
- Directional_element_interface (me).set (get_default_dir (me));
+ if (!Directional_element_interface::get (me))
+ Directional_element_interface ::set (me,get_default_dir (me));
Direction dir = LEFT;
do
if (str == "head")
{
o = Offset (0, Stem::head_positions (stem)
- [Directional_element_interface (me).get ()] * hs);
+ [Directional_element_interface::get (me)] * hs);
/*
Default position is centered in X, on outer side of head Y
*/
o += Offset (0.5 * n->extent (X_AXIS).length (),
- 0.5 * ss * Directional_element_interface (me).get ());
+ 0.5 * ss * Directional_element_interface::get (me));
}
else if (str == "alongside-stem")
{
*/
o += Offset (n->extent (X_AXIS).length ()
* (1 + Stem::get_direction (stem)),
- 0.5 * ss * Directional_element_interface (me).get ());
+ 0.5 * ss * Directional_element_interface::get (me));
}
else if (str == "stem")
{
SCM l = scm_assoc
(scm_listify (a,
gh_int2scm (stem ? Stem::get_direction (stem) : 1 * dir),
- gh_int2scm (Directional_element_interface (me).get () * dir),
+ gh_int2scm (Directional_element_interface::get (me) * dir),
SCM_UNDEFINED),
scm_eval2 (ly_symbol2scm ("slur-extremity-offset-alist"), SCM_EOL));
Offset o;
Score_element* stem_l = unsmob_element (col->get_elt_property ("stem"));
- Direction dir = Directional_element_interface (me).get ();
+ Direction dir = Directional_element_interface::get (me);
if (!stem_l)
{
o[Y_AXIS] = col->relative_coordinate (common[Y_AXIS], Y_AXIS);
return o;
}
- Direction stem_dir = Directional_element_interface (stem_l).get ();
+ Direction stem_dir = Directional_element_interface::get (stem_l);
o[X_AXIS] = stem_l->relative_coordinate (0, X_AXIS);
/*
if (gh_number_p (d))
a = me->lookup_l ()->dashed_slur (one, thick, thick * gh_scm2double (d));
else
- a = me->lookup_l ()->slur (one, Directional_element_interface (me).get () * thick, thick);
+ a = me->lookup_l ()->slur (one, Directional_element_interface::get (me) * thick, thick);
return a.create_scheme();
}
Real r_0 = me->paper_l ()->get_var ("slur_ratio");
Slur_bezier_bow bb (get_encompass_offset_arr (me),
- Directional_element_interface (me).get (),
+ Directional_element_interface::get (me),
h_inf, r_0);
if (bb.fit_factor () > 1.0)
Bezier b;
int i = 0;
- if (!Directional_element_interface (me).get ()
+ if (!Directional_element_interface::get (me)
|| ! gh_symbol_p (index_cell (me->get_elt_property ("attachment"), LEFT)))
set_extremities (me);
}
Array<Offset> enc (get_encompass_offset_arr (me));
- Direction dir = Directional_element_interface (me).get ();
+ Direction dir = Directional_element_interface::get (me);
Real x1 = enc[0][X_AXIS];
Real x2 = enc.top ()[X_AXIS];
if (!parent->spanned_rank_iv ().contains_b (this->spanned_rank_iv ()))
{
programming_error (to_str ("Spanner `%s' is not fully contained in parent spanner `%s'.",
- classname (this),
- classname (parent)));
+ name().ch_C(),
+ parent->name ().ch_C ()));
}
}
}
int beams_i = Stem::beam_count(stem, RIGHT) >? Stem::beam_count (stem, LEFT);
mol.translate (Offset(stem->relative_coordinate (0, X_AXIS) - me->relative_coordinate (0, X_AXIS),
Stem::stem_end_position (stem ) * ss / 2 -
- Directional_element_interface (beam).get () * beams_i * interbeam_f));
+ Directional_element_interface::get (beam) * beams_i * interbeam_f));
}
else
{
Direction
Stem::get_direction (Score_element*me)
{
- Direction d = Directional_element_interface (me).get ();
+ Direction d = Directional_element_interface::get (me);
if (!d)
{
d = get_default_dir (me);
// urg, AAARGH!
- Directional_element_interface (me).set (d);
+ Directional_element_interface::set (me, d);
}
return d ;
}
if (!dir)
{
dir = get_default_dir (me);
- Directional_element_interface (me).set (dir);
+ Directional_element_interface::set (me, dir);
}
/*
{
Score_element * beam = beam_l (me);
- Direction beam_dir = Directional_element_interface (beam).get ();
+ Direction beam_dir = Directional_element_interface::get (beam);
if (!beam_dir)
{
programming_error ("Beam dir not set.");
Real stem_length = a[multiplicity <? (a.size () - 1)] * staff_space;
- if (!beam_dir || (beam_dir == Directional_element_interface (me).get ()))
+ if (!beam_dir || (beam_dir == Directional_element_interface::get (me)))
/* normal beamed stem */
{
if (multiplicity)
Pointer_group_interface__extract_elements (me, (Score_element*)0, "ties");
- Direction d = Directional_element_interface (me).get ();
+ Direction d = Directional_element_interface::get (me);
if (d)
{
for (int i = ties.size (); i--;)
{
Score_element * t = ties[i];
- Directional_element_interface (t).set (d);
+ Directional_element_interface::set (t, d);
}
return;
}
if (ties.size () == 1)
{
Score_element * t = ties[0];
- Directional_element_interface (t).set (Tie::get_default_dir (t));
+ Directional_element_interface::set (t,Tie::get_default_dir (t));
return;
}
ties.sort (tie_compare);
- Directional_element_interface tie0(ties[0]);
- tie0.set (DOWN);
+ Directional_element_interface::set( ties[0], DOWN);
ties.del (0);
- Directional_element_interface tietop(ties.pop ());
- tietop.set (UP);
-
+ Directional_element_interface ::set(ties.pop (), UP);
for (int i=ties.size(); i--; )
{
Score_element * t = ties[i];
Direction d = (Direction) sign (p);
if (!d)
d = UP;
- Directional_element_interface (t).set (d);
+ Directional_element_interface::set (t, d);
}
}
if (sl && sr)
{
- if (Directional_element_interface (sl).get () == UP
- && Directional_element_interface (sr).get () == UP)
+ if (Directional_element_interface::get (sl) == UP
+ && Directional_element_interface::get (sr) == UP)
return DOWN;
}
else if (sl || sr)
{
Item *s = sl ? sl : sr;
- return - Directional_element_interface (s). get ();
+ return - Directional_element_interface::get (s);
}
return SCM_UNSPECIFIED;
}
- if (!Directional_element_interface (me).get ())
- Directional_element_interface (me).set (Tie::get_default_dir (me));
+ if (!Directional_element_interface::get (me))
+ Directional_element_interface::set (me, Tie::get_default_dir (me));
Real staff_space = Staff_symbol_referencer::staff_space (me);
- 2 * x_gap_f;
}
- Direction dir = Directional_element_interface (me).get();
+ Direction dir = Directional_element_interface::get(me);
Real h_inf = me->paper_l ()->get_var ("tie_height_limit_factor") * staff_space;
Real r_0 = me->paper_l ()->get_var ("tie_ratio");
i++;
}
- Molecule a = me->lookup_l ()->slur (b, Directional_element_interface (me).get () * thick, thick);
+ Molecule a = me->lookup_l ()->slur (b, Directional_element_interface::get (me) * thick, thick);
return a.create_scheme ();
}
}
return false;
}
-
-/*ugh.
- */
-Time_signature_change_req*
-Timing_translator::time_signature_req_l() const
-{
- Time_signature_change_req *m_l=0;
- for (int i=0; !m_l && i < timing_req_l_arr_.size (); i++)
- {
- m_l=dynamic_cast<Time_signature_change_req*> (timing_req_l_arr_[i]);
- }
- return m_l;
-}
-
void
Timing_translator::do_process_music()
{
daddy_trans_l_->set_property ("measurePosition", m.make_scm ());
daddy_trans_l_->set_property ("beatLength", Moment (1,4).make_scm ());
daddy_trans_l_->set_property ("measureLength", Moment (1).make_scm());
+ daddy_trans_l_->set_property ("timeSignatureFraction",
+ gh_cons (gh_int2scm (4), gh_int2scm (4)));
}
Moment
Moment len = Moment (l) * one_beat;
daddy_trans_l_->set_property ("measureLength", len.make_scm ());
daddy_trans_l_->set_property ("beatLength", one_beat.make_scm ());
+ daddy_trans_l_->set_property ("timeSignatureFraction",
+ gh_cons (gh_int2scm (l), gh_int2scm (o)));
}
Timing_translator::Timing_translator()
return list;
}
void
-Translator_group::add_simple_translator (Translator*t)
-{
- simple_trans_list_ = add_translator (simple_trans_list_, t);
-}
-void
Translator_group::add_group_translator (Translator *t)
{
trans_group_list_ = add_translator (trans_group_list_,t);
return trans_l;
}
-
+#if 0
+/*
+ should not use, instead: use properties to communicate between engravers.
+ */
Translator*
Translator_group::get_simple_translator (String type) const
{
return daddy_trans_l_->get_simple_translator (type);
return 0;
}
-
+#endif
bool
Translator_group::is_bottom_translator_b () const
Real w = dynamic_cast<Spanner*>(me)->spanner_length () + ncw;
Real staff_space = me->paper_l ()->get_var ("interline");
- Direction dir = Directional_element_interface (me).get ();
+ Direction dir = Directional_element_interface::get (me);
Real dy = gh_scm2double (me->get_elt_property ("delta-y"));
SCM number = me->get_elt_property ("text");
if (gh_string_p (number) && number_visibility)
Score_element * commony = me->common_refpoint (me->get_elt_property ("columns"), Y_AXIS);
Score_element * commonx = me->common_refpoint (me->get_elt_property ("columns"), X_AXIS);
- Direction d = Directional_element_interface (me).get ();
+ Direction d = Directional_element_interface::get (me);
/*
Use outer non-rest columns to determine slope
Link_array<Score_element> column_arr=
Pointer_group_interface__extract_elements (me, (Score_element*)0, "columns");
- Direction d = Directional_element_interface (me).get ();
+ Direction d = Directional_element_interface::get (me);
*dy = column_arr.top ()->extent (Y_AXIS) [d]
- column_arr[0]->extent (Y_AXIS) [d];
}
return SCM_UNSPECIFIED;
}
- Direction d = Directional_element_interface (me).get ();
+ Direction d = Directional_element_interface::get (me);
if (!d)
{
d = Tuplet_spanner::get_default_dir (me);
- Directional_element_interface (me).set (d);
+ Directional_element_interface::set (me, d);
}
Real dy, offset;
{
me->set_elt_property ("bars", SCM_EOL);
Side_position::set_axis (me, Y_AXIS);
- Directional_element_interface (me).set (UP);
+ Directional_element_interface::set (me, UP);
}
# * slurs
# * lyrics
# * articulation
-#
+# * grace notes
+# * tuplets
+
# todo:
-# * automatic PC/mac/unix conversion
# * slur/stem directions
# * voices (2nd half of frame?)
# * more intelligent lyrics
# * beams (better use autobeam?)
-# * more robust: try entertainer.etf (freenote), schubert ave maria (gmd)
+# * more robust: try entertainer.etf (freenote)
+# * dynamics
+#
program_name = 'etf2ly'
version = '@TOPLEVEL_VERSION@'
return nn
+class Tuplet:
+ def __init__ (self, number):
+ self.start_note = number
+ self.finale = []
+
+ def append_finale (self, fin):
+ self.finale.append (fin)
+
+ def factor (self):
+ n = self.finale[0][2]*self.finale[0][3]
+ d = self.finale[0][0]*self.finale[0][1]
+ return rat_simplify( (n, d))
+
+ def dump_start (self):
+ return '\\times %d/%d { ' % self.factor ()
+
+ def dump_end (self):
+ return ' }'
+
+ def calculate (self, chords):
+ edu_left = self.finale[0][0] * self.finale[0][1]
+
+ startch = chords[self.start_note]
+ c = startch
+ while c and edu_left:
+ c.tuplet = self
+ if c == startch:
+ c.chord_prefix = self.dump_start () + c.chord_prefix
+
+ if not c.grace:
+ edu_left = edu_left - c.EDU_duration ()
+ if edu_left == 0:
+ c.chord_suffix = c.chord_suffix+ self.dump_end ()
+ c = c.next
+
+ if edu_left:
+ sys.stderr.write ("\nHuh? Tuplet starting at entry %d was too short." % self.start_note)
+
class Slur:
def __init__ (self, number):
self.number = number
cs.note_suffix = '(' + cs.note_suffix
ce.note_prefix = ce.note_prefix + ')'
except IndexError:
- sys.stderr.write ("""\nHuh? Incorrect slur start/endpoint
-len(list) is %d, start/end is (%d,%d)\n""" % (len (chords), startnote, endnote))
+ sys.stderr.write ("""\nHuh? Slur no %d between (%d,%d), with %d notes""" % (self.number, startnote, endnote, len (chords)))
class Global_measure:
11: '\\prall',
12: '\\mordent',
8: '\\fermata',
+ 4: '^',
+ 1: '.',
+ 3: '>',
18: '"arp"' , # arpeggio
};
try:
a = articulation_dict[self.type]
except KeyError:
+ sys.stderr.write ("\nUnknown articulation no. %d on note no. %d" % (self.type, self.notenumber))
a = '"art"'
c.note_suffix = '-' + a + c.note_suffix
def set_measure (self, m):
self.measure = m
+ def calculate (self):
+
+ # do grace notes.
+ lastch = None
+ for c in self.chords:
+ if c.grace and (lastch == None or (not lastch.grace)):
+ c.chord_prefix = r'\grace {' + c.chord_prefix
+ elif not c.grace and lastch and lastch.grace:
+ lastch.chord_suffix = lastch.chord_suffix + ' } '
+
+ lastch = c
+
+
+
def dump (self):
- str = ''
+ str = '%% FR(%d)\n' % self.number
left = self.measure.global_measure.length ()
+
+
+ ln = ''
for c in self.chords:
- str = str + c.ly_string () + ' '
+ add = c.ly_string () + ' '
+ if len (ln) + len(add) > 72:
+ str = str + ln + '\n'
+ ln = ''
+ ln = ln + add
left = rat_subtract (left, c.length ())
-
+
+ str = str + ln
+
if left[0] < 0:
- sys.stderr.write ("""Huh? Going backwards.
-Frame no %d, start/end (%d,%d)
-""" % (self.number, self.start, self.end))
+ sys.stderr.write ("""\nHuh? Going backwards in frame no %d, start/end (%d,%d)""" % (self.number, self.start, self.end))
left = (0,1)
if left[0]:
- str = str + 's*%d/%d' % left
-
- str = str + '\n'
+ str = str + rat_to_lily_duration (left)
+
+ str = str + ' | \n'
return str
def encodeint (i):
last_clef = m.clef
if e:
if gap <> (0,1):
- k = k +' s1*%d/%d \n ' % gap
+ k = k +' ' + rat_to_lily_duration (gap) + '\n'
gap = (0,1)
k = k + e
if fr:
first_frame = fr
if gap <> (0,1):
- laystr = laystr +'} s1*%d/%d {\n ' % gap
+ laystr = laystr +'} %s {\n ' % rat_to_lily_duration (gap)
gap = (0,1)
laystr = laystr + fr.dump ()
else:
dots = 2
return (log, dots)
+def rat_to_lily_duration (rat):
+ (n,d) = rat
+
+ basedur = 1
+ while d and d % 2 == 0:
+ basedur = basedur << 1
+ d = d >> 1
+
+ str = 's%d' % basedur
+ if n <> 1:
+ str = str + '*%d' % n
+ if d <> 1:
+ str = str + '/%d' % d
+
+ return str
+
+
class Chord:
def __init__ (self, finale_entry):
self.pitches = []
self.note_suffix = ''
self.chord_suffix = ''
self.chord_prefix = ''
+ self.tuplet = None
+ self.grace = 0
def measure (self):
if not self.frame:
return self.frame.measure
def length (self):
+ if self.grace:
+ return (0,1)
+
l = (1, self.duration[0])
d = 1 << self.duration[1]
dotfact = rat_subtract ((2,1), (1,d))
- return rat_multiply (dotfact, l)
+ mylen = rat_multiply (dotfact, l)
+
+ if self.tuplet:
+ mylen = rat_multiply (mylen, self.tuplet.factor())
+ return mylen
def number (self):
return self.finale[0][0]
+
+ def EDU_duration (self):
+ return self.finale[0][3]
def set_duration (self):
- ((no, prev, next, dur, pos, entryflag, extended, follow),
- notelist) = self.finale
- self.duration = EDU_to_duration(dur)
+ self.duration = EDU_to_duration(self.EDU_duration ())
+ def calculate (self):
+ self.find_realpitch ()
+ self.set_duration ()
+
+ flag = self.finale[0][5]
+ if Chord.GRACE_MASK & flag:
+ self.grace = 1
+
+
def find_realpitch (self):
((no, prev, next, dur, pos, entryflag, extended, follow), notelist) = self.finale
REST_MASK = 0x40000000L
TIE_START_MASK = 0x40000000L
+ GRACE_MASK = 0x00800000L
+
def ly_string (self):
s = ''
vere = re.compile(r"""^\^(ve|ch|se)\(([0-9-]+),([0-9-]+)\) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+)""")
versere = re.compile(r"""^\^verse\(([0-9]+)\)(.*)\^end""")
+TPre = re.compile(r"""^\^TP\(([0-9]+),([0-9]+)\) *([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+)""")
+
+
class Etf_file:
def __init__ (self, name):
self.measures = [None]
self.entries = [None]
self.chords = [None]
self.frames = [None]
+ self.tuplets = [None]
self.staffs = [None]
self.slurs = [None]
self.articulations = [None]
bn = string.atoi (m.group (1))
where = string.atoi (m.group (2)) / 1024.0
return m
+ def try_TP(self, l):
+ m = TPre.match (l)
+ if m:
+ (nil, num) = map (string.atoi, (m.groups ()[0:2]))
+ entries = map (string.atoi, (m.groups ()[2:]))
+
+ if self.tuplets[-1] == None or num <> self.tuplets[-1].start_note:
+ self.tuplets.append (Tuplet (num))
+ self.tuplets[-1].append_finale (entries)
+
def try_IM (self, l):
m = IMre.match (l)
if m:
entryflag = string.atol (entryflag,16)
if no > len (self.entries):
- sys.stderr.write ("Huh? Entry number to large,\nexpected %d got %d. Filling with void entries.\n" % (len(self.entries), no ))
+ sys.stderr.write ("\nHuh? Entry number to large,\nexpected %d got %d. Filling with void entries.\n" % (len(self.entries), no ))
while len (self.entries) <> no:
c = ((len (self.entries), 0, 0, 0, 0, 0L, 0, 0), [])
self.entries.append (c)
m = self.try_IM (l)
if not m:
m = self.try_Sx (l)
+ if not m:
+ m = self.try_TP (l)
if not m:
m = self.try_verse (l)
mno = mno + 1
for c in self.chords[1:]:
- c.find_realpitch ()
- c.set_duration ()
+ c.calculate()
+
+ for f in self.frames[1:]:
+ f.calculate ()
+
+ for t in self.tuplets[1:]:
+ t.calculate (self.chords)
for s in self.slurs [1:]:
s.calculate (self.chords)
str = str + '\n\n' + s.dump ()
staffs.append ('\\' + s.staffid ())
- if staffs:
- str = str + '\\score { < %s > } ' % string.join (staffs)
# should use \addlyrics ?
if len (self.verses) > 1:
sys.stderr.write ("\nLyrics found; edit to use \\addlyrics to couple to a staff\n")
+ if staffs:
+ str = str + '\\score { < %s > } ' % string.join (staffs)
+
return str
projects / lilypond.git / commitdiff