]> git.donarmstrong.com Git - lilypond.git/blobdiff - lily/tie-formatting-problem.cc
* Documentation/topdocs/NEWS.tely (Top): doc new feature.
[lilypond.git] / lily / tie-formatting-problem.cc
index 882dd7ae8baa86cded287ba532e4a4dc2b00afc1..dada24694cb14f1f0c0673f61ed8e2f546bc29ca 100644 (file)
@@ -42,12 +42,16 @@ Tie_formatting_problem::print_ties_configuration (Ties_configuration const *ties
 Interval
 Tie_formatting_problem::get_attachment (Real y, Drul_array<int> columns) const
 {
-  Interval attachments;
+  Interval attachments (0,0);
   Direction d = LEFT;
   do
     {
-      Chord_outline_map::const_iterator i (chord_outlines_.find (columns[d]));
-      attachments[d] = skyline_height ((*i).second, y, -d);
+      Tuple2<int> key (columns[d], int (d));
+      Chord_outline_map::const_iterator i (chord_outlines_.find (key));
+      if (i == chord_outlines_.end ())
+       programming_error ("Can't find chord outline");
+      else
+       attachments[d] = skyline_height ((*i).second, y, -d);
     }
   while (flip (&d) != LEFT);
   
@@ -109,13 +113,15 @@ Tie_formatting_problem::set_column_chord_outline (vector<Item*> bounds,
          boxes.push_back (Box (x, y));
        }
     }
+
+  Tuple2<int> key (column_rank, int (dir));
   
-  chord_outlines_[column_rank] = empty_skyline (-dir);
+  chord_outlines_[key] = empty_skyline (-dir);
       
   if (bounds[0]->break_status_dir ())
     {
       Real x = robust_relative_extent (bounds[0],  x_refpoint_, X_AXIS)[-dir];
-      chord_outlines_[column_rank].at (0).height_ = x; 
+      chord_outlines_[key].at (0).height_ = x; 
     }
   else
     {
@@ -125,11 +131,11 @@ Tie_formatting_problem::set_column_chord_outline (vector<Item*> bounds,
          x.unite (head_boxes[j][X_AXIS]);
        }
       
-      chord_outlines_[column_rank].at (0).height_ = x[dir];
+      chord_outlines_[key].at (0).height_ = x[dir];
     }
       
   for (vsize i = 0; i < boxes.size (); i++)
-    insert_extent_into_skyline (&chord_outlines_[column_rank]  ,
+    insert_extent_into_skyline (&chord_outlines_[key]  ,
                                boxes[i], Y_AXIS, -dir);
 
   if (stem
@@ -145,18 +151,36 @@ Tie_formatting_problem::set_column_chord_outline (vector<Item*> bounds,
       y.add_point (Stem::head_positions (stem)[-stemdir]
                   * staff_space * .5);
          
-      insert_extent_into_skyline (&chord_outlines_[column_rank], Box (x,y), Y_AXIS, -dir);
+      insert_extent_into_skyline (&chord_outlines_[key], Box (x,y), Y_AXIS, -dir);
 
-      stem_extents_[dir].unite (Box (x,y));
+      stem_extents_[key].unite (Box (x,y));
 
       if (dir == LEFT)
        {
          Box flag_box = Stem::get_translated_flag (stem).extent_box ();
          flag_box.translate( Offset (x[RIGHT], X_AXIS));
-         insert_extent_into_skyline (&chord_outlines_[column_rank], flag_box,
+         insert_extent_into_skyline (&chord_outlines_[key], flag_box,
                                      Y_AXIS, -dir);
        }
     }
+  else if (stem)
+    {
+      Grob *head = Stem::support_head (stem);
+
+      /*
+       In case of invisible stem, don't pass x-center of heads.
+       */
+      Real x_center = head->extent (x_refpoint_, X_AXIS).center ();
+      Interval x_ext;
+      x_ext[-dir] = x_center;
+      Interval y_ext;
+      for (vsize j = 0; j < head_boxes.size (); j++)
+       y_ext.unite (head_boxes[j][Y_AXIS]);
+         
+      insert_extent_into_skyline (&chord_outlines_[key],
+                                 Box (x_ext, y_ext),
+                                 Y_AXIS, -dir);
+    }
   
   Direction updowndir = DOWN;
   do
@@ -173,16 +197,16 @@ Tie_formatting_problem::set_column_chord_outline (vector<Item*> bounds,
        }
 
       if (!x.is_empty ())
-       insert_extent_into_skyline (&chord_outlines_[column_rank],
+       insert_extent_into_skyline (&chord_outlines_[key],
                                    Box (x,y),
                                    Y_AXIS, -dir);
     }
   while (flip (&updowndir) != DOWN);
   
-  head_extents_[dir].set_empty ();
+  head_extents_[key].set_empty ();
   for (vsize i = 0; i < head_boxes.size (); i++)
     {
-      head_extents_[dir].unite (head_boxes[i]);
+      head_extents_[key].unite (head_boxes[i]);
     }
 }
 
@@ -298,7 +322,8 @@ Tie_formatting_problem::from_semi_ties (vector<Grob*> const &lv_ties, Direction
   
   details_.from_grob (lv_ties[0]);
   vector<Item*> heads;
-  
+
+  int column_rank = -1;
   for (vsize i = 0; i < lv_ties.size (); i++)
     {
       Tie_specification spec;
@@ -311,8 +336,11 @@ Tie_formatting_problem::from_semi_ties (vector<Grob*> const &lv_ties, Direction
        {
          spec.position_ = int (Staff_symbol_referencer::get_position (head));
        }
+      
 
       spec.note_head_drul_[head_dir] = head;
+      column_rank = dynamic_cast<Item*> (head)->get_column ()->get_rank ();
+      spec.column_ranks_ = Drul_array<int> (column_rank, column_rank);
       heads.push_back (head);
       specifications_.push_back (spec);
     }
@@ -327,17 +355,20 @@ Tie_formatting_problem::from_semi_ties (vector<Grob*> const &lv_ties, Direction
 
   Real extremal = head_dir * infinity_f;   
 
-  for (vsize i = 0; i < chord_outlines_[head_dir].size (); i++)
+  Tuple2<int> head_key (column_rank, head_dir);
+  Tuple2<int> open_key (column_rank, -head_dir);
+  
+  for (vsize i = 0; i < chord_outlines_[head_key].size (); i++)
     {
       extremal = head_dir * min (head_dir * extremal,
-                                  head_dir * chord_outlines_[head_dir][i].height_);
+                                head_dir * chord_outlines_[head_key][i].height_);
     }
 
   Skyline_entry right_entry;
   right_entry.width_.set_full ();
   right_entry.height_ = extremal - head_dir * 1.5;
   
-  chord_outlines_[-head_dir].push_back (right_entry);
+  chord_outlines_[open_key].push_back (right_entry);
 }
 
 
@@ -391,12 +422,12 @@ Tie_formatting_problem::generate_configuration (int pos, Direction dir,
     }
   
   if (y_tune
-      && max (fabs (head_extents_[LEFT][Y_AXIS][dir] - y),
-             fabs (head_extents_[RIGHT][Y_AXIS][dir] - y)) < 0.25
+      && max (fabs (get_head_extent (columns[LEFT], LEFT, Y_AXIS)[dir] - y),
+             fabs (get_head_extent (columns[RIGHT], RIGHT, Y_AXIS)[dir] - y)) < 0.25
       && !Staff_symbol_referencer::on_line (details_.staff_symbol_referencer_, pos))
     {
       conf->delta_y_ =
-       (head_extents_[LEFT][Y_AXIS][dir] - y)
+       (get_head_extent (columns[LEFT], LEFT, Y_AXIS)[dir] - y)
        + dir * details_.outer_tie_vertical_gap_;
     }
 
@@ -467,19 +498,31 @@ Tie_formatting_problem::generate_configuration (int pos, Direction dir,
   do
     {
       Real y = conf->position_ * details_.staff_space_ * 0.5 + conf->delta_y_;
-      if (stem_extents_[d][X_AXIS].is_empty ()
-         || !stem_extents_[d][Y_AXIS].contains (y))
+      if (get_stem_extent (conf->column_ranks_[d], d, X_AXIS).is_empty ()
+         || !get_stem_extent (conf->column_ranks_[d], d, Y_AXIS).contains (y))
        continue;
 
       conf->attachment_x_[d] =
        d * min (d * conf->attachment_x_[d],
-                d * (stem_extents_[d][X_AXIS][-d] - d * details_.stem_gap_));
+                d * (get_stem_extent (conf->column_ranks_[d], d, X_AXIS)[-d] - d * details_.stem_gap_));
     }
   while (flip (&d) != LEFT);
   
   return conf;
 }
 
+Interval
+Tie_formatting_problem::get_head_extent (int col, Direction d, Axis a) const
+{
+  return (*head_extents_.find (Tuple2<int> (col, int (d)))).second[a];
+}
+
+Interval
+Tie_formatting_problem::get_stem_extent (int col, Direction d, Axis a) const
+{
+  return (*stem_extents_.find (Tuple2<int> (col, int (d)))).second[a];
+}
+
 /**
    TIE_IDX and TIES_CONF are optional.
  */
@@ -842,7 +885,6 @@ Tie_formatting_problem::find_best_variation (Ties_configuration const &base,
 Ties_configuration
 Tie_formatting_problem::generate_optimal_chord_configuration ()
 {
-  
   Ties_configuration base = generate_base_chord_configuration ();
   vector<Tie_configuration_variation> vars = generate_collision_variations (base);