gtk2_ardour/editor_canvas.cc

   1 /*
   2     Copyright (C) 2005 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include "gtkmm2ext/utils.h"
  25
  26 #include "ardour/profile.h"
  27 #include "ardour/rc_configuration.h"
  28 #include "ardour/smf_source.h"
  29
  30 #include "pbd/error.h"
  31
  32 #include "canvas/canvas.h"
  33 #include "canvas/rectangle.h"
  34 #include "canvas/pixbuf.h"
  35 #include "canvas/scroll_group.h"
  36 #include "canvas/text.h"
  37 #include "canvas/debug.h"
  38
  39 #include "ardour_ui.h"
  40 #include "automation_time_axis.h"
  41 #include "editor.h"
  42 #include "editing.h"
  43 #include "rgb_macros.h"
  44 #include "utils.h"
  45 #include "audio_time_axis.h"
  46 #include "editor_drag.h"
  47 #include "region_view.h"
  48 #include "editor_group_tabs.h"
  49 #include "editor_summary.h"
  50 #include "video_timeline.h"
  51 #include "keyboard.h"
  52 #include "editor_cursors.h"
  53 #include "mouse_cursors.h"
  54 #include "ui_config.h"
  55 #include "verbose_cursor.h"
  56
  57 #include "i18n.h"
  58
  59 using namespace std;
  60 using namespace ARDOUR;
  61 using namespace ARDOUR_UI_UTILS;
  62 using namespace PBD;
  63 using namespace Gtk;
  64 using namespace Glib;
  65 using namespace Gtkmm2ext;
  66 using namespace Editing;
  67
  68 void
  69 Editor::initialize_canvas ()
  70 {
  71         _track_canvas_viewport = new ArdourCanvas::GtkCanvasViewport (horizontal_adjustment, vertical_adjustment);
  72         _track_canvas = _track_canvas_viewport->canvas ();
  73
  74         _track_canvas->set_background_color (UIConfiguration::instance().color ("arrange base"));
  75
  76         /* scroll group for items that should not automatically scroll
  77          *  (e.g verbose cursor). It shares the canvas coordinate space.
  78         */
  79         no_scroll_group = new ArdourCanvas::Container (_track_canvas->root());
  80
  81         ArdourCanvas::ScrollGroup* hsg;
  82         ArdourCanvas::ScrollGroup* hg;
  83         ArdourCanvas::ScrollGroup* cg;
  84
  85         h_scroll_group = hg = new ArdourCanvas::ScrollGroup (_track_canvas->root(), ArdourCanvas::ScrollGroup::ScrollsHorizontally);
  86         CANVAS_DEBUG_NAME (h_scroll_group, "canvas h scroll");
  87         _track_canvas->add_scroller (*hg);
  88
  89         hv_scroll_group = hsg = new ArdourCanvas::ScrollGroup (_track_canvas->root(),
  90                                                                ArdourCanvas::ScrollGroup::ScrollSensitivity (ArdourCanvas::ScrollGroup::ScrollsVertically|
  91                                                                                                              ArdourCanvas::ScrollGroup::ScrollsHorizontally));
  92         CANVAS_DEBUG_NAME (hv_scroll_group, "canvas hv scroll");
  93         _track_canvas->add_scroller (*hsg);
  94
  95         cursor_scroll_group = cg = new ArdourCanvas::ScrollGroup (_track_canvas->root(), ArdourCanvas::ScrollGroup::ScrollsHorizontally);
  96         CANVAS_DEBUG_NAME (cursor_scroll_group, "canvas cursor scroll");
  97         _track_canvas->add_scroller (*cg);
  98
  99         _verbose_cursor = new VerboseCursor (this);
 100
 101         /* on the bottom, an image */
 102
 103         if (Profile->get_sae()) {
 104                 Image img (::get_icon (X_("saelogo")));
 105                 // logo_item = new ArdourCanvas::Pixbuf (_track_canvas->root(), 0.0, 0.0, img.get_pixbuf());
 106                 // logo_item->property_height_in_pixels() = true;
 107                 // logo_item->property_width_in_pixels() = true;
 108                 // logo_item->property_height_set() = true;
 109                 // logo_item->property_width_set() = true;
 110                 // logo_item->show ();
 111         }
 112
 113         /*a group to hold global rects like punch/loop indicators */
 114         global_rect_group = new ArdourCanvas::Container (hv_scroll_group);
 115         CANVAS_DEBUG_NAME (global_rect_group, "global rect group");
 116
 117         transport_loop_range_rect = new ArdourCanvas::Rectangle (global_rect_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, ArdourCanvas::COORD_MAX));
 118         CANVAS_DEBUG_NAME (transport_loop_range_rect, "loop rect");
 119         transport_loop_range_rect->hide();
 120
 121         transport_punch_range_rect = new ArdourCanvas::Rectangle (global_rect_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, ArdourCanvas::COORD_MAX));
 122         CANVAS_DEBUG_NAME (transport_punch_range_rect, "punch rect");
 123         transport_punch_range_rect->hide();
 124
 125         /*a group to hold time (measure) lines */
 126         time_line_group = new ArdourCanvas::Container (h_scroll_group);
 127         CANVAS_DEBUG_NAME (time_line_group, "time line group");
 128
 129         _trackview_group = new ArdourCanvas::Container (hv_scroll_group);
 130         CANVAS_DEBUG_NAME (_trackview_group, "Canvas TrackViews");
 131
 132         // used as rubberband rect
 133         rubberband_rect = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, 0.0));
 134         rubberband_rect->hide();
 135
 136         /* a group to hold stuff while it gets dragged around. Must be the
 137          * uppermost (last) group with hv_scroll_group as a parent
 138          */
 139         _drag_motion_group = new ArdourCanvas::Container (hv_scroll_group);
 140         CANVAS_DEBUG_NAME (_drag_motion_group, "Canvas Drag Motion");
 141
 142         /* TIME BAR CANVAS */
 143
 144         _time_markers_group = new ArdourCanvas::Container (h_scroll_group);
 145         CANVAS_DEBUG_NAME (_time_markers_group, "time bars");
 146
 147         cd_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, 0.0));
 148         CANVAS_DEBUG_NAME (cd_marker_group, "cd marker group");
 149         /* the vide is temporarily placed a the same location as the
 150            cd_marker_group, but is moved later.
 151         */
 152         videotl_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple(0.0, 0.0));
 153         CANVAS_DEBUG_NAME (videotl_group, "videotl group");
 154         marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height + 1.0));
 155         CANVAS_DEBUG_NAME (marker_group, "marker group");
 156         transport_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 2.0) + 1.0));
 157         CANVAS_DEBUG_NAME (transport_marker_group, "transport marker group");
 158         range_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 3.0) + 1.0));
 159         CANVAS_DEBUG_NAME (range_marker_group, "range marker group");
 160         tempo_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 4.0) + 1.0));
 161         CANVAS_DEBUG_NAME (tempo_group, "tempo group");
 162         meter_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 5.0) + 1.0));
 163         CANVAS_DEBUG_NAME (meter_group, "meter group");
 164
 165         meter_bar = new ArdourCanvas::Rectangle (meter_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 166         CANVAS_DEBUG_NAME (meter_bar, "meter Bar");
 167         meter_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 168
 169         tempo_bar = new ArdourCanvas::Rectangle (tempo_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 170         CANVAS_DEBUG_NAME (tempo_bar, "Tempo  Bar");
 171         tempo_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 172
 173         range_marker_bar = new ArdourCanvas::Rectangle (range_marker_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 174         CANVAS_DEBUG_NAME (range_marker_bar, "Range Marker Bar");
 175         range_marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 176
 177         transport_marker_bar = new ArdourCanvas::Rectangle (transport_marker_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 178         CANVAS_DEBUG_NAME (transport_marker_bar, "transport Marker Bar");
 179         transport_marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 180
 181         marker_bar = new ArdourCanvas::Rectangle (marker_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 182         CANVAS_DEBUG_NAME (marker_bar, "Marker Bar");
 183         marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 184
 185         cd_marker_bar = new ArdourCanvas::Rectangle (cd_marker_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 186         CANVAS_DEBUG_NAME (cd_marker_bar, "CD Marker Bar");
 187         cd_marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 188
 189         ARDOUR_UI::instance()->video_timeline = new VideoTimeLine(this, videotl_group, (timebar_height * videotl_bar_height));
 190
 191         cd_marker_bar_drag_rect = new ArdourCanvas::Rectangle (cd_marker_group, ArdourCanvas::Rect (0.0, 0.0, 100, timebar_height));
 192         CANVAS_DEBUG_NAME (cd_marker_bar_drag_rect, "cd marker drag");
 193         cd_marker_bar_drag_rect->set_outline (false);
 194         cd_marker_bar_drag_rect->hide ();
 195
 196         range_bar_drag_rect = new ArdourCanvas::Rectangle (range_marker_group, ArdourCanvas::Rect (0.0, 0.0, 100, timebar_height));
 197         CANVAS_DEBUG_NAME (range_bar_drag_rect, "range drag");
 198         range_bar_drag_rect->set_outline (false);
 199         range_bar_drag_rect->hide ();
 200
 201         transport_bar_drag_rect = new ArdourCanvas::Rectangle (transport_marker_group, ArdourCanvas::Rect (0.0, 0.0, 100, timebar_height));
 202         CANVAS_DEBUG_NAME (transport_bar_drag_rect, "transport drag");
 203         transport_bar_drag_rect->set_outline (false);
 204         transport_bar_drag_rect->hide ();
 205
 206         transport_punchin_line = new ArdourCanvas::Line (hv_scroll_group);
 207         transport_punchin_line->set_x0 (0);
 208         transport_punchin_line->set_y0 (0);
 209         transport_punchin_line->set_x1 (0);
 210         transport_punchin_line->set_y1 (ArdourCanvas::COORD_MAX);
 211         transport_punchin_line->hide ();
 212
 213         transport_punchout_line  = new ArdourCanvas::Line (hv_scroll_group);
 214         transport_punchout_line->set_x0 (0);
 215         transport_punchout_line->set_y0 (0);
 216         transport_punchout_line->set_x1 (0);
 217         transport_punchout_line->set_y1 (ArdourCanvas::COORD_MAX);
 218         transport_punchout_line->hide();
 219
 220         tempo_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_tempo_bar_event), tempo_bar));
 221         meter_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_meter_bar_event), meter_bar));
 222         marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_marker_bar_event), marker_bar));
 223         cd_marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_cd_marker_bar_event), cd_marker_bar));
 224         videotl_group->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_videotl_bar_event), videotl_group));
 225         range_marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_range_marker_bar_event), range_marker_bar));
 226         transport_marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_transport_marker_bar_event), transport_marker_bar));
 227
 228         playhead_cursor = new EditorCursor (*this, &Editor::canvas_playhead_cursor_event);
 229
 230         if (logo_item) {
 231                 logo_item->lower_to_bottom ();
 232         }
 233
 234         _canvas_drop_zone = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, 0.0));
 235         /* this thing is transparent */
 236         _canvas_drop_zone->set_fill (false);
 237         _canvas_drop_zone->set_outline (false);
 238         _canvas_drop_zone->Event.connect (sigc::mem_fun (*this, &Editor::canvas_drop_zone_event));
 239
 240         /* these signals will initially be delivered to the canvas itself, but if they end up remaining unhandled, they are passed to Editor-level
 241            handlers.
 242         */
 243
 244         _track_canvas->signal_scroll_event().connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_scroll_event), true));
 245         _track_canvas->signal_motion_notify_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_motion_notify_event));
 246         _track_canvas->signal_button_press_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_button_press_event));
 247         _track_canvas->signal_button_release_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_button_release_event));
 248         _track_canvas->signal_drag_motion().connect (sigc::mem_fun (*this, &Editor::track_canvas_drag_motion));
 249         _track_canvas->signal_key_press_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_key_press));
 250         _track_canvas->signal_key_release_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_key_release));
 251
 252         _track_canvas->set_name ("EditorMainCanvas");
 253         _track_canvas->add_events (Gdk::POINTER_MOTION_HINT_MASK | Gdk::SCROLL_MASK | Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK);
 254         _track_canvas->signal_leave_notify_event().connect (sigc::mem_fun(*this, &Editor::left_track_canvas), false);
 255         _track_canvas->signal_enter_notify_event().connect (sigc::mem_fun(*this, &Editor::entered_track_canvas), false);
 256         _track_canvas->set_flags (CAN_FOCUS);
 257
 258         /* set up drag-n-drop */
 259
 260         vector<TargetEntry> target_table;
 261
 262         // Drag-N-Drop from the region list can generate this target
 263         target_table.push_back (TargetEntry ("regions"));
 264
 265         target_table.push_back (TargetEntry ("text/plain"));
 266         target_table.push_back (TargetEntry ("text/uri-list"));
 267         target_table.push_back (TargetEntry ("application/x-rootwin-drop"));
 268
 269         _track_canvas->drag_dest_set (target_table);
 270         _track_canvas->signal_drag_data_received().connect (sigc::mem_fun(*this, &Editor::track_canvas_drag_data_received));
 271
 272         _track_canvas_viewport->signal_size_allocate().connect (sigc::mem_fun(*this, &Editor::track_canvas_viewport_allocate));
 273
 274         initialize_rulers ();
 275
 276         UIConfiguration::instance().ColorsChanged.connect (sigc::mem_fun (*this, &Editor::color_handler));
 277         color_handler();
 278
 279 }
 280
 281 void
 282 Editor::track_canvas_viewport_allocate (Gtk::Allocation alloc)
 283 {
 284         _canvas_viewport_allocation = alloc;
 285         track_canvas_viewport_size_allocated ();
 286 }
 287
 288 void
 289 Editor::track_canvas_viewport_size_allocated ()
 290 {
 291         bool height_changed = _visible_canvas_height != _canvas_viewport_allocation.get_height();
 292
 293         _visible_canvas_width  = _canvas_viewport_allocation.get_width ();
 294         _visible_canvas_height = _canvas_viewport_allocation.get_height ();
 295
 296         _canvas_drop_zone->set_y1 (_canvas_drop_zone->y0() + (_visible_canvas_height - 20.0));
 297
 298         // SHOWTRACKS
 299
 300         if (height_changed) {
 301
 302                 for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
 303                         i->second->canvas_height_set (_visible_canvas_height);
 304                 }
 305
 306                 vertical_adjustment.set_page_size (_visible_canvas_height);
 307                 if ((vertical_adjustment.get_value() + _visible_canvas_height) >= vertical_adjustment.get_upper()) {
 308                         /*
 309                            We're increasing the size of the canvas while the bottom is visible.
 310                            We scroll down to keep in step with the controls layout.
 311                         */
 312                         vertical_adjustment.set_value (_full_canvas_height - _visible_canvas_height);
 313                 }
 314
 315                 set_visible_track_count (_visible_track_count);
 316         }
 317
 318         update_fixed_rulers();
 319         redisplay_tempo (false);
 320         _summary->set_overlays_dirty ();
 321 }
 322
 323 void
 324 Editor::reset_controls_layout_width ()
 325 {
 326         GtkRequisition req = { 0, 0 };
 327         gint w;
 328
 329         edit_controls_vbox.size_request (req);
 330         w = req.width;
 331
 332         if (_group_tabs->is_mapped()) {
 333                 _group_tabs->size_request (req);
 334                 w += req.width;
 335         }
 336
 337         /* the controls layout has no horizontal scrolling, its visible
 338            width is always equal to the total width of its contents.
 339         */
 340
 341         controls_layout.property_width() = w;
 342         controls_layout.property_width_request() = w;
 343 }
 344
 345 void
 346 Editor::reset_controls_layout_height (int32_t h)
 347 {
 348         /* ensure that the rect that represents the "bottom" of the canvas
 349          * (the drag-n-drop zone) is, in fact, at the bottom.
 350          */
 351
 352         _canvas_drop_zone->set_position (ArdourCanvas::Duple (0, h));
 353
 354         /* track controls layout must span the full height of "h" (all tracks)
 355          * plus the bottom rect.
 356          */
 357
 358         h += _canvas_drop_zone->height ();
 359
 360         /* set the height of the scrollable area (i.e. the sum of all contained widgets)
 361          * for the controls layout. The size request is set elsewhere.
 362          */
 363
 364         controls_layout.property_height() = h;
 365
 366 }
 367
 368 bool
 369 Editor::track_canvas_map_handler (GdkEventAny* /*ev*/)
 370 {
 371         if (!_cursor_stack.empty()) {
 372                 set_canvas_cursor (get_canvas_cursor());
 373         } else {
 374                 PBD::error << "cursor stack is empty" << endmsg;
 375         }
 376         return false;
 377 }
 378
 379 /** This is called when something is dropped onto the track canvas */
 380 void
 381 Editor::track_canvas_drag_data_received (const RefPtr<Gdk::DragContext>& context,
 382                                          int x, int y,
 383                                          const SelectionData& data,
 384                                          guint info, guint time)
 385 {
 386         if (data.get_target() == "regions") {
 387                 drop_regions (context, x, y, data, info, time);
 388         } else {
 389                 drop_paths (context, x, y, data, info, time);
 390         }
 391 }
 392
 393 bool
 394 Editor::idle_drop_paths (vector<string> paths, framepos_t frame, double ypos, bool copy)
 395 {
 396         drop_paths_part_two (paths, frame, ypos, copy);
 397         return false;
 398 }
 399
 400 void
 401 Editor::drop_paths_part_two (const vector<string>& paths, framepos_t frame, double ypos, bool copy)
 402 {
 403         RouteTimeAxisView* tv;
 404
 405         /* MIDI files must always be imported, because we consider them
 406          * writable. So split paths into two vectors, and follow the import
 407          * path on the MIDI part.
 408          */
 409
 410         vector<string> midi_paths;
 411         vector<string> audio_paths;
 412
 413         for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
 414                 if (SMFSource::safe_midi_file_extension (*i)) {
 415                         midi_paths.push_back (*i);
 416                 } else {
 417                         audio_paths.push_back (*i);
 418                 }
 419         }
 420
 421
 422         std::pair<TimeAxisView*, int> const tvp = trackview_by_y_position (ypos, false);
 423         if (tvp.first == 0) {
 424
 425                 /* drop onto canvas background: create new tracks */
 426
 427                 frame = 0;
 428                 InstrumentSelector is; // instantiation builds instrument-list and sets default.
 429                 do_import (midi_paths, Editing::ImportDistinctFiles, ImportAsTrack, SrcBest, frame, is.selected_instrument());
 430
 431                 if (Profile->get_sae() || UIConfiguration::instance().get_only_copy_imported_files() || copy) {
 432                         do_import (audio_paths, Editing::ImportDistinctFiles, Editing::ImportAsTrack, SrcBest, frame);
 433                 } else {
 434                         do_embed (audio_paths, Editing::ImportDistinctFiles, ImportAsTrack, frame);
 435                 }
 436
 437         } else if ((tv = dynamic_cast<RouteTimeAxisView*> (tvp.first)) != 0) {
 438
 439                 /* check that its a track, not a bus */
 440
 441                 if (tv->track()) {
 442                         /* select the track, then embed/import */
 443                         selection->set (tv);
 444
 445                         do_import (midi_paths, Editing::ImportSerializeFiles, ImportToTrack, SrcBest, frame);
 446
 447                         if (Profile->get_sae() || UIConfiguration::instance().get_only_copy_imported_files() || copy) {
 448                                 do_import (audio_paths, Editing::ImportSerializeFiles, Editing::ImportToTrack, SrcBest, frame);
 449                         } else {
 450                                 do_embed (audio_paths, Editing::ImportSerializeFiles, ImportToTrack, frame);
 451                         }
 452                 }
 453         }
 454 }
 455
 456 void
 457 Editor::drop_paths (const RefPtr<Gdk::DragContext>& context,
 458                     int x, int y,
 459                     const SelectionData& data,
 460                     guint info, guint time)
 461 {
 462         vector<string> paths;
 463         GdkEvent ev;
 464         framepos_t frame;
 465         double cy;
 466
 467         if (convert_drop_to_paths (paths, context, x, y, data, info, time) == 0) {
 468
 469                 /* D-n-D coordinates are window-relative, so convert to canvas coordinates
 470                  */
 471
 472                 ev.type = GDK_BUTTON_RELEASE;
 473                 ev.button.x = x;
 474                 ev.button.y = y;
 475
 476                 frame = window_event_sample (&ev, 0, &cy);
 477
 478                 snap_to (frame);
 479
 480                 bool copy = ((context->get_actions() & (Gdk::ACTION_COPY | Gdk::ACTION_LINK | Gdk::ACTION_MOVE)) == Gdk::ACTION_COPY);
 481 #ifdef GTKOSX
 482                 /* We are not allowed to call recursive main event loops from within
 483                    the main event loop with GTK/Quartz. Since import/embed wants
 484                    to push up a progress dialog, defer all this till we go idle.
 485                 */
 486                 Glib::signal_idle().connect (sigc::bind (sigc::mem_fun (*this, &Editor::idle_drop_paths), paths, frame, cy, copy));
 487 #else
 488                 drop_paths_part_two (paths, frame, cy, copy);
 489 #endif
 490         }
 491
 492         context->drag_finish (true, false, time);
 493 }
 494
 495 /** @param allow_horiz true to allow horizontal autoscroll, otherwise false.
 496  *
 497  *  @param allow_vert true to allow vertical autoscroll, otherwise false.
 498  *
 499  */
 500 void
 501 Editor::maybe_autoscroll (bool allow_horiz, bool allow_vert, bool from_headers)
 502 {
 503         if (!UIConfiguration::instance().get_autoscroll_editor () || autoscroll_active ()) {
 504                 return;
 505         }
 506
 507         /* define a rectangular boundary for scrolling. If the mouse moves
 508          * outside of this area and/or continue to be outside of this area,
 509          * then we will continuously auto-scroll the canvas in the appropriate
 510          * direction(s)
 511          *
 512          * the boundary is defined in coordinates relative to the toplevel
 513          * window since that is what we're going to call ::get_pointer() on
 514          * during autoscrolling to determine if we're still outside the
 515          * boundary or not.
 516          */
 517
 518         ArdourCanvas::Rect scrolling_boundary;
 519         Gtk::Allocation alloc;
 520
 521         if (from_headers) {
 522                 alloc = controls_layout.get_allocation ();
 523         } else {
 524                 alloc = _track_canvas_viewport->get_allocation ();
 525
 526                 /* reduce height by the height of the timebars, which happens
 527                    to correspond to the position of the hv_scroll_group.
 528                 */
 529
 530                 alloc.set_height (alloc.get_height() - hv_scroll_group->position().y);
 531                 alloc.set_y (alloc.get_y() + hv_scroll_group->position().y);
 532
 533                 /* now reduce it again so that we start autoscrolling before we
 534                  * move off the top or bottom of the canvas
 535                  */
 536
 537                 alloc.set_height (alloc.get_height() - 20);
 538                 alloc.set_y (alloc.get_y() + 10);
 539
 540                 /* the effective width of the autoscroll boundary so
 541                    that we start scrolling before we hit the edge.
 542
 543                    this helps when the window is slammed up against the
 544                    right edge of the screen, making it hard to scroll
 545                    effectively.
 546                 */
 547
 548                 if (alloc.get_width() > 20) {
 549                         alloc.set_width (alloc.get_width() - 20);
 550                         alloc.set_x (alloc.get_x() + 10);
 551                 }
 552
 553         }
 554
 555         scrolling_boundary = ArdourCanvas::Rect (alloc.get_x(), alloc.get_y(), alloc.get_x() + alloc.get_width(), alloc.get_y() + alloc.get_height());
 556
 557         int x, y;
 558         Gdk::ModifierType mask;
 559
 560         get_window()->get_pointer (x, y, mask);
 561
 562         if ((allow_horiz && ((x < scrolling_boundary.x0 && leftmost_frame > 0) || x >= scrolling_boundary.x1)) ||
 563             (allow_vert && ((y < scrolling_boundary.y0 && vertical_adjustment.get_value() > 0)|| y >= scrolling_boundary.y1))) {
 564                 start_canvas_autoscroll (allow_horiz, allow_vert, scrolling_boundary);
 565         }
 566 }
 567
 568 bool
 569 Editor::autoscroll_active () const
 570 {
 571         return autoscroll_connection.connected ();
 572 }
 573
 574 bool
 575 Editor::autoscroll_canvas ()
 576 {
 577         int x, y;
 578         Gdk::ModifierType mask;
 579         frameoffset_t dx = 0;
 580         bool no_stop = false;
 581
 582         get_window()->get_pointer (x, y, mask);
 583
 584         VisualChange vc;
 585         bool vertical_motion = false;
 586
 587         if (autoscroll_horizontal_allowed) {
 588
 589                 framepos_t new_frame = leftmost_frame;
 590
 591                 /* horizontal */
 592
 593                 if (x > autoscroll_boundary.x1) {
 594
 595                         /* bring it back into view */
 596                         dx = x - autoscroll_boundary.x1;
 597                         dx += 10 + (2 * (autoscroll_cnt/2));
 598
 599                         dx = pixel_to_sample (dx);
 600
 601                         if (leftmost_frame < max_framepos - dx) {
 602                                 new_frame = leftmost_frame + dx;
 603                         } else {
 604                                 new_frame = max_framepos;
 605                         }
 606
 607                         no_stop = true;
 608
 609                 } else if (x < autoscroll_boundary.x0) {
 610
 611                         dx = autoscroll_boundary.x0 - x;
 612                         dx += 10 + (2 * (autoscroll_cnt/2));
 613
 614                         dx = pixel_to_sample (dx);
 615
 616                         if (leftmost_frame >= dx) {
 617                                 new_frame = leftmost_frame - dx;
 618                         } else {
 619                                 new_frame = 0;
 620                         }
 621
 622                         no_stop = true;
 623                 }
 624
 625                 if (new_frame != leftmost_frame) {
 626                         vc.time_origin = new_frame;
 627                         vc.add (VisualChange::TimeOrigin);
 628                 }
 629         }
 630
 631         if (autoscroll_vertical_allowed) {
 632
 633                 // const double vertical_pos = vertical_adjustment.get_value();
 634                 const int speed_factor = 10;
 635
 636                 /* vertical */
 637
 638                 if (y < autoscroll_boundary.y0) {
 639
 640                         /* scroll to make higher tracks visible */
 641
 642                         if (autoscroll_cnt && (autoscroll_cnt % speed_factor == 0)) {
 643                                 scroll_up_one_track ();
 644                                 vertical_motion = true;
 645                         }
 646
 647                 } else if (y > autoscroll_boundary.y1) {
 648
 649                         if (autoscroll_cnt && (autoscroll_cnt % speed_factor == 0)) {
 650                                 scroll_down_one_track ();
 651                                 vertical_motion = true;
 652                         }
 653                 }
 654
 655                 no_stop = true;
 656         }
 657
 658         if (vc.pending || vertical_motion) {
 659
 660                 /* change horizontal first */
 661
 662                 if (vc.pending) {
 663                         visual_changer (vc);
 664                 }
 665
 666                 /* now send a motion event to notify anyone who cares
 667                    that we have moved to a new location (because we scrolled)
 668                 */
 669
 670                 GdkEventMotion ev;
 671
 672                 ev.type = GDK_MOTION_NOTIFY;
 673                 ev.state = Gdk::BUTTON1_MASK;
 674
 675                 /* the motion handler expects events in canvas coordinate space */
 676
 677                 /* we asked for the mouse position above (::get_pointer()) via
 678                  * our own top level window (we being the Editor). Convert into
 679                  * coordinates within the canvas window.
 680                  */
 681
 682                 int cx;
 683                 int cy;
 684
 685                 translate_coordinates (*_track_canvas, x, y, cx, cy);
 686
 687                 /* clamp x and y to remain within the autoscroll boundary,
 688                  * which is defined in window coordinates
 689                  */
 690
 691                 x = min (max ((ArdourCanvas::Coord) cx, autoscroll_boundary.x0), autoscroll_boundary.x1);
 692                 y = min (max ((ArdourCanvas::Coord) cy, autoscroll_boundary.y0), autoscroll_boundary.y1);
 693
 694                 /* now convert from Editor window coordinates to canvas
 695                  * window coordinates
 696                  */
 697
 698                 ArdourCanvas::Duple d = _track_canvas->window_to_canvas (ArdourCanvas::Duple (cx, cy));
 699                 ev.x = d.x;
 700                 ev.y = d.y;
 701                 ev.state = mask;
 702
 703                 motion_handler (0, (GdkEvent*) &ev, true);
 704
 705         } else if (no_stop) {
 706
 707                 /* not changing visual state but pointer is outside the scrolling boundary
 708                  * so we still need to deliver a fake motion event
 709                  */
 710
 711                 GdkEventMotion ev;
 712
 713                 ev.type = GDK_MOTION_NOTIFY;
 714                 ev.state = Gdk::BUTTON1_MASK;
 715
 716                 /* the motion handler expects events in canvas coordinate space */
 717
 718                 /* first convert from Editor window coordinates to canvas
 719                  * window coordinates
 720                  */
 721
 722                 int cx;
 723                 int cy;
 724
 725                 /* clamp x and y to remain within the visible area. except
 726                  * .. if horizontal scrolling is allowed, always allow us to
 727                  * move back to zero
 728                  */
 729
 730                 if (autoscroll_horizontal_allowed) {
 731                         x = min (max ((ArdourCanvas::Coord) x, 0.0), autoscroll_boundary.x1);
 732                 } else {
 733                         x = min (max ((ArdourCanvas::Coord) x, autoscroll_boundary.x0), autoscroll_boundary.x1);
 734                 }
 735                 y = min (max ((ArdourCanvas::Coord) y, autoscroll_boundary.y0), autoscroll_boundary.y1);
 736
 737                 translate_coordinates (*_track_canvas_viewport, x, y, cx, cy);
 738
 739                 ArdourCanvas::Duple d = _track_canvas->window_to_canvas (ArdourCanvas::Duple (cx, cy));
 740                 ev.x = d.x;
 741                 ev.y = d.y;
 742                 ev.state = mask;
 743
 744                 motion_handler (0, (GdkEvent*) &ev, true);
 745
 746         } else {
 747                 stop_canvas_autoscroll ();
 748                 return false;
 749         }
 750
 751         autoscroll_cnt++;
 752
 753         return true; /* call me again */
 754 }
 755
 756 void
 757 Editor::start_canvas_autoscroll (bool allow_horiz, bool allow_vert, const ArdourCanvas::Rect& boundary)
 758 {
 759         if (!_session) {
 760                 return;
 761         }
 762
 763         stop_canvas_autoscroll ();
 764
 765         autoscroll_cnt = 0;
 766         autoscroll_horizontal_allowed = allow_horiz;
 767         autoscroll_vertical_allowed = allow_vert;
 768         autoscroll_boundary = boundary;
 769
 770         /* do the first scroll right now
 771         */
 772
 773         autoscroll_canvas ();
 774
 775         /* scroll again at very very roughly 30FPS */
 776
 777         autoscroll_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &Editor::autoscroll_canvas), 30);
 778 }
 779
 780 void
 781 Editor::stop_canvas_autoscroll ()
 782 {
 783         autoscroll_connection.disconnect ();
 784 }
 785
 786 Editor::EnterContext*
 787 Editor::get_enter_context(ItemType type)
 788 {
 789         for (ssize_t i = _enter_stack.size() - 1; i >= 0; --i) {
 790                 if (_enter_stack[i].item_type == type) {
 791                         return &_enter_stack[i];
 792                 }
 793         }
 794         return NULL;
 795 }
 796
 797 bool
 798 Editor::left_track_canvas (GdkEventCrossing */*ev*/)
 799 {
 800         DropDownKeys ();
 801         within_track_canvas = false;
 802         set_entered_track (0);
 803         set_entered_regionview (0);
 804         reset_canvas_action_sensitivity (false);
 805         return false;
 806 }
 807
 808 bool
 809 Editor::entered_track_canvas (GdkEventCrossing */*ev*/)
 810 {
 811         within_track_canvas = true;
 812         reset_canvas_action_sensitivity (true);
 813         return FALSE;
 814 }
 815
 816 void
 817 Editor::ensure_time_axis_view_is_visible (TimeAxisView const & track, bool at_top)
 818 {
 819         if (track.hidden()) {
 820                 return;
 821         }
 822
 823         /* compute visible area of trackview group, as offsets from top of
 824          * trackview group.
 825          */
 826
 827         double const current_view_min_y = vertical_adjustment.get_value();
 828         double const current_view_max_y = current_view_min_y + vertical_adjustment.get_page_size();
 829
 830         double const track_min_y = track.y_position ();
 831         double const track_max_y = track.y_position () + track.effective_height ();
 832
 833         if (!at_top &&
 834             (track_min_y >= current_view_min_y &&
 835              track_max_y < current_view_max_y)) {
 836                 /* already visible, and caller did not ask to place it at the
 837                  * top of the track canvas
 838                  */
 839                 return;
 840         }
 841
 842         double new_value;
 843
 844         if (at_top) {
 845                 new_value = track_min_y;
 846         } else {
 847                 if (track_min_y < current_view_min_y) {
 848                         // Track is above the current view
 849                         new_value = track_min_y;
 850                 } else if (track_max_y > current_view_max_y) {
 851                         // Track is below the current view
 852                         new_value = track.y_position () + track.effective_height() - vertical_adjustment.get_page_size();
 853                 } else {
 854                         new_value = track_min_y;
 855                 }
 856         }
 857
 858         vertical_adjustment.set_value(new_value);
 859 }
 860
 861 /** Called when the main vertical_adjustment has changed */
 862 void
 863 Editor::tie_vertical_scrolling ()
 864 {
 865         if (pending_visual_change.idle_handler_id < 0) {
 866                 _summary->set_overlays_dirty ();
 867         }
 868 }
 869
 870 void
 871 Editor::set_horizontal_position (double p)
 872 {
 873         horizontal_adjustment.set_value (p);
 874
 875         leftmost_frame = (framepos_t) floor (p * samples_per_pixel);
 876
 877         update_fixed_rulers ();
 878         redisplay_tempo (true);
 879
 880         if (pending_visual_change.idle_handler_id < 0) {
 881                 _summary->set_overlays_dirty ();
 882         }
 883
 884         update_video_timeline();
 885 }
 886
 887 void
 888 Editor::color_handler()
 889 {
 890         ArdourCanvas::Color base = UIConfiguration::instance().color ("ruler base");
 891         ArdourCanvas::Color text = UIConfiguration::instance().color ("ruler text");
 892         timecode_ruler->set_fill_color (base);
 893         timecode_ruler->set_outline_color (text);
 894         minsec_ruler->set_fill_color (base);
 895         minsec_ruler->set_outline_color (text);
 896         samples_ruler->set_fill_color (base);
 897         samples_ruler->set_outline_color (text);
 898         bbt_ruler->set_fill_color (base);
 899         bbt_ruler->set_outline_color (text);
 900
 901         playhead_cursor->set_color (UIConfiguration::instance().color ("play head"));
 902
 903         meter_bar->set_fill_color (UIConfiguration::instance().color_mod ("meter bar", "marker bar"));
 904         meter_bar->set_outline_color (UIConfiguration::instance().color ("marker bar separator"));
 905
 906         tempo_bar->set_fill_color (UIConfiguration::instance().color_mod ("tempo bar", "marker bar"));
 907         tempo_bar->set_outline_color (UIConfiguration::instance().color ("marker bar separator"));
 908
 909         marker_bar->set_fill_color (UIConfiguration::instance().color_mod ("marker bar", "marker bar"));
 910         marker_bar->set_outline_color (UIConfiguration::instance().color ("marker bar separator"));
 911
 912         cd_marker_bar->set_fill_color (UIConfiguration::instance().color_mod ("cd marker bar", "marker bar"));
 913         cd_marker_bar->set_outline_color (UIConfiguration::instance().color ("marker bar separator"));
 914
 915         range_marker_bar->set_fill_color (UIConfiguration::instance().color_mod ("range marker bar", "marker bar"));
 916         range_marker_bar->set_outline_color (UIConfiguration::instance().color ("marker bar separator"));
 917
 918         transport_marker_bar->set_fill_color (UIConfiguration::instance().color_mod ("transport marker bar", "marker bar"));
 919         transport_marker_bar->set_outline_color (UIConfiguration::instance().color ("marker bar separator"));
 920
 921         cd_marker_bar_drag_rect->set_fill_color (UIConfiguration::instance().color ("range drag bar rect"));
 922         cd_marker_bar_drag_rect->set_outline_color (UIConfiguration::instance().color ("range drag bar rect"));
 923
 924         range_bar_drag_rect->set_fill_color (UIConfiguration::instance().color ("range drag bar rect"));
 925         range_bar_drag_rect->set_outline_color (UIConfiguration::instance().color ("range drag bar rect"));
 926
 927         transport_bar_drag_rect->set_fill_color (UIConfiguration::instance().color ("transport drag rect"));
 928         transport_bar_drag_rect->set_outline_color (UIConfiguration::instance().color ("transport drag rect"));
 929
 930         transport_loop_range_rect->set_fill_color (UIConfiguration::instance().color_mod ("transport loop rect", "loop rectangle"));
 931         transport_loop_range_rect->set_outline_color (UIConfiguration::instance().color ("transport loop rect"));
 932
 933         transport_punch_range_rect->set_fill_color (UIConfiguration::instance().color ("transport punch rect"));
 934         transport_punch_range_rect->set_outline_color (UIConfiguration::instance().color ("transport punch rect"));
 935
 936         transport_punchin_line->set_outline_color (UIConfiguration::instance().color ("punch line"));
 937         transport_punchout_line->set_outline_color (UIConfiguration::instance().color ("punch line"));
 938
 939         rubberband_rect->set_outline_color (UIConfiguration::instance().color ("rubber band rect"));
 940         rubberband_rect->set_fill_color (UIConfiguration::instance().color_mod ("rubber band rect", "selection rect"));
 941
 942         location_marker_color = UIConfiguration::instance().color ("location marker");
 943         location_range_color = UIConfiguration::instance().color ("location range");
 944         location_cd_marker_color = UIConfiguration::instance().color ("location cd marker");
 945         location_loop_color = UIConfiguration::instance().color ("location loop");
 946         location_punch_color = UIConfiguration::instance().color ("location punch");
 947
 948         refresh_location_display ();
 949
 950         /* redraw the whole thing */
 951         _track_canvas->set_background_color (UIConfiguration::instance().color ("arrange base"));
 952         _track_canvas->queue_draw ();
 953
 954 /*
 955         redisplay_tempo (true);
 956
 957         if (_session)
 958               _session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); // redraw metric markers
 959 */
 960 }
 961
 962 double
 963 Editor::horizontal_position () const
 964 {
 965         return sample_to_pixel (leftmost_frame);
 966 }
 967
 968 bool
 969 Editor::track_canvas_key_press (GdkEventKey*)
 970 {
 971         return false;
 972 }
 973
 974 bool
 975 Editor::track_canvas_key_release (GdkEventKey*)
 976 {
 977         return false;
 978 }
 979
 980 double
 981 Editor::clamp_verbose_cursor_x (double x)
 982 {
 983         if (x < 0) {
 984                 x = 0;
 985         } else {
 986                 x = min (_visible_canvas_width - 200.0, x);
 987         }
 988         return x;
 989 }
 990
 991 double
 992 Editor::clamp_verbose_cursor_y (double y)
 993 {
 994         y = max (0.0, y);
 995         y = min (_visible_canvas_height - 50, y);
 996         return y;
 997 }
 998
 999 ArdourCanvas::GtkCanvasViewport*
1000 Editor::get_track_canvas() const
1001 {
1002         return _track_canvas_viewport;
1003 }
1004
1005 Gdk::Cursor*
1006 Editor::get_canvas_cursor () const
1007 {
1008         /* The top of the cursor stack is always the currently visible cursor. */
1009         return _cursor_stack.back();
1010 }
1011
1012 void
1013 Editor::set_canvas_cursor (Gdk::Cursor* cursor)
1014 {
1015         Glib::RefPtr<Gdk::Window> win = _track_canvas->get_window();
1016
1017         if (win && !_cursors->is_invalid (cursor)) {
1018                 /* glibmm 2.4 doesn't allow null cursor pointer because it uses
1019                    a Gdk::Cursor& as the argument to Gdk::Window::set_cursor().
1020                    But a null pointer just means "use parent window cursor",
1021                    and so should be allowed. Gtkmm 3.x has fixed this API.
1022
1023                    For now, drop down and use C API
1024                 */
1025                 gdk_window_set_cursor (win->gobj(), cursor ? cursor->gobj() : 0);
1026         }
1027 }
1028
1029 size_t
1030 Editor::push_canvas_cursor (Gdk::Cursor* cursor)
1031 {
1032         if (!_cursors->is_invalid (cursor)) {
1033                 _cursor_stack.push_back (cursor);
1034                 set_canvas_cursor (cursor);
1035         }
1036         return _cursor_stack.size() - 1;
1037 }
1038
1039 void
1040 Editor::pop_canvas_cursor ()
1041 {
1042         while (true) {
1043                 if (_cursor_stack.size() <= 1) {
1044                         PBD::error << "attempt to pop default cursor" << endmsg;
1045                         return;
1046                 }
1047
1048                 _cursor_stack.pop_back();
1049                 if (_cursor_stack.back()) {
1050                         /* Popped to an existing cursor, we're done.  Otherwise, the
1051                            context that created this cursor has been destroyed, so we need
1052                            to skip to the next down the stack. */
1053                         set_canvas_cursor (_cursor_stack.back());
1054                         return;
1055                 }
1056         }
1057 }
1058
1059 Gdk::Cursor*
1060 Editor::which_grabber_cursor () const
1061 {
1062         Gdk::Cursor* c = _cursors->grabber;
1063
1064         switch (_edit_point) {
1065         case EditAtMouse:
1066                 c = _cursors->grabber_edit_point;
1067                 break;
1068         default:
1069                 boost::shared_ptr<Movable> m = _movable.lock();
1070                 if (m && m->locked()) {
1071                         c = _cursors->speaker;
1072                 }
1073                 break;
1074         }
1075
1076         return c;
1077 }
1078
1079 Gdk::Cursor*
1080 Editor::which_trim_cursor (bool left) const
1081 {
1082         if (!entered_regionview) {
1083                 return 0;
1084         }
1085
1086         Trimmable::CanTrim ct = entered_regionview->region()->can_trim ();
1087
1088         if (left) {
1089
1090                 if (ct & Trimmable::FrontTrimEarlier) {
1091                         return _cursors->left_side_trim;
1092                 } else {
1093                         return _cursors->left_side_trim_right_only;
1094                 }
1095         } else {
1096                 if (ct & Trimmable::EndTrimLater) {
1097                         return _cursors->right_side_trim;
1098                 } else {
1099                         return _cursors->right_side_trim_left_only;
1100                 }
1101         }
1102 }
1103
1104 Gdk::Cursor*
1105 Editor::which_mode_cursor () const
1106 {
1107         Gdk::Cursor* mode_cursor = MouseCursors::invalid_cursor ();
1108
1109         switch (mouse_mode) {
1110         case MouseRange:
1111                 mode_cursor = _cursors->selector;
1112                 break;
1113
1114         case MouseCut:
1115                 mode_cursor = _cursors->scissors;
1116                 break;
1117
1118         case MouseObject:
1119         case MouseContent:
1120                 /* don't use mode cursor, pick a grabber cursor based on the item */
1121                 break;
1122
1123         case MouseDraw:
1124                 mode_cursor = _cursors->midi_pencil;
1125                 break;
1126
1127         case MouseTimeFX:
1128                 mode_cursor = _cursors->time_fx; // just use playhead
1129                 break;
1130
1131         case MouseAudition:
1132                 mode_cursor = _cursors->speaker;
1133                 break;
1134         }
1135
1136         /* up-down cursor as a cue that automation can be dragged up and down when in join object/range mode */
1137         if (get_smart_mode()) {
1138
1139                 double x, y;
1140                 get_pointer_position (x, y);
1141
1142                 if (x >= 0 && y >= 0) {
1143
1144                         vector<ArdourCanvas::Item const *> items;
1145
1146                         /* Note how we choose a specific scroll group to get
1147                          * items from. This could be problematic.
1148                          */
1149
1150                         hv_scroll_group->add_items_at_point (ArdourCanvas::Duple (x,y), items);
1151
1152                         // first item will be the upper most
1153
1154                         if (!items.empty()) {
1155                                 const ArdourCanvas::Item* i = items.front();
1156
1157                                 if (i && i->parent() && i->parent()->get_data (X_("timeselection"))) {
1158                                         pair<TimeAxisView*, int> tvp = trackview_by_y_position (_last_motion_y);
1159                                         if (dynamic_cast<AutomationTimeAxisView*> (tvp.first)) {
1160                                                 mode_cursor = _cursors->up_down;
1161                                         }
1162                                 }
1163                         }
1164                 }
1165         }
1166
1167         return mode_cursor;
1168 }
1169
1170 Gdk::Cursor*
1171 Editor::which_track_cursor () const
1172 {
1173         Gdk::Cursor* cursor = MouseCursors::invalid_cursor();
1174
1175         switch (_join_object_range_state) {
1176         case JOIN_OBJECT_RANGE_NONE:
1177         case JOIN_OBJECT_RANGE_OBJECT:
1178                 cursor = which_grabber_cursor ();
1179                 break;
1180         case JOIN_OBJECT_RANGE_RANGE:
1181                 cursor = _cursors->selector;
1182                 break;
1183         }
1184
1185         return cursor;
1186 }
1187
1188 Gdk::Cursor*
1189 Editor::which_canvas_cursor(ItemType type) const
1190 {
1191         Gdk::Cursor* cursor = which_mode_cursor ();
1192
1193         if (mouse_mode == MouseRange) {
1194                 switch (type) {
1195                 case StartSelectionTrimItem:
1196                         cursor = _cursors->left_side_trim;
1197                         break;
1198                 case EndSelectionTrimItem:
1199                         cursor = _cursors->right_side_trim;
1200                         break;
1201                 default:
1202                         break;
1203                 }
1204         }
1205
1206         if ((mouse_mode == MouseObject || get_smart_mode ()) ||
1207             mouse_mode == MouseContent) {
1208
1209                 /* find correct cursor to use in object/smart mode */
1210
1211                 switch (type) {
1212                 case RegionItem:
1213                 /* We don't choose a cursor for these items on top of a region view,
1214                    because this would push a new context on the enter stack which
1215                    means switching the region context for things like smart mode
1216                    won't actualy change the cursor. */
1217                 // case RegionViewNameHighlight:
1218                 // case RegionViewName:
1219                 // case WaveItem:
1220                 case StreamItem:
1221                 case AutomationTrackItem:
1222                         cursor = which_track_cursor ();
1223                         break;
1224                 case PlayheadCursorItem:
1225                         switch (_edit_point) {
1226                         case EditAtMouse:
1227                                 cursor = _cursors->grabber_edit_point;
1228                                 break;
1229                         default:
1230                                 cursor = _cursors->grabber;
1231                                 break;
1232                         }
1233                         break;
1234                 case SelectionItem:
1235                         cursor = _cursors->selector;
1236                         break;
1237                 case ControlPointItem:
1238                         cursor = _cursors->fader;
1239                         break;
1240                 case GainLineItem:
1241                         cursor = _cursors->cross_hair;
1242                         break;
1243                 case AutomationLineItem:
1244                         cursor = _cursors->cross_hair;
1245                         break;
1246                 case StartSelectionTrimItem:
1247                         cursor = _cursors->left_side_trim;
1248                         break;
1249                 case EndSelectionTrimItem:
1250                         cursor = _cursors->right_side_trim;
1251                         break;
1252                 case FadeInItem:
1253                         cursor = _cursors->fade_in;
1254                         break;
1255                 case FadeInHandleItem:
1256                         cursor = _cursors->fade_in;
1257                         break;
1258                 case FadeInTrimHandleItem:
1259                         cursor = _cursors->fade_in;
1260                         break;
1261                 case FadeOutItem:
1262                         cursor = _cursors->fade_out;
1263                         break;
1264                 case FadeOutHandleItem:
1265                         cursor = _cursors->fade_out;
1266                         break;
1267                 case FadeOutTrimHandleItem:
1268                         cursor = _cursors->fade_out;
1269                         break;
1270                 case FeatureLineItem:
1271                         cursor = _cursors->cross_hair;
1272                         break;
1273                 case LeftFrameHandle:
1274                         if ( effective_mouse_mode() == MouseObject )  // (smart mode): if the user is in the btm half, show the trim cursor
1275                                 cursor = which_trim_cursor (true);
1276                         else
1277                                 cursor = _cursors->selector;  // (smart mode): in the top half, just show the selection (range) cursor
1278                         break;
1279                 case RightFrameHandle:
1280                         if ( effective_mouse_mode() == MouseObject )  //see above
1281                                 cursor = which_trim_cursor (false);
1282                         else
1283                                 cursor = _cursors->selector;
1284                         break;
1285                 case StartCrossFadeItem:
1286                         cursor = _cursors->fade_in;
1287                         break;
1288                 case EndCrossFadeItem:
1289                         cursor = _cursors->fade_out;
1290                         break;
1291                 case CrossfadeViewItem:
1292                         cursor = _cursors->cross_hair;
1293                         break;
1294                 case NoteItem:
1295                         cursor = _cursors->grabber_note;
1296                 default:
1297                         break;
1298                 }
1299
1300         } else if (mouse_mode == MouseDraw) {
1301
1302                 /* ControlPointItem is not really specific to region gain mode
1303                    but it is the same cursor so don't worry about this for now.
1304                    The result is that we'll see the fader cursor if we enter
1305                    non-region-gain-line control points while in MouseDraw
1306                    mode, even though we can't edit them in this mode.
1307                 */
1308
1309                 switch (type) {
1310                 case GainLineItem:
1311                 case ControlPointItem:
1312                         cursor = _cursors->fader;
1313                         break;
1314                 case NoteItem:
1315                         cursor = _cursors->grabber_note;
1316                 default:
1317                         break;
1318                 }
1319         }
1320
1321         switch (type) {
1322                 /* These items use the timebar cursor at all times */
1323         case TimecodeRulerItem:
1324         case MinsecRulerItem:
1325         case BBTRulerItem:
1326         case SamplesRulerItem:
1327                 cursor = _cursors->timebar;
1328                 break;
1329
1330                 /* These items use the grabber cursor at all times */
1331         case MeterMarkerItem:
1332         case TempoMarkerItem:
1333         case MeterBarItem:
1334         case TempoBarItem:
1335         case MarkerItem:
1336         case MarkerBarItem:
1337         case RangeMarkerBarItem:
1338         case CdMarkerBarItem:
1339         case VideoBarItem:
1340         case TransportMarkerBarItem:
1341         case DropZoneItem:
1342                 cursor = which_grabber_cursor();
1343                 break;
1344
1345         default:
1346                 break;
1347         }
1348
1349         return cursor;
1350 }
1351
1352 void
1353 Editor::choose_canvas_cursor_on_entry (ItemType type)
1354 {
1355         if (_drags->active()) {
1356                 return;
1357         }
1358
1359         Gdk::Cursor* cursor = which_canvas_cursor(type);
1360
1361         if (!_cursors->is_invalid (cursor)) {
1362                 // Push a new enter context
1363                 const EnterContext ctx = { type, CursorContext::create(*this, cursor) };
1364                 _enter_stack.push_back(ctx);
1365         }
1366 }
1367
1368 void
1369 Editor::update_all_enter_cursors ()
1370 {
1371         for (std::vector<EnterContext>::iterator i = _enter_stack.begin(); i != _enter_stack.end(); ++i) {
1372                 i->cursor_ctx->change(which_canvas_cursor(i->item_type));
1373         }
1374 }
1375
1376 double
1377 Editor::trackviews_height() const
1378 {
1379         if (!_trackview_group) {
1380                 return 0;
1381         }
1382
1383         return _visible_canvas_height - _trackview_group->canvas_origin().y;
1384 }