(c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
*/
-
+#include "outputter.hh"
#include "p-score.hh"
#include "paper-def.hh"
#include "lookup.hh"
#include "item.hh"
#include "p-col.hh"
-Score_elem*
-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();
-}
-
-Score_elem*
-Score_elem::dependent(int i) const
+Score_elem::Score_elem()
{
- return (Score_elem*) get_in_edge_arr()[i];
+ transparent_b_ = false;
+ pscore_l_=0;
+ status_i_ = 0;
}
-int
-Score_elem::dependent_size() const
+Score_elem::Score_elem (Score_elem const&s)
+ : Directed_graph_node (s), Graphical_element (s)
{
- return get_in_edge_arr().size();
+ /* 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);
+ transparent_b_ = s.transparent_b_;
+ status_i_ = s.status_i_;
+ pscore_l_ = s.pscore_l_;
}
-
-String
-Score_elem::TeX_string() const
+Score_elem::~Score_elem()
{
- assert( status > POSTCALCED);
- if (transparent_b_ )
- return "";
- String s( "\\placebox{%}{%}{%}");
- Array<String> a;
- a.push(print_dimen(offset_.y));
- a.push(print_dimen(offset_.x));
- String t = output->TeX_string();
- if (t == "")
- return t;
-
- a.push( t);
- String r;
- if (check_debug)
- r = String("\n%start: ") + name() + "\n";
- r += substitute_args(s, a);;
- return r;
-
+ assert (status_i_ >=0);
+ status_i_ = -1;
}
-
-Score_elem::Score_elem(Score_elem const&s)
+Score_elem*
+Score_elem::dependency (int i) const
{
- transparent_b_ = s.transparent_b_;
- empty_b_ = s.empty_b_;
- /* 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);
- x_group_element_i_ = 0;
- y_group_element_i_ = 0;
- status = s.status;
- assert(!s.output);
- output = 0;
- pscore_l_ = s.pscore_l_;
- offset_ = Offset(0,0);
+ return (Score_elem*) get_out_edge_arr ()[i];
}
-Score_elem::~Score_elem()
+int
+Score_elem::dependency_size () const
{
- // some paranoia to prevent weird segv's
- assert(status < DELETED);
- delete output;
- status = DELETED;
- output = 0;
- assert(!x_group_element_i_ && !y_group_element_i_);
+ return get_out_edge_arr ().size ();
}
-void
-Score_elem::translate_x(Real x)
+Score_elem*
+Score_elem::dependent (int i) const
{
- offset_.x += x;
+ return (Score_elem*) get_in_edge_arr()[i];
}
-
-
-void
-Score_elem::translate_y(Real y)
+int
+Score_elem::dependent_size() const
{
- offset_.y += y;
+ return get_in_edge_arr().size ();
}
-void
-Score_elem::translate(Offset O)
-{
- translate_y(O.y);
- translate_x(O.x);
-}
Interval
Score_elem::do_width() const
{
- Interval r;
-
- if (!output){
- Molecule*m = brew_molecule_p();
- r = m->extent().x;
- delete m;
- } else
- r = output->extent().x;
- return r;
-}
-
-Interval
-Score_elem::width() const
-{
- Interval r=(empty_b_)?Interval(0,0):do_width();
-
- if (!r.empty_b()) // float exception on DEC Alpha
- r+=offset_.x;
+ Interval r;
- return r;
+ Molecule*m = brew_molecule_p();
+ r = m->extent().x ();
+ delete m;
+
+ return r;
}
Interval
Score_elem::do_height() const
{
- Interval r;
- if (!output){
- Molecule*m = brew_molecule_p();
- r = m->extent().y;
- delete m;
- } else
- r = output->extent().y;
- return r;
+ Interval r;
+ Molecule*m = brew_molecule_p();
+ r = m->extent().y ();
+ delete m;
+ return r;
}
-Interval
-Score_elem::height() const
-{
- Interval r=(empty_b_)?Interval(0,0): do_height();
-
- if (!r.empty_b())
- r+=offset_.y;
-
-
- return r;
-}
+/*
+ STANDARD METHS
+ */
void
-Score_elem::print()const
+Score_elem::print() const
{
#ifndef NPRINT
- mtor << name() << "{\n";
- mtor << "dets: " << dependent_size() << "dependencies: " <<
- dependency_size();
- if (offset_.x || offset_.y)
- mtor << "offset (" << offset_.x << ", " << offset_.y <<")";
- mtor << "\n";
-
- do_print();
- if (output)
- output->print();
-
- mtor << "}\n";
+ DOUT << name() << "{\n";
+ DOUT << "dets: " << dependent_size() << "dependencies: " <<
+ dependency_size();
+
+ Graphical_element::print ();
+ do_print();
+
+ DOUT << "}\n";
#endif
}
-
-Score_elem::Score_elem()
-{
- transparent_b_ = empty_b_ = false;
- x_group_element_i_ = 0;
- y_group_element_i_ =0;
- pscore_l_=0;
- offset_ = Offset(0,0);
- output = 0;
- status = ORPHAN;
-}
-
-
Paper_def*
Score_elem::paper() const
{
- assert(pscore_l_);
- return pscore_l_->paper_l_;
+ assert (pscore_l_);
+ return pscore_l_->paper_l_;
}
+
void
Score_elem::add_processing()
{
- if (status >= VIRGIN)
- return;
- status = VIRGIN;
- do_add_processing();
+ if (status_i_)
+ return;
+ status_i_ ++;
+ do_add_processing();
}
+
void
-Score_elem::pre_processing()
+Score_elem::calcalute_dependencies (int final, int busy,
+ Score_elem_method_pointer funcptr)
{
- if (status >= PRECALCED )
- return;
+ if (status_i_ >= final)
+ return;
- assert(status != PRECALCING); // cyclic dependency
- status = PRECALCING;
+ assert (status_i_!= busy);
+ status_i_= busy;
- for (int i=0; i < dependency_size(); i++)
- dependency(i)->pre_processing();
+ for (int i=0; i < dependency_size(); i++)
+ dependency (i)->calcalute_dependencies (final, busy, funcptr);
-
- do_pre_processing();
- status = PRECALCED;
+ Link_array<Score_elem> extra (get_extra_dependencies());
+ for (int i=0; i < extra.size(); i++)
+ extra[i]->calcalute_dependencies (final, busy, funcptr);
+
+ invalidate_cache (X_AXIS);
+ invalidate_cache (Y_AXIS);
+ (this->*funcptr)();
+ status_i_= final;
}
void
-Score_elem::breakable_col_processing()
+Score_elem::do_brew_molecule ()
{
- if (status >= PREBROKEN )
- return;
-
- assert(status != PREBREAKING); // cyclic dependency
- status = PREBREAKING;
+ if (transparent_b_)
+ return ;
+ Molecule *output= brew_molecule_p ();
+ pscore_l_->outputter_l_->output_molecule (output, absolute_offset ());
+}
- for (int i=0; i < dependency_size(); i++)
- dependency(i)->breakable_col_processing();
+/*
+
+ VIRTUAL STUBS
-
- do_breakable_col_processing();
- status = PREBROKEN;
-}
+ */
void
-Score_elem::break_processing()
+Score_elem::do_break_processing()
{
- if (status >= BROKEN )
- return;
-
- assert(status != BREAKING); // cyclic dependency
- status = BREAKING;
-
- for (int i=0; i < dependency_size(); i++)
- dependency(i)->break_processing();
-
-
- do_break_processing();
- status = BROKEN;
+ handle_broken_dependencies();
}
void
-Score_elem::do_break_processing()
+Score_elem::do_post_processing()
{
- handle_broken_dependencies();
}
-
void
-Score_elem::post_processing()
+Score_elem::do_breakable_col_processing()
{
- if (status >= POSTCALCED)
- return;
- assert(status != POSTCALCING);// cyclic dependency
- status=POSTCALCING;
-
-
- for (int i=0; i < dependency_size(); i++)
- dependency(i)->post_processing();
- do_post_processing();
- status=POSTCALCED;
+ handle_prebroken_dependencies();
}
-void
-Score_elem::molecule_processing()
+void
+Score_elem::do_pre_processing()
{
- if (status >= OUTPUT)
- return;
- status = OUTPUT; // do it only once.
-
- for (int i=0; i < dependency_size(); i++)
- dependency(i)->molecule_processing();
-
- if (transparent_b_)
- return ;
- output= brew_molecule_p();
}
void
-Score_elem::do_post_processing()
+Score_elem::do_add_processing()
{
}
void
-Score_elem::do_breakable_col_processing()
+Score_elem::do_substitute_dependency (Score_elem*,Score_elem*)
{
- handle_prebroken_dependencies();
}
-
void
-Score_elem::do_pre_processing()
+Score_elem::do_substitute_dependent (Score_elem*,Score_elem*)
{
}
void
-Score_elem::do_add_processing()
+Score_elem::do_unlink()
{
-
}
void
-Score_elem::do_substitute_dependency(Score_elem*,Score_elem*)
+Score_elem::do_junk_links()
{
}
-
-IMPLEMENT_STATIC_NAME(Score_elem);
-IMPLEMENT_IS_TYPE_B(Score_elem);
+IMPLEMENT_IS_TYPE_B1(Score_elem, Graphical_element);
Molecule*
-Score_elem::brew_molecule_p()const
-{
- Atom a(paper()->lookup_l()->fill(Box(Interval(0,0), Interval(0,0))));
- return new Molecule (a);
-}
-Offset
-Score_elem::offset() const
+Score_elem::brew_molecule_p() const
{
- return offset_;
+ Atom a (paper()->lookup_l ()->fill (Box (Interval (0,0), Interval (0,0))));
+ return new Molecule (a);
}
+
Line_of_score *
-Score_elem::line_l()const
+Score_elem::line_l() const
{
- return 0;
+ return 0;
}
/*
+
DEPENDENCIES
- */
+
+ */
void
-Score_elem::remove_dependency(Score_elem*e)
+Score_elem::remove_dependency (Score_elem*e)
{
- remove_edge_out(e);
- do_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)
+{
+ do_substitute_dependency (old,new_l);
+ old->do_substitute_dependent (this, 0);
}
-
void
Score_elem::handle_broken_dependencies()
{
- Line_of_score *line = line_l();
- if (!line)
- return;
-
- Link_array<Score_elem> remove_us_arr;
- for (int i=0; i < dependency_size(); 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);
- do_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);
- do_substitute_dependency( elt, my_item);
- if (my_item)
- add_dependency( my_item);
+ Line_of_score *line = line_l();
+ if (!line)
+ return;
+
+ Link_array<Score_elem> remove_us_arr;
+ for (int i=0; i < dependency_size(); 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())
+ {
+ Item * my_item = elt->item()->find_prebroken_piece (line);
+
+ substitute_dependency (elt, my_item);
+ if (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]);
-
- /* Reset this. If we are a (broken) copy of a spanner, then
- break_processing() was not called on us (and we are not breaking). */
- if (status < BROKEN)
- status = BROKEN;
+ 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]);
}
/*
void
Score_elem::handle_prebroken_dependencies()
{
- Link_array<Score_elem> remove_us_arr;
- for (int i=0; i < dependency_size(); i++) {
- Score_elem * elt = dependency(i);
- Item *it_l = elt->item();
- if (it_l && it_l->pcol_l_->breakable_b())
- if (item()) {
- Score_elem *new_l = it_l->find_prebroken_piece(item()->pcol_l_);
- if (new_l != elt ) {
- do_substitute_dependency( elt, new_l);
- remove_us_arr.push(elt);
-
- add_dependency(new_l);
- }
- }else {
- add_dependency(it_l->broken_to_a_[0]);
- add_dependency(it_l->broken_to_a_[1]);
- }
-
+ Link_array<Score_elem> old_arr, new_arr;
+
+ for (int i=0; i < dependency_size(); 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()->break_status_i_);
+ if (new_l != elt)
+ {
+ new_arr.push (new_l);
+ old_arr.push (elt);
+ }
+ }
+ else
+ {
+ new_arr.push (it_l->broken_to_drul_[LEFT]);
+ old_arr.push (0);
+ old_arr.push (0);
+ new_arr.push (it_l->broken_to_drul_[RIGHT]);
+ }
}
-
- 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]);
-
- /*
- see comment at handle_broken_dependencies()
- */
- if (status < PREBROKEN)
- status = PREBROKEN;
+
+ for (int i=0; i < old_arr.size(); i++)
+ if (old_arr[i])
+ substitute_dependency (old_arr[i], new_arr[i]);
}
-
void
-Score_elem::unlink_all()
+Score_elem::junk_links ()
{
- for (int i=0; i < dependency_size(); i++)
- dependency(i)->unlink_all();
- junk_links();
- y_group_element_i_ = 0;
- x_group_element_i_ = 0;
+ Directed_graph_node::junk_links();
+ Graphical_element::junk_links ();
+ do_junk_links();
}
void
Score_elem::unlink()
{
- while ( dependency_size()) {
- do_substitute_dependency(dependency(0),0);
- remove_edge_out_idx(0);
+ do_unlink();
+ while (dependency_size())
+ {
+ 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);
}
+Link_array<Score_elem>
+Score_elem::get_extra_dependencies() const
+{
+ Link_array<Score_elem> empty;
+ return empty;
+}
-void
-Score_elem::OK()const
+bool
+Score_elem::linked_b() const
{
-#ifndef NDEBUG
- for (int i=0; i < dependency_size(); i++) {
- dependency(i)->OK();
- }
-#endif
+ return get_extra_dependencies().size() ||
+ dependency_size();
}
+
+
projects / lilypond.git / blobdiff