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;
 517                         if ((pl = dynamic_cast<AudioPlaylist*> (atv->get_diskstream()->playlist())) != 0) {
 518
 519                                 Playlist::RegionList* rl = pl->regions_at (event_frame (event));
 520
 521                                 if (!rl->empty()) {
 522                                         DescendingRegionLayerSorter cmp;
 523                                         rl->sort (cmp);
 524
 525                                         AudioRegionView* arv = atv->view->find_view (*(dynamic_cast<AudioRegion*> (rl->front())));
 526
 527                                         /* proxy */
 528
 529                                         delete rl;
 530
 531                                         return canvas_region_view_event (event, arv->get_canvas_group(), arv);
 532                                 }
 533                         }
 534                 }
 535         }
 536
 537         return TRUE;
 538 }
 539
 540 bool
 541 Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
 542 {
 543         ItemType type;
 544
 545         switch (event->type) {
 546         case GDK_BUTTON_PRESS:
 547         case GDK_2BUTTON_PRESS:
 548         case GDK_3BUTTON_PRESS:
 549                 clicked_control_point = cp;
 550                 clicked_trackview = &cp->line.trackview;
 551                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 552                 clicked_regionview = 0;
 553                 break;
 554
 555         case GDK_SCROLL_UP:
 556                 break;
 557
 558         case GDK_SCROLL_DOWN:
 559                 break;
 560
 561         default:
 562                 break;
 563         }
 564
 565         if (dynamic_cast<AudioRegionGainLine*> (&cp->line) != 0) {
 566                 type = GainControlPointItem;
 567         } else if (dynamic_cast<AutomationGainLine*> (&cp->line) != 0) {
 568                 type = GainAutomationControlPointItem;
 569         } else if (dynamic_cast<AutomationPanLine*> (&cp->line) != 0) {
 570                 type = PanAutomationControlPointItem;
 571         } else if (dynamic_cast<RedirectAutomationLine*> (&cp->line) != 0) {
 572                 type = RedirectAutomationControlPointItem;
 573         } else {
 574                 return false;
 575         }
 576
 577         return typed_event (item, event, type);
 578 }
 579
 580 bool
 581 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
 582 {
 583         ItemType type;
 584
 585         if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
 586                 type = GainLineItem;
 587         } else if (dynamic_cast<AutomationGainLine*> (al) != 0) {
 588                 type = GainAutomationLineItem;
 589         } else if (dynamic_cast<AutomationPanLine*> (al) != 0) {
 590                 type = PanAutomationLineItem;
 591         } else if (dynamic_cast<RedirectAutomationLine*> (al) != 0) {
 592                 type = RedirectAutomationLineItem;
 593         } else {
 594                 return false;
 595         }
 596
 597         return typed_event (item, event, type);
 598 }
 599
 600 bool
 601 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 602 {
 603         bool ret = false;
 604
 605         switch (event->type) {
 606         case GDK_BUTTON_PRESS:
 607         case GDK_2BUTTON_PRESS:
 608         case GDK_3BUTTON_PRESS:
 609                 clicked_selection = rect->id;
 610                 ret = button_press_handler (item, event, SelectionItem);
 611                 break;
 612         case GDK_BUTTON_RELEASE:
 613                 ret = button_release_handler (item, event, SelectionItem);
 614                 break;
 615         case GDK_MOTION_NOTIFY:
 616                 ret = motion_handler (item, event, SelectionItem);
 617                 break;
 618                 /* Don't need these at the moment. */
 619         case GDK_ENTER_NOTIFY:
 620                 ret = enter_handler (item, event, SelectionItem);
 621                 break;
 622
 623         case GDK_LEAVE_NOTIFY:
 624                 ret = leave_handler (item, event, SelectionItem);
 625                 break;
 626
 627         default:
 628                 break;
 629         }
 630
 631         return ret;
 632 }
 633
 634 bool
 635 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 636 {
 637         bool ret = false;
 638
 639         switch (event->type) {
 640         case GDK_BUTTON_PRESS:
 641         case GDK_2BUTTON_PRESS:
 642         case GDK_3BUTTON_PRESS:
 643                 clicked_selection = rect->id;
 644                 ret = button_press_handler (item, event, StartSelectionTrimItem);
 645                 break;
 646         case GDK_BUTTON_RELEASE:
 647                 ret = button_release_handler (item, event, StartSelectionTrimItem);
 648                 break;
 649         case GDK_MOTION_NOTIFY:
 650                 ret = motion_handler (item, event, StartSelectionTrimItem);
 651                 break;
 652         case GDK_ENTER_NOTIFY:
 653                 ret = enter_handler (item, event, StartSelectionTrimItem);
 654                 break;
 655
 656         case GDK_LEAVE_NOTIFY:
 657                 ret = leave_handler (item, event, StartSelectionTrimItem);
 658                 break;
 659
 660         default:
 661                 break;
 662         }
 663
 664         return ret;
 665 }
 666
 667 bool
 668 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 669 {
 670         bool ret = false;
 671
 672         switch (event->type) {
 673         case GDK_BUTTON_PRESS:
 674         case GDK_2BUTTON_PRESS:
 675         case GDK_3BUTTON_PRESS:
 676                 clicked_selection = rect->id;
 677                 ret = button_press_handler (item, event, EndSelectionTrimItem);
 678                 break;
 679         case GDK_BUTTON_RELEASE:
 680                 ret = button_release_handler (item, event, EndSelectionTrimItem);
 681                 break;
 682         case GDK_MOTION_NOTIFY:
 683                 ret = motion_handler (item, event, EndSelectionTrimItem);
 684                 break;
 685         case GDK_ENTER_NOTIFY:
 686                 ret = enter_handler (item, event, EndSelectionTrimItem);
 687                 break;
 688
 689         case GDK_LEAVE_NOTIFY:
 690                 ret = leave_handler (item, event, EndSelectionTrimItem);
 691                 break;
 692
 693         default:
 694                 break;
 695         }
 696
 697         return ret;
 698 }
 699
 700
 701 bool
 702 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, AudioRegionView* rv)
 703 {
 704         bool ret = false;
 705
 706         switch (event->type) {
 707         case GDK_BUTTON_PRESS:
 708         case GDK_2BUTTON_PRESS:
 709         case GDK_3BUTTON_PRESS:
 710                 clicked_regionview = rv;
 711                 clicked_control_point = 0;
 712                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 713                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 714                 ret = button_press_handler (item, event, AudioRegionViewNameHighlight);
 715                 break;
 716         case GDK_BUTTON_RELEASE:
 717                 ret = button_release_handler (item, event, AudioRegionViewNameHighlight);
 718                 break;
 719         case GDK_MOTION_NOTIFY:
 720                 ret = motion_handler (item, event, AudioRegionViewNameHighlight);
 721                 break;
 722         case GDK_ENTER_NOTIFY:
 723                 ret = enter_handler (item, event, AudioRegionViewNameHighlight);
 724                 break;
 725
 726         case GDK_LEAVE_NOTIFY:
 727                 ret = leave_handler (item, event, AudioRegionViewNameHighlight);
 728                 break;
 729
 730         default:
 731                 break;
 732         }
 733
 734         return ret;
 735 }
 736
 737 bool
 738 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView* rv)
 739 {
 740         bool ret = false;
 741
 742         switch (event->type) {
 743         case GDK_BUTTON_PRESS:
 744         case GDK_2BUTTON_PRESS:
 745         case GDK_3BUTTON_PRESS:
 746                 clicked_regionview = rv;
 747                 clicked_control_point = 0;
 748                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 749                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 750                 ret = button_press_handler (item, event, AudioRegionViewName);
 751                 break;
 752         case GDK_BUTTON_RELEASE:
 753                 ret = button_release_handler (item, event, AudioRegionViewName);
 754                 break;
 755         case GDK_MOTION_NOTIFY:
 756                 ret = motion_handler (item, event, AudioRegionViewName);
 757                 break;
 758         case GDK_ENTER_NOTIFY:
 759                 ret = enter_handler (item, event, AudioRegionViewName);
 760                 break;
 761
 762         case GDK_LEAVE_NOTIFY:
 763                 ret = leave_handler (item, event, AudioRegionViewName);
 764                 break;
 765
 766         default:
 767                 break;
 768         }
 769
 770         return ret;
 771 }
 772
 773 bool
 774 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* marker)
 775 {
 776         return typed_event (item, event, MarkerItem);
 777 }
 778
 779 bool
 780 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 781 {
 782         return typed_event (item, event, MarkerBarItem);
 783 }
 784
 785 bool
 786 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 787 {
 788         return typed_event (item, event, RangeMarkerBarItem);
 789 }
 790
 791 bool
 792 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 793 {
 794         return typed_event (item, event, TransportMarkerBarItem);
 795 }
 796
 797 bool
 798 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* marker)
 799 {
 800         return typed_event (item, event, TempoMarkerItem);
 801 }
 802
 803 bool
 804 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* marker)
 805 {
 806         return typed_event (item, event, MeterMarkerItem);
 807 }
 808
 809 bool
 810 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 811 {
 812         return typed_event (item, event, TempoBarItem);
 813 }
 814
 815 bool
 816 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 817 {
 818         return typed_event (item, event, MeterBarItem);
 819 }
 820
 821 bool
 822 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 823 {
 824         return typed_event (item, event, PlayheadCursorItem);
 825 }
 826
 827 bool
 828 Editor::canvas_edit_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 829 {
 830         return typed_event (item, event, EditCursorItem);
 831 }
 832
 833 bool
 834 Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
 835 {
 836         return typed_event (item, event, NoItem);
 837 }
 838