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                 gnome_canvas_item_set (verbose_canvas_cursor,
 321                                      "x", ev->motion.x + 20,
 322                                      "y", ev->motion.y + 20,
 323                                      NULL);
 324         }
 325         return FALSE;
 326 }
 327
 328 gint
 329 Editor::typed_event (GnomeCanvasItem *item, GdkEvent *event, ItemType type)
 330 {
 331         gint ret = FALSE;
 332
 333         switch (event->type) {
 334         case GDK_BUTTON_PRESS:
 335         case GDK_2BUTTON_PRESS:
 336         case GDK_3BUTTON_PRESS:
 337                 ret = button_press_handler (item, event, type);
 338                 break;
 339         case GDK_BUTTON_RELEASE:
 340                 ret = button_release_handler (item, event, type);
 341                 break;
 342         case GDK_MOTION_NOTIFY:
 343                 ret = motion_handler (item, event, type);
 344                 break;
 345
 346         case GDK_ENTER_NOTIFY:
 347                 ret = enter_handler (item, event, type);
 348                 break;
 349
 350         case GDK_LEAVE_NOTIFY:
 351                 ret = leave_handler (item, event, type);
 352                 break;
 353
 354         default:
 355                 break;
 356         }
 357
 358         return ret;
 359 }
 360
 361 gint
 362 Editor::canvas_region_view_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
 363 {
 364         gint 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, RegionItem);
 375                 break;
 376
 377         case GDK_BUTTON_RELEASE:
 378                 ret = button_release_handler (item, event, RegionItem);
 379                 break;
 380
 381         case GDK_MOTION_NOTIFY:
 382                 ret = motion_handler (item, event, RegionItem);
 383                 break;
 384
 385         case GDK_ENTER_NOTIFY:
 386                 set_entered_regionview (rv);
 387                 break;
 388
 389         case GDK_LEAVE_NOTIFY:
 390                 set_entered_regionview (0);
 391                 break;
 392
 393         default:
 394                 break;
 395         }
 396
 397         return ret;
 398 }
 399
 400 gint
 401 Editor::canvas_stream_view_event (GnomeCanvasItem *item, GdkEvent *event, AudioTimeAxisView *tv)
 402 {
 403         gint ret = FALSE;
 404
 405         switch (event->type) {
 406         case GDK_BUTTON_PRESS:
 407         case GDK_2BUTTON_PRESS:
 408         case GDK_3BUTTON_PRESS:
 409                 clicked_regionview = 0;
 410                 clicked_control_point = 0;
 411                 clicked_trackview = tv;
 412                 clicked_audio_trackview = tv;
 413                 ret = button_press_handler (item, event, StreamItem);
 414                 break;
 415
 416         case GDK_BUTTON_RELEASE:
 417                 ret = button_release_handler (item, event, StreamItem);
 418                 break;
 419
 420         case GDK_MOTION_NOTIFY:
 421                 ret = motion_handler (item, event, StreamItem);
 422                 break;
 423
 424         case GDK_ENTER_NOTIFY:
 425                 break;
 426
 427         default:
 428                 break;
 429         }
 430
 431         return ret;
 432 }
 433
 434
 435
 436 gint
 437 Editor::canvas_automation_track_event (GnomeCanvasItem *item, GdkEvent *event, AutomationTimeAxisView *atv)
 438 {
 439         gint ret = FALSE;
 440
 441         switch (event->type) {
 442         case GDK_BUTTON_PRESS:
 443         case GDK_2BUTTON_PRESS:
 444         case GDK_3BUTTON_PRESS:
 445                 clicked_regionview = 0;
 446                 clicked_control_point = 0;
 447                 clicked_trackview = atv;
 448                 clicked_audio_trackview = 0;
 449                 ret = button_press_handler (item, event, AutomationTrackItem);
 450                 break;
 451
 452         case GDK_BUTTON_RELEASE:
 453                 ret = button_release_handler (item, event, AutomationTrackItem);
 454                 break;
 455
 456         case GDK_MOTION_NOTIFY:
 457                 ret = motion_handler (item, event, AutomationTrackItem);
 458                 break;
 459
 460         case GDK_ENTER_NOTIFY:
 461                 ret = enter_handler (item, event, AutomationTrackItem);
 462                 break;
 463
 464         case GDK_LEAVE_NOTIFY:
 465                 ret = leave_handler (item, event, AutomationTrackItem);
 466                 break;
 467
 468         default:
 469                 break;
 470         }
 471
 472         return ret;
 473 }
 474
 475 gint
 476 Editor::canvas_fade_in_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
 477 {
 478         /* we handle only button 3 press/release events */
 479
 480         switch (event->type) {
 481         case GDK_BUTTON_PRESS:
 482                 clicked_regionview = rv;
 483                 clicked_control_point = 0;
 484                 clicked_trackview = &rv->get_time_axis_view();
 485                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 486                 if (event->button.button == 3) {
 487                         return button_press_handler (item, event, FadeInItem);
 488                 }
 489                 break;
 490
 491         case GDK_BUTTON_RELEASE:
 492                 if (event->button.button == 3) {
 493                         return button_release_handler (item, event, FadeInItem);
 494                 }
 495                 break;
 496
 497         default:
 498                 break;
 499
 500         }
 501
 502         /* proxy for the regionview */
 503
 504         return canvas_region_view_event (rv->get_canvas_group(), event, rv);
 505 }
 506
 507 gint
 508 Editor::canvas_fade_in_handle_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
 509 {
 510         gint ret = FALSE;
 511
 512         switch (event->type) {
 513         case GDK_BUTTON_PRESS:
 514         case GDK_2BUTTON_PRESS:
 515         case GDK_3BUTTON_PRESS:
 516                 clicked_regionview = rv;
 517                 clicked_control_point = 0;
 518                 clicked_trackview = &rv->get_time_axis_view();
 519                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 520                 ret = button_press_handler (item, event, FadeInHandleItem);
 521                 break;
 522
 523         case GDK_BUTTON_RELEASE:
 524                 ret = button_release_handler (item, event, FadeInHandleItem);
 525                 break;
 526
 527         case GDK_MOTION_NOTIFY:
 528                 ret = motion_handler (item, event, FadeInHandleItem);
 529                 break;
 530
 531         case GDK_ENTER_NOTIFY:
 532                 ret = enter_handler (item, event, FadeInHandleItem);
 533                 break;
 534
 535         case GDK_LEAVE_NOTIFY:
 536                 ret = leave_handler (item, event, FadeInHandleItem);
 537                 break;
 538
 539         default:
 540                 break;
 541         }
 542
 543         return ret;
 544 }
 545
 546 gint
 547 Editor::canvas_fade_out_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
 548 {
 549         /* we handle only button 3 press/release events */
 550
 551         switch (event->type) {
 552         case GDK_BUTTON_PRESS:
 553                 clicked_regionview = rv;
 554                 clicked_control_point = 0;
 555                 clicked_trackview = &rv->get_time_axis_view();
 556                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 557                 if (event->button.button == 3) {
 558                         return button_press_handler (item, event, FadeOutItem);
 559                 }
 560                 break;
 561
 562         case GDK_BUTTON_RELEASE:
 563                 if (event->button.button == 3) {
 564                         return button_release_handler (item, event, FadeOutItem);
 565                 }
 566                 break;
 567
 568         default:
 569                 break;
 570
 571         }
 572
 573         /* proxy for the regionview */
 574
 575         return canvas_region_view_event (rv->get_canvas_group(), event, rv);
 576 }
 577
 578 gint
 579 Editor::canvas_fade_out_handle_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
 580 {
 581         gint ret = FALSE;
 582
 583         switch (event->type) {
 584         case GDK_BUTTON_PRESS:
 585         case GDK_2BUTTON_PRESS:
 586         case GDK_3BUTTON_PRESS:
 587                 clicked_regionview = rv;
 588                 clicked_control_point = 0;
 589                 clicked_trackview = &rv->get_time_axis_view();
 590                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 591                 ret = button_press_handler (item, event, FadeOutHandleItem);
 592                 break;
 593
 594         case GDK_BUTTON_RELEASE:
 595                 ret = button_release_handler (item, event, FadeOutHandleItem);
 596                 break;
 597
 598         case GDK_MOTION_NOTIFY:
 599                 ret = motion_handler (item, event, FadeOutHandleItem);
 600                 break;
 601
 602         case GDK_ENTER_NOTIFY:
 603                 ret = enter_handler (item, event, FadeOutHandleItem);
 604                 break;
 605
 606         case GDK_LEAVE_NOTIFY:
 607                 ret = leave_handler (item, event, FadeOutHandleItem);
 608                 break;
 609
 610         default:
 611                 break;
 612         }
 613
 614         return ret;
 615 }
 616
 617 struct DescendingRegionLayerSorter {
 618     bool operator()(Region* a, Region* b) {
 619             return a->layer() > b->layer();
 620     }
 621 };
 622
 623 gint
 624 Editor::canvas_crossfade_view_event (GnomeCanvasItem* item, GdkEvent* event, CrossfadeView* xfv)
 625 {
 626         /* we handle only button 3 press/release events */
 627
 628         switch (event->type) {
 629         case GDK_BUTTON_PRESS:
 630                 clicked_crossfadeview = xfv;
 631                 clicked_trackview = &clicked_crossfadeview->get_time_axis_view();
 632                 if (event->button.button == 3) {
 633                         return button_press_handler (item, event, CrossfadeViewItem);
 634                 }
 635                 break;
 636
 637         case GDK_BUTTON_RELEASE:
 638                 if (event->button.button == 3) {
 639                         gint ret = button_release_handler (item, event, CrossfadeViewItem);
 640                         return ret;
 641                 }
 642                 break;
 643
 644         default:
 645                 break;
 646
 647         }
 648
 649
 650         /* proxy for the upper most regionview */
 651
 652         /* XXX really need to check if we are in the name highlight,
 653            and proxy to that when required.
 654         */
 655
 656         TimeAxisView& tv (xfv->get_time_axis_view());
 657         AudioTimeAxisView* atv;
 658
 659         if ((atv = dynamic_cast<AudioTimeAxisView*>(&tv)) != 0) {
 660
 661                 if (atv->is_audio_track()) {
 662
 663                         AudioPlaylist* pl = atv->get_diskstream()->playlist();
 664                         Playlist::RegionList* rl = pl->regions_at (event_frame (event));
 665
 666                         if (!rl->empty()) {
 667                                 DescendingRegionLayerSorter cmp;
 668                                 rl->sort (cmp);
 669
 670                                 AudioRegionView* arv = atv->view->find_view (*(dynamic_cast<AudioRegion*> (rl->front())));
 671
 672                                 /* proxy */
 673
 674                                 delete rl;
 675
 676                                 return canvas_region_view_event (arv->get_canvas_group(), event, arv);
 677                         }
 678                 }
 679         }
 680
 681         return TRUE;
 682 }
 683
 684 gint
 685 Editor::canvas_control_point_event (GnomeCanvasItem *item, GdkEvent *event)
 686 {
 687         ItemType type;
 688         ControlPoint *cp;
 689
 690         if ((cp = static_cast<ControlPoint *> (gtk_object_get_data (GTK_OBJECT(item), "control_point"))) == 0) {
 691                 fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
 692                 /*NOTREACHED*/
 693         }
 694
 695         if (dynamic_cast<AudioRegionGainLine*> (&cp->line) != 0) {
 696                 type = GainControlPointItem;
 697         } else if (dynamic_cast<AutomationGainLine*> (&cp->line) != 0) {
 698                 type = GainAutomationControlPointItem;
 699         } else if (dynamic_cast<AutomationPanLine*> (&cp->line) != 0) {
 700                 type = PanAutomationControlPointItem;
 701         } else if (dynamic_cast<RedirectAutomationLine*> (&cp->line) != 0) {
 702                 type = RedirectAutomationControlPointItem;
 703         } else {
 704                 return FALSE;
 705         }
 706
 707         return typed_event (item, event, type);
 708 }
 709
 710 gint
 711 Editor::canvas_line_event (GnomeCanvasItem *item, GdkEvent *event)
 712 {
 713         ItemType type;
 714         AutomationLine *al;
 715
 716         if ((al = static_cast<AutomationLine *> (gtk_object_get_data (GTK_OBJECT(item), "line"))) == 0) {
 717                 fatal << _("programming error: line canvas item has no line object pointer!") << endmsg;
 718                 /*NOTREACHED*/
 719         }
 720
 721         if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
 722                 type = GainLineItem;
 723         } else if (dynamic_cast<AutomationGainLine*> (al) != 0) {
 724                 type = GainAutomationLineItem;
 725         } else if (dynamic_cast<AutomationPanLine*> (al) != 0) {
 726                 type = PanAutomationLineItem;
 727         } else if (dynamic_cast<RedirectAutomationLine*> (al) != 0) {
 728                 type = RedirectAutomationLineItem;
 729         } else {
 730                 return FALSE;
 731         }
 732
 733         return typed_event (item, event, type);
 734 }
 735
 736
 737 gint
 738 Editor::canvas_selection_rect_event (GnomeCanvasItem *item, GdkEvent *event)
 739 {
 740         gint ret = FALSE;
 741         SelectionRect *rect = 0;
 742
 743         if ((rect = reinterpret_cast<SelectionRect*> (gtk_object_get_data (GTK_OBJECT(item), "rect"))) == 0) {
 744                 fatal << _("programming error: no \"rect\" pointer associated with selection item") << endmsg;
 745                 /*NOTREACHED*/
 746         }
 747
 748         switch (event->type) {
 749         case GDK_BUTTON_PRESS:
 750         case GDK_2BUTTON_PRESS:
 751         case GDK_3BUTTON_PRESS:
 752                 clicked_selection = rect->id;
 753                 ret = button_press_handler (item, event, SelectionItem);
 754                 break;
 755         case GDK_BUTTON_RELEASE:
 756                 ret = button_release_handler (item, event, SelectionItem);
 757                 break;
 758         case GDK_MOTION_NOTIFY:
 759                 ret = motion_handler (item, event, SelectionItem);
 760                 break;
 761                 /* Don't need these at the moment. */
 762         case GDK_ENTER_NOTIFY:
 763                 ret = enter_handler (item, event, SelectionItem);
 764                 break;
 765
 766         case GDK_LEAVE_NOTIFY:
 767                 ret = leave_handler (item, event, SelectionItem);
 768                 break;
 769
 770         default:
 771                 break;
 772         }
 773
 774         return ret;
 775 }
 776
 777 gint
 778 Editor::canvas_selection_start_trim_event (GnomeCanvasItem *item, GdkEvent *event)
 779 {
 780         gint ret = FALSE;
 781         SelectionRect *rect = 0;
 782
 783         if ((rect = reinterpret_cast<SelectionRect*> (gtk_object_get_data (GTK_OBJECT(item), "rect"))) == 0) {
 784                 fatal << _("programming error: no \"rect\" pointer associated with selection item") << endmsg;
 785                 /*NOTREACHED*/
 786         }
 787
 788         switch (event->type) {
 789         case GDK_BUTTON_PRESS:
 790         case GDK_2BUTTON_PRESS:
 791         case GDK_3BUTTON_PRESS:
 792                 clicked_selection = rect->id;
 793                 ret = button_press_handler (item, event, StartSelectionTrimItem);
 794                 break;
 795         case GDK_BUTTON_RELEASE:
 796                 ret = button_release_handler (item, event, StartSelectionTrimItem);
 797                 break;
 798         case GDK_MOTION_NOTIFY:
 799                 ret = motion_handler (item, event, StartSelectionTrimItem);
 800                 break;
 801         case GDK_ENTER_NOTIFY:
 802                 ret = enter_handler (item, event, StartSelectionTrimItem);
 803                 break;
 804
 805         case GDK_LEAVE_NOTIFY:
 806                 ret = leave_handler (item, event, StartSelectionTrimItem);
 807                 break;
 808
 809         default:
 810                 break;
 811         }
 812
 813         return ret;
 814 }
 815
 816 gint
 817 Editor::canvas_selection_end_trim_event (GnomeCanvasItem *item, GdkEvent *event)
 818 {
 819         gint ret = FALSE;
 820         SelectionRect *rect = 0;
 821
 822         if ((rect = reinterpret_cast<SelectionRect*> (gtk_object_get_data (GTK_OBJECT(item), "rect"))) == 0) {
 823                 fatal << _("programming error: no \"rect\" pointer associated with selection item") << endmsg;
 824                 /*NOTREACHED*/
 825         }
 826
 827         switch (event->type) {
 828         case GDK_BUTTON_PRESS:
 829         case GDK_2BUTTON_PRESS:
 830         case GDK_3BUTTON_PRESS:
 831                 clicked_selection = rect->id;
 832                 ret = button_press_handler (item, event, EndSelectionTrimItem);
 833                 break;
 834         case GDK_BUTTON_RELEASE:
 835                 ret = button_release_handler (item, event, EndSelectionTrimItem);
 836                 break;
 837         case GDK_MOTION_NOTIFY:
 838                 ret = motion_handler (item, event, EndSelectionTrimItem);
 839                 break;
 840         case GDK_ENTER_NOTIFY:
 841                 ret = enter_handler (item, event, EndSelectionTrimItem);
 842                 break;
 843
 844         case GDK_LEAVE_NOTIFY:
 845                 ret = leave_handler (item, event, EndSelectionTrimItem);
 846                 break;
 847
 848         default:
 849                 break;
 850         }
 851
 852         return ret;
 853 }
 854
 855
 856 gint
 857 Editor::canvas_region_view_name_highlight_event (GnomeCanvasItem *item, GdkEvent *event)
 858 {
 859         gint ret = FALSE;
 860
 861         switch (event->type) {
 862         case GDK_BUTTON_PRESS:
 863         case GDK_2BUTTON_PRESS:
 864         case GDK_3BUTTON_PRESS:
 865                 clicked_regionview = reinterpret_cast<AudioRegionView *> (gtk_object_get_data(GTK_OBJECT(item), "regionview"));
 866                 clicked_control_point = 0;
 867                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 868                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 869                 ret = button_press_handler (item, event, AudioRegionViewNameHighlight);
 870                 break;
 871         case GDK_BUTTON_RELEASE:
 872                 ret = button_release_handler (item, event, AudioRegionViewNameHighlight);
 873                 break;
 874         case GDK_MOTION_NOTIFY:
 875                 ret = motion_handler (item, event, AudioRegionViewNameHighlight);
 876                 break;
 877         case GDK_ENTER_NOTIFY:
 878                 ret = enter_handler (item, event, AudioRegionViewNameHighlight);
 879                 break;
 880
 881         case GDK_LEAVE_NOTIFY:
 882                 ret = leave_handler (item, event, AudioRegionViewNameHighlight);
 883                 break;
 884
 885         default:
 886                 break;
 887         }
 888
 889         return ret;
 890 }
 891
 892 gint
 893 Editor::canvas_region_view_name_event (GnomeCanvasItem *item, GdkEvent *event)
 894 {
 895         gint ret = FALSE;
 896
 897         switch (event->type) {
 898         case GDK_BUTTON_PRESS:
 899         case GDK_2BUTTON_PRESS:
 900         case GDK_3BUTTON_PRESS:
 901                 clicked_regionview = reinterpret_cast<AudioRegionView *> (gtk_object_get_data(GTK_OBJECT(item), "regionview"));
 902                 clicked_control_point = 0;
 903                 clicked_trackview = &clicked_regionview->get_time_axis_view();
 904                 clicked_audio_trackview = dynamic_cast<AudioTimeAxisView*>(clicked_trackview);
 905                 ret = button_press_handler (item, event, AudioRegionViewName);
 906                 break;
 907         case GDK_BUTTON_RELEASE:
 908                 ret = button_release_handler (item, event, AudioRegionViewName);
 909                 break;
 910         case GDK_MOTION_NOTIFY:
 911                 ret = motion_handler (item, event, AudioRegionViewName);
 912                 break;
 913         case GDK_ENTER_NOTIFY:
 914                 ret = enter_handler (item, event, AudioRegionViewName);
 915                 break;
 916
 917         case GDK_LEAVE_NOTIFY:
 918                 ret = leave_handler (item, event, AudioRegionViewName);
 919                 break;
 920
 921         default:
 922                 break;
 923         }
 924
 925         return ret;
 926 }
 927
 928 gint
 929 Editor::canvas_marker_event (GnomeCanvasItem *item, GdkEvent *event)
 930 {
 931         return typed_event (item, event, MarkerItem);
 932 }
 933
 934 gint
 935 Editor::canvas_marker_bar_event (GnomeCanvasItem *item, GdkEvent *event)
 936 {
 937         return typed_event (item, event, MarkerBarItem);
 938 }
 939
 940 gint
 941 Editor::canvas_range_marker_bar_event (GnomeCanvasItem *item, GdkEvent *event)
 942 {
 943         return typed_event (item, event, RangeMarkerBarItem);
 944 }
 945
 946 gint
 947 Editor::canvas_transport_marker_bar_event (GnomeCanvasItem *item, GdkEvent *event)
 948 {
 949         return typed_event (item, event, TransportMarkerBarItem);
 950 }
 951
 952 gint
 953 Editor::canvas_tempo_marker_event (GnomeCanvasItem *item, GdkEvent *event)
 954 {
 955         return typed_event (item, event, TempoMarkerItem);
 956 }
 957
 958 gint
 959 Editor::canvas_meter_marker_event (GnomeCanvasItem *item, GdkEvent *event)
 960 {
 961         return typed_event (item, event, MeterMarkerItem);
 962 }
 963
 964 gint
 965 Editor::canvas_tempo_bar_event (GnomeCanvasItem *item, GdkEvent *event)
 966 {
 967         return typed_event (item, event, TempoBarItem);
 968 }
 969
 970 gint
 971 Editor::canvas_meter_bar_event (GnomeCanvasItem *item, GdkEvent *event)
 972 {
 973         return typed_event (item, event, MeterBarItem);
 974 }
 975
 976 gint
 977 Editor::canvas_playhead_cursor_event (GnomeCanvasItem *item, GdkEvent *event)
 978 {
 979         return typed_event (item, event, PlayheadCursorItem);
 980 }
 981
 982 gint
 983 Editor::canvas_edit_cursor_event (GnomeCanvasItem *item, GdkEvent *event)
 984 {
 985         return typed_event (item, event, EditCursorItem);
 986 }
 987
 988 gint
 989 Editor::canvas_zoom_rect_event (GnomeCanvasItem *item, GdkEvent *event)
 990 {
 991         return typed_event (item, event, NoItem);
 992 }
 993
 994 gint
 995 Editor::canvas_copy_region_event (GnomeCanvasItem *item, GdkEvent *event)
 996 {
 997         return typed_event (item, event, RegionItem);
 998 }
 999