gtk2_ardour/editor_mouse.cc

   1 /*
   2     Copyright (C) 2000-2001 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 <cassert>
  22 #include <cstdlib>
  23 #include <stdint.h>
  24 #include <cmath>
  25 #include <set>
  26 #include <string>
  27 #include <algorithm>
  28
  29 #include <pbd/error.h>
  30 #include <gtkmm2ext/utils.h>
  31 #include <pbd/memento_command.h>
  32
  33 #include "ardour_ui.h"
  34 #include "editor.h"
  35 #include "time_axis_view.h"
  36 #include "audio_time_axis.h"
  37 #include "audio_region_view.h"
  38 #include "marker.h"
  39 #include "streamview.h"
  40 #include "region_gain_line.h"
  41 #include "automation_time_axis.h"
  42 #include "prompter.h"
  43 #include "utils.h"
  44 #include "selection.h"
  45 #include "keyboard.h"
  46 #include "editing.h"
  47 #include "rgb_macros.h"
  48
  49 #include <ardour/types.h>
  50 #include <ardour/route.h>
  51 #include <ardour/audio_track.h>
  52 #include <ardour/audio_diskstream.h>
  53 #include <ardour/playlist.h>
  54 #include <ardour/audioplaylist.h>
  55 #include <ardour/audioregion.h>
  56 #include <ardour/dB.h>
  57 #include <ardour/utils.h>
  58 #include <ardour/region_factory.h>
  59
  60 #include <bitset>
  61
  62 #include "i18n.h"
  63
  64 using namespace std;
  65 using namespace ARDOUR;
  66 using namespace PBD;
  67 using namespace sigc;
  68 using namespace Gtk;
  69 using namespace Editing;
  70
  71 nframes_t
  72 Editor::event_frame (GdkEvent* event, double* pcx, double* pcy)
  73 {
  74         double cx, cy;
  75
  76         if (pcx == 0) {
  77                 pcx = &cx;
  78         }
  79         if (pcy == 0) {
  80                 pcy = &cy;
  81         }
  82
  83         *pcx = 0;
  84         *pcy = 0;
  85
  86         switch (event->type) {
  87         case GDK_BUTTON_RELEASE:
  88         case GDK_BUTTON_PRESS:
  89         case GDK_2BUTTON_PRESS:
  90         case GDK_3BUTTON_PRESS:
  91                 track_canvas.w2c(event->button.x, event->button.y, *pcx, *pcy);
  92                 break;
  93         case GDK_MOTION_NOTIFY:
  94                 track_canvas.w2c(event->motion.x, event->motion.y, *pcx, *pcy);
  95                 break;
  96         case GDK_ENTER_NOTIFY:
  97         case GDK_LEAVE_NOTIFY:
  98                 track_canvas.w2c(event->crossing.x, event->crossing.y, *pcx, *pcy);
  99                 break;
 100         case GDK_KEY_PRESS:
 101         case GDK_KEY_RELEASE:
 102                 // track_canvas.w2c(event->key.x, event->key.y, *pcx, *pcy);
 103                 break;
 104         default:
 105                 warning << string_compose (_("Editor::event_frame() used on unhandled event type %1"), event->type) << endmsg;
 106                 break;
 107         }
 108
 109         /* note that pixel_to_frame() never returns less than zero, so even if the pixel
 110            position is negative (as can be the case with motion events in particular),
 111            the frame location is always positive.
 112         */
 113
 114         return pixel_to_frame (*pcx);
 115 }
 116
 117 void
 118 Editor::mouse_mode_toggled (MouseMode m)
 119 {
 120         if (ignore_mouse_mode_toggle) {
 121                 return;
 122         }
 123
 124         switch (m) {
 125         case MouseRange:
 126                 if (mouse_select_button.get_active()) {
 127                         set_mouse_mode (m);
 128                 }
 129                 break;
 130
 131         case MouseObject:
 132                 if (mouse_move_button.get_active()) {
 133                         set_mouse_mode (m);
 134                 }
 135                 break;
 136
 137         case MouseGain:
 138                 if (mouse_gain_button.get_active()) {
 139                         set_mouse_mode (m);
 140                 }
 141                 break;
 142
 143         case MouseZoom:
 144                 if (mouse_zoom_button.get_active()) {
 145                         set_mouse_mode (m);
 146                 }
 147                 break;
 148
 149         case MouseTimeFX:
 150                 if (mouse_timefx_button.get_active()) {
 151                         set_mouse_mode (m);
 152                 }
 153                 break;
 154
 155         case MouseAudition:
 156                 if (mouse_audition_button.get_active()) {
 157                         set_mouse_mode (m);
 158                 }
 159                 break;
 160
 161         default:
 162                 break;
 163         }
 164 }
 165
 166 void
 167 Editor::set_mouse_mode (MouseMode m, bool force)
 168 {
 169         if (drag_info.item) {
 170                 return;
 171         }
 172
 173         if (!force && m == mouse_mode) {
 174                 return;
 175         }
 176
 177         mouse_mode = m;
 178
 179         instant_save ();
 180
 181         if (mouse_mode != MouseRange) {
 182
 183                 /* in all modes except range, hide the range selection,
 184                    show the object (region) selection.
 185                 */
 186
 187                 for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
 188                         (*i)->set_should_show_selection (true);
 189                 }
 190                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 191                         (*i)->hide_selection ();
 192                 }
 193
 194         } else {
 195
 196                 /*
 197                    in range mode,show the range selection.
 198                 */
 199
 200                 for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
 201                         if ((*i)->get_selected()) {
 202                                 (*i)->show_selection (selection->time);
 203                         }
 204                 }
 205         }
 206
 207         /* XXX the hack of unsetting all other buttongs should go
 208            away once GTK2 allows us to use regular radio buttons drawn like
 209            normal buttons, rather than my silly GroupedButton hack.
 210         */
 211
 212         ignore_mouse_mode_toggle = true;
 213
 214         switch (mouse_mode) {
 215         case MouseRange:
 216                 mouse_select_button.set_active (true);
 217                 current_canvas_cursor = selector_cursor;
 218                 break;
 219
 220         case MouseObject:
 221                 mouse_move_button.set_active (true);
 222                 current_canvas_cursor = grabber_cursor;
 223                 break;
 224
 225         case MouseGain:
 226                 mouse_gain_button.set_active (true);
 227                 current_canvas_cursor = cross_hair_cursor;
 228                 break;
 229
 230         case MouseZoom:
 231                 mouse_zoom_button.set_active (true);
 232                 current_canvas_cursor = zoom_cursor;
 233                 break;
 234
 235         case MouseTimeFX:
 236                 mouse_timefx_button.set_active (true);
 237                 current_canvas_cursor = time_fx_cursor; // just use playhead
 238                 break;
 239
 240         case MouseAudition:
 241                 mouse_audition_button.set_active (true);
 242                 current_canvas_cursor = speaker_cursor;
 243                 break;
 244         }
 245
 246         ignore_mouse_mode_toggle = false;
 247
 248         if (is_drawable()) {
 249                 track_canvas.get_window()->set_cursor(*current_canvas_cursor);
 250         }
 251 }
 252
 253 void
 254 Editor::step_mouse_mode (bool next)
 255 {
 256         switch (current_mouse_mode()) {
 257         case MouseObject:
 258                 if (next) set_mouse_mode (MouseRange);
 259                 else set_mouse_mode (MouseTimeFX);
 260                 break;
 261
 262         case MouseRange:
 263                 if (next) set_mouse_mode (MouseZoom);
 264                 else set_mouse_mode (MouseObject);
 265                 break;
 266
 267         case MouseZoom:
 268                 if (next) set_mouse_mode (MouseGain);
 269                 else set_mouse_mode (MouseRange);
 270                 break;
 271
 272         case MouseGain:
 273                 if (next) set_mouse_mode (MouseTimeFX);
 274                 else set_mouse_mode (MouseZoom);
 275                 break;
 276
 277         case MouseTimeFX:
 278                 if (next) set_mouse_mode (MouseAudition);
 279                 else set_mouse_mode (MouseGain);
 280                 break;
 281
 282         case MouseAudition:
 283                 if (next) set_mouse_mode (MouseObject);
 284                 else set_mouse_mode (MouseTimeFX);
 285                 break;
 286         }
 287 }
 288
 289 void
 290 Editor::button_selection (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
 291 {
 292         bool commit = false;
 293         bool c1;
 294         bool c2;
 295
 296         /* in object/audition/timefx mode, any button press sets
 297            the selection if the object can be selected. this is a
 298            bit of hack, because we want to avoid this if the
 299            mouse operation is a region alignment.
 300
 301            note: not dbl-click or triple-click
 302         */
 303
 304         if (((mouse_mode != MouseObject) &&
 305              (mouse_mode != MouseAudition || item_type != RegionItem) &&
 306              (mouse_mode != MouseTimeFX || item_type != RegionItem)) ||
 307             (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE || event->button.button > 3)) {
 308
 309                 return;
 310         }
 311
 312         Selection::Operation op = Keyboard::selection_type (event->button.state);
 313         bool press = (event->type == GDK_BUTTON_PRESS);
 314
 315         begin_reversible_command (_("select on click"));
 316
 317         switch (item_type) {
 318         case RegionItem:
 319                 c1 = set_selected_track_from_click (op, true);
 320                 c2 = set_selected_regionview_from_click (press, op, true);
 321                 commit = (c1 || c2);
 322                 break;
 323
 324         case RegionViewNameHighlight:
 325         case RegionViewName:
 326                 c1 = set_selected_track_from_click (op, true);
 327                 c2 = set_selected_regionview_from_click (press, op, true);
 328                 commit = (c1 || c2);
 329                 break;
 330
 331         case GainAutomationControlPointItem:
 332         case PanAutomationControlPointItem:
 333         case RedirectAutomationControlPointItem:
 334                 c1 = set_selected_track_from_click (op, true);
 335                 c2 = set_selected_control_point_from_click (op, false);
 336                 commit = (c1 || c2);
 337                 break;
 338
 339         case StreamItem:
 340                 commit = set_selected_track_from_click (op, true);
 341                 break;
 342
 343         case AutomationTrackItem:
 344                 commit = set_selected_track_from_click (op, true);
 345                 break;
 346
 347         default:
 348                 break;
 349         }
 350
 351 #define SELECT_TRACK_FROM_CANVAS_IN_RANGE_MODE
 352 #ifdef  SELECT_TRACK_FROM_CANVAS_IN_RANGE_MODE
 353         /* in range mode, button 1/2/3 press potentially selects a track */
 354
 355         if (mouse_mode == MouseRange &&
 356             event->type == GDK_BUTTON_PRESS &&
 357             event->button.button <= 3) {
 358
 359                 switch (item_type) {
 360                 case StreamItem:
 361                 case RegionItem:
 362                 case AutomationTrackItem:
 363                         commit = set_selected_track_from_click (op, true);
 364                         break;
 365
 366                 default:
 367                         break;
 368                 }
 369         }
 370 #endif
 371         if (commit) {
 372                 commit_reversible_command ();
 373         }
 374 }
 375
 376 bool
 377 Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
 378 {
 379         nframes_t where = event_frame (event, 0, 0);
 380
 381         track_canvas.grab_focus();
 382
 383         if (session && session->actively_recording()) {
 384                 return true;
 385         }
 386
 387         button_selection (item, event, item_type);
 388
 389         if (drag_info.item == 0 &&
 390             (Keyboard::is_delete_event (&event->button) ||
 391              Keyboard::is_context_menu_event (&event->button) ||
 392              Keyboard::is_edit_event (&event->button))) {
 393
 394                 /* handled by button release */
 395                 return true;
 396         }
 397
 398         switch (event->button.button) {
 399         case 1:
 400
 401                 if (event->type == GDK_BUTTON_PRESS) {
 402
 403                         if (drag_info.item) {
 404                                 drag_info.item->ungrab (event->button.time);
 405                         }
 406
 407                         /* single mouse clicks on any of these item types operate
 408                            independent of mouse mode, mostly because they are
 409                            not on the main track canvas or because we want
 410                            them to be modeless.
 411                         */
 412
 413                         switch (item_type) {
 414                         case EditCursorItem:
 415                         case PlayheadCursorItem:
 416                                 start_cursor_grab (item, event);
 417                                 return true;
 418
 419                         case MarkerItem:
 420                                 if (Keyboard::modifier_state_equals (event->button.state,
 421                                                                      Keyboard::ModifierMask(Keyboard::Control|Keyboard::Shift))) {
 422                                         hide_marker (item, event);
 423                                 } else {
 424                                         start_marker_grab (item, event);
 425                                 }
 426                                 return true;
 427
 428                         case TempoMarkerItem:
 429                                 if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
 430                                         start_tempo_marker_copy_grab (item, event);
 431                                 } else {
 432                                         start_tempo_marker_grab (item, event);
 433                                 }
 434                                 return true;
 435
 436                         case MeterMarkerItem:
 437                                 if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
 438                                         start_meter_marker_copy_grab (item, event);
 439                                 } else {
 440                                         start_meter_marker_grab (item, event);
 441                                 }
 442                                 return true;
 443
 444                         case TempoBarItem:
 445                                 return true;
 446
 447                         case MeterBarItem:
 448                                 return true;
 449
 450                         case RangeMarkerBarItem:
 451                                 start_range_markerbar_op (item, event, CreateRangeMarker);
 452                                 return true;
 453                                 break;
 454
 455                         case TransportMarkerBarItem:
 456                                 start_range_markerbar_op (item, event, CreateTransportMarker);
 457                                 return true;
 458                                 break;
 459
 460                         default:
 461                                 break;
 462                         }
 463                 }
 464
 465                 switch (mouse_mode) {
 466                 case MouseRange:
 467                         switch (item_type) {
 468                         case StartSelectionTrimItem:
 469                                 start_selection_op (item, event, SelectionStartTrim);
 470                                 break;
 471
 472                         case EndSelectionTrimItem:
 473                                 start_selection_op (item, event, SelectionEndTrim);
 474                                 break;
 475
 476                         case SelectionItem:
 477                                 if (Keyboard::modifier_state_contains
 478                                     (event->button.state, Keyboard::ModifierMask(Keyboard::Alt))) {
 479                                         // contains and not equals because I can't use alt as a modifier alone.
 480                                         start_selection_grab (item, event);
 481                                 } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
 482                                         /* grab selection for moving */
 483                                         start_selection_op (item, event, SelectionMove);
 484                                 }
 485                                 else {
 486                                         /* this was debated, but decided the more common action was to
 487                                            make a new selection */
 488                                         start_selection_op (item, event, CreateSelection);
 489                                 }
 490                                 break;
 491
 492                         default:
 493                                 start_selection_op (item, event, CreateSelection);
 494                         }
 495                         return true;
 496                         break;
 497
 498                 case MouseObject:
 499                         if (Keyboard::modifier_state_contains (event->button.state,
 500                                                                Keyboard::ModifierMask(Keyboard::Control|Keyboard::Alt))
 501                                 && event->type == GDK_BUTTON_PRESS) {
 502
 503                                 start_rubberband_select (item, event);
 504
 505                         } else if (event->type == GDK_BUTTON_PRESS) {
 506
 507                                 switch (item_type) {
 508                                 case FadeInHandleItem:
 509                                         start_fade_in_grab (item, event);
 510                                         return true;
 511
 512                                 case FadeOutHandleItem:
 513                                         start_fade_out_grab (item, event);
 514                                         return true;
 515
 516                                 case RegionItem:
 517                                         if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
 518                                                 start_region_copy_grab (item, event);
 519                                         } else if (Keyboard::the_keyboard().key_is_down (GDK_b)) {
 520                                                 start_region_brush_grab (item, event);
 521                                         } else {
 522                                                 start_region_grab (item, event);
 523                                         }
 524                                         break;
 525
 526                                 case RegionViewNameHighlight:
 527                                         start_trim (item, event);
 528                                         return true;
 529                                         break;
 530
 531                                 case RegionViewName:
 532                                         /* rename happens on edit clicks */
 533                                                 start_trim (clicked_regionview->get_name_highlight(), event);
 534                                                 return true;
 535                                         break;
 536
 537                                 case GainAutomationControlPointItem:
 538                                 case PanAutomationControlPointItem:
 539                                 case RedirectAutomationControlPointItem:
 540                                         start_control_point_grab (item, event);
 541                                         return true;
 542                                         break;
 543
 544                                 case GainAutomationLineItem:
 545                                 case PanAutomationLineItem:
 546                                 case RedirectAutomationLineItem:
 547                                         start_line_grab_from_line (item, event);
 548                                         return true;
 549                                         break;
 550
 551                                 case StreamItem:
 552                                 case AutomationTrackItem:
 553                                         start_rubberband_select (item, event);
 554                                         break;
 555
 556                                 /* <CMT Additions> */
 557                                 case ImageFrameHandleStartItem:
 558                                         imageframe_start_handle_op(item, event) ;
 559                                         return(true) ;
 560                                         break ;
 561                                 case ImageFrameHandleEndItem:
 562                                         imageframe_end_handle_op(item, event) ;
 563                                         return(true) ;
 564                                         break ;
 565                                 case MarkerViewHandleStartItem:
 566                                         markerview_item_start_handle_op(item, event) ;
 567                                         return(true) ;
 568                                         break ;
 569                                 case MarkerViewHandleEndItem:
 570                                         markerview_item_end_handle_op(item, event) ;
 571                                         return(true) ;
 572                                         break ;
 573                                 /* </CMT Additions> */
 574
 575                                 /* <CMT Additions> */
 576                                 case MarkerViewItem:
 577                                         start_markerview_grab(item, event) ;
 578                                         break ;
 579                                 case ImageFrameItem:
 580                                         start_imageframe_grab(item, event) ;
 581                                         break ;
 582                                 /* </CMT Additions> */
 583
 584                                 case MarkerBarItem:
 585
 586                                         break;
 587
 588                                 default:
 589                                         break;
 590                                 }
 591                         }
 592                         return true;
 593                         break;
 594
 595                 case MouseGain:
 596                         switch (item_type) {
 597                         case RegionItem:
 598                                 // start_line_grab_from_regionview (item, event);
 599                                 break;
 600
 601                         case GainControlPointItem:
 602                                 start_control_point_grab (item, event);
 603                                 return true;
 604
 605                         case GainLineItem:
 606                                 start_line_grab_from_line (item, event);
 607                                 return true;
 608
 609                         case GainAutomationControlPointItem:
 610                         case PanAutomationControlPointItem:
 611                         case RedirectAutomationControlPointItem:
 612                                 start_control_point_grab (item, event);
 613                                 return true;
 614                                 break;
 615
 616                         default:
 617                                 break;
 618                         }
 619                         return true;
 620                         break;
 621
 622                         switch (item_type) {
 623                         case GainAutomationControlPointItem:
 624                         case PanAutomationControlPointItem:
 625                         case RedirectAutomationControlPointItem:
 626                                 start_control_point_grab (item, event);
 627                                 break;
 628
 629                         case GainAutomationLineItem:
 630                         case PanAutomationLineItem:
 631                         case RedirectAutomationLineItem:
 632                                 start_line_grab_from_line (item, event);
 633                                 break;
 634
 635                         case RegionItem:
 636                                 // XXX need automation mode to identify which
 637                                 // line to use
 638                                 // start_line_grab_from_regionview (item, event);
 639                                 break;
 640
 641                         default:
 642                                 break;
 643                         }
 644                         return true;
 645                         break;
 646
 647                 case MouseZoom:
 648                         if (event->type == GDK_BUTTON_PRESS) {
 649                                 start_mouse_zoom (item, event);
 650                         }
 651
 652                         return true;
 653                         break;
 654
 655                 case MouseTimeFX:
 656                         if (item_type == RegionItem) {
 657                                 start_time_fx (item, event);
 658                         }
 659                         break;
 660
 661                 case MouseAudition:
 662                         /* handled in release */
 663                         break;
 664
 665                 default:
 666                         break;
 667                 }
 668                 break;
 669
 670         case 2:
 671                 switch (mouse_mode) {
 672                 case MouseObject:
 673                         if (event->type == GDK_BUTTON_PRESS) {
 674                                 switch (item_type) {
 675                                 case RegionItem:
 676                                         if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
 677                                                 start_region_copy_grab (item, event);
 678                                         } else {
 679                                                 start_region_grab (item, event);
 680                                         }
 681
 682                                         break;
 683                                 case GainAutomationControlPointItem:
 684                                 case PanAutomationControlPointItem:
 685                                 case RedirectAutomationControlPointItem:
 686                                         start_control_point_grab (item, event);
 687                                         return true;
 688                                         break;
 689
 690                                 default:
 691                                         break;
 692                                 }
 693                         }
 694
 695
 696                         switch (item_type) {
 697                         case RegionViewNameHighlight:
 698                                 start_trim (item, event);
 699                                 return true;
 700                                 break;
 701
 702                         case RegionViewName:
 703                                 start_trim (clicked_regionview->get_name_highlight(), event);
 704                                 return true;
 705                                 break;
 706
 707                         default:
 708                                 break;
 709                         }
 710
 711                         break;
 712
 713                 case MouseRange:
 714                         if (event->type == GDK_BUTTON_PRESS) {
 715                                 /* relax till release */
 716                         }
 717                         return true;
 718                         break;
 719
 720
 721                 case MouseZoom:
 722                         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
 723                                 temporal_zoom_session();
 724                         } else {
 725                                 temporal_zoom_to_frame (true, event_frame(event));
 726                         }
 727                         return true;
 728                         break;
 729
 730                 default:
 731                         break;
 732                 }
 733
 734                 break;
 735
 736         case 3:
 737                 break;
 738
 739         case 4:
 740                 switch (mouse_mode) {
 741                 case MouseZoom:
 742                         //temporal_zoom_to_frame (true, where);
 743                         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
 744                                 temporal_zoom_to_frame (true, where);
 745                         }
 746                         else {
 747                                 temporal_zoom_step (true);
 748                         }
 749                         break;
 750                 default:
 751
 752                         if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::Alt))) {
 753                                 scroll_backward (0.6f);
 754                                 return true;
 755                         }
 756                         else if (Keyboard::no_modifier_keys_pressed (&event->button)) {
 757                                 scroll_tracks_up_line ();
 758                         } else {
 759                                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
 760                                         if (clicked_trackview) {
 761                                                 if (!current_stepping_trackview) {
 762                                                   step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
 763                                                         current_stepping_trackview = clicked_trackview;
 764                                                 }
 765                                                 gettimeofday (&last_track_height_step_timestamp, 0);
 766                                                 current_stepping_trackview->step_height (true);
 767                                         }
 768                                 }
 769                                 else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
 770                                         temporal_zoom_to_frame (true, where);
 771                                 }
 772                         }
 773                 }
 774                 break;
 775
 776         case 5:
 777                 switch (mouse_mode) {
 778                 case MouseZoom:
 779                         // temporal_zoom_to_frame (false, where);
 780                         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
 781                                 temporal_zoom_to_frame (false, where);
 782                         }
 783                         else {
 784                                 temporal_zoom_step (false);
 785                         }
 786                         break;
 787                 default:
 788
 789                         if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::Alt))) {
 790                                 scroll_forward (0.6f);
 791                                 return true;
 792                         }
 793                         else if (Keyboard::no_modifier_keys_pressed (&event->button)) {
 794                                 scroll_tracks_down_line ();
 795                         } else {
 796                                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
 797                                         if (clicked_trackview) {
 798                                                 if (!current_stepping_trackview) {
 799                                                   step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
 800                                                         current_stepping_trackview = clicked_trackview;
 801                                                 }
 802                                                 gettimeofday (&last_track_height_step_timestamp, 0);
 803                                                 current_stepping_trackview->step_height (false);
 804                                         }
 805                                 } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
 806                                         temporal_zoom_to_frame (false, where);
 807                                 }
 808                         }
 809                 }
 810                 break;
 811
 812         default:
 813                 break;
 814
 815         }
 816
 817         return false;
 818 }
 819
 820 bool
 821 Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
 822 {
 823         nframes_t where = event_frame (event, 0, 0);
 824
 825         /* no action if we're recording */
 826
 827         if (session && session->actively_recording()) {
 828                 return true;
 829         }
 830
 831         /* first, see if we're finishing a drag ... */
 832
 833         if (drag_info.item) {
 834                 if (end_grab (item, event)) {
 835                         /* grab dragged, so do nothing else */
 836                         return true;
 837                 }
 838         }
 839
 840         button_selection (item, event, item_type);
 841
 842         /* edit events get handled here */
 843
 844         if (drag_info.item == 0 && Keyboard::is_edit_event (&event->button)) {
 845                 switch (item_type) {
 846                 case RegionItem:
 847                         edit_region ();
 848                         break;
 849
 850                 case TempoMarkerItem:
 851                         edit_tempo_marker (item);
 852                         break;
 853
 854                 case MeterMarkerItem:
 855                         edit_meter_marker (item);
 856                         break;
 857
 858                 case RegionViewName:
 859                         if (clicked_regionview->name_active()) {
 860                                 return mouse_rename_region (item, event);
 861                         }
 862                         break;
 863
 864                 default:
 865                         break;
 866                 }
 867                 return true;
 868         }
 869
 870         /* context menu events get handled here */
 871
 872         if (Keyboard::is_context_menu_event (&event->button)) {
 873
 874                 if (drag_info.item == 0) {
 875
 876                         /* no matter which button pops up the context menu, tell the menu
 877                            widget to use button 1 to drive menu selection.
 878                         */
 879
 880                         switch (item_type) {
 881                         case FadeInItem:
 882                         case FadeInHandleItem:
 883                         case FadeOutItem:
 884                         case FadeOutHandleItem:
 885                                 popup_fade_context_menu (1, event->button.time, item, item_type);
 886                                 break;
 887
 888                         case StreamItem:
 889                                 popup_track_context_menu (1, event->button.time, item_type, false, where);
 890                                 break;
 891
 892                         case RegionItem:
 893                         case RegionViewNameHighlight:
 894                         case RegionViewName:
 895                                 popup_track_context_menu (1, event->button.time, item_type, false, where);
 896                                 break;
 897
 898                         case SelectionItem:
 899                                 popup_track_context_menu (1, event->button.time, item_type, true, where);
 900                                 break;
 901
 902                         case AutomationTrackItem:
 903                                 popup_track_context_menu (1, event->button.time, item_type, false, where);
 904                                 break;
 905
 906                         case MarkerBarItem:
 907                         case RangeMarkerBarItem:
 908                         case TransportMarkerBarItem:
 909                         case TempoBarItem:
 910                         case MeterBarItem:
 911                                 popup_ruler_menu (pixel_to_frame(event->button.x), item_type);
 912                                 break;
 913
 914                         case MarkerItem:
 915                                 marker_context_menu (&event->button, item);
 916                                 break;
 917
 918                         case TempoMarkerItem:
 919                                 tm_marker_context_menu (&event->button, item);
 920                                 break;
 921
 922                         case MeterMarkerItem:
 923                                 tm_marker_context_menu (&event->button, item);
 924                                 break;
 925
 926                         case CrossfadeViewItem:
 927                                 popup_track_context_menu (1, event->button.time, item_type, false, where);
 928                                 break;
 929
 930                         /* <CMT Additions> */
 931                         case ImageFrameItem:
 932                                 popup_imageframe_edit_menu(1, event->button.time, item, true) ;
 933                                 break ;
 934                         case ImageFrameTimeAxisItem:
 935                                 popup_imageframe_edit_menu(1, event->button.time, item, false) ;
 936                                 break ;
 937                         case MarkerViewItem:
 938                                 popup_marker_time_axis_edit_menu(1, event->button.time, item, true) ;
 939                                 break ;
 940                         case MarkerTimeAxisItem:
 941                                 popup_marker_time_axis_edit_menu(1, event->button.time, item, false) ;
 942                                 break ;
 943                         /* <CMT Additions> */
 944
 945
 946                         default:
 947                                 break;
 948                         }
 949
 950                         return true;
 951                 }
 952         }
 953
 954         /* delete events get handled here */
 955
 956         if (drag_info.item == 0 && Keyboard::is_delete_event (&event->button)) {
 957
 958                 switch (item_type) {
 959                 case TempoMarkerItem:
 960                         remove_tempo_marker (item);
 961                         break;
 962
 963                 case MeterMarkerItem:
 964                         remove_meter_marker (item);
 965                         break;
 966
 967                 case MarkerItem:
 968                         remove_marker (*item, event);
 969                         break;
 970
 971                 case RegionItem:
 972                         if (mouse_mode == MouseObject) {
 973                                 remove_clicked_region ();
 974                         }
 975                         break;
 976
 977                 case GainControlPointItem:
 978                         if (mouse_mode == MouseGain) {
 979                                 remove_gain_control_point (item, event);
 980                         }
 981                         break;
 982
 983                 case GainAutomationControlPointItem:
 984                 case PanAutomationControlPointItem:
 985                 case RedirectAutomationControlPointItem:
 986                         remove_control_point (item, event);
 987                         break;
 988
 989                 default:
 990                         break;
 991                 }
 992                 return true;
 993         }
 994
 995         switch (event->button.button) {
 996         case 1:
 997
 998                 switch (item_type) {
 999                 /* see comments in button_press_handler */
1000                 case EditCursorItem:
1001                 case PlayheadCursorItem:
1002                 case MarkerItem:
1003                 case GainLineItem:
1004                 case GainAutomationLineItem:
1005                 case PanAutomationLineItem:
1006                 case RedirectAutomationLineItem:
1007                 case StartSelectionTrimItem:
1008                 case EndSelectionTrimItem:
1009                         return true;
1010
1011                 case MarkerBarItem:
1012                         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
1013                                 snap_to (where, 0, true);
1014                         }
1015                         mouse_add_new_marker (where);
1016                         return true;
1017
1018                 case TempoBarItem:
1019                         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
1020                                 snap_to (where);
1021                         }
1022                         mouse_add_new_tempo_event (where);
1023                         return true;
1024
1025                 case MeterBarItem:
1026                         mouse_add_new_meter_event (pixel_to_frame (event->button.x));
1027                         return true;
1028                         break;
1029
1030                 default:
1031                         break;
1032                 }
1033
1034                 switch (mouse_mode) {
1035                 case MouseObject:
1036                         switch (item_type) {
1037                         case AutomationTrackItem:
1038                                 dynamic_cast<AutomationTimeAxisView*>(clicked_trackview)->add_automation_event
1039                                         (item,
1040                                          event,
1041                                          where,
1042                                          event->button.y);
1043                                 return true;
1044                                 break;
1045
1046                         default:
1047                                 break;
1048                         }
1049                         break;
1050
1051                 case MouseGain:
1052                         // Gain only makes sense for audio regions
1053                         if ( ! dynamic_cast<AudioRegionView*>(clicked_regionview))
1054                                 break;
1055
1056                         switch (item_type) {
1057                         case RegionItem:
1058                                 dynamic_cast<AudioRegionView*>(clicked_regionview)->add_gain_point_event (item, event);
1059                                 return true;
1060                                 break;
1061
1062                         case AutomationTrackItem:
1063                                 dynamic_cast<AutomationTimeAxisView*>(clicked_trackview)->
1064                                         add_automation_event (item, event, where, event->button.y);
1065                                 return true;
1066                                 break;
1067                         default:
1068                                 break;
1069                         }
1070                         break;
1071
1072                 case MouseAudition:
1073                         switch (item_type) {
1074                         case RegionItem:
1075                                 audition_selected_region ();
1076                                 break;
1077                         default:
1078                                 break;
1079                         }
1080                         break;
1081
1082                 default:
1083                         break;
1084
1085                 }
1086
1087                 return true;
1088                 break;
1089
1090
1091         case 2:
1092                 switch (mouse_mode) {
1093
1094                 case MouseObject:
1095                         switch (item_type) {
1096                         case RegionItem:
1097                                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
1098                                         raise_region ();
1099                                 } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::Shift|Keyboard::Alt))) {
1100                                         lower_region ();
1101                                 } else {
1102                                         // Button2 click is unused
1103                                 }
1104                                 return true;
1105
1106                                 break;
1107
1108                         default:
1109                                 break;
1110                         }
1111                         break;
1112
1113                 case MouseRange:
1114
1115                         // x_style_paste (where, 1.0);
1116                         return true;
1117                         break;
1118
1119                 default:
1120                         break;
1121                 }
1122
1123                 break;
1124
1125         case 3:
1126                 break;
1127
1128         default:
1129                 break;
1130         }
1131         return false;
1132 }
1133
1134 bool
1135 Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
1136 {
1137         ControlPoint* cp;
1138         Marker * marker;
1139         double fraction;
1140
1141         switch (item_type) {
1142         case GainControlPointItem:
1143                 if (mouse_mode == MouseGain) {
1144                         cp = static_cast<ControlPoint*>(item->get_data ("control_point"));
1145                         cp->set_visible (true);
1146
1147                         double at_x, at_y;
1148                         at_x = cp->get_x();
1149                         at_y = cp->get_y ();
1150                         cp->item->i2w (at_x, at_y);
1151                         at_x += 20.0;
1152                         at_y += 20.0;
1153
1154                         fraction = 1.0 - (cp->get_y() / cp->line.height());
1155
1156                         set_verbose_canvas_cursor (cp->line.get_verbose_cursor_string (fraction), at_x, at_y);
1157                         show_verbose_canvas_cursor ();
1158
1159                         if (is_drawable()) {
1160                                 track_canvas.get_window()->set_cursor (*fader_cursor);
1161                         }
1162                 }
1163                 break;
1164
1165         case GainAutomationControlPointItem:
1166         case PanAutomationControlPointItem:
1167         case RedirectAutomationControlPointItem:
1168                 cp = static_cast<ControlPoint*>(item->get_data ("control_point"));
1169                 cp->set_visible (true);
1170
1171                 double at_x, at_y;
1172                 at_x = cp->get_x();
1173                 at_y = cp->get_y ();
1174                 cp->item->i2w (at_x, at_y);
1175                 at_x += 20.0;
1176                 at_y += 20.0;
1177
1178                 fraction = 1.0 - (cp->get_y() / cp->line.height());
1179
1180                 set_verbose_canvas_cursor (cp->line.get_verbose_cursor_string (fraction), at_x, at_y);
1181                 show_verbose_canvas_cursor ();
1182
1183                 if (is_drawable()) {
1184                         track_canvas.get_window()->set_cursor (*fader_cursor);
1185                 }
1186                 break;
1187
1188         case GainLineItem:
1189                 if (mouse_mode == MouseGain) {
1190                         ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
1191                         if (line)
1192                                 line->property_fill_color_rgba() = color_map[cEnteredGainLine];
1193                         if (is_drawable()) {
1194                                 track_canvas.get_window()->set_cursor (*fader_cursor);
1195                         }
1196                 }
1197                 break;
1198
1199         case GainAutomationLineItem:
1200         case RedirectAutomationLineItem:
1201         case PanAutomationLineItem:
1202                 {
1203                         ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
1204                         if (line)
1205                                 line->property_fill_color_rgba() = color_map[cEnteredAutomationLine];
1206                 }
1207                 if (is_drawable()) {
1208                         track_canvas.get_window()->set_cursor (*fader_cursor);
1209                 }
1210                 break;
1211
1212         case RegionViewNameHighlight:
1213                 if (is_drawable() && mouse_mode == MouseObject) {
1214                         track_canvas.get_window()->set_cursor (*trimmer_cursor);
1215                 }
1216                 break;
1217
1218         case StartSelectionTrimItem:
1219         case EndSelectionTrimItem:
1220         /* <CMT Additions> */
1221         case ImageFrameHandleStartItem:
1222         case ImageFrameHandleEndItem:
1223         case MarkerViewHandleStartItem:
1224         case MarkerViewHandleEndItem:
1225         /* </CMT Additions> */
1226
1227                 if (is_drawable()) {
1228                         track_canvas.get_window()->set_cursor (*trimmer_cursor);
1229                 }
1230                 break;
1231
1232         case EditCursorItem:
1233         case PlayheadCursorItem:
1234                 if (is_drawable()) {
1235                         track_canvas.get_window()->set_cursor (*grabber_cursor);
1236                 }
1237                 break;
1238
1239         case RegionViewName:
1240
1241                 /* when the name is not an active item, the entire name highlight is for trimming */
1242
1243                 if (!reinterpret_cast<RegionView *> (item->get_data ("regionview"))->name_active()) {
1244                         if (mouse_mode == MouseObject && is_drawable()) {
1245                                 track_canvas.get_window()->set_cursor (*trimmer_cursor);
1246                         }
1247                 }
1248                 break;
1249
1250
1251         case AutomationTrackItem:
1252                 if (is_drawable()) {
1253                         Gdk::Cursor *cursor;
1254                         switch (mouse_mode) {
1255                         case MouseRange:
1256                                 cursor = selector_cursor;
1257                                 break;
1258                         case MouseZoom:
1259                                 cursor = zoom_cursor;
1260                                 break;
1261                         default:
1262                                 cursor = cross_hair_cursor;
1263                                 break;
1264                         }
1265
1266                         track_canvas.get_window()->set_cursor (*cursor);
1267
1268                         AutomationTimeAxisView* atv;
1269                         if ((atv = static_cast<AutomationTimeAxisView*>(item->get_data ("trackview"))) != 0) {
1270                                 clear_entered_track = false;
1271                                 set_entered_track (atv);
1272                         }
1273                 }
1274                 break;
1275
1276         case MarkerBarItem:
1277         case RangeMarkerBarItem:
1278         case TransportMarkerBarItem:
1279         case MeterBarItem:
1280         case TempoBarItem:
1281                 if (is_drawable()) {
1282                         time_canvas.get_window()->set_cursor (*timebar_cursor);
1283                 }
1284                 break;
1285
1286         case MarkerItem:
1287                 if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
1288                         break;
1289                 }
1290                 marker->set_color_rgba (color_map[cEnteredMarker]);
1291                 // fall through
1292         case MeterMarkerItem:
1293         case TempoMarkerItem:
1294                 if (is_drawable()) {
1295                         time_canvas.get_window()->set_cursor (*timebar_cursor);
1296                 }
1297                 break;
1298         case FadeInHandleItem:
1299         case FadeOutHandleItem:
1300                 if (mouse_mode == MouseObject) {
1301                         ArdourCanvas::SimpleRect *rect = dynamic_cast<ArdourCanvas::SimpleRect *> (item);
1302                         if (rect) {
1303                                 rect->property_fill_color_rgba() = 0;
1304                                 rect->property_outline_pixels() = 1;
1305                         }
1306                 }
1307                 break;
1308
1309         default:
1310                 break;
1311         }
1312
1313         /* second pass to handle entered track status in a comprehensible way.
1314          */
1315
1316         switch (item_type) {
1317         case GainLineItem:
1318         case GainAutomationLineItem:
1319         case RedirectAutomationLineItem:
1320         case PanAutomationLineItem:
1321         case GainControlPointItem:
1322         case GainAutomationControlPointItem:
1323         case PanAutomationControlPointItem:
1324         case RedirectAutomationControlPointItem:
1325                 /* these do not affect the current entered track state */
1326                 clear_entered_track = false;
1327                 break;
1328
1329         case AutomationTrackItem:
1330                 /* handled above already */
1331                 break;
1332
1333         default:
1334                 set_entered_track (0);
1335                 break;
1336         }
1337
1338         return false;
1339 }
1340
1341 bool
1342 Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
1343 {
1344         AutomationLine* al;
1345         ControlPoint* cp;
1346         Marker *marker;
1347         Location *loc;
1348         RegionView* rv;
1349         bool is_start;
1350
1351         switch (item_type) {
1352         case GainControlPointItem:
1353         case GainAutomationControlPointItem:
1354         case PanAutomationControlPointItem:
1355         case RedirectAutomationControlPointItem:
1356                 cp = reinterpret_cast<ControlPoint*>(item->get_data ("control_point"));
1357                 if (cp->line.npoints() > 1) {
1358                         if (!cp->selected) {
1359                                 cp->set_visible (false);
1360                         }
1361                 }
1362
1363                 if (is_drawable()) {
1364                         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
1365                 }
1366
1367                 hide_verbose_canvas_cursor ();
1368                 break;
1369
1370         case RegionViewNameHighlight:
1371         case StartSelectionTrimItem:
1372         case EndSelectionTrimItem:
1373         case EditCursorItem:
1374         case PlayheadCursorItem:
1375         /* <CMT Additions> */
1376         case ImageFrameHandleStartItem:
1377         case ImageFrameHandleEndItem:
1378         case MarkerViewHandleStartItem:
1379         case MarkerViewHandleEndItem:
1380         /* </CMT Additions> */
1381                 if (is_drawable()) {
1382                         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
1383                 }
1384                 break;
1385
1386         case GainLineItem:
1387         case GainAutomationLineItem:
1388         case RedirectAutomationLineItem:
1389         case PanAutomationLineItem:
1390                 al = reinterpret_cast<AutomationLine*> (item->get_data ("line"));
1391                 {
1392                         ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
1393                         if (line)
1394                                 line->property_fill_color_rgba() = al->get_line_color();
1395                 }
1396                 if (is_drawable()) {
1397                         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
1398                 }
1399                 break;
1400
1401         case RegionViewName:
1402                 /* see enter_handler() for notes */
1403                 if (!reinterpret_cast<RegionView *> (item->get_data ("regionview"))->name_active()) {
1404                         if (is_drawable() && mouse_mode == MouseObject) {
1405                                 track_canvas.get_window()->set_cursor (*current_canvas_cursor);
1406                         }
1407                 }
1408                 break;
1409
1410         case RangeMarkerBarItem:
1411         case TransportMarkerBarItem:
1412         case MeterBarItem:
1413         case TempoBarItem:
1414         case MarkerBarItem:
1415                 if (is_drawable()) {
1416                         time_canvas.get_window()->set_cursor (*timebar_cursor);
1417                 }
1418                 break;
1419
1420         case MarkerItem:
1421                 if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
1422                         break;
1423                 }
1424                 loc = find_location_from_marker (marker, is_start);
1425                 if (loc) location_flags_changed (loc, this);
1426                 // fall through
1427         case MeterMarkerItem:
1428         case TempoMarkerItem:
1429
1430                 if (is_drawable()) {
1431                         time_canvas.get_window()->set_cursor (*timebar_cursor);
1432                 }
1433
1434                 break;
1435
1436         case FadeInHandleItem:
1437         case FadeOutHandleItem:
1438                 rv = static_cast<RegionView*>(item->get_data ("regionview"));
1439                 {
1440                         ArdourCanvas::SimpleRect *rect = dynamic_cast<ArdourCanvas::SimpleRect *> (item);
1441                         if (rect) {
1442                                 rect->property_fill_color_rgba() = rv->get_fill_color();
1443                                 rect->property_outline_pixels() = 0;
1444                         }
1445                 }
1446                 break;
1447
1448         case AutomationTrackItem:
1449                 if (is_drawable()) {
1450                         track_canvas.get_window()->set_cursor (*current_canvas_cursor);
1451                         clear_entered_track = true;
1452                         Glib::signal_idle().connect (mem_fun(*this, &Editor::left_automation_track));
1453                 }
1454                 break;
1455
1456         default:
1457                 break;
1458         }
1459
1460         return false;
1461 }
1462
1463 gint
1464 Editor::left_automation_track ()
1465 {
1466         if (clear_entered_track) {
1467                 set_entered_track (0);
1468                 clear_entered_track = false;
1469         }
1470         return false;
1471 }
1472
1473 bool
1474 Editor::motion_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type, bool from_autoscroll)
1475 {
1476         gint x, y;
1477
1478         /* We call this so that MOTION_NOTIFY events continue to be
1479            delivered to the canvas. We need to do this because we set
1480            Gdk::POINTER_MOTION_HINT_MASK on the canvas. This reduces
1481            the density of the events, at the expense of a round-trip
1482            to the server. Given that this will mostly occur on cases
1483            where DISPLAY = :0.0, and given the cost of what the motion
1484            event might do, its a good tradeoff.
1485         */
1486
1487         track_canvas.get_pointer (x, y);
1488
1489         if (current_stepping_trackview) {
1490                 /* don't keep the persistent stepped trackview if the mouse moves */
1491                 current_stepping_trackview = 0;
1492                 step_timeout.disconnect ();
1493         }
1494
1495         if (session && session->actively_recording()) {
1496                 /* Sorry. no dragging stuff around while we record */
1497                 return true;
1498         }
1499
1500         drag_info.item_type = item_type;
1501         drag_info.current_pointer_frame = event_frame (event, &drag_info.current_pointer_x,
1502                                                        &drag_info.current_pointer_y);
1503
1504         if (!from_autoscroll && drag_info.item) {
1505                 /* item != 0 is the best test i can think of for dragging.
1506                 */
1507                 if (!drag_info.move_threshold_passed) {
1508
1509                         drag_info.move_threshold_passed = (abs ((int) (drag_info.current_pointer_x - drag_info.grab_x)) > 4);
1510
1511                         // and change the initial grab loc/frame if this drag info wants us to
1512
1513                         if (drag_info.want_move_threshold && drag_info.move_threshold_passed) {
1514                                 drag_info.grab_frame = drag_info.current_pointer_frame;
1515                                 drag_info.grab_x = drag_info.current_pointer_x;
1516                                 drag_info.grab_y = drag_info.current_pointer_y;
1517                                 drag_info.last_pointer_frame = drag_info.grab_frame;
1518                                 drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
1519                         }
1520                 }
1521         }
1522
1523         switch (item_type) {
1524         case PlayheadCursorItem:
1525         case EditCursorItem:
1526         case MarkerItem:
1527         case GainControlPointItem:
1528         case RedirectAutomationControlPointItem:
1529         case GainAutomationControlPointItem:
1530         case PanAutomationControlPointItem:
1531         case TempoMarkerItem:
1532         case MeterMarkerItem:
1533         case RegionViewNameHighlight:
1534         case StartSelectionTrimItem:
1535         case EndSelectionTrimItem:
1536         case SelectionItem:
1537         case GainLineItem:
1538         case RedirectAutomationLineItem:
1539         case GainAutomationLineItem:
1540         case PanAutomationLineItem:
1541         case FadeInHandleItem:
1542         case FadeOutHandleItem:
1543         /* <CMT Additions> */
1544         case ImageFrameHandleStartItem:
1545         case ImageFrameHandleEndItem:
1546         case MarkerViewHandleStartItem:
1547         case MarkerViewHandleEndItem:
1548         /* </CMT Additions> */
1549           if (drag_info.item && (event->motion.state & Gdk::BUTTON1_MASK ||
1550                                  (event->motion.state & Gdk::BUTTON2_MASK))) {
1551                   if (!from_autoscroll) {
1552                           maybe_autoscroll (event);
1553                   }
1554                   (this->*(drag_info.motion_callback)) (item, event);
1555                   goto handled;
1556           }
1557           goto not_handled;
1558
1559         default:
1560                 break;
1561         }
1562
1563         switch (mouse_mode) {
1564         case MouseObject:
1565         case MouseRange:
1566         case MouseZoom:
1567         case MouseTimeFX:
1568                 if (drag_info.item && (event->motion.state & GDK_BUTTON1_MASK ||
1569                                        (event->motion.state & GDK_BUTTON2_MASK))) {
1570                         if (!from_autoscroll) {
1571                                 maybe_autoscroll (event);
1572                         }
1573                         (this->*(drag_info.motion_callback)) (item, event);
1574                         goto handled;
1575                 }
1576                 goto not_handled;
1577                 break;
1578
1579         default:
1580                 break;
1581         }
1582
1583   handled:
1584         track_canvas_motion (event);
1585         // drag_info.last_pointer_frame = drag_info.current_pointer_frame;
1586         return true;
1587
1588   not_handled:
1589         return false;
1590 }
1591
1592 void
1593 Editor::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
1594 {
1595         if (drag_info.item == 0) {
1596                 fatal << _("programming error: start_grab called without drag item") << endmsg;
1597                 /*NOTREACHED*/
1598                 return;
1599         }
1600
1601         if (cursor == 0) {
1602                 cursor = grabber_cursor;
1603         }
1604
1605         // if dragging with button2, the motion is x constrained, with Alt-button2 it is y constrained
1606
1607         if (event->button.button == 2) {
1608                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Alt)) {
1609                         drag_info.y_constrained = true;
1610                         drag_info.x_constrained = false;
1611                 } else {
1612                         drag_info.y_constrained = false;
1613                         drag_info.x_constrained = true;
1614                 }
1615         } else {
1616                 drag_info.x_constrained = false;
1617                 drag_info.y_constrained = false;
1618         }
1619
1620         drag_info.grab_frame = event_frame(event, &drag_info.grab_x, &drag_info.grab_y);
1621         drag_info.last_pointer_frame = drag_info.grab_frame;
1622         drag_info.current_pointer_frame = drag_info.grab_frame;
1623         drag_info.current_pointer_x = drag_info.grab_x;
1624         drag_info.current_pointer_y = drag_info.grab_y;
1625         drag_info.cumulative_x_drag = 0;
1626         drag_info.cumulative_y_drag = 0;
1627         drag_info.first_move = true;
1628         drag_info.move_threshold_passed = false;
1629         drag_info.want_move_threshold = false;
1630         drag_info.pointer_frame_offset = 0;
1631         drag_info.brushing = false;
1632         drag_info.copied_location = 0;
1633
1634         drag_info.item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK,
1635                               *cursor,
1636                               event->button.time);
1637
1638         if (session && session->transport_rolling()) {
1639                 drag_info.was_rolling = true;
1640         } else {
1641                 drag_info.was_rolling = false;
1642         }
1643
1644         switch (snap_type) {
1645         case SnapToRegionStart:
1646         case SnapToRegionEnd:
1647         case SnapToRegionSync:
1648         case SnapToRegionBoundary:
1649                 build_region_boundary_cache ();
1650                 break;
1651         default:
1652                 break;
1653         }
1654 }
1655
1656 void
1657 Editor::swap_grab (ArdourCanvas::Item* new_item, Gdk::Cursor* cursor, uint32_t time)
1658 {
1659         drag_info.item->ungrab (0);
1660         drag_info.item = new_item;
1661
1662         if (cursor == 0) {
1663                 cursor = grabber_cursor;
1664         }
1665
1666         drag_info.item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK, *cursor, time);
1667 }
1668
1669 bool
1670 Editor::end_grab (ArdourCanvas::Item* item, GdkEvent* event)
1671 {
1672         bool did_drag = false;
1673
1674         stop_canvas_autoscroll ();
1675
1676         if (drag_info.item == 0) {
1677                 return false;
1678         }
1679
1680         drag_info.item->ungrab (event->button.time);
1681
1682         if (drag_info.finished_callback) {
1683                 (this->*(drag_info.finished_callback)) (item, event);
1684         }
1685
1686         did_drag = !drag_info.first_move;
1687
1688         hide_verbose_canvas_cursor();
1689
1690         drag_info.item = 0;
1691         drag_info.copy = false;
1692         drag_info.motion_callback = 0;
1693         drag_info.finished_callback = 0;
1694         drag_info.last_trackview = 0;
1695         drag_info.last_frame_position = 0;
1696         drag_info.grab_frame = 0;
1697         drag_info.last_pointer_frame = 0;
1698         drag_info.current_pointer_frame = 0;
1699         drag_info.brushing = false;
1700
1701         if (drag_info.copied_location) {
1702                 delete drag_info.copied_location;
1703                 drag_info.copied_location = 0;
1704         }
1705
1706         return did_drag;
1707 }
1708
1709 void
1710 Editor::set_edit_cursor (GdkEvent* event)
1711 {
1712         nframes_t pointer_frame = event_frame (event);
1713
1714         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
1715                 if (snap_type != SnapToEditCursor) {
1716                         snap_to (pointer_frame);
1717                 }
1718         }
1719
1720         edit_cursor->set_position (pointer_frame);
1721         edit_cursor_clock.set (pointer_frame);
1722 }
1723
1724 void
1725 Editor::set_playhead_cursor (GdkEvent* event)
1726 {
1727         nframes_t pointer_frame = event_frame (event);
1728
1729         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
1730                 snap_to (pointer_frame);
1731         }
1732
1733         if (session) {
1734                 session->request_locate (pointer_frame, session->transport_rolling());
1735         }
1736 }
1737
1738 void
1739 Editor::start_fade_in_grab (ArdourCanvas::Item* item, GdkEvent* event)
1740 {
1741         drag_info.item = item;
1742         drag_info.motion_callback = &Editor::fade_in_drag_motion_callback;
1743         drag_info.finished_callback = &Editor::fade_in_drag_finished_callback;
1744
1745         start_grab (event);
1746
1747         if ((drag_info.data = (item->get_data ("regionview"))) == 0) {
1748                 fatal << _("programming error: fade in canvas item has no regionview data pointer!") << endmsg;
1749                 /*NOTREACHED*/
1750         }
1751
1752         AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
1753
1754         drag_info.pointer_frame_offset = drag_info.grab_frame - ((nframes_t) arv->audio_region()->fade_in().back()->when + arv->region()->position());
1755 }
1756
1757 void
1758 Editor::fade_in_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
1759 {
1760         AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
1761         nframes_t pos;
1762         nframes_t fade_length;
1763
1764         if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
1765                 pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
1766         }
1767         else {
1768                 pos = 0;
1769         }
1770
1771         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
1772                 snap_to (pos);
1773         }
1774
1775         if (pos < (arv->region()->position() + 64)) {
1776                 fade_length = 64; // this should be a minimum defined somewhere
1777         } else if (pos > arv->region()->last_frame()) {
1778                 fade_length = arv->region()->length();
1779         } else {
1780                 fade_length = pos - arv->region()->position();
1781         }
1782
1783         arv->reset_fade_in_shape_width (fade_length);
1784
1785         show_verbose_duration_cursor (arv->region()->position(),  arv->region()->position() + fade_length, 10);
1786
1787         drag_info.first_move = false;
1788 }
1789
1790 void
1791 Editor::fade_in_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
1792 {
1793         if (drag_info.first_move) return;
1794
1795         AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
1796         nframes_t pos;
1797         nframes_t fade_length;
1798
1799         if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
1800                 pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
1801         }
1802         else {
1803                 pos = 0;
1804         }
1805
1806         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
1807                 snap_to (pos);
1808         }
1809
1810         if (pos < (arv->region()->position() + 64)) {
1811                 fade_length = 64; // this should be a minimum defined somewhere
1812         }
1813         else if (pos > arv->region()->last_frame()) {
1814                 fade_length = arv->region()->length();
1815         }
1816         else {
1817                 fade_length = pos - arv->region()->position();
1818         }
1819
1820         begin_reversible_command (_("change fade in length"));
1821         AutomationList& alist = arv->audio_region()->fade_in();
1822         XMLNode &before = alist.get_state();
1823
1824         arv->audio_region()->set_fade_in_length (fade_length);
1825
1826         XMLNode &after = alist.get_state();
1827         session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
1828         commit_reversible_command ();
1829         fade_in_drag_motion_callback (item, event);
1830 }
1831
1832 void
1833 Editor::start_fade_out_grab (ArdourCanvas::Item* item, GdkEvent* event)
1834 {
1835         drag_info.item = item;
1836         drag_info.motion_callback = &Editor::fade_out_drag_motion_callback;
1837         drag_info.finished_callback = &Editor::fade_out_drag_finished_callback;
1838
1839         start_grab (event);
1840
1841         if ((drag_info.data = (item->get_data ("regionview"))) == 0) {
1842                 fatal << _("programming error: fade out canvas item has no regionview data pointer!") << endmsg;
1843                 /*NOTREACHED*/
1844         }
1845
1846         AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
1847
1848         drag_info.pointer_frame_offset = drag_info.grab_frame - (arv->region()->length() - (nframes_t) arv->audio_region()->fade_out().back()->when + arv->region()->position());
1849 }
1850
1851 void
1852 Editor::fade_out_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
1853 {
1854         AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
1855         nframes_t pos;
1856         nframes_t fade_length;
1857
1858         if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
1859                 pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
1860         }
1861         else {
1862                 pos = 0;
1863         }
1864
1865         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
1866                 snap_to (pos);
1867         }
1868
1869         if (pos > (arv->region()->last_frame() - 64)) {
1870                 fade_length = 64; // this should really be a minimum fade defined somewhere
1871         }
1872         else if (pos < arv->region()->position()) {
1873                 fade_length = arv->region()->length();
1874         }
1875         else {
1876                 fade_length = arv->region()->last_frame() - pos;
1877         }
1878
1879         arv->reset_fade_out_shape_width (fade_length);
1880
1881         show_verbose_duration_cursor (arv->region()->last_frame() - fade_length, arv->region()->last_frame(), 10);
1882
1883         drag_info.first_move = false;
1884 }
1885
1886 void
1887 Editor::fade_out_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
1888 {
1889         if (drag_info.first_move) return;
1890
1891         AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
1892         nframes_t pos;
1893         nframes_t fade_length;
1894
1895         if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
1896                 pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
1897         }
1898         else {
1899                 pos = 0;
1900         }
1901
1902         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
1903                 snap_to (pos);
1904         }
1905
1906         if (pos > (arv->region()->last_frame() - 64)) {
1907                 fade_length = 64; // this should really be a minimum fade defined somewhere
1908         }
1909         else if (pos < arv->region()->position()) {
1910                 fade_length = arv->region()->length();
1911         }
1912         else {
1913                 fade_length = arv->region()->last_frame() - pos;
1914         }
1915
1916         begin_reversible_command (_("change fade out length"));
1917         AutomationList& alist = arv->audio_region()->fade_out();
1918         XMLNode &before = alist.get_state();
1919
1920         arv->audio_region()->set_fade_out_length (fade_length);
1921
1922         XMLNode &after = alist.get_state();
1923         session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
1924         commit_reversible_command ();
1925
1926         fade_out_drag_motion_callback (item, event);
1927 }
1928
1929 void
1930 Editor::start_cursor_grab (ArdourCanvas::Item* item, GdkEvent* event)
1931 {
1932         drag_info.item = item;
1933         drag_info.motion_callback = &Editor::cursor_drag_motion_callback;
1934         drag_info.finished_callback = &Editor::cursor_drag_finished_callback;
1935
1936         start_grab (event);
1937
1938         if ((drag_info.data = (item->get_data ("cursor"))) == 0) {
1939                 fatal << _("programming error: cursor canvas item has no cursor data pointer!") << endmsg;
1940                 /*NOTREACHED*/
1941         }
1942
1943         Cursor* cursor = (Cursor *) drag_info.data;
1944
1945         if (session && cursor == playhead_cursor) {
1946                 if (drag_info.was_rolling) {
1947                         session->request_stop ();
1948                 }
1949         }
1950
1951         drag_info.pointer_frame_offset = drag_info.grab_frame - cursor->current_frame;
1952
1953         show_verbose_time_cursor (cursor->current_frame, 10);
1954 }
1955
1956 void
1957 Editor::cursor_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
1958 {
1959         Cursor* cursor = (Cursor *) drag_info.data;
1960         nframes_t adjusted_frame;
1961
1962         if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
1963                 adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
1964         }
1965         else {
1966                 adjusted_frame = 0;
1967         }
1968
1969         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
1970                 if (cursor != edit_cursor || snap_type != SnapToEditCursor) {
1971                         snap_to (adjusted_frame);
1972                 }
1973         }
1974
1975         if (adjusted_frame == drag_info.last_pointer_frame) return;
1976
1977         cursor->set_position (adjusted_frame);
1978
1979         if (cursor == edit_cursor) {
1980                 edit_cursor_clock.set (cursor->current_frame);
1981         }
1982
1983         show_verbose_time_cursor (cursor->current_frame, 10);
1984
1985         drag_info.last_pointer_frame = adjusted_frame;
1986         drag_info.first_move = false;
1987 }
1988
1989 void
1990 Editor::cursor_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
1991 {
1992         if (drag_info.first_move) return;
1993
1994         cursor_drag_motion_callback (item, event);
1995
1996         if (item == &playhead_cursor->canvas_item) {
1997                 if (session) {
1998                         session->request_locate (playhead_cursor->current_frame, drag_info.was_rolling);
1999                 }
2000         } else if (item == &edit_cursor->canvas_item) {
2001                 edit_cursor->set_position (edit_cursor->current_frame);
2002                 edit_cursor_clock.set (edit_cursor->current_frame);
2003         }
2004 }
2005
2006 void
2007 Editor::update_marker_drag_item (Location *location)
2008 {
2009         double x1 = frame_to_pixel (location->start());
2010         double x2 = frame_to_pixel (location->end());
2011
2012         if (location->is_mark()) {
2013                 marker_drag_line_points.front().set_x(x1);
2014                 marker_drag_line_points.back().set_x(x1);
2015                 marker_drag_line->property_points() = marker_drag_line_points;
2016         }
2017         else {
2018                 range_marker_drag_rect->property_x1() = x1;
2019                 range_marker_drag_rect->property_x2() = x2;
2020         }
2021 }
2022
2023 void
2024 Editor::start_marker_grab (ArdourCanvas::Item* item, GdkEvent* event)
2025 {
2026         Marker* marker;
2027
2028         if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
2029                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
2030                 /*NOTREACHED*/
2031         }
2032
2033         bool is_start;
2034
2035         Location  *location = find_location_from_marker (marker, is_start);
2036
2037         drag_info.item = item;
2038         drag_info.data = marker;
2039         drag_info.motion_callback = &Editor::marker_drag_motion_callback;
2040         drag_info.finished_callback = &Editor::marker_drag_finished_callback;
2041
2042         start_grab (event);
2043
2044         drag_info.copied_location = new Location (*location);
2045         drag_info.pointer_frame_offset = drag_info.grab_frame - (is_start ? location->start() : location->end());
2046
2047         update_marker_drag_item (location);
2048
2049         if (location->is_mark()) {
2050                 marker_drag_line->show();
2051                 marker_drag_line->raise_to_top();
2052         }
2053         else {
2054                 range_marker_drag_rect->show();
2055                 range_marker_drag_rect->raise_to_top();
2056         }
2057
2058         if (is_start) show_verbose_time_cursor (location->start(), 10);
2059         else show_verbose_time_cursor (location->end(), 10);
2060 }
2061
2062 void
2063 Editor::marker_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
2064 {
2065         nframes_t f_delta;
2066         Marker* marker = (Marker *) drag_info.data;
2067         Location  *real_location;
2068         Location  *copy_location;
2069         bool is_start;
2070         bool move_both = false;
2071
2072
2073         nframes_t newframe;
2074         if (drag_info.pointer_frame_offset <= (long) drag_info.current_pointer_frame) {
2075                 newframe = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
2076         }
2077         else {
2078                 newframe = 0;
2079         }
2080
2081         nframes_t next = newframe;
2082
2083         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
2084                 snap_to (newframe, 0, true);
2085         }
2086
2087         if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) {
2088                 return;
2089         }
2090
2091         /* call this to find out if its the start or end */
2092
2093         real_location = find_location_from_marker (marker, is_start);
2094
2095         /* use the copy that we're "dragging" around */
2096
2097         copy_location = drag_info.copied_location;
2098
2099         f_delta = copy_location->end() - copy_location->start();
2100
2101         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
2102                 move_both = true;
2103         }
2104
2105         if (copy_location->is_mark()) {
2106                 /* just move it */
2107
2108                 copy_location->set_start (newframe);
2109
2110         } else {
2111
2112                 if (is_start) { // start-of-range marker
2113
2114                         if (move_both) {
2115                                 copy_location->set_start (newframe);
2116                                 copy_location->set_end (newframe + f_delta);
2117                         } else  if (newframe < copy_location->end()) {
2118                                 copy_location->set_start (newframe);
2119                         } else {
2120                                 snap_to (next, 1, true);
2121                                 copy_location->set_end (next);
2122                                 copy_location->set_start (newframe);
2123                         }
2124
2125                 } else { // end marker
2126
2127                         if (move_both) {
2128                                 copy_location->set_end (newframe);
2129                                 copy_location->set_start (newframe - f_delta);
2130                         } else if (newframe > copy_location->start()) {
2131                                 copy_location->set_end (newframe);
2132
2133                         } else if (newframe > 0) {
2134                                 snap_to (next, -1, true);
2135                                 copy_location->set_start (next);
2136                                 copy_location->set_end (newframe);
2137                         }
2138                 }
2139         }
2140
2141         drag_info.last_pointer_frame = drag_info.current_pointer_frame;
2142         drag_info.first_move = false;
2143
2144         update_marker_drag_item (copy_location);
2145
2146         LocationMarkers* lm = find_location_markers (real_location);
2147         lm->set_position (copy_location->start(), copy_location->end());
2148
2149         show_verbose_time_cursor (newframe, 10);
2150 }
2151
2152 void
2153 Editor::marker_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
2154 {
2155         if (drag_info.first_move) {
2156                 marker_drag_motion_callback (item, event);
2157
2158         }
2159
2160         Marker* marker = (Marker *) drag_info.data;
2161         bool is_start;
2162
2163
2164         begin_reversible_command ( _("move marker") );
2165         XMLNode &before = session->locations()->get_state();
2166
2167         Location * location = find_location_from_marker (marker, is_start);
2168
2169         if (location) {
2170                 if (location->is_mark()) {
2171                         location->set_start (drag_info.copied_location->start());
2172                 } else {
2173                         location->set (drag_info.copied_location->start(), drag_info.copied_location->end());
2174                 }
2175         }
2176
2177         XMLNode &after = session->locations()->get_state();
2178         session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
2179         commit_reversible_command ();
2180
2181         marker_drag_line->hide();
2182         range_marker_drag_rect->hide();
2183 }
2184
2185 void
2186 Editor::start_meter_marker_grab (ArdourCanvas::Item* item, GdkEvent* event)
2187 {
2188         Marker* marker;
2189         MeterMarker* meter_marker;
2190
2191         if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
2192                 fatal << _("programming error: meter marker canvas item has no marker object pointer!") << endmsg;
2193                 /*NOTREACHED*/
2194         }
2195
2196         meter_marker = dynamic_cast<MeterMarker*> (marker);
2197
2198         MetricSection& section (meter_marker->meter());
2199
2200         if (!section.movable()) {
2201                 return;
2202         }
2203
2204         drag_info.item = item;
2205         drag_info.data = marker;
2206         drag_info.motion_callback = &Editor::meter_marker_drag_motion_callback;
2207         drag_info.finished_callback = &Editor::meter_marker_drag_finished_callback;
2208
2209         start_grab (event);
2210
2211         drag_info.pointer_frame_offset = drag_info.grab_frame - meter_marker->meter().frame();
2212
2213         show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
2214 }
2215
2216 void
2217 Editor::start_meter_marker_copy_grab (ArdourCanvas::Item* item, GdkEvent* event)
2218 {
2219         Marker* marker;
2220         MeterMarker* meter_marker;
2221
2222         if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
2223                 fatal << _("programming error: meter marker canvas item has no marker object pointer!") << endmsg;
2224                 /*NOTREACHED*/
2225         }
2226
2227         meter_marker = dynamic_cast<MeterMarker*> (marker);
2228
2229         // create a dummy marker for visual representation of moving the copy.
2230         // The actual copying is not done before we reach the finish callback.
2231         char name[64];
2232         snprintf (name, sizeof(name), "%g/%g", meter_marker->meter().beats_per_bar(), meter_marker->meter().note_divisor ());
2233         MeterMarker* new_marker = new MeterMarker(*this, *meter_group, color_map[cMeterMarker], name,
2234                                                   *new MeterSection(meter_marker->meter()));
2235
2236         drag_info.item = &new_marker->the_item();
2237         drag_info.copy = true;
2238         drag_info.data = new_marker;
2239         drag_info.motion_callback = &Editor::meter_marker_drag_motion_callback;
2240         drag_info.finished_callback = &Editor::meter_marker_drag_finished_callback;
2241
2242         start_grab (event);
2243
2244         drag_info.pointer_frame_offset = drag_info.grab_frame - meter_marker->meter().frame();
2245
2246         show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
2247 }
2248
2249 void
2250 Editor::meter_marker_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
2251 {
2252         MeterMarker* marker = (MeterMarker *) drag_info.data;
2253         nframes_t adjusted_frame;
2254
2255         if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
2256                 adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
2257         }
2258         else {
2259                 adjusted_frame = 0;
2260         }
2261
2262         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
2263                 snap_to (adjusted_frame);
2264         }
2265
2266         if (adjusted_frame == drag_info.last_pointer_frame) return;
2267
2268         marker->set_position (adjusted_frame);
2269
2270
2271         drag_info.last_pointer_frame = adjusted_frame;
2272         drag_info.first_move = false;
2273
2274         show_verbose_time_cursor (adjusted_frame, 10);
2275 }
2276
2277 void
2278 Editor::meter_marker_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
2279 {
2280         if (drag_info.first_move) return;
2281
2282         meter_marker_drag_motion_callback (drag_info.item, event);
2283
2284         MeterMarker* marker = (MeterMarker *) drag_info.data;
2285         BBT_Time when;
2286
2287         TempoMap& map (session->tempo_map());
2288         map.bbt_time (drag_info.last_pointer_frame, when);
2289
2290         if (drag_info.copy == true) {
2291                 begin_reversible_command (_("copy meter mark"));
2292                 XMLNode &before = map.get_state();
2293                 map.add_meter (marker->meter(), when);
2294                 XMLNode &after = map.get_state();
2295                 session->add_command(new MementoCommand<TempoMap>(map, &before, &after));
2296                 commit_reversible_command ();
2297
2298                 // delete the dummy marker we used for visual representation of copying.
2299                 // a new visual marker will show up automatically.
2300                 delete marker;
2301         } else {
2302                 begin_reversible_command (_("move meter mark"));
2303                 XMLNode &before = map.get_state();
2304                 map.move_meter (marker->meter(), when);
2305                 XMLNode &after = map.get_state();
2306                 session->add_command(new MementoCommand<TempoMap>(map, &before, &after));
2307                 commit_reversible_command ();
2308         }
2309 }
2310
2311 void
2312 Editor::start_tempo_marker_grab (ArdourCanvas::Item* item, GdkEvent* event)
2313 {
2314         Marker* marker;
2315         TempoMarker* tempo_marker;
2316
2317         if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
2318                 fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg;
2319                 /*NOTREACHED*/
2320         }
2321
2322         if ((tempo_marker = dynamic_cast<TempoMarker *> (marker)) == 0) {
2323                 fatal << _("programming error: marker for tempo is not a tempo marker!") << endmsg;
2324                 /*NOTREACHED*/
2325         }
2326
2327         MetricSection& section (tempo_marker->tempo());
2328
2329         if (!section.movable()) {
2330                 return;
2331         }
2332
2333         drag_info.item = item;
2334         drag_info.data = marker;
2335         drag_info.motion_callback = &Editor::tempo_marker_drag_motion_callback;
2336         drag_info.finished_callback = &Editor::tempo_marker_drag_finished_callback;
2337
2338         start_grab (event);
2339
2340         drag_info.pointer_frame_offset = drag_info.grab_frame - tempo_marker->tempo().frame();
2341         show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
2342 }
2343
2344 void
2345 Editor::start_tempo_marker_copy_grab (ArdourCanvas::Item* item, GdkEvent* event)
2346 {
2347         Marker* marker;
2348         TempoMarker* tempo_marker;
2349
2350         if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
2351                 fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg;
2352                 /*NOTREACHED*/
2353         }
2354
2355         if ((tempo_marker = dynamic_cast<TempoMarker *> (marker)) == 0) {
2356                 fatal << _("programming error: marker for tempo is not a tempo marker!") << endmsg;
2357                 /*NOTREACHED*/
2358         }
2359
2360         // create a dummy marker for visual representation of moving the copy.
2361         // The actual copying is not done before we reach the finish callback.
2362         char name[64];
2363         snprintf (name, sizeof (name), "%.2f", tempo_marker->tempo().beats_per_minute());
2364         TempoMarker* new_marker = new TempoMarker(*this, *tempo_group, color_map[cTempoMarker], name,
2365                                                   *new TempoSection(tempo_marker->tempo()));
2366
2367         drag_info.item = &new_marker->the_item();
2368         drag_info.copy = true;
2369         drag_info.data = new_marker;
2370         drag_info.motion_callback = &Editor::tempo_marker_drag_motion_callback;
2371         drag_info.finished_callback = &Editor::tempo_marker_drag_finished_callback;
2372
2373         start_grab (event);
2374
2375         drag_info.pointer_frame_offset = drag_info.grab_frame - tempo_marker->tempo().frame();
2376
2377         show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
2378 }
2379
2380 void
2381 Editor::tempo_marker_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
2382 {
2383         TempoMarker* marker = (TempoMarker *) drag_info.data;
2384         nframes_t adjusted_frame;
2385
2386         if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
2387                 adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
2388         }
2389         else {
2390                 adjusted_frame = 0;
2391         }
2392
2393         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
2394                 snap_to (adjusted_frame);
2395         }
2396
2397         if (adjusted_frame == drag_info.last_pointer_frame) return;
2398
2399         /* OK, we've moved far enough to make it worth actually move the thing. */
2400
2401         marker->set_position (adjusted_frame);
2402
2403         show_verbose_time_cursor (adjusted_frame, 10);
2404
2405         drag_info.last_pointer_frame = adjusted_frame;
2406         drag_info.first_move = false;
2407 }
2408
2409 void
2410 Editor::tempo_marker_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
2411 {
2412         if (drag_info.first_move) return;
2413
2414         tempo_marker_drag_motion_callback (drag_info.item, event);
2415
2416         TempoMarker* marker = (TempoMarker *) drag_info.data;
2417         BBT_Time when;
2418
2419         TempoMap& map (session->tempo_map());
2420         map.bbt_time (drag_info.last_pointer_frame, when);
2421
2422         if (drag_info.copy == true) {
2423                 begin_reversible_command (_("copy tempo mark"));
2424                 XMLNode &before = map.get_state();
2425                 map.add_tempo (marker->tempo(), when);
2426                 XMLNode &after = map.get_state();
2427                 session->add_command (new MementoCommand<TempoMap>(map, &before, &after));
2428                 commit_reversible_command ();
2429
2430                 // delete the dummy marker we used for visual representation of copying.
2431                 // a new visual marker will show up automatically.
2432                 delete marker;
2433         } else {
2434                 begin_reversible_command (_("move tempo mark"));
2435                 XMLNode &before = map.get_state();
2436                 map.move_tempo (marker->tempo(), when);
2437                 XMLNode &after = map.get_state();
2438                 session->add_command (new MementoCommand<TempoMap>(map, &before, &after));
2439                 commit_reversible_command ();
2440         }
2441 }
2442
2443 void
2444 Editor::remove_gain_control_point (ArdourCanvas::Item*item, GdkEvent* event)
2445 {
2446         ControlPoint* control_point;
2447
2448         if ((control_point = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"))) == 0) {
2449                 fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
2450                 /*NOTREACHED*/
2451         }
2452
2453         // We shouldn't remove the first or last gain point
2454         if (control_point->line.is_last_point(*control_point) ||
2455                 control_point->line.is_first_point(*control_point)) {
2456                 return;
2457         }
2458
2459         control_point->line.remove_point (*control_point);
2460 }
2461
2462 void
2463 Editor::remove_control_point (ArdourCanvas::Item*item, GdkEvent* event)
2464 {
2465         ControlPoint* control_point;
2466
2467         if ((control_point = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"))) == 0) {
2468                 fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
2469                 /*NOTREACHED*/
2470         }
2471
2472         control_point->line.remove_point (*control_point);
2473 }
2474
2475 void
2476 Editor::start_control_point_grab (ArdourCanvas::Item* item, GdkEvent* event)
2477 {
2478         ControlPoint* control_point;
2479
2480         if ((control_point = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"))) == 0) {
2481                 fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
2482                 /*NOTREACHED*/
2483         }
2484
2485         drag_info.item = item;
2486         drag_info.data = control_point;
2487         drag_info.motion_callback = &Editor::control_point_drag_motion_callback;
2488         drag_info.finished_callback = &Editor::control_point_drag_finished_callback;
2489
2490         start_grab (event, fader_cursor);
2491
2492         control_point->line.start_drag (control_point, 0);
2493
2494         float fraction = 1.0 - (control_point->get_y() / control_point->line.height());
2495         set_verbose_canvas_cursor (control_point->line.get_verbose_cursor_string (fraction),
2496                                    drag_info.current_pointer_x + 20, drag_info.current_pointer_y + 20);
2497
2498         show_verbose_canvas_cursor ();
2499 }
2500
2501 void
2502 Editor::control_point_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
2503 {
2504         ControlPoint* cp = reinterpret_cast<ControlPoint *> (drag_info.data);
2505
2506         double cx = drag_info.current_pointer_x;
2507         double cy = drag_info.current_pointer_y;
2508
2509         drag_info.cumulative_x_drag = cx - drag_info.grab_x ;
2510         drag_info.cumulative_y_drag = cy - drag_info.grab_y ;
2511
2512         if (drag_info.x_constrained) {
2513                 cx = drag_info.grab_x;
2514         }
2515         if (drag_info.y_constrained) {
2516                 cy = drag_info.grab_y;
2517         }
2518
2519         cp->line.parent_group().w2i (cx, cy);
2520
2521         cx = max (0.0, cx);
2522         cy = max (0.0, cy);
2523         cy = min ((double) cp->line.height(), cy);
2524
2525         //translate cx to frames
2526         nframes_t cx_frames = unit_to_frame (cx);
2527
2528         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()) && !drag_info.x_constrained) {
2529                 snap_to (cx_frames);
2530         }
2531
2532         float fraction = 1.0 - (cy / cp->line.height());
2533
2534         bool push;
2535
2536         if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
2537                 push = true;
2538         } else {
2539                 push = false;
2540         }
2541
2542         cp->line.point_drag (*cp, cx_frames , fraction, push);
2543
2544         set_verbose_canvas_cursor_text (cp->line.get_verbose_cursor_string (fraction));
2545
2546         drag_info.first_move = false;
2547 }
2548
2549 void
2550 Editor::control_point_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
2551 {
2552         ControlPoint* cp = reinterpret_cast<ControlPoint *> (drag_info.data);
2553
2554         if (drag_info.first_move) {
2555
2556                 /* just a click */
2557
2558                 if ((event->type == GDK_BUTTON_RELEASE) && (event->button.button == 1) && Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
2559                         reset_point_selection ();
2560                 }
2561
2562         } else {
2563                 control_point_drag_motion_callback (item, event);
2564         }
2565         cp->line.end_drag (cp);
2566 }
2567
2568 void
2569 Editor::start_line_grab_from_regionview (ArdourCanvas::Item* item, GdkEvent* event)
2570 {
2571         switch (mouse_mode) {
2572         case MouseGain:
2573                 assert(dynamic_cast<AudioRegionView*>(clicked_regionview));
2574                 start_line_grab (dynamic_cast<AudioRegionView*>(clicked_regionview)->get_gain_line(), event);
2575                 break;
2576         default:
2577                 break;
2578         }
2579 }
2580
2581 void
2582 Editor::start_line_grab_from_line (ArdourCanvas::Item* item, GdkEvent* event)
2583 {
2584         AutomationLine* al;
2585
2586         if ((al = reinterpret_cast<AutomationLine*> (item->get_data ("line"))) == 0) {
2587                 fatal << _("programming error: line canvas item has no line pointer!") << endmsg;
2588                 /*NOTREACHED*/
2589         }
2590
2591         start_line_grab (al, event);
2592 }
2593
2594 void
2595 Editor::start_line_grab (AutomationLine* line, GdkEvent* event)
2596 {
2597         double cx;
2598         double cy;
2599         nframes_t frame_within_region;
2600
2601         /* need to get x coordinate in terms of parent (TimeAxisItemView)
2602            origin.
2603         */
2604
2605         cx = event->button.x;
2606         cy = event->button.y;
2607         line->parent_group().w2i (cx, cy);
2608         frame_within_region = (nframes_t) floor (cx * frames_per_unit);
2609
2610         if (!line->control_points_adjacent (frame_within_region, current_line_drag_info.before,
2611                                             current_line_drag_info.after)) {
2612                 /* no adjacent points */
2613                 return;
2614         }
2615
2616         drag_info.item = &line->grab_item();
2617         drag_info.data = line;
2618         drag_info.motion_callback = &Editor::line_drag_motion_callback;
2619         drag_info.finished_callback = &Editor::line_drag_finished_callback;
2620
2621         start_grab (event, fader_cursor);
2622
2623         double fraction = 1.0 - (cy / line->height());
2624
2625         line->start_drag (0, fraction);
2626
2627         set_verbose_canvas_cursor (line->get_verbose_cursor_string (fraction),
2628                                    drag_info.current_pointer_x + 20, drag_info.current_pointer_y + 20);
2629         show_verbose_canvas_cursor ();
2630 }
2631
2632 void
2633 Editor::line_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
2634 {
2635         AutomationLine* line = reinterpret_cast<AutomationLine *> (drag_info.data);
2636         double cx = drag_info.current_pointer_x;
2637         double cy = drag_info.current_pointer_y;
2638
2639         line->parent_group().w2i (cx, cy);
2640
2641         double fraction;
2642         fraction = 1.0 - (cy / line->height());
2643
2644         bool push;
2645
2646         if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
2647                 push = false;
2648         } else {
2649                 push = true;
2650         }
2651
2652         line->line_drag (current_line_drag_info.before, current_line_drag_info.after, fraction, push);
2653
2654         set_verbose_canvas_cursor_text (line->get_verbose_cursor_string (fraction));
2655 }
2656
2657 void
2658 Editor::line_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
2659 {
2660         AutomationLine* line = reinterpret_cast<AutomationLine *> (drag_info.data);
2661         line_drag_motion_callback (item, event);
2662         line->end_drag (0);
2663 }
2664
2665 void
2666 Editor::start_region_grab (ArdourCanvas::Item* item, GdkEvent* event)
2667 {
2668         if (selection->regions.empty() || clicked_regionview == 0) {
2669                 return;
2670         }
2671
2672         drag_info.copy = false;
2673         drag_info.item = item;
2674         drag_info.data = clicked_regionview;
2675         drag_info.motion_callback = &Editor::region_drag_motion_callback;
2676         drag_info.finished_callback = &Editor::region_drag_finished_callback;
2677
2678         start_grab (event);
2679
2680         double speed = 1.0;
2681         TimeAxisView* tvp = clicked_trackview;
2682         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
2683
2684         if (tv && tv->is_audio_track()) {
2685                 speed = tv->get_diskstream()->speed();
2686         }
2687
2688         drag_info.last_frame_position = (nframes_t) (clicked_regionview->region()->position() / speed);
2689         drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
2690         drag_info.last_trackview = &clicked_regionview->get_time_axis_view();
2691         // we want a move threshold
2692         drag_info.want_move_threshold = true;
2693
2694         show_verbose_time_cursor (drag_info.last_frame_position, 10);
2695
2696         begin_reversible_command (_("move region(s)"));
2697 }
2698
2699 void
2700 Editor::start_region_copy_grab (ArdourCanvas::Item* item, GdkEvent* event)
2701 {
2702         if (selection->regions.empty() || clicked_regionview == 0) {
2703                 return;
2704         }
2705
2706         drag_info.copy = true;
2707         drag_info.item = item;
2708         drag_info.data = clicked_regionview;
2709
2710         start_grab(event);
2711
2712         TimeAxisView* tv = &clicked_regionview->get_time_axis_view();
2713         RouteTimeAxisView* atv = dynamic_cast<RouteTimeAxisView*>(tv);
2714         double speed = 1.0;
2715
2716         if (atv && atv->is_audio_track()) {
2717                 speed = atv->get_diskstream()->speed();
2718         }
2719
2720         drag_info.last_trackview = &clicked_regionview->get_time_axis_view();
2721         drag_info.last_frame_position = (nframes_t) (clicked_regionview->region()->position() / speed);
2722         drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
2723         // we want a move threshold
2724         drag_info.want_move_threshold = true;
2725         drag_info.motion_callback = &Editor::region_drag_motion_callback;
2726         drag_info.finished_callback = &Editor::region_drag_finished_callback;
2727 }
2728
2729 void
2730 Editor::start_region_brush_grab (ArdourCanvas::Item* item, GdkEvent* event)
2731 {
2732         if (selection->regions.empty() || clicked_regionview == 0) {
2733                 return;
2734         }
2735
2736         drag_info.copy = false;
2737         drag_info.item = item;
2738         drag_info.data = clicked_regionview;
2739         drag_info.motion_callback = &Editor::region_drag_motion_callback;
2740         drag_info.finished_callback = &Editor::region_drag_finished_callback;
2741
2742         start_grab (event);
2743
2744         double speed = 1.0;
2745         TimeAxisView* tvp = clicked_trackview;
2746         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
2747
2748         if (tv && tv->is_audio_track()) {
2749                 speed = tv->get_diskstream()->speed();
2750         }
2751
2752         drag_info.last_frame_position = (nframes_t) (clicked_regionview->region()->position() / speed);
2753         drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
2754         drag_info.last_trackview = &clicked_regionview->get_time_axis_view();
2755         // we want a move threshold
2756         drag_info.want_move_threshold = true;
2757         drag_info.brushing = true;
2758
2759         begin_reversible_command (_("Drag region brush"));
2760 }
2761
2762 void
2763 Editor::region_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
2764 {
2765         double x_delta;
2766         double y_delta = 0;
2767         RegionView* rv = reinterpret_cast<RegionView*> (drag_info.data);
2768         nframes_t pending_region_position = 0;
2769         int32_t pointer_y_span = 0, canvas_pointer_y_span = 0, original_pointer_order;
2770         int32_t visible_y_high = 0, visible_y_low = 512;  //high meaning higher numbered.. not the height on the screen
2771         bool clamp_y_axis = false;
2772         vector<int32_t>  height_list(512) ;
2773         vector<int32_t>::iterator j;
2774
2775         show_verbose_time_cursor (drag_info.last_frame_position, 10);
2776
2777         if (drag_info.copy && drag_info.move_threshold_passed && drag_info.want_move_threshold) {
2778
2779                 drag_info.want_move_threshold = false; // don't copy again
2780
2781                 /* this is committed in the grab finished callback. */
2782
2783                 begin_reversible_command (_("Drag region copy"));
2784
2785                 /* duplicate the region(s) */
2786
2787                 vector<RegionView*> new_regionviews;
2788
2789                 set<Playlist*> affected_playlists;
2790                 pair<set<Playlist*>::iterator,bool> insert_result;
2791
2792                 for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
2793                         RegionView* rv;
2794
2795                         rv = (*i);
2796
2797                         Playlist* to_playlist = rv->region()->playlist();
2798                         RouteTimeAxisView* atv = dynamic_cast<RouteTimeAxisView*>(&rv->get_time_axis_view());
2799
2800                         insert_result = affected_playlists.insert (to_playlist);
2801                         if (insert_result.second) {
2802                                 session->add_command (new MementoCommand<Playlist>(*to_playlist, &to_playlist->get_state(), 0));
2803                         }
2804
2805                         latest_regionview = 0;
2806
2807                         sigc::connection c = atv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
2808
2809                         /* create a new region with the same name. */
2810
2811                         // FIXME: ew.  need a (virtual) Region::duplicate() or something?
2812
2813                         boost::shared_ptr<Region> newregion;
2814                         boost::shared_ptr<Region> ar;
2815
2816                         if ((ar = boost::dynamic_pointer_cast<AudioRegion>(rv->region())) != 0) {
2817                                 newregion = RegionFactory::create (ar);
2818                         }
2819                         assert(newregion != 0);
2820
2821                         /* if the original region was locked, we don't care */
2822
2823                         newregion->set_locked (false);
2824
2825                         to_playlist->add_region (newregion, (nframes_t) (rv->region()->position() * atv->get_diskstream()->speed()));
2826
2827                         c.disconnect ();
2828
2829                         if (latest_regionview) {
2830                                 new_regionviews.push_back (latest_regionview);
2831                         }
2832                 }
2833
2834                 if (new_regionviews.empty()) {
2835                         return;
2836                 }
2837
2838                 /* reset selection to new regionviews */
2839
2840                 selection->set (new_regionviews);
2841
2842                 /* reset drag_info data to reflect the fact that we are dragging the copies */
2843
2844                 drag_info.data = new_regionviews.front();
2845                 swap_grab (new_regionviews.front()->get_canvas_group (), 0, event->motion.time);
2846         }
2847
2848         /* Which trackview is this ? */
2849
2850         TimeAxisView* tvp = trackview_by_y_position (drag_info.current_pointer_y);
2851         AudioTimeAxisView* tv = dynamic_cast<AudioTimeAxisView*>(tvp);
2852
2853         /* The region motion is only processed if the pointer is over
2854            an audio track.
2855         */
2856
2857         if (!tv || !tv->is_audio_track()) {
2858                 /* To make sure we hide the verbose canvas cursor when the mouse is
2859                    not held over and audiotrack.
2860                 */
2861                 hide_verbose_canvas_cursor ();
2862                 return;
2863         }
2864
2865         original_pointer_order = drag_info.last_trackview->order;
2866
2867         /************************************************************
2868                  Y-Delta Computation
2869         ************************************************************/
2870
2871         if (drag_info.brushing) {
2872                 clamp_y_axis = true;
2873                 pointer_y_span = 0;
2874                 goto y_axis_done;
2875         }
2876
2877         if ((pointer_y_span = (drag_info.last_trackview->order - tv->order)) != 0) {
2878
2879                 int32_t children = 0, numtracks = 0;
2880                 // XXX hard coding track limit, oh my, so very very bad
2881                 bitset <1024> tracks (0x00);
2882                 /* get a bitmask representing the visible tracks */
2883
2884                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
2885                         TimeAxisView *tracklist_timeview;
2886                         tracklist_timeview = (*i);
2887                         AudioTimeAxisView* atv2 = dynamic_cast<AudioTimeAxisView*>(tracklist_timeview);
2888                         list<TimeAxisView*> children_list;
2889
2890                         /* zeroes are audio tracks. ones are other types. */
2891
2892                         if (!atv2->hidden()) {
2893
2894                                 if (visible_y_high < atv2->order) {
2895                                         visible_y_high = atv2->order;
2896                                 }
2897                                 if (visible_y_low > atv2->order) {
2898                                         visible_y_low = atv2->order;
2899                                 }
2900
2901                                 if (!atv2->is_audio_track()) {
2902                                         tracks = tracks |= (0x01 << atv2->order);
2903                                 }
2904
2905                                 height_list[atv2->order] = (*i)->height;
2906                                 children = 1;
2907                                 if ((children_list = atv2->get_child_list()).size() > 0) {
2908                                         for (list<TimeAxisView*>::iterator j = children_list.begin(); j != children_list.end(); ++j) {
2909                                                 tracks = tracks |= (0x01 << (atv2->order + children));
2910                                                 height_list[atv2->order + children] =  (*j)->height;
2911                                                 numtracks++;
2912                                                 children++;
2913                                         }
2914                                 }
2915                                 numtracks++;
2916                         }
2917                 }
2918                 /* find the actual span according to the canvas */
2919
2920                 canvas_pointer_y_span = pointer_y_span;
2921                 if (drag_info.last_trackview->order >= tv->order) {
2922                         int32_t y;
2923                         for (y = tv->order; y < drag_info.last_trackview->order; y++) {
2924                                 if (height_list[y] == 0 ) {
2925                                         canvas_pointer_y_span--;
2926                                 }
2927                         }
2928                 } else {
2929                         int32_t y;
2930                         for (y = drag_info.last_trackview->order;y <= tv->order; y++) {
2931                                 if (    height_list[y] == 0 ) {
2932                                         canvas_pointer_y_span++;
2933                                 }
2934                         }
2935                 }
2936
2937                 for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
2938                         RegionView* rv2 = (*i);
2939                         double ix1, ix2, iy1, iy2;
2940                         int32_t n = 0;
2941
2942                         rv2->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
2943                         rv2->get_canvas_group()->i2w (ix1, iy1);
2944                         TimeAxisView* tvp2 = trackview_by_y_position (iy1);
2945                         RouteTimeAxisView* atv2 = dynamic_cast<RouteTimeAxisView*>(tvp2);
2946
2947                         if (atv2->order != original_pointer_order) {
2948                                 /* this isn't the pointer track */
2949
2950                                 if (canvas_pointer_y_span > 0) {
2951
2952                                         /* moving up the canvas */
2953                                         if ((atv2->order - canvas_pointer_y_span) >= visible_y_low) {
2954
2955                                                 int32_t visible_tracks = 0;
2956                                                 while (visible_tracks < canvas_pointer_y_span ) {
2957                                                         visible_tracks++;
2958
2959                                                         while (height_list[atv2->order - (visible_tracks - n)] == 0) {
2960                                                                 /* we're passing through a hidden track */
2961                                                                 n--;
2962                                                         }
2963                                                 }
2964
2965                                                 if (tracks[atv2->order - (canvas_pointer_y_span - n)] != 0x00) {
2966                                                         clamp_y_axis = true;
2967                                                 }
2968
2969                                         } else {
2970                                                 clamp_y_axis = true;
2971                                         }
2972
2973                                 } else if (canvas_pointer_y_span < 0) {
2974
2975                                         /*moving down the canvas*/
2976
2977                                         if ((atv2->order - (canvas_pointer_y_span - n)) <= visible_y_high) { // we will overflow
2978
2979
2980                                                 int32_t visible_tracks = 0;
2981
2982                                                 while (visible_tracks > canvas_pointer_y_span ) {
2983                                                         visible_tracks--;
2984
2985                                                         while (height_list[atv2->order - (visible_tracks - n)] == 0) {
2986                                                                 n++;
2987                                                         }
2988                                                 }
2989                                                 if (  tracks[atv2->order - ( canvas_pointer_y_span - n)] != 0x00) {
2990                                                         clamp_y_axis = true;
2991
2992                                                 }
2993                                         } else {
2994
2995                                                 clamp_y_axis = true;
2996                                         }
2997                                 }
2998
2999                         } else {
3000
3001                                 /* this is the pointer's track */
3002                                 if ((atv2->order - pointer_y_span) > visible_y_high) { // we will overflow
3003                                         clamp_y_axis = true;
3004                                 } else if ((atv2->order - pointer_y_span) < visible_y_low) { // we will underflow
3005                                         clamp_y_axis = true;
3006                                 }
3007                         }
3008                         if (clamp_y_axis) {
3009                                 break;
3010                         }
3011                 }
3012
3013         } else  if (drag_info.last_trackview == tv) {
3014                 clamp_y_axis = true;
3015         }
3016
3017   y_axis_done:
3018         if (!clamp_y_axis) {
3019                 drag_info.last_trackview = tv;
3020         }
3021
3022         /************************************************************
3023                         X DELTA COMPUTATION
3024         ************************************************************/
3025
3026         /* compute the amount of pointer motion in frames, and where
3027            the region would be if we moved it by that much.
3028         */
3029
3030         if (drag_info.move_threshold_passed) {
3031
3032                 if ((int32_t)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
3033
3034                         nframes_t sync_frame;
3035                         nframes_t sync_offset;
3036                         int32_t sync_dir;
3037
3038                         pending_region_position = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
3039
3040                         sync_offset = rv->region()->sync_offset (sync_dir);
3041                         sync_frame = rv->region()->adjust_to_sync (pending_region_position);
3042
3043                         /* we snap if the snap modifier is not enabled.
3044                          */
3045
3046                         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
3047                                 snap_to (sync_frame);
3048                         }
3049
3050                         if (sync_frame - sync_offset <= sync_frame) {
3051                                 pending_region_position = sync_frame - (sync_dir*sync_offset);
3052                         } else {
3053                                 pending_region_position = 0;
3054                         }
3055
3056                 } else {
3057                         pending_region_position = 0;
3058                 }
3059
3060                 if (pending_region_position > max_frames - rv->region()->length()) {
3061                         pending_region_position = drag_info.last_frame_position;
3062                 }
3063
3064                 // printf ("3: pending_region_position= %lu    %lu\n", pending_region_position, drag_info.last_frame_position );
3065
3066                 if (pending_region_position != drag_info.last_frame_position && !drag_info.x_constrained) {
3067
3068                         /* now compute the canvas unit distance we need to move the regiondrag_info.last_trackview->order
3069                            to make it appear at the new location.
3070                         */
3071
3072                         if (pending_region_position > drag_info.last_frame_position) {
3073                                 x_delta = ((double) (pending_region_position - drag_info.last_frame_position) / frames_per_unit);
3074                         } else {
3075                                 x_delta = -((double) (drag_info.last_frame_position - pending_region_position) / frames_per_unit);
3076                         }
3077
3078                         drag_info.last_frame_position = pending_region_position;
3079
3080                 } else {
3081                         x_delta = 0;
3082                 }
3083
3084         } else {
3085                 /* threshold not passed */
3086
3087                 x_delta = 0;
3088         }
3089
3090         /*************************************************************
3091                         PREPARE TO MOVE
3092         ************************************************************/
3093
3094         if (x_delta == 0 && (pointer_y_span == 0)) {
3095                 /* haven't reached next snap point, and we're not switching
3096                    trackviews. nothing to do.
3097                 */
3098                 return;
3099         }
3100
3101         if (x_delta < 0) {
3102                 for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
3103
3104                         RegionView* rv2 = (*i);
3105
3106                         // If any regionview is at zero, we need to know so we can stop further leftward motion.
3107
3108                         double ix1, ix2, iy1, iy2;
3109                         rv2->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
3110                         rv2->get_canvas_group()->i2w (ix1, iy1);
3111
3112                         if (ix1 <= 1) {
3113                                 x_delta = 0;
3114                                 break;
3115                         }
3116                 }
3117         }
3118
3119         /*************************************************************
3120                         MOTION
3121         ************************************************************/
3122
3123         pair<set<Playlist*>::iterator,bool> insert_result;
3124         const list<RegionView*>& layered_regions = selection->regions.by_layer();
3125
3126         for (list<RegionView*>::const_iterator i = layered_regions.begin(); i != layered_regions.end(); ++i) {
3127
3128                 RegionView* rv = (*i);
3129                 double ix1, ix2, iy1, iy2;
3130                 int32_t temp_pointer_y_span = pointer_y_span;
3131
3132                 /* get item BBox, which will be relative to parent. so we have
3133                    to query on a child, then convert to world coordinates using
3134                    the parent.
3135                 */
3136
3137                 rv->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
3138                 rv->get_canvas_group()->i2w (ix1, iy1);
3139                 TimeAxisView* tvp2 = trackview_by_y_position (iy1);
3140                 AudioTimeAxisView* canvas_atv = dynamic_cast<AudioTimeAxisView*>(tvp2);
3141                 AudioTimeAxisView* temp_atv;
3142
3143                 if ((pointer_y_span != 0) && !clamp_y_axis) {
3144                         y_delta = 0;
3145                         int32_t x = 0;
3146                         for (j = height_list.begin(); j!= height_list.end(); j++) {
3147                                 if (x == canvas_atv->order) {
3148                                         /* we found the track the region is on */
3149                                         if (x != original_pointer_order) {
3150                                                 /*this isn't from the same track we're dragging from */
3151                                                 temp_pointer_y_span = canvas_pointer_y_span;
3152                                         }
3153                                         while (temp_pointer_y_span > 0) {
3154                                                 /* we're moving up canvas-wise,
3155                                                    so  we need to find the next track height
3156                                                 */
3157                                                 if (j != height_list.begin()) {
3158                                                         j--;
3159                                                 }
3160                                                 if (x != original_pointer_order) {
3161                                                         /* we're not from the dragged track, so ignore hidden tracks. */
3162                                                         if ((*j) == 0) {
3163                                                                 temp_pointer_y_span++;
3164                                                         }
3165                                                 }
3166                                                 y_delta -= (*j);
3167                                                 temp_pointer_y_span--;
3168                                         }
3169                                         while (temp_pointer_y_span < 0) {
3170                                                 y_delta += (*j);
3171                                                 if (x != original_pointer_order) {
3172                                                         if ((*j) == 0) {
3173                                                                 temp_pointer_y_span--;
3174                                                         }
3175                                                 }
3176
3177                                                 if (j != height_list.end()) {
3178                                                         j++;
3179                                                 }
3180                                                 temp_pointer_y_span++;
3181                                         }
3182                                         /* find out where we'll be when we move and set height accordingly */
3183
3184                                         tvp2 = trackview_by_y_position (iy1 + y_delta);
3185                                         temp_atv = dynamic_cast<AudioTimeAxisView*>(tvp2);
3186                                         rv->set_height (temp_atv->height);
3187
3188                                         /*   if you un-comment the following, the region colours will follow the track colours whilst dragging,
3189                                              personally, i think this can confuse things, but never mind.
3190                                         */
3191
3192                                         //const GdkColor& col (temp_atv->view->get_region_color());
3193                                         //rv->set_color (const_cast<GdkColor&>(col));
3194                                         break;
3195                                 }
3196                                 x++;
3197                         }
3198                 }
3199
3200                 /* prevent the regionview from being moved to before
3201                    the zero position on the canvas.
3202                 */
3203                 /* clamp */
3204
3205                 if (x_delta < 0) {
3206                         if (-x_delta > ix1) {
3207                                 x_delta = -ix1;
3208                         }
3209                 } else if ((x_delta > 0) &&(rv->region()->last_frame() > max_frames - x_delta)) {
3210                         x_delta = max_frames - rv->region()->last_frame();
3211                 }
3212
3213                 if (drag_info.first_move) {
3214
3215                         /* hide any dependent views */
3216
3217 //                      rv->get_time_axis_view().hide_dependent_views (*rv);
3218
3219                         /* this is subtle. raising the regionview itself won't help,
3220                            because raise_to_top() just puts the item on the top of
3221                            its parent's stack. so, we need to put the trackview canvas_display group
3222                            on the top, since its parent is the whole canvas.
3223                         */
3224
3225                         rv->get_canvas_group()->raise_to_top();
3226                         rv->get_time_axis_view().canvas_display->raise_to_top();
3227                         cursor_group->raise_to_top();
3228
3229                         /* freeze the playlists from notifying till
3230                            the motion is done.
3231                         */
3232
3233                         AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (&rv->get_time_axis_view());
3234                         if (atv && atv->is_audio_track()) {
3235                                 AudioPlaylist* pl = dynamic_cast<AudioPlaylist*>(atv->get_diskstream()->playlist());
3236                                 if (pl) {
3237                                         /* only freeze and capture state once */
3238
3239                                         insert_result = motion_frozen_playlists.insert (pl);
3240                                         if (insert_result.second) {
3241                                                 pl->freeze();
3242                                                 session->add_command(new MementoCommand<Playlist>(*pl, &pl->get_state(), 0));
3243                                         }
3244                                 }
3245                         }
3246                 }
3247
3248                 if (drag_info.brushing) {
3249                         mouse_brush_insert_region (rv, pending_region_position);
3250                 } else {
3251                         rv->move (x_delta, y_delta);
3252                 }
3253         }
3254
3255         if (drag_info.first_move) {
3256                 cursor_group->raise_to_top();
3257         }
3258
3259         drag_info.first_move = false;
3260
3261         if (x_delta != 0 && !drag_info.brushing) {
3262                 show_verbose_time_cursor (drag_info.last_frame_position, 10);
3263         }
3264
3265 }
3266
3267 void
3268 Editor::region_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
3269 {
3270         nframes_t where;
3271         RegionView* rv = reinterpret_cast<RegionView *> (drag_info.data);
3272         pair<set<Playlist*>::iterator,bool> insert_result;
3273         bool nocommit = true;
3274         double speed;
3275         RouteTimeAxisView* atv;
3276         bool regionview_y_movement;
3277         bool regionview_x_movement;
3278
3279         /* first_move is set to false if the regionview has been moved in the
3280            motion handler.
3281         */
3282
3283         if (drag_info.first_move) {
3284                 /* just a click */
3285                 goto out;
3286         }
3287
3288         nocommit = false;
3289
3290         /* The regionview has been moved at some stage during the grab so we need
3291            to account for any mouse movement between this event and the last one.
3292         */
3293
3294         region_drag_motion_callback (item, event);
3295
3296         if (drag_info.brushing) {
3297                 /* all changes were made during motion event handlers */
3298                 goto out;
3299         }
3300
3301         /* adjust for track speed */
3302         speed = 1.0;
3303
3304         atv = dynamic_cast<AudioTimeAxisView*> (drag_info.last_trackview);
3305         if (atv && atv->get_diskstream()) {
3306                 speed = atv->get_diskstream()->speed();
3307         }
3308
3309         regionview_x_movement = (drag_info.last_frame_position != (nframes_t) (rv->region()->position()/speed));
3310         regionview_y_movement = (drag_info.last_trackview != &rv->get_time_axis_view());
3311
3312         //printf ("last_frame: %s position is %lu  %g\n", rv->get_time_axis_view().name().c_str(), drag_info.last_frame_position, speed);
3313         //printf ("last_rackview: %s \n", drag_info.last_trackview->name().c_str());
3314
3315         if (regionview_y_movement) {
3316
3317                 /* motion between tracks */
3318
3319                 list<RegionView*> new_selection;
3320
3321                 /* moved to a different audio track. */
3322
3323                 for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ) {
3324
3325                         RegionView* rv2 = (*i);
3326
3327                         /* the region that used to be in the old playlist is not
3328                            moved to the new one - we make a copy of it. as a result,
3329                            any existing editor for the region should no longer be
3330                            visible.
3331                         */
3332
3333                         if (!drag_info.copy) {
3334                                 rv2->hide_region_editor();
3335                         }
3336                         new_selection.push_back (rv2);
3337                         i++;
3338                 }
3339
3340                 /* first, freeze the target tracks */
3341
3342                 for (list<RegionView*>::const_iterator i = new_selection.begin(); i != new_selection.end();i++ ) {
3343
3344                         Playlist* from_playlist;
3345                         Playlist* to_playlist;
3346
3347                         double ix1, ix2, iy1, iy2;
3348
3349                         (*i)->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
3350                         (*i)->get_canvas_group()->i2w (ix1, iy1);
3351                         TimeAxisView* tvp2 = trackview_by_y_position (iy1);
3352                         AudioTimeAxisView* atv2 = dynamic_cast<AudioTimeAxisView*>(tvp2);
3353
3354                         from_playlist = (*i)->region()->playlist();
3355                         to_playlist = atv2->playlist();
3356
3357                         /* the from_playlist was frozen in the "first_move" case
3358                            of the motion handler. the insert can fail,
3359                            but that doesn't matter. it just means
3360                            we already have the playlist in the list.
3361                         */
3362
3363                         motion_frozen_playlists.insert (from_playlist);
3364
3365                         /* only freeze the to_playlist once */
3366
3367                         insert_result = motion_frozen_playlists.insert(to_playlist);
3368                         if (insert_result.second) {
3369                                 to_playlist->freeze();
3370                                 session->add_command(new MementoCommand<Playlist>(*to_playlist, &to_playlist->get_state(), 0));
3371                         }
3372
3373                 }
3374
3375                 /* now do it again with the actual operations */
3376
3377                 for (list<RegionView*>::const_iterator i = new_selection.begin(); i != new_selection.end();i++ ) {
3378
3379                         Playlist* from_playlist;
3380                         Playlist* to_playlist;
3381
3382                         double ix1, ix2, iy1, iy2;
3383
3384                         (*i)->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
3385                         (*i)->get_canvas_group()->i2w (ix1, iy1);
3386                         TimeAxisView* tvp2 = trackview_by_y_position (iy1);
3387                         AudioTimeAxisView* atv2 = dynamic_cast<AudioTimeAxisView*>(tvp2);
3388
3389                         from_playlist = (*i)->region()->playlist();
3390                         to_playlist = atv2->playlist();
3391
3392                         latest_regionview = 0;
3393
3394                         where = (nframes_t) (unit_to_frame (ix1) * speed);
3395                         boost::shared_ptr<Region> new_region (RegionFactory::create ((*i)->region()));
3396
3397                         from_playlist->remove_region (((*i)->region()));
3398
3399                         sigc::connection c = atv2->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
3400                         to_playlist->add_region (new_region, where);
3401                         c.disconnect ();
3402
3403                         if (latest_regionview) {
3404                                 selection->add (latest_regionview);
3405                         }
3406                 }
3407
3408         } else {
3409
3410                 /* motion within a single track */
3411
3412                 for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
3413
3414                         rv = (*i);
3415
3416                         if (rv->region()->locked()) {
3417                                 continue;
3418                         }
3419
3420                         if (regionview_x_movement) {
3421                                 double ownspeed = 1.0;
3422                                 AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (&(rv->get_time_axis_view()));
3423
3424                                 if (atv && atv->get_diskstream()) {
3425                                         ownspeed = atv->get_diskstream()->speed();
3426                                 }
3427
3428                                 /* base the new region position on the current position of the regionview.*/
3429
3430                                 double ix1, ix2, iy1, iy2;
3431
3432                                 rv->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
3433                                 rv->get_canvas_group()->i2w (ix1, iy1);
3434                                 where = (nframes_t) (unit_to_frame (ix1) * ownspeed);
3435
3436                         } else {
3437
3438                                 where = rv->region()->position();
3439                         }
3440
3441                         rv->get_time_axis_view().reveal_dependent_views (*rv);
3442
3443                         /* no need to add an undo here, we did that when we added this playlist to motion_frozen playlists */
3444
3445                         rv->region()->set_position (where, (void *) this);
3446                 }
3447         }
3448
3449   out:
3450         for (set<Playlist*>::iterator p = motion_frozen_playlists.begin(); p != motion_frozen_playlists.end(); ++p) {
3451                 (*p)->thaw ();
3452                 session->add_command (new MementoCommand<Playlist>(*(*p), 0, & (*p)->get_state()));
3453         }
3454
3455         motion_frozen_playlists.clear ();
3456
3457         if (!nocommit) {
3458                 commit_reversible_command ();
3459         }
3460 }
3461
3462 void
3463 Editor::region_view_item_click (AudioRegionView& rv, GdkEventButton* event)
3464 {
3465         /* Either add to or set the set the region selection, unless
3466            this is an alignment click (control used)
3467         */
3468
3469         if (Keyboard::modifier_state_contains (event->state, Keyboard::Control)) {
3470                 TimeAxisView* tv = &rv.get_time_axis_view();
3471                 AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*>(tv);
3472                 double speed = 1.0;
3473                 if (atv && atv->is_audio_track()) {
3474                         speed = atv->get_diskstream()->speed();
3475                 }
3476
3477                 if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Alt))) {
3478
3479                         align_region (rv.region(), SyncPoint, (nframes_t) (edit_cursor->current_frame * speed));
3480
3481                 } else if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Shift))) {
3482
3483                         align_region (rv.region(), End, (nframes_t) (edit_cursor->current_frame * speed));
3484
3485                 } else {
3486
3487                         align_region (rv.region(), Start, (nframes_t) (edit_cursor->current_frame * speed));
3488                 }
3489         }
3490 }
3491
3492 void
3493 Editor::show_verbose_time_cursor (nframes_t frame, double offset, double xpos, double ypos)
3494 {
3495         char buf[128];
3496         SMPTE::Time smpte;
3497         BBT_Time bbt;
3498         float secs;
3499
3500         if (session == 0) {
3501                 return;
3502         }
3503
3504         switch (ARDOUR_UI::instance()->secondary_clock.mode ()) {
3505         case AudioClock::BBT:
3506                 session->bbt_time (frame, bbt);
3507                 snprintf (buf, sizeof (buf), "%02" PRIu32 "|%02" PRIu32 "|%02" PRIu32, bbt.bars, bbt.beats, bbt.ticks);
3508                 break;
3509
3510         case AudioClock::SMPTE:
3511                 session->smpte_time (frame, smpte);
3512                 snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32, smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
3513                 break;
3514
3515         case AudioClock::MinSec:
3516                 /* XXX fix this to compute min/sec properly */
3517                 session->smpte_time (frame, smpte);
3518                 secs = smpte.seconds + ((float) smpte.frames / Config->get_smpte_frames_per_second());
3519                 snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%.4f", smpte.hours, smpte.minutes, secs);
3520                 break;
3521
3522         default:
3523                 snprintf (buf, sizeof(buf), "%u", frame);
3524                 break;
3525         }
3526
3527         if (xpos >= 0 && ypos >=0) {
3528                 set_verbose_canvas_cursor (buf, xpos + offset, ypos + offset);
3529         }
3530         else {
3531                 set_verbose_canvas_cursor (buf, drag_info.current_pointer_x + offset, drag_info.current_pointer_y + offset);
3532         }
3533         show_verbose_canvas_cursor ();
3534 }
3535
3536 void
3537 Editor::show_verbose_duration_cursor (nframes_t start, nframes_t end, double offset, double xpos, double ypos)
3538 {
3539         char buf[128];
3540         SMPTE::Time smpte;
3541         BBT_Time sbbt;
3542         BBT_Time ebbt;
3543         float secs;
3544         Meter meter_at_start(session->tempo_map().meter_at(start));
3545
3546         if (session == 0) {
3547                 return;
3548         }
3549
3550         switch (ARDOUR_UI::instance()->secondary_clock.mode ()) {
3551         case AudioClock::BBT:
3552                 session->bbt_time (start, sbbt);
3553                 session->bbt_time (end, ebbt);
3554
3555                 /* subtract */
3556                 /* XXX this computation won't work well if the
3557                 user makes a selection that spans any meter changes.
3558                 */
3559
3560                 ebbt.bars -= sbbt.bars;
3561                 if (ebbt.beats >= sbbt.beats) {
3562                         ebbt.beats -= sbbt.beats;
3563                 } else {
3564                         ebbt.bars--;
3565                         ebbt.beats =  int(meter_at_start.beats_per_bar()) + ebbt.beats - sbbt.beats;
3566                 }
3567                 if (ebbt.ticks >= sbbt.ticks) {
3568                         ebbt.ticks -= sbbt.ticks;
3569                 } else {
3570                         ebbt.beats--;
3571                         ebbt.ticks = int(Meter::ticks_per_beat) + ebbt.ticks - sbbt.ticks;
3572                 }
3573
3574                 snprintf (buf, sizeof (buf), "%02" PRIu32 "|%02" PRIu32 "|%02" PRIu32, ebbt.bars, ebbt.beats, ebbt.ticks);
3575                 break;
3576
3577         case AudioClock::SMPTE:
3578                 session->smpte_duration (end - start, smpte);
3579                 snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32, smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
3580                 break;
3581
3582         case AudioClock::MinSec:
3583                 /* XXX fix this to compute min/sec properly */
3584                 session->smpte_duration (end - start, smpte);
3585                 secs = smpte.seconds + ((float) smpte.frames / Config->get_smpte_frames_per_second());
3586                 snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%.4f", smpte.hours, smpte.minutes, secs);
3587                 break;
3588
3589         default:
3590                 snprintf (buf, sizeof(buf), "%u", end - start);
3591                 break;
3592         }
3593
3594         if (xpos >= 0 && ypos >=0) {
3595                 set_verbose_canvas_cursor (buf, xpos + offset, ypos + offset);
3596         }
3597         else {
3598                 set_verbose_canvas_cursor (buf, drag_info.current_pointer_x + offset, drag_info.current_pointer_y + offset);
3599         }
3600         show_verbose_canvas_cursor ();
3601 }
3602
3603 void
3604 Editor::collect_new_region_view (RegionView* rv)
3605 {
3606         latest_regionview = rv;
3607 }
3608
3609 void
3610 Editor::start_selection_grab (ArdourCanvas::Item* item, GdkEvent* event)
3611 {
3612         if (clicked_regionview == 0) {
3613                 return;
3614         }
3615
3616         /* lets try to create new Region for the selection */
3617
3618         vector<boost::shared_ptr<AudioRegion> > new_regions;
3619         create_region_from_selection (new_regions);
3620
3621         if (new_regions.empty()) {
3622                 return;
3623         }
3624
3625         /* XXX fix me one day to use all new regions */
3626
3627         boost::shared_ptr<Region> region (new_regions.front());
3628
3629         /* add it to the current stream/playlist.
3630
3631            tricky: the streamview for the track will add a new regionview. we will
3632            catch the signal it sends when it creates the regionview to
3633            set the regionview we want to then drag.
3634         */
3635
3636         latest_regionview = 0;
3637         sigc::connection c = clicked_audio_trackview->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
3638
3639         /* A selection grab currently creates two undo/redo operations, one for
3640            creating the new region and another for moving it.
3641         */
3642
3643         begin_reversible_command (_("selection grab"));
3644
3645         Playlist* playlist = clicked_trackview->playlist();
3646
3647         XMLNode *before = &(playlist->get_state());
3648         clicked_trackview->playlist()->add_region (region, selection->time[clicked_selection].start);
3649         XMLNode *after = &(playlist->get_state());
3650         session->add_command(new MementoCommand<Playlist>(*playlist, before, after));
3651
3652         commit_reversible_command ();
3653
3654         c.disconnect ();
3655
3656         if (latest_regionview == 0) {
3657                 /* something went wrong */
3658                 return;
3659         }
3660
3661         /* we need to deselect all other regionviews, and select this one
3662            i'm ignoring undo stuff, because the region creation will take care of it */
3663         selection->set (latest_regionview);
3664
3665         drag_info.item = latest_regionview->get_canvas_group();
3666         drag_info.data = latest_regionview;
3667         drag_info.motion_callback = &Editor::region_drag_motion_callback;
3668         drag_info.finished_callback = &Editor::region_drag_finished_callback;
3669
3670         start_grab (event);
3671
3672         drag_info.last_trackview = clicked_trackview;
3673         drag_info.last_frame_position = latest_regionview->region()->position();
3674         drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
3675
3676         show_verbose_time_cursor (drag_info.last_frame_position, 10);
3677 }
3678
3679 void
3680 Editor::cancel_selection ()
3681 {
3682         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
3683                 (*i)->hide_selection ();
3684         }
3685         begin_reversible_command (_("cancel selection"));
3686         selection->clear ();
3687         clicked_selection = 0;
3688         commit_reversible_command ();
3689 }
3690
3691 void
3692 Editor::start_selection_op (ArdourCanvas::Item* item, GdkEvent* event, SelectionOp op)
3693 {
3694         nframes_t start = 0;
3695         nframes_t end = 0;
3696
3697         if (session == 0) {
3698                 return;
3699         }
3700
3701         drag_info.item = item;
3702         drag_info.motion_callback = &Editor::drag_selection;
3703         drag_info.finished_callback = &Editor::end_selection_op;
3704
3705         selection_op = op;
3706
3707         switch (op) {
3708         case CreateSelection:
3709                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
3710                         drag_info.copy = true;
3711                 } else {
3712                         drag_info.copy = false;
3713                 }
3714                 start_grab (event, selector_cursor);
3715                 break;
3716
3717         case SelectionStartTrim:
3718                 if (clicked_trackview) {
3719                         clicked_trackview->order_selection_trims (item, true);
3720                 }
3721                 start_grab (event, trimmer_cursor);
3722                 start = selection->time[clicked_selection].start;
3723                 drag_info.pointer_frame_offset = drag_info.grab_frame - start;
3724                 break;
3725
3726         case SelectionEndTrim:
3727                 if (clicked_trackview) {
3728                         clicked_trackview->order_selection_trims (item, false);
3729                 }
3730                 start_grab (event, trimmer_cursor);
3731                 end = selection->time[clicked_selection].end;
3732                 drag_info.pointer_frame_offset = drag_info.grab_frame - end;
3733                 break;
3734
3735         case SelectionMove:
3736                 start = selection->time[clicked_selection].start;
3737                 start_grab (event);
3738                 drag_info.pointer_frame_offset = drag_info.grab_frame - start;
3739                 break;
3740         }
3741
3742         if (selection_op == SelectionMove) {
3743                 show_verbose_time_cursor(start, 10);
3744         } else {
3745                 show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
3746         }
3747 }
3748
3749 void
3750 Editor::drag_selection (ArdourCanvas::Item* item, GdkEvent* event)
3751 {
3752         nframes_t start = 0;
3753         nframes_t end = 0;
3754         nframes_t length;
3755         nframes_t pending_position;
3756
3757         if ((int32_t) drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
3758                 pending_position = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
3759         }
3760         else {
3761                 pending_position = 0;
3762         }
3763
3764         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
3765                 snap_to (pending_position);
3766         }
3767
3768         /* only alter selection if the current frame is
3769            different from the last frame position (adjusted)
3770          */
3771
3772         if (pending_position == drag_info.last_pointer_frame) return;
3773
3774         switch (selection_op) {
3775         case CreateSelection:
3776
3777                 if (drag_info.first_move) {
3778                         snap_to (drag_info.grab_frame);
3779                 }
3780
3781                 if (pending_position < drag_info.grab_frame) {
3782                         start = pending_position;
3783                         end = drag_info.grab_frame;
3784                 } else {
3785                         end = pending_position;
3786                         start = drag_info.grab_frame;
3787                 }
3788
3789                 /* first drag: Either add to the selection
3790                    or create a new selection->
3791                 */
3792
3793                 if (drag_info.first_move) {
3794
3795                         begin_reversible_command (_("range selection"));
3796
3797                         if (drag_info.copy) {
3798                                 /* adding to the selection */
3799                                 clicked_selection = selection->add (start, end);
3800                                 drag_info.copy = false;
3801                         } else {
3802                                 /* new selection-> */
3803                                 clicked_selection = selection->set (clicked_trackview, start, end);
3804                         }
3805                 }
3806                 break;
3807
3808         case SelectionStartTrim:
3809
3810                 if (drag_info.first_move) {
3811                         begin_reversible_command (_("trim selection start"));
3812                 }
3813
3814                 start = selection->time[clicked_selection].start;
3815                 end = selection->time[clicked_selection].end;
3816
3817                 if (pending_position > end) {
3818                         start = end;
3819                 } else {
3820                         start = pending_position;
3821                 }
3822                 break;
3823
3824         case SelectionEndTrim:
3825
3826                 if (drag_info.first_move) {
3827                         begin_reversible_command (_("trim selection end"));
3828                 }
3829
3830                 start = selection->time[clicked_selection].start;
3831                 end = selection->time[clicked_selection].end;
3832
3833                 if (pending_position < start) {
3834                         end = start;
3835                 } else {
3836                         end = pending_position;
3837                 }
3838
3839                 break;
3840
3841         case SelectionMove:
3842
3843                 if (drag_info.first_move) {
3844                         begin_reversible_command (_("move selection"));
3845                 }
3846
3847                 start = selection->time[clicked_selection].start;
3848                 end = selection->time[clicked_selection].end;
3849
3850                 length = end - start;
3851
3852                 start = pending_position;
3853                 snap_to (start);
3854
3855                 end = start + length;
3856
3857                 break;
3858         }
3859
3860         if (event->button.x >= horizontal_adjustment.get_value() + canvas_width) {
3861                 start_canvas_autoscroll (1);
3862         }
3863
3864         if (start != end) {
3865                 selection->replace (clicked_selection, start, end);
3866         }
3867
3868         drag_info.last_pointer_frame = pending_position;
3869         drag_info.first_move = false;
3870
3871         if (selection_op == SelectionMove) {
3872                 show_verbose_time_cursor(start, 10);
3873         } else {
3874                 show_verbose_time_cursor(pending_position, 10);
3875         }
3876 }
3877
3878 void
3879 Editor::end_selection_op (ArdourCanvas::Item* item, GdkEvent* event)
3880 {
3881         if (!drag_info.first_move) {
3882                 drag_selection (item, event);
3883                 /* XXX this is not object-oriented programming at all. ick */
3884                 if (selection->time.consolidate()) {
3885                         selection->TimeChanged ();
3886                 }
3887                 commit_reversible_command ();
3888         } else {
3889                 /* just a click, no pointer movement.*/
3890
3891                 if (Keyboard::no_modifier_keys_pressed (&event->button)) {
3892
3893                         selection->clear_time();
3894
3895                 }
3896         }
3897
3898         /* XXX what happens if its a music selection? */
3899         session->set_audio_range (selection->time);
3900         stop_canvas_autoscroll ();
3901 }
3902
3903 void
3904 Editor::start_trim (ArdourCanvas::Item* item, GdkEvent* event)
3905 {
3906         double speed = 1.0;
3907         TimeAxisView* tvp = clicked_trackview;
3908         AudioTimeAxisView* tv = dynamic_cast<AudioTimeAxisView*>(tvp);
3909
3910         if (tv && tv->is_audio_track()) {
3911                 speed = tv->get_diskstream()->speed();
3912         }
3913
3914         nframes_t region_start = (nframes_t) (clicked_regionview->region()->position() / speed);
3915         nframes_t region_end = (nframes_t) (clicked_regionview->region()->last_frame() / speed);
3916         nframes_t region_length = (nframes_t) (clicked_regionview->region()->length() / speed);
3917
3918         motion_frozen_playlists.clear();
3919
3920         //drag_info.item = clicked_regionview->get_name_highlight();
3921         drag_info.item = item;
3922         drag_info.motion_callback = &Editor::trim_motion_callback;
3923         drag_info.finished_callback = &Editor::trim_finished_callback;
3924
3925         start_grab (event, trimmer_cursor);
3926
3927         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
3928                 trim_op = ContentsTrim;
3929         } else {
3930                 /* These will get overridden for a point trim.*/
3931                 if (drag_info.current_pointer_frame < (region_start + region_length/2)) {
3932                         /* closer to start */
3933                         trim_op = StartTrim;
3934                 } else if (drag_info.current_pointer_frame > (region_end - region_length/2)) {
3935                         /* closer to end */
3936                         trim_op = EndTrim;
3937                 }
3938         }
3939
3940         switch (trim_op) {
3941         case StartTrim:
3942                 show_verbose_time_cursor(region_start, 10);
3943                 break;
3944         case EndTrim:
3945                 show_verbose_time_cursor(region_end, 10);
3946                 break;
3947         case ContentsTrim:
3948                 show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
3949                 break;
3950         }
3951 }
3952
3953 void
3954 Editor::trim_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
3955 {
3956         RegionView* rv = clicked_regionview;
3957         nframes_t frame_delta = 0;
3958         bool left_direction;
3959         bool obey_snap = !Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier());
3960
3961         /* snap modifier works differently here..
3962            its' current state has to be passed to the
3963            various trim functions in order to work properly
3964         */
3965
3966         double speed = 1.0;
3967         TimeAxisView* tvp = clicked_trackview;
3968         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
3969         pair<set<Playlist*>::iterator,bool> insert_result;
3970
3971         if (tv && tv->is_audio_track()) {
3972                 speed = tv->get_diskstream()->speed();
3973         }
3974
3975         if (drag_info.last_pointer_frame > drag_info.current_pointer_frame) {
3976                 left_direction = true;
3977         } else {
3978                 left_direction = false;
3979         }
3980
3981         if (obey_snap) {
3982                 snap_to (drag_info.current_pointer_frame);
3983         }
3984
3985         if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) {
3986                 return;
3987         }
3988
3989         if (drag_info.first_move) {
3990
3991                 string trim_type;
3992
3993                 switch (trim_op) {
3994                 case StartTrim:
3995                         trim_type = "Region start trim";
3996                         break;
3997                 case EndTrim:
3998                         trim_type = "Region end trim";
3999                         break;
4000                 case ContentsTrim:
4001                         trim_type = "Region content trim";
4002                         break;
4003                 }
4004
4005                 begin_reversible_command (trim_type);
4006
4007                 for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
4008                         (*i)->region()->freeze ();
4009
4010                         AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
4011                         if (arv)
4012                                 arv->temporarily_hide_envelope ();
4013
4014                         Playlist * pl = (*i)->region()->playlist();
4015                         insert_result = motion_frozen_playlists.insert (pl);
4016                         if (insert_result.second) {
4017                                 session->add_command(new MementoCommand<Playlist>(*pl, &pl->get_state(), 0));
4018                         }
4019                 }
4020         }
4021
4022         if (left_direction) {
4023                 frame_delta = (drag_info.last_pointer_frame - drag_info.current_pointer_frame);
4024         } else {
4025                 frame_delta = (drag_info.current_pointer_frame - drag_info.last_pointer_frame);
4026         }
4027
4028         switch (trim_op) {
4029         case StartTrim:
4030                 if ((left_direction == false) && (drag_info.current_pointer_frame <= rv->region()->first_frame()/speed)) {
4031                         break;
4032                 } else {
4033                         for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
4034                                 single_start_trim (**i, frame_delta, left_direction, obey_snap);
4035                         }
4036                         break;
4037                 }
4038
4039         case EndTrim:
4040                 if ((left_direction == true) && (drag_info.current_pointer_frame > (nframes_t) (rv->region()->last_frame()/speed))) {
4041                         break;
4042                 } else {
4043                         for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
4044                                 single_end_trim (**i, frame_delta, left_direction, obey_snap);
4045                         }
4046                         break;
4047                 }
4048
4049         case ContentsTrim:
4050                 {
4051                         bool swap_direction = false;
4052
4053                         if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
4054                                 swap_direction = true;
4055                         }
4056
4057                         for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin();
4058                              i != selection->regions.by_layer().end(); ++i)
4059                         {
4060                                 single_contents_trim (**i, frame_delta, left_direction, swap_direction, obey_snap);
4061                         }
4062                 }
4063                 break;
4064         }
4065
4066         switch (trim_op) {
4067         case StartTrim:
4068                 show_verbose_time_cursor((nframes_t) (rv->region()->position()/speed), 10);
4069                 break;
4070         case EndTrim:
4071                 show_verbose_time_cursor((nframes_t) (rv->region()->last_frame()/speed), 10);
4072                 break;
4073         case ContentsTrim:
4074                 show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
4075                 break;
4076         }
4077
4078         drag_info.last_pointer_frame = drag_info.current_pointer_frame;
4079         drag_info.first_move = false;
4080 }
4081
4082 void
4083 Editor::single_contents_trim (RegionView& rv, nframes_t frame_delta, bool left_direction, bool swap_direction, bool obey_snap)
4084 {
4085         boost::shared_ptr<Region> region (rv.region());
4086
4087         if (region->locked()) {
4088                 return;
4089         }
4090
4091         nframes_t new_bound;
4092
4093         double speed = 1.0;
4094         TimeAxisView* tvp = clicked_trackview;
4095         RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
4096
4097         if (tv && tv->is_audio_track()) {
4098                 speed = tv->get_diskstream()->speed();
4099         }
4100
4101         if (left_direction) {
4102                 if (swap_direction) {
4103                         new_bound = (nframes_t) (region->position()/speed) + frame_delta;
4104                 } else {
4105                         new_bound = (nframes_t) (region->position()/speed) - frame_delta;
4106                 }
4107         } else {
4108                 if (swap_direction) {
4109                         new_bound = (nframes_t) (region->position()/speed) - frame_delta;
4110                 } else {
4111                         new_bound = (nframes_t) (region->position()/speed) + frame_delta;
4112                 }
4113         }
4114
4115         if (obey_snap) {
4116                 snap_to (new_bound);
4117         }
4118         region->trim_start ((nframes_t) (new_bound * speed), this);
4119         rv.region_changed (StartChanged);
4120 }
4121
4122 void
4123 Editor::single_start_trim (RegionView& rv, nframes_t frame_delta, bool left_direction, bool obey_snap)
4124 {
4125         boost::shared_ptr<Region> region (rv.region());
4126
4127         if (region->locked()) {
4128                 return;
4129         }
4130
4131         nframes_t new_bound;
4132
4133         double speed = 1.0;
4134         TimeAxisView* tvp = clicked_trackview;
4135         AudioTimeAxisView* tv = dynamic_cast<AudioTimeAxisView*>(tvp);
4136
4137         if (tv && tv->is_audio_track()) {
4138                 speed = tv->get_diskstream()->speed();
4139         }
4140
4141         if (left_direction) {
4142                 new_bound = (nframes_t) (region->position()/speed) - frame_delta;
4143         } else {
4144                 new_bound = (nframes_t) (region->position()/speed) + frame_delta;
4145         }
4146
4147         if (obey_snap) {
4148                 snap_to (new_bound, (left_direction ? 0 : 1));
4149         }
4150
4151         region->trim_front ((nframes_t) (new_bound * speed), this);
4152
4153         rv.region_changed (Change (LengthChanged|PositionChanged|StartChanged));
4154 }
4155
4156 void
4157 Editor::single_end_trim (RegionView& rv, nframes_t frame_delta, bool left_direction, bool obey_snap)
4158 {
4159         boost::shared_ptr<Region> region (rv.region());
4160
4161         if (region->locked()) {
4162                 return;
4163         }
4164
4165         nframes_t new_bound;
4166
4167         double speed = 1.0;
4168         TimeAxisView* tvp = clicked_trackview;
4169         AudioTimeAxisView* tv = dynamic_cast<AudioTimeAxisView*>(tvp);
4170
4171         if (tv && tv->is_audio_track()) {
4172                 speed = tv->get_diskstream()->speed();
4173         }
4174
4175         if (left_direction) {
4176                 new_bound = (nframes_t) ((region->last_frame() + 1)/speed) - frame_delta;
4177         } else {
4178                 new_bound = (nframes_t) ((region->last_frame() + 1)/speed) + frame_delta;
4179         }
4180
4181         if (obey_snap) {
4182                 snap_to (new_bound);
4183         }
4184         region->trim_end ((nframes_t) (new_bound * speed), this);
4185         rv.region_changed (LengthChanged);
4186 }
4187
4188 void
4189 Editor::trim_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
4190 {
4191         if (!drag_info.first_move) {
4192                 trim_motion_callback (item, event);
4193
4194                 if (!clicked_regionview->get_selected()) {
4195                         thaw_region_after_trim (*clicked_regionview);
4196                 } else {
4197
4198                         for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin();
4199                              i != selection->regions.by_layer().end(); ++i)
4200                         {
4201                                 thaw_region_after_trim (**i);
4202                         }
4203                 }
4204
4205                 for (set<Playlist*>::iterator p = motion_frozen_playlists.begin(); p != motion_frozen_playlists.end(); ++p) {
4206                         //(*p)->thaw ();
4207                         session->add_command (new MementoCommand<Playlist>(*(*p), 0, &(*p)->get_state()));
4208                 }
4209
4210                 motion_frozen_playlists.clear ();
4211
4212                 commit_reversible_command();
4213         } else {
4214                 /* no mouse movement */
4215                 point_trim (event);
4216         }
4217 }
4218
4219 void
4220 Editor::point_trim (GdkEvent* event)
4221 {
4222         RegionView* rv = clicked_regionview;
4223         nframes_t new_bound = drag_info.current_pointer_frame;
4224
4225         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
4226                 snap_to (new_bound);
4227         }
4228
4229         /* Choose action dependant on which button was pressed */
4230         switch (event->button.button) {
4231         case 1:
4232                 trim_op = StartTrim;
4233                 begin_reversible_command (_("Start point trim"));
4234
4235                 if (rv->get_selected()) {
4236
4237                         for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin();
4238                              i != selection->regions.by_layer().end(); ++i)
4239                         {
4240                                 if (!(*i)->region()->locked()) {
4241                                         Playlist *pl = (*i)->region()->playlist();
4242                                         XMLNode &before = pl->get_state();
4243                                         (*i)->region()->trim_front (new_bound, this);
4244                                         XMLNode &after = pl->get_state();
4245                                         session->add_command(new MementoCommand<Playlist>(*pl, &before, &after));
4246                                 }
4247                         }
4248
4249                 } else {
4250
4251                         if (!rv->region()->locked()) {
4252                                 Playlist *pl = rv->region()->playlist();
4253                                 XMLNode &before = pl->get_state();
4254                                 rv->region()->trim_front (new_bound, this);
4255                                 XMLNode &after = pl->get_state();
4256                                 session->add_command(new MementoCommand<Playlist>(*pl, &before, &after));
4257                         }
4258                 }
4259
4260                 commit_reversible_command();
4261
4262                 break;
4263         case 2:
4264                 trim_op = EndTrim;
4265                 begin_reversible_command (_("End point trim"));
4266
4267                 if (rv->get_selected()) {
4268
4269                         for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i)
4270                         {
4271                                 if (!(*i)->region()->locked()) {
4272                                         Playlist *pl = (*i)->region()->playlist();
4273                                         XMLNode &before = pl->get_state();
4274                                         (*i)->region()->trim_end (new_bound, this);
4275                                         XMLNode &after = pl->get_state();
4276                                         session->add_command(new MementoCommand<Playlist>(*pl, &before, &after));
4277                                 }
4278                         }
4279
4280                 } else {
4281
4282                         if (!rv->region()->locked()) {
4283                                 Playlist *pl = rv->region()->playlist();
4284                                 XMLNode &before = pl->get_state();
4285                                 rv->region()->trim_end (new_bound, this);
4286                                 XMLNode &after = pl->get_state();
4287                                 session->add_command (new MementoCommand<Playlist>(*pl, &before, &after));
4288                         }
4289                 }
4290
4291                 commit_reversible_command();
4292
4293                 break;
4294         default:
4295                 break;
4296         }
4297 }
4298
4299 void
4300 Editor::thaw_region_after_trim (RegionView& rv)
4301 {
4302         boost::shared_ptr<Region> region (rv.region());
4303
4304         if (region->locked()) {
4305                 return;
4306         }
4307
4308         region->thaw (_("trimmed region"));
4309         XMLNode &after = region->playlist()->get_state();
4310         session->add_command (new MementoCommand<Playlist>(*(region->playlist()), 0, &after));
4311
4312         AudioRegionView* arv = dynamic_cast<AudioRegionView*>(&rv);
4313         if (arv)
4314                 arv->unhide_envelope ();
4315 }
4316
4317 void
4318 Editor::hide_marker (ArdourCanvas::Item* item, GdkEvent* event)
4319 {
4320         Marker* marker;
4321         bool is_start;
4322
4323         if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
4324                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
4325                 /*NOTREACHED*/
4326         }
4327
4328         Location* location = find_location_from_marker (marker, is_start);
4329         location->set_hidden (true, this);
4330 }
4331
4332
4333 void
4334 Editor::start_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event, RangeMarkerOp op)
4335 {
4336         if (session == 0) {
4337                 return;
4338         }
4339
4340         drag_info.item = item;
4341         drag_info.motion_callback = &Editor::drag_range_markerbar_op;
4342         drag_info.finished_callback = &Editor::end_range_markerbar_op;
4343
4344         range_marker_op = op;
4345
4346         if (!temp_location) {
4347                 temp_location = new Location;
4348         }
4349
4350         switch (op) {
4351         case CreateRangeMarker:
4352         case CreateTransportMarker:
4353
4354                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
4355                         drag_info.copy = true;
4356                 } else {
4357                         drag_info.copy = false;
4358                 }
4359                 start_grab (event, selector_cursor);
4360                 break;
4361         }
4362
4363         show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
4364
4365 }
4366
4367 void
4368 Editor::drag_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event)
4369 {
4370         nframes_t start = 0;
4371         nframes_t end = 0;
4372         ArdourCanvas::SimpleRect *crect = (range_marker_op == CreateRangeMarker) ? range_bar_drag_rect: transport_bar_drag_rect;
4373
4374         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
4375                 snap_to (drag_info.current_pointer_frame);
4376         }
4377
4378         /* only alter selection if the current frame is
4379            different from the last frame position.
4380          */
4381
4382         if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) return;
4383
4384         switch (range_marker_op) {
4385         case CreateRangeMarker:
4386         case CreateTransportMarker:
4387                 if (drag_info.first_move) {
4388                         snap_to (drag_info.grab_frame);
4389                 }
4390
4391                 if (drag_info.current_pointer_frame < drag_info.grab_frame) {
4392                         start = drag_info.current_pointer_frame;
4393                         end = drag_info.grab_frame;
4394                 } else {
4395                         end = drag_info.current_pointer_frame;
4396                         start = drag_info.grab_frame;
4397                 }
4398
4399                 /* first drag: Either add to the selection
4400                    or create a new selection.
4401                 */
4402
4403                 if (drag_info.first_move) {
4404
4405                         temp_location->set (start, end);
4406
4407                         crect->show ();
4408
4409                         update_marker_drag_item (temp_location);
4410                         range_marker_drag_rect->show();
4411                         range_marker_drag_rect->raise_to_top();
4412
4413                 }
4414                 break;
4415         }
4416
4417         if (event->button.x >= horizontal_adjustment.get_value() + canvas_width) {
4418                 start_canvas_autoscroll (1);
4419         }
4420
4421         if (start != end) {
4422                 temp_location->set (start, end);
4423
4424                 double x1 = frame_to_pixel (start);
4425                 double x2 = frame_to_pixel (end);
4426                 crect->property_x1() = x1;
4427                 crect->property_x2() = x2;
4428
4429                 update_marker_drag_item (temp_location);
4430         }
4431
4432         drag_info.last_pointer_frame = drag_info.current_pointer_frame;
4433         drag_info.first_move = false;
4434
4435         show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
4436
4437 }
4438
4439 void
4440 Editor::end_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event)
4441 {
4442         Location * newloc = 0;
4443
4444         if (!drag_info.first_move) {
4445                 drag_range_markerbar_op (item, event);
4446
4447                 switch (range_marker_op) {
4448                 case CreateRangeMarker:
4449                     {
4450                         begin_reversible_command (_("new range marker"));
4451                         XMLNode &before = session->locations()->get_state();
4452                         newloc = new Location(temp_location->start(), temp_location->end(), "unnamed", Location::IsRangeMarker);
4453                         session->locations()->add (newloc, true);
4454                         XMLNode &after = session->locations()->get_state();
4455                         session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
4456                         commit_reversible_command ();
4457
4458                         range_bar_drag_rect->hide();
4459                         range_marker_drag_rect->hide();
4460                         break;
4461                     }
4462
4463                 case CreateTransportMarker:
4464                         // popup menu to pick loop or punch
4465                         new_transport_marker_context_menu (&event->button, item);
4466
4467                         break;
4468                 }
4469         } else {
4470                 /* just a click, no pointer movement. remember that context menu stuff was handled elsewhere */
4471
4472                 if (Keyboard::no_modifier_keys_pressed (&event->button)) {
4473
4474                         nframes_t start;
4475                         nframes_t end;
4476
4477                         start = session->locations()->first_mark_before (drag_info.grab_frame);
4478                         end = session->locations()->first_mark_after (drag_info.grab_frame);
4479
4480                         if (end == max_frames) {
4481                                 end = session->current_end_frame ();
4482                         }
4483
4484                         if (start == 0) {
4485                                 start = session->current_start_frame ();
4486                         }
4487
4488                         switch (mouse_mode) {
4489                         case MouseObject:
4490                                 /* find the two markers on either side and then make the selection from it */
4491                                 cerr << "select between " << start << " .. " << end << endl;
4492                                 select_all_within (start, end, 0.0f, FLT_MAX, Selection::Set);
4493                                 break;
4494
4495                         case MouseRange:
4496                                 /* find the two markers on either side of the click and make the range out of it */
4497                                 selection->set (0, start, end);
4498                                 break;
4499
4500                         default:
4501                                 break;
4502                         }
4503                 }
4504         }
4505
4506         stop_canvas_autoscroll ();
4507 }
4508
4509
4510
4511 void
4512 Editor::start_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event)
4513 {
4514         drag_info.item = item;
4515         drag_info.motion_callback = &Editor::drag_mouse_zoom;
4516         drag_info.finished_callback = &Editor::end_mouse_zoom;
4517
4518         start_grab (event, zoom_cursor);
4519
4520         show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
4521 }
4522
4523 void
4524 Editor::drag_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event)
4525 {
4526         nframes_t start;
4527         nframes_t end;
4528
4529         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
4530                 snap_to (drag_info.current_pointer_frame);
4531
4532                 if (drag_info.first_move) {
4533                         snap_to (drag_info.grab_frame);
4534                 }
4535         }
4536
4537         if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) return;
4538
4539         /* base start and end on initial click position */
4540         if (drag_info.current_pointer_frame < drag_info.grab_frame) {
4541                 start = drag_info.current_pointer_frame;
4542                 end = drag_info.grab_frame;
4543         } else {
4544                 end = drag_info.current_pointer_frame;
4545                 start = drag_info.grab_frame;
4546         }
4547
4548         if (start != end) {
4549
4550                 if (drag_info.first_move) {
4551                         zoom_rect->show();
4552                         zoom_rect->raise_to_top();
4553                 }
4554
4555                 reposition_zoom_rect(start, end);
4556
4557                 drag_info.last_pointer_frame = drag_info.current_pointer_frame;
4558                 drag_info.first_move = false;
4559
4560                 show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
4561         }
4562 }
4563
4564 void
4565 Editor::end_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event)
4566 {
4567         if (!drag_info.first_move) {
4568                 drag_mouse_zoom (item, event);
4569
4570                 if (drag_info.grab_frame < drag_info.last_pointer_frame) {
4571                         temporal_zoom_by_frame (drag_info.grab_frame, drag_info.last_pointer_frame, "mouse zoom");
4572                 } else {
4573                         temporal_zoom_by_frame (drag_info.last_pointer_frame, drag_info.grab_frame, "mouse zoom");
4574                 }
4575         } else {
4576                 temporal_zoom_to_frame (false, drag_info.grab_frame);
4577                 /*
4578                 temporal_zoom_step (false);
4579                 center_screen (drag_info.grab_frame);
4580                 */
4581         }
4582
4583         zoom_rect->hide();
4584 }
4585
4586 void
4587 Editor::reposition_zoom_rect (nframes_t start, nframes_t end)
4588 {
4589         double x1 = frame_to_pixel (start);
4590         double x2 = frame_to_pixel (end);
4591         double y2 = canvas_height - 2;
4592
4593         zoom_rect->property_x1() = x1;
4594         zoom_rect->property_y1() = 1.0;
4595         zoom_rect->property_x2() = x2;
4596         zoom_rect->property_y2() = y2;
4597 }
4598
4599 void
4600 Editor::start_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event)
4601 {
4602         drag_info.item = item;
4603         drag_info.motion_callback = &Editor::drag_rubberband_select;
4604         drag_info.finished_callback = &Editor::end_rubberband_select;
4605
4606         start_grab (event, cross_hair_cursor);
4607
4608         show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
4609 }
4610
4611 void
4612 Editor::drag_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event)
4613 {
4614         nframes_t start;
4615         nframes_t end;
4616         double y1;
4617         double y2;
4618
4619         /* use a bigger drag threshold than the default */
4620
4621         if (abs ((int) (drag_info.current_pointer_frame - drag_info.grab_frame)) < 8) {
4622                 return;
4623         }
4624
4625 //      if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
4626 //              snap_to (drag_info.current_pointer_frame);
4627
4628 //              if (drag_info.first_move) {
4629 //                      snap_to (drag_info.grab_frame);
4630 //              }
4631 //      }
4632
4633
4634         /* base start and end on initial click position */
4635         if (drag_info.current_pointer_frame < drag_info.grab_frame) {
4636                 start = drag_info.current_pointer_frame;
4637                 end = drag_info.grab_frame;
4638         } else {
4639                 end = drag_info.current_pointer_frame;
4640                 start = drag_info.grab_frame;
4641         }
4642
4643         if (drag_info.current_pointer_y < drag_info.grab_y) {
4644                 y1 = drag_info.current_pointer_y;
4645                 y2 = drag_info.grab_y;
4646         }
4647         else {
4648                 y2 = drag_info.current_pointer_y;
4649                 y1 = drag_info.grab_y;
4650         }
4651
4652
4653         if (start != end || y1 != y2) {
4654
4655                 double x1 = frame_to_pixel (start);
4656                 double x2 = frame_to_pixel (end);
4657
4658                 rubberband_rect->property_x1() = x1;
4659                 rubberband_rect->property_y1() = y1;
4660                 rubberband_rect->property_x2() = x2;
4661                 rubberband_rect->property_y2() = y2;
4662
4663                 rubberband_rect->show();
4664                 rubberband_rect->raise_to_top();
4665
4666                 drag_info.last_pointer_frame = drag_info.current_pointer_frame;
4667                 drag_info.first_move = false;
4668
4669                 show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
4670         }
4671 }
4672
4673 void
4674 Editor::end_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event)
4675 {
4676         if (!drag_info.first_move) {
4677
4678                 drag_rubberband_select (item, event);
4679
4680                 double y1,y2;
4681                 if (drag_info.current_pointer_y < drag_info.grab_y) {
4682                         y1 = drag_info.current_pointer_y;
4683                         y2 = drag_info.grab_y;
4684                 }
4685                 else {
4686                         y2 = drag_info.current_pointer_y;
4687                         y1 = drag_info.grab_y;
4688                 }
4689
4690
4691                 Selection::Operation op = Keyboard::selection_type (event->button.state);
4692                 bool commit;
4693
4694                 begin_reversible_command (_("select regions"));
4695
4696                 if (drag_info.grab_frame < drag_info.last_pointer_frame) {
4697                         commit = select_all_within (drag_info.grab_frame, drag_info.last_pointer_frame, y1, y2, op);
4698                 } else {
4699                         commit = select_all_within (drag_info.last_pointer_frame, drag_info.grab_frame, y1, y2, op);
4700                 }
4701
4702                 if (commit) {
4703                         commit_reversible_command ();
4704                 }
4705
4706         } else {
4707                 selection->clear_regions();
4708                 selection->clear_points ();
4709                 selection->clear_lines ();
4710         }
4711
4712         rubberband_rect->hide();
4713 }
4714
4715
4716 gint
4717 Editor::mouse_rename_region (ArdourCanvas::Item* item, GdkEvent* event)
4718 {
4719         using namespace Gtkmm2ext;
4720
4721         ArdourPrompter prompter (false);
4722
4723         prompter.set_prompt (_("Name for region:"));
4724         prompter.set_initial_text (clicked_regionview->region()->name());
4725         prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
4726         prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
4727         prompter.show_all ();
4728         switch (prompter.run ()) {
4729         case Gtk::RESPONSE_ACCEPT:
4730         string str;
4731                 prompter.get_result(str);
4732                 if (str.length()) {
4733                 clicked_regionview->region()->set_name (str);
4734                 }
4735                 break;
4736         }
4737         return true;
4738 }
4739
4740 void
4741 Editor::start_time_fx (ArdourCanvas::Item* item, GdkEvent* event)
4742 {
4743         drag_info.item = item;
4744         drag_info.motion_callback = &Editor::time_fx_motion;
4745         drag_info.finished_callback = &Editor::end_time_fx;
4746
4747         start_grab (event);
4748
4749         show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
4750 }
4751
4752 void
4753 Editor::time_fx_motion (ArdourCanvas::Item *item, GdkEvent* event)
4754 {
4755         RegionView* rv = clicked_regionview;
4756
4757         if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
4758                 snap_to (drag_info.current_pointer_frame);
4759         }
4760
4761         if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) {
4762                 return;
4763         }
4764
4765         if (drag_info.current_pointer_frame > rv->region()->position()) {
4766                 rv->get_time_axis_view().show_timestretch (rv->region()->position(), drag_info.current_pointer_frame);
4767         }
4768
4769         drag_info.last_pointer_frame = drag_info.current_pointer_frame;
4770         drag_info.first_move = false;
4771
4772         show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
4773 }
4774
4775 void
4776 Editor::end_time_fx (ArdourCanvas::Item* item, GdkEvent* event)
4777 {
4778         clicked_regionview->get_time_axis_view().hide_timestretch ();
4779
4780         if (drag_info.first_move) {
4781                 return;
4782         }
4783
4784         nframes_t newlen = drag_info.last_pointer_frame - clicked_regionview->region()->position();
4785         float percentage = (float) ((double) newlen - (double) clicked_regionview->region()->length()) / ((double) newlen) * 100.0f;
4786
4787         begin_reversible_command (_("timestretch"));
4788
4789         if (run_timestretch (selection->regions, percentage) == 0) {
4790                 session->commit_reversible_command ();
4791         }
4792 }
4793
4794 void
4795 Editor::mouse_brush_insert_region (RegionView* rv, nframes_t pos)
4796 {
4797         /* no brushing without a useful snap setting */
4798
4799         // FIXME
4800         AudioRegionView* arv = dynamic_cast<AudioRegionView*>(rv);
4801         assert(arv);
4802
4803         switch (snap_mode) {
4804         case SnapMagnetic:
4805                 return; /* can't work because it allows region to be placed anywhere */
4806         default:
4807                 break; /* OK */
4808         }
4809
4810         switch (snap_type) {
4811         case SnapToFrame:
4812         case SnapToMark:
4813         case SnapToEditCursor:
4814                 return;
4815
4816         default:
4817                 break;
4818         }
4819
4820         /* don't brush a copy over the original */
4821
4822         if (pos == rv->region()->position()) {
4823                 return;
4824         }
4825
4826         RouteTimeAxisView* atv = dynamic_cast<RouteTimeAxisView*>(&arv->get_time_axis_view());
4827
4828         if (atv == 0 || !atv->is_audio_track()) {
4829                 return;
4830         }
4831
4832         Playlist* playlist = atv->playlist();
4833         double speed = atv->get_diskstream()->speed();
4834
4835         XMLNode &before = playlist->get_state();
4836         playlist->add_region (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (arv->audio_region())), (nframes_t) (pos * speed));
4837         XMLNode &after = playlist->get_state();
4838         session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
4839
4840         // playlist is frozen, so we have to update manually
4841
4842         playlist->Modified(); /* EMIT SIGNAL */
4843 }
4844
4845 gint
4846 Editor::track_height_step_timeout ()
4847 {
4848         struct timeval now;
4849         struct timeval delta;
4850
4851         gettimeofday (&now, 0);
4852         timersub (&now, &last_track_height_step_timestamp, &delta);
4853
4854         if (delta.tv_sec * 1000000 + delta.tv_usec > 250000) { /* milliseconds */
4855                 current_stepping_trackview = 0;
4856                 return false;
4857         }
4858         return true;
4859 }