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
  23 #include <ardour/audio_diskstream.h>
  24 #include <ardour/audioplaylist.h>
  25
  26 #include "editor.h"
  27 #include "keyboard.h"
  28 #include "public_editor.h"
  29 #include "audio_region_view.h"
  30 #include "audio_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                         nframes_t where = event_frame (&event, 0, 0);
  74                         temporal_zoom_to_frame (false, 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 = 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                         nframes_t where = event_frame (&event, 0, 0);
 105                         temporal_zoom_to_frame (true, 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 = 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, RegionView *rv)
 216 {
 217         bool ret = false;
 218
 219         if (!rv->sensitive ()) {
 220                 return false;
 221         }
 222
 223         switch (event->type) {
 224         case GDK_BUTTON_PRESS:
 225         case GDK_2BUTTON_PRESS:
 226         case GDK_3BUTTON_PRESS:
 227                 clicked_regionview = rv;
 228                 clicked_control_point = 0;
 229                 clicked_trackview = &rv->get_time_axis_view();
 230                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 231                 ret = button_press_handler (item, event, RegionItem);
 232                 break;
 233
 234         case GDK_BUTTON_RELEASE:
 235                 ret = button_release_handler (item, event, RegionItem);
 236                 break;
 237
 238         case GDK_MOTION_NOTIFY:
 239                 ret = motion_handler (item, event, RegionItem);
 240                 break;
 241
 242         case GDK_ENTER_NOTIFY:
 243                 set_entered_regionview (rv);
 244                 break;
 245
 246         case GDK_LEAVE_NOTIFY:
 247                 set_entered_regionview (0);
 248                 break;
 249
 250         default:
 251                 break;
 252         }
 253
 254         return ret;
 255 }
 256
 257 bool
 258 Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, RouteTimeAxisView *tv)
 259 {
 260         bool ret = FALSE;
 261
 262         switch (event->type) {
 263         case GDK_BUTTON_PRESS:
 264         case GDK_2BUTTON_PRESS:
 265         case GDK_3BUTTON_PRESS:
 266                 clicked_regionview = 0;
 267                 clicked_control_point = 0;
 268                 clicked_trackview = tv;
 269                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(tv);
 270                 ret = button_press_handler (item, event, StreamItem);
 271                 break;
 272
 273         case GDK_BUTTON_RELEASE:
 274                 ret = button_release_handler (item, event, StreamItem);
 275                 break;
 276
 277         case GDK_MOTION_NOTIFY:
 278                 ret = motion_handler (item, event, StreamItem);
 279                 break;
 280
 281         case GDK_ENTER_NOTIFY:
 282                 break;
 283
 284         default:
 285                 break;
 286         }
 287
 288         return ret;
 289 }
 290
 291
 292
 293 bool
 294 Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
 295 {
 296         bool ret = false;
 297
 298         switch (event->type) {
 299         case GDK_BUTTON_PRESS:
 300         case GDK_2BUTTON_PRESS:
 301         case GDK_3BUTTON_PRESS:
 302                 clicked_regionview = 0;
 303                 clicked_control_point = 0;
 304                 clicked_trackview = atv;
 305                 clicked_audio_trackview = 0;
 306                 ret = button_press_handler (item, event, AutomationTrackItem);
 307                 break;
 308
 309         case GDK_BUTTON_RELEASE:
 310                 ret = button_release_handler (item, event, AutomationTrackItem);
 311                 break;
 312
 313         case GDK_MOTION_NOTIFY:
 314                 ret = motion_handler (item, event, AutomationTrackItem);
 315                 break;
 316
 317         case GDK_ENTER_NOTIFY:
 318                 ret = enter_handler (item, event, AutomationTrackItem);
 319                 break;
 320
 321         case GDK_LEAVE_NOTIFY:
 322                 ret = leave_handler (item, event, AutomationTrackItem);
 323                 break;
 324
 325         default:
 326                 break;
 327         }
 328
 329         return ret;
 330 }
 331
 332 bool
 333 Editor::canvas_fade_in_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 334 {
 335         /* we handle only button 3 press/release events */
 336
 337         if (!rv->sensitive()) {
 338                 return false;
 339         }
 340
 341         switch (event->type) {
 342         case GDK_BUTTON_PRESS:
 343                 clicked_regionview = rv;
 344                 clicked_control_point = 0;
 345                 clicked_trackview = &rv->get_time_axis_view();
 346                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 347                 if (event->button.button == 3) {
 348                         return button_press_handler (item, event, FadeInItem);
 349                 }
 350                 break;
 351
 352         case GDK_BUTTON_RELEASE:
 353                 if (event->button.button == 3) {
 354                         return button_release_handler (item, event, FadeInItem);
 355                 }
 356                 break;
 357
 358         default:
 359                 break;
 360
 361         }
 362
 363         /* proxy for the regionview */
 364
 365         return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 366 }
 367
 368 bool
 369 Editor::canvas_fade_in_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 370 {
 371         bool ret = false;
 372
 373         if (!rv->sensitive()) {
 374                 return false;
 375         }
 376
 377         switch (event->type) {
 378         case GDK_BUTTON_PRESS:
 379         case GDK_2BUTTON_PRESS:
 380         case GDK_3BUTTON_PRESS:
 381                 clicked_regionview = rv;
 382                 clicked_control_point = 0;
 383                 clicked_trackview = &rv->get_time_axis_view();
 384                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 385                 ret = button_press_handler (item, event, FadeInHandleItem);
 386                 break;
 387
 388         case GDK_BUTTON_RELEASE:
 389                 ret = button_release_handler (item, event, FadeInHandleItem);
 390                 break;
 391
 392         case GDK_MOTION_NOTIFY:
 393                 ret = motion_handler (item, event, FadeInHandleItem);
 394                 break;
 395
 396         case GDK_ENTER_NOTIFY:
 397                 ret = enter_handler (item, event, FadeInHandleItem);
 398                 break;
 399
 400         case GDK_LEAVE_NOTIFY:
 401                 ret = leave_handler (item, event, FadeInHandleItem);
 402                 break;
 403
 404         default:
 405                 break;
 406         }
 407
 408         return ret;
 409 }
 410
 411 bool
 412 Editor::canvas_fade_out_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 413 {
 414         /* we handle only button 3 press/release events */
 415
 416         if (!rv->sensitive()) {
 417                 return false;
 418         }
 419
 420         switch (event->type) {
 421         case GDK_BUTTON_PRESS:
 422                 clicked_regionview = rv;
 423                 clicked_control_point = 0;
 424                 clicked_trackview = &rv->get_time_axis_view();
 425                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 426                 if (event->button.button == 3) {
 427                         return button_press_handler (item, event, FadeOutItem);
 428                 }
 429                 break;
 430
 431         case GDK_BUTTON_RELEASE:
 432                 if (event->button.button == 3) {
 433                         return button_release_handler (item, event, FadeOutItem);
 434                 }
 435                 break;
 436
 437         default:
 438                 break;
 439
 440         }
 441
 442         /* proxy for the regionview */
 443
 444         return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 445 }
 446
 447 bool
 448 Editor::canvas_fade_out_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
 449 {
 450         bool ret = false;
 451
 452         if (!rv->sensitive()) {
 453                 return false;
 454         }
 455
 456         switch (event->type) {
 457         case GDK_BUTTON_PRESS:
 458         case GDK_2BUTTON_PRESS:
 459         case GDK_3BUTTON_PRESS:
 460                 clicked_regionview = rv;
 461                 clicked_control_point = 0;
 462                 clicked_trackview = &rv->get_time_axis_view();
 463                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 464                 ret = button_press_handler (item, event, FadeOutHandleItem);
 465                 break;
 466
 467         case GDK_BUTTON_RELEASE:
 468                 ret = button_release_handler (item, event, FadeOutHandleItem);
 469                 break;
 470
 471         case GDK_MOTION_NOTIFY:
 472                 ret = motion_handler (item, event, FadeOutHandleItem);
 473                 break;
 474
 475         case GDK_ENTER_NOTIFY:
 476                 ret = enter_handler (item, event, FadeOutHandleItem);
 477                 break;
 478
 479         case GDK_LEAVE_NOTIFY:
 480                 ret = leave_handler (item, event, FadeOutHandleItem);
 481                 break;
 482
 483         default:
 484                 break;
 485         }
 486
 487         return ret;
 488 }
 489
 490 struct DescendingRegionLayerSorter {
 491     bool operator()(boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
 492             return a->layer() > b->layer();
 493     }
 494 };
 495
 496 bool
 497 Editor::canvas_crossfade_view_event (GdkEvent* event, ArdourCanvas::Item* item, CrossfadeView* xfv)
 498 {
 499         /* we handle only button 3 press/release events */
 500
 501         switch (event->type) {
 502         case GDK_BUTTON_PRESS:
 503                 clicked_crossfadeview = xfv;
 504                 clicked_trackview = &clicked_crossfadeview->get_time_axis_view();
 505                 if (event->button.button == 3) {
 506                         return button_press_handler (item, event, CrossfadeViewItem);
 507                 }
 508                 break;
 509
 510         case GDK_BUTTON_RELEASE:
 511                 if (event->button.button == 3) {
 512                         bool ret = button_release_handler (item, event, CrossfadeViewItem);
 513                         return ret;
 514                 }
 515                 break;
 516
 517         default:
 518                 break;
 519
 520         }
 521
 522
 523         /* proxy for the upper most regionview */
 524
 525         /* XXX really need to check if we are in the name highlight,
 526            and proxy to that when required.
 527         */
 528
 529         TimeAxisView& tv (xfv->get_time_axis_view());
 530         AudioTimeAxisView* atv;
 531
 532         if ((atv = dynamic_cast<AudioTimeAxisView*>(&tv)) != 0) {
 533
 534                 if (atv->is_audio_track()) {
 535
 536                         boost::shared_ptr<AudioPlaylist> pl;
 537                         if ((pl = boost::dynamic_pointer_cast<AudioPlaylist> (atv->get_diskstream()->playlist())) != 0) {
 538
 539                                 Playlist::RegionList* rl = pl->regions_at (event_frame (event));
 540
 541                                 if (!rl->empty()) {
 542                                         DescendingRegionLayerSorter cmp;
 543                                         rl->sort (cmp);
 544
 545                                         RegionView* rv = atv->view()->find_view (rl->front());
 546
 547                                         /* proxy */
 548
 549                                         delete rl;
 550
 551                                         return canvas_region_view_event (event, rv->get_canvas_group(), rv);
 552                                 }
 553                         }
 554                 }
 555         }
 556
 557         return TRUE;
 558 }
 559
 560 bool
 561 Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
 562 {
 563         ItemType type;
 564
 565         switch (event->type) {
 566         case GDK_BUTTON_PRESS:
 567         case GDK_2BUTTON_PRESS:
 568         case GDK_3BUTTON_PRESS:
 569                 clicked_control_point = cp;
 570                 clicked_trackview = &cp->line.trackview;
 571                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 572                 clicked_regionview = 0;
 573                 break;
 574
 575         case GDK_SCROLL_UP:
 576                 break;
 577
 578         case GDK_SCROLL_DOWN:
 579                 break;
 580
 581         default:
 582                 break;
 583         }
 584
 585         if (dynamic_cast<AudioRegionGainLine*> (&cp->line) != 0) {
 586                 type = GainControlPointItem;
 587         } else if (dynamic_cast<AutomationGainLine*> (&cp->line) != 0) {
 588                 type = GainAutomationControlPointItem;
 589         } else if (dynamic_cast<AutomationPanLine*> (&cp->line) != 0) {
 590                 type = PanAutomationControlPointItem;
 591         } else if (dynamic_cast<RedirectAutomationLine*> (&cp->line) != 0) {
 592                 type = RedirectAutomationControlPointItem;
 593         } else {
 594                 return false;
 595         }
 596
 597         return typed_event (item, event, type);
 598 }
 599
 600 bool
 601 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
 602 {
 603         ItemType type;
 604
 605         if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
 606                 type = GainLineItem;
 607         } else if (dynamic_cast<AutomationGainLine*> (al) != 0) {
 608                 type = GainAutomationLineItem;
 609         } else if (dynamic_cast<AutomationPanLine*> (al) != 0) {
 610                 type = PanAutomationLineItem;
 611         } else if (dynamic_cast<RedirectAutomationLine*> (al) != 0) {
 612                 type = RedirectAutomationLineItem;
 613         } else {
 614                 return false;
 615         }
 616
 617         return typed_event (item, event, type);
 618 }
 619
 620 bool
 621 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 622 {
 623         bool ret = false;
 624
 625         switch (event->type) {
 626         case GDK_BUTTON_PRESS:
 627         case GDK_2BUTTON_PRESS:
 628         case GDK_3BUTTON_PRESS:
 629                 clicked_selection = rect->id;
 630                 ret = button_press_handler (item, event, SelectionItem);
 631                 break;
 632         case GDK_BUTTON_RELEASE:
 633                 ret = button_release_handler (item, event, SelectionItem);
 634                 break;
 635         case GDK_MOTION_NOTIFY:
 636                 ret = motion_handler (item, event, SelectionItem);
 637                 break;
 638                 /* Don't need these at the moment. */
 639         case GDK_ENTER_NOTIFY:
 640                 ret = enter_handler (item, event, SelectionItem);
 641                 break;
 642
 643         case GDK_LEAVE_NOTIFY:
 644                 ret = leave_handler (item, event, SelectionItem);
 645                 break;
 646
 647         default:
 648                 break;
 649         }
 650
 651         return ret;
 652 }
 653
 654 bool
 655 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 656 {
 657         bool ret = false;
 658
 659         switch (event->type) {
 660         case GDK_BUTTON_PRESS:
 661         case GDK_2BUTTON_PRESS:
 662         case GDK_3BUTTON_PRESS:
 663                 clicked_selection = rect->id;
 664                 ret = button_press_handler (item, event, StartSelectionTrimItem);
 665                 break;
 666         case GDK_BUTTON_RELEASE:
 667                 ret = button_release_handler (item, event, StartSelectionTrimItem);
 668                 break;
 669         case GDK_MOTION_NOTIFY:
 670                 ret = motion_handler (item, event, StartSelectionTrimItem);
 671                 break;
 672         case GDK_ENTER_NOTIFY:
 673                 ret = enter_handler (item, event, StartSelectionTrimItem);
 674                 break;
 675
 676         case GDK_LEAVE_NOTIFY:
 677                 ret = leave_handler (item, event, StartSelectionTrimItem);
 678                 break;
 679
 680         default:
 681                 break;
 682         }
 683
 684         return ret;
 685 }
 686
 687 bool
 688 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 689 {
 690         bool ret = false;
 691
 692         switch (event->type) {
 693         case GDK_BUTTON_PRESS:
 694         case GDK_2BUTTON_PRESS:
 695         case GDK_3BUTTON_PRESS:
 696                 clicked_selection = rect->id;
 697                 ret = button_press_handler (item, event, EndSelectionTrimItem);
 698                 break;
 699         case GDK_BUTTON_RELEASE:
 700                 ret = button_release_handler (item, event, EndSelectionTrimItem);
 701                 break;
 702         case GDK_MOTION_NOTIFY:
 703                 ret = motion_handler (item, event, EndSelectionTrimItem);
 704                 break;
 705         case GDK_ENTER_NOTIFY:
 706                 ret = enter_handler (item, event, EndSelectionTrimItem);
 707                 break;
 708
 709         case GDK_LEAVE_NOTIFY:
 710                 ret = leave_handler (item, event, EndSelectionTrimItem);
 711                 break;
 712
 713         default:
 714                 break;
 715         }
 716
 717         return ret;
 718 }
 719
 720
 721 bool
 722 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
 723 {
 724         bool ret = false;
 725
 726         if (!rv->sensitive()) {
 727                 return false;
 728         }
 729
 730         switch (event->type) {
 731         case GDK_BUTTON_PRESS:
 732         case GDK_2BUTTON_PRESS:
 733         case GDK_3BUTTON_PRESS:
 734                 clicked_regionview = rv;
 735                 clicked_control_point = 0;
 736                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 737                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 738                 ret = button_press_handler (item, event, RegionViewNameHighlight);
 739                 break;
 740         case GDK_BUTTON_RELEASE:
 741                 ret = button_release_handler (item, event, RegionViewNameHighlight);
 742                 break;
 743         case GDK_MOTION_NOTIFY:
 744                 ret = motion_handler (item, event, RegionViewNameHighlight);
 745                 break;
 746         case GDK_ENTER_NOTIFY:
 747                 ret = enter_handler (item, event, RegionViewNameHighlight);
 748                 break;
 749
 750         case GDK_LEAVE_NOTIFY:
 751                 ret = leave_handler (item, event, RegionViewNameHighlight);
 752                 break;
 753
 754         default:
 755                 break;
 756         }
 757
 758         return ret;
 759 }
 760
 761 bool
 762 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
 763 {
 764         bool ret = false;
 765
 766         if (!rv->sensitive()) {
 767                 return false;
 768         }
 769
 770         switch (event->type) {
 771         case GDK_BUTTON_PRESS:
 772         case GDK_2BUTTON_PRESS:
 773         case GDK_3BUTTON_PRESS:
 774                 clicked_regionview = rv;
 775                 clicked_control_point = 0;
 776                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 777                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 778                 ret = button_press_handler (item, event, RegionViewName);
 779                 break;
 780         case GDK_BUTTON_RELEASE:
 781                 ret = button_release_handler (item, event, RegionViewName);
 782                 break;
 783         case GDK_MOTION_NOTIFY:
 784                 ret = motion_handler (item, event, RegionViewName);
 785                 break;
 786         case GDK_ENTER_NOTIFY:
 787                 ret = enter_handler (item, event, RegionViewName);
 788                 break;
 789
 790         case GDK_LEAVE_NOTIFY:
 791                 ret = leave_handler (item, event, RegionViewName);
 792                 break;
 793
 794         default:
 795                 break;
 796         }
 797
 798         return ret;
 799 }
 800
 801 bool
 802 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* marker)
 803 {
 804         return typed_event (item, event, MarkerItem);
 805 }
 806
 807 bool
 808 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 809 {
 810         return typed_event (item, event, MarkerBarItem);
 811 }
 812
 813 bool
 814 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 815 {
 816         return typed_event (item, event, RangeMarkerBarItem);
 817 }
 818
 819 bool
 820 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 821 {
 822         return typed_event (item, event, TransportMarkerBarItem);
 823 }
 824
 825 bool
 826 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* marker)
 827 {
 828         return typed_event (item, event, TempoMarkerItem);
 829 }
 830
 831 bool
 832 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* marker)
 833 {
 834         return typed_event (item, event, MeterMarkerItem);
 835 }
 836
 837 bool
 838 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 839 {
 840         return typed_event (item, event, TempoBarItem);
 841 }
 842
 843 bool
 844 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 845 {
 846         return typed_event (item, event, MeterBarItem);
 847 }
 848
 849 bool
 850 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 851 {
 852         return typed_event (item, event, PlayheadCursorItem);
 853 }
 854
 855 bool
 856 Editor::canvas_edit_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 857 {
 858         return typed_event (item, event, EditCursorItem);
 859 }
 860
 861 bool
 862 Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
 863 {
 864         return typed_event (item, event, NoItem);
 865 }
 866