Atom::print() const
{
#ifndef NPRINT
- mtor << "texstring: " <<sym_.tex<<"\n";
+ DOUT << "texstring: " <<sym_.tex<<"\n";
#endif
}
Box
Atom::extent() const
{
- Box b( sym_.dim);
- b.translate(off_);
+ Box b (sym_.dim);
+ b.translate (off_);
return b;
}
-Atom::Atom(Symbol s)
+Atom::Atom (Symbol s)
{
sym_=s;
}
Atom::TeX_string() const
{
/* infinity checks. */
- assert( abs(off_.x()) < 100 CM);
- assert( abs(off_.y()) < 100 CM);
+ assert (abs (off_.x()) < 100 CM);
+ assert (abs (off_.y()) < 100 CM);
// whugh.. Hard coded...
- String s("\\placebox{%}{%}{%}");
+ String s ("\\placebox{%}{%}{%}");
Array<String> a;
- a.push(print_dimen(off_.y()));
- a.push(print_dimen(off_.x()));
- a.push(sym_.tex);
- return substitute_args(s, a);
+ a.push (print_dimen (off_.y()));
+ a.push (print_dimen (off_.x()));
+ a.push (sym_.tex);
+ return substitute_args (s, a);
}
#include "debug.hh"
-Audio_column::Audio_column( Moment at_mom )
+Audio_column::Audio_column (Moment at_mom)
{
at_mom_ = at_mom;
audio_score_l_ = 0;
}
void
-Audio_column::add( Audio_item* l )
+Audio_column::add (Audio_item* l)
{
- audio_item_l_list_.bottom().add( l );
+ audio_item_l_list_.bottom().add (l);
l->audio_column_l_ = this;
}
Audio_column::print() const
{
#ifndef NPRINT
- mtor << "Audio_column {";
- mtor << "at: " << at_mom_ << "\n";
- mtor << "}\n";
+ DOUT << "Audio_column {";
+ DOUT << "at: " << at_mom_ << "\n";
+ DOUT << "}\n";
#endif
}
#include "audio-item.hh"
#include "midi-item.hh"
-Audio_instrument::Audio_instrument( String instrument_str )
- : Audio_item( 0 )
+Audio_instrument::Audio_instrument (String instrument_str)
+ : Audio_item (0)
{
str_ = instrument_str;
}
Midi_item*
Audio_instrument::midi_item_p()
{
- return new Midi_instrument( 0, str_ );
+ return new Midi_instrument (0, str_);
}
-Audio_item::Audio_item( Request* req_l )
+Audio_item::Audio_item (Request* req_l)
{
audio_column_l_ = 0;
req_l_ = req_l;
}
-Audio_key::Audio_key( Request* req_l )
- : Audio_item( req_l )
+Audio_key::Audio_key (Request* req_l)
+ : Audio_item (req_l)
{
}
Midi_item*
Audio_key::midi_item_p()
{
- return new Midi_key( this );
+ return new Midi_key (this);
}
-Audio_note::Audio_note( Request* req_l )
- : Audio_item( req_l )
+Audio_note::Audio_note (Request* req_l)
+ : Audio_item (req_l)
{
}
Midi_item*
Audio_note::midi_item_p()
{
- return new Midi_note( this );
+ return new Midi_note (this);
}
-Audio_tempo::Audio_tempo( int per_minute_4_i )
- : Audio_item( 0 )
+Audio_tempo::Audio_tempo (int per_minute_4_i)
+ : Audio_item (0)
{
per_minute_4_i_ = per_minute_4_i;
}
Midi_item*
Audio_tempo::midi_item_p()
{
- return new Midi_tempo( this );
+ return new Midi_tempo (this);
}
-Audio_meter::Audio_meter( Request* req_l )
- : Audio_item( req_l )
+Audio_meter::Audio_meter (Request* req_l)
+ : Audio_item (req_l)
{
}
Midi_item*
Audio_meter::midi_item_p()
{
- return new Midi_meter( this );
+ return new Midi_meter (this);
}
-Audio_text::Audio_text( Audio_text::Type type, String text_str )
- : Audio_item( 0 )
+Audio_text::Audio_text (Audio_text::Type type, String text_str)
+ : Audio_item (0)
{
text_str_ = text_str;
type_ = type;
Midi_item*
Audio_text::midi_item_p()
{
- return new Midi_text( this );
+ return new Midi_text (this);
}
#include "audio-score.hh"
#include "score.hh"
-Audio_score::Audio_score( Score* l )
+Audio_score::Audio_score (Score* l)
{
score_l_ = l;
}
void
-Audio_score::add( Audio_column* p )
+Audio_score::add (Audio_column* p)
{
p->audio_score_l_ = this;
- audio_column_p_list_.bottom().add(p);
+ audio_column_p_list_.bottom().add (p);
}
void
-Audio_score::output( Midi_stream& midi_stream_r )
+Audio_score::output (Midi_stream& midi_stream_r)
{
int tracks_i = audio_staff_l_list_.size() + 1;
// ugh
int clocks_per_4_i = 384;
- midi_stream_r << Midi_header( 1, tracks_i, clocks_per_4_i );
- output_header_track( midi_stream_r );
+ midi_stream_r << Midi_header (1, tracks_i, clocks_per_4_i);
+ output_header_track (midi_stream_r);
int n = 1;
- for ( PCursor<Audio_staff*> i( audio_staff_l_list_ ); i.ok(); i++ )
- i->output( midi_stream_r, n++ );
+ for ( PCursor<Audio_staff*> i (audio_staff_l_list_); i.ok(); i++ )
+ i->output (midi_stream_r, n++);
}
void
-Audio_score::output_header_track( Midi_stream& midi_stream_r )
+Audio_score::output_header_track (Midi_stream& midi_stream_r)
{
Midi_track midi_track;
- time_t t = time( 0 );
+ time_t t = time (0);
// perhaps multiple text events?
- String str = String( "Creator: " ) + get_version_str() + "\n";
+ String str = String ("Creator: ") + get_version_str() + "\n";
- Midi_text creator( Midi_text::TEXT, str );
- midi_track.add( Moment( 0 ), &creator );
+ Midi_text creator (Midi_text::TEXT, str);
+ midi_track.add (Moment (0), &creator );
str = "Automatically generated at ";
- str += ctime( &t );
- str = str.left_str( str.length_i() - 1 );
+ str += ctime (&t);
+ str = str.left_str (str.length_i() - 1);
str += "\n";
- Midi_text generate( Midi_text::TEXT, str );
- midi_track.add( Moment( 0 ), &generate );
+ Midi_text generate (Midi_text::TEXT, str);
+ midi_track.add (Moment (0), &generate );
str = "from musical definition: ";
str += score_l_->location_str();
- Midi_text from( Midi_text::TEXT, str );
- midi_track.add( Moment( 0 ), &from );
+ Midi_text from (Midi_text::TEXT, str);
+ midi_track.add (Moment (0), &from );
- Midi_text track_name( Midi_text::TRACK_NAME, "Track "
- + String_convert::i2dec_str( 0, 0, '0' ) );
- midi_track.add( Moment( 0 ), &track_name );
+ Midi_text track_name (Midi_text::TRACK_NAME, "Track "
+ + String_convert::i2dec_str (0, 0, '0') );
+ midi_track.add (Moment (0), &track_name );
- Midi_tempo tempo( score_l_->midi_p_->get_tempo_i( Moment( 1, 4 ) ) );
- midi_track.add( Moment(0), &tempo);
+ Midi_tempo tempo (score_l_->midi_p_->get_tempo_i (Moment (1, 4) ) );
+ midi_track.add (Moment (0), &tempo);
midi_stream_r << midi_track;
}
void
-Audio_score::add_staff( Audio_staff* l )
+Audio_score::add_staff (Audio_staff* l)
{
- audio_staff_l_list_.bottom().add( l );
+ audio_staff_l_list_.bottom().add (l);
}
void
-Audio_score::add(Audio_element *p)
+Audio_score::add (Audio_element *p)
{
- audio_elem_p_list_.bottom().add( p);
+ audio_elem_p_list_.bottom().add (p);
}
void
Audio_score::print() const
{
#ifndef NPRINT
- mtor << "Audio_score { ";
+ DOUT << "Audio_score { ";
score_l_->midi_p_->print();
- mtor << "\ncolumns: ";
- for ( PCursor<Audio_column*> i( audio_column_p_list_ ); i.ok(); i++ )
+ DOUT << "\ncolumns: ";
+ for ( PCursor<Audio_column*> i (audio_column_p_list_); i.ok(); i++ )
i->print();
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
#include "midi-walker.hh"
void
-Audio_staff::add( Audio_item* l )
+Audio_staff::add (Audio_item* l)
{
- audio_item_l_list_.bottom().add( l );
+ audio_item_l_list_.bottom().add (l);
}
void
-Audio_staff::output( Midi_stream& midi_stream_r, int track_i )
+Audio_staff::output (Midi_stream& midi_stream_r, int track_i)
{
Midi_track midi_track;
midi_track.number_i_ = track_i;
- for ( Midi_walker i( this, &midi_track ); i.ok(); i++ )
+ for ( Midi_walker i (this, &midi_track); i.ok(); i++ )
i.process();
midi_stream_r << midi_track;
}
Link_array<Score_elem> elems = axis_admin_.elem_l_arr_;
for (int i=0; i < elems.size(); i++) {
Item * it_l = elems[i]->item();
- assert(it_l);
+ assert (it_l);
// somebody probably broke it in pieces
- assert (it_l->pcol_l_ == pcol_l_ );
+ assert (it_l->pcol_l_ == pcol_l_);
}
}
for (int i=0; i < elems.size(); i++) {
Item* it_l = elems[i]->item();
for ( int j=0; j < 2; j++) {
- Item *new_l = it_l->find_prebroken_piece(broken_to_a_[j]->pcol_l_);
- ((Axis_group_item*)broken_to_a_[j])->add_element( new_l );
+ Item *new_l = it_l->find_prebroken_piece (broken_to_a_[j]->pcol_l_);
+ ((Axis_group_item*)broken_to_a_[j])->add_element (new_l);
}
}
Item::do_breakable_col_processing();
&& item_l->break_status_i() == 0) {
// last two checks are paranoia
Item * broken_item_l =
- item_l->find_prebroken_piece( my_line );
- add_element( broken_item_l );
+ item_l->find_prebroken_piece (my_line);
+ add_element (broken_item_l);
}
- remove_element( elems[i] );
+ remove_element (elems[i]);
}
}
return;
}
- break_into_pieces( true );
+ break_into_pieces (true);
Link_array<Score_elem> loose_elems = axis_admin_.elem_l_arr_;
remove_all();
Score_elem * elt = loose_elems[i];
Line_of_score *elt_line = elt->line_l();
- if ( ! elt_line ){
+ if ( ! elt_line){
/* this piece doesn't know where it belongs.
Find out if it was broken, and use the broken remains
*/
= (Axis_group_spanner*)broken_into_l_arr_[j];
Spanner * broken_span_l
- = sp->find_broken_piece(
+ = sp->find_broken_piece (
((Score_elem*)my_broken_l)->line_l());
if (broken_span_l)
- my_broken_l->add_element(broken_span_l );
+ my_broken_l->add_element (broken_span_l);
}
} else if (elt->item()
&& elt->item()->breakable_b_
- && elt->item()->break_status_i() == 0) {
+ && elt->item()->break_status_i () == 0) {
// broken items
for (int j =0; j < 2; j++) {
Item * my_item = elt->item()->broken_to_a_[j];
Line_of_score * item_line_l = my_item->line_l() ;
- if ( ! item_line_l )
+ if ( ! item_line_l)
continue;
Axis_group_spanner * v
- = (Axis_group_spanner*)find_broken_piece( item_line_l );
+ = (Axis_group_spanner*)find_broken_piece (item_line_l);
if (v)
- v->add_element( my_item );
+ v->add_element (my_item);
}
}
Put it in appropriate piece of this spanner
*/
Axis_group_spanner * my_broken_l
- = (Axis_group_spanner*)find_broken_piece( elt->line_l() );
- my_broken_l->add_element( elt );
+ = (Axis_group_spanner*)find_broken_piece (elt->line_l());
+ my_broken_l->add_element (elt);
}
}
/** don't copy anything: an element can only be in one
Axis_group_element at one time. */
-Axis_group_administration::Axis_group_administration(
+Axis_group_administration::Axis_group_administration (
Axis_group_administration const&)
{
}
bool
-Axis_group_administration::contains_b(Score_elem const *e)const
+Axis_group_administration::contains_b (Score_elem const *e)const
{
- return elem_l_arr_.find_l(e);
+ return elem_l_arr_.find_l (e);
}
Interval
-Axis_group_administration::extent(Axis axis)const
+Axis_group_administration::extent (Axis axis)const
{
Interval r;
for (int i=0; i < elem_l_arr_.size(); i++)
- r.unite(elem_l_arr_[i]->extent(axis));
+ r.unite (elem_l_arr_[i]->extent (axis));
return r;
}
void
-Axis_group_administration::add_element(Score_elem*e,
+Axis_group_administration::add_element (Score_elem*e,
Axis_group_element*g, Axis a1, Axis a2)
{
- assert( ! e->axis_group_l_a_[a1] && !e->axis_group_l_a_[a2] );
+ assert (! e->axis_group_l_a_[a1] && !e->axis_group_l_a_[a2]);
e->axis_group_l_a_[a1] = g;
e->axis_group_l_a_[a2] = g;
elem_l_arr_.push ( e);
void
-Axis_group_administration::remove_element(Score_elem*e, Axis a1, Axis a2)
+Axis_group_administration::remove_element (Score_elem*e, Axis a1, Axis a2)
{
- assert( contains_b( e));
- elem_l_arr_.unordered_substitute(e,0);
+ assert (contains_b (e));
+ elem_l_arr_.unordered_substitute (e,0);
e->axis_group_l_a_[a1] = 0;
e->axis_group_l_a_[a2] = 0;
}
void
-Axis_group_administration::remove_all(Axis a1, Axis a2)
+Axis_group_administration::remove_all (Axis a1, Axis a2)
{
for (int i=0; i < elem_l_arr_.size(); i++) {
Score_elem*e=elem_l_arr_[i];
{
#ifndef NPRINT
for (int i=0; i < elem_l_arr_.size(); i++)
- mtor << elem_l_arr_[i]->name() << ' ';
+ DOUT << elem_l_arr_[i]->name() << ' ';
#endif
}
#include "string.hh"
String
-axis_name_str(Axis a)
+axis_name_str (Axis a)
{
return String (a + 'x');
}
void
-Bar_column_engraver::acknowledge_element(Score_elem_info info)
+Bar_column_engraver::acknowledge_element (Score_elem_info info)
{
- if (info.elem_l_->is_type_b(Script::static_name())
+ if (info.elem_l_->is_type_b (Script::static_name())
&& info.req_l_->command()
&& info.origin_grav_l_arr_.size() == 1) {
- script_l_arr_.push( (Script*)info.elem_l_->item());
+ script_l_arr_.push ((Script*)info.elem_l_->item());
} else {
if (info.origin_grav_l_arr_.size() == 1
- && info.elem_l_->is_type_b(Bar::static_name()))
+ && info.elem_l_->is_type_b (Bar::static_name()))
bar_l_ = (Bar*)info.elem_l_->item();
}
- if ( bar_l_ && !barcol_p_ ) {
+ if ( bar_l_ && !barcol_p_) {
barcol_p_ = new Bar_column;
barcol_p_->breakable_b_ =true;
- barcol_p_->set_bar( bar_l_ );
- announce_element(Score_elem_info(barcol_p_, 0));
+ barcol_p_->set_bar (bar_l_);
+ announce_element (Score_elem_info (barcol_p_, 0));
}
- if (barcol_p_ ) {
+ if (barcol_p_) {
for (int i=0; i < script_l_arr_.size(); i++) {
script_l_arr_[i]->breakable_b_ = true;
- barcol_p_->add(script_l_arr_[i]);
+ barcol_p_->add (script_l_arr_[i]);
}
script_l_arr_.clear();
}
Bar_column_engraver::do_pre_move_processing()
{
if (barcol_p_) {
- typeset_element( barcol_p_ );
+ typeset_element (barcol_p_);
barcol_p_ =0;
}
}
}
void
-Bar_column::set_bar(Bar*b)
+Bar_column::set_bar (Bar*b)
{
- Script_column::add_support( b );
+ Script_column::add_support (b);
bar_l_ = b;
}
void
-Bar_column::do_substitute_dependency(Score_elem*o,Score_elem*n)
+Bar_column::do_substitute_dependency (Score_elem*o,Score_elem*n)
{
- Script_column::do_substitute_dependency(o,n);
- if ( o == bar_l_ ) {
+ Script_column::do_substitute_dependency (o,n);
+ if ( o == bar_l_) {
bar_l_ = n ? (Bar*)n->item() : 0;
}
}
}
bool
-Bar_engraver::do_try_request(Request*r_l)
+Bar_engraver::do_try_request (Request*r_l)
{
Command_req* c_l = r_l->command();
if (!c_l|| !c_l->bar())
return false;
Bar_req * b= c_l->bar();
- if (bar_req_l_ && bar_req_l_->equal_b(b))
+ if (bar_req_l_ && bar_req_l_->equal_b (b))
return false;
bar_req_l_ = b;
void
Bar_engraver::do_process_requests()
{
- if (bar_req_l_ ) {
+ if (bar_req_l_) {
bar_p_ = new Bar;
bar_p_->type_str_=bar_req_l_->type_str_;
} else if (!get_staff_info().time_C_->whole_in_measure_) {
}
if (bar_p_){
- announce_element(Score_elem_info(bar_p_, bar_req_l_) );
+ announce_element (Score_elem_info (bar_p_, bar_req_l_));
} else {
Disallow_break_req r;
- daddy_grav_l_->try_request(&r);
+ daddy_grav_l_->try_request (&r);
}
}
Bar_engraver::do_pre_move_processing()
{
if (bar_p_) {
- typeset_element(bar_p_);
+ typeset_element (bar_p_);
bar_p_ =0;
}
}
static Command_script_req dummy;
void
-Bar_number_grav::acknowledge_element(Score_elem_info i)
+Bar_number_grav::acknowledge_element (Score_elem_info i)
{
if (i.origin_grav_l_arr_.size() == 1 &&
- i.elem_l_->is_type_b( Bar::static_name()) && !script_p_) {
+ i.elem_l_->is_type_b (Bar::static_name()) && !script_p_) {
script_p_ = new Script;
Text_def *td_p =new Text_def;
script_p_->breakable_b_ = true;
script_p_->dir_i_ = 1;
- announce_element(Score_elem_info( script_p_, &dummy));
+ announce_element (Score_elem_info (script_p_, &dummy));
}
}
void
Bar_number_grav::do_pre_move_processing()
{
- if ( script_p_ ) {
- typeset_element(script_p_);
+ if ( script_p_) {
+ typeset_element (script_p_);
script_p_ =0;
}
}
void
Bar::do_print()const
{
- mtor << type_str_;
+ DOUT << type_str_;
}
Molecule*
Bar::brew_molecule_p()const
{
Paper_def *p = paper();
- Symbol s = p->lookup_l()->bar( type_str_,
- p->get_var("bar_size") );
- Molecule*output = new Molecule(Atom(s));
+ Symbol s = p->lookup_l()->bar (type_str_,
+ p->get_var ("bar_size"));
+ Molecule*output = new Molecule (Atom (s));
return output;
}
int beams_i_;
Stem_info(){}
- Stem_info(Stem const *);
+ Stem_info (Stem const *);
};
-Stem_info::Stem_info(Stem const *s)
+Stem_info::Stem_info (Stem const *s)
{
x = s->hpos_f();
dir_i_ = s->dir_i_;
- beams_i_ = intlog2( s->flag_i_ ) - 2;
+ beams_i_ = intlog2( s->flag_i_) - 2;
/*
[todo]
*/
- Real notehead_y = s->paper()->interline_f();
+ Real notehead_y = s->paper()->interline_f ();
// huh? why do i need the / 2
-// Real interbeam_f = s->paper()->interbeam_f();
- Real interbeam_f = s->paper()->interbeam_f() / 2;
+// Real interbeam_f = s->paper()->interbeam_f ();
+ Real interbeam_f = s->paper()->interbeam_f () / 2;
/* well eh, huh?
idealy_f_ = dir_i_ * s->stem_start_f() + beams_i_ * interbeam_f;
- if ( beams_i_ < 3 )
+ if ( beams_i_ < 3)
idealy_f_ += 2 * interline_f;
else
idealy_f_ += 1.5 * interline_f;
miny_f_ = dir_i_ * s->stem_start_f() + notehead_y + beams_i_ * interbeam_f;
idealy_f_ = miny_f_ >? idealy_f_;
-// assert(miny_f_ <= idealy_f_);
+// assert (miny_f_ <= idealy_f_);
}
Offset
Beam::center()const
{
- Real w=(paper()->note_width() + width().length())/2.0;
- return Offset(w, (left_pos + w* slope)*paper()->internote_f());
+ Real w=(paper()->note_width () + width ().length ())/2.0;
+ return Offset (w, (left_pos + w* slope)*paper()->internote_f ());
}
}
void
-Beam::add(Stem*s)
+Beam::add (Stem*s)
{
- stems.push(s);
- s->add_dependency(this);
+ stems.push (s);
+ s->add_dependency (this);
s->print_flag_b_ = false;
}
if (i->invisible_b())
continue;
- Stem_info info(i);
- sinfo.push(info);
+ Stem_info info (i);
+ sinfo.push (info);
}
- if (! sinfo.size() )
+ if (! sinfo.size())
slope = left_pos = 0;
else if (sinfo.size() == 1) {
slope = 0;
Least_squares l;
for (int i=0; i < sinfo.size(); i++) {
sinfo[i].x -= leftx;
- l.input.push(Offset(sinfo[i].x, sinfo[i].idealy_f_));
+ l.input.push (Offset (sinfo[i].x, sinfo[i].idealy_f_));
}
- l.minimise(slope, left_pos);
+ l.minimise (slope, left_pos);
}
Real dy = 0.0;
slope *= dir_i_;
/*
- This neat trick is by Werner Lemberg, damped = tanh(slope) corresponds
+ This neat trick is by Werner Lemberg, damped = tanh (slope) corresponds
with some tables in [Wanske]
*/
- slope = 0.6 * tanh(slope);
+ slope = 0.6 * tanh (slope);
// ugh
- Real sl = slope*paper()->internote_f();
- paper()->lookup_l()->beam(sl, 20 PT);
- slope = sl /paper()->internote_f();
+ Real sl = slope*paper()->internote_f ();
+ paper()->lookup_l ()->beam (sl, 20 PT);
+ slope = sl /paper()->internote_f ();
}
void
Stem *s = stems[j];
Real x = s->hpos_f()-x0;
- s->set_stemend(left_pos + slope * x);
+ s->set_stemend (left_pos + slope * x);
}
}
Beam::do_post_processing()
{
if ( stems.size() < 2) {
- warning("Beam with less than 2 stems");
+ warning ("Beam with less than 2 stems");
transparent_b_ = true;
return ;
}
}
void
-Beam::set_grouping(Rhythmic_grouping def, Rhythmic_grouping cur)
+Beam::set_grouping (Rhythmic_grouping def, Rhythmic_grouping cur)
{
def.OK();
cur.OK();
- assert(cur.children.size() == stems.size());
+ assert (cur.children.size() == stems.size ());
- cur.split(def);
+ cur.split (def);
Array<int> b;
{
for (int j=0; j <stems.size(); j++) {
Stem *s = stems[j];
- int f = intlog2(abs(s->flag_i_))-2;
- assert(f>0);
- flags.push(f);
+ int f = intlog2(abs (s->flag_i_))-2;
+ assert (f>0);
+ flags.push (f);
}
int fi =0;
- b= cur.generate_beams(flags, fi);
- b.insert(0,0);
- b.push(0);
- assert(stems.size() == b.size()/2);
+ b= cur.generate_beams (flags, fi);
+ b.insert (0,0);
+ b.push (0);
+ assert (stems.size() == b.size ()/2);
}
- for (int j=0, i=0; i < b.size() && j <stems.size(); i+= 2, j++) {
+ for (int j=0, i=0; i < b.size() && j <stems.size (); i+= 2, j++) {
Stem *s = stems[j];
s->beams_left_i_ = b[i];
s->beams_right_i_ = b[i+1];
Interval
Beam::do_width() const
{
- return Interval( stems[0]->hpos_f(),
- stems.top()->hpos_f() );
+ return Interval (stems[0]->hpos_f(),
+ stems.top()->hpos_f ());
}
/*
beams to go with one stem.
*/
Molecule
-Beam::stem_beams(Stem *here, Stem *next, Stem *prev)const
+Beam::stem_beams (Stem *here, Stem *next, Stem *prev)const
{
- assert( !next || next->hpos_f() > here->hpos_f() );
- assert( !prev || prev->hpos_f() < here->hpos_f() );
-// Real dy=paper()->internote_f()*2;
- Real dy = paper()->interbeam_f();
- Real stemdx = paper()->rule_thickness();
- Real sl = slope*paper()->internote_f();
- paper()->lookup_l()->beam(sl, 20 PT);
+ assert (!next || next->hpos_f() > here->hpos_f () );
+ assert (!prev || prev->hpos_f() < here->hpos_f () );
+// Real dy=paper()->internote_f ()*2;
+ Real dy = paper()->interbeam_f ();
+ Real stemdx = paper()->rule_thickness ();
+ Real sl = slope*paper()->internote_f ();
+ paper()->lookup_l ()->beam (sl, 20 PT);
Molecule leftbeams;
Molecule rightbeams;
if (prev) {
int lhalfs= lhalfs = here->beams_left_i_ - prev->beams_right_i_ ;
int lwholebeams= here->beams_left_i_ <? prev->beams_right_i_ ;
- Real w = (here->hpos_f() - prev->hpos_f())/4;
+ Real w = (here->hpos_f() - prev->hpos_f ())/4;
Symbol dummy;
- Atom a(dummy);
+ Atom a (dummy);
if (lhalfs) // generates warnings if not
- a = paper()->lookup_l()->beam(sl, w);
- a.translate(Offset (-w, -w * sl));
+ a = paper()->lookup_l ()->beam (sl, w);
+ a.translate (Offset (-w, -w * sl));
for (int j = 0; j < lhalfs; j++) {
- Atom b(a);
- b.translate( -dir_i_ * dy * (lwholebeams+j), Y_AXIS);
- leftbeams.add( b );
+ Atom b (a);
+ b.translate (-dir_i_ * dy * (lwholebeams+j), Y_AXIS);
+ leftbeams.add (b);
}
}
int rhalfs = here->beams_right_i_ - next->beams_left_i_;
int rwholebeams = here->beams_right_i_ <? next->beams_left_i_;
- Real w = next->hpos_f() - here->hpos_f();
- Atom a = paper()->lookup_l()->beam(sl, w + stemdx);
+ Real w = next->hpos_f() - here->hpos_f ();
+ Atom a = paper()->lookup_l ()->beam (sl, w + stemdx);
int j = 0;
for (; j < rwholebeams; j++) {
- Atom b(a);
- b.translate( -dir_i_ * dy * j, Y_AXIS);
- rightbeams.add( b );
+ Atom b (a);
+ b.translate (-dir_i_ * dy * j, Y_AXIS);
+ rightbeams.add (b);
}
w /= 4;
if (rhalfs)
- a = paper()->lookup_l()->beam(sl, w);
+ a = paper()->lookup_l ()->beam (sl, w);
for (; j < rwholebeams + rhalfs; j++) {
- Atom b(a);
- b.translate( -dir_i_ * dy * j, Y_AXIS);
- rightbeams.add(b );
+ Atom b (a);
+ b.translate (-dir_i_ * dy * j, Y_AXIS);
+ rightbeams.add (b);
}
}
- leftbeams.add(rightbeams);
+ leftbeams.add (rightbeams);
return leftbeams;
}
Molecule *mol_p = new Molecule;
// huh? inter-what
-// Real inter_f = paper()->interbeam_f();
- Real inter_f = paper()->internote_f();
+// Real inter_f = paper()->interbeam_f ();
+ Real inter_f = paper()->internote_f ();
Real x0 = stems[0]->hpos_f();
for (int j=0; j <stems.size(); j++) {
Stem *i = stems[j];
Stem * prev = (j > 0)? stems[j-1] : 0;
Stem * next = (j < stems.size()-1) ? stems[j+1] :0;
- Molecule sb = stem_beams(i, next, prev);
+ Molecule sb = stem_beams (i, next, prev);
Real x = i->hpos_f()-x0;
- sb.translate(Offset(x, (x * slope + left_pos)* inter_f));
- mol_p->add(sb);
+ sb.translate (Offset (x, (x * slope + left_pos)* inter_f));
+ mol_p->add (sb);
}
- mol_p->translate(x0 - left_col_l_->hpos_f_, X_AXIS);
+ mol_p->translate (x0 - left_col_l_->hpos_f_, X_AXIS);
return mol_p;
}
Beam::do_print()const
{
#ifndef NPRINT
- mtor << "slope " <<slope << "left ypos " << left_pos;
+ DOUT << "slope " <<slope << "left ypos " << left_pos;
Spanner::do_print();
#endif
}
void
-Beam::do_substitute_dependent(Score_elem*o,Score_elem*n)
+Beam::do_substitute_dependent (Score_elem*o,Score_elem*n)
{
- if (o->is_type_b( Stem::static_name() )) {
- stems.substitute( (Stem*)o->item(), n?(Stem*) n->item():0);
+ if (o->is_type_b (Stem::static_name())) {
+ stems.substitute ((Stem*)o->item(), n?(Stem*) n->item ():0);
}
}
{
int dy = right_pos_i_-left_pos_i_;
- Real w = width().length();
+ Real w = width().length ();
- return Offset(w/2,dy * paper()->internote_f());
+ return Offset (w/2,dy * paper()->internote_f ());
}
Bow::brew_molecule_p() const
{
Molecule*output = new Molecule;
- Real w = width().length();
+ Real w = width().length ();
int dy = right_pos_i_ - left_pos_i_;
- Real nw_f = paper()->note_width();
- Real nh_f = paper()->internote_f();
+ Real nw_f = paper()->note_width ();
+ Real nh_f = paper()->internote_f ();
w+= (right_dx_f_ - left_dx_f_) * nw_f ;
Real round_w = w; // slur lookup rounds the slurwidth .
- Symbol sl = paper()->lookup_l()->slur(dy , round_w, dir_i_);
+ Symbol sl = paper()->lookup_l ()->slur (dy , round_w, dir_i_);
Real error = w-round_w;
- Atom a(sl);
- a.translate(Offset((left_dx_f_ + 0.5 )*nw_f + error/2,
+ Atom a (sl);
+ a.translate (Offset ((left_dx_f_ + 0.5)*nw_f + error/2,
left_pos_i_ * nh_f));
- output->add(a);
+ output->add (a);
return output;
}
{
}
-Box::Box(Interval ix, Interval iy)
+Box::Box (Interval ix, Interval iy)
{
x() = ix;
y() = iy;
String
Col_stats::str() const {
- String s(count_i_);
+ String s (count_i_);
s += " lines";
if (count_i_)
- s += String(Real(cols_i_)/count_i_, ", (with an average of %.1f columns)");
+ s += String (Real (cols_i_)/count_i_, ", (with an average of %.1f columns)");
return s;
}
void
-Col_stats::add(Line_of_cols const& line)
+Col_stats::add (Line_of_cols const& line)
{
count_i_++;
cols_i_ += line.size();
Break_algorithm::all_cols()const
{
Line_of_cols retval;
- for (PCursor<PCol*> c(pscore_l_->col_p_list_.top());
+ for (PCursor<PCol*> c (pscore_l_->col_p_list_.top());
c.ok(); c++) {
- retval.push(c);
+ retval.push (c);
}
return retval;
}
Array<int>
Break_algorithm::find_break_indices() const
{
- Line_of_cols all(all_cols());
+ Line_of_cols all (all_cols());
Array<int> retval;
for (int i=0; i < all.size(); i++)
if (all[i]->breakable_b())
- retval.push(i);
+ retval.push (i);
if ( linelength <=0)
while ( retval.size() >2)
- retval.del(1);
+ retval.del (1);
return retval;
}
Line_of_cols
Break_algorithm::find_breaks() const
{
- Line_of_cols all(all_cols());
+ Line_of_cols all (all_cols());
Line_of_cols retval;
for (int i=0; i < all.size(); i++)
if (all[i]->breakable_b())
- retval.push(all[i]);
+ retval.push (all[i]);
if ( linelength <=0)
while ( retval.size() >2)
- retval.del(1);
+ retval.del (1);
return retval;
}
Line_spacer*
-Break_algorithm::generate_spacing_problem(Line_of_cols curline)const
+Break_algorithm::generate_spacing_problem (Line_of_cols curline)const
{
Line_spacer * sp= (*get_line_spacer)();
sp->paper_l_ = pscore_l_->paper_l_;
- sp->add_column(curline[0], true, 0.0);
+ sp->add_column (curline[0], true, 0.0);
for (int i=1; i< curline.size()-1; i++)
- sp->add_column(curline[i]);
+ sp->add_column (curline[i]);
if ( linelength > 0)
- sp->add_column(curline.top(), true, linelength);
+ sp->add_column (curline.top(), true, linelength);
else
- sp->add_column(curline.top());
+ sp->add_column (curline.top());
sp->prepare();
return sp;
}
void
-Break_algorithm::set_pscore(Paper_score*s)
+Break_algorithm::set_pscore (Paper_score*s)
{
pscore_l_ = s;
linelength = s->paper_l_->linewidth_f();
}
bool
-Break_algorithm::feasible(Line_of_cols curline) const
+Break_algorithm::feasible (Line_of_cols curline) const
{
if (linelength <= 0)
return true;
Real l =0;
for (int i=0; i < curline.size(); i++)
- l +=curline[i]->width().length();
+ l +=curline[i]->width().length ();
return l < linelength;
}
Break_algorithm::problem_OK() const
{
if (!pscore_l_->col_p_list_.size())
- error("Score does not have any columns");
+ error ("Score does not have any columns");
OK();
}
Break_algorithm::OK()const
{
#ifndef NDEBUG
- iter_top(pscore_l_->col_p_list_,start);
+ iter_top (pscore_l_->col_p_list_,start);
PCursor<PCol *> end (pscore_l_->col_p_list_.bottom());
- assert(start->breakable_b());
- assert(end->breakable_b());
+ assert (start->breakable_b());
+ assert (end->breakable_b());
#endif
}
clef_p_ = 0;
clef_req_l_ =0;
- set_type("violin");
+ set_type ("violin");
}
bool
-Clef_engraver::set_type(String s)
+Clef_engraver::set_type (String s)
{
clef_type_str_ = s;
if (clef_type_str_ == "violin") {
}
void
-Clef_engraver::fill_staff_info(Staff_info &i)
+Clef_engraver::fill_staff_info (Staff_info &i)
{
i.c0_position_i_l_ = &c0_position_i_;
}
void
-Clef_engraver::read_req(Clef_change_req*c_l)
+Clef_engraver::read_req (Clef_change_req*c_l)
{
- if (!set_type(c_l->clef_str_))
- c_l->error("unknown clef type ");
+ if (!set_type (c_l->clef_str_))
+ c_l->error ("unknown clef type ");
}
void
-Clef_engraver::acknowledge_element(Score_elem_info info)
+Clef_engraver::acknowledge_element (Score_elem_info info)
{
- if (info.elem_l_->name() == Bar::static_name() ) {
+ if (info.elem_l_->name() == Bar::static_name ()) {
create_clef();
- if ( !clef_req_l_ )
+ if ( !clef_req_l_)
clef_p_->default_b_ = true;
}
}
}
bool
-Clef_engraver::do_try_request(Request * r_l)
+Clef_engraver::do_try_request (Request * r_l)
{
Command_req* creq_l= r_l->command();
if (!creq_l || !creq_l->clefchange())
clef_req_l_ = creq_l->clefchange();
- read_req(clef_req_l_);
+ read_req (clef_req_l_);
return true;
}
{
if (!clef_p_) {
clef_p_ = new Clef_item;
- announce_element(Score_elem_info(clef_p_,clef_req_l_));
+ announce_element (Score_elem_info (clef_p_,clef_req_l_));
}
- clef_p_->read(*this);
+ clef_p_->read (*this);
}
void
{
if (!clef_p_)
return;
- typeset_element(clef_p_);
+ typeset_element (clef_p_);
clef_p_ = 0;
}
breakable_b_ =true;
default_b_ = false;
change_b_ = true;
- read("violin");
+ read ("violin");
}
void
-Clef_item::read(String t)
+Clef_item::read (String t)
{
type_= t;
if (type_ == "violin")
y_off = 6;
}
void
-Clef_item::read(Clef_engraver const &k)
+Clef_item::read (Clef_engraver const &k)
{
- read(k.clef_type_str_);
+ read (k.clef_type_str_);
}
Molecule*
String t = type_;
if (change_b_)
t += "_change";
- Symbol s = paper()->lookup_l()->clef(t);
- Molecule*output = new Molecule(Atom(s));
- output->translate( paper()->internote_f() * y_off, Y_AXIS);
+ Symbol s = paper()->lookup_l ()->clef (t);
+ Molecule*output = new Molecule (Atom (s));
+ output->translate (paper()->internote_f () * y_off, Y_AXIS);
return output;
}
Colinfo::print() const
{
#ifndef NPRINT
- mtor << "column { ";
+ DOUT << "column { ";
if (fixed())
- mtor << "fixed at " << fixed_position()<<", ";
- assert(pcol_l_);
- mtor << "[" << minleft() << ", " << minright() << "]";
- mtor <<"}\n";
+ DOUT << "fixed at " << fixed_position()<<", ";
+ assert (pcol_l_);
+ DOUT << "[" << minleft() << ", " << minright () << "]";
+ DOUT <<"}\n";
#endif
}
-Colinfo::Colinfo(PCol *col_l, Real const *fixed_C)
+Colinfo::Colinfo (PCol *col_l, Real const *fixed_C)
{
if (fixed_C)
- fixpos_p_.set_l(fixed_C);
+ fixpos_p_.set_l (fixed_C);
ugh_b_ = false;
pcol_l_ = col_l;
width = pcol_l_->width();
}
void
-Col_hpositions::add( PCol*c)
+Col_hpositions::add (PCol*c)
{
- cols.push(c);
+ cols.push (c);
}
void
Col_hpositions::print() const
{
#ifndef NPRINT
- mtor << "energy : " << energy_f_ << '\n';
- mtor << "line of " << config.size() << " cols\n";
- Vector v(config);
- mtor << v;
+ DOUT << "energy : " << energy_f_ << '\n';
+ DOUT << "line of " << config.size() << " cols\n";
+ Vector v (config);
+ DOUT << v;
#endif
}
Col_hpositions::OK()const
{
#ifndef NDEBUG
- assert(config.size() == cols.size());
+ assert (config.size() == cols.size ());
#endif
}
void
Col_hpositions::solve_line()
{
- spacer_l_->solve(this);
+ spacer_l_->solve (this);
}
void
Col_hpositions::approximate_solve_line()
{
- spacer_l_->lower_bound_solution(this);
+ spacer_l_->lower_bound_solution (this);
}
#include "collision.hh"
void
-Collision_engraver::acknowledge_element(Score_elem_info i)
+Collision_engraver::acknowledge_element (Score_elem_info i)
{
- if (!(i.elem_l_->name() == Note_column::static_name()))
+ if (!(i.elem_l_->name() == Note_column::static_name ()))
return;
if (!col_p_) {
col_p_ = new Collision;
- announce_element(Score_elem_info(col_p_,0));
+ announce_element (Score_elem_info (col_p_,0));
}
- col_p_->add((Note_column*)i.elem_l_->item());
+ col_p_->add ((Note_column*)i.elem_l_->item());
}
void
Collision_engraver::do_pre_move_processing()
{
if (col_p_) {
- typeset_element(col_p_);
+ typeset_element (col_p_);
col_p_ =0;
}
}
Cadenza_req::do_print()const
{
#ifndef NPRINT
- mtor << on_b_;
+ DOUT << on_b_;
#endif
}
bool
-Cadenza_req::do_equal_b(Request*r)const
+Cadenza_req::do_equal_b (Request*r)const
{
- Cadenza_req*cad = r->command()->timing()->cadenza();
+ Cadenza_req*cad = r->command()->timing ()->cadenza ();
return cad->on_b_ == on_b_;
}
-Cadenza_req::Cadenza_req(bool b)
+Cadenza_req::Cadenza_req (bool b)
{
on_b_ =b;
}
bool
-Bar_req::do_equal_b(Request*r)const
+Bar_req::do_equal_b (Request*r)const
{
- Bar_req * b = r->command()->bar();
+ Bar_req * b = r->command()->bar ();
return type_str_ == b->type_str_;
}
void
Bar_req::do_print() const
{
- mtor << type_str_;
+ DOUT << type_str_;
}
-Bar_req::Bar_req(String s)
+Bar_req::Bar_req (String s)
{
type_str_ = s;
}
-Partial_measure_req::Partial_measure_req(Moment m)
+Partial_measure_req::Partial_measure_req (Moment m)
{
duration_ =m;
}
bool
-Partial_measure_req::do_equal_b(Request* r)const
+Partial_measure_req::do_equal_b (Request* r)const
{
- Partial_measure_req *p = r->command()->timing()->partial();
+ Partial_measure_req *p = r->command()->timing ()->partial ();
return p->duration_ == duration_;
}
Barcheck_req::do_print() const{}
bool
-Barcheck_req::do_equal_b(Request*)const
+Barcheck_req::do_equal_b (Request*)const
{
return true;
}
Clef_change_req::do_print() const
{
#ifndef NPRINT
- mtor << clef_str_ ;
+ DOUT << clef_str_ ;
#endif
}
-Clef_change_req::Clef_change_req(String s)
+Clef_change_req::Clef_change_req (String s)
{
clef_str_ = s;
}
Group_feature_req::do_print() const
{
#ifndef NPRINT
- mtor << type_str_ << "=" << value_str_;
+ DOUT << type_str_ << "=" << value_str_;
#endif
}
void
Partial_measure_req::do_print() const
{
- mtor << duration_;
+ DOUT << duration_;
}
Meter_change_req::do_print() const
{
#ifndef NPRINT
- mtor << beats_i_ << "/" << one_beat_i_;
+ DOUT << beats_i_ << "/" << one_beat_i_;
#endif
}
bool
-Meter_change_req::do_equal_b(Request * r)const
+Meter_change_req::do_equal_b (Request * r)const
{
- Meter_change_req * m = r->command()->timing()->meterchange();
+ Meter_change_req * m = r->command()->timing ()->meterchange ();
return m->beats_i_ == beats_i_
&& one_beat_i_ == m->one_beat_i_;
}
void
-Meter_change_req::set(int b,int o)
+Meter_change_req::set (int b,int o)
{
beats_i_=b;
one_beat_i_=o;
void
Tempo_req::do_print()const
{
- mtor << dur_.str() << " = " <<metronome_i_ ;
+ DOUT << dur_.str() << " = " <<metronome_i_ ;
}
IMPLEMENT_IS_TYPE_B1(Tempo_req, Timing_req);
bool
-Tempo_req::do_equal_b(Request *r)const
+Tempo_req::do_equal_b (Request *r)const
{
- Tempo_req *t = r->command()->timing()->tempo();
+ Tempo_req *t = r->command()->timing ()->tempo ();
- return t->dur_.length()== dur_.length() && metronome_i_ == t->metronome_i_;
+ return t->dur_.length()== dur_.length () && metronome_i_ == t->metronome_i_;
}
/* *************** */
Measure_grouping_req::do_print() const
{
for (int i=0; i < elt_length_arr_.size(); i++) {
- mtor << beat_i_arr_[i] <<"*" << elt_length_arr_[i]<<" ";
+ DOUT << beat_i_arr_[i] <<"*" << elt_length_arr_[i]<<" ";
}
}
bool
-Measure_grouping_req::do_equal_b(Request*)const
+Measure_grouping_req::do_equal_b (Request*)const
{
return false; // todo
}
/* *************** */
void
-Key_change_req::transpose(Melodic_req const & d)const
+Key_change_req::transpose (Melodic_req const & d)const
{
WARN << "don't know how to transpose a key. \n";
for (int i=0; i < melodic_p_arr_.size(); i++) {
- melodic_p_arr_[i]->transpose(d);
+ melodic_p_arr_[i]->transpose (d);
}
}
multi_octave_b_= false;
}
-Key_change_req::Key_change_req(Key_change_req const&c)
+Key_change_req::Key_change_req (Key_change_req const&c)
{
for (int i=0; i < c.melodic_p_arr_.size(); i++)
- melodic_p_arr_.push( c.melodic_p_arr_[i]->clone()->musical()->melodic() );
+ melodic_p_arr_.push (c.melodic_p_arr_[i]->clone()->musical ()->melodic ());
minor_b_ = c.minor_b_;
multi_octave_b_ = c.multi_octave_b_;
}
Key_change_req::flats_i()
{
int flats_i = 0;
- for ( int i = 0; i < melodic_p_arr_.size(); i++ ) {
+ for ( int i = 0; i < melodic_p_arr_.size(); i++) {
Melodic_req* mel_l = melodic_p_arr_[i]->melodic();
- assert( mel_l );
- if ( mel_l->accidental_i_ < 0 )
+ assert (mel_l);
+ if ( mel_l->accidental_i_ < 0)
flats_i -= mel_l->accidental_i_;
}
return flats_i;
Key_change_req::sharps_i()
{
int sharps_i = 0;
- for ( int i = 0; i < melodic_p_arr_.size(); i++ ) {
+ for ( int i = 0; i < melodic_p_arr_.size(); i++) {
Melodic_req* mel_l = melodic_p_arr_[i]->melodic();
- assert( mel_l );
- if ( mel_l->accidental_i_ > 0 )
+ assert (mel_l);
+ if ( mel_l->accidental_i_ > 0)
sharps_i+= mel_l->accidental_i_;
}
return sharps_i;
Symbol
Crescendo::get_symbol()const
{
- Real w_dim = width().length();
- if ( left_dyn_b_ ) {
+ Real w_dim = width().length ();
+ if ( left_dyn_b_) {
w_dim -= absdyn_dim;
}
- if ( right_dyn_b_ ) {
+ if ( right_dyn_b_) {
w_dim -= absdyn_dim;
}
if (w_dim < 0) {
- warning("Crescendo too small");
+ warning ("Crescendo too small");
w_dim = 0;
}
- return Symbol( paper()->lookup_l()->hairpin( w_dim, grow_dir_i_ < 0) );
+ return Symbol (paper()->lookup_l ()->hairpin (w_dim, grow_dir_i_ < 0));
}
Molecule*
x_off_dim += absdyn_dim;
m_p = new Molecule;
- Symbol s(get_symbol());
- m_p->add(Atom(s));
- m_p->translate(Offset(x_off_dim, pos_i_ * paper()->internote_f()));
+ Symbol s (get_symbol());
+ m_p->add (Atom (s));
+ m_p->translate (Offset (x_off_dim, pos_i_ * paper()->internote_f ()));
return m_p;
}
// ugh
struct _Dinit {
_Dinit() {
- nulldev = new ofstream("/dev/null");
- monitor = new Dstream(&cout,".dstreamrc");
+ nulldev = new ofstream ("/dev/null");
+ monitor = new Dstream (&cout,".dstreamrc");
}
~_Dinit() {
delete nulldev;
void
mynewhandler()
{
- assert(false);
+ assert (false);
}
void
-float_handler(int)
+float_handler (int)
{
cerr << "Floating point exception .. \n"<< flush;
- assert(false);
+ assert (false);
}
/// just to make sure print_rat is linked in
{
rat_printer = print_rat;
#ifndef NDEBUG
- set_new_handler(&mynewhandler);
+ set_new_handler (&mynewhandler);
#endif
- set_flower_debug(*monitor, check_debug);
+ set_flower_debug (*monitor, check_debug);
- signal(SIGFPE, float_handler);
+ signal (SIGFPE, float_handler);
}
bool check_debug=false;
void
-set_debug(bool b)
+set_debug (bool b)
{
check_debug =b;
- set_flower_debug(*monitor, check_debug);
+ set_flower_debug (*monitor, check_debug);
}
#include "string.hh"
Real
-parse_dimen(String dim)
+parse_dimen (String dim)
{
int i=dim.length_i()-1;
char const *s = dim;
- while (i > 0 && (isspace(s[i]) || isalpha(s[i])) ){
+ while (i > 0 && (isspace (s[i]) || isalpha (s[i]))){
i--;
}
- String unit(s + i+1);
- return convert_dimen(dim.value_f(), unit);
+ String unit (s + i+1);
+ return convert_dimen (dim.value_f(), unit);
}
Real
-convert_dimen(Real quant, String unit)
+convert_dimen (Real quant, String unit)
{
if (unit == "cm")
return quant * CM_TO_PT;
}
String
-print_dimen(Real r)
+print_dimen (Real r)
{
- String s(r, "%.3f");
+ String s (r, "%.3f");
s += "pt ";
return s;
}
}
bool
-Dynamic_engraver::do_try_request(Request * r)
+Dynamic_engraver::do_try_request (Request * r)
{
Musical_req * m = r->musical();
if (!m || !m->dynamic())
return false;
- dynamic_req_l_arr_.push(m->dynamic());
+ dynamic_req_l_arr_.push (m->dynamic());
return true;
}
void
if (dreq_l->absdynamic()) {
Text_def * td_p = new Text_def;
td_p->align_i_ = 0;
- String loud =Dynamic_req::loudness_str(
+ String loud =Dynamic_req::loudness_str (
dreq_l->absdynamic()->loudness_);
- td_p->text_str_ = paper()->lookup_l()->dynamic(loud).tex;
+ td_p->text_str_ = paper()->lookup_l ()->dynamic (loud).tex;
td_p->style_str_ = "dynamic";
assert (!dynamic_p_) ; // TODO
- dynamic_p_ = new Text_item(td_p);
- announce_element(Score_elem_info(dynamic_p_, dreq_l));
+ dynamic_p_ = new Text_item (td_p);
+ announce_element (Score_elem_info (dynamic_p_, dreq_l));
} else if (dreq_l->span_dynamic()) {
Span_dynamic_req* span_l = dreq_l->span_dynamic();
if (span_l->spantype == Span_req::STOP) {
if (!cresc_p_) {
- span_l->warning("Can't find cresc to end " );
+ span_l->warning ("Can't find cresc to end ");
} else {
- assert(!to_end_cresc_p_);
+ assert (!to_end_cresc_p_);
to_end_cresc_p_ =cresc_p_;
cresc_p_ = 0;
}
} else if (span_l->spantype == Span_req::START) {
cresc_req_l_ = span_l;
- assert(!new_cresc_p);
+ assert (!new_cresc_p);
new_cresc_p = new Crescendo;
new_cresc_p->grow_dir_i_ = span_l->dynamic_dir_i_;
- announce_element(Score_elem_info(new_cresc_p, span_l));
+ announce_element (Score_elem_info (new_cresc_p, span_l));
}
}
}
- if ( new_cresc_p ) {
+ if ( new_cresc_p) {
cresc_p_ = new_cresc_p;
- cresc_p_->left_col_l_ = get_staff_info().musical_l();
+ cresc_p_->left_col_l_ = get_staff_info().musical_l ();
if (dynamic_p_) {
cresc_p_->left_dyn_b_ = true;
}
{
Staff_symbol* s_l = get_staff_info().staff_sym_l_;
if (dynamic_p_) {
- dynamic_p_->set_staffsym(s_l);
- typeset_element(dynamic_p_);
+ dynamic_p_->set_staffsym (s_l);
+ typeset_element (dynamic_p_);
dynamic_p_ = 0;
}
if ( to_end_cresc_p_) {
if (dynamic_p_)
to_end_cresc_p_->right_dyn_b_=true;
- to_end_cresc_p_->right_col_l_ = get_staff_info().musical_l();
- to_end_cresc_p_->set_staffsym(s_l);
- typeset_element(to_end_cresc_p_);
+ to_end_cresc_p_->right_col_l_ = get_staff_info().musical_l ();
+ to_end_cresc_p_->set_staffsym (s_l);
+ typeset_element (to_end_cresc_p_);
to_end_cresc_p_ = 0;
}
}
void
-Dynamic_engraver::set_feature(Feature i)
+Dynamic_engraver::set_feature (Feature i)
{
if (i.type_ == "vdir")
dir_i_ = i.value_;
delete dynamic_p_;
delete to_end_cresc_p_;
if (cresc_p_) {
- cresc_req_l_->warning("unended crescendo");
+ cresc_req_l_->warning ("unended crescendo");
}
delete cresc_p_;
}
void
-Dynamic_engraver::acknowledge_element(Score_elem_info i)
+Dynamic_engraver::acknowledge_element (Score_elem_info i)
{
- if (i.elem_l_->name() == Note_column::static_name()) {
- if (dynamic_p_) dynamic_p_->add_support(i.elem_l_);
+ if (i.elem_l_->name() == Note_column::static_name ()) {
+ if (dynamic_p_) dynamic_p_->add_support (i.elem_l_);
if (to_end_cresc_p_)
- to_end_cresc_p_->add_support(i.elem_l_);
+ to_end_cresc_p_->add_support (i.elem_l_);
if (cresc_p_)
- cresc_p_->add_support(i.elem_l_);
+ cresc_p_->add_support (i.elem_l_);
}
}
bool
-Axis_group_element::contains_b(Score_elem const*e)const
+Axis_group_element::contains_b (Score_elem const*e)const
{
- return axis_admin_.contains_b(e);
+ return axis_admin_.contains_b (e);
}
Link_array<Score_elem>
void
-Vertical_group_element::add_element(Score_elem*e)
+Vertical_group_element::add_element (Score_elem*e)
{
- axis_admin_.add_element(e, this, Y_AXIS, Y_AXIS);
+ axis_admin_.add_element (e, this, Y_AXIS, Y_AXIS);
}
void
-Vertical_group_element::remove_element(Score_elem*e)
+Vertical_group_element::remove_element (Score_elem*e)
{
- axis_admin_.remove_element(e, Y_AXIS, Y_AXIS);
+ axis_admin_.remove_element (e, Y_AXIS, Y_AXIS);
}
Interval
Vertical_group_element::do_height() const
{
- return axis_admin_.extent(Y_AXIS);
+ return axis_admin_.extent (Y_AXIS);
}
void
Vertical_group_element::remove_all()
{
- axis_admin_.remove_all(Y_AXIS,Y_AXIS);
+ axis_admin_.remove_all (Y_AXIS,Y_AXIS);
}
// ****************
void
Horizontal_group_element::remove_all()
{
- axis_admin_.remove_all(X_AXIS,X_AXIS);
+ axis_admin_.remove_all (X_AXIS,X_AXIS);
}
void
-Horizontal_group_element::add_element(Score_elem*e)
+Horizontal_group_element::add_element (Score_elem*e)
{
- axis_admin_.add_element(e,this, X_AXIS,X_AXIS);
+ axis_admin_.add_element (e,this, X_AXIS,X_AXIS);
}
void
-Horizontal_group_element::remove_element(Score_elem*e)
+Horizontal_group_element::remove_element (Score_elem*e)
{
- axis_admin_.remove_element(e,X_AXIS,X_AXIS);
+ axis_admin_.remove_element (e,X_AXIS,X_AXIS);
}
Interval
Horizontal_group_element::do_width()const
{
- return axis_admin_.extent(X_AXIS);
+ return axis_admin_.extent (X_AXIS);
}
void
Horizontal_vertical_group_element::remove_all()
{
- axis_admin_.remove_all(X_AXIS,Y_AXIS);
+ axis_admin_.remove_all (X_AXIS,Y_AXIS);
}
void
-Horizontal_vertical_group_element::add_element(Score_elem *e)
+Horizontal_vertical_group_element::add_element (Score_elem *e)
{
- axis_admin_.add_element(e, this, X_AXIS, Y_AXIS);
+ axis_admin_.add_element (e, this, X_AXIS, Y_AXIS);
}
void
-Horizontal_vertical_group_element::remove_element(Score_elem*e)
+Horizontal_vertical_group_element::remove_element (Score_elem*e)
{
- axis_admin_.remove_element(e, X_AXIS, Y_AXIS);
+ axis_admin_.remove_element (e, X_AXIS, Y_AXIS);
}
#include "score-elem.hh"
#include "input-translator.hh"
-Engraver* get_engraver_p(String);
+Engraver* get_engraver_p (String);
void
Engraver_group_engraver::print()const
Engraver_group_engraver::~Engraver_group_engraver()
{
- assert(removable_b());
+ assert (removable_b());
}
void
Engraver_group_engraver::check_removal()
{
- for (int i =0; i < group_l_arr_.size(); ) {
+ for (int i =0; i < group_l_arr_.size();) {
group_l_arr_[i]->check_removal();
if (group_l_arr_[i]->removable_b())
- terminate_engraver(group_l_arr_[i]);
+ terminate_engraver (group_l_arr_[i]);
else
i++;
}
}
void
-Engraver_group_engraver::set_feature(Feature d)
+Engraver_group_engraver::set_feature (Feature d)
{
- PCursor<Engraver*> i(grav_list_.top());
+ PCursor<Engraver*> i (grav_list_.top());
// why the while construct?
while (i.ok()) {
// this construction to ensure clean deletion
Engraver *grav_l = i++;
- grav_l->set_feature(d);
+ grav_l->set_feature (d);
}
}
void
Engraver_group_engraver::sync_features()
{
- PCursor<Engraver*> i(grav_list_.top());
+ PCursor<Engraver*> i (grav_list_.top());
while (i.ok()) {
Engraver *grav_l = i++;
grav_l->sync_features();
void
Engraver_group_engraver::do_pre_move_processing()
{
- PCursor<Engraver*> i(grav_list_.top());
+ PCursor<Engraver*> i (grav_list_.top());
while (i.ok()) {
Engraver *grav_l = i++;
grav_l->pre_move_processing();
void
Engraver_group_engraver::do_process_requests()
{
- PCursor<Engraver*> i(grav_list_.top());
+ PCursor<Engraver*> i (grav_list_.top());
while (i.ok()) {
Engraver *grav_l = i++;
grav_l->process_requests();
void
Engraver_group_engraver::do_post_move_processing()
{
- PCursor<Engraver*> i(grav_list_.top());
+ PCursor<Engraver*> i (grav_list_.top());
while (i.ok()) {
// this construction to ensure clean deletion
Engraver *grav_l = i++;
bool
-Engraver_group_engraver::contains_b(Engraver* grav_l)const
+Engraver_group_engraver::contains_b (Engraver* grav_l)const
{
- bool parent_b = Engraver::contains_b(grav_l);
+ bool parent_b = Engraver::contains_b (grav_l);
if (parent_b)
return true;
- for (PCursor<Engraver*> i(grav_list_.top()); i.ok(); i++)
- if (i->contains_b(grav_l))
+ for (PCursor<Engraver*> i (grav_list_.top()); i.ok (); i++)
+ if (i->contains_b (grav_l))
return true;
return false;
}
bool
-Engraver_group_engraver::do_try_request(Request*req_l)
+Engraver_group_engraver::do_try_request (Request*req_l)
{
bool hebbes_b =false;
for (int i =0; !hebbes_b && i < nongroup_l_arr_.size() ; i++)
- hebbes_b =nongroup_l_arr_[i]->try_request(req_l);
+ hebbes_b =nongroup_l_arr_[i]->try_request (req_l);
if (!hebbes_b && daddy_grav_l_)
- hebbes_b = daddy_grav_l_->try_request(req_l);
+ hebbes_b = daddy_grav_l_->try_request (req_l);
return hebbes_b ;
}
bool
-Engraver_group_engraver::try_request(Request* r)
+Engraver_group_engraver::try_request (Request* r)
{
- return Engraver::try_request(r);
+ return Engraver::try_request (r);
}
void
-Engraver_group_engraver::add(Engraver *grav_p)
+Engraver_group_engraver::add (Engraver *grav_p)
{
- grav_list_.bottom().add(grav_p);
+ grav_list_.bottom().add (grav_p);
grav_p->daddy_grav_l_ = this;
- if (grav_p->is_type_b(Engraver_group_engraver::static_name())) {
- group_l_arr_.push((Engraver_group_engraver*)grav_p);
+ if (grav_p->is_type_b (Engraver_group_engraver::static_name())) {
+ group_l_arr_.push ((Engraver_group_engraver*)grav_p);
} else {
- nongroup_l_arr_ .push(grav_p);
+ nongroup_l_arr_ .push (grav_p);
}
}
Engraver *
-Engraver_group_engraver::remove_engraver_p(Engraver*grav_l)
+Engraver_group_engraver::remove_engraver_p (Engraver*grav_l)
{
- group_l_arr_.substitute((Engraver_group_engraver*)grav_l,0);
- nongroup_l_arr_.substitute(grav_l,0);
- PCursor<Engraver*> grav_cur( grav_list_.find(grav_l) );
+ group_l_arr_.substitute ((Engraver_group_engraver*)grav_l,0);
+ nongroup_l_arr_.substitute (grav_l,0);
+ PCursor<Engraver*> grav_cur (grav_list_.find (grav_l));
return grav_cur.remove_p();
}
void
-Engraver_group_engraver::terminate_engraver(Engraver*r_l)
+Engraver_group_engraver::terminate_engraver (Engraver*r_l)
{
- mtor << "Removing " << r_l->name() << " at " << get_staff_info().when() << "\n";
+ DOUT << "Removing " << r_l->name() << " at " << get_staff_info ().when () << "\n";
r_l->removal_processing();
- Engraver * grav_p =remove_engraver_p(r_l);
+ Engraver * grav_p =remove_engraver_p (r_l);
delete grav_p;
}
#ifndef NPRINT
if ( !check_debug)
return ;
- mtor << "ID: " << id_str_ ;
- mtor << " iterators: " << iterator_count_<< "\n";
- for (PCursor<Engraver*> i(grav_list_.top()); i.ok(); i++)
+ DOUT << "ID: " << id_str_ ;
+ DOUT << " iterators: " << iterator_count_<< "\n";
+ for (PCursor<Engraver*> i (grav_list_.top()); i.ok (); i++)
i->print();
#endif
}
Engraver_group_engraver*
-Engraver_group_engraver::find_engraver_l(String n, String id)
+Engraver_group_engraver::find_engraver_l (String n, String id)
{
if (name() == n && id_str_ == id)
return this;
Engraver_group_engraver * r = 0;
for (int i =0; !r && i< group_l_arr_.size(); i++) {
- r = group_l_arr_[i]->find_engraver_l(n,id);
+ r = group_l_arr_[i]->find_engraver_l (n,id);
}
return r;
}
Translator*
-Engraver_group_engraver::find_get_translator_l(String n,String id)
+Engraver_group_engraver::find_get_translator_l (String n,String id)
{
Translator * ret=0;
- Input_translator * itrans_l= itrans_l_-> recursive_find ( n );
- if (itrans_l ) {
- ret = find_engraver_l(n,id);
+ Input_translator * itrans_l= itrans_l_-> recursive_find ( n);
+ if (itrans_l) {
+ ret = find_engraver_l (n,id);
if (!ret) {
Engraver_group_engraver * group =
itrans_l-> get_group_engraver_p();
- add(group);
+ add (group);
ret = group;
- if (group->itrans_l_->is_name_b( n ) )
+ if (group->itrans_l_->is_name_b (n) )
ret ->id_str_ = id;
else
- return ret->find_get_translator_l(n,id);
+ return ret->find_get_translator_l (n,id);
}
} else if (daddy_grav_l_)
- ret =daddy_grav_l_->find_get_translator_l(n,id);
+ ret =daddy_grav_l_->find_get_translator_l (n,id);
else {
- warning("Can't find or create `" + n + "' called `" + id + "'\n");
+ warning ("Can't find or create `" + n + "' called `" + id + "'\n");
ret =0;
}
return ret;
}
Translator*
-Engraver_group_engraver::ancestor_l(int l)
+Engraver_group_engraver::ancestor_l (int l)
{
if (!l || !daddy_grav_l_)
return this;
- return daddy_grav_l_->ancestor_l(l-1);
+ return daddy_grav_l_->ancestor_l (l-1);
}
void
-Engraver_group_engraver::announce_element(Score_elem_info info)
+Engraver_group_engraver::announce_element (Score_elem_info info)
{
- announce_info_arr_.push(info);
- Engraver::announce_element(info);
+ announce_info_arr_.push (info);
+ Engraver::announce_element (info);
}
void
info.req_l_ = &dummy_req;
for (int i=0; i < nongroup_l_arr_.size(); i++) { // Is this good enough?6
if (nongroup_l_arr_[i] != info.origin_grav_l_arr_[0])
- nongroup_l_arr_[i]->acknowledge_element(info);
+ nongroup_l_arr_[i]->acknowledge_element (info);
}
}
announce_info_arr_.clear();
void
Engraver_group_engraver::do_removal_processing()
{
- for (PCursor<Engraver*> i(grav_list_.top()); i.ok(); i++)
+ for (PCursor<Engraver*> i (grav_list_.top()); i.ok (); i++)
i->removal_processing();
}
Staff_info inf = Engraver::get_staff_info();
for (int i=0; i < nongroup_l_arr_.size(); i++)
- nongroup_l_arr_[i]->fill_staff_info(inf);
+ nongroup_l_arr_[i]->fill_staff_info (inf);
return inf;
}
Engraver_group_engraver::get_default_interpreter()
{
// ?
- if ( is_bottom_engraver_b() )
+ if ( is_bottom_engraver_b())
return daddy_grav_l_->get_default_interpreter();
Engraver_group_engraver *grav_p= itrans_l_->
- get_default_itrans_l()->get_group_engraver_p();
- add(grav_p );
+ get_default_itrans_l()->get_group_engraver_p ();
+ add (grav_p);
if (grav_p->is_bottom_engraver_b())
return grav_p;
else
}
Engraver*
-Engraver_group_engraver::get_simple_engraver(char const *type)const
+Engraver_group_engraver::get_simple_engraver (char const *type)const
{
for (int i=0; i < nongroup_l_arr_.size(); i++) {
- if (nongroup_l_arr_[i]->name() == type )
+ if (nongroup_l_arr_[i]->name() == type)
return nongroup_l_arr_[i];
}
- if ( daddy_grav_l_ )
- return daddy_grav_l_->get_simple_engraver(type);
+ if ( daddy_grav_l_)
+ return daddy_grav_l_->get_simple_engraver (type);
return 0;
}
void
Engraver::removal_processing()
{
- if ( status < CREATION_INITED )
+ if ( status < CREATION_INITED)
do_creation_processing();
do_removal_processing();
}
bool
-Engraver::try_request(Request * r)
+Engraver::try_request (Request * r)
{
if (status < MOVE_INITED)
post_move_processing();
- return do_try_request(r);
+ return do_try_request (r);
}
void
}
void
-Engraver::fill_staff_info(Staff_info&)
+Engraver::fill_staff_info (Staff_info&)
{
}
Scalar
-Engraver::get_feature(String t)
+Engraver::get_feature (String t)
{
- return daddy_grav_l_->get_feature(t);
+ return daddy_grav_l_->get_feature (t);
}
bool
-Engraver::do_try_request(Request*)
+Engraver::do_try_request (Request*)
{
return false;
}
}
void
-Engraver::announce_element(Score_elem_info i)
+Engraver::announce_element (Score_elem_info i)
{
- i.origin_grav_l_arr_.push(this);
- daddy_grav_l_->announce_element(i);
+ i.origin_grav_l_arr_.push (this);
+ daddy_grav_l_->announce_element (i);
}
void
-Engraver::typeset_element(Score_elem*p)
+Engraver::typeset_element (Score_elem*p)
{
- daddy_grav_l_->typeset_element(p);
+ daddy_grav_l_->typeset_element (p);
}
Paper_def*
}
bool
-Engraver::contains_b(Engraver *grav_l)const
+Engraver::contains_b (Engraver *grav_l)const
{
return this == grav_l;
}
Engraver::print() const
{
#ifndef NPRINT
- mtor << "\n" << name() << " {";
+ DOUT << "\n" << name() << " {";
do_print();
- mtor << "}";
+ DOUT << "}";
#endif
}
}
bool
-General_script_def::equal_b(General_script_def const&g)const
+General_script_def::equal_b (General_script_def const&g)const
{
- if (name() != g.name())
+ if (name() != g.name ())
return false;
- return do_equal_b(&g);
+ return do_equal_b (&g);
}
bool
-General_script_def::do_equal_b(General_script_def const*)const
+General_script_def::do_equal_b (General_script_def const*)const
{
return true;
}
void
General_script_def::print() const
{
- mtor << name() << "{";
+ DOUT << name() << "{";
do_print();
- mtor << "}";
+ DOUT << "}";
}
void
}
Atom
-General_script_def::get_atom(Paper_def*, int)const
+General_script_def::get_atom (Paper_def*, int)const
{
Symbol s;
- return Atom(s);
+ return Atom (s);
}
IMPLEMENT_IS_TYPE_B(General_script_def);
struct Engraver_table_entry {
String name_str_;
Grav_ctor ctor_l_;
- Engraver_table_entry(String s, Grav_ctor f) {
+ Engraver_table_entry (String s, Grav_ctor f) {
name_str_ =s;
ctor_l_ = f;
}
static Array<Engraver_table_entry> *grav_table=0;
void
-add_engraver(String s, Grav_ctor f)
+add_engraver (String s, Grav_ctor f)
{
if (!grav_table)
grav_table = new Array<Engraver_table_entry>;
- grav_table->push(Engraver_table_entry(s, f));
+ grav_table->push (Engraver_table_entry (s, f));
}
Engraver*
-get_engraver_p(String s)
+get_engraver_p (String s)
{
for (int i=0; i < grav_table->size(); i++) {
if ((*grav_table)[i].name_str_ == s)
return (*(*grav_table)[i].ctor_l_)();
}
- error("Unknown engraver `" + s +"\'");
+ error ("Unknown engraver `" + s +"\'");
return 0;
}
{
String name_str_;
Perf_ctor ctor_l_;
- Performer_table_entry(String s, Perf_ctor f) {
+ Performer_table_entry (String s, Perf_ctor f) {
name_str_ =s;
ctor_l_ = f;
}
static Array<Performer_table_entry> *perf_table=0;
void
-add_performer(String s, Perf_ctor f)
+add_performer (String s, Perf_ctor f)
{
if (!perf_table)
perf_table = new Array<Performer_table_entry>;
- perf_table->push(Performer_table_entry(s, f));
+ perf_table->push (Performer_table_entry (s, f));
}
Performer*
-get_performer_p(String s)
+get_performer_p (String s)
{
for (int i=0; i < perf_table->size(); i++) {
if ((*perf_table)[i].name_str_ == s)
return (*(*perf_table)[i].ctor_l_)();
}
- error("Unknown performer `" + s +"\'");
+ error ("Unknown performer `" + s +"\'");
return 0;
}
#endif
struct Performer_table_entry {
String name_str_;
Perf_ctor ctor_l_;
- Performer_table_entry(String s, Perf_ctor f) {
+ Performer_table_entry (String s, Perf_ctor f) {
name_str_ =s;
ctor_l_ = f;
}
static Array<Performer_table_entry> *perf_table=0;
void
-add_Performer(String s, Perf_ctor f)
+add_Performer (String s, Perf_ctor f)
{
if (!perf_table)
perf_table = new Array<Performer_table_entry>;
- perf_table->push(Performer_table_entry(s, f));
+ perf_table->push (Performer_table_entry (s, f));
}
Performer*
-get_performer_p(String s)
+get_performer_p (String s)
{
for (int i=0; i < perf_table->size(); i++) {
if ((*perf_table)[i].name_str_ == s)
return (*(*perf_table)[i].ctor_l_)();
}
- error("Unknown performer `" + s +"\'");
+ error ("Unknown performer `" + s +"\'");
return 0;
}
}
Translator*
-Global_translator::ancestor_l(int)
+Global_translator::ancestor_l (int)
{
return this;
}
void
-Global_translator::add_moment_to_process(Moment m)
+Global_translator::add_moment_to_process (Moment m)
{
if (m > last_mom_)
return;
for (int i=0; i < extra_mom_pq_.size(); i++)
if (extra_mom_pq_[i] == m)
return;
- extra_mom_pq_.insert(m);
+ extra_mom_pq_.insert (m);
}
int
}
void
-Global_translator::set_score(Score *s)
+Global_translator::set_score (Score *s)
{
score_l_ = s;
- last_mom_ = score_l_->music_p_->time_int().max();
+ last_mom_ = score_l_->music_p_->time_int().max ();
}
void
-Global_translator::modify_next(Moment &w)
+Global_translator::modify_next (Moment &w)
{
while (extra_mom_pq_.size() &&
extra_mom_pq_.front() <= w)
}
void
-Global_translator::prepare(Moment)
+Global_translator::prepare (Moment)
{
}
Line_of_cols all = all_cols();
Array<int> breaks = find_break_indices();
- optimal_paths.set_size(breaks.size());
+ optimal_paths.set_size (breaks.size());
Break_node first_node ;
first_node.prev_break_i_ = -1;
start with a short line, add measures. At some point
the line becomes infeasible. Then we don't try to add more
*/
- for (int start_idx = break_idx; start_idx--; ){
+ for (int start_idx = break_idx; start_idx--;){
if (break_idx - start_idx > max_measures_i_)
break;
continue;
- Line_of_cols line = all.slice(breaks[start_idx], breaks[break_idx]+1);
+ Line_of_cols line = all.slice (breaks[start_idx], breaks[break_idx]+1);
line[0] = line[0]->postbreak_p_;
- line.top() = line.top()->prebreak_p_;
+ line.top() = line.top ()->prebreak_p_;
- if (!feasible(line))
+ if (!feasible (line))
break;
Col_hpositions approx;
approx.cols = line;
- approx.spacer_l_ = generate_spacing_problem( line );
- spacer_p_list.bottom().add(approx.spacer_l_);
+ approx.spacer_l_ = generate_spacing_problem (line);
+ spacer_p_list.bottom().add (approx.spacer_l_);
- ((Break_algorithm*)this)->approx_stats_.add( approx.cols );
- approx.approximate_solve_line( );
+ ((Break_algorithm*)this)->approx_stats_.add (approx.cols);
+ approx.approximate_solve_line();
- if (approx.energy_f_ > energy_bound_f_ ){
+ if (approx.energy_f_ > energy_bound_f_){
continue;
}
// this is a likely candidate. Store it.
- candidate_lines.push( approx );
- candidates.push( start_idx );
+ candidate_lines.push (approx);
+ candidates.push (start_idx);
}
continue;
if ( !candidate_lines[j].satisfies_constraints_b_) {
- candidate_lines[j].solve_line( );
- ((Break_algorithm*)this)->exact_stats_.add ( candidate_lines[j].cols );
+ candidate_lines[j].solve_line();
+ ((Break_algorithm*)this)->exact_stats_.add ( candidate_lines[j].cols);
}
Real this_energy
= optimal_paths[start].line_config_.energy_f_
+ candidate_lines[j].energy_f_ ;
- if ( this_energy < minimal_energy ) {
+ if ( this_energy < minimal_energy) {
minimal_j = j;
minimal_energy = this_energy;
}
optimal_paths[break_idx].line_config_ = candidate_lines[minimal_j];
}
- if ( !(break_idx % HAPPY_DOTS_I) )
+ if ( !(break_idx % HAPPY_DOTS_I))
*mlog << "[" << break_idx << "]"<<flush;
}
Array<Col_hpositions> lines;
/* skip 0-th element, since it is a "dummy" elt*/
- for (int i = optimal_paths.size()-1; i> 0; ) {
- final_breaks.push ( i );
+ for (int i = optimal_paths.size()-1; i> 0;) {
+ final_breaks.push ( i);
assert ( i > optimal_paths[i].prev_break_i_);
// there was no "feasible path"
- if (!optimal_paths[i].line_config_.config.size() )
+ if (!optimal_paths[i].line_config_.config.size())
return lines;
i = optimal_paths[i].prev_break_i_;
}
- for (int i= final_breaks.size(); i--; )
- lines.push ( optimal_paths[final_breaks[i]].line_config_ );
+ for (int i= final_breaks.size(); i--;)
+ lines.push ( optimal_paths[final_breaks[i]].line_config_);
return lines;
void
Gourlay_breaking::do_set_pscore()
{
- energy_bound_f_ = pscore_l_->paper_l_->get_var( "gourlay_energybound");
- max_measures_i_ =int (rint( pscore_l_->paper_l_->get_var( "gourlay_maxmeasures")));
+ energy_bound_f_ = pscore_l_->paper_l_->get_var ("gourlay_energybound");
+ max_measures_i_ =int (rint (pscore_l_->paper_l_->get_var ("gourlay_maxmeasures")));
}
Rhythmic_grouping::OK()const
{
#ifndef NDEBUG
- assert(bool(children.size()) != bool(interval_));
+ assert (bool (children.size()) != bool (interval_));
for (int i= 0; i < children.size(); i++) {
children[i]->OK();
if (i>0)
- assert(children[i-1]->interval().right ==
+ assert (children[i-1]->interval().right ==
children[i]->interval().left);
}
#endif
Moment
Rhythmic_grouping::length() const
{
- return interval().length();
+ return interval().length ();
}
MInterval
return *interval_;
else
return
- MInterval(children[0]->interval().left,
- children.top()->interval().right);
+ MInterval (children[0]->interval().left,
+ children.top()->interval ().right);
}
void
-Rhythmic_grouping::split(Rhythmic_grouping r)
+Rhythmic_grouping::split (Rhythmic_grouping r)
{
if (interval_)
return ;
- r.intersect(interval());
- split(r.intervals());
+ r.intersect (interval());
+ split (r.intervals());
for (int i= 0; i < children.size(); i++) {
if (!children[i]->interval_) {
- Rhythmic_grouping here(r);
- children[i]->split(here);
+ Rhythmic_grouping here (r);
+ children[i]->split (here);
}
}
}
{
Array<MInterval> r;
if (interval_ || children.size() == 1) {
- MInterval i(interval());
+ MInterval i (interval());
MInterval r1(i), r2(i);
r1.right = r2.left = i.center();
- r.push(r1); r.push(r2);
+ r.push (r1); r.push (r2);
} else {
for (int i=0; i < children.size(); i++)
- r.push(children[i]->interval());
+ r.push (children[i]->interval());
}
return r;
}
void
-Rhythmic_grouping::intersect(MInterval t)
+Rhythmic_grouping::intersect (MInterval t)
{
if (interval_) {
- interval_->intersect(t);
+ interval_->intersect (t);
return;
}
for (int i=0; i < children.size(); i++) {
- MInterval inter = intersection(t, children[i]->interval());
- if (inter.empty_b() || inter.length() <= Rational( 0 )) {
+ MInterval inter = intersection (t, children[i]->interval());
+ if (inter.empty_b() || inter.length () <= Rational (0)) {
delete children[i];
children[i] =0;
} else {
- children[i]->intersect(t);
+ children[i]->intersect (t);
}
}
- for (int i=0; i < children.size(); ) {
+ for (int i=0; i < children.size();) {
if (!children[i])
- children.del(i);
+ children.del (i);
else
i++;
}
*/
void
-Rhythmic_grouping::split(Array<MInterval> splitpoints)
+Rhythmic_grouping::split (Array<MInterval> splitpoints)
{
//check on splitpoints..
int j = 0, i = 0, starti = 0, startj = 0;
Array<Rhythmic_grouping*> ch;
while (1) {
- if ( i >= children.size() || j >= splitpoints.size())
+ if ( i >= children.size() || j >= splitpoints.size ())
break;
- assert(
+ assert (
children[starti]->interval().left== splitpoints[startj].left);
if (children[i]->interval().right < splitpoints[j].right) {
i ++;
- } else if (children[i]->interval().right > splitpoints[j].right ) {
+ } else if (children[i]->interval().right > splitpoints[j].right) {
j ++;
} else {
if (i == starti) {
- ch.push(children[i]);
+ ch.push (children[i]);
} else {
- Rhythmic_grouping *newchild=new Rhythmic_grouping(
- children.slice(starti, i+1));
+ Rhythmic_grouping *newchild=new Rhythmic_grouping (
+ children.slice (starti, i+1));
- ch.push(newchild);
+ ch.push (newchild);
}
i ++;
j++;
}
-Rhythmic_grouping::Rhythmic_grouping(MInterval t, int n)
+Rhythmic_grouping::Rhythmic_grouping (MInterval t, int n)
{
init();
if (n == 1 || !n) {
- interval_ = new MInterval(t);
+ interval_ = new MInterval (t);
return;
}
- Moment dt = t.length()/Rational(n);
- MInterval basic = MInterval(t.left, t.left+dt);
+ Moment dt = t.length()/Rational (n);
+ MInterval basic = MInterval (t.left, t.left+dt);
for (int i= 0; i < n; i++)
- children.push(new Rhythmic_grouping( dt*Rational(i) + basic ));
+ children.push (new Rhythmic_grouping (dt*Rational (i) + basic));
}
-Rhythmic_grouping::Rhythmic_grouping(Array<Rhythmic_grouping*> r)
- :children(r)
+Rhythmic_grouping::Rhythmic_grouping (Array<Rhythmic_grouping*> r)
+ :children (r)
{
interval_ =0;
}
}
void
-Rhythmic_grouping::copy(Rhythmic_grouping const&s)
+Rhythmic_grouping::copy (Rhythmic_grouping const&s)
{
- interval_ = (s.interval_)? new MInterval(*s.interval_) : 0;
+ interval_ = (s.interval_)? new MInterval (*s.interval_) : 0;
for (int i=0; i < s.children.size(); i++)
- children.push(new Rhythmic_grouping(*s.children[i]));
+ children.push (new Rhythmic_grouping (*s.children[i]));
}
void
Rhythmic_grouping::operator=(Rhythmic_grouping const &s)
{
junk();
- copy(s);
+ copy (s);
}
-Rhythmic_grouping::Rhythmic_grouping(Rhythmic_grouping const&s)
+Rhythmic_grouping::Rhythmic_grouping (Rhythmic_grouping const&s)
{
init();
- copy(s);
+ copy (s);
}
void
Rhythmic_grouping::print()const
{
#ifndef NPRINT
- mtor << "{ \n";
+ DOUT << "{ \n";
if (interval_)
- mtor<<" Interval "<< interval_->str();
+ DOUT <<" Interval "<< interval_->str();
for (int i=0; i < children.size(); i++) {
children[i]->print();
}
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
bool
-Rhythmic_grouping::child_fit_b(Moment start)
+Rhythmic_grouping::child_fit_b (Moment start)
{
if (children.size())
- return ( children.top()->interval().right== start);
+ return ( children.top()->interval ().right== start);
return true;
}
void
-Rhythmic_grouping::add_child(Moment start, Moment len)
+Rhythmic_grouping::add_child (Moment start, Moment len)
{
Moment stop = start+len;
- assert(child_fit_b(start));
- children.push(new Rhythmic_grouping(MInterval(start, stop)));
+ assert (child_fit_b (start));
+ children.push (new Rhythmic_grouping (MInterval (start, stop)));
}
Rhythmic_grouping::Rhythmic_grouping()
}
int
-min_elt(Array<int> v)
+min_elt (Array<int> v)
{
int i = 1000; // ugh
for (int j = 0 ; j < v.size(); j++)
}
Array<int>
-Rhythmic_grouping::generate_beams(Array<int> flags, int &flagidx)
+Rhythmic_grouping::generate_beams (Array<int> flags, int &flagidx)
{
assert (!interval_) ;
Array<int> child_beams;
if (children[i]->interval_) {
int f = flags[flagidx++];
- child_beams.push(f);
+ child_beams.push (f);
} else {
child_beams = children[i]->
- generate_beams(flags, flagidx);
+ generate_beams (flags, flagidx);
}
- children_beams.push(child_beams);
+ children_beams.push (child_beams);
}
Array<int> beams;
int lastm, m, nextm;
bool add_right = (i < children_beams.size() -1);
if (!i)
- m = min_elt(children_beams[i]);
+ m = min_elt (children_beams[i]);
if (add_right)
- nextm = min_elt(children_beams[i+1]);
+ nextm = min_elt (children_beams[i+1]);
if (children_beams[i].size() == 1) {
if (add_right)
- beams.push(m);
+ beams.push (m);
if (add_left)
- beams.push(m);
+ beams.push (m);
} else {
if (add_left)
- beams.push(lastm <? m);
- beams.concat(children_beams[i]);
+ beams.push (lastm <? m);
+ beams.concat (children_beams[i]);
if (add_right)
- beams.push(m <? nextm);
+ beams.push (m <? nextm);
}
lastm = m;
m = nextm;
}
- assert(!(beams.size()%2));
+ assert (!(beams.size()%2));
return beams;
}
void
-Rhythmic_grouping::translate(Moment m)
+Rhythmic_grouping::translate (Moment m)
{
if (interval_)
*interval_ += m;
else
for (int i=0; i < children.size(); i++)
- children[i]->translate(m);
+ children[i]->translate (m);
}
void
-Rhythmic_grouping::extend(MInterval m)const
+Rhythmic_grouping::extend (MInterval m)const
{
- assert(m.left >= interval().left);
- while (m.right >interval().right ) {
- Array<Rhythmic_grouping*> a(children);
+ assert (m.left >= interval().left);
+ while (m.right >interval().right) {
+ Array<Rhythmic_grouping*> a (children);
for (int i=0; i < a.size(); i++) {
- a[i] =new Rhythmic_grouping(*children[i]);
- a[i]->translate(children.top()->interval().right);
+ a[i] =new Rhythmic_grouping (*children[i]);
+ a[i]->translate (children.top()->interval ().right);
}
- ((Rhythmic_grouping*)this)->children.concat(a);
+ ((Rhythmic_grouping*)this)->children.concat (a);
}
- assert(m.right <= interval().right);
+ assert (m.right <= interval().right);
OK();
}
Rhythmic_grouping
-parse_grouping(Array<int> beat_i_arr, Array<Moment> elt_length_arr)
+parse_grouping (Array<int> beat_i_arr, Array<Moment> elt_length_arr)
{
Moment here =0;
- assert(beat_i_arr.size() == elt_length_arr.size());
+ assert (beat_i_arr.size() == elt_length_arr.size ());
Array<Rhythmic_grouping*> children;
for (int i=0; i < beat_i_arr.size(); i++) {
Moment last = here;
- here += elt_length_arr[i] * Moment(beat_i_arr[i]);
- children.push(
- new Rhythmic_grouping(MInterval(last, here),
- beat_i_arr[i] ));
+ here += elt_length_arr[i] * Moment (beat_i_arr[i]);
+ children.push (
+ new Rhythmic_grouping (MInterval (last, here),
+ beat_i_arr[i]));
}
- return Rhythmic_grouping(children);
+ return Rhythmic_grouping (children);
}
}
void
-Head_column::do_substitute_dependency(Score_elem*o,
+Head_column::do_substitute_dependency (Score_elem*o,
Score_elem*n)
{
- Script_column::do_substitute_dependency(o,n);
- if (o->name() == Note_head::static_name()) {
- head_l_arr_.substitute( (Note_head*)o->item(),
+ Script_column::do_substitute_dependency (o,n);
+ if (o->name() == Note_head::static_name ()) {
+ head_l_arr_.substitute ((Note_head*)o->item(),
(n)? (Note_head*)n->item() : 0);
}
if (stem_l_ == o) {
void
-Head_column::set(Stem*stem_l)
+Head_column::set (Stem*stem_l)
{
stem_l_ = stem_l;
- Score_elem::add_dependency(stem_l);
+ Score_elem::add_dependency (stem_l);
for (int i=0; script_l_arr_.size(); i++)
- script_l_arr_[i]->set_stem( stem_l );
+ script_l_arr_[i]->set_stem (stem_l);
}
void
-Head_column::add(Script *script_l)
+Head_column::add (Script *script_l)
{
- Script_column::add(script_l) ;
- if (stem_l_ )
- script_l->set_stem( stem_l_ );
+ Script_column::add (script_l) ;
+ if (stem_l_)
+ script_l->set_stem (stem_l_);
}
void
-Head_column::add(Note_head *n_l)
+Head_column::add (Note_head *n_l)
{
- add_support(n_l);
- head_l_arr_.push(n_l);
+ add_support (n_l);
+ head_l_arr_.push (n_l);
}
Head_column::do_print() const
{
#ifndef NPRINT
- mtor << "heads: " << head_l_arr_.size();
+ DOUT << "heads: " << head_l_arr_.size();
#endif
}
}
bool
-Note_head_engraver::do_try_request(Request *req_l)
+Note_head_engraver::do_try_request (Request *req_l)
{
if (note_req_l_)
return false;
- if (req_l->musical() && (req_l->musical()->note() || req_l->musical()->rest()))
- note_req_l_=req_l->musical()->rhythmic();
+ if (req_l->musical() && (req_l->musical ()->note () || req_l->musical ()->rest ()))
+ note_req_l_=req_l->musical()->rhythmic ();
else
return false;
if (!note_req_l_)
return;
- Note_head*n_p = new Note_head(8); // ugh
+ Note_head*n_p = new Note_head (8); // ugh
note_p_ = n_p;
- n_p->set_rhythmic(note_req_l_->rhythmic());
+ n_p->set_rhythmic (note_req_l_->rhythmic());
if (note_req_l_->note()) {
- n_p->position_i_ = note_req_l_->note()->height();
+ n_p->position_i_ = note_req_l_->note()->height ();
Staff_info inf = get_staff_info();
if (inf.c0_position_i_l_)
n_p->position_i_ += *inf.c0_position_i_l_;
n_p->rest_b_ = true;
}
- Score_elem_info itinf(note_p_,note_req_l_);
- announce_element(itinf);
+ Score_elem_info itinf (note_p_,note_req_l_);
+ announce_element (itinf);
}
void
Note_head_engraver::do_pre_move_processing()
{
if (note_p_) {
- typeset_element(note_p_);
+ typeset_element (note_p_);
note_p_ = 0;
}
}
Horizontal_align_item::OK() const
{
for (int i =0; i < item_l_arr_.size(); i++)
- assert ( pcol_l_ == item_l_arr_[i]->pcol_l_ );
+ assert ( pcol_l_ == item_l_arr_[i]->pcol_l_);
}
bool
-Horizontal_align_item::contains_b(Item *i)const
+Horizontal_align_item::contains_b (Item *i)const
{
- return item_l_arr_.find_l(i);
+ return item_l_arr_.find_l (i);
}
void
-Horizontal_align_item::add(Item *i,int p)
+Horizontal_align_item::add (Item *i,int p)
{
- assert(! contains_b(i));
- priority_i_arr_.push(p);
- item_l_arr_.push(i);
- add_dependency(i);
+ assert (! contains_b (i));
+ priority_i_arr_.push (p);
+ item_l_arr_.push (i);
+ add_dependency (i);
}
void
-Horizontal_align_item::do_substitute_dependency(Score_elem*o,Score_elem*n)
+Horizontal_align_item::do_substitute_dependency (Score_elem*o,Score_elem*n)
{
int i;
- while ((i = item_l_arr_.find_i(o->item())) >=0) {
+ while ((i = item_l_arr_.find_i (o->item())) >=0) {
if (n)
item_l_arr_[i] = n->item();
else
- item_l_arr_.del(i);
+ item_l_arr_.del (i);
}
}
Horizontal_align_item_content const &h2) {
return h1.priority_i_ - h2.priority_i_;
}
- Horizontal_align_item_content(Item*i, int p) {
+ Horizontal_align_item_content (Item*i, int p) {
priority_i_ = p;
item_l_ = i;
}
{
Array<Horizontal_align_item_content> content;
for (int i =0; i < item_l_arr_.size(); i++)
- content.push(
- Horizontal_align_item_content(
+ content.push (
+ Horizontal_align_item_content (
item_l_arr_[i], priority_i_arr_[i]));
- content.sort(Horizontal_align_item_content::compare);
+ content.sort (Horizontal_align_item_content::compare);
item_l_arr_.clear();
priority_i_arr_.clear();
for (int i =0; i < content.size(); i++) {
- item_l_arr_.push( content[i].item_l_ );
- priority_i_arr_.push( content[i].priority_i_);
+ item_l_arr_.push (content[i].item_l_);
+ priority_i_arr_.push (content[i].priority_i_);
}
}
Interval item_width= item_l_arr_[i]->width();
if (item_width.empty_b()) {
- item_width = Interval(0,0);
+ item_width = Interval (0,0);
}
- dims.push( item_width);
+ dims.push (item_width);
total += item_width.length();
}
Real center_dx_f = 0;
for ( int i=0 ; i < item_l_arr_.size(); i++) {
Real dx = where_f -dims[i][-1];
- item_l_arr_[i]->translate( dx , X_AXIS);
+ item_l_arr_[i]->translate (dx , X_AXIS);
if (item_l_arr_[i] == center_l_)
center_dx_f = where_f;
where_f += dims[i].length();
}
- if (center_dx_f && !align_i_ )
+ if (center_dx_f && !align_i_)
for ( int i=0 ; i < item_l_arr_.size(); i++)
- item_l_arr_[i]->translate( - center_dx_f , X_AXIS);
+ item_l_arr_[i]->translate (- center_dx_f , X_AXIS);
}
Interval
Horizontal_align_item::do_width() const
{
- return Interval(0,0);
+ return Interval (0,0);
}
void
Idealspacing::print() const
{
#ifndef NPRINT
- mtor << "idealspacing {" ;
- mtor << "distance "<<space_f_<< " strength " << hooke_f_ ;
- mtor << "left " << left_i_ << " right " << right_i_ << "}\n";
+ DOUT << "idealspacing {" ;
+ DOUT << "distance "<<space_f_<< " strength " << hooke_f_ ;
+ DOUT << "left " << left_i_ << " right " << right_i_ << "}\n";
#endif
}
void
Idealspacing::OK() const
{
- assert(hooke_f_ >= 0);
+ assert (hooke_f_ >= 0);
}
const int MAXITER=100; // qlpsolve.hh
/*
- assume x(idx) == value, and adjust constraints, lin and quad accordingly
+ assume x (idx) == value, and adjust constraints, lin and quad accordingly
TODO: add const_term
*/
void
-Ineq_constrained_qp::eliminate_var(int idx, Real value)
+Ineq_constrained_qp::eliminate_var (int idx, Real value)
{
- Vector row(quad.row(idx));
+ Vector row (quad.row (idx));
row*= value;
- quad.delete_row(idx);
+ quad.delete_row (idx);
- quad.delete_column(idx);
+ quad.delete_column (idx);
- lin.del(idx);
- row.del(idx);
+ lin.del (idx);
+ row.del (idx);
lin +=row ;
for (int i=0; i < cons.size(); i++) {
consrhs[i] -= cons[i](idx) *value;
- cons[i].del(idx);
+ cons[i].del (idx);
}
}
void
-Ineq_constrained_qp::add_inequality_cons(Vector c, double r)
+Ineq_constrained_qp::add_inequality_cons (Vector c, double r)
{
- cons.push(c);
- consrhs.push(r);
+ cons.push (c);
+ consrhs.push (r);
}
-Ineq_constrained_qp::Ineq_constrained_qp(int novars):
- quad(novars),
- lin(novars),
+Ineq_constrained_qp::Ineq_constrained_qp (int novars):
+ quad (novars),
+ lin (novars),
const_term (0.0)
{
}
void
Ineq_constrained_qp::OK() const
{
-#if !defined(NDEBUG) && defined(PARANOID)
- assert(cons.size() == consrhs.size());
+#if !defined (NDEBUG) && defined (PARANOID)
+ assert (cons.size() == consrhs.size ());
Matrix Qdif= quad - quad.transposed();
- assert(Qdif.norm()/quad.norm() < EPS);
+ assert (Qdif.norm()/quad.norm () < EPS);
#endif
}
int
-min_elt_index(Vector v)
+min_elt_index (Vector v)
{
Real m=infinity_f;
int idx=-1;
for (int i = 0; i < v.dim(); i++){
- if (v(i) < m) {
+ if (v (i) < m) {
idx = i;
- m = v(i);
+ m = v (i);
}
- assert(v(i) <= infinity_f);
+ assert (v (i) <= infinity_f);
}
return idx;
}
the next point is found in a direction determined by projecting
the gradient onto the active constraints. (well, not really the
gradient. The optimal solution obeying the active constraints is
- tried. This is why H = Q^-1 in initialisation) )
+ tried. This is why H = Q^-1 in initialisation))
*/
Vector
-Ineq_constrained_qp::constraint_solve(Vector start) const
+Ineq_constrained_qp::constraint_solve (Vector start) const
{
if (!dim())
- return Vector(0);
+ return Vector (0);
// experimental
if (quad.dim() > 10)
quad.try_set_band();
- Active_constraints act(this);
+ Active_constraints act (this);
act.OK();
- Vector x(start);
+ Vector x (start);
Vector gradient=quad*x+lin;
// Real fvalue = x*quad*x/2 + lin*x + const_term;
// it's no use.
- Vector last_gradient(gradient);
+ Vector last_gradient (gradient);
int iterations=0;
while (iterations++ < MAXITER) {
- Vector direction= - act.find_active_optimum(gradient);
+ Vector direction= - act.find_active_optimum (gradient);
- mtor << "gradient "<< gradient<< "\ndirection " << direction<<"\n";
+ DOUT << "gradient "<< gradient<< "\ndirection " << direction<<"\n";
if (direction.norm() > EPS) {
- mtor << act.status() << '\n';
+ DOUT << act.status() << '\n';
Real minalf = infinity_f;
- Inactive_iter minidx(act);
+ Inactive_iter minidx (act);
/*
bump into the edges of the simplex
*/
- for (Inactive_iter ia(act); ia.ok(); ia++) {
+ for (Inactive_iter ia (act); ia.ok(); ia++) {
if (ia.vec() * direction >= 0)
continue;
- Real alfa= - (ia.vec()*x - ia.rhs())/
+ Real alfa= - (ia.vec()*x - ia.rhs ())/
(ia.vec()*direction);
if (minalf > alfa) {
}
}
Real unbounded_alfa = 1.0;
- Real optimal_step = min(minalf, unbounded_alfa);
+ Real optimal_step = min (minalf, unbounded_alfa);
Vector deltax=direction * optimal_step;
x += deltax;
gradient += optimal_step * (quad * deltax);
- mtor << "step = " << optimal_step<< " (|dx| = " <<
+ DOUT << "step = " << optimal_step<< " (|dx| = " <<
deltax.norm() << ")\n";
if (minalf < unbounded_alfa) {
/* bumped into an edge. try again, in smaller space. */
- act.add(minidx.idx());
- mtor << "adding cons "<< minidx.idx()<<'\n';
+ act.add (minidx.idx());
+ DOUT << "adding cons "<< minidx.idx()<<'\n';
continue;
}
/*ASSERT: we are at optimal solution for this "plane"*/
}
- Vector lagrange_mult=act.get_lagrange(gradient);
- int m= min_elt_index(lagrange_mult);
+ Vector lagrange_mult=act.get_lagrange (gradient);
+ int m= min_elt_index (lagrange_mult);
- if (m>=0 && lagrange_mult(m) > 0) {
+ if (m>=0 && lagrange_mult (m) > 0) {
break; // optimal sol.
} else if (m<0) {
- assert(gradient.norm() < EPS) ;
+ assert (gradient.norm() < EPS) ;
break;
}
- mtor << "dropping cons " << m<<'\n';
- act.drop(m);
+ DOUT << "dropping cons " << m<<'\n';
+ act.drop (m);
}
if (iterations >= MAXITER)
WARN<<"didn't converge!\n";
- mtor << ": found " << x<<" in " << iterations <<" iterations\n";
- assert_solution(x);
+ DOUT << ": found " << x<<" in " << iterations <<" iterations\n";
+ assert_solution (x);
return x;
}
Vector
-Ineq_constrained_qp::solve(Vector start)const
+Ineq_constrained_qp::solve (Vector start)const
{
/* no hassle if no constraints*/
- if ( ! cons.size() ) {
- Choleski_decomposition chol( quad );
- return - chol.solve(lin);
+ if ( ! cons.size()) {
+ Choleski_decomposition chol (quad);
+ return - chol.solve (lin);
} else {
- return constraint_solve( start );
+ return constraint_solve (start);
}
}
#include "performer-group-performer.hh"
bool
-Input_translator::is_name_b(String n)
+Input_translator::is_name_b (String n)
{
for (int i=0; i < alias_str_arr_.size(); i++)
if (alias_str_arr_[i] == n)
#ifndef NPRINT
if ( ! check_debug)
return ;
- mtor << base_str_ <<" " << type_str_<<" {\n";
- mtor << "Consists of ";
+ DOUT << base_str_ <<" " << type_str_<<" {\n";
+ DOUT << "Consists of ";
for (int i=0; i< consists_str_arr_.size(); i++)
- mtor << consists_str_arr_[i] << ',';
+ DOUT << consists_str_arr_[i] << ',';
if (contains_itrans_p_list_.size())
- mtor << "\nContains " ;
- for (PCursor<Input_translator*> i(contains_itrans_p_list_.top()); i.ok(); i++)
+ DOUT << "\nContains " ;
+ for (PCursor<Input_translator*> i (contains_itrans_p_list_.top()); i.ok (); i++)
i->print();
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
Input_translator *
-Input_translator::recursive_find(String nm)
+Input_translator::recursive_find (String nm)
{
- if ( is_name_b( nm) )
+ if ( is_name_b (nm))
return this;
Input_translator * r =0;
// what bout for() ?
- PCursor<Input_translator*> i(contains_itrans_p_list_.top());
+ PCursor<Input_translator*> i (contains_itrans_p_list_.top());
for (; !r &&i.ok(); i++) {
- if (i->recursive_find(nm))
+ if (i->recursive_find (nm))
r = i.ptr();
}
}
Input_translator *
-Input_translator::find_itrans_l(String nm)
+Input_translator::find_itrans_l (String nm)
{
- for (PCursor<Input_translator*> i(contains_itrans_p_list_.top()); i.ok(); i++)
- if (i->is_name_b( nm))
+ for (PCursor<Input_translator*> i (contains_itrans_p_list_.top()); i.ok (); i++)
+ if (i->is_name_b (nm))
return i;
return 0;
{
assert (base_str_ == "Engraver");
Engraver_group_engraver * grav_p = (Engraver_group_engraver*)
- get_engraver_p(type_str_);
+ get_engraver_p (type_str_);
for (int i=0; i < consists_str_arr_.size(); i++) {
- grav_p->add( get_engraver_p( consists_str_arr_[i]) );
+ grav_p->add (get_engraver_p (consists_str_arr_[i]));
}
grav_p->itrans_l_ = this;
grav_p->id_str_ = default_id_str_;
{
assert (base_str_ == "Performer");
Performer_group_performer * perf_p = (Performer_group_performer*)
- get_performer_p(type_str_);
+ get_performer_p (type_str_);
for (int i=0; i < consists_str_arr_.size(); i++) {
- perf_p->add( get_performer_p( consists_str_arr_[i]) );
+ perf_p->add (get_performer_p (consists_str_arr_[i]));
}
perf_p->itrans_l_ = this;
perf_p->id_str_ = default_id_str_;
}
void
-Input_translator::add(Input_translator *ip)
+Input_translator::add (Input_translator *ip)
{
- contains_itrans_p_list_.bottom().add(ip);
+ contains_itrans_p_list_.bottom().add (ip);
}
Input_translator*
Input_translator::get_default_itrans_l()
{
- if ( contains_itrans_p_list_.size() )
+ if ( contains_itrans_p_list_.size())
return contains_itrans_p_list_.top();
else
return 0;
}
-Input_translator_list::Input_translator_list(Input_translator_list const &s)
+Input_translator_list::Input_translator_list (Input_translator_list const &s)
{
- for (PCursor<Input_translator*> pc(s); pc.ok(); pc++) {
+ for (PCursor<Input_translator*> pc (s); pc.ok(); pc++) {
Input_translator *q = pc;
- Input_translator *p=new Input_translator(*q) ;
- bottom().add(p);
+ Input_translator *p=new Input_translator (*q) ;
+ bottom().add (p);
}
}
Item::do_print() const
{
#ifndef NPRINT
- mtor << "(unknown)";
+ DOUT << "(unknown)";
#endif
}
Real
Item::hpos_f()const
{
- return pcol_l_->hpos_f_ + absolute_coordinate(X_AXIS);
+ return pcol_l_->hpos_f_ + absolute_coordinate (X_AXIS);
}
Line_of_score *
void
Item::copy_breakable_items()
{
- if ( broken_to_a_[0] || broken_to_a_[1] )
+ if ( broken_to_a_[0] || broken_to_a_[1])
return;
Item *new_copies[2];
for (int i=0; i < 2; i++) {
- Item * item_p = clone()->item();
- item_p->copy_dependencies(*this);
+ Item * item_p = clone()->item ();
+ item_p->copy_dependencies (*this);
item_p->break_status_i_ = -1+ 2*i;
- pscore_l_->typeset_item(item_p, pcol_l_);
+ pscore_l_->typeset_item (item_p, pcol_l_);
item_p->handle_prebroken_dependencies();
new_copies[i] =item_p;
}
/*
Otherwise the broken items won't be pre_process()'ed.
*/
- add_dependency( broken_to_a_[0] );
- add_dependency( broken_to_a_[1] );
+ add_dependency (broken_to_a_[0]);
+ add_dependency (broken_to_a_[1]);
}
Item*
-Item::find_prebroken_piece(Line_of_score*l) const
+Item::find_prebroken_piece (Line_of_score*l) const
{
if (line_l() == l)
return (Item*)this;
}
Item*
-Item::find_prebroken_piece(PCol*c)const
+Item::find_prebroken_piece (PCol*c)const
{
- if (c == pcol_l_ )
+ if (c == pcol_l_)
return (Item *) this; // ugh
if (c == pcol_l_->prebreak_p_)
else if (c==pcol_l_->postbreak_p_)
return (Item *)broken_to_a_[1];
- assert(false);
+ assert (false);
}
void
Item::handle_prebroken_dependencies()
{
- if ( breakable_b_ )
+ if ( breakable_b_)
Score_elem::handle_prebroken_dependencies();
}
if (inf.c0_position_i_l_)
c0_i = *get_staff_info().c0_position_i_l_;
- kit_p_ = new Key_item(c0_i);
- announce_element(Score_elem_info(kit_p_,keyreq_l_));
- kit_p_->read(*this);
+ kit_p_ = new Key_item (c0_i);
+ announce_element (Score_elem_info (kit_p_,keyreq_l_));
+ kit_p_->read (*this);
}
}
bool
-Key_engraver::do_try_request(Request * req_l)
+Key_engraver::do_try_request (Request * req_l)
{
Command_req* creq_l= req_l->command();
if (!creq_l|| !creq_l->keychange())
if (keyreq_l_)
return false; // TODO
keyreq_l_ = creq_l->keychange();
- read_req(keyreq_l_);
+ read_req (keyreq_l_);
return true;
}
void
-Key_engraver::acknowledge_element(Score_elem_info info)
+Key_engraver::acknowledge_element (Score_elem_info info)
{
Command_req * r_l = info.req_l_->command() ;
if (r_l && r_l->clefchange()) {
create_key();
- } else if (info.elem_l_->name() == Bar::static_name()) {
+ } else if (info.elem_l_->name() == Bar::static_name ()) {
if ( !keyreq_l_)
default_key_b_ = true;
create_key();
Key_engraver::do_process_requests()
{
if (key_.multi_octave_b_) {
- assert(false); // TODO .
+ assert (false); // TODO .
} else if (keyreq_l_) {
create_key();
}
{
if (kit_p_) {
kit_p_->default_b_ = default_key_b_;
- typeset_element( kit_p_);
+ typeset_element (kit_p_);
kit_p_ = 0;
}
}
void
-Key_engraver::read_req(Key_change_req * r)
+Key_engraver::read_req (Key_change_req * r)
{
key_.multi_octave_b_ = r->multi_octave_b_;
accidental_idx_arr_.clear();
int a_i = m_l->accidental_i_;
int o_i = m_l->octave_i_;
if (r->multi_octave_b_)
- key_.set(o_i, n_i, a_i);
+ key_.set (o_i, n_i, a_i);
else
- key_.set(n_i, a_i);
- accidental_idx_arr_.push(n_i);
+ key_.set (n_i, a_i);
+ accidental_idx_arr_.push (n_i);
}
}
const int FLAT_TOP_PITCH=2; /* fes,ges,as and bes typeset in lower octave */
const int SHARP_TOP_PITCH=4; /* ais and bis typeset in lower octave */
-Key_item::Key_item(int c)
+Key_item::Key_item (int c)
{
breakable_b_ =true;
default_b_ = false;
- set_c_position(c);
+ set_c_position (c);
}
void
-Key_item::read(Key_engraver const & key_grav_r)
+Key_item::read (Key_engraver const & key_grav_r)
{
- assert(!key_grav_r.key_.multi_octave_b_);
+ assert (!key_grav_r.key_.multi_octave_b_);
const Array<int> &idx_arr =key_grav_r.accidental_idx_arr_;
for (int i = 0 ; i< idx_arr.size(); i++) {
int note = idx_arr[i];
- int acc = ((Key &) key_grav_r.key_).oct(0).acc(note);
+ int acc = ((Key &) key_grav_r.key_).oct (0).acc (note);
- add(note, acc);
+ add (note, acc);
}
}
void
-Key_item::set_c_position(int c0)
+Key_item::set_c_position (int c0)
{
- int octaves =(abs(c0) / 7) +1 ;
+ int octaves =(abs (c0) / 7) +1 ;
c_position=(c0 + 7*octaves)%7;
}
void
-Key_item::add(int p, int a)
+Key_item::add (int p, int a)
{
if ((a<0 && p>FLAT_TOP_PITCH) ||
(a>0 && p>SHARP_TOP_PITCH)) {
p -= 7; /* Typeset below c_position */
}
- pitch.push(p);
- acc.push(a);
+ pitch.push (p);
+ acc.push (a);
}
Key_item::brew_molecule_p()const
{
Molecule*output = new Molecule;
- Real inter = paper()->internote_f();
+ Real inter = paper()->internote_f ();
for (int i =0; i < pitch.size(); i++) {
- Symbol s= paper()->lookup_l()->accidental(acc[i]);
- Atom a(s);
- a.translate((c_position + pitch[i]) * inter, Y_AXIS);
- Molecule m(a);
- output->add_right(m);
+ Symbol s= paper()->lookup_l ()->accidental (acc[i]);
+ Atom a (s);
+ a.translate ((c_position + pitch[i]) * inter, Y_AXIS);
+ Molecule m (a);
+ output->add_right (m);
}
- if ( pitch.size() ) {
- Molecule m(paper()->lookup_l()->fill(Box(
- Interval(0, paper()->note_width()),
- Interval(0,0))));
+ if ( pitch.size()) {
+ Molecule m (paper()->lookup_l ()->fill (Box (
+ Interval (0, paper()->note_width ()),
+ Interval (0,0))));
- output->add_right(m);
+ output->add_right (m);
}
return output;
}
void
Key_item::do_pre_processing()
{
- if (default_b_ ) {
+ if (default_b_) {
empty_b_ = transparent_b_ = (break_status_i() != 1);
}
}
Key_performer::do_print() const
{
#ifndef NPRINT
- if ( key_req_l_ )
+ if ( key_req_l_)
key_req_l_->print();
#endif
}
void
Key_performer::process_requests()
{
- if ( key_req_l_ )
- play( new Audio_key( key_req_l_ ) );
+ if ( key_req_l_)
+ play (new Audio_key (key_req_l_) );
key_req_l_ = 0;
}
bool
-Key_performer::do_try_request( Request* req_l )
+Key_performer::do_try_request (Request* req_l)
{
- if ( key_req_l_ )
+ if ( key_req_l_)
return false;
- if ( req_l->command() )
- key_req_l_ = req_l->command()->keychange();
+ if ( req_l->command())
+ key_req_l_ = req_l->command()->keychange ();
- if ( key_req_l_ )
+ if ( key_req_l_)
return true;
return false;
Octave_key::Octave_key()
{
- accidental_i_arr_.set_size(7);
+ accidental_i_arr_.set_size (7);
for (int i= 0; i < 7 ; i++)
accidental_i_arr_[i] = 0;
}
Key::Key()
{
multi_octave_b_ = false;
- octaves.set_size(OCTAVES);
+ octaves.set_size (OCTAVES);
}
Octave_key&
-Key::oct(int i)
+Key::oct (int i)
{
return octaves[i+ZEROOCTAVE];
}
void
-Octave_key::set(int i, int a)
+Octave_key::set (int i, int a)
{
- assert(a > -3 && a < 3);
+ assert (a > -3 && a < 3);
accidental_i_arr_[i]=a;
}
void
-Key::set(int o, int n , int a)
+Key::set (int o, int n , int a)
{
- octaves[o + ZEROOCTAVE].set(n,a);
+ octaves[o + ZEROOCTAVE].set (n,a);
}
void
Key::set (int n, int a)
{
for (int i= 0; i < OCTAVES ; i++)
- octaves[i].set(n,a);
+ octaves[i].set (n,a);
}
{
Keyword_ent *table;
int maxkey;
- Keyword_table(Keyword_ent *);
- int lookup(char const *s) const;
+ Keyword_table (Keyword_ent *);
+ int lookup (char const *s) const;
};
/* for qsort */
int
- tabcmp(void const * p1, void const * p2)
+ tabcmp (void const * p1, void const * p2)
{
- return strcmp(((Keyword_ent const *) p1)->name,
+ return strcmp (((Keyword_ent const *) p1)->name,
((Keyword_ent const *) p2)->name);
}
-Keyword_table::Keyword_table(Keyword_ent *tab)
+Keyword_table::Keyword_table (Keyword_ent *tab)
{
table = tab;
for (maxkey = 0; table[maxkey].name; maxkey++);
/* sort them */
- qsort(table, maxkey, sizeof(Keyword_ent), tabcmp);
+ qsort (table, maxkey, sizeof (Keyword_ent), tabcmp);
}
/*
lookup with binsearch, return tokencode.
*/
int
-Keyword_table::lookup(char const *s)const
+Keyword_table::lookup (char const *s)const
{
int lo,
hi,
{
cmp = (lo + hi) / 2;
- result = strcmp(s, table[cmp].name);
+ result = strcmp (s, table[cmp].name);
if (result < 0)
hi = cmp;
lo = cmp;
}
while (hi - lo > 1);
- if (!strcmp(s, table[lo].name))
+ if (!strcmp (s, table[lo].name))
{
return table[lo].tokcode;
} else
void
Least_squares::OK() const
{
- assert( input.size() > 1 );
+ assert (input.size() > 1);
Real dx = 0.0;
for (int i=1; i < input.size(); i++)
- dx += abs (input[i-1].x() - input[i].x());
+ dx += abs (input[i-1].x() - input[i].x ());
- assert(dx);
+ assert (dx);
}
void
-Least_squares::minimise(Real &coef, Real &offset)
+Least_squares::minimise (Real &coef, Real &offset)
{
OK();
Real sx = 0.0;
Real y = input[i].y();
sx += x;
sy += y;
- sqx += sqr(x);
+ sqx += sqr (x);
sxy += x*y;
}
int N = input.size();
- coef = (N * sxy - sx*sy )/(N*sqx - sqr(sx));
+ coef = (N * sxy - sx*sy)/(N*sqx - sqr (sx));
offset = (sy - coef * sx)/N;
}
lily_version_sz()
{
static char v[1024]; // ugh
- sprintf(v, s, build);
+ sprintf (v, s, build);
return v;
}
}
void
-Line_group_engraver::acknowledge_element(Score_elem_info elem)
+Line_group_engraver::acknowledge_element (Score_elem_info elem)
{
- if ( !elem.elem_l_->axis_group_l_a_[Y_AXIS] )
- staffline_p_->add_element(elem.elem_l_);
+ if ( !elem.elem_l_->axis_group_l_a_[Y_AXIS])
+ staffline_p_->add_element (elem.elem_l_);
}
void
Line_group_engraver::do_removal_processing()
{
- staffline_p_->right_col_l_ = get_staff_info().command_pcol_l();
- typeset_element(staffline_p_);
+ staffline_p_->right_col_l_ = get_staff_info().command_pcol_l ();
+ typeset_element (staffline_p_);
staffline_p_ = 0;
}
Line_group_engraver::do_creation_processing()
{
staffline_p_ = new Vertical_group_spanner ;
- staffline_p_->left_col_l_ = get_staff_info().command_pcol_l();
+ staffline_p_->left_col_l_ = get_staff_info().command_pcol_l ();
// don't broadcast to self.
- announce_element(Score_elem_info(staffline_p_,0));
+ announce_element (Score_elem_info (staffline_p_,0));
}
Item * support_l = support_l_arr_[i];
Note_req * note_l = mel_l_arr_[i];
- if (tied_l_arr_.find_l(support_l) &&
+ if (tied_l_arr_.find_l (support_l) &&
!note_l->forceacc_b_)
continue;
- if( !note_l->forceacc_b_ &&
- local_key_.oct(note_l->octave_i_).acc(note_l->notename_i_)
+ if (!note_l->forceacc_b_ &&
+ local_key_.oct (note_l->octave_i_).acc (note_l->notename_i_)
== note_l->accidental_i_)
continue;
if (inf.c0_position_i_l_)
c0_i = *get_staff_info().c0_position_i_l_;
- key_item_p = new Local_key_item(c0_i);
+ key_item_p = new Local_key_item (c0_i);
}
- key_item_p->add(note_l);
- key_item_p->add_support(support_l);
- local_key_.oct(note_l->octave_i_)
- .set(note_l->notename_i_, note_l->accidental_i_);
+ key_item_p->add (note_l);
+ key_item_p->add_support (support_l);
+ local_key_.oct (note_l->octave_i_)
+ .set (note_l->notename_i_, note_l->accidental_i_);
}
}
if (key_item_p) {
- for(int i=0; i < support_l_arr_.size(); i++)
- key_item_p->add_support(support_l_arr_[i]);
+ for (int i=0; i < support_l_arr_.size(); i++)
+ key_item_p->add_support (support_l_arr_[i]);
- announce_element(Score_elem_info(key_item_p, 0)); // ugh ugh ugh
- typeset_element(key_item_p);
+ announce_element (Score_elem_info (key_item_p, 0)); // ugh ugh ugh
+ typeset_element (key_item_p);
}
mel_l_arr_.clear();
whoah .. this looks hairy!
*/
void
-Local_key_engraver::acknowledge_element(Score_elem_info info)
+Local_key_engraver::acknowledge_element (Score_elem_info info)
{
Score_elem * elem_l = info.elem_l_;
- if (info.req_l_->musical() && info.req_l_->musical()->note()) {
- Note_req * note_l = info.req_l_->musical()->note();
+ if (info.req_l_->musical() && info.req_l_->musical ()->note ()) {
+ Note_req * note_l = info.req_l_->musical()->note ();
Item * item_l = info.elem_l_->item();
- mel_l_arr_.push(note_l );
- support_l_arr_.push(item_l);
+ mel_l_arr_.push (note_l);
+ support_l_arr_.push (item_l);
} else if (info.req_l_->command()
- && info.req_l_->command()->keychange()) {
+ && info.req_l_->command()->keychange ()) {
Key_engraver * key_grav_l =
(Key_engraver*)info.origin_grav_l_arr_[0];
key_C_ = &key_grav_l->key_;
local_key_ = *key_C_;
- } else if (elem_l->name() == Key_item::static_name()) {
+ } else if (elem_l->name() == Key_item::static_name ()) {
Key_engraver * key_grav_l =
(Key_engraver*)info.origin_grav_l_arr_[0];
key_C_ = &key_grav_l->key_;
- } else if (elem_l->name() == Tie::static_name()) {
+ } else if (elem_l->name() == Tie::static_name ()) {
Tie * tie_l = (Tie*)elem_l->spanner();
if (tie_l->same_pitch_b_)
- tied_l_arr_.push(tie_l-> right_head_l_ );
+ tied_l_arr_.push (tie_l-> right_head_l_);
}
}
-Local_key_item::Local_key_item(int i)
+Local_key_item::Local_key_item (int i)
{
c0_position = i;
}
void
-Local_key_item::add_support(Item*head_l)
+Local_key_item::add_support (Item*head_l)
{
- support_items_.push(head_l);
- add_dependency(head_l);
+ support_items_.push (head_l);
+ add_dependency (head_l);
}
void
-Local_key_item::add(Melodic_req*m_l)
+Local_key_item::add (Melodic_req*m_l)
{
- add(m_l->octave_i_, m_l->notename_i_, m_l->accidental_i_);
+ add (m_l->octave_i_, m_l->notename_i_, m_l->accidental_i_);
}
void
l.name_i_ = p;
l.accidental_i_ = a;
for (int i=0; i< accs.size(); i++)
- if (!Local_acc::compare(l, accs[i]))
+ if (!Local_acc::compare (l, accs[i]))
return;
- accs.push(l);
+ accs.push (l);
}
void
Local_key_item::do_pre_processing()
{
- accs.sort(Local_acc::compare);
+ accs.sort (Local_acc::compare);
}
Molecule*
// do one octave
if (accs[i].octave_i_ != lastoct) {
if (octmol){
- Real dy =lastoct*7*paper()->internote_f();
- octmol->translate( dy, Y_AXIS);
- output->add(*octmol);
+ Real dy =lastoct*7*paper()->internote_f ();
+ octmol->translate (dy, Y_AXIS);
+ output->add (*octmol);
delete octmol;
}
octmol= new Molecule;
}
lastoct = accs[i].octave_i_;
- Symbol s =paper()->lookup_l()->accidental(accs[i].accidental_i_);
- Atom a(s);
- Real dy = (accs[i].name_i_ + c0_position) * paper()->internote_f();
- a.translate(dy, Y_AXIS);
+ Symbol s =paper()->lookup_l ()->accidental (accs[i].accidental_i_);
+ Atom a (s);
+ Real dy = (accs[i].name_i_ + c0_position) * paper()->internote_f ();
+ a.translate (dy, Y_AXIS);
- octmol->add_right(a);
+ octmol->add_right (a);
}
if (octmol){
- Real dy =lastoct*7*paper()->internote_f();
- octmol->translate( dy, Y_AXIS);
- output->add(*octmol);
+ Real dy =lastoct*7*paper()->internote_f ();
+ octmol->translate (dy, Y_AXIS);
+ output->add (*octmol);
delete octmol;
}
- Interval head_width=itemlist_width(support_items_);
- output->translate(-output->extent().x().right + head_width.left , X_AXIS);
+ Interval head_width=itemlist_width (support_items_);
+ output->translate (-output->extent().x ().right + head_width.left , X_AXIS);
return output;
}
int
-Local_acc::compare(Local_acc&a, Local_acc&b)
+Local_acc::compare (Local_acc&a, Local_acc&b)
{
if (a.octave_i_ - b.octave_i_)
return a.octave_i_ - b.octave_i_;
IMPLEMENT_IS_TYPE_B1(Local_key_item,Item);
void
-Local_key_item::do_substitute_dependency(Score_elem*o,Score_elem*n)
+Local_key_item::do_substitute_dependency (Score_elem*o,Score_elem*n)
{
Item* o_l = o->item();
Item* n_l = n?n->item():0;
- support_items_.substitute(o_l, n_l);
+ support_items_.substitute (o_l, n_l);
}
symtables_ = new Symtables;
}
-Lookup::Lookup(Lookup const &s)
+Lookup::Lookup (Lookup const &s)
{
paper_l_ = s.paper_l_;
texsetting = s.texsetting;
- symtables_ = new Symtables(*s.symtables_);
+ symtables_ = new Symtables (*s.symtables_);
}
Lookup::~Lookup()
{
}
void
-Lookup::add(String s, Symtable*p)
+Lookup::add (String s, Symtable*p)
{
- symtables_->add(s, p);
+ symtables_->add (s, p);
}
void
Lookup::print()const
{
#ifndef NPRINT
- mtor << "Lookup: " << texsetting << " {\n";
+ DOUT << "Lookup: " << texsetting << " {\n";
symtables_->print();
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
Symbol
-Lookup::text(String style, String text, int dir) const
+Lookup::text (String style, String text, int dir) const
{
Array<String> a;
- a.push(text);
- Symbol tsym = (*symtables_)("style")->lookup(style);
- a[0] = substitute_args(tsym.tex,a);
+ a.push (text);
+ Symbol tsym = (*symtables_)("style")->lookup (style);
+ a[0] = substitute_args (tsym.tex,a);
- Symbol s = (*symtables_)("align")->lookup(dir);
- s.tex = substitute_args(s.tex,a);
+ Symbol s = (*symtables_)("align")->lookup (dir);
+ s.tex = substitute_args (s.tex,a);
s.dim = tsym.dim;
return s;
}
Symbol
-Lookup::ball(int j) const
+Lookup::ball (int j) const
{
if (j > 4)
j = 4;
Symtable * st = (*symtables_)("balls");
- return st->lookup(String(j));
+ return st->lookup (String (j));
}
Symbol
-Lookup::rest(int j, bool o) const
+Lookup::rest (int j, bool o) const
{
- return (*symtables_)("rests")->lookup(String(j) + (o ? "o" : "") );
+ return (*symtables_)("rests")->lookup (String (j) + (o ? "o" : ""));
}
Symbol
-Lookup::fill(Box b) const
+Lookup::fill (Box b) const
{
- Symbol s( (*symtables_)("param")->lookup("fill"));
+ Symbol s ((*symtables_)("param")->lookup ("fill"));
s.dim = b;
return s;
}
Symbol
-Lookup::accidental(int j) const
+Lookup::accidental (int j) const
{
- return (*symtables_)("accidentals")->lookup(String(j));
+ return (*symtables_)("accidentals")->lookup (String (j));
}
Symbol
-Lookup::bar(String s, Real h) const
+Lookup::bar (String s, Real h) const
{
Array<String> a;
- a.push(print_dimen( h));
- Symbol ret=(*symtables_)("bars")->lookup(s);;
- ret.tex = substitute_args(ret.tex, a);
- ret.dim.y() = Interval( 0, h);
+ a.push (print_dimen (h));
+ Symbol ret=(*symtables_)("bars")->lookup (s);;
+ ret.tex = substitute_args (ret.tex, a);
+ ret.dim.y() = Interval (0, h);
return ret;
}
Symbol
-Lookup::script(String s) const
+Lookup::script (String s) const
{
- return (*symtables_)("scripts")->lookup(s);
+ return (*symtables_)("scripts")->lookup (s);
}
Symbol
-Lookup::dynamic(String s) const
+Lookup::dynamic (String s) const
{
- return (*symtables_)("dynamics")->lookup(s);
+ return (*symtables_)("dynamics")->lookup (s);
}
Symbol
-Lookup::clef(String s) const
+Lookup::clef (String s) const
{
- return (*symtables_)("clefs")->lookup(s);
+ return (*symtables_)("clefs")->lookup (s);
}
Symbol
-Lookup::dots(int j) const
+Lookup::dots (int j) const
{
if (j>3) {
j = 3;
- warning("max 3 dots"); // todo
+ warning ("max 3 dots"); // todo
}
- return (*symtables_)("dots")->lookup(j);
+ return (*symtables_)("dots")->lookup (j);
}
Symbol
-Lookup::flag(int j) const
+Lookup::flag (int j) const
{
- return (*symtables_)("flags")->lookup(j);
+ return (*symtables_)("flags")->lookup (j);
}
Symbol
-Lookup::streepjes(int i) const
+Lookup::streepjes (int i) const
{
- assert(i);
+ assert (i);
int arg;
String idx;
arg = i;
idx = "toplines";
}
- Symbol ret = (*symtables_)("streepjes")->lookup(idx);
+ Symbol ret = (*symtables_)("streepjes")->lookup (idx);
Array<String> a;
- a.push(arg);
- ret.tex = substitute_args(ret.tex, a);
+ a.push (arg);
+ ret.tex = substitute_args (ret.tex, a);
return ret;
}
Symbol
-Lookup::hairpin(Real &wid, bool decresc) const
+Lookup::hairpin (Real &wid, bool decresc) const
{
- int idx = int(rint(wid / 6 PT));
- if(!idx) idx ++;
+ int idx = int (rint (wid / 6 PT));
+ if (!idx) idx ++;
wid = idx*6 PT;
String idxstr = (decresc)? "decrescendosym" : "crescendosym";
- Symbol ret=(*symtables_)("param")->lookup(idxstr);
+ Symbol ret=(*symtables_)("param")->lookup (idxstr);
Array<String> a;
- a.push(idx);
- ret.tex = substitute_args(ret.tex, a);
- ret.dim.x() = Interval(0,wid);
+ a.push (idx);
+ ret.tex = substitute_args (ret.tex, a);
+ ret.dim.x() = Interval (0,wid);
return ret;
}
Symbol
-Lookup::linestaff(int lines, Real wid) const
+Lookup::linestaff (int lines, Real wid) const
{
Real internote_f = paper_l_ ->internote_f();
Symbol s;
Real dy = (lines >0) ? (lines-1)*internote_f : 0;
- s.dim = Box(Interval(0,wid), Interval(0,dy));
+ s.dim = Box (Interval (0,wid), Interval (0,dy));
Array<String> a;
- a.push(lines);
- a.push(print_dimen(wid));
+ a.push (lines);
+ a.push (print_dimen (wid));
- s.tex = (*symtables_)("param")->lookup("linestaf").tex;
- s.tex = substitute_args(s.tex, a);
+ s.tex = (*symtables_)("param")->lookup ("linestaf").tex;
+ s.tex = substitute_args (s.tex, a);
return s;
}
Symbol
-Lookup::meter(Array<Scalar> a) const
+Lookup::meter (Array<Scalar> a) const
{
Symbol s;
- s.dim.x() = Interval( 0 PT, 10 PT);
- s.dim.y() = Interval(0, 20 PT); // todo
- String src = (*symtables_)("param")->lookup("meter").tex;
- s.tex = substitute_args(src,a);
+ s.dim.x() = Interval (0 PT, 10 PT);
+ s.dim.y() = Interval (0, 20 PT); // todo
+ String src = (*symtables_)("param")->lookup ("meter").tex;
+ s.tex = substitute_args (src,a);
return s;
}
Symbol
-Lookup::stem(Real y1,Real y2) const
+Lookup::stem (Real y1,Real y2) const
{
if (y1 > y2) {
Real t = y1;
}
Symbol s;
- s.dim.x() = Interval(0,0);
- s.dim.y() = Interval(y1,y2);
+ s.dim.x() = Interval (0,0);
+ s.dim.y() = Interval (y1,y2);
Array<String> a;
- a.push(print_dimen(y1));
- a.push(print_dimen(y2));
+ a.push (print_dimen (y1));
+ a.push (print_dimen (y2));
- String src = (*symtables_)("param")->lookup("stem").tex;
- s.tex = substitute_args(src,a);
+ String src = (*symtables_)("param")->lookup ("stem").tex;
+ s.tex = substitute_args (src,a);
return s;
}
should be handled via TeX code and Lookup::bar()
*/
Symbol
-Lookup::vbrace(Real &y) const
+Lookup::vbrace (Real &y) const
{
if (y < 2* 20 PT) {
- warning ( "piano brace too small (" + print_dimen(y)+ ")");
+ warning ( "piano brace too small (" + print_dimen (y)+ ")");
y = 2*20 PT;
}
if (y > 67 * 2 PT) {
- warning ( "piano brace too big (" + print_dimen(y)+ ")");
+ warning ( "piano brace too big (" + print_dimen (y)+ ")");
y = 67 *2 PT;
}
- int idx = int(rint((y/2.0 - 20 ) + 148));
+ int idx = int (rint ((y/2.0 - 20) + 148));
- Symbol s = (*symtables_)("param")->lookup("brace");
+ Symbol s = (*symtables_)("param")->lookup ("brace");
{
Array<String> a;
- a.push(idx);
- s.tex = substitute_args(s.tex,a);
- s.dim.y() = Interval(0,y);
+ a.push (idx);
+ s.tex = substitute_args (s.tex,a);
+ s.dim.y() = Interval (0,y);
}
{
Array<String> a;
- a.push(print_dimen( y/2 ));
- a.push(print_dimen(0));
- a.push(s.tex);
- s.tex = substitute_args("\\placebox{%}{%}{%}", a);
+ a.push (print_dimen (y/2));
+ a.push (print_dimen (0));
+ a.push (s.tex);
+ s.tex = substitute_args ("\\placebox{%}{%}{%}", a);
}
}
bool
-Lyric_engraver::do_try_request(Request*r)
+Lyric_engraver::do_try_request (Request*r)
{
Musical_req * m =r->musical();
if (!m || ! m->lreq_l())
void
Lyric_engraver::do_process_requests()
{
- if ( lreq_l_ ) {
- lyric_item_p_ = new Text_item(lreq_l_->tdef_p_ );
+ if ( lreq_l_) {
+ lyric_item_p_ = new Text_item (lreq_l_->tdef_p_);
- lyric_item_p_->translate( paper()->note_width()/2 , X_AXIS);
+ lyric_item_p_->translate (paper()->note_width ()/2 , X_AXIS);
lyric_item_p_->dir_i_ = -1;
lyric_item_p_->fat_b_ = true;
- announce_element( Score_elem_info( lyric_item_p_, lreq_l_));
+ announce_element (Score_elem_info (lyric_item_p_, lreq_l_));
}
}
void
Lyric_engraver::do_pre_move_processing()
{
- if ( lyric_item_p_ ){
- typeset_element( lyric_item_p_);
+ if ( lyric_item_p_){
+ typeset_element (lyric_item_p_);
lyric_item_p_ =0;
}
}
Lyric_performer::do_print() const
{
#ifndef NPRINT
- if ( lreq_arr_.size() )
+ if ( lreq_arr_.size())
lreq_arr_[ 0 ]->print();
#endif
}
void
Lyric_performer::process_requests()
{
- if ( lreq_arr_.size() )
- play( new Audio_text( Audio_text::LYRIC, lreq_arr_[ 0 ]->tdef_p_->text_str_ ) );
+ if ( lreq_arr_.size())
+ play (new Audio_text (Audio_text::LYRIC, lreq_arr_[ 0 ]->tdef_p_->text_str_) );
lreq_arr_.clear();
}
bool
-Lyric_performer::do_try_request( Request* req_l )
+Lyric_performer::do_try_request (Request* req_l)
{
Musical_req* m_l = req_l->musical();
- if ( !m_l || ! m_l->lreq_l() )
+ if ( !m_l || ! m_l->lreq_l())
return false;
- lreq_arr_.push( m_l->lreq_l() );
+ lreq_arr_.push (m_l->lreq_l());
return true;
}
bool version_ignore_b_ = false;
int exit_status_i_;
-void destill_inname( String &name_str_r);
+void destill_inname (String &name_str_r);
Long_option_init theopts[] = {
{1, "output", 'o'},
static File_path path;
void
-do_one_file(String init_str, String file_str)
+do_one_file (String init_str, String file_str)
{
- if ( init_str != "" && "" == path.find( init_str ) ) {
+ if ( init_str != "" && "" == path.find (init_str) ) {
error ( "Can not find `" + init_str +"\'");
return ;
}
- if ( file_str!= "" && path.find( file_str ) == "" ) {
+ if ( file_str!= "" && path.find (file_str) == "" ) {
error ( "Can not find `" + file_str + "'");
return ;
}
Sources sources;
source_l_g = &sources;
- source_l_g->set_path(&path);
+ source_l_g->set_path (&path);
{
- My_lily_parser parser(source_l_g);
- parser.set_version_check(version_ignore_b_);
- parser.parse_file(init_str, file_str);
+ My_lily_parser parser (source_l_g);
+ parser.set_version_check (version_ignore_b_);
+ parser.parse_file (init_str, file_str);
}
do_scores();
source_l_g = 0;
// must override (come before) "/usr/local/share/lilypond"!
- char const * env_l=getenv("LILYINCLUDE");
+ char const * env_l=getenv ("LILYINCLUDE");
if (env_l) {
- path.add(env_l);
+ path.add (env_l);
}
- path.add( "" );
- path.add( String( DIR_DATADIR ) + "/init/" );
+ path.add ("");
+ path.add (String (DIR_DATADIR) + "/init/" );
- path.push(DIR_DATADIR );
+ path.push (DIR_DATADIR);
- Getopt_long oparser(argc, argv,theopts);
+ Getopt_long oparser (argc, argv,theopts);
cout << get_version_str() << endl;
- String init_str("symbol.ly");
+ String init_str ("symbol.ly");
while (Long_option_init const * opt = oparser()) {
switch ( opt->shortname){
case 'o':
- set_default_output(oparser.optional_argument_ch_C_);
+ set_default_output (oparser.optional_argument_ch_C_);
break;
case 'w':
notice();
- exit(0);
+ exit (0);
break;
case 'I':
- path.push(oparser.optional_argument_ch_C_);
+ path.push (oparser.optional_argument_ch_C_);
break;
case 'i':
init_str = oparser.optional_argument_ch_C_;
break;
case 'h':
usage();
- exit(0);
+ exit (0);
break;
case 'V':
version_ignore_b_ = true;
break;
case 'd':
- set_debug(true);
+ set_debug (true);
break;
case 'M':
only_midi = true;
break;
default:
- assert(false);
+ assert (false);
break;
}
}
int p=0;
const char *arg ;
- while ( (arg= oparser.get_next_arg()) ) {
- String f(arg);
- destill_inname(f);
- do_one_file(init_str,f);
+ while ( (arg= oparser.get_next_arg())) {
+ String f (arg);
+ destill_inname (f);
+ do_one_file (init_str,f);
p++;
}
if (!p) {
- do_one_file(init_str, "");
+ do_one_file (init_str, "");
}
return exit_status_i_;
/// make input file name: add default extension. "" is stdin.
void
-destill_inname( String &name_str_r)
+destill_inname (String &name_str_r)
{
- if ( name_str_r.length_i() )
+ if ( name_str_r.length_i())
{
- if( name_str_r[ 0 ] != '-' )
+ if (name_str_r[ 0 ] != '-')
{
String a,b,c,d;
- split_path(name_str_r,a,b,c,d);
+ split_path (name_str_r,a,b,c,d);
// add extension if not present.
if (d == "")
{
meter_req_l_ = 0;
meter_p_ =0;
- default_grouping_ = Rhythmic_grouping(MInterval(0,4),4); // ugh
+ default_grouping_ = Rhythmic_grouping (MInterval (0,4),4); // ugh
}
void
-Meter_engraver::fill_staff_info(Staff_info&inf)
+Meter_engraver::fill_staff_info (Staff_info&inf)
{
inf.time_C_ = &time_;
inf.rhythmic_C_ = &default_grouping_;
}
bool
-Meter_engraver::do_try_request(Request*r)
+Meter_engraver::do_try_request (Request*r)
{
bool gotcha = false;
- if (r->command() && r->command()->timing()) {
+ if (r->command() && r->command ()->timing ()) {
gotcha = true;
- Timing_req * tr_l = r->command()->timing();
+ Timing_req * tr_l = r->command()->timing ();
Meter_change_req *m_l = tr_l->meterchange();
if (m_l) {
meter_req_l_ = m_l;
int b_i= m_l->beats_i_;
int o_i = m_l->one_beat_i_;
- if (! time_.allow_meter_change_b() )
- tr_l->warning("Meter change not allowed here");
+ if (! time_.allow_meter_change_b())
+ tr_l->warning ("Meter change not allowed here");
else{
- time_.set_meter(b_i, o_i);
+ time_.set_meter (b_i, o_i);
default_grouping_ =
- Rhythmic_grouping(MInterval(0,Moment(b_i, o_i)), b_i);
+ Rhythmic_grouping (MInterval (0,Moment (b_i, o_i)), b_i);
}
} else if (tr_l->partial()) {
Moment m = tr_l->partial()->duration_;
- String error = time_.try_set_partial_str(m);
+ String error = time_.try_set_partial_str (m);
if (error != "") {
- tr_l->warning(error);
+ tr_l->warning (error);
} else
- time_.setpartial(m);
+ time_.setpartial (m);
} else if (tr_l->barcheck()) {
if (time_.whole_in_measure_) {
- tr_l ->warning( "Barcheck failed");
+ tr_l ->warning ("Barcheck failed");
time_.whole_in_measure_ = 0; // resync
time_.error_b_ = true;
}
} else if (tr_l->cadenza()) {
- time_.set_cadenza(tr_l->cadenza()->on_b_);
+ time_.set_cadenza (tr_l->cadenza()->on_b_);
} else if (tr_l->measuregrouping()) {
- default_grouping_ = parse_grouping(
+ default_grouping_ = parse_grouping (
tr_l->measuregrouping()->beat_i_arr_,
tr_l->measuregrouping()->elt_length_arr_);
void
Meter_engraver::do_creation_processing()
{
- time_.when_ = get_staff_info().when();
+ time_.when_ = get_staff_info().when ();
}
void
Meter_engraver::do_process_requests()
{
- if (meter_req_l_ ) {
+ if (meter_req_l_) {
Array<Scalar> args;
- args.push(meter_req_l_->beats_i_);
- args.push(meter_req_l_->one_beat_i_);
+ args.push (meter_req_l_->beats_i_);
+ args.push (meter_req_l_->one_beat_i_);
- meter_p_ = new Meter(args);
+ meter_p_ = new Meter (args);
}
if (meter_p_)
- announce_element(Score_elem_info(meter_p_, meter_req_l_) );
+ announce_element (Score_elem_info (meter_p_, meter_req_l_));
}
void
Meter_engraver::do_pre_move_processing()
{
if (meter_p_) {
- typeset_element(meter_p_);
+ typeset_element (meter_p_);
meter_p_ =0;
meter_req_l_ = 0;
}
grav_l = grav_l->daddy_grav_l_;
}
- assert( grav_l->name() == Score_engraver::static_name());
+ assert (grav_l->name() == Score_engraver::static_name ());
if (!time_.cadenza_b_)
- ((Score_engraver*)grav_l)->add_moment_to_process( time_.next_bar_moment());
+ ((Score_engraver*)grav_l)->add_moment_to_process (time_.next_bar_moment());
}
void
Meter_engraver::do_post_move_processing()
{
- time_.add( get_staff_info().when() - time_.when_ );
+ time_.add (get_staff_info().when () - time_.when_);
}
Meter_performer::do_print() const
{
#ifndef NPRINT
- if ( meter_req_l_ )
+ if ( meter_req_l_)
meter_req_l_->print();
#endif
}
void
Meter_performer::process_requests()
{
- if ( meter_req_l_ )
- play( new Audio_meter( meter_req_l_ ) );
+ if ( meter_req_l_)
+ play (new Audio_meter (meter_req_l_) );
meter_req_l_ = 0;
}
bool
-Meter_performer::do_try_request( Request* req_l )
+Meter_performer::do_try_request (Request* req_l)
{
- if ( meter_req_l_ )
+ if ( meter_req_l_)
return false;
- if ( req_l->command() )
- meter_req_l_ = req_l->command()->meterchange();
+ if ( req_l->command())
+ meter_req_l_ = req_l->command()->meterchange ();
- if ( meter_req_l_ )
+ if ( meter_req_l_)
return true;
return false;
#include "paper-def.hh"
#include "lookup.hh"
-Meter::Meter(Array<Scalar>a)
- :args(a)
+Meter::Meter (Array<Scalar>a)
+ :args (a)
{
breakable_b_ = true;
}
Molecule*
Meter::brew_molecule_p()const
{
- Symbol s = paper()->lookup_l()->meter(args);
- return new Molecule(Atom(s));
+ Symbol s = paper()->lookup_l ()->meter (args);
+ return new Molecule (Atom (s));
}
outfile_str_ = "";
itrans_p_ = 0;
// ugh
- set_tempo( Moment( 1, 4 ), 60 );
+ set_tempo (Moment (1, 4), 60 );
}
-Midi_def::Midi_def( Midi_def const& s )
+Midi_def::Midi_def (Midi_def const& s)
{
whole_seconds_f_ = s.whole_seconds_f_;
- itrans_p_ = s.itrans_p_ ? new Input_translator( *s.itrans_p_ ) : 0;
+ itrans_p_ = s.itrans_p_ ? new Input_translator (*s.itrans_p_) : 0;
outfile_str_ = s.outfile_str_;
}
}
Real
-Midi_def::duration_to_seconds_f( Moment mom )
+Midi_def::duration_to_seconds_f (Moment mom)
{
- if ( !mom )
+ if ( !mom)
return 0;
- return Moment( whole_seconds_f_ ) * mom;
+ return Moment (whole_seconds_f_) * mom;
}
Global_translator*
Midi_def::get_global_translator_p() const
{
- return itrans_p_->get_group_performer_p()->global_l();
+ return itrans_p_->get_group_performer_p()->global_l ();
}
int
-Midi_def::get_tempo_i( Moment moment )
+Midi_def::get_tempo_i (Moment moment)
{
- return Moment( whole_seconds_f_ ) * Moment( 60 ) * moment;
+ return Moment (whole_seconds_f_) * Moment (60 ) * moment;
}
void
Midi_def::print() const
{
#ifndef NPRINT
- mtor << "Midi {";
- mtor << "4/min: " << Real( 60 ) / ( whole_seconds_f_ * 4 );
- mtor << "out: " << outfile_str_;
- mtor << "}\n";
+ DOUT << "Midi {";
+ DOUT << "4/min: " << Real (60) / ( whole_seconds_f_ * 4 );
+ DOUT << "out: " << outfile_str_;
+ DOUT << "}\n";
#endif
}
void
-Midi_def::set( Input_translator* itrans_p )
+Midi_def::set (Input_translator* itrans_p)
{
delete itrans_p_;
itrans_p_ = itrans_p;
}
void
-Midi_def::set_tempo( Moment moment, int count_per_minute_i )
+Midi_def::set_tempo (Moment moment, int count_per_minute_i)
{
- whole_seconds_f_ = Moment( count_per_minute_i ) / Moment( 60 ) / moment;
+ whole_seconds_f_ = Moment (count_per_minute_i) / Moment (60 ) / moment;
}
IMPLEMENT_IS_TYPE_B1(Midi_track, Midi_chunk);
Midi_chunk::Midi_chunk()
- : Midi_item( 0 )
+ : Midi_item (0)
{
}
void
-Midi_chunk::add( String str )
+Midi_chunk::add (String str)
{
data_str_ += str;
}
void
-Midi_chunk::set( String header_str, String data_str, String footer_str )
+Midi_chunk::set (String header_str, String data_str, String footer_str)
{
data_str_ = data_str;
footer_str_ = footer_str;
Midi_chunk::str() const
{
String str = header_str_;
- String length_str = String_convert::i2hex_str( data_str_.length_i() + footer_str_.length_i(), 8, '0' );
- length_str = String_convert::hex2bin_str( length_str );
+ String length_str = String_convert::i2hex_str (data_str_.length_i() + footer_str_.length_i (), 8, '0');
+ length_str = String_convert::hex2bin_str (length_str);
str += length_str;
str += data_str_;
str += footer_str_;
return str;
}
-Midi_duration::Midi_duration( Real seconds_f )
- : Midi_item( 0 )
+Midi_duration::Midi_duration (Real seconds_f)
+ : Midi_item (0)
{
seconds_f_ = seconds_f;
}
String
Midi_duration::str() const
{
- return String( "<duration: " ) + String( seconds_f_ ) + ">";
+ return String ("<duration: ") + String (seconds_f_ ) + ">";
}
-Midi_header::Midi_header( int format_i, int tracks_i, int clocks_per_4_i )
+Midi_header::Midi_header (int format_i, int tracks_i, int clocks_per_4_i)
: Midi_chunk()
{
String str;
- String format_str = String_convert::i2hex_str( format_i, 4, '0' );
- str += String_convert::hex2bin_str( format_str );
+ String format_str = String_convert::i2hex_str (format_i, 4, '0');
+ str += String_convert::hex2bin_str (format_str);
- String tracks_str = String_convert::i2hex_str( tracks_i, 4, '0' );
- str += String_convert::hex2bin_str( tracks_str );
+ String tracks_str = String_convert::i2hex_str (tracks_i, 4, '0');
+ str += String_convert::hex2bin_str (tracks_str);
- String tempo_str = String_convert::i2hex_str( clocks_per_4_i, 4, '0' );
- str += String_convert::hex2bin_str( tempo_str );
+ String tempo_str = String_convert::i2hex_str (clocks_per_4_i, 4, '0');
+ str += String_convert::hex2bin_str (tempo_str);
- set( "MThd", str, "" );
+ set ("MThd", str, "");
}
char const* const instrument_name_sz_a_[ ] = {
/* 24 */ "tango accordian",
/* (25-32 guitar) */
- /* 25 */ "acoustic guitar(nylon)",
- /* 26 */ "acoustic guitar(steel)",
- /* 27 */ "electric guitar(jazz)",
- /* 28 */ "electric guitar(clean)",
- /* 29 */ "electric guitar(muted)",
+ /* 25 */ "acoustic guitar (nylon)",
+ /* 26 */ "acoustic guitar (steel)",
+ /* 27 */ "electric guitar (jazz)",
+ /* 28 */ "electric guitar (clean)",
+ /* 29 */ "electric guitar (muted)",
/* 30 */ "overdriven guitar",
/* 31 */ "distortion guitar",
/* 32 */ "guitar harmonics",
/* (33-40 bass) */
/* 33 */ "acoustic bass",
- /* 34 */ "electric bass(finger)",
- /* 35 */ "electric bass(pick)",
+ /* 34 */ "electric bass (finger)",
+ /* 35 */ "electric bass (pick)",
/* 36 */ "fretless bass",
/* 37 */ "slap bass 1",
/* 38 */ "slap bass 2",
0
};
-Midi_instrument::Midi_instrument( int channel_i, String instrument_str )
- : Midi_item( 0 )
+Midi_instrument::Midi_instrument (int channel_i, String instrument_str)
+ : Midi_item (0)
{
instrument_str_ = instrument_str;
instrument_str_.to_lower();
Midi_instrument::str() const
{
Byte program_byte = 0;
- for ( int i = 0; instrument_name_sz_a_[i]; i++ )
- if ( instrument_str_ == String(instrument_name_sz_a_[ i ] )) {
+ for ( int i = 0; instrument_name_sz_a_[i]; i++)
+ if ( instrument_str_ == String (instrument_name_sz_a_[ i ])) {
program_byte = (Byte)i;
break;
}
- if ( !program_byte )
- return String( "" );
+ if ( !program_byte)
+ return String ("");
- String str = String( (char)( 0xc0 + channel_i_ ) );
- str += String( (char)program_byte );
+ String str = String ((char)( 0xc0 + channel_i_) );
+ str += String ((char)program_byte);
return str;
}
-Midi_item::Midi_item( Audio_item* audio_item_l )
+Midi_item::Midi_item (Audio_item* audio_item_l)
{
audio_item_l_ = audio_item_l;
channel_i_ = 0;
}
void
-Midi_item::output( Midi_stream* midi_stream_l ) const
+Midi_item::output (Midi_stream* midi_stream_l) const
{
*midi_stream_l << str();
}
String
-Midi_item::i2varint_str( int i )
+Midi_item::i2varint_str (int i)
{
int buffer_i = i & 0x7f;
- while ( (i >>= 7) > 0 ) {
+ while ( (i >>= 7) > 0) {
buffer_i <<= 8;
buffer_i |= 0x80;
buffer_i += (i & 0x7f);
}
String str;
- while ( 1 ) {
+ while ( 1) {
str += (char)buffer_i;
- if ( buffer_i & 0x80 )
+ if ( buffer_i & 0x80)
buffer_i >>= 8;
else
break;
return str;
}
-Midi_key::Midi_key( Audio_item* audio_item_l )
- : Midi_item( audio_item_l )
+Midi_key::Midi_key (Audio_item* audio_item_l)
+ : Midi_item (audio_item_l)
{
}
String
Midi_key::str() const
{
- Key_change_req* k = audio_item_l_->req_l_->command()->keychange();
+ Key_change_req* k = audio_item_l_->req_l_->command()->keychange ();
int sharps_i = k->sharps_i();
int flats_i = k->flats_i();
// midi cannot handle non-conventional keys
- if ( flats_i && sharps_i )
+ if ( flats_i && sharps_i)
return "";
int accidentals_i = sharps_i - flats_i;
String str = "ff5902";
- str += String_convert::i2hex_str( accidentals_i, 2, '0' );
+ str += String_convert::i2hex_str (accidentals_i, 2, '0');
int minor_i = k->minor_b();
- str += String_convert::i2hex_str( minor_i, 2, '0' );
- return String_convert::hex2bin_str( str );
+ str += String_convert::i2hex_str (minor_i, 2, '0');
+ return String_convert::hex2bin_str (str);
}
-Midi_meter::Midi_meter( Audio_item* audio_item_l )
- : Midi_item( audio_item_l )
+Midi_meter::Midi_meter (Audio_item* audio_item_l)
+ : Midi_item (audio_item_l)
{
clocks_per_1_i_ = 18;
}
String
Midi_meter::str() const
{
- Meter_change_req* m = audio_item_l_->req_l_->command()->meterchange();
+ Meter_change_req* m = audio_item_l_->req_l_->command()->meterchange ();
int num_i = m->beats_i_;
int den_i = m->one_beat_i_;
String str = "ff5804";
- str += String_convert::i2hex_str( num_i, 2, '0' );
- str += String_convert::i2hex_str( intlog2( den_i ) , 2, '0' );
- str += String_convert::i2hex_str( clocks_per_1_i_, 2, '0' );
- str += String_convert::i2hex_str( 8, 2, '0' );
- return String_convert::hex2bin_str( str );
+ str += String_convert::i2hex_str (num_i, 2, '0');
+ str += String_convert::i2hex_str (intlog2( den_i) , 2, '0' );
+ str += String_convert::i2hex_str (clocks_per_1_i_, 2, '0');
+ str += String_convert::i2hex_str (8, 2, '0');
+ return String_convert::hex2bin_str (str);
}
-Midi_note::Midi_note( Audio_item* audio_item_l )
- : Midi_item( audio_item_l )
+Midi_note::Midi_note (Audio_item* audio_item_l)
+ : Midi_item (audio_item_l)
{
dynamic_byte_ = 0x7f;
}
Moment
Midi_note::duration() const
{
- return audio_item_l_->req_l_->musical()->rhythmic()->duration();
+ return audio_item_l_->req_l_->musical()->rhythmic ()->duration ();
}
int
Midi_note::pitch_i() const
{
- return audio_item_l_->req_l_->musical()->melodic()->pitch();
+ return audio_item_l_->req_l_->musical()->melodic ()->pitch ();
}
String
Midi_note::str() const
{
- if ( pitch_i() == INT_MAX )
- return String( "" );
+ if ( pitch_i() == INT_MAX)
+ return String ("");
- Byte status_byte = (char)( 0x90 + channel_i_ );
+ Byte status_byte = (char)( 0x90 + channel_i_);
- String str = String( (char)status_byte );
- str += (char)( pitch_i() + c0_pitch_i_c_ );
+ String str = String ((char)status_byte);
+ str += (char)( pitch_i() + c0_pitch_i_c_);
// poor man's staff dynamics:
- str += (char)( dynamic_byte_ - 0x10 * channel_i_ );
+ str += (char)( dynamic_byte_ - 0x10 * channel_i_);
return str;
}
-Midi_note_off::Midi_note_off( Midi_note* midi_note_l )
- : Midi_item( midi_note_l->audio_item_l_ )
+Midi_note_off::Midi_note_off (Midi_note* midi_note_l)
+ : Midi_item (midi_note_l->audio_item_l_)
{
// 0x64 is supposed to be neutral, but let's try
aftertouch_byte_ = 0x64;
int
Midi_note_off::pitch_i() const
{
- return audio_item_l_->req_l_->musical()->melodic()->pitch();
+ return audio_item_l_->req_l_->musical()->melodic ()->pitch ();
}
String
Midi_note_off::str() const
{
- if ( pitch_i() == INT_MAX )
- return String( "" );
+ if ( pitch_i() == INT_MAX)
+ return String ("");
- Byte status_byte = (char)( 0x80 + channel_i_ );
+ Byte status_byte = (char)( 0x80 + channel_i_);
- String str = String( (char)status_byte );
- str += (char)( pitch_i() + Midi_note::c0_pitch_i_c_ );
+ String str = String ((char)status_byte);
+ str += (char)( pitch_i() + Midi_note::c0_pitch_i_c_);
str += (char)aftertouch_byte_;
return str;
}
-Midi_tempo::Midi_tempo( Audio_item* audio_item_l )
- : Midi_item( audio_item_l )
+Midi_tempo::Midi_tempo (Audio_item* audio_item_l)
+ : Midi_item (audio_item_l)
{
- per_minute_4_i_ = ( (Audio_tempo*)audio_item_l_ )->per_minute_4_i_;
+ per_minute_4_i_ = ( (Audio_tempo*)audio_item_l_)->per_minute_4_i_;
}
-Midi_tempo::Midi_tempo( int per_minute_4_i )
- : Midi_item( 0 )
+Midi_tempo::Midi_tempo (int per_minute_4_i)
+ : Midi_item (0)
{
per_minute_4_i_ = per_minute_4_i;
}
{
int useconds_per_4_i = 60 * (int)1e6 / per_minute_4_i_;
String str = "ff5103";
- str += String_convert::i2hex_str( useconds_per_4_i, 6, '0' );
- return String_convert::hex2bin_str( str );
+ str += String_convert::i2hex_str (useconds_per_4_i, 6, '0');
+ return String_convert::hex2bin_str (str);
}
-Midi_text::Midi_text( Audio_item* audio_item_l )
- : Midi_item( audio_item_l )
+Midi_text::Midi_text (Audio_item* audio_item_l)
+ : Midi_item (audio_item_l)
{
- text_str_ = ( (Audio_text*)audio_item_l_ )->text_str_;
- type_ = (Type)( (Audio_text*)audio_item_l_ )->type_;
+ text_str_ = ( (Audio_text*)audio_item_l_)->text_str_;
+ type_ = (Type)( (Audio_text*)audio_item_l_)->type_;
}
-Midi_text::Midi_text( Midi_text::Type type, String text_str )
- : Midi_item( 0 )
+Midi_text::Midi_text (Midi_text::Type type, String text_str)
+ : Midi_item (0)
{
text_str_ = text_str;
type_ = type;
String
Midi_text::str() const
{
- String str = "ff" + String_convert::i2hex_str( type_, 2, '0' );
- str = String_convert::hex2bin_str( str );
- str += i2varint_str( text_str_.length_i() );
+ String str = "ff" + String_convert::i2hex_str (type_, 2, '0');
+ str = String_convert::hex2bin_str (str);
+ str += i2varint_str (text_str_.length_i());
str += text_str_;
return str;
}
String data_str;
// only for format 0 (currently using format 1)?
- data_str += String_convert::hex2bin_str( data_ch_C );
+ data_str += String_convert::hex2bin_str (data_ch_C);
char const* footer_ch_C = "00" "ff2f" "00";
- String footer_str = String_convert::hex2bin_str( footer_ch_C );
+ String footer_str = String_convert::hex2bin_str (footer_ch_C);
- set( "MTrk", data_str, footer_str );
+ set ("MTrk", data_str, footer_str);
}
void
-Midi_track::add( int delta_time_i, String event_str )
+Midi_track::add (int delta_time_i, String event_str)
{
- if ( delta_time_i < 0 ) {
- cout << String_convert::bin2hex_str( i2varint_str( delta_time_i ) ) << endl;
- cout << String_convert::bin2hex_str( event_str ) << endl;
+ if ( delta_time_i < 0) {
+ cout << String_convert::bin2hex_str (i2varint_str (delta_time_i) ) << endl;
+ cout << String_convert::bin2hex_str (event_str) << endl;
}
- assert(delta_time_i >= 0);
- Midi_chunk::add( i2varint_str( delta_time_i ) + event_str );
+ assert (delta_time_i >= 0);
+ Midi_chunk::add (i2varint_str (delta_time_i) + event_str );
}
void
-Midi_track::add( Moment delta_time_moment, Midi_item* mitem_l )
+Midi_track::add (Moment delta_time_moment, Midi_item* mitem_l)
{
// use convention of 384 clocks per 4
// use Duration_convert
- int delta_time_i = delta_time_moment * Moment( 384 ) / Moment( 1, 4 );
+ int delta_time_i = delta_time_moment * Moment (384) / Moment (1, 4 );
// ? int ( delta_time_moment * 4 * 384)
- add( delta_time_i, mitem_l->str() );
+ add (delta_time_i, mitem_l->str());
}
#include "midi-stream.hh"
#include "debug.hh"
-Midi_stream::Midi_stream( String filename_str )
+Midi_stream::Midi_stream (String filename_str)
{
filename_str_ = filename_str;
os_p_ = 0;
}
Midi_stream&
-Midi_stream::operator <<( String str )
+Midi_stream::operator <<( String str)
{
- if ( check_debug )
- str = String_convert::bin2hex_str( str );
+ if ( check_debug)
+ str = String_convert::bin2hex_str (str);
*os_p_ << str;
- if ( check_debug )
+ if ( check_debug)
*os_p_ << "\n";
return *this;
}
Midi_stream&
-Midi_stream::operator <<( Midi_item const& mitem_c_r )
+Midi_stream::operator <<( Midi_item const& mitem_c_r)
{
// *this << mitem_c_r.str();
- mitem_c_r.output( this );
- if ( check_debug )
+ mitem_c_r.output (this);
+ if ( check_debug)
*os_p_ << "\n";
return *this;
}
Midi_stream&
-Midi_stream::operator <<( int i )
+Midi_stream::operator <<( int i)
{
// output binary string ourselves
- *this << Midi_item::i2varint_str( i );
+ *this << Midi_item::i2varint_str (i);
return *this;
}
void
Midi_stream::open()
{
- os_p_ = new ofstream( filename_str_ );
- if ( !*os_p_ )
- error ("can't open `" + filename_str_ + "\'" );
+ os_p_ = new ofstream (filename_str_);
+ if ( !*os_p_)
+ error ("can't open `" + filename_str_ + "\'");
}
}
int
-compare( Midi_note_event const& left, Midi_note_event const& right )
+compare (Midi_note_event const& left, Midi_note_event const& right)
{
- return sign( left.key - right.key );
+ return sign (left.key - right.key);
}
-Midi_walker::Midi_walker( Audio_staff* audio_staff_l, Midi_track* track_l )
- : PCursor<Audio_item*>( audio_staff_l->audio_item_l_list_ )
+Midi_walker::Midi_walker (Audio_staff* audio_staff_l, Midi_track* track_l)
+ : PCursor<Audio_item*>( audio_staff_l->audio_item_l_list_)
{
track_l_ = track_l;
last_mom_ = 0;
Midi_walker::~Midi_walker()
{
// ugh
- do_stop_notes( last_mom_ + Moment( 10, 1 ) );
+ do_stop_notes (last_mom_ + Moment (10, 1) );
}
/**
Find out if start_note event is needed, and do it if needed.
*/
void
-Midi_walker::do_start_note( Midi_note* note_l )
+Midi_walker::do_start_note (Midi_note* note_l)
{
- Moment stop_mom = note_l->duration() + ptr()->audio_column_l_->at_mom();
- for ( int i=0; i < stop_note_queue.size(); i++ ) {
- if ( stop_note_queue[ i ].val->pitch_i() == note_l->pitch_i() ) {
- if ( stop_note_queue[ i ].key < stop_mom )
+ Moment stop_mom = note_l->duration() + ptr ()->audio_column_l_->at_mom ();
+ for ( int i=0; i < stop_note_queue.size(); i++) {
+ if ( stop_note_queue[ i ].val->pitch_i() == note_l->pitch_i ()) {
+ if ( stop_note_queue[ i ].key < stop_mom)
stop_note_queue[ i ].ignore_b_ = true;
else // skip the stopnote
return;
}
Midi_note_event e;
- e.val = new Midi_note_off( note_l );
+ e.val = new Midi_note_off (note_l);
e.key = stop_mom;
- stop_note_queue.insert( e );
+ stop_note_queue.insert (e);
- output_event( ptr()->audio_column_l_->at_mom(), note_l );
+ output_event (ptr()->audio_column_l_->at_mom (), note_l);
}
/**
Output note events for all notes which end before #max_mom#
*/
void
-Midi_walker::do_stop_notes( Moment max_mom )
+Midi_walker::do_stop_notes (Moment max_mom)
{
- while ( stop_note_queue.size() && stop_note_queue.front().key <= max_mom ) {
+ while ( stop_note_queue.size() && stop_note_queue.front ().key <= max_mom) {
Midi_note_event e = stop_note_queue.get();
- if ( e.ignore_b_ )
+ if ( e.ignore_b_)
continue;
Moment stop_mom = e.key;
Midi_note_off* note_l = e.val;
- output_event( stop_mom, note_l );
+ output_event (stop_mom, note_l);
}
}
Advance the track to #now#, output the item, and adjust current "moment".
*/
void
-Midi_walker::output_event( Moment now_mom, Midi_item* l )
+Midi_walker::output_event (Moment now_mom, Midi_item* l)
{
Moment delta_t = now_mom - last_mom_ ;
last_mom_ += delta_t;
- track_l_->add( delta_t, l );
+ track_l_->add (delta_t, l);
}
void
Midi_walker::process()
{
- do_stop_notes( ptr()->audio_column_l_->at_mom() );
+ do_stop_notes (ptr()->audio_column_l_->at_mom ());
- Midi_item* p = ptr()->midi_item_p();
+ Midi_item* p = ptr()->midi_item_p ();
p->channel_i_ = track_l_->number_i_;
- if ( p->name() != Midi_note::static_name() )
- output_event( ptr()->audio_column_l_->at_mom(), p );
+ if ( p->name() != Midi_note::static_name ())
+ output_event (ptr()->audio_column_l_->at_mom (), p);
else
- do_start_note( (Midi_note*)p );
+ do_start_note ((Midi_note*)p);
delete p;
}
d/= 2;
i++;
}
- assert(!(d/2));
+ assert (!(d/2));
return i;
}
double
log_2(double x) {
- return log(x) /log(2.0);
+ return log (x) /log (2.0);
}
#if 1
Interval
-itemlist_width(const Array<Item*> &its)
+itemlist_width (const Array<Item*> &its)
{
Interval iv ;
iv.set_empty();
Molecule::TeX_string() const
{
String s;
- for(iter_top(ats,c); c.ok(); c++)
+ for (iter_top (ats,c); c.ok(); c++)
s+=c->TeX_string();
return s;
}
Molecule::extent() const
{
Box b;
- for(iter_top(ats,c); c.ok(); c++)
- b.unite(c->extent());
+ for (iter_top (ats,c); c.ok(); c++)
+ b.unite (c->extent());
return b;
}
void
-Molecule::translate(Offset o)
+Molecule::translate (Offset o)
{
- for (iter_top(ats,c); c.ok(); c++)
- c->translate(o);
+ for (iter_top (ats,c); c.ok(); c++)
+ c->translate (o);
}
void
-Molecule::translate(Real x,Axis a)
+Molecule::translate (Real x,Axis a)
{
- for (iter_top(ats,c); c.ok(); c++)
- c->translate(x,a);
+ for (iter_top (ats,c); c.ok(); c++)
+ c->translate (x,a);
}
void
-Molecule::add(Molecule const &m)
+Molecule::add (Molecule const &m)
{
- for (iter_top(m.ats,c); c.ok(); c++) {
- add(**c);
+ for (iter_top (m.ats,c); c.ok(); c++) {
+ add (**c);
}
}
void
-Molecule::add_right(Molecule const &m)
+Molecule::add_right (Molecule const &m)
{
if (!ats.size()) {
- add(m);
+ add (m);
return;
}
- Real xof=extent().x().right - m.extent().x().left;
+ Real xof=extent().x ().right - m.extent ().x ().left;
- Molecule toadd(m);
- toadd.translate(Offset(xof, 0.0));
- add(toadd);
+ Molecule toadd (m);
+ toadd.translate (Offset (xof, 0.0));
+ add (toadd);
}
void
-Molecule::add_left(Molecule const &m)
+Molecule::add_left (Molecule const &m)
{
if (!ats.size()) {
- add(m);
+ add (m);
return;
}
- Real xof=extent().x().left - m.extent().x().right;
+ Real xof=extent().x ().left - m.extent ().x ().right;
- Molecule toadd(m);
- toadd.translate(Offset(xof, 0.0));
- add(toadd);
+ Molecule toadd (m);
+ toadd.translate (Offset (xof, 0.0));
+ add (toadd);
}
void
-Molecule::add_top(Molecule const &m)
+Molecule::add_top (Molecule const &m)
{
if (!ats.size()) {
- add(m);
+ add (m);
return;
}
- Real yof=extent().y().right - m.extent().y().left;
+ Real yof=extent().y ().right - m.extent ().y ().left;
- Molecule toadd(m);
- toadd.translate(yof, Y_AXIS);
- add(toadd);
+ Molecule toadd (m);
+ toadd.translate (yof, Y_AXIS);
+ add (toadd);
}
void
-Molecule::add_bottom(Molecule const &m)
+Molecule::add_bottom (Molecule const &m)
{
if (!ats.size()) {
- add(m);
+ add (m);
return;
}
- Real yof=extent().y().left- m.extent().y().right;
- Molecule toadd(m);
- toadd.translate(yof, Y_AXIS);
- add(toadd);
+ Real yof=extent().y ().left- m.extent ().y ().right;
+ Molecule toadd (m);
+ toadd.translate (yof, Y_AXIS);
+ add (toadd);
}
void
Molecule::operator = (Molecule const &)
{
- assert(false);
+ assert (false);
}
-Molecule::Molecule(Molecule const &s)
+Molecule::Molecule (Molecule const &s)
{
- add(s);
+ add (s);
}
void
#ifndef NPRINT
if (! check_debug)
return;
- for (iter_top(ats,c); c.ok(); c++)
+ for (iter_top (ats,c); c.ok(); c++)
c->print();
#endif
}
void
-Molecule::add(Atom const &a)
+Molecule::add (Atom const &a)
{
- ats.bottom().add(new Atom(a));
+ ats.bottom().add (new Atom (a));
}
#ifndef NPRINT
if ( !check_debug)
return ;
- mtor << name() << "{";
- mtor << "report to " <<
- report_to_l() << " (" << report_to_l()->name() << ")\n";
- mtor << "next at " << next_moment() << " ";
+ DOUT << name() << "{";
+ DOUT << "report to " <<
+ report_to_l() << " (" << report_to_l ()->name () << ")\n";
+ DOUT << "next at " << next_moment() << " ";
do_print();
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
Translator *
Music_iterator::get_req_translator_l()
{
- assert(report_to_l());
- if (report_to_l()->is_bottom_engraver_b() )
+ assert (report_to_l());
+ if (report_to_l()->is_bottom_engraver_b ())
return report_to_l();
- set_translator( report_to_l()->get_default_interpreter() );
+ set_translator (report_to_l()->get_default_interpreter ());
return report_to_l();
}
void
-Music_iterator::push_translator(Translator*t)
+Music_iterator::push_translator (Translator*t)
{
- report_to_l_arr_.push(t);
+ report_to_l_arr_.push (t);
t->iterator_count_ ++;
}
Translator*
Music_iterator::report_to_l()const
{
- if (! report_to_l_arr_.size() )
+ if (! report_to_l_arr_.size())
return 0;
return report_to_l_arr_.top();
}
void
-Music_iterator::set_translator(Translator*trans)
+Music_iterator::set_translator (Translator*trans)
{
if (report_to_l()==trans)
return;
- if ( report_to_l() )
+ if ( report_to_l())
pop_translator();
if (trans)
- push_translator(trans);
+ push_translator (trans);
}
void
Music_iterator::~Music_iterator()
{
- set_translator(0);
+ set_translator (0);
}
Moment
}
void
-Music_iterator::process_and_next(Moment)
+Music_iterator::process_and_next (Moment)
{
first_b_ = false;
}
}
Music_iterator*
-Music_iterator::static_get_iterator_p(Music *m,
+Music_iterator::static_get_iterator_p (Music *m,
Translator *report_l)
{
Music_iterator * p =0;
- if (m->is_type_b( Request_chord::static_name()))
- p = new Request_chord_iterator( (Request_chord*) m);
- else if (m->is_type_b( Chord::static_name()))
- p = new Chord_iterator( (Chord*) m);
- else if (m->is_type_b( Voice::static_name()))
- p = new Voice_iterator( (Voice*) m);
+ if (m->is_type_b (Request_chord::static_name()))
+ p = new Request_chord_iterator ((Request_chord*) m);
+ else if (m->is_type_b (Chord::static_name()))
+ p = new Chord_iterator ((Chord*) m);
+ else if (m->is_type_b (Voice::static_name()))
+ p = new Voice_iterator ((Voice*) m);
if (m -> type_str_ != "") {
Translator * a =report_l->
- find_get_translator_l(m-> type_str_, m->id_str_);
- p->set_translator( a);
+ find_get_translator_l (m-> type_str_, m->id_str_);
+ p->set_translator (a);
}
- if (! p->report_to_l() )
- p ->set_translator(report_l);
+ if (! p->report_to_l())
+ p ->set_translator (report_l);
return p;
}
Music_iterator*
-Music_iterator::get_iterator_p(Music*m)const
+Music_iterator::get_iterator_p (Music*m)const
{
- Music_iterator*p = static_get_iterator_p(m,report_to_l());
+ Music_iterator*p = static_get_iterator_p (m,report_to_l());
p->daddy_iter_l_ = (Music_iterator*)this;
p->construct_children();
return p;
/* ************** */
-Chord_iterator::Chord_iterator(Chord const *chord_C)
+Chord_iterator::Chord_iterator (Chord const *chord_C)
{
chord_C_ = chord_C;
}
Chord_iterator::construct_children()
{
int j = 0;
- for(PCursor<Music*> i(chord_C_->music_p_list_.top()); //, int j = 0;
+ for (PCursor<Music*> i (chord_C_->music_p_list_.top()); //, int j = 0;
i.ok(); j++, i++) {
- Music_iterator * mi = get_iterator_p( i.ptr());
- if ( mi->ok() ) {
- set_translator(mi->report_to_l()->ancestor_l(
- chord_C_->multi_level_i_ ) );
- children_p_list_.bottom().add( mi );
+ Music_iterator * mi = get_iterator_p (i.ptr());
+ if ( mi->ok()) {
+ set_translator (mi->report_to_l()->ancestor_l (
+ chord_C_->multi_level_i_) );
+ children_p_list_.bottom().add (mi);
} else
delete mi;
}
Chord_iterator::do_print() const
{
#ifndef NPRINT
- for (PCursor<Music_iterator*> i(children_p_list_.top()); i.ok(); i++) {
+ for (PCursor<Music_iterator*> i (children_p_list_.top()); i.ok (); i++) {
i->print();
}
#endif
}
void
-Chord_iterator::process_and_next(Moment until)
+Chord_iterator::process_and_next (Moment until)
{
- for (PCursor<Music_iterator*> i(children_p_list_.top()); i.ok(); ) {
+ for (PCursor<Music_iterator*> i (children_p_list_.top()); i.ok ();) {
if (i->next_moment() == until) {
- i->process_and_next(until);
+ i->process_and_next (until);
}
if (!i->ok())
delete i.remove_p();
else
i++;
}
- Music_iterator::process_and_next(until);
+ Music_iterator::process_and_next (until);
}
Chord_iterator::next_moment()const
{
Moment next_ = infinity_mom;
- for (PCursor<Music_iterator*> i(children_p_list_.top()); i.ok(); i++)
+ for (PCursor<Music_iterator*> i (children_p_list_.top()); i.ok (); i++)
next_ = next_ <? i->next_moment() ;
return next_;
}
iter_p_->print();
}
-Voice_iterator::Voice_iterator(Voice const*v)
+Voice_iterator::Voice_iterator (Voice const*v)
: PCursor<Music*> ( v->music_p_list_)
{
here_mom_ = v->offset_mom_;
{
delete iter_p_;
iter_p_ =0;
- MInterval elt_time = ptr()->time_int();
+ MInterval elt_time = ptr()->time_int ();
if (!elt_time.empty_b())
here_mom_ += elt_time.length();
PCursor<Music*>::next();
void
Voice_iterator::start_next_element()
{
- assert( !iter_p_);
- iter_p_ = get_iterator_p( ptr());
+ assert (!iter_p_);
+ iter_p_ = get_iterator_p (ptr());
}
void
Voice_iterator::set_voice_translator()
{
- if (iter_p_->report_to_l()->depth_i() > report_to_l()->depth_i())
- set_translator(iter_p_->report_to_l());
+ if (iter_p_->report_to_l()->depth_i () > report_to_l ()->depth_i ())
+ set_translator (iter_p_->report_to_l());
}
Voice_iterator::~Voice_iterator()
{
- assert(! iter_p_);
+ assert (! iter_p_);
}
IMPLEMENT_IS_TYPE_B1(Voice_iterator,Music_iterator);
void
-Voice_iterator::process_and_next(Moment until)
+Voice_iterator::process_and_next (Moment until)
{
while (1) {
Moment local_until = until - here_mom_;
- while ( iter_p_->ok() ) {
+ while ( iter_p_->ok()) {
Moment here = iter_p_->next_moment();
if (here != local_until)
goto loopexit;
- iter_p_->process_and_next(local_until);
+ iter_p_->process_and_next (local_until);
}
- if (!iter_p_->ok() ) {
+ if (!iter_p_->ok()) {
leave_element();
- if ( PCursor<Music*>::ok() ) {
+ if ( PCursor<Music*>::ok()) {
start_next_element();
set_voice_translator();
} else {
loopexit:
- Music_iterator::process_and_next(until);
+ Music_iterator::process_and_next (until);
}
Moment
get_req_translator_l();
}
-Request_chord_iterator::Request_chord_iterator(Request_chord*el_l)
+Request_chord_iterator::Request_chord_iterator (Request_chord*el_l)
{
elt_l_ = el_l;
- elt_duration_ = el_l->time_int().length();
+ elt_duration_ = el_l->time_int().length ();
last_b_ = false;
}
Moment
Request_chord_iterator::next_moment()const
{
- Moment m(0);
+ Moment m (0);
if (!first_b_)
m = elt_duration_;
return m;
Request_chord_iterator::do_print() const
{
#ifndef NPRINT
- mtor << "duration: " << elt_duration_;
+ DOUT << "duration: " << elt_duration_;
#endif
}
void
-Request_chord_iterator::process_and_next(Moment mom)
+Request_chord_iterator::process_and_next (Moment mom)
{
- if ( first_b_ ) {
- for (PCursor<Music*> i(elt_l_->music_p_list_); i.ok(); i++) {
- assert(i->is_type_b(Request::static_name()));
+ if ( first_b_) {
+ for (PCursor<Music*> i (elt_l_->music_p_list_); 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);
+ bool gotcha = report_to_l()->try_request (req_l);
if (!gotcha)
- req_l->warning("Junking request: " + String(req_l->name()));
+ req_l->warning ("Junking request: " + String (req_l->name()));
}
first_b_ = false;
}
- if ( mom >= elt_duration_ )
+ if ( mom >= elt_duration_)
last_b_ = true;
}
#include "debug.hh"
#include "music-list.hh"
-Music_list::Music_list(Music_list const&s)
- : Music(s)
+Music_list::Music_list (Music_list const&s)
+ : Music (s)
{
multi_level_i_ = s.multi_level_i_;
- for (iter(s.music_p_list_.top(), i); i.ok(); i++)
- add(i->clone());
+ for (iter (s.music_p_list_.top(), i); i.ok (); i++)
+ add (i->clone());
}
IMPLEMENT_IS_TYPE_B1(Music_list, Music);
Chord::time_int()const
{
MInterval m;
- for (iter(music_p_list_.top(), i); i.ok(); i++)
- m.unite(i->time_int());
+ for (iter (music_p_list_.top(), i); i.ok (); i++)
+ m.unite (i->time_int());
return m;
}
void
-Chord::translate(Moment m)
+Chord::translate (Moment m)
{
- for (iter(music_p_list_.top(), i); i.ok(); i++)
- i->translate(m);
+ for (iter (music_p_list_.top(), i); i.ok (); i++)
+ i->translate (m);
}
Chord::Chord()
Voice::time_int() const
{
Moment last=0;
- for (iter(music_p_list_.top(), i); i.ok(); i++) {
+ for (iter (music_p_list_.top(), i); i.ok (); i++) {
MInterval interval = i->time_int();
/*
c4 <> c4
*/
- if ( !interval.empty_b() )
+ if ( !interval.empty_b())
last += interval.length();
}
- return offset_mom_ + MInterval(0,last);
+ return offset_mom_ + MInterval (0,last);
}
void
-Voice::translate(Moment dt)
+Voice::translate (Moment dt)
{
offset_mom_ += dt;
}
}
void
-Music_list::add(Music*m_p)
+Music_list::add (Music*m_p)
{
if (!m_p)
return;
m_p->parent_music_l_ = this;
- music_p_list_.bottom().add(m_p);
+ music_p_list_.bottom().add (m_p);
}
void
-Music_list::transpose(Melodic_req const*rq)
+Music_list::transpose (Melodic_req const*rq)
{
- for (iter(music_p_list_.top(),i); i.ok(); i++)
- i->transpose(rq);
+ for (iter (music_p_list_.top(),i); i.ok (); i++)
+ i->transpose (rq);
}
void
Music_list::do_print()const
{
#ifndef NPRINT
- for (iter(music_p_list_.top(),i); i.ok(); i++)
+ for (iter (music_p_list_.top(),i); i.ok (); i++)
i->print();
#endif
}
MInterval
Music::time_int() const
{
- return MInterval(0,0);
+ return MInterval (0,0);
}
void
#ifndef NPRINT
if ( ! check_debug)
return ;
- mtor << name() << "{";
+ DOUT << name() << "{";
if (type_str_!="" || id_str_!="")
- mtor << "`" <<type_str_ << " = " << id_str_<<"\'";
+ DOUT << "`" <<type_str_ << " = " << id_str_<<"\'";
do_print();
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
void
-Music::transpose(Melodic_req const*)
+Music::transpose (Melodic_req const*)
{
}
void
-Music::translate(Moment )
+Music::translate (Moment)
{
}
{
#ifndef NPRINT
Rhythmic_req::do_print();
- mtor << "dir : " << dir_i_;
+ DOUT << "dir : " << dir_i_;
#endif
}
Span_req::do_print() const
{
#ifndef NPRINT
- mtor << spantype ;
+ DOUT << spantype ;
#endif
}
Spacing_req::do_print()const
{
#ifndef NPRINT
- mtor << "next " << next << "dist " << distance << "strength\n";
+ DOUT << "next " << next << "dist " << distance << "strength\n";
#endif
}
}
void
-Melodic_req::transpose(Melodic_req const & delta)
+Melodic_req::transpose (Melodic_req const & delta)
{
int old_pitch = pitch();
int delta_pitch = delta.pitch();
octave_i_ += delta.octave_i_;
notename_i_ += delta.notename_i_;
- while (notename_i_ >= 7 ) {
+ while (notename_i_ >= 7) {
notename_i_ -= 7;
octave_i_ ++;
}
int delta_acc = new_pitch - old_pitch - delta_pitch;
accidental_i_ -= delta_acc;
- if (abs(accidental_i_) > 2) {
- delta.warning("transposition makes accidental larger than 2");
+ if (abs (accidental_i_) > 2) {
+ delta.warning ("transposition makes accidental larger than 2");
}
}
IMPLEMENT_IS_TYPE_B1(Melodic_req,Musical_req);
bool
-Melodic_req::do_equal_b(Request*r)const
+Melodic_req::do_equal_b (Request*r)const
{
- Melodic_req* m= r->musical()->melodic();
- return !compare( *m, *this);
+ Melodic_req* m= r->musical()->melodic ();
+ return !compare (*m, *this);
}
int
-Melodic_req::compare(Melodic_req const &m1 , Melodic_req const&m2)
+Melodic_req::compare (Melodic_req const &m1 , Melodic_req const&m2)
{
int o= m1.octave_i_ - m2.octave_i_;
int n = m1.notename_i_ - m2.notename_i_;
Melodic_req::do_print() const
{
#ifndef NPRINT
- mtor << "notename: " << notename_i_
+ DOUT << "notename: " << notename_i_
<< " acc: " <<accidental_i_<<" oct: "<< octave_i_;
#endif
}
/* *************** */
int
-Rhythmic_req::compare(Rhythmic_req const &r1, Rhythmic_req const &r2)
+Rhythmic_req::compare (Rhythmic_req const &r1, Rhythmic_req const &r2)
{
- return (r1.duration() - r2.duration());
+ return (r1.duration() - r2.duration ());
}
bool
-Rhythmic_req::do_equal_b(Request*r)const
+Rhythmic_req::do_equal_b (Request*r)const
{
- Rhythmic_req* rh = r->musical()->rhythmic();
+ Rhythmic_req* rh = r->musical()->rhythmic ();
- return !compare(*this, *rh);
+ return !compare (*this, *rh);
}
void
-Rhythmic_req::set_duration(Duration d)
+Rhythmic_req::set_duration (Duration d)
{
duration_ = d;
}
Rhythmic_req::do_print() const
{
#ifndef NPRINT
- mtor << "duration { " <<duration_.str() << "}";
+ DOUT << "duration { " <<duration_.str() << "}";
#endif
}
}
/* *************** */
-Lyric_req::Lyric_req(Text_def* def_p)
- :Text_req(0, def_p)
+Lyric_req::Lyric_req (Text_def* def_p)
+ :Text_req (0, def_p)
{
def_p->align_i_ = 0; // centre
dir_i_ = -1; // lyrics below (invisible) staff
/* *************** */
bool
-Note_req::do_equal_b(Request*r)const
+Note_req::do_equal_b (Request*r)const
{
- return Rhythmic_req::do_equal_b(r) && Melodic_req::do_equal_b(r);
+ return Rhythmic_req::do_equal_b (r) && Melodic_req::do_equal_b (r);
}
#ifndef NPRINT
Melodic_req::do_print();
if (forceacc_b_) {
- mtor << " force accidental\n";
+ DOUT << " force accidental\n";
}
Rhythmic_req::do_print();
#endif
bool
-Span_req:: do_equal_b(Request*r)const
+Span_req:: do_equal_b (Request*r)const
{
Span_req * s = r->span();
return spantype - s->spantype;
}
/* *************** */
-Script_req::Script_req(Script_req const&s)
+Script_req::Script_req (Script_req const&s)
{
dir_i_ = s.dir_i_;
scriptdef_p_ = s.scriptdef_p_ ? s.scriptdef_p_->clone() : 0;
/*
don't check dirs?
- (d1.dir_i_ == d2.dir_i_ )
+ (d1.dir_i_ == d2.dir_i_)
*/
bool
-Script_req::do_equal_b(Request*r)const
+Script_req::do_equal_b (Request*r)const
{
Script_req * s = r->script();
- return scriptdef_p_->equal_b(*s->scriptdef_p_);
+ return scriptdef_p_->equal_b (*s->scriptdef_p_);
}
Script_req::Script_req()
Script_req::do_print() const
{
#ifndef NPRINT
- mtor << " dir " << dir_i_ ;
+ DOUT << " dir " << dir_i_ ;
scriptdef_p_->print();
#endif
}
tdef_p_ = 0;
}
-Text_req::Text_req(Text_req const& src)
+Text_req::Text_req (Text_req const& src)
{
- tdef_p_ = new Text_def(*src.tdef_p_);
+ tdef_p_ = new Text_def (*src.tdef_p_);
dir_i_ = src.dir_i_;
}
-Text_req::Text_req(int dir_i, Text_def* tdef_p)
+Text_req::Text_req (int dir_i, Text_def* tdef_p)
{
dir_i_ = dir_i;
tdef_p_ = tdef_p;
Text_req::do_print() const
{
#ifndef NPRINT
- mtor << " dir " << dir_i_ ;
+ DOUT << " dir " << dir_i_ ;
tdef_p_->print();
#endif
}
{
#ifndef NPRINT
- mtor << "duration: " << duration();
+ DOUT << "duration: " << duration();
#endif
}
{
#ifndef NPRINT
Dynamic_req::do_print();
- mtor << " loudness " <<loudness_str(loudness_);
+ DOUT << " loudness " <<loudness_str (loudness_);
#endif
}
String
-Dynamic_req::loudness_str(Loudness l)
+Dynamic_req::loudness_str (Loudness l)
{
switch (l) {
case FFF: return "fff";
case PP: return "pp";
case PPP: return "ppp";
}
- assert(false);
+ assert (false);
return "";
}
{
#ifndef NPRINT
Span_req::do_print();
- mtor << "louder/louder: " <<dynamic_dir_i_;
+ DOUT << "louder/louder: " <<dynamic_dir_i_;
#endif
}
lexer_p_->clear_notenames();
}
void
-My_lily_parser::set_version_check(bool ig)
+My_lily_parser::set_version_check (bool ig)
{
ignore_version_b_ = ig;
}
String s = "";
if (init_parse_b_)
s = "Init";
- set_yydebug( !monitor->silence(s+"Parser") && check_debug);
- lexer_p_->set_debug( !monitor->silence(s+"Lexer") && check_debug);
+ set_yydebug (!monitor->silence (s+"Parser") && check_debug);
+ lexer_p_->set_debug (!monitor->silence (s+"Lexer") && check_debug);
#endif
}
if (init_parse_b_)
s = "Init";
- if (!monitor->silence(s+"Declarations") && check_debug) {
- lexer_p_->print_declarations(init_parse_b_);
+ if (!monitor->silence (s+"Declarations") && check_debug) {
+ lexer_p_->print_declarations (init_parse_b_);
}
#endif
}
void
-My_lily_parser::parse_file(String init, String s)
+My_lily_parser::parse_file (String init, String s)
{
lexer_p_ = new My_lily_lexer;
init_str_ = init;
*mlog << "Parsing ... ";
init_parse_b_ = true;
- lexer_p_->new_input( init, source_l_);
+ lexer_p_->new_input (init, source_l_);
do_yyparse();
print_declarations();
init_parse_b_ = false;
- lexer_p_->new_input( s , source_l_);
+ lexer_p_->new_input (s , source_l_);
do_yyparse();
print_declarations();
- if(!define_spot_array_.empty())
- warning("Braces don't match.");
+ if (!define_spot_array_.empty())
+ warning ("Braces don't match.");
}
My_lily_parser::~My_lily_parser()
void
My_lily_parser::remember_spot()
{
- define_spot_array_.push(here_input());
+ define_spot_array_.push (here_input());
}
char const *
}
void
-My_lily_parser::parser_error(String s)
+My_lily_parser::parser_error (String s)
{
- here_input().error(s);
- if ( fatal_error_i_ )
- exit( fatal_error_i_ );
+ here_input().error (s);
+ if ( fatal_error_i_)
+ exit (fatal_error_i_);
error_level_i_ = 1;
}
void
-My_lily_parser::set_duration_mode(String s)
+My_lily_parser::set_duration_mode (String s)
{
s = s.upper_str();
last_duration_mode_b_ = (s== "LAST");
}
void
-My_lily_parser::set_default_duration(Duration const *d)
+My_lily_parser::set_default_duration (Duration const *d)
{
last_duration_mode_b_ = false;
default_duration_ = *d;
void
-My_lily_parser::set_last_duration(Duration const *d)
+My_lily_parser::set_last_duration (Duration const *d)
{
if (last_duration_mode_b_)
default_duration_ = *d;
Chord*
-My_lily_parser::get_word_element(Text_def* tdef_p, Duration * duration_p)
+My_lily_parser::get_word_element (Text_def* tdef_p, Duration * duration_p)
{
Chord* velt_p = new Request_chord;
- Lyric_req* lreq_p = new Lyric_req(tdef_p);
+ Lyric_req* lreq_p = new Lyric_req (tdef_p);
lreq_p->duration_ = *duration_p;
- lreq_p->set_spot( here_input());
+ lreq_p->set_spot (here_input());
- velt_p->add(lreq_p);
+ velt_p->add (lreq_p);
delete duration_p;
return velt_p;
}
Chord *
-My_lily_parser::get_rest_element(String s, Duration * duration_p )
+My_lily_parser::get_rest_element (String s, Duration * duration_p)
{
Chord* velt_p = new Request_chord;
- velt_p->set_spot( here_input());
+ velt_p->set_spot (here_input());
if (s=="s") { /* Space */
Skip_req * skip_p = new Skip_req;
skip_p->duration_ = *duration_p;
- skip_p->set_spot( here_input());
- velt_p->add(skip_p);
+ skip_p->set_spot (here_input());
+ velt_p->add (skip_p);
}
else {
Rest_req * rest_req_p = new Rest_req;
rest_req_p->duration_ = *duration_p;
- rest_req_p->set_spot( here_input());
+ rest_req_p->set_spot (here_input());
- velt_p->add(rest_req_p);
+ velt_p->add (rest_req_p);
}
Stem_req * stem_p = new Stem_req;
stem_p->duration_ = *duration_p;
- stem_p->set_spot ( here_input ());
- velt_p->add(stem_p);
+ stem_p->set_spot ( here_input());
+ velt_p->add (stem_p);
delete duration_p;
return velt_p;
}
Chord *
-My_lily_parser::get_note_element(Note_req *rq, Duration * duration_p )
+My_lily_parser::get_note_element (Note_req *rq, Duration * duration_p)
{
Chord*v = new Request_chord;
- v->set_spot( here_input());
+ v->set_spot (here_input());
- v->add(rq);
+ v->add (rq);
if (duration_p->type_i_ >= 2) {
Stem_req * stem_req_p = new Stem_req();
stem_req_p->duration_ = *duration_p;
- stem_req_p->set_spot( here_input());
- v->add(stem_req_p);
+ stem_req_p->set_spot (here_input());
+ v->add (stem_req_p);
}
- rq->set_duration(*duration_p);
- rq->set_spot( here_input());
+ rq->set_duration (*duration_p);
+ rq->set_spot (here_input());
delete duration_p ;
return v;
}
Request*
-My_lily_parser::get_parens_request(char c)
+My_lily_parser::get_parens_request (char c)
{
Request* req_p=0;
switch (c) {
req_p = new Slur_req;
break;
default:
- assert(false);
+ assert (false);
break;
}
break;
}
- if (req_p->musical()->span_dynamic()) {
- Span_dynamic_req* s_l= (req_p->musical()->span_dynamic()) ;
+ if (req_p->musical()->span_dynamic ()) {
+ Span_dynamic_req* s_l= (req_p->musical()->span_dynamic ()) ;
s_l->dynamic_dir_i_ = (c == '<') ? 1:-1;
}
- req_p->set_spot( here_input());
+ req_p->set_spot (here_input());
return req_p;
}
-My_lily_parser::My_lily_parser(Sources * source_l)
+My_lily_parser::My_lily_parser (Sources * source_l)
{
first_b_ = true;
source_l_ = source_l;
}
void
-My_lily_parser::add_requests(Chord*v)
+My_lily_parser::add_requests (Chord*v)
{
for (int i = 0; i < pre_reqs.size(); i++) {
- v->add(pre_reqs[i]);
+ v->add (pre_reqs[i]);
}
pre_reqs.clear();
for (int i = 0; i <post_reqs.size(); i++) {
- v->add(post_reqs[i]);
+ v->add (post_reqs[i]);
}
post_reqs.clear();
}
My_lily_parser::here_input()const
{
Source_file * f_l= lexer_p_->source_file_l();
- return Input(f_l, here_ch_C());
+ return Input (f_l, here_ch_C());
}
void
-My_lily_parser::add_notename(String s, Melodic_req * m_p)
+My_lily_parser::add_notename (String s, Melodic_req * m_p)
{
- lexer_p_->add_notename(s, m_p);
+ lexer_p_->add_notename (s, m_p);
}
#include "rest-column.hh"
bool
-Note_column_engraver::acceptable_elem_b(Score_elem const*elem_C)const
+Note_column_engraver::acceptable_elem_b (Score_elem const*elem_C)const
{
char const*nC = elem_C->name();
- return (nC == Script::static_name() || nC == Note_head::static_name()
+ return (nC == Script::static_name() || nC == Note_head::static_name ()
|| nC == Stem::static_name());
}
Note_column*
{
if (!ncol_p_){
ncol_p_ = new Note_column;
- announce_element(Score_elem_info(ncol_p_, 0));
+ announce_element (Score_elem_info (ncol_p_, 0));
}
return ncol_p_;
}
{
if (!restcol_p_) {
restcol_p_ = new Rest_column;
- announce_element(Score_elem_info(restcol_p_,0));
+ announce_element (Score_elem_info (restcol_p_,0));
}
return restcol_p_;
}
void
-Note_column_engraver::acknowledge_element(Score_elem_info i)
+Note_column_engraver::acknowledge_element (Score_elem_info i)
{
- if (!acceptable_elem_b(i.elem_l_))
+ if (!acceptable_elem_b (i.elem_l_))
return;
char const*nC = i.elem_l_->name();
- if (nC == Script::static_name() && i.req_l_ && i.req_l_->musical()) {
- script_l_arr_.push((Script*)i.elem_l_->item());
+ if (nC == Script::static_name() && i.req_l_ && i.req_l_->musical ()) {
+ script_l_arr_.push ((Script*)i.elem_l_->item());
} else if (nC == Note_head::static_name()) {
Note_head * h_l = (Note_head*)i.elem_l_->item();
if (h_l->rest_b_)
- rest_col_l()->add(h_l);
+ rest_col_l()->add (h_l);
else
- note_col_l()->add(h_l);
+ note_col_l()->add (h_l);
} else if (nC == Stem::static_name()){
stem_l_ = (Stem*)i.elem_l_->item();
}
- if ( ncol_p_ || restcol_p_ ) {
- if ( stem_l_ ) {
+ if ( ncol_p_ || restcol_p_) {
+ if ( stem_l_) {
if (restcol_p_&& !restcol_p_->stem_l_)
- restcol_p_->set (stem_l_ );
+ restcol_p_->set (stem_l_);
if (ncol_p_ && !ncol_p_->stem_l_)
- ncol_p_->set(stem_l_);
+ ncol_p_->set (stem_l_);
}
for (int i=0; i < script_l_arr_.size(); i++) {
if (restcol_p_)
- restcol_p_->add(script_l_arr_[i]);
- if ( ncol_p_ )
- ncol_p_->add(script_l_arr_[i]);
+ restcol_p_->add (script_l_arr_[i]);
+ if ( ncol_p_)
+ ncol_p_->add (script_l_arr_[i]);
}
script_l_arr_.clear();
if (ncol_p_) {
if (! ncol_p_->h_shift_b_)
ncol_p_->h_shift_b_ = h_shift_b_;
- if (! ncol_p_->dir_i_ )
+ if (! ncol_p_->dir_i_)
ncol_p_->dir_i_ = dir_i_;
- typeset_element(ncol_p_);
+ typeset_element (ncol_p_);
ncol_p_ =0;
}
if (restcol_p_) {
- if (! restcol_p_->dir_i_ )
+ if (! restcol_p_->dir_i_)
restcol_p_->dir_i_ = dir_i_;
- typeset_element(restcol_p_);
+ typeset_element (restcol_p_);
restcol_p_ =0;
}
}
}
void
-Note_column_engraver::set_feature(Feature i)
+Note_column_engraver::set_feature (Feature i)
{
if (i.type_ == "vdir")
dir_i_ = i.value_;
IMPLEMENT_IS_TYPE_B1(Note_column,Head_column);
void
-Note_column::set(Stem*s)
+Note_column::set (Stem*s)
{
stem_l_ = s;
- add_support(s);
+ add_support (s);
}
Note_column::Note_column()
void
Note_column::sort()
{
- head_l_arr_.sort( Note_head::compare);
+ head_l_arr_.sort (Note_head::compare);
}
Interval_t<int>
Note_column::do_pre_processing()
{
if (!dir_i_&& !stem_l_){
- dir_i_ = (head_positions_interval().center() >= 5) ? -1 : 1;
+ dir_i_ = (head_positions_interval().center () >= 5) ? -1 : 1;
}
Head_column::do_pre_processing();
}
Note_performer::do_print() const
{
#ifndef NPRINT
- if ( note_req_l_ ) {
+ if ( note_req_l_) {
note_req_l_->print();
}
#endif
Note_performer::process_requests()
{
// this is _really_ braindead, but it generates some output
- if ( !note_req_l_ || !note_req_l_->melodic() || !note_req_l_->rhythmic() )
+ if ( !note_req_l_ || !note_req_l_->melodic() || !note_req_l_->rhythmic ())
return;
- play( new Audio_note( note_req_l_ ) );
+ play (new Audio_note (note_req_l_) );
note_req_l_ = 0;
}
bool
-Note_performer::do_try_request( Request* req_l )
+Note_performer::do_try_request (Request* req_l)
{
- if ( note_req_l_ )
+ if ( note_req_l_)
return false;
- if ( !req_l->musical() || !req_l->musical()->note() )
+ if ( !req_l->musical() || !req_l->musical ()->note ())
return false;
- note_req_l_ = req_l->musical()->melodic();
+ note_req_l_ = req_l->musical()->melodic ();
return true;
}
String *
-get_scriptdef(char c)
+get_scriptdef (char c)
{
String s;
switch (c) {
case '.' : s = "staccato";
break;
default:
- assert(false);
+ assert (false);
}
- return new String(s);
+ return new String (s);
}
Request*
-get_script_req(int d , General_script_def*def)
+get_script_req (int d , General_script_def*def)
{
Musical_script_req* script_req_p = new Musical_script_req;
script_req_p->dir_i_ =d;
Request*
-get_stemdir_req(int d)
+get_stemdir_req (int d)
{
- d = sign(long(d));
+ d = sign (long (d));
Group_feature_req * gfreq_p = new Group_feature_req;
gfreq_p->type_str_ = "vdir";
- gfreq_p->value_str_ = String(d);
+ gfreq_p->value_str_ = String (d);
return gfreq_p;
}
Request*
-get_hshift_req(int i)
+get_hshift_req (int i)
{
Group_feature_req * gfreq_p = new Group_feature_req;
gfreq_p->type_str_ = "hshift";
- gfreq_p->value_str_ = String(i);
+ gfreq_p->value_str_ = String (i);
return gfreq_p;
}
Request*
-get_grouping_req(Array<int> i_arr)
+get_grouping_req (Array<int> i_arr)
{
Measure_grouping_req * mr_p = new Measure_grouping_req;
- for (int i=0; i <i_arr.size(); ) {
- mr_p->elt_length_arr_.push(Moment(1, i_arr[i++]));
- mr_p->beat_i_arr_.push(i_arr[i++]);
+ for (int i=0; i <i_arr.size();) {
+ mr_p->elt_length_arr_.push (Moment (1, i_arr[i++]));
+ mr_p->beat_i_arr_.push (i_arr[i++]);
}
return mr_p;
}
*/
-Note_head::Note_head(int ss)
+Note_head::Note_head (int ss)
{
x_dir_i_ = 0;
staff_size_i_=ss;
}
void
-Note_head::set_rhythmic(Rhythmic_req*r_req_l)
+Note_head::set_rhythmic (Rhythmic_req*r_req_l)
{
balltype_i_ = r_req_l->duration_.type_i_;
dots_i_ = r_req_l->duration_.dots_i_;
{
#ifndef NPRINT
if (rest_b_)
- mtor << "REST! ";
- mtor << "balltype_i_ "<< balltype_i_ << ", position_i_ = "<< position_i_
+ DOUT << "REST! ";
+ DOUT << "balltype_i_ "<< balltype_i_ << ", position_i_ = "<< position_i_
<< "dots_i_ " << dots_i_;
#endif
}
int
-Note_head::compare(Note_head *const &a, Note_head * const &b)
+Note_head::compare (Note_head *const &a, Note_head * const &b)
{
return a->position_i_ - b->position_i_;
}
bool streepjes_b = (position_i_<-1) || (position_i_ > staff_size_i_+1);
if (!rest_b_)
- s = p->lookup_l()->ball(balltype_i_);
+ s = p->lookup_l()->ball (balltype_i_);
else {
- s = p->lookup_l()->rest(balltype_i_, streepjes_b);
+ s = p->lookup_l()->rest (balltype_i_, streepjes_b);
}
- out = new Molecule(Atom(s));
- out->translate( x_dir_i_ * s.dim.x().length() , X_AXIS);
+ out = new Molecule (Atom (s));
+ out->translate (x_dir_i_ * s.dim.x().length () , X_AXIS);
if (dots_i_) {
- Symbol d = p->lookup_l()->dots(dots_i_ );
+ Symbol d = p->lookup_l()->dots (dots_i_);
Molecule dm;
- dm.add(Atom(d));
- dm.translate( inter_f * dot_delta_y_i_ , Y_AXIS);
- out->add_right(dm);
+ dm.add (Atom (d));
+ dm.translate (inter_f * dot_delta_y_i_ , Y_AXIS);
+ out->add_right (dm);
}
}
if (streepjes_b) {
- int dir = sign(position_i_);
+ int dir = sign (position_i_);
int s =(position_i_<-1) ? -((-position_i_)/2): (position_i_-staff_size_i_)/2;
- Symbol str = p->lookup_l()->streepjes(s);
+ Symbol str = p->lookup_l()->streepjes (s);
Molecule sm;
- sm.add(Atom(str));
+ sm.add (Atom (str));
if (position_i_ % 2)
- sm.translate(-inter_f* dir, Y_AXIS);
- out->add(sm);
+ sm.translate (-inter_f* dir, Y_AXIS);
+ out->add (sm);
}
- out->translate(inter_f*position_i_, Y_AXIS);
+ out->translate (inter_f*position_i_, Y_AXIS);
return out;
}
template class P<Melodic_req>;
void
-Notename_table::add(String s, Melodic_req *m_p)
+Notename_table::add (String s, Melodic_req *m_p)
{
- elem(s).set_p(m_p);
+ elem (s).set_p (m_p);
}
Melodic_req*
-Notename_table::get_l(String s)
+Notename_table::get_l (String s)
{
- if (! elt_b(s))
+ if (! elt_b (s))
return 0;
- return elem(s);
+ return elem (s);
}
{
Interval w;
- for (iter_top(its,i); i.ok(); i++)
- w.unite(i->width());
+ for (iter_top (its,i); i.ok(); i++)
+ w.unite (i->width());
if (w.empty_b())
- w.unite(Interval(0,0));
+ w.unite (Interval (0,0));
return w;
}
}
void
-PCol::set_rank(int i)
+PCol::set_rank (int i)
{
rank_i_ = i;
if (prebreak_p_)
PCol::print() const
{
#ifndef NPRINT
- mtor << "PCol {";
+ DOUT << "PCol {";
- mtor << "rank: " << rank_i_ << '\n';
+ DOUT << "rank: " << rank_i_ << '\n';
- mtor << "# symbols: " << its.size() ;
+ DOUT << "# symbols: " << its.size() ;
if (breakable_b()){
- mtor << "\npre,post: ";
+ DOUT << "\npre,post: ";
prebreak_p_->print();
postbreak_p_->print();
} else if (daddy_l_) {
- mtor<<'\n' << ((this == daddy_l_->prebreak_p_) ?
+ DOUT <<'\n' << ((this == daddy_l_->prebreak_p_) ?
"prebreak" : "postbreak");
- mtor << '\n';
+ DOUT << '\n';
}
- mtor << "extent: " << width().str() << "\n";
- mtor << "}\n";
+ DOUT << "extent: " << width().str () << "\n";
+ DOUT << "}\n";
#endif
}
int
-PCol::compare(PCol const &c1, PCol const &c2)
+PCol::compare (PCol const &c1, PCol const &c2)
{
- return c1.rank_i() - c2.rank_i();
+ return c1.rank_i() - c2.rank_i ();
}
void
PCol::OK() const
{
#ifndef NDEBUG
- if (prebreak_p_ || postbreak_p_ ) {
- assert(prebreak_p_&&postbreak_p_);
- assert(prebreak_p_->daddy_l_ == this);
- assert(postbreak_p_->daddy_l_ == this);
+ if (prebreak_p_ || postbreak_p_) {
+ assert (prebreak_p_&&postbreak_p_);
+ assert (prebreak_p_->daddy_l_ == this);
+ assert (postbreak_p_->daddy_l_ == this);
}
#endif
}
}
void
-PCol::add( Item *i)
+PCol::add (Item *i)
{
- its.bottom().add(i);
+ its.bottom().add (i);
i->pcol_l_ = this;
}
bool
PCol::used_b()const
{
- return daddy_l_ || breakable_b() || its.size()|| used_b_;
+ return daddy_l_ || breakable_b() || its.size ()|| used_b_;
}
#include "word-wrap.hh"
#include "gourlay-breaking.hh"
-Paper_score::Paper_score(Paper_def*p)
+Paper_score::Paper_score (Paper_def*p)
{
paper_l_ = p;
super_elem_l_ = new Super_elem;
- typeset_element(super_elem_l_);
+ typeset_element (super_elem_l_);
}
Paper_score::~Paper_score()
}
void
-Paper_score::typeset_element(Score_elem * elem_p)
+Paper_score::typeset_element (Score_elem * elem_p)
{
- elem_p_list_.bottom().add(elem_p);
+ elem_p_list_.bottom().add (elem_p);
elem_p->pscore_l_ = this;
elem_p->add_processing();
}
void
-Paper_score::typeset_item(Item *i, PCol *c)
+Paper_score::typeset_item (Item *i, PCol *c)
{
- assert(c && i);
+ assert (c && i);
int breakstat = i->break_status_i_;
if (breakstat == -1) {
c = c->postbreak_p_;
}
- c->add(i);
- typeset_element(i);
+ c->add (i);
+ typeset_element (i);
}
void
-Paper_score::typeset_broken_spanner(Spanner*span_p)
+Paper_score::typeset_broken_spanner (Spanner*span_p)
{
span_p->left_col_l_->starters.bottom().add (span_p);
- assert(span_p->left_col_l_->line_l_ == span_p->right_col_l_->line_l_);
+ assert (span_p->left_col_l_->line_l_ == span_p->right_col_l_->line_l_);
- typeset_element(span_p);
+ typeset_element (span_p);
}
void
-Paper_score::typeset_unbroken_spanner(Spanner*span_p)
+Paper_score::typeset_unbroken_spanner (Spanner*span_p)
{
- span_p_list_.bottom().add(span_p);
+ span_p_list_.bottom().add (span_p);
span_p->pscore_l_=this;
if (span_p->left_col_l_)
Paper_score::clean_cols()
{
int rank_i = 0;
- for (iter_top(col_p_list_,c); c.ok(); )
+ for (iter_top (col_p_list_,c); c.ok();)
if (!c->used_b()) {
delete c.remove_p();
} else {
- c->set_rank(rank_i++);
+ c->set_rank (rank_i++);
c++;
}
}
void
-Paper_score::add(PCol *p)
+Paper_score::add (PCol *p)
{
p->pscore_l_ = this;
if (p->breakable_b()){
p->prebreak_p_->pscore_l_ = this;
p->postbreak_p_->pscore_l_ = this;
}
- col_p_list_.bottom().add(p);
+ col_p_list_.bottom().add (p);
}
void
-Paper_score::output(Tex_stream &ts)
+Paper_score::output (Tex_stream &ts)
{
ts << "\n "<< paper_l_->lookup_l()->texsetting << "%(Tex id)\n";
ts<< super_elem_l_->TeX_string();
Paper_score::OK()const
{
#ifndef NDEBUG
- for (iter_top(col_p_list_,cc); cc.ok(); cc++)
+ for (iter_top (col_p_list_,cc); cc.ok(); cc++)
cc->OK();
- for (PCursor<Score_elem*> i( elem_p_list_.top()); i.ok(); i++)
+ for (PCursor<Score_elem*> i (elem_p_list_.top()); i.ok (); i++)
i->OK();
#endif
}
#ifndef NPRINT
if ( !check_debug)
return ;
- mtor << "Paper_score { ";
+ DOUT << "Paper_score { ";
paper_l_->print();
- mtor << "\n elements: ";
- for (iter_top(elem_p_list_,cc); cc.ok(); cc++)
+ DOUT << "\n elements: ";
+ for (iter_top (elem_p_list_,cc); cc.ok(); cc++)
cc->print();
- mtor << "\n unbroken spanners: ";
- for (iter(span_p_list_.top(), i); i.ok(); i++)
+ DOUT << "\n unbroken spanners: ";
+ for (iter (span_p_list_.top(), i); i.ok (); i++)
i->print();
- mtor << "\ncolumns: ";
- for (iter_top(col_p_list_,cc); cc.ok(); cc++)
+ DOUT << "\ncolumns: ";
+ for (iter_top (col_p_list_,cc); cc.ok(); cc++)
cc->print();
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
}
PCursor<PCol *>
-Paper_score::find_col(PCol const *c)const
+Paper_score::find_col (PCol const *c)const
{
PCol const *what = c;
- if (what->daddy_l_ )
+ if (what->daddy_l_)
what = what->daddy_l_;
- return col_p_list_.find((PCol*)what);
+ return col_p_list_.find ((PCol*)what);
}
void
-Paper_score::set_breaking(Array<Col_hpositions> const &breaking)
+Paper_score::set_breaking (Array<Col_hpositions> const &breaking)
{
- super_elem_l_->line_of_score_l_->set_breaking( breaking);
+ super_elem_l_->line_of_score_l_->set_breaking (breaking);
super_elem_l_->break_processing();
- for (iter(span_p_list_.top(),i); i.ok(); ) {
+ for (iter (span_p_list_.top(),i); i.ok ();) {
Spanner *span_p = i.remove_p();
if (span_p->broken_b()) {
span_p->unlink();
delete span_p;
}else{
- typeset_broken_spanner(span_p);
+ typeset_broken_spanner (span_p);
}
}
- for (iter(elem_p_list_.top(),i ); i.ok() ;) {
+ for (iter (elem_p_list_.top(),i); i.ok () ;) {
Item *i_l =i->item();
if ( i_l && !i_l->pcol_l_->line_l_) {
i_l->unlink();
i++;
}
- for (iter_top(col_p_list_, i); i.ok(); i++)
+ for (iter_top (col_p_list_, i); i.ok(); i++)
i->clean_breakable_items();
}
{
Break_algorithm *algorithm_p;
Array<Col_hpositions> sol;
- bool try_wrap = ! paper_l_->get_var( "castingalgorithm");
+ bool try_wrap = ! paper_l_->get_var ("castingalgorithm");
if (!try_wrap) {
algorithm_p = new Gourlay_breaking ;
- algorithm_p->set_pscore(this);
+ algorithm_p->set_pscore (this);
sol = algorithm_p->solve();
delete algorithm_p;
if ( ! sol.size()) {
- warning( "Can not solve this casting problem exactly; revert to Word_wrap");
+ warning ("Can not solve this casting problem exactly; revert to Word_wrap");
try_wrap = true;
}
}
if (try_wrap) {
algorithm_p = new Word_wrap;
- algorithm_p->set_pscore(this);
+ algorithm_p->set_pscore (this);
sol = algorithm_p->solve();
delete algorithm_p;
}
- set_breaking(sol);
+ set_breaking (sol);
}
void
postprocess();
#ifndef NDEBUGA
- for(PCursor<Score_elem*> i(elem_p_list_.top()); i.ok(); i++)
+ for (PCursor<Score_elem*> i (elem_p_list_.top()); i.ok (); i++)
assert (i->status() >= 9);
#endif
}
/** Get all breakable columns between l and r, (not counting l and r). */
Link_array<PCol>
-Paper_score::breakable_col_range(PCol*l,PCol*r)const
+Paper_score::breakable_col_range (PCol*l,PCol*r)const
{
Link_array<PCol> ret;
- PCursor<PCol*> start(l ? find_col(l)+1 : col_p_list_.top() );
- PCursor<PCol*> stop(r ? find_col(r) : col_p_list_.bottom());
+ PCursor<PCol*> start (l ? find_col (l)+1 : col_p_list_.top());
+ PCursor<PCol*> stop (r ? find_col (r) : col_p_list_.bottom());
/*
ugh! windows-suck-suck-suck.
*/
- while ( PCursor<PCol*>::compare(start,stop) < 0 ) {
+ while ( PCursor<PCol*>::compare (start,stop) < 0) {
if (start->breakable_b())
- ret.push(start);
+ ret.push (start);
start++;
}
return ret;
}
Link_array<PCol>
-Paper_score::col_range(PCol*l,PCol*r)const
+Paper_score::col_range (PCol*l,PCol*r)const
{
Link_array<PCol> ret;
- PCursor<PCol*> start(l ? find_col(l)+1 : col_p_list_.top() );
- PCursor<PCol*> stop(r ? find_col(r) : col_p_list_.bottom());
- ret.push(l);
+ PCursor<PCol*> start (l ? find_col (l)+1 : col_p_list_.top());
+ PCursor<PCol*> stop (r ? find_col (r) : col_p_list_.bottom());
+ ret.push (l);
/*
ugh! windows-suck-suck-suck.
*/
- while ( PCursor<PCol*>::compare(start,stop) < 0 )
- ret.push(start++);
- ret.push(r);
+ while ( PCursor<PCol*>::compare (start,stop) < 0)
+ ret.push (start++);
+ ret.push (r);
return ret;
}
Link_array<PCol>
-Paper_score::broken_col_range(PCol*l,PCol*r)const
+Paper_score::broken_col_range (PCol*l,PCol*r)const
{
Link_array<PCol> ret;
- PCursor<PCol*> start(l ? find_col(l)+1 : col_p_list_.top() );
- PCursor<PCol*> stop(r ? find_col(r) : col_p_list_.bottom());
+ PCursor<PCol*> start (l ? find_col (l)+1 : col_p_list_.top());
+ PCursor<PCol*> stop (r ? find_col (r) : col_p_list_.bottom());
/*
ugh! windows-suck-suck-suck.
*/
- while ( PCursor<PCol*>::compare(start,stop) < 0 ) {
- if (start->breakable_b() && !start->line_l_ )
- ret.push(start);
+ while ( PCursor<PCol*>::compare (start,stop) < 0) {
+ if (start->breakable_b() && !start->line_l_)
+ ret.push (start);
start++;
}
#include "assoc-iter.hh"
void
-Paper_def::set_var(String s, Real r)
+Paper_def::set_var (String s, Real r)
{
- real_vars_p_->elem(s) = r;
+ real_vars_p_->elem (s) = r;
}
Real
-Paper_def::get_var(String s)const
+Paper_def::get_var (String s)const
{
- if(! real_vars_p_->elt_b(s))
+ if (! real_vars_p_->elt_b (s))
error ( "unknown paper variable `" + s+"'");
- return real_vars_p_->elem(s);
+ return real_vars_p_->elem (s);
}
Real
Paper_def::linewidth_f() const
{
- return get_var("linewidth");
+ return get_var ("linewidth");
}
Real
-Paper_def::duration_to_dist(Moment d)
+Paper_def::duration_to_dist (Moment d)
{
- Real dur_f = (d) ?pow(get_var("geometric"), log_2(d)) : 0;
- return get_var("basicspace") + get_var("unitspace") * dur_f;
+ Real dur_f = (d) ?pow (get_var ("geometric"), log_2(d)) : 0;
+ return get_var ("basicspace") + get_var ("unitspace") * dur_f;
}
delete lookup_p_;
}
-Paper_def::Paper_def(Paper_def const&s)
+Paper_def::Paper_def (Paper_def const&s)
{
- itrans_p_ = s.itrans_p_ ? new Input_translator( *s.itrans_p_):0;
- lookup_p_ = s.lookup_p_? new Lookup(*s.lookup_p_) : 0;
+ itrans_p_ = s.itrans_p_ ? new Input_translator (*s.itrans_p_):0;
+ lookup_p_ = s.lookup_p_? new Lookup (*s.lookup_p_) : 0;
lookup_p_->paper_l_ = this;
real_vars_p_ = new Assoc<String,Real> (*s.real_vars_p_);
outfile_str_ = s.outfile_str_;
}
void
-Paper_def::set(Input_translator * itrans_p)
+Paper_def::set (Input_translator * itrans_p)
{
delete itrans_p_;
itrans_p_ = itrans_p;
}
void
-Paper_def::set(Lookup*l)
+Paper_def::set (Lookup*l)
{
- assert(l != lookup_p_);
+ assert (l != lookup_p_);
delete lookup_p_;
lookup_p_ = l;
lookup_p_->paper_l_ = this;
Real
Paper_def::interline_f() const
{
- return get_var("interline");
+ return get_var ("interline");
}
Real
Paper_def::rule_thickness()const
{
- return get_var("rule_thickness");
+ return get_var ("rule_thickness");
}
Real
Paper_def::interbeam_f() const
{
- return get_var("interbeam");
+ return get_var ("interbeam");
}
Real
Paper_def::internote_f() const
Real
Paper_def::note_width()const
{
- return get_var("notewidth");
+ return get_var ("notewidth");
}
void
Paper_def::print() const
{
#ifndef NPRINT
- mtor << "Paper {";
- mtor << "out: " <<outfile_str_;
+ DOUT << "Paper {";
+ DOUT << "out: " <<outfile_str_;
lookup_p_->print();
itrans_p_->print();
- for (Assoc_iter<String,Real> i(*real_vars_p_); i.ok(); i++) {
- mtor << i.key() << "= " << i.val() << "\n";
+ for (Assoc_iter<String,Real> i (*real_vars_p_); i.ok(); i++) {
+ DOUT << i.key() << "= " << i.val () << "\n";
}
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
Lookup const *
Paper_def::lookup_l()
{
- assert( lookup_p_ );
+ assert (lookup_p_);
return lookup_p_;
}
Global_translator*
Paper_def::get_global_translator_p() const
{
- return itrans_p_->get_group_engraver_p()->global_l();
+ return itrans_p_->get_group_engraver_p()->global_l ();
}
}
void
-Performer_group_performer::add( Performer *perf_p )
+Performer_group_performer::add (Performer *perf_p)
{
- perf_p_list_.bottom().add(perf_p);
+ perf_p_list_.bottom().add (perf_p);
perf_p->daddy_perf_l_ = this;
- if (perf_p->is_type_b(Performer_group_performer::static_name())) {
- group_l_arr_.push((Performer_group_performer*)perf_p);
+ if (perf_p->is_type_b (Performer_group_performer::static_name())) {
+ group_l_arr_.push ((Performer_group_performer*)perf_p);
} else {
- nongroup_l_arr_ .push(perf_p);
+ nongroup_l_arr_ .push (perf_p);
}
}
Translator*
-Performer_group_performer::ancestor_l( int l )
+Performer_group_performer::ancestor_l (int l)
{
if (!l || !daddy_perf_l_)
return this;
- return daddy_perf_l_->ancestor_l( l - 1 );
+ return daddy_perf_l_->ancestor_l (l - 1);
}
int
void
Performer_group_performer::do_creation_processing()
{
- for ( PCursor<Performer*> i( perf_p_list_.top() ); i.ok(); i++ )
+ for ( PCursor<Performer*> i (perf_p_list_.top()); i.ok (); i++ )
i->creation_processing();
}
#ifndef NPRINT
if ( !check_debug)
return ;
- for ( PCursor<Performer*> i( perf_p_list_.top() ); i.ok(); i++ )
+ for ( PCursor<Performer*> i (perf_p_list_.top()); i.ok (); i++ )
i->print();
#endif
}
void
Performer_group_performer::do_removal_processing()
{
- for ( PCursor<Performer*> i( perf_p_list_.top() ); i.ok(); i++ )
+ for ( PCursor<Performer*> i (perf_p_list_.top()); i.ok (); i++ )
i->do_removal_processing();
}
bool
-Performer_group_performer::do_try_request( Request* req_l )
+Performer_group_performer::do_try_request (Request* req_l)
{
bool hebbes_b =false;
for (int i =0; !hebbes_b && i < nongroup_l_arr_.size() ; i++)
- hebbes_b =nongroup_l_arr_[i]->try_request(req_l);
- if ( !hebbes_b && daddy_perf_l_ )
- hebbes_b = daddy_perf_l_->try_request(req_l);
+ hebbes_b =nongroup_l_arr_[i]->try_request (req_l);
+ if ( !hebbes_b && daddy_perf_l_)
+ hebbes_b = daddy_perf_l_->try_request (req_l);
return hebbes_b ;
}
Translator*
-Performer_group_performer::find_get_translator_l( String n,String id )
+Performer_group_performer::find_get_translator_l (String n,String id)
{
Translator * ret=0;
- Input_translator* itrans_l= itrans_l_-> recursive_find ( n );
- if (itrans_l ) {
- ret = find_performer_l(n,id);
+ Input_translator* itrans_l= itrans_l_-> recursive_find ( n);
+ if (itrans_l) {
+ ret = find_performer_l (n,id);
if (!ret) {
Performer_group_performer * group =
itrans_l-> get_group_performer_p();
- add(group);
+ add (group);
ret = group;
- if (group->itrans_l_->is_name_b( n ) )
+ if (group->itrans_l_->is_name_b (n) )
ret ->id_str_ = id;
else
- return ret->find_get_translator_l(n,id);
+ return ret->find_get_translator_l (n,id);
}
} else if (daddy_perf_l_)
- ret =daddy_perf_l_->find_get_translator_l(n,id);
+ ret =daddy_perf_l_->find_get_translator_l (n,id);
else {
- warning("Can't find or create `" + n + "' called `" + id + "'\n");
+ warning ("Can't find or create `" + n + "' called `" + id + "'\n");
ret =0;
}
return ret;
}
Performer_group_performer*
-Performer_group_performer::find_performer_l( String n, String id )
+Performer_group_performer::find_performer_l (String n, String id)
{
if (name() == n && id_str_ == id)
return this;
Performer_group_performer * r = 0;
for (int i =0; !r && i< group_l_arr_.size(); i++) {
- r = group_l_arr_[i]->find_performer_l(n,id);
+ r = group_l_arr_[i]->find_performer_l (n,id);
}
return r;
Performer_group_performer::get_default_interpreter()
{
// ?
- if ( is_bottom_performer_b() )
+ if ( is_bottom_performer_b())
return daddy_perf_l_->get_default_interpreter();
Performer_group_performer *perf_p= itrans_l_->
- get_default_itrans_l()->get_group_performer_p();
- add(perf_p );
+ get_default_itrans_l()->get_group_performer_p ();
+ add (perf_p);
if (perf_p->is_bottom_performer_b())
return perf_p;
else
void
Performer_group_performer::process_requests()
{
- for ( PCursor<Performer*> i( perf_p_list_.top() ); i.ok(); i++ )
+ for ( PCursor<Performer*> i (perf_p_list_.top()); i.ok (); i++ )
i->process_requests();
}
bool
-Performer_group_performer::try_request( Request* r )
+Performer_group_performer::try_request (Request* r)
{
- return Performer::try_request( r );
+ return Performer::try_request (r);
}
}
void
-Performer::play( Audio_element* p )
+Performer::play (Audio_element* p)
{
- daddy_perf_l_->play( p );
+ daddy_perf_l_->play (p);
}
int
Performer::print() const
{
#ifndef NPRINT
- mtor << "\n" << name() << " {";
+ DOUT << "\n" << name() << " {";
do_print();
- mtor << "}";
+ DOUT << "}";
#endif
}
}
bool
-Performer::do_try_request( Request* req_l )
+Performer::do_try_request (Request* req_l)
{
return false;
}
bool
-Performer::try_request(Request*r)
+Performer::try_request (Request*r)
{
if (!init_b_) {
creation_processing();
}
- return do_try_request(r);
+ return do_try_request (r);
}
void
#include "qlp.hh"
void
-Mixed_qp::add_equality_cons(Vector , double )
+Mixed_qp::add_equality_cons (Vector , double)
{
- assert(false);
+ assert (false);
}
void
-Mixed_qp::add_fixed_var(int i, Real r)
+Mixed_qp::add_fixed_var (int i, Real r)
{
- eq_cons.push(i);
- eq_consrhs.push(r);
+ eq_cons.push (i);
+ eq_consrhs.push (r);
}
cons should be ascending
*/
Vector
-Mixed_qp::solve(Vector start) const
+Mixed_qp::solve (Vector start) const
{
if (!dim())
- return Vector(0);
+ return Vector (0);
print();
- Ineq_constrained_qp pure(*this);
+ Ineq_constrained_qp pure (*this);
for (int i= eq_cons.size()-1; i>=0; i--) {
- pure.eliminate_var(eq_cons[i], eq_consrhs[i]);
- start.del(eq_cons[i]);
+ pure.eliminate_var (eq_cons[i], eq_consrhs[i]);
+ start.del (eq_cons[i]);
}
- Vector sol = pure.solve(start);
+ Vector sol = pure.solve (start);
for (int i= 0; i < eq_cons.size(); i++) {
- sol.insert( eq_consrhs[i],eq_cons[i]);
+ sol.insert (eq_consrhs[i],eq_cons[i]);
}
return sol;
}
void
-Ineq_constrained_qp::assert_solution(Vector sol) const
+Ineq_constrained_qp::assert_solution (Vector sol) const
{
Array<int> binding;
for (int i=0; i < cons.size(); i++) {
Real R=cons[i] * sol- consrhs[i];
- assert(R> -EPS);
+ assert (R> -EPS);
if (R < EPS)
- binding.push(i);
+ binding.push (i);
}
// KKT check...
// todo
Ineq_constrained_qp::print() const
{
#ifndef NPRINT
- mtor << "Quad " << quad;
- mtor << "lin " << lin <<"\n"
+ DOUT << "Quad " << quad;
+ DOUT << "lin " << lin <<"\n"
<< "const " << const_term<<"\n";
for (int i=0; i < cons.size(); i++) {
- mtor << "constraint["<<i<<"]: " << cons[i] << " >= " << consrhs[i];
- mtor << "\n";
+ DOUT << "constraint["<<i<<"]: " << cons[i] << " >= " << consrhs[i];
+ DOUT << "\n";
}
#endif
}
-Mixed_qp::Mixed_qp(int n)
- : Ineq_constrained_qp(n)
+Mixed_qp::Mixed_qp (int n)
+ : Ineq_constrained_qp (n)
{
}
{
#ifndef NDEBUG
Ineq_constrained_qp::OK();
- assert(eq_consrhs.size() == eq_cons.size());
+ assert (eq_consrhs.size() == eq_cons.size ());
#endif
}
#ifndef NPRINT
Ineq_constrained_qp::print();
for (int i=0; i < eq_cons.size(); i++) {
- mtor << "eq cons "<<i<<": x["<<eq_cons[i]<<"] == " << eq_consrhs[i]<<"\n";
+ DOUT << "eq cons "<<i<<": x["<<eq_cons[i]<<"] == " << eq_consrhs[i]<<"\n";
}
#endif
}
String
Active_constraints::status() const
{
- String s("Active|Inactive [");
+ String s ("Active|Inactive [");
for (int i=0; i< active.size(); i++) {
- s += String(active[i]) + " ";
+ s += String (active[i]) + " ";
}
s+="| ";
for (int i=0; i< inactive.size(); i++) {
- s += String(inactive[i]) + " ";
+ s += String (inactive[i]) + " ";
}
s+="]";
#ifndef NDEBUG
H.OK();
A.OK();
- assert(active.size() +inactive.size() == opt->cons.size());
- assert(H.dim() == opt->dim());
- assert(active.size() == A.rows());
+ assert (active.size() +inactive.size () == opt->cons.size ());
+ assert (H.dim() == opt->dim ());
+ assert (active.size() == A.rows ());
Array<int> allcons;
for (int i=0; i < opt->cons.size(); i++)
- allcons.push(0);
+ allcons.push (0);
for (int i=0; i < active.size(); i++) {
int j = active[i];
allcons[j]++;
allcons[j]++;
}
for (int i=0; i < allcons.size(); i++)
- assert(allcons[i] == 1);
+ assert (allcons[i] == 1);
#endif
}
Vector
-Active_constraints::get_lagrange(Vector gradient)
+Active_constraints::get_lagrange (Vector gradient)
{
return (A*gradient);
}
void
-Active_constraints::add(int k)
+Active_constraints::add (int k)
{
// add indices
int cidx=inactive[k];
- active.push(cidx);
+ active.push (cidx);
- inactive.swap(k,inactive.size()-1);
+ inactive.swap (k,inactive.size()-1);
inactive.pop();
- Vector a( opt->cons[cidx] );
+ Vector a (opt->cons[cidx]);
// update of matrices
Vector Ha = H*a;
Real aHa = a*Ha;
- Vector addrow(Ha.dim());
- if (abs(aHa) > EPS) {
+ Vector addrow (Ha.dim());
+ if (abs (aHa) > EPS) {
/*
a != 0, so if Ha = O(EPS), then
Ha * aH / aHa = O(EPS^2/EPS)
if H*a == 0, the constraints are dependent.
*/
- H -= Matrix(Ha/aHa , Ha);
+ H -= Matrix (Ha/aHa , Ha);
/*
*/
addrow=Ha;
addrow/= aHa;
- A -= Matrix(A*a, addrow);
- A.insert_row(addrow,A.rows());
+ A -= Matrix (A*a, addrow);
+ A.insert_row (addrow,A.rows());
}else
WARN << "degenerate constraints";
}
void
-Active_constraints::drop(int k)
+Active_constraints::drop (int k)
{
int q=active.size()-1;
// drop indices
- inactive.push(active[k]);
- active.swap(k,q);
- A.swap_rows(k,q);
+ inactive.push (active[k]);
+ active.swap (k,q);
+ A.swap_rows (k,q);
active.pop();
- Vector a(A.row(q));
+ Vector a (A.row (q));
if (a.norm() > EPS) {
/*
*/
Real q = a*opt->quad*a;
- Matrix aaq(a,a/q);
+ Matrix aaq (a,a/q);
H += aaq;
A -= A*opt->quad*aaq;
}else
WARN << "degenerate constraints";
#ifndef NDEBUG
- Vector rem_row(A.row(q));
- assert(rem_row.norm() < EPS);
+ Vector rem_row (A.row (q));
+ assert (rem_row.norm() < EPS);
#endif
- A.delete_row(q);
+ A.delete_row (q);
}
-Active_constraints::Active_constraints(Ineq_constrained_qp const *op)
+Active_constraints::Active_constraints (Ineq_constrained_qp const *op)
: A(0,op->dim()),
H(op->dim()),
- opt(op)
+ opt (op)
{
for (int i=0; i < op->cons.size(); i++)
- inactive.push(i);
- Choleski_decomposition chol(op->quad);
+ inactive.push (i);
+ Choleski_decomposition chol (op->quad);
/*
ugh.
constraints.
*/
Vector
-Active_constraints::find_active_optimum(Vector g)
+Active_constraints::find_active_optimum (Vector g)
{
return H*g;
}
MInterval
Request::time_int() const
{
- return MInterval(0, duration());
+ return MInterval (0, duration());
}
bool
-Request::equal_b(Request *r)const
+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 );
+ 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;
}
bool
-Request::do_equal_b(Request*)const
+Request::do_equal_b (Request*)const
{
return false;
}
translate the rest symbols
*/
void
-Rest_column::translate_heads(int dy_i)
+Rest_column::translate_heads (int dy_i)
{
for (int i=0; i < head_l_arr_.size(); i++)
head_l_arr_[i]->position_i_ += dy_i;
Score_align_engraver::do_pre_move_processing()
{
if (align_p_) {
- typeset_element( align_p_);
+ typeset_element (align_p_);
align_p_ =0;
}
}
void
-Score_align_engraver::acknowledge_element(Score_elem_info inf)
+Score_align_engraver::acknowledge_element (Score_elem_info inf)
{
- if (inf.elem_l_->is_type_b(type_ch_C_ )) {
+ if (inf.elem_l_->is_type_b (type_ch_C_)) {
- if (!align_p_ ) {
+ if (!align_p_) {
align_p_ = new Horizontal_group_item;
align_p_->breakable_b_ = true;
- announce_element(Score_elem_info(align_p_,0));
+ announce_element (Score_elem_info (align_p_,0));
}
Score_elem * unbound_elem = inf.elem_l_;
- while ( unbound_elem->axis_group_l_a_[X_AXIS] )
+ while ( unbound_elem->axis_group_l_a_[X_AXIS])
unbound_elem = unbound_elem->axis_group_l_a_[X_AXIS];
- align_p_->add_element(unbound_elem );
+ align_p_->add_element (unbound_elem);
}
}
{ \
public: \
DECLARE_MY_RUNTIME_TYPEINFO; \
- C ## _align_engraver() : Score_align_engraver() \
+ C ## _align_engraver() : Score_align_engraver () \
{ type_ch_C_ = T::static_name();\
priority_i_ = p;} \
}; \
#include "p-col.hh"
#include "score-column.hh"
-Score_column::Score_column(Moment w)
+Score_column::Score_column (Moment w)
{
when_ = w;
musical_b_ = false;
Score_column::print() const
{
#ifndef NPRINT
- mtor << "Score_column { mus "<< musical_b_ <<" at " << when_<<'\n';
- mtor << "durations: [";
+ DOUT << "Score_column { mus "<< musical_b_ <<" at " << when_<<'\n';
+ DOUT << "durations: [";
for (int i=0; i < durations.size(); i++)
- mtor << durations[i] << " ";
- mtor << "]\n";
+ DOUT << durations[i] << " ";
+ DOUT << "]\n";
PCol::print();
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
int
-Moment_compare(Moment const &m1, Moment const &m2)
+Moment_compare (Moment const &m1, Moment const &m2)
{
- return sign(m1-m2);
+ return sign (m1-m2);
}
void
Score_column::preprocess()
{
- durations.sort(Moment_compare);
+ durations.sort (Moment_compare);
}
void
-Score_column::add_duration(Moment d)
+Score_column::add_duration (Moment d)
{
- assert(d);
+ assert (d);
for (int i = 0; i< durations.size(); i++) {
if (d == durations[i])
return ;
}
- durations.push(d);
+ durations.push (d);
}
void
Score_column::do_set_breakable()
{
- Score_column *c1 = new Score_column(when_);
- Score_column *c2 = new Score_column(when_);
+ Score_column *c1 = new Score_column (when_);
+ Score_column *c2 = new Score_column (when_);
prebreak_p_ =c1;
postbreak_p_ = c2;
c1->durations = durations;
#include "score-elem-info.hh"
#include "request.hh"
-Score_elem_info::Score_elem_info(Score_elem*s_l, Request*r_l)
+Score_elem_info::Score_elem_info (Score_elem*s_l, Request*r_l)
{
elem_l_ = s_l;
req_l_ = r_l;
#include "p-col.hh"
Score_elem*
-Score_elem::dependency(int i)const
+Score_elem::dependency (int i)const
{
return (Score_elem*) get_out_edge_arr()[i];
}
int
Score_elem::dependency_size() const
{
- return get_out_edge_arr().size();
+ return get_out_edge_arr().size ();
}
Score_elem*
-Score_elem::dependent(int i) const
+Score_elem::dependent (int i) const
{
return (Score_elem*) get_in_edge_arr()[i];
}
int
Score_elem::dependent_size() const
{
- return get_in_edge_arr().size();
+ return get_in_edge_arr().size ();
}
String
-Score_elem::TeX_string_without_offset(Offset o)const
+Score_elem::TeX_string_without_offset (Offset o)const
{
- if (transparent_b_ )
+ if (transparent_b_)
return "";
- String s( "\\placebox{%}{%}{%}");
+ String s ("\\placebox{%}{%}{%}");
Array<String> a;
- a.push( print_dimen(o.y() ));
- a.push( print_dimen(o.x() ));
+ a.push (print_dimen (o.y()));
+ a.push (print_dimen (o.x()));
String t = output->TeX_string();
if (t == "")
return t;
- a.push( t);
+ a.push (t);
String r;
if (check_debug)
- r = String("\n%start: ") + name() + "\n";
- r += substitute_args(s, a);;
+ r = String ("\n%start: ") + name() + "\n";
+ r += substitute_args (s, a);;
return r;
}
String
Score_elem::TeX_string() const
{
- assert( status_ > POSTCALCED);
- return TeX_string_without_offset(offset_);
+ assert (status_ > POSTCALCED);
+ return TeX_string_without_offset (offset_);
}
void
-Score_elem::copy_dependencies(Score_elem const &s)
+Score_elem::copy_dependencies (Score_elem const &s)
{
/* called from derived ctor, so most info points to the same deps
as (Directed_graph_node&)s. Nobody points to us, so don't copy
dependents.
*/
- copy_edges_out(s);
+ copy_edges_out (s);
}
-Score_elem::Score_elem(Score_elem const&s)
+Score_elem::Score_elem (Score_elem const&s)
{
transparent_b_ = s.transparent_b_;
empty_b_ = s.empty_b_;
axis_group_l_a_[0] = axis_group_l_a_[1] =0;
status_ = s.status_;
- assert(!s.output);
+ assert (!s.output);
output = 0;
pscore_l_ = s.pscore_l_;
- offset_ = Offset(0,0);
+ offset_ = Offset (0,0);
}
Score_elem::~Score_elem()
{
// some paranoia to prevent weird segv's
- assert(status_ < DELETED);
+ assert (status_ < DELETED);
delete output;
status_ = DELETED;
output = 0;
GEOMETRY
*/
Real
-Score_elem::absolute_coordinate(Axis a)const
+Score_elem::absolute_coordinate (Axis a)const
{
Real r = offset_[a];
for ( Axis_group_element * axis_group_l = axis_group_l_a_[a];
Offset
Score_elem::absolute_offset() const
{
- return Offset(absolute_coordinate(X_AXIS), absolute_coordinate(Y_AXIS));
+ return Offset (absolute_coordinate (X_AXIS), absolute_coordinate (Y_AXIS));
}
void
-Score_elem::translate(Real y, Axis a)
+Score_elem::translate (Real y, Axis a)
{
offset_[a] += y;
}
Real
-Score_elem::relative_coordinate(Axis_group_element*e, Axis a)const
+Score_elem::relative_coordinate (Axis_group_element*e, Axis a)const
{
Real r =0.0;
for ( Axis_group_element * axis_group_l = axis_group_l_a_[a];
}
Axis_group_element*
-Score_elem::common_group(Score_elem const* s, Axis a)const
+Score_elem::common_group (Score_elem const* s, Axis a)const
{
Link_array<Axis_group_element> my_groups;
for ( Axis_group_element * axis_group_l = axis_group_l_a_[a];
axis_group_l;
axis_group_l = axis_group_l->axis_group_l_a_[a])
- my_groups.push( axis_group_l );
+ my_groups.push (axis_group_l);
Axis_group_element* common_l=0;
for ( Axis_group_element * axis_group_l = s->axis_group_l_a_[a];
!common_l && axis_group_l;
axis_group_l = axis_group_l->axis_group_l_a_[a])
- common_l = my_groups.find_l( axis_group_l );
+ common_l = my_groups.find_l (axis_group_l);
return common_l;
}
void
-Score_elem::translate(Offset O)
+Score_elem::translate (Offset O)
{
offset_ += O;
}
if (!output){
Molecule*m = brew_molecule_p();
- r = m->extent().x();
+ r = m->extent().x ();
delete m;
} else
- r = output->extent().x();
+ r = output->extent().x ();
return r;
}
Interval
Score_elem::width() const
{
- return extent( X_AXIS);
+ return extent (X_AXIS);
}
Interval
-Score_elem::extent(Axis a)const
+Score_elem::extent (Axis a)const
{
Interval r;
- if ( !empty_b_ ) {
+ if ( !empty_b_) {
- r = (a == X_AXIS)? do_width(): do_height();
+ r = (a == X_AXIS)? do_width(): do_height ();
}
if (!r.empty_b()) // float exception on DEC Alpha
Interval r;
if (!output){
Molecule*m = brew_molecule_p();
- r = m->extent().y();
+ r = m->extent().y ();
delete m;
} else
- r = output->extent().y();
+ r = output->extent().y ();
return r;
}
Interval
Score_elem::height() const
{
- return extent(Y_AXIS);
+ return extent (Y_AXIS);
}
/*
Score_elem::print()const
{
#ifndef NPRINT
- mtor << name() << "{\n";
- mtor << "dets: " << dependent_size() << "dependencies: " <<
+ DOUT << name() << "{\n";
+ DOUT << "dets: " << dependent_size() << "dependencies: " <<
dependency_size();
- if (offset_.x() || offset_.y())
- mtor << "offset (" << offset_.x() << ", " << offset_.y() <<")";
- mtor << "\n";
+ if (offset_.x() || offset_.y ())
+ DOUT << "offset (" << offset_.x() << ", " << offset_.y () <<")";
+ DOUT << "\n";
do_print();
if (output)
output->print();
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
transparent_b_ = empty_b_ = false;
axis_group_l_a_[0] = axis_group_l_a_[1] =0;
pscore_l_=0;
- offset_ = Offset(0,0);
+ offset_ = Offset (0,0);
output = 0;
status_ = ORPHAN;
}
Paper_def*
Score_elem::paper() const
{
- assert(pscore_l_);
+ assert (pscore_l_);
return pscore_l_->paper_l_;
}
void
Score_elem::pre_processing()
{
- if (status_ >= PRECALCED )
+ if (status_ >= PRECALCED)
return;
- assert(status_ != PRECALCING); // cyclic dependency
+ assert (status_ != PRECALCING); // cyclic dependency
status_ = PRECALCING;
for (int i=0; i < dependency_size(); i++)
- dependency(i)->pre_processing();
+ dependency (i)->pre_processing();
- Link_array<Score_elem> extra(get_extra_dependencies());
+ Link_array<Score_elem> extra (get_extra_dependencies());
for (int i=0; i < extra.size(); i++)
extra[i]->pre_processing();
void
Score_elem::breakable_col_processing()
{
- if (status_ >= PREBROKEN )
+ if (status_ >= PREBROKEN)
return;
- if(status_== PREBREAKING) {
+ if (status_== PREBREAKING) {
status_ = PREBROKEN;
return ;
}
status_ = PREBREAKING;
for (int i=0; i < dependency_size(); i++)
- dependency(i)->breakable_col_processing();
+ dependency (i)->breakable_col_processing();
- Link_array<Score_elem> extra(get_extra_dependencies());
+ Link_array<Score_elem> extra (get_extra_dependencies());
for (int i=0; i < extra.size(); i++)
extra[i]->breakable_col_processing();
void
Score_elem::break_processing()
{
- if (status_ >= BROKEN )
+ if (status_ >= BROKEN)
return;
if (status_ == BREAKING) {
status_ = BREAKING;
for (int i=0; i < dependency_size(); i++)
- dependency(i)->break_processing();
+ dependency (i)->break_processing();
- Link_array<Score_elem> extra(get_extra_dependencies());
+ Link_array<Score_elem> extra (get_extra_dependencies());
for (int i=0; i < extra.size(); i++)
extra[i]->break_processing();
{
if (status_ >= POSTCALCED)
return;
- assert(status_ != POSTCALCING);// cyclic dependency
+ assert (status_ != POSTCALCING);// cyclic dependency
status_=POSTCALCING;
for (int i=0; i < dependency_size(); i++)
- dependency(i)->post_processing();
+ dependency (i)->post_processing();
- Link_array<Score_elem> extra(get_extra_dependencies());
+ Link_array<Score_elem> extra (get_extra_dependencies());
for (int i=0; i < extra.size(); i++)
extra[i]->post_processing();
status_ = OUTPUT; // do it only once.
for (int i=0; i < dependency_size(); i++)
- dependency(i)->molecule_processing();
+ dependency (i)->molecule_processing();
- Link_array<Score_elem> extra(get_extra_dependencies());
+ Link_array<Score_elem> extra (get_extra_dependencies());
for (int i=0; i < extra.size(); i++)
extra[i]->molecule_processing();
}
void
-Score_elem::do_substitute_dependency(Score_elem*,Score_elem*)
+Score_elem::do_substitute_dependency (Score_elem*,Score_elem*)
{
}
void
-Score_elem::do_substitute_dependent(Score_elem*,Score_elem*)
+Score_elem::do_substitute_dependent (Score_elem*,Score_elem*)
{
}
Molecule*
Score_elem::brew_molecule_p()const
{
- Atom a(paper()->lookup_l()->fill(Box(Interval(0,0), Interval(0,0))));
+ Atom a (paper()->lookup_l ()->fill (Box (Interval (0,0), Interval (0,0))));
return new Molecule (a);
}
*/
void
-Score_elem::remove_dependency(Score_elem*e)
+Score_elem::remove_dependency (Score_elem*e)
{
- remove_edge_out(e);
- substitute_dependency(e, 0);
+ remove_edge_out (e);
+ substitute_dependency (e, 0);
}
void
-Score_elem::add_dependency(Score_elem*e)
+Score_elem::add_dependency (Score_elem*e)
{
- Directed_graph_node::add(e);
+ Directed_graph_node::add (e);
}
void
-Score_elem::substitute_dependency(Score_elem* old, Score_elem* new_l)
+Score_elem::substitute_dependency (Score_elem* old, Score_elem* new_l)
{
- do_substitute_dependency(old,new_l);
- old->do_substitute_dependent(this, 0);
+ do_substitute_dependency (old,new_l);
+ old->do_substitute_dependent (this, 0);
}
void
Score_elem::junk_dependencies()
{
- while ( dependency_size() ) {
- remove_edge_out( dependency( 0 ));
+ while ( dependency_size()) {
+ remove_edge_out (dependency (0));
}
}
Link_array<Score_elem> remove_us_arr;
for (int i=0; i < dependency_size(); i++) {
- Score_elem * elt = dependency(i);
+ Score_elem * elt = dependency (i);
if (elt->line_l() != line){
if (elt->spanner()) {
Spanner * sp = elt->spanner();
- Spanner * broken = sp->find_broken_piece(line);
- substitute_dependency(sp, broken);
-
- add_dependency(broken);
- } else if (elt->item() && elt->item()->pcol_l_->breakpoint_b()
- && elt->item()->break_status_i() == 0) {
- Item * my_item = elt->item()->find_prebroken_piece(line);
- substitute_dependency( elt, my_item);
+ Spanner * broken = sp->find_broken_piece (line);
+ substitute_dependency (sp, broken);
+
+ add_dependency (broken);
+ } else if (elt->item() && elt->item ()->pcol_l_->breakpoint_b ()
+ && elt->item()->break_status_i () == 0) {
+ Item * my_item = elt->item()->find_prebroken_piece (line);
+ substitute_dependency (elt, my_item);
if (my_item)
- add_dependency( my_item);
+ add_dependency (my_item);
}
- remove_us_arr.push(elt);
+ remove_us_arr.push (elt);
}
}
remove_us_arr.default_sort();
remove_us_arr.uniq();
for (int i=0; i <remove_us_arr.size(); i++)
- remove_dependency(remove_us_arr[i]);
+ remove_dependency (remove_us_arr[i]);
status_ = BROKEN;
}
Link_array<Score_elem> old_arr, new_arr;
for (int i=0; i < dependency_size(); i++) {
- Score_elem * elt = dependency(i);
+ Score_elem * elt = dependency (i);
Item *it_l = elt->item();
if (it_l && it_l->breakable_b_)
if (item()) {
- Score_elem *new_l = it_l->find_prebroken_piece(item()->pcol_l_);
- if (new_l != elt ) {
+ Score_elem *new_l = it_l->find_prebroken_piece (item()->pcol_l_);
+ if (new_l != elt) {
new_arr.push (new_l);
- old_arr.push(elt);
+ old_arr.push (elt);
}
}else {
- new_arr.push(it_l->broken_to_a_[0]);
- old_arr.push(0);
- old_arr.push(0);
- new_arr.push(it_l->broken_to_a_[1]);
+ new_arr.push (it_l->broken_to_a_[0]);
+ old_arr.push (0);
+ old_arr.push (0);
+ new_arr.push (it_l->broken_to_a_[1]);
}
}
for (int i=0; i < old_arr.size(); i++)
if (old_arr[i])
- substitute_dependency( old_arr[i], new_arr[i] );
+ substitute_dependency (old_arr[i], new_arr[i]);
status_ = PREBROKEN;
Score_elem::unlink_all()
{
for (int i=0; i < dependency_size(); i++)
- dependency(i)->unlink_all();
- Link_array<Score_elem> extra(get_extra_dependencies());
+ dependency (i)->unlink_all();
+ Link_array<Score_elem> extra (get_extra_dependencies());
for (int i=0; i < extra.size(); i++)
extra[i]->unlink_all();
{
do_unlink();
while ( dependency_size()) {
- do_substitute_dependency(dependency(0),0);
- remove_edge_out_idx(0);
+ do_substitute_dependency (dependency (0),0);
+ remove_edge_out_idx (0);
}
- while ( dependent_size() ) {
- dependent(0)->remove_dependency(this);
+ while ( dependent_size()) {
+ dependent (0)->remove_dependency (this);
}
for (int j=0; j < 2; j++)
if ( axis_group_l_a_[j])
- axis_group_l_a_[j]->remove_element(this);
+ axis_group_l_a_[j]->remove_element (this);
}
{
#ifndef NDEBUG
for (int i=0; i < dependency_size(); i++) {
- dependency(i)->OK();
+ dependency (i)->OK();
}
#endif
}
void
-Score_engraver::set_score(Score *s)
+Score_engraver::set_score (Score *s)
{
- Global_translator::set_score(s);
+ Global_translator::set_score (s);
scoreline_l_ = s->pscore_p_->super_elem_l_->line_of_score_l_;
}
void
-Score_engraver::prepare(Moment w)
+Score_engraver::prepare (Moment w)
{
- set_columns(new Score_column(w), new Score_column(w));
+ set_columns (new Score_column (w), new Score_column (w));
disallow_break_b_ = false;
void
Score_engraver::do_creation_processing()
{
- scoreline_l_->left_col_l_ = get_staff_info().command_pcol_l();
+ scoreline_l_->left_col_l_ = get_staff_info().command_pcol_l ();
scoreline_l_->left_col_l_ ->set_breakable();
Engraver_group_engraver::do_creation_processing();
}
Score_engraver::do_removal_processing()
{
Engraver_group_engraver::do_removal_processing();
- scoreline_l_->right_col_l_ = get_staff_info().command_pcol_l();
+ scoreline_l_->right_col_l_ = get_staff_info().command_pcol_l ();
scoreline_l_->right_col_l_ ->set_breakable();
typeset_all();
- set_columns(0,0);
+ set_columns (0,0);
}
void
}
void
-Score_engraver::announce_element(Score_elem_info info)
+Score_engraver::announce_element (Score_elem_info info)
{
- announce_info_arr_.push(info);
- info.origin_grav_l_arr_.push(this);
+ announce_info_arr_.push (info);
+ info.origin_grav_l_arr_.push (this);
}
void
if (announce_info_arr_[i].req_l_) {
Musical_req *m = announce_info_arr_[i].req_l_->musical();
if (m && m->rhythmic()) {
- musical_column_l_->add_duration( m->duration());
+ musical_column_l_->add_duration (m->duration());
}
}
Engraver_group_engraver::do_announces();
void
-Score_engraver::typeset_element(Score_elem *elem_p)
+Score_engraver::typeset_element (Score_elem *elem_p)
{
- if ( elem_p->item() && elem_p->item()->breakable_b_ ) {
- nobreak_item_p_arr_.push(elem_p->item());
+ if ( elem_p->item() && elem_p->item ()->breakable_b_) {
+ nobreak_item_p_arr_.push (elem_p->item());
} else
- musical_item_p_arr_.push(elem_p);
+ musical_item_p_arr_.push (elem_p);
}
void
Score_engraver::typeset_all()
{
- PCol * c= get_staff_info().command_pcol_l();
+ PCol * c= get_staff_info().command_pcol_l ();
Paper_score *ps_l = score_l_->pscore_p_;
for (int i =0; i < nobreak_item_p_arr_.size(); i++) {
- ps_l->typeset_item(nobreak_item_p_arr_[i], c);
+ ps_l->typeset_item (nobreak_item_p_arr_[i], c);
// should get rid of this.. .
- scoreline_l_->add_dependency(nobreak_item_p_arr_[i]);
+ scoreline_l_->add_dependency (nobreak_item_p_arr_[i]);
}
nobreak_item_p_arr_.clear();
for (int i=0; i < musical_item_p_arr_.size(); i++) {
- PCol* m = get_staff_info().musical_pcol_l();
+ PCol* m = get_staff_info().musical_pcol_l ();
Score_elem *elem_p = musical_item_p_arr_[i];
- scoreline_l_->add(elem_p);
+ scoreline_l_->add (elem_p);
if (elem_p->spanner()) {
- ps_l->typeset_unbroken_spanner(elem_p->spanner());
+ ps_l->typeset_unbroken_spanner (elem_p->spanner());
} else if (elem_p->item()) {
- ps_l->typeset_item(elem_p->item(), m);
+ ps_l->typeset_item (elem_p->item(), m);
} else
- assert(false);
+ assert (false);
}
musical_item_p_arr_.clear();
}
void
Score_engraver::do_pre_move_processing()
{
- if ( !disallow_break_b_ ){
- get_staff_info().command_pcol_l()->set_breakable();
+ if ( !disallow_break_b_){
+ get_staff_info().command_pcol_l ()->set_breakable ();
breaks_i_ ++;
if ( ! (breaks_i_%8))
*mlog << "[" << breaks_i_ << "]" << flush;
}
void
-Score_engraver::set_columns(Score_column *new_command_l,
+Score_engraver::set_columns (Score_column *new_command_l,
Score_column *new_musical_l)
{
- if ( command_column_l_ && command_column_l_->used_b() )
- score_l_->pscore_p_->add(command_column_l_);
+ if ( command_column_l_ && command_column_l_->used_b())
+ score_l_->pscore_p_->add (command_column_l_);
else {
delete command_column_l_ ;
command_column_l_ =0;
bool
-Score_engraver::do_try_request(Request*r)
+Score_engraver::do_try_request (Request*r)
{
- bool gotcha = Engraver_group_engraver::do_try_request(r);
- if ( !gotcha && r->command() && r->command()->disallowbreak())
+ bool gotcha = Engraver_group_engraver::do_try_request (r);
+ if ( !gotcha && r->command() && r->command ()->disallowbreak ())
disallow_break_b_ = true;
return gotcha;
}
Score_horizontal_align_engraver::do_pre_move_processing()
{
if (halign_p_) {
- typeset_element(halign_p_);
+ typeset_element (halign_p_);
halign_p_ =0;
}
}
void
-Score_horizontal_align_engraver::acknowledge_element(Score_elem_info i)
+Score_horizontal_align_engraver::acknowledge_element (Score_elem_info i)
{
Engraver* reg = i.origin_grav_l_arr_[0];
- if (reg->is_type_b(
- Score_align_engraver::static_name()) )
+ if (reg->is_type_b (
+ Score_align_engraver::static_name()))
{
Score_align_engraver * align_grav_l = (Score_align_engraver*) reg;
if (!halign_p_) {
halign_p_ = new Break_align_item;
halign_p_->breakable_b_ = true;
- announce_element(Score_elem_info(halign_p_,0));
+ announce_element (Score_elem_info (halign_p_,0));
}
Item * it = i.elem_l_->item();
if (align_grav_l->type_ch_C_ == Bar::static_name())
halign_p_->center_l_ = it;
- halign_p_->add(it, align_grav_l->priority_i_);
+ halign_p_->add (it, align_grav_l->priority_i_);
}
}
Translator*
-Score_performer::ancestor_l(int l)
+Score_performer::ancestor_l (int l)
{
- return Global_translator::ancestor_l(l);
+ return Global_translator::ancestor_l (l);
}
void
-Score_performer::play(Audio_element * p)
+Score_performer::play (Audio_element * p)
{
- if (p->is_type_b(Audio_item::static_name())) {
- audio_column_l_->add( (Audio_item*)p);
- } else if (p->is_type_b(Audio_staff::static_name())) {
- score_l_->audio_score_p_->add_staff( (Audio_staff*)p );
+ if (p->is_type_b (Audio_item::static_name())) {
+ audio_column_l_->add ((Audio_item*)p);
+ } else if (p->is_type_b (Audio_staff::static_name())) {
+ score_l_->audio_score_p_->add_staff ((Audio_staff*)p);
}
- score_l_->audio_score_p_->add(p);
+ score_l_->audio_score_p_->add (p);
}
void
-Score_performer::prepare(Moment m)
+Score_performer::prepare (Moment m)
{
now_mom_ = m;
- audio_column_l_ = new Audio_column(m);
- score_l_->audio_score_p_->add(audio_column_l_);
+ audio_column_l_ = new Audio_column (m);
+ score_l_->audio_score_p_->add (audio_column_l_);
}
void
-Score_performer::set_score(Score* score_l)
+Score_performer::set_score (Score* score_l)
{
- Global_translator::set_score(score_l);
+ Global_translator::set_score (score_l);
}
int
Score_performer::get_tempo_i()const
{
- return score_l_->midi_p_->get_tempo_i(Moment(1, 4));
+ return score_l_->midi_p_->get_tempo_i (Moment (1, 4));
}
errorlevel_i_ = 0;
}
-Score::Score(Score const &s)
+Score::Score (Score const &s)
{
- assert(!pscore_p_);
+ assert (!pscore_p_);
music_p_ = s.music_p_->clone();
- midi_p_ = new Midi_def(*s.midi_p_);
- paper_p_ = new Paper_def(*s.paper_p_);
+ midi_p_ = new Midi_def (*s.midi_p_);
+ paper_p_ = new Paper_def (*s.paper_p_);
}
Score::~Score()
}
void
-Score::run_translator(Global_translator * trans_l)
+Score::run_translator (Global_translator * trans_l)
{
trans_l->set_score (this);
- Music_iterator * iter = Music_iterator::static_get_iterator_p(music_p_,
+ Music_iterator * iter = Music_iterator::static_get_iterator_p (music_p_,
trans_l);
iter->construct_children();
- if ( ! iter->ok() ) {
+ if ( ! iter->ok()) {
delete iter;
warning ("Need music in a score");
errorlevel_i_ =1;
trans_l->start();
- while ( iter->ok() || trans_l->moments_left_i() ) {
+ while ( iter->ok() || trans_l->moments_left_i ()) {
Moment w = infinity_mom;
- if (iter->ok() ) {
+ if (iter->ok()) {
w = iter->next_moment();
- mtor << w;
+ DOUT << w;
iter->print();
}
- trans_l->modify_next( w );
- trans_l->prepare(w);
+ trans_l->modify_next (w);
+ trans_l->prepare (w);
trans_l->print();
- iter->process_and_next( w );
+ iter->process_and_next (w);
trans_l->process();
}
delete iter;
void
Score::midi()
{
- if ( !midi_p_ )
+ if ( !midi_p_)
return;
*mlog << "\nCreating MIDI elements ..." << flush;
- audio_score_p_ = new Audio_score( this );
+ audio_score_p_ = new Audio_score (this);
Global_translator* score_trans= midi_p_->get_global_translator_p();
- run_translator( score_trans );
+ run_translator (score_trans);
delete score_trans;
- if( errorlevel_i_){
+ if (errorlevel_i_){
// should we? hampers debugging.
- warning( "Errors found, /*not processing score*/" );
+ warning ("Errors found, /*not processing score*/");
// return;
}
*mlog << endl;
return;
*mlog << "\nCreating elements ..." << flush;
- pscore_p_ = new Paper_score(paper_p_);
+ pscore_p_ = new Paper_score (paper_p_);
Global_translator * score_trans= paper_p_->get_global_translator_p();
- run_translator( score_trans );
+ run_translator (score_trans);
delete score_trans;
- if( errorlevel_i_) {
+ if (errorlevel_i_) {
// should we? hampers debugging.
- warning("Errors found, /*not processing score*/");
+ warning ("Errors found, /*not processing score*/");
// return;
}
void
Score::midi_output()
{
- if ( midi_p_->outfile_str_ == "" )
+ if ( midi_p_->outfile_str_ == "")
midi_p_->outfile_str_ = default_out_fn + ".midi";
- Midi_stream midi_stream( midi_p_->outfile_str_ );
+ Midi_stream midi_stream (midi_p_->outfile_str_);
*mlog << "MIDI output to " << midi_p_->outfile_str_ << " ..." << endl;
- audio_score_p_->output( midi_stream );
+ audio_score_p_->output (midi_stream);
*mlog << endl;
}
if (paper_p_->outfile_str_=="")
paper_p_->outfile_str_ = default_out_fn + ".tex";
- if ( errorlevel_i_ ) {
+ if ( errorlevel_i_) {
*mlog << "lilypond: warning: no output to: " << paper_p_->outfile_str_
<< " (errorlevel=" << errorlevel_i_ << ")" << endl;
return;
*mlog << "TeX output to " << paper_p_->outfile_str_ << " ...\n";
- Tex_stream the_output(paper_p_->outfile_str_);
+ Tex_stream the_output (paper_p_->outfile_str_);
the_output << "% outputting Score, defined at: " <<
location_str() << "\n";
- pscore_p_->output(the_output);
+ pscore_p_->output (the_output);
}
void
Score::print() const
{
#ifndef NPRINT
- mtor << "score {\n";
+ DOUT << "score {\n";
music_p_->print();
if (midi_p_)
midi_p_->print();
- mtor << "}\n";
+ DOUT << "}\n";
#endif
}
void
-Score::set(Paper_def *pap_p)
+Score::set (Paper_def *pap_p)
{
delete paper_p_;
paper_p_ = pap_p;
}
void
-Score::set(Midi_def* midi_p)
+Score::set (Midi_def* midi_p)
{
delete midi_p_;
midi_p_ = midi_p;
String
Line_of_score::TeX_string() const
{
- String s("\\hbox{%<- line of score\n");
+ String s ("\\hbox{%<- line of score\n");
if (error_mark_b_)
s+= "\\scorelineerrormark";
Link_array<Score_elem> elems;
if (col_l->error_mark_b_) {
- chunk_str += String("\\columnerrormark");
+ chunk_str += String ("\\columnerrormark");
}
// now output the items.
- for (iter_top(col_l->its,j); j.ok(); j++) {
- elems.push(j);
+ for (iter_top (col_l->its,j); j.ok(); j++) {
+ elems.push (j);
}
// spanners.
- for (iter_top(col_l->starters,j); j.ok(); j++) {
- if (j->name() != name())
- elems.push(j);
+ for (iter_top (col_l->starters,j); j.ok(); j++) {
+ if (j->name() != name ())
+ elems.push (j);
}
for (int j =0; j< elems.size(); j++) {
Offset o = elems[j]->absolute_offset();
o[X_AXIS] += cols[i]->hpos_f_;
- s += elems[j]->TeX_string_without_offset(o);
+ s += elems[j]->TeX_string_without_offset (o);
}
}
s += "}";
IMPLEMENT_IS_TYPE_B1(Line_of_score,Spanner);
void
-Line_of_score::add(Score_elem*e)
+Line_of_score::add (Score_elem*e)
{
// avoid excess dependencies.
- if(!( e->axis_group_l_a_[0] || e->axis_group_l_a_[1]))
- add_dependency(e);
+ if (!( e->axis_group_l_a_[0] || e->axis_group_l_a_[1]))
+ add_dependency (e);
}
bool
-Line_of_score::contains_b(PCol const* c)const
+Line_of_score::contains_b (PCol const* c)const
{
- return cols.find_l((PCol*)c);
+ return cols.find_l ((PCol*)c);
}
void
-Line_of_score::set_breaking(Array<Col_hpositions> const &breaking)
+Line_of_score::set_breaking (Array<Col_hpositions> const &breaking)
{
for (int j=0; j < breaking.size(); j++) {
- const Array<PCol*> &curline(breaking[j].cols);
- const Array<PCol*> &errors(breaking[j].error_col_l_arr_);
- const Array<Real> &config(breaking[j].config);
+ const Array<PCol*> &curline (breaking[j].cols);
+ const Array<PCol*> &errors (breaking[j].error_col_l_arr_);
+ const Array<Real> &config (breaking[j].config);
for (int i=0; i < errors.size(); i++)
errors[i]->error_mark_b_ = true;
Line_of_score *line_p =0;
if (breaking.size() >1) {
- line_p = (Line_of_score*)clone()->spanner();
- line_p->copy_dependencies( *this );
+ line_p = (Line_of_score*)clone()->spanner ();
+ line_p->copy_dependencies (*this);
line_l = line_p;
} else
line_l = this;
line_l->right_col_l_= curline.top();
if (line_p) {
- pscore_l_->typeset_broken_spanner(line_p);
- broken_into_l_arr_.push(line_p);
+ pscore_l_->typeset_broken_spanner (line_p);
+ broken_into_l_arr_.push (line_p);
}
for (int i=0; i < curline.size(); i++){
}
void
-Line_of_score::break_into_pieces(bool)
+Line_of_score::break_into_pieces (bool)
{
}
if (broken_into_l_arr_.size())
for (int i=0; i < broken_into_l_arr_.size(); i++) {
- ret.push((Line_of_score*)broken_into_l_arr_[i]);
+ ret.push ((Line_of_score*)broken_into_l_arr_[i]);
}
else
- ret.push((Line_of_score*)this); // ugh
+ ret.push ((Line_of_score*)this); // ugh
return ret;
}
}
if (is_p->errorlevel_i_) {
- is_p->warning("Score contains errors. Will not process it. ");
+ is_p->warning ("Score contains errors. Will not process it. ");
exit_status_i_ |= 1;
} else {
- is_p->print ();
+ is_p->print();
is_p->process();
}
delete is_p;
}
void
-add_score(Score * s)
+add_score (Score * s)
{
- score_array_global.push(s);
+ score_array_global.push (s);
}
void
-set_default_output(String s)
+set_default_output (String s)
{
default_out_fn = s;
}
void
-Script_column::add(Script*s_l)
+Script_column::add (Script*s_l)
{
- script_l_arr_.push(s_l);
- add_dependency(s_l);
- add_element(s_l);
+ script_l_arr_.push (s_l);
+ add_dependency (s_l);
+ add_element (s_l);
}
Script_column::do_print()const
{
#ifndef NPRINT
- mtor << "scripts: " << script_l_arr_.size() << '\n';
+ DOUT << "scripts: " << script_l_arr_.size() << '\n';
#endif
}
static int
-idx(bool inside, int dir)
+idx (bool inside, int dir)
{
int j = (dir+1);
- if ( !inside )
+ if ( !inside)
j ++;
return j;
}
Array<Script*> placed_l_arr_a[4];
for (int i=0; i < script_l_arr_.size(); i++) {
Script*s_l = script_l_arr_[i];
- placed_l_arr_a[idx( s_l->inside_staff_b_ , s_l->dir_i_) ].push(s_l);
+ placed_l_arr_a[idx (s_l->inside_staff_b_ , s_l->dir_i_) ].push (s_l);
}
for (int j =0; j <4; j++) {
- placed_l_arr_a[j].sort( Script::compare);
+ placed_l_arr_a[j].sort (Script::compare);
}
for (int j =0; j < 4; j++) {
if (placed_l_arr_a[j].size())
for (int i=0; i < support_l_arr_.size(); i++)
- placed_l_arr_a[j][0]->add_support( support_l_arr_[i]);
+ placed_l_arr_a[j][0]->add_support (support_l_arr_[i]);
}
Item * support_l=0;
int j = 0;
- for (; j < 2; j++ ) {
+ for (; j < 2; j++) {
for (int i=0; i < placed_l_arr_a[j].size(); i++) {
if (support_l)
- placed_l_arr_a[j][i]->add_support(support_l);
+ placed_l_arr_a[j][i]->add_support (support_l);
support_l = placed_l_arr_a[j][i];
}
}
support_l = 0;
- for (; j < 4; j++ ) {
+ for (; j < 4; j++) {
for (int i=0; i < placed_l_arr_a[j].size(); i++) {
if (support_l)
- placed_l_arr_a[j][i]->add_support(support_l);
+ placed_l_arr_a[j][i]->add_support (support_l);
support_l = placed_l_arr_a[j][i];
}
}
void
-Script_column::add_support(Item*i_l)
+Script_column::add_support (Item*i_l)
{
- support_l_arr_.push(i_l);
- add_dependency( i_l);
- add_element(i_l);
+ support_l_arr_.push (i_l);
+ add_dependency (i_l);
+ add_element (i_l);
}
void
-Script_column::do_substitute_dependency(Score_elem*o,Score_elem*n)
+Script_column::do_substitute_dependency (Score_elem*o,Score_elem*n)
{
if (o->item()) {
- script_l_arr_.substitute((Script*)o->item(),(Script*) (n?n->item():0));
- support_l_arr_.substitute(o->item(), (n?n->item():0));
+ script_l_arr_.substitute ((Script*)o->item(),(Script*) (n?n->item ():0));
+ support_l_arr_.substitute (o->item(), (n?n->item ():0));
}
}
}
void
-Script_def::set_from_input(String idx, bool follow, int stem, int staff ,bool invert, int priority_i)
+Script_def::set_from_input (String idx, bool follow, int stem, int staff ,bool invert, int priority_i)
{
inside_staff_b_ = follow;
symidx_str_ = idx ;
Script_def::do_print() const
{
#ifndef NPRINT
- mtor << "Script_def{ idx: " << symidx_str_
+ DOUT << "Script_def{ idx: " << symidx_str_
<< " direction, stem: " << rel_stem_dir_i_ << " staff : " << staff_dir_i_ << "}\n";
#endif
}
bool
-Script_def::do_equal_b(General_script_def const *g)const
+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_ &&
}
Atom
-Script_def::get_atom(Paper_def *p , int d)const
+Script_def::get_atom (Paper_def *p , int d)const
{
String preidx_str ="";
if (invertsym_b_&& d < 0)
preidx_str = "-";
- return p->lookup_l()->script(preidx_str + symidx_str_);
+ return p->lookup_l()->script (preidx_str + symidx_str_);
}
}
bool
-Script_engraver::do_try_request(Request *r_l)
+Script_engraver::do_try_request (Request *r_l)
{
- if (!r_l->musical() || ! r_l->musical()->musicalscript())
+ if (!r_l->musical() || ! r_l->musical ()->musicalscript ())
return false ;
for (int i=0; i < script_req_l_arr_.size(); i++) {
- if ( r_l->equal_b(script_req_l_arr_[i]))
+ if ( r_l->equal_b (script_req_l_arr_[i]))
return true;
}
- script_req_l_arr_.push( r_l->script());
+ script_req_l_arr_.push (r_l->script());
return true;
}
Script *p =new Script;
p->dir_i_ = l->dir_i_;
p->specs_l_ = l->scriptdef_p_;
- script_p_arr_.push(p);
- announce_element(Score_elem_info(p, l));
+ script_p_arr_.push (p);
+ announce_element (Score_elem_info (p, l));
}
}
Staff_symbol* s_l = get_staff_info().staff_sym_l_;
for (int i=0; i < script_p_arr_.size(); i++) {
Script*script_p = script_p_arr_[i];
- script_p->set_staffsym( s_l);
- typeset_element(script_p);
+ script_p->set_staffsym (s_l);
+ typeset_element (script_p);
}
script_p_arr_.clear();
}
}
void
-Script::do_substitute_dependency(Score_elem*o,Score_elem*n)
+Script::do_substitute_dependency (Score_elem*o,Score_elem*n)
{
- Staff_side::do_substitute_dependency(o,n);
+ Staff_side::do_substitute_dependency (o,n);
if (o == stem_l_) {
stem_l_ = n ? (Stem*)n->item() : 0;
}
}
void
-Script::set_stem(Stem*st_l)
+Script::set_stem (Stem*st_l)
{
stem_l_ = st_l;
- add_support(st_l);
+ add_support (st_l);
}
{
int s_i=specs_l_->rel_stem_dir_i();
if (s_i) {
- if(stem_l_)
+ if (stem_l_)
dir_i_ = stem_l_->dir_i_ * s_i;
else{
- specs_l_->warning("Script needs stem direction");
+ specs_l_->warning ("Script needs stem direction");
dir_i_ = -1;
}
} else {
dir_i_ =specs_l_->staff_dir_i();
}
- assert(dir_i_);
+ assert (dir_i_);
}
Interval
Script::do_width() const
{
- return specs_l_->get_atom(paper(), dir_i_).extent().x();
+ return specs_l_->get_atom (paper(), dir_i_).extent ().x ();
}
void
Interval
Script::symbol_height()const
{
- return specs_l_->get_atom(paper(), dir_i_).extent().y();
+ return specs_l_->get_atom (paper(), dir_i_).extent ().y ();
}
Molecule*
Script::brew_molecule_p() const
{
- Real dy = paper()->internote_f();
+ Real dy = paper()->internote_f ();
- Molecule*out = new Molecule(specs_l_->get_atom(paper(), dir_i_));
- out->translate(dy * pos_i_, Y_AXIS);
+ Molecule*out = new Molecule (specs_l_->get_atom (paper(), dir_i_));
+ out->translate (dy * pos_i_, Y_AXIS);
return out;
}
IMPLEMENT_IS_TYPE_B2(Script,Item,Staff_side);
int
-Script::compare(Script *const&l1, Script *const&l2)
+Script::compare (Script *const&l1, Script *const&l2)
{
- return l1->specs_l_->priority_i() - l2->specs_l_->priority_i();
+ return l1->specs_l_->priority_i() - l2->specs_l_->priority_i ();
}
#include "note-column.hh"
bool
-Slur_engraver::do_try_request(Request *req_l)
+Slur_engraver::do_try_request (Request *req_l)
{
Musical_req *mus_l = req_l->musical();
- if(!mus_l || !mus_l->slur())
+ if (!mus_l || !mus_l->slur())
return false;
- new_slur_req_l_arr_.push(mus_l->slur());
+ new_slur_req_l_arr_.push (mus_l->slur());
return true;
}
void
-Slur_engraver::acknowledge_element(Score_elem_info info)
+Slur_engraver::acknowledge_element (Score_elem_info info)
{
- if (info.elem_l_->name() == Note_column::static_name()) {
+ if (info.elem_l_->name() == Note_column::static_name ()) {
Note_column *col_l =(Note_column*) info.elem_l_->item() ;// ugh
for (int i = 0; i < slur_l_stack_.size(); i++)
- slur_l_stack_[i]->add(col_l );
+ slur_l_stack_[i]->add (col_l);
for (int i = 0; i < end_slur_l_arr_.size(); i++)
- end_slur_l_arr_[i]->add(col_l);
+ end_slur_l_arr_[i]->add (col_l);
}
}
void
-Slur_engraver::set_feature(Feature f)
+Slur_engraver::set_feature (Feature f)
{
if (f.type_ == "vdir")
dir_i_ = f.value_ ;
if (slur_req_l->spantype == Span_req::STOP) {
if (slur_l_stack_.empty())
- slur_req_l->warning("can't find slur to end");
+ slur_req_l->warning ("can't find slur to end");
else {
- end_slur_l_arr_.push(slur_l_stack_.pop());
+ end_slur_l_arr_.push (slur_l_stack_.pop());
requests_arr_.pop();
}
} else if (slur_req_l->spantype == Span_req::START) {
// push a new slur onto stack.
//(use temp. array to wait for all slur STOPs)
Slur * s_p =new Slur;
- requests_arr_.push(slur_req_l);
- start_slur_l_arr_.push(s_p);
- announce_element(Score_elem_info(s_p, slur_req_l));
+ requests_arr_.push (slur_req_l);
+ start_slur_l_arr_.push (s_p);
+ announce_element (Score_elem_info (s_p, slur_req_l));
}
}
for (int i=0; i < start_slur_l_arr_.size(); i++)
- slur_l_stack_.push(start_slur_l_arr_[i]);
+ slur_l_stack_.push (start_slur_l_arr_[i]);
}
void
for (int i = 0; i < end_slur_l_arr_.size(); i++) {
if (dir_i_)
end_slur_l_arr_[i]->dir_i_ = dir_i_;
- typeset_element(end_slur_l_arr_[i]);
+ typeset_element (end_slur_l_arr_[i]);
}
end_slur_l_arr_.clear();
}
Slur_engraver::~Slur_engraver()
{
for (int i=0; i < requests_arr_.size(); i++) {
- requests_arr_[i]->warning("unterminated slur");
+ requests_arr_[i]->warning ("unterminated slur");
}
}
void
-Slur::add(Note_column*n)
+Slur::add (Note_column*n)
{
- encompass_arr_.push(n);
- add_dependency(n);
+ encompass_arr_.push (n);
+ add_dependency (n);
}
void
void
-Slur::do_substitute_dependency(Score_elem*o, Score_elem*n)
+Slur::do_substitute_dependency (Score_elem*o, Score_elem*n)
{
int i;
- while((i = encompass_arr_.find_i((Note_column*)o->item())) >=0) {
+ while ((i = encompass_arr_.find_i ((Note_column*)o->item())) >=0) {
if (n)
encompass_arr_[i] = (Note_column*)n->item();
else
- encompass_arr_.del(i);
+ encompass_arr_.del (i);
}
}
static int
-Note_column_compare(Note_column *const&n1 , Note_column* const&n2)
+Note_column_compare (Note_column *const&n1 , Note_column* const&n2)
{
- return n1->pcol_l_->rank_i() - n2->pcol_l_->rank_i();
+ return n1->pcol_l_->rank_i() - n2->pcol_l_->rank_i ();
}
void
Slur::do_post_processing()
{
- encompass_arr_.sort(Note_column_compare);
+ encompass_arr_.sort (Note_column_compare);
if (!dir_i_)
set_default_dir();
- Real inter_f = paper()->internote_f();
+ Real inter_f = paper()->internote_f ();
if (encompass_arr_[0]->stem_l_)
- left_pos_i_ = rint(encompass_arr_[0]->stem_l_->height()[dir_i_]/inter_f);
+ left_pos_i_ = rint (encompass_arr_[0]->stem_l_->height()[dir_i_]/inter_f);
else
left_pos_i_ = rint ( encompass_arr_[0]->head_positions_interval()[dir_i_]);
if (encompass_arr_.top()->stem_l_)
- right_pos_i_ = rint(encompass_arr_.top()->stem_l_->height()[dir_i_]/inter_f);
+ right_pos_i_ = rint (encompass_arr_.top()->stem_l_->height ()[dir_i_]/inter_f);
else
- right_pos_i_ = rint (encompass_arr_.top()->head_positions_interval()[dir_i_]);
+ right_pos_i_ = rint (encompass_arr_.top()->head_positions_interval ()[dir_i_]);
left_pos_i_ += dir_i_;
right_pos_i_ += dir_i_;
}
void
-Span_bar_engraver::acknowledge_element(Score_elem_info i)
+Span_bar_engraver::acknowledge_element (Score_elem_info i)
{
int depth = i.origin_grav_l_arr_.size();
if ( depth > 1
- && i.elem_l_->is_type_b( Bar::static_name() ) )
+ && i.elem_l_->is_type_b (Bar::static_name()) )
{
- bar_l_arr_.push( (Bar*)i.elem_l_->item() );
+ bar_l_arr_.push ((Bar*)i.elem_l_->item());
if (bar_l_arr_.size() >= 2 && !spanbar_p_) {
spanbar_p_ = get_span_bar_p();
- announce_element( Score_elem_info(spanbar_p_,0) );
+ announce_element (Score_elem_info (spanbar_p_,0));
}
- } else if (i.elem_l_->is_type_b( Vertical_align_spanner::static_name() )
+ } else if (i.elem_l_->is_type_b (Vertical_align_spanner::static_name())
&& i.origin_grav_l_arr_.size() <= 2) {
valign_l_ = (Vertical_align_spanner*)i.elem_l_->spanner();
}
{
if (spanbar_p_) {
for (int i=0; i < bar_l_arr_.size() ; i++)
- spanbar_p_->add(bar_l_arr_[i]);
- spanbar_p_->set( valign_l_ );
- typeset_element(spanbar_p_);
+ spanbar_p_->add (bar_l_arr_[i]);
+ spanbar_p_->set (valign_l_);
+ typeset_element (spanbar_p_);
spanbar_p_ =0;
}
- bar_l_arr_.set_size( 0);
+ bar_l_arr_.set_size (0);
}
#include "vertical-align-elem.hh"
void
-Span_bar::add(Bar*b)
+Span_bar::add (Bar*b)
{
b->spanned_i_ ++;
- spanning_l_arr_.push(b);
- add_dependency( b );
+ spanning_l_arr_.push (b);
+ add_dependency (b);
}
void
-Span_bar::do_substitute_dependency(Score_elem*o, Score_elem*n)
+Span_bar::do_substitute_dependency (Score_elem*o, Score_elem*n)
{
Bar * bold = 0;
- if (o->is_type_b(Bar::static_name() ))
+ if (o->is_type_b (Bar::static_name()))
bold = (Bar*)o->item();
else
return;
bold->spanned_i_ --;
Bar * b =0;
- if (n && n->is_type_b(Bar::static_name() )) {
+ if (n && n->is_type_b (Bar::static_name())) {
b = (Bar*)n->item();
b->spanned_i_ ++;
}
- spanning_l_arr_.substitute( bold , b);
+ spanning_l_arr_.substitute (bold , b);
}
void
-Span_bar::set(Vertical_align_element *a)
+Span_bar::set (Vertical_align_element *a)
{
- add_dependency( a );
+ add_dependency (a);
}
Interval
Span_bar::do_width() const
{
- return paper()->lookup_l()->bar(type_str_, 40 PT).dim.x(); // ugh
+ return paper()->lookup_l ()->bar (type_str_, 40 PT).dim.x (); // ugh
}
void
Span_bar::do_pre_processing()
{
- if ( spanning_l_arr_.size () < 1) {
+ if ( spanning_l_arr_.size() < 1) {
transparent_b_ = true;
empty_b_ =true;
} else {
}
Symbol
-Span_bar::get_bar_sym(Real dy) const
+Span_bar::get_bar_sym (Real dy) const
{
- return paper()->lookup_l()->bar(type_str_, dy);
+ return paper()->lookup_l ()->bar (type_str_, dy);
}
Interval y_int;
for (int i=0; i < spanning_l_arr_.size(); i++) {
Axis_group_element *common =
- common_group(spanning_l_arr_[i], Y_AXIS);
+ common_group (spanning_l_arr_[i], Y_AXIS);
- Real y = spanning_l_arr_[i]->relative_coordinate(common, Y_AXIS)
- -relative_coordinate(common,Y_AXIS);
+ Real y = spanning_l_arr_[i]->relative_coordinate (common, Y_AXIS)
+ -relative_coordinate (common,Y_AXIS);
- y_int.unite( y + spanning_l_arr_[i]->height() );
+ y_int.unite (y + spanning_l_arr_[i]->height());
}
- Symbol s = get_bar_sym(y_int.length());
- Molecule*output = new Molecule(Atom(s));
- output->translate ( y_int[-1], Y_AXIS );
+ Symbol s = get_bar_sym (y_int.length());
+ Molecule*output = new Molecule (Atom (s));
+ output->translate ( y_int[-1], Y_AXIS);
return output;
}
Symbol
-Piano_brace::get_bar_sym(Real dy)const
+Piano_brace::get_bar_sym (Real dy)const
{
- return paper()->lookup_l()->vbrace(dy);
+ return paper()->lookup_l ()->vbrace (dy);
}
Interval
Piano_brace::do_width()const
{
- return Interval(0,0);
+ return Interval (0,0);
}
Spanner::do_print()const
{
#ifndef NPRINT
- mtor << "Between col ";
- if ( left_col_l_ )
- mtor << left_col_l_->rank_i();
+ DOUT << "Between col ";
+ if ( left_col_l_)
+ DOUT << left_col_l_->rank_i();
else
- mtor << "nop";
- mtor << ", ";
- if ( right_col_l_ )
- mtor << right_col_l_->rank_i();
+ DOUT << "nop";
+ DOUT << ", ";
+ if ( right_col_l_)
+ DOUT << right_col_l_->rank_i();
else
- mtor << "nop";
+ DOUT << "nop";
if (broken_into_l_arr_.size())
- mtor << "with broken pieces\n";
+ DOUT << "with broken pieces\n";
#endif
}
void
-Spanner::break_into_pieces(bool copy_deps_b)
+Spanner::break_into_pieces (bool copy_deps_b)
{
- if ( broken_into_l_arr_.size() )
+ if ( broken_into_l_arr_.size())
return;
PCol * left = left_col_l_;
PCol * right = right_col_l_;
- if(left->daddy_l_) left = left->daddy_l_;
- if(right->daddy_l_) right = right->daddy_l_;
+ if (left->daddy_l_) left = left->daddy_l_;
+ if (right->daddy_l_) right = right->daddy_l_;
- Link_array<PCol> break_cols = pscore_l_->broken_col_range(left,right);
+ Link_array<PCol> break_cols = pscore_l_->broken_col_range (left,right);
Link_array<Spanner> broken_into_l_arr;
- break_cols.insert(left,0);
- break_cols.push(right);
+ break_cols.insert (left,0);
+ break_cols.push (right);
for (int i=1; i < break_cols.size(); i++) {
- Spanner* span_p = clone()->spanner();
+ Spanner* span_p = clone()->spanner ();
if (copy_deps_b)
- span_p->copy_dependencies( *this );
+ span_p->copy_dependencies (*this);
left = break_cols[i-1];
right = break_cols[i];
if (!right->line_l_)
if (!left->line_l_)
left = left->postbreak_p_;
- assert(left&&right && left->line_l_ == right->line_l_);
+ assert (left&&right && left->line_l_ == right->line_l_);
span_p->left_col_l_ = left;
span_p->right_col_l_ = right;
- pscore_l_->typeset_broken_spanner(span_p);
- broken_into_l_arr.push( span_p );
+ pscore_l_->typeset_broken_spanner (span_p);
+ broken_into_l_arr.push (span_p);
}
broken_into_l_arr_ = broken_into_l_arr;
set_my_columns();
if (!line_l()) {
- break_into_pieces(true);
+ break_into_pieces (true);
for (int i=0; i < broken_into_l_arr_.size(); i++)
broken_into_l_arr_[i]->handle_broken_dependencies();
} else {
{
Real r = right_col_l_->hpos_f_;
Real l = left_col_l_->hpos_f_;
- assert(*left_col_l_ < *right_col_l_);
- assert(r>=l);
+ assert (*left_col_l_ < *right_col_l_);
+ assert (r>=l);
- return Interval(0, r-l);
+ return Interval (0, r-l);
}
Line_of_score *
Spanner*
-Spanner::find_broken_piece(Line_of_score*l)const
+Spanner::find_broken_piece (Line_of_score*l)const
{
for (int i=0; i < broken_into_l_arr_.size(); i++)
- if(broken_into_l_arr_[i]->line_l() == l)
+ if (broken_into_l_arr_[i]->line_l() == l)
return broken_into_l_arr_[i];
return 0;
Moment
Staff_info::when()
{
- return command_l()->when();
+ return command_l()->when ();
}
audio_staff_p_ = new Audio_staff;
// staff name
- play(new Audio_text( Audio_text::TRACK_NAME, instrument_str()));
+ play (new Audio_text (Audio_text::TRACK_NAME, instrument_str()));
// instrument description
- play(new Audio_text( Audio_text::INSTRUMENT_NAME, instrument_str()));
+ play (new Audio_text (Audio_text::INSTRUMENT_NAME, instrument_str()));
// tempo
- play(new Audio_tempo(get_tempo_i()));
+ play (new Audio_tempo (get_tempo_i()));
// instrument
- play(new Audio_instrument(instrument_str()));
+ play (new Audio_instrument (instrument_str()));
}
void
Staff_performer::do_removal_processing()
{
- Performer::play( audio_staff_p_ );
+ Performer::play (audio_staff_p_);
audio_staff_p_ = 0;
}
}
void
-Staff_performer::play( Audio_element* p )
+Staff_performer::play (Audio_element* p)
{
- if (p->is_type_b(Audio_item::static_name())) {
- audio_staff_p_->add((Audio_item*)p);
+ if (p->is_type_b (Audio_item::static_name())) {
+ audio_staff_p_->add ((Audio_item*)p);
}
- Performer::play(p);
+ Performer::play (p);
}
#include "debug.hh"
void
-Staff_side::set_staffsym(Staff_symbol* s_l)
+Staff_side::set_staffsym (Staff_symbol* s_l)
{
staff_sym_l_ = s_l;
- add_dependency( s_l );
+ add_dependency (s_l);
}
Staff_side::Staff_side()
{
pos_i_ =0;
- sym_int_ = Interval(0,0);
+ sym_int_ = Interval (0,0);
staff_size_i_ = 0;
staff_sym_l_=0;
dir_i_ =0;
Interval r;
for (int i=0; i < support_l_arr_.size(); i++)
- r.unite(support_l_arr_[i]->height());
+ r.unite (support_l_arr_[i]->height());
if (r.empty_b()) {
- r = Interval(0,0);
+ r = Interval (0,0);
}
return r;
}
void
-Staff_side::add_support(Score_elem*i)
+Staff_side::add_support (Score_elem*i)
{
- support_l_arr_.push(i);
- add_dependency(i);
+ support_l_arr_.push (i);
+ add_dependency (i);
}
int
Staff_side::get_position_i()const
{
if (!dir_i_) {
- warning("Staff_side::get_position_i(): "
+ warning ("Staff_side::get_position_i(): "
"somebody forgot to set my vertical direction, returning -20");
return -20;
}
Real y=0;
- Real inter_f = paper()-> internote_f();
+ Real inter_f = paper()-> internote_f ();
if (!inside_staff_b_) {
y = (dir_i_ > 0 && staff_sym_l_) ? staff_sym_l_->steps_i() + 2: -2;
y *=inter_f;
Interval v= support_height();
y = v[dir_i_] + 2*dir_i_*inter_f; // ugh
}
- return int(rint(Real(y)/inter_f)); // should ret a float?
+ return int (rint (Real (y)/inter_f)); // should ret a float?
}
Interval
Staff_side::symbol_height() const
{
- return Interval(0,0);
+ return Interval (0,0);
}
void
Staff_side::do_post_processing()
{
sym_int_ = symbol_height();
- pos_i_ = get_position_i( );
+ pos_i_ = get_position_i();
if (dir_i_)
- pos_i_ += int(rint(- sym_int_[-dir_i_] / paper()->internote_f()));
+ pos_i_ += int (rint (- sym_int_[-dir_i_] / paper()->internote_f ()));
}
void
-Staff_side::do_substitute_dependency(Score_elem*o, Score_elem*n)
+Staff_side::do_substitute_dependency (Score_elem*o, Score_elem*n)
{
- support_l_arr_.unordered_substitute(o,n);
+ support_l_arr_.unordered_substitute (o,n);
if (staff_sym_l_ == o)
staff_sym_l_ = n ? (Staff_symbol*) n->spanner():0;
}
-Staff_symbol::Staff_symbol(int l)
+Staff_symbol::Staff_symbol (int l)
{
no_lines_i_ = l;
}
{
#ifndef NPRINT
Spanner::do_print();
- mtor << "lines: " << no_lines_i_;
+ DOUT << "lines: " << no_lines_i_;
#endif
}
Molecule*
Staff_symbol::brew_molecule_p() const
{
- Atom a = paper()->lookup_l()->linestaff(no_lines_i_, width().length());
- return new Molecule(a);
+ Atom a = paper()->lookup_l ()->linestaff (no_lines_i_, width ().length ());
+ return new Molecule (a);
}
void
-Staff_symbol::set_extent(PCol*p1, PCol*p2)
+Staff_symbol::set_extent (PCol*p1, PCol*p2)
{
- assert(p1&&p2);
+ assert (p1&&p2);
left_col_l_ = p1;
right_col_l_ = p2;
}
Real
Staff_symbol::inter_note_f()const
{
- return paper()->internote_f();
+ return paper()->internote_f ();
}
int
}
bool
-Stem_beam_engraver::do_try_request(Request*req_l)
+Stem_beam_engraver::do_try_request (Request*req_l)
{
Musical_req* mus_l = req_l->musical();
/* Debiele puntkomma's. Laat je er eentje per ongeluk achter een
- if(..) staan, lijkt het net op een luis in gcc.
+ if (..) staan, lijkt het net op een luis in gcc.
(ofwel Python rules)
*/
return false;
- if ( mus_l->beam() ) {
- if (bool(beam_p_ ) == bool(mus_l->beam()->spantype == Span_req::START))
+ if ( mus_l->beam()) {
+ if (bool (beam_p_) == bool (mus_l->beam()->spantype == Span_req::START))
return false;
- if (beam_req_l_ && beam_req_l_ ->equal_b(mus_l))
+ if (beam_req_l_ && beam_req_l_ ->equal_b (mus_l))
return false;
beam_req_l_ = mus_l->beam();
return true;
}
- if ( mus_l->stem() ) {
- if (current_grouping && !current_grouping->child_fit_b(
+ if ( mus_l->stem()) {
+ if (current_grouping && !current_grouping->child_fit_b (
get_staff_info().time_C_->whole_in_measure_))
return false;
- if (stem_req_l_ && !stem_req_l_->equal_b( mus_l ) )
+ if (stem_req_l_ && !stem_req_l_->equal_b (mus_l) )
return false;
stem_req_l_ = mus_l->stem();
} else {
beam_p_ = new Beam;
start_req_l_ = beam_req_l_;
- beam_p_->left_col_l_ = get_staff_info().musical_pcol_l();
+ beam_p_->left_col_l_ = get_staff_info().musical_pcol_l ();
current_grouping = new Rhythmic_grouping;
if (beam_req_l_->nplet) {
Text_spanner* t = new Text_spanner();
Text_def *defp = new Text_def;
- t->set_support(beam_p_);
+ t->set_support (beam_p_);
defp->align_i_ = 0;
defp->text_str_ = beam_req_l_->nplet;
defp->style_str_="italic";
t->spec_p_ = defp;
- announce_element(Score_elem_info(t,0));
- typeset_element(t);
+ announce_element (Score_elem_info (t,0));
+ typeset_element (t);
}
- announce_element ( Score_elem_info(beam_p_, 0));
+ announce_element ( Score_elem_info (beam_p_, 0));
}
}
if (stem_req_l_) {
- stem_p_ = new Stem(8);
+ stem_p_ = new Stem (8);
if (current_grouping)
- current_grouping->add_child(
+ current_grouping->add_child (
get_staff_info().time_C_->whole_in_measure_,
stem_req_l_->duration());
if (beam_p_) {
if (stem_req_l_->duration_.type_i_<= 4)
- stem_req_l_->warning( "stem doesn't fit in Beam");
+ stem_req_l_->warning ("stem doesn't fit in Beam");
else
- beam_p_->add(stem_p_);
+ beam_p_->add (stem_p_);
stem_p_->print_flag_b_ = false;
} else {
stem_p_->print_flag_b_ = true;
}
- announce_element(Score_elem_info(stem_p_, stem_req_l_));
+ announce_element (Score_elem_info (stem_p_, stem_req_l_));
}
}
void
-Stem_beam_engraver::acknowledge_element(Score_elem_info info)
+Stem_beam_engraver::acknowledge_element (Score_elem_info info)
{
if (!stem_p_)
return;
- if (info.elem_l_->name() == Note_head::static_name() &&
+ if (info.elem_l_->name() == Note_head::static_name () &&
stem_req_l_->duration()
- == info.req_l_->musical()->rhythmic()->duration()){
+ == info.req_l_->musical()->rhythmic ()->duration ()){
Note_head * n_l= (Note_head*)info.elem_l_->item();
- stem_p_->add(n_l);
+ stem_p_->add (n_l);
}
}
void
if (default_dir_i_)
stem_p_->dir_i_ = default_dir_i_;
- typeset_element(stem_p_);
+ typeset_element (stem_p_);
stem_p_ = 0;
}
if (beam_p_ && end_beam_b_) {
Rhythmic_grouping const * rg_C = get_staff_info().rhythmic_C_;
- rg_C->extend(current_grouping->interval());
- beam_p_->set_grouping(*rg_C, *current_grouping);
- beam_p_->right_col_l_ = get_staff_info().musical_pcol_l();
- typeset_element(beam_p_);
+ rg_C->extend (current_grouping->interval());
+ beam_p_->set_grouping (*rg_C, *current_grouping);
+ beam_p_->right_col_l_ = get_staff_info().musical_pcol_l ();
+ typeset_element (beam_p_);
delete current_grouping;
current_grouping = 0;
beam_p_ = 0;
Stem_beam_engraver::~Stem_beam_engraver()
{
if (beam_p_)
- start_req_l_->warning("unterminated beam");
+ start_req_l_->warning ("unterminated beam");
}
void
-Stem_beam_engraver::set_feature(Feature i)
+Stem_beam_engraver::set_feature (Feature i)
{
if (i.type_ == "vdir")
default_dir_i_ = i.value_;
}
-Stem::Stem(int c)
+Stem::Stem (int c)
{
beams_left_i_ = 0;
beams_right_i_ = 0;
Stem::do_print() const
{
#ifndef NPRINT
- mtor << "flag "<< flag_i_ << " print_flag_b_ " << print_flag_b_;
+ DOUT << "flag "<< flag_i_ << " print_flag_b_ " << print_flag_b_;
#endif
}
void
-Stem::set_stemend(Real se)
+Stem::set_stemend (Real se)
{
// todo: margins
if (! ((dir_i_ > 0 && se >= max_head_i()) ||
- (se <= min_head_i() && dir_i_ <0)) )
- warning("Weird stem size; check for narrow beams");
+ (se <= min_head_i() && dir_i_ <0)) )
+ warning ("Weird stem size; check for narrow beams");
stem_top_f_ = (dir_i_ < 0) ? max_head_i() : se;
stem_bottom_f_ = (dir_i_ < 0) ? se : min_head_i();
}
void
-Stem::add(Note_head *n)
+Stem::add (Note_head *n)
{
- n->add_dependency(this);
+ n->add_dependency (this);
if (n->rest_b_) {
- rest_l_arr_.push(n);
+ rest_l_arr_.push (n);
} else if (n->balltype_i_ == 1) {
- whole_l_arr_.push(n);
+ whole_l_arr_.push (n);
return;
} else{
- head_l_arr_.push(n);
+ head_l_arr_.push (n);
}
}
// ugh... how about non 5-line staffs?
- if ((max_head_i() < -2 && dir_i_ == 1 )
- ||(min_head_i() > staff_size_i_ && dir_i_ == -1) ){
- set_stemend( staff_size_i_ /2 -1 );
+ if ((max_head_i() < -2 && dir_i_ == 1)
+ ||(min_head_i() > staff_size_i_ && dir_i_ == -1)){
+ set_stemend (staff_size_i_ /2 -1);
} else {
- set_stemend( (dir_i_ > 0) ? max_head_i() + STEMLEN :
+ set_stemend ((dir_i_ > 0) ? max_head_i() + STEMLEN :
min_head_i() - STEMLEN);
}
if (!stem_length_f())
set_default_stemlen();
- set_stemend((dir_i_< 0) ?
- max_head_i()-stem_length_f(): min_head_i() +stem_length_f());
+ set_stemend ((dir_i_< 0) ?
+ max_head_i()-stem_length_f (): min_head_i () +stem_length_f ());
if (dir_i_ > 0){
- stem_xoffset_f_ = paper()->note_width()-paper()->rule_thickness();
+ stem_xoffset_f_ = paper()->note_width ()-paper ()->rule_thickness ();
} else
stem_xoffset_f_ = 0;
}
void
Stem::set_noteheads()
{
- if(!head_l_arr_.size())
+ if (!head_l_arr_.size())
return;
- head_l_arr_.sort(Note_head::compare);
+ head_l_arr_.sort (Note_head::compare);
if (dir_i_ < 0)
head_l_arr_.reverse();
int parity=1;
int lastpos = head_l_arr_[0]->position_i_;
for (int i=1; i < head_l_arr_.size(); i ++) {
- int dy =abs(lastpos- head_l_arr_[i]->position_i_);
+ int dy =abs (lastpos- head_l_arr_[i]->position_i_);
if (dy <= 1) {
if (parity)
if (stem_bottom_f_== stem_top_f_)
set_default_extents();
set_noteheads();
- flag_i_ = dir_i_*abs(flag_i_);
+ flag_i_ = dir_i_*abs (flag_i_);
transparent_b_ = invisible_b();
empty_b_ = invisible_b();
}
Interval
Stem::do_width()const
{
- if (!print_flag_b_ || abs(flag_i_) <= 4)
- return Interval(0,0); // TODO!
+ if (!print_flag_b_ || abs (flag_i_) <= 4)
+ return Interval (0,0); // TODO!
Paper_def*p= paper();
- Interval r(p->lookup_l()->flag(flag_i_).dim.x());
+ Interval r (p->lookup_l()->flag (flag_i_).dim.x ());
r+= stem_xoffset_f_;
return r;
}
Real bot = stem_bottom_f_;
Real top = stem_top_f_;
- assert(bot!=top);
+ assert (bot!=top);
Paper_def *p =paper();
Real dy = p->internote_f();
- Symbol ss =p->lookup_l()->stem(bot*dy,top*dy);
+ Symbol ss =p->lookup_l()->stem (bot*dy,top*dy);
- out = new Molecule(Atom(ss));
+ out = new Molecule (Atom (ss));
- if (print_flag_b_&&abs(flag_i_) > 4){
- Symbol fl = p->lookup_l()->flag(flag_i_);
- Molecule m(fl);
+ if (print_flag_b_&&abs (flag_i_) > 4){
+ Symbol fl = p->lookup_l()->flag (flag_i_);
+ Molecule m (fl);
if (flag_i_ < -4){
- out->add_bottom(m);
+ out->add_bottom (m);
} else if (flag_i_ > 4) {
- out->add_top(m);
+ out->add_top (m);
} else
- assert(false);
+ assert (false);
}
- out->translate(stem_xoffset_f_, X_AXIS);
+ out->translate (stem_xoffset_f_, X_AXIS);
return out;
}
void
-Stem::do_substitute_dependency(Score_elem*o,Score_elem*n)
+Stem::do_substitute_dependency (Score_elem*o,Score_elem*n)
{
Item * o_l = o->item();
Item * n_l = n? n->item():0;
- whole_l_arr_.substitute((Note_head*)o_l, (Note_head*)n_l);
- head_l_arr_.substitute((Note_head*)o_l, (Note_head*)n_l);
- rest_l_arr_.substitute((Note_head*)o_l, (Note_head*)n_l);
+ whole_l_arr_.substitute ((Note_head*)o_l, (Note_head*)n_l);
+ head_l_arr_.substitute ((Note_head*)o_l, (Note_head*)n_l);
+ rest_l_arr_.substitute ((Note_head*)o_l, (Note_head*)n_l);
}
String s;
for (int i=0; i < lines_arr_.size(); i++){
s += lines_arr_[i]->TeX_string();
- if (i + 1<lines_arr_.size() )
+ if (i + 1<lines_arr_.size())
s += "\\interscoreline"; // TODO
}
return s;
{
lines_arr_ = line_of_score_l_->get_lines();
for (int i =0; i < lines_arr_.size(); i++)
- add_dependency(lines_arr_[i]);
+ add_dependency (lines_arr_[i]);
}
void
-Super_elem::do_substitute_dependency(Score_elem*o,Score_elem* n)
+Super_elem::do_substitute_dependency (Score_elem*o,Score_elem* n)
{
if (line_of_score_l_ == o->spanner())
line_of_score_l_ = n?(Line_of_score*)n->spanner():0;
void
Super_elem::do_add_processing()
{
- pscore_l_->typeset_unbroken_spanner( line_of_score_l_ );
- add_dependency(line_of_score_l_);
+ pscore_l_->typeset_unbroken_spanner (line_of_score_l_);
+ add_dependency (line_of_score_l_);
}
bool
-Swallow_engraver::do_try_request(Request*)
+Swallow_engraver::do_try_request (Request*)
{
return true;
}
Symbol::Symbol()
- : dim(Interval(0,0),Interval(0,0))
+ : dim (Interval (0,0),Interval (0,0))
{
tex = "\\unknown";
}
-Symbol::Symbol(String s, Box b)
- : dim(b)
+Symbol::Symbol (String s, Box b)
+ : dim (b)
{
tex = s;
}
String
Symbol::str()const
{
- return "symbol(\'"+tex+"\', (" + dim.x().str() + ", " + dim.y().str() + "))";
+ return "symbol (\'"+tex+"\', (" + dim.x().str () + ", " + dim.y ().str () + "))";
}
{
}
-Symtables::Symtables(Symtables const &s)
+Symtables::Symtables (Symtables const &s)
{
- for (Assoc_iter<String, Symtable*> i(s); i.ok(); i++) {
- add(i.key(), new Symtable(*i.val()));
+ for (Assoc_iter<String, Symtable*> i (s); i.ok(); i++) {
+ add (i.key(), new Symtable (*i.val ()));
}
}
Symtables::~Symtables()
{
- for (Assoc_iter<String, Symtable*> i(*this); i.ok(); i++) {
+ for (Assoc_iter<String, Symtable*> i (*this); i.ok(); i++) {
delete i.val();
}
}
Symbol
-Symtable::lookup(String s) const
+Symtable::lookup (String s) const
{
- if (elt_b(s))
+ if (elt_b (s))
return (*this)[s];
else {
- warning( "Symtable `" + id_str+ "\': unknown symbol `" +s+"'\n");
+ warning ("Symtable `" + id_str+ "\': unknown symbol `" +s+"'\n");
Symbol sy;
return sy;
}
void
Symtables::print() const
{
- for (Assoc_iter<String, Symtable*> i(*this); i.ok(); i++) {
- mtor << "table \'" << i.key() << "\' {\n";
- i.val()->print();
- mtor << "}\n";
+ for (Assoc_iter<String, Symtable*> i (*this); i.ok(); i++) {
+ DOUT << "table \'" << i.key() << "\' {\n";
+ i.val()->print ();
+ DOUT << "}\n";
}
}
void
Symtable::print() const
{
- for (Assoc_iter<String, Symbol> i(*this); i.ok(); i++) {
- mtor << "\'" << i.key() << "\'->" << i.val().str() << "\n";
+ for (Assoc_iter<String, Symbol> i (*this); i.ok(); i++) {
+ DOUT << "\'" << i.key() << "\'->" << i.val ().str () << "\n";
}
}
void
-Symtables::add(String s, Symtable*p)
+Symtables::add (String s, Symtable*p)
{
p-> id_str = s;
- Assoc<String, Symtable*>::add(s,p);
+ Assoc<String, Symtable*>::add (s,p);
}
#include "lookup.hh"
Symbol
-Lookup::beam_element(int sidx, int widx, Real slope) const
+Lookup::beam_element (int sidx, int widx, Real slope) const
{
- Symbol bs=(*symtables_)("beamslopes")->lookup("slope");
+ Symbol bs=(*symtables_)("beamslopes")->lookup ("slope");
Array<String> args;
- args.push(sidx);
- args.push(widx);
- bs.tex = substitute_args(bs.tex,args);
+ args.push (sidx);
+ args.push (widx);
+ bs.tex = substitute_args (bs.tex,args);
int w = 2 << widx;
Real width = w PT;
- bs.dim.x() = Interval(0,width);
- bs.dim.y() = Interval(0,width*slope);
+ bs.dim.x() = Interval (0,width);
+ bs.dim.y() = Interval (0,width*slope);
return bs;
}
// ugh.. hard wired tex-code.
static int
-slope_index(Real &s)
+slope_index (Real &s)
{
- if (abs(s) > 0.5) {
+ if (abs (s) > 0.5) {
WARN << "beam steeper than 0.5 (" << s << ")\n";
- s = sign(s) * 0.5;
+ s = sign (s) * 0.5;
}
- int i = int(rint(s * 20.0));
+ int i = int (rint (s * 20.0));
s = i/20.0;
if (s>0)
}
Symbol
-Lookup::rule_symbol(Real height, Real width) const
+Lookup::rule_symbol (Real height, Real width) const
{
- Symbol bs=(*symtables_)("beamslopes")->lookup("horizontal");
+ Symbol bs=(*symtables_)("beamslopes")->lookup ("horizontal");
Array<String> args;
- args.push(print_dimen(height));
- args.push(print_dimen(width));
- bs.tex = substitute_args(bs.tex,args);
- bs.dim.x() = Interval(0,width);
- bs.dim.y() = Interval(0,height);
+ args.push (print_dimen (height));
+ args.push (print_dimen (width));
+ bs.tex = substitute_args (bs.tex,args);
+ bs.dim.x() = Interval (0,width);
+ bs.dim.y() = Interval (0,height);
return bs;
}
Symbol
-Lookup::beam(Real &slope, Real width) const
+Lookup::beam (Real &slope, Real width) const
{
- int sidx = slope_index(slope);
+ int sidx = slope_index (slope);
if (!slope)
- return rule_symbol(2 PT, width);
+ return rule_symbol (2 PT, width);
if (width < 2 PT) {
- WARN<<"Beam too narrow. (" << print_dimen(width) <<")\n";
+ WARN<<"Beam too narrow. (" << print_dimen (width) <<")\n";
width = 2 PT;
}
Real elemwidth = 64 PT;
Real overlap = elemwidth/4;
Real last_x = width - elemwidth;
Real x = overlap;
- Atom elem(beam_element(sidx, widx, slope));
- Atom a(elem);
- m.add(a);
+ Atom elem (beam_element (sidx, widx, slope));
+ Atom a (elem);
+ m.add (a);
while (x < last_x) {
a=elem;
- a.translate(Offset(x-overlap, (x-overlap)*slope));
- m.add(a);
+ a.translate (Offset (x-overlap, (x-overlap)*slope));
+ m.add (a);
x += elemwidth - overlap;
}
a=elem;
- a.translate(Offset(last_x, (last_x) * slope));
- m.add(a);
+ a.translate (Offset (last_x, (last_x) * slope));
+ m.add (a);
Symbol ret;
ret.tex = m.TeX_string();
- ret.dim.y() = Interval(0,width*slope);
- ret.dim.x() = Interval(0,width);
+ ret.dim.y() = Interval (0,width*slope);
+ ret.dim.x() = Interval (0,width);
return ret;
}
static
-char direction_char(int y_sign)
+char direction_char (int y_sign)
{
char c='#';
- switch(y_sign){
+ switch (y_sign){
case -1:
c = 'd';
break;
c = 'u';
break;
default:
- assert(false);
+ assert (false);
}
return c;
}
Symbol
-Lookup::half_slur_middlepart(Real &dx, int dir) const
+Lookup::half_slur_middlepart (Real &dx, int dir) const
{
if (dx >= 400 PT) {// todo
- WARN<<"halfslur too large" <<print_dimen(dx)<< "shrinking (ugh)\n";
+ WARN<<"halfslur too large" <<print_dimen (dx)<< "shrinking (ugh)\n";
dx = 400 PT;
}
- int widx = int(floor(dx / 4.0));
+ int widx = int (floor (dx / 4.0));
dx = widx * 4.0;
if (widx) widx --;
else {
Symbol s;
- s.dim.y() = Interval(min(0,0), max(0,0)); // todo
- s.dim.x() = Interval(0,dx);
+ s.dim.y() = Interval (min (0,0), max (0,0)); // todo
+ s.dim.x() = Interval (0,dx);
- String f = String("\\hslurchar");
- f += direction_char(0);
+ String f = String ("\\hslurchar");
+ f += direction_char (0);
int idx = widx;
if (dir < 0)
assert (idx < 256);
- f+=String( "{" ) + String( idx ) + "}";
+ f+=String ("{") + String (idx ) + "}";
s.tex = f;
- Atom a(s);
- a.translate(dx/2, X_AXIS);
+ Atom a (s);
+ a.translate (dx/2, X_AXIS);
s.tex = a.TeX_string();
return s;
}
Symbol
-Lookup::half_slur(int dy, Real &dx, int dir, int xpart) const
+Lookup::half_slur (int dy, Real &dx, int dir, int xpart) const
{
Real orig_dx = dx;
if (!xpart)
- return half_slur_middlepart(dx, dir);
+ return half_slur_middlepart (dx, dir);
int widx;
if (dx >= 96 PT) {
- WARN << "Slur half too wide." << print_dimen(orig_dx) << " shrinking (ugh)\n";
+ WARN << "Slur half too wide." << print_dimen (orig_dx) << " shrinking (ugh)\n";
dx = 96 PT;
}
- widx = int(rint(dx/12.0));
+ widx = int (rint (dx/12.0));
dx = widx*12.0;
if (widx)
widx --;
else {
- WARN << "slur too narrow " << print_dimen(orig_dx)<<"\n";
+ WARN << "slur too narrow " << print_dimen (orig_dx)<<"\n";
}
Symbol s;
- s.dim.x() = Interval(0,dx);
- s.dim.y() = Interval(min(0,dy), max(0,dy));
+ s.dim.x() = Interval (0,dx);
+ s.dim.y() = Interval (min (0,dy), max (0,dy));
- String f = String("\\hslurchar");
+ String f = String ("\\hslurchar");
- f+= direction_char(dir);
+ f+= direction_char (dir);
int hidx = dy;
if (hidx <0)
idx += 128;
assert (idx < 256);
- f+=String( "{" ) + String( idx ) + "}";
+ f+=String ("{") + String (idx ) + "}";
s.tex = f;
Symbol
Lookup::slur (int dy , Real &dx, int dir) const
{
- assert(dx >=0 && abs(dir) <= 1);
- int y_sign = sign(dy);
+ assert (dx >=0 && abs (dir) <= 1);
+ int y_sign = sign (dy);
- bool large = abs(dy) > 8;
+ bool large = abs (dy) > 8;
if (y_sign) {
large |= dx>= 4*16 PT;
large |= dx>= 4*54 PT;
if (large) {
- return big_slur(dy, dx, dir);
+ return big_slur (dy, dx, dir);
}
Real orig_dx = dx;
- int widx = int(floor(dx/4.0)); // slurs better too small..
+ int widx = int (floor (dx/4.0)); // slurs better too small..
dx = 4.0 * widx;
if (widx)
widx --;
else {
- WARN << "slur too narrow: " << print_dimen(orig_dx) << "\n";
+ WARN << "slur too narrow: " << print_dimen (orig_dx) << "\n";
}
int hidx = dy;
}
Symbol s;
- s.dim.x() = Interval(0,dx);
- s.dim.y() = Interval(min(0,dy), max(0,dy));
+ s.dim.x() = Interval (0,dx);
+ s.dim.y() = Interval (min (0,dy), max (0,dy));
- String f = String("\\slurchar") + String( direction_char(y_sign) );
+ String f = String ("\\slurchar") + String (direction_char (y_sign));
int idx=-1;
if (y_sign) {
idx += 128;
} else {
if (dx >= 4*54 PT) {
- WARN << "slur too wide: " << print_dimen(dx) <<
+ WARN << "slur too wide: " << print_dimen (dx) <<
" shrinking (ugh)\n";
dx = 4*54 PT;
}
}
assert (idx < 256);
- f+=String( "{" ) + String( idx ) + "}";
+ f+=String ("{") + String (idx ) + "}";
s.tex = f;
- Atom a(s);
- a.translate(dx/2, X_AXIS);
+ Atom a (s);
+ a.translate (dx/2, X_AXIS);
s.dim = a.extent();
s.tex = a.TeX_string();
return s;
}
Symbol
-Lookup::big_slur(int dy , Real &dx, int dir) const
+Lookup::big_slur (int dy , Real &dx, int dir) const
{
- assert(dx >= 24 PT);
- Real slur_extra =abs(dy) /2.0 + 2;
- int l_dy = int(Real (dy)/2 + slur_extra*dir);
+ assert (dx >= 24 PT);
+ Real slur_extra =abs (dy) /2.0 + 2;
+ int l_dy = int (Real (dy)/2 + slur_extra*dir);
int r_dy = dy - l_dy;
Real internote_f = paper_l_->internote_f();
Real left_wid = dx/4.0;
Real right_wid = left_wid;
- Atom l = half_slur(l_dy, left_wid, dir, -1);
- Atom r = half_slur(r_dy, right_wid, dir, 1);
+ Atom l = half_slur (l_dy, left_wid, dir, -1);
+ Atom r = half_slur (r_dy, right_wid, dir, 1);
Real mid_wid = dx - left_wid - right_wid;
- Atom m = half_slur(0, mid_wid, dir, 0);
+ Atom m = half_slur (0, mid_wid, dir, 0);
Molecule mol;
- mol.add(l);
- Atom a(m);
- a.translate(slur_extra * internote_f, Y_AXIS);
- mol.add_right(m);
- mol.add_right(r);
- mol.translate( l_dy * internote_f, Y_AXIS);
+ mol.add (l);
+ Atom a (m);
+ a.translate (slur_extra * internote_f, Y_AXIS);
+ mol.add_right (m);
+ mol.add_right (r);
+ mol.translate (l_dy * internote_f, Y_AXIS);
Symbol s;
s.tex = mol.TeX_string();
s.dim = mol.extent();
make an abstract interface to output, operations:
- move(x,y), put(symbol).
+ move (x,y), put (symbol).
*/
#include <fstream.h>
const int MAXLINELEN = 200;
-Tex_stream::Tex_stream(String filename)
+Tex_stream::Tex_stream (String filename)
{
- os = new ofstream(filename);
+ os = new ofstream (filename);
if (!*os)
- error("can't open `" + filename+"\'");
+ error ("can't open `" + filename+"\'");
nest_level = 0;
line_len_i_ = 0;
outputting_comment=false;
{
*os << "% Creator: " << get_version_str() << "\n";
*os << "% Automatically generated, at ";
- time_t t(time(0));
- *os << ctime(&t)<<"\n";
+ time_t t (time (0));
+ *os << ctime (&t)<<"\n";
}
Tex_stream::~Tex_stream()
{
delete os;
- assert(nest_level == 0);
+ assert (nest_level == 0);
}
// print string. don't forget indent.
continue;
}
line_len_i_ ++;
- switch(*cp)
+ switch (*cp)
{
case '%':
outputting_comment = true;
if (nest_level < 0) {
delete os; // we want to see the remains.
- assert(nest_level>=0);
+ assert (nest_level>=0);
}
/* FALLTHROUGH */
Tex_stream::break_line()
{
*os << "%\n";
- *os << String(' ', nest_level);
+ *os << String (' ', nest_level);
line_len_i_ = 0;
}
#include "varray.hh"
String
-vstrut(Real h)
+vstrut (Real h)
{
- return String("\\vrule height ") + print_dimen(h) + "depth 0pt width 0pt";
+ return String ("\\vrule height ") + print_dimen (h) + "depth 0pt width 0pt";
}
static void
-substitute_arg(String& r, String arg)
+substitute_arg (String& r, String arg)
{
- int p = r.index_i('%');
+ int p = r.index_i ('%');
if (p < 0)
return ;
- r = r.left_str(p) + arg + r.right_str(r.length_i() - p -1);
+ r = r.left_str (p) + arg + r.right_str (r.length_i() - p -1);
}
String
-substitute_args(String source, Array<String> args)
+substitute_args (String source, Array<String> args)
{
String retval (source);
for (int i = 0 ; i < args.size(); i++)
- substitute_arg(retval, args[i]);
+ substitute_arg (retval, args[i]);
/*
- while (retval.index_i('%') >= 0)
- substitute_arg(retval, "");
+ while (retval.index_i ('%') >= 0)
+ substitute_arg (retval, "");
*/
return retval;
}
String
-substitute_args(String source, Array<Scalar> args)
+substitute_args (String source, Array<Scalar> args)
{
Array<String> sv;
for (int i = 0 ; i < args.size(); i++)
- sv.push(args[i]);
+ sv.push (args[i]);
- return substitute_args(source, sv);
+ return substitute_args (source, sv);
}
#include "dimen.hh"
Interval
-Text_def::width(Paper_def * p) const
+Text_def::width (Paper_def * p) const
{
- Atom a = get_atom(p,0);
+ Atom a = get_atom (p,0);
- Real guess_width_f = text_str_.length_i() * a.sym_.dim.x().length(); // ugh
- Interval i(0, guess_width_f);
+ Real guess_width_f = text_str_.length_i() * a.sym_.dim.x ().length (); // ugh
+ Interval i (0, guess_width_f);
i += - (align_i_ + 1)* i.center();
return i;
}
Text_def::do_print() const
{
#ifndef NPRINT
-
mtor << "align " <<align_i_ << " `" << text_str_ << "'";
+
DOUT << "align " <<align_i_ << " `" << text_str_ << "'";
#endif
}
}
bool
-Text_def::do_equal_b(General_script_def const *gdef) const
+Text_def::do_equal_b (General_script_def const *gdef) const
{
Text_def const *def= (Text_def*)gdef;
return align_i_ == def->align_i_ && text_str_ == def->text_str_
}
Atom
-Text_def::get_atom(Paper_def *p, int ) const
+Text_def::get_atom (Paper_def *p, int) const
{
- return p->lookup_l()->text(style_str_, text_str_, -align_i_);
+ return p->lookup_l()->text (style_str_, text_str_, -align_i_);
}
void
Text_def::print() const
{
- mtor << "Text `" << text_str_ << "\', style " <<
+ DOUT << "Text `" << text_str_ << "\', style " <<
style_str_ << "align " << align_i_ << '\n';
}
}
bool
-Text_engraver::do_try_request(Request*req_l)
+Text_engraver::do_try_request (Request*req_l)
{
Musical_req *m = req_l->musical();
if (!m || ! m->text())
return false;
- if (text_req_l_ && text_req_l_->equal_b(m))
+ if (text_req_l_ && text_req_l_->equal_b (m))
return false;
text_req_l_ = m->text();
return true;
}
void
-Text_engraver::acknowledge_element(Score_elem_info i)
+Text_engraver::acknowledge_element (Score_elem_info i)
{
- if (text_p_ && i.elem_l_->name() == Note_column::static_name()) {
- text_p_->add_support(i.elem_l_);
+ if (text_p_ && i.elem_l_->name() == Note_column::static_name ()) {
+ text_p_->add_support (i.elem_l_);
}
}
void
Text_engraver::do_process_requests()
{
if (text_req_l_) {
- text_p_ = new Text_item(text_req_l_->tdef_p_, text_req_l_->dir_i_); // ugh
- announce_element(Score_elem_info(text_p_, text_req_l_));
+ text_p_ = new Text_item (text_req_l_->tdef_p_, text_req_l_->dir_i_); // ugh
+ announce_element (Score_elem_info (text_p_, text_req_l_));
}
}
void
if (dir_i_ && !text_p_->dir_i_)
text_p_->dir_i_ = dir_i_;
Staff_symbol* s_l = get_staff_info().staff_sym_l_;
- text_p_->set_staffsym(s_l);
- typeset_element(text_p_);
+ text_p_->set_staffsym (s_l);
+ typeset_element (text_p_);
text_p_ = 0;
}
}
void
-Text_engraver::set_feature(Feature i)
+Text_engraver::set_feature (Feature i)
{
if (i.type_ == "vdir")
dir_i_ = i.value_;
#include "molecule.hh"
#include "lookup.hh"
-Text_item::Text_item(General_script_def*tdef_l, int d)
+Text_item::Text_item (General_script_def*tdef_l, int d)
{
dir_i_ = d;
fat_b_ = false;
Interval
Text_item::symbol_height()const
{
- return tdef_p_->get_atom(paper(), dir_i_).sym_.dim.y();
+ return tdef_p_->get_atom (paper(), dir_i_).sym_.dim.y ();
}
Molecule*
Text_item::brew_molecule_p() const
{
- Atom a(tdef_p_->get_atom(paper(), dir_i_));
+ Atom a (tdef_p_->get_atom (paper(), dir_i_));
/*
if ( fat_b_)
- a.sym.dim.x = tdef_p_->width(paper());
+ a.sym.dim.x = tdef_p_->width (paper());
*/
- Molecule* mol_p = new Molecule(a);
+ Molecule* mol_p = new Molecule (a);
- if(dir_i_<0 ) // should do something better anyway.
- mol_p->translate( -mol_p->extent().y().left , Y_AXIS);
- mol_p->translate( pos_i_ * paper()->internote_f(), Y_AXIS);
+ if (dir_i_<0) // should do something better anyway.
+ mol_p->translate (-mol_p->extent().y ().left , Y_AXIS);
+ mol_p->translate (pos_i_ * paper()->internote_f (), Y_AXIS);
return mol_p;
}
void
-Text_spanner::set_support(Directional_spanner*d)
+Text_spanner::set_support (Directional_spanner*d)
{
if (support_span_l_)
- remove_dependency(support_span_l_);
+ remove_dependency (support_span_l_);
support_span_l_ =d;
- add_dependency(d);
+ add_dependency (d);
}
Text_spanner::Text_spanner()
Text_spanner::do_post_processing()
{
text_off_ = support_span_l_->center() +
- Offset(0,support_span_l_->dir_i_ * paper()->internote_f() * 4); // todo
+ Offset (0,support_span_l_->dir_i_ * paper()->internote_f () * 4); // todo
}
Molecule*
Text_spanner::brew_molecule_p() const
{
- Atom tsym (spec_p_->get_atom(paper(),0));
- tsym.translate(text_off_);
+ Atom tsym (spec_p_->get_atom (paper(),0));
+ tsym.translate (text_off_);
Molecule*output = new Molecule;
- output->add( tsym );
+ output->add (tsym);
return output;
}
{
right_col_l_ = support_span_l_->right_col_l_;
left_col_l_ = support_span_l_->left_col_l_;
- assert(left_col_l_ && right_col_l_);
+ assert (left_col_l_ && right_col_l_);
}
Interval
Text_spanner::height()const
{
- return brew_molecule_p()->extent().y();
+ return brew_molecule_p()->extent ().y ();
}
void
-Text_spanner::do_substitute_dependency(Score_elem* o, Score_elem*n)
+Text_spanner::do_substitute_dependency (Score_elem* o, Score_elem*n)
{
if (support_span_l_ == o)
support_span_l_ = (Directional_spanner*) (n?n->spanner():0);
delete spec_p_;
}
-Text_spanner::Text_spanner(Text_spanner const&s)
- : Spanner( s)
+Text_spanner::Text_spanner (Text_spanner const&s)
+ : Spanner (s)
{
support_span_l_ = s.support_span_l_;
spec_p_ = s.spec_p_? s.spec_p_->clone() : 0;
void
Tie_engraver::sync_features()
{
- dir_i_ = get_feature("vdir");
+ dir_i_ = get_feature ("vdir");
}
void
Tie_engraver::do_post_move_processing()
{
- if (tie_p_ && get_staff_info().when() == end_mom_) {
+ if (tie_p_ && get_staff_info().when () == end_mom_) {
end_tie_p_ = tie_p_;
end_req_l_ = req_l_;
end_melodic_req_l_ = melodic_req_l_;
}
bool
-Tie_engraver::acceptable_request_b(Request*r)
+Tie_engraver::acceptable_request_b (Request*r)
{
- return r->musical() && r->musical()->tie();
+ return r->musical() && r->musical ()->tie ();
}
bool
-Tie_engraver::do_try_request(Request*r)
+Tie_engraver::do_try_request (Request*r)
{
- if(!acceptable_request_b(r))
+ if (!acceptable_request_b (r))
return false;
- if (req_l_ ) {
+ if (req_l_) {
return false;
}
- req_l_ = r->musical()->tie();
- end_mom_ = r->parent_music_l_->time_int().length()
- + get_staff_info().when();
+ req_l_ = r->musical()->tie ();
+ end_mom_ = r->parent_music_l_->time_int().length ()
+ + get_staff_info().when ();
return true;
}
}
void
-Tie_engraver::acknowledge_element(Score_elem_info i)
+Tie_engraver::acknowledge_element (Score_elem_info i)
{
- if (i.elem_l_->name() == Note_head::static_name()) {
+ if (i.elem_l_->name() == Note_head::static_name ()) {
if (tie_p_) {
- tie_p_->set_head(-1, (Note_head*)i.elem_l_->item());
- melodic_req_l_ = i.req_l_->musical()->melodic();
+ tie_p_->set_head (-1, (Note_head*)i.elem_l_->item());
+ melodic_req_l_ = i.req_l_->musical()->melodic ();
}
if (end_tie_p_) {
- end_tie_p_->set_head(1, (Note_head*)i.elem_l_->item());
+ end_tie_p_->set_head (1, (Note_head*)i.elem_l_->item());
if (!Melodic_req::compare ( *end_melodic_req_l_, *melodic_req_l_))
end_tie_p_->same_pitch_b_ = true;
- announce_element(Score_elem_info(end_tie_p_,end_req_l_));
+ announce_element (Score_elem_info (end_tie_p_,end_req_l_));
}
}
}
if (dir_i_)
end_tie_p_->dir_i_ = dir_i_;
- typeset_element(end_tie_p_);
+ typeset_element (end_tie_p_);
end_tie_p_ =0;
end_req_l_ =0;
}
Tie_engraver::~Tie_engraver()
{
if (tie_p_) {
- req_l_->warning("unended Tie");
+ req_l_->warning ("unended Tie");
delete tie_p_;
}
}
void
-Tie_engraver::set_feature(Feature f)
+Tie_engraver::set_feature (Feature f)
{
if (f.type_ == "vdir")
dir_i_ = f.value_;
void
-Tie::set_head(int x_pos, Note_head * head_l)
+Tie::set_head (int x_pos, Note_head * head_l)
{
if (x_pos >0) {
- assert(!right_head_l_);
+ assert (!right_head_l_);
right_head_l_ = head_l;
} else {
- assert(!left_head_l_);
+ assert (!left_head_l_);
left_head_l_ = head_l;
}
- add_dependency(head_l);
+ add_dependency (head_l);
}
Tie::Tie()
void
Tie::do_add_processing()
{
- assert(left_head_l_ && right_head_l_);
+ assert (left_head_l_ && right_head_l_);
left_col_l_ = left_head_l_ -> pcol_l_;
right_col_l_ = right_head_l_ -> pcol_l_;
}
void
Tie::do_post_processing()
{
- assert(left_head_l_ || right_head_l_);
+ assert (left_head_l_ || right_head_l_);
left_pos_i_ = (left_head_l_)?
left_head_l_->position_i_ : right_head_l_->position_i_;
right_pos_i_ = (right_head_l_) ?
void
-Tie::do_substitute_dependency(Score_elem*o, Score_elem*n)
+Tie::do_substitute_dependency (Score_elem*o, Score_elem*n)
{
Note_head *new_l =n?(Note_head*)n->item():0;
if (o->item() == left_head_l_)
String
Time_description::str()const
{
- String s( "Time_description { ");
+ String s ("Time_description { ");
if (cadenza_b_)
- s+=String( " (cadenza) ");
+ s+=String (" (cadenza) ");
s+= "at ";
s+=when_;
- s+="\nmeter " + String(whole_per_measure_/one_beat_) +":" +
- String(Rational(Rational(1)/one_beat_));
- s+= "\nposition "+String( bars_i_) + ":"+ whole_in_measure_ +"\n}\n";
+ s+="\nmeter " + String (whole_per_measure_/one_beat_) +":" +
+ String (Rational (Rational (1)/one_beat_));
+ s+= "\nposition "+String (bars_i_) + ":"+ whole_in_measure_ +"\n}\n";
return s;
}
Time_description::print() const
{
#ifndef NPRINT
- mtor << str();
+ DOUT << str();
#endif
}
void
{
#ifndef NDEBUG
if (!cadenza_b_)
- assert(whole_in_measure_ < whole_per_measure_);
- assert(Moment(0) <= whole_in_measure_);
- assert(one_beat_);
+ assert (whole_in_measure_ < whole_per_measure_);
+ assert (Moment (0) <= whole_in_measure_);
+ assert (one_beat_);
#endif
}
void
-Time_description::set_cadenza(bool b)
+Time_description::set_cadenza (bool b)
{
if (cadenza_b_ && !b) {
if (whole_in_measure_) {
error_b_ = false;
whole_per_measure_ = 1;
whole_in_measure_ =0;
- one_beat_ = Moment(1,4);
+ one_beat_ = Moment (1,4);
when_ = 0;
bars_i_ = 0;
cadenza_b_ = false;
}
void
-Time_description::add(Moment dt)
+Time_description::add (Moment dt)
{
- assert(dt >= Rational(0));
+ assert (dt >= Rational (0));
when_ += dt;
whole_in_measure_ += dt;
- while ( !cadenza_b_ && whole_in_measure_ >= whole_per_measure_ ) {
+ while ( !cadenza_b_ && whole_in_measure_ >= whole_per_measure_) {
whole_in_measure_ -= whole_per_measure_;
bars_i_ ++;
}
}
void
-Time_description::set_meter(int l, int o)
+Time_description::set_meter (int l, int o)
{
- assert(o);
- one_beat_ = Rational(1)/Moment(o);
- whole_per_measure_ = Moment(l) * one_beat_;
+ assert (o);
+ one_beat_ = Rational (1)/Moment (o);
+ whole_per_measure_ = Moment (l) * one_beat_;
}
bool
error messages if not possible, "" if possible
*/
String
-Time_description::try_set_partial_str(Moment p)const
+Time_description::try_set_partial_str (Moment p)const
{
- if (p<Rational(0))
+ if (p<Rational (0))
return ("Partial must be non-negative");
if (p > whole_per_measure_)
return ("Partial measure too large");
}
void
-Time_description::setpartial(Moment p)
+Time_description::setpartial (Moment p)
{
whole_in_measure_ = whole_per_measure_ - p;
}
Moment
Time_description::barleft()const
{
- assert(!cadenza_b_);
+ assert (!cadenza_b_);
return whole_per_measure_-whole_in_measure_;
}
int
-Time_description::compare(Time_description const &t1, Time_description const&t2)
+Time_description::compare (Time_description const &t1, Time_description const&t2)
{
- int i = sign(t1.when_-t2.when_);
+ int i = sign (t1.when_-t2.when_);
if (!i) {
- assert(t1.bars_i_==t2.bars_i_);
- assert(t1.one_beat_ == t2.one_beat_);
- assert(t1.whole_in_measure_ == t2.whole_in_measure_);
- assert(t1.whole_per_measure_ == t2.whole_per_measure_);
+ assert (t1.bars_i_==t2.bars_i_);
+ assert (t1.one_beat_ == t2.one_beat_);
+ assert (t1.whole_in_measure_ == t2.whole_in_measure_);
+ assert (t1.whole_per_measure_ == t2.whole_per_measure_);
}
return i;
Timing_engraver::Timing_engraver()
{
- default_grouping_ = Rhythmic_grouping(MInterval(0,4),4); // ugh
+ default_grouping_ = Rhythmic_grouping (MInterval (0,4),4); // ugh
}
void
-Timing_engraver::fill_staff_info(Staff_info &inf)
+Timing_engraver::fill_staff_info (Staff_info &inf)
{
inf.time_C_ = &time_;
inf.rhythmic_C_ = &default_grouping_;
IMPLEMENT_IS_TYPE_B(Translator);
bool
-Translator::try_request(Request*)
+Translator::try_request (Request*)
{
return false;
}
#include "interval.hh"
void
-Vertical_align_element::add(Score_elem*el_l)
+Vertical_align_element::add (Score_elem*el_l)
{
- assert( ! contains_b(el_l));
- elem_l_arr_.push(el_l);
- add_dependency(el_l);
+ assert (! contains_b (el_l));
+ elem_l_arr_.push (el_l);
+ add_dependency (el_l);
}
void
-Vertical_align_element::do_substitute_dependency(Score_elem*o,Score_elem*n)
+Vertical_align_element::do_substitute_dependency (Score_elem*o,Score_elem*n)
{
int i;
- while((i = elem_l_arr_.find_i(o))>=0)
+ while ((i = elem_l_arr_.find_i (o))>=0)
if (n)
elem_l_arr_[i] = n;
else
- elem_l_arr_.del(i);
+ elem_l_arr_.del (i);
}
/**
Vertical_align_element::do_post_processing()
{
Array<Interval> dims;
- for (int i=0; i < elem_l_arr_.size(); i++ ) {
+ for (int i=0; i < elem_l_arr_.size(); i++) {
Interval y = elem_l_arr_[i]->height() ;
if (y.empty_b())
- y = Interval(0,0);
+ y = Interval (0,0);
- dims.push(y);
+ dims.push (y);
}
Real where_f=0;
for ( int i=0 ; i < elem_l_arr_.size(); i++) {
- elem_l_arr_[i]->translate( - dims[i][1] - where_f, Y_AXIS);
+ elem_l_arr_[i]->translate (- dims[i][1] - where_f, Y_AXIS);
where_f += dims[i].length();
}
}
bool
-Vertical_align_element::contains_b(Score_elem const *e)const
+Vertical_align_element::contains_b (Score_elem const *e)const
{
- return elem_l_arr_.find_l(e);
+ return elem_l_arr_.find_l (e);
}
Vertical_align_element::Vertical_align_element()
Vertical_align_engraver::do_creation_processing()
{
valign_p_ =new Vertical_align_spanner;
- valign_p_->left_col_l_ = get_staff_info().command_pcol_l() ;
- announce_element( Score_elem_info( valign_p_ , 0 ));
+ valign_p_->left_col_l_ = get_staff_info().command_pcol_l () ;
+ announce_element (Score_elem_info (valign_p_ , 0));
}
void
Vertical_align_engraver::do_removal_processing()
{
- valign_p_->right_col_l_ = get_staff_info().command_pcol_l();
- typeset_element( valign_p_);
+ valign_p_->right_col_l_ = get_staff_info().command_pcol_l ();
+ typeset_element (valign_p_);
valign_p_ =0;
}
void
-Vertical_align_engraver::acknowledge_element(Score_elem_info i)
+Vertical_align_engraver::acknowledge_element (Score_elem_info i)
{
if ( i.origin_grav_l_arr_.size() == 2 &&
- i.elem_l_->is_type_b(Vertical_group_element::static_name()) &&
- !i.elem_l_->axis_group_l_a_[Y_AXIS] ) {
- assert( !valign_p_->contains_b( i.elem_l_) );
+ i.elem_l_->is_type_b (Vertical_group_element::static_name()) &&
+ !i.elem_l_->axis_group_l_a_[Y_AXIS] ) {
+ assert (!valign_p_->contains_b (i.elem_l_));
- valign_p_->add ( i.elem_l_ );
+ valign_p_->add ( i.elem_l_);
}
}
}
bool
-Voice_group_engravers::do_try_request(Request*r_l)
+Voice_group_engravers::do_try_request (Request*r_l)
{
Command_req* c_l = r_l->command();
if (c_l&& c_l->groupfeature()) {
Feature f;
f.type_ = c_l->groupfeature()->type_str_;
f.value_ = c_l->groupfeature()->value_str_;
- set_feature(f);
+ set_feature (f);
return true;
}
- return Engraver_group_engraver::do_try_request(r_l);
+ return Engraver_group_engraver::do_try_request (r_l);
}
Scalar
-Voice_group_engravers::get_feature(String f)
+Voice_group_engravers::get_feature (String f)
{
if (f == "vdir")
return dir_i_;
- Engraver_group_engraver::get_feature(f);
+ Engraver_group_engraver::get_feature (f);
}
ADD_THIS_ENGRAVER(Voice_group_engravers);
#include "input.hh"
ostream &warnout (cerr);
-ostream *mlog(&cerr);
+ostream *mlog (&cerr);
void
-error_t(String const & s, Moment const & r)
+error_t (String const & s, Moment const & r)
{
- String t_mom = String(trunc(r)) + String(r - Moment(trunc(r)));
+ String t_mom = String (trunc (r)) + String (r - Moment (trunc (r)));
String e=s+ " (t = " + t_mom + ")";
- error(e);
+ error (e);
}
void
-error_t(String const & s, Time_description const &t_tdes)
+error_t (String const & s, Time_description const &t_tdes)
{
- String e=s+ " (at t=" + String(t_tdes.bars_i_) + ": " + String(t_tdes.whole_in_measure_) + ")\n";
- error(e);
+ String e=s+ " (at t=" + String (t_tdes.bars_i_) + ": " + String (t_tdes.whole_in_measure_) + ")\n";
+ error (e);
}
{
problem_OK();
- PCursor<PCol*> curcol(pscore_l_->col_p_list_.top());
+ PCursor<PCol*> curcol (pscore_l_->col_p_list_.top());
Array<Col_hpositions> breaking;
- Line_of_cols breakpoints(find_breaks());
- assert(breakpoints.size()>=2);
+ Line_of_cols breakpoints (find_breaks());
+ assert (breakpoints.size()>=2);
int break_idx_i=0;
while ( break_idx_i < breakpoints.size() -1) {
// do another line
PCol *post = breakpoints[break_idx_i]->postbreak_p_;
- current.add( post);
+ current.add (post);
curcol++; // skip the breakable.
break_idx_i++;
// add another measure.
while (breakpoints[break_idx_i] != curcol.ptr()){
- current.add(curcol);
+ current.add (curcol);
curcol++;
}
- current.add(breakpoints[break_idx_i]->prebreak_p_ );
+ current.add (breakpoints[break_idx_i]->prebreak_p_);
- current.spacer_l_ = generate_spacing_problem( current.cols );
+ current.spacer_l_ = generate_spacing_problem (current.cols);
// try to solve
- if (!feasible(current.cols)) {
+ if (!feasible (current.cols)) {
if (!minimum.cols.size()) {
- warning("Ugh, this measure is too long, breakpoint: "
- + String(break_idx_i) +
+ warning ("Ugh, this measure is too long, breakpoint: "
+ + String (break_idx_i) +
" (generating stupido solution)");
current.stupid_solution();
current.energy_f_ = - 1; // make sure we break out.
}
*mlog << "[" <<break_idx_i<<"]"<<flush;
- breaking.push(minimum);
+ breaking.push (minimum);
}
print_stats();
return breaking;
projects / lilypond.git / commitdiff