#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];
+ return (Score_elem*) get_out_edge_arr ()[i];
}
int
-Score_elem::dependency_size() const
+Score_elem::dependency_size () const
{
- return get_out_edge_arr().size ();
+ return get_out_edge_arr ().size ();
}
Score_elem*
return get_in_edge_arr().size ();
}
-
-
String
-Score_elem::TeX_string_without_offset (Offset o)const
+Score_elem::make_TeX_string (Offset o)const
{
- if (transparent_b_)
- return "";
String s ("\\placebox{%}{%}{%}");
Array<String> a;
a.push (print_dimen (o.y()));
a.push (print_dimen (o.x()));
String t = output->TeX_string();
if (t == "")
- return t;
+ return 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
+Score_elem::do_TeX_output_str () const
{
- assert (status_ > POSTCALCED);
- return TeX_string_without_offset (offset_);
+ return make_TeX_string(absolute_offset());
}
-void
-Score_elem::copy_dependencies (Score_elem const &s)
+Score_elem::Score_elem (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.
+ as (Directed_graph_node&)s. Nobody points to us, so don't copy
+ dependents.
*/
copy_edges_out (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;
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];
- axis_group_l; axis_group_l = axis_group_l->axis_group_l_a_[a])
+ 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])
- r += axis_group_l->offset_[a];
+ r += axis_group_l->offset_[a];
return r;
}
return Offset (absolute_coordinate (X_AXIS), absolute_coordinate (Y_AXIS));
}
- void
+void
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_l != e;
- axis_group_l = axis_group_l->axis_group_l_a_[a])
- r += axis_group_l->offset_[a];
+ for (Axis_group_element * axis_group_l = axis_group_l_a_[a];
+ axis_group_l != e;
+ axis_group_l = axis_group_l->axis_group_l_a_[a])
+ r += axis_group_l->offset_[a];
return r;
}
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);
+ 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);
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);
+ 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);
return common_l;
}
if (!output)
{
- Molecule*m = brew_molecule_p();
- r = m->extent().x ();
- delete m;
+ Molecule*m = brew_molecule_p();
+ r = m->extent().x ();
+ delete m;
}
else
- r = output->extent().x ();
+ r = output->extent().x ();
return r;
}
}
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
- r+=offset_[a];
+ r+=offset_[a];
return r;
}
Interval r;
if (!output)
{
- Molecule*m = brew_molecule_p();
- r = m->extent().y ();
- delete m;
+ Molecule*m = brew_molecule_p();
+ r = m->extent().y ();
+ delete m;
}
else
- r = output->extent().y ();
+ r = output->extent().y ();
return r;
}
STANDARD METHS
*/
void
-Score_elem::print()const
+Score_elem::print() const
{
#ifndef NPRINT
DOUT << name() << "{\n";
DOUT << "dets: " << dependent_size() << "dependencies: " <<
- dependency_size();
+ dependency_size();
if (offset_.x() || offset_.y ())
- DOUT << "offset (" << offset_.x() << ", " << offset_.y () <<")";
+ DOUT << "offset (" << offset_.x() << ", " << offset_.y () <<")";
DOUT << "\n";
do_print();
if (output)
- output->print();
+ output->print();
DOUT << "}\n";
#endif
Score_elem::add_processing()
{
if (status_ >= VIRGIN)
- return;
+ return;
status_ = VIRGIN;
do_add_processing();
}
Score_elem::pre_processing()
{
if (status_ >= PRECALCED)
- return;
+ return;
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());
for (int i=0; i < extra.size(); i++)
- extra[i]->pre_processing();
+ extra[i]->pre_processing();
do_pre_processing();
status_ = PRECALCED;
Score_elem::breakable_col_processing()
{
if (status_ >= PREBROKEN)
- return;
+ return;
if (status_== PREBREAKING)
{
- status_ = PREBROKEN;
- return ;
+ 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();
+ extra[i]->breakable_col_processing();
do_breakable_col_processing();
Score_elem::break_processing()
{
if (status_ >= BROKEN)
- return;
+ return;
if (status_ == BREAKING)
{
- status_ = BROKEN;
- return;
+ status_ = BROKEN;
+ return;
}
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());
for (int i=0; i < extra.size(); i++)
- extra[i]->break_processing();
+ extra[i]->break_processing();
Score_elem::post_processing()
{
if (status_ >= POSTCALCED)
- return;
+ return;
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());
for (int i=0; i < extra.size(); i++)
- extra[i]->post_processing();
+ extra[i]->post_processing();
do_post_processing();
}
Score_elem::Status
-Score_elem::status()const
+Score_elem::status() const
{
return status_;
}
void
Score_elem::molecule_processing()
{
- if (status_ >= OUTPUT)
- return;
- status_ = OUTPUT; // do it only once.
+ if (status_ >= BREWED)
+ return;
+ status_ = BREWED; // 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());
for (int i=0; i < extra.size(); i++)
- extra[i]->molecule_processing();
+ extra[i]->molecule_processing();
if (transparent_b_)
- return ;
+ return ;
output= brew_molecule_p();
}
+String
+Score_elem::TeX_output_str() const
+{
+ String s;
+ if (status_ >= TEXOUTPUT)
+ return "";
+
+ ((Score_elem*)this)->status_ = TEXOUTPUT;
+
+ for (int i=0; i < dependency_size(); i++)
+ s += dependency (i)->TeX_output_str();
+
+ Link_array<Score_elem> extra (get_extra_dependencies());
+ for (int i=0; i < extra.size(); i++)
+ s += extra[i]->TeX_output_str ();
+
+ if (!transparent_b_)
+ s+= do_TeX_output_str();
+
+ return s;
+}
+
/*
VIRTUAL STUBS
void
Score_elem::do_unlink()
-{}
+{
+}
+
+void
+Score_elem::do_junk_links()
+{
+}
IMPLEMENT_IS_TYPE_B(Score_elem);
Molecule*
-Score_elem::brew_molecule_p()const
+Score_elem::brew_molecule_p() const
{
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;
}
old->do_substitute_dependent (this, 0);
}
-void
-Score_elem::junk_dependencies()
-{
- while ( dependency_size())
- {
- remove_edge_out (dependency (0));
- }
-}
-
void
Score_elem::handle_broken_dependencies()
{
Line_of_score *line = line_l();
if (!line)
- return;
+ 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() && 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);
- }
- remove_us_arr.push (elt);
- }
+ 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.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;
}
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()->pcol_l_);
- if (new_l != elt)
- {
- new_arr.push (new_l);
- old_arr.push (elt);
- }
- }else
+ 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 (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 (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]);
+ }
}
for (int i=0; i < old_arr.size(); i++)
- if (old_arr[i])
- substitute_dependency (old_arr[i], new_arr[i]);
+ if (old_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();
+ dependency (i)->unlink_all();
Link_array<Score_elem> extra (get_extra_dependencies());
for (int i=0; i < extra.size(); i++)
- extra[i]->unlink_all();
+ extra[i]->unlink_all();
junk_links();
- axis_group_l_a_[0] = axis_group_l_a_[1] =0;
+ axis_group_l_a_[X_AXIS] = axis_group_l_a_[Y_AXIS] =0;
+ do_unlink();
}
void
Score_elem::unlink()
{
do_unlink();
- while ( dependency_size())
+ 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())
+ while (dependent_size())
{
- dependent (0)->remove_dependency (this);
+ 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);
+ if (axis_group_l_a_[j])
+ axis_group_l_a_[j]->remove_element (this);
}
void
-Score_elem::OK()const
+Score_elem::OK() const
{
#ifndef NDEBUG
for (int i=0; i < dependency_size(); i++)
{
- dependency (i)->OK();
+ dependency (i)->OK();
}
#endif
}
Link_array<Score_elem>
-Score_elem::get_extra_dependencies()const
+Score_elem::get_extra_dependencies() const
{
Link_array<Score_elem> empty;
return empty;
}
+
+bool
+Score_elem::linked_b() const
+{
+ return get_extra_dependencies().size() ||
+ dependency_size();
+}
projects / lilypond.git / blobdiff