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