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