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