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