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 "canvas/canvas.h"
  31 #include "canvas/rectangle.h"
  32 #include "canvas/pixbuf.h"
  33 #include "canvas/scroll_group.h"
  34 #include "canvas/text.h"
  35 #include "canvas/debug.h"
  36
  37 #include "ardour_ui.h"
  38 #include "automation_time_axis.h"
  39 #include "editor.h"
  40 #include "global_signals.h"
  41 #include "editing.h"
  42 #include "rgb_macros.h"
  43 #include "utils.h"
  44 #include "audio_time_axis.h"
  45 #include "editor_drag.h"
  46 #include "region_view.h"
  47 #include "editor_group_tabs.h"
  48 #include "editor_summary.h"
  49 #include "video_timeline.h"
  50 #include "keyboard.h"
  51 #include "editor_cursors.h"
  52 #include "mouse_cursors.h"
  53 #include "verbose_cursor.h"
  54
  55 #include "i18n.h"
  56
  57 using namespace std;
  58 using namespace ARDOUR;
  59 using namespace ARDOUR_UI_UTILS;
  60 using namespace PBD;
  61 using namespace Gtk;
  62 using namespace Glib;
  63 using namespace Gtkmm2ext;
  64 using namespace Editing;
  65
  66 void
  67 Editor::initialize_canvas ()
  68 {
  69         _track_canvas_viewport = new ArdourCanvas::GtkCanvasViewport (horizontal_adjustment, vertical_adjustment);
  70         _track_canvas = _track_canvas_viewport->canvas ();
  71
  72         /* scroll group for items that should not automatically scroll
  73          *  (e.g verbose cursor). It shares the canvas coordinate space.
  74         */
  75         no_scroll_group = new ArdourCanvas::Container (_track_canvas->root());
  76
  77         ArdourCanvas::ScrollGroup* hsg;
  78         ArdourCanvas::ScrollGroup* hg;
  79         ArdourCanvas::ScrollGroup* vg;
  80
  81         hv_scroll_group = hsg = new ArdourCanvas::ScrollGroup (_track_canvas->root(),
  82                                                                ArdourCanvas::ScrollGroup::ScrollSensitivity (ArdourCanvas::ScrollGroup::ScrollsVertically|
  83                                                                                                              ArdourCanvas::ScrollGroup::ScrollsHorizontally));
  84         CANVAS_DEBUG_NAME (hv_scroll_group, "canvas hv scroll");
  85         _track_canvas->add_scroller (*hsg);
  86
  87         v_scroll_group = vg = new ArdourCanvas::ScrollGroup (_track_canvas->root(), ArdourCanvas::ScrollGroup::ScrollsVertically);
  88         CANVAS_DEBUG_NAME (v_scroll_group, "canvas v scroll");
  89         _track_canvas->add_scroller (*vg);
  90
  91         h_scroll_group = hg = new ArdourCanvas::ScrollGroup (_track_canvas->root(), ArdourCanvas::ScrollGroup::ScrollsHorizontally);
  92         CANVAS_DEBUG_NAME (h_scroll_group, "canvas h scroll");
  93         _track_canvas->add_scroller (*hg);
  94
  95         _verbose_cursor = new VerboseCursor (this);
  96
  97         /* on the bottom, an image */
  98
  99         if (Profile->get_sae()) {
 100                 Image img (::get_icon (X_("saelogo")));
 101                 // logo_item = new ArdourCanvas::Pixbuf (_track_canvas->root(), 0.0, 0.0, img.get_pixbuf());
 102                 // logo_item->property_height_in_pixels() = true;
 103                 // logo_item->property_width_in_pixels() = true;
 104                 // logo_item->property_height_set() = true;
 105                 // logo_item->property_width_set() = true;
 106                 // logo_item->show ();
 107         }
 108
 109         /*a group to hold global rects like punch/loop indicators */
 110         global_rect_group = new ArdourCanvas::Container (hv_scroll_group);
 111         CANVAS_DEBUG_NAME (global_rect_group, "global rect group");
 112
 113         transport_loop_range_rect = new ArdourCanvas::Rectangle (global_rect_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, ArdourCanvas::COORD_MAX));
 114         CANVAS_DEBUG_NAME (transport_loop_range_rect, "loop rect");
 115         transport_loop_range_rect->hide();
 116
 117         transport_punch_range_rect = new ArdourCanvas::Rectangle (global_rect_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, ArdourCanvas::COORD_MAX));
 118         CANVAS_DEBUG_NAME (transport_punch_range_rect, "punch rect");
 119         transport_punch_range_rect->hide();
 120
 121         /*a group to hold time (measure) lines */
 122         time_line_group = new ArdourCanvas::Container (hv_scroll_group);
 123         CANVAS_DEBUG_NAME (time_line_group, "time line group");
 124
 125         _trackview_group = new ArdourCanvas::Container (hv_scroll_group);
 126         CANVAS_DEBUG_NAME (_trackview_group, "Canvas TrackViews");
 127
 128         // used to show zoom mode active zooming
 129         zoom_rect = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, 0.0));
 130         zoom_rect->hide();
 131         zoom_rect->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_zoom_rect_event), (ArdourCanvas::Item*) 0));
 132
 133         // used as rubberband rect
 134         rubberband_rect = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, 0.0));
 135         rubberband_rect->hide();
 136
 137         /* a group to hold stuff while it gets dragged around. Must be the
 138          * uppermost (last) group with hv_scroll_group as a parent
 139          */
 140         _drag_motion_group = new ArdourCanvas::Container (hv_scroll_group);
 141         CANVAS_DEBUG_NAME (_drag_motion_group, "Canvas Drag Motion");
 142
 143         /* TIME BAR CANVAS */
 144
 145         _time_markers_group = new ArdourCanvas::Container (h_scroll_group);
 146         CANVAS_DEBUG_NAME (_time_markers_group, "time bars");
 147
 148         cd_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, 0.0));
 149         CANVAS_DEBUG_NAME (cd_marker_group, "cd marker group");
 150         /* the vide is temporarily placed a the same location as the
 151            cd_marker_group, but is moved later.
 152         */
 153         videotl_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple(0.0, 0.0));
 154         CANVAS_DEBUG_NAME (videotl_group, "videotl group");
 155         marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height + 1.0));
 156         CANVAS_DEBUG_NAME (marker_group, "marker group");
 157         transport_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 2.0) + 1.0));
 158         CANVAS_DEBUG_NAME (transport_marker_group, "transport marker group");
 159         range_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 3.0) + 1.0));
 160         CANVAS_DEBUG_NAME (range_marker_group, "range marker group");
 161         tempo_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 4.0) + 1.0));
 162         CANVAS_DEBUG_NAME (tempo_group, "tempo group");
 163         meter_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 5.0) + 1.0));
 164         CANVAS_DEBUG_NAME (meter_group, "meter group");
 165
 166         meter_bar = new ArdourCanvas::Rectangle (meter_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 167         CANVAS_DEBUG_NAME (meter_bar, "meter Bar");
 168         meter_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 169
 170         tempo_bar = new ArdourCanvas::Rectangle (tempo_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 171         CANVAS_DEBUG_NAME (tempo_bar, "Tempo  Bar");
 172         tempo_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 173
 174         range_marker_bar = new ArdourCanvas::Rectangle (range_marker_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 175         CANVAS_DEBUG_NAME (range_marker_bar, "Range Marker Bar");
 176         range_marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 177
 178         transport_marker_bar = new ArdourCanvas::Rectangle (transport_marker_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 179         CANVAS_DEBUG_NAME (transport_marker_bar, "transport Marker Bar");
 180         transport_marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 181
 182         marker_bar = new ArdourCanvas::Rectangle (marker_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 183         CANVAS_DEBUG_NAME (marker_bar, "Marker Bar");
 184         marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 185
 186         cd_marker_bar = new ArdourCanvas::Rectangle (cd_marker_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 187         CANVAS_DEBUG_NAME (cd_marker_bar, "CD Marker Bar");
 188         cd_marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 189
 190         ARDOUR_UI::instance()->video_timeline = new VideoTimeLine(this, videotl_group, (timebar_height * videotl_bar_height));
 191
 192         cd_marker_bar_drag_rect = new ArdourCanvas::Rectangle (cd_marker_group, ArdourCanvas::Rect (0.0, 0.0, 100, timebar_height));
 193         CANVAS_DEBUG_NAME (cd_marker_bar_drag_rect, "cd marker drag");
 194         cd_marker_bar_drag_rect->set_outline (false);
 195         cd_marker_bar_drag_rect->hide ();
 196
 197         range_bar_drag_rect = new ArdourCanvas::Rectangle (range_marker_group, ArdourCanvas::Rect (0.0, 0.0, 100, timebar_height));
 198         CANVAS_DEBUG_NAME (range_bar_drag_rect, "range drag");
 199         range_bar_drag_rect->set_outline (false);
 200         range_bar_drag_rect->hide ();
 201
 202         transport_bar_drag_rect = new ArdourCanvas::Rectangle (transport_marker_group, ArdourCanvas::Rect (0.0, 0.0, 100, timebar_height));
 203         CANVAS_DEBUG_NAME (transport_bar_drag_rect, "transport drag");
 204         transport_bar_drag_rect->set_outline (false);
 205         transport_bar_drag_rect->hide ();
 206
 207         transport_punchin_line = new ArdourCanvas::Line (hv_scroll_group);
 208         transport_punchin_line->set_x0 (0);
 209         transport_punchin_line->set_y0 (0);
 210         transport_punchin_line->set_x1 (0);
 211         transport_punchin_line->set_y1 (ArdourCanvas::COORD_MAX);
 212         transport_punchin_line->hide ();
 213
 214         transport_punchout_line  = new ArdourCanvas::Line (hv_scroll_group);
 215         transport_punchout_line->set_x0 (0);
 216         transport_punchout_line->set_y0 (0);
 217         transport_punchout_line->set_x1 (0);
 218         transport_punchout_line->set_y1 (ArdourCanvas::COORD_MAX);
 219         transport_punchout_line->hide();
 220
 221         tempo_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_tempo_bar_event), tempo_bar));
 222         meter_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_meter_bar_event), meter_bar));
 223         marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_marker_bar_event), marker_bar));
 224         cd_marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_cd_marker_bar_event), cd_marker_bar));
 225         videotl_group->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_videotl_bar_event), videotl_group));
 226         range_marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_range_marker_bar_event), range_marker_bar));
 227         transport_marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_transport_marker_bar_event), transport_marker_bar));
 228
 229         playhead_cursor = new EditorCursor (*this, &Editor::canvas_playhead_cursor_event);
 230
 231         if (logo_item) {
 232                 logo_item->lower_to_bottom ();
 233         }
 234
 235
 236         _canvas_drop_zone = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, 0.0));
 237         /* this thing is transparent */
 238         _canvas_drop_zone->set_fill (false);
 239         _canvas_drop_zone->set_outline (false);
 240         _canvas_drop_zone->Event.connect (sigc::mem_fun (*this, &Editor::canvas_drop_zone_event));
 241
 242         /* these signals will initially be delivered to the canvas itself, but if they end up remaining unhandled, they are passed to Editor-level
 243            handlers.
 244         */
 245
 246         _track_canvas->signal_scroll_event().connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_scroll_event), true));
 247         _track_canvas->signal_motion_notify_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_motion_notify_event));
 248         _track_canvas->signal_button_press_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_button_press_event));
 249         _track_canvas->signal_button_release_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_button_release_event));
 250         _track_canvas->signal_drag_motion().connect (sigc::mem_fun (*this, &Editor::track_canvas_drag_motion));
 251         _track_canvas->signal_key_press_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_key_press));
 252         _track_canvas->signal_key_release_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_key_release));
 253
 254         _track_canvas->set_name ("EditorMainCanvas");
 255         _track_canvas->add_events (Gdk::POINTER_MOTION_HINT_MASK | Gdk::SCROLL_MASK | Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK);
 256         _track_canvas->signal_leave_notify_event().connect (sigc::mem_fun(*this, &Editor::left_track_canvas), false);
 257         _track_canvas->signal_enter_notify_event().connect (sigc::mem_fun(*this, &Editor::entered_track_canvas), false);
 258         _track_canvas->set_flags (CAN_FOCUS);
 259
 260         /* set up drag-n-drop */
 261
 262         vector<TargetEntry> target_table;
 263
 264         // Drag-N-Drop from the region list can generate this target
 265         target_table.push_back (TargetEntry ("regions"));
 266
 267         target_table.push_back (TargetEntry ("text/plain"));
 268         target_table.push_back (TargetEntry ("text/uri-list"));
 269         target_table.push_back (TargetEntry ("application/x-rootwin-drop"));
 270
 271         _track_canvas->drag_dest_set (target_table);
 272         _track_canvas->signal_drag_data_received().connect (sigc::mem_fun(*this, &Editor::track_canvas_drag_data_received));
 273
 274         _track_canvas_viewport->signal_size_allocate().connect (sigc::mem_fun(*this, &Editor::track_canvas_viewport_allocate));
 275
 276         initialize_rulers ();
 277
 278         ColorsChanged.connect (sigc::mem_fun (*this, &Editor::color_handler));
 279         color_handler();
 280
 281 }
 282
 283 void
 284 Editor::track_canvas_viewport_allocate (Gtk::Allocation alloc)
 285 {
 286         _canvas_viewport_allocation = alloc;
 287         track_canvas_viewport_size_allocated ();
 288 }
 289
 290 void
 291 Editor::track_canvas_viewport_size_allocated ()
 292 {
 293         bool height_changed = _visible_canvas_height != _canvas_viewport_allocation.get_height();
 294
 295         _visible_canvas_width  = _canvas_viewport_allocation.get_width ();
 296         _visible_canvas_height = _canvas_viewport_allocation.get_height ();
 297
 298         _canvas_drop_zone->set_y1 (_canvas_drop_zone->y0() + (_visible_canvas_height - 20.0));
 299
 300         // SHOWTRACKS
 301
 302         if (height_changed) {
 303
 304                 for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
 305                         i->second->canvas_height_set (_visible_canvas_height);
 306                 }
 307
 308                 vertical_adjustment.set_page_size (_visible_canvas_height);
 309                 if ((vertical_adjustment.get_value() + _visible_canvas_height) >= vertical_adjustment.get_upper()) {
 310                         /*
 311                            We're increasing the size of the canvas while the bottom is visible.
 312                            We scroll down to keep in step with the controls layout.
 313                         */
 314                         vertical_adjustment.set_value (_full_canvas_height - _visible_canvas_height);
 315                 }
 316
 317                 set_visible_track_count (_visible_track_count);
 318         }
 319
 320         update_fixed_rulers();
 321         redisplay_tempo (false);
 322         _summary->set_overlays_dirty ();
 323 }
 324
 325 void
 326 Editor::reset_controls_layout_width ()
 327 {
 328         GtkRequisition req;
 329         gint w;
 330
 331         edit_controls_vbox.size_request (req);
 332         w = req.width;
 333
 334         if (_group_tabs->is_mapped()) {
 335                 _group_tabs->size_request (req);
 336                 w += req.width;
 337         }
 338
 339         /* the controls layout has no horizontal scrolling, its visible
 340            width is always equal to the total width of its contents.
 341         */
 342
 343         controls_layout.property_width() = w;
 344         controls_layout.property_width_request() = w;
 345 }
 346
 347 void
 348 Editor::reset_controls_layout_height (int32_t h)
 349 {
 350         /* ensure that the rect that represents the "bottom" of the canvas
 351          * (the drag-n-drop zone) is, in fact, at the bottom.
 352          */
 353
 354         _canvas_drop_zone->set_position (ArdourCanvas::Duple (0, h));
 355
 356         /* track controls layout must span the full height of "h" (all tracks)
 357          * plus the bottom rect.
 358          */
 359
 360         h += _canvas_drop_zone->height ();
 361
 362         /* set the height of the scrollable area (i.e. the sum of all contained widgets)
 363          * for the controls layout. The size request is set elsewhere.
 364          */
 365
 366         controls_layout.property_height() = h;
 367
 368 }
 369
 370 bool
 371 Editor::track_canvas_map_handler (GdkEventAny* /*ev*/)
 372 {
 373         if (current_canvas_cursor) {
 374                 set_canvas_cursor (current_canvas_cursor);
 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
 429                 do_import (midi_paths, Editing::ImportDistinctFiles, ImportAsTrack, SrcBest, frame);
 430
 431                 if (Profile->get_sae() || Config->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() || Config->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 (!Config->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         int cx, cy;
 521
 522         if (from_headers) {
 523                 alloc = controls_layout.get_allocation ();
 524         } else {
 525                 alloc = _track_canvas_viewport->get_allocation ();
 526                 cx = alloc.get_x();
 527                 cy = alloc.get_y();
 528
 529                 /* reduce height by the height of the timebars, which happens
 530                    to correspond to the position of the hv_scroll_group.
 531                 */
 532
 533                 alloc.set_height (alloc.get_height() - hv_scroll_group->position().y);
 534                 alloc.set_y (alloc.get_y() + hv_scroll_group->position().y);
 535
 536                 /* now reduce it again so that we start autoscrolling before we
 537                  * move off the top or bottom of the canvas
 538                  */
 539
 540                 alloc.set_height (alloc.get_height() - 20);
 541                 alloc.set_y (alloc.get_y() + 10);
 542
 543                 /* the effective width of the autoscroll boundary so
 544                    that we start scrolling before we hit the edge.
 545
 546                    this helps when the window is slammed up against the
 547                    right edge of the screen, making it hard to scroll
 548                    effectively.
 549                 */
 550
 551                 if (alloc.get_width() > 20) {
 552                         alloc.set_width (alloc.get_width() - 20);
 553                         alloc.set_x (alloc.get_x() + 10);
 554                 }
 555
 556         }
 557
 558         scrolling_boundary = ArdourCanvas::Rect (alloc.get_x(), alloc.get_y(), alloc.get_x() + alloc.get_width(), alloc.get_y() + alloc.get_height());
 559
 560         int x, y;
 561         Gdk::ModifierType mask;
 562
 563         get_window()->get_pointer (x, y, mask);
 564
 565         if ((allow_horiz && ((x < scrolling_boundary.x0 && leftmost_frame > 0) || x >= scrolling_boundary.x1)) ||
 566             (allow_vert && ((y < scrolling_boundary.y0 && vertical_adjustment.get_value() > 0)|| y >= scrolling_boundary.y1))) {
 567                 start_canvas_autoscroll (allow_horiz, allow_vert, scrolling_boundary);
 568         }
 569 }
 570
 571 bool
 572 Editor::autoscroll_active () const
 573 {
 574         return autoscroll_connection.connected ();
 575 }
 576
 577 bool
 578 Editor::autoscroll_canvas ()
 579 {
 580         int x, y;
 581         Gdk::ModifierType mask;
 582         frameoffset_t dx = 0;
 583         bool no_stop = false;
 584         bool y_motion = false;
 585
 586         get_window()->get_pointer (x, y, mask);
 587
 588         VisualChange vc;
 589         bool vertical_motion = false;
 590
 591         if (autoscroll_horizontal_allowed) {
 592
 593                 framepos_t new_frame = leftmost_frame;
 594
 595                 /* horizontal */
 596
 597                 if (x > autoscroll_boundary.x1) {
 598
 599                         /* bring it back into view */
 600                         dx = x - autoscroll_boundary.x1;
 601                         dx += 10 + (2 * (autoscroll_cnt/2));
 602
 603                         dx = pixel_to_sample (dx);
 604
 605                         if (leftmost_frame < max_framepos - dx) {
 606                                 new_frame = leftmost_frame + dx;
 607                         } else {
 608                                 new_frame = max_framepos;
 609                         }
 610
 611                         no_stop = true;
 612
 613                 } else if (x < autoscroll_boundary.x0) {
 614
 615                         dx = autoscroll_boundary.x0 - x;
 616                         dx += 10 + (2 * (autoscroll_cnt/2));
 617
 618                         dx = pixel_to_sample (dx);
 619
 620                         if (leftmost_frame >= dx) {
 621                                 new_frame = leftmost_frame - dx;
 622                         } else {
 623                                 new_frame = 0;
 624                         }
 625
 626                         no_stop = true;
 627                 }
 628
 629                 if (new_frame != leftmost_frame) {
 630                         vc.time_origin = new_frame;
 631                         vc.add (VisualChange::TimeOrigin);
 632                 }
 633         }
 634
 635         if (autoscroll_vertical_allowed) {
 636
 637                 // const double vertical_pos = vertical_adjustment.get_value();
 638                 const int speed_factor = 10;
 639
 640                 /* vertical */
 641
 642                 if (y < autoscroll_boundary.y0) {
 643
 644                         /* scroll to make higher tracks visible */
 645
 646                         if (autoscroll_cnt && (autoscroll_cnt % speed_factor == 0)) {
 647                                 y_motion = scroll_up_one_track ();
 648                                 vertical_motion = true;
 649                         }
 650
 651                 } else if (y > autoscroll_boundary.y1) {
 652
 653                         if (autoscroll_cnt && (autoscroll_cnt % speed_factor == 0)) {
 654                                 y_motion = scroll_down_one_track ();
 655                                 vertical_motion = true;
 656                         }
 657                 }
 658
 659                 no_stop = true;
 660         }
 661
 662         if (vc.pending || vertical_motion) {
 663
 664                 /* change horizontal first */
 665
 666                 if (vc.pending) {
 667                         visual_changer (vc);
 668                 }
 669
 670                 /* now send a motion event to notify anyone who cares
 671                    that we have moved to a new location (because we scrolled)
 672                 */
 673
 674                 GdkEventMotion ev;
 675
 676                 ev.type = GDK_MOTION_NOTIFY;
 677                 ev.state = Gdk::BUTTON1_MASK;
 678
 679                 /* the motion handler expects events in canvas coordinate space */
 680
 681                 /* we asked for the mouse position above (::get_pointer()) via
 682                  * our own top level window (we being the Editor). Convert into
 683                  * coordinates within the canvas window.
 684                  */
 685
 686                 int cx;
 687                 int cy;
 688
 689                 translate_coordinates (*_track_canvas, x, y, cx, cy);
 690
 691                 /* clamp x and y to remain within the autoscroll boundary,
 692                  * which is defined in window coordinates
 693                  */
 694
 695                 x = min (max ((ArdourCanvas::Coord) cx, autoscroll_boundary.x0), autoscroll_boundary.x1);
 696                 y = min (max ((ArdourCanvas::Coord) cy, autoscroll_boundary.y0), autoscroll_boundary.y1);
 697
 698                 /* now convert from Editor window coordinates to canvas
 699                  * window coordinates
 700                  */
 701
 702                 ArdourCanvas::Duple d = _track_canvas->window_to_canvas (ArdourCanvas::Duple (cx, cy));
 703                 ev.x = d.x;
 704                 ev.y = d.y;
 705
 706                 motion_handler (0, (GdkEvent*) &ev, true);
 707
 708         } else if (no_stop) {
 709
 710                 /* not changing visual state but pointer is outside the scrolling boundary
 711                  * so we still need to deliver a fake motion event
 712                  */
 713
 714                 GdkEventMotion ev;
 715
 716                 ev.type = GDK_MOTION_NOTIFY;
 717                 ev.state = Gdk::BUTTON1_MASK;
 718
 719                 /* the motion handler expects events in canvas coordinate space */
 720
 721                 /* first convert from Editor window coordinates to canvas
 722                  * window coordinates
 723                  */
 724
 725                 int cx;
 726                 int cy;
 727
 728                 /* clamp x and y to remain within the visible area. except
 729                  * .. if horizontal scrolling is allowed, always allow us to
 730                  * move back to zero
 731                  */
 732
 733                 if (autoscroll_horizontal_allowed) {
 734                         x = min (max ((ArdourCanvas::Coord) x, 0.0), autoscroll_boundary.x1);
 735                 } else {
 736                         x = min (max ((ArdourCanvas::Coord) x, autoscroll_boundary.x0), autoscroll_boundary.x1);
 737                 }
 738                 y = min (max ((ArdourCanvas::Coord) y, autoscroll_boundary.y0), autoscroll_boundary.y1);
 739
 740                 translate_coordinates (*_track_canvas_viewport, x, y, cx, cy);
 741
 742                 ArdourCanvas::Duple d = _track_canvas->window_to_canvas (ArdourCanvas::Duple (cx, cy));
 743                 ev.x = d.x;
 744                 ev.y = d.y;
 745
 746                 motion_handler (0, (GdkEvent*) &ev, true);
 747
 748         } else {
 749                 stop_canvas_autoscroll ();
 750                 return false;
 751         }
 752
 753         autoscroll_cnt++;
 754
 755         return true; /* call me again */
 756 }
 757
 758 void
 759 Editor::start_canvas_autoscroll (bool allow_horiz, bool allow_vert, const ArdourCanvas::Rect& boundary)
 760 {
 761         if (!_session) {
 762                 return;
 763         }
 764
 765         stop_canvas_autoscroll ();
 766
 767         autoscroll_cnt = 0;
 768         autoscroll_horizontal_allowed = allow_horiz;
 769         autoscroll_vertical_allowed = allow_vert;
 770         autoscroll_boundary = boundary;
 771
 772         /* do the first scroll right now
 773         */
 774
 775         autoscroll_canvas ();
 776
 777         /* scroll again at very very roughly 30FPS */
 778
 779         autoscroll_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &Editor::autoscroll_canvas), 30);
 780 }
 781
 782 void
 783 Editor::stop_canvas_autoscroll ()
 784 {
 785         autoscroll_connection.disconnect ();
 786 }
 787
 788 bool
 789 Editor::left_track_canvas (GdkEventCrossing */*ev*/)
 790 {
 791         DropDownKeys ();
 792         within_track_canvas = false;
 793         set_entered_track (0);
 794         set_entered_regionview (0);
 795         reset_canvas_action_sensitivity (false);
 796         return false;
 797 }
 798
 799 bool
 800 Editor::entered_track_canvas (GdkEventCrossing */*ev*/)
 801 {
 802         within_track_canvas = true;
 803         reset_canvas_action_sensitivity (true);
 804         return FALSE;
 805 }
 806
 807 void
 808 Editor::_ensure_time_axis_view_is_visible (const TimeAxisView& tav, bool at_top)
 809 {
 810         double begin = tav.y_position();
 811         double v = vertical_adjustment.get_value ();
 812
 813         if (!at_top && (begin < v || begin + tav.current_height() > v + _visible_canvas_height)) {
 814                 /* try to put the TimeAxisView roughly central */
 815                 if (begin >= _visible_canvas_height/2.0) {
 816                         begin -= _visible_canvas_height/2.0;
 817                 }
 818         }
 819
 820         /* Clamp the y pos so that we do not extend beyond the canvas full
 821          * height.
 822          */
 823         if (_full_canvas_height - begin < _visible_canvas_height){
 824                 begin = _full_canvas_height - _visible_canvas_height;
 825         }
 826
 827         vertical_adjustment.set_value (begin);
 828 }
 829
 830 /** Called when the main vertical_adjustment has changed */
 831 void
 832 Editor::tie_vertical_scrolling ()
 833 {
 834         if (pending_visual_change.idle_handler_id < 0) {
 835                 _summary->set_overlays_dirty ();
 836         }
 837 }
 838
 839 void
 840 Editor::set_horizontal_position (double p)
 841 {
 842         horizontal_adjustment.set_value (p);
 843
 844         leftmost_frame = (framepos_t) floor (p * samples_per_pixel);
 845
 846         update_fixed_rulers ();
 847         redisplay_tempo (true);
 848
 849         if (pending_visual_change.idle_handler_id < 0) {
 850                 _summary->set_overlays_dirty ();
 851         }
 852
 853         update_video_timeline();
 854 }
 855
 856 void
 857 Editor::color_handler()
 858 {
 859         ArdourCanvas::Color base = ARDOUR_UI::config()->get_canvasvar_RulerBase();
 860         ArdourCanvas::Color text = ARDOUR_UI::config()->get_canvasvar_RulerText();
 861         timecode_ruler->set_fill_color (base);
 862         timecode_ruler->set_outline_color (text);
 863         minsec_ruler->set_fill_color (base);
 864         minsec_ruler->set_outline_color (text);
 865         samples_ruler->set_fill_color (base);
 866         samples_ruler->set_outline_color (text);
 867         bbt_ruler->set_fill_color (base);
 868         bbt_ruler->set_outline_color (text);
 869
 870         playhead_cursor->set_color (ARDOUR_UI::config()->get_canvasvar_PlayHead());
 871
 872         meter_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_MeterBar());
 873         meter_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 874
 875         tempo_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TempoBar());
 876         tempo_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 877
 878         marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_MarkerBar());
 879         marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 880
 881         cd_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_CDMarkerBar());
 882         cd_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 883
 884         range_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeMarkerBar());
 885         range_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 886
 887         transport_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportMarkerBar());
 888         transport_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 889
 890         cd_marker_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
 891         cd_marker_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
 892
 893         range_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
 894         range_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
 895
 896         transport_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportDragRect());
 897         transport_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportDragRect());
 898
 899         transport_loop_range_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportLoopRect());
 900         transport_loop_range_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportLoopRect());
 901
 902         transport_punch_range_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportPunchRect());
 903         transport_punch_range_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportPunchRect());
 904
 905         transport_punchin_line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_PunchLine());
 906         transport_punchout_line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_PunchLine());
 907
 908         zoom_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_ZoomRect());
 909         zoom_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_ZoomRect());
 910
 911         rubberband_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RubberBandRect());
 912         rubberband_rect->set_fill_color ((guint32) ARDOUR_UI::config()->get_canvasvar_RubberBandRect());
 913
 914         location_marker_color = ARDOUR_UI::config()->get_canvasvar_LocationMarker();
 915         location_range_color = ARDOUR_UI::config()->get_canvasvar_LocationRange();
 916         location_cd_marker_color = ARDOUR_UI::config()->get_canvasvar_LocationCDMarker();
 917         location_loop_color = ARDOUR_UI::config()->get_canvasvar_LocationLoop();
 918         location_punch_color = ARDOUR_UI::config()->get_canvasvar_LocationPunch();
 919
 920         refresh_location_display ();
 921 /*
 922         redisplay_tempo (true);
 923
 924         if (_session)
 925               _session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); // redraw metric markers
 926 */
 927 }
 928
 929 double
 930 Editor::horizontal_position () const
 931 {
 932         return sample_to_pixel (leftmost_frame);
 933 }
 934
 935 bool
 936 Editor::track_canvas_key_press (GdkEventKey*)
 937 {
 938         /* XXX: event does not report the modifier key pressed down, AFAICS, so use the Keyboard object instead */
 939         if (mouse_mode == Editing::MouseZoom && Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
 940                 set_canvas_cursor (_cursors->zoom_out, true);
 941         }
 942
 943         return false;
 944 }
 945
 946 bool
 947 Editor::track_canvas_key_release (GdkEventKey*)
 948 {
 949         if (mouse_mode == Editing::MouseZoom && !Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
 950                 set_canvas_cursor (_cursors->zoom_in, true);
 951         }
 952
 953         return false;
 954 }
 955
 956 double
 957 Editor::clamp_verbose_cursor_x (double x)
 958 {
 959         if (x < 0) {
 960                 x = 0;
 961         } else {
 962                 x = min (_visible_canvas_width - 200.0, x);
 963         }
 964         return x;
 965 }
 966
 967 double
 968 Editor::clamp_verbose_cursor_y (double y)
 969 {
 970         y = max (0.0, y);
 971         y = min (_visible_canvas_height - 50, y);
 972         return y;
 973 }
 974
 975 ArdourCanvas::GtkCanvasViewport*
 976 Editor::get_track_canvas() const
 977 {
 978         return _track_canvas_viewport;
 979 }
 980
 981 void
 982 Editor::set_canvas_cursor (Gdk::Cursor* cursor, bool save)
 983 {
 984         if (save) {
 985                 current_canvas_cursor = cursor;
 986         }
 987
 988         Glib::RefPtr<Gdk::Window> win = _track_canvas->get_window();
 989
 990         if (win && cursor) {
 991                 win->set_cursor (*cursor);
 992         }
 993 }
 994
 995 void
 996 Editor::push_canvas_cursor (Gdk::Cursor* cursor)
 997 {
 998         if (cursor) {
 999                 _cursor_stack.push (cursor);
1000                 set_canvas_cursor (cursor, false);
1001         }
1002 }
1003
1004 void
1005 Editor::pop_canvas_cursor ()
1006 {
1007         if (!_cursor_stack.empty()) {
1008                 Gdk::Cursor* cursor = _cursor_stack.top ();
1009                 _cursor_stack.pop ();
1010                 set_canvas_cursor (cursor, false);
1011         }
1012 }
1013
1014 Gdk::Cursor*
1015 Editor::which_grabber_cursor () const
1016 {
1017         Gdk::Cursor* c = _cursors->grabber;
1018
1019         if (_internal_editing) {
1020                 switch (mouse_mode) {
1021                 case MouseDraw:
1022                         c = _cursors->midi_pencil;
1023                         break;
1024
1025                 case MouseObject:
1026                         c = _cursors->grabber_note;
1027                         break;
1028
1029                 case MouseTimeFX:
1030                         c = _cursors->midi_resize;
1031                         break;
1032
1033                 case MouseRange:
1034                         c = _cursors->grabber_note;
1035                         break;
1036
1037                 default:
1038                         break;
1039                 }
1040
1041         } else {
1042
1043                 switch (_edit_point) {
1044                 case EditAtMouse:
1045                         c = _cursors->grabber_edit_point;
1046                         break;
1047                 default:
1048                         boost::shared_ptr<Movable> m = _movable.lock();
1049                         if (m && m->locked()) {
1050                                 c = _cursors->speaker;
1051                         }
1052                         break;
1053                 }
1054         }
1055
1056         return c;
1057 }
1058
1059 Gdk::Cursor*
1060 Editor::which_trim_cursor (bool left) const
1061 {
1062         if (!entered_regionview) {
1063                 return 0;
1064         }
1065
1066         Trimmable::CanTrim ct = entered_regionview->region()->can_trim ();
1067
1068         if (left) {
1069
1070                 if (ct & Trimmable::FrontTrimEarlier) {
1071                         return _cursors->left_side_trim;
1072                 } else {
1073                         return _cursors->left_side_trim_right_only;
1074                 }
1075         } else {
1076                 if (ct & Trimmable::EndTrimLater) {
1077                         return _cursors->right_side_trim;
1078                 } else {
1079                         return _cursors->right_side_trim_left_only;
1080                 }
1081         }
1082 }
1083
1084 Gdk::Cursor*
1085 Editor::which_mode_cursor () const
1086 {
1087         Gdk::Cursor* mode_cursor = 0;
1088
1089         switch (mouse_mode) {
1090         case MouseRange:
1091                 mode_cursor = _cursors->selector;
1092                 if (_internal_editing) {
1093                         mode_cursor = which_grabber_cursor();
1094                 }
1095                 break;
1096
1097         case MouseObject:
1098                 /* don't use mode cursor, pick a grabber cursor based on the item */
1099                 break;
1100
1101         case MouseDraw:
1102                 mode_cursor = _cursors->midi_pencil;
1103                 break;
1104
1105         case MouseGain:
1106                 mode_cursor = _cursors->cross_hair;
1107                 break;
1108
1109         case MouseZoom:
1110                 if (Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
1111                         mode_cursor = _cursors->zoom_out;
1112                 } else {
1113                         mode_cursor = _cursors->zoom_in;
1114                 }
1115                 break;
1116
1117         case MouseTimeFX:
1118                 mode_cursor = _cursors->time_fx; // just use playhead
1119                 break;
1120
1121         case MouseAudition:
1122                 mode_cursor = _cursors->speaker;
1123                 break;
1124         }
1125
1126         /* up-down cursor as a cue that automation can be dragged up and down when in join object/range mode */
1127         if (!_internal_editing && get_smart_mode() ) {
1128
1129                 double x, y;
1130                 get_pointer_position (x, y);
1131
1132                 if (x >= 0 && y >= 0) {
1133
1134                         vector<ArdourCanvas::Item const *> items;
1135
1136                         /* Note how we choose a specific scroll group to get
1137                          * items from. This could be problematic.
1138                          */
1139
1140                         hv_scroll_group->add_items_at_point (ArdourCanvas::Duple (x,y), items);
1141
1142                         // first item will be the upper most
1143
1144                         if (!items.empty()) {
1145                                 const ArdourCanvas::Item* i = items.front();
1146
1147                                 if (i && i->parent() && i->parent()->get_data (X_("timeselection"))) {
1148                                         pair<TimeAxisView*, int> tvp = trackview_by_y_position (_last_motion_y);
1149                                         if (dynamic_cast<AutomationTimeAxisView*> (tvp.first)) {
1150                                                 mode_cursor = _cursors->up_down;
1151                                         }
1152                                 }
1153                         }
1154                 }
1155         }
1156
1157         return mode_cursor;
1158 }
1159
1160 Gdk::Cursor*
1161 Editor::which_track_cursor () const
1162 {
1163         Gdk::Cursor* cursor = 0;
1164
1165         assert (mouse_mode == MouseObject || get_smart_mode());
1166
1167         if (!_internal_editing) {
1168                 switch (_join_object_range_state) {
1169                 case JOIN_OBJECT_RANGE_NONE:
1170                 case JOIN_OBJECT_RANGE_OBJECT:
1171                         cursor = which_grabber_cursor ();
1172                         cerr << "region use grabber\n";
1173                         break;
1174                 case JOIN_OBJECT_RANGE_RANGE:
1175                         cursor = _cursors->selector;
1176                         cerr << "region use selector\n";
1177                         break;
1178                 }
1179         }
1180
1181         return cursor;
1182 }
1183
1184 bool
1185 Editor::reset_canvas_cursor ()
1186 {
1187         if (!is_drawable()) {
1188                 return false;
1189         }
1190
1191         Gdk::Cursor* cursor = which_mode_cursor ();
1192
1193         if (cursor) {
1194                 set_canvas_cursor (cursor);
1195                 return true;
1196         }
1197
1198         return false;
1199 }
1200
1201 void
1202 Editor::choose_canvas_cursor_on_entry (GdkEventCrossing* /*event*/, ItemType type)
1203 {
1204         Gdk::Cursor* cursor = 0;
1205
1206         cerr << "entered new item type " << enum_2_string (type) << endl;
1207
1208         if (_drags->active()) {
1209                 return;
1210         }
1211
1212         cursor = which_mode_cursor ();
1213
1214         if (mouse_mode == MouseObject || get_smart_mode ()) {
1215
1216                 /* find correct cursor to use in object/smart mode */
1217
1218                 switch (type) {
1219                 case RegionItem:
1220                 case RegionViewNameHighlight:
1221                 case RegionViewName:
1222                 case WaveItem:
1223                 case StreamItem:
1224                 case AutomationTrackItem:
1225                         cursor = which_track_cursor ();
1226                         break;
1227                 case PlayheadCursorItem:
1228                         switch (_edit_point) {
1229                         case EditAtMouse:
1230                                 cursor = _cursors->grabber_edit_point;
1231                                 break;
1232                         default:
1233                                 cursor = _cursors->grabber;
1234                                 break;
1235                         }
1236                         break;
1237                 case SelectionItem:
1238                         cursor = _cursors->selector;
1239                         break;
1240                 case ControlPointItem:
1241                         cursor = _cursors->fader;
1242                         break;
1243                 case GainLineItem:
1244                         cursor = _cursors->fader;
1245                         break;
1246                 case AutomationLineItem:
1247                         cursor = _cursors->cross_hair;
1248                         break;
1249                 case StartSelectionTrimItem:
1250                         cursor = _cursors->left_side_trim;
1251                         break;
1252                 case EndSelectionTrimItem:
1253                         cursor = _cursors->right_side_trim;
1254                         break;
1255                 case FadeInItem:
1256                         cursor = _cursors->fade_in;
1257                         break;
1258                 case FadeInHandleItem:
1259                         cursor = _cursors->fade_in;
1260                         break;
1261                 case FadeInTrimHandleItem:
1262                         cursor = _cursors->fade_in;
1263                         break;
1264                 case FadeOutItem:
1265                         cursor = _cursors->fade_out;
1266                         break;
1267                 case FadeOutHandleItem:
1268                         cursor = _cursors->fade_out;
1269                         break;
1270                 case FadeOutTrimHandleItem:
1271                         cursor = _cursors->fade_out;
1272                         break;
1273                 case NoteItem:
1274                         cursor = which_grabber_cursor();
1275                         break;
1276                 case FeatureLineItem:
1277                         cursor = _cursors->cross_hair;
1278                         break;
1279                 case LeftFrameHandle:
1280                         cursor = which_trim_cursor (true);
1281                         break;
1282                 case RightFrameHandle:
1283                         cursor = which_trim_cursor (false);
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                 default:
1295                         break;
1296                 }
1297         }
1298
1299         switch (type) {
1300                 /* These items use the timebar cursor at all times */
1301         case TimecodeRulerItem:
1302         case MinsecRulerItem:
1303         case BBTRulerItem:
1304         case SamplesRulerItem:
1305                 cursor = _cursors->timebar;
1306                 break;
1307
1308                 /* These items use the grabber cursor at all times */
1309         case MeterMarkerItem:
1310         case TempoMarkerItem:
1311         case MeterBarItem:
1312         case TempoBarItem:
1313         case MarkerItem:
1314         case MarkerBarItem:
1315         case RangeMarkerBarItem:
1316         case CdMarkerBarItem:
1317         case VideoBarItem:
1318         case TransportMarkerBarItem:
1319                 cursor = which_grabber_cursor();
1320                 break;
1321
1322         default:
1323                 break;
1324         }
1325
1326         if (cursor) {
1327                 set_canvas_cursor (cursor, false);
1328         }
1329 }