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 "canvas_impl.h"
  40 #include "simplerect.h"
  41
  42 #include "i18n.h"
  43
  44 using namespace sigc;
  45 using namespace ARDOUR;
  46 using namespace PBD;
  47 using namespace Gtk;
  48
  49 bool
  50 Editor::track_canvas_scroll (GdkEventScroll* ev)
  51 {
  52         int x, y;
  53         double wx, wy;
  54
  55         switch (ev->direction) {
  56         case GDK_SCROLL_UP:
  57                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
  58                         //if (ev->state == GDK_CONTROL_MASK) {
  59                         /* XXX
  60                            the ev->x will be out of step with the canvas
  61                            if we're in mid zoom, so we have to get the damn mouse
  62                            pointer again
  63                         */
  64                         track_canvas.get_pointer (x, y);
  65                         track_canvas.window_to_world (x, y, wx, wy);
  66                         wx += horizontal_adjustment.get_value();
  67                         wy += vertical_adjustment.get_value();
  68
  69                         GdkEvent event;
  70                         event.type = GDK_BUTTON_RELEASE;
  71                         event.button.x = wx;
  72                         event.button.y = wy;
  73
  74                         nframes_t where = event_frame (&event, 0, 0);
  75                         temporal_zoom_to_frame (false, where);
  76                         return true;
  77                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
  78                         if (!current_stepping_trackview) {
  79                                 step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
  80                                 if (!(current_stepping_trackview = trackview_by_y_position (ev->y))) {
  81                                         return false;
  82                                 }
  83                         }
  84                         gettimeofday (&last_track_height_step_timestamp, 0);
  85                         current_stepping_trackview->step_height (true);
  86                         return true;
  87                 } else {
  88                         scroll_tracks_up_line ();
  89                         return true;
  90                 }
  91                 break;
  92         case GDK_SCROLL_DOWN:
  93                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
  94                         //if (ev->state == GDK_CONTROL_MASK) {
  95                         track_canvas.get_pointer (x, y);
  96                         track_canvas.window_to_world (x, y, wx, wy);
  97                         wx += horizontal_adjustment.get_value();
  98                         wy += vertical_adjustment.get_value();
  99
 100                         GdkEvent event;
 101                         event.type = GDK_BUTTON_RELEASE;
 102                         event.button.x = wx;
 103                         event.button.y = wy;
 104
 105                         nframes_t where = event_frame (&event, 0, 0);
 106                         temporal_zoom_to_frame (true, where);
 107                         return true;
 108                 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
 109                         if (!current_stepping_trackview) {
 110                                 step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
 111                                 if (!(current_stepping_trackview = trackview_by_y_position (ev->y))) {
 112                                         return false;
 113                                 }
 114                         }
 115                         gettimeofday (&last_track_height_step_timestamp, 0);
 116                         current_stepping_trackview->step_height (false);
 117                         return true;
 118                 } else {
 119                         scroll_tracks_down_line ();
 120                         return true;
 121                 }
 122                 break;
 123
 124         default:
 125                 /* no left/right handling yet */
 126                 break;
 127         }
 128
 129         return false;
 130 }
 131
 132 bool
 133 Editor::track_canvas_scroll_event (GdkEventScroll *event)
 134 {
 135         track_canvas.grab_focus();
 136         track_canvas_scroll (event);
 137         return false;
 138 }
 139
 140 bool
 141 Editor::track_canvas_button_press_event (GdkEventButton *event)
 142 {
 143         track_canvas.grab_focus();
 144         return false;
 145 }
 146
 147 bool
 148 Editor::track_canvas_button_release_event (GdkEventButton *event)
 149 {
 150         if (drag_info.item) {
 151                 end_grab (drag_info.item, (GdkEvent*) event);
 152         }
 153         return false;
 154 }
 155
 156 bool
 157 Editor::track_canvas_motion_notify_event (GdkEventMotion *event)
 158 {
 159         int x, y;
 160         /* keep those motion events coming */
 161         track_canvas.get_pointer (x, y);
 162         return false;
 163 }
 164
 165 bool
 166 Editor::track_canvas_motion (GdkEvent *ev)
 167 {
 168         if (verbose_cursor_visible) {
 169                 verbose_canvas_cursor->property_x() = ev->motion.x + 20;
 170                 verbose_canvas_cursor->property_y() = ev->motion.y + 20;
 171         }
 172         return false;
 173 }
 174
 175 bool
 176 Editor::typed_event (ArdourCanvas::Item* item, GdkEvent *event, ItemType type)
 177 {
 178         gint ret = FALSE;
 179
 180         switch (event->type) {
 181         case GDK_BUTTON_PRESS:
 182         case GDK_2BUTTON_PRESS:
 183         case GDK_3BUTTON_PRESS:
 184                 ret = button_press_handler (item, event, type);
 185                 break;
 186         case GDK_BUTTON_RELEASE:
 187                 ret = button_release_handler (item, event, type);
 188                 break;
 189         case GDK_MOTION_NOTIFY:
 190                 ret = motion_handler (item, event, type);
 191                 break;
 192
 193         case GDK_ENTER_NOTIFY:
 194                 ret = enter_handler (item, event, type);
 195                 break;
 196
 197         case GDK_LEAVE_NOTIFY:
 198                 ret = leave_handler (item, event, type);
 199                 break;
 200
 201         default:
 202                 break;
 203         }
 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                 }
 556         }
 557
 558         return TRUE;
 559 }
 560
 561 bool
 562 Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
 563 {
 564         switch (event->type) {
 565         case GDK_BUTTON_PRESS:
 566         case GDK_2BUTTON_PRESS:
 567         case GDK_3BUTTON_PRESS:
 568                 clicked_control_point = cp;
 569                 clicked_axisview = &cp->line.trackview;
 570                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 571                 clicked_regionview = 0;
 572                 break;
 573
 574         case GDK_SCROLL_UP:
 575                 break;
 576
 577         case GDK_SCROLL_DOWN:
 578                 break;
 579
 580         default:
 581                 break;
 582         }
 583
 584         return typed_event (item, event, ControlPointItem);
 585 }
 586
 587 bool
 588 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
 589 {
 590         ItemType type;
 591
 592         if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
 593                 type = GainLineItem;
 594         } else {
 595                 type = AutomationLineItem;
 596         }
 597
 598         return typed_event (item, event, type);
 599 }
 600
 601 bool
 602 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 603 {
 604         bool ret = false;
 605
 606         switch (event->type) {
 607         case GDK_BUTTON_PRESS:
 608         case GDK_2BUTTON_PRESS:
 609         case GDK_3BUTTON_PRESS:
 610                 clicked_selection = rect->id;
 611                 ret = button_press_handler (item, event, SelectionItem);
 612                 break;
 613         case GDK_BUTTON_RELEASE:
 614                 ret = button_release_handler (item, event, SelectionItem);
 615                 break;
 616         case GDK_MOTION_NOTIFY:
 617                 ret = motion_handler (item, event, SelectionItem);
 618                 break;
 619                 /* Don't need these at the moment. */
 620         case GDK_ENTER_NOTIFY:
 621                 ret = enter_handler (item, event, SelectionItem);
 622                 break;
 623
 624         case GDK_LEAVE_NOTIFY:
 625                 ret = leave_handler (item, event, SelectionItem);
 626                 break;
 627
 628         default:
 629                 break;
 630         }
 631
 632         return ret;
 633 }
 634
 635 bool
 636 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 637 {
 638         bool ret = false;
 639
 640         switch (event->type) {
 641         case GDK_BUTTON_PRESS:
 642         case GDK_2BUTTON_PRESS:
 643         case GDK_3BUTTON_PRESS:
 644                 clicked_selection = rect->id;
 645                 ret = button_press_handler (item, event, StartSelectionTrimItem);
 646                 break;
 647         case GDK_BUTTON_RELEASE:
 648                 ret = button_release_handler (item, event, StartSelectionTrimItem);
 649                 break;
 650         case GDK_MOTION_NOTIFY:
 651                 ret = motion_handler (item, event, StartSelectionTrimItem);
 652                 break;
 653         case GDK_ENTER_NOTIFY:
 654                 ret = enter_handler (item, event, StartSelectionTrimItem);
 655                 break;
 656
 657         case GDK_LEAVE_NOTIFY:
 658                 ret = leave_handler (item, event, StartSelectionTrimItem);
 659                 break;
 660
 661         default:
 662                 break;
 663         }
 664
 665         return ret;
 666 }
 667
 668 bool
 669 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 670 {
 671         bool ret = false;
 672
 673         switch (event->type) {
 674         case GDK_BUTTON_PRESS:
 675         case GDK_2BUTTON_PRESS:
 676         case GDK_3BUTTON_PRESS:
 677                 clicked_selection = rect->id;
 678                 ret = button_press_handler (item, event, EndSelectionTrimItem);
 679                 break;
 680         case GDK_BUTTON_RELEASE:
 681                 ret = button_release_handler (item, event, EndSelectionTrimItem);
 682                 break;
 683         case GDK_MOTION_NOTIFY:
 684                 ret = motion_handler (item, event, EndSelectionTrimItem);
 685                 break;
 686         case GDK_ENTER_NOTIFY:
 687                 ret = enter_handler (item, event, EndSelectionTrimItem);
 688                 break;
 689
 690         case GDK_LEAVE_NOTIFY:
 691                 ret = leave_handler (item, event, EndSelectionTrimItem);
 692                 break;
 693
 694         default:
 695                 break;
 696         }
 697
 698         return ret;
 699 }
 700
 701
 702 bool
 703 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
 704 {
 705         bool ret = false;
 706
 707         if (!rv->sensitive()) {
 708                 return false;
 709         }
 710
 711         switch (event->type) {
 712         case GDK_BUTTON_PRESS:
 713         case GDK_2BUTTON_PRESS:
 714         case GDK_3BUTTON_PRESS:
 715                 clicked_regionview = rv;
 716                 clicked_control_point = 0;
 717                 clicked_axisview = &clicked_regionview->get_time_axis_view();
 718                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 719                 ret = button_press_handler (item, event, RegionViewNameHighlight);
 720                 break;
 721         case GDK_BUTTON_RELEASE:
 722                 ret = button_release_handler (item, event, RegionViewNameHighlight);
 723                 break;
 724         case GDK_MOTION_NOTIFY:
 725                 ret = motion_handler (item, event, RegionViewNameHighlight);
 726                 break;
 727         case GDK_ENTER_NOTIFY:
 728                 ret = enter_handler (item, event, RegionViewNameHighlight);
 729                 break;
 730
 731         case GDK_LEAVE_NOTIFY:
 732                 ret = leave_handler (item, event, RegionViewNameHighlight);
 733                 break;
 734
 735         default:
 736                 break;
 737         }
 738
 739         return ret;
 740 }
 741
 742 bool
 743 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
 744 {
 745         bool ret = false;
 746
 747         if (!rv->sensitive()) {
 748                 return false;
 749         }
 750
 751         switch (event->type) {
 752         case GDK_BUTTON_PRESS:
 753         case GDK_2BUTTON_PRESS:
 754         case GDK_3BUTTON_PRESS:
 755                 clicked_regionview = rv;
 756                 clicked_control_point = 0;
 757                 clicked_axisview = &clicked_regionview->get_time_axis_view();
 758                 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
 759                 ret = button_press_handler (item, event, RegionViewName);
 760                 break;
 761         case GDK_BUTTON_RELEASE:
 762                 ret = button_release_handler (item, event, RegionViewName);
 763                 break;
 764         case GDK_MOTION_NOTIFY:
 765                 ret = motion_handler (item, event, RegionViewName);
 766                 break;
 767         case GDK_ENTER_NOTIFY:
 768                 ret = enter_handler (item, event, RegionViewName);
 769                 break;
 770
 771         case GDK_LEAVE_NOTIFY:
 772                 ret = leave_handler (item, event, RegionViewName);
 773                 break;
 774
 775         default:
 776                 break;
 777         }
 778
 779         return ret;
 780 }
 781
 782 bool
 783 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* marker)
 784 {
 785         return typed_event (item, event, MarkerItem);
 786 }
 787
 788 bool
 789 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 790 {
 791         return typed_event (item, event, MarkerBarItem);
 792 }
 793
 794 bool
 795 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 796 {
 797         return typed_event (item, event, RangeMarkerBarItem);
 798 }
 799
 800 bool
 801 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 802 {
 803         return typed_event (item, event, TransportMarkerBarItem);
 804 }
 805
 806 bool
 807 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* marker)
 808 {
 809         return typed_event (item, event, TempoMarkerItem);
 810 }
 811
 812 bool
 813 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* marker)
 814 {
 815         return typed_event (item, event, MeterMarkerItem);
 816 }
 817
 818 bool
 819 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 820 {
 821         return typed_event (item, event, TempoBarItem);
 822 }
 823
 824 bool
 825 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 826 {
 827         return typed_event (item, event, MeterBarItem);
 828 }
 829
 830 bool
 831 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 832 {
 833         return typed_event (item, event, PlayheadCursorItem);
 834 }
 835
 836 bool
 837 Editor::canvas_edit_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 838 {
 839         return typed_event (item, event, EditCursorItem);
 840 }
 841
 842 bool
 843 Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
 844 {
 845         return typed_event (item, event, NoItem);
 846 }
 847