subsect(Introduction) label(introduction)
-This page is dedicated to the distribution of precompiled and preformatted
-LilyPond binaries for Windows NT 4.0 . This package is covered under the
-GNU General Public License and all of the source and documentation are
+This page is dedicated to the distribution of precompiled and
+preformatted LilyPond binaries for Windows NT 4.0 . This package is
+covered under the GNU General Public License and all of the source is
available on the official
url(LilyPond Homepage)(http://www.cs.ruu.nl/people/hanwen/lilypond/index.html).
+A full set of url(documentation)(http://www.cs.ruu.nl/people/hanwen/lilypond/Documentation/tex/out-www/index.html) in various formats is also available.
includefile(../BLURB.in)
In a batch file you can add the following entries: nl()
bf(set LILYPONDPREFIX=em(LilyPond-dir)) nl()
bf(set path=%path%;%LILYPONDPREFIX%\bin;em(MiKTeX-dir)\miktex\bin) nl()
- bf(set TEXINPUTS=%LILYPONDPREFIX%\texmf\tex\lilypond;;) nl()
- bf(set MFINPUTS=%LILYPONDPREFIX%\texmf\mf\public\lilypond;;) nl()
+ bf(set TEXINPUTS=%LILYPONDPREFIX%\share\lilypond\tex;;) nl()
+ bf(set MFINPUTS=%LILYPONDPREFIX%\share\lilypond\mf;;) nl()
COMMENT( dit(Windows Environment)
In the Windows environment you can select
properties menu of the My Computer icon. Click on
V retval;
if (!elem_b (k))
return retval ;
- retval ((Dictionary<V> *) this)->elem (k);
+ return ((Dictionary<V> *) this)->elem (k);
}
V remove (String s)
return sqrt (norm_sq());
}
operator Array<Real>() { return dat; }
+ Array<Real> const &to_array()const { return dat; }
void print() const;
/// set to j-th element of unit-base
void set_unit (int j) ;
#ifndef VIRTUAL_METHODS_HH
#define VIRTUAL_METHODS_HH
+#include <typeinfo>
#include "stdlib.h" // size_t
/** Declare the classes name as a static and virtual function.
s->name() != S::static_name (). Overlapping strings need not be merged in C++
*/
#define DECLARE_MY_RUNTIME_TYPEINFO \
-static bool static_is_type_b (const char*s);\
-virtual bool is_type_b (const char *s) const { return static_is_type_b (s); } \
-virtual char const *name() const{ return static_name (); } \
-virtual size_t class_size () const { return static_class_size (); }\
-static size_t static_class_size (); \
+virtual char const *name() const{ return static_name (); }\
static char const *static_name()
-#define IMPLEMENT_STATIC_NAME(c)\
- char const *c::static_name() { return #c; } \
- size_t c::static_class_size () { return sizeof (c); }
+#if 0
+ /*
+ oops. before() has nothing to do with inheritance
+ */
+inline bool operator > (type_info const &a1, type_info const &a2)
+{
+ return a2.before (a1);
+}
+inline bool operator < (type_info const &a1, type_info const &a2)
+{
+ return a1.before (a2);
+}
-#define VIRTUAL_COPY_CONS(T, R)\
- virtual R *clone() const { return new T(*this); } \
- int yet_another_stupid_function_to_allow_semicolon()
+inline bool operator <= (type_info const &a1, type_info const &a2)
+{
+ return a1 == a2 || a1 < a2;
+}
+
+inline bool operator >= (type_info const &a1, type_info const &a2)
+{
+ return a1 == a2 || a1 > a2;
+}
+#endif
+
+#define IMPLEMENT_STATIC_NAME(c)\
+ char const *c::static_name() { return #c; }
+
+ /*
+ size_t c::static_class_size () { return sizeof (c); }
+ */
+#define VIRTUAL_COPY_CONS(T, R)\
+ virtual R *clone() const { return new T(*this); }
#define DECLARE_VIRTUAL_COPY_CONS(T, R)\
virtual R *clone() const
+
#define IMPLEMENT_VIRTUAL_COPY_CONS(T, R)\
R *T::clone() const { return new T(*this); }\
#define IMPLEMENT_IS_TYPE_B(D)\
- IMPLEMENT_STATIC_NAME(D)\
+ IMPLEMENT_STATIC_NAME(D)
+
+/*
bool D::static_is_type_b (const char *s)\
{\
return s == static_name();\
-}
+}*/
#define IMPLEMENT_IS_TYPE_B1(D, B)\
- IMPLEMENT_STATIC_NAME(D)\
+ IMPLEMENT_STATIC_NAME(D)
+/*
bool D::static_is_type_b (const char *s)\
{\
return s == static_name() || B::static_is_type_b (s);\
}
+*/
#define IMPLEMENT_IS_TYPE_B2(D, BA, BB)\
- IMPLEMENT_STATIC_NAME(D)\
+ IMPLEMENT_STATIC_NAME(D)
+
+/*
+
bool D::static_is_type_b (const char *s)\
{\
return s == static_name() || BA::static_is_type_b (s) || BB::static_is_type_b (s);\
}
+*/
#endif
Abbreviation::do_substitute_dependent (Score_element*o, Score_element*n)
{
if (stem_l_ == o)
- stem_l_ = n ? dynamic_cast<Stem*> (n) : 0;
+ stem_l_ = dynamic_cast<Stem*> (n);
}
bool
Abbreviation_beam_engraver::do_try_request (Request*r)
{
- Musical_req* mus_l = dynamic_cast <Musical_req *> (r);
- if (!mus_l)
- return false;
-
- Abbreviation_beam_req * b = dynamic_cast <Abbreviation_beam_req *> (mus_l);
+ Abbreviation_beam_req * b = dynamic_cast <Abbreviation_beam_req *> (r);
if (!b)
return false;
return false;
Direction d = (!abeam_p_) ? LEFT : RIGHT;
- if (span_reqs_drul_[d] && !span_reqs_drul_[d]->equal_b (mus_l))
+ if (span_reqs_drul_[d] && !span_reqs_drul_[d]->equal_b (b))
return false;
span_reqs_drul_[d] = b;
void
Abbreviation_beam_engraver::acknowledge_element (Score_element_info i)
{
- if (!abeam_p_ || !i.elem_l_->is_type_b (Stem::static_name ()))
+ Stem* s = dynamic_cast<Stem *> (i.elem_l_);
+ if (!abeam_p_ || !s)
return;
- Stem* s = (Stem*)dynamic_cast <Item *> (i.elem_l_);
-
int type_i = span_reqs_drul_[LEFT]->type_i_;
s->flag_i_ = intlog2 (type_i) - 2;
if (span_reqs_drul_[RIGHT])
(c) 1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-
#include "atom.hh"
#include "interval.hh"
#include "string.hh"
}
+
Atom::Atom ()
: dim_ (Interval (0,0),Interval (0,0))
{
But Atom is used as a simple type *everywhere*,
and we don't have virtual contructors.
*/
- lambda_ = 0;
str_ = "unknown\n";
+ origin_l_ = 0;
}
Atom::Atom (String s, Box b)
: dim_ (b)
{
- lambda_ = 0;
str_ = s;
+ origin_l_ = 0;
}
return off_;
}
-
-
void
Atom::translate_axis (Real r, Axis a)
{
bool
Tuplet_engraver::do_try_request (Request *r)
{
- Command_req * c = dynamic_cast <Command_req *> (r);
- if (!(c &&
- dynamic_cast <Bracket_req *> (c)))
+ if (Bracket_req * b = dynamic_cast <Bracket_req *> (r))
{
- return false;
+ bracket_req_arr_.push (b);
+ return true;
}
-
- Bracket_req * b = dynamic_cast <Bracket_req *> (c);
- bracket_req_arr_.push (b);
- return true;
+ return false;
}
void
void
Tuplet_engraver::acknowledge_element (Score_element_info i)
{
- if (i.elem_l_->is_type_b (Note_column::static_name ()))
+ if (Note_column *nc = dynamic_cast<Note_column *> (i.elem_l_))
{
- Note_column *nc = (Note_column*)dynamic_cast <Item *> (i.elem_l_);
+
for (int j =0; j <started_span_p_arr_.size (); j++)
// started_span_p_arr_[j]->add_column (nc);
;
#include "request.hh"
#include "script.hh"
#include "bar.hh"
+#include <typeinfo>
Bar_column_engraver::Bar_column_engraver()
{
Item * it = dynamic_cast <Item *> (info.elem_l_);
if (!it)
return;
-
- if (it->is_type_b (Script::static_name())
+ Script *s = dynamic_cast<Script*> (it);
+ Bar *b = dynamic_cast<Bar*> (it);
+ if (s
&& it->breakable_b_
&& info.origin_grav_l_arr_.size() == 1
&& it->break_priority_i_ == break_priority_i_)
{
create_column ();
- barcol_p_->add_script ((Script*)it);
+ barcol_p_->add_script (s);
}
else if (info.origin_grav_l_arr_.size() == 1
&& it->break_priority_i_ == break_priority_i_
- && it->breakable_b_
- && it->is_type_b (Bar::static_name()))
+ && it->breakable_b_
+ &&b)
+
{
create_column ();
- barcol_p_->set_bar ( (Bar*)it);
+ barcol_p_->set_bar (b);
}
}
Script_column::do_substitute_dependency (o,n);
if (o == bar_l_)
{
- bar_l_ = n ? (Bar*)dynamic_cast <Item *> (n) : 0;
+ bar_l_ = dynamic_cast<Bar *> (n);
}
}
bool
Bar_engraver::do_try_request (Request*r_l)
{
- Command_req* c_l = dynamic_cast <Command_req *> (r_l);
- if (!c_l|| !dynamic_cast <Bar_req *> (c_l))
- return false;
- Bar_req * b= dynamic_cast <Bar_req *> (c_l);
- if (bar_req_l_ && bar_req_l_->equal_b (b))
- return false;
+ if (Bar_req * b= dynamic_cast <Bar_req *> (r_l))
+ {
+ if (bar_req_l_ && bar_req_l_->equal_b (b)) // huh?
+ return false;
+
+ bar_req_l_ = b;
+
+ return true;
+ }
- bar_req_l_ = b;
+ return false;
- return true;
}
void
void
Bar_number_engraver::acknowledge_element (Score_element_info i)
{
-
- Item *it=dynamic_cast <Item *> (i.elem_l_);
- if (script_p_
- || !it || !it->is_type_b (Bar::static_name()))
+ Bar *b =dynamic_cast <Bar *> (i.elem_l_);
+ if (script_p_ || !b)
return;
/* Only put numbers on bars that are at our own level (don't put
script_p_->break_priority_i_ = int (pri);
}
else
- script_p_->break_priority_i_ = it->break_priority_i_;
+ script_p_->break_priority_i_ = b->break_priority_i_;
Scalar padding = get_property ("barScriptPadding");
if (padding.length_i() && padding.isnum_b ())
bool
Beam_engraver::do_try_request(Request*r)
{
- Musical_req* mus_l = dynamic_cast <Musical_req *> (r);
- if (!mus_l)
- return false;
-
- Beam_req* b = dynamic_cast <Beam_req *> (mus_l);
+ Beam_req* b = dynamic_cast <Beam_req *> (r);
if (!b)
return false;
return false;
Direction d = (!beam_p_) ? LEFT : RIGHT;
- if (span_reqs_drul_[d] && !span_reqs_drul_[d]->equal_b (mus_l))
+ if (span_reqs_drul_[d] && !span_reqs_drul_[d]->equal_b (b))
return false;
span_reqs_drul_[d] = b;
void
Beam_engraver::acknowledge_element (Score_element_info i)
{
- if (!beam_p_ || !i.elem_l_->is_type_b (Stem::static_name ()))
+ Stem* s = dynamic_cast<Stem *> (i.elem_l_);
+ if (!beam_p_ || !s)
return;
- Stem* s = (Stem*)dynamic_cast <Item *> (i.elem_l_);
if (!dynamic_cast <Rhythmic_req *> (i.req_l_))
{
::warning ( _("Stem must have Rhythmic structure."));
void
Beam::do_substitute_dependent (Score_element*o,Score_element*n)
{
- if (o->is_type_b (Stem::static_name ()))
- stems_.substitute ((Stem*)dynamic_cast <Item *> (o), n? (Stem*) dynamic_cast <Item *> (n):0);
+ if (Stem * os = dynamic_cast<Stem*> (o))
+ stems_.substitute (os,
+ dynamic_cast<Stem *> (n));
}
Interval
if (mi->ok())
{
if (simultaneous_music_l ()->translator_type_str_.empty_b ())
- set_translator (mi->report_to_l()->ancestor_l (simultaneous_music_l ()->multi_level_i_));
+ set_translator (mi->report_to_l()->ancestor_l (0));
children_p_list_.bottom().add (mi);
}
else
#include "debug.hh"
#include "command-request.hh"
#include "time-description.hh"
-
-
#include "note-head.hh"
#include "key-item.hh"
#include "local-key-item.hh"
void
Clef_engraver::acknowledge_element (Score_element_info info)
{
- if (info.elem_l_->is_type_b (Bar::static_name ())
+ if (dynamic_cast<Bar*>(info.elem_l_)
&& clef_type_str_.length_i())
{
create_clef();
/* ugh; should make Clef_referenced baseclass */
Item * it_l =dynamic_cast <Item *> (info.elem_l_);
-if (it_l)
- {
- if (it_l->is_type_b (Note_head::static_name ()))
+ if (it_l)
{
- Note_head * h = (Note_head*)it_l;
- h->position_i_ += c0_position_i_;
- }
- else if (it_l->is_type_b (Local_key_item::static_name ()))
- {
- Local_key_item *i = (Local_key_item*)it_l;
- i->c0_position_i_ =c0_position_i_;
- }
- else if (it_l->is_type_b (Key_item::static_name ()))
- {
- Key_item *k = (Key_item*)it_l;
- k-> set_c_position (c0_position_i_);
- }
- }
+ if (Note_head * h = dynamic_cast<Note_head*>(it_l))
+ {
+ h->position_i_ += c0_position_i_;
+ }
+ else if (Local_key_item *i = dynamic_cast<Local_key_item*> (it_l))
+ {
+ i->c0_position_i_ =c0_position_i_;
+ }
+ else if (Key_item *k = dynamic_cast<Key_item*>(it_l))
+ {
+ k-> set_c_position (c0_position_i_);
+ }
+ }
}
void
bool
Clef_engraver::do_try_request (Request * r_l)
{
- Command_req* creq_l= dynamic_cast <Command_req *> (r_l);
- if (!creq_l || !dynamic_cast <Clef_change_req *> (creq_l))
+ if (Clef_change_req *cl = dynamic_cast <Clef_change_req *> (r_l))
+ {
+ clef_req_l_ = cl;
+ read_req (clef_req_l_);
+ return true;
+ }
+ else
return false;
- clef_req_l_ = dynamic_cast <Clef_change_req *> (creq_l);
- read_req (clef_req_l_);
- return true;
}
void
void
Collision_engraver::acknowledge_element (Score_element_info i)
{
- if (i.elem_l_->is_type_b (Note_column::static_name ()))
+ if (Note_column * c = dynamic_cast<Note_column *> (i.elem_l_))
{
- Note_column * c = (Note_column*) dynamic_cast <Item *> (i.elem_l_);
if (c->rest_b ())
return ;
void
Collision::add_column (Note_column* ncol_l)
{
+ // ugh. Fixme.
clash_l_arr_.push (ncol_l);
add_element (ncol_l);
add_dependency (ncol_l);
void
Collision::do_substitute_dependency (Score_element*o_l,Score_element*n_l)
{
- clash_l_arr_.substitute ((Note_column*)dynamic_cast <Item *> (o_l),
- (Note_column*)(n_l?dynamic_cast <Item *> (n_l):0));
+ if (o_l)
+ {
+ clash_l_arr_.substitute (dynamic_cast<Note_column *> (o_l),
+ dynamic_cast <Note_column *> (n_l));
+
+ }
}
void
Dot_column_engraver::acknowledge_element (Score_element_info info)
{
- Item * i=dynamic_cast <Item *> (info.elem_l_);
-
- if (! (i && i->is_type_b (Rhythmic_head::static_name ())))
+ Rhythmic_head * h = dynamic_cast<Rhythmic_head*>(info.elem_l_);
+ if (!h)
return;
- Rhythmic_head * h = (Rhythmic_head*)i;
-
if (!h->dots_l_)
return;
Dot_column::do_substitute_dependency (Score_element*o,Score_element*n)
{
Item *oi =dynamic_cast <Item *> (o);
- Item *ni = n?dynamic_cast <Item *> (n):0;
- if (oi&&oi->is_type_b (Rhythmic_head::static_name ()))
- head_l_arr_.substitute ((Rhythmic_head*)oi, (Rhythmic_head*)ni);
- else if (oi && oi->is_type_b (Dots::static_name ()))
- dot_l_arr_.substitute ((Dots*) oi, (Dots*) ni);
+ if (oi && dynamic_cast<Rhythmic_head *> (oi))
+ head_l_arr_.substitute (dynamic_cast<Rhythmic_head*> (oi),
+ dynamic_cast<Rhythmic_head*>(n));
+ else if (oi && dynamic_cast<Dots *> (oi))
+ dot_l_arr_.substitute (dynamic_cast<Dots*> (oi),
+ dynamic_cast<Dots*> (n));
}
void
bool
Dynamic_engraver::do_try_request (Request * r)
{
- Musical_req * m = dynamic_cast <Musical_req *> (r);
- if (!m)
- return false;
- Dynamic_req * d = dynamic_cast <Dynamic_req *> (m);
- if (!d)
- return false;
-
-#if 0
- if (cresc_p_ && dynamic_cast <Span_dynamic_req *> (d)
- && dynamic_cast <Span_dynamic_req *> (d)->spantype == Span_req::START)
- return false;
-#endif
- for (int i=0; i < dynamic_req_l_arr_.size (); i++)
- if (d->equal_b (dynamic_req_l_arr_[i]))
+ if(Dynamic_req * d = dynamic_cast <Dynamic_req *> (r))
+ {
+ for (int i=0; i < dynamic_req_l_arr_.size (); i++)
+ if (d->equal_b (dynamic_req_l_arr_[i]))
+ return true;
+
+ dynamic_req_l_arr_.push (d);
return true;
-
- dynamic_req_l_arr_.push (dynamic_cast <Dynamic_req *> (m));
- return true;
+ }
+ return false;
}
void
Dynamic_engraver::do_process_requests()
for (int i=0; i < dynamic_req_l_arr_.size(); i++)
{
Dynamic_req *dreq_l = dynamic_req_l_arr_[i];
- if (
dynamic_cast <Absolute_dynamic_req *> (dreq_l))
+ if (
Absolute_dynamic_req *absd = dynamic_cast<Absolute_dynamic_req *> (dreq_l))
{
if (dynamic_p_)
Text_def * td_p = new Text_def;
td_p->align_dir_ = CENTER;
- String loud = dynamic_cast <Absolute_dynamic_req *> (dreq_l)->loudness_str ();
- td_p->text_str_ = paper ()->lookup_l (0)->dynamic (loud).str_;
+ String loud = absd->loudness_str ();
+ td_p->text_str_ = paper ()->lookup_l (0)->dynamic (loud).str_; // ugh
td_p->style_str_ = "dynamic";
dynamic_p_ = new Text_item (td_p);
announce_element (Score_element_info (dynamic_p_, dreq_l));
}
- else if (dynamic_cast <Span_dynamic_req *> (dreq_l))
+ else if (Span_dynamic_req *span_l = dynamic_cast <Span_dynamic_req *> (dreq_l))
{
- Span_dynamic_req* span_l = dynamic_cast <Span_dynamic_req *> (dreq_l);
if (span_l->spantype == Span_req::STOP)
{
if (!cresc_p_)
void
Dynamic_engraver::acknowledge_element (Score_element_info i)
{
- if (i.elem_l_->is_type_b (Note_column::static_name ()))
+ if (dynamic_cast<Note_column *> (i.elem_l_))
{
if (dynamic_p_)
dynamic_p_->add_support (i.elem_l_);
Engraver::daddy_grav_l () const
{
return (daddy_trans_l_ )
- ? (Engraver_group_engraver*) dynamic_cast <Engraver *> (daddy_trans_l_)
+ ? dynamic_cast<Engraver_group_engraver *> (daddy_trans_l_)
: 0;
}
void
Hara_kiri_line_group_engraver::typeset_element(Score_element * e)
{
- if (e->is_type_b (Note_head::static_name ()))
- ((Hara_kiri_vertical_group_spanner*)staffline_p_)->add_note
- ((Note_head*)dynamic_cast <Item *> (e));
-
+ if (Note_head *h = dynamic_cast<Note_head *> (e))
+ {
+ dynamic_cast<Hara_kiri_vertical_group_spanner*> (staffline_p_)
+ ->add_note (h);
+ }
Line_group_engraver_group::typeset_element (e);
}
void
Hara_kiri_vertical_group_spanner::do_substitute_dependency (Score_element*o, Score_element*n)
{
- if (o->is_type_b (Note_head::static_name ()))
- head_l_arr_.substitute ((Note_head*)dynamic_cast <Item *> (o),
- (n)? (Note_head*)dynamic_cast <Item *> (n) : 0);
+ if (dynamic_cast<Note_head *> (o))
+ head_l_arr_.substitute (dynamic_cast<Note_head *> (o),
+ (n)? dynamic_cast<Note_head *> (n) : 0);
}
if (note_req_l_)
return false;
- if (!(dynamic_cast <Note_req *> (req_l)))
- return false;
-
- note_req_l_=dynamic_cast <Rhythmic_req *> (req_l);
- return true;
+ if (Note_req * nr = dynamic_cast <Note_req *> (req_l))
+ {
+ note_req_l_= nr;
+ return true;
+ }
+ return false;
}
void
bool
Note_heads_engraver::do_try_request (Request *req_l)
{
- if (!dynamic_cast <Musical_req *> (req_l))
- return false;
-
- Note_req * n =dynamic_cast <Note_req *> (req_l);
- if (!n)
- return false;
-
- note_req_l_arr_.push (n);
- return true;
+ if (Note_req * n =dynamic_cast <Note_req *> (req_l))
+ {
+ note_req_l_arr_.push (n);
+ return true;
+ }
+ return false;
}
void
dot_p_arr_.push (d);
}
- note_p->position_i_ = dynamic_cast <Note_req *> (note_req_l)->pitch_.steps ();
+ note_p->position_i_ = note_req_l->pitch_.steps ();
Score_element_info itinf (note_p,note_req_l);
#ifndef ATOM_HH
#define ATOM_HH
-#include "lily-guile.hh"
+#include "protected-scm.hh"
#include "string.hh"
#include "box.hh"
#include "lily-proto.hh"
/// a symbol which can be translated, and freely copied
class Atom {
Offset off_;
+
+
public:
+ Protected_scm lambda_;
+ Score_element * origin_l_;
+
// urg, only used as a temp buffer
String str_;
String font_;
- SCM lambda_;
Box dim_;
Offset offset () const;
SCM lambda_scm (String str, Array<Real> args_arr);
SCM lambda_scm (String str, Array<Scalar> args_arr);
+
+
+
#endif // LILY_GUILE_HH
class Music_sequence : public Music
{
public:
- int multi_level_i_;
Music_list * music_p_list_p_;
Music_sequence (Music_sequence const&);
--- /dev/null
+/*
+ protected-scm.hh -- declare Protected_scm
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#ifndef PROTECTED_SCM_HH
+#define PROTECTED_SCM_HH
+
+#include "lily-guile.hh"
+
+/*
+ Mix GUILE GC with C++ ctors and dtors.
+ */
+class Protected_scm
+{
+ SCM object_;
+public:
+ Protected_scm ();
+ Protected_scm (SCM);
+ Protected_scm (Protected_scm const &);
+ ~Protected_scm ();
+ Protected_scm &operator = (Protected_scm const &);
+ operator SCM ();
+};
+
+#endif /* PROTECTED_SCM_HH */
class Spring_spacer : public Line_spacer {
friend class Durations_iter;
-
-
+
Pointer_list<Idealspacing *> ideal_p_list_;
Array<Column_info> cols_;
Array<Column_info> loose_col_arr_;
- Array<Spacer_rod> rods_;
+
/// mark column #i# as being loose.
void loosen_column (int i);
int
Item::left_right_compare(Item const *l, Item const *r)
{
- while (!l->is_type_b (Paper_column::static_name ()))
- l = dynamic_cast<Item*> (l->axis_group_l_a_[X_AXIS]);
- while (!r->is_type_b (Paper_column::static_name ()))
- r = dynamic_cast<Item*> (r->axis_group_l_a_[X_AXIS]);
+ while (!(dynamic_cast<Paper_column const *> (l)))
+ l = dynamic_cast<Item const*> (l->axis_group_l_a_[X_AXIS]);
+ while (!(dynamic_cast<Paper_column const *> (r)))
+ r = dynamic_cast<Item const*> (r->axis_group_l_a_[X_AXIS]);
Paper_column *p1 = (Paper_column*)l;
Paper_column* p2 = (Paper_column*)r;
break_priority_i_ = s.break_priority_i_;
}
-Item *
-Item::access_Item ()
-{
- return this;
-}
bool
Key_engraver::do_try_request (Request * req_l)
{
- Command_req* creq_l= dynamic_cast <Command_req *> (req_l);
- if (!creq_l|| !dynamic_cast <Key_change_req *> (creq_l))
- return false;
-
- if (keyreq_l_)
- return false; // TODO
- keyreq_l_ = dynamic_cast <Key_change_req *> (creq_l);
- read_req (keyreq_l_);
- return true;
+ if (Key_change_req *kc = dynamic_cast <Key_change_req *> (req_l))
+ {
+ if (keyreq_l_)
+ warning ("Fixme: key change merge.");
+ keyreq_l_ = kc;
+ read_req (keyreq_l_);
+ return true;
+ }
+ return false;
}
void
Key_engraver::acknowledge_element (Score_element_info info)
{
- Command_req * r_l = dynamic_cast <Command_req *> (info.req_l_) ;
-
- if (r_l && dynamic_cast <Clef_change_req *> (r_l))
+ if (dynamic_cast <Clef_change_req *> (info.req_l_))
{
int i= get_property ("createKeyOnClefChange").length_i ();
if (i)
create_key ();
}
- else if (info.elem_l_->is_type_b (Bar::static_name ())
+ else if (dynamic_cast<Bar *> (info.elem_l_)
&& accidental_idx_arr_.size ())
{
if (!keyreq_l_)
{
#ifndef NPRINT
if (key_req_l_)
- key_req_l_->print();
+ key_req_l_->print();
#endif
}
Key_performer::do_process_requests()
{
if (key_req_l_)
- play (new Audio_key (key_req_l_));
+ play (new Audio_key (key_req_l_));
key_req_l_ = 0;
}
bool
Key_performer::do_try_request (Request* req_l)
{
- if (key_req_l_)
- return false;
-
- if (dynamic_cast <Key_change_req *> (req_l))
+ if (Key_change_req *kc = dynamic_cast <Key_change_req *> (req_l))
{
- key_req_l_ = dynamic_cast <Key_change_req*> (req_l);
+ if (key_req_l_)
+ warning ("FIXME. Key change merge");
+
+ key_req_l_ = kc;
return true;
}
}
else
{
- key_C_ = &((Key_engraver*)dynamic_cast <Engraver *> (result))->key_;
+ key_C_ = &(dynamic_cast<Key_engraver *> (result))->key_;
local_key_ = *key_C_;
}
}
void
Local_key_engraver::acknowledge_element (Score_element_info info)
{
- Score_element * elem_l = info.elem_l_;
- Item * item_l = dynamic_cast <Item *> (elem_l);
-
Note_req * note_l = dynamic_cast <Note_req *> (info.req_l_);
-
- if (note_l && item_l && item_l->is_type_b (Note_head::static_name ()))
+ Note_head * note_head = dynamic_cast<Note_head *> (info.elem_l_);
+
+ if (note_l && note_head)
{
mel_l_arr_.push (note_l);
- support_l_arr_.push (item_l);
+ support_l_arr_.push (note_head);
}
else if (dynamic_cast <Key_change_req*> (info.req_l_))
{
local_key_ = *key_C_;
}
- else if (elem_l->is_type_b (Tie::static_name ()))
+ else if (Tie * tie_l = dynamic_cast<Tie *> (info.elem_l_))
{
- Tie * tie_l = (Tie*)dynamic_cast <Spanner *> (elem_l);
if (tie_l->same_pitch_b_)
tied_l_arr_.push (tie_l-> head_l_drul_[RIGHT]);
}
a.dim_[Y_AXIS] *= 1 / 1000.0;
Array<Real> arr;
arr.push (m.code ());
- a.lambda_ = lambda_scm ("char", arr);
+ a.lambda_ = (lambda_scm ("char", arr));
a.font_ = font_;
return a;
}
Array<Real> arr;
arr.push (h);
Atom a = (*symtables_p_) ("bars")->lookup (str);
- a.lambda_ = lambda_scm (a.str_, arr);
+ a.lambda_ = (lambda_scm (a.str_, arr));
a.dim_.y () = Interval (-h/2, h/2);
a.font_ = font_;
return a;
Atom
Lookup::beam (Real slope, Real width, Real thick) const
{
- Atom a (ps_beam (slope, width, thick));
Real height = slope * width;
Real min_y = (0 <? height) - thick/2;
Real max_y = (0 >? height) + thick/2;
-
+
+ Array<Real> arr;
+ arr.push (width);
+ arr.push (slope);
+ arr.push (thick);
+
+ Atom a;
+ a.lambda_ = (lambda_scm ("beam", arr));
a.dim_[X_AXIS] = Interval (0, width);
a.dim_[Y_AXIS] = Interval (min_y, max_y);
return a;
a.dim_[Y_AXIS] = Interval (0 <? dy, 0 >? dy);
// (lambda (o) (dashed-slur o '((0.1 0.2) (1.1 1.2) (2.1 2.2) (3.1 3.2))))
- a.lambda_ =
+ a.lambda_ = (
ly_append (ly_lambda_o (),
ly_list1 (ly_append (ly_func_o ("dashed-slur"),
gh_cons (gh_double2scm (thick), gh_cons (gh_double2scm (dash),
gh_cons (ly_list2 (gh_double2scm (controls[2].x ()), gh_double2scm (controls[2].y ())),
gh_cons (ly_list2 (gh_double2scm (controls[3].x ()), gh_double2scm (controls[3].y ())),
gh_cons (ly_list2 (gh_double2scm (controls[0].x ()), gh_double2scm (controls[0].y ())),
- SCM_EOL)))))))))));
+ SCM_EOL))))))))))));
return a;
}
Array<Real> args;
args.push (height);
args.push (width);
- bs.lambda_ = lambda_scm (bs.str_, args);
+ bs.lambda_ = (lambda_scm (bs.str_, args));
bs.dim_.x () = Interval (0, width);
bs.dim_.y () = Interval (0, height);
return bs;
}
Atom
-Lookup::special_time_signature (String s, Array<Scalar> arr) const
+Lookup::special_time_signature (String s, Array<Real> arr) const
{
-#if 0
- String symbolname = "timesig-"+s+"%/%";
- Atom a (afm_find (lambda_scm (symbolname, arr)));
+ String symbolname = "timesig-" + s;
+ if (!arr.empty ())
+ symbolname += to_str (arr[0]);
+ if (arr.size () >1)
+ symbolname += "/" + to_str (arr[1]);
+
+ Atom a = afm_find (symbolname);
if (!a.empty ())
return a;
+
+#if 0 //guess we covered this
// Try if the full name was given
a = afm_find ("timesig-"+s);
if (!a.empty ())
return a;
- // Resort to default layout with numbers
#endif
+
+ // Resort to default layout with numbers
return time_signature (arr);
}
a.push (y2);
a.push (-y1);
- s.lambda_ = lambda_scm ("stem", a);
+ s.lambda_ = (lambda_scm ("stem", a));
s.font_ = font_;
return s;
}
a.push (text);
Atom s = (*symtables_p_) ("style")->lookup (style);
- s.lambda_ = lambda_scm (s.str_, a);
+ s.lambda_ = (lambda_scm (s.str_, a));
s.font_ = font_;
return s;
}
Atom
-Lookup::time_signature (Array<Scalar> a) const
+Lookup::time_signature (Array<Real> a) const
{
Atom s ((*symtables_p_) ("param")->lookup ("time_signature"));
- s.lambda_ = lambda_scm (s.str_, a);
+ s.lambda_ = (lambda_scm (s.str_, a));
return s;
}
Array<Real> a;
a.push (idx);
- brace.lambda_ = lambda_scm (brace.str_, a);
+ brace.lambda_ = (lambda_scm (brace.str_, a));
brace.dim_[Y_AXIS] = Interval (-y/2,y/2);
brace.font_ = font_;
return s;
}
-Atom
-Lookup::ps_beam (Real slope, Real width, Real thick) const
-{
- String ps;
- ps += to_str (width) + " "+ to_str (slope) + " " + to_str (thick)
- + " draw_beam ";
-
- Atom s;
- s.str_ = ps;
- return s;
-}
-
Atom
Lookup::slur (Array<Offset> controls) const
{
Atom a;
// (lambda (o) (slur o '((0.1 0.2) (1.1 1.2) (2.1 2.2) (3.1 3.2) .. )))
- a.lambda_ =
+ a.lambda_ = (
ly_append (ly_lambda_o (),
ly_list1 (ly_append (ly_func_o ("slur"),
ly_list1 (ly_list2 (ly_quote (),
gh_cons (ly_list2 (gh_double2scm (controls[2].x ()), gh_double2scm (controls[2].y ())),
gh_cons (ly_list2 (gh_double2scm (controls[3].x ()), gh_double2scm (controls[3].y ())),
gh_cons (ly_list2 (gh_double2scm (controls[0].x ()), gh_double2scm (controls[0].y ())),
- SCM_EOL)))))))))))));
+ SCM_EOL))))))))))))));
a.dim_[X_AXIS] = Interval (0, dx);
a.dim_[Y_AXIS] = Interval (0 <? dy, 0 >? dy);
}
Array<Real> arr;
arr.push (y);
- a.lambda_ = lambda_scm ("bracket", arr);
+ a.lambda_ = (lambda_scm ("bracket", arr));
a.dim_[Y_AXIS] = Interval (-y/2,y/2);
a.dim_[X_AXIS] = Interval (0,4 PT);
return a;
bool
Lyric_engraver::do_try_request (Request*r)
{
- Musical_req * m =dynamic_cast <Musical_req *> (r);
- if (!m || ! dynamic_cast <Lyric_req *> (m))
- return false;
- lreq_l_ = dynamic_cast <Lyric_req *> (m);
-
- return true;
+ if (Lyric_req * lr = dynamic_cast <Lyric_req *> (r))
+ {
+ lreq_l_ = lr;
+ return true;
+ }
+ return false;
}
void
if (!prefix_directory.empty_b())
{
- global_path.add (prefix_directory + "/share/lilypond/init/");
- global_path.add (prefix_directory + "/share/lilypond");
+ global_path.add (prefix_directory + "/share/lilypond/ly/");
+ global_path.add (prefix_directory + "/share/lilypond/afm/");
+ }
+ else
+ {
+ global_path.add (String (DIR_DATADIR) + "/ly/");
+ global_path.add (String (DIR_DATADIR) + "/afm/");
}
-
- global_path.add (String (DIR_DATADIR) + "/ly/");
- global_path.add (String (DIR_DATADIR) + "/afm/");
}
+
void
main_prog (int argc, char **argv)
{
default_outname_base_global = outname_str;
do_one_file (i, default_outname_base_global);
}
+ exit( exit_status_i_);
}
int
#endif
}
-/*
- urg: make input file name:
+/**
+ make input file name from command arg.
- input: file name
+ @input file name
- output: file name with added default extension. "" is stdin.
+ @output file name with added default extension. "" is stdin.
in reference argument: the extension. ".ly" if none
*/
String
split_path (str,a,b,c,ext_r);
// add extension if not present.
+ // UGH. Should parametrise in list of default extensions.
if (ext_r.empty_b ())
{
ext_r = ".fly";
bool
Mark_engraver::do_try_request (Request* r_l)
{
- Command_req* c_l = dynamic_cast <Command_req *> (r_l);
- if (!c_l || !dynamic_cast <Mark_req *> (c_l) || mark_req_l_)
- return false;
-
- mark_req_l_ = dynamic_cast <Mark_req *> (c_l);
-
- return true;
+ if (Mark_req *mr = dynamic_cast <Mark_req *> (r_l))
+ {
+ mark_req_l_ = mr;
+ return true;
+ }
+ return false;
}
void
bool
Multi_measure_rest_engraver::do_try_request (Request* req_l)
{
- if (!dynamic_cast<Multi_measure_rest_req *> (req_l))
- return false;
-
- if (multi_measure_req_l_)
- if (!multi_measure_req_l_->equal_b (req_l)
- || req_start_mom_ != now_moment ())
- return false;
-
- multi_measure_req_l_ = dynamic_cast<Multi_measure_rest_req *> (req_l);
- req_start_mom_ = now_moment ();
+ if (Multi_measure_rest_req *mr = dynamic_cast<Multi_measure_rest_req *> (req_l))
+ {
+ if (multi_measure_req_l_)
+ if (!multi_measure_req_l_->equal_b (req_l)
+ || req_start_mom_ != now_moment ())
+ return false;
- rest_req_stop_mom_ = req_start_mom_ + multi_measure_req_l_->duration_.length ();
-
- return true;
+ multi_measure_req_l_ = mr;
+ req_start_mom_ = now_moment ();
+
+ rest_req_stop_mom_ = req_start_mom_ + multi_measure_req_l_->duration_.length ();
+ return true;
+ }
+ return false;
}
void
Music_iterator::static_get_iterator_p (Music const *m, Translator_group *report_l)
{
Music_iterator * p =0;
- if (m->is_type_b (Request_chord::static_name()))
+ if (dynamic_cast<Request_chord const *> (m))
p = new Request_chord_iterator;
- else if (m->is_type_b (Simultaneous_music::static_name()))
+ else if (dynamic_cast<Simultaneous_music const *> (m))
p = new Simultaneous_music_iterator;
- else if (m->is_type_b (Sequential_music::static_name()))
+ else if (dynamic_cast<Sequential_music const *> (m))
p = new Sequential_music_iterator;
- else if (m->is_type_b (Translation_property::static_name ()))
+ else if (dynamic_cast<Translation_property const *> (m))
p = new Property_iterator;
- else if (m->is_type_b (Change_translator::static_name ()))
+ else if (dynamic_cast<Change_translator const *> (m))
p = new Change_iterator;
- else if (m->is_type_b (Compressed_music::static_name ()))
+ else if (dynamic_cast<Compressed_music const *> (m))
p = new Compressed_music_iterator;
- else if (m->is_type_b (Music_wrapper::static_name ()))
+ else if (dynamic_cast<Music_wrapper const *> (m))
p = new Music_wrapper_iterator;
p->music_l_ = m;
Request_chord::Request_chord()
: Simultaneous_music (new Music_list)
{
- multi_level_i_ =0;
}
{
for (iter (music_p_list_p_->top(),i); i.ok (); i++)
{
- Musical_req *m = dynamic_cast<Musical_req*> (i.ptr ());
- if (m && dynamic_cast <Melodic_req *> (m))
+ if (Melodic_req *m= dynamic_cast <Melodic_req *> (i.ptr ()))
{
- Musical_pitch &pit = dynamic_cast <Melodic_req *> (m)->pitch_;
+ Musical_pitch &pit = m->pitch_;
pit.to_relative_octave (last);
return pit;
}
for (Dictionary_iter<Identifier*> i (*translator_p_dict_p_); i.ok (); i++)
{
- Translator * t = i.val ()->access_Translator (false);
+ Translator * t = i.val ()->access_content_Translator (false);
t-> output_def_l_ = this;
}
}
Music_output_def::find_translator_l (String name) const
{
if (translator_p_dict_p_->elem_b (name))
- return (*translator_p_dict_p_)[name]->access_Translator ();
+ return (*translator_p_dict_p_)[name]->access_content_Translator (false);
if (global_translator_dict_p->elem_b (name))
return (*global_translator_dict_p)[name];
if (!t)
error (_("Can't find Score context"));
t = t->clone ();
- Global_translator *g = dynamic_cast <Translator_group *> (t)->global_l ();
+ Global_translator *g = dynamic_cast <Global_translator *> (t);
t->add_processing ();
return g;
return "";
Identifier * id = (*scope_p_) ["output"];
- String *p = dynamic_cast <String *> (id);
+ String *p = id->access_content_String (false);
return p ? *p : String ("");
}
Music_sequence::Music_sequence (Music_sequence const&s)
: Music (s)
{
- multi_level_i_ = s.multi_level_i_;
music_p_list_p_ = new Music_list (*s.music_p_list_p_);
}
Music_sequence::Music_sequence(Music_list *mlist_p)
{
- multi_level_i_ = 0;
music_p_list_p_ = mlist_p;
}
Melodic_req::do_equal_b (Request*r) const
{
Melodic_req* m= dynamic_cast <Melodic_req *> (r);
- return !compare (*m, *this);
+ return m&& !compare (*m, *this);
}
int
{
Rhythmic_req* rh = dynamic_cast <Rhythmic_req *> (r);
- return !compare (*this, *rh);
+ return rh&& !compare (*this, *rh);
}
bool
Note_req::do_equal_b (Request*r) const
{
- return Rhythmic_req::do_equal_b (r) && Melodic_req::do_equal_b (r);
+ Note_req *n = dynamic_cast<Note_req*> (r);
+ return n&& Rhythmic_req::do_equal_b (n) && Melodic_req::do_equal_b (n);
}
Span_req:: do_equal_b (Request*r) const
{
Span_req * s = dynamic_cast <Span_req *> (r);
- return spantype == s->spantype;
+ return s&& spantype == s->spantype;
}
Span_req::Span_req ()
{
Script_req * s = dynamic_cast <Script_req *> (r);
- return scriptdef_p_->equal_b (*s->scriptdef_p_);
+ return s&& scriptdef_p_->equal_b (*s->scriptdef_p_);
}
Script_req::Script_req ()
Absolute_dynamic_req::do_equal_b (Request *r) const
{
Absolute_dynamic_req *a = dynamic_cast <Absolute_dynamic_req *> (r);
- return loudness_ == a->loudness_;
+ return a&& loudness_ == a->loudness_;
}
String
{
Span_dynamic_req * s = dynamic_cast <Span_dynamic_req *> (req);
- return Span_req::do_equal_b (req) && s->dynamic_dir_ == dynamic_dir_;
+ return s&& Span_req::do_equal_b (req) && s->dynamic_dir_ == dynamic_dir_;
}
Span_dynamic_req::Span_dynamic_req ()
}
void
-My_lily_lexer::set_identifier (String name_str, Identifier* i, bool unique_b)
+My_lily_lexer::set_identifier (String name_str, Identifier* i, bool )
{
Identifier *old =0;
if (scope_l_arr_.top ()->elem_b (name_str))
}
void
-My_lily_lexer::print_declarations (bool init_b) const
+My_lily_lexer::print_declarations (bool ) const
{
for (int i=scope_l_arr_.size (); i--; )
{
return v;
}
+
+/*
+ UGH.
+ */
Array<Request*>*
My_lily_parser::get_parens_request (int t)
{
My_lily_parser::default_paper_p ()
{
Identifier *id = lexer_p_->lookup_identifier ("$defaultpaper");
- return id ? id->access_Paper_def () : new Paper_def ;
+ return id ? id->access_content_Paper_def (true) : new Paper_def ;
}
Midi_def*
My_lily_parser::default_midi_p ()
{
Identifier *id = lexer_p_->lookup_identifier ("$defaultmidi");
- return id ? id->access_Midi_def () : new Midi_def ;
+ return id ? id->access_content_Midi_def (true) : new Midi_def ;
}
{
if (stem_l_ == o)
{
- stem_l_ = n ? (Stem*)dynamic_cast <Item *> (n):0;
+ stem_l_ = n ? dynamic_cast<Stem *> (n):0;
}
- if (o->is_type_b (Note_head::static_name ()))
+ if (dynamic_cast<Note_head *> (o))
{
- head_l_arr_.substitute ((Note_head*)dynamic_cast <Item *> (o),
- (n)? (Note_head*)dynamic_cast <Item *> (n) : 0);
+ head_l_arr_.substitute (dynamic_cast<Note_head *> (o),
+ (n)? dynamic_cast<Note_head *> (n) : 0);
}
Script_column::do_substitute_dependency (o,n);
- if (o->is_type_b (Rest::static_name ()))
+ if (dynamic_cast<Rest *> (o))
{
- rest_l_arr_.substitute ((Rest*)dynamic_cast <Item *> (o),
- (n)? (Rest*)dynamic_cast <Item *> (n) : 0);
+ rest_l_arr_.substitute (dynamic_cast<Rest *> (o),
+ (n)? dynamic_cast<Rest *> (n) : 0);
}
}
void
Note_column::add_head (Rhythmic_head *h)
{
- if (h->is_type_b (Rest::static_name ()))
+ if (dynamic_cast<Rest *> (h))
{
rest_l_arr_.push ((Rest*)h);
add_support (h);
}
- if (h->is_type_b (Note_head::static_name ()))
+ if (dynamic_cast<Note_head *> (h))
{
head_l_arr_.push ((Note_head*) h);
add_support (h);
#include "file-results.hh"
#include "misc.hh"
+#if 0 // has w32 advanced?
// sucking Cygnus egcs - w32
#include "list.tcc"
#include "cursor.tcc"
+#endif
Paper_score::Paper_score ()
{
Item const*l=l_item_l;
Item const*r=r_item_l;
- while (! l->is_type_b(Paper_column::static_name ()))
+ // huh? see Item::left_right_compare ()
+ while (! (dynamic_cast<Paper_column const *> (l)))
l = dynamic_cast<Item*> (l->axis_group_l_a_[X_AXIS]);
- while (! r->is_type_b(Paper_column::static_name ()))
+ while (! (dynamic_cast<Paper_column const *> (r)))
r = dynamic_cast<Item*>(r->axis_group_l_a_[X_AXIS]);
PCursor<Paper_column*> start (l ? find_col ((Paper_column*)l)+1 : col_p_list_.top ());
Performer::daddy_perf_l () const
{
return (daddy_trans_l_)
- ?(Performer_group_performer*) dynamic_cast <Performer *> (daddy_trans_l_)
+ ?dynamic_cast<Performer_group_performer *> (daddy_trans_l_)
: 0;
}
void
Pitch_squash_engraver::acknowledge_element (Score_element_info i)
{
- if (i.elem_l_->is_type_b (Note_head::static_name ()))
+ if (Note_head *nh = dynamic_cast<Note_head *> (i.elem_l_))
{
- Note_head * nl = (Note_head*)dynamic_cast <Item *> (i.elem_l_);
- nl->position_i_ =0;
+ nh->position_i_ =0;
}
}
void
Plet_engraver::acknowledge_element (Score_element_info i)
{
- if (!i.elem_l_->is_type_b (Stem::static_name ()))
+
+ Stem * st = (dynamic_cast<Stem *> (i.elem_l_));
+ if (!st)
return;
if (!plet_spanner_p_)
return;
return;
if (!plet_spanner_p_->stem_l_drul_[LEFT])
- plet_spanner_p_->set_stem (LEFT, (Stem*)dynamic_cast <Item *> (i.elem_l_));
+ plet_spanner_p_->set_stem (LEFT, st);
else
if (span_reqs_drul_[RIGHT] && !plet_spanner_p_->stem_l_drul_[RIGHT])
- plet_spanner_p_->set_stem (RIGHT, (Stem*)dynamic_cast <Item *> (i.elem_l_));
+ plet_spanner_p_->set_stem (RIGHT, st);
}
bool
void
Plet_spanner::do_substitute_dependency (Score_element* o, Score_element* n)
{
- Stem* new_l = n ? (Stem*)dynamic_cast <Item *> (n) : 0;
+ Stem* new_l = n ? dynamic_cast<Stem *> (n) : 0;
if (dynamic_cast <Item *> (o) == stem_l_drul_[LEFT])
stem_l_drul_[LEFT] = new_l;
else if (dynamic_cast <Item *> (o) == stem_l_drul_[RIGHT])
bool
Plet_swallow_engraver::do_try_request (Request* req_l)
{
- return
dynamic_cast <Plet_req *> (req_l);
+ return
dynamic_cast<Plet_req *> (req_l);
}
Priority_horizontal_align_engraver::acknowledge_element (Score_element_info i)
{
Engraver* reg = i.origin_grav_l_arr_[0];
- if (reg->is_type_b (Score_priority_engraver::static_name()))
+ if (dynamic_cast<Score_priority_engraver *> (reg))
{
if (!halign_p_)
{
--- /dev/null
+/*
+ protected-scm.cc -- implement Protected_scm
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+#include "protected-scm.hh"
+extern "C"
+{
+#include <libguile/gc.h>
+};
+
+
+Protected_scm::Protected_scm ()
+{
+ object_ = 0;
+}
+
+Protected_scm::Protected_scm (SCM s)
+{
+ object_ = s ? scm_protect_object (s): 0;
+}
+
+Protected_scm::Protected_scm (Protected_scm const &s)
+{
+ object_ = s.object_ ? scm_protect_object (s.object_) : 0;
+}
+
+Protected_scm &
+Protected_scm::operator =(Protected_scm const &s)
+{
+ if (this == &s)
+ return *this;
+ if (object_)
+ scm_unprotect_object(object_);
+
+ object_ = (s.object_) ? scm_protect_object (s.object_): 0;
+ return *this;
+}
+
+Protected_scm::~Protected_scm ()
+{
+ if (object_)
+ scm_unprotect_object (object_);
+}
+
+Protected_scm::operator SCM ()
+{
+ return object_;
+}
{
for (PCursor<Music*> i (elt_l ()->music_p_list_p_->top ()); i.ok(); i++)
{
- assert (i->is_type_b (Request::static_name()));
- Request * req_l = (Request*)i.ptr();
- bool gotcha = report_to_l()->try_request (req_l);
- if (!gotcha)
- req_l->warning (_f ("junking request: `%s\'", req_l->name()));
+ if (Request * req_l = dynamic_cast<Request*> (i.ptr()))
+ {
+ bool gotcha = report_to_l()->try_request (req_l);
+ if (!gotcha)
+ req_l->warning (_f ("junking request: `%s\'", req_l->name()));
+ }
+ else
+ i.ptr ()->warning (_f ("Huh? Not a Request: `%s\'", i.ptr()->name ()));
}
first_b_ = false;
}
bool
Request::equal_b (Request *r) const
{
- if (is_type_b (r->name()))
- return r->do_equal_b ((Request*)this);
- if (r->is_type_b (name()))
- return do_equal_b (r);
-
- return false;
+ return r->do_equal_b (this) || this->do_equal_b (r) ;
}
bool
Request::do_equal_b (Request*) const
{
- return false;
+ return true;
}
void
Rest_collision_engraver::acknowledge_element (Score_element_info i)
{
- if (i.elem_l_->is_type_b (Note_column::static_name()))
- note_column_l_arr_.push ((Note_column*)dynamic_cast <Item *> (i.elem_l_));
+ if (dynamic_cast<Note_column *> (i.elem_l_))
+ note_column_l_arr_.push (dynamic_cast<Note_column *> (i.elem_l_));
}
void
void
Rest_collision::do_substitute_dependency (Score_element*o,Score_element*n)
{
- Item*o_l = dynamic_cast <Item *> (o);
-
-
- if (o_l&&o_l->is_type_b (Note_column::static_name ()))
+ if (Note_column *onl = dynamic_cast<Note_column *> (o))
{
- Note_column *n_l = n?(Note_column*)dynamic_cast <Item *> (n):0;
- rest_l_arr_.substitute ((Note_column*)o_l, n_l);
- ncol_l_arr_.substitute ((Note_column*)o_l, n_l);
+ Note_column *n_l = n?dynamic_cast<Note_column *> (n):0;
+ rest_l_arr_.substitute (onl, n_l);
+ ncol_l_arr_.substitute (onl, n_l);
}
}
}
bool
-Rest_engraver::do_try_request (Request *r)
+Rest_engraver::do_try_request (Request *req)
{
- Musical_req *m = dynamic_cast <Musical_req *> (r);
- if (!m || !dynamic_cast <Rest_req *> (m))
- return false;
-
- rest_req_l_ = dynamic_cast <Rest_req *> (m); // ugh
- return true;
+ if (Rest_req *r = dynamic_cast <Rest_req *> (req))
+ {
+ rest_req_l_ = r;
+ return true;
+ }
+ return false;
}
IMPLEMENT_IS_TYPE_B1(Rest_engraver, Engraver);
Item * item = dynamic_cast <Item *> (i.elem_l_);
if (!item)
return;
- if (item->is_type_b (Script::static_name ())
+ if (dynamic_cast<Script *> (item)
&& i.req_l_
&& dynamic_cast <Musical_req *> (i.req_l_))
{
script_l_arr_.push ((Script*)item);
}
- else if (item->is_type_b (Stem::static_name()))
+ else if (dynamic_cast<Stem *> (item))
{
stem_l_ = (Stem*) item;
}
- else if (item->is_type_b (Rhythmic_head::static_name ()))
+ else if (dynamic_cast<Rhythmic_head *> (item))
{
rhead_l_arr_.push ((Rhythmic_head*)item);
}
- else if (item->is_type_b (Dot_column::static_name ()))
+ else if (dynamic_cast<Dot_column *> (item))
{
dotcol_l_ = (Dot_column*) item;
}
Rhythmic_head::do_substitute_dependent (Score_element*o,Score_element*n)
{
if (o == dots_l_)
- dots_l_ = n ? (Dots*)dynamic_cast <Item *> (n) :0;
+ dots_l_ = n ? dynamic_cast<Dots *> (n) :0;
}
IMPLEMENT_IS_TYPE_B1(Rhythmic_head, Item);
if (transparent_b_)
return;
Molecule *output= brew_molecule_p ();
+ for (PCursor<Atom*> i(output->atoms_); i.ok(); i++)
+ {
+ i->origin_l_ = this;
+ }
+
pscore_l_->outputter_l_->output_molecule (output, absolute_offset (), name());
delete output;
}
Score_element * elt = dependency (i);
if (elt->line_l() != line)
{
- if (dynamic_cast <Spanner *> (elt))
+ if (Spanner *sp = dynamic_cast<Spanner *> (elt))
{
- Spanner * sp = dynamic_cast <Spanner *> (elt);
Spanner * broken = sp->find_broken_piece (line);
substitute_dependency (sp, broken);
add_dependency (broken);
}
- else if (dynamic_cast <Item *> (elt))
+ else if (Item *original = dynamic_cast <Item *> (elt))
{
- Item * my_item = dynamic_cast <Item *> (elt)->find_prebroken_piece (line);
+ Item * my_item = original->find_prebroken_piece (line);
substitute_dependency (elt, my_item);
if (my_item)
*/
if (announce_info_arr_[i].req_l_)
{
- Musical_req *m =dynamic_cast <Musical_req *> ( announce_info_arr_[i].req_l_);
- if (m && dynamic_cast <Rhythmic_req *> (m))
+ if (Rhythmic_req *rq = dynamic_cast <Rhythmic_req *> (announce_info_arr_[i].req_l_))
{
- musical_column_l_->add_duration (m->duration());
+ musical_column_l_->add_duration (rq->duration());
}
}
Engraver_group_engraver::do_announces();
for (int i =0; i < elem_p_arr_.size(); i++)
{
Score_element * elem_p = elem_p_arr_[i];
- if (dynamic_cast <Spanner *> (elem_p))
+ if (Spanner *s = dynamic_cast <Spanner *> (elem_p))
{
- Spanner *s = dynamic_cast <Spanner *> (elem_p);
pscore_p_->typeset_unbroken_spanner (s);
/*
{
bool gotcha = Engraver_group_engraver::do_try_request (r);
- if (gotcha || !dynamic_cast <Command_req *> (r))
- return gotcha;
-
- Command_req * c = dynamic_cast <Command_req *> (r);
- if (dynamic_cast <Break_req *> (c))
+ if (!gotcha)
{
- Break_req* b = (Break_req*)dynamic_cast <Break_req *> (c);
- if (b->penalty_i_ <= Break_req::DISALLOW)
- break_penalty_i_ = b->penalty_i_;
- else if (b->penalty_i_ >= Break_req::FORCE)
+ if (Break_req* b = dynamic_cast<Break_req *> (r))
{
- command_column_l_->break_penalty_i_ = b->penalty_i_;
- gotcha = true;
+ if (b->penalty_i_ <= Break_req::DISALLOW)
+ break_penalty_i_ = b->penalty_i_;
+ else if (b->penalty_i_ >= Break_req::FORCE)
+ {
+ command_column_l_->break_penalty_i_ = b->penalty_i_;
+ gotcha = true;
+ }
}
}
- return gotcha;
+ return gotcha;
+
}
IMPLEMENT_IS_TYPE_B1(Score_engraver,Engraver_group_engraver);
Score_engraver::do_add_processing ()
{
Translator_group::do_add_processing ();
- assert (output_def_l_->is_type_b (Paper_def::static_name ()));
+ assert (dynamic_cast<Paper_def *> (output_def_l_));
assert (!daddy_trans_l_);
pscore_p_ = new Paper_score;
pscore_p_->paper_l_ = (Paper_def*)output_def_l_;
void
Score_performer::play (Audio_element * p)
{
- if (p->is_type_b (Audio_item::static_name()))
+ if (dynamic_cast<Audio_item *> (p))
{
audio_column_l_->add_audio_item ((Audio_item*)p);
}
- else if (p->is_type_b (Audio_staff::static_name()))
+ else if (dynamic_cast<Audio_staff *> (p))
{
performance_p_->add_staff ((Audio_staff*)p);
}
Score_performer::do_add_processing ()
{
Translator_group::do_add_processing ();
- assert (output_def_l_->is_type_b (Midi_def::static_name ()));
+ assert (dynamic_cast<Midi_def *> (output_def_l_));
performance_p_ = new Performance;
performance_p_->midi_l_ = (Midi_def*) output_def_l_;
}
Don't try to eat up our (probable) parent.
*/
if (inf.origin_grav_l_arr_.size () <= 1 &&
- item_l->is_type_b (Break_align_item::static_name ()))
+ dynamic_cast<Break_align_item *> (item_l))
return;
for (int i=0; i < def_p_arr_.size (); i++)
{
if (no_paper_global_b
- && def_p_arr_[i]->is_type_b (Paper_def::static_name ()))
+ && dynamic_cast<Paper_def*>(def_p_arr_[i]))
continue;
run_translator (def_p_arr_[i]);
}
{
if (dynamic_cast <Item *> (o))
{
- script_l_arr_.substitute ((Script*)dynamic_cast <Item *> (o),(Script*) (n?dynamic_cast <Item *> (n):0));
- support_l_arr_.substitute (dynamic_cast <Item *> (o), (n?dynamic_cast <Item *> (n):0));
+ script_l_arr_.substitute (dynamic_cast<Script *> (o),
+ dynamic_cast <Script *> (n));
+ support_l_arr_.substitute (dynamic_cast <Item *> (o),
+ dynamic_cast <Item *> (n));
}
}
bool
Script_def::do_equal_b (General_script_def const *g) const
{
- Script_def const * c = (Script_def const*) g;
- return (symidx_str_ == c->symidx_str_ &&
+ Script_def const * c = dynamic_cast<Script_def const*> (g);
+ return c&& (symidx_str_ == c->symidx_str_ &&
rel_stem_dir_ == c->rel_stem_dir_&&
staff_dir_ == c->staff_dir_&&
invertsym_b_ == c->invertsym_b_);
if (!script_p->specs_p_->inside_b())
script_p->add_support (s_l);
- if (script_p->specs_p_->is_type_b (Text_def::static_name ()))
+ if (dynamic_cast<Text_def *> (script_p->specs_p_)) // UGH
{
Text_def * td_l = (Text_def*)script_p->specs_p_;
Scalar style = get_property ("textstyle");
Staff_side::do_substitute_dependency (o,n);
if (o == stem_l_)
{
- stem_l_ = n ? (Stem*)dynamic_cast <Item *> (n) : 0;
+ stem_l_ = dynamic_cast<Stem *> (n);
}
}
void
Separating_group_spanner::do_substitute_dependency (Score_element*o, Score_element*n)
{
- if (o->is_type_b (Single_malt_grouping_item::static_name ()))
+ if (dynamic_cast<Single_malt_grouping_item *> (o))
{
- Single_malt_grouping_item*ns = n ?
- (Single_malt_grouping_item*)dynamic_cast <Item *> (n) : 0;
- spacing_unit_l_arr_.substitute ((Single_malt_grouping_item*)dynamic_cast <Item *> (o), ns);
+ Single_malt_grouping_item*ns = dynamic_cast<Single_malt_grouping_item *> (n);
+ spacing_unit_l_arr_.substitute (dynamic_cast<Single_malt_grouping_item *> (o), ns);
}
}
Item * it = dynamic_cast <Item *> (i.elem_l_);
if (it && !it->axis_group_l_a_[X_AXIS])
{
- Single_malt_grouping_item *&p_ref_ (it->breakable_b_ ?
- break_malt_p_ : nobreak_malt_p_);
+ Single_malt_grouping_item *&p_ref_ (it->breakable_b_
+ ? break_malt_p_ : nobreak_malt_p_);
if (!p_ref_)
{
{
if (dynamic_cast <Item *> (o))
{
- item_l_arr_.unordered_substitute (dynamic_cast <Item *> (o), n ? dynamic_cast <Item *> (n) : 0);
+ item_l_arr_.unordered_substitute (dynamic_cast <Item *> (o),
+ dynamic_cast <Item *> (n));
}
}
Slur_engraver::do_try_request (Request *req_l)
{
Musical_req *mus_l = dynamic_cast <Musical_req *> (req_l);
- if (!mus_l || !dynamic_cast <Slur_req *> (mus_l))
- return false;
-
- new_slur_req_l_arr_.push (dynamic_cast <Slur_req *> (mus_l));
- return true;
+ if (Slur_req *sl = dynamic_cast <Slur_req *> (mus_l))
+ {
+ new_slur_req_l_arr_.push (dynamic_cast <Slur_req *> (mus_l));
+ return true;
+ }
+ return false;
}
void
Slur_engraver::acknowledge_element (Score_element_info info)
{
- if (info.elem_l_->is_type_b (Note_column::static_name ()))
+ if (dynamic_cast<Note_column *> (info.elem_l_))
{
- Note_column *col_l =(Note_column*) dynamic_cast <Item *> (info.elem_l_) ;// ugh
+ Note_column *col_l =dynamic_cast<Note_column *> (info.elem_l_) ;// ugh
for (int i = 0; i < slur_l_stack_.size(); i++)
slur_l_stack_[i]->add_column (col_l);
for (int i = 0; i < end_slur_l_arr_.size(); i++)
Slur::do_substitute_dependency (Score_element*o, Score_element*n)
{
int i;
- while ((i = encompass_arr_.find_i ((Note_column*)dynamic_cast <Item *> (o))) >=0)
+ while ((i = encompass_arr_.find_i (dynamic_cast<Note_column *> (o))) >=0)
{
if (n)
- encompass_arr_[i] = (Note_column*)dynamic_cast <Item *> (n);
+ encompass_arr_[i] = dynamic_cast<Note_column *> (n);
else
encompass_arr_.del (i);
}
{
int depth = i.origin_grav_l_arr_.size();
if (depth > 1
- && i.elem_l_->is_type_b (Bar::static_name()))
+ && dynamic_cast<Bar *> (i.elem_l_))
{
- bar_l_arr_.push ((Bar*)dynamic_cast <Item *> (i.elem_l_));
+ bar_l_arr_.push (dynamic_cast<Bar *> (i.elem_l_));
if (bar_l_arr_.size() >= 2 && !spanbar_p_)
/*
spanbar_p_-> type_str_ = bar_l_arr_[0]->type_str_;
}
}
- else if (i.elem_l_->is_type_b (Vertical_align_spanner::static_name())
+ else if (dynamic_cast<Vertical_align_spanner *> (i.elem_l_)
&& i.origin_grav_l_arr_.size() <= 2)
{
- valign_l_ = (Vertical_align_spanner*)dynamic_cast <Spanner *> (i.elem_l_);
+ valign_l_ = dynamic_cast<Vertical_align_spanner *> (i.elem_l_);
}
}
Staff_group_bar_engraver::acknowledge_element (Score_element_info i)
{
Span_bar_engraver::acknowledge_element (i);
- if (i.elem_l_->is_type_b (Piano_brace::static_name ()))
+ if (dynamic_cast<Piano_brace *> (i.elem_l_))
{
Span_bar* b = dynamic_cast <Span_bar *> (i.elem_l_);
Piano_brace * piano_l = (Piano_brace*) b;
#include "score-column.hh"
#include "paper-def.hh"
#include "colhpos.hh"
+#include "main.hh"
Vector
Spring_spacer::default_solution() const
void
Spring_spacer::solve (Column_x_positions*positions) const
{
-
DOUT << "Spring_spacer::solve ()...";
- Vector solution_try;
+ Vector solution_try;
+
bool constraint_satisfaction = try_initial_solution_and_tell (solution_try);
if (constraint_satisfaction)
{
make_matrices (lp.quad_,lp.lin_, lp.const_term_);
make_constraints (lp);
set_fixed_cols (lp);
-
+
Vector solution_vec (lp.solve (solution_try));
-
+
positions->satisfies_constraints_b_ = check_constraints (solution_vec);
if (!positions->satisfies_constraints_b_)
{
{
positions->set_stupid_solution (solution_try);
}
+
DOUT << "Finished Spring_spacer::solve ()...";
}
if (!it
|| script_p_
- || !it->is_type_b (Bar::static_name())
+ || !(dynamic_cast<Bar *> (it))
|| (i.origin_grav_l_arr_.size() != 1))
return;
void
Staff_performer::play (Audio_element* p)
{
- if (p->is_type_b (Audio_item::static_name ()))
+ if (dynamic_cast<Audio_item *> (p))
{
audio_staff_p_->add_audio_item ( (Audio_item*)p);
}
void
Stem_engraver::acknowledge_element(Score_element_info i)
{
- if (i.elem_l_->is_type_b (Rhythmic_head::static_name()))
+ if (dynamic_cast<Rhythmic_head *> (i.elem_l_))
{
- Rhythmic_head *h = (Rhythmic_head*) dynamic_cast <Item *> (i.elem_l_);
+ Rhythmic_head *h = dynamic_cast<Rhythmic_head *> (i.elem_l_);
if (!stem_p_)
{
Rhythmic_req * r = dynamic_cast <Rhythmic_req *> (i.req_l_);
Stem::add_head (Rhythmic_head *n)
{
n->add_dependency (this); // ?
- if (n->is_type_b (Note_head::static_name ()))
+ if (dynamic_cast<Note_head *> (n))
{
head_l_arr_.push ((Note_head*)n);
}
- else if (n->is_type_b (Rest::static_name ()))
+ else if (dynamic_cast<Rest *> (n))
{
rest_l_arr_.push ((Rest*)n);
}
Symtables::~Symtables()
{
- for (Dictionary_iter< Symtable*> i (*this); i.ok(); i++)
+ for (Dictionary_iter<Symtable*> i (*this); i.ok(); i++)
{
delete i.val();
}
{
error (_f ("Symtable `%s\' unknown", s));
/*
- We can 't return, because we'll dump core anyway.
+ We can 't return, because we would dump core anyway.
*/
return 0;
}
else
- return Dictionary<Symtable*>::operator[](s);
+ return elem(s);
}
void
Symtables::print() const
bool
Text_def::do_equal_b (General_script_def const *gdef) const
{
- Text_def const *def= (Text_def*)gdef;
- return align_dir_ == def->align_dir_ && text_str_ == def->text_str_
+ Text_def const *def= dynamic_cast<Text_def const*>(gdef);
+ return def&& align_dir_ == def->align_dir_ && text_str_ == def->text_str_
&& style_str_ == def->style_str_;
}
Text_item::get_position_f () const
{
// uhuh, tdef/gdef?
- if ( (tdef_p_->name () != Text_def::static_name ())
- || ( ( (Text_def*)tdef_p_)->style_str_ != "finger"))
- return Staff_side::get_position_f ();
+ if (Text_def *tdl = dynamic_cast<Text_def*>(tdef_p_))
+ {
+ if (tdl->style_str_ != "finger") // HUHH?
+ return Staff_side::get_position_f ();
+ }
if (!dir_)
{
void
Tie::do_substitute_dependency (Score_element*o, Score_element*n)
{
- Note_head *new_l =n?(Note_head*)dynamic_cast <Item *> (n):0;
+ Note_head *new_l =n?dynamic_cast<Note_head *> (n):0;
if (dynamic_cast <Item *> (o) == head_l_drul_[LEFT])
head_l_drul_[LEFT] = new_l;
else if (dynamic_cast <Item *> (o) == head_l_drul_[RIGHT])
bool
Ties_engraver::do_try_request (Request*req)
{
- if (! dynamic_cast <Musical_req *> (req))
- return false;
-
- if(Tie_req * r= dynamic_cast <Tie_req *> (req))
+ if (Tie_req * r = dynamic_cast <Tie_req *> (req))
{
req_l_ = r;
return true;
{
if (!req_l_ && ! end_req_l_)
return;
- if (i.elem_l_->is_type_b (Note_head::static_name ()))
+ if (Note_head * h = dynamic_cast <Note_head *> (i.elem_l_))
{
- Note_head * h = dynamic_cast <Note_head *> (i.elem_l_);
Melodic_req *m = dynamic_cast <Melodic_req *> (i.req_l_);
head_mel_tuple_arr_.push (Head_melodic_tuple (h, m));
Time_signature_engraver::do_process_requests()
{
Translator * result =
- daddy_grav_l()->get_simple_translator (Timing_engraver::static_name());
+ daddy_grav_l()->get_simple_translator (Timing_engraver::static_name ()); // ugh
if (!result)
{
return ;
}
- Timing_engraver * timing_grav_l= (Timing_engraver*) dynamic_cast <Engraver *> (result);
+ Timing_engraver * timing_grav_l= dynamic_cast<Timing_engraver *> (result);
Time_signature_change_req *req = timing_grav_l->time_signature_req_l();
if (req)
{
- Array<Scalar> args;
+ Array<Real> args;
args.push (req->beats_i_);
args.push (req->one_beat_i_);
bool
Timing_translator::do_try_request(Request*r)
{
- Command_req * c = dynamic_cast <Command_req *> (r);
- if (!(c && dynamic_cast <Timing_req *> (c)))
- return false;
- for (int i=0; i < timing_req_l_arr_.size (); i++)
+ if (Timing_req *t = dynamic_cast <Timing_req *> (r))
{
- if (timing_req_l_arr_[i]->equal_b(r))
- return true;
- if (timing_req_l_arr_[i]->name() == r->name())
+ for (int i=0; i < timing_req_l_arr_.size (); i++)
{
- r->warning (_ ("conflicting timing request"));
- return false;
+ if (timing_req_l_arr_[i]->equal_b(t))
+ return true;
+ if (timing_req_l_arr_[i]->name() == r->name())
+ {
+ r->warning (_ ("conflicting timing request"));
+ return false;
+ }
}
+
+ timing_req_l_arr_.push(t);
+ return true;
}
-
- timing_req_l_arr_.push(dynamic_cast <Timing_req *> (c));
- return true;
+ return false;
}
+/*ugh.
+ */
Time_signature_change_req*
Timing_translator::time_signature_req_l() const
{
for (int i=0; i < timing_req_l_arr_.size (); i++)
{
Timing_req * tr_l = timing_req_l_arr_[i];
- Time_signature_change_req *m_l = dynamic_cast <Time_signature_change_req *> (tr_l);
- if (m_l)
+
+ if (Time_signature_change_req *m_l = dynamic_cast <Time_signature_change_req *> (tr_l))
{
int b_i= m_l->beats_i_;
int o_i = m_l->one_beat_i_;
Rhythmic_grouping (MInterval (0,Moment (b_i, o_i)), b_i);
}
}
- else if (dynamic_cast <Partial_measure_req *> (tr_l))
+ else if (
Partial_measure_req *pm = dynamic_cast <Partial_measure_req *> (tr_l))
{
- Moment m = dynamic_cast <Partial_measure_req *> (tr_l)->duration_;
+ Moment m = pm->duration_;
String error = time_.try_set_partial_str (m);
if (error.length_i ())
{
}
}
- else if (dynamic_cast <Cadenza_req *> (tr_l))
+ else if (Cadenza_req *cr = dynamic_cast <Cadenza_req *> (tr_l))
{
- time_.set_cadenza (dynamic_cast <Cadenza_req *> (tr_l)->on_b_);
+ time_.set_cadenza (cr->on_b_);
}
- else if (dynamic_cast <Measure_grouping_req *> (tr_l))
+ else if (Measure_grouping_req *mg=dynamic_cast <Measure_grouping_req *> (tr_l))
{
default_grouping_ =
- parse_grouping (dynamic_cast <Measure_grouping_req *> (tr_l)->beat_i_arr_,
- dynamic_cast <Measure_grouping_req *> (tr_l)->elt_length_arr_);
+ parse_grouping (mg->beat_i_arr_,
+ mg->elt_length_arr_);
}
}
{
timing_req_l_arr_.set_size (0);
Global_translator *global_l =
- daddy_trans_l_->ancestor_l (100)->global_l (); // ugh 100.
+ dynamic_cast<Global_translator*> (daddy_trans_l_->ancestor_l (100)); // ugh 100.
/* allbars == ! skipbars */
bool
Type_swallow_translator::do_try_request (Request*r)
{
- if (type_&&r->is_type_b (type_))
- return true;
- return false;
+ // if (type_ && type_->before (typeid( *r))) //
+ // return true;
+ return false; // ugh. FIXME.
}
IMPLEMENT_IS_TYPE_B1(Type_swallow_translator, Translator);
Vertical_align_engraver::acknowledge_element (Score_element_info i)
{
if (i.origin_grav_l_arr_.size() == 1 &&
- i.elem_l_->is_type_b (Vertical_group_spanner::static_name()) &&
+ dynamic_cast<Vertical_group_spanner *> (i.elem_l_) &&
!i.elem_l_->axis_group_l_a_[Y_AXIS])
{
assert (!valign_p_->contains_b (i.elem_l_));
-LILYPOND_INCLUDES = $(include-lib) $(depth)/lib/$(outdir) $(include-flower) $(depth)/flower/$(outdir)
+LILYPOND_INCLUDES = -Istinho $(include-lib) $(depth)/lib/$(outdir) $(include-flower) $(depth)/flower/$(outdir)
# should use to create .spec ?
#
SUBDIRS = scripts buildscripts flower lib lily mf mi2mu po debian \
Documentation init input tex make mutopia test intl stepmake\
- ps
+ ps
#
SCRIPTS = configure aclocal.m4
# - rewrite in python
program_name = 'convert-mudela'
-version = '0.3'
+version = '0.4'
import os
outfile.close ()
if __main__.edit:
+ try:
+ os.remove(infile_name + '~')
+ except:
+ pass
os.rename (infile_name, infile_name + '~')
os.rename (infile_name + '.NEW', infile_name)
rm -f ${srcdir}/config.cache
PYTHON=${PYTHON:-python} ${srcdir}/configure --prefix=${distdir} \
- --srcdir=${srcdir} \
- --enable-tex-prefix=${distdir}/texmf \
- --enable-tex-dir=${distdir}/texmf/tex \
- --enable-mf-dir=${distdir}/texmf/mf
+ --srcdir=${srcdir}
if ! make ; then
echo "make failed"
#
# Rename python files to <filename>.py
#
-mv $distdir/bin/ly2dvi32 $distdir/bin/ly2dvi.py
+mv $distdir/bin/ly2dvi $distdir/bin/ly2dvi.py
mv $distdir/bin/convert-mudela $distdir/bin/convert-mudela.py
mv $distdir/bin/mudela-book $distdir/bin/mudela-book.py
#
mkdir $distdir/doc
cp Documentation/man/out/*.txt $distdir/doc
-mv $distdir/doc/ly2dvi32.txt $distdir/doc/ly2dvi_py.txt
+mv $distdir/doc/ly2dvi32.txt $distdir/doc/ly2dvi.txt
cd $distdir/..
$ZIP_CMD $ZIP_FILE $name
echo "Wrote $ZIP_FILE"
YY_FILES := $(wildcard *.yy)
LL_FILES := $(wildcard *.ll)
-SOURCE_FILES+=$(YY_FILES) $(CC_FILES) $(INL_FILES) $(TCC_FILES) $(HH_FILES) $(LL_FILES)
-O_FILES+=$(addprefix $(outdir)/, $(YY_FILES:.yy=.o) $(CC_FILES:.cc=.o) $(LL_FILES:.ll=.o))
+SOURCE_FILES+= $(CC_FILES) $(YY_FILES) $(INL_FILES) $(TCC_FILES) $(HH_FILES) $(LL_FILES)
+O_FILES+=$(addprefix $(outdir)/, $(CC_FILES:.cc=.o) $(LL_FILES:.ll=.o) $(YY_FILES:.yy=.o))
TAGS_FILES += $(TCC_FILES) $(HH_FILES) $(INL_FILES) $(CC_FILES)
#
ARFLAGS = ru
-INCLUDES = include $(outdir) $($(PACKAGE)_INCLUDES)
+INCLUDES = include $(outdir) $($(PACKAGE)_INCLUDES) $(MODULE_INCLUDES)
# urg: for windows ?
# LOADLIBES = $(MODULE_LIBES) $($(PACKAGE)_LIBES) $(EXTRA_LIBES) -lstdc++
projects / lilypond.git / commitdiff