#include <set>
#include <string>
#include <algorithm>
+#include <sys/time.h>
#include <pbd/error.h>
#include <gtkmm2ext/utils.h>
using namespace Gtk;
using namespace Editing;
-nframes_t
-Editor::event_frame (GdkEvent* event, double* pcx, double* pcy)
+bool
+Editor::mouse_frame (nframes64_t& where, bool& in_track_canvas) const
+{
+ int x, y;
+ double wx, wy;
+ Gdk::ModifierType mask;
+ Glib::RefPtr<Gdk::Window> canvas_window = const_cast<Editor*>(this)->track_canvas.get_window();
+ Glib::RefPtr<const Gdk::Window> pointer_window;
+
+ pointer_window = canvas_window->get_pointer (x, y, mask);
+
+ if (pointer_window == track_canvas.get_bin_window()) {
+
+ track_canvas.window_to_world (x, y, wx, wy);
+ in_track_canvas = true;
+
+ } else {
+ in_track_canvas = false;
+
+ if (pointer_window == time_canvas.get_bin_window()) {
+ time_canvas.window_to_world (x, y, wx, wy);
+ } else {
+ return false;
+ }
+ }
+
+ wx += horizontal_adjustment.get_value();
+ wy += vertical_adjustment.get_value();
+
+ GdkEvent event;
+ event.type = GDK_BUTTON_RELEASE;
+ event.button.x = wx;
+ event.button.y = wy;
+
+ where = event_frame (&event, 0, 0);
+ return true;
+}
+
+nframes64_t
+Editor::event_frame (GdkEvent* event, double* pcx, double* pcy) const
{
double cx, cy;
}
}
+Gdk::Cursor*
+Editor::which_grabber_cursor ()
+{
+ switch (_edit_point) {
+ case EditAtMouse:
+ return grabber_edit_point_cursor;
+ break;
+ default:
+ return grabber_cursor;
+ break;
+ }
+}
+
+void
+Editor::set_canvas_cursor ()
+{
+ switch (mouse_mode) {
+ case MouseRange:
+ current_canvas_cursor = selector_cursor;
+ break;
+
+ case MouseObject:
+ current_canvas_cursor = which_grabber_cursor();
+ break;
+
+ case MouseGain:
+ current_canvas_cursor = cross_hair_cursor;
+ break;
+
+ case MouseZoom:
+ current_canvas_cursor = zoom_cursor;
+ break;
+
+ case MouseTimeFX:
+ current_canvas_cursor = time_fx_cursor; // just use playhead
+ break;
+
+ case MouseAudition:
+ current_canvas_cursor = speaker_cursor;
+ break;
+ }
+
+ if (is_drawable()) {
+ track_canvas.get_window()->set_cursor(*current_canvas_cursor);
+ }
+}
+
void
Editor::set_mouse_mode (MouseMode m, bool force)
{
}
}
- /* XXX the hack of unsetting all other buttongs should go
+ /* XXX the hack of unsetting all other buttons should go
away once GTK2 allows us to use regular radio buttons drawn like
normal buttons, rather than my silly GroupedButton hack.
*/
switch (mouse_mode) {
case MouseRange:
mouse_select_button.set_active (true);
- current_canvas_cursor = selector_cursor;
break;
case MouseObject:
mouse_move_button.set_active (true);
- current_canvas_cursor = grabber_cursor;
break;
case MouseGain:
mouse_gain_button.set_active (true);
- current_canvas_cursor = cross_hair_cursor;
break;
case MouseZoom:
mouse_zoom_button.set_active (true);
- current_canvas_cursor = zoom_cursor;
break;
case MouseTimeFX:
mouse_timefx_button.set_active (true);
- current_canvas_cursor = time_fx_cursor; // just use playhead
break;
case MouseAudition:
mouse_audition_button.set_active (true);
- current_canvas_cursor = speaker_cursor;
break;
}
ignore_mouse_mode_toggle = false;
-
- if (is_drawable()) {
- track_canvas.get_window()->set_cursor(*current_canvas_cursor);
- }
+
+ set_canvas_cursor ();
}
void
void
Editor::button_selection (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
- bool commit = false;
-
/* in object/audition/timefx mode, any button press sets
the selection if the object can be selected. this is a
bit of hack, because we want to avoid this if the
switch (item_type) {
case RegionItem:
if (mouse_mode != MouseRange) {
- commit = set_selected_regionview_from_click (press, op, true);
+ set_selected_regionview_from_click (press, op, true);
} else if (event->type == GDK_BUTTON_PRESS) {
- commit = set_selected_track_from_click (press, op, false);
+ set_selected_track_as_side_effect ();
}
break;
case RegionViewNameHighlight:
case RegionViewName:
if (mouse_mode != MouseRange) {
- commit = set_selected_regionview_from_click (press, op, true);
+ set_selected_regionview_from_click (press, op, true);
} else if (event->type == GDK_BUTTON_PRESS) {
- commit = set_selected_track_from_click (press, op, false);
+ set_selected_track_as_side_effect ();
}
break;
case FadeOutHandleItem:
case FadeOutItem:
if (mouse_mode != MouseRange) {
- commit = set_selected_regionview_from_click (press, op, true);
+ set_selected_regionview_from_click (press, op, true);
} else if (event->type == GDK_BUTTON_PRESS) {
- commit = set_selected_track_from_click (press, op, false);
+ set_selected_track_as_side_effect ();
}
break;
case GainAutomationControlPointItem:
case PanAutomationControlPointItem:
case RedirectAutomationControlPointItem:
- commit = set_selected_track_from_click (press, op, true);
+ set_selected_track_as_side_effect ();
if (mouse_mode != MouseRange) {
- commit |= set_selected_control_point_from_click (op, false);
+ set_selected_control_point_from_click (op, false);
}
break;
case StreamItem:
/* for context click or range selection, select track */
if (event->button.button == 3) {
- commit = set_selected_track_from_click (press, op, true);
+ set_selected_track_as_side_effect ();
} else if (event->type == GDK_BUTTON_PRESS && mouse_mode == MouseRange) {
- commit = set_selected_track_from_click (press, op, false);
+ set_selected_track_as_side_effect ();
}
break;
case AutomationTrackItem:
- commit = set_selected_track_from_click (press, op, true);
+ set_selected_track_as_side_effect (true);
break;
default:
break;
}
-
-// if (commit) {
-// commit_reversible_command ();
-// }
}
+const static double ZERO_GAIN_FRACTION = gain_to_slider_position(dB_to_coefficient(0.0));
+
bool
Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
*/
switch (item_type) {
- case EditCursorItem:
case PlayheadCursorItem:
start_cursor_grab (item, event);
return true;
case MarkerItem:
- if (Keyboard::modifier_state_equals (event->button.state,
- Keyboard::ModifierMask(Keyboard::Control|Keyboard::Shift))) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
hide_marker (item, event);
} else {
start_marker_grab (item, event);
return true;
case TempoMarkerItem:
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
start_tempo_marker_copy_grab (item, event);
} else {
start_tempo_marker_grab (item, event);
return true;
case MeterMarkerItem:
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
start_meter_marker_copy_grab (item, event);
} else {
start_meter_marker_grab (item, event);
return true;
break;
+ case CdMarkerBarItem:
+ start_range_markerbar_op (item, event, CreateCDMarker);
+ return true;
+ break;
+
case TransportMarkerBarItem:
start_range_markerbar_op (item, event, CreateTransportMarker);
return true;
case SelectionItem:
if (Keyboard::modifier_state_contains
- (event->button.state, Keyboard::ModifierMask(Keyboard::Alt))) {
+ (event->button.state, Keyboard::ModifierMask(Keyboard::SecondaryModifier))) {
// contains and not equals because I can't use alt as a modifier alone.
start_selection_grab (item, event);
- } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
+ } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
/* grab selection for moving */
start_selection_op (item, event, SelectionMove);
- }
- else {
+ } else {
/* this was debated, but decided the more common action was to
make a new selection */
start_selection_op (item, event, CreateSelection);
break;
case MouseObject:
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::Control|Keyboard::Alt)) &&
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier|Keyboard::SecondaryModifier)) &&
event->type == GDK_BUTTON_PRESS) {
start_rubberband_select (item, event);
return true;
case RegionItem:
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
start_region_copy_grab (item, event);
} else if (Keyboard::the_keyboard().key_is_down (GDK_b)) {
start_region_brush_grab (item, event);
break;
case MouseAudition:
- /* handled in release */
+ _scrubbing = true;
+ scrub_reversals = 0;
+ scrub_reverse_distance = 0;
+ last_scrub_x = event->button.x;
+ scrubbing_direction = 0;
+ track_canvas.get_window()->set_cursor (*transparent_cursor);
+ /* rest handled in motion & release */
break;
default:
if (event->type == GDK_BUTTON_PRESS) {
switch (item_type) {
case RegionItem:
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
start_region_copy_grab (item, event);
} else {
start_region_grab (item, event);
}
-
+ return true;
break;
+
case GainAutomationControlPointItem:
case PanAutomationControlPointItem:
case RedirectAutomationControlPointItem:
case MouseZoom:
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
temporal_zoom_session();
} else {
temporal_zoom_to_frame (true, event_frame(event));
Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
nframes_t where = event_frame (event, 0, 0);
+ AutomationTimeAxisView* atv = 0;
/* no action if we're recording */
case MarkerBarItem:
case RangeMarkerBarItem:
- case TransportMarkerBarItem:
+ case TransportMarkerBarItem:
+ case CdMarkerBarItem:
case TempoBarItem:
case MeterBarItem:
popup_ruler_menu (pixel_to_frame(event->button.x), item_type);
switch (item_type) {
/* see comments in button_press_handler */
- case EditCursorItem:
case PlayheadCursorItem:
case MarkerItem:
case GainLineItem:
mouse_add_new_marker (where);
return true;
+ case CdMarkerBarItem:
+ // if we get here then a dragged range wasn't done
+ if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
+ snap_to (where, 0, true);
+ }
+ mouse_add_new_marker (where, true);
+ return true;
+
case TempoBarItem:
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
snap_to (where);
case MouseObject:
switch (item_type) {
case AutomationTrackItem:
- dynamic_cast<AutomationTimeAxisView*>(clicked_trackview)->add_automation_event
- (item,
- event,
- where,
- event->button.y);
+ atv = dynamic_cast<AutomationTimeAxisView*>(clicked_trackview);
+ if (atv) {
+ atv->add_automation_event (item, event, where, event->button.y);
+ }
return true;
+
break;
-
+
default:
break;
}
break;
case MouseAudition:
- switch (item_type) {
- case RegionItem:
- audition_selected_region ();
- break;
- default:
- break;
+ _scrubbing = false;
+ track_canvas.get_window()->set_cursor (*current_canvas_cursor);
+ if (scrubbing_direction == 0) {
+ /* no drag, just a click */
+ switch (item_type) {
+ case RegionItem:
+ play_selected_region ();
+ break;
+ default:
+ break;
+ }
+ } else {
+ /* make sure we stop */
+ session->request_transport_speed (0.0);
}
break;
case MouseObject:
switch (item_type) {
case RegionItem:
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
raise_region ();
- } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::Shift|Keyboard::Alt))) {
+ } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::TertiaryModifier|Keyboard::SecondaryModifier))) {
lower_region ();
} else {
// Button2 click is unused
Marker * marker;
double fraction;
+ if (last_item_entered != item) {
+ last_item_entered = item;
+ last_item_entered_n = 0;
+ }
+
switch (item_type) {
case GainControlPointItem:
if (mouse_mode == MouseGain) {
fraction = 1.0 - (cp->get_y() / cp->line.height());
- set_verbose_canvas_cursor (cp->line.get_verbose_cursor_string (fraction), at_x, at_y);
- show_verbose_canvas_cursor ();
-
- if (is_drawable()) {
+ if (is_drawable() && !_scrubbing) {
track_canvas.get_window()->set_cursor (*fader_cursor);
}
+
+ last_item_entered_n++;
+ set_verbose_canvas_cursor (cp->line.get_verbose_cursor_string (fraction), at_x, at_y);
+ if (last_item_entered_n < 10) {
+ show_verbose_canvas_cursor ();
+ }
}
break;
if (mouse_mode == MouseGain) {
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
if (line)
- line->property_fill_color_rgba() = color_map[cEnteredGainLine];
+ line->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_EnteredGainLine.get();
if (is_drawable()) {
track_canvas.get_window()->set_cursor (*fader_cursor);
}
{
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
if (line)
- line->property_fill_color_rgba() = color_map[cEnteredAutomationLine];
+ line->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_EnteredAutomationLine.get();
}
if (is_drawable()) {
track_canvas.get_window()->set_cursor (*fader_cursor);
}
break;
- case EditCursorItem:
case PlayheadCursorItem:
if (is_drawable()) {
- track_canvas.get_window()->set_cursor (*grabber_cursor);
+ switch (_edit_point) {
+ case EditAtMouse:
+ track_canvas.get_window()->set_cursor (*grabber_edit_point_cursor);
+ break;
+ default:
+ track_canvas.get_window()->set_cursor (*grabber_cursor);
+ break;
+ }
}
break;
case MarkerBarItem:
case RangeMarkerBarItem:
case TransportMarkerBarItem:
+ case CdMarkerBarItem:
case MeterBarItem:
case TempoBarItem:
if (is_drawable()) {
if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
break;
}
- marker->set_color_rgba (color_map[cEnteredMarker]);
+ entered_marker = marker;
+ marker->set_color_rgba (ARDOUR_UI::config()->canvasvar_EnteredMarker.get());
// fall through
case MeterMarkerItem:
case TempoMarkerItem:
case RegionViewNameHighlight:
case StartSelectionTrimItem:
case EndSelectionTrimItem:
- case EditCursorItem:
case PlayheadCursorItem:
/* <CMT Additions> */
case ImageFrameHandleStartItem:
case RangeMarkerBarItem:
case TransportMarkerBarItem:
+ case CdMarkerBarItem:
case MeterBarItem:
case TempoBarItem:
case MarkerBarItem:
if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
break;
}
- loc = find_location_from_marker (marker, is_start);
- if (loc) location_flags_changed (loc, this);
+ entered_marker = 0;
+ if ((loc = find_location_from_marker (marker, is_start)) != 0) {
+ location_flags_changed (loc, this);
+ }
// fall through
case MeterMarkerItem:
case TempoMarkerItem:
bool
Editor::motion_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type, bool from_autoscroll)
{
- gint x, y;
-
- /* We call this so that MOTION_NOTIFY events continue to be
- delivered to the canvas. We need to do this because we set
- Gdk::POINTER_MOTION_HINT_MASK on the canvas. This reduces
- the density of the events, at the expense of a round-trip
- to the server. Given that this will mostly occur on cases
- where DISPLAY = :0.0, and given the cost of what the motion
- event might do, its a good tradeoff.
- */
-
- track_canvas.get_pointer (x, y);
+ if (event->motion.is_hint) {
+ gint x, y;
+
+ /* We call this so that MOTION_NOTIFY events continue to be
+ delivered to the canvas. We need to do this because we set
+ Gdk::POINTER_MOTION_HINT_MASK on the canvas. This reduces
+ the density of the events, at the expense of a round-trip
+ to the server. Given that this will mostly occur on cases
+ where DISPLAY = :0.0, and given the cost of what the motion
+ event might do, its a good tradeoff.
+ */
+
+ track_canvas.get_pointer (x, y);
+ }
if (current_stepping_trackview) {
/* don't keep the persistent stepped trackview if the mouse moves */
}
drag_info.item_type = item_type;
+ drag_info.last_pointer_x = drag_info.current_pointer_x;
+ drag_info.last_pointer_y = drag_info.current_pointer_y;
drag_info.current_pointer_frame = event_frame (event, &drag_info.current_pointer_x,
&drag_info.current_pointer_y);
+ switch (mouse_mode) {
+ case MouseAudition:
+ if (_scrubbing) {
+
+ double delta;
+
+ if (scrubbing_direction == 0) {
+ /* first move */
+ session->request_locate (drag_info.current_pointer_frame, false);
+ session->request_transport_speed (0.1);
+ scrubbing_direction = 1;
+
+ } else {
+
+ if (last_scrub_x > drag_info.current_pointer_x) {
+
+ /* pointer moved to the left */
+
+ if (scrubbing_direction > 0) {
+
+ /* we reversed direction to go backwards */
+
+ scrub_reversals++;
+ scrub_reverse_distance += (int) (last_scrub_x - drag_info.current_pointer_x);
+
+ } else {
+
+ /* still moving to the left (backwards) */
+
+ scrub_reversals = 0;
+ scrub_reverse_distance = 0;
+
+ delta = 0.01 * (last_scrub_x - drag_info.current_pointer_x);
+ session->request_transport_speed (session->transport_speed() - delta);
+ }
+
+ } else {
+ /* pointer moved to the right */
+
+ if (scrubbing_direction < 0) {
+ /* we reversed direction to go forward */
+
+ scrub_reversals++;
+ scrub_reverse_distance += (int) (drag_info.current_pointer_x - last_scrub_x);
+
+ } else {
+ /* still moving to the right */
+
+ scrub_reversals = 0;
+ scrub_reverse_distance = 0;
+
+ delta = 0.01 * (drag_info.current_pointer_x - last_scrub_x);
+ session->request_transport_speed (session->transport_speed() + delta);
+ }
+ }
+
+ /* if there have been more than 2 opposite motion moves detected, or one that moves
+ back more than 10 pixels, reverse direction
+ */
+
+ if (scrub_reversals >= 2 || scrub_reverse_distance > 10) {
+
+ if (scrubbing_direction > 0) {
+ /* was forwards, go backwards */
+ session->request_transport_speed (-0.1);
+ scrubbing_direction = -1;
+ } else {
+ /* was backwards, go forwards */
+ session->request_transport_speed (0.1);
+ scrubbing_direction = 1;
+ }
+
+ scrub_reverse_distance = 0;
+ scrub_reversals = 0;
+ }
+ }
+
+ last_scrub_x = drag_info.current_pointer_x;
+ }
+
+ default:
+ break;
+ }
+
if (!from_autoscroll && drag_info.item) {
/* item != 0 is the best test i can think of for dragging.
*/
if (!drag_info.move_threshold_passed) {
- bool x_threshold_passed = (abs ((int) (drag_info.current_pointer_x - drag_info.grab_x)) > 4);
- bool y_threshold_passed = (abs ((int) (drag_info.current_pointer_y - drag_info.grab_y)) > 4);
-
+ bool x_threshold_passed = (::llabs ((nframes64_t) (drag_info.current_pointer_x - drag_info.grab_x)) > 4LL);
+ bool y_threshold_passed = (::llabs ((nframes64_t) (drag_info.current_pointer_y - drag_info.grab_y)) > 4LL);
+
drag_info.move_threshold_passed = (x_threshold_passed || y_threshold_passed);
// and change the initial grab loc/frame if this drag info wants us to
switch (item_type) {
case PlayheadCursorItem:
- case EditCursorItem:
case MarkerItem:
case GainControlPointItem:
case RedirectAutomationControlPointItem:
}
if (cursor == 0) {
- cursor = grabber_cursor;
+ cursor = which_grabber_cursor ();
}
// if dragging with button2, the motion is x constrained, with Alt-button2 it is y constrained
if (event->button.button == 2) {
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Alt)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::SecondaryModifier)) {
drag_info.y_constrained = true;
drag_info.x_constrained = false;
} else {
drag_info.y_constrained = false;
}
- drag_info.grab_frame = event_frame(event, &drag_info.grab_x, &drag_info.grab_y);
+ drag_info.grab_frame = event_frame (event, &drag_info.grab_x, &drag_info.grab_y);
drag_info.last_pointer_frame = drag_info.grab_frame;
drag_info.current_pointer_frame = drag_info.grab_frame;
drag_info.current_pointer_x = drag_info.grab_x;
drag_info.current_pointer_y = drag_info.grab_y;
+ drag_info.last_pointer_x = drag_info.current_pointer_x;
+ drag_info.last_pointer_y = drag_info.current_pointer_y;
drag_info.cumulative_x_drag = 0;
drag_info.cumulative_y_drag = 0;
drag_info.first_move = true;
drag_info.item = new_item;
if (cursor == 0) {
- cursor = grabber_cursor;
+ cursor = which_grabber_cursor ();
}
drag_info.item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK, *cursor, time);
stop_canvas_autoscroll ();
if (drag_info.item == 0) {
- cerr << "end grab with no item\n";
return false;
}
drag_info.item->ungrab (event->button.time);
if (drag_info.finished_callback) {
+ drag_info.last_pointer_x = drag_info.current_pointer_x;
+ drag_info.last_pointer_y = drag_info.current_pointer_y;
(this->*(drag_info.finished_callback)) (item, event);
}
return did_drag;
}
-void
-Editor::set_edit_cursor (GdkEvent* event)
-{
- nframes_t pointer_frame = event_frame (event);
-
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- if (snap_type != SnapToEditCursor) {
- snap_to (pointer_frame);
- }
- }
-
- edit_cursor->set_position (pointer_frame);
- edit_cursor_clock.set (pointer_frame);
-}
-
-void
-Editor::set_playhead_cursor (GdkEvent* event)
-{
- nframes_t pointer_frame = event_frame (event);
-
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- snap_to (pointer_frame);
- }
-
- if (session) {
- session->request_locate (pointer_frame, session->transport_rolling());
- }
-}
-
void
Editor::start_fade_in_grab (ArdourCanvas::Item* item, GdkEvent* event)
{
nframes_t pos;
nframes_t fade_length;
- if ((int32_t)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
+ if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
}
else {
if (drag_info.first_move) return;
- if ((int32_t)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
+ if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
} else {
pos = 0;
XMLNode &before = alist.get_state();
tmp->audio_region()->set_fade_in_length (fade_length);
+ tmp->audio_region()->set_fade_in_active (true);
XMLNode &after = alist.get_state();
session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
nframes_t pos;
nframes_t fade_length;
- if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
+ if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
- }
- else {
+ } else {
pos = 0;
}
nframes_t pos;
nframes_t fade_length;
- if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
+ if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
}
else {
XMLNode &before = alist.get_state();
tmp->audio_region()->set_fade_out_length (fade_length);
+ tmp->audio_region()->set_fade_out_active (true);
XMLNode &after = alist.get_state();
session->add_command(new MementoCommand<AutomationList>(alist, &before, &after));
Cursor* cursor = (Cursor *) drag_info.data;
nframes_t adjusted_frame;
- if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
+ if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
}
else {
}
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- if (cursor != edit_cursor || snap_type != SnapToEditCursor) {
+ if (cursor == playhead_cursor) {
snap_to (adjusted_frame);
}
}
cursor->set_position (adjusted_frame);
- if (cursor == edit_cursor) {
- edit_cursor_clock.set (cursor->current_frame);
- } else {
- UpdateAllTransportClocks (cursor->current_frame);
- }
+ UpdateAllTransportClocks (cursor->current_frame);
show_verbose_time_cursor (cursor->current_frame, 10);
if (session) {
session->request_locate (playhead_cursor->current_frame, drag_info.was_rolling);
}
- } else if (item == &edit_cursor->canvas_item) {
- edit_cursor->set_position (edit_cursor->current_frame);
- edit_cursor_clock.set (edit_cursor->current_frame);
}
}
start_grab (event);
+ _dragging_edit_point = true;
+
drag_info.copied_location = new Location (*location);
drag_info.pointer_frame_offset = drag_info.grab_frame - (is_start ? location->start() : location->end());
update_marker_drag_item (location);
if (location->is_mark()) {
- marker_drag_line->show();
- marker_drag_line->raise_to_top();
- }
- else {
+ // marker_drag_line->show();
+ // marker_drag_line->raise_to_top();
+ } else {
range_marker_drag_rect->show();
range_marker_drag_rect->raise_to_top();
}
-
- if (is_start) show_verbose_time_cursor (location->start(), 10);
- else show_verbose_time_cursor (location->end(), 10);
+
+ if (is_start) {
+ show_verbose_time_cursor (location->start(), 10);
+ } else {
+ show_verbose_time_cursor (location->end(), 10);
+ }
+
+ Selection::Operation op = Keyboard::selection_type (event->button.state);
+
+ switch (op) {
+ case Selection::Toggle:
+ selection->toggle (marker);
+ break;
+ case Selection::Set:
+ selection->set (marker);
+ break;
+ case Selection::Extend:
+ selection->add (marker);
+ break;
+ case Selection::Add:
+ selection->add (marker);
+ break;
+ }
}
void
bool is_start;
bool move_both = false;
-
nframes_t newframe;
- if (drag_info.pointer_frame_offset <= (long) drag_info.current_pointer_frame) {
+ if (drag_info.pointer_frame_offset <= drag_info.current_pointer_frame) {
newframe = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
- }
- else {
+ } else {
newframe = 0;
}
/* call this to find out if its the start or end */
- real_location = find_location_from_marker (marker, is_start);
+ if ((real_location = find_location_from_marker (marker, is_start)) == 0) {
+ return;
+ }
+
+ if (real_location->locked()) {
+ return;
+ }
/* use the copy that we're "dragging" around */
f_delta = copy_location->end() - copy_location->start();
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
move_both = true;
}
LocationMarkers* lm = find_location_markers (real_location);
lm->set_position (copy_location->start(), copy_location->end());
-
+ edit_point_clock.set (copy_location->start());
+
show_verbose_time_cursor (newframe, 10);
}
marker_drag_motion_callback (item, event);
}
+
+ _dragging_edit_point = false;
Marker* marker = (Marker *) drag_info.data;
bool is_start;
-
begin_reversible_command ( _("move marker") );
XMLNode &before = session->locations()->get_state();
Location * location = find_location_from_marker (marker, is_start);
-
+
if (location) {
+
+ if (location->locked()) {
+ return;
+ }
+
if (location->is_mark()) {
location->set_start (drag_info.copied_location->start());
} else {
}
drag_info.item = item;
+ drag_info.copy = false;
drag_info.data = marker;
drag_info.motion_callback = &Editor::meter_marker_drag_motion_callback;
drag_info.finished_callback = &Editor::meter_marker_drag_finished_callback;
// The actual copying is not done before we reach the finish callback.
char name[64];
snprintf (name, sizeof(name), "%g/%g", meter_marker->meter().beats_per_bar(), meter_marker->meter().note_divisor ());
- MeterMarker* new_marker = new MeterMarker(*this, *meter_group, color_map[cMeterMarker], name,
+ MeterMarker* new_marker = new MeterMarker(*this, *meter_group, ARDOUR_UI::config()->canvasvar_MeterMarker.get(), name,
*new MeterSection(meter_marker->meter()));
drag_info.item = &new_marker->the_item();
MeterMarker* marker = (MeterMarker *) drag_info.data;
nframes_t adjusted_frame;
- if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
+ if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
}
else {
}
drag_info.item = item;
+ drag_info.copy = false;
drag_info.data = marker;
drag_info.motion_callback = &Editor::tempo_marker_drag_motion_callback;
drag_info.finished_callback = &Editor::tempo_marker_drag_finished_callback;
// The actual copying is not done before we reach the finish callback.
char name[64];
snprintf (name, sizeof (name), "%.2f", tempo_marker->tempo().beats_per_minute());
- TempoMarker* new_marker = new TempoMarker(*this, *tempo_group, color_map[cTempoMarker], name,
+ TempoMarker* new_marker = new TempoMarker(*this, *tempo_group, ARDOUR_UI::config()->canvasvar_TempoMarker.get(), name,
*new TempoSection(tempo_marker->tempo()));
drag_info.item = &new_marker->the_item();
TempoMarker* marker = (TempoMarker *) drag_info.data;
nframes_t adjusted_frame;
- if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
+ if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
}
else {
start_grab (event, fader_cursor);
+ // start the grab at the center of the control point so
+ // the point doesn't 'jump' to the mouse after the first drag
+ drag_info.grab_x = control_point->get_x();
+ drag_info.grab_y = control_point->get_y();
+ control_point->line.parent_group().i2w(drag_info.grab_x, drag_info.grab_y);
+ track_canvas.w2c(drag_info.grab_x, drag_info.grab_y,
+ drag_info.grab_x, drag_info.grab_y);
+
+ drag_info.grab_frame = pixel_to_frame(drag_info.grab_x);
+
control_point->line.start_drag (control_point, drag_info.grab_frame, 0);
float fraction = 1.0 - (control_point->get_y() / control_point->line.height());
{
ControlPoint* cp = reinterpret_cast<ControlPoint *> (drag_info.data);
- double cx = drag_info.current_pointer_x;
- double cy = drag_info.current_pointer_y;
+ double dx = drag_info.current_pointer_x - drag_info.last_pointer_x;
+ double dy = drag_info.current_pointer_y - drag_info.last_pointer_y;
+
+ if (event->button.state & Keyboard::SecondaryModifier) {
+ dx *= 0.1;
+ dy *= 0.1;
+ }
+
+ double cx = drag_info.grab_x + drag_info.cumulative_x_drag + dx;
+ double cy = drag_info.grab_y + drag_info.cumulative_y_drag + dy;
- drag_info.cumulative_x_drag = cx - drag_info.grab_x ;
- drag_info.cumulative_y_drag = cy - drag_info.grab_y ;
+ // calculate zero crossing point. back off by .01 to stay on the
+ // positive side of zero
+ double _unused = 0;
+ double zero_gain_y = (1.0 - ZERO_GAIN_FRACTION) * cp->line.height() - .01;
+ cp->line.parent_group().i2w(_unused, zero_gain_y);
+
+ // make sure we hit zero when passing through
+ if ((cy < zero_gain_y and (cy - dy) > zero_gain_y)
+ or (cy > zero_gain_y and (cy - dy) < zero_gain_y)) {
+ cy = zero_gain_y;
+ }
if (drag_info.x_constrained) {
cx = drag_info.grab_x;
cy = drag_info.grab_y;
}
+ drag_info.cumulative_x_drag = cx - drag_info.grab_x;
+ drag_info.cumulative_y_drag = cy - drag_info.grab_y;
+
cp->line.parent_group().w2i (cx, cy);
cx = max (0.0, cx);
}
float fraction = 1.0 - (cy / cp->line.height());
-
+
bool push;
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier)) {
push = true;
} else {
push = false;
/* just a click */
- if ((event->type == GDK_BUTTON_RELEASE) && (event->button.button == 1) && Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
+ if ((event->type == GDK_BUTTON_RELEASE) && (event->button.button == 1) && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
reset_point_selection ();
}
Editor::line_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
{
AutomationLine* line = reinterpret_cast<AutomationLine *> (drag_info.data);
+
+ double dy = drag_info.current_pointer_y - drag_info.last_pointer_y;
+
+ if (event->button.state & Keyboard::SecondaryModifier) {
+ dy *= 0.1;
+ }
+
double cx = drag_info.current_pointer_x;
- double cy = drag_info.current_pointer_y;
+ double cy = drag_info.grab_y + drag_info.cumulative_y_drag + dy;
+
+ // calculate zero crossing point. back off by .01 to stay on the
+ // positive side of zero
+ double _unused = 0;
+ double zero_gain_y = (1.0 - ZERO_GAIN_FRACTION) * line->height() - .01;
+ line->parent_group().i2w(_unused, zero_gain_y);
+
+ // make sure we hit zero when passing through
+ if ((cy < zero_gain_y and (cy - dy) > zero_gain_y)
+ or (cy > zero_gain_y and (cy - dy) < zero_gain_y)) {
+ cy = zero_gain_y;
+ }
+
+ drag_info.cumulative_y_drag = cy - drag_info.grab_y;
line->parent_group().w2i (cx, cy);
-
+
+ cy = max (0.0, cy);
+ cy = min ((double) line->height(), cy);
+
double fraction;
fraction = 1.0 - (cy / line->height());
bool push;
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier)) {
push = false;
} else {
push = true;
drag_info.copy = false;
drag_info.item = item;
drag_info.data = clicked_regionview;
- drag_info.motion_callback = &Editor::region_drag_motion_callback;
- drag_info.finished_callback = &Editor::region_drag_finished_callback;
+
+ if (Config->get_edit_mode() == Splice) {
+ drag_info.motion_callback = &Editor::region_drag_splice_motion_callback;
+ drag_info.finished_callback = &Editor::region_drag_splice_finished_callback;
+ } else {
+ drag_info.motion_callback = &Editor::region_drag_motion_callback;
+ drag_info.finished_callback = &Editor::region_drag_finished_callback;
+ }
start_grab (event);
void
Editor::start_region_brush_grab (ArdourCanvas::Item* item, GdkEvent* event)
{
- if (selection->regions.empty() || clicked_regionview == 0) {
+ if (selection->regions.empty() || clicked_regionview == 0 || Config->get_edit_mode() == Splice) {
return;
}
}
void
-Editor::region_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
+Editor::possibly_copy_regions_during_grab (GdkEvent* event)
{
- double x_delta;
- double y_delta = 0;
- RegionView* rv = reinterpret_cast<RegionView*> (drag_info.data);
- nframes_t pending_region_position = 0;
- int32_t pointer_y_span = 0, canvas_pointer_y_span = 0, original_pointer_order;
- int32_t visible_y_high = 0, visible_y_low = 512; //high meaning higher numbered.. not the height on the screen
- bool clamp_y_axis = false;
- vector<int32_t> height_list(512) ;
- vector<int32_t>::iterator j;
-
if (drag_info.copy && drag_info.move_threshold_passed && drag_info.want_move_threshold) {
drag_info.want_move_threshold = false; // don't copy again
/* duplicate the region(s) */
-
+
vector<RegionView*> new_regionviews;
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
/* reset selection to new regionviews */
selection->set (new_regionviews);
-
+
/* reset drag_info data to reflect the fact that we are dragging the copies */
drag_info.data = new_regionviews.front();
-
+
swap_grab (new_regionviews.front()->get_canvas_group (), 0, event->motion.time);
}
+}
+bool
+Editor::check_region_drag_possible (AudioTimeAxisView** tv)
+{
/* Which trackview is this ? */
TimeAxisView* tvp = trackview_by_y_position (drag_info.current_pointer_y);
-
AudioTimeAxisView* tv = dynamic_cast<AudioTimeAxisView*>(tvp);
+
(*tv) = dynamic_cast<AudioTimeAxisView*>(tvp);
/* The region motion is only processed if the pointer is over
an audio track.
*/
- if (!tv || !tv->is_audio_track()) {
+ if (!(*tv) || !(*tv)->is_audio_track()) {
/* To make sure we hide the verbose canvas cursor when the mouse is
not held over and audiotrack.
*/
hide_verbose_canvas_cursor ();
- return;
+ return false;
}
+ return true;
+}
+
+struct RegionSelectionByPosition {
+ bool operator() (RegionView*a, RegionView* b) {
+ return a->region()->position () < b->region()->position();
+ }
+};
+
+void
+Editor::region_drag_splice_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
+{
+ AudioTimeAxisView* tv;
+
+ if (!check_region_drag_possible (&tv)) {
+ return;
+ }
+
+ if (!drag_info.move_threshold_passed) {
+ return;
+ }
+
+ int dir;
+
+ if (drag_info.current_pointer_x - drag_info.grab_x > 0) {
+ dir = 1;
+ } else {
+ dir = -1;
+ }
+
+ RegionSelection copy (selection->regions);
+
+ RegionSelectionByPosition cmp;
+ copy.sort (cmp);
+
+ for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
+
+ AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (&(*i)->get_time_axis_view());
+
+ if (!atv) {
+ continue;
+ }
+
+ boost::shared_ptr<Playlist> playlist;
+
+ if ((playlist = atv->playlist()) == 0) {
+ continue;
+ }
+
+ if (!playlist->region_is_shuffle_constrained ((*i)->region())) {
+ continue;
+ }
+
+ if (dir > 0) {
+ if (drag_info.current_pointer_frame < (*i)->region()->last_frame() + 1) {
+ continue;
+ }
+ } else {
+ if (drag_info.current_pointer_frame > (*i)->region()->first_frame()) {
+ continue;
+ }
+ }
+
+
+ playlist->shuffle ((*i)->region(), dir);
+
+ drag_info.grab_x = drag_info.current_pointer_x;
+ }
+}
+
+void
+Editor::region_drag_splice_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
+{
+}
+
+void
+Editor::region_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
+{
+ double x_delta;
+ double y_delta = 0;
+ RegionView* rv = reinterpret_cast<RegionView*> (drag_info.data);
+ nframes_t pending_region_position = 0;
+ int32_t pointer_y_span = 0, canvas_pointer_y_span = 0, original_pointer_order;
+ int32_t visible_y_high = 0, visible_y_low = 512; //high meaning higher numbered.. not the height on the screen
+ bool clamp_y_axis = false;
+ vector<int32_t> height_list(512) ;
+ vector<int32_t>::iterator j;
+ AudioTimeAxisView* tv;
+
+ possibly_copy_regions_during_grab (event);
+
+ if (!check_region_drag_possible (&tv)) {
+ return;
+ }
+
original_pointer_order = drag_info.last_trackview->order;
/************************************************************
pointer_y_span = 0;
goto y_axis_done;
}
-
+
if ((pointer_y_span = (drag_info.last_trackview->order - tv->order)) != 0) {
int32_t children = 0, numtracks = 0;
the region would be if we moved it by that much.
*/
- if (drag_info.move_threshold_passed) {
+ if ( drag_info.move_threshold_passed ) {
- if ((int32_t)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
+ if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
nframes_t sync_frame;
nframes_t sync_offset;
int32_t sync_dir;
-
+
pending_region_position = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
-
+
sync_offset = rv->region()->sync_offset (sync_dir);
- sync_frame = rv->region()->adjust_to_sync (pending_region_position);
- /* we snap if the snap modifier is not enabled.
+ /* we don't handle a sync point that lies before zero.
*/
+ if (sync_dir >= 0 || (sync_dir < 0 && pending_region_position >= sync_offset)) {
+ sync_frame = pending_region_position + (sync_dir*sync_offset);
+
+ /* we snap if the snap modifier is not enabled.
+ */
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
- snap_to (sync_frame);
- }
+ if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
+ snap_to (sync_frame);
+ }
- if (sync_frame - sync_offset <= sync_frame) {
- pending_region_position = sync_frame - (sync_dir*sync_offset);
+ pending_region_position = rv->region()->adjust_to_sync (sync_frame);
+
} else {
- pending_region_position = 0;
+ pending_region_position = drag_info.last_frame_position;
}
} else {
// printf ("3: pending_region_position= %lu %lu\n", pending_region_position, drag_info.last_frame_position );
- if (pending_region_position != drag_info.last_frame_position && !drag_info.x_constrained) {
+ bool x_move_allowed = ( !drag_info.x_constrained && (Config->get_edit_mode() != Lock)) || ( drag_info.x_constrained && (Config->get_edit_mode() == Lock)) ;
+ if ( pending_region_position != drag_info.last_frame_position && x_move_allowed ) {
- /* now compute the canvas unit distance we need to move the regiondrag_info.last_trackview->order
+ /* now compute the canvas unit distance we need to move the regionview
to make it appear at the new location.
*/
-
+
if (pending_region_position > drag_info.last_frame_position) {
x_delta = ((double) (pending_region_position - drag_info.last_frame_position) / frames_per_unit);
} else {
x_delta = -((double) (drag_info.last_frame_position - pending_region_position) / frames_per_unit);
}
-
+
drag_info.last_frame_position = pending_region_position;
} else {
x_delta = 0;
}
-
+
/*************************************************************
PREPARE TO MOVE
************************************************************/
return;
}
+
if (x_delta < 0) {
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
const list<RegionView*>& layered_regions = selection->regions.by_layer();
-
+
for (list<RegionView*>::const_iterator i = layered_regions.begin(); i != layered_regions.end(); ++i) {
RegionView* rv = (*i);
if (-x_delta > ix1) {
x_delta = -ix1;
}
- } else if ((x_delta > 0) &&(rv->region()->last_frame() > max_frames - x_delta)) {
+ } else if ((x_delta > 0) && (rv->region()->last_frame() > max_frames - x_delta)) {
x_delta = max_frames - rv->region()->last_frame();
}
+
if (drag_info.first_move) {
/* hide any dependent views */
rv->get_canvas_group()->raise_to_top();
rv->get_time_axis_view().canvas_display->raise_to_top();
cursor_group->raise_to_top();
-
rv->fake_set_opaque (true);
}
-
+
if (drag_info.brushing) {
mouse_brush_insert_region (rv, pending_region_position);
} else {
RouteTimeAxisView* atv;
bool regionview_y_movement;
bool regionview_x_movement;
+ vector<RegionView*> copies;
/* first_move is set to false if the regionview has been moved in the
motion handler.
region_drag_motion_callback (item, event);
+ if (Config->get_edit_mode() == Splice && !pre_drag_region_selection.empty()) {
+ selection->set (pre_drag_region_selection);
+ pre_drag_region_selection.clear ();
+ }
+
if (drag_info.brushing) {
/* all changes were made during motion event handlers */
+
+ if (drag_info.copy) {
+ for (list<RegionView*>::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
+ copies.push_back (*i);
+ }
+ }
+
goto out;
}
vector<RegionView*> new_selection;
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ) {
-
+
RegionView* rv = (*i);
double ix1, ix2, iy1, iy2;
boost::shared_ptr<Playlist> from_playlist = rv->region()->playlist();
boost::shared_ptr<Playlist> to_playlist = atv2->playlist();
-
+
where = (nframes_t) (unit_to_frame (ix1) * speed);
boost::shared_ptr<Region> new_region (RegionFactory::create (rv->region()));
session->add_command (new MementoCommand<Playlist>(*from_playlist, &from_playlist->get_state(), 0));
from_playlist->remove_region ((rv->region()));
session->add_command (new MementoCommand<Playlist>(*from_playlist, 0, &from_playlist->get_state()));
+
+ } else {
+
+ /* the regionview we dragged around is a temporary copy, queue it for deletion */
+
+ copies.push_back (rv);
}
- latest_regionview = 0;
+ latest_regionviews.clear ();
sigc::connection c = atv2->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
session->add_command (new MementoCommand<Playlist>(*to_playlist, &to_playlist->get_state(), 0));
session->add_command (new MementoCommand<Playlist>(*to_playlist, 0, &to_playlist->get_state()));
c.disconnect ();
- if (latest_regionview) {
- new_selection.push_back (latest_regionview);
+ if (!latest_regionviews.empty()) {
+ new_selection.insert (new_selection.end(), latest_regionviews.begin(), latest_regionviews.end());
}
- if (drag_info.copy) {
- // get rid of the copy
- delete rv;
- }
-
/* OK, this is where it gets tricky. If the playlist was being used by >1 tracks, and the region
was selected in all of them, then removing it from the playlist will have removed all
trace of it from the selection (i.e. there were N regions selected, we removed 1,
here. if the region selection is not empty, then restart the loop because we know that
we must have removed at least the region(view) we've just been working on as well as any
that we processed on previous iterations.
+
+ EXCEPT .... if we are doing a copy drag, then the selection hasn't been modified and
+ we can just iterate.
*/
- if (selection->regions.empty()) {
- break;
- } else {
- i = selection->regions.by_layer().begin();
+ if (drag_info.copy) {
+ ++i;
+ } else {
+ if (selection->regions.empty()) {
+ break;
+ } else {
+ i = selection->regions.by_layer().begin();
+ }
}
}
}
/* add it */
-
- latest_regionview = 0;
+
+ latest_regionviews.clear ();
sigc::connection c = atv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
to_playlist->add_region (newregion, (nframes_t) (where * atv->get_diskstream()->speed()));
c.disconnect ();
-
- if (latest_regionview) {
- atv->reveal_dependent_views (*latest_regionview);
- selection->add (latest_regionview);
+
+ if (!latest_regionviews.empty()) {
+ // XXX why just the first one ? we only expect one
+ atv->reveal_dependent_views (*latest_regionviews.front());
+ selection->add (latest_regionviews);
}
/* if the original region was locked, we don't care for the new one */
session->add_command (new MementoCommand<Playlist>(*to_playlist, 0, &to_playlist->get_state()));
- /* get rid of the copy */
-
if (drag_info.copy) {
- delete rv;
+ copies.push_back (rv);
}
}
}
if (!nocommit) {
commit_reversible_command ();
}
+
+ for (vector<RegionView*>::iterator x = copies.begin(); x != copies.end(); ++x) {
+ delete *x;
+ }
}
void
this is an alignment click (control used)
*/
- if (Keyboard::modifier_state_contains (event->state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_contains (event->state, Keyboard::PrimaryModifier)) {
TimeAxisView* tv = &rv.get_time_axis_view();
AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*>(tv);
double speed = 1.0;
speed = atv->get_diskstream()->speed();
}
- if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Alt))) {
+ nframes64_t where = get_preferred_edit_position();
- align_region (rv.region(), SyncPoint, (nframes_t) (edit_cursor->current_frame * speed));
+ if (where >= 0) {
- } else if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Shift))) {
-
- align_region (rv.region(), End, (nframes_t) (edit_cursor->current_frame * speed));
-
- } else {
-
- align_region (rv.region(), Start, (nframes_t) (edit_cursor->current_frame * speed));
+ if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) {
+
+ align_region (rv.region(), SyncPoint, (nframes_t) (where * speed));
+
+ } else if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
+
+ align_region (rv.region(), End, (nframes_t) (where * speed));
+
+ } else {
+
+ align_region (rv.region(), Start, (nframes_t) (where * speed));
+ }
}
}
}
void
Editor::collect_new_region_view (RegionView* rv)
{
- latest_regionview = rv;
+ latest_regionviews.push_back (rv);
}
void
set the regionview we want to then drag.
*/
- latest_regionview = 0;
+ latest_regionviews.clear();
sigc::connection c = clicked_audio_trackview->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
/* A selection grab currently creates two undo/redo operations, one for
c.disconnect ();
- if (latest_regionview == 0) {
+ if (latest_regionviews.empty()) {
/* something went wrong */
return;
}
/* we need to deselect all other regionviews, and select this one
- i'm ignoring undo stuff, because the region creation will take care of it */
- selection->set (latest_regionview);
+ i'm ignoring undo stuff, because the region creation will take care of it
+ */
+ selection->set (latest_regionviews);
- drag_info.item = latest_regionview->get_canvas_group();
- drag_info.data = latest_regionview;
+ drag_info.item = latest_regionviews.front()->get_canvas_group();
+ drag_info.data = latest_regionviews.front();
drag_info.motion_callback = &Editor::region_drag_motion_callback;
drag_info.finished_callback = &Editor::region_drag_finished_callback;
start_grab (event);
drag_info.last_trackview = clicked_trackview;
- drag_info.last_frame_position = latest_regionview->region()->position();
+ drag_info.last_frame_position = latest_regionviews.front()->region()->position();
drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
show_verbose_time_cursor (drag_info.last_frame_position, 10);
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
(*i)->hide_selection ();
}
- begin_reversible_command (_("cancel selection"));
selection->clear ();
clicked_selection = 0;
- commit_reversible_command ();
}
void
switch (op) {
case CreateSelection:
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
drag_info.copy = true;
} else {
drag_info.copy = false;
nframes_t length;
nframes_t pending_position;
- if ((int32_t) drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
+ if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pending_position = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
- }
- else {
+ } else {
pending_position = 0;
}
start_grab (event, trimmer_cursor);
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
trim_op = ContentsTrim;
} else {
/* These will get overridden for a point trim.*/
begin_reversible_command (trim_type);
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
- (*i)->fake_set_opaque(false);
+ (*i)->fake_set_opaque(false);
(*i)->region()->freeze ();
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
{
bool swap_direction = false;
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Control)) {
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
swap_direction = true;
}
if (!drag_info.first_move) {
trim_motion_callback (item, event);
- if (!clicked_regionview->get_selected()) {
+ if (!selection->selected (clicked_regionview)) {
thaw_region_after_trim (*clicked_regionview);
} else {
trim_op = StartTrim;
begin_reversible_command (_("Start point trim"));
- if (rv->get_selected()) {
+ if (selection->selected (rv)) {
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin();
i != selection->regions.by_layer().end(); ++i)
trim_op = EndTrim;
begin_reversible_command (_("End point trim"));
- if (rv->get_selected()) {
+ if (selection->selected (rv)) {
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i)
{
switch (op) {
case CreateRangeMarker:
case CreateTransportMarker:
-
- if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
+ case CreateCDMarker:
+
+ if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
drag_info.copy = true;
} else {
drag_info.copy = false;
{
nframes_t start = 0;
nframes_t end = 0;
- ArdourCanvas::SimpleRect *crect = (range_marker_op == CreateRangeMarker) ? range_bar_drag_rect: transport_bar_drag_rect;
+ ArdourCanvas::SimpleRect *crect;
+
+ switch (range_marker_op) {
+ case CreateRangeMarker:
+ crect = range_bar_drag_rect;
+ break;
+ case CreateTransportMarker:
+ crect = transport_bar_drag_rect;
+ break;
+ case CreateCDMarker:
+ crect = cd_marker_bar_drag_rect;
+ break;
+ default:
+ cerr << "Error: unknown range marker op passed to Editor::drag_range_markerbar_op ()" << endl;
+ return;
+ break;
+ }
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
snap_to (drag_info.current_pointer_frame);
switch (range_marker_op) {
case CreateRangeMarker:
case CreateTransportMarker:
+ case CreateCDMarker:
if (drag_info.first_move) {
snap_to (drag_info.grab_frame);
}
{
Location * newloc = 0;
string rangename;
+ int flags;
if (!drag_info.first_move) {
drag_range_markerbar_op (item, event);
switch (range_marker_op) {
case CreateRangeMarker:
+ case CreateCDMarker:
{
begin_reversible_command (_("new range marker"));
XMLNode &before = session->locations()->get_state();
session->locations()->next_available_name(rangename,"unnamed");
- newloc = new Location(temp_location->start(), temp_location->end(), rangename, Location::IsRangeMarker);
+ if (range_marker_op == CreateCDMarker) {
+ flags = Location::IsRangeMarker|Location::IsCDMarker;
+ cd_marker_bar_drag_rect->hide();
+ }
+ else {
+ flags = Location::IsRangeMarker;
+ range_bar_drag_rect->hide();
+ }
+ newloc = new Location(temp_location->start(), temp_location->end(), rangename, (Location::Flags) flags);
session->locations()->add (newloc, true);
XMLNode &after = session->locations()->get_state();
session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
commit_reversible_command ();
- range_bar_drag_rect->hide();
range_marker_drag_rect->hide();
break;
}
} else {
/* just a click, no pointer movement. remember that context menu stuff was handled elsewhere */
- if (Keyboard::no_modifier_keys_pressed (&event->button)) {
+ if (Keyboard::no_modifier_keys_pressed (&event->button) && range_marker_op != CreateCDMarker) {
nframes_t start;
nframes_t end;
switch (mouse_mode) {
case MouseObject:
/* find the two markers on either side and then make the selection from it */
- select_all_within (start, end, 0.0f, FLT_MAX, Selection::Set);
+ select_all_within (start, end, 0.0f, FLT_MAX, track_views, Selection::Set);
break;
case MouseRange:
return;
}
- if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
+ if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()) && Config->get_rubberbanding_snaps_to_grid()) {
if (drag_info.first_move) {
snap_to (drag_info.grab_frame);
}
begin_reversible_command (_("rubberband selection"));
if (drag_info.grab_frame < drag_info.last_pointer_frame) {
- commit = select_all_within (drag_info.grab_frame, drag_info.last_pointer_frame, y1, y2, op);
+ commit = select_all_within (drag_info.grab_frame, drag_info.last_pointer_frame, y1, y2, track_views, op);
} else {
- commit = select_all_within (drag_info.last_pointer_frame, drag_info.grab_frame, y1, y2, op);
+ commit = select_all_within (drag_info.last_pointer_frame, drag_info.grab_frame, y1, y2, track_views, op);
}
if (commit) {
string str;
prompter.get_result(str);
if (str.length()) {
- clicked_regionview->region()->set_name (str);
+ clicked_regionview->region()->set_name (str);
}
break;
}
if (drag_info.first_move) {
return;
}
+
+ if (drag_info.last_pointer_frame < clicked_regionview->region()->position()) {
+ /* backwards drag of the left edge - not usable */
+ return;
+ }
nframes_t newlen = drag_info.last_pointer_frame - clicked_regionview->region()->position();
+#ifdef USE_RUBBERBAND
+ float percentage = (float) ((double) newlen / (double) clicked_regionview->region()->length());
+#else
float percentage = (float) ((double) newlen - (double) clicked_regionview->region()->length()) / ((double) newlen) * 100.0f;
-
+#endif
+
begin_reversible_command (_("timestretch"));
- if (run_timestretch (selection->regions, percentage) == 0) {
+ // XXX how do timeFX on multiple regions ?
+
+ RegionSelection rs;
+ rs.add (clicked_regionview);
+
+ if (time_stretch (rs, percentage) == 0) {
session->commit_reversible_command ();
}
}
}
switch (snap_type) {
- case SnapToFrame:
case SnapToMark:
- case SnapToEditCursor:
return;
default:
}
return true;
}
+
projects / ardour.git / blobdiff