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