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