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