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