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_gain_line.h"
  38 #include "automation_pan_line.h"
  39 #include "automation_time_axis.h"
  40 #include "redirect_automation_line.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         nframes64_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                         nframes64_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                         last_track_height_step_timestamp = get_microseconds();
  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                         nframes64_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                         last_track_height_step_timestamp = get_microseconds();
 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         nframes64_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_trackview = &rv->get_time_axis_view();
 310                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 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_trackview = tv;
 351                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(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_trackview = atv;
 391                 clicked_audio_trackview = 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_trackview = &rv->get_time_axis_view();
 432                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 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_trackview = &rv->get_time_axis_view();
 470                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 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_trackview = &rv->get_time_axis_view();
 511                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 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_trackview = &rv->get_time_axis_view();
 549                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 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_trackview = &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         ItemType type;
 657
 658         switch (event->type) {
 659         case GDK_BUTTON_PRESS:
 660         case GDK_2BUTTON_PRESS:
 661         case GDK_3BUTTON_PRESS:
 662                 clicked_control_point = cp;
 663                 clicked_trackview = &cp->line.trackview;
 664                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 665                 clicked_regionview = 0;
 666                 break;
 667
 668         case GDK_SCROLL_UP:
 669                 break;
 670
 671         case GDK_SCROLL_DOWN:
 672                 break;
 673
 674         default:
 675                 break;
 676         }
 677
 678         if (dynamic_cast<AudioRegionGainLine*> (&cp->line) != 0) {
 679                 type = GainControlPointItem;
 680         } else if (dynamic_cast<AutomationGainLine*> (&cp->line) != 0) {
 681                 type = GainAutomationControlPointItem;
 682         } else if (dynamic_cast<AutomationPanLine*> (&cp->line) != 0) {
 683                 type = PanAutomationControlPointItem;
 684         } else if (dynamic_cast<RedirectAutomationLine*> (&cp->line) != 0) {
 685                 type = RedirectAutomationControlPointItem;
 686         } else {
 687                 return false;
 688         }
 689
 690         return typed_event (item, event, type);
 691 }
 692
 693 bool
 694 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
 695 {
 696         ItemType type;
 697
 698         if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
 699                 type = GainLineItem;
 700         } else if (dynamic_cast<AutomationGainLine*> (al) != 0) {
 701                 type = GainAutomationLineItem;
 702         } else if (dynamic_cast<AutomationPanLine*> (al) != 0) {
 703                 type = PanAutomationLineItem;
 704         } else if (dynamic_cast<RedirectAutomationLine*> (al) != 0) {
 705                 type = RedirectAutomationLineItem;
 706         } else {
 707                 return false;
 708         }
 709
 710         return typed_event (item, event, type);
 711 }
 712
 713 bool
 714 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 715 {
 716         bool ret = false;
 717
 718         switch (event->type) {
 719         case GDK_BUTTON_PRESS:
 720         case GDK_2BUTTON_PRESS:
 721         case GDK_3BUTTON_PRESS:
 722                 clicked_selection = rect->id;
 723                 ret = button_press_handler (item, event, SelectionItem);
 724                 break;
 725         case GDK_BUTTON_RELEASE:
 726                 ret = button_release_handler (item, event, SelectionItem);
 727                 break;
 728         case GDK_MOTION_NOTIFY:
 729                 ret = motion_handler (item, event, SelectionItem);
 730                 break;
 731                 /* Don't need these at the moment. */
 732         case GDK_ENTER_NOTIFY:
 733                 ret = enter_handler (item, event, SelectionItem);
 734                 break;
 735
 736         case GDK_LEAVE_NOTIFY:
 737                 ret = leave_handler (item, event, SelectionItem);
 738                 break;
 739
 740         default:
 741                 break;
 742         }
 743
 744         return ret;
 745 }
 746
 747 bool
 748 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 749 {
 750         bool ret = false;
 751
 752         switch (event->type) {
 753         case GDK_BUTTON_PRESS:
 754         case GDK_2BUTTON_PRESS:
 755         case GDK_3BUTTON_PRESS:
 756                 clicked_selection = rect->id;
 757                 ret = button_press_handler (item, event, StartSelectionTrimItem);
 758                 break;
 759         case GDK_BUTTON_RELEASE:
 760                 ret = button_release_handler (item, event, StartSelectionTrimItem);
 761                 break;
 762         case GDK_MOTION_NOTIFY:
 763                 ret = motion_handler (item, event, StartSelectionTrimItem);
 764                 break;
 765         case GDK_ENTER_NOTIFY:
 766                 ret = enter_handler (item, event, StartSelectionTrimItem);
 767                 break;
 768
 769         case GDK_LEAVE_NOTIFY:
 770                 ret = leave_handler (item, event, StartSelectionTrimItem);
 771                 break;
 772
 773         default:
 774                 break;
 775         }
 776
 777         return ret;
 778 }
 779
 780 bool
 781 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
 782 {
 783         bool ret = false;
 784
 785         switch (event->type) {
 786         case GDK_BUTTON_PRESS:
 787         case GDK_2BUTTON_PRESS:
 788         case GDK_3BUTTON_PRESS:
 789                 clicked_selection = rect->id;
 790                 ret = button_press_handler (item, event, EndSelectionTrimItem);
 791                 break;
 792         case GDK_BUTTON_RELEASE:
 793                 ret = button_release_handler (item, event, EndSelectionTrimItem);
 794                 break;
 795         case GDK_MOTION_NOTIFY:
 796                 ret = motion_handler (item, event, EndSelectionTrimItem);
 797                 break;
 798         case GDK_ENTER_NOTIFY:
 799                 ret = enter_handler (item, event, EndSelectionTrimItem);
 800                 break;
 801
 802         case GDK_LEAVE_NOTIFY:
 803                 ret = leave_handler (item, event, EndSelectionTrimItem);
 804                 break;
 805
 806         default:
 807                 break;
 808         }
 809
 810         return ret;
 811 }
 812
 813
 814 bool
 815 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
 816 {
 817         bool ret = false;
 818
 819         if (!rv->sensitive()) {
 820                 return false;
 821         }
 822
 823         switch (event->type) {
 824         case GDK_BUTTON_PRESS:
 825         case GDK_2BUTTON_PRESS:
 826         case GDK_3BUTTON_PRESS:
 827                 clicked_regionview = rv;
 828                 clicked_control_point = 0;
 829                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 830                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 831                 ret = button_press_handler (item, event, RegionViewNameHighlight);
 832                 break;
 833         case GDK_BUTTON_RELEASE:
 834                 ret = button_release_handler (item, event, RegionViewNameHighlight);
 835                 break;
 836         case GDK_MOTION_NOTIFY:
 837                 ret = motion_handler (item, event, RegionViewNameHighlight);
 838                 break;
 839         case GDK_ENTER_NOTIFY:
 840                 ret = enter_handler (item, event, RegionViewNameHighlight);
 841                 break;
 842
 843         case GDK_LEAVE_NOTIFY:
 844                 ret = leave_handler (item, event, RegionViewNameHighlight);
 845                 break;
 846
 847         default:
 848                 break;
 849         }
 850
 851         return ret;
 852 }
 853
 854 bool
 855 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
 856 {
 857         bool ret = false;
 858
 859         if (!rv->sensitive()) {
 860                 return false;
 861         }
 862
 863         switch (event->type) {
 864         case GDK_BUTTON_PRESS:
 865         case GDK_2BUTTON_PRESS:
 866         case GDK_3BUTTON_PRESS:
 867                 clicked_regionview = rv;
 868                 clicked_control_point = 0;
 869                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 870                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 871                 ret = button_press_handler (item, event, RegionViewName);
 872                 break;
 873         case GDK_BUTTON_RELEASE:
 874                 ret = button_release_handler (item, event, RegionViewName);
 875                 break;
 876         case GDK_MOTION_NOTIFY:
 877                 ret = motion_handler (item, event, RegionViewName);
 878                 break;
 879         case GDK_ENTER_NOTIFY:
 880                 ret = enter_handler (item, event, RegionViewName);
 881                 break;
 882
 883         case GDK_LEAVE_NOTIFY:
 884                 ret = leave_handler (item, event, RegionViewName);
 885                 break;
 886
 887         default:
 888                 break;
 889         }
 890
 891         return ret;
 892 }
 893
 894 bool
 895 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* marker)
 896 {
 897         return typed_event (item, event, MarkerItem);
 898 }
 899
 900 bool
 901 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 902 {
 903         return typed_event (item, event, MarkerBarItem);
 904 }
 905
 906 bool
 907 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 908 {
 909         return typed_event (item, event, RangeMarkerBarItem);
 910 }
 911
 912 bool
 913 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 914 {
 915         return typed_event (item, event, TransportMarkerBarItem);
 916 }
 917
 918 bool
 919 Editor::canvas_cd_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 920 {
 921         return typed_event (item, event, CdMarkerBarItem);
 922 }
 923
 924 bool
 925 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* marker)
 926 {
 927         return typed_event (item, event, TempoMarkerItem);
 928 }
 929
 930 bool
 931 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* marker)
 932 {
 933         return typed_event (item, event, MeterMarkerItem);
 934 }
 935
 936 bool
 937 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 938 {
 939         return typed_event (item, event, TempoBarItem);
 940 }
 941
 942 bool
 943 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
 944 {
 945         return typed_event (item, event, MeterBarItem);
 946 }
 947
 948 bool
 949 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
 950 {
 951         return typed_event (item, event, PlayheadCursorItem);
 952 }
 953
 954 bool
 955 Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
 956 {
 957         return typed_event (item, event, NoItem);
 958 }
 959