/*
- p-col.cc -- implement PCol
+ p-col.cc -- implement Paper_column
- source file of the LilyPond music typesetter
+ source file of the GNU LilyPond music typesetter
- (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+ (c) 1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
#include "p-col.hh"
#include "p-score.hh"
-#include "p-staff.hh"
#include "debug.hh"
-Interval
-PCol::width() const
+void
+Paper_column::add_rod (Paper_column * p, Real d)
{
- Interval w;
+ Direction dir = Direction (sign (p->rank_i () - rank_i ()));
+ for (int i=0; i < minimal_dists_arr_drul_[dir].size (); i++)
+ {
+ Column_rod &rod = minimal_dists_arr_drul_[dir][i];
+ if (rod.other_l_ == p)
+ {
+ rod.distance_f_ = rod.distance_f_ >? d;
+ return ;
+ }
+ }
+
+ Column_rod cr;
+ cr.distance_f_ = d;
+ cr.other_l_ = p;
- for (iter_top(its,i); i.ok(); i++)
- w.unite(i->width());
- if (w.empty_b())
- w.unite(Interval(0,0));
- return w;
+ minimal_dists_arr_drul_[dir].push (cr);
+
}
int
-PCol::rank() const
+Paper_column::rank_i() const
{
- assert(rank_i_ != -1);
- return rank_i_;
+ return rank_i_;
}
void
-PCol::set_rank(int i)
+Paper_column::set_rank (int i)
{
- rank_i_ = i;
- if (prebreak_p_)
- prebreak_p_->rank_i_ = i;
- if (postbreak_p_)
- postbreak_p_->rank_i_ = i;
+ rank_i_ = i;
+ if (prebreak_l())
+ prebreak_l()->rank_i_ = i;
+ if (postbreak_l())
+ postbreak_l()->rank_i_ = i;
}
void
-PCol::print() const
+Paper_column::do_print() const
{
#ifndef NPRINT
- mtor << "PCol {";
-
- mtor << "rank: " << rank_i_ << '\n';
-
- mtor << "# symbols: " << its.size() ;
- if (breakable_b()){
- mtor << "\npre,post: ";
- prebreak_p_->print();
- postbreak_p_->print();
- } else if (daddy_l_) {
- mtor<<'\n' << ((this == daddy_l_->prebreak_p_) ?
- "prebreak" : "postbreak");
- mtor << '\n';
+ DOUT << "rank: " << rank_i_ << '\n';
+ if (prebreak_l())
+ {
+ DOUT << "\npre: ";
+ prebreak_l()->print();
+ }
+ if (postbreak_l())
+ {
+ DOUT << "post: ";
+ postbreak_l()->print();
+ }
+ if (break_status_dir_)
+ {
+ DOUT << '\n' << ((break_status_dir_ == LEFT) ? "prebreak" : "postbreak");
+ DOUT << '\n';
+ }
+
+ DOUT << "Left: ";
+ for (int i=0; i < minimal_dists_arr_drul_[LEFT].size (); i++)
+ {
+ minimal_dists_arr_drul_[LEFT][i].print ();
+ }
+ DOUT << "Right: ";
+ for (int i=0; i < minimal_dists_arr_drul_[RIGHT].size (); i++)
+ {
+ minimal_dists_arr_drul_[RIGHT][i].print ();
}
- mtor << "extent: " << width().str() << "\n";
- mtor << "}\n";
#endif
}
int
-PCol::compare(PCol const &c1, PCol const &c2)
+Paper_column::compare (Paper_column const &c1, Paper_column const &c2)
{
- return c1.rank() - c2.rank();
+ return c1.rank_i() - c2.rank_i ();
}
-void
-PCol::OK() const
+Paper_column*
+Paper_column::prebreak_l() 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);
- }
-#endif
+ return dynamic_cast<Paper_column*>(broken_to_drul_[LEFT]);
}
-void
-PCol::set_breakable()
+Paper_column*
+Paper_column::postbreak_l() const
{
- if (breakable_b())
- return;
+ return dynamic_cast<Paper_column*>( broken_to_drul_[RIGHT]);
+}
+bool
+Paper_column::breakpoint_b() const
+{
+ return !line_l_;
+}
- prebreak_p_ = new PCol(this);
- postbreak_p_ = new PCol(this);
- prebreak_p_->pscore_l_ = pscore_l_;
- postbreak_p_->pscore_l_ = pscore_l_;
+Paper_column::Paper_column()
+{
+ used_b_ = false;
+ error_mark_b_ = false;
+ line_l_=0;
+ rank_i_ = -1;
}
-bool
-PCol::breakable_b() const
+Line_of_score*
+Paper_column::line_l() const
{
- return prebreak_p_||postbreak_p_;
+ return line_l_;
}
-PCol::PCol(PCol *parent)
+bool
+Paper_column::used_b() const
{
- daddy_l_ = parent;
- prebreak_p_=0;
- postbreak_p_=0;
- line_l_=0;
- hpos = -1.0;
- pscore_l_ = 0;
+ return linked_b();
}
-PCol::~PCol()
+
+
+Paper_column*
+Paper_column::column_l () const
{
- delete prebreak_p_;
- delete postbreak_p_;
+ return (Paper_column*)(this);
}
+
void
-PCol::add( Item *i)
+Paper_column::preprocess ()
{
- its.bottom().add(i);
- i->pcol_l_ = this;
+ minimal_dists_arr_drul_[LEFT].sort (Column_rod::compare);
+ minimal_dists_arr_drul_[RIGHT].sort (Column_rod::compare);
}
bool
-PCol::used_b()const
+Paper_column::breakable_b () const
{
- return breakable_b() || its.size();
+ return breakable_b_;
}