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     $Id$
  19 */
  20
  21 #include <cstdlib>
  22 #include <cmath>
  23
  24 #include <ardour/diskstream.h>
  25 #include <ardour/audioplaylist.h>
  26
  27 #include "editor.h"
  28 #include "public_editor.h"
  29 #include "regionview.h"
  30 #include "streamview.h"
  31 #include "crossfade_view.h"
  32 #include "audio_time_axis.h"
  33 #include "region_gain_line.h"
  34 #include "automation_gain_line.h"
  35 #include "automation_pan_line.h"
  36 #include "automation_time_axis.h"
  37 #include "redirect_automation_line.h"
  38 #include "canvas_impl.h"
  39 #include "simplerect.h"
  40
  41 #include "i18n.h"
  42
  43 using namespace sigc;
  44 using namespace ARDOUR;
  45 using namespace Gtk;
  46
  47 bool
  48 Editor::track_canvas_scroll (GdkEventScroll* ev)
  49 {
  50         int x, y;
  51         double wx, wy;
  52
  53         switch (ev->direction) {
  54         case GDK_SCROLL_UP:
  55           if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
  56             //if (ev->state == GDK_CONTROL_MASK) {
  57               /* XXX
  58                the ev->x will be out of step with the canvas
  59                if we're in mid zoom, so we have to get the damn mouse
  60                pointer again
  61               */
  62                 track_canvas.get_pointer (x, y);
  63                 track_canvas.window_to_world (x, y, wx, wy);
  64                 wx += horizontal_adjustment.get_value();
  65                 wy += vertical_adjustment.get_value();
  66
  67                 GdkEvent event;
  68                 event.type = GDK_BUTTON_RELEASE;
  69                 event.button.x = wx;
  70                 event.button.y = wy;
  71
  72                 jack_nframes_t where = event_frame (&event, 0, 0);
  73                 temporal_zoom_to_frame (true, where);
  74                 return true;
  75           } else {
  76                 scroll_tracks_up_line ();
  77                 return true;
  78           }
  79           break;
  80         case GDK_SCROLL_DOWN:
  81           if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
  82             //if (ev->state == GDK_CONTROL_MASK) {
  83                 track_canvas.get_pointer (x, y);
  84                 track_canvas.window_to_world (x, y, wx, wy);
  85                 wx += horizontal_adjustment.get_value();
  86                 wy += vertical_adjustment.get_value();
  87
  88                 GdkEvent event;
  89                 event.type = GDK_BUTTON_RELEASE;
  90                 event.button.x = wx;
  91                 event.button.y = wy;
  92
  93                 jack_nframes_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::Shift)) {
  97                 if (clicked_trackview) {
  98                   if (!current_stepping_trackview) {
  99                     step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
 100                     current_stepping_trackview = clicked_trackview;
 101                   }
 102                   gettimeofday (&last_track_height_step_timestamp, 0);
 103                   current_stepping_trackview->step_height (true);
 104                 }
 105                 return true;
 106           } else {
 107                 scroll_tracks_down_line ();
 108                 return true;
 109           }
 110           break;
 111         default:
 112                 /* no left/right handling yet */
 113                 break;
 114         }
 115
 116         return false;
 117 }
 118
 119 bool
 120 Editor::track_canvas_event (GdkEvent *event, ArdourCanvas::Item* item)
 121 {
 122         gint x, y;
 123
 124         /* this is the handler for events that are not handled by
 125            items.
 126         */
 127
 128         switch (event->type) {
 129         case GDK_MOTION_NOTIFY:
 130                 /* keep those motion events coming */
 131                 track_canvas.get_pointer (x, y);
 132                 return track_canvas_motion (event);
 133
 134         case GDK_BUTTON_PRESS:
 135                 track_canvas.grab_focus();
 136                 break;
 137
 138         case GDK_BUTTON_RELEASE:
 139                 switch (event->button.button) {
 140                 case 4:
 141                 case 5:
 142                         button_release_handler (item, event, NoItem);
 143                         break;
 144                 }
 145                 break;
 146
 147         case GDK_SCROLL:
 148                 track_canvas.grab_focus();
 149                 track_canvas_scroll (&event->scroll);
 150                 break;
 151
 152         default:
 153                 break;
 154         }
 155
 156         return FALSE;
 157 }
 158
 159 bool
 160 Editor::track_canvas_motion (GdkEvent *ev)
 161 {
 162         if (verbose_cursor_visible) {
 163                 verbose_canvas_cursor->property_x() = ev->motion.x + 20;
 164                 verbose_canvas_cursor->property_y() = ev->motion.y + 20;
 165         }
 166         return false;
 167 }
 168
 169 bool
 170 Editor::typed_event (ArdourCanvas::Item* item, GdkEvent *event, ItemType type)
 171 {
 172         gint ret = FALSE;
 173
 174         switch (event->type) {
 175         case GDK_BUTTON_PRESS:
 176         case GDK_2BUTTON_PRESS:
 177         case GDK_3BUTTON_PRESS:
 178                 ret = button_press_handler (item, event, type);
 179                 break;
 180         case GDK_BUTTON_RELEASE:
 181                 ret = button_release_handler (item, event, type);
 182                 break;
 183         case GDK_MOTION_NOTIFY:
 184                 ret = motion_handler (item, event, type);
 185                 break;
 186
 187         case GDK_ENTER_NOTIFY:
 188                 ret = enter_handler (item, event, type);
 189                 break;
 190
 191         case GDK_LEAVE_NOTIFY:
 192                 ret = leave_handler (item, event, type);
 193                 break;
 194
 195         default:
 196                 break;
 197         }
 198
 199         return ret;
 200 }
 201
 202 bool
 203 Editor::canvas_region_view_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 204 {
 205         gint ret = FALSE;
 206
 207         switch (event->type) {
 208         case GDK_BUTTON_PRESS:
 209         case GDK_2BUTTON_PRESS:
 210         case GDK_3BUTTON_PRESS:
 211                 clicked_regionview = rv;
 212                 clicked_control_point = 0;
 213                 clicked_trackview = &rv->get_time_axis_view();
 214                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 215                 ret = button_press_handler (item, event, RegionItem);
 216                 break;
 217
 218         case GDK_BUTTON_RELEASE:
 219                 ret = button_release_handler (item, event, RegionItem);
 220                 break;
 221
 222         case GDK_MOTION_NOTIFY:
 223                 ret = motion_handler (item, event, RegionItem);
 224                 break;
 225
 226         case GDK_ENTER_NOTIFY:
 227                 set_entered_regionview (rv);
 228                 break;
 229
 230         case GDK_LEAVE_NOTIFY:
 231                 set_entered_regionview (0);
 232                 break;
 233
 234         default:
 235                 break;
 236         }
 237
 238         return ret;
 239 }
 240
 241 bool
 242 Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, AudioTimeAxisView *tv)
 243 {
 244         bool ret = FALSE;
 245
 246         switch (event->type) {
 247         case GDK_BUTTON_PRESS:
 248         case GDK_2BUTTON_PRESS:
 249         case GDK_3BUTTON_PRESS:
 250                 clicked_regionview = 0;
 251                 clicked_control_point = 0;
 252                 clicked_trackview = tv;
 253                 clicked_audio_trackview = tv;
 254                 ret = button_press_handler (item, event, StreamItem);
 255                 break;
 256
 257         case GDK_BUTTON_RELEASE:
 258                 ret = button_release_handler (item, event, StreamItem);
 259                 break;
 260
 261         case GDK_MOTION_NOTIFY:
 262                 ret = motion_handler (item, event, StreamItem);
 263                 break;
 264
 265         case GDK_ENTER_NOTIFY:
 266                 break;
 267
 268         default:
 269                 break;
 270         }
 271
 272         return ret;
 273 }
 274
 275
 276
 277 bool
 278 Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
 279 {
 280         bool ret = false;
 281
 282         switch (event->type) {
 283         case GDK_BUTTON_PRESS:
 284         case GDK_2BUTTON_PRESS:
 285         case GDK_3BUTTON_PRESS:
 286                 clicked_regionview = 0;
 287                 clicked_control_point = 0;
 288                 clicked_trackview = atv;
 289                 clicked_audio_trackview = 0;
 290                 ret = button_press_handler (item, event, AutomationTrackItem);
 291                 break;
 292
 293         case GDK_BUTTON_RELEASE:
 294                 ret = button_release_handler (item, event, AutomationTrackItem);
 295                 break;
 296
 297         case GDK_MOTION_NOTIFY:
 298                 ret = motion_handler (item, event, AutomationTrackItem);
 299                 break;
 300
 301         case GDK_ENTER_NOTIFY:
 302                 ret = enter_handler (item, event, AutomationTrackItem);
 303                 break;
 304
 305         case GDK_LEAVE_NOTIFY:
 306                 ret = leave_handler (item, event, AutomationTrackItem);
 307                 break;
 308
 309         default:
 310                 break;
 311         }
 312
 313         return ret;
 314 }
 315
 316 bool
 317 Editor::canvas_fade_in_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 318 {
 319         /* we handle only button 3 press/release events */
 320
 321         switch (event->type) {
 322         case GDK_BUTTON_PRESS:
 323                 clicked_regionview = rv;
 324                 clicked_control_point = 0;
 325                 clicked_trackview = &rv->get_time_axis_view();
 326                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 327                 if (event->button.button == 3) {
 328                         return button_press_handler (item, event, FadeInItem);
 329                 }
 330                 break;
 331
 332         case GDK_BUTTON_RELEASE:
 333                 if (event->button.button == 3) {
 334                         return button_release_handler (item, event, FadeInItem);
 335                 }
 336                 break;
 337
 338         default:
 339                 break;
 340
 341         }
 342
 343         /* proxy for the regionview */
 344
 345         return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 346 }
 347
 348 bool
 349 Editor::canvas_fade_in_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 350 {
 351         bool ret = false;
 352
 353         switch (event->type) {
 354         case GDK_BUTTON_PRESS:
 355         case GDK_2BUTTON_PRESS:
 356         case GDK_3BUTTON_PRESS:
 357                 clicked_regionview = rv;
 358                 clicked_control_point = 0;
 359                 clicked_trackview = &rv->get_time_axis_view();
 360                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 361                 ret = button_press_handler (item, event, FadeInHandleItem);
 362                 break;
 363
 364         case GDK_BUTTON_RELEASE:
 365                 ret = button_release_handler (item, event, FadeInHandleItem);
 366                 break;
 367
 368         case GDK_MOTION_NOTIFY:
 369                 ret = motion_handler (item, event, FadeInHandleItem);
 370                 break;
 371
 372         case GDK_ENTER_NOTIFY:
 373                 ret = enter_handler (item, event, FadeInHandleItem);
 374                 break;
 375
 376         case GDK_LEAVE_NOTIFY:
 377                 ret = leave_handler (item, event, FadeInHandleItem);
 378                 break;
 379
 380         default:
 381                 break;
 382         }
 383
 384         return ret;
 385 }
 386
 387 bool
 388 Editor::canvas_fade_out_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 389 {
 390         /* we handle only button 3 press/release events */
 391
 392         switch (event->type) {
 393         case GDK_BUTTON_PRESS:
 394                 clicked_regionview = rv;
 395                 clicked_control_point = 0;
 396                 clicked_trackview = &rv->get_time_axis_view();
 397                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 398                 if (event->button.button == 3) {
 399                         return button_press_handler (item, event, FadeOutItem);
 400                 }
 401                 break;
 402
 403         case GDK_BUTTON_RELEASE:
 404                 if (event->button.button == 3) {
 405                         return button_release_handler (item, event, FadeOutItem);
 406                 }
 407                 break;
 408
 409         default:
 410                 break;
 411
 412         }
 413
 414         /* proxy for the regionview */
 415
 416         return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 417 }
 418
 419 bool
 420 Editor::canvas_fade_out_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 421 {
 422         bool ret = false;
 423
 424         switch (event->type) {
 425         case GDK_BUTTON_PRESS:
 426         case GDK_2BUTTON_PRESS:
 427         case GDK_3BUTTON_PRESS:
 428                 clicked_regionview = rv;
 429                 clicked_control_point = 0;
 430                 clicked_trackview = &rv->get_time_axis_view();
 431                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 432                 ret = button_press_handler (item, event, FadeOutHandleItem);
 433                 break;
 434
 435         case GDK_BUTTON_RELEASE:
 436                 ret = button_release_handler (item, event, FadeOutHandleItem);
 437                 break;
 438
 439         case GDK_MOTION_NOTIFY:
 440                 ret = motion_handler (item, event, FadeOutHandleItem);
 441                 break;
 442
 443         case GDK_ENTER_NOTIFY:
 444                 ret = enter_handler (item, event, FadeOutHandleItem);
 445                 break;
 446
 447         case GDK_LEAVE_NOTIFY:
 448                 ret = leave_handler (item, event, FadeOutHandleItem);
 449                 break;
 450
 451         default:
 452                 break;
 453         }
 454
 455         return ret;
 456 }
 457
 458 struct DescendingRegionLayerSorter {
 459     bool operator()(Region* a, Region* b) {
 460             return a->layer() > b->layer();
 461     }
 462 };
 463
 464 bool
 465 Editor::canvas_crossfade_view_event (GdkEvent* event, ArdourCanvas::Item* item, CrossfadeView* xfv)
 466 {
 467         /* we handle only button 3 press/release events */
 468
 469         switch (event->type) {
 470         case GDK_BUTTON_PRESS:
 471                 clicked_crossfadeview = xfv;
 472                 clicked_trackview = &clicked_crossfadeview->get_time_axis_view();
 473                 if (event->button.button == 3) {
 474                         return button_press_handler (item, event, CrossfadeViewItem);
 475                 }
 476                 break;
 477
 478         case GDK_BUTTON_RELEASE:
 479                 if (event->button.button == 3) {
 480                         bool ret = button_release_handler (item, event, CrossfadeViewItem);
 481                         return ret;
 482                 }
 483                 break;
 484
 485         default:
 486                 break;
 487
 488         }
 489
 490
 491         /* proxy for the upper most regionview */
 492
 493         /* XXX really need to check if we are in the name highlight,
 494            and proxy to that when required.
 495         */
 496
 497         TimeAxisView& tv (xfv->get_time_axis_view());
 498         AudioTimeAxisView* atv;
 499
 500         if ((atv = dynamic_cast<AudioTimeAxisView*>(&tv)) != 0) {
 501
 502                 if (atv->is_audio_track()) {
 503
 504                         AudioPlaylist* pl = atv->get_diskstream()->playlist();
 505                         Playlist::RegionList* rl = pl->regions_at (event_frame (event));
 506
 507                         if (!rl->empty()) {
 508                                 DescendingRegionLayerSorter cmp;
 509                                 rl->sort (cmp);
 510
 511                                 AudioRegionView* arv = atv->view->find_view (*(dynamic_cast<AudioRegion*> (rl->front())));
 512
 513                                 /* proxy */
 514
 515                                 delete rl;
 516
 517                                 return canvas_region_view_event (event, arv->get_canvas_group(), arv);
 518                         }
 519                 }
 520         }
 521
 522         return TRUE;
 523 }
 524
 525 bool
 526 Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
 527 {
 528         ItemType type;
 529
 530         switch (event->type) {
 531         case GDK_BUTTON_PRESS:
 532         case GDK_2BUTTON_PRESS:
 533         case GDK_3BUTTON_PRESS:
 534                 clicked_control_point = cp;
 535                 clicked_trackview = &cp->line.trackview;
 536                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 537                 clicked_regionview = 0;
 538                 break;
 539
 540         default:
 541                 break;
 542         }
 543
 544         if (dynamic_cast<AudioRegionGainLine*> (&cp->line) != 0) {
 545                 type = GainControlPointItem;
 546         } else if (dynamic_cast<AutomationGainLine*> (&cp->line) != 0) {
 547                 type = GainAutomationControlPointItem;
 548         } else if (dynamic_cast<AutomationPanLine*> (&cp->line) != 0) {
 549                 type = PanAutomationControlPointItem;
 550         } else if (dynamic_cast<RedirectAutomationLine*> (&cp->line) != 0) {
 551                 type = RedirectAutomationControlPointItem;
 552         } else {
 553                 return false;
 554         }
 555
 556         return typed_event (item, event, type);
 557 }
 558
 559 bool
 560 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
 561 {
 562         ItemType type;
 563
 564         if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
 565                 type = GainLineItem;
 566         } else if (dynamic_cast<AutomationGainLine*> (al) != 0) {
 567                 type = GainAutomationLineItem;
 568         } else if (dynamic_cast<AutomationPanLine*> (al) != 0) {
 569                 type = PanAutomationLineItem;
 570         } else if (dynamic_cast<RedirectAutomationLine*> (al) != 0) {
 571                 type = RedirectAutomationLineItem;
 572         } else {
 573                 return false;
 574         }
 575
 576         return typed_event (item, event, type);
 577 }
 578
 579 bool
 580 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 581 {
 582         bool ret = false;
 583
 584         switch (event->type) {
 585         case GDK_BUTTON_PRESS:
 586         case GDK_2BUTTON_PRESS:
 587         case GDK_3BUTTON_PRESS:
 588                 clicked_selection = rect->id;
 589                 ret = button_press_handler (item, event, SelectionItem);
 590                 break;
 591         case GDK_BUTTON_RELEASE:
 592                 ret = button_release_handler (item, event, SelectionItem);
 593                 break;
 594         case GDK_MOTION_NOTIFY:
 595                 ret = motion_handler (item, event, SelectionItem);
 596                 break;
 597                 /* Don't need these at the moment. */
 598         case GDK_ENTER_NOTIFY:
 599                 ret = enter_handler (item, event, SelectionItem);
 600                 break;
 601
 602         case GDK_LEAVE_NOTIFY:
 603                 ret = leave_handler (item, event, SelectionItem);
 604                 break;
 605
 606         default:
 607                 break;
 608         }
 609
 610         return ret;
 611 }
 612
 613 bool
 614 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 615 {
 616         bool ret = false;
 617
 618         switch (event->type) {
 619         case GDK_BUTTON_PRESS:
 620         case GDK_2BUTTON_PRESS:
 621         case GDK_3BUTTON_PRESS:
 622                 clicked_selection = rect->id;
 623                 ret = button_press_handler (item, event, StartSelectionTrimItem);
 624                 break;
 625         case GDK_BUTTON_RELEASE:
 626                 ret = button_release_handler (item, event, StartSelectionTrimItem);
 627                 break;
 628         case GDK_MOTION_NOTIFY:
 629                 ret = motion_handler (item, event, StartSelectionTrimItem);
 630                 break;
 631         case GDK_ENTER_NOTIFY:
 632                 ret = enter_handler (item, event, StartSelectionTrimItem);
 633                 break;
 634
 635         case GDK_LEAVE_NOTIFY:
 636                 ret = leave_handler (item, event, StartSelectionTrimItem);
 637                 break;
 638
 639         default:
 640                 break;
 641         }
 642
 643         return ret;
 644 }
 645
 646 bool
 647 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 648 {
 649         bool ret = false;
 650
 651         switch (event->type) {
 652         case GDK_BUTTON_PRESS:
 653         case GDK_2BUTTON_PRESS:
 654         case GDK_3BUTTON_PRESS:
 655                 clicked_selection = rect->id;
 656                 ret = button_press_handler (item, event, EndSelectionTrimItem);
 657                 break;
 658         case GDK_BUTTON_RELEASE:
 659                 ret = button_release_handler (item, event, EndSelectionTrimItem);
 660                 break;
 661         case GDK_MOTION_NOTIFY:
 662                 ret = motion_handler (item, event, EndSelectionTrimItem);
 663                 break;
 664         case GDK_ENTER_NOTIFY:
 665                 ret = enter_handler (item, event, EndSelectionTrimItem);
 666                 break;
 667
 668         case GDK_LEAVE_NOTIFY:
 669                 ret = leave_handler (item, event, EndSelectionTrimItem);
 670                 break;
 671
 672         default:
 673                 break;
 674         }
 675
 676         return ret;
 677 }
 678
 679
 680 bool
 681 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, AudioRegionView* rv)
 682 {
 683         bool ret = false;
 684
 685         switch (event->type) {
 686         case GDK_BUTTON_PRESS:
 687         case GDK_2BUTTON_PRESS:
 688         case GDK_3BUTTON_PRESS:
 689                 clicked_regionview = rv;
 690                 clicked_control_point = 0;
 691                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 692                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 693                 ret = button_press_handler (item, event, AudioRegionViewNameHighlight);
 694                 break;
 695         case GDK_BUTTON_RELEASE:
 696                 ret = button_release_handler (item, event, AudioRegionViewNameHighlight);
 697                 break;
 698         case GDK_MOTION_NOTIFY:
 699                 ret = motion_handler (item, event, AudioRegionViewNameHighlight);
 700                 break;
 701         case GDK_ENTER_NOTIFY:
 702                 ret = enter_handler (item, event, AudioRegionViewNameHighlight);
 703                 break;
 704
 705         case GDK_LEAVE_NOTIFY:
 706                 ret = leave_handler (item, event, AudioRegionViewNameHighlight);
 707                 break;
 708
 709         default:
 710                 break;
 711         }
 712
 713         return ret;
 714 }
 715
 716 bool
 717 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView* rv)
 718 {
 719         bool ret = false;
 720
 721         switch (event->type) {
 722         case GDK_BUTTON_PRESS:
 723         case GDK_2BUTTON_PRESS:
 724         case GDK_3BUTTON_PRESS:
 725                 clicked_regionview = rv;
 726                 clicked_control_point = 0;
 727                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 728                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 729                 ret = button_press_handler (item, event, AudioRegionViewName);
 730                 break;
 731         case GDK_BUTTON_RELEASE:
 732                 ret = button_release_handler (item, event, AudioRegionViewName);
 733                 break;
 734         case GDK_MOTION_NOTIFY:
 735                 ret = motion_handler (item, event, AudioRegionViewName);
 736                 break;
 737         case GDK_ENTER_NOTIFY:
 738                 ret = enter_handler (item, event, AudioRegionViewName);
 739                 break;
 740
 741         case GDK_LEAVE_NOTIFY:
 742                 ret = leave_handler (item, event, AudioRegionViewName);
 743                 break;
 744
 745         default:
 746                 break;
 747         }
 748
 749         return ret;
 750 }
 751
 752 bool
 753 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* marker)
 754 {
 755         return typed_event (item, event, MarkerItem);
 756 }
 757
 758 bool
 759 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 760 {
 761         return typed_event (item, event, MarkerBarItem);
 762 }
 763
 764 bool
 765 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 766 {
 767         return typed_event (item, event, RangeMarkerBarItem);
 768 }
 769
 770 bool
 771 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 772 {
 773         return typed_event (item, event, TransportMarkerBarItem);
 774 }
 775
 776 bool
 777 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* marker)
 778 {
 779         return typed_event (item, event, TempoMarkerItem);
 780 }
 781
 782 bool
 783 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* marker)
 784 {
 785         return typed_event (item, event, MeterMarkerItem);
 786 }
 787
 788 bool
 789 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 790 {
 791         return typed_event (item, event, TempoBarItem);
 792 }
 793
 794 bool
 795 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 796 {
 797         return typed_event (item, event, MeterBarItem);
 798 }
 799
 800 bool
 801 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 802 {
 803         return typed_event (item, event, PlayheadCursorItem);
 804 }
 805
 806 bool
 807 Editor::canvas_edit_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 808 {
 809         return typed_event (item, event, EditCursorItem);
 810 }
 811
 812 bool
 813 Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
 814 {
 815         return typed_event (item, event, NoItem);
 816 }
 817