/*
- p-score.cc -- implement PScore
+ p-score.cc -- implement Paper_score
source file of the GNU LilyPond music typesetter
- (c) 1996, 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+ (c) 1996, 1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "super-elem.hh"
-#include "idealspacing.hh"
+#include "main.hh"
#include "debug.hh"
#include "lookup.hh"
#include "spanner.hh"
#include "paper-def.hh"
-#include "scoreline.hh"
+#include "line-of-score.hh"
+#include "p-col.hh"
#include "p-score.hh"
-#include "tex-stream.hh"
-#include "break.hh"
#include "p-col.hh"
-
-void
-PScore::typeset_element(Score_elem * elem_p)
+#include "scope.hh"
+#include "word-wrap.hh"
+#include "gourlay-breaking.hh"
+#include "paper-stream.hh"
+#include "paper-outputter.hh"
+#include "file-results.hh"
+#include "misc.hh"
+
+Paper_score::Paper_score ()
{
- elem_p_list_.bottom().add(elem_p);
- elem_p->pscore_l_ = this;
+ outputter_l_ =0;
+ Line_of_score * line_p = new Line_of_score;
+ typeset_unbroken_spanner (line_p);
- elem_p->add_processing();
+ line_l_ = line_p;
}
-void
-PScore::typeset_item(Item *i, PCol *c, int breakstat)
+Paper_score::Paper_score (Paper_score const &s)
+ : Music_output (s)
{
- assert(c && i);
-
- if (breakstat == -1) {
- typeset_item(i, c->prebreak_p_);
- return;
- }
-
- if (breakstat == 1) {
- typeset_item(i, c->postbreak_p_);
- return;
- }
-
- c->add(i);
- typeset_element(i);
+ assert (false);
}
-void
-PScore::typeset_broken_spanner(Spanner*span_p)
+Paper_score::~Paper_score ()
{
- span_p->left_col_l_->starters.bottom().add (span_p);
- span_p->right_col_l_->stoppers.bottom().add(span_p);
- assert(span_p->left_col_l_->line_l_ == span_p->right_col_l_->line_l_);
-
- typeset_element(span_p);
+ for (int i=0; i < span_p_arr_.size (); i++)
+ delete span_p_arr_[i];
+ for (int i=0; i < elem_p_arr_.size (); i++)
+ delete elem_p_arr_[i];
}
-
void
-PScore::typeset_unbroken_spanner(Spanner*span_p)
-{
- spanners.bottom().add(span_p);
- span_p->pscore_l_=this;
-
- if ( span_p->left_col_l_)
- span_p->left_col_l_->used_b_ = true;
- if ( span_p->right_col_l_)
- span_p->right_col_l_->used_b_ = true;
-
- // do not init start/stop fields. These are for broken spans only.
- span_p->add_processing();
-}
-
-Idealspacing*
-PScore::get_spacing(PCol*l, PCol*r)
+Paper_score::typeset_element (Score_element * elem_p)
{
- assert(l!=r);
-
- Idealspacing*i_p =new Idealspacing(l,r);
- suz.bottom().add(i_p);
-
- return i_p;
+ elem_p_arr_.push (elem_p);
+ elem_p->pscore_l_ = this;
+ elem_p->add_processing ();
}
void
-PScore::clean_cols()
+Paper_score::typeset_unbroken_spanner (Spanner*span_p)
{
- int rank_i = 0;
- for (iter_top(cols,c); c.ok(); )
- if (!c->used_b()) {
- delete c.remove_p();
- } else {
- c->set_rank(rank_i++);
- c++;
- }
+ span_p_arr_.push (span_p);
+ span_p->pscore_l_=this;
+ span_p->add_processing ();
}
void
-PScore::do_connect(PCol *c1, PCol *c2, Real d, Real h)
+Paper_score::add_column (Paper_column *p)
{
- if (!c1 || !c2 )
- return;
- Idealspacing*s_l=get_spacing(c1,c2);
-
-
- s_l->hooke = h;
- s_l->space =d;
+ p->set_rank (col_l_arr_.size ());
+ col_l_arr_.push (p);
+ typeset_element(p);
}
-void
-PScore::connect(PCol* c1, PCol *c2, Real d, Real h)
-{
- do_connect(c1,c2,d,h);
- do_connect(c1->postbreak_p_, c2,d,h);
- do_connect(c1, c2->prebreak_p_,d,h);
- do_connect(c1->postbreak_p_, c2->prebreak_p_,d,h);
-}
+
void
-PScore::add(PCol *p)
+Paper_score::print () const
{
- p->pscore_l_ = this;
- if (p->breakable_b()){
- p->prebreak_p_->pscore_l_ = this;
- p->postbreak_p_->pscore_l_ = this;
- }
- cols.bottom().add(p);
+#ifndef NPRINT
+ if (!check_debug)
+ return ;
+ DOUT << "Paper_score { ";
+ DOUT << "\n elements: ";
+ for (int i=0; i < span_p_arr_.size (); i++)
+ span_p_arr_[i]->print ();
+ for (int i=0; i < elem_p_arr_.size (); i++)
+ elem_p_arr_[i]->print();
+
+ DOUT << "}\n";
+#endif
}
-PScore::PScore(Paper_def*p)
+int
+Paper_score::find_col_idx (Paper_column const *c) const
{
- paper_l_ = p;
- super_elem_l_ = new Super_elem;
- typeset_element(super_elem_l_);
+ Paper_column const *what = c;
+
+ return col_l_arr_.find_i ((Paper_column*)what);
}
-void
-PScore::output(Tex_stream &ts)
+Array<Column_x_positions>
+Paper_score::calc_breaking ()
{
- ts << "\n "<< paper_l_->lookup_l()->texsetting << "%(Tex id)\n";
- ts<< super_elem_l_->TeX_string();
- ts << "\n\\EndLilyPondOutput";
+ Break_algorithm *algorithm_p=0;
+ Array<Column_x_positions> sol;
+ bool try_wrap = !paper_l_->get_var ("castingalgorithm");
+
+ if (!try_wrap)
+ {
+ algorithm_p = new Gourlay_breaking ;
+ algorithm_p->set_pscore (this);
+ sol = algorithm_p->solve ();
+ delete algorithm_p;
+ if (! sol.size ())
+ {
+ warning (_ ("Can't 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);
+ sol = algorithm_p->solve ();
+ delete algorithm_p;
+ }
+ return sol;
}
-PScore::~PScore()
-{
- super_elem_l_->unlink_all();
-}
-void
-PScore::OK()const
+void delete_array_contents (Link_array<Score_element> const&to_remove, Dictionary<int> &type_stats)
{
-#ifndef NDEBUG
- for (iter_top(cols,cc); cc.ok(); cc++)
- cc->OK();
- for (iter_top(suz,i); i.ok(); i++)
- i->OK();
-#endif
-}
+ for (int i=0; i < to_remove.size (); i++)
+ {
+ Score_element * e = to_remove[i];
+ String nm = e->name();
+ if (type_stats.elem_b (nm))
+ type_stats[nm] ++;
+ else
+ type_stats[nm] = 1;
+
+ if (dynamic_cast<Item*> (e))
+ type_stats["Item"] ++;
+ else if (dynamic_cast<Spanner*>(e))
+ type_stats["Spanner"] ++;
+ type_stats["Total"] ++;
+
+ e->unlink ();
+ assert (!e->linked_b ());
+ delete e;
+ }
-void
-PScore::print() const
-{
-#ifndef NPRINT
- mtor << "PScore { ";
- paper_l_->print();
- mtor << "\n elements: ";
- for (iter_top(elem_p_list_,cc); cc.ok(); cc++)
- cc->print();
- mtor << "\n unbroken spanners: ";
- for (iter(spanners.top(), i); i.ok(); i++)
- i->print();
- mtor << "\ncolumns: ";
- for (iter_top(cols,cc); cc.ok(); cc++)
- cc->print();
-
- mtor << "\nideals: ";
- for (iter_top(suz,i); i.ok(); i++)
- i->print();
- mtor << "}\n";
-#endif
}
-
-void
-PScore::preprocess()
+Link_array<Score_element>
+Paper_score::remove_break_helpers ()
{
- super_elem_l_->breakable_col_processing();
- super_elem_l_->pre_processing();
-}
+ Link_array<Score_element> to_remove;
+ Link_array<Score_element> keep;
+ for (int i=0; i < elem_p_arr_.size (); i++)
+ {
+ Score_element*e = elem_p_arr_[i];
+ if (e->break_helper_only_b_)
+ to_remove.push (e);
+ else
+ keep.push (e);
+ }
-void
-PScore::postprocess()
-{
- super_elem_l_->post_processing();
- super_elem_l_->molecule_processing();
-}
+ elem_p_arr_ = keep;
+ Link_array<Spanner> keeps;
+ for (int i=0; i<span_p_arr_.size ();i++)
+ {
+ Spanner *s = span_p_arr_[i];
+ Score_element *e = s;
+ if (e->break_helper_only_b_)
+ to_remove.push (e);
+ else
+ keeps.push (s);
+ }
-PCursor<PCol *>
-PScore::find_col(PCol const *c)const
-{
- PCol const *what = c;
- if (what->daddy_l_ )
- what = what->daddy_l_;
-
- return cols.find((PCol*)what);
-}
+ span_p_arr_ =keeps;
+
+ return to_remove;
+}
void
-PScore::set_breaking(Array<Col_hpositions> const &breaking)
+Paper_score::process ()
{
- super_elem_l_->line_of_score_l_->set_breaking( breaking);
- super_elem_l_->break_processing();
+ Dictionary<int> type_stats;
+ type_stats["Item"] =0;
+ type_stats["Spanner"] =0;
+ type_stats["Total"]=0;
+
+ print ();
+ *mlog << _ ("Preprocessing elements...") << " " << flush;
+ line_l_->breakable_col_processing ();
+ line_l_->pre_processing ();
+
+ *mlog << '\n' << _ ("Calculating column positions...") << " " << flush;
+ line_l_->space_processing ();
+ Array<Column_x_positions> breaking = calc_breaking ();
- for (iter(spanners.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);
- }
- }
- 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();
- delete i.remove_p();
- } else
- i++;
+ delete_array_contents (remove_break_helpers(), type_stats);
+
+ Paper_stream* paper_stream_p = paper_l_->paper_stream_p ();
+ outputter_l_ = paper_l_->paper_outputter_p (paper_stream_p, header_l_, origin_str_);
+
+ Link_array<Line_of_score> lines;
+ for (int i=0; i < breaking.size (); i++)
+ {
+ Line_of_score *line_l = line_l_->set_breaking (breaking, i);
+ lines.push (line_l);
+ if (line_l != line_l_)
+ typeset_element (line_l);
}
- for (iter_top(cols, i); i.ok(); i++)
- i->clean_breakable_items();
+ if (experimental_features_global_b)
+ *mlog << elem_p_arr_.size () + span_p_arr_.size () << " elements. ";
+ *mlog << "\nLine ... ";
+ for (int i=0; i < lines.size (); i++)
+ {
+ *mlog << '[' << flush;
+
+ Line_of_score *line_l = lines[i];
+ line_l->break_processing ();
+ line_l->post_processing ();
+ *mlog << i << flush;
+ line_l->output_all ();
+
+ if (experimental_features_global_b)
+ *mlog << '(' << elem_p_arr_.size () + span_p_arr_.size () << ')';
+
+ *mlog << ']' << flush;
+ Link_array<Score_element> to_remove (remove_line (line_l));
+
+ delete_array_contents (to_remove, type_stats);
+ }
+
+ // huh?
+ delete outputter_l_;
+ delete paper_stream_p;
+ outputter_l_ = 0;
+
+
+ /*
+ todo: sort output
+ */
+ if (experimental_features_global_b)
+ {
+ for (Dictionary_iter<int> i(type_stats); i.ok(); i++)
+ {
+ *mlog << i.key () << ": " << i.val () << " objects\n";
+ }
+ }
+ *mlog << '\n' << flush;
+
}
-void
-PScore::calc_breaking()
-{
- Word_wrap w(*this);
- set_breaking(w.solve());
-}
-void
-PScore::process()
+Link_array<Score_element>
+Paper_score::remove_line (Line_of_score *l)
{
- clean_cols();
- print();
- *mlog << "Preprocessing elements... " <<flush;
- preprocess();
- *mlog << "\nCalculating column positions ... " <<flush;
- calc_breaking();
- *mlog << "\nPostprocessing elements..." << endl;
- postprocess();
-}
+ Link_array<Score_element> to_remove;
+ Link_array<Score_element> keep;
+ for (int i=0; i < elem_p_arr_.size (); i++)
+ {
+ Score_element*e = elem_p_arr_[i];
+ if (e->line_l () == l)
+ to_remove.push (e);
+ else
+ keep.push (e);
+ }
-/** Get all breakable columns between l and r, (not counting l and r). */
-Link_array<PCol>
-PScore::breakable_col_range(PCol*l,PCol*r)const
-{
- Link_array<PCol> ret;
-
- PCursor<PCol*> start(l ? find_col(l)+1 : cols.top() );
- PCursor<PCol*> stop(r ? find_col(r) : cols.bottom());
-
- /*
- ugh! windows-suck-suck-suck.
- */
- while ( PCursor<PCol*>::compare(start,stop) < 0 ) {
- if (start->breakable_b())
- ret.push(start);
- start++;
+ elem_p_arr_ = keep;
+ Link_array<Spanner> keeps;
+ for (int i=0; i<span_p_arr_.size ();i++)
+ {
+ Spanner *s = span_p_arr_[i];
+ Score_element *e = s;
+ if (e->line_l () == l)
+ to_remove.push (e);
+ else
+ keeps.push (s);
}
- return ret;
-}
-Link_array<PCol>
-PScore::col_range(PCol*l,PCol*r)const
-{
- Link_array<PCol> ret;
-
- PCursor<PCol*> start(l ? find_col(l)+1 : cols.top() );
- PCursor<PCol*> stop(r ? find_col(r) : cols.bottom());
- ret.push(l);
-
- /*
- ugh! windows-suck-suck-suck.
- */
- while ( PCursor<PCol*>::compare(start,stop) < 0 )
- ret.push(start++);
- ret.push(r);
- return ret;
+
+ span_p_arr_ =keeps;
+ return to_remove;
}
-Link_array<PCol>
-PScore::broken_col_range(PCol*l,PCol*r)const
+Link_array<Item>
+Paper_score::broken_col_range (Item const*l, Item const*r) const
{
- Link_array<PCol> ret;
+ Link_array<Item> ret;
- PCursor<PCol*> start(l ? find_col(l)+1 : cols.top() );
- PCursor<PCol*> stop(r ? find_col(r) : cols.bottom());
+ l = l->column_l ();
+ r = r->column_l ();
- /*
- ugh! windows-suck-suck-suck.
- */
- while ( PCursor<PCol*>::compare(start,stop) < 0 ) {
- if (start->breakable_b() && !start->line_l_ )
- ret.push(start);
- start++;
+ int start = l
+ ? find_col_idx (dynamic_cast<Paper_column*> ((Item*)l))+1
+ : 0;
+
+ int stop = r
+ ? find_col_idx (dynamic_cast<Paper_column*>((Item*)r))
+ : col_l_arr_.size ();
+
+ while (start < stop)
+ {
+ Paper_column *c = col_l_arr_[start];
+ if (c->breakable_b_ && !c->line_l_)
+ ret.push (c);
+ start++;
}
- return ret;
+ return ret;
}