gtk2_ardour/editor_canvas_events.cc

   1 /*
   2     Copyright (C) 2000 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 #include <cstdlib>
  21 #include <cmath>
  22 #include <algorithm>
  23 #include <typeinfo>
  24
  25 #include "pbd/stacktrace.h"
  26
  27 #include "ardour/audio_track.h"
  28 #include "ardour/midi_track.h"
  29 #include "ardour/midi_region.h"
  30 #include "ardour/region_factory.h"
  31 #include "ardour/profile.h"
  32
  33 #include "canvas/canvas.h"
  34 #include "canvas/text.h"
  35 #include "canvas/scroll_group.h"
  36
  37 #include "editor.h"
  38 #include "keyboard.h"
  39 #include "public_editor.h"
  40 #include "audio_region_view.h"
  41 #include "audio_streamview.h"
  42 #include "audio_time_axis.h"
  43 #include "region_gain_line.h"
  44 #include "automation_line.h"
  45 #include "automation_time_axis.h"
  46 #include "automation_line.h"
  47 #include "control_point.h"
  48 #include "editor_drag.h"
  49 #include "midi_time_axis.h"
  50 #include "editor_regions.h"
  51 #include "ui_config.h"
  52 #include "verbose_cursor.h"
  53
  54 #include "i18n.h"
  55
  56 using namespace std;
  57 using namespace ARDOUR;
  58 using namespace PBD;
  59 using namespace Gtk;
  60 using namespace ArdourCanvas;
  61
  62 using Gtkmm2ext::Keyboard;
  63
  64 bool
  65 Editor::track_canvas_scroll (GdkEventScroll* ev)
  66 {
  67         if (Keyboard::some_magic_widget_has_focus()) {
  68                 return false;
  69         }
  70
  71         framepos_t xdelta;
  72         int direction = ev->direction;
  73
  74         /* this event arrives without transformation by the canvas, so we have
  75          * to transform the coordinates to be able to look things up.
  76          */
  77
  78         Duple event_coords = _track_canvas->window_to_canvas (Duple (ev->x, ev->y));
  79
  80   retry:
  81         switch (direction) {
  82         case GDK_SCROLL_UP:
  83                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollZoomHorizontalModifier)) {
  84                         //for mouse-wheel zoom, force zoom-focus to mouse
  85                         Editing::ZoomFocus temp_focus = zoom_focus;
  86                         zoom_focus = Editing::ZoomFocusMouse;
  87                         temporal_zoom_step (false);
  88                         zoom_focus = temp_focus;
  89                         return true;
  90                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollHorizontalModifier)) {
  91                         direction = GDK_SCROLL_LEFT;
  92                         goto retry;
  93                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollZoomVerticalModifier)) {
  94                         if (!current_stepping_trackview) {
  95                                 step_timeout = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Editor::track_height_step_timeout), 500);
  96                                 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (event_coords.y, false);
  97                                 current_stepping_trackview = p.first;
  98                                 if (!current_stepping_trackview) {
  99                                         return false;
 100                                 }
 101                         }
 102                         last_track_height_step_timestamp = get_microseconds();
 103                         current_stepping_trackview->step_height (false);
 104                         return true;
 105                 } else {
 106                         scroll_up_one_track ();
 107                         return true;
 108                 }
 109                 break;
 110
 111         case GDK_SCROLL_DOWN:
 112                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollZoomHorizontalModifier)) {
 113                         //for mouse-wheel zoom, force zoom-focus to mouse
 114                         Editing::ZoomFocus temp_focus = zoom_focus;
 115                         zoom_focus = Editing::ZoomFocusMouse;
 116                         temporal_zoom_step (true);
 117                         zoom_focus = temp_focus;
 118                         return true;
 119                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollHorizontalModifier)) {
 120                         direction = GDK_SCROLL_RIGHT;
 121                         goto retry;
 122                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollZoomVerticalModifier)) {
 123                         if (!current_stepping_trackview) {
 124                                 step_timeout = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Editor::track_height_step_timeout), 500);
 125                                 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (event_coords.y, false);
 126                                 current_stepping_trackview = p.first;
 127                                 if (!current_stepping_trackview) {
 128                                         return false;
 129                                 }
 130                         }
 131                         last_track_height_step_timestamp = get_microseconds();
 132                         current_stepping_trackview->step_height (true);
 133                         return true;
 134                 } else {
 135                         scroll_down_one_track ();
 136                         return true;
 137                 }
 138                 break;
 139
 140         case GDK_SCROLL_LEFT:
 141                 xdelta = (current_page_samples() / 8);
 142                 if (leftmost_frame > xdelta) {
 143                         reset_x_origin (leftmost_frame - xdelta);
 144                 } else {
 145                         reset_x_origin (0);
 146                 }
 147                 break;
 148
 149         case GDK_SCROLL_RIGHT:
 150                 xdelta = (current_page_samples() / 8);
 151                 if (max_framepos - xdelta > leftmost_frame) {
 152                         reset_x_origin (leftmost_frame + xdelta);
 153                 } else {
 154                         reset_x_origin (max_framepos - current_page_samples());
 155                 }
 156                 break;
 157
 158         default:
 159                 /* what? */
 160                 break;
 161         }
 162
 163         return false;
 164 }
 165
 166 bool
 167 Editor::canvas_scroll_event (GdkEventScroll *event, bool from_canvas)
 168 {
 169         if (from_canvas) {
 170                 boost::optional<ArdourCanvas::Rect> rulers = _time_markers_group->bounding_box();
 171                 if (rulers && rulers->contains (Duple (event->x, event->y))) {
 172                         return canvas_ruler_event ((GdkEvent*) event, timecode_ruler, TimecodeRulerItem);
 173                 }
 174         }
 175
 176         _track_canvas->grab_focus();
 177         return track_canvas_scroll (event);
 178 }
 179
 180 bool
 181 Editor::track_canvas_button_press_event (GdkEventButton *event)
 182 {
 183         _track_canvas->grab_focus();
 184         if (!Keyboard::is_context_menu_event (event)) {
 185                 begin_reversible_selection_op (X_("Clear Selection Click (track canvas)"));
 186                 selection->clear ();
 187                 commit_reversible_selection_op();
 188         }
 189         return false;
 190 }
 191
 192 bool
 193 Editor::track_canvas_button_release_event (GdkEventButton *event)
 194 {
 195         if (!Keyboard::is_context_menu_event (event)) {
 196                 if (_drags->active ()) {
 197                         _drags->end_grab ((GdkEvent*) event);
 198                 }
 199         }
 200         return false;
 201 }
 202
 203 bool
 204 Editor::track_canvas_motion_notify_event (GdkEventMotion */*event*/)
 205 {
 206         int x, y;
 207         /* keep those motion events coming */
 208         _track_canvas->get_pointer (x, y);
 209         return false;
 210 }
 211
 212 bool
 213 Editor::typed_event (ArdourCanvas::Item* item, GdkEvent *event, ItemType type)
 214 {
 215         gint ret = FALSE;
 216
 217         switch (event->type) {
 218         case GDK_BUTTON_PRESS:
 219         case GDK_2BUTTON_PRESS:
 220         case GDK_3BUTTON_PRESS:
 221                 ret = button_press_handler (item, event, type);
 222                 break;
 223         case GDK_BUTTON_RELEASE:
 224                 ret = button_release_handler (item, event, type);
 225                 break;
 226         case GDK_MOTION_NOTIFY:
 227                 ret = motion_handler (item, event);
 228                 break;
 229
 230         case GDK_ENTER_NOTIFY:
 231                 ret = enter_handler (item, event, type);
 232                 break;
 233
 234         case GDK_LEAVE_NOTIFY:
 235                 ret = leave_handler (item, event, type);
 236                 break;
 237
 238         case GDK_KEY_PRESS:
 239                 ret = key_press_handler (item, event, type);
 240                 break;
 241
 242         case GDK_KEY_RELEASE:
 243                 ret = key_release_handler (item, event, type);
 244                 break;
 245
 246         default:
 247                 break;
 248         }
 249         return ret;
 250 }
 251
 252 bool
 253 Editor::canvas_region_view_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView *rv)
 254 {
 255         bool ret = false;
 256
 257         if (!rv->sensitive ()) {
 258                 return false;
 259         }
 260
 261         switch (event->type) {
 262         case GDK_BUTTON_PRESS:
 263         case GDK_2BUTTON_PRESS:
 264         case GDK_3BUTTON_PRESS:
 265                 clicked_regionview = rv;
 266                 clicked_control_point = 0;
 267                 clicked_axisview = &rv->get_time_axis_view();
 268                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 269                 ret = button_press_handler (item, event, RegionItem);
 270                 break;
 271
 272         case GDK_BUTTON_RELEASE:
 273                 ret = button_release_handler (item, event, RegionItem);
 274                 break;
 275
 276         case GDK_MOTION_NOTIFY:
 277                 ret = motion_handler (item, event);
 278                 break;
 279
 280         case GDK_ENTER_NOTIFY:
 281                 set_entered_regionview (rv);
 282                 ret = enter_handler (item, event, RegionItem);
 283                 break;
 284
 285         case GDK_LEAVE_NOTIFY:
 286                 if (event->crossing.detail != GDK_NOTIFY_INFERIOR) {
 287                         set_entered_regionview (0);
 288                         ret = leave_handler (item, event, RegionItem);
 289                 }
 290                 break;
 291
 292         default:
 293                 break;
 294         }
 295
 296         return ret;
 297 }
 298
 299 bool
 300 Editor::canvas_wave_view_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
 301 {
 302         /* we only care about enter events here, required for mouse/cursor
 303          * tracking. there is a non-linear (non-child/non-parent) relationship
 304          * between various components of a regionview and so when we leave one
 305          * of them (e.g. a trim handle) and enter another (e.g. the waveview)
 306          * no other items get notified. enter/leave handling does not propagate
 307          * in the same way as other events, so we need to catch this because
 308          * entering (and leaving) the waveview is equivalent to
 309          * entering/leaving the regionview (which is why it is passed in as a
 310          * third argument).
 311          *
 312          * And in fact, we really only care about enter events.
 313          */
 314
 315         bool ret = false;
 316
 317         if (!rv->sensitive ()) {
 318                 return false;
 319         }
 320
 321         switch (event->type) {
 322         case GDK_ENTER_NOTIFY:
 323                 set_entered_regionview (rv);
 324                 ret = enter_handler (item, event, WaveItem);
 325                 break;
 326
 327         default:
 328                 break;
 329         }
 330
 331         return ret;
 332 }
 333
 334
 335 bool
 336 Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, RouteTimeAxisView *tv)
 337 {
 338         bool ret = FALSE;
 339
 340         switch (event->type) {
 341         case GDK_BUTTON_PRESS:
 342         case GDK_2BUTTON_PRESS:
 343         case GDK_3BUTTON_PRESS:
 344                 clicked_regionview = 0;
 345                 clicked_control_point = 0;
 346                 clicked_axisview = tv;
 347                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 348                 ret = button_press_handler (item, event, StreamItem);
 349                 break;
 350
 351         case GDK_BUTTON_RELEASE:
 352                 ret = button_release_handler (item, event, StreamItem);
 353                 break;
 354
 355         case GDK_MOTION_NOTIFY:
 356                 ret = motion_handler (item, event);
 357                 break;
 358
 359         case GDK_ENTER_NOTIFY:
 360                 set_entered_track (tv);
 361                 ret = enter_handler (item, event, StreamItem);
 362                 break;
 363
 364         case GDK_LEAVE_NOTIFY:
 365                 if (event->crossing.detail != GDK_NOTIFY_INFERIOR) {
 366                         set_entered_track (0);
 367                 }
 368                 ret = leave_handler (item, event, StreamItem);
 369                 break;
 370
 371         default:
 372                 break;
 373         }
 374
 375         return ret;
 376 }
 377
 378 bool
 379 Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
 380 {
 381         bool ret = false;
 382
 383         switch (event->type) {
 384         case GDK_BUTTON_PRESS:
 385         case GDK_2BUTTON_PRESS:
 386         case GDK_3BUTTON_PRESS:
 387                 clicked_regionview = 0;
 388                 clicked_control_point = 0;
 389                 clicked_axisview = atv;
 390                 clicked_routeview = 0;
 391                 ret = button_press_handler (item, event, AutomationTrackItem);
 392                 break;
 393
 394         case GDK_BUTTON_RELEASE:
 395                 ret = button_release_handler (item, event, AutomationTrackItem);
 396                 break;
 397
 398         case GDK_MOTION_NOTIFY:
 399                 ret = motion_handler (item, event);
 400                 break;
 401
 402         case GDK_ENTER_NOTIFY:
 403                 ret = enter_handler (item, event, AutomationTrackItem);
 404                 break;
 405
 406         case GDK_LEAVE_NOTIFY:
 407                 ret = leave_handler (item, event, AutomationTrackItem);
 408                 break;
 409
 410         default:
 411                 break;
 412         }
 413
 414         return ret;
 415 }
 416
 417 bool
 418 Editor::canvas_start_xfade_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 419 {
 420         if (!rv->sensitive()) {
 421                 return false;
 422         }
 423
 424         switch (event->type) {
 425         case GDK_BUTTON_PRESS:
 426                 clicked_regionview = rv;
 427                 clicked_control_point = 0;
 428                 clicked_axisview = &rv->get_time_axis_view();
 429                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 430                 if (event->button.button == 3) {
 431                         return button_press_handler (item, event, StartCrossFadeItem);
 432                 }
 433                 break;
 434
 435         case GDK_BUTTON_RELEASE:
 436                 if (event->button.button == 3) {
 437                         return button_release_handler (item, event, StartCrossFadeItem);
 438                 }
 439                 break;
 440
 441         default:
 442                 break;
 443
 444         }
 445
 446         /* In Mixbus, the crossfade area is used to trim the region while leaving the fade anchor intact (see preserve_fade_anchor)*/
 447         /* however in A3 this feature is unfinished, and it might be better to do it with a modifier-trim instead, anyway */
 448         /* if we return RegionItem here then we avoid the issue until it is resolved later */
 449         return typed_event (item, event, RegionItem); // StartCrossFadeItem);
 450 }
 451
 452 bool
 453 Editor::canvas_end_xfade_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 454 {
 455         if (!rv->sensitive()) {
 456                 return false;
 457         }
 458
 459         switch (event->type) {
 460         case GDK_BUTTON_PRESS:
 461                 clicked_regionview = rv;
 462                 clicked_control_point = 0;
 463                 clicked_axisview = &rv->get_time_axis_view();
 464                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 465                 if (event->button.button == 3) {
 466                         return button_press_handler (item, event, EndCrossFadeItem);
 467                 }
 468                 break;
 469
 470         case GDK_BUTTON_RELEASE:
 471                 if (event->button.button == 3) {
 472                         return button_release_handler (item, event, EndCrossFadeItem);
 473                 }
 474                 break;
 475
 476         default:
 477                 break;
 478
 479         }
 480
 481         /* In Mixbus, the crossfade area is used to trim the region while leaving the fade anchor intact (see preserve_fade_anchor)*/
 482         /* however in A3 this feature is unfinished, and it might be better to do it with a modifier-trim instead, anyway */
 483         /* if we return RegionItem here then we avoid the issue until it is resolved later */
 484         return typed_event (item, event, RegionItem); // EndCrossFadeItem);
 485 }
 486
 487 bool
 488 Editor::canvas_fade_in_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 489 {
 490         /* we handle only button 3 press/release events */
 491
 492         if (!rv->sensitive()) {
 493                 return false;
 494         }
 495
 496         switch (event->type) {
 497         case GDK_BUTTON_PRESS:
 498                 clicked_regionview = rv;
 499                 clicked_control_point = 0;
 500                 clicked_axisview = &rv->get_time_axis_view();
 501                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 502                 if (event->button.button == 3) {
 503                         return button_press_handler (item, event, FadeInItem);
 504                 }
 505                 break;
 506
 507         case GDK_BUTTON_RELEASE:
 508                 if (event->button.button == 3) {
 509                         return button_release_handler (item, event, FadeInItem);
 510                 }
 511                 break;
 512
 513         default:
 514                 break;
 515
 516         }
 517
 518         /* proxy for the regionview, except enter/leave events */
 519
 520         if (event->type == GDK_ENTER_NOTIFY || event->type == GDK_LEAVE_NOTIFY) {
 521                 return true;
 522         } else {
 523                 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 524         }
 525 }
 526
 527 bool
 528 Editor::canvas_fade_in_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv, bool trim)
 529 {
 530         bool ret = false;
 531
 532         if (!rv->sensitive()) {
 533                 return false;
 534         }
 535
 536         switch (event->type) {
 537         case GDK_BUTTON_PRESS:
 538         case GDK_2BUTTON_PRESS:
 539         case GDK_3BUTTON_PRESS:
 540                 clicked_regionview = rv;
 541                 clicked_control_point = 0;
 542                 clicked_axisview = &rv->get_time_axis_view();
 543                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 544                 ret = button_press_handler (item, event, trim ? FadeInTrimHandleItem : FadeInHandleItem);
 545                 break;
 546
 547         case GDK_BUTTON_RELEASE:
 548                 ret = button_release_handler (item, event, trim ? FadeInTrimHandleItem : FadeInHandleItem);
 549                 maybe_locate_with_edit_preroll ( rv->region()->position() );
 550                 break;
 551
 552         case GDK_MOTION_NOTIFY:
 553                 ret = motion_handler (item, event);
 554                 break;
 555
 556         case GDK_ENTER_NOTIFY:
 557                 ret = enter_handler (item, event, trim ? FadeInTrimHandleItem : FadeInHandleItem);
 558                 break;
 559
 560         case GDK_LEAVE_NOTIFY:
 561                 ret = leave_handler (item, event, trim ? FadeInTrimHandleItem : FadeInHandleItem);
 562                 break;
 563
 564         default:
 565                 break;
 566         }
 567
 568         return ret;
 569 }
 570
 571 bool
 572 Editor::canvas_fade_out_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 573 {
 574         /* we handle only button 3 press/release events */
 575
 576         if (!rv->sensitive()) {
 577                 return false;
 578         }
 579
 580         switch (event->type) {
 581         case GDK_BUTTON_PRESS:
 582                 clicked_regionview = rv;
 583                 clicked_control_point = 0;
 584                 clicked_axisview = &rv->get_time_axis_view();
 585                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 586                 if (event->button.button == 3) {
 587                         return button_press_handler (item, event, FadeOutItem);
 588                 }
 589                 break;
 590
 591         case GDK_BUTTON_RELEASE:
 592                 if (event->button.button == 3) {
 593                         return button_release_handler (item, event, FadeOutItem);
 594                 }
 595                 break;
 596
 597         default:
 598                 break;
 599
 600         }
 601
 602         /* proxy for the regionview, except enter/leave events */
 603
 604         if (event->type == GDK_ENTER_NOTIFY || event->type == GDK_LEAVE_NOTIFY) {
 605                 return true;
 606         } else {
 607                 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 608         }
 609 }
 610
 611 bool
 612 Editor::canvas_fade_out_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv, bool trim)
 613 {
 614         bool ret = false;
 615
 616         if (!rv->sensitive()) {
 617                 return false;
 618         }
 619
 620         switch (event->type) {
 621         case GDK_BUTTON_PRESS:
 622         case GDK_2BUTTON_PRESS:
 623         case GDK_3BUTTON_PRESS:
 624                 clicked_regionview = rv;
 625                 clicked_control_point = 0;
 626                 clicked_axisview = &rv->get_time_axis_view();
 627                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 628                 ret = button_press_handler (item, event, trim ? FadeOutTrimHandleItem : FadeOutHandleItem);
 629                 break;
 630
 631         case GDK_BUTTON_RELEASE:
 632                 ret = button_release_handler (item, event, trim ? FadeOutTrimHandleItem : FadeOutHandleItem);
 633                 maybe_locate_with_edit_preroll ( rv->region()->last_frame() - rv->get_fade_out_shape_width() );
 634                 break;
 635
 636         case GDK_MOTION_NOTIFY:
 637                 ret = motion_handler (item, event);
 638                 break;
 639
 640         case GDK_ENTER_NOTIFY:
 641                 ret = enter_handler (item, event, trim ? FadeOutTrimHandleItem : FadeOutHandleItem);
 642                 break;
 643
 644         case GDK_LEAVE_NOTIFY:
 645                 ret = leave_handler (item, event, trim ? FadeOutTrimHandleItem : FadeOutHandleItem);
 646                 break;
 647
 648         default:
 649                 break;
 650         }
 651
 652         return ret;
 653 }
 654
 655 struct DescendingRegionLayerSorter {
 656     bool operator()(boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
 657             return a->layer() > b->layer();
 658     }
 659 };
 660
 661 bool
 662 Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
 663 {
 664         switch (event->type) {
 665         case GDK_BUTTON_PRESS:
 666         case GDK_2BUTTON_PRESS:
 667         case GDK_3BUTTON_PRESS:
 668                 clicked_control_point = cp;
 669                 clicked_axisview = &cp->line().trackview;
 670                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 671                 clicked_regionview = 0;
 672                 break;
 673
 674         case GDK_SCROLL_UP:
 675                 break;
 676
 677         case GDK_SCROLL_DOWN:
 678                 break;
 679
 680         default:
 681                 break;
 682         }
 683
 684         return typed_event (item, event, ControlPointItem);
 685 }
 686
 687 bool
 688 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
 689 {
 690         ItemType type;
 691         AudioRegionGainLine* gl;
 692         if ((gl = dynamic_cast<AudioRegionGainLine*> (al)) != 0) {
 693                 type = GainLineItem;
 694                 clicked_regionview = &gl->region_view ();
 695         } else {
 696                 type = AutomationLineItem;
 697                 clicked_regionview = 0;
 698         }
 699
 700         clicked_control_point = 0;
 701         clicked_axisview = &al->trackview;
 702         clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 703
 704         return typed_event (item, event, type);
 705 }
 706
 707 bool
 708 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 709 {
 710         bool ret = false;
 711
 712         switch (event->type) {
 713         case GDK_BUTTON_PRESS:
 714         case GDK_2BUTTON_PRESS:
 715         case GDK_3BUTTON_PRESS:
 716                 clicked_selection = rect->id;
 717                 ret = button_press_handler (item, event, SelectionItem);
 718                 break;
 719         case GDK_BUTTON_RELEASE:
 720                 ret = button_release_handler (item, event, SelectionItem);
 721                 break;
 722         case GDK_MOTION_NOTIFY:
 723                 ret = motion_handler (item, event);
 724                 break;
 725                 /* Don't need these at the moment. */
 726         case GDK_ENTER_NOTIFY:
 727                 ret = enter_handler (item, event, SelectionItem);
 728                 break;
 729
 730         case GDK_LEAVE_NOTIFY:
 731                 ret = leave_handler (item, event, SelectionItem);
 732                 break;
 733
 734         default:
 735                 break;
 736         }
 737
 738         return ret;
 739 }
 740
 741 bool
 742 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 743 {
 744         bool ret = false;
 745
 746         switch (event->type) {
 747         case GDK_BUTTON_PRESS:
 748         case GDK_2BUTTON_PRESS:
 749         case GDK_3BUTTON_PRESS:
 750                 clicked_selection = rect->id;
 751                 ret = button_press_handler (item, event, StartSelectionTrimItem);
 752                 break;
 753         case GDK_BUTTON_RELEASE:
 754                 ret = button_release_handler (item, event, StartSelectionTrimItem);
 755                 break;
 756         case GDK_MOTION_NOTIFY:
 757                 ret = motion_handler (item, event);
 758                 break;
 759         case GDK_ENTER_NOTIFY:
 760                 ret = enter_handler (item, event, StartSelectionTrimItem);
 761                 break;
 762
 763         case GDK_LEAVE_NOTIFY:
 764                 ret = leave_handler (item, event, StartSelectionTrimItem);
 765                 break;
 766
 767         default:
 768                 break;
 769         }
 770
 771         return ret;
 772 }
 773
 774 bool
 775 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 776 {
 777         bool ret = false;
 778
 779         switch (event->type) {
 780         case GDK_BUTTON_PRESS:
 781         case GDK_2BUTTON_PRESS:
 782         case GDK_3BUTTON_PRESS:
 783                 clicked_selection = rect->id;
 784                 ret = button_press_handler (item, event, EndSelectionTrimItem);
 785                 break;
 786         case GDK_BUTTON_RELEASE:
 787                 ret = button_release_handler (item, event, EndSelectionTrimItem);
 788                 break;
 789         case GDK_MOTION_NOTIFY:
 790                 ret = motion_handler (item, event);
 791                 break;
 792         case GDK_ENTER_NOTIFY:
 793                 ret = enter_handler (item, event, EndSelectionTrimItem);
 794                 break;
 795
 796         case GDK_LEAVE_NOTIFY:
 797                 ret = leave_handler (item, event, EndSelectionTrimItem);
 798                 break;
 799
 800         default:
 801                 break;
 802         }
 803
 804         return ret;
 805 }
 806
 807 bool
 808 Editor::canvas_frame_handle_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
 809 {
 810         bool ret = false;
 811
 812         /* frame handles are not active when in internal edit mode, because actual notes
 813            might be in the area occupied by the handle - we want them to be editable as normal.
 814         */
 815
 816         if (internal_editing() || !rv->sensitive()) {
 817                 return false;
 818         }
 819
 820         /* NOTE: frame handles pretend to be the colored trim bar from an event handling
 821            perspective. XXX change this ??
 822         */
 823
 824         ItemType type;
 825
 826         if (item->get_data ("isleft")) {
 827                 type = LeftFrameHandle;
 828         } else {
 829                 type = RightFrameHandle;
 830         }
 831
 832         switch (event->type) {
 833         case GDK_BUTTON_PRESS:
 834         case GDK_2BUTTON_PRESS:
 835         case GDK_3BUTTON_PRESS:
 836                 clicked_regionview = rv;
 837                 clicked_control_point = 0;
 838                 clicked_axisview = &clicked_regionview->get_time_axis_view();
 839                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 840                 ret = button_press_handler (item, event, type);
 841                 break;
 842         case GDK_BUTTON_RELEASE:
 843                 ret = button_release_handler (item, event, type);
 844                 break;
 845         case GDK_MOTION_NOTIFY:
 846                 ret = motion_handler (item, event);
 847                 break;
 848         case GDK_ENTER_NOTIFY:
 849                 ret = enter_handler (item, event, type);
 850                 break;
 851
 852         case GDK_LEAVE_NOTIFY:
 853                 ret = leave_handler (item, event, type);
 854                 break;
 855
 856         default:
 857                 break;
 858         }
 859
 860         return ret;
 861 }
 862
 863
 864 bool
 865 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
 866 {
 867         bool ret = false;
 868
 869         if (!rv->sensitive()) {
 870                 return false;
 871         }
 872
 873         switch (event->type) {
 874         case GDK_BUTTON_PRESS:
 875         case GDK_2BUTTON_PRESS:
 876         case GDK_3BUTTON_PRESS:
 877                 clicked_regionview = rv;
 878                 clicked_control_point = 0;
 879                 clicked_axisview = &clicked_regionview->get_time_axis_view();
 880                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 881                 ret = button_press_handler (item, event, RegionViewNameHighlight);
 882                 break;
 883         case GDK_BUTTON_RELEASE:
 884                 ret = button_release_handler (item, event, RegionViewNameHighlight);
 885                 break;
 886         case GDK_MOTION_NOTIFY:
 887                 motion_handler (item, event);
 888                 ret = true; // force this to avoid progagating the event into the regionview
 889                 break;
 890         case GDK_ENTER_NOTIFY:
 891                 ret = enter_handler (item, event, RegionViewNameHighlight);
 892                 break;
 893
 894         case GDK_LEAVE_NOTIFY:
 895                 ret = leave_handler (item, event, RegionViewNameHighlight);
 896                 break;
 897
 898         default:
 899                 break;
 900         }
 901
 902         return ret;
 903 }
 904
 905 bool
 906 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
 907 {
 908         bool ret = false;
 909
 910         if (!rv->sensitive()) {
 911                 return false;
 912         }
 913
 914         switch (event->type) {
 915         case GDK_BUTTON_PRESS:
 916         case GDK_2BUTTON_PRESS:
 917         case GDK_3BUTTON_PRESS:
 918                 clicked_regionview = rv;
 919                 clicked_control_point = 0;
 920                 clicked_axisview = &clicked_regionview->get_time_axis_view();
 921                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 922                 ret = button_press_handler (item, event, RegionViewName);
 923                 break;
 924         case GDK_BUTTON_RELEASE:
 925                 ret = button_release_handler (item, event, RegionViewName);
 926                 break;
 927         case GDK_MOTION_NOTIFY:
 928                 ret = motion_handler (item, event);
 929                 break;
 930         case GDK_ENTER_NOTIFY:
 931                 ret = enter_handler (item, event, RegionViewName);
 932                 break;
 933
 934         case GDK_LEAVE_NOTIFY:
 935                 ret = leave_handler (item, event, RegionViewName);
 936                 break;
 937
 938         default:
 939                 break;
 940         }
 941
 942         return ret;
 943 }
 944
 945 bool
 946 Editor::canvas_feature_line_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView*)
 947 {
 948         bool ret = false;
 949
 950         switch (event->type) {
 951         case GDK_BUTTON_PRESS:
 952         case GDK_2BUTTON_PRESS:
 953         case GDK_3BUTTON_PRESS:
 954                 clicked_regionview = 0;
 955                 clicked_control_point = 0;
 956                 clicked_axisview = 0;
 957                 clicked_routeview = 0; //dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 958                 ret = button_press_handler (item, event, FeatureLineItem);
 959                 break;
 960
 961         case GDK_BUTTON_RELEASE:
 962                 ret = button_release_handler (item, event, FeatureLineItem);
 963                 break;
 964
 965         case GDK_MOTION_NOTIFY:
 966                 ret = motion_handler (item, event);
 967                 break;
 968
 969         case GDK_ENTER_NOTIFY:
 970                 ret = enter_handler (item, event, FeatureLineItem);
 971                 break;
 972
 973         case GDK_LEAVE_NOTIFY:
 974                 ret = leave_handler (item, event, FeatureLineItem);
 975                 break;
 976
 977         default:
 978                 break;
 979         }
 980
 981         return ret;
 982 }
 983
 984 bool
 985 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, ArdourMarker* /*marker*/)
 986 {
 987         return typed_event (item, event, MarkerItem);
 988 }
 989
 990 bool
 991 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 992 {
 993         return typed_event (item, event, MarkerBarItem);
 994 }
 995
 996 bool
 997 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 998 {
 999         return typed_event (item, event, RangeMarkerBarItem);
1000 }
1001
1002 bool
1003 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
1004 {
1005         return typed_event (item, event, TransportMarkerBarItem);
1006 }
1007
1008 bool
1009 Editor::canvas_cd_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
1010 {
1011         return typed_event (item, event, CdMarkerBarItem);
1012 }
1013
1014 bool
1015 Editor::canvas_videotl_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
1016 {
1017         return typed_event (item, event, VideoBarItem);
1018 }
1019
1020 bool
1021 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* /*marker*/)
1022 {
1023         return typed_event (item, event, TempoMarkerItem);
1024 }
1025
1026 bool
1027 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* /*marker*/)
1028 {
1029         return typed_event (item, event, MeterMarkerItem);
1030 }
1031
1032 bool
1033 Editor::canvas_ruler_event (GdkEvent *event, ArdourCanvas::Item* item, ItemType type)
1034 {
1035         framepos_t xdelta;
1036         bool handled = false;
1037
1038         if (event->type == GDK_SCROLL) {
1039
1040                 /* scroll events in the rulers are handled a little differently from
1041                    scrolling elsewhere in the canvas.
1042                 */
1043
1044                 switch (event->scroll.direction) {
1045                 case GDK_SCROLL_UP:
1046
1047                         if (Profile->get_mixbus()) {
1048                                 //for mouse-wheel zoom, force zoom-focus to mouse
1049                                 Editing::ZoomFocus temp_focus = zoom_focus;
1050                                 zoom_focus = Editing::ZoomFocusMouse;
1051                                 temporal_zoom_step (false);
1052                                 zoom_focus = temp_focus;
1053                         } else {
1054                                 temporal_zoom_step (false);
1055                         }
1056                         handled = true;
1057                         break;
1058
1059                 case GDK_SCROLL_DOWN:
1060                         if (Profile->get_mixbus()) {
1061                                 //for mouse-wheel zoom, force zoom-focus to mouse
1062                                 Editing::ZoomFocus temp_focus = zoom_focus;
1063                                 zoom_focus = Editing::ZoomFocusMouse;
1064                                 temporal_zoom_step (true);
1065                                 zoom_focus = temp_focus;
1066                         } else {
1067                                 temporal_zoom_step (true);
1068                         }
1069                         handled = true;
1070                         break;
1071
1072                 case GDK_SCROLL_LEFT:
1073                         xdelta = (current_page_samples() / 2);
1074                         if (leftmost_frame > xdelta) {
1075                                 reset_x_origin (leftmost_frame - xdelta);
1076                         } else {
1077                                 reset_x_origin (0);
1078                         }
1079                         handled = true;
1080                         break;
1081
1082                 case GDK_SCROLL_RIGHT:
1083                         xdelta = (current_page_samples() / 2);
1084                         if (max_framepos - xdelta > leftmost_frame) {
1085                                 reset_x_origin (leftmost_frame + xdelta);
1086                         } else {
1087                                 reset_x_origin (max_framepos - current_page_samples());
1088                         }
1089                         handled = true;
1090                         break;
1091
1092                 default:
1093                         /* what? */
1094                         break;
1095                 }
1096                 return handled;
1097         }
1098
1099         return typed_event (item, event, type);
1100 }
1101
1102 bool
1103 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
1104 {
1105         return typed_event (item, event, TempoBarItem);
1106 }
1107
1108 bool
1109 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
1110 {
1111         return typed_event (item, event, MeterBarItem);
1112 }
1113
1114 bool
1115 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
1116 {
1117         return typed_event (item, event, PlayheadCursorItem);
1118 }
1119
1120 bool
1121 Editor::canvas_note_event (GdkEvent *event, ArdourCanvas::Item* item)
1122 {
1123         if (!internal_editing()) {
1124                 return false;
1125         }
1126
1127         return typed_event (item, event, NoteItem);
1128 }
1129
1130 bool
1131 Editor::canvas_drop_zone_event (GdkEvent* event)
1132 {
1133         GdkEventScroll scroll;
1134         ArdourCanvas::Duple winpos;
1135
1136         switch (event->type) {
1137         case GDK_BUTTON_RELEASE:
1138                 if (event->button.button == 1) {
1139                         begin_reversible_selection_op (X_("Nowhere Click"));
1140                         selection->clear_objects ();
1141                         selection->clear_tracks ();
1142                         commit_reversible_selection_op ();
1143                 }
1144                 break;
1145
1146         case GDK_SCROLL:
1147                 /* convert coordinates back into window space so that
1148                    we can just call canvas_scroll_event().
1149                 */
1150                 winpos = _track_canvas->canvas_to_window (Duple (event->scroll.x, event->scroll.y));
1151                 scroll = event->scroll;
1152                 scroll.x = winpos.x;
1153                 scroll.y = winpos.y;
1154                 return canvas_scroll_event (&scroll, true);
1155                 break;
1156
1157         case GDK_ENTER_NOTIFY:
1158                 return typed_event (_canvas_drop_zone, event, DropZoneItem);
1159
1160         case GDK_LEAVE_NOTIFY:
1161                 return typed_event (_canvas_drop_zone, event, DropZoneItem);
1162
1163         default:
1164                 break;
1165         }
1166
1167         return true;
1168 }
1169
1170 bool
1171 Editor::track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const& context, int x, int y, guint time)
1172 {
1173         boost::shared_ptr<Region> region;
1174         boost::shared_ptr<Region> region_copy;
1175         RouteTimeAxisView* rtav;
1176         GdkEvent event;
1177         double px;
1178         double py;
1179
1180         string target = _track_canvas->drag_dest_find_target (context, _track_canvas->drag_dest_get_target_list());
1181
1182         if (target.empty()) {
1183                 return false;
1184         }
1185
1186         event.type = GDK_MOTION_NOTIFY;
1187         event.button.x = x;
1188         event.button.y = y;
1189         /* assume we're dragging with button 1 */
1190         event.motion.state = Gdk::BUTTON1_MASK;
1191
1192         (void) window_event_sample (&event, &px, &py);
1193
1194         std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py, false);
1195         bool can_drop = false;
1196
1197         if (tv.first != 0) {
1198
1199                 /* over a time axis view of some kind */
1200
1201                 rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
1202
1203                 if (rtav != 0 && rtav->is_track ()) {
1204                         /* over a track, not a bus */
1205                         can_drop = true;
1206                 }
1207
1208
1209         } else {
1210                 /* not over a time axis view, so drop is possible */
1211                 can_drop = true;
1212         }
1213
1214         if (can_drop) {
1215                 region = _regions->get_dragged_region ();
1216
1217                 if (region) {
1218
1219                         if (tv.first == 0
1220                             && (
1221                                 boost::dynamic_pointer_cast<AudioRegion> (region) != 0 ||
1222                                 boost::dynamic_pointer_cast<MidiRegion> (region) != 0
1223                                )
1224                            )
1225                         {
1226                                 /* drop to drop-zone */
1227                                 context->drag_status (context->get_suggested_action(), time);
1228                                 return true;
1229                         }
1230
1231                         if ((boost::dynamic_pointer_cast<AudioRegion> (region) != 0 &&
1232                              dynamic_cast<AudioTimeAxisView*> (tv.first) != 0) ||
1233                             (boost::dynamic_pointer_cast<MidiRegion> (region) != 0 &&
1234                              dynamic_cast<MidiTimeAxisView*> (tv.first) != 0)) {
1235
1236                                 /* audio to audio
1237                                    OR
1238                                    midi to midi
1239                                 */
1240
1241                                 context->drag_status (context->get_suggested_action(), time);
1242                                 return true;
1243                         }
1244                 } else {
1245                         /* DND originating from outside ardour
1246                          *
1247                          * TODO: check if file is audio/midi, allow drops on same track-type only,
1248                          * currently: if audio is dropped on a midi-track, it is only added to the region-list
1249                          */
1250                         if (Profile->get_sae() || UIConfiguration::instance().get_only_copy_imported_files()) {
1251                                 context->drag_status(Gdk::ACTION_COPY, time);
1252                         } else {
1253                                 if ((context->get_actions() & (Gdk::ACTION_COPY | Gdk::ACTION_LINK | Gdk::ACTION_MOVE)) == Gdk::ACTION_COPY) {
1254                                         context->drag_status(Gdk::ACTION_COPY, time);
1255                                 } else {
1256                                         context->drag_status(Gdk::ACTION_LINK, time);
1257                                 }
1258                         }
1259                         return true;
1260                 }
1261         }
1262
1263         /* no drop here */
1264         context->drag_status (Gdk::DragAction (0), time);
1265         return false;
1266 }
1267
1268 void
1269 Editor::drop_regions (const Glib::RefPtr<Gdk::DragContext>& /*context*/,
1270                       int x, int y,
1271                       const SelectionData& /*data*/,
1272                       guint /*info*/, guint /*time*/)
1273 {
1274         GdkEvent event;
1275         double px;
1276         double py;
1277
1278         event.type = GDK_MOTION_NOTIFY;
1279         event.button.x = x;
1280         event.button.y = y;
1281         /* assume we're dragging with button 1 */
1282         event.motion.state = Gdk::BUTTON1_MASK;
1283         framepos_t const pos = window_event_sample (&event, &px, &py);
1284
1285         boost::shared_ptr<Region> region = _regions->get_dragged_region ();
1286         if (!region) { return; }
1287
1288         RouteTimeAxisView* rtav = 0;
1289         std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py, false);
1290
1291         if (tv.first != 0) {
1292                 rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
1293         } else {
1294                 try {
1295                         if (boost::dynamic_pointer_cast<AudioRegion> (region)) {
1296                                 uint32_t output_chan = region->n_channels();
1297                                 if ((Config->get_output_auto_connect() & AutoConnectMaster) && session()->master_out()) {
1298                                         output_chan =  session()->master_out()->n_inputs().n_audio();
1299                                 }
1300                                 list<boost::shared_ptr<AudioTrack> > audio_tracks;
1301                                 audio_tracks = session()->new_audio_track (region->n_channels(), output_chan, ARDOUR::Normal, 0, 1, region->name());
1302                                 rtav = axis_view_from_route (audio_tracks.front());
1303                         } else if (boost::dynamic_pointer_cast<MidiRegion> (region)) {
1304                                 ChanCount one_midi_port (DataType::MIDI, 1);
1305                                 list<boost::shared_ptr<MidiTrack> > midi_tracks;
1306                                 midi_tracks = session()->new_midi_track (one_midi_port, one_midi_port, boost::shared_ptr<ARDOUR::PluginInfo>(), ARDOUR::Normal, 0, 1, region->name());
1307                                 rtav = axis_view_from_route (midi_tracks.front());
1308                         } else {
1309                                 return;
1310                         }
1311                 } catch (...) {
1312                         error << _("Could not create new track after region placed in the drop zone") << endmsg;
1313                         return;
1314                 }
1315         }
1316
1317         if (rtav != 0 && rtav->is_track ()) {
1318                 boost::shared_ptr<Region> region_copy = RegionFactory::create (region, true);
1319
1320                 if ((boost::dynamic_pointer_cast<AudioRegion> (region_copy) != 0 && dynamic_cast<AudioTimeAxisView*> (rtav) != 0) ||
1321                     (boost::dynamic_pointer_cast<MidiRegion> (region_copy) != 0 && dynamic_cast<MidiTimeAxisView*> (rtav) != 0)) {
1322                         _drags->set (new RegionInsertDrag (this, region_copy, rtav, pos), &event);
1323                         _drags->end_grab (0);
1324                 }
1325         }
1326 }
1327
1328 bool
1329 Editor::key_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType)
1330 {
1331         return false;
1332 }
1333
1334 bool
1335 Editor::key_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType type)
1336 {
1337
1338         bool handled = false;
1339
1340         switch (type) {
1341         case TempoMarkerItem:
1342                 switch (event->key.keyval) {
1343                 case GDK_Delete:
1344                         remove_tempo_marker (item);
1345                         handled = true;
1346                         break;
1347                 default:
1348                         break;
1349                 }
1350                 break;
1351
1352         case MeterMarkerItem:
1353                 switch (event->key.keyval) {
1354                 case GDK_Delete:
1355                         remove_meter_marker (item);
1356                         handled = true;
1357                         break;
1358                 default:
1359                         break;
1360                 }
1361                 break;
1362
1363         default:
1364                 break;
1365         }
1366
1367         return handled;
1368 }
1369