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 */
  19
  20 #include <cassert>
  21 #include <cstdlib>
  22 #include <stdint.h>
  23 #include <cmath>
  24 #include <set>
  25 #include <string>
  26 #include <algorithm>
  27
  28 #include "pbd/error.h"
  29 #include "pbd/enumwriter.h"
  30 #include "pbd/memento_command.h"
  31 #include "pbd/basename.h"
  32 #include "pbd/stateful_diff_command.h"
  33
  34 #include "gtkmm2ext/bindings.h"
  35 #include "gtkmm2ext/utils.h"
  36 #include "gtkmm2ext/tearoff.h"
  37
  38 #include "ardour_ui.h"
  39 #include "actions.h"
  40 #include "canvas-note.h"
  41 #include "editor.h"
  42 #include "time_axis_view.h"
  43 #include "audio_time_axis.h"
  44 #include "audio_region_view.h"
  45 #include "midi_region_view.h"
  46 #include "marker.h"
  47 #include "streamview.h"
  48 #include "region_gain_line.h"
  49 #include "automation_time_axis.h"
  50 #include "control_point.h"
  51 #include "prompter.h"
  52 #include "utils.h"
  53 #include "selection.h"
  54 #include "keyboard.h"
  55 #include "editing.h"
  56 #include "rgb_macros.h"
  57 #include "control_point_dialog.h"
  58 #include "editor_drag.h"
  59 #include "automation_region_view.h"
  60 #include "edit_note_dialog.h"
  61 #include "mouse_cursors.h"
  62 #include "editor_cursors.h"
  63 #include "verbose_cursor.h"
  64
  65 #include "ardour/types.h"
  66 #include "ardour/profile.h"
  67 #include "ardour/route.h"
  68 #include "ardour/audio_track.h"
  69 #include "ardour/audio_diskstream.h"
  70 #include "ardour/midi_diskstream.h"
  71 #include "ardour/playlist.h"
  72 #include "ardour/audioplaylist.h"
  73 #include "ardour/audioregion.h"
  74 #include "ardour/midi_region.h"
  75 #include "ardour/dB.h"
  76 #include "ardour/utils.h"
  77 #include "ardour/region_factory.h"
  78 #include "ardour/source_factory.h"
  79 #include "ardour/session.h"
  80 #include "ardour/operations.h"
  81
  82 #include <bitset>
  83
  84 #include "i18n.h"
  85
  86 using namespace std;
  87 using namespace ARDOUR;
  88 using namespace PBD;
  89 using namespace Gtk;
  90 using namespace Editing;
  91 using Gtkmm2ext::Keyboard;
  92
  93 bool
  94 Editor::mouse_frame (framepos_t& where, bool& in_track_canvas) const
  95 {
  96         int x, y;
  97         double wx, wy;
  98         Gdk::ModifierType mask;
  99         Glib::RefPtr<Gdk::Window> canvas_window = const_cast<Editor*>(this)->track_canvas->get_window();
 100         Glib::RefPtr<const Gdk::Window> pointer_window;
 101
 102         if (!canvas_window) {
 103                 return false;
 104         }
 105
 106         pointer_window = canvas_window->get_pointer (x, y, mask);
 107
 108         if (pointer_window == track_canvas->get_bin_window()) {
 109                 wx = x;
 110                 wy = y;
 111                 in_track_canvas = true;
 112
 113         } else {
 114                 in_track_canvas = false;
 115                         return false;
 116         }
 117
 118         GdkEvent event;
 119         event.type = GDK_BUTTON_RELEASE;
 120         event.button.x = wx;
 121         event.button.y = wy;
 122
 123         where = event_frame (&event, 0, 0);
 124         return true;
 125 }
 126
 127 framepos_t
 128 Editor::event_frame (GdkEvent const * event, double* pcx, double* pcy) const
 129 {
 130         double cx, cy;
 131
 132         if (pcx == 0) {
 133                 pcx = &cx;
 134         }
 135         if (pcy == 0) {
 136                 pcy = &cy;
 137         }
 138
 139         *pcx = 0;
 140         *pcy = 0;
 141
 142         switch (event->type) {
 143         case GDK_BUTTON_RELEASE:
 144         case GDK_BUTTON_PRESS:
 145         case GDK_2BUTTON_PRESS:
 146         case GDK_3BUTTON_PRESS:
 147                 *pcx = event->button.x;
 148                 *pcy = event->button.y;
 149                 _trackview_group->w2i(*pcx, *pcy);
 150                 break;
 151         case GDK_MOTION_NOTIFY:
 152                 *pcx = event->motion.x;
 153                 *pcy = event->motion.y;
 154                 _trackview_group->w2i(*pcx, *pcy);
 155                 break;
 156         case GDK_ENTER_NOTIFY:
 157         case GDK_LEAVE_NOTIFY:
 158                 track_canvas->w2c(event->crossing.x, event->crossing.y, *pcx, *pcy);
 159                 break;
 160         case GDK_KEY_PRESS:
 161         case GDK_KEY_RELEASE:
 162                 // track_canvas->w2c(event->key.x, event->key.y, *pcx, *pcy);
 163                 break;
 164         default:
 165                 warning << string_compose (_("Editor::event_frame() used on unhandled event type %1"), event->type) << endmsg;
 166                 break;
 167         }
 168
 169         /* note that pixel_to_frame() never returns less than zero, so even if the pixel
 170            position is negative (as can be the case with motion events in particular),
 171            the frame location is always positive.
 172         */
 173
 174         return pixel_to_frame (*pcx);
 175 }
 176
 177 Gdk::Cursor*
 178 Editor::which_grabber_cursor ()
 179 {
 180         Gdk::Cursor* c = _cursors->grabber;
 181
 182         if (_internal_editing) {
 183                 switch (mouse_mode) {
 184                 case MouseRange:
 185                         c = _cursors->midi_pencil;
 186                         break;
 187
 188                 case MouseObject:
 189                         c = _cursors->grabber_note;
 190                         break;
 191
 192                 case MouseTimeFX:
 193                         c = _cursors->midi_resize;
 194                         break;
 195
 196                 default:
 197                         break;
 198                 }
 199
 200         } else {
 201
 202                 switch (_edit_point) {
 203                 case EditAtMouse:
 204                         c = _cursors->grabber_edit_point;
 205                         break;
 206                 default:
 207                         boost::shared_ptr<Movable> m = _movable.lock();
 208                         if (m && m->locked()) {
 209                                 c = _cursors->speaker;
 210                         }
 211                         break;
 212                 }
 213         }
 214
 215         return c;
 216 }
 217
 218 void
 219 Editor::set_current_trimmable (boost::shared_ptr<Trimmable> t)
 220 {
 221         boost::shared_ptr<Trimmable> st = _trimmable.lock();
 222
 223         if (!st || st == t) {
 224                 _trimmable = t;
 225                 set_canvas_cursor ();
 226         }
 227 }
 228
 229 void
 230 Editor::set_current_movable (boost::shared_ptr<Movable> m)
 231 {
 232         boost::shared_ptr<Movable> sm = _movable.lock();
 233
 234         if (!sm || sm != m) {
 235                 _movable = m;
 236                 set_canvas_cursor ();
 237         }
 238 }
 239
 240 void
 241 Editor::set_canvas_cursor ()
 242 {
 243         if (_internal_editing) {
 244
 245                 switch (mouse_mode) {
 246                 case MouseRange:
 247                         current_canvas_cursor = _cursors->midi_pencil;
 248                         break;
 249
 250                 case MouseObject:
 251                         current_canvas_cursor = which_grabber_cursor();
 252                         break;
 253
 254                 case MouseTimeFX:
 255                         current_canvas_cursor = _cursors->midi_resize;
 256                         break;
 257
 258                 default:
 259                         return;
 260                 }
 261
 262         } else {
 263
 264                 switch (mouse_mode) {
 265                 case MouseRange:
 266                         current_canvas_cursor = _cursors->selector;
 267                         break;
 268
 269                 case MouseObject:
 270                         current_canvas_cursor = which_grabber_cursor();
 271                         break;
 272
 273                 case MouseGain:
 274                         current_canvas_cursor = _cursors->cross_hair;
 275                         break;
 276
 277                 case MouseZoom:
 278                         if (Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
 279                                 current_canvas_cursor = _cursors->zoom_out;
 280                         } else {
 281                                 current_canvas_cursor = _cursors->zoom_in;
 282                         }
 283                         break;
 284
 285                 case MouseTimeFX:
 286                         current_canvas_cursor = _cursors->time_fx; // just use playhead
 287                         break;
 288
 289                 case MouseAudition:
 290                         current_canvas_cursor = _cursors->speaker;
 291                         break;
 292                 }
 293         }
 294
 295         switch (_join_object_range_state) {
 296         case JOIN_OBJECT_RANGE_NONE:
 297                 break;
 298         case JOIN_OBJECT_RANGE_OBJECT:
 299                 current_canvas_cursor = which_grabber_cursor ();
 300                 break;
 301         case JOIN_OBJECT_RANGE_RANGE:
 302                 current_canvas_cursor = _cursors->selector;
 303                 break;
 304         }
 305
 306         /* up-down cursor as a cue that automation can be dragged up and down when in join object/range mode */
 307         if (join_object_range_button.get_active() && last_item_entered) {
 308                 if (last_item_entered->property_parent() && (*last_item_entered->property_parent()).get_data (X_("timeselection"))) {
 309                         pair<TimeAxisView*, int> tvp = trackview_by_y_position (_last_motion_y + vertical_adjustment.get_value() - canvas_timebars_vsize);
 310                         if (dynamic_cast<AutomationTimeAxisView*> (tvp.first)) {
 311                                 current_canvas_cursor = _cursors->up_down;
 312                         }
 313                 }
 314         }
 315
 316         set_canvas_cursor (current_canvas_cursor, true);
 317 }
 318
 319 void
 320 Editor::set_mouse_mode (MouseMode m, bool force)
 321 {
 322         if (_drags->active ()) {
 323                 return;
 324         }
 325
 326         if (!force && m == mouse_mode) {
 327                 return;
 328         }
 329
 330         Glib::RefPtr<Action> act;
 331
 332         switch (m) {
 333         case MouseRange:
 334                 act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-range"));
 335                 break;
 336
 337         case MouseObject:
 338                 act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-object"));
 339                 break;
 340
 341         case MouseGain:
 342                 act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-gain"));
 343                 break;
 344
 345         case MouseZoom:
 346                 act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-zoom"));
 347                 break;
 348
 349         case MouseTimeFX:
 350                 act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-timefx"));
 351                 break;
 352
 353         case MouseAudition:
 354                 act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-audition"));
 355                 break;
 356         }
 357
 358         assert (act);
 359
 360         Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
 361         assert (tact);
 362
 363         /* go there and back to ensure that the toggled handler is called to set up mouse_mode */
 364         tact->set_active (false);
 365         tact->set_active (true);
 366
 367         MouseModeChanged (); /* EMIT SIGNAL */
 368 }
 369
 370 void
 371 Editor::mouse_mode_toggled (MouseMode m)
 372 {
 373         mouse_mode = m;
 374
 375         instant_save ();
 376
 377         if (!internal_editing()) {
 378                 if (mouse_mode != MouseRange && _join_object_range_state == JOIN_OBJECT_RANGE_NONE) {
 379
 380                         /* in all modes except range and joined object/range, hide the range selection,
 381                            show the object (region) selection.
 382                         */
 383
 384                         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 385                                 (*i)->hide_selection ();
 386                         }
 387
 388                 } else {
 389
 390                         /*
 391                           in range or object/range mode, show the range selection.
 392                         */
 393
 394                         for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
 395                                 (*i)->show_selection (selection->time);
 396                         }
 397                 }
 398         }
 399
 400         set_canvas_cursor ();
 401
 402         MouseModeChanged (); /* EMIT SIGNAL */
 403 }
 404
 405 void
 406 Editor::step_mouse_mode (bool next)
 407 {
 408         switch (current_mouse_mode()) {
 409         case MouseObject:
 410                 if (next) {
 411                         if (Profile->get_sae()) {
 412                                 set_mouse_mode (MouseZoom);
 413                         } else {
 414                                 set_mouse_mode (MouseRange);
 415                         }
 416                 } else {
 417                         set_mouse_mode (MouseTimeFX);
 418                 }
 419                 break;
 420
 421         case MouseRange:
 422                 if (next) set_mouse_mode (MouseZoom);
 423                 else set_mouse_mode (MouseObject);
 424                 break;
 425
 426         case MouseZoom:
 427                 if (next) {
 428                         if (Profile->get_sae()) {
 429                                 set_mouse_mode (MouseTimeFX);
 430                         } else {
 431                                 set_mouse_mode (MouseGain);
 432                         }
 433                 } else {
 434                         if (Profile->get_sae()) {
 435                                 set_mouse_mode (MouseObject);
 436                         } else {
 437                                 set_mouse_mode (MouseRange);
 438                         }
 439                 }
 440                 break;
 441
 442         case MouseGain:
 443                 if (next) set_mouse_mode (MouseTimeFX);
 444                 else set_mouse_mode (MouseZoom);
 445                 break;
 446
 447         case MouseTimeFX:
 448                 if (next) {
 449                         set_mouse_mode (MouseAudition);
 450                 } else {
 451                         if (Profile->get_sae()) {
 452                                 set_mouse_mode (MouseZoom);
 453                         } else {
 454                                 set_mouse_mode (MouseGain);
 455                         }
 456                 }
 457                 break;
 458
 459         case MouseAudition:
 460                 if (next) set_mouse_mode (MouseObject);
 461                 else set_mouse_mode (MouseTimeFX);
 462                 break;
 463         }
 464 }
 465
 466 void
 467 Editor::button_selection (ArdourCanvas::Item* /*item*/, GdkEvent* event, ItemType item_type)
 468 {
 469         /* in object/audition/timefx/gain-automation mode,
 470            any button press sets the selection if the object
 471            can be selected. this is a bit of hack, because
 472            we want to avoid this if the mouse operation is a
 473            region alignment.
 474
 475            note: not dbl-click or triple-click
 476
 477            Also note that there is no region selection in internal edit mode, otherwise
 478            for operations operating on the selection (e.g. cut) it is not obvious whether
 479            to cut notes or regions.
 480         */
 481
 482         if (((mouse_mode != MouseObject) &&
 483              (_join_object_range_state != JOIN_OBJECT_RANGE_OBJECT) &&
 484              (mouse_mode != MouseAudition || item_type != RegionItem) &&
 485              (mouse_mode != MouseTimeFX || item_type != RegionItem) &&
 486              (mouse_mode != MouseGain) &&
 487              (mouse_mode != MouseRange)) ||
 488             ((event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE) || event->button.button > 3) ||
 489             internal_editing()) {
 490
 491                 return;
 492         }
 493
 494         if (event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) {
 495
 496                 if ((event->button.state & Keyboard::RelevantModifierKeyMask) && event->button.button != 1) {
 497
 498                         /* almost no selection action on modified button-2 or button-3 events */
 499
 500                         if (item_type != RegionItem && event->button.button != 2) {
 501                                 return;
 502                         }
 503                 }
 504         }
 505
 506         Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
 507         bool press = (event->type == GDK_BUTTON_PRESS);
 508
 509         switch (item_type) {
 510         case RegionItem:
 511                 if (mouse_mode != MouseRange || _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) {
 512                         set_selected_regionview_from_click (press, op, true);
 513                 } else if (event->type == GDK_BUTTON_PRESS) {
 514                         selection->clear_tracks ();
 515                         set_selected_track_as_side_effect (op, true);
 516                 }
 517                 if (_join_object_range_state == JOIN_OBJECT_RANGE_OBJECT && !selection->regions.empty()) {
 518                         clicked_selection = select_range_around_region (selection->regions.front());
 519                 }
 520                 break;
 521
 522         case RegionViewNameHighlight:
 523         case RegionViewName:
 524         case LeftFrameHandle:
 525         case RightFrameHandle:
 526                 if (mouse_mode != MouseRange || _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) {
 527                         set_selected_regionview_from_click (press, op, true);
 528                 } else if (event->type == GDK_BUTTON_PRESS) {
 529                         set_selected_track_as_side_effect (op);
 530                 }
 531                 break;
 532
 533
 534         case FadeInHandleItem:
 535         case FadeInItem:
 536         case FadeOutHandleItem:
 537         case FadeOutItem:
 538                 if (mouse_mode != MouseRange || _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) {
 539                         set_selected_regionview_from_click (press, op, true);
 540                 } else if (event->type == GDK_BUTTON_PRESS) {
 541                         set_selected_track_as_side_effect (op);
 542                 }
 543                 break;
 544
 545         case ControlPointItem:
 546                 set_selected_track_as_side_effect (op, true);
 547                 if (mouse_mode != MouseRange || _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) {
 548                         set_selected_control_point_from_click (op, false);
 549                 }
 550                 break;
 551
 552         case StreamItem:
 553                 /* for context click, select track */
 554                 if (event->button.button == 3) {
 555                         selection->clear_tracks ();
 556                         set_selected_track_as_side_effect (op, true);
 557                 }
 558                 break;
 559
 560         case AutomationTrackItem:
 561                 set_selected_track_as_side_effect (op, true);
 562                 break;
 563
 564         default:
 565                 break;
 566         }
 567 }
 568
 569 bool
 570 Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
 571 {
 572         /* single mouse clicks on any of these item types operate
 573            independent of mouse mode, mostly because they are
 574            not on the main track canvas or because we want
 575            them to be modeless.
 576         */
 577
 578         switch (item_type) {
 579         case PlayheadCursorItem:
 580                 _drags->set (new CursorDrag (this, item, true), event);
 581                 return true;
 582
 583         case MarkerItem:
 584                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
 585                         hide_marker (item, event);
 586                 } else {
 587                         _drags->set (new MarkerDrag (this, item), event);
 588                 }
 589                 return true;
 590
 591         case TempoMarkerItem:
 592                 _drags->set (
 593                         new TempoMarkerDrag (
 594                                 this,
 595                                 item,
 596                                 Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)
 597                                 ),
 598                         event
 599                         );
 600                 return true;
 601
 602         case MeterMarkerItem:
 603                 _drags->set (
 604                         new MeterMarkerDrag (
 605                                 this,
 606                                 item,
 607                                 Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)
 608                                 ),
 609                         event
 610                         );
 611                 return true;
 612
 613         case MarkerBarItem:
 614         case TempoBarItem:
 615         case MeterBarItem:
 616                 if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
 617                         _drags->set (new CursorDrag (this, &playhead_cursor->canvas_item, false), event);
 618                 }
 619                 return true;
 620                 break;
 621
 622
 623         case RangeMarkerBarItem:
 624                 if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
 625                         _drags->set (new CursorDrag (this, &playhead_cursor->canvas_item, false), event);
 626                 } else {
 627                         _drags->set (new RangeMarkerBarDrag (this, item, RangeMarkerBarDrag::CreateRangeMarker), event);
 628                 }
 629                 return true;
 630                 break;
 631
 632         case CdMarkerBarItem:
 633                 if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
 634                         _drags->set (new CursorDrag (this, &playhead_cursor->canvas_item, false), event);
 635                 } else {
 636                         _drags->set (new RangeMarkerBarDrag (this, item, RangeMarkerBarDrag::CreateCDMarker), event);
 637                 }
 638                 return true;
 639                 break;
 640
 641         case TransportMarkerBarItem:
 642                 if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
 643                         _drags->set (new CursorDrag (this, &playhead_cursor->canvas_item, false), event);
 644                 } else {
 645                         _drags->set (new RangeMarkerBarDrag (this, item, RangeMarkerBarDrag::CreateTransportMarker), event);
 646                 }
 647                 return true;
 648                 break;
 649
 650         default:
 651                 break;
 652         }
 653
 654         if (_join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) {
 655                 /* special case: allow trim of range selections in joined object mode;
 656                    in theory eff should equal MouseRange in this case, but it doesn't
 657                    because entering the range selection canvas item results in entered_regionview
 658                    being set to 0, so update_join_object_range_location acts as if we aren't
 659                    over a region.
 660                 */
 661                 if (item_type == StartSelectionTrimItem) {
 662                         _drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionStartTrim), event);
 663                 } else if (item_type == EndSelectionTrimItem) {
 664                         _drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionEndTrim), event);
 665                 }
 666         }
 667
 668         Editing::MouseMode eff = effective_mouse_mode ();
 669
 670         /* special case: allow drag of region fade in/out in object mode with join object/range enabled */
 671         if (item_type == FadeInHandleItem || item_type == FadeOutHandleItem) {
 672                 eff = MouseObject;
 673         }
 674
 675         switch (eff) {
 676         case MouseRange:
 677                 switch (item_type) {
 678                 case StartSelectionTrimItem:
 679                         _drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionStartTrim), event);
 680                         break;
 681
 682                 case EndSelectionTrimItem:
 683                         _drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionEndTrim), event);
 684                         break;
 685
 686                 case SelectionItem:
 687                         if (Keyboard::modifier_state_contains
 688                             (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier))) {
 689                                 // contains and not equals because I can't use alt as a modifier alone.
 690                                 start_selection_grab (item, event);
 691                         } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::SecondaryModifier)) {
 692                                 /* grab selection for moving */
 693                                 _drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionMove), event);
 694                         } else {
 695                                 double const y = event->button.y + vertical_adjustment.get_value() - canvas_timebars_vsize;
 696                                 pair<TimeAxisView*, int> tvp = trackview_by_y_position (y);
 697                                 if (tvp.first) {
 698                                         AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*> (tvp.first);
 699                                         if (join_object_range_button.get_active() && atv) {
 700                                                 /* smart "join" mode: drag automation */
 701                                                 _drags->set (new AutomationRangeDrag (this, atv->base_item(), selection->time), event, _cursors->up_down);
 702                                         } else {
 703                                                 /* this was debated, but decided the more common action was to
 704                                                    make a new selection */
 705                                                 _drags->set (new SelectionDrag (this, item, SelectionDrag::CreateSelection), event);
 706                                         }
 707                                 }
 708                         }
 709                         break;
 710
 711                 case NoteItem:
 712                         if (internal_editing()) {
 713                                 /* trim notes if we're in internal edit mode and near the ends of the note */
 714                                 ArdourCanvas::CanvasNote* cn = dynamic_cast<ArdourCanvas::CanvasNote*> (item);
 715                                 if (cn && cn->big_enough_to_trim() && cn->mouse_near_ends()) {
 716                                         _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor);
 717                                 } else {
 718                                         _drags->set (new NoteDrag (this, item), event);
 719                                 }
 720                         }
 721                         return true;
 722
 723                 case StreamItem:
 724                         if (internal_editing()) {
 725                                 if (dynamic_cast<MidiTimeAxisView*> (clicked_axisview)) {
 726                                         _drags->set (new RegionCreateDrag (this, item, clicked_axisview), event);
 727                                         return true;
 728                                 }
 729                         } else {
 730                                 _drags->set (new SelectionDrag (this, item, SelectionDrag::CreateSelection), event);
 731                                 return true;
 732                         }
 733                         break;
 734
 735                 case RegionViewNameHighlight:
 736                         if (!clicked_regionview->region()->locked()) {
 737                                 RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id);
 738                                 _drags->set (new TrimDrag (this, item, clicked_regionview, s.by_layer()), event);
 739                                 return true;
 740                         }
 741                         break;
 742
 743                 case LeftFrameHandle:
 744                 case RightFrameHandle:
 745                         if (!internal_editing() && !clicked_regionview->region()->locked()) {
 746                                 RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id);
 747                                 _drags->set (new TrimDrag (this, item, clicked_regionview, s.by_layer()), event);
 748                                 return true;
 749                         }
 750                         break;
 751
 752                 default:
 753                         if (!internal_editing()) {
 754                                 _drags->set (new SelectionDrag (this, item, SelectionDrag::CreateSelection), event);
 755                         }
 756                 }
 757                 return true;
 758                 break;
 759
 760         case MouseObject:
 761                 switch (item_type) {
 762                 case NoteItem:
 763                         if (internal_editing()) {
 764                                 ArdourCanvas::CanvasNoteEvent* cn = dynamic_cast<ArdourCanvas::CanvasNoteEvent*> (item);
 765                                 if (cn->mouse_near_ends()) {
 766                                         _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor);
 767                                 } else {
 768                                         _drags->set (new NoteDrag (this, item), event);
 769                                 }
 770                                 return true;
 771                         }
 772                         break;
 773
 774                 default:
 775                         break;
 776                 }
 777
 778                 if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier|Keyboard::SecondaryModifier)) &&
 779                     event->type == GDK_BUTTON_PRESS) {
 780
 781                         _drags->set (new RubberbandSelectDrag (this, item), event);
 782
 783                 } else if (event->type == GDK_BUTTON_PRESS) {
 784
 785                         switch (item_type) {
 786                         case FadeInHandleItem:
 787                         {
 788                                 RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id);
 789                                 _drags->set (new FadeInDrag (this, item, reinterpret_cast<RegionView*> (item->get_data("regionview")), s), event, _cursors->fade_in);
 790                                 return true;
 791                         }
 792
 793                         case FadeOutHandleItem:
 794                         {
 795                                 RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id);
 796                                 _drags->set (new FadeOutDrag (this, item, reinterpret_cast<RegionView*> (item->get_data("regionview")), s), event, _cursors->fade_out);
 797                                 return true;
 798                         }
 799
 800                         case FeatureLineItem:
 801                         {
 802                                 if (Keyboard::modifier_state_contains (event->button.state, Keyboard::TertiaryModifier)) {
 803                                         remove_transient(item);
 804                                         return true;
 805                                 }
 806
 807                                 _drags->set (new FeatureLineDrag (this, item), event);
 808                                 return true;
 809                                 break;
 810                         }
 811
 812                         case RegionItem:
 813                                 if (dynamic_cast<AutomationRegionView*> (clicked_regionview)) {
 814                                         /* click on an automation region view; do nothing here and let the ARV's signal handler
 815                                            sort it out.
 816                                         */
 817                                         break;
 818                                 }
 819
 820                                 if (internal_editing ()) {
 821                                         /* no region drags in internal edit mode */
 822                                         break;
 823                                 }
 824
 825                                 /* click on a normal region view */
 826                                 if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
 827                                         add_region_copy_drag (item, event, clicked_regionview);
 828                                 } else if (Keyboard::the_keyboard().key_is_down (GDK_b)) {
 829                                         add_region_brush_drag (item, event, clicked_regionview);
 830                                 } else {
 831                                         add_region_drag (item, event, clicked_regionview);
 832                                 }
 833
 834                                 if (_join_object_range_state == JOIN_OBJECT_RANGE_OBJECT && !selection->regions.empty()) {
 835                                         _drags->add (new SelectionDrag (this, clicked_axisview->get_selection_rect (clicked_selection)->rect, SelectionDrag::SelectionMove));
 836                                 }
 837
 838                                 _drags->start_grab (event);
 839                                 break;
 840
 841                         case RegionViewNameHighlight:
 842                         case LeftFrameHandle:
 843                         case RightFrameHandle:
 844                                 if (!clicked_regionview->region()->locked()) {
 845                                         RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id);
 846                                         _drags->set (new TrimDrag (this, item, clicked_regionview, s.by_layer()), event);
 847                                         return true;
 848                                 }
 849                                 break;
 850
 851                         case RegionViewName:
 852                         {
 853                                 /* rename happens on edit clicks */
 854                                 RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id);
 855                                 _drags->set (new TrimDrag (this, clicked_regionview->get_name_highlight(), clicked_regionview, s.by_layer()), event);
 856                                 return true;
 857                                 break;
 858                         }
 859
 860                         case ControlPointItem:
 861                                 _drags->set (new ControlPointDrag (this, item), event);
 862                                 return true;
 863                                 break;
 864
 865                         case AutomationLineItem:
 866                                 _drags->set (new LineDrag (this, item), event);
 867                                 return true;
 868                                 break;
 869
 870                         case StreamItem:
 871                                 if (internal_editing()) {
 872                                         if (dynamic_cast<MidiTimeAxisView*> (clicked_axisview)) {
 873                                                 _drags->set (new RegionCreateDrag (this, item, clicked_axisview), event);
 874                                         }
 875                                         return true;
 876                                 } else {
 877                                         _drags->set (new RubberbandSelectDrag (this, item), event);
 878                                 }
 879                                 break;
 880
 881                         case AutomationTrackItem:
 882                         {
 883                                 TimeAxisView* parent = clicked_axisview->get_parent ();
 884                                 if (parent && dynamic_cast<MidiTimeAxisView*> (parent)) {
 885                                         /* create a MIDI region so that we have somewhere to put automation */
 886                                         _drags->set (new RegionCreateDrag (this, item, parent), event);
 887                                 } else {
 888                                         /* rubberband drag to select automation points */
 889                                         _drags->set (new RubberbandSelectDrag (this, item), event);
 890                                 }
 891                                 break;
 892                         }
 893
 894                         case SelectionItem:
 895                         {
 896                                 if (join_object_range_button.get_active()) {
 897                                         /* we're in "smart" joined mode, and we've clicked on a Selection */
 898                                         double const y = event->button.y + vertical_adjustment.get_value() - canvas_timebars_vsize;
 899                                         pair<TimeAxisView*, int> tvp = trackview_by_y_position (y);
 900                                         if (tvp.first) {
 901                                                 /* if we're over an automation track, start a drag of its data */
 902                                                 AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*> (tvp.first);
 903                                                 if (atv) {
 904                                                         _drags->set (new AutomationRangeDrag (this, atv->base_item(), selection->time), event, _cursors->up_down);
 905                                                 }
 906
 907                                                 /* if we're over a track and a region, and in the `object' part of a region,
 908                                                    put a selection around the region and drag both
 909                                                 */
 910                                                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
 911                                                 if (rtv && _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) {
 912                                                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (rtv->route ());
 913                                                         if (t) {
 914                                                                 boost::shared_ptr<Playlist> pl = t->playlist ();
 915                                                                 if (pl) {
 916
 917                                                                         boost::shared_ptr<Region> r = pl->top_region_at (event_frame (event));
 918                                                                         if (r) {
 919                                                                                 RegionView* rv = rtv->view()->find_view (r);
 920                                                                                 clicked_selection = select_range_around_region (rv);
 921                                                                                 _drags->add (new SelectionDrag (this, item, SelectionDrag::SelectionMove));
 922                                                                                 list<RegionView*> rvs;
 923                                                                                 rvs.push_back (rv);
 924                                                                                 _drags->add (new RegionMoveDrag (this, item, rv, rvs, false, false));
 925                                                                                 _drags->start_grab (event);
 926                                                                         }
 927                                                                 }
 928                                                         }
 929                                                 }
 930                                         }
 931                                 }
 932                                 break;
 933                         }
 934
 935 #ifdef WITH_CMT
 936                         case ImageFrameHandleStartItem:
 937                                 imageframe_start_handle_op(item, event) ;
 938                                 return(true) ;
 939                                 break ;
 940                         case ImageFrameHandleEndItem:
 941                                 imageframe_end_handle_op(item, event) ;
 942                                 return(true) ;
 943                                 break ;
 944                         case MarkerViewHandleStartItem:
 945                                 markerview_item_start_handle_op(item, event) ;
 946                                 return(true) ;
 947                                 break ;
 948                         case MarkerViewHandleEndItem:
 949                                 markerview_item_end_handle_op(item, event) ;
 950                                 return(true) ;
 951                                 break ;
 952                         case MarkerViewItem:
 953                                 start_markerview_grab(item, event) ;
 954                                 break ;
 955                         case ImageFrameItem:
 956                                 start_imageframe_grab(item, event) ;
 957                                 break ;
 958 #endif
 959
 960                         case MarkerBarItem:
 961
 962                                 break;
 963
 964                         default:
 965                                 break;
 966                         }
 967                 }
 968                 return true;
 969                 break;
 970
 971         case MouseGain:
 972                 switch (item_type) {
 973                 case RegionItem:
 974                         /* start a grab so that if we finish after moving
 975                            we can tell what happened.
 976                         */
 977                         _drags->set (new RegionGainDrag (this, item), event, current_canvas_cursor);
 978                         break;
 979
 980                 case GainLineItem:
 981                         _drags->set (new LineDrag (this, item), event);
 982                         return true;
 983
 984                 case ControlPointItem:
 985                         _drags->set (new ControlPointDrag (this, item), event);
 986                         return true;
 987                         break;
 988
 989                 default:
 990                         break;
 991                 }
 992                 return true;
 993                 break;
 994
 995                 switch (item_type) {
 996                 case ControlPointItem:
 997                         _drags->set (new ControlPointDrag (this, item), event);
 998                         break;
 999
1000                 case AutomationLineItem:
1001                         _drags->set (new LineDrag (this, item), event);
1002                         break;
1003
1004                 case RegionItem:
1005                         // XXX need automation mode to identify which
1006                         // line to use
1007                         // start_line_grab_from_regionview (item, event);
1008                         break;
1009
1010                 default:
1011                         break;
1012                 }
1013                 return true;
1014                 break;
1015
1016         case MouseZoom:
1017                 if (event->type == GDK_BUTTON_PRESS) {
1018                         _drags->set (new MouseZoomDrag (this, item), event);
1019                 }
1020
1021                 return true;
1022                 break;
1023
1024         case MouseTimeFX:
1025                 if (internal_editing() && item_type == NoteItem) {
1026                         /* drag notes if we're in internal edit mode */
1027                         _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor);
1028                         return true;
1029                 } else if ((!internal_editing() || dynamic_cast<AudioRegionView*> (clicked_regionview)) && clicked_regionview) {
1030                         /* do time-FX if we're not in internal edit mode, or we are but we clicked on an audio region */
1031                         _drags->set (new TimeFXDrag (this, item, clicked_regionview, selection->regions.by_layer()), event);
1032                         return true;
1033                 }
1034                 break;
1035
1036         case MouseAudition:
1037                 _drags->set (new ScrubDrag (this, item), event);
1038                 scrub_reversals = 0;
1039                 scrub_reverse_distance = 0;
1040                 last_scrub_x = event->button.x;
1041                 scrubbing_direction = 0;
1042                 set_canvas_cursor (_cursors->transparent);
1043                 return true;
1044                 break;
1045
1046         default:
1047                 break;
1048         }
1049
1050         return false;
1051 }
1052
1053 bool
1054 Editor::button_press_handler_2 (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
1055 {
1056         Editing::MouseMode const eff = effective_mouse_mode ();
1057         switch (eff) {
1058         case MouseObject:
1059                 switch (item_type) {
1060                 case RegionItem:
1061                         if (internal_editing ()) {
1062                                 /* no region drags in internal edit mode */
1063                                 return false;
1064                         }
1065
1066                         if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
1067                                 add_region_copy_drag (item, event, clicked_regionview);
1068                         } else {
1069                                 add_region_drag (item, event, clicked_regionview);
1070                         }
1071                         _drags->start_grab (event);
1072                         return true;
1073                         break;
1074                 case ControlPointItem:
1075                         _drags->set (new ControlPointDrag (this, item), event);
1076                         return true;
1077                         break;
1078
1079                 default:
1080                         break;
1081                 }
1082
1083                 switch (item_type) {
1084                 case RegionViewNameHighlight:
1085                         _drags->set (new TrimDrag (this, item, clicked_regionview, selection->regions.by_layer()), event);
1086                         return true;
1087                         break;
1088
1089                 case LeftFrameHandle:
1090                 case RightFrameHandle:
1091                         if (!internal_editing ()) {
1092                                 _drags->set (new TrimDrag (this, item, clicked_regionview, selection->regions.by_layer()), event);
1093                         }
1094                         return true;
1095                         break;
1096
1097                 case RegionViewName:
1098                         _drags->set (new TrimDrag (this, clicked_regionview->get_name_highlight(), clicked_regionview, selection->regions.by_layer()), event);
1099                         return true;
1100                         break;
1101
1102                 default:
1103                         break;
1104                 }
1105
1106                 break;
1107
1108         case MouseRange:
1109                 /* relax till release */
1110                 return true;
1111                 break;
1112
1113
1114         case MouseZoom:
1115                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
1116                         temporal_zoom_to_frame (false, event_frame (event));
1117                 } else {
1118                         temporal_zoom_to_frame (true, event_frame(event));
1119                 }
1120                 return true;
1121                 break;
1122
1123         default:
1124                 break;
1125         }
1126
1127         return false;
1128 }
1129
1130 bool
1131 Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
1132 {
1133         if (event->type != GDK_BUTTON_PRESS) {
1134                 return false;
1135         }
1136
1137         Glib::RefPtr<Gdk::Window> canvas_window = const_cast<Editor*>(this)->track_canvas->get_window();
1138
1139         if (canvas_window) {
1140                 Glib::RefPtr<const Gdk::Window> pointer_window;
1141                 int x, y;
1142                 double wx, wy;
1143                 Gdk::ModifierType mask;
1144
1145                 pointer_window = canvas_window->get_pointer (x, y, mask);
1146
1147                 if (pointer_window == track_canvas->get_bin_window()) {
1148                         track_canvas->window_to_world (x, y, wx, wy);
1149                 }
1150         }
1151
1152         pre_press_cursor = current_canvas_cursor;
1153
1154         track_canvas->grab_focus();
1155
1156         if (_session && _session->actively_recording()) {
1157                 return true;
1158         }
1159
1160         button_selection (item, event, item_type);
1161
1162         if (!_drags->active () &&
1163             (Keyboard::is_delete_event (&event->button) ||
1164              Keyboard::is_context_menu_event (&event->button) ||
1165              Keyboard::is_edit_event (&event->button))) {
1166
1167                 /* handled by button release */
1168                 return true;
1169         }
1170
1171         switch (event->button.button) {
1172         case 1:
1173                 return button_press_handler_1 (item, event, item_type);
1174                 break;
1175
1176         case 2:
1177                 return button_press_handler_2 (item, event, item_type);
1178                 break;
1179
1180         case 3:
1181                 break;
1182
1183         default:
1184                 return button_press_dispatch (&event->button);
1185                 break;
1186
1187         }
1188
1189         return false;
1190 }
1191
1192 bool
1193 Editor::button_press_dispatch (GdkEventButton* ev)
1194 {
1195         /* this function is intended only for buttons 4 and above.
1196          */
1197
1198         Gtkmm2ext::MouseButton b (ev->state, ev->button);
1199         return button_bindings->activate (b, Gtkmm2ext::Bindings::Press);
1200 }
1201
1202 bool
1203 Editor::button_release_dispatch (GdkEventButton* ev)
1204 {
1205         /* this function is intended only for buttons 4 and above.
1206          */
1207
1208         Gtkmm2ext::MouseButton b (ev->state, ev->button);
1209         return button_bindings->activate (b, Gtkmm2ext::Bindings::Release);
1210 }
1211
1212 bool
1213 Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
1214 {
1215         framepos_t where = event_frame (event, 0, 0);
1216         AutomationTimeAxisView* atv = 0;
1217
1218         if (pre_press_cursor) {
1219                 set_canvas_cursor (pre_press_cursor);
1220                 pre_press_cursor = 0;
1221         }
1222
1223         /* no action if we're recording */
1224
1225         if (_session && _session->actively_recording()) {
1226                 return true;
1227         }
1228
1229         /* see if we're finishing a drag */
1230
1231         bool were_dragging = false;
1232         if (_drags->active ()) {
1233                 bool const r = _drags->end_grab (event);
1234                 if (r) {
1235                         /* grab dragged, so do nothing else */
1236                         return true;
1237                 }
1238
1239                 were_dragging = true;
1240         }
1241
1242         update_region_layering_order_editor ();
1243
1244         /* edit events get handled here */
1245
1246         if (!_drags->active () && Keyboard::is_edit_event (&event->button)) {
1247                 switch (item_type) {
1248                 case RegionItem:
1249                         show_region_properties ();
1250                         break;
1251
1252                 case TempoMarkerItem:
1253                         edit_tempo_marker (item);
1254                         break;
1255
1256                 case MeterMarkerItem:
1257                         edit_meter_marker (item);
1258                         break;
1259
1260                 case RegionViewName:
1261                         if (clicked_regionview->name_active()) {
1262                                 return mouse_rename_region (item, event);
1263                         }
1264                         break;
1265
1266                 case ControlPointItem:
1267                         edit_control_point (item);
1268                         break;
1269
1270                 case NoteItem:
1271                         edit_note (item);
1272                         break;
1273
1274                 default:
1275                         break;
1276                 }
1277                 return true;
1278         }
1279
1280         /* context menu events get handled here */
1281
1282         if (Keyboard::is_context_menu_event (&event->button)) {
1283
1284                 if (!_drags->active ()) {
1285
1286                         /* no matter which button pops up the context menu, tell the menu
1287                            widget to use button 1 to drive menu selection.
1288                         */
1289
1290                         switch (item_type) {
1291                         case FadeInItem:
1292                         case FadeInHandleItem:
1293                         case FadeOutItem:
1294                         case FadeOutHandleItem:
1295                                 popup_fade_context_menu (1, event->button.time, item, item_type);
1296                                 break;
1297
1298                         case StreamItem:
1299                                 popup_track_context_menu (1, event->button.time, item_type, false);
1300                                 break;
1301
1302                         case RegionItem:
1303                         case RegionViewNameHighlight:
1304                         case LeftFrameHandle:
1305                         case RightFrameHandle:
1306                         case RegionViewName:
1307                                 popup_track_context_menu (1, event->button.time, item_type, false);
1308                                 break;
1309
1310                         case SelectionItem:
1311                                 popup_track_context_menu (1, event->button.time, item_type, true);
1312                                 break;
1313
1314                         case AutomationTrackItem:
1315                                 popup_track_context_menu (1, event->button.time, item_type, false);
1316                                 break;
1317
1318                         case MarkerBarItem:
1319                         case RangeMarkerBarItem:
1320                         case TransportMarkerBarItem:
1321                         case CdMarkerBarItem:
1322                         case TempoBarItem:
1323                         case MeterBarItem:
1324                                 popup_ruler_menu (where, item_type);
1325                                 break;
1326
1327                         case MarkerItem:
1328                                 marker_context_menu (&event->button, item);
1329                                 break;
1330
1331                         case TempoMarkerItem:
1332                                 tempo_or_meter_marker_context_menu (&event->button, item);
1333                                 break;
1334
1335                         case MeterMarkerItem:
1336                                 tempo_or_meter_marker_context_menu (&event->button, item);
1337                                 break;
1338
1339                         case CrossfadeViewItem:
1340                                 popup_track_context_menu (1, event->button.time, item_type, false);
1341                                 break;
1342
1343                         case ControlPointItem:
1344                                 popup_control_point_context_menu (item, event);
1345                                 break;
1346
1347 #ifdef WITH_CMT
1348                         case ImageFrameItem:
1349                                 popup_imageframe_edit_menu(1, event->button.time, item, true) ;
1350                                 break ;
1351                         case ImageFrameTimeAxisItem:
1352                                 popup_imageframe_edit_menu(1, event->button.time, item, false) ;
1353                                 break ;
1354                         case MarkerViewItem:
1355                                 popup_marker_time_axis_edit_menu(1, event->button.time, item, true) ;
1356                                 break ;
1357                         case MarkerTimeAxisItem:
1358                                 popup_marker_time_axis_edit_menu(1, event->button.time, item, false) ;
1359                                 break ;
1360 #endif
1361
1362                         default:
1363                                 break;
1364                         }
1365
1366                         return true;
1367                 }
1368         }
1369
1370         /* delete events get handled here */
1371
1372         Editing::MouseMode const eff = effective_mouse_mode ();
1373
1374         if (!_drags->active () && Keyboard::is_delete_event (&event->button)) {
1375
1376                 switch (item_type) {
1377                 case TempoMarkerItem:
1378                         remove_tempo_marker (item);
1379                         break;
1380
1381                 case MeterMarkerItem:
1382                         remove_meter_marker (item);
1383                         break;
1384
1385                 case MarkerItem:
1386                         remove_marker (*item, event);
1387                         break;
1388
1389                 case RegionItem:
1390                         if (eff == MouseObject) {
1391                                 remove_clicked_region ();
1392                         }
1393                         break;
1394
1395                 case ControlPointItem:
1396                         remove_control_point (item);
1397                         break;
1398
1399                 case NoteItem:
1400                         remove_midi_note (item, event);
1401                         break;
1402
1403                 default:
1404                         break;
1405                 }
1406                 return true;
1407         }
1408
1409         switch (event->button.button) {
1410         case 1:
1411
1412                 switch (item_type) {
1413                 /* see comments in button_press_handler */
1414                 case PlayheadCursorItem:
1415                 case MarkerItem:
1416                 case GainLineItem:
1417                 case AutomationLineItem:
1418                 case StartSelectionTrimItem:
1419                 case EndSelectionTrimItem:
1420                         return true;
1421
1422                 case MarkerBarItem:
1423                         if (!_dragging_playhead) {
1424                                 snap_to_with_modifier (where, event, 0, true);
1425                                 mouse_add_new_marker (where);
1426                         }
1427                         return true;
1428
1429                 case CdMarkerBarItem:
1430                         if (!_dragging_playhead) {
1431                                 // if we get here then a dragged range wasn't done
1432                                 snap_to_with_modifier (where, event, 0, true);
1433                                 mouse_add_new_marker (where, true);
1434                         }
1435                         return true;
1436
1437                 case TempoBarItem:
1438                         if (!_dragging_playhead) {
1439                                 snap_to_with_modifier (where, event);
1440                                 mouse_add_new_tempo_event (where);
1441                         }
1442                         return true;
1443
1444                 case MeterBarItem:
1445                         if (!_dragging_playhead) {
1446                                 mouse_add_new_meter_event (pixel_to_frame (event->button.x));
1447                         }
1448                         return true;
1449                         break;
1450
1451                 default:
1452                         break;
1453                 }
1454
1455                 switch (eff) {
1456                 case MouseObject:
1457                         switch (item_type) {
1458                         case AutomationTrackItem:
1459                                 atv = dynamic_cast<AutomationTimeAxisView*>(clicked_axisview);
1460                                 if (atv) {
1461                                         atv->add_automation_event (item, event, where, event->button.y);
1462                                 }
1463                                 return true;
1464                                 break;
1465
1466                         default:
1467                                 break;
1468                         }
1469                         break;
1470
1471                 case MouseGain:
1472                         switch (item_type) {
1473                         case RegionItem:
1474                         {
1475                                 /* check that we didn't drag before releasing, since
1476                                    its really annoying to create new control
1477                                    points when doing this.
1478                                 */
1479                                 AudioRegionView* arv = dynamic_cast<AudioRegionView*> (clicked_regionview);
1480                                 if (were_dragging && arv) {
1481                                         arv->add_gain_point_event (item, event);
1482                                 }
1483                                 return true;
1484                                 break;
1485                         }
1486
1487                         case AutomationTrackItem:
1488                                 dynamic_cast<AutomationTimeAxisView*>(clicked_axisview)->
1489                                         add_automation_event (item, event, where, event->button.y);
1490                                 return true;
1491                                 break;
1492                         default:
1493                                 break;
1494                         }
1495                         break;
1496
1497                 case MouseAudition:
1498                         set_canvas_cursor (current_canvas_cursor);
1499                         if (scrubbing_direction == 0) {
1500                                 /* no drag, just a click */
1501                                 switch (item_type) {
1502                                 case RegionItem:
1503                                         play_selected_region ();
1504                                         break;
1505                                 default:
1506                                         break;
1507                                 }
1508                         } else {
1509                                 /* make sure we stop */
1510                                 _session->request_transport_speed (0.0);
1511                         }
1512                         break;
1513
1514                 default:
1515                         break;
1516
1517                 }
1518
1519                 /* do any (de)selection operations that should occur on button release */
1520                 button_selection (item, event, item_type);
1521                 return true;
1522                 break;
1523
1524
1525         case 2:
1526                 switch (eff) {
1527
1528                 case MouseObject:
1529                         switch (item_type) {
1530                         case RegionItem:
1531                                 if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
1532                                         raise_region ();
1533                                 } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::TertiaryModifier|Keyboard::SecondaryModifier))) {
1534                                         lower_region ();
1535                                 } else {
1536                                         // Button2 click is unused
1537                                 }
1538                                 return true;
1539
1540                                 break;
1541
1542                         default:
1543                                 break;
1544                         }
1545                         break;
1546
1547                 case MouseRange:
1548
1549                         // x_style_paste (where, 1.0);
1550                         return true;
1551                         break;
1552
1553                 default:
1554                         break;
1555                 }
1556
1557                 break;
1558
1559         case 3:
1560                 break;
1561
1562         default:
1563                 break;
1564         }
1565
1566         return false;
1567 }
1568
1569 bool
1570 Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
1571 {
1572         ControlPoint* cp;
1573         Marker * marker;
1574         double fraction;
1575         bool ret = true;
1576
1577         last_item_entered = item;
1578
1579         switch (item_type) {
1580         case ControlPointItem:
1581                 if (mouse_mode == MouseGain || mouse_mode == MouseObject) {
1582                         cp = static_cast<ControlPoint*>(item->get_data ("control_point"));
1583                         cp->set_visible (true);
1584
1585                         double at_x, at_y;
1586                         at_x = cp->get_x();
1587                         at_y = cp->get_y ();
1588                         cp->i2w (at_x, at_y);
1589                         at_x += 10.0;
1590                         at_y += 10.0;
1591
1592                         fraction = 1.0 - (cp->get_y() / cp->line().height());
1593
1594                         if (is_drawable() && !_drags->active ()) {
1595                                 set_canvas_cursor (_cursors->fader);
1596                         }
1597
1598                         _verbose_cursor->set (cp->line().get_verbose_cursor_string (fraction), at_x, at_y);
1599                         _verbose_cursor->show ();
1600                 }
1601                 break;
1602
1603         case GainLineItem:
1604                 if (mouse_mode == MouseGain) {
1605                         ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
1606                         if (line)
1607                                 line->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_EnteredGainLine.get();
1608                         if (is_drawable()) {
1609                                 set_canvas_cursor (_cursors->fader);
1610                         }
1611                 }
1612                 break;
1613
1614         case AutomationLineItem:
1615                 if (mouse_mode == MouseGain || mouse_mode == MouseObject) {
1616                         {
1617                                 ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
1618                                 if (line)
1619                                         line->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_EnteredAutomationLine.get();
1620                         }
1621                         if (is_drawable()) {
1622                                 set_canvas_cursor (_cursors->fader);
1623                         }
1624                 }
1625                 break;
1626
1627         case RegionViewNameHighlight:
1628                 if (is_drawable() && mouse_mode == MouseObject && entered_regionview) {
1629                         set_canvas_cursor_for_region_view (event->crossing.x, entered_regionview);
1630                         _over_region_trim_target = true;
1631                 }
1632                 break;
1633
1634         case LeftFrameHandle:
1635         case RightFrameHandle:
1636                 if (is_drawable() && mouse_mode == MouseObject && !internal_editing() && entered_regionview) {
1637                         set_canvas_cursor_for_region_view (event->crossing.x, entered_regionview);
1638                 }
1639                 break;
1640
1641         case StartSelectionTrimItem:
1642         case EndSelectionTrimItem:
1643
1644 #ifdef WITH_CMT
1645         case ImageFrameHandleStartItem:
1646         case ImageFrameHandleEndItem:
1647         case MarkerViewHandleStartItem:
1648         case MarkerViewHandleEndItem:
1649 #endif
1650
1651                 if (is_drawable()) {
1652                         set_canvas_cursor (_cursors->trimmer);
1653                 }
1654                 break;
1655
1656         case PlayheadCursorItem:
1657                 if (is_drawable()) {
1658                         switch (_edit_point) {
1659                         case EditAtMouse:
1660                                 set_canvas_cursor (_cursors->grabber_edit_point);
1661                                 break;
1662                         default:
1663                                 set_canvas_cursor (_cursors->grabber);
1664                                 break;
1665                         }
1666                 }
1667                 break;
1668
1669         case RegionViewName:
1670
1671                 /* when the name is not an active item, the entire name highlight is for trimming */
1672
1673                 if (!reinterpret_cast<RegionView *> (item->get_data ("regionview"))->name_active()) {
1674                         if (mouse_mode == MouseObject && is_drawable()) {
1675                                 set_canvas_cursor_for_region_view (event->crossing.x, entered_regionview);
1676                                 _over_region_trim_target = true;
1677                         }
1678                 }
1679                 break;
1680
1681
1682         case AutomationTrackItem:
1683                 if (is_drawable()) {
1684                         Gdk::Cursor *cursor;
1685                         switch (mouse_mode) {
1686                         case MouseRange:
1687                                 cursor = _cursors->selector;
1688                                 break;
1689                         case MouseZoom:
1690                                 cursor = _cursors->zoom_in;
1691                                 break;
1692                         default:
1693                                 cursor = _cursors->cross_hair;
1694                                 break;
1695                         }
1696
1697                         set_canvas_cursor (cursor);
1698
1699                         AutomationTimeAxisView* atv;
1700                         if ((atv = static_cast<AutomationTimeAxisView*>(item->get_data ("trackview"))) != 0) {
1701                                 clear_entered_track = false;
1702                                 set_entered_track (atv);
1703                         }
1704                 }
1705                 break;
1706
1707         case MarkerBarItem:
1708         case RangeMarkerBarItem:
1709         case TransportMarkerBarItem:
1710         case CdMarkerBarItem:
1711         case MeterBarItem:
1712         case TempoBarItem:
1713                 if (is_drawable()) {
1714                         set_canvas_cursor (_cursors->timebar);
1715                 }
1716                 break;
1717
1718         case MarkerItem:
1719                 if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
1720                         break;
1721                 }
1722                 entered_marker = marker;
1723                 marker->set_color_rgba (ARDOUR_UI::config()->canvasvar_EnteredMarker.get());
1724                 // fall through
1725         case MeterMarkerItem:
1726         case TempoMarkerItem:
1727                 if (is_drawable()) {
1728                         set_canvas_cursor (_cursors->timebar);
1729                 }
1730                 break;
1731
1732         case FadeInHandleItem:
1733                 if (mouse_mode == MouseObject && !internal_editing()) {
1734                         ArdourCanvas::SimpleRect *rect = dynamic_cast<ArdourCanvas::SimpleRect *> (item);
1735                         if (rect) {
1736                                 rect->property_fill_color_rgba() = 0xBBBBBBAA;
1737                         }
1738                         set_canvas_cursor (_cursors->fade_in);
1739                 }
1740                 break;
1741
1742         case FadeOutHandleItem:
1743                 if (mouse_mode == MouseObject && !internal_editing()) {
1744                         ArdourCanvas::SimpleRect *rect = dynamic_cast<ArdourCanvas::SimpleRect *> (item);
1745                         if (rect) {
1746                                 rect->property_fill_color_rgba() = 0xBBBBBBAA;
1747                         }
1748                         set_canvas_cursor (_cursors->fade_out);
1749                 }
1750                 break;
1751         case FeatureLineItem:
1752                 {
1753                         ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
1754                         line->property_fill_color_rgba() = 0xFF0000FF;
1755                 }
1756                 break;
1757         case SelectionItem:
1758                 if (join_object_range_button.get_active()) {
1759                         set_canvas_cursor ();
1760                 }
1761                 break;
1762
1763         default:
1764                 break;
1765         }
1766
1767         /* second pass to handle entered track status in a comprehensible way.
1768          */
1769
1770         switch (item_type) {
1771         case GainLineItem:
1772         case AutomationLineItem:
1773         case ControlPointItem:
1774                 /* these do not affect the current entered track state */
1775                 clear_entered_track = false;
1776                 break;
1777
1778         case AutomationTrackItem:
1779                 /* handled above already */
1780                 break;
1781
1782         default:
1783                 set_entered_track (0);
1784                 break;
1785         }
1786
1787         return ret;
1788 }
1789
1790 bool
1791 Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
1792 {
1793         AutomationLine* al;
1794         ControlPoint* cp;
1795         Marker *marker;
1796         Location *loc;
1797         RegionView* rv;
1798         bool is_start;
1799         bool ret = true;
1800
1801         switch (item_type) {
1802         case ControlPointItem:
1803                 cp = reinterpret_cast<ControlPoint*>(item->get_data ("control_point"));
1804                 if (cp->line().the_list()->interpolation() != AutomationList::Discrete) {
1805                         if (cp->line().npoints() > 1 && !cp->get_selected()) {
1806                                 cp->set_visible (false);
1807                         }
1808                 }
1809
1810                 if (is_drawable()) {
1811                         set_canvas_cursor (current_canvas_cursor);
1812                 }
1813
1814                 _verbose_cursor->hide ();
1815                 break;
1816
1817         case RegionViewNameHighlight:
1818         case LeftFrameHandle:
1819         case RightFrameHandle:
1820         case StartSelectionTrimItem:
1821         case EndSelectionTrimItem:
1822         case PlayheadCursorItem:
1823
1824 #ifdef WITH_CMT
1825         case ImageFrameHandleStartItem:
1826         case ImageFrameHandleEndItem:
1827         case MarkerViewHandleStartItem:
1828         case MarkerViewHandleEndItem:
1829 #endif
1830
1831                 _over_region_trim_target = false;
1832
1833                 if (is_drawable()) {
1834                         set_canvas_cursor (current_canvas_cursor);
1835                 }
1836                 break;
1837
1838         case GainLineItem:
1839         case AutomationLineItem:
1840                 al = reinterpret_cast<AutomationLine*> (item->get_data ("line"));
1841                 {
1842                         ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
1843                         if (line)
1844                                 line->property_fill_color_rgba() = al->get_line_color();
1845                 }
1846                 if (is_drawable()) {
1847                         set_canvas_cursor (current_canvas_cursor);
1848                 }
1849                 break;
1850
1851         case RegionViewName:
1852                 /* see enter_handler() for notes */
1853                 _over_region_trim_target = false;
1854
1855                 if (!reinterpret_cast<RegionView *> (item->get_data ("regionview"))->name_active()) {
1856                         if (is_drawable() && mouse_mode == MouseObject) {
1857                                 set_canvas_cursor (current_canvas_cursor);
1858                         }
1859                 }
1860                 break;
1861
1862         case RangeMarkerBarItem:
1863         case TransportMarkerBarItem:
1864         case CdMarkerBarItem:
1865         case MeterBarItem:
1866         case TempoBarItem:
1867         case MarkerBarItem:
1868                 if (is_drawable()) {
1869                         set_canvas_cursor (current_canvas_cursor);
1870                 }
1871                 break;
1872
1873         case MarkerItem:
1874                 if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
1875                         break;
1876                 }
1877                 entered_marker = 0;
1878                 if ((loc = find_location_from_marker (marker, is_start)) != 0) {
1879                         location_flags_changed (loc, this);
1880                 }
1881                 // fall through
1882         case MeterMarkerItem:
1883         case TempoMarkerItem:
1884
1885                 if (is_drawable()) {
1886                         set_canvas_cursor (_cursors->timebar);
1887                 }
1888
1889                 break;
1890
1891         case FadeInHandleItem:
1892         case FadeOutHandleItem:
1893                 rv = static_cast<RegionView*>(item->get_data ("regionview"));
1894                 {
1895                         ArdourCanvas::SimpleRect *rect = dynamic_cast<ArdourCanvas::SimpleRect *> (item);
1896                         if (rect) {
1897                                 rect->property_fill_color_rgba() = rv->get_fill_color();
1898                                 rect->property_outline_pixels() = 0;
1899                         }
1900                 }
1901                 set_canvas_cursor (current_canvas_cursor);
1902                 break;
1903
1904         case AutomationTrackItem:
1905                 if (is_drawable()) {
1906                         set_canvas_cursor (current_canvas_cursor);
1907                         clear_entered_track = true;
1908                         Glib::signal_idle().connect (sigc::mem_fun(*this, &Editor::left_automation_track));
1909                 }
1910                 break;
1911         case FeatureLineItem:
1912                 {
1913                         ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
1914                         line->property_fill_color_rgba() = (guint) ARDOUR_UI::config()->canvasvar_ZeroLine.get();;
1915                 }
1916                 break;
1917
1918         default:
1919                 break;
1920         }
1921
1922         return ret;
1923 }
1924
1925 gint
1926 Editor::left_automation_track ()
1927 {
1928         if (clear_entered_track) {
1929                 set_entered_track (0);
1930                 clear_entered_track = false;
1931         }
1932         return false;
1933 }
1934
1935 void
1936 Editor::scrub (framepos_t frame, double current_x)
1937 {
1938         double delta;
1939
1940         if (scrubbing_direction == 0) {
1941                 /* first move */
1942                 _session->request_locate (frame, false);
1943                 _session->request_transport_speed (0.1);
1944                 scrubbing_direction = 1;
1945
1946         } else {
1947
1948                 if (last_scrub_x > current_x) {
1949
1950                         /* pointer moved to the left */
1951
1952                         if (scrubbing_direction > 0) {
1953
1954                                 /* we reversed direction to go backwards */
1955
1956                                 scrub_reversals++;
1957                                 scrub_reverse_distance += (int) (last_scrub_x - current_x);
1958
1959                         } else {
1960
1961                                 /* still moving to the left (backwards) */
1962
1963                                 scrub_reversals = 0;
1964                                 scrub_reverse_distance = 0;
1965
1966                                 delta = 0.01 * (last_scrub_x - current_x);
1967                                 _session->request_transport_speed_nonzero (_session->transport_speed() - delta);
1968                         }
1969
1970                 } else {
1971                         /* pointer moved to the right */
1972
1973                         if (scrubbing_direction < 0) {
1974                                 /* we reversed direction to go forward */
1975
1976                                 scrub_reversals++;
1977                                 scrub_reverse_distance += (int) (current_x - last_scrub_x);
1978
1979                         } else {
1980                                 /* still moving to the right */
1981
1982                                 scrub_reversals = 0;
1983                                 scrub_reverse_distance = 0;
1984
1985                                 delta = 0.01 * (current_x - last_scrub_x);
1986                                 _session->request_transport_speed_nonzero (_session->transport_speed() + delta);
1987                         }
1988                 }
1989
1990                 /* if there have been more than 2 opposite motion moves detected, or one that moves
1991                    back more than 10 pixels, reverse direction
1992                 */
1993
1994                 if (scrub_reversals >= 2 || scrub_reverse_distance > 10) {
1995
1996                         if (scrubbing_direction > 0) {
1997                                 /* was forwards, go backwards */
1998                                 _session->request_transport_speed (-0.1);
1999                                 scrubbing_direction = -1;
2000                         } else {
2001                                 /* was backwards, go forwards */
2002                                 _session->request_transport_speed (0.1);
2003                                 scrubbing_direction = 1;
2004                         }
2005
2006                         scrub_reverse_distance = 0;
2007                         scrub_reversals = 0;
2008                 }
2009         }
2010
2011         last_scrub_x = current_x;
2012 }
2013
2014 bool
2015 Editor::motion_handler (ArdourCanvas::Item* /*item*/, GdkEvent* event, bool from_autoscroll)
2016 {
2017         _last_motion_y = event->motion.y;
2018
2019         if (event->motion.is_hint) {
2020                 gint x, y;
2021
2022                 /* We call this so that MOTION_NOTIFY events continue to be
2023                    delivered to the canvas. We need to do this because we set
2024                    Gdk::POINTER_MOTION_HINT_MASK on the canvas. This reduces
2025                    the density of the events, at the expense of a round-trip
2026                    to the server. Given that this will mostly occur on cases
2027                    where DISPLAY = :0.0, and given the cost of what the motion
2028                    event might do, its a good tradeoff.
2029                 */
2030
2031                 track_canvas->get_pointer (x, y);
2032         }
2033
2034         if (current_stepping_trackview) {
2035                 /* don't keep the persistent stepped trackview if the mouse moves */
2036                 current_stepping_trackview = 0;
2037                 step_timeout.disconnect ();
2038         }
2039
2040         if (_session && _session->actively_recording()) {
2041                 /* Sorry. no dragging stuff around while we record */
2042                 return true;
2043         }
2044
2045         JoinObjectRangeState const old = _join_object_range_state;
2046         update_join_object_range_location (event->motion.x, event->motion.y);
2047         if (_join_object_range_state != old) {
2048                 set_canvas_cursor ();
2049         }
2050
2051         if (_over_region_trim_target) {
2052                 set_canvas_cursor_for_region_view (event->motion.x, entered_regionview);
2053         }
2054
2055         bool handled = false;
2056         if (_drags->active ()) {
2057                 handled = _drags->motion_handler (event, from_autoscroll);
2058         }
2059
2060         if (!handled) {
2061                 return false;
2062         }
2063
2064         track_canvas_motion (event);
2065         return true;
2066 }
2067
2068 bool
2069 Editor::can_remove_control_point (ArdourCanvas::Item* item)
2070 {
2071         ControlPoint* control_point;
2072
2073         if ((control_point = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"))) == 0) {
2074                 fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
2075                 /*NOTREACHED*/
2076         }
2077
2078         AutomationLine& line = control_point->line ();
2079         if (dynamic_cast<AudioRegionGainLine*> (&line)) {
2080                 /* we shouldn't remove the first or last gain point in region gain lines */
2081                 if (line.is_last_point(*control_point) || line.is_first_point(*control_point)) {
2082                         return false;
2083                 }
2084         }
2085
2086         return true;
2087 }
2088
2089 void
2090 Editor::remove_control_point (ArdourCanvas::Item* item)
2091 {
2092         if (!can_remove_control_point (item)) {
2093                 return;
2094         }
2095
2096         ControlPoint* control_point;
2097
2098         if ((control_point = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"))) == 0) {
2099                 fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
2100                 /*NOTREACHED*/
2101         }
2102
2103         control_point->line().remove_point (*control_point);
2104 }
2105
2106 void
2107 Editor::edit_control_point (ArdourCanvas::Item* item)
2108 {
2109         ControlPoint* p = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"));
2110
2111         if (p == 0) {
2112                 fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
2113                 /*NOTREACHED*/
2114         }
2115
2116         ControlPointDialog d (p);
2117         d.set_position (Gtk::WIN_POS_MOUSE);
2118         ensure_float (d);
2119
2120         if (d.run () != RESPONSE_ACCEPT) {
2121                 return;
2122         }
2123
2124         p->line().modify_point_y (*p, d.get_y_fraction ());
2125 }
2126
2127 void
2128 Editor::edit_note (ArdourCanvas::Item* item)
2129 {
2130         ArdourCanvas::CanvasNoteEvent* e = dynamic_cast<ArdourCanvas::CanvasNoteEvent*> (item);
2131         assert (e);
2132
2133         EditNoteDialog d (&e->region_view(), e);
2134         d.set_position (Gtk::WIN_POS_MOUSE);
2135         ensure_float (d);
2136
2137         d.run ();
2138 }
2139
2140
2141 void
2142 Editor::visible_order_range (int* low, int* high) const
2143 {
2144         *low = TimeAxisView::max_order ();
2145         *high = 0;
2146
2147         for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
2148
2149                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
2150
2151                 if (!rtv->hidden()) {
2152
2153                         if (*high < rtv->order()) {
2154                                 *high = rtv->order ();
2155                         }
2156
2157                         if (*low > rtv->order()) {
2158                                 *low = rtv->order ();
2159                         }
2160                 }
2161         }
2162 }
2163
2164 void
2165 Editor::region_view_item_click (AudioRegionView& rv, GdkEventButton* event)
2166 {
2167         /* Either add to or set the set the region selection, unless
2168            this is an alignment click (control used)
2169         */
2170
2171         if (Keyboard::modifier_state_contains (event->state, Keyboard::PrimaryModifier)) {
2172                 TimeAxisView* tv = &rv.get_time_axis_view();
2173                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(tv);
2174                 double speed = 1.0;
2175                 if (rtv && rtv->is_track()) {
2176                         speed = rtv->track()->speed();
2177                 }
2178
2179                 framepos_t where = get_preferred_edit_position();
2180
2181                 if (where >= 0) {
2182
2183                         if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) {
2184
2185                                 align_region (rv.region(), SyncPoint, (framepos_t) (where * speed));
2186
2187                         } else if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
2188
2189                                 align_region (rv.region(), End, (framepos_t) (where * speed));
2190
2191                         } else {
2192
2193                                 align_region (rv.region(), Start, (framepos_t) (where * speed));
2194                         }
2195                 }
2196         }
2197 }
2198
2199 void
2200 Editor::collect_new_region_view (RegionView* rv)
2201 {
2202         latest_regionviews.push_back (rv);
2203 }
2204
2205 void
2206 Editor::collect_and_select_new_region_view (RegionView* rv)
2207 {
2208         selection->add(rv);
2209         latest_regionviews.push_back (rv);
2210 }
2211
2212 void
2213 Editor::cancel_selection ()
2214 {
2215         for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
2216                 (*i)->hide_selection ();
2217         }
2218
2219         selection->clear ();
2220         clicked_selection = 0;
2221 }
2222
2223
2224 void
2225 Editor::point_trim (GdkEvent* event, framepos_t new_bound)
2226 {
2227         RegionView* rv = clicked_regionview;
2228
2229         /* Choose action dependant on which button was pressed */
2230         switch (event->button.button) {
2231         case 1:
2232                 begin_reversible_command (_("start point trim"));
2233
2234                 if (selection->selected (rv)) {
2235                         for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin();
2236                              i != selection->regions.by_layer().end(); ++i)
2237                         {
2238                                 if ( (*i) == NULL){
2239                                     cerr << "region view contains null region" << endl;
2240                                 }
2241
2242                                 if (!(*i)->region()->locked()) {
2243                                         (*i)->region()->clear_changes ();
2244                                         (*i)->region()->trim_front (new_bound);
2245                                         _session->add_command(new StatefulDiffCommand ((*i)->region()));
2246                                 }
2247                         }
2248
2249                 } else {
2250                         if (!rv->region()->locked()) {
2251                                 rv->region()->clear_changes ();
2252                                 rv->region()->trim_front (new_bound);
2253                                 _session->add_command(new StatefulDiffCommand (rv->region()));
2254                         }
2255                 }
2256
2257                 commit_reversible_command();
2258
2259                 break;
2260         case 2:
2261                 begin_reversible_command (_("End point trim"));
2262
2263                 if (selection->selected (rv)) {
2264
2265                         for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i)
2266                         {
2267                                 if (!(*i)->region()->locked()) {
2268                                         (*i)->region()->clear_changes();
2269                                         (*i)->region()->trim_end (new_bound);
2270                                         _session->add_command(new StatefulDiffCommand ((*i)->region()));
2271                                 }
2272                         }
2273
2274                 } else {
2275
2276                         if (!rv->region()->locked()) {
2277                                 rv->region()->clear_changes ();
2278                                 rv->region()->trim_end (new_bound);
2279                                 _session->add_command (new StatefulDiffCommand (rv->region()));
2280                         }
2281                 }
2282
2283                 commit_reversible_command();
2284
2285                 break;
2286         default:
2287                 break;
2288         }
2289 }
2290
2291 void
2292 Editor::hide_marker (ArdourCanvas::Item* item, GdkEvent* /*event*/)
2293 {
2294         Marker* marker;
2295         bool is_start;
2296
2297         if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
2298                 fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
2299                 /*NOTREACHED*/
2300         }
2301
2302         Location* location = find_location_from_marker (marker, is_start);
2303         location->set_hidden (true, this);
2304 }
2305
2306
2307 void
2308 Editor::reposition_zoom_rect (framepos_t start, framepos_t end)
2309 {
2310         double x1 = frame_to_pixel (start);
2311         double x2 = frame_to_pixel (end);
2312         double y2 = full_canvas_height - 1.0;
2313
2314         zoom_rect->property_x1() = x1;
2315         zoom_rect->property_y1() = 1.0;
2316         zoom_rect->property_x2() = x2;
2317         zoom_rect->property_y2() = y2;
2318 }
2319
2320
2321 gint
2322 Editor::mouse_rename_region (ArdourCanvas::Item* /*item*/, GdkEvent* /*event*/)
2323 {
2324         using namespace Gtkmm2ext;
2325
2326         ArdourPrompter prompter (false);
2327
2328         prompter.set_prompt (_("Name for region:"));
2329         prompter.set_initial_text (clicked_regionview->region()->name());
2330         prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
2331         prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
2332         prompter.show_all ();
2333         switch (prompter.run ()) {
2334         case Gtk::RESPONSE_ACCEPT:
2335                 string str;
2336                 prompter.get_result(str);
2337                 if (str.length()) {
2338                         clicked_regionview->region()->set_name (str);
2339                 }
2340                 break;
2341         }
2342         return true;
2343 }
2344
2345
2346 void
2347 Editor::mouse_brush_insert_region (RegionView* rv, framepos_t pos)
2348 {
2349         /* no brushing without a useful snap setting */
2350
2351         switch (_snap_mode) {
2352         case SnapMagnetic:
2353                 return; /* can't work because it allows region to be placed anywhere */
2354         default:
2355                 break; /* OK */
2356         }
2357
2358         switch (_snap_type) {
2359         case SnapToMark:
2360                 return;
2361
2362         default:
2363                 break;
2364         }
2365
2366         /* don't brush a copy over the original */
2367
2368         if (pos == rv->region()->position()) {
2369                 return;
2370         }
2371
2372         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&rv->get_time_axis_view());
2373
2374         if (rtv == 0 || !rtv->is_track()) {
2375                 return;
2376         }
2377
2378         boost::shared_ptr<Playlist> playlist = rtv->playlist();
2379         double speed = rtv->track()->speed();
2380
2381         playlist->clear_changes ();
2382         boost::shared_ptr<Region> new_region (RegionFactory::create (rv->region(), true));
2383         playlist->add_region (new_region, (framepos_t) (pos * speed));
2384         _session->add_command (new StatefulDiffCommand (playlist));
2385
2386         // playlist is frozen, so we have to update manually XXX this is disgusting
2387
2388         playlist->RegionAdded (new_region); /* EMIT SIGNAL */
2389 }
2390
2391 gint
2392 Editor::track_height_step_timeout ()
2393 {
2394         if (get_microseconds() - last_track_height_step_timestamp < 250000) {
2395                 current_stepping_trackview = 0;
2396                 return false;
2397         }
2398         return true;
2399 }
2400
2401 void
2402 Editor::add_region_drag (ArdourCanvas::Item* item, GdkEvent* event, RegionView* region_view)
2403 {
2404         assert (region_view);
2405
2406         if (!region_view->region()->playlist()) {
2407                 return;
2408         }
2409
2410         _region_motion_group->raise_to_top ();
2411
2412         if (Config->get_edit_mode() == Splice) {
2413                 _drags->add (new RegionSpliceDrag (this, item, region_view, selection->regions.by_layer()));
2414         } else {
2415                 RegionSelection s = get_equivalent_regions (selection->regions, ARDOUR::Properties::edit.property_id);
2416                 _drags->add (new RegionMoveDrag (this, item, region_view, s.by_layer(), false, false));
2417         }
2418
2419         /* sync the canvas to what we think is its current state */
2420         update_canvas_now();
2421 }
2422
2423 void
2424 Editor::add_region_copy_drag (ArdourCanvas::Item* item, GdkEvent* event, RegionView* region_view)
2425 {
2426         assert (region_view);
2427
2428         if (!region_view->region()->playlist()) {
2429                 return;
2430         }
2431
2432         _region_motion_group->raise_to_top ();
2433
2434         RegionSelection s = get_equivalent_regions (selection->regions, ARDOUR::Properties::edit.property_id);
2435         _drags->add (new RegionMoveDrag (this, item, region_view, s.by_layer(), false, true));
2436 }
2437
2438 void
2439 Editor::add_region_brush_drag (ArdourCanvas::Item* item, GdkEvent* event, RegionView* region_view)
2440 {
2441         assert (region_view);
2442
2443         if (!region_view->region()->playlist()) {
2444                 return;
2445         }
2446
2447         if (Config->get_edit_mode() == Splice) {
2448                 return;
2449         }
2450
2451         RegionSelection s = get_equivalent_regions (selection->regions, ARDOUR::Properties::edit.property_id);
2452         _drags->add (new RegionMoveDrag (this, item, region_view, s.by_layer(), true, false));
2453
2454         begin_reversible_command (Operations::drag_region_brush);
2455 }
2456
2457 /** Start a grab where a time range is selected, track(s) are selected, and the
2458  *  user clicks and drags a region with a modifier in order to create a new region containing
2459  *  the section of the clicked region that lies within the time range.
2460  */
2461 void
2462 Editor::start_selection_grab (ArdourCanvas::Item* /*item*/, GdkEvent* event)
2463 {
2464         if (clicked_regionview == 0) {
2465                 return;
2466         }
2467
2468         /* lets try to create new Region for the selection */
2469
2470         vector<boost::shared_ptr<Region> > new_regions;
2471         create_region_from_selection (new_regions);
2472
2473         if (new_regions.empty()) {
2474                 return;
2475         }
2476
2477         /* XXX fix me one day to use all new regions */
2478
2479         boost::shared_ptr<Region> region (new_regions.front());
2480
2481         /* add it to the current stream/playlist.
2482
2483            tricky: the streamview for the track will add a new regionview. we will
2484            catch the signal it sends when it creates the regionview to
2485            set the regionview we want to then drag.
2486         */
2487
2488         latest_regionviews.clear();
2489         sigc::connection c = clicked_routeview->view()->RegionViewAdded.connect (sigc::mem_fun(*this, &Editor::collect_new_region_view));
2490
2491         /* A selection grab currently creates two undo/redo operations, one for
2492            creating the new region and another for moving it.
2493         */
2494
2495         begin_reversible_command (Operations::selection_grab);
2496
2497         boost::shared_ptr<Playlist> playlist = clicked_axisview->playlist();
2498
2499         playlist->clear_changes ();
2500         clicked_routeview->playlist()->add_region (region, selection->time[clicked_selection].start);
2501         _session->add_command(new StatefulDiffCommand (playlist));
2502
2503         commit_reversible_command ();
2504
2505         c.disconnect ();
2506
2507         if (latest_regionviews.empty()) {
2508                 /* something went wrong */
2509                 return;
2510         }
2511
2512         /* we need to deselect all other regionviews, and select this one
2513            i'm ignoring undo stuff, because the region creation will take care of it
2514         */
2515         selection->set (latest_regionviews);
2516
2517         _drags->set (new RegionMoveDrag (this, latest_regionviews.front()->get_canvas_group(), latest_regionviews.front(), latest_regionviews, false, false), event);
2518 }
2519
2520 void
2521 Editor::escape ()
2522 {
2523         if (_drags->active ()) {
2524                 _drags->abort ();
2525         } else {
2526                 selection->clear ();
2527         }
2528 }
2529
2530 void
2531 Editor::set_internal_edit (bool yn)
2532 {
2533         _internal_editing = yn;
2534
2535         if (yn) {
2536                 mouse_select_button.set_image (*(manage (new Image (::get_icon("midi_tool_pencil")))));
2537                 mouse_select_button.get_image ()->show ();
2538                 ARDOUR_UI::instance()->set_tip (mouse_select_button, _("Draw/Edit MIDI Notes"));
2539                 mouse_mode_toggled (mouse_mode);
2540
2541                 pre_internal_mouse_mode = mouse_mode;
2542
2543                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
2544                         (*i)->enter_internal_edit_mode ();
2545                 }
2546
2547         } else {
2548
2549                 mouse_select_button.set_image (*(manage (new Image (::get_icon("tool_range")))));
2550                 mouse_select_button.get_image ()->show ();
2551                 ARDOUR_UI::instance()->set_tip (mouse_select_button, _("Select/Move Ranges"));
2552                 mouse_mode_toggled (mouse_mode); // sets cursor
2553
2554                 for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
2555                         (*i)->leave_internal_edit_mode ();
2556                 }
2557
2558                 if (mouse_mode == MouseRange && pre_internal_mouse_mode != MouseRange) {
2559                         /* we were drawing .. flip back to something sensible */
2560                         set_mouse_mode (pre_internal_mouse_mode);
2561                 }
2562         }
2563 }
2564
2565 /** Update _join_object_range_state which indicate whether we are over the top or bottom half of a region view,
2566  *  used by the `join object/range' tool mode.
2567  */
2568 void
2569 Editor::update_join_object_range_location (double x, double y)
2570 {
2571         /* XXX: actually, this decides based on whether the mouse is in the top or bottom half of a RouteTimeAxisView;
2572            entered_{track,regionview} is not always setup (e.g. if the mouse is over a TimeSelection), and to get a Region
2573            that we're over requires searching the playlist.
2574         */
2575
2576         if (join_object_range_button.get_active() == false || (mouse_mode != MouseRange && mouse_mode != MouseObject)) {
2577                 _join_object_range_state = JOIN_OBJECT_RANGE_NONE;
2578                 return;
2579         }
2580
2581         if (mouse_mode == MouseObject) {
2582                 _join_object_range_state = JOIN_OBJECT_RANGE_OBJECT;
2583         } else if (mouse_mode == MouseRange) {
2584                 _join_object_range_state = JOIN_OBJECT_RANGE_RANGE;
2585         }
2586
2587         /* XXX: maybe we should make entered_track work in all cases, rather than resorting to this */
2588         pair<TimeAxisView*, int> tvp = trackview_by_y_position (y + vertical_adjustment.get_value() - canvas_timebars_vsize);
2589
2590         if (tvp.first) {
2591
2592                 RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
2593                 if (rtv) {
2594
2595                         double cx = 0;
2596                         double cy = y;
2597                         rtv->canvas_display()->w2i (cx, cy);
2598
2599                         double const c = cy / rtv->view()->child_height();
2600                         double d;
2601                         double const f = modf (c, &d);
2602
2603                         _join_object_range_state = f < 0.5 ? JOIN_OBJECT_RANGE_RANGE : JOIN_OBJECT_RANGE_OBJECT;
2604                 }
2605         }
2606 }
2607
2608 Editing::MouseMode
2609 Editor::effective_mouse_mode () const
2610 {
2611         if (_join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) {
2612                 return MouseObject;
2613         } else if (_join_object_range_state == JOIN_OBJECT_RANGE_RANGE) {
2614                 return MouseRange;
2615         }
2616
2617         return mouse_mode;
2618 }
2619
2620 void
2621 Editor::remove_midi_note (ArdourCanvas::Item* item, GdkEvent *)
2622 {
2623         ArdourCanvas::CanvasNoteEvent* e = dynamic_cast<ArdourCanvas::CanvasNoteEvent*> (item);
2624         assert (e);
2625
2626         e->region_view().delete_note (e->note ());
2627 }
2628
2629 void
2630 Editor::set_canvas_cursor_for_region_view (double x, RegionView* rv)
2631 {
2632         assert (rv);
2633
2634         ArdourCanvas::Group* g = rv->get_canvas_group ();
2635         ArdourCanvas::Group* p = g->get_parent_group ();
2636
2637         /* Compute x in region view parent coordinates */
2638         double dy = 0;
2639         p->w2i (x, dy);
2640
2641         double x1, x2, y1, y2;
2642         g->get_bounds (x1, y1, x2, y2);
2643
2644         /* Halfway across the region */
2645         double const h = (x1 + x2) / 2;
2646
2647         Trimmable::CanTrim ct = rv->region()->can_trim ();
2648         if (x <= h) {
2649                 if (ct & Trimmable::FrontTrimEarlier) {
2650                         set_canvas_cursor (_cursors->left_side_trim);
2651                 } else {
2652                         set_canvas_cursor (_cursors->left_side_trim_right_only);
2653                 }
2654         } else {
2655                 if (ct & Trimmable::EndTrimLater) {
2656                         set_canvas_cursor (_cursors->right_side_trim);
2657                 } else {
2658                         set_canvas_cursor (_cursors->right_side_trim_left_only);
2659                 }
2660         }
2661 }
2662
2663 /** Obtain the pointer position in world coordinates */
2664 void
2665 Editor::get_pointer_position (double& x, double& y) const
2666 {
2667         int px, py;
2668         track_canvas->get_pointer (px, py);
2669         track_canvas->window_to_world (px, py, x, y);
2670 }