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