X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_canvas.cc;h=6413b6d6910de00031a27aecd6851676a0711b76;hb=46c83693284ece4a732d26e62113ea4ac584d539;hp=13057dc3b2d0134035e5f4d3ad90dbdb95be4ed8;hpb=f552c1cc5c91b60e6d0af3ccc442d439db1dd8b8;p=ardour.git

diff --git a/gtk2_ardour/editor_canvas.cc b/gtk2_ardour/editor_canvas.cc
index 13057dc3b2..6413b6d691 100644
--- a/gtk2_ardour/editor_canvas.cc
+++ b/gtk2_ardour/editor_canvas.cc
@@ -27,6 +27,8 @@
 #include "ardour/rc_configuration.h"
 #include "ardour/smf_source.h"
 
+#include "pbd/error.h"
+
 #include "canvas/canvas.h"
 #include "canvas/rectangle.h"
 #include "canvas/pixbuf.h"
@@ -56,6 +58,7 @@
 
 using namespace std;
 using namespace ARDOUR;
+using namespace ARDOUR_UI_UTILS;
 using namespace PBD;
 using namespace Gtk;
 using namespace Glib;
@@ -68,9 +71,20 @@ Editor::initialize_canvas ()
 	_track_canvas_viewport = new ArdourCanvas::GtkCanvasViewport (horizontal_adjustment, vertical_adjustment);
 	_track_canvas = _track_canvas_viewport->canvas ();
 
+	_track_canvas->set_background_color (ARDOUR_UI::config()->color ("arrange base"));
+
+	/* scroll group for items that should not automatically scroll
+	 *  (e.g verbose cursor). It shares the canvas coordinate space.
+	*/
+	no_scroll_group = new ArdourCanvas::Container (_track_canvas->root());
+
 	ArdourCanvas::ScrollGroup* hsg; 
 	ArdourCanvas::ScrollGroup* hg;
-	ArdourCanvas::ScrollGroup* vg;
+	ArdourCanvas::ScrollGroup* cg;
+
+	h_scroll_group = hg = new ArdourCanvas::ScrollGroup (_track_canvas->root(), ArdourCanvas::ScrollGroup::ScrollsHorizontally);
+	CANVAS_DEBUG_NAME (h_scroll_group, "canvas h scroll");
+	_track_canvas->add_scroller (*hg);
 
 	hv_scroll_group = hsg = new ArdourCanvas::ScrollGroup (_track_canvas->root(), 
 							       ArdourCanvas::ScrollGroup::ScrollSensitivity (ArdourCanvas::ScrollGroup::ScrollsVertically|
@@ -78,13 +92,9 @@ Editor::initialize_canvas ()
 	CANVAS_DEBUG_NAME (hv_scroll_group, "canvas hv scroll");
 	_track_canvas->add_scroller (*hsg);
 
-	v_scroll_group = vg = new ArdourCanvas::ScrollGroup (_track_canvas->root(), ArdourCanvas::ScrollGroup::ScrollsVertically);
-	CANVAS_DEBUG_NAME (v_scroll_group, "canvas v scroll");
-	_track_canvas->add_scroller (*vg);
-
-	h_scroll_group = hg = new ArdourCanvas::ScrollGroup (_track_canvas->root(), ArdourCanvas::ScrollGroup::ScrollsHorizontally);
-	CANVAS_DEBUG_NAME (h_scroll_group, "canvas h scroll");
-	_track_canvas->add_scroller (*hg);
+	cursor_scroll_group = cg = new ArdourCanvas::ScrollGroup (_track_canvas->root(), ArdourCanvas::ScrollGroup::ScrollsHorizontally);
+	CANVAS_DEBUG_NAME (cursor_scroll_group, "canvas cursor scroll");
+	_track_canvas->add_scroller (*cg);
 
 	_verbose_cursor = new VerboseCursor (this);
 
@@ -101,7 +111,7 @@ Editor::initialize_canvas ()
 	}
 
 	/*a group to hold global rects like punch/loop indicators */
-	global_rect_group = new ArdourCanvas::Group (hv_scroll_group);
+	global_rect_group = new ArdourCanvas::Container (hv_scroll_group);
 	CANVAS_DEBUG_NAME (global_rect_group, "global rect group");
 
         transport_loop_range_rect = new ArdourCanvas::Rectangle (global_rect_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, ArdourCanvas::COORD_MAX));
@@ -113,17 +123,12 @@ Editor::initialize_canvas ()
 	transport_punch_range_rect->hide();
 
 	/*a group to hold time (measure) lines */
-	time_line_group = new ArdourCanvas::Group (hv_scroll_group);
+	time_line_group = new ArdourCanvas::Container (h_scroll_group);
 	CANVAS_DEBUG_NAME (time_line_group, "time line group");
 
-	_trackview_group = new ArdourCanvas::Group (hv_scroll_group);
+	_trackview_group = new ArdourCanvas::Container (hv_scroll_group);
 	CANVAS_DEBUG_NAME (_trackview_group, "Canvas TrackViews");
 	
-	// used to show zoom mode active zooming
-	zoom_rect = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, 0.0));
-	zoom_rect->hide();
-	zoom_rect->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_zoom_rect_event), (ArdourCanvas::Item*) 0));
-
 	// used as rubberband rect
 	rubberband_rect = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, 0.0));
 	rubberband_rect->hide();
@@ -131,30 +136,30 @@ Editor::initialize_canvas ()
 	/* a group to hold stuff while it gets dragged around. Must be the
 	 * uppermost (last) group with hv_scroll_group as a parent
 	 */
-	_drag_motion_group = new ArdourCanvas::Group (hv_scroll_group);                                                                                                                                     
+	_drag_motion_group = new ArdourCanvas::Container (hv_scroll_group);                                                                                                                                     
         CANVAS_DEBUG_NAME (_drag_motion_group, "Canvas Drag Motion");
 
 	/* TIME BAR CANVAS */
 	
-	_time_markers_group = new ArdourCanvas::Group (h_scroll_group);
+	_time_markers_group = new ArdourCanvas::Container (h_scroll_group);
 	CANVAS_DEBUG_NAME (_time_markers_group, "time bars");
 
-	cd_marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, 0.0));
+	cd_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, 0.0));
 	CANVAS_DEBUG_NAME (cd_marker_group, "cd marker group");
 	/* the vide is temporarily placed a the same location as the
 	   cd_marker_group, but is moved later.
 	*/
-	videotl_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple(0.0, 0.0));
+	videotl_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple(0.0, 0.0));
 	CANVAS_DEBUG_NAME (videotl_group, "videotl group");
-	marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height + 1.0));
+	marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height + 1.0));
 	CANVAS_DEBUG_NAME (marker_group, "marker group");
-	transport_marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 2.0) + 1.0));
+	transport_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 2.0) + 1.0));
 	CANVAS_DEBUG_NAME (transport_marker_group, "transport marker group");
-	range_marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 3.0) + 1.0));
+	range_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 3.0) + 1.0));
 	CANVAS_DEBUG_NAME (range_marker_group, "range marker group");
-	tempo_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 4.0) + 1.0));
+	tempo_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 4.0) + 1.0));
 	CANVAS_DEBUG_NAME (tempo_group, "tempo group");
-	meter_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 5.0) + 1.0));
+	meter_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 5.0) + 1.0));
 	CANVAS_DEBUG_NAME (meter_group, "meter group");
 
 	meter_bar = new ArdourCanvas::Rectangle (meter_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
@@ -226,7 +231,6 @@ Editor::initialize_canvas ()
 		logo_item->lower_to_bottom ();
 	}
 
-
 	_canvas_drop_zone = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, 0.0));
 	/* this thing is transparent */
 	_canvas_drop_zone->set_fill (false);
@@ -319,7 +323,7 @@ Editor::track_canvas_viewport_size_allocated ()
 void
 Editor::reset_controls_layout_width ()
 {
-	GtkRequisition req;
+	GtkRequisition req = { 0, 0 };
 	gint w;
 
 	edit_controls_vbox.size_request (req);
@@ -364,8 +368,10 @@ Editor::reset_controls_layout_height (int32_t h)
 bool
 Editor::track_canvas_map_handler (GdkEventAny* /*ev*/)
 {
-	if (current_canvas_cursor) {
-		set_canvas_cursor (current_canvas_cursor);
+	if (!_cursor_stack.empty()) {
+		set_canvas_cursor (get_canvas_cursor());
+	} else {
+		PBD::error << "cursor stack is empty" << endmsg;
 	}
 	return false;
 }
@@ -413,7 +419,7 @@ Editor::drop_paths_part_two (const vector<string>& paths, framepos_t frame, doub
 	}
 
 
-	std::pair<TimeAxisView*, int> const tvp = trackview_by_y_position (ypos);
+	std::pair<TimeAxisView*, int> const tvp = trackview_by_y_position (ypos, false);
 	if (tvp.first == 0) {
 
 		/* drop onto canvas background: create new tracks */
@@ -422,7 +428,7 @@ Editor::drop_paths_part_two (const vector<string>& paths, framepos_t frame, doub
 
 		do_import (midi_paths, Editing::ImportDistinctFiles, ImportAsTrack, SrcBest, frame);
 		
-		if (Profile->get_sae() || Config->get_only_copy_imported_files() || copy) {
+		if (Profile->get_sae() || ARDOUR_UI::config()->get_only_copy_imported_files() || copy) {
 			do_import (audio_paths, Editing::ImportDistinctFiles, Editing::ImportAsTrack, SrcBest, frame);
 		} else {
 			do_embed (audio_paths, Editing::ImportDistinctFiles, ImportAsTrack, frame);
@@ -438,7 +444,7 @@ Editor::drop_paths_part_two (const vector<string>& paths, framepos_t frame, doub
 
 			do_import (midi_paths, Editing::ImportSerializeFiles, ImportToTrack, SrcBest, frame);
 
-			if (Profile->get_sae() || Config->get_only_copy_imported_files() || copy) {
+			if (Profile->get_sae() || ARDOUR_UI::config()->get_only_copy_imported_files() || copy) {
 				do_import (audio_paths, Editing::ImportSerializeFiles, Editing::ImportToTrack, SrcBest, frame);
 			} else {
 				do_embed (audio_paths, Editing::ImportSerializeFiles, ImportToTrack, frame);
@@ -494,7 +500,7 @@ Editor::drop_paths (const RefPtr<Gdk::DragContext>& context,
 void
 Editor::maybe_autoscroll (bool allow_horiz, bool allow_vert, bool from_headers)
 {
-	if (!Config->get_autoscroll_editor () || autoscroll_active ()) {
+	if (!ARDOUR_UI::config()->get_autoscroll_editor () || autoscroll_active ()) {
 		return;
 	}
 
@@ -511,14 +517,11 @@ Editor::maybe_autoscroll (bool allow_horiz, bool allow_vert, bool from_headers)
 
 	ArdourCanvas::Rect scrolling_boundary;
 	Gtk::Allocation alloc;
-	int cx, cy;
 
 	if (from_headers) {
 		alloc = controls_layout.get_allocation ();
 	} else {	
 		alloc = _track_canvas_viewport->get_allocation ();
-		cx = alloc.get_x();
-		cy = alloc.get_y();
 
 		/* reduce height by the height of the timebars, which happens
 		   to correspond to the position of the hv_scroll_group.
@@ -575,7 +578,6 @@ Editor::autoscroll_canvas ()
 	Gdk::ModifierType mask;
 	frameoffset_t dx = 0;
 	bool no_stop = false;
-	bool y_motion = false;
 
 	get_window()->get_pointer (x, y, mask);
 
@@ -638,14 +640,14 @@ Editor::autoscroll_canvas ()
 			/* scroll to make higher tracks visible */
 
 			if (autoscroll_cnt && (autoscroll_cnt % speed_factor == 0)) {
-				y_motion = scroll_up_one_track ();
+				scroll_up_one_track ();
 				vertical_motion = true;
 			}
 
 		} else if (y > autoscroll_boundary.y1) {
 
 			if (autoscroll_cnt && (autoscroll_cnt % speed_factor == 0)) {
-				y_motion = scroll_down_one_track ();
+				scroll_down_one_track ();
 				vertical_motion = true;
 			}
 		}
@@ -779,6 +781,17 @@ Editor::stop_canvas_autoscroll ()
 	autoscroll_connection.disconnect ();
 }
 
+Editor::EnterContext*
+Editor::get_enter_context(ItemType type)
+{
+	for (ssize_t i = _enter_stack.size() - 1; i >= 0; --i) {
+		if (_enter_stack[i].item_type == type) {
+			return &_enter_stack[i];
+		}
+	}
+	return NULL;
+}
+
 bool
 Editor::left_track_canvas (GdkEventCrossing */*ev*/)
 {
@@ -799,26 +812,48 @@ Editor::entered_track_canvas (GdkEventCrossing */*ev*/)
 }
 
 void
-Editor::_ensure_time_axis_view_is_visible (const TimeAxisView& tav, bool at_top)
+Editor::ensure_time_axis_view_is_visible (TimeAxisView const & track, bool at_top)
 {
-	double begin = tav.y_position();
-	double v = vertical_adjustment.get_value ();
-
-	if (!at_top && (begin < v || begin + tav.current_height() > v + _visible_canvas_height)) {
-		/* try to put the TimeAxisView roughly central */
-		if (begin >= _visible_canvas_height/2.0) {
-			begin -= _visible_canvas_height/2.0;
-		}
+	if (track.hidden()) {
+		return;
 	}
 
-	/* Clamp the y pos so that we do not extend beyond the canvas full
-	 * height. 
+	/* compute visible area of trackview group, as offsets from top of
+	 * trackview group.
 	 */
-	if (_full_canvas_height - begin < _visible_canvas_height){
-		begin = _full_canvas_height - _visible_canvas_height;
+
+	double const current_view_min_y = vertical_adjustment.get_value();
+	double const current_view_max_y = current_view_min_y + vertical_adjustment.get_page_size();
+
+	double const track_min_y = track.y_position ();
+	double const track_max_y = track.y_position () + track.effective_height ();
+
+	if (!at_top && 
+	    (track_min_y >= current_view_min_y &&
+	     track_max_y < current_view_max_y)) {
+		/* already visible, and caller did not ask to place it at the
+		 * top of the track canvas
+		 */
+		return;
+	}
+
+	double new_value;
+
+	if (at_top) {
+		new_value = track_min_y;
+	} else {
+		if (track_min_y < current_view_min_y) {
+			// Track is above the current view
+			new_value = track_min_y;
+		} else if (track_max_y > current_view_max_y) {
+			// Track is below the current view
+			new_value = track.y_position () + track.effective_height() - vertical_adjustment.get_page_size();
+		} else {
+			new_value = track_min_y;
+		}
 	}
 
-	vertical_adjustment.set_value (begin);
+	vertical_adjustment.set_value(new_value);
 }
 
 /** Called when the main vertical_adjustment has changed */
@@ -850,8 +885,8 @@ Editor::set_horizontal_position (double p)
 void
 Editor::color_handler()
 {
-	ArdourCanvas::Color base = ARDOUR_UI::config()->get_canvasvar_RulerBase();
-	ArdourCanvas::Color text = ARDOUR_UI::config()->get_canvasvar_RulerText();
+	ArdourCanvas::Color base = ARDOUR_UI::config()->color ("ruler base");
+	ArdourCanvas::Color text = ARDOUR_UI::config()->color ("ruler text");
 	timecode_ruler->set_fill_color (base);
 	timecode_ruler->set_outline_color (text);
 	minsec_ruler->set_fill_color (base);
@@ -861,58 +896,59 @@ Editor::color_handler()
 	bbt_ruler->set_fill_color (base);
 	bbt_ruler->set_outline_color (text);
 	
-	playhead_cursor->set_color (ARDOUR_UI::config()->get_canvasvar_PlayHead());
-	_verbose_cursor->set_color (ARDOUR_UI::config()->get_canvasvar_VerboseCanvasCursor());
-
-	meter_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_MeterBar());
-	meter_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
+	playhead_cursor->set_color (ARDOUR_UI::config()->color ("play head"));
 
-	tempo_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TempoBar());
-	tempo_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
+	meter_bar->set_fill_color (ARDOUR_UI::config()->color_mod ("meter bar", "marker bar"));
+	meter_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator"));
 
-	marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_MarkerBar());
-	marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
+	tempo_bar->set_fill_color (ARDOUR_UI::config()->color_mod ("tempo bar", "marker bar"));
+	tempo_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator"));
 
-	cd_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_CDMarkerBar());
-	cd_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
+	marker_bar->set_fill_color (ARDOUR_UI::config()->color_mod ("marker bar", "marker bar"));
+	marker_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator"));
 
-	range_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeMarkerBar());
-	range_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
+	cd_marker_bar->set_fill_color (ARDOUR_UI::config()->color_mod ("cd marker bar", "marker bar"));
+	cd_marker_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator"));
 
-	transport_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportMarkerBar());
-	transport_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
+	range_marker_bar->set_fill_color (ARDOUR_UI::config()->color_mod ("range marker bar", "marker bar"));
+	range_marker_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator"));
 
-	cd_marker_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
-	cd_marker_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
+	transport_marker_bar->set_fill_color (ARDOUR_UI::config()->color_mod ("transport marker bar", "marker bar"));
+	transport_marker_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator"));
 
-	range_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
-	range_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
+	cd_marker_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->color ("range drag bar rect"));
+	cd_marker_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->color ("range drag bar rect"));
 
-	transport_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportDragRect());
-	transport_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportDragRect());
+	range_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->color ("range drag bar rect"));
+	range_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->color ("range drag bar rect"));
 
-	transport_loop_range_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportLoopRect());
-	transport_loop_range_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportLoopRect());
+	transport_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->color ("transport drag rect"));
+	transport_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->color ("transport drag rect"));
 
-	transport_punch_range_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportPunchRect());
-	transport_punch_range_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportPunchRect());
+	transport_loop_range_rect->set_fill_color (ARDOUR_UI::config()->color_mod ("transport loop rect", "loop rectangle"));
+	transport_loop_range_rect->set_outline_color (ARDOUR_UI::config()->color ("transport loop rect"));
 
-	transport_punchin_line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_PunchLine());
-	transport_punchout_line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_PunchLine());
+	transport_punch_range_rect->set_fill_color (ARDOUR_UI::config()->color ("transport punch rect"));
+	transport_punch_range_rect->set_outline_color (ARDOUR_UI::config()->color ("transport punch rect"));
 
-	zoom_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_ZoomRect());
-	zoom_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_ZoomRect());
+	transport_punchin_line->set_outline_color (ARDOUR_UI::config()->color ("punch line"));
+	transport_punchout_line->set_outline_color (ARDOUR_UI::config()->color ("punch line"));
 
-	rubberband_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RubberBandRect());
-	rubberband_rect->set_fill_color ((guint32) ARDOUR_UI::config()->get_canvasvar_RubberBandRect());
+	rubberband_rect->set_outline_color (ARDOUR_UI::config()->color ("rubber band rect"));
+	rubberband_rect->set_fill_color (ARDOUR_UI::config()->color_mod ("rubber band rect", "selection rect"));
 
-	location_marker_color = ARDOUR_UI::config()->get_canvasvar_LocationMarker();
-	location_range_color = ARDOUR_UI::config()->get_canvasvar_LocationRange();
-	location_cd_marker_color = ARDOUR_UI::config()->get_canvasvar_LocationCDMarker();
-	location_loop_color = ARDOUR_UI::config()->get_canvasvar_LocationLoop();
-	location_punch_color = ARDOUR_UI::config()->get_canvasvar_LocationPunch();
+	location_marker_color = ARDOUR_UI::config()->color ("location marker");
+	location_range_color = ARDOUR_UI::config()->color ("location range");
+	location_cd_marker_color = ARDOUR_UI::config()->color ("location cd marker");
+	location_loop_color = ARDOUR_UI::config()->color ("location loop");
+	location_punch_color = ARDOUR_UI::config()->color ("location punch");
 
 	refresh_location_display ();
+
+	/* redraw the whole thing */
+	_track_canvas->set_background_color (ARDOUR_UI::config()->color ("arrange base"));
+	_track_canvas->queue_draw ();
+        
 /*
 	redisplay_tempo (true);
 
@@ -930,21 +966,12 @@ Editor::horizontal_position () const
 bool
 Editor::track_canvas_key_press (GdkEventKey*)
 {
-	/* XXX: event does not report the modifier key pressed down, AFAICS, so use the Keyboard object instead */
-	if (mouse_mode == Editing::MouseZoom && Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
-		set_canvas_cursor (_cursors->zoom_out, true);
-	}
-
 	return false;
 }
 
 bool
 Editor::track_canvas_key_release (GdkEventKey*)
 {
-	if (mouse_mode == Editing::MouseZoom && !Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
-		set_canvas_cursor (_cursors->zoom_in, true);
-	}
-
 	return false;
 }
 
@@ -973,36 +1000,57 @@ Editor::get_track_canvas() const
 	return _track_canvas_viewport;
 }
 
-void
-Editor::set_canvas_cursor (Gdk::Cursor* cursor, bool save)
+Gdk::Cursor*
+Editor::get_canvas_cursor () const
 {
-	if (save) {
-		current_canvas_cursor = cursor;
-	}
+	/* The top of the cursor stack is always the currently visible cursor. */
+	return _cursor_stack.back();
+}
 
+void
+Editor::set_canvas_cursor (Gdk::Cursor* cursor)
+{
 	Glib::RefPtr<Gdk::Window> win = _track_canvas->get_window();
 
-	if (win && cursor) {
-	        win->set_cursor (*cursor);
+	if (win && !_cursors->is_invalid (cursor)) {
+		/* glibmm 2.4 doesn't allow null cursor pointer because it uses
+		   a Gdk::Cursor& as the argument to Gdk::Window::set_cursor().
+		   But a null pointer just means "use parent window cursor",
+		   and so should be allowed. Gtkmm 3.x has fixed this API.
+
+		   For now, drop down and use C API
+		*/
+		gdk_window_set_cursor (win->gobj(), cursor ? cursor->gobj() : 0);
 	}
 }
 
-void
+size_t
 Editor::push_canvas_cursor (Gdk::Cursor* cursor)
 {
-	if (cursor) {
-		_cursor_stack.push (cursor);
-		set_canvas_cursor (cursor, false);
+	if (!_cursors->is_invalid (cursor)) {
+		_cursor_stack.push_back (cursor);
+		set_canvas_cursor (cursor);
 	}
+	return _cursor_stack.size() - 1;
 }
 
 void
 Editor::pop_canvas_cursor ()
 {
-	if (!_cursor_stack.empty()) {
-		Gdk::Cursor* cursor = _cursor_stack.top ();
-		_cursor_stack.pop ();
-		set_canvas_cursor (cursor, false);
+	while (true) {
+		if (_cursor_stack.size() <= 1) {
+			PBD::error << "attempt to pop default cursor" << endmsg;
+			return;
+		}
+
+		_cursor_stack.pop_back();
+		if (_cursor_stack.back()) {
+			/* Popped to an existing cursor, we're done.  Otherwise, the
+			   context that created this cursor has been destroyed, so we need
+			   to skip to the next down the stack. */
+			set_canvas_cursor (_cursor_stack.back());
+			return;
+		}
 	}
 }
 
@@ -1011,41 +1059,16 @@ Editor::which_grabber_cursor () const
 {
 	Gdk::Cursor* c = _cursors->grabber;
 
-	if (_internal_editing) {
-		switch (mouse_mode) {
-		case MouseDraw:
-			c = _cursors->midi_pencil;
-			break;
-
-		case MouseObject:
-			c = _cursors->grabber_note;
-			break;
-
-		case MouseTimeFX:
-			c = _cursors->midi_resize;
-			break;
-			
-		case MouseRange:
-			c = _cursors->grabber_note;
-			break;
-
-		default:
-			break;
-		}
-
-	} else {
-
-		switch (_edit_point) {
-		case EditAtMouse:
-			c = _cursors->grabber_edit_point;
-			break;
-		default:
-			boost::shared_ptr<Movable> m = _movable.lock();
-			if (m && m->locked()) {
-				c = _cursors->speaker;
-			}
-			break;
+	switch (_edit_point) {
+	case EditAtMouse:
+		c = _cursors->grabber_edit_point;
+		break;
+	default:
+		boost::shared_ptr<Movable> m = _movable.lock();
+		if (m && m->locked()) {
+			c = _cursors->speaker;
 		}
+		break;
 	}
 
 	return c;
@@ -1079,17 +1102,19 @@ Editor::which_trim_cursor (bool left) const
 Gdk::Cursor*
 Editor::which_mode_cursor () const
 {
-	Gdk::Cursor* mode_cursor = 0;
+	Gdk::Cursor* mode_cursor = MouseCursors::invalid_cursor ();
 
 	switch (mouse_mode) {
 	case MouseRange:
 		mode_cursor = _cursors->selector;
-		if (_internal_editing) {
-			mode_cursor = which_grabber_cursor();
-		}
 		break;
 
+	case MouseCut:
+		mode_cursor = _cursors->scissors;
+		break;
+			
 	case MouseObject:
+	case MouseContent:
 		/* don't use mode cursor, pick a grabber cursor based on the item */
 		break;
 
@@ -1097,18 +1122,6 @@ Editor::which_mode_cursor () const
 		mode_cursor = _cursors->midi_pencil;
 		break;
 
-	case MouseGain:
-		mode_cursor = _cursors->cross_hair;
-		break;
-
-	case MouseZoom:
-		if (Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
-			mode_cursor = _cursors->zoom_out;
-		} else {
-			mode_cursor = _cursors->zoom_in;
-		}
-		break;
-
 	case MouseTimeFX:
 		mode_cursor = _cursors->time_fx; // just use playhead
 		break;
@@ -1119,7 +1132,7 @@ Editor::which_mode_cursor () const
 	}
 
 	/* up-down cursor as a cue that automation can be dragged up and down when in join object/range mode */
-	if (!_internal_editing && get_smart_mode() ) {
+	if (get_smart_mode()) {
 
 		double x, y;
 		get_pointer_position (x, y);
@@ -1155,66 +1168,53 @@ Editor::which_mode_cursor () const
 Gdk::Cursor*
 Editor::which_track_cursor () const
 {
-	Gdk::Cursor* cursor = 0;
-
-	assert (mouse_mode == MouseObject || get_smart_mode());
+	Gdk::Cursor* cursor = MouseCursors::invalid_cursor();
 
-	if (!_internal_editing) {
-		switch (_join_object_range_state) {
-		case JOIN_OBJECT_RANGE_NONE:
-		case JOIN_OBJECT_RANGE_OBJECT:
-			cursor = which_grabber_cursor ();
-			cerr << "region use grabber\n";
-			break;
-		case JOIN_OBJECT_RANGE_RANGE:
-			cursor = _cursors->selector;
-			cerr << "region use selector\n";
-			break;
-		}
+	switch (_join_object_range_state) {
+	case JOIN_OBJECT_RANGE_NONE:
+	case JOIN_OBJECT_RANGE_OBJECT:
+		cursor = which_grabber_cursor ();
+		break;
+	case JOIN_OBJECT_RANGE_RANGE:
+		cursor = _cursors->selector;
+		break;
 	}
 
 	return cursor;
 }
 
-bool
-Editor::reset_canvas_cursor ()
+Gdk::Cursor*
+Editor::which_canvas_cursor(ItemType type) const
 {
-	if (!is_drawable()) {
-		return false;
-	}
-
 	Gdk::Cursor* cursor = which_mode_cursor ();
 
-	if (cursor) {
-		set_canvas_cursor (cursor);
-		return true;
-	}
-
-	return false;
-}
-
-void
-Editor::choose_canvas_cursor_on_entry (GdkEventCrossing* /*event*/, ItemType type)
-{
-	Gdk::Cursor* cursor = 0;
-
-	cerr << "entered new item type " << enum_2_string (type) << endl;
-
-	if (_drags->active()) {
-		return;
+	if (mouse_mode == MouseRange) {
+		switch (type) {
+		case StartSelectionTrimItem:
+			cursor = _cursors->left_side_trim;
+			break;
+		case EndSelectionTrimItem:
+			cursor = _cursors->right_side_trim;
+			break;
+		default:
+			break;
+		}
 	}
-
-	cursor = which_mode_cursor ();
-
-	if (mouse_mode == MouseObject || get_smart_mode ()) {
+	
+	if ((mouse_mode == MouseObject || get_smart_mode ()) ||
+	    mouse_mode == MouseContent) {
 
 		/* find correct cursor to use in object/smart mode */
 
 		switch (type) {
 		case RegionItem:
-		case RegionViewNameHighlight:
-		case RegionViewName:
-		case WaveItem:
+		/* We don't choose a cursor for these items on top of a region view,
+		   because this would push a new context on the enter stack which
+		   means switching the region context for things like smart mode
+		   won't actualy change the cursor. */
+		// case RegionViewNameHighlight:
+		// case RegionViewName:
+		// case WaveItem:
 		case StreamItem:
 		case AutomationTrackItem:
 			cursor = which_track_cursor ();
@@ -1236,7 +1236,7 @@ Editor::choose_canvas_cursor_on_entry (GdkEventCrossing* /*event*/, ItemType typ
 			cursor = _cursors->fader;
 			break;
 		case GainLineItem:
-			cursor = _cursors->fader;
+			cursor = _cursors->cross_hair;
 			break;
 		case AutomationLineItem:
 			cursor = _cursors->cross_hair;
@@ -1265,17 +1265,20 @@ Editor::choose_canvas_cursor_on_entry (GdkEventCrossing* /*event*/, ItemType typ
 		case FadeOutTrimHandleItem:
 			cursor = _cursors->fade_out;
 			break;
-		case NoteItem:
-			cursor = which_grabber_cursor();
-			break;
 		case FeatureLineItem:
 			cursor = _cursors->cross_hair;
 			break;
 		case LeftFrameHandle:
-			cursor = which_trim_cursor (true);
+			if ( effective_mouse_mode() == MouseObject )  // (smart mode): if the user is in the btm half, show the trim cursor
+				cursor = which_trim_cursor (true);
+			else
+				cursor = _cursors->selector;  // (smart mode): in the top half, just show the selection (range) cursor
 			break;
 		case RightFrameHandle:
-			cursor = which_trim_cursor (false);
+			if ( effective_mouse_mode() == MouseObject )  //see above
+				cursor = which_trim_cursor (false);
+			else
+				cursor = _cursors->selector;
 			break;
 		case StartCrossFadeItem:
 			cursor = _cursors->fade_in;
@@ -1286,6 +1289,28 @@ Editor::choose_canvas_cursor_on_entry (GdkEventCrossing* /*event*/, ItemType typ
 		case CrossfadeViewItem:
 			cursor = _cursors->cross_hair;
 			break;
+		case NoteItem:
+			cursor = _cursors->grabber_note;
+		default:
+			break;
+		}
+
+	} else if (mouse_mode == MouseDraw) {
+		
+		/* ControlPointItem is not really specific to region gain mode
+		   but it is the same cursor so don't worry about this for now.
+		   The result is that we'll see the fader cursor if we enter
+		   non-region-gain-line control points while in MouseDraw
+		   mode, even though we can't edit them in this mode.
+		*/
+
+		switch (type) {
+		case GainLineItem:
+		case ControlPointItem:
+			cursor = _cursors->fader;
+			break;
+		case NoteItem:
+			cursor = _cursors->grabber_note;
 		default:
 			break;
 		}
@@ -1311,6 +1336,7 @@ Editor::choose_canvas_cursor_on_entry (GdkEventCrossing* /*event*/, ItemType typ
 	case CdMarkerBarItem:
 	case VideoBarItem:
 	case TransportMarkerBarItem:
+	case DropZoneItem:
 		cursor = which_grabber_cursor();
 		break;
 
@@ -1318,7 +1344,39 @@ Editor::choose_canvas_cursor_on_entry (GdkEventCrossing* /*event*/, ItemType typ
 		break;
 	}
 
-	if (cursor) {
-		set_canvas_cursor (cursor, false);
+	return cursor;
+}
+
+void
+Editor::choose_canvas_cursor_on_entry (ItemType type)
+{
+	if (_drags->active()) {
+		return;
+	}
+
+	Gdk::Cursor* cursor = which_canvas_cursor(type);
+
+	if (!_cursors->is_invalid (cursor)) {
+		// Push a new enter context
+		const EnterContext ctx = { type, CursorContext::create(*this, cursor) };
+		_enter_stack.push_back(ctx);
+	}
+}
+
+void
+Editor::update_all_enter_cursors ()
+{
+	for (std::vector<EnterContext>::iterator i = _enter_stack.begin(); i != _enter_stack.end(); ++i) {
+		i->cursor_ctx->change(which_canvas_cursor(i->item_type));
+	}
+}
+
+double
+Editor::trackviews_height() const
+{
+	if (!_trackview_group) {
+		return 0;
 	}
+
+	return _visible_canvas_height - _trackview_group->canvas_origin().y;
 }