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