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