X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_summary.cc;h=cd4356eb75bc1cb64585d7e2985625e230b29f19;hb=3b079064e62facf91a35d2307709fc00feb0bb19;hp=3fa379a9b950407e7607856edf2244cfcef018a6;hpb=db98653d2072d24b00495924f5bd3ac381a7a582;p=ardour.git

diff --git a/gtk2_ardour/editor_summary.cc b/gtk2_ardour/editor_summary.cc
index 3fa379a9b9..cd4356eb75 100644
--- a/gtk2_ardour/editor_summary.cc
+++ b/gtk2_ardour/editor_summary.cc
@@ -26,6 +26,9 @@
 #include "region_view.h"
 #include "rgb_macros.h"
 #include "keyboard.h"
+#include "editor_routes.h"
+#include "editor_cursors.h"
+#include "mouse_cursors.h"
 
 using namespace std;
 using namespace ARDOUR;
@@ -44,11 +47,14 @@ EditorSummary::EditorSummary (Editor* e)
 	  _last_playhead (-1),
 	  _move_dragging (false),
 	  _moved (false),
+	  _view_rectangle_x (0, 0),
+	  _view_rectangle_y (0, 0),
 	  _zoom_dragging (false)
-
 {
 	Region::RegionPropertyChanged.connect (region_property_connection, invalidator (*this), boost::bind (&CairoWidget::set_dirty, this), gui_context());
 	_editor->playhead_cursor->PositionChanged.connect (position_connection, invalidator (*this), ui_bind (&EditorSummary::playhead_position_changed, this, _1), gui_context());
+
+	add_events (Gdk::POINTER_MOTION_MASK);	
 }
 
 /** Connect to a session.
@@ -57,7 +63,7 @@ EditorSummary::EditorSummary (Editor* e)
 void
 EditorSummary::set_session (Session* s)
 {
-	EditorComponent::set_session (s);
+	SessionHandlePtr::set_session (s);
 
 	set_dirty ();
 
@@ -86,17 +92,20 @@ EditorSummary::on_expose_event (GdkEventExpose* event)
 
 	cairo_t* cr = gdk_cairo_create (get_window()->gobj());
 
-	/* Render the view rectangle */
+	/* Render the view rectangle.  If there is an editor visual pending, don't update
+	   the view rectangle now --- wait until the expose event that we'll get after
+	   the visual change.  This prevents a flicker.
+	*/
 
-	pair<double, double> x;
-	pair<double, double> y;
-	get_editor (&x, &y);
+	if (_editor->pending_visual_change.idle_handler_id < 0) {
+		get_editor (&_view_rectangle_x, &_view_rectangle_y);
+	}
 
-	cairo_move_to (cr, x.first, y.first);
-	cairo_line_to (cr, x.second, y.first);
-	cairo_line_to (cr, x.second, y.second);
-	cairo_line_to (cr, x.first, y.second);
-	cairo_line_to (cr, x.first, y.first);
+	cairo_move_to (cr, _view_rectangle_x.first, _view_rectangle_y.first);
+	cairo_line_to (cr, _view_rectangle_x.second, _view_rectangle_y.first);
+	cairo_line_to (cr, _view_rectangle_x.second, _view_rectangle_y.second);
+	cairo_line_to (cr, _view_rectangle_x.first, _view_rectangle_y.second);
+	cairo_line_to (cr, _view_rectangle_x.first, _view_rectangle_y.first);
 	cairo_set_source_rgba (cr, 1, 1, 1, 0.25);
 	cairo_fill_preserve (cr);
 	cairo_set_line_width (cr, 1);
@@ -138,13 +147,19 @@ EditorSummary::render (cairo_t* cr)
 
 	/* compute start and end points for the summary */
 	
-	nframes_t const session_length = _session->current_end_frame() - _session->current_start_frame ();
+	framecnt_t const session_length = _session->current_end_frame() - _session->current_start_frame ();
 	double const theoretical_start = _session->current_start_frame() - session_length * _overhang_fraction;
 	_start = theoretical_start > 0 ? theoretical_start : 0;
 	_end = _session->current_end_frame() + session_length * _overhang_fraction;
 
 	/* compute track height */
-	size_t const N = _editor->track_views.size ();
+	int N = 0;
+	for (TrackViewList::const_iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
+		if (!(*i)->hidden()) {
+			++N;
+		}
+	}
+	
 	if (N == 0) {
 		_track_height = 16;
 	} else {
@@ -163,6 +178,10 @@ EditorSummary::render (cairo_t* cr)
 	double y = 0;
 	for (TrackViewList::const_iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
 
+		if ((*i)->hidden()) {
+			continue;
+		}
+
 		cairo_set_source_rgb (cr, 0.2, 0.2, 0.2);
 		cairo_set_line_width (cr, _track_height - 2);
 		cairo_move_to (cr, 0, y + _track_height / 2);
@@ -291,45 +310,18 @@ EditorSummary::on_button_press_event (GdkEventButton* ev)
 		_start_editor_y = yr;
 		_start_mouse_x = ev->x;
 		_start_mouse_y = ev->y;
+		_start_position = get_position (ev->x, ev->y);
 
-		if (
-			_start_editor_x.first <= _start_mouse_x && _start_mouse_x <= _start_editor_x.second &&
-			_start_editor_y.first <= _start_mouse_y && _start_mouse_y <= _start_editor_y.second
+		if (_start_position != INSIDE && _start_position != BELOW_OR_ABOVE &&
+		    _start_position != TO_LEFT_OR_RIGHT && _start_position != OTHERWISE_OUTSIDE
 			) {
 
-			_start_position = IN_VIEWBOX;
-
-		} else if (_start_editor_x.first <= _start_mouse_x && _start_mouse_x <= _start_editor_x.second) {
-
-			_start_position = BELOW_OR_ABOVE_VIEWBOX;
-
-		} else {
-
-			_start_position = TO_LEFT_OR_RIGHT_OF_VIEWBOX;
-		}
+			/* start a zoom drag */
 
-		if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
-
-			/* primary-modifier-click: start a zoom drag */
-
-			double const hx = (xr.first + xr.second) * 0.5;
-			_zoom_left = ev->x < hx;
+			_zoom_position = get_position (ev->x, ev->y);
 			_zoom_dragging = true;
 			_editor->_dragging_playhead = true;
 
-
-			/* In theory, we could support vertical dragging, which logically
-			   might scale track heights in order to make the editor reflect
-			   the dragged viewbox.  However, having tried this:
-			   a) it's hard to do
-			   b) it's quite slow
-			   c) it doesn't seem particularly useful, especially with the
-			   limited height of the summary
-
-			   So at the moment we don't support that...
-			*/
-
-
 		} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
 
 			/* secondary-modifier-click: locate playhead */
@@ -343,7 +335,7 @@ EditorSummary::on_button_press_event (GdkEventButton* ev)
 
 		} else {
 
-			/* ordinary click: start a move drag */
+			/* start a move drag */
 
 			_move_dragging = true;
 			_moved = false;
@@ -354,9 +346,13 @@ EditorSummary::on_button_press_event (GdkEventButton* ev)
 	return true;
 }
 
+/** Fill in x and y with the editor's current viewable area in summary coordinates */
 void
 EditorSummary::get_editor (pair<double, double>* x, pair<double, double>* y) const
 {
+	assert (x);
+	assert (y);
+	
 	x->first = (_editor->leftmost_position () - _start) * _x_scale;
 	x->second = x->first + _editor->current_page_frames() * _x_scale;
 
@@ -364,6 +360,98 @@ EditorSummary::get_editor (pair<double, double>* x, pair<double, double>* y) con
 	y->second = editor_y_to_summary (_editor->vertical_adjustment.get_value () + _editor->canvas_height() - _editor->get_canvas_timebars_vsize());
 }
 
+/** Get an expression of the position of a point with respect to the view rectangle */
+EditorSummary::Position
+EditorSummary::get_position (double x, double y) const
+{
+	/* how close the mouse has to be to the edge of the view rectangle to be considered `on it',
+	   in pixels */
+
+	int x_edge_size = (_view_rectangle_x.second - _view_rectangle_x.first) / 4;
+	x_edge_size = min (x_edge_size, 8);
+	x_edge_size = max (x_edge_size, 1);
+
+	int y_edge_size = (_view_rectangle_y.second - _view_rectangle_y.first) / 4;
+	y_edge_size = min (y_edge_size, 8);
+	y_edge_size = max (y_edge_size, 1);
+	
+	bool const near_left = (std::abs (x - _view_rectangle_x.first) < x_edge_size);
+	bool const near_right = (std::abs (x - _view_rectangle_x.second) < x_edge_size);
+ 	bool const near_top = (std::abs (y - _view_rectangle_y.first) < y_edge_size);
+ 	bool const near_bottom = (std::abs (y - _view_rectangle_y.second) < y_edge_size);
+	bool const within_x = _view_rectangle_x.first < x && x < _view_rectangle_x.second;
+	bool const within_y = _view_rectangle_y.first < y && y < _view_rectangle_y.second;
+
+	if (near_left && near_top) {
+		return LEFT_TOP;
+	} else if (near_left && near_bottom) {
+		return LEFT_BOTTOM;
+	} else if (near_right && near_top) {
+		return RIGHT_TOP;
+	} else if (near_right && near_bottom) {
+		return RIGHT_BOTTOM;
+	} else if (near_left && within_y) {
+		return LEFT;
+	} else if (near_right && within_y) {
+		return RIGHT;
+	} else if (near_top && within_x) {
+		return TOP;
+	} else if (near_bottom && within_x) {
+		return BOTTOM;
+	} else if (within_x && within_y) {
+		return INSIDE;
+	} else if (within_x) {
+		return BELOW_OR_ABOVE;
+	} else if (within_y) {
+		return TO_LEFT_OR_RIGHT;
+	} else {
+		return OTHERWISE_OUTSIDE;
+	}
+}
+
+void
+EditorSummary::set_cursor (Position p)
+{
+	switch (p) {
+	case LEFT:
+		get_window()->set_cursor (*_editor->_cursors->resize_left);
+		break;
+	case LEFT_TOP:
+		get_window()->set_cursor (*_editor->_cursors->resize_top_left);
+		break;
+	case TOP:
+		get_window()->set_cursor (*_editor->_cursors->resize_top);
+		break;
+	case RIGHT_TOP:
+		get_window()->set_cursor (*_editor->_cursors->resize_top_right);
+		break;
+	case RIGHT:
+		get_window()->set_cursor (*_editor->_cursors->resize_right);
+		break;
+	case RIGHT_BOTTOM:
+		get_window()->set_cursor (*_editor->_cursors->resize_bottom_right);
+		break;
+	case BOTTOM:
+		get_window()->set_cursor (*_editor->_cursors->resize_bottom);
+		break;
+	case LEFT_BOTTOM:
+		get_window()->set_cursor (*_editor->_cursors->resize_bottom_left);
+		break;
+	case INSIDE:
+		get_window()->set_cursor (*_editor->_cursors->move);
+		break;
+	case TO_LEFT_OR_RIGHT:
+		get_window()->set_cursor (*_editor->_cursors->expand_left_right);
+		break;
+	case BELOW_OR_ABOVE:
+		get_window()->set_cursor (*_editor->_cursors->expand_up_down);
+		break;
+	default:
+		get_window()->set_cursor ();
+		break;
+	}
+}
+
 bool
 EditorSummary::on_motion_notify_event (GdkEventMotion* ev)
 {
@@ -376,13 +464,13 @@ EditorSummary::on_motion_notify_event (GdkEventMotion* ev)
 		_moved = true;
 
 		/* don't alter x if we clicked outside and above or below the viewbox */
-		if (_start_position == IN_VIEWBOX || _start_position == TO_LEFT_OR_RIGHT_OF_VIEWBOX) {
+		if (_start_position == INSIDE || _start_position == TO_LEFT_OR_RIGHT || _start_position == OTHERWISE_OUTSIDE) {
 			xr.first += ev->x - _start_mouse_x;
 			xr.second += ev->x - _start_mouse_x;
 		}
 
 		/* don't alter y if we clicked outside and to the left or right of the viewbox */
-		if (_start_position == IN_VIEWBOX || _start_position == BELOW_OR_ABOVE_VIEWBOX) {
+		if (_start_position == INSIDE || _start_position == BELOW_OR_ABOVE) {
 			y += ev->y - _start_mouse_y;
 		}
 
@@ -396,18 +484,33 @@ EditorSummary::on_motion_notify_event (GdkEventMotion* ev)
 		}
 
 		set_editor (xr, y);
+		set_cursor (_start_position);
 
 	} else if (_zoom_dragging) {
 
 		double const dx = ev->x - _start_mouse_x;
+		double const dy = ev->y - _start_mouse_y;
 
-		if (_zoom_left) {
+		if (_zoom_position == LEFT || _zoom_position == LEFT_TOP || _zoom_position == LEFT_BOTTOM) {
 			xr.first += dx;
-		} else {
+		} else if (_zoom_position == RIGHT || _zoom_position == RIGHT_TOP || _zoom_position == RIGHT_BOTTOM) {
 			xr.second += dx;
 		}
 
-		set_editor (xr, y);
+		if (_zoom_position == TOP || _zoom_position == LEFT_TOP || _zoom_position == RIGHT_TOP) {
+			yr.first += dy;
+		} else if (_zoom_position == BOTTOM || _zoom_position == LEFT_BOTTOM || _zoom_position == RIGHT_BOTTOM) {
+			yr.second += dy;
+		}
+
+		set_overlays_dirty ();
+		set_cursor (_zoom_position);
+		set_editor (xr, yr);
+
+	} else {
+
+		set_cursor (get_position (ev->x, ev->y));
+
 	}
 
 	return true;
@@ -494,6 +597,52 @@ EditorSummary::set_editor (pair<double,double> const & x, double const y)
 		return;
 	}
 	
+	set_editor_x (x);
+	set_editor_y (y);
+}
+
+/** Set the editor to display given x and y ranges.  x zoom and track heights are
+ *  adjusted if necessary.
+ *  x and y parameters are specified in summary coordinates.
+ */
+void
+EditorSummary::set_editor (pair<double,double> const & x, pair<double, double> const & y)
+{
+	if (_editor->pending_visual_change.idle_handler_id >= 0) {
+		/* see comment in other set_editor () */
+		return;
+	}
+
+	set_editor_x (x);
+	set_editor_y (y);
+}
+
+/** Set the x range visible in the editor.
+ *  Caller should have checked that Editor::pending_visual_change.idle_handler_id is < 0
+ *  @param x new x range in summary coordinates.
+ */
+void
+EditorSummary::set_editor_x (pair<double, double> const & x)
+{
+	_editor->reset_x_origin (x.first / _x_scale + _start);
+
+	double const nx = (
+		((x.second - x.first) / _x_scale) /
+		_editor->frame_to_unit (_editor->current_page_frames())
+		);
+	
+	if (nx != _editor->get_current_zoom ()) {
+		_editor->reset_zoom (nx);
+	}	
+}
+
+/** Set the top of the y range visible in the editor.
+ *  Caller should have checked that Editor::pending_visual_change.idle_handler_id is < 0
+ *  @param y new editor top in summary coodinates.
+ */
+void
+EditorSummary::set_editor_y (double const y)
+{
 	double y1 = summary_y_to_editor (y);
 	double const eh = _editor->canvas_height() - _editor->get_canvas_timebars_vsize ();
 	double y2 = y1 + eh;
@@ -508,21 +657,90 @@ EditorSummary::set_editor (pair<double,double> const & x, double const y)
 		y1 = 0;
 	}
 
-	_editor->reset_x_origin (x.first / _x_scale + _start);
 	_editor->reset_y_origin (y1);
+}
+
+/** Set the y range visible in the editor.  This is achieved by scaling track heights,
+ *  if necessary.
+ *  Caller should have checked that Editor::pending_visual_change.idle_handler_id is < 0
+ *  @param y new editor range in summary coodinates.
+ */
+void
+EditorSummary::set_editor_y (pair<double, double> const & y)
+{
+	/* Compute current height of tracks between y.first and y.second.  We add up
+	   the total height into `total_height' and the height of complete tracks into
+	   `scale height'.
+	*/
+
+	/* Copy of target range for use below */
+	pair<double, double> yc = y;
+	/* Total height of all tracks */
+	double total_height = 0;
+	/* Height of any parts of tracks that aren't fully in the desired range */
+	double partial_height = 0;
+	/* Height of any tracks that are fully in the desired range */
+	double scale_height = 0;
 	
-	double const nx = (
-		((x.second - x.first) / _x_scale) /
-		_editor->frame_to_unit (_editor->current_page_frames())
-		);
+	_editor->_routes->suspend_redisplay ();
+
+	for (TrackViewList::const_iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
+
+		if ((*i)->hidden()) {
+			continue;
+		}
+		
+		double const h = (*i)->effective_height ();
+		total_height += h;
+
+		if (yc.first > 0 && yc.first < _track_height) {
+			partial_height += (_track_height - yc.first) * h / _track_height;
+		} else if (yc.first <= 0 && yc.second >= _track_height) {
+			scale_height += h;
+		} else if (yc.second > 0 && yc.second < _track_height) {
+			partial_height += yc.second * h / _track_height;
+			break;
+		}
+
+		yc.first -= _track_height;
+		yc.second -= _track_height;
+	}
+
+	/* Height that we will use for scaling; use the whole editor height unless there are not
+	   enough tracks to fill it.
+	*/
+	double const ch = min (total_height, _editor->canvas_height() - _editor->get_canvas_timebars_vsize());
 	
-	if (nx != _editor->get_current_zoom ()) {
-		_editor->reset_zoom (nx);
-	}	
+	/* hence required scale factor of the complete tracks to fit the required y range;
+	   the amount of space they should take up divided by the amount they currently take up.
+	*/
+	double const scale = (ch - partial_height) / scale_height;
+
+	yc = y;
+
+	/* Scale complete tracks within the range to make it fit */
+	
+	for (TrackViewList::const_iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
+
+		if ((*i)->hidden()) {
+			continue;
+		}
+
+		if (yc.first <= 0 && yc.second >= _track_height) {
+			(*i)->set_height (max (TimeAxisView::preset_height (HeightSmall), (uint32_t) ((*i)->effective_height() * scale)));
+		}
+
+		yc.first -= _track_height;
+		yc.second -= _track_height;
+	}
+
+	_editor->_routes->resume_redisplay ();
+	
+        set_editor_y (y.first);
 }
 
 void
-EditorSummary::playhead_position_changed (nframes64_t p)
+EditorSummary::playhead_position_changed (framepos_t p)
 {
 	if (_session && int (p * _x_scale) != int (_last_playhead)) {
 		set_overlays_dirty ();
@@ -533,8 +751,12 @@ double
 EditorSummary::summary_y_to_editor (double y) const
 {
 	double ey = 0;
-	TrackViewList::const_iterator i = _editor->track_views.begin ();
-	while (i != _editor->track_views.end()) {
+	for (TrackViewList::const_iterator i = _editor->track_views.begin (); i != _editor->track_views.end(); ++i) {
+		
+		if ((*i)->hidden()) {
+			continue;
+		}
+		
 		double const h = (*i)->effective_height ();
 		if (y < _track_height) {
 			/* in this track */
@@ -543,7 +765,6 @@ EditorSummary::summary_y_to_editor (double y) const
 
 		ey += h;
 		y -= _track_height;
-		++i;
 	}
 
 	return ey;
@@ -553,8 +774,12 @@ double
 EditorSummary::editor_y_to_summary (double y) const
 {
 	double sy = 0;
-	TrackViewList::const_iterator i = _editor->track_views.begin ();
-	while (i != _editor->track_views.end()) {
+	for (TrackViewList::const_iterator i = _editor->track_views.begin (); i != _editor->track_views.end(); ++i) {
+		
+		if ((*i)->hidden()) {
+			continue;
+		}
+
 		double const h = (*i)->effective_height ();
 		if (y < h) {
 			/* in this track */
@@ -563,7 +788,6 @@ EditorSummary::editor_y_to_summary (double y) const
 
 		sy += _track_height;
 		y -= h;
-		++i;
 	}
 
 	return sy;