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