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