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