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