Prevent marker labels overlapping. Fixes #3535.

git-svn-id: svn://localhost/ardour2/branches/3.0@8015 d708f5d6-7413-0410-9779-e7cbd77b26cf

gtk2_ardour/editor.cc

@@ -4377,6 +4377,8 @@ Editor::post_zoom ()
 	refresh_location_display();
 	_summary->set_overlays_dirty ();
 
+	update_marker_labels ();
+
 	instant_save ();
 }
 

gtk2_ardour/editor.h

@@ -615,6 +615,18 @@ class Editor : public PublicEditor, public PBD::ScopedConnectionList, public ARD
 	typedef std::map<ARDOUR::Location*,LocationMarkers *> LocationMarkerMap;
 	LocationMarkerMap location_markers;
 
+	void update_marker_labels ();
+	void update_marker_labels (ArdourCanvas::Group *);
+	void check_marker_label (Marker *);
+
+	/** A set of lists of Markers that are in each of the canvas groups
+	 *  for the marker sections at the top of the editor.  These lists
+	 *  are kept sorted in time order between marker movements, so that after
+	 *  a marker has moved we can decide whether we need to update the labels
+	 *  for all markers or for just a few.
+	 */
+	std::map<ArdourCanvas::Group *, std::list<Marker *> > _sorted_marker_lists;
+
 	void hide_marker (ArdourCanvas::Item*, GdkEvent*);
 	void clear_marker_display ();
 	void mouse_add_new_marker (framepos_t where, bool is_cd=false, bool is_xrun=false);

gtk2_ardour/editor_markers.cc

@@ -65,6 +65,9 @@ Editor::add_new_location (Location *location)
 	LocationMarkers *lam = new LocationMarkers;
 	uint32_t color;
 
+	/* make a note here of which group this marker ends up in */
+	ArdourCanvas::Group* group = 0;
+
 	if (location->is_cd_marker()) {
 		color = location_cd_marker_color;
 	} else if (location->is_mark()) {
@@ -81,30 +84,38 @@ Editor::add_new_location (Location *location)
 
 		if (location->is_cd_marker() && ruler_cd_marker_action->get_active()) {
 			lam->start = new Marker (*this, *cd_marker_group, *cursor_group, color, location->name(), Marker::Mark, location->start());
-		}
-		else {
+			group = cd_marker_group;
+		} else {
 			lam->start = new Marker (*this, *marker_group, *cursor_group, color, location->name(), Marker::Mark, location->start());
+			group = marker_group;
 		}
-		lam->end   = 0;
+		
+		lam->end = 0;
 
 	} else if (location->is_auto_loop()) {
+		
 		// transport marker
 		lam->start = new Marker (*this, *transport_marker_group, *cursor_group, color,
 					 location->name(), Marker::LoopStart, location->start());
 		lam->end   = new Marker (*this, *transport_marker_group, *cursor_group, color,
 					 location->name(), Marker::LoopEnd, location->end());
+		group = transport_marker_group;
 
 	} else if (location->is_auto_punch()) {
+		
 		// transport marker
 		lam->start = new Marker (*this, *transport_marker_group, *cursor_group, color,
 					 location->name(), Marker::PunchIn, location->start());
 		lam->end   = new Marker (*this, *transport_marker_group, *cursor_group, color,
 					 location->name(), Marker::PunchOut, location->end());
-
+		group = transport_marker_group;
+		
 	} else if (location->is_session_range()) {
+
 		// session range
 		lam->start = new Marker (*this, *marker_group, *cursor_group, color, _("start"), Marker::SessionStart, location->start());
 		lam->end = new Marker (*this, *marker_group, *cursor_group, color, _("end"), Marker::SessionEnd, location->end());
+		group = marker_group;
 		
 	} else {
 		// range marker
@@ -113,12 +124,13 @@ Editor::add_new_location (Location *location)
 						 location->name(), Marker::RangeStart, location->start());
 			lam->end   = new Marker (*this, *cd_marker_group, *cursor_group, color,
 						 location->name(), Marker::RangeEnd, location->end());
-		}
-		else {
+			group = cd_marker_group;
+		} else {
 			lam->start = new Marker (*this, *range_marker_group, *cursor_group, color,
 						 location->name(), Marker::RangeStart, location->start());
 			lam->end   = new Marker (*this, *range_marker_group, *cursor_group, color,
 						 location->name(), Marker::RangeEnd, location->end());
+			group = range_marker_group;
 		}
 	}
 
@@ -148,6 +160,17 @@ Editor::add_new_location (Location *location)
 
 	lam->canvas_height_set (_canvas_height);
 	lam->set_show_lines (_show_marker_lines);
+
+	/* Add these markers to the appropriate sorted marker lists, which will render
+	   them unsorted until the update_marker_labels() below sorts them out.
+	*/
+	_sorted_marker_lists[group].push_back (lam->start);
+	if (lam->end) {
+		_sorted_marker_lists[group].push_back (lam->end);
+	}
+
+	/* Do a full update of the markers in this group */
+	update_marker_labels (group);
 }
 
 void
@@ -170,6 +193,154 @@ Editor::location_changed (Location *location)
 	} else if (location->is_auto_punch()) {
 		update_punch_range_view ();
 	}
+
+	check_marker_label (lam->start);
+	if (lam->end) {
+		check_marker_label (lam->end);
+	}
+}
+
+/** Look at a marker and check whether its label, and those of the previous and next markers,
+ *  need to have their labels updated (in case those labels need to be shortened or can be
+ *  lengthened)
+ */
+void
+Editor::check_marker_label (Marker* m)
+{
+	/* Get a time-ordered list of markers from the last time anything changed */
+	std::list<Marker*>& sorted = _sorted_marker_lists[m->get_parent()];
+	
+	list<Marker*>::iterator i = find (sorted.begin(), sorted.end(), m);
+
+	list<Marker*>::iterator prev = sorted.end ();
+	list<Marker*>::iterator next = i;
+	++next;
+
+	/* Look to see if the previous marker is still behind `m' in time */
+	if (i != sorted.begin()) {
+
+		prev = i;
+		--prev;
+
+		if ((*prev)->position() > m->position()) {
+			/* This marker is no longer in the correct order with the previous one, so
+			 * update all the markers in this group.
+			 */
+			update_marker_labels (m->get_parent ());
+			return;
+		}
+	}
+
+	/* Look to see if the next marker is still ahead of `m' in time */
+	if (next != sorted.end() && (*next)->position() < m->position()) {
+		/* This marker is no longer in the correct order with the next one, so
+		 * update all the markers in this group.
+		 */
+		update_marker_labels (m->get_parent ());
+		return;
+	}
+
+	if (prev != sorted.end()) {
+
+		/* Update just the available space between the previous marker and this one */
+		
+		double const p = frame_to_pixel (m->position() - (*prev)->position());
+
+		if (m->label_on_left()) {
+			(*prev)->set_right_label_limit (p / 2);
+		} else {
+			(*prev)->set_right_label_limit (p);
+		}
+		
+		if ((*prev)->label_on_left ()) {
+			m->set_left_label_limit (p);
+		} else {
+			m->set_left_label_limit (p / 2);
+		}
+	}
+
+	if (next != sorted.end()) {
+
+		/* Update just the available space between this marker and the next */
+		
+		double const p = frame_to_pixel ((*next)->position() - m->position());
+
+		if ((*next)->label_on_left()) {
+			m->set_right_label_limit (p / 2);
+		} else {
+			m->set_right_label_limit (p);
+		}
+
+		if (m->label_on_left()) {
+			(*next)->set_left_label_limit (p);
+		} else {
+			(*next)->set_left_label_limit (p / 2);
+		}
+	}
+}
+
+struct MarkerComparator {
+	bool operator() (Marker const * a, Marker const * b) {
+		return a->position() < b->position();
+	}
+};
+
+/** Update all marker labels in all groups */
+void
+Editor::update_marker_labels ()
+{
+	for (std::map<ArdourCanvas::Group *, std::list<Marker *> >::iterator i = _sorted_marker_lists.begin(); i != _sorted_marker_lists.end(); ++i) {
+		update_marker_labels (i->first);
+	}
+}
+
+/** Look at all markers in a group and update label widths */
+void
+Editor::update_marker_labels (ArdourCanvas::Group* group)
+{
+	list<Marker*>& sorted = _sorted_marker_lists[group];
+
+	if (sorted.empty()) {
+		return;
+	}
+
+	/* We sort the list of markers and then set up the space available between each one */
+	
+	sorted.sort (MarkerComparator ());
+
+	list<Marker*>::iterator i = sorted.begin ();
+
+	list<Marker*>::iterator prev = sorted.end ();
+	list<Marker*>::iterator next = i;
+	++next;
+	
+	while (i != sorted.end()) {
+
+		if (prev != sorted.end()) {
+			double const p = frame_to_pixel ((*i)->position() - (*prev)->position());
+			
+			if ((*prev)->label_on_left()) {
+				(*i)->set_left_label_limit (p);
+			} else {
+				(*i)->set_left_label_limit (p / 2);
+			}
+				
+		}
+
+		if (next != sorted.end()) {
+			double const p = frame_to_pixel ((*next)->position() - (*i)->position());
+
+			if ((*next)->label_on_left()) {
+				(*i)->set_right_label_limit (p / 2);
+			} else {
+				(*i)->set_right_label_limit (p);
+			}
+		}
+
+		prev = i;
+		++i;
+		++next;
+	}
 }
 
 void

gtk2_ardour/marker.cc

@@ -56,6 +56,9 @@ Marker::Marker (PublicEditor& ed, ArdourCanvas::Group& parent, ArdourCanvas::Gro
 	, _line_shown (false)
 	, _canvas_height (0)
 	, _color (rgba)
+	, _left_label_limit (DBL_MAX)
+	, _right_label_limit (DBL_MAX)
+
 {
 	double label_offset = 0;
 
@@ -355,13 +358,40 @@ Marker::the_item() const
 void
 Marker::set_name (const string& new_name)
 {
-	int name_width = pixel_width (new_name, *name_font) + 2;
+	_name = new_name;
 
-	name_pixbuf->property_pixbuf() = pixbuf_from_string(new_name, name_font, name_width, name_height, Gdk::Color ("#000000"));
+	setup_name_pixbuf ();
+}
 
-	if (_type == SessionEnd || _type == RangeEnd || _type == LoopEnd || _type == PunchOut) {
-		name_pixbuf->property_x() = - (name_width);
+/** @return true if our label is on the left of the mark, otherwise false */
+bool
+Marker::label_on_left () const
+{
+	return (_type == SessionEnd || _type == RangeEnd || _type == LoopEnd || _type == PunchOut);
+}
+
+void
+Marker::setup_name_pixbuf ()
+{
+	double limit = DBL_MAX;
+	
+	if (label_on_left ()) {
+		limit = _left_label_limit;
+	} else {
+		limit = _right_label_limit;
 	}
+
+	/* Work out how wide the name can be */
+	int name_width = min ((double) pixel_width (_name, *name_font) + 2, limit);
+	if (name_width == 0) {
+		name_width = 1;
+	}
+
+	if (label_on_left ()) {
+		name_pixbuf->property_x() = -name_width;
+	}
+
+	name_pixbuf->property_pixbuf() = pixbuf_from_string (_name, name_font, name_width, name_height, Gdk::Color ("#000000"));
 }
 
 void
@@ -420,6 +450,36 @@ Marker::set_color_rgba (uint32_t c)
 	}
 }
 
+/** Set the number of pixels that are available for a label to the left of the centre of this marker */
+void
+Marker::set_left_label_limit (double p)
+{
+	/* Account for the size of the marker */
+	_left_label_limit = p - 13;
+	if (_left_label_limit < 0) {
+		_left_label_limit = 0;
+	}
+	
+	if (label_on_left ()) {
+		setup_name_pixbuf ();
+	}
+}
+
+/** Set the number of pixels that are available for a label to the right of the centre of this marker */
+void
+Marker::set_right_label_limit (double p)
+{
+	/* Account for the size of the marker */
+	_right_label_limit = p - 13;
+	if (_right_label_limit < 0) {
+		_right_label_limit = 0;
+	}
+	
+	if (!label_on_left ()) {
+		setup_name_pixbuf ();
+	}
+}
+
 /***********************************************************************/
 
 TempoMarker::TempoMarker (PublicEditor& editor, ArdourCanvas::Group& parent, ArdourCanvas::Group& line_parent, guint32 rgba, const string& text,

gtk2_ardour/marker.h

@@ -84,6 +84,15 @@ class Marker : public sigc::trackable
 
 	Type type () { return _type; }
 
+	void set_left_label_limit (double);
+	void set_right_label_limit (double);
+
+	std::string name () const {
+		return _name;
+	}
+
+	bool label_on_left () const;
+	
   protected:
 	PublicEditor& editor;
 
@@ -98,6 +107,7 @@ class Marker : public sigc::trackable
 	ArdourCanvas::SimpleLine* _line;
 	ArdourCanvas::Points *line_points;
 
+	std::string  _name;
 	double        unit_position;
 	framepos_t    frame_position;
 	double       _shift;
@@ -108,9 +118,12 @@ class Marker : public sigc::trackable
 	bool         _line_shown;
 	double       _canvas_height;
 	uint32_t     _color;
+	double       _left_label_limit; ///< the number of pixels available to the left of this marker for a label
+	double       _right_label_limit; ///< the number of pixels available to the right of this marker for a label
 
 	void reposition ();
 	void setup_line_x ();
+	void setup_name_pixbuf ();
 };
 
 class TempoMarker : public Marker