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/midi_region.h"
  30 #include "ardour/audioregion.h"
  31 #include "ardour/region_factory.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
  51 #include "i18n.h"
  52
  53 using namespace sigc;
  54 using namespace std;
  55 using namespace ARDOUR;
  56 using namespace PBD;
  57 using namespace Gtk;
  58 using namespace ArdourCanvas;
  59
  60 bool
  61 Editor::track_canvas_scroll (GdkEventScroll* ev)
  62 {
  63         int x, y;
  64         double wx, wy;
  65         nframes64_t xdelta;
  66         int direction = ev->direction;
  67
  68         Gnome::Canvas::Item* item = track_canvas->get_item_at(ev->x, ev->y);
  69         InteractiveItem* interactive_item = dynamic_cast<InteractiveItem*>(item);
  70         if (interactive_item) {
  71                 return interactive_item->on_event(reinterpret_cast<GdkEvent*>(ev));
  72         }
  73
  74   retry:
  75         switch (direction) {
  76         case GDK_SCROLL_UP:
  77                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
  78                         //if (ev->state == GDK_CONTROL_MASK) {
  79                         /* XXX
  80                            the ev->x will be out of step with the canvas
  81                            if we're in mid zoom, so we have to get the damn mouse
  82                            pointer again
  83                         */
  84                         track_canvas->get_pointer (x, y);
  85                         track_canvas->window_to_world (x, y, wx, wy);
  86
  87                         GdkEvent event;
  88                         event.type = GDK_BUTTON_RELEASE;
  89                         event.button.x = wx;
  90                         event.button.y = wy;
  91
  92                         nframes64_t where = event_frame (&event, 0, 0);
  93                         temporal_zoom_to_frame (false, where);
  94                         return true;
  95                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
  96                         direction = GDK_SCROLL_LEFT;
  97                         goto retry;
  98                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
  99                         if (!current_stepping_trackview) {
 100                                 step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
 101                                 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
 102                                 current_stepping_trackview = p.first;
 103                                 if (!current_stepping_trackview) {
 104                                         return false;
 105                                 }
 106                         }
 107                         last_track_height_step_timestamp = get_microseconds();
 108                         current_stepping_trackview->step_height (true);
 109                         return true;
 110                 } else {
 111                         scroll_tracks_up_line ();
 112                         return true;
 113                 }
 114                 break;
 115
 116         case GDK_SCROLL_DOWN:
 117                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
 118                         //if (ev->state == GDK_CONTROL_MASK) {
 119                         track_canvas->get_pointer (x, y);
 120                         track_canvas->window_to_world (x, y, wx, wy);
 121
 122                         GdkEvent event;
 123                         event.type = GDK_BUTTON_RELEASE;
 124                         event.button.x = wx;
 125                         event.button.y = wy;
 126
 127                         nframes64_t where = event_frame (&event, 0, 0);
 128                         temporal_zoom_to_frame (true, where);
 129                         return true;
 130                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
 131                         direction = GDK_SCROLL_RIGHT;
 132                         goto retry;
 133                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
 134                         if (!current_stepping_trackview) {
 135                                 step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
 136                                 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
 137                                 current_stepping_trackview = p.first;
 138                                 if (!current_stepping_trackview) {
 139                                         return false;
 140                                 }
 141                         }
 142                         last_track_height_step_timestamp = get_microseconds();
 143                         current_stepping_trackview->step_height (false);
 144                         return true;
 145                 } else {
 146                         scroll_tracks_down_line ();
 147                         return true;
 148                 }
 149                 break;
 150
 151         case GDK_SCROLL_LEFT:
 152                 xdelta = (current_page_frames() / 8);
 153                 if (leftmost_frame > xdelta) {
 154                         reset_x_origin (leftmost_frame - xdelta);
 155                 } else {
 156                         reset_x_origin (0);
 157                 }
 158                 break;
 159
 160         case GDK_SCROLL_RIGHT:
 161                 xdelta = (current_page_frames() / 8);
 162                 if (max_frames - xdelta > leftmost_frame) {
 163                         reset_x_origin (leftmost_frame + xdelta);
 164                 } else {
 165                         reset_x_origin (max_frames - current_page_frames());
 166                 }
 167                 break;
 168
 169         default:
 170                 /* what? */
 171                 break;
 172         }
 173
 174         return false;
 175 }
 176
 177 bool
 178 Editor::track_canvas_scroll_event (GdkEventScroll *event)
 179 {
 180         track_canvas->grab_focus();
 181         track_canvas_scroll (event);
 182         return false;
 183 }
 184
 185 bool
 186 Editor::track_canvas_button_press_event (GdkEventButton *event)
 187 {
 188         selection->clear ();
 189         track_canvas->grab_focus();
 190         return false;
 191 }
 192
 193 bool
 194 Editor::track_canvas_button_release_event (GdkEventButton *event)
 195 {
 196         if (_drag) {
 197                 _drag->end_grab ((GdkEvent*) event);
 198                 delete _drag;
 199                 _drag = 0;
 200         }
 201         return false;
 202 }
 203
 204 bool
 205 Editor::track_canvas_motion_notify_event (GdkEventMotion *event)
 206 {
 207         int x, y;
 208         /* keep those motion events coming */
 209         track_canvas->get_pointer (x, y);
 210         return false;
 211 }
 212
 213 bool
 214 Editor::track_canvas_motion (GdkEvent *ev)
 215 {
 216         if (verbose_cursor_visible) {
 217                 verbose_canvas_cursor->property_x() = clamp_verbose_cursor_x (ev->motion.x + 10);
 218                 verbose_canvas_cursor->property_y() = clamp_verbose_cursor_y (ev->motion.y + 10);
 219         }
 220
 221         return false;
 222 }
 223
 224 bool
 225 Editor::typed_event (ArdourCanvas::Item* item, GdkEvent *event, ItemType type)
 226 {
 227         gint ret = FALSE;
 228
 229         switch (event->type) {
 230         case GDK_BUTTON_PRESS:
 231         case GDK_2BUTTON_PRESS:
 232         case GDK_3BUTTON_PRESS:
 233                 ret = button_press_handler (item, event, type);
 234                 break;
 235         case GDK_BUTTON_RELEASE:
 236                 ret = button_release_handler (item, event, type);
 237                 break;
 238         case GDK_MOTION_NOTIFY:
 239                 ret = motion_handler (item, event);
 240                 break;
 241
 242         case GDK_ENTER_NOTIFY:
 243                 ret = enter_handler (item, event, type);
 244                 break;
 245
 246         case GDK_LEAVE_NOTIFY:
 247                 ret = leave_handler (item, event, type);
 248                 break;
 249
 250         default:
 251                 break;
 252         }
 253         return ret;
 254 }
 255
 256 bool
 257 Editor::canvas_region_view_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView *rv)
 258 {
 259         bool ret = false;
 260
 261         if (!rv->sensitive ()) {
 262                 return false;
 263         }
 264
 265
 266         switch (event->type) {
 267         case GDK_BUTTON_PRESS:
 268         case GDK_2BUTTON_PRESS:
 269         case GDK_3BUTTON_PRESS:
 270                 clicked_regionview = rv;
 271                 clicked_control_point = 0;
 272                 clicked_axisview = &rv->get_time_axis_view();
 273                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 274                 ret = button_press_handler (item, event, RegionItem);
 275                 break;
 276
 277         case GDK_BUTTON_RELEASE:
 278                 ret = button_release_handler (item, event, RegionItem);
 279                 break;
 280
 281         case GDK_MOTION_NOTIFY:
 282                 ret = motion_handler (item, event);
 283                 break;
 284
 285         case GDK_ENTER_NOTIFY:
 286                 set_entered_track (&rv->get_time_axis_view ());
 287                 set_entered_regionview (rv);
 288                 break;
 289
 290         case GDK_LEAVE_NOTIFY:
 291                 set_entered_track (0);
 292                 set_entered_regionview (0);
 293                 break;
 294
 295         default:
 296                 break;
 297         }
 298
 299         return ret;
 300 }
 301
 302 bool
 303 Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, RouteTimeAxisView *tv)
 304 {
 305         bool ret = FALSE;
 306
 307         switch (event->type) {
 308         case GDK_BUTTON_PRESS:
 309         case GDK_2BUTTON_PRESS:
 310         case GDK_3BUTTON_PRESS:
 311                 clicked_regionview = 0;
 312                 clicked_control_point = 0;
 313                 clicked_axisview = tv;
 314                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(tv);
 315                 ret = button_press_handler (item, event, StreamItem);
 316                 break;
 317
 318         case GDK_BUTTON_RELEASE:
 319                 ret = button_release_handler (item, event, StreamItem);
 320                 break;
 321
 322         case GDK_MOTION_NOTIFY:
 323                 ret = motion_handler (item, event, StreamItem);
 324                 break;
 325
 326         case GDK_ENTER_NOTIFY:
 327                 set_entered_track (tv);
 328                 break;
 329
 330         case GDK_LEAVE_NOTIFY:
 331                 set_entered_track (0);
 332                 break;
 333
 334         default:
 335                 break;
 336         }
 337
 338         return ret;
 339 }
 340
 341 bool
 342 Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
 343 {
 344         bool ret = false;
 345
 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                 list<boost::shared_ptr<Region> > regions;
 934                 TreeView* source;
 935                 region_list_display.get_object_drag_data (regions, &source);
 936                 assert (regions.size() == 1);
 937                 boost::shared_ptr<Region> region = regions.front ();
 938
 939                 boost::shared_ptr<Region> region_copy = RegionFactory::create (region);
 940
 941                 if (boost::dynamic_pointer_cast<AudioRegion> (region_copy) != 0 &&
 942                     dynamic_cast<AudioTimeAxisView*> (tv.first) == 0) {
 943
 944                         /* audio -> non-audio */
 945                         return true;
 946                 }
 947
 948                 if (boost::dynamic_pointer_cast<MidiRegion> (region_copy) == 0 &&
 949                     dynamic_cast<MidiTimeAxisView*> (tv.first) != 0) {
 950
 951                         /* MIDI -> non-MIDI */
 952                         return true;
 953                 }
 954
 955                 _drag = new RegionInsertDrag (this, region_copy, rtav, pos);
 956                 _drag->start_grab (&event);
 957         }
 958
 959         _drag->motion_handler (&event, false);
 960
 961         return true;
 962 }