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