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_diskstream.h"
  28 #include "ardour/audioplaylist.h"
  29 #include "ardour/audioregion.h"
  30 #include "ardour/region_factory.h"
  31 #include "ardour/midi_region.h"
  32
  33 #include "editor.h"
  34 #include "keyboard.h"
  35 #include "public_editor.h"
  36 #include "audio_region_view.h"
  37 #include "audio_streamview.h"
  38 #include "crossfade_view.h"
  39 #include "audio_time_axis.h"
  40 #include "region_gain_line.h"
  41 #include "automation_line.h"
  42 #include "automation_time_axis.h"
  43 #include "automation_line.h"
  44 #include "control_point.h"
  45 #include "canvas_impl.h"
  46 #include "simplerect.h"
  47 #include "interactive-item.h"
  48 #include "editor_drag.h"
  49 #include "midi_time_axis.h"
  50 #include "editor_regions.h"
  51
  52 #include "i18n.h"
  53
  54 using namespace sigc;
  55 using namespace std;
  56 using namespace ARDOUR;
  57 using namespace PBD;
  58 using namespace Gtk;
  59 using namespace ArdourCanvas;
  60
  61 bool
  62 Editor::track_canvas_scroll (GdkEventScroll* ev)
  63 {
  64         int x, y;
  65         double wx, wy;
  66         nframes64_t xdelta;
  67         int direction = ev->direction;
  68
  69         Gnome::Canvas::Item* item = track_canvas->get_item_at(ev->x, ev->y);
  70         InteractiveItem* interactive_item = dynamic_cast<InteractiveItem*>(item);
  71         if (interactive_item) {
  72                 return interactive_item->on_event(reinterpret_cast<GdkEvent*>(ev));
  73         }
  74
  75   retry:
  76         switch (direction) {
  77         case GDK_SCROLL_UP:
  78                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
  79                         //if (ev->state == GDK_CONTROL_MASK) {
  80                         /* XXX
  81                            the ev->x will be out of step with the canvas
  82                            if we're in mid zoom, so we have to get the damn mouse
  83                            pointer again
  84                         */
  85                         track_canvas->get_pointer (x, y);
  86                         track_canvas->window_to_world (x, y, wx, wy);
  87
  88                         GdkEvent event;
  89                         event.type = GDK_BUTTON_RELEASE;
  90                         event.button.x = wx;
  91                         event.button.y = wy;
  92
  93                         nframes64_t where = event_frame (&event, 0, 0);
  94                         temporal_zoom_to_frame (false, where);
  95                         return true;
  96                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
  97                         direction = GDK_SCROLL_LEFT;
  98                         goto retry;
  99                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 100                         if (!current_stepping_trackview) {
 101                                 step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
 102                                 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
 103                                 current_stepping_trackview = p.first;
 104                                 if (!current_stepping_trackview) {
 105                                         return false;
 106                                 }
 107                         }
 108                         last_track_height_step_timestamp = get_microseconds();
 109                         current_stepping_trackview->step_height (true);
 110                         return true;
 111                 } else {
 112                         scroll_tracks_up_line ();
 113                         return true;
 114                 }
 115                 break;
 116
 117         case GDK_SCROLL_DOWN:
 118                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 119                         //if (ev->state == GDK_CONTROL_MASK) {
 120                         track_canvas->get_pointer (x, y);
 121                         track_canvas->window_to_world (x, y, wx, wy);
 122
 123                         GdkEvent event;
 124                         event.type = GDK_BUTTON_RELEASE;
 125                         event.button.x = wx;
 126                         event.button.y = wy;
 127
 128                         nframes64_t where = event_frame (&event, 0, 0);
 129                         temporal_zoom_to_frame (true, where);
 130                         return true;
 131                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
 132                         direction = GDK_SCROLL_RIGHT;
 133                         goto retry;
 134                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 135                         if (!current_stepping_trackview) {
 136                                 step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
 137                                 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
 138                                 current_stepping_trackview = p.first;
 139                                 if (!current_stepping_trackview) {
 140                                         return false;
 141                                 }
 142                         }
 143                         last_track_height_step_timestamp = get_microseconds();
 144                         current_stepping_trackview->step_height (false);
 145                         return true;
 146                 } else {
 147                         scroll_tracks_down_line ();
 148                         return true;
 149                 }
 150                 break;
 151
 152         case GDK_SCROLL_LEFT:
 153                 xdelta = (current_page_frames() / 8);
 154                 if (leftmost_frame > xdelta) {
 155                         reset_x_origin (leftmost_frame - xdelta);
 156                 } else {
 157                         reset_x_origin (0);
 158                 }
 159                 break;
 160
 161         case GDK_SCROLL_RIGHT:
 162                 xdelta = (current_page_frames() / 8);
 163                 if (max_frames - xdelta > leftmost_frame) {
 164                         reset_x_origin (leftmost_frame + xdelta);
 165                 } else {
 166                         reset_x_origin (max_frames - current_page_frames());
 167                 }
 168                 break;
 169
 170         default:
 171                 /* what? */
 172                 break;
 173         }
 174
 175         return false;
 176 }
 177
 178 bool
 179 Editor::track_canvas_scroll_event (GdkEventScroll *event)
 180 {
 181         track_canvas->grab_focus();
 182         track_canvas_scroll (event);
 183         return false;
 184 }
 185
 186 bool
 187 Editor::track_canvas_button_press_event (GdkEventButton */*event*/)
 188 {
 189         selection->clear ();
 190         track_canvas->grab_focus();
 191         return false;
 192 }
 193
 194 bool
 195 Editor::track_canvas_button_release_event (GdkEventButton *event)
 196 {
 197         if (_drag) {
 198                 _drag->end_grab ((GdkEvent*) event);
 199                 delete _drag;
 200                 _drag = 0;
 201         }
 202         return false;
 203 }
 204
 205 bool
 206 Editor::track_canvas_motion_notify_event (GdkEventMotion */*event*/)
 207 {
 208         int x, y;
 209         /* keep those motion events coming */
 210         track_canvas->get_pointer (x, y);
 211         return false;
 212 }
 213
 214 bool
 215 Editor::track_canvas_motion (GdkEvent *ev)
 216 {
 217         if (verbose_cursor_visible) {
 218                 verbose_canvas_cursor->property_x() = clamp_verbose_cursor_x (ev->motion.x + 10);
 219                 verbose_canvas_cursor->property_y() = clamp_verbose_cursor_y (ev->motion.y + 10);
 220         }
 221
 222         return false;
 223 }
 224
 225 bool
 226 Editor::typed_event (ArdourCanvas::Item* item, GdkEvent *event, ItemType type)
 227 {
 228         gint ret = FALSE;
 229
 230         switch (event->type) {
 231         case GDK_BUTTON_PRESS:
 232         case GDK_2BUTTON_PRESS:
 233         case GDK_3BUTTON_PRESS:
 234                 ret = button_press_handler (item, event, type);
 235                 break;
 236         case GDK_BUTTON_RELEASE:
 237                 ret = button_release_handler (item, event, type);
 238                 break;
 239         case GDK_MOTION_NOTIFY:
 240                 ret = motion_handler (item, event);
 241                 break;
 242
 243         case GDK_ENTER_NOTIFY:
 244                 ret = enter_handler (item, event, type);
 245                 break;
 246
 247         case GDK_LEAVE_NOTIFY:
 248                 ret = leave_handler (item, event, type);
 249                 break;
 250
 251         default:
 252                 break;
 253         }
 254         return ret;
 255 }
 256
 257 bool
 258 Editor::canvas_region_view_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView *rv)
 259 {
 260         bool ret = false;
 261
 262         if (!rv->sensitive ()) {
 263                 return false;
 264         }
 265
 266
 267         switch (event->type) {
 268         case GDK_BUTTON_PRESS:
 269         case GDK_2BUTTON_PRESS:
 270         case GDK_3BUTTON_PRESS:
 271                 clicked_regionview = rv;
 272                 clicked_control_point = 0;
 273                 clicked_axisview = &rv->get_time_axis_view();
 274                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 275                 ret = button_press_handler (item, event, RegionItem);
 276                 break;
 277
 278         case GDK_BUTTON_RELEASE:
 279                 ret = button_release_handler (item, event, RegionItem);
 280                 break;
 281
 282         case GDK_MOTION_NOTIFY:
 283                 ret = motion_handler (item, event);
 284                 break;
 285
 286         case GDK_ENTER_NOTIFY:
 287                 set_entered_track (&rv->get_time_axis_view ());
 288                 set_entered_regionview (rv);
 289                 break;
 290
 291         case GDK_LEAVE_NOTIFY:
 292                 set_entered_track (0);
 293                 set_entered_regionview (0);
 294                 break;
 295
 296         default:
 297                 break;
 298         }
 299
 300         return ret;
 301 }
 302
 303 bool
 304 Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, RouteTimeAxisView *tv)
 305 {
 306         bool ret = FALSE;
 307
 308         switch (event->type) {
 309         case GDK_BUTTON_PRESS:
 310         case GDK_2BUTTON_PRESS:
 311         case GDK_3BUTTON_PRESS:
 312                 clicked_regionview = 0;
 313                 clicked_control_point = 0;
 314                 clicked_axisview = tv;
 315                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(tv);
 316                 ret = button_press_handler (item, event, StreamItem);
 317                 break;
 318
 319         case GDK_BUTTON_RELEASE:
 320                 ret = button_release_handler (item, event, StreamItem);
 321                 break;
 322
 323         case GDK_MOTION_NOTIFY:
 324                 ret = motion_handler (item, event, StreamItem);
 325                 break;
 326
 327         case GDK_ENTER_NOTIFY:
 328                 set_entered_track (tv);
 329                 break;
 330
 331         case GDK_LEAVE_NOTIFY:
 332                 set_entered_track (0);
 333                 break;
 334
 335         default:
 336                 break;
 337         }
 338
 339         return ret;
 340 }
 341
 342 bool
 343 Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
 344 {
 345         bool ret = false;
 346
 347         switch (event->type) {
 348         case GDK_BUTTON_PRESS:
 349         case GDK_2BUTTON_PRESS:
 350         case GDK_3BUTTON_PRESS:
 351                 clicked_regionview = 0;
 352                 clicked_control_point = 0;
 353                 clicked_axisview = atv;
 354                 clicked_routeview = 0;
 355                 ret = button_press_handler (item, event, AutomationTrackItem);
 356                 break;
 357
 358         case GDK_BUTTON_RELEASE:
 359                 ret = button_release_handler (item, event, AutomationTrackItem);
 360                 break;
 361
 362         case GDK_MOTION_NOTIFY:
 363                 ret = motion_handler (item, event);
 364                 break;
 365
 366         case GDK_ENTER_NOTIFY:
 367                 ret = enter_handler (item, event, AutomationTrackItem);
 368                 break;
 369
 370         case GDK_LEAVE_NOTIFY:
 371                 ret = leave_handler (item, event, AutomationTrackItem);
 372                 break;
 373
 374         default:
 375                 break;
 376         }
 377
 378         return ret;
 379 }
 380
 381 bool
 382 Editor::canvas_fade_in_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 383 {
 384         /* we handle only button 3 press/release events */
 385
 386         if (!rv->sensitive()) {
 387                 return false;
 388         }
 389
 390         switch (event->type) {
 391         case GDK_BUTTON_PRESS:
 392                 clicked_regionview = rv;
 393                 clicked_control_point = 0;
 394                 clicked_axisview = &rv->get_time_axis_view();
 395                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 396                 if (event->button.button == 3) {
 397                         return button_press_handler (item, event, FadeInItem);
 398                 }
 399                 break;
 400
 401         case GDK_BUTTON_RELEASE:
 402                 if (event->button.button == 3) {
 403                         return button_release_handler (item, event, FadeInItem);
 404                 }
 405                 break;
 406
 407         default:
 408                 break;
 409
 410         }
 411
 412         /* proxy for the regionview */
 413
 414         return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 415 }
 416
 417 bool
 418 Editor::canvas_fade_in_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 419 {
 420         bool ret = false;
 421
 422         if (!rv->sensitive()) {
 423                 return false;
 424         }
 425
 426         switch (event->type) {
 427         case GDK_BUTTON_PRESS:
 428         case GDK_2BUTTON_PRESS:
 429         case GDK_3BUTTON_PRESS:
 430                 clicked_regionview = rv;
 431                 clicked_control_point = 0;
 432                 clicked_axisview = &rv->get_time_axis_view();
 433                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 434                 ret = button_press_handler (item, event, FadeInHandleItem);
 435                 break;
 436
 437         case GDK_BUTTON_RELEASE:
 438                 ret = button_release_handler (item, event, FadeInHandleItem);
 439                 break;
 440
 441         case GDK_MOTION_NOTIFY:
 442                 ret = motion_handler (item, event);
 443                 break;
 444
 445         case GDK_ENTER_NOTIFY:
 446                 ret = enter_handler (item, event, FadeInHandleItem);
 447                 break;
 448
 449         case GDK_LEAVE_NOTIFY:
 450                 ret = leave_handler (item, event, FadeInHandleItem);
 451                 break;
 452
 453         default:
 454                 break;
 455         }
 456
 457         return ret;
 458 }
 459
 460 bool
 461 Editor::canvas_fade_out_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 462 {
 463         /* we handle only button 3 press/release events */
 464
 465         if (!rv->sensitive()) {
 466                 return false;
 467         }
 468
 469         switch (event->type) {
 470         case GDK_BUTTON_PRESS:
 471                 clicked_regionview = rv;
 472                 clicked_control_point = 0;
 473                 clicked_axisview = &rv->get_time_axis_view();
 474                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 475                 if (event->button.button == 3) {
 476                         return button_press_handler (item, event, FadeOutItem);
 477                 }
 478                 break;
 479
 480         case GDK_BUTTON_RELEASE:
 481                 if (event->button.button == 3) {
 482                         return button_release_handler (item, event, FadeOutItem);
 483                 }
 484                 break;
 485
 486         default:
 487                 break;
 488
 489         }
 490
 491         /* proxy for the regionview */
 492
 493         return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 494 }
 495
 496 bool
 497 Editor::canvas_fade_out_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 498 {
 499         bool ret = false;
 500
 501         if (!rv->sensitive()) {
 502                 return false;
 503         }
 504
 505         switch (event->type) {
 506         case GDK_BUTTON_PRESS:
 507         case GDK_2BUTTON_PRESS:
 508         case GDK_3BUTTON_PRESS:
 509                 clicked_regionview = rv;
 510                 clicked_control_point = 0;
 511                 clicked_axisview = &rv->get_time_axis_view();
 512                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 513                 ret = button_press_handler (item, event, FadeOutHandleItem);
 514                 break;
 515
 516         case GDK_BUTTON_RELEASE:
 517                 ret = button_release_handler (item, event, FadeOutHandleItem);
 518                 break;
 519
 520         case GDK_MOTION_NOTIFY:
 521                 ret = motion_handler (item, event);
 522                 break;
 523
 524         case GDK_ENTER_NOTIFY:
 525                 ret = enter_handler (item, event, FadeOutHandleItem);
 526                 break;
 527
 528         case GDK_LEAVE_NOTIFY:
 529                 ret = leave_handler (item, event, FadeOutHandleItem);
 530                 break;
 531
 532         default:
 533                 break;
 534         }
 535
 536         return ret;
 537 }
 538
 539 struct DescendingRegionLayerSorter {
 540     bool operator()(boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
 541             return a->layer() > b->layer();
 542     }
 543 };
 544
 545 bool
 546 Editor::canvas_crossfade_view_event (GdkEvent* event, ArdourCanvas::Item* item, CrossfadeView* xfv)
 547 {
 548         /* we handle only button 3 press/release events */
 549
 550         switch (event->type) {
 551         case GDK_BUTTON_PRESS:
 552                 clicked_crossfadeview = xfv;
 553                 clicked_axisview = &clicked_crossfadeview->get_time_axis_view();
 554                 if (event->button.button == 3) {
 555                         return button_press_handler (item, event, CrossfadeViewItem);
 556                 }
 557                 break;
 558
 559         case GDK_BUTTON_RELEASE:
 560                 if (event->button.button == 3) {
 561                         bool ret = button_release_handler (item, event, CrossfadeViewItem);
 562                         return ret;
 563                 }
 564                 break;
 565
 566         default:
 567                 break;
 568
 569         }
 570
 571         /* XXX do not forward double clicks */
 572
 573         if (event->type == GDK_2BUTTON_PRESS) {
 574                 return false;
 575         }
 576
 577         /* proxy for the upper most regionview */
 578
 579         /* XXX really need to check if we are in the name highlight,
 580            and proxy to that when required.
 581         */
 582
 583         TimeAxisView& tv (xfv->get_time_axis_view());
 584         AudioTimeAxisView* atv;
 585
 586         if ((atv = dynamic_cast<AudioTimeAxisView*>(&tv)) != 0) {
 587
 588                 if (atv->is_audio_track()) {
 589
 590                         boost::shared_ptr<AudioPlaylist> pl;
 591                         if ((pl = boost::dynamic_pointer_cast<AudioPlaylist> (atv->get_diskstream()->playlist())) != 0) {
 592
 593                                 Playlist::RegionList* rl = pl->regions_at (event_frame (event));
 594
 595                                 if (!rl->empty()) {
 596                                         DescendingRegionLayerSorter cmp;
 597                                         rl->sort (cmp);
 598
 599                                         RegionView* rv = atv->view()->find_view (rl->front());
 600
 601                                         delete rl;
 602
 603                                         /* proxy */
 604
 605                                         return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 606                                 }
 607
 608                                 delete rl;
 609                         }
 610                 }
 611         }
 612
 613         return TRUE;
 614 }
 615
 616 bool
 617 Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
 618 {
 619         switch (event->type) {
 620         case GDK_BUTTON_PRESS:
 621         case GDK_2BUTTON_PRESS:
 622         case GDK_3BUTTON_PRESS:
 623                 clicked_control_point = cp;
 624                 clicked_axisview = &cp->line().trackview;
 625                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 626                 clicked_regionview = 0;
 627                 break;
 628
 629         case GDK_SCROLL_UP:
 630                 break;
 631
 632         case GDK_SCROLL_DOWN:
 633                 break;
 634
 635         default:
 636                 break;
 637         }
 638
 639         return typed_event (item, event, ControlPointItem);
 640 }
 641
 642 bool
 643 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
 644 {
 645         ItemType type;
 646
 647         if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
 648                 type = GainLineItem;
 649         } else {
 650                 type = AutomationLineItem;
 651         }
 652
 653         return typed_event (item, event, type);
 654 }
 655
 656 bool
 657 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 658 {
 659         bool ret = false;
 660
 661         switch (event->type) {
 662         case GDK_BUTTON_PRESS:
 663         case GDK_2BUTTON_PRESS:
 664         case GDK_3BUTTON_PRESS:
 665                 clicked_selection = rect->id;
 666                 ret = button_press_handler (item, event, SelectionItem);
 667                 break;
 668         case GDK_BUTTON_RELEASE:
 669                 ret = button_release_handler (item, event, SelectionItem);
 670                 break;
 671         case GDK_MOTION_NOTIFY:
 672                 ret = motion_handler (item, event);
 673                 break;
 674                 /* Don't need these at the moment. */
 675         case GDK_ENTER_NOTIFY:
 676                 ret = enter_handler (item, event, SelectionItem);
 677                 break;
 678
 679         case GDK_LEAVE_NOTIFY:
 680                 ret = leave_handler (item, event, SelectionItem);
 681                 break;
 682
 683         default:
 684                 break;
 685         }
 686
 687         return ret;
 688 }
 689
 690 bool
 691 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 692 {
 693         bool ret = false;
 694
 695         switch (event->type) {
 696         case GDK_BUTTON_PRESS:
 697         case GDK_2BUTTON_PRESS:
 698         case GDK_3BUTTON_PRESS:
 699                 clicked_selection = rect->id;
 700                 ret = button_press_handler (item, event, StartSelectionTrimItem);
 701                 break;
 702         case GDK_BUTTON_RELEASE:
 703                 ret = button_release_handler (item, event, StartSelectionTrimItem);
 704                 break;
 705         case GDK_MOTION_NOTIFY:
 706                 ret = motion_handler (item, event);
 707                 break;
 708         case GDK_ENTER_NOTIFY:
 709                 ret = enter_handler (item, event, StartSelectionTrimItem);
 710                 break;
 711
 712         case GDK_LEAVE_NOTIFY:
 713                 ret = leave_handler (item, event, StartSelectionTrimItem);
 714                 break;
 715
 716         default:
 717                 break;
 718         }
 719
 720         return ret;
 721 }
 722
 723 bool
 724 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 725 {
 726         bool ret = false;
 727
 728         switch (event->type) {
 729         case GDK_BUTTON_PRESS:
 730         case GDK_2BUTTON_PRESS:
 731         case GDK_3BUTTON_PRESS:
 732                 clicked_selection = rect->id;
 733                 ret = button_press_handler (item, event, EndSelectionTrimItem);
 734                 break;
 735         case GDK_BUTTON_RELEASE:
 736                 ret = button_release_handler (item, event, EndSelectionTrimItem);
 737                 break;
 738         case GDK_MOTION_NOTIFY:
 739                 ret = motion_handler (item, event);
 740                 break;
 741         case GDK_ENTER_NOTIFY:
 742                 ret = enter_handler (item, event, EndSelectionTrimItem);
 743                 break;
 744
 745         case GDK_LEAVE_NOTIFY:
 746                 ret = leave_handler (item, event, EndSelectionTrimItem);
 747                 break;
 748
 749         default:
 750                 break;
 751         }
 752
 753         return ret;
 754 }
 755
 756
 757 bool
 758 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
 759 {
 760         bool ret = false;
 761
 762         if (!rv->sensitive()) {
 763                 return false;
 764         }
 765
 766         switch (event->type) {
 767         case GDK_BUTTON_PRESS:
 768         case GDK_2BUTTON_PRESS:
 769         case GDK_3BUTTON_PRESS:
 770                 clicked_regionview = rv;
 771                 clicked_control_point = 0;
 772                 clicked_axisview = &clicked_regionview->get_time_axis_view();
 773                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 774                 ret = button_press_handler (item, event, RegionViewNameHighlight);
 775                 break;
 776         case GDK_BUTTON_RELEASE:
 777                 ret = button_release_handler (item, event, RegionViewNameHighlight);
 778                 break;
 779         case GDK_MOTION_NOTIFY:
 780                 ret = motion_handler (item, event);
 781                 break;
 782         case GDK_ENTER_NOTIFY:
 783                 ret = enter_handler (item, event, RegionViewNameHighlight);
 784                 break;
 785
 786         case GDK_LEAVE_NOTIFY:
 787                 ret = leave_handler (item, event, RegionViewNameHighlight);
 788                 break;
 789
 790         default:
 791                 break;
 792         }
 793
 794         return ret;
 795 }
 796
 797 bool
 798 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
 799 {
 800         bool ret = false;
 801
 802         if (!rv->sensitive()) {
 803                 return false;
 804         }
 805
 806         switch (event->type) {
 807         case GDK_BUTTON_PRESS:
 808         case GDK_2BUTTON_PRESS:
 809         case GDK_3BUTTON_PRESS:
 810                 clicked_regionview = rv;
 811                 clicked_control_point = 0;
 812                 clicked_axisview = &clicked_regionview->get_time_axis_view();
 813                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 814                 ret = button_press_handler (item, event, RegionViewName);
 815                 break;
 816         case GDK_BUTTON_RELEASE:
 817                 ret = button_release_handler (item, event, RegionViewName);
 818                 break;
 819         case GDK_MOTION_NOTIFY:
 820                 ret = motion_handler (item, event);
 821                 break;
 822         case GDK_ENTER_NOTIFY:
 823                 ret = enter_handler (item, event, RegionViewName);
 824                 break;
 825
 826         case GDK_LEAVE_NOTIFY:
 827                 ret = leave_handler (item, event, RegionViewName);
 828                 break;
 829
 830         default:
 831                 break;
 832         }
 833
 834         return ret;
 835 }
 836
 837 bool
 838 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* /*marker*/)
 839 {
 840         return typed_event (item, event, MarkerItem);
 841 }
 842
 843 bool
 844 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 845 {
 846         return typed_event (item, event, MarkerBarItem);
 847 }
 848
 849 bool
 850 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 851 {
 852         return typed_event (item, event, RangeMarkerBarItem);
 853 }
 854
 855 bool
 856 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 857 {
 858         return typed_event (item, event, TransportMarkerBarItem);
 859 }
 860
 861 bool
 862 Editor::canvas_cd_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 863 {
 864         return typed_event (item, event, CdMarkerBarItem);
 865 }
 866
 867 bool
 868 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* /*marker*/)
 869 {
 870         return typed_event (item, event, TempoMarkerItem);
 871 }
 872
 873 bool
 874 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* /*marker*/)
 875 {
 876         return typed_event (item, event, MeterMarkerItem);
 877 }
 878
 879 bool
 880 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 881 {
 882         return typed_event (item, event, TempoBarItem);
 883 }
 884
 885 bool
 886 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 887 {
 888         return typed_event (item, event, MeterBarItem);
 889 }
 890
 891 bool
 892 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 893 {
 894         return typed_event (item, event, PlayheadCursorItem);
 895 }
 896
 897 bool
 898 Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
 899 {
 900         return typed_event (item, event, NoItem);
 901 }
 902
 903 bool
 904 Editor::track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const & /*c*/, int x, int y, guint /*time*/)
 905 {
 906         double wx;
 907         double wy;
 908         track_canvas->window_to_world (x, y, wx, wy);
 909
 910         GdkEvent event;
 911         event.type = GDK_MOTION_NOTIFY;
 912         event.button.x = wx;
 913         event.button.y = wy;
 914         /* assume we're dragging with button 1 */
 915         event.motion.state = Gdk::BUTTON1_MASK;
 916
 917         if (_drag == 0) {
 918
 919                 double px;
 920                 double py;
 921                 nframes64_t const pos = event_frame (&event, &px, &py);
 922
 923                 std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py);
 924                 if (tv.first == 0) {
 925                         return true;
 926                 }
 927
 928                 RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
 929                 if (rtav == 0 || !rtav->is_track ()) {
 930                         return true;
 931                 }
 932
 933                 boost::shared_ptr<Region> region = _regions->get_dragged_region ();
 934
 935                 boost::shared_ptr<Region> region_copy = RegionFactory::create (region);
 936
 937                 if (boost::dynamic_pointer_cast<AudioRegion> (region_copy) != 0 &&
 938                     dynamic_cast<AudioTimeAxisView*> (tv.first) == 0) {
 939
 940                         /* audio -> non-audio */
 941                         return true;
 942                 }
 943
 944                 if (boost::dynamic_pointer_cast<MidiRegion> (region_copy) == 0 &&
 945                     dynamic_cast<MidiTimeAxisView*> (tv.first) != 0) {
 946
 947                         /* MIDI -> non-MIDI */
 948                         return true;
 949                 }
 950
 951                 _drag = new RegionInsertDrag (this, region_copy, rtav, pos);
 952                 _drag->start_grab (&event);
 953         }
 954
 955         _drag->motion_handler (&event, false);
 956
 957         return true;
 958 }