git-svn-id: svn://localhost/ardour2/branches/3.0@4716 d708f5d6-7413-0410-9779-e7cbd77b26cf
6018 lines
153 KiB
C++
6018 lines
153 KiB
C++
/*
|
|
Copyright (C) 2000-2001 Paul Davis
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
#include <cassert>
|
|
#include <cstdlib>
|
|
#include <stdint.h>
|
|
#include <cmath>
|
|
#include <set>
|
|
#include <string>
|
|
#include <algorithm>
|
|
|
|
#include "pbd/error.h"
|
|
#include <gtkmm2ext/utils.h>
|
|
#include <gtkmm2ext/tearoff.h>
|
|
#include "pbd/memento_command.h"
|
|
#include "pbd/basename.h"
|
|
|
|
#include "ardour_ui.h"
|
|
#include "editor.h"
|
|
#include "time_axis_view.h"
|
|
#include "audio_time_axis.h"
|
|
#include "audio_region_view.h"
|
|
#include "midi_region_view.h"
|
|
#include "marker.h"
|
|
#include "streamview.h"
|
|
#include "region_gain_line.h"
|
|
#include "automation_time_axis.h"
|
|
#include "control_point.h"
|
|
#include "prompter.h"
|
|
#include "utils.h"
|
|
#include "selection.h"
|
|
#include "keyboard.h"
|
|
#include "editing.h"
|
|
#include "rgb_macros.h"
|
|
#include "control_point_dialog.h"
|
|
|
|
#include "ardour/types.h"
|
|
#include "ardour/profile.h"
|
|
#include "ardour/route.h"
|
|
#include "ardour/audio_track.h"
|
|
#include "ardour/audio_diskstream.h"
|
|
#include "ardour/midi_diskstream.h"
|
|
#include "ardour/playlist.h"
|
|
#include "ardour/audioplaylist.h"
|
|
#include "ardour/audioregion.h"
|
|
#include "ardour/midi_region.h"
|
|
#include "ardour/dB.h"
|
|
#include "ardour/utils.h"
|
|
#include "ardour/region_factory.h"
|
|
#include "ardour/source_factory.h"
|
|
|
|
#include <bitset>
|
|
|
|
#include "i18n.h"
|
|
|
|
using namespace std;
|
|
using namespace ARDOUR;
|
|
using namespace PBD;
|
|
using namespace sigc;
|
|
using namespace Gtk;
|
|
using namespace Editing;
|
|
|
|
const static double ZERO_GAIN_FRACTION = gain_to_slider_position(dB_to_coefficient(0.0));
|
|
|
|
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;
|
|
|
|
if (!canvas_window) {
|
|
return false;
|
|
}
|
|
|
|
pointer_window = canvas_window->get_pointer (x, y, mask);
|
|
|
|
if (pointer_window == track_canvas->get_bin_window()) {
|
|
wx = x;
|
|
wy = y;
|
|
in_track_canvas = true;
|
|
|
|
} else {
|
|
in_track_canvas = false;
|
|
return false;
|
|
}
|
|
|
|
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;
|
|
|
|
if (pcx == 0) {
|
|
pcx = &cx;
|
|
}
|
|
if (pcy == 0) {
|
|
pcy = &cy;
|
|
}
|
|
|
|
*pcx = 0;
|
|
*pcy = 0;
|
|
|
|
switch (event->type) {
|
|
case GDK_BUTTON_RELEASE:
|
|
case GDK_BUTTON_PRESS:
|
|
case GDK_2BUTTON_PRESS:
|
|
case GDK_3BUTTON_PRESS:
|
|
|
|
*pcx = event->button.x;
|
|
*pcy = event->button.y;
|
|
_trackview_group->w2i(*pcx, *pcy);
|
|
break;
|
|
case GDK_MOTION_NOTIFY:
|
|
|
|
*pcx = event->motion.x;
|
|
*pcy = event->motion.y;
|
|
_trackview_group->w2i(*pcx, *pcy);
|
|
break;
|
|
case GDK_ENTER_NOTIFY:
|
|
case GDK_LEAVE_NOTIFY:
|
|
track_canvas->w2c(event->crossing.x, event->crossing.y, *pcx, *pcy);
|
|
break;
|
|
case GDK_KEY_PRESS:
|
|
case GDK_KEY_RELEASE:
|
|
// track_canvas->w2c(event->key.x, event->key.y, *pcx, *pcy);
|
|
break;
|
|
default:
|
|
warning << string_compose (_("Editor::event_frame() used on unhandled event type %1"), event->type) << endmsg;
|
|
break;
|
|
}
|
|
|
|
/* note that pixel_to_frame() never returns less than zero, so even if the pixel
|
|
position is negative (as can be the case with motion events in particular),
|
|
the frame location is always positive.
|
|
*/
|
|
|
|
return pixel_to_frame (*pcx);
|
|
}
|
|
|
|
void
|
|
Editor::mouse_mode_toggled (MouseMode m)
|
|
{
|
|
if (ignore_mouse_mode_toggle) {
|
|
return;
|
|
}
|
|
|
|
switch (m) {
|
|
case MouseRange:
|
|
if (mouse_select_button.get_active()) {
|
|
set_mouse_mode (m);
|
|
}
|
|
break;
|
|
|
|
case MouseObject:
|
|
if (mouse_move_button.get_active()) {
|
|
set_mouse_mode (m);
|
|
}
|
|
break;
|
|
|
|
case MouseGain:
|
|
if (mouse_gain_button.get_active()) {
|
|
set_mouse_mode (m);
|
|
}
|
|
break;
|
|
|
|
case MouseZoom:
|
|
if (mouse_zoom_button.get_active()) {
|
|
set_mouse_mode (m);
|
|
}
|
|
break;
|
|
|
|
case MouseTimeFX:
|
|
if (mouse_timefx_button.get_active()) {
|
|
set_mouse_mode (m);
|
|
}
|
|
break;
|
|
|
|
case MouseAudition:
|
|
if (mouse_audition_button.get_active()) {
|
|
set_mouse_mode (m);
|
|
}
|
|
break;
|
|
|
|
case MouseNote:
|
|
if (mouse_note_button.get_active()) {
|
|
set_mouse_mode (m);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
Gdk::Cursor*
|
|
Editor::which_grabber_cursor ()
|
|
{
|
|
switch (_edit_point) {
|
|
case EditAtMouse:
|
|
return grabber_edit_point_cursor;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return grabber_cursor;
|
|
}
|
|
|
|
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;
|
|
|
|
case MouseNote:
|
|
set_midi_edit_cursor (current_midi_edit_mode());
|
|
break;
|
|
}
|
|
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor(*current_canvas_cursor);
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::set_mouse_mode (MouseMode m, bool force)
|
|
{
|
|
if (drag_info.item) {
|
|
return;
|
|
}
|
|
|
|
if (!force && m == mouse_mode) {
|
|
return;
|
|
}
|
|
|
|
mouse_mode = m;
|
|
|
|
instant_save ();
|
|
|
|
if (mouse_mode != MouseRange) {
|
|
|
|
/* in all modes except range, hide the range selection,
|
|
show the object (region) selection.
|
|
*/
|
|
|
|
for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
|
|
(*i)->set_should_show_selection (true);
|
|
}
|
|
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
|
|
(*i)->hide_selection ();
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
in range mode,show the range selection.
|
|
*/
|
|
|
|
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
|
|
if ((*i)->get_selected()) {
|
|
(*i)->show_selection (selection->time);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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.
|
|
*/
|
|
|
|
ignore_mouse_mode_toggle = true;
|
|
|
|
switch (mouse_mode) {
|
|
case MouseRange:
|
|
mouse_select_button.set_active (true);
|
|
break;
|
|
|
|
case MouseObject:
|
|
mouse_move_button.set_active (true);
|
|
break;
|
|
|
|
case MouseGain:
|
|
mouse_gain_button.set_active (true);
|
|
break;
|
|
|
|
case MouseZoom:
|
|
mouse_zoom_button.set_active (true);
|
|
break;
|
|
|
|
case MouseTimeFX:
|
|
mouse_timefx_button.set_active (true);
|
|
break;
|
|
|
|
case MouseAudition:
|
|
mouse_audition_button.set_active (true);
|
|
break;
|
|
|
|
case MouseNote:
|
|
mouse_note_button.set_active (true);
|
|
set_midi_edit_cursor (current_midi_edit_mode());
|
|
break;
|
|
}
|
|
|
|
if (midi_tools_tearoff) {
|
|
if (mouse_mode == MouseNote) {
|
|
midi_tools_tearoff->show();
|
|
} else {
|
|
midi_tools_tearoff->hide();
|
|
}
|
|
}
|
|
|
|
ignore_mouse_mode_toggle = false;
|
|
|
|
set_canvas_cursor ();
|
|
}
|
|
|
|
void
|
|
Editor::step_mouse_mode (bool next)
|
|
{
|
|
switch (current_mouse_mode()) {
|
|
case MouseObject:
|
|
if (next) {
|
|
if (Profile->get_sae()) {
|
|
set_mouse_mode (MouseZoom);
|
|
} else {
|
|
set_mouse_mode (MouseRange);
|
|
}
|
|
} else {
|
|
set_mouse_mode (MouseTimeFX);
|
|
}
|
|
break;
|
|
|
|
case MouseRange:
|
|
if (next) set_mouse_mode (MouseZoom);
|
|
else set_mouse_mode (MouseObject);
|
|
break;
|
|
|
|
case MouseZoom:
|
|
if (next) {
|
|
if (Profile->get_sae()) {
|
|
set_mouse_mode (MouseTimeFX);
|
|
} else {
|
|
set_mouse_mode (MouseGain);
|
|
}
|
|
} else {
|
|
if (Profile->get_sae()) {
|
|
set_mouse_mode (MouseObject);
|
|
} else {
|
|
set_mouse_mode (MouseRange);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MouseGain:
|
|
if (next) set_mouse_mode (MouseTimeFX);
|
|
else set_mouse_mode (MouseZoom);
|
|
break;
|
|
|
|
case MouseTimeFX:
|
|
if (next) {
|
|
set_mouse_mode (MouseAudition);
|
|
} else {
|
|
if (Profile->get_sae()) {
|
|
set_mouse_mode (MouseZoom);
|
|
} else {
|
|
set_mouse_mode (MouseGain);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MouseAudition:
|
|
if (next) set_mouse_mode (MouseObject);
|
|
else set_mouse_mode (MouseTimeFX);
|
|
break;
|
|
|
|
case MouseNote:
|
|
if (next) set_mouse_mode (MouseObject);
|
|
else set_mouse_mode (MouseAudition);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::midi_edit_mode_toggled (MidiEditMode m)
|
|
{
|
|
if (ignore_midi_edit_mode_toggle) {
|
|
return;
|
|
}
|
|
|
|
switch (m) {
|
|
case MidiEditPencil:
|
|
if (midi_tool_pencil_button.get_active())
|
|
set_midi_edit_mode (m);
|
|
break;
|
|
|
|
case MidiEditSelect:
|
|
if (midi_tool_select_button.get_active())
|
|
set_midi_edit_mode (m);
|
|
break;
|
|
|
|
case MidiEditResize:
|
|
if (midi_tool_resize_button.get_active())
|
|
set_midi_edit_mode (m);
|
|
break;
|
|
|
|
case MidiEditErase:
|
|
if (midi_tool_erase_button.get_active())
|
|
set_midi_edit_mode (m);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
set_midi_edit_cursor(m);
|
|
}
|
|
|
|
|
|
void
|
|
Editor::set_midi_edit_mode (MidiEditMode m, bool force)
|
|
{
|
|
if (drag_info.item) {
|
|
return;
|
|
}
|
|
|
|
if (!force && m == midi_edit_mode) {
|
|
return;
|
|
}
|
|
|
|
midi_edit_mode = m;
|
|
|
|
instant_save ();
|
|
|
|
ignore_midi_edit_mode_toggle = true;
|
|
|
|
switch (midi_edit_mode) {
|
|
case MidiEditPencil:
|
|
midi_tool_pencil_button.set_active (true);
|
|
break;
|
|
|
|
case MidiEditSelect:
|
|
midi_tool_select_button.set_active (true);
|
|
break;
|
|
|
|
case MidiEditResize:
|
|
midi_tool_resize_button.set_active (true);
|
|
break;
|
|
|
|
case MidiEditErase:
|
|
midi_tool_erase_button.set_active (true);
|
|
break;
|
|
}
|
|
|
|
ignore_midi_edit_mode_toggle = false;
|
|
|
|
set_midi_edit_cursor (current_midi_edit_mode());
|
|
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor(*current_canvas_cursor);
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::set_midi_edit_cursor (MidiEditMode m)
|
|
{
|
|
switch (midi_edit_mode) {
|
|
case MidiEditPencil:
|
|
current_canvas_cursor = midi_pencil_cursor;
|
|
break;
|
|
|
|
case MidiEditSelect:
|
|
current_canvas_cursor = midi_select_cursor;
|
|
break;
|
|
|
|
case MidiEditResize:
|
|
current_canvas_cursor = midi_resize_cursor;
|
|
break;
|
|
|
|
case MidiEditErase:
|
|
current_canvas_cursor = midi_erase_cursor;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::button_selection (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
|
|
{
|
|
/* in object/audition/timefx/gain-automation 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 mouse operation is a
|
|
region alignment.
|
|
|
|
note: not dbl-click or triple-click
|
|
*/
|
|
|
|
if (((mouse_mode != MouseObject) &&
|
|
(mouse_mode != MouseAudition || item_type != RegionItem) &&
|
|
(mouse_mode != MouseTimeFX || item_type != RegionItem) &&
|
|
(mouse_mode != MouseGain) &&
|
|
(mouse_mode != MouseRange)) ||
|
|
|
|
((event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE) || event->button.button > 3)) {
|
|
|
|
return;
|
|
}
|
|
|
|
if (event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) {
|
|
|
|
if ((event->button.state & Keyboard::RelevantModifierKeyMask) && event->button.button != 1) {
|
|
|
|
/* almost no selection action on modified button-2 or button-3 events */
|
|
|
|
if (item_type != RegionItem && event->button.button != 2) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Selection::Operation op = Keyboard::selection_type (event->button.state);
|
|
bool press = (event->type == GDK_BUTTON_PRESS);
|
|
|
|
// begin_reversible_command (_("select on click"));
|
|
|
|
switch (item_type) {
|
|
case RegionItem:
|
|
if (mouse_mode != MouseRange) {
|
|
set_selected_regionview_from_click (press, op, true);
|
|
} else if (event->type == GDK_BUTTON_PRESS) {
|
|
set_selected_track_as_side_effect ();
|
|
}
|
|
break;
|
|
|
|
case RegionViewNameHighlight:
|
|
case RegionViewName:
|
|
if (mouse_mode != MouseRange) {
|
|
set_selected_regionview_from_click (press, op, true);
|
|
} else if (event->type == GDK_BUTTON_PRESS) {
|
|
set_selected_track_as_side_effect ();
|
|
}
|
|
break;
|
|
|
|
|
|
case FadeInHandleItem:
|
|
case FadeInItem:
|
|
case FadeOutHandleItem:
|
|
case FadeOutItem:
|
|
if (mouse_mode != MouseRange) {
|
|
set_selected_regionview_from_click (press, op, true);
|
|
} else if (event->type == GDK_BUTTON_PRESS) {
|
|
set_selected_track_as_side_effect ();
|
|
}
|
|
break;
|
|
|
|
case ControlPointItem:
|
|
set_selected_track_as_side_effect ();
|
|
if (mouse_mode != MouseRange) {
|
|
set_selected_control_point_from_click (op, false);
|
|
}
|
|
break;
|
|
|
|
case StreamItem:
|
|
/* for context click or range selection, select track */
|
|
if (event->button.button == 3) {
|
|
set_selected_track_as_side_effect ();
|
|
} else if (event->type == GDK_BUTTON_PRESS && mouse_mode == MouseRange) {
|
|
set_selected_track_as_side_effect ();
|
|
}
|
|
break;
|
|
|
|
case AutomationTrackItem:
|
|
set_selected_track_as_side_effect (true);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool
|
|
Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
|
|
{
|
|
Glib::RefPtr<Gdk::Window> canvas_window = const_cast<Editor*>(this)->track_canvas->get_window();
|
|
|
|
if (canvas_window) {
|
|
Glib::RefPtr<const Gdk::Window> pointer_window;
|
|
int x, y;
|
|
double wx, wy;
|
|
Gdk::ModifierType mask;
|
|
|
|
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);
|
|
allow_vertical_scroll = true;
|
|
} else {
|
|
allow_vertical_scroll = false;
|
|
}
|
|
}
|
|
|
|
track_canvas->grab_focus();
|
|
|
|
if (session && session->actively_recording()) {
|
|
return true;
|
|
}
|
|
|
|
button_selection (item, event, item_type);
|
|
|
|
if (drag_info.item == 0 &&
|
|
(Keyboard::is_delete_event (&event->button) ||
|
|
Keyboard::is_context_menu_event (&event->button) ||
|
|
Keyboard::is_edit_event (&event->button))) {
|
|
|
|
/* handled by button release */
|
|
return true;
|
|
}
|
|
|
|
switch (event->button.button) {
|
|
case 1:
|
|
|
|
if (event->type == GDK_BUTTON_PRESS) {
|
|
|
|
if (drag_info.item) {
|
|
drag_info.item->ungrab (event->button.time);
|
|
}
|
|
|
|
/* single mouse clicks on any of these item types operate
|
|
independent of mouse mode, mostly because they are
|
|
not on the main track canvas or because we want
|
|
them to be modeless.
|
|
*/
|
|
|
|
switch (item_type) {
|
|
case PlayheadCursorItem:
|
|
start_cursor_grab (item, event);
|
|
return true;
|
|
|
|
case MarkerItem:
|
|
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::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::CopyModifier)) {
|
|
start_meter_marker_copy_grab (item, event);
|
|
} else {
|
|
start_meter_marker_grab (item, event);
|
|
}
|
|
return true;
|
|
|
|
case MarkerBarItem:
|
|
case TempoBarItem:
|
|
case MeterBarItem:
|
|
if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
|
|
start_cursor_grab_no_stop(&playhead_cursor->canvas_item, event);
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
|
|
case RangeMarkerBarItem:
|
|
if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
|
|
start_cursor_grab_no_stop(&playhead_cursor->canvas_item, event);
|
|
} else {
|
|
start_range_markerbar_op (item, event, CreateRangeMarker);
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
case CdMarkerBarItem:
|
|
if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
|
|
start_cursor_grab_no_stop(&playhead_cursor->canvas_item, event);
|
|
} else {
|
|
start_range_markerbar_op (item, event, CreateCDMarker);
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
case TransportMarkerBarItem:
|
|
if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
|
|
start_cursor_grab_no_stop(&playhead_cursor->canvas_item, event);
|
|
} else {
|
|
start_range_markerbar_op (item, event, CreateTransportMarker);
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (mouse_mode) {
|
|
case MouseRange:
|
|
switch (item_type) {
|
|
case StartSelectionTrimItem:
|
|
start_selection_op (item, event, SelectionStartTrim);
|
|
break;
|
|
|
|
case EndSelectionTrimItem:
|
|
start_selection_op (item, event, SelectionEndTrim);
|
|
break;
|
|
|
|
case SelectionItem:
|
|
if (Keyboard::modifier_state_contains
|
|
(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::PrimaryModifier)) {
|
|
/* grab selection for moving */
|
|
start_selection_op (item, event, SelectionMove);
|
|
} else {
|
|
/* this was debated, but decided the more common action was to
|
|
make a new selection */
|
|
start_selection_op (item, event, CreateSelection);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
start_selection_op (item, event, CreateSelection);
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
case MouseObject:
|
|
if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier|Keyboard::SecondaryModifier)) &&
|
|
event->type == GDK_BUTTON_PRESS) {
|
|
|
|
start_rubberband_select (item, event);
|
|
|
|
} else if (event->type == GDK_BUTTON_PRESS) {
|
|
|
|
switch (item_type) {
|
|
case FadeInHandleItem:
|
|
start_fade_in_grab (item, event);
|
|
return true;
|
|
|
|
case FadeOutHandleItem:
|
|
start_fade_out_grab (item, event);
|
|
return true;
|
|
|
|
case RegionItem:
|
|
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);
|
|
} else {
|
|
start_region_grab (item, event);
|
|
}
|
|
break;
|
|
|
|
case RegionViewNameHighlight:
|
|
start_trim (item, event);
|
|
return true;
|
|
break;
|
|
|
|
case RegionViewName:
|
|
/* rename happens on edit clicks */
|
|
start_trim (clicked_regionview->get_name_highlight(), event);
|
|
return true;
|
|
break;
|
|
|
|
case ControlPointItem:
|
|
start_control_point_grab (item, event);
|
|
return true;
|
|
break;
|
|
|
|
case AutomationLineItem:
|
|
start_line_grab_from_line (item, event);
|
|
return true;
|
|
break;
|
|
|
|
case StreamItem:
|
|
case AutomationTrackItem:
|
|
start_rubberband_select (item, event);
|
|
break;
|
|
|
|
#ifdef WITH_CMT
|
|
case ImageFrameHandleStartItem:
|
|
imageframe_start_handle_op(item, event) ;
|
|
return(true) ;
|
|
break ;
|
|
case ImageFrameHandleEndItem:
|
|
imageframe_end_handle_op(item, event) ;
|
|
return(true) ;
|
|
break ;
|
|
case MarkerViewHandleStartItem:
|
|
markerview_item_start_handle_op(item, event) ;
|
|
return(true) ;
|
|
break ;
|
|
case MarkerViewHandleEndItem:
|
|
markerview_item_end_handle_op(item, event) ;
|
|
return(true) ;
|
|
break ;
|
|
case MarkerViewItem:
|
|
start_markerview_grab(item, event) ;
|
|
break ;
|
|
case ImageFrameItem:
|
|
start_imageframe_grab(item, event) ;
|
|
break ;
|
|
#endif
|
|
|
|
case MarkerBarItem:
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
case MouseGain:
|
|
switch (item_type) {
|
|
case RegionItem:
|
|
/* start a grab so that if we finish after moving
|
|
we can tell what happened.
|
|
*/
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::region_gain_motion_callback;
|
|
drag_info.finished_callback = 0;
|
|
start_grab (event, current_canvas_cursor);
|
|
break;
|
|
|
|
case GainLineItem:
|
|
start_line_grab_from_line (item, event);
|
|
return true;
|
|
|
|
case ControlPointItem:
|
|
start_control_point_grab (item, event);
|
|
return true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
switch (item_type) {
|
|
case ControlPointItem:
|
|
start_control_point_grab (item, event);
|
|
break;
|
|
|
|
case AutomationLineItem:
|
|
start_line_grab_from_line (item, event);
|
|
break;
|
|
|
|
case RegionItem:
|
|
// XXX need automation mode to identify which
|
|
// line to use
|
|
// start_line_grab_from_regionview (item, event);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
case MouseZoom:
|
|
if (event->type == GDK_BUTTON_PRESS) {
|
|
start_mouse_zoom (item, event);
|
|
}
|
|
|
|
return true;
|
|
break;
|
|
|
|
case MouseTimeFX:
|
|
if (item_type == RegionItem) {
|
|
start_time_fx (item, event);
|
|
}
|
|
break;
|
|
|
|
case MouseAudition:
|
|
_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;
|
|
|
|
case MouseNote:
|
|
start_create_region_grab (item, event);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
switch (mouse_mode) {
|
|
case MouseObject:
|
|
if (event->type == GDK_BUTTON_PRESS) {
|
|
switch (item_type) {
|
|
case RegionItem:
|
|
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 ControlPointItem:
|
|
start_control_point_grab (item, event);
|
|
return true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
switch (item_type) {
|
|
case RegionViewNameHighlight:
|
|
start_trim (item, event);
|
|
return true;
|
|
break;
|
|
|
|
case RegionViewName:
|
|
start_trim (clicked_regionview->get_name_highlight(), event);
|
|
return true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case MouseRange:
|
|
if (event->type == GDK_BUTTON_PRESS) {
|
|
/* relax till release */
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
|
|
case MouseZoom:
|
|
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
|
|
temporal_zoom_session();
|
|
} else {
|
|
temporal_zoom_to_frame (true, event_frame(event));
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case 3:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
|
|
{
|
|
nframes64_t where = event_frame (event, 0, 0);
|
|
AutomationTimeAxisView* atv = 0;
|
|
|
|
/* no action if we're recording */
|
|
|
|
if (session && session->actively_recording()) {
|
|
return true;
|
|
}
|
|
|
|
/* first, see if we're finishing a drag ... */
|
|
|
|
if (drag_info.item) {
|
|
if (end_grab (item, event)) {
|
|
/* grab dragged, so do nothing else */
|
|
return true;
|
|
}
|
|
}
|
|
|
|
button_selection (item, event, item_type);
|
|
|
|
/* edit events get handled here */
|
|
|
|
if (drag_info.item == 0 && Keyboard::is_edit_event (&event->button)) {
|
|
switch (item_type) {
|
|
case RegionItem:
|
|
edit_region ();
|
|
break;
|
|
|
|
case TempoMarkerItem:
|
|
edit_tempo_marker (item);
|
|
break;
|
|
|
|
case MeterMarkerItem:
|
|
edit_meter_marker (item);
|
|
break;
|
|
|
|
case RegionViewName:
|
|
if (clicked_regionview->name_active()) {
|
|
return mouse_rename_region (item, event);
|
|
}
|
|
break;
|
|
|
|
case ControlPointItem:
|
|
edit_control_point (item);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* context menu events get handled here */
|
|
|
|
if (Keyboard::is_context_menu_event (&event->button)) {
|
|
|
|
if (drag_info.item == 0) {
|
|
|
|
/* no matter which button pops up the context menu, tell the menu
|
|
widget to use button 1 to drive menu selection.
|
|
*/
|
|
|
|
switch (item_type) {
|
|
case FadeInItem:
|
|
case FadeInHandleItem:
|
|
case FadeOutItem:
|
|
case FadeOutHandleItem:
|
|
popup_fade_context_menu (1, event->button.time, item, item_type);
|
|
break;
|
|
|
|
case StreamItem:
|
|
popup_track_context_menu (1, event->button.time, item_type, false, where);
|
|
break;
|
|
|
|
case RegionItem:
|
|
case RegionViewNameHighlight:
|
|
case RegionViewName:
|
|
popup_track_context_menu (1, event->button.time, item_type, false, where);
|
|
break;
|
|
|
|
case SelectionItem:
|
|
popup_track_context_menu (1, event->button.time, item_type, true, where);
|
|
break;
|
|
|
|
case AutomationTrackItem:
|
|
popup_track_context_menu (1, event->button.time, item_type, false, where);
|
|
break;
|
|
|
|
case MarkerBarItem:
|
|
case RangeMarkerBarItem:
|
|
case TransportMarkerBarItem:
|
|
case CdMarkerBarItem:
|
|
case TempoBarItem:
|
|
case MeterBarItem:
|
|
popup_ruler_menu (pixel_to_frame(event->button.x), item_type);
|
|
break;
|
|
|
|
case MarkerItem:
|
|
marker_context_menu (&event->button, item);
|
|
break;
|
|
|
|
case TempoMarkerItem:
|
|
tm_marker_context_menu (&event->button, item);
|
|
break;
|
|
|
|
case MeterMarkerItem:
|
|
tm_marker_context_menu (&event->button, item);
|
|
break;
|
|
|
|
case CrossfadeViewItem:
|
|
popup_track_context_menu (1, event->button.time, item_type, false, where);
|
|
break;
|
|
|
|
#ifdef WITH_CMT
|
|
case ImageFrameItem:
|
|
popup_imageframe_edit_menu(1, event->button.time, item, true) ;
|
|
break ;
|
|
case ImageFrameTimeAxisItem:
|
|
popup_imageframe_edit_menu(1, event->button.time, item, false) ;
|
|
break ;
|
|
case MarkerViewItem:
|
|
popup_marker_time_axis_edit_menu(1, event->button.time, item, true) ;
|
|
break ;
|
|
case MarkerTimeAxisItem:
|
|
popup_marker_time_axis_edit_menu(1, event->button.time, item, false) ;
|
|
break ;
|
|
#endif
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/* delete events get handled here */
|
|
|
|
if (drag_info.item == 0 && Keyboard::is_delete_event (&event->button)) {
|
|
|
|
switch (item_type) {
|
|
case TempoMarkerItem:
|
|
remove_tempo_marker (item);
|
|
break;
|
|
|
|
case MeterMarkerItem:
|
|
remove_meter_marker (item);
|
|
break;
|
|
|
|
case MarkerItem:
|
|
remove_marker (*item, event);
|
|
break;
|
|
|
|
case RegionItem:
|
|
if (mouse_mode == MouseObject) {
|
|
remove_clicked_region ();
|
|
}
|
|
break;
|
|
|
|
case ControlPointItem:
|
|
if (mouse_mode == MouseGain) {
|
|
remove_gain_control_point (item, event);
|
|
} else {
|
|
remove_control_point (item, event);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
switch (event->button.button) {
|
|
case 1:
|
|
|
|
switch (item_type) {
|
|
/* see comments in button_press_handler */
|
|
case PlayheadCursorItem:
|
|
case MarkerItem:
|
|
case GainLineItem:
|
|
case AutomationLineItem:
|
|
case StartSelectionTrimItem:
|
|
case EndSelectionTrimItem:
|
|
return true;
|
|
|
|
case MarkerBarItem:
|
|
if (!_dragging_playhead) {
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (where, 0, true);
|
|
}
|
|
mouse_add_new_marker (where);
|
|
}
|
|
return true;
|
|
|
|
case CdMarkerBarItem:
|
|
if (!_dragging_playhead) {
|
|
// 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 (!_dragging_playhead) {
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (where);
|
|
}
|
|
mouse_add_new_tempo_event (where);
|
|
}
|
|
return true;
|
|
|
|
case MeterBarItem:
|
|
if (!_dragging_playhead) {
|
|
mouse_add_new_meter_event (pixel_to_frame (event->button.x));
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (mouse_mode) {
|
|
case MouseObject:
|
|
switch (item_type) {
|
|
case AutomationTrackItem:
|
|
atv = dynamic_cast<AutomationTimeAxisView*>(clicked_routeview);
|
|
if (atv) {
|
|
atv->add_automation_event (item, event, where, event->button.y);
|
|
}
|
|
return true;
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case MouseGain:
|
|
// Gain only makes sense for audio regions
|
|
|
|
if (!dynamic_cast<AudioRegionView*>(clicked_regionview)) {
|
|
break;
|
|
}
|
|
|
|
switch (item_type) {
|
|
case RegionItem:
|
|
/* check that we didn't drag before releasing, since
|
|
its really annoying to create new control
|
|
points when doing this.
|
|
*/
|
|
if (drag_info.first_move) {
|
|
dynamic_cast<AudioRegionView*>(clicked_regionview)->add_gain_point_event (item, event);
|
|
}
|
|
return true;
|
|
break;
|
|
|
|
case AutomationTrackItem:
|
|
dynamic_cast<AutomationTimeAxisView*>(clicked_axisview)->
|
|
add_automation_event (item, event, where, event->button.y);
|
|
return true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case MouseAudition:
|
|
_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;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
return true;
|
|
break;
|
|
|
|
|
|
case 2:
|
|
switch (mouse_mode) {
|
|
|
|
case MouseObject:
|
|
switch (item_type) {
|
|
case RegionItem:
|
|
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
|
|
raise_region ();
|
|
} else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::TertiaryModifier|Keyboard::SecondaryModifier))) {
|
|
lower_region ();
|
|
} else {
|
|
// Button2 click is unused
|
|
}
|
|
return true;
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case MouseRange:
|
|
|
|
// x_style_paste (where, 1.0);
|
|
return true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case 3:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
|
|
{
|
|
ControlPoint* cp;
|
|
Marker * marker;
|
|
double fraction;
|
|
|
|
if (last_item_entered != item) {
|
|
last_item_entered = item;
|
|
last_item_entered_n = 0;
|
|
}
|
|
|
|
switch (item_type) {
|
|
case ControlPointItem:
|
|
if (mouse_mode == MouseGain || mouse_mode == MouseObject) {
|
|
cp = static_cast<ControlPoint*>(item->get_data ("control_point"));
|
|
cp->set_visible (true);
|
|
|
|
double at_x, at_y;
|
|
at_x = cp->get_x();
|
|
at_y = cp->get_y ();
|
|
cp->item()->i2w (at_x, at_y);
|
|
at_x += 10.0;
|
|
at_y += 10.0;
|
|
|
|
fraction = 1.0 - (cp->get_y() / cp->line().height());
|
|
|
|
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;
|
|
|
|
case GainLineItem:
|
|
if (mouse_mode == MouseGain) {
|
|
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
|
|
if (line)
|
|
line->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_EnteredGainLine.get();
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*fader_cursor);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case AutomationLineItem:
|
|
if (mouse_mode == MouseGain || mouse_mode == MouseObject) {
|
|
{
|
|
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
|
|
if (line)
|
|
line->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_EnteredAutomationLine.get();
|
|
}
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*fader_cursor);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RegionViewNameHighlight:
|
|
if (is_drawable() && mouse_mode == MouseObject) {
|
|
track_canvas->get_window()->set_cursor (*trimmer_cursor);
|
|
}
|
|
break;
|
|
|
|
case StartSelectionTrimItem:
|
|
case EndSelectionTrimItem:
|
|
|
|
#ifdef WITH_CMT
|
|
case ImageFrameHandleStartItem:
|
|
case ImageFrameHandleEndItem:
|
|
case MarkerViewHandleStartItem:
|
|
case MarkerViewHandleEndItem:
|
|
#endif
|
|
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*trimmer_cursor);
|
|
}
|
|
break;
|
|
|
|
case PlayheadCursorItem:
|
|
if (is_drawable()) {
|
|
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 RegionViewName:
|
|
|
|
/* when the name is not an active item, the entire name highlight is for trimming */
|
|
|
|
if (!reinterpret_cast<RegionView *> (item->get_data ("regionview"))->name_active()) {
|
|
if (mouse_mode == MouseObject && is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*trimmer_cursor);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case AutomationTrackItem:
|
|
if (is_drawable()) {
|
|
Gdk::Cursor *cursor;
|
|
switch (mouse_mode) {
|
|
case MouseRange:
|
|
cursor = selector_cursor;
|
|
break;
|
|
case MouseZoom:
|
|
cursor = zoom_cursor;
|
|
break;
|
|
default:
|
|
cursor = cross_hair_cursor;
|
|
break;
|
|
}
|
|
|
|
track_canvas->get_window()->set_cursor (*cursor);
|
|
|
|
AutomationTimeAxisView* atv;
|
|
if ((atv = static_cast<AutomationTimeAxisView*>(item->get_data ("trackview"))) != 0) {
|
|
clear_entered_track = false;
|
|
set_entered_track (atv);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MarkerBarItem:
|
|
case RangeMarkerBarItem:
|
|
case TransportMarkerBarItem:
|
|
case CdMarkerBarItem:
|
|
case MeterBarItem:
|
|
case TempoBarItem:
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*timebar_cursor);
|
|
}
|
|
break;
|
|
|
|
case MarkerItem:
|
|
if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
|
|
break;
|
|
}
|
|
entered_marker = marker;
|
|
marker->set_color_rgba (ARDOUR_UI::config()->canvasvar_EnteredMarker.get());
|
|
// fall through
|
|
case MeterMarkerItem:
|
|
case TempoMarkerItem:
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*timebar_cursor);
|
|
}
|
|
break;
|
|
case FadeInHandleItem:
|
|
case FadeOutHandleItem:
|
|
if (mouse_mode == MouseObject) {
|
|
ArdourCanvas::SimpleRect *rect = dynamic_cast<ArdourCanvas::SimpleRect *> (item);
|
|
if (rect) {
|
|
rect->property_fill_color_rgba() = 0;
|
|
rect->property_outline_pixels() = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* second pass to handle entered track status in a comprehensible way.
|
|
*/
|
|
|
|
switch (item_type) {
|
|
case GainLineItem:
|
|
case AutomationLineItem:
|
|
case ControlPointItem:
|
|
/* these do not affect the current entered track state */
|
|
clear_entered_track = false;
|
|
break;
|
|
|
|
case AutomationTrackItem:
|
|
/* handled above already */
|
|
break;
|
|
|
|
default:
|
|
set_entered_track (0);
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
|
|
{
|
|
AutomationLine* al;
|
|
ControlPoint* cp;
|
|
Marker *marker;
|
|
Location *loc;
|
|
RegionView* rv;
|
|
bool is_start;
|
|
|
|
switch (item_type) {
|
|
case ControlPointItem:
|
|
cp = reinterpret_cast<ControlPoint*>(item->get_data ("control_point"));
|
|
if (cp->line().the_list()->interpolation() != AutomationList::Discrete) {
|
|
if (cp->line().npoints() > 1 && !cp->selected()) {
|
|
cp->set_visible (false);
|
|
}
|
|
}
|
|
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*current_canvas_cursor);
|
|
}
|
|
|
|
hide_verbose_canvas_cursor ();
|
|
break;
|
|
|
|
case RegionViewNameHighlight:
|
|
case StartSelectionTrimItem:
|
|
case EndSelectionTrimItem:
|
|
case PlayheadCursorItem:
|
|
|
|
#ifdef WITH_CMT
|
|
case ImageFrameHandleStartItem:
|
|
case ImageFrameHandleEndItem:
|
|
case MarkerViewHandleStartItem:
|
|
case MarkerViewHandleEndItem:
|
|
#endif
|
|
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*current_canvas_cursor);
|
|
}
|
|
break;
|
|
|
|
case GainLineItem:
|
|
case AutomationLineItem:
|
|
al = reinterpret_cast<AutomationLine*> (item->get_data ("line"));
|
|
{
|
|
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
|
|
if (line)
|
|
line->property_fill_color_rgba() = al->get_line_color();
|
|
}
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*current_canvas_cursor);
|
|
}
|
|
break;
|
|
|
|
case RegionViewName:
|
|
/* see enter_handler() for notes */
|
|
if (!reinterpret_cast<RegionView *> (item->get_data ("regionview"))->name_active()) {
|
|
if (is_drawable() && mouse_mode == MouseObject) {
|
|
track_canvas->get_window()->set_cursor (*current_canvas_cursor);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RangeMarkerBarItem:
|
|
case TransportMarkerBarItem:
|
|
case CdMarkerBarItem:
|
|
case MeterBarItem:
|
|
case TempoBarItem:
|
|
case MarkerBarItem:
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*current_canvas_cursor);
|
|
}
|
|
break;
|
|
|
|
case MarkerItem:
|
|
if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
|
|
break;
|
|
}
|
|
entered_marker = 0;
|
|
if ((loc = find_location_from_marker (marker, is_start)) != 0) {
|
|
location_flags_changed (loc, this);
|
|
}
|
|
// fall through
|
|
case MeterMarkerItem:
|
|
case TempoMarkerItem:
|
|
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*timebar_cursor);
|
|
}
|
|
|
|
break;
|
|
|
|
case FadeInHandleItem:
|
|
case FadeOutHandleItem:
|
|
rv = static_cast<RegionView*>(item->get_data ("regionview"));
|
|
{
|
|
ArdourCanvas::SimpleRect *rect = dynamic_cast<ArdourCanvas::SimpleRect *> (item);
|
|
if (rect) {
|
|
rect->property_fill_color_rgba() = rv->get_fill_color();
|
|
rect->property_outline_pixels() = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case AutomationTrackItem:
|
|
if (is_drawable()) {
|
|
track_canvas->get_window()->set_cursor (*current_canvas_cursor);
|
|
clear_entered_track = true;
|
|
Glib::signal_idle().connect (mem_fun(*this, &Editor::left_automation_track));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
gint
|
|
Editor::left_automation_track ()
|
|
{
|
|
if (clear_entered_track) {
|
|
set_entered_track (0);
|
|
clear_entered_track = false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
Editor::scrub ()
|
|
{
|
|
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;
|
|
}
|
|
|
|
bool
|
|
Editor::motion_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type, bool from_autoscroll)
|
|
{
|
|
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 */
|
|
current_stepping_trackview = 0;
|
|
step_timeout.disconnect ();
|
|
}
|
|
|
|
if (session && session->actively_recording()) {
|
|
/* Sorry. no dragging stuff around while we record */
|
|
return true;
|
|
}
|
|
|
|
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) {
|
|
scrub ();
|
|
}
|
|
break;
|
|
|
|
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 = (::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
|
|
|
|
if (drag_info.want_move_threshold && drag_info.move_threshold_passed) {
|
|
drag_info.grab_frame = drag_info.current_pointer_frame;
|
|
drag_info.grab_x = drag_info.current_pointer_x;
|
|
drag_info.grab_y = drag_info.current_pointer_y;
|
|
drag_info.last_pointer_frame = drag_info.grab_frame;
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (item_type) {
|
|
case PlayheadCursorItem:
|
|
case MarkerItem:
|
|
case ControlPointItem:
|
|
case MarkerBarItem:
|
|
case TempoBarItem:
|
|
case MeterBarItem:
|
|
case RangeMarkerBarItem:
|
|
case TransportMarkerBarItem:
|
|
case CdMarkerBarItem:
|
|
case TempoMarkerItem:
|
|
case MeterMarkerItem:
|
|
case RegionViewNameHighlight:
|
|
case StartSelectionTrimItem:
|
|
case EndSelectionTrimItem:
|
|
case SelectionItem:
|
|
case GainLineItem:
|
|
case AutomationLineItem:
|
|
case FadeInHandleItem:
|
|
case FadeOutHandleItem:
|
|
|
|
#ifdef WITH_CMT
|
|
case ImageFrameHandleStartItem:
|
|
case ImageFrameHandleEndItem:
|
|
case MarkerViewHandleStartItem:
|
|
case MarkerViewHandleEndItem:
|
|
#endif
|
|
|
|
if (drag_info.item && (event->motion.state & Gdk::BUTTON1_MASK ||
|
|
(event->motion.state & Gdk::BUTTON2_MASK))) {
|
|
if (!from_autoscroll) {
|
|
maybe_autoscroll_horizontally (&event->motion);
|
|
}
|
|
if (drag_info.motion_callback) {
|
|
(this->*(drag_info.motion_callback)) (item, event);
|
|
}
|
|
goto handled;
|
|
}
|
|
goto not_handled;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (mouse_mode) {
|
|
case MouseGain:
|
|
if (item_type == RegionItem) {
|
|
if (drag_info.item && drag_info.motion_callback) {
|
|
(this->*(drag_info.motion_callback)) (item, event);
|
|
}
|
|
goto handled;
|
|
}
|
|
break;
|
|
|
|
case MouseObject:
|
|
case MouseRange:
|
|
case MouseZoom:
|
|
case MouseTimeFX:
|
|
case MouseNote:
|
|
if (drag_info.item && (event->motion.state & GDK_BUTTON1_MASK ||
|
|
(event->motion.state & GDK_BUTTON2_MASK))) {
|
|
if (!from_autoscroll) {
|
|
maybe_autoscroll (&event->motion);
|
|
}
|
|
if (drag_info.motion_callback) {
|
|
(this->*(drag_info.motion_callback)) (item, event);
|
|
}
|
|
goto handled;
|
|
}
|
|
goto not_handled;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
handled:
|
|
track_canvas_motion (event);
|
|
// drag_info.last_pointer_frame = drag_info.current_pointer_frame;
|
|
return true;
|
|
|
|
not_handled:
|
|
return false;
|
|
}
|
|
|
|
void
|
|
Editor::break_drag ()
|
|
{
|
|
stop_canvas_autoscroll ();
|
|
hide_verbose_canvas_cursor ();
|
|
|
|
if (drag_info.item) {
|
|
drag_info.item->ungrab (0);
|
|
|
|
/* put it back where it came from */
|
|
|
|
double cxw, cyw;
|
|
cxw = 0;
|
|
cyw = 0;
|
|
drag_info.item->i2w (cxw, cyw);
|
|
drag_info.item->move (drag_info.original_x - cxw, drag_info.original_y - cyw);
|
|
}
|
|
|
|
finalize_drag ();
|
|
}
|
|
|
|
void
|
|
Editor::finalize_drag ()
|
|
{
|
|
drag_info.item = 0;
|
|
drag_info.copy = false;
|
|
drag_info.motion_callback = 0;
|
|
drag_info.finished_callback = 0;
|
|
drag_info.dest_trackview = 0;
|
|
drag_info.source_trackview = 0;
|
|
drag_info.last_frame_position = 0;
|
|
drag_info.grab_frame = 0;
|
|
drag_info.last_pointer_frame = 0;
|
|
drag_info.current_pointer_frame = 0;
|
|
drag_info.brushing = false;
|
|
range_marker_drag_rect->hide();
|
|
drag_info.clear_copied_locations ();
|
|
}
|
|
|
|
void
|
|
Editor::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
|
|
{
|
|
if (drag_info.item == 0) {
|
|
fatal << _("programming error: start_grab called without drag item") << endmsg;
|
|
/*NOTREACHED*/
|
|
return;
|
|
}
|
|
|
|
if (cursor == 0) {
|
|
cursor = which_grabber_cursor ();
|
|
}
|
|
|
|
// if dragging with button2, the motion is x constrained, with Alt-button2 it is y constrained
|
|
|
|
if (Keyboard::is_button2_event (&event->button)) {
|
|
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.x_constrained = true;
|
|
}
|
|
} else {
|
|
drag_info.x_constrained = false;
|
|
drag_info.y_constrained = false;
|
|
}
|
|
|
|
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.move_threshold_passed = false;
|
|
drag_info.want_move_threshold = false;
|
|
drag_info.pointer_frame_offset = 0;
|
|
drag_info.brushing = false;
|
|
drag_info.clear_copied_locations ();
|
|
|
|
drag_info.original_x = 0;
|
|
drag_info.original_y = 0;
|
|
drag_info.item->i2w (drag_info.original_x, drag_info.original_y);
|
|
|
|
drag_info.item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK,
|
|
*cursor,
|
|
event->button.time);
|
|
|
|
if (session && session->transport_rolling()) {
|
|
drag_info.was_rolling = true;
|
|
} else {
|
|
drag_info.was_rolling = false;
|
|
}
|
|
|
|
switch (snap_type) {
|
|
case SnapToRegionStart:
|
|
case SnapToRegionEnd:
|
|
case SnapToRegionSync:
|
|
case SnapToRegionBoundary:
|
|
build_region_boundary_cache ();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::swap_grab (ArdourCanvas::Item* new_item, Gdk::Cursor* cursor, uint32_t time)
|
|
{
|
|
drag_info.item->ungrab (0);
|
|
drag_info.item = new_item;
|
|
|
|
if (cursor == 0) {
|
|
cursor = which_grabber_cursor ();
|
|
}
|
|
|
|
drag_info.item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK, *cursor, time);
|
|
}
|
|
|
|
/** @param item Canvas item
|
|
* @param event GDK event, or 0.
|
|
*/
|
|
bool
|
|
Editor::end_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
bool did_drag = false;
|
|
|
|
stop_canvas_autoscroll ();
|
|
|
|
if (drag_info.item == 0) {
|
|
return false;
|
|
}
|
|
|
|
drag_info.item->ungrab (event ? event->button.time : 0);
|
|
|
|
if (drag_info.finished_callback && event) {
|
|
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);
|
|
}
|
|
|
|
did_drag = !drag_info.first_move;
|
|
|
|
hide_verbose_canvas_cursor();
|
|
|
|
finalize_drag ();
|
|
|
|
return did_drag;
|
|
}
|
|
|
|
void
|
|
Editor::region_gain_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (drag_info.first_move && drag_info.move_threshold_passed) {
|
|
drag_info.first_move = false;
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::start_fade_in_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::fade_in_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::fade_in_drag_finished_callback;
|
|
|
|
start_grab (event);
|
|
|
|
if ((drag_info.data = (item->get_data ("regionview"))) == 0) {
|
|
fatal << _("programming error: fade in canvas item has no regionview data pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
|
|
|
|
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - ((nframes64_t) arv->audio_region()->fade_in()->back()->when + arv->region()->position());
|
|
}
|
|
|
|
void
|
|
Editor::fade_in_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
|
|
nframes64_t pos;
|
|
nframes64_t fade_length;
|
|
|
|
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;
|
|
}
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (pos);
|
|
}
|
|
|
|
if (pos < (arv->region()->position() + 64)) {
|
|
fade_length = 64; // this should be a minimum defined somewhere
|
|
} else if (pos > arv->region()->last_frame()) {
|
|
fade_length = arv->region()->length();
|
|
} else {
|
|
fade_length = pos - arv->region()->position();
|
|
}
|
|
/* mapover the region selection */
|
|
|
|
for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
|
|
|
|
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*i);
|
|
|
|
if (!tmp) {
|
|
continue;
|
|
}
|
|
|
|
tmp->reset_fade_in_shape_width (fade_length);
|
|
}
|
|
|
|
show_verbose_duration_cursor (arv->region()->position(), arv->region()->position() + fade_length, 10);
|
|
|
|
drag_info.first_move = false;
|
|
}
|
|
|
|
void
|
|
Editor::fade_in_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
|
|
nframes64_t pos;
|
|
nframes64_t fade_length;
|
|
|
|
if (drag_info.first_move) return;
|
|
|
|
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;
|
|
}
|
|
|
|
if (pos < (arv->region()->position() + 64)) {
|
|
fade_length = 64; // this should be a minimum defined somewhere
|
|
} else if (pos > arv->region()->last_frame()) {
|
|
fade_length = arv->region()->length();
|
|
} else {
|
|
fade_length = pos - arv->region()->position();
|
|
}
|
|
|
|
begin_reversible_command (_("change fade in length"));
|
|
|
|
for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
|
|
|
|
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*i);
|
|
|
|
if (!tmp) {
|
|
continue;
|
|
}
|
|
|
|
boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_in();
|
|
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.get(), &before, &after));
|
|
}
|
|
|
|
commit_reversible_command ();
|
|
}
|
|
|
|
void
|
|
Editor::start_fade_out_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::fade_out_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::fade_out_drag_finished_callback;
|
|
|
|
start_grab (event);
|
|
|
|
if ((drag_info.data = (item->get_data ("regionview"))) == 0) {
|
|
fatal << _("programming error: fade out canvas item has no regionview data pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
|
|
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - (arv->region()->length() - (nframes64_t) arv->audio_region()->fade_out()->back()->when + arv->region()->position());
|
|
}
|
|
|
|
void
|
|
Editor::fade_out_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
|
|
nframes64_t pos;
|
|
nframes64_t fade_length;
|
|
|
|
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;
|
|
}
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (pos);
|
|
}
|
|
|
|
if (pos > (arv->region()->last_frame() - 64)) {
|
|
fade_length = 64; // this should really be a minimum fade defined somewhere
|
|
}
|
|
else if (pos < arv->region()->position()) {
|
|
fade_length = arv->region()->length();
|
|
}
|
|
else {
|
|
fade_length = arv->region()->last_frame() - pos;
|
|
}
|
|
|
|
/* mapover the region selection */
|
|
|
|
for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
|
|
|
|
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*i);
|
|
|
|
if (!tmp) {
|
|
continue;
|
|
}
|
|
|
|
tmp->reset_fade_out_shape_width (fade_length);
|
|
}
|
|
|
|
show_verbose_duration_cursor (arv->region()->last_frame() - fade_length, arv->region()->last_frame(), 10);
|
|
|
|
drag_info.first_move = false;
|
|
}
|
|
|
|
void
|
|
Editor::fade_out_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (drag_info.first_move) return;
|
|
|
|
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
|
|
nframes64_t pos;
|
|
nframes64_t fade_length;
|
|
|
|
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;
|
|
}
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (pos);
|
|
}
|
|
|
|
if (pos > (arv->region()->last_frame() - 64)) {
|
|
fade_length = 64; // this should really be a minimum fade defined somewhere
|
|
}
|
|
else if (pos < arv->region()->position()) {
|
|
fade_length = arv->region()->length();
|
|
}
|
|
else {
|
|
fade_length = arv->region()->last_frame() - pos;
|
|
}
|
|
|
|
begin_reversible_command (_("change fade out length"));
|
|
|
|
for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
|
|
|
|
AudioRegionView* tmp = dynamic_cast<AudioRegionView*> (*i);
|
|
|
|
if (!tmp) {
|
|
continue;
|
|
}
|
|
|
|
boost::shared_ptr<AutomationList> alist = tmp->audio_region()->fade_out();
|
|
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.get(), &before, &after));
|
|
}
|
|
|
|
commit_reversible_command ();
|
|
}
|
|
|
|
void
|
|
Editor::start_cursor_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::cursor_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::cursor_drag_finished_callback;
|
|
|
|
start_grab (event);
|
|
|
|
if ((drag_info.data = (item->get_data ("cursor"))) == 0) {
|
|
fatal << _("programming error: cursor canvas item has no cursor data pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
Cursor* cursor = (Cursor *) drag_info.data;
|
|
|
|
if (cursor == playhead_cursor) {
|
|
_dragging_playhead = true;
|
|
|
|
if (session && drag_info.was_rolling) {
|
|
session->request_stop ();
|
|
}
|
|
|
|
if (session && session->is_auditioning()) {
|
|
session->cancel_audition ();
|
|
}
|
|
}
|
|
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - cursor->current_frame;
|
|
|
|
show_verbose_time_cursor (cursor->current_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::start_cursor_grab_no_stop (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::cursor_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::cursor_drag_finished_ensure_locate_callback;
|
|
|
|
start_grab (event);
|
|
|
|
if ((drag_info.data = (item->get_data ("cursor"))) == 0) {
|
|
fatal << _("programming error: cursor canvas item has no cursor data pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
Cursor* cursor = (Cursor *) drag_info.data;
|
|
nframes64_t where = event_frame (event, 0, 0);
|
|
|
|
snap_to(where);
|
|
playhead_cursor->set_position (where);
|
|
|
|
if (cursor == playhead_cursor) {
|
|
_dragging_playhead = true;
|
|
|
|
if (session && session->is_auditioning()) {
|
|
session->cancel_audition ();
|
|
}
|
|
}
|
|
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - cursor->current_frame;
|
|
|
|
show_verbose_time_cursor (cursor->current_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::cursor_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
Cursor* cursor = (Cursor *) drag_info.data;
|
|
nframes64_t adjusted_frame;
|
|
|
|
if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
|
|
adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
|
|
}
|
|
else {
|
|
adjusted_frame = 0;
|
|
}
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
if (cursor == playhead_cursor) {
|
|
snap_to (adjusted_frame);
|
|
}
|
|
}
|
|
|
|
if (adjusted_frame == drag_info.last_pointer_frame) return;
|
|
|
|
cursor->set_position (adjusted_frame);
|
|
|
|
show_verbose_time_cursor (cursor->current_frame, 10);
|
|
|
|
#ifdef GTKOSX
|
|
track_canvas->update_now ();
|
|
#endif
|
|
UpdateAllTransportClocks (cursor->current_frame);
|
|
|
|
drag_info.last_pointer_frame = adjusted_frame;
|
|
drag_info.first_move = false;
|
|
}
|
|
|
|
void
|
|
Editor::cursor_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
_dragging_playhead = false;
|
|
|
|
if (drag_info.first_move) {
|
|
return;
|
|
}
|
|
|
|
cursor_drag_motion_callback (item, event);
|
|
|
|
if (item == &playhead_cursor->canvas_item) {
|
|
if (session) {
|
|
session->request_locate (playhead_cursor->current_frame, drag_info.was_rolling);
|
|
_pending_locate_request = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::cursor_drag_finished_ensure_locate_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
_dragging_playhead = false;
|
|
|
|
cursor_drag_motion_callback (item, event);
|
|
|
|
if (item == &playhead_cursor->canvas_item) {
|
|
if (session) {
|
|
session->request_locate (playhead_cursor->current_frame, drag_info.was_rolling);
|
|
_pending_locate_request = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::update_marker_drag_item (Location *location)
|
|
{
|
|
double x1 = frame_to_pixel (location->start());
|
|
double x2 = frame_to_pixel (location->end());
|
|
|
|
if (location->is_mark()) {
|
|
marker_drag_line_points.front().set_x(x1);
|
|
marker_drag_line_points.back().set_x(x1);
|
|
marker_drag_line->property_points() = marker_drag_line_points;
|
|
} else {
|
|
range_marker_drag_rect->property_x1() = x1;
|
|
range_marker_drag_rect->property_x2() = x2;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
Editor::start_marker_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
Marker* marker;
|
|
|
|
if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
|
|
fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
bool is_start;
|
|
|
|
Location *location = find_location_from_marker (marker, is_start);
|
|
|
|
drag_info.item = item;
|
|
drag_info.data = marker;
|
|
drag_info.motion_callback = &Editor::marker_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::marker_drag_finished_callback;
|
|
|
|
start_grab (event);
|
|
|
|
_dragging_edit_point = true;
|
|
|
|
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 {
|
|
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);
|
|
}
|
|
|
|
Selection::Operation op = Keyboard::selection_type (event->button.state);
|
|
|
|
switch (op) {
|
|
case Selection::Toggle:
|
|
selection->toggle (marker);
|
|
break;
|
|
case Selection::Set:
|
|
if (!selection->selected (marker)) {
|
|
selection->set (marker);
|
|
}
|
|
break;
|
|
case Selection::Extend:
|
|
{
|
|
Locations::LocationList ll;
|
|
list<Marker*> to_add;
|
|
nframes64_t s, e;
|
|
selection->markers.range (s, e);
|
|
s = min (marker->position(), s);
|
|
e = max (marker->position(), e);
|
|
s = min (s, e);
|
|
e = max (s, e);
|
|
if (e < max_frames) {
|
|
++e;
|
|
}
|
|
session->locations()->find_all_between (s, e, ll, Location::Flags (0));
|
|
for (Locations::LocationList::iterator i = ll.begin(); i != ll.end(); ++i) {
|
|
LocationMarkers* lm = find_location_markers (*i);
|
|
if (lm) {
|
|
if (lm->start) {
|
|
to_add.push_back (lm->start);
|
|
}
|
|
if (lm->end) {
|
|
to_add.push_back (lm->end);
|
|
}
|
|
}
|
|
}
|
|
if (!to_add.empty()) {
|
|
selection->add (to_add);
|
|
}
|
|
break;
|
|
}
|
|
case Selection::Add:
|
|
selection->add (marker);
|
|
break;
|
|
}
|
|
|
|
/* set up copies for us to manipulate during the drag */
|
|
|
|
drag_info.clear_copied_locations ();
|
|
|
|
for (MarkerSelection::iterator i = selection->markers.begin(); i != selection->markers.end(); ++i) {
|
|
Location *l = find_location_from_marker (*i, is_start);
|
|
drag_info.copied_locations.push_back (new Location (*l));
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::marker_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
nframes64_t f_delta = 0;
|
|
nframes64_t newframe;
|
|
bool is_start;
|
|
bool move_both = false;
|
|
Marker* dragged_marker = (Marker*) drag_info.data;
|
|
Marker* marker;
|
|
Location *real_location;
|
|
Location *copy_location = 0;
|
|
|
|
if (drag_info.pointer_frame_offset <= drag_info.current_pointer_frame) {
|
|
newframe = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
|
|
} else {
|
|
newframe = 0;
|
|
}
|
|
|
|
nframes64_t next = newframe;
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (newframe, 0, true);
|
|
}
|
|
|
|
if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) {
|
|
return;
|
|
}
|
|
|
|
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
|
|
move_both = true;
|
|
}
|
|
|
|
MarkerSelection::iterator i;
|
|
list<Location*>::iterator x;
|
|
|
|
/* find the marker we're dragging, and compute the delta */
|
|
|
|
for (i = selection->markers.begin(), x = drag_info.copied_locations.begin();
|
|
x != drag_info.copied_locations.end() && i != selection->markers.end();
|
|
++i, ++x) {
|
|
|
|
copy_location = *x;
|
|
marker = *i;
|
|
|
|
if (marker == dragged_marker) {
|
|
|
|
if ((real_location = find_location_from_marker (marker, is_start)) == 0) {
|
|
/* que pasa ?? */
|
|
return;
|
|
}
|
|
|
|
if (real_location->is_mark()) {
|
|
f_delta = newframe - copy_location->start();
|
|
} else {
|
|
|
|
|
|
switch (marker->type()) {
|
|
case Marker::Start:
|
|
case Marker::LoopStart:
|
|
case Marker::PunchIn:
|
|
f_delta = newframe - copy_location->start();
|
|
break;
|
|
|
|
case Marker::End:
|
|
case Marker::LoopEnd:
|
|
case Marker::PunchOut:
|
|
f_delta = newframe - copy_location->end();
|
|
break;
|
|
default:
|
|
/* what kind of marker is this ? */
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == selection->markers.end()) {
|
|
/* hmm, impossible - we didn't find the dragged marker */
|
|
return;
|
|
}
|
|
|
|
/* now move them all */
|
|
|
|
for (i = selection->markers.begin(), x = drag_info.copied_locations.begin();
|
|
x != drag_info.copied_locations.end() && i != selection->markers.end();
|
|
++i, ++x) {
|
|
|
|
copy_location = *x;
|
|
marker = *i;
|
|
|
|
/* call this to find out if its the start or end */
|
|
|
|
if ((real_location = find_location_from_marker (marker, is_start)) == 0) {
|
|
continue;
|
|
}
|
|
|
|
if (real_location->locked()) {
|
|
continue;
|
|
}
|
|
|
|
if (copy_location->is_mark()) {
|
|
|
|
/* just move it */
|
|
|
|
copy_location->set_start (copy_location->start() + f_delta);
|
|
|
|
} else {
|
|
|
|
nframes64_t new_start = copy_location->start() + f_delta;
|
|
nframes64_t new_end = copy_location->end() + f_delta;
|
|
|
|
if (is_start) { // start-of-range marker
|
|
|
|
if (move_both) {
|
|
copy_location->set_start (new_start);
|
|
copy_location->set_end (new_end);
|
|
} else if (new_start < copy_location->end()) {
|
|
copy_location->set_start (new_start);
|
|
} else {
|
|
snap_to (next, 1, true);
|
|
copy_location->set_end (next);
|
|
copy_location->set_start (newframe);
|
|
}
|
|
|
|
} else { // end marker
|
|
|
|
if (move_both) {
|
|
copy_location->set_end (new_end);
|
|
copy_location->set_start (new_start);
|
|
} else if (new_end > copy_location->start()) {
|
|
copy_location->set_end (new_end);
|
|
} else if (newframe > 0) {
|
|
snap_to (next, -1, true);
|
|
copy_location->set_start (next);
|
|
copy_location->set_end (newframe);
|
|
}
|
|
}
|
|
}
|
|
update_marker_drag_item (copy_location);
|
|
|
|
LocationMarkers* lm = find_location_markers (real_location);
|
|
|
|
if (lm) {
|
|
lm->set_position (copy_location->start(), copy_location->end());
|
|
}
|
|
}
|
|
|
|
drag_info.last_pointer_frame = drag_info.current_pointer_frame;
|
|
drag_info.first_move = false;
|
|
|
|
if (drag_info.copied_locations.empty()) {
|
|
abort();
|
|
}
|
|
|
|
edit_point_clock.set (drag_info.copied_locations.front()->start());
|
|
show_verbose_time_cursor (newframe, 10);
|
|
|
|
#ifdef GTKOSX
|
|
track_canvas->update_now ();
|
|
#endif
|
|
edit_point_clock.set (copy_location->start());
|
|
}
|
|
|
|
void
|
|
Editor::marker_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (drag_info.first_move) {
|
|
|
|
/* just a click, do nothing but finish
|
|
off the selection process
|
|
*/
|
|
|
|
Selection::Operation op = Keyboard::selection_type (event->button.state);
|
|
Marker* marker = (Marker *) drag_info.data;
|
|
|
|
switch (op) {
|
|
case Selection::Set:
|
|
if (selection->selected (marker) && selection->markers.size() > 1) {
|
|
selection->set (marker);
|
|
}
|
|
break;
|
|
|
|
case Selection::Toggle:
|
|
case Selection::Extend:
|
|
case Selection::Add:
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
_dragging_edit_point = false;
|
|
|
|
|
|
begin_reversible_command ( _("move marker") );
|
|
XMLNode &before = session->locations()->get_state();
|
|
|
|
MarkerSelection::iterator i;
|
|
list<Location*>::iterator x;
|
|
bool is_start;
|
|
|
|
for (i = selection->markers.begin(), x = drag_info.copied_locations.begin();
|
|
x != drag_info.copied_locations.end() && i != selection->markers.end();
|
|
++i, ++x) {
|
|
|
|
Location * location = find_location_from_marker ((*i), is_start);
|
|
|
|
if (location) {
|
|
|
|
if (location->locked()) {
|
|
return;
|
|
}
|
|
|
|
if (location->is_mark()) {
|
|
location->set_start ((*x)->start());
|
|
} else {
|
|
location->set ((*x)->start(), (*x)->end());
|
|
}
|
|
}
|
|
}
|
|
|
|
XMLNode &after = session->locations()->get_state();
|
|
session->add_command(new MementoCommand<Locations>(*(session->locations()), &before, &after));
|
|
commit_reversible_command ();
|
|
|
|
marker_drag_line->hide();
|
|
range_marker_drag_rect->hide();
|
|
}
|
|
|
|
void
|
|
Editor::start_meter_marker_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
Marker* marker;
|
|
MeterMarker* meter_marker;
|
|
|
|
if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
|
|
fatal << _("programming error: meter marker canvas item has no marker object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
meter_marker = dynamic_cast<MeterMarker*> (marker);
|
|
|
|
MetricSection& section (meter_marker->meter());
|
|
|
|
if (!section.movable()) {
|
|
return;
|
|
}
|
|
|
|
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;
|
|
|
|
start_grab (event);
|
|
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - meter_marker->meter().frame();
|
|
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::start_meter_marker_copy_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
Marker* marker;
|
|
MeterMarker* meter_marker;
|
|
|
|
if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
|
|
fatal << _("programming error: meter marker canvas item has no marker object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
meter_marker = dynamic_cast<MeterMarker*> (marker);
|
|
|
|
// create a dummy marker for visual representation of moving the copy.
|
|
// 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, ARDOUR_UI::config()->canvasvar_MeterMarker.get(), name,
|
|
*new MeterSection(meter_marker->meter()));
|
|
|
|
drag_info.item = &new_marker->the_item();
|
|
drag_info.copy = true;
|
|
drag_info.data = new_marker;
|
|
drag_info.motion_callback = &Editor::meter_marker_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::meter_marker_drag_finished_callback;
|
|
|
|
start_grab (event);
|
|
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - meter_marker->meter().frame();
|
|
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::meter_marker_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
MeterMarker* marker = (MeterMarker *) drag_info.data;
|
|
nframes64_t adjusted_frame;
|
|
|
|
if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
|
|
adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
|
|
}
|
|
else {
|
|
adjusted_frame = 0;
|
|
}
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (adjusted_frame);
|
|
}
|
|
|
|
if (adjusted_frame == drag_info.last_pointer_frame) return;
|
|
|
|
marker->set_position (adjusted_frame);
|
|
|
|
|
|
drag_info.last_pointer_frame = adjusted_frame;
|
|
drag_info.first_move = false;
|
|
|
|
show_verbose_time_cursor (adjusted_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::meter_marker_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (drag_info.first_move) return;
|
|
|
|
meter_marker_drag_motion_callback (drag_info.item, event);
|
|
|
|
MeterMarker* marker = (MeterMarker *) drag_info.data;
|
|
BBT_Time when;
|
|
|
|
TempoMap& map (session->tempo_map());
|
|
map.bbt_time (drag_info.last_pointer_frame, when);
|
|
|
|
if (drag_info.copy == true) {
|
|
begin_reversible_command (_("copy meter mark"));
|
|
XMLNode &before = map.get_state();
|
|
map.add_meter (marker->meter(), when);
|
|
XMLNode &after = map.get_state();
|
|
session->add_command(new MementoCommand<TempoMap>(map, &before, &after));
|
|
commit_reversible_command ();
|
|
|
|
// delete the dummy marker we used for visual representation of copying.
|
|
// a new visual marker will show up automatically.
|
|
delete marker;
|
|
} else {
|
|
begin_reversible_command (_("move meter mark"));
|
|
XMLNode &before = map.get_state();
|
|
map.move_meter (marker->meter(), when);
|
|
XMLNode &after = map.get_state();
|
|
session->add_command(new MementoCommand<TempoMap>(map, &before, &after));
|
|
commit_reversible_command ();
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::start_tempo_marker_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
Marker* marker;
|
|
TempoMarker* tempo_marker;
|
|
|
|
if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
|
|
fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
if ((tempo_marker = dynamic_cast<TempoMarker *> (marker)) == 0) {
|
|
fatal << _("programming error: marker for tempo is not a tempo marker!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
MetricSection& section (tempo_marker->tempo());
|
|
|
|
if (!section.movable()) {
|
|
return;
|
|
}
|
|
|
|
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;
|
|
|
|
start_grab (event);
|
|
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - tempo_marker->tempo().frame();
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::start_tempo_marker_copy_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
Marker* marker;
|
|
TempoMarker* tempo_marker;
|
|
|
|
if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
|
|
fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
if ((tempo_marker = dynamic_cast<TempoMarker *> (marker)) == 0) {
|
|
fatal << _("programming error: marker for tempo is not a tempo marker!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
// create a dummy marker for visual representation of moving the copy.
|
|
// 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, ARDOUR_UI::config()->canvasvar_TempoMarker.get(), name,
|
|
*new TempoSection(tempo_marker->tempo()));
|
|
|
|
drag_info.item = &new_marker->the_item();
|
|
drag_info.copy = true;
|
|
drag_info.data = new_marker;
|
|
drag_info.motion_callback = &Editor::tempo_marker_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::tempo_marker_drag_finished_callback;
|
|
|
|
start_grab (event);
|
|
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - tempo_marker->tempo().frame();
|
|
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::tempo_marker_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
TempoMarker* marker = (TempoMarker *) drag_info.data;
|
|
nframes64_t adjusted_frame;
|
|
|
|
if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
|
|
adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
|
|
}
|
|
else {
|
|
adjusted_frame = 0;
|
|
}
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (adjusted_frame);
|
|
}
|
|
|
|
if (adjusted_frame == drag_info.last_pointer_frame) return;
|
|
|
|
/* OK, we've moved far enough to make it worth actually move the thing. */
|
|
|
|
marker->set_position (adjusted_frame);
|
|
|
|
show_verbose_time_cursor (adjusted_frame, 10);
|
|
|
|
drag_info.last_pointer_frame = adjusted_frame;
|
|
drag_info.first_move = false;
|
|
}
|
|
|
|
void
|
|
Editor::tempo_marker_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (drag_info.first_move) return;
|
|
|
|
tempo_marker_drag_motion_callback (drag_info.item, event);
|
|
|
|
TempoMarker* marker = (TempoMarker *) drag_info.data;
|
|
BBT_Time when;
|
|
|
|
TempoMap& map (session->tempo_map());
|
|
map.bbt_time (drag_info.last_pointer_frame, when);
|
|
|
|
if (drag_info.copy == true) {
|
|
begin_reversible_command (_("copy tempo mark"));
|
|
XMLNode &before = map.get_state();
|
|
map.add_tempo (marker->tempo(), when);
|
|
XMLNode &after = map.get_state();
|
|
session->add_command (new MementoCommand<TempoMap>(map, &before, &after));
|
|
commit_reversible_command ();
|
|
|
|
// delete the dummy marker we used for visual representation of copying.
|
|
// a new visual marker will show up automatically.
|
|
delete marker;
|
|
} else {
|
|
begin_reversible_command (_("move tempo mark"));
|
|
XMLNode &before = map.get_state();
|
|
map.move_tempo (marker->tempo(), when);
|
|
XMLNode &after = map.get_state();
|
|
session->add_command (new MementoCommand<TempoMap>(map, &before, &after));
|
|
commit_reversible_command ();
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::remove_gain_control_point (ArdourCanvas::Item*item, GdkEvent* event)
|
|
{
|
|
ControlPoint* control_point;
|
|
|
|
if ((control_point = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"))) == 0) {
|
|
fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
// We shouldn't remove the first or last gain point
|
|
if (control_point->line().is_last_point(*control_point) ||
|
|
control_point->line().is_first_point(*control_point)) {
|
|
return;
|
|
}
|
|
|
|
control_point->line().remove_point (*control_point);
|
|
}
|
|
|
|
void
|
|
Editor::remove_control_point (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
ControlPoint* control_point;
|
|
|
|
if ((control_point = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"))) == 0) {
|
|
fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
control_point->line().remove_point (*control_point);
|
|
}
|
|
|
|
void
|
|
Editor::start_control_point_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
ControlPoint* control_point;
|
|
|
|
if ((control_point = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"))) == 0) {
|
|
fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
drag_info.item = item;
|
|
drag_info.data = control_point;
|
|
drag_info.motion_callback = &Editor::control_point_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::control_point_drag_finished_callback;
|
|
|
|
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());
|
|
set_verbose_canvas_cursor (control_point->line().get_verbose_cursor_string (fraction),
|
|
drag_info.current_pointer_x + 10, drag_info.current_pointer_y + 10);
|
|
|
|
show_verbose_canvas_cursor ();
|
|
}
|
|
|
|
void
|
|
Editor::control_point_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
ControlPoint* cp = reinterpret_cast<ControlPoint *> (drag_info.data);
|
|
|
|
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;
|
|
|
|
// 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;
|
|
}
|
|
if (drag_info.y_constrained) {
|
|
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);
|
|
cy = max (0.0, cy);
|
|
cy = min ((double) cp->line().height(), cy);
|
|
|
|
//translate cx to frames
|
|
nframes64_t cx_frames = unit_to_frame (cx);
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()) && !drag_info.x_constrained) {
|
|
snap_to (cx_frames);
|
|
}
|
|
|
|
float fraction = 1.0 - (cy / cp->line().height());
|
|
|
|
bool push;
|
|
|
|
if (Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier)) {
|
|
push = true;
|
|
} else {
|
|
push = false;
|
|
}
|
|
|
|
cp->line().point_drag (*cp, cx_frames , fraction, push);
|
|
|
|
set_verbose_canvas_cursor_text (cp->line().get_verbose_cursor_string (fraction));
|
|
|
|
drag_info.first_move = false;
|
|
}
|
|
|
|
void
|
|
Editor::control_point_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
ControlPoint* cp = reinterpret_cast<ControlPoint *> (drag_info.data);
|
|
|
|
if (drag_info.first_move) {
|
|
|
|
/* just a click */
|
|
|
|
if ((event->type == GDK_BUTTON_RELEASE) && (event->button.button == 1) && Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
|
|
reset_point_selection ();
|
|
}
|
|
|
|
} else {
|
|
control_point_drag_motion_callback (item, event);
|
|
}
|
|
cp->line().end_drag (cp);
|
|
}
|
|
|
|
void
|
|
Editor::edit_control_point (ArdourCanvas::Item* item)
|
|
{
|
|
ControlPoint* p = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"));
|
|
|
|
if (p == 0) {
|
|
fatal << _("programming error: control point canvas item has no control point object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
ControlPointDialog d (p);
|
|
d.set_position (Gtk::WIN_POS_MOUSE);
|
|
ensure_float (d);
|
|
|
|
if (d.run () != RESPONSE_ACCEPT) {
|
|
return;
|
|
}
|
|
|
|
p->line().modify_point_y (*p, d.get_y_fraction ());
|
|
}
|
|
|
|
|
|
void
|
|
Editor::start_line_grab_from_regionview (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
switch (mouse_mode) {
|
|
case MouseGain:
|
|
assert(dynamic_cast<AudioRegionView*>(clicked_regionview));
|
|
start_line_grab (dynamic_cast<AudioRegionView*>(clicked_regionview)->get_gain_line(), event);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::start_line_grab_from_line (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
AutomationLine* al;
|
|
|
|
if ((al = reinterpret_cast<AutomationLine*> (item->get_data ("line"))) == 0) {
|
|
fatal << _("programming error: line canvas item has no line pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
start_line_grab (al, event);
|
|
}
|
|
|
|
void
|
|
Editor::start_line_grab (AutomationLine* line, GdkEvent* event)
|
|
{
|
|
double cx;
|
|
double cy;
|
|
nframes64_t frame_within_region;
|
|
|
|
/* need to get x coordinate in terms of parent (TimeAxisItemView)
|
|
origin, and ditto for y.
|
|
*/
|
|
|
|
cx = event->button.x;
|
|
cy = event->button.y;
|
|
|
|
line->parent_group().w2i (cx, cy);
|
|
|
|
frame_within_region = (nframes64_t) floor (cx * frames_per_unit);
|
|
|
|
if (!line->control_points_adjacent (frame_within_region, current_line_drag_info.before,
|
|
current_line_drag_info.after)) {
|
|
/* no adjacent points */
|
|
return;
|
|
}
|
|
|
|
drag_info.item = &line->grab_item();
|
|
drag_info.data = line;
|
|
drag_info.motion_callback = &Editor::line_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::line_drag_finished_callback;
|
|
|
|
start_grab (event, fader_cursor);
|
|
|
|
/* store grab start in parent frame */
|
|
|
|
drag_info.grab_x = cx;
|
|
drag_info.grab_y = cy;
|
|
|
|
double fraction = 1.0 - (cy / line->height());
|
|
|
|
line->start_drag (0, drag_info.grab_frame, fraction);
|
|
|
|
set_verbose_canvas_cursor (line->get_verbose_cursor_string (fraction),
|
|
drag_info.current_pointer_x + 10, drag_info.current_pointer_y + 10);
|
|
show_verbose_canvas_cursor ();
|
|
}
|
|
|
|
void
|
|
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 cy = drag_info.grab_y + drag_info.cumulative_y_drag + dy;
|
|
|
|
drag_info.cumulative_y_drag = cy - drag_info.grab_y;
|
|
|
|
cy = max (0.0, cy);
|
|
cy = min ((double) line->height(), cy);
|
|
|
|
|
|
double fraction = 1.0 - (cy / line->height());
|
|
|
|
bool push;
|
|
|
|
if (Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier)) {
|
|
push = false;
|
|
} else {
|
|
push = true;
|
|
}
|
|
|
|
line->line_drag (current_line_drag_info.before, current_line_drag_info.after, fraction, push);
|
|
|
|
set_verbose_canvas_cursor_text (line->get_verbose_cursor_string (fraction));
|
|
}
|
|
|
|
void
|
|
Editor::line_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
AutomationLine* line = reinterpret_cast<AutomationLine *> (drag_info.data);
|
|
line_drag_motion_callback (item, event);
|
|
line->end_drag (0);
|
|
}
|
|
|
|
void
|
|
Editor::start_region_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (selection->regions.empty() || clicked_regionview == 0) {
|
|
return;
|
|
}
|
|
_region_motion_group->raise_to_top ();
|
|
drag_info.copy = false;
|
|
drag_info.item = item;
|
|
drag_info.data = clicked_regionview;
|
|
|
|
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);
|
|
|
|
double speed = 1.0;
|
|
TimeAxisView* tvp = clicked_axisview;
|
|
RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
|
|
|
|
if (tv && tv->is_track()) {
|
|
speed = tv->get_diskstream()->speed();
|
|
}
|
|
|
|
drag_info.last_frame_position = (nframes64_t) (clicked_regionview->region()->position() / speed);
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
|
|
drag_info.source_trackview = &clicked_regionview->get_time_axis_view();
|
|
drag_info.source_layer = clicked_regionview->region()->layer();
|
|
drag_info.dest_trackview = drag_info.source_trackview;
|
|
drag_info.dest_layer = drag_info.source_layer;
|
|
// we want a move threshold
|
|
drag_info.want_move_threshold = true;
|
|
show_verbose_time_cursor (drag_info.last_frame_position, 10);
|
|
|
|
begin_reversible_command (_("move region(s)"));
|
|
|
|
/* sync the canvas to what we think is its current state */
|
|
track_canvas->update_now();
|
|
}
|
|
|
|
void
|
|
Editor::start_create_region_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
drag_info.copy = false;
|
|
drag_info.item = item;
|
|
drag_info.data = clicked_axisview;
|
|
drag_info.source_trackview = clicked_axisview;
|
|
drag_info.dest_trackview = drag_info.source_trackview;
|
|
drag_info.dest_layer = drag_info.source_layer;
|
|
drag_info.motion_callback = &Editor::create_region_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::create_region_drag_finished_callback;
|
|
|
|
start_grab (event);
|
|
}
|
|
|
|
void
|
|
Editor::start_region_copy_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (selection->regions.empty() || clicked_regionview == 0) {
|
|
return;
|
|
}
|
|
_region_motion_group->raise_to_top ();
|
|
drag_info.copy = true;
|
|
drag_info.item = item;
|
|
drag_info.data = clicked_regionview;
|
|
|
|
start_grab(event);
|
|
|
|
TimeAxisView* tv = &clicked_regionview->get_time_axis_view();
|
|
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(tv);
|
|
double speed = 1.0;
|
|
|
|
if (rtv && rtv->is_track()) {
|
|
speed = rtv->get_diskstream()->speed();
|
|
}
|
|
|
|
drag_info.source_trackview = &clicked_regionview->get_time_axis_view();
|
|
drag_info.dest_trackview = drag_info.source_trackview;
|
|
drag_info.dest_layer = drag_info.source_layer;
|
|
drag_info.last_frame_position = (nframes64_t) (clicked_regionview->region()->position() / speed);
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
|
|
// we want a move threshold
|
|
drag_info.want_move_threshold = true;
|
|
drag_info.motion_callback = &Editor::region_drag_motion_callback;
|
|
drag_info.finished_callback = &Editor::region_drag_finished_callback;
|
|
show_verbose_time_cursor (drag_info.last_frame_position, 10);
|
|
}
|
|
|
|
void
|
|
Editor::start_region_brush_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (selection->regions.empty() || clicked_regionview == 0 || Config->get_edit_mode() == Splice) {
|
|
return;
|
|
}
|
|
|
|
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;
|
|
|
|
start_grab (event);
|
|
|
|
double speed = 1.0;
|
|
TimeAxisView* tvp = clicked_axisview;
|
|
RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
|
|
|
|
if (tv && tv->is_track()) {
|
|
speed = tv->get_diskstream()->speed();
|
|
}
|
|
|
|
drag_info.last_frame_position = (nframes64_t) (clicked_regionview->region()->position() / speed);
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
|
|
drag_info.source_trackview = &clicked_regionview->get_time_axis_view();
|
|
drag_info.dest_trackview = drag_info.source_trackview;
|
|
drag_info.dest_layer = drag_info.source_layer;
|
|
// we want a move threshold
|
|
drag_info.want_move_threshold = true;
|
|
drag_info.brushing = true;
|
|
|
|
begin_reversible_command (_("Drag region brush"));
|
|
}
|
|
|
|
void
|
|
Editor::possibly_copy_regions_during_grab (GdkEvent* event)
|
|
{
|
|
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 regionview(s) and region(s) */
|
|
|
|
vector<RegionView*> new_regionviews;
|
|
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
|
|
RegionView* rv;
|
|
RegionView* nrv;
|
|
|
|
rv = (*i);
|
|
AudioRegionView* arv = dynamic_cast<AudioRegionView*>(rv);
|
|
MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
|
|
|
|
const boost::shared_ptr<const Region> original = rv->region();
|
|
boost::shared_ptr<Region> region_copy = RegionFactory::create (original);
|
|
|
|
if (arv) {
|
|
boost::shared_ptr<AudioRegion> audioregion_copy
|
|
= boost::dynamic_pointer_cast<AudioRegion>(region_copy);
|
|
nrv = new AudioRegionView (*arv, audioregion_copy);
|
|
} else if (mrv) {
|
|
boost::shared_ptr<MidiRegion> midiregion_copy
|
|
= boost::dynamic_pointer_cast<MidiRegion>(region_copy);
|
|
nrv = new MidiRegionView (*mrv, midiregion_copy);
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
nrv->get_canvas_group()->show ();
|
|
new_regionviews.push_back (nrv);
|
|
}
|
|
|
|
if (new_regionviews.empty()) {
|
|
return;
|
|
}
|
|
|
|
/* reset selection to new regionviews. This will not set selection visual status for
|
|
these regionviews since they don't belong to a track, so do that by hand too.
|
|
*/
|
|
|
|
selection->set (new_regionviews);
|
|
|
|
for (vector<RegionView*>::iterator i = new_regionviews.begin(); i != new_regionviews.end(); ++i) {
|
|
(*i)->set_selected (true);
|
|
}
|
|
|
|
/* 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);
|
|
/*
|
|
sync the canvas to what we think is its current state
|
|
without it, the canvas seems to
|
|
"forget" to update properly after the upcoming reparent()
|
|
..only if the mouse is in rapid motion at the time of the grab.
|
|
something to do with regionview creation raking so long?
|
|
*/
|
|
track_canvas->update_now();
|
|
}
|
|
}
|
|
|
|
bool
|
|
Editor::check_region_drag_possible (RouteTimeAxisView** tv, layer_t* layer)
|
|
{
|
|
/* Which trackview is this ? */
|
|
|
|
std::pair<TimeAxisView*, int> const tvp = trackview_by_y_position (drag_info.current_pointer_y);
|
|
(*tv) = dynamic_cast<RouteTimeAxisView*> (tvp.first);
|
|
(*layer) = tvp.second;
|
|
|
|
/* The region motion is only processed if the pointer is over
|
|
an audio track.
|
|
*/
|
|
|
|
if (!(*tv) || !(*tv)->is_track()) {
|
|
/* To make sure we hide the verbose canvas cursor when the mouse is
|
|
not held over and audiotrack.
|
|
*/
|
|
hide_verbose_canvas_cursor ();
|
|
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)
|
|
{
|
|
RouteTimeAxisView* tv;
|
|
layer_t layer;
|
|
|
|
if (!check_region_drag_possible (&tv, &layer)) {
|
|
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) {
|
|
|
|
RouteTimeAxisView* atv = dynamic_cast<RouteTimeAxisView*> (&(*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::visible_order_range (int* low, int* high) const
|
|
{
|
|
*low = TimeAxisView::max_order ();
|
|
*high = 0;
|
|
|
|
for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
|
|
|
|
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
|
|
|
|
if (!rtv->hidden()) {
|
|
|
|
if (*high < rtv->order()) {
|
|
*high = rtv->order ();
|
|
}
|
|
|
|
if (*low > rtv->order()) {
|
|
*low = rtv->order ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** @param new_order New track order.
|
|
* @param old_order Old track order.
|
|
* @param visible_y_low Lowest visible order.
|
|
* @param visible_y_high Highest visible order.
|
|
* @param tracks Bitset of tracks indexed by order; 0 means a audio/MIDI track, 1 means something else.
|
|
* @param heigh_list Heights of tracks indexed by order.
|
|
* @return true if y movement should not happen, otherwise false.
|
|
*/
|
|
bool
|
|
Editor::y_movement_disallowed (
|
|
int new_order, int old_order, int y_span, int visible_y_low, int visible_y_high,
|
|
bitset<512> const & tracks, vector<int32_t> const & height_list
|
|
) const
|
|
{
|
|
if (new_order != old_order) {
|
|
|
|
/* this isn't the pointer track */
|
|
|
|
if (y_span > 0) {
|
|
|
|
/* moving up the canvas */
|
|
if ( (new_order - y_span) >= visible_y_low) {
|
|
|
|
int32_t n = 0;
|
|
|
|
/* work out where we'll end up with this y span, taking hidden TimeAxisViews into account */
|
|
int32_t visible_tracks = 0;
|
|
while (visible_tracks < y_span ) {
|
|
visible_tracks++;
|
|
while (height_list[new_order - (visible_tracks - n)] == 0) {
|
|
/* passing through a hidden track */
|
|
n--;
|
|
}
|
|
}
|
|
|
|
if (tracks[new_order - (y_span - n)] != 0x00) {
|
|
/* moving to a non-track; disallow */
|
|
return true;
|
|
}
|
|
|
|
|
|
} else {
|
|
/* moving beyond the lowest visible track; disallow */
|
|
return true;
|
|
}
|
|
|
|
} else if (y_span < 0) {
|
|
|
|
/* moving down the canvas */
|
|
if ((new_order - y_span) <= visible_y_high) {
|
|
|
|
int32_t visible_tracks = 0;
|
|
int32_t n = 0;
|
|
while (visible_tracks > y_span ) {
|
|
visible_tracks--;
|
|
|
|
while (height_list[new_order - (visible_tracks - n)] == 0) {
|
|
/* passing through a hidden track */
|
|
n++;
|
|
}
|
|
}
|
|
|
|
if (tracks[new_order - (y_span - n)] != 0x00) {
|
|
/* moving to a non-track; disallow */
|
|
return true;
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
/* moving beyond the highest visible track; disallow */
|
|
return true;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
/* this is the pointer's track */
|
|
|
|
if ((new_order - y_span) > visible_y_high) {
|
|
/* we will overflow */
|
|
return true;
|
|
} else if ((new_order - y_span) < visible_y_low) {
|
|
/* we will overflow */
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
Editor::region_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
double x_delta;
|
|
double y_delta = 0;
|
|
nframes64_t pending_region_position = 0;
|
|
int32_t pointer_order_span = 0, canvas_pointer_order_span = 0;
|
|
int32_t pointer_layer_span = 0;
|
|
|
|
bool clamp_y_axis = false;
|
|
vector<int32_t>::iterator j;
|
|
|
|
possibly_copy_regions_during_grab (event);
|
|
|
|
/* *pointer* variables reflect things about the pointer; as we may be moving
|
|
multiple regions, much detail must be computed per-region */
|
|
|
|
/* current_pointer_view will become the TimeAxisView that we're currently pointing at, and
|
|
current_pointer_layer the current layer on that TimeAxisView */
|
|
RouteTimeAxisView* current_pointer_view;
|
|
layer_t current_pointer_layer;
|
|
if (!check_region_drag_possible (¤t_pointer_view, ¤t_pointer_layer)) {
|
|
return;
|
|
}
|
|
|
|
/* TimeAxisView that we were pointing at last time we entered this method */
|
|
TimeAxisView const * const last_pointer_view = drag_info.dest_trackview;
|
|
/* the order of the track that we were pointing at last time we entered this method */
|
|
int32_t const last_pointer_order = last_pointer_view->order ();
|
|
/* the layer that we were pointing at last time we entered this method */
|
|
layer_t const last_pointer_layer = drag_info.dest_layer;
|
|
|
|
/************************************************************
|
|
Y DELTA COMPUTATION
|
|
************************************************************/
|
|
|
|
/* Height of TimeAxisViews, indexed by order */
|
|
/* XXX: hard-coded limit of TimeAxisViews */
|
|
vector<int32_t> height_list (512);
|
|
|
|
if (drag_info.brushing) {
|
|
clamp_y_axis = true;
|
|
pointer_order_span = 0;
|
|
goto y_axis_done;
|
|
}
|
|
|
|
/* the change in track order between this callback and the last */
|
|
pointer_order_span = last_pointer_view->order() - current_pointer_view->order();
|
|
/* the change in layer between this callback and the last;
|
|
only meaningful if pointer_order_span == 0 (ie we've not moved tracks) */
|
|
pointer_layer_span = last_pointer_layer - current_pointer_layer;
|
|
|
|
if (pointer_order_span != 0) {
|
|
|
|
int32_t children = 0;
|
|
/* XXX: hard-coded limit of tracks */
|
|
bitset <512> tracks (0x00);
|
|
|
|
int visible_y_high;
|
|
int visible_y_low;
|
|
visible_order_range (&visible_y_low, &visible_y_high);
|
|
|
|
/* get a bitmask representing the visible tracks */
|
|
|
|
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
|
|
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
|
|
TimeAxisView::Children children_list;
|
|
|
|
/* zeroes are audio/MIDI tracks. ones are other types. */
|
|
|
|
if (!rtv->hidden()) {
|
|
|
|
if (!rtv->is_track()) {
|
|
/* not an audio nor MIDI track */
|
|
tracks = tracks |= (0x01 << rtv->order());
|
|
}
|
|
|
|
height_list[rtv->order()] = (*i)->current_height();
|
|
children = 1;
|
|
|
|
if ((children_list = rtv->get_child_list()).size() > 0) {
|
|
for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) {
|
|
tracks = tracks |= (0x01 << (rtv->order() + children));
|
|
height_list[rtv->order() + children] = (*j)->current_height();
|
|
children++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* find the actual pointer span, in terms of the number of visible tracks;
|
|
to do this, we reduce |pointer_order_span| by the number of hidden tracks
|
|
over the span */
|
|
|
|
canvas_pointer_order_span = pointer_order_span;
|
|
if (last_pointer_view->order() >= current_pointer_view->order()) {
|
|
for (int32_t y = current_pointer_view->order(); y < last_pointer_view->order(); y++) {
|
|
if (height_list[y] == 0) {
|
|
canvas_pointer_order_span--;
|
|
}
|
|
}
|
|
} else {
|
|
for (int32_t y = last_pointer_view->order(); y <= current_pointer_view->order(); y++) {
|
|
if (height_list[y] == 0) {
|
|
canvas_pointer_order_span++;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
|
|
|
|
RegionView* rv = (*i);
|
|
|
|
if (rv->region()->locked()) {
|
|
continue;
|
|
}
|
|
|
|
double ix1, ix2, iy1, iy2;
|
|
rv->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
|
|
rv->get_canvas_frame()->i2w (ix1, iy1);
|
|
iy1 += vertical_adjustment.get_value() - canvas_timebars_vsize;
|
|
|
|
/* get the new trackview for this particular region */
|
|
std::pair<TimeAxisView*, int> const tvp = trackview_by_y_position (iy1);
|
|
assert (tvp.first);
|
|
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
|
|
|
|
/* I know this method has a slightly excessive argument list, but I think
|
|
it's nice to separate the code out all the same, since it has such a
|
|
simple result, and it makes it clear that there are no other
|
|
side-effects.
|
|
*/
|
|
|
|
/* XXX: not sure that we should be passing canvas_pointer_order_span in here,
|
|
as surely this is a per-region thing... */
|
|
|
|
clamp_y_axis = y_movement_disallowed (
|
|
rtv->order(), last_pointer_order, canvas_pointer_order_span, visible_y_low, visible_y_high,
|
|
tracks, height_list
|
|
);
|
|
|
|
if (clamp_y_axis) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
} else if (drag_info.dest_trackview == current_pointer_view) {
|
|
|
|
if (current_pointer_layer == last_pointer_layer) {
|
|
/* No movement; clamp */
|
|
clamp_y_axis = true;
|
|
}
|
|
}
|
|
|
|
y_axis_done:
|
|
if (!clamp_y_axis) {
|
|
drag_info.dest_trackview = current_pointer_view;
|
|
drag_info.dest_layer = current_pointer_layer;
|
|
}
|
|
|
|
/************************************************************
|
|
X DELTA COMPUTATION
|
|
************************************************************/
|
|
|
|
/* compute the amount of pointer motion in frames, and where
|
|
the region would be if we moved it by that much.
|
|
*/
|
|
if ( drag_info.move_threshold_passed ) {
|
|
|
|
if (drag_info.current_pointer_frame >= drag_info.pointer_frame_offset) {
|
|
|
|
nframes64_t sync_frame;
|
|
nframes64_t sync_offset;
|
|
int32_t sync_dir;
|
|
|
|
pending_region_position = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
|
|
|
|
sync_offset = clicked_regionview->region()->sync_offset (sync_dir);
|
|
|
|
/* 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);
|
|
}
|
|
|
|
pending_region_position = clicked_regionview->region()->adjust_to_sync (sync_frame);
|
|
|
|
} else {
|
|
pending_region_position = drag_info.last_frame_position;
|
|
}
|
|
|
|
} else {
|
|
pending_region_position = 0;
|
|
}
|
|
|
|
if (pending_region_position > max_frames - clicked_regionview->region()->length()) {
|
|
pending_region_position = drag_info.last_frame_position;
|
|
}
|
|
|
|
bool x_move_allowed;
|
|
|
|
if (Config->get_edit_mode() == Lock) {
|
|
if (drag_info.copy) {
|
|
x_move_allowed = !drag_info.x_constrained;
|
|
} else {
|
|
/* in locked edit mode, reverse the usual meaning of x_constrained */
|
|
x_move_allowed = drag_info.x_constrained;
|
|
}
|
|
} else {
|
|
x_move_allowed = !drag_info.x_constrained;
|
|
}
|
|
|
|
if (( pending_region_position != drag_info.last_frame_position) && x_move_allowed ) {
|
|
|
|
/* 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);
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
|
|
|
|
RegionView* rv = (*i);
|
|
|
|
// If any regionview is at zero, we need to know so we can stop further leftward motion.
|
|
|
|
double ix1, ix2, iy1, iy2;
|
|
rv->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
|
|
rv->get_canvas_frame()->i2w (ix1, iy1);
|
|
|
|
if (-x_delta > ix1 + horizontal_adjustment.get_value()) {
|
|
x_delta = 0;
|
|
pending_region_position = drag_info.last_frame_position;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
drag_info.last_frame_position = pending_region_position;
|
|
|
|
} else {
|
|
x_delta = 0;
|
|
}
|
|
|
|
} else {
|
|
/* threshold not passed */
|
|
|
|
x_delta = 0;
|
|
}
|
|
|
|
/*************************************************************
|
|
PREPARE TO MOVE
|
|
************************************************************/
|
|
|
|
if (x_delta == 0 && pointer_order_span == 0 && pointer_layer_span == 0) {
|
|
/* haven't reached next snap point, and we're not switching
|
|
trackviews nor layers. nothing to do.
|
|
*/
|
|
return;
|
|
}
|
|
|
|
/*************************************************************
|
|
MOTION
|
|
************************************************************/
|
|
bool do_move = true;
|
|
if (drag_info.first_move) {
|
|
if (!drag_info.move_threshold_passed) {
|
|
do_move = false;
|
|
}
|
|
}
|
|
|
|
if (do_move) {
|
|
|
|
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 (rv->region()->locked()) {
|
|
continue;
|
|
}
|
|
|
|
/* here we are calculating the y distance from the
|
|
top of the first track view to the top of the region
|
|
area of the track view that we're working on */
|
|
|
|
/* this x value is just a dummy value so that we have something
|
|
to pass to i2w () */
|
|
|
|
double ix1 = 0;
|
|
|
|
/* distance from the top of this track view to the region area
|
|
of our track view is always 1 */
|
|
|
|
double iy1 = 1;
|
|
|
|
/* convert to world coordinates, ie distance from the top of
|
|
the ruler section */
|
|
|
|
rv->get_canvas_frame()->i2w (ix1, iy1);
|
|
|
|
/* compensate for the ruler section and the vertical scrollbar position */
|
|
iy1 += get_trackview_group_vertical_offset ();
|
|
|
|
if (drag_info.first_move) {
|
|
|
|
// hide any dependent views
|
|
|
|
rv->get_time_axis_view().hide_dependent_views (*rv);
|
|
|
|
/*
|
|
reparent to a non scrolling group so that we can keep the
|
|
region selection above all time axis views.
|
|
reparenting means we have to move the rv as the two
|
|
parent groups have different coordinates.
|
|
*/
|
|
|
|
rv->get_canvas_group()->property_y() = iy1 - 1;
|
|
rv->get_canvas_group()->reparent(*_region_motion_group);
|
|
|
|
rv->fake_set_opaque (true);
|
|
}
|
|
|
|
/* current view for this particular region */
|
|
std::pair<TimeAxisView*, int> pos = trackview_by_y_position (iy1);
|
|
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (pos.first);
|
|
|
|
if (pointer_order_span != 0 && !clamp_y_axis) {
|
|
|
|
/* INTER-TRACK MOVEMENT */
|
|
|
|
/* move through the height list to the track that the region is currently on */
|
|
vector<int32_t>::iterator j = height_list.begin ();
|
|
int32_t x = 0;
|
|
while (j != height_list.end () && x != rtv->order ()) {
|
|
++x;
|
|
++j;
|
|
}
|
|
|
|
y_delta = 0;
|
|
int32_t temp_pointer_order_span = canvas_pointer_order_span;
|
|
|
|
if (j != height_list.end ()) {
|
|
|
|
/* Account for layers in the original and
|
|
destination tracks. If we're moving around in layers we assume
|
|
that only one track is involved, so it's ok to use *pointer*
|
|
variables here. */
|
|
|
|
StreamView* lv = last_pointer_view->view ();
|
|
assert (lv);
|
|
|
|
/* move to the top of the last trackview */
|
|
if (lv->layer_display () == Stacked) {
|
|
y_delta -= (lv->layers() - last_pointer_layer - 1) * lv->child_height ();
|
|
}
|
|
|
|
StreamView* cv = current_pointer_view->view ();
|
|
assert (cv);
|
|
|
|
/* move to the right layer on the current trackview */
|
|
if (cv->layer_display () == Stacked) {
|
|
y_delta += (cv->layers() - current_pointer_layer - 1) * cv->child_height ();
|
|
}
|
|
|
|
/* And for being on a non-topmost layer on the new
|
|
track */
|
|
|
|
while (temp_pointer_order_span > 0) {
|
|
/* we're moving up canvas-wise,
|
|
so we need to find the next track height
|
|
*/
|
|
if (j != height_list.begin()) {
|
|
j--;
|
|
}
|
|
|
|
if (x != last_pointer_order) {
|
|
if ((*j) == 0) {
|
|
++temp_pointer_order_span;
|
|
}
|
|
}
|
|
|
|
y_delta -= (*j);
|
|
temp_pointer_order_span--;
|
|
}
|
|
|
|
while (temp_pointer_order_span < 0) {
|
|
|
|
y_delta += (*j);
|
|
|
|
if (x != last_pointer_order) {
|
|
if ((*j) == 0) {
|
|
--temp_pointer_order_span;
|
|
}
|
|
}
|
|
|
|
if (j != height_list.end()) {
|
|
j++;
|
|
}
|
|
|
|
temp_pointer_order_span++;
|
|
}
|
|
|
|
|
|
/* find out where we'll be when we move and set height accordingly */
|
|
|
|
std::pair<TimeAxisView*, int> const pos = trackview_by_y_position (iy1 + y_delta);
|
|
RouteTimeAxisView const * temp_rtv = dynamic_cast<RouteTimeAxisView*> (pos.first);
|
|
rv->set_height (temp_rtv->view()->child_height());
|
|
|
|
/* if you un-comment the following, the region colours will follow
|
|
the track colours whilst dragging; personally
|
|
i think this can confuse things, but never mind.
|
|
*/
|
|
|
|
//const GdkColor& col (temp_rtv->view->get_region_color());
|
|
//rv->set_color (const_cast<GdkColor&>(col));
|
|
}
|
|
}
|
|
|
|
if (pointer_order_span == 0 && pointer_layer_span != 0 && !clamp_y_axis) {
|
|
|
|
/* INTER-LAYER MOVEMENT in the same track */
|
|
y_delta = rtv->view()->child_height () * pointer_layer_span;
|
|
}
|
|
|
|
|
|
if (drag_info.brushing) {
|
|
mouse_brush_insert_region (rv, pending_region_position);
|
|
} else {
|
|
rv->move (x_delta, y_delta);
|
|
}
|
|
|
|
} /* foreach region */
|
|
|
|
} /* if do_move */
|
|
|
|
if (drag_info.first_move && drag_info.move_threshold_passed) {
|
|
cursor_group->raise_to_top();
|
|
drag_info.first_move = false;
|
|
}
|
|
|
|
if (x_delta != 0 && !drag_info.brushing) {
|
|
show_verbose_time_cursor (drag_info.last_frame_position, 10);
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::region_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
bool nocommit = true;
|
|
vector<RegionView*> copies;
|
|
RouteTimeAxisView* source_tv;
|
|
boost::shared_ptr<Diskstream> ds;
|
|
boost::shared_ptr<Playlist> from_playlist;
|
|
vector<RegionView*> new_selection;
|
|
typedef set<boost::shared_ptr<Playlist> > PlaylistSet;
|
|
PlaylistSet modified_playlists;
|
|
PlaylistSet frozen_playlists;
|
|
list <sigc::connection> modified_playlist_connections;
|
|
pair<PlaylistSet::iterator,bool> insert_result, frozen_insert_result;
|
|
nframes64_t drag_delta;
|
|
bool changed_tracks, changed_position;
|
|
std::pair<TimeAxisView*, int> tvp;
|
|
std::map<RegionView*, RouteTimeAxisView*> final;
|
|
|
|
/* first_move is set to false if the regionview has been moved in the
|
|
motion handler.
|
|
*/
|
|
|
|
if (drag_info.first_move) {
|
|
/* just a click */
|
|
goto out;
|
|
}
|
|
|
|
nocommit = false;
|
|
|
|
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;
|
|
}
|
|
|
|
char* op_string;
|
|
|
|
/* reverse this here so that we have the correct logic to finalize
|
|
the drag.
|
|
*/
|
|
|
|
if (Config->get_edit_mode() == Lock && !drag_info.copy) {
|
|
drag_info.x_constrained = !drag_info.x_constrained;
|
|
}
|
|
|
|
if (drag_info.copy) {
|
|
if (drag_info.x_constrained) {
|
|
op_string = _("fixed time region copy");
|
|
} else {
|
|
op_string = _("region copy");
|
|
}
|
|
} else {
|
|
if (drag_info.x_constrained) {
|
|
op_string = _("fixed time region drag");
|
|
} else {
|
|
op_string = _("region drag");
|
|
}
|
|
}
|
|
|
|
begin_reversible_command (op_string);
|
|
changed_position = (drag_info.last_frame_position != (nframes64_t) (clicked_regionview->region()->position()));
|
|
tvp = trackview_by_y_position (drag_info.current_pointer_y);
|
|
changed_tracks = (tvp.first != &clicked_regionview->get_time_axis_view());
|
|
|
|
drag_delta = clicked_regionview->region()->position() - drag_info.last_frame_position;
|
|
|
|
track_canvas->update_now ();
|
|
|
|
/* make a list of where each region ended up */
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
|
|
|
|
double ix1, ix2, iy1, iy2;
|
|
(*i)->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
|
|
(*i)->get_canvas_frame()->i2w (ix1, iy1);
|
|
iy1 += vertical_adjustment.get_value() - canvas_timebars_vsize;
|
|
|
|
std::pair<TimeAxisView*, int> tv = trackview_by_y_position (iy1);
|
|
final[*i] = dynamic_cast<RouteTimeAxisView*> (tv.first);
|
|
}
|
|
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ) {
|
|
|
|
RegionView* rv = (*i);
|
|
RouteTimeAxisView* dest_rtv = final[*i];
|
|
|
|
nframes64_t where;
|
|
|
|
if (rv->region()->locked()) {
|
|
++i;
|
|
continue;
|
|
}
|
|
|
|
if (changed_position && !drag_info.x_constrained) {
|
|
where = rv->region()->position() - drag_delta;
|
|
} else {
|
|
where = rv->region()->position();
|
|
}
|
|
|
|
boost::shared_ptr<Region> new_region;
|
|
|
|
if (drag_info.copy) {
|
|
/* we already made a copy */
|
|
new_region = rv->region();
|
|
|
|
/* undo the previous hide_dependent_views so that xfades don't
|
|
disappear on copying regions
|
|
*/
|
|
|
|
//rv->get_time_axis_view().reveal_dependent_views (*rv);
|
|
|
|
} else if (changed_tracks && dest_rtv->playlist()) {
|
|
new_region = RegionFactory::create (rv->region());
|
|
}
|
|
|
|
if (changed_tracks || drag_info.copy) {
|
|
|
|
boost::shared_ptr<Playlist> to_playlist = dest_rtv->playlist();
|
|
if (!to_playlist) {
|
|
++i;
|
|
continue;
|
|
}
|
|
|
|
latest_regionviews.clear ();
|
|
|
|
sigc::connection c = dest_rtv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
|
|
|
|
insert_result = modified_playlists.insert (to_playlist);
|
|
if (insert_result.second) {
|
|
session->add_command (new MementoCommand<Playlist>(*to_playlist, &to_playlist->get_state(), 0));
|
|
}
|
|
|
|
to_playlist->add_region (new_region, where);
|
|
|
|
c.disconnect ();
|
|
|
|
if (!latest_regionviews.empty()) {
|
|
// XXX why just the first one ? we only expect one
|
|
// commented out in nick_m's canvas reworking. is that intended?
|
|
//dest_atv->reveal_dependent_views (*latest_regionviews.front());
|
|
new_selection.push_back (latest_regionviews.front());
|
|
}
|
|
|
|
} else {
|
|
/*
|
|
motion on the same track. plonk the previously reparented region
|
|
back to its original canvas group (its streamview).
|
|
No need to do anything for copies as they are fake regions which will be deleted.
|
|
*/
|
|
|
|
rv->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
|
|
rv->get_canvas_group()->property_y() = 0;
|
|
|
|
/* just change the model */
|
|
|
|
boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
|
|
|
|
insert_result = modified_playlists.insert (playlist);
|
|
if (insert_result.second) {
|
|
session->add_command (new MementoCommand<Playlist>(*playlist, &playlist->get_state(), 0));
|
|
}
|
|
/* freeze to avoid lots of relayering in the case of a multi-region drag */
|
|
frozen_insert_result = frozen_playlists.insert(playlist);
|
|
if (frozen_insert_result.second) {
|
|
playlist->freeze();
|
|
}
|
|
|
|
rv->region()->set_position (where, (void*) this);
|
|
}
|
|
|
|
if (changed_tracks && !drag_info.copy) {
|
|
|
|
/* get the playlist where this drag started. we can't use rv->region()->playlist()
|
|
because we may have copied the region and it has not been attached to a playlist.
|
|
*/
|
|
|
|
assert ((source_tv = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view())));
|
|
assert ((ds = source_tv->get_diskstream()));
|
|
assert ((from_playlist = ds->playlist()));
|
|
|
|
/* moved to a different audio track, without copying */
|
|
|
|
/* the region that used to be in the old playlist is not
|
|
moved to the new one - we use a copy of it. as a result,
|
|
any existing editor for the region should no longer be
|
|
visible.
|
|
*/
|
|
|
|
rv->hide_region_editor();
|
|
rv->fake_set_opaque (false);
|
|
|
|
/* remove the region from the old playlist */
|
|
|
|
insert_result = modified_playlists.insert (from_playlist);
|
|
if (insert_result.second) {
|
|
session->add_command (new MementoCommand<Playlist>(*from_playlist, &from_playlist->get_state(), 0));
|
|
}
|
|
|
|
from_playlist->remove_region ((rv->region()));
|
|
|
|
/* 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 a playlist will have removed all
|
|
trace of it from the selection (i.e. there were N regions selected, we removed 1,
|
|
but since its the same playlist for N tracks, all N tracks updated themselves, removed the
|
|
corresponding regionview, and the selection is now empty).
|
|
|
|
this could have invalidated any and all iterators into the region selection.
|
|
|
|
the heuristic we use here is: if the region selection is empty, break out of the loop
|
|
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();
|
|
}
|
|
|
|
} else {
|
|
++i;
|
|
}
|
|
|
|
if (drag_info.copy) {
|
|
copies.push_back (rv);
|
|
}
|
|
}
|
|
|
|
if (new_selection.empty()) {
|
|
if (drag_info.copy) {
|
|
/* the region(view)s that are selected and being dragged around
|
|
are copies and do not belong to any track. remove them
|
|
from the selection right here.
|
|
*/
|
|
selection->clear_regions();
|
|
}
|
|
} else {
|
|
/* this will clear any existing selection that would have been
|
|
cleared in the other clause above
|
|
*/
|
|
selection->set (new_selection);
|
|
}
|
|
|
|
for (set<boost::shared_ptr<Playlist> >::iterator p = frozen_playlists.begin(); p != frozen_playlists.end(); ++p) {
|
|
(*p)->thaw();
|
|
}
|
|
|
|
out:
|
|
if (!nocommit) {
|
|
for (set<boost::shared_ptr<Playlist> >::iterator p = modified_playlists.begin(); p != modified_playlists.end(); ++p) {
|
|
session->add_command (new MementoCommand<Playlist>(*(*p), 0, &(*p)->get_state()));
|
|
}
|
|
commit_reversible_command ();
|
|
}
|
|
|
|
for (vector<RegionView*>::iterator x = copies.begin(); x != copies.end(); ++x) {
|
|
delete *x;
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
Editor::create_region_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (drag_info.move_threshold_passed) {
|
|
if (drag_info.first_move) {
|
|
// TODO: create region-create-drag region view here
|
|
drag_info.first_move = false;
|
|
}
|
|
|
|
// TODO: resize region-create-drag region view here
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::create_region_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (drag_info.dest_trackview);
|
|
if (!mtv)
|
|
return;
|
|
|
|
const boost::shared_ptr<MidiDiskstream> diskstream =
|
|
boost::dynamic_pointer_cast<MidiDiskstream>(mtv->view()->trackview().track()->diskstream());
|
|
|
|
if (!diskstream) {
|
|
warning << "Cannot create non-MIDI region" << endl;
|
|
return;
|
|
}
|
|
|
|
if (drag_info.first_move) {
|
|
begin_reversible_command (_("create region"));
|
|
XMLNode &before = mtv->playlist()->get_state();
|
|
|
|
nframes64_t start = drag_info.grab_frame;
|
|
snap_to (start, -1);
|
|
const Meter& m = session->tempo_map().meter_at(start);
|
|
const Tempo& t = session->tempo_map().tempo_at(start);
|
|
double length = floor (m.frames_per_bar(t, session->frame_rate()));
|
|
|
|
boost::shared_ptr<Source> src = session->create_midi_source_for_session(*diskstream.get());
|
|
|
|
mtv->playlist()->add_region (boost::dynamic_pointer_cast<MidiRegion>
|
|
(RegionFactory::create(src, 0, (nframes_t) length,
|
|
PBD::basename_nosuffix(src->name()))), start);
|
|
XMLNode &after = mtv->playlist()->get_state();
|
|
session->add_command(new MementoCommand<Playlist>(*mtv->playlist().get(), &before, &after));
|
|
commit_reversible_command();
|
|
|
|
} else {
|
|
create_region_drag_motion_callback (item, event);
|
|
// TODO: create region-create-drag region here
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::region_view_item_click (AudioRegionView& rv, GdkEventButton* event)
|
|
{
|
|
/* Either add to or set the set the region selection, unless
|
|
this is an alignment click (control used)
|
|
*/
|
|
|
|
if (Keyboard::modifier_state_contains (event->state, Keyboard::PrimaryModifier)) {
|
|
TimeAxisView* tv = &rv.get_time_axis_view();
|
|
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(tv);
|
|
double speed = 1.0;
|
|
if (rtv && rtv->is_track()) {
|
|
speed = rtv->get_diskstream()->speed();
|
|
}
|
|
|
|
nframes64_t where = get_preferred_edit_position();
|
|
|
|
if (where >= 0) {
|
|
|
|
if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) {
|
|
|
|
align_region (rv.region(), SyncPoint, (nframes64_t) (where * speed));
|
|
|
|
} else if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
|
|
|
|
align_region (rv.region(), End, (nframes64_t) (where * speed));
|
|
|
|
} else {
|
|
|
|
align_region (rv.region(), Start, (nframes64_t) (where * speed));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::show_verbose_time_cursor (nframes64_t frame, double offset, double xpos, double ypos)
|
|
{
|
|
char buf[128];
|
|
SMPTE::Time smpte;
|
|
BBT_Time bbt;
|
|
int hours, mins;
|
|
nframes64_t frame_rate;
|
|
float secs;
|
|
|
|
if (session == 0) {
|
|
return;
|
|
}
|
|
|
|
AudioClock::Mode m;
|
|
|
|
if (Profile->get_sae() || Profile->get_small_screen()) {
|
|
m = ARDOUR_UI::instance()->primary_clock.mode();
|
|
} else {
|
|
m = ARDOUR_UI::instance()->secondary_clock.mode();
|
|
}
|
|
|
|
switch (m) {
|
|
case AudioClock::BBT:
|
|
session->bbt_time (frame, bbt);
|
|
snprintf (buf, sizeof (buf), "%02" PRIu32 "|%02" PRIu32 "|%02" PRIu32, bbt.bars, bbt.beats, bbt.ticks);
|
|
break;
|
|
|
|
case AudioClock::SMPTE:
|
|
session->smpte_time (frame, smpte);
|
|
snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32, smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
|
|
break;
|
|
|
|
case AudioClock::MinSec:
|
|
/* XXX this is copied from show_verbose_duration_cursor() */
|
|
frame_rate = session->frame_rate();
|
|
hours = frame / (frame_rate * 3600);
|
|
frame = frame % (frame_rate * 3600);
|
|
mins = frame / (frame_rate * 60);
|
|
frame = frame % (frame_rate * 60);
|
|
secs = (float) frame / (float) frame_rate;
|
|
snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%.4f", hours, mins, secs);
|
|
break;
|
|
|
|
default:
|
|
snprintf (buf, sizeof(buf), "%" PRIi64, frame);
|
|
break;
|
|
}
|
|
|
|
if (xpos >= 0 && ypos >=0) {
|
|
set_verbose_canvas_cursor (buf, xpos + offset, ypos + offset);
|
|
}
|
|
else {
|
|
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);
|
|
}
|
|
show_verbose_canvas_cursor ();
|
|
}
|
|
|
|
void
|
|
Editor::show_verbose_duration_cursor (nframes64_t start, nframes64_t end, double offset, double xpos, double ypos)
|
|
{
|
|
char buf[128];
|
|
SMPTE::Time smpte;
|
|
BBT_Time sbbt;
|
|
BBT_Time ebbt;
|
|
int hours, mins;
|
|
nframes64_t distance, frame_rate;
|
|
float secs;
|
|
Meter meter_at_start(session->tempo_map().meter_at(start));
|
|
|
|
if (session == 0) {
|
|
return;
|
|
}
|
|
|
|
AudioClock::Mode m;
|
|
|
|
if (Profile->get_sae() || Profile->get_small_screen()) {
|
|
m = ARDOUR_UI::instance()->primary_clock.mode ();
|
|
} else {
|
|
m = ARDOUR_UI::instance()->secondary_clock.mode ();
|
|
}
|
|
|
|
switch (m) {
|
|
case AudioClock::BBT:
|
|
session->bbt_time (start, sbbt);
|
|
session->bbt_time (end, ebbt);
|
|
|
|
/* subtract */
|
|
/* XXX this computation won't work well if the
|
|
user makes a selection that spans any meter changes.
|
|
*/
|
|
|
|
ebbt.bars -= sbbt.bars;
|
|
if (ebbt.beats >= sbbt.beats) {
|
|
ebbt.beats -= sbbt.beats;
|
|
} else {
|
|
ebbt.bars--;
|
|
ebbt.beats = int(meter_at_start.beats_per_bar()) + ebbt.beats - sbbt.beats;
|
|
}
|
|
if (ebbt.ticks >= sbbt.ticks) {
|
|
ebbt.ticks -= sbbt.ticks;
|
|
} else {
|
|
ebbt.beats--;
|
|
ebbt.ticks = int(Meter::ticks_per_beat) + ebbt.ticks - sbbt.ticks;
|
|
}
|
|
|
|
snprintf (buf, sizeof (buf), "%02" PRIu32 "|%02" PRIu32 "|%02" PRIu32, ebbt.bars, ebbt.beats, ebbt.ticks);
|
|
break;
|
|
|
|
case AudioClock::SMPTE:
|
|
session->smpte_duration (end - start, smpte);
|
|
snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32, smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
|
|
break;
|
|
|
|
case AudioClock::MinSec:
|
|
/* XXX this stuff should be elsewhere.. */
|
|
distance = end - start;
|
|
frame_rate = session->frame_rate();
|
|
hours = distance / (frame_rate * 3600);
|
|
distance = distance % (frame_rate * 3600);
|
|
mins = distance / (frame_rate * 60);
|
|
distance = distance % (frame_rate * 60);
|
|
secs = (float) distance / (float) frame_rate;
|
|
snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%.4f", hours, mins, secs);
|
|
break;
|
|
|
|
default:
|
|
snprintf (buf, sizeof(buf), "%" PRIi64, end - start);
|
|
break;
|
|
}
|
|
|
|
if (xpos >= 0 && ypos >=0) {
|
|
set_verbose_canvas_cursor (buf, xpos + offset, ypos + offset);
|
|
}
|
|
else {
|
|
set_verbose_canvas_cursor (buf, drag_info.current_pointer_x + offset, drag_info.current_pointer_y + offset);
|
|
}
|
|
|
|
show_verbose_canvas_cursor ();
|
|
}
|
|
|
|
void
|
|
Editor::collect_new_region_view (RegionView* rv)
|
|
{
|
|
latest_regionviews.push_back (rv);
|
|
}
|
|
|
|
void
|
|
Editor::collect_and_select_new_region_view (RegionView* rv)
|
|
{
|
|
selection->add(rv);
|
|
latest_regionviews.push_back (rv);
|
|
}
|
|
|
|
void
|
|
Editor::start_selection_grab (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (clicked_regionview == 0) {
|
|
return;
|
|
}
|
|
|
|
/* lets try to create new Region for the selection */
|
|
|
|
vector<boost::shared_ptr<Region> > new_regions;
|
|
create_region_from_selection (new_regions);
|
|
|
|
if (new_regions.empty()) {
|
|
return;
|
|
}
|
|
|
|
/* XXX fix me one day to use all new regions */
|
|
|
|
boost::shared_ptr<Region> region (new_regions.front());
|
|
|
|
/* add it to the current stream/playlist.
|
|
|
|
tricky: the streamview for the track will add a new regionview. we will
|
|
catch the signal it sends when it creates the regionview to
|
|
set the regionview we want to then drag.
|
|
*/
|
|
|
|
latest_regionviews.clear();
|
|
sigc::connection c = clicked_routeview->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
|
|
|
|
/* A selection grab currently creates two undo/redo operations, one for
|
|
creating the new region and another for moving it.
|
|
*/
|
|
|
|
begin_reversible_command (_("selection grab"));
|
|
|
|
boost::shared_ptr<Playlist> playlist = clicked_axisview->playlist();
|
|
|
|
XMLNode *before = &(playlist->get_state());
|
|
clicked_routeview->playlist()->add_region (region, selection->time[clicked_selection].start);
|
|
XMLNode *after = &(playlist->get_state());
|
|
session->add_command(new MementoCommand<Playlist>(*playlist, before, after));
|
|
|
|
commit_reversible_command ();
|
|
|
|
c.disconnect ();
|
|
|
|
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_regionviews);
|
|
|
|
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.source_trackview = clicked_routeview;
|
|
drag_info.dest_trackview = drag_info.source_trackview;
|
|
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);
|
|
}
|
|
|
|
void
|
|
Editor::cancel_selection ()
|
|
{
|
|
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
|
|
(*i)->hide_selection ();
|
|
}
|
|
selection->clear ();
|
|
clicked_selection = 0;
|
|
}
|
|
|
|
void
|
|
Editor::start_selection_op (ArdourCanvas::Item* item, GdkEvent* event, SelectionOp op)
|
|
{
|
|
nframes64_t start = 0;
|
|
nframes64_t end = 0;
|
|
|
|
if (session == 0) {
|
|
return;
|
|
}
|
|
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::drag_selection;
|
|
drag_info.finished_callback = &Editor::end_selection_op;
|
|
|
|
selection_op = op;
|
|
|
|
switch (op) {
|
|
case CreateSelection:
|
|
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
|
|
drag_info.copy = true;
|
|
} else {
|
|
drag_info.copy = false;
|
|
}
|
|
start_grab (event, selector_cursor);
|
|
break;
|
|
|
|
case SelectionStartTrim:
|
|
if (clicked_axisview) {
|
|
clicked_axisview->order_selection_trims (item, true);
|
|
}
|
|
start_grab (event, trimmer_cursor);
|
|
start = selection->time[clicked_selection].start;
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - start;
|
|
break;
|
|
|
|
case SelectionEndTrim:
|
|
if (clicked_axisview) {
|
|
clicked_axisview->order_selection_trims (item, false);
|
|
}
|
|
start_grab (event, trimmer_cursor);
|
|
end = selection->time[clicked_selection].end;
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - end;
|
|
break;
|
|
|
|
case SelectionMove:
|
|
start = selection->time[clicked_selection].start;
|
|
start_grab (event);
|
|
drag_info.pointer_frame_offset = drag_info.grab_frame - start;
|
|
break;
|
|
}
|
|
|
|
if (selection_op == SelectionMove) {
|
|
show_verbose_time_cursor(start, 10);
|
|
} else {
|
|
show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::drag_selection (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
nframes64_t start = 0;
|
|
nframes64_t end = 0;
|
|
nframes64_t length;
|
|
nframes64_t pending_position;
|
|
|
|
if (drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
|
|
pending_position = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
|
|
} else {
|
|
pending_position = 0;
|
|
}
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (pending_position);
|
|
}
|
|
|
|
/* only alter selection if the current frame is
|
|
different from the last frame position (adjusted)
|
|
*/
|
|
|
|
if (pending_position == drag_info.last_pointer_frame) return;
|
|
|
|
switch (selection_op) {
|
|
case CreateSelection:
|
|
|
|
if (drag_info.first_move) {
|
|
snap_to (drag_info.grab_frame);
|
|
}
|
|
|
|
if (pending_position < drag_info.grab_frame) {
|
|
start = pending_position;
|
|
end = drag_info.grab_frame;
|
|
} else {
|
|
end = pending_position;
|
|
start = drag_info.grab_frame;
|
|
}
|
|
|
|
/* first drag: Either add to the selection
|
|
or create a new selection->
|
|
*/
|
|
|
|
if (drag_info.first_move) {
|
|
|
|
begin_reversible_command (_("range selection"));
|
|
|
|
if (drag_info.copy) {
|
|
/* adding to the selection */
|
|
clicked_selection = selection->add (start, end);
|
|
drag_info.copy = false;
|
|
} else {
|
|
/* new selection-> */
|
|
clicked_selection = selection->set (clicked_axisview, start, end);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SelectionStartTrim:
|
|
|
|
if (drag_info.first_move) {
|
|
begin_reversible_command (_("trim selection start"));
|
|
}
|
|
|
|
start = selection->time[clicked_selection].start;
|
|
end = selection->time[clicked_selection].end;
|
|
|
|
if (pending_position > end) {
|
|
start = end;
|
|
} else {
|
|
start = pending_position;
|
|
}
|
|
break;
|
|
|
|
case SelectionEndTrim:
|
|
|
|
if (drag_info.first_move) {
|
|
begin_reversible_command (_("trim selection end"));
|
|
}
|
|
|
|
start = selection->time[clicked_selection].start;
|
|
end = selection->time[clicked_selection].end;
|
|
|
|
if (pending_position < start) {
|
|
end = start;
|
|
} else {
|
|
end = pending_position;
|
|
}
|
|
|
|
break;
|
|
|
|
case SelectionMove:
|
|
|
|
if (drag_info.first_move) {
|
|
begin_reversible_command (_("move selection"));
|
|
}
|
|
|
|
start = selection->time[clicked_selection].start;
|
|
end = selection->time[clicked_selection].end;
|
|
|
|
length = end - start;
|
|
|
|
start = pending_position;
|
|
snap_to (start);
|
|
|
|
end = start + length;
|
|
|
|
break;
|
|
}
|
|
|
|
if (event->button.x >= horizontal_adjustment.get_value() + canvas_width) {
|
|
start_canvas_autoscroll (1, 0);
|
|
}
|
|
|
|
if (start != end) {
|
|
selection->replace (clicked_selection, start, end);
|
|
}
|
|
|
|
drag_info.last_pointer_frame = pending_position;
|
|
drag_info.first_move = false;
|
|
|
|
if (selection_op == SelectionMove) {
|
|
show_verbose_time_cursor(start, 10);
|
|
} else {
|
|
show_verbose_time_cursor(pending_position, 10);
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::end_selection_op (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (!drag_info.first_move) {
|
|
drag_selection (item, event);
|
|
/* XXX this is not object-oriented programming at all. ick */
|
|
if (selection->time.consolidate()) {
|
|
selection->TimeChanged ();
|
|
}
|
|
commit_reversible_command ();
|
|
} else {
|
|
/* just a click, no pointer movement.*/
|
|
|
|
if (Keyboard::no_modifier_keys_pressed (&event->button)) {
|
|
|
|
selection->clear_time();
|
|
|
|
}
|
|
}
|
|
|
|
/* XXX what happens if its a music selection? */
|
|
session->set_audio_range (selection->time);
|
|
stop_canvas_autoscroll ();
|
|
}
|
|
|
|
void
|
|
Editor::start_trim (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
double speed = 1.0;
|
|
TimeAxisView* tvp = clicked_axisview;
|
|
RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
|
|
|
|
if (tv && tv->is_track()) {
|
|
speed = tv->get_diskstream()->speed();
|
|
}
|
|
|
|
nframes64_t region_start = (nframes64_t) (clicked_regionview->region()->position() / speed);
|
|
nframes64_t region_end = (nframes64_t) (clicked_regionview->region()->last_frame() / speed);
|
|
nframes64_t region_length = (nframes64_t) (clicked_regionview->region()->length() / speed);
|
|
|
|
//drag_info.item = clicked_regionview->get_name_highlight();
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::trim_motion_callback;
|
|
drag_info.finished_callback = &Editor::trim_finished_callback;
|
|
|
|
start_grab (event, trimmer_cursor);
|
|
|
|
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
|
|
trim_op = ContentsTrim;
|
|
} else {
|
|
/* These will get overridden for a point trim.*/
|
|
if (drag_info.current_pointer_frame < (region_start + region_length/2)) {
|
|
/* closer to start */
|
|
trim_op = StartTrim;
|
|
} else if (drag_info.current_pointer_frame > (region_end - region_length/2)) {
|
|
/* closer to end */
|
|
trim_op = EndTrim;
|
|
}
|
|
}
|
|
|
|
switch (trim_op) {
|
|
case StartTrim:
|
|
show_verbose_time_cursor(region_start, 10);
|
|
break;
|
|
case EndTrim:
|
|
show_verbose_time_cursor(region_end, 10);
|
|
break;
|
|
case ContentsTrim:
|
|
show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::trim_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
RegionView* rv = clicked_regionview;
|
|
nframes64_t frame_delta = 0;
|
|
bool left_direction;
|
|
bool obey_snap = !Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier());
|
|
|
|
/* snap modifier works differently here..
|
|
its' current state has to be passed to the
|
|
various trim functions in order to work properly
|
|
*/
|
|
|
|
double speed = 1.0;
|
|
TimeAxisView* tvp = clicked_axisview;
|
|
RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
|
|
pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
|
|
|
|
if (tv && tv->is_track()) {
|
|
speed = tv->get_diskstream()->speed();
|
|
}
|
|
|
|
if (drag_info.last_pointer_frame > drag_info.current_pointer_frame) {
|
|
left_direction = true;
|
|
} else {
|
|
left_direction = false;
|
|
}
|
|
|
|
if (obey_snap) {
|
|
snap_to (drag_info.current_pointer_frame);
|
|
}
|
|
|
|
if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) {
|
|
return;
|
|
}
|
|
|
|
if (drag_info.first_move) {
|
|
|
|
string trim_type;
|
|
|
|
switch (trim_op) {
|
|
case StartTrim:
|
|
trim_type = "Region start trim";
|
|
break;
|
|
case EndTrim:
|
|
trim_type = "Region end trim";
|
|
break;
|
|
case ContentsTrim:
|
|
trim_type = "Region content trim";
|
|
break;
|
|
}
|
|
|
|
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)->region()->freeze ();
|
|
|
|
AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
|
|
if (arv)
|
|
arv->temporarily_hide_envelope ();
|
|
|
|
boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
|
|
insert_result = motion_frozen_playlists.insert (pl);
|
|
if (insert_result.second) {
|
|
session->add_command(new MementoCommand<Playlist>(*pl, &pl->get_state(), 0));
|
|
pl->freeze();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (left_direction) {
|
|
frame_delta = (drag_info.last_pointer_frame - drag_info.current_pointer_frame);
|
|
} else {
|
|
frame_delta = (drag_info.current_pointer_frame - drag_info.last_pointer_frame);
|
|
}
|
|
|
|
switch (trim_op) {
|
|
case StartTrim:
|
|
if ((left_direction == false) && (drag_info.current_pointer_frame <= rv->region()->first_frame()/speed)) {
|
|
break;
|
|
} else {
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
|
|
single_start_trim (**i, frame_delta, left_direction, obey_snap);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case EndTrim:
|
|
if ((left_direction == true) && (drag_info.current_pointer_frame > (nframes64_t) (rv->region()->last_frame()/speed))) {
|
|
break;
|
|
} else {
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
|
|
single_end_trim (**i, frame_delta, left_direction, obey_snap);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ContentsTrim:
|
|
{
|
|
bool swap_direction = false;
|
|
|
|
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
|
|
swap_direction = true;
|
|
}
|
|
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin();
|
|
i != selection->regions.by_layer().end(); ++i)
|
|
{
|
|
single_contents_trim (**i, frame_delta, left_direction, swap_direction, obey_snap);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch (trim_op) {
|
|
case StartTrim:
|
|
show_verbose_time_cursor((nframes64_t) (rv->region()->position()/speed), 10);
|
|
break;
|
|
case EndTrim:
|
|
show_verbose_time_cursor((nframes64_t) (rv->region()->last_frame()/speed), 10);
|
|
break;
|
|
case ContentsTrim:
|
|
show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
|
|
break;
|
|
}
|
|
|
|
drag_info.last_pointer_frame = drag_info.current_pointer_frame;
|
|
drag_info.first_move = false;
|
|
}
|
|
|
|
void
|
|
Editor::single_contents_trim (RegionView& rv, nframes64_t frame_delta, bool left_direction, bool swap_direction, bool obey_snap)
|
|
{
|
|
boost::shared_ptr<Region> region (rv.region());
|
|
|
|
if (region->locked()) {
|
|
return;
|
|
}
|
|
|
|
nframes64_t new_bound;
|
|
|
|
double speed = 1.0;
|
|
TimeAxisView* tvp = clicked_axisview;
|
|
RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
|
|
|
|
if (tv && tv->is_track()) {
|
|
speed = tv->get_diskstream()->speed();
|
|
}
|
|
|
|
if (left_direction) {
|
|
if (swap_direction) {
|
|
new_bound = (nframes64_t) (region->position()/speed) + frame_delta;
|
|
} else {
|
|
new_bound = (nframes64_t) (region->position()/speed) - frame_delta;
|
|
}
|
|
} else {
|
|
if (swap_direction) {
|
|
new_bound = (nframes64_t) (region->position()/speed) - frame_delta;
|
|
} else {
|
|
new_bound = (nframes64_t) (region->position()/speed) + frame_delta;
|
|
}
|
|
}
|
|
|
|
if (obey_snap) {
|
|
snap_to (new_bound);
|
|
}
|
|
region->trim_start ((nframes64_t) (new_bound * speed), this);
|
|
rv.region_changed (StartChanged);
|
|
}
|
|
|
|
void
|
|
Editor::single_start_trim (RegionView& rv, nframes64_t frame_delta, bool left_direction, bool obey_snap)
|
|
{
|
|
boost::shared_ptr<Region> region (rv.region());
|
|
|
|
if (region->locked()) {
|
|
return;
|
|
}
|
|
|
|
nframes64_t new_bound;
|
|
|
|
double speed = 1.0;
|
|
TimeAxisView* tvp = clicked_axisview;
|
|
RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
|
|
|
|
if (tv && tv->is_track()) {
|
|
speed = tv->get_diskstream()->speed();
|
|
}
|
|
|
|
if (left_direction) {
|
|
new_bound = (nframes64_t) (region->position()/speed) - frame_delta;
|
|
} else {
|
|
new_bound = (nframes64_t) (region->position()/speed) + frame_delta;
|
|
}
|
|
|
|
if (obey_snap) {
|
|
snap_to (new_bound, (left_direction ? 0 : 1));
|
|
}
|
|
|
|
region->trim_front ((nframes64_t) (new_bound * speed), this);
|
|
|
|
rv.region_changed (Change (LengthChanged|PositionChanged|StartChanged));
|
|
}
|
|
|
|
void
|
|
Editor::single_end_trim (RegionView& rv, nframes64_t frame_delta, bool left_direction, bool obey_snap)
|
|
{
|
|
boost::shared_ptr<Region> region (rv.region());
|
|
|
|
if (region->locked()) {
|
|
return;
|
|
}
|
|
|
|
nframes64_t new_bound;
|
|
|
|
double speed = 1.0;
|
|
TimeAxisView* tvp = clicked_axisview;
|
|
RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
|
|
|
|
if (tv && tv->is_track()) {
|
|
speed = tv->get_diskstream()->speed();
|
|
}
|
|
|
|
if (left_direction) {
|
|
new_bound = (nframes64_t) ((region->last_frame() + 1)/speed) - frame_delta;
|
|
} else {
|
|
new_bound = (nframes64_t) ((region->last_frame() + 1)/speed) + frame_delta;
|
|
}
|
|
|
|
if (obey_snap) {
|
|
snap_to (new_bound);
|
|
}
|
|
region->trim_end ((nframes64_t) (new_bound * speed), this);
|
|
rv.region_changed (LengthChanged);
|
|
}
|
|
|
|
void
|
|
Editor::trim_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (!drag_info.first_move) {
|
|
trim_motion_callback (item, event);
|
|
|
|
if (!selection->selected (clicked_regionview)) {
|
|
thaw_region_after_trim (*clicked_regionview);
|
|
} else {
|
|
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin();
|
|
i != selection->regions.by_layer().end(); ++i)
|
|
{
|
|
thaw_region_after_trim (**i);
|
|
(*i)->fake_set_opaque (true);
|
|
}
|
|
}
|
|
|
|
for (set<boost::shared_ptr<Playlist> >::iterator p = motion_frozen_playlists.begin(); p != motion_frozen_playlists.end(); ++p) {
|
|
(*p)->thaw ();
|
|
session->add_command (new MementoCommand<Playlist>(*(*p).get(), 0, &(*p)->get_state()));
|
|
}
|
|
|
|
motion_frozen_playlists.clear ();
|
|
|
|
commit_reversible_command();
|
|
} else {
|
|
/* no mouse movement */
|
|
point_trim (event);
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::point_trim (GdkEvent* event)
|
|
{
|
|
RegionView* rv = clicked_regionview;
|
|
nframes64_t new_bound = drag_info.current_pointer_frame;
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (new_bound);
|
|
}
|
|
|
|
/* Choose action dependant on which button was pressed */
|
|
switch (event->button.button) {
|
|
case 1:
|
|
trim_op = StartTrim;
|
|
begin_reversible_command (_("Start point trim"));
|
|
|
|
if (selection->selected (rv)) {
|
|
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin();
|
|
i != selection->regions.by_layer().end(); ++i)
|
|
{
|
|
if (!(*i)->region()->locked()) {
|
|
boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
|
|
XMLNode &before = pl->get_state();
|
|
(*i)->region()->trim_front (new_bound, this);
|
|
XMLNode &after = pl->get_state();
|
|
session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!rv->region()->locked()) {
|
|
boost::shared_ptr<Playlist> pl = rv->region()->playlist();
|
|
XMLNode &before = pl->get_state();
|
|
rv->region()->trim_front (new_bound, this);
|
|
XMLNode &after = pl->get_state();
|
|
session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
|
|
}
|
|
}
|
|
|
|
commit_reversible_command();
|
|
|
|
break;
|
|
case 2:
|
|
trim_op = EndTrim;
|
|
begin_reversible_command (_("End point trim"));
|
|
|
|
if (selection->selected (rv)) {
|
|
|
|
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i)
|
|
{
|
|
if (!(*i)->region()->locked()) {
|
|
boost::shared_ptr<Playlist> pl = (*i)->region()->playlist();
|
|
XMLNode &before = pl->get_state();
|
|
(*i)->region()->trim_end (new_bound, this);
|
|
XMLNode &after = pl->get_state();
|
|
session->add_command(new MementoCommand<Playlist>(*pl.get(), &before, &after));
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!rv->region()->locked()) {
|
|
boost::shared_ptr<Playlist> pl = rv->region()->playlist();
|
|
XMLNode &before = pl->get_state();
|
|
rv->region()->trim_end (new_bound, this);
|
|
XMLNode &after = pl->get_state();
|
|
session->add_command (new MementoCommand<Playlist>(*pl.get(), &before, &after));
|
|
}
|
|
}
|
|
|
|
commit_reversible_command();
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::thaw_region_after_trim (RegionView& rv)
|
|
{
|
|
boost::shared_ptr<Region> region (rv.region());
|
|
|
|
if (region->locked()) {
|
|
return;
|
|
}
|
|
|
|
region->thaw (_("trimmed region"));
|
|
XMLNode &after = region->playlist()->get_state();
|
|
session->add_command (new MementoCommand<Playlist>(*(region->playlist()), 0, &after));
|
|
|
|
AudioRegionView* arv = dynamic_cast<AudioRegionView*>(&rv);
|
|
if (arv)
|
|
arv->unhide_envelope ();
|
|
}
|
|
|
|
void
|
|
Editor::hide_marker (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
Marker* marker;
|
|
bool is_start;
|
|
|
|
if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
|
|
fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
|
|
/*NOTREACHED*/
|
|
}
|
|
|
|
Location* location = find_location_from_marker (marker, is_start);
|
|
location->set_hidden (true, this);
|
|
}
|
|
|
|
|
|
void
|
|
Editor::start_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event, RangeMarkerOp op)
|
|
{
|
|
if (session == 0) {
|
|
return;
|
|
}
|
|
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::drag_range_markerbar_op;
|
|
drag_info.finished_callback = &Editor::end_range_markerbar_op;
|
|
|
|
range_marker_op = op;
|
|
|
|
if (!temp_location) {
|
|
temp_location = new Location;
|
|
}
|
|
|
|
switch (op) {
|
|
case CreateRangeMarker:
|
|
case CreateTransportMarker:
|
|
case CreateCDMarker:
|
|
|
|
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::TertiaryModifier)) {
|
|
drag_info.copy = true;
|
|
} else {
|
|
drag_info.copy = false;
|
|
}
|
|
start_grab (event, selector_cursor);
|
|
break;
|
|
}
|
|
|
|
show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
|
|
|
|
}
|
|
|
|
void
|
|
Editor::drag_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
nframes64_t start = 0;
|
|
nframes64_t end = 0;
|
|
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);
|
|
}
|
|
|
|
/* only alter selection if the current frame is
|
|
different from the last frame position.
|
|
*/
|
|
|
|
if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) return;
|
|
|
|
switch (range_marker_op) {
|
|
case CreateRangeMarker:
|
|
case CreateTransportMarker:
|
|
case CreateCDMarker:
|
|
if (drag_info.first_move) {
|
|
snap_to (drag_info.grab_frame);
|
|
}
|
|
|
|
if (drag_info.current_pointer_frame < drag_info.grab_frame) {
|
|
start = drag_info.current_pointer_frame;
|
|
end = drag_info.grab_frame;
|
|
} else {
|
|
end = drag_info.current_pointer_frame;
|
|
start = drag_info.grab_frame;
|
|
}
|
|
|
|
/* first drag: Either add to the selection
|
|
or create a new selection.
|
|
*/
|
|
|
|
if (drag_info.first_move) {
|
|
|
|
temp_location->set (start, end);
|
|
|
|
crect->show ();
|
|
|
|
update_marker_drag_item (temp_location);
|
|
range_marker_drag_rect->show();
|
|
//range_marker_drag_rect->raise_to_top();
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (event->button.x >= horizontal_adjustment.get_value() + canvas_width) {
|
|
start_canvas_autoscroll (1, 0);
|
|
}
|
|
|
|
if (start != end) {
|
|
temp_location->set (start, end);
|
|
|
|
double x1 = frame_to_pixel (start);
|
|
double x2 = frame_to_pixel (end);
|
|
crect->property_x1() = x1;
|
|
crect->property_x2() = x2;
|
|
|
|
update_marker_drag_item (temp_location);
|
|
}
|
|
|
|
drag_info.last_pointer_frame = drag_info.current_pointer_frame;
|
|
drag_info.first_move = false;
|
|
|
|
show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
|
|
|
|
}
|
|
|
|
void
|
|
Editor::end_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
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");
|
|
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_marker_drag_rect->hide();
|
|
break;
|
|
}
|
|
|
|
case CreateTransportMarker:
|
|
// popup menu to pick loop or punch
|
|
new_transport_marker_context_menu (&event->button, item);
|
|
|
|
break;
|
|
}
|
|
} else {
|
|
/* just a click, no pointer movement. remember that context menu stuff was handled elsewhere */
|
|
|
|
if (Keyboard::no_modifier_keys_pressed (&event->button) && range_marker_op != CreateCDMarker) {
|
|
|
|
nframes64_t start;
|
|
nframes64_t end;
|
|
|
|
start = session->locations()->first_mark_before (drag_info.grab_frame);
|
|
end = session->locations()->first_mark_after (drag_info.grab_frame);
|
|
|
|
if (end == max_frames) {
|
|
end = session->current_end_frame ();
|
|
}
|
|
|
|
if (start == 0) {
|
|
start = session->current_start_frame ();
|
|
}
|
|
|
|
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, track_views, Selection::Set);
|
|
break;
|
|
|
|
case MouseRange:
|
|
/* find the two markers on either side of the click and make the range out of it */
|
|
selection->set (0, start, end);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
stop_canvas_autoscroll ();
|
|
}
|
|
|
|
|
|
|
|
void
|
|
Editor::start_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::drag_mouse_zoom;
|
|
drag_info.finished_callback = &Editor::end_mouse_zoom;
|
|
|
|
start_grab (event, zoom_cursor);
|
|
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::drag_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
nframes64_t start;
|
|
nframes64_t end;
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (drag_info.current_pointer_frame);
|
|
|
|
if (drag_info.first_move) {
|
|
snap_to (drag_info.grab_frame);
|
|
}
|
|
}
|
|
|
|
if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) return;
|
|
|
|
/* base start and end on initial click position */
|
|
if (drag_info.current_pointer_frame < drag_info.grab_frame) {
|
|
start = drag_info.current_pointer_frame;
|
|
end = drag_info.grab_frame;
|
|
} else {
|
|
end = drag_info.current_pointer_frame;
|
|
start = drag_info.grab_frame;
|
|
}
|
|
|
|
if (start != end) {
|
|
|
|
if (drag_info.first_move) {
|
|
zoom_rect->show();
|
|
zoom_rect->raise_to_top();
|
|
}
|
|
|
|
reposition_zoom_rect(start, end);
|
|
|
|
drag_info.last_pointer_frame = drag_info.current_pointer_frame;
|
|
drag_info.first_move = false;
|
|
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::end_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (!drag_info.first_move) {
|
|
drag_mouse_zoom (item, event);
|
|
|
|
if (drag_info.grab_frame < drag_info.last_pointer_frame) {
|
|
temporal_zoom_by_frame (drag_info.grab_frame, drag_info.last_pointer_frame, "mouse zoom");
|
|
} else {
|
|
temporal_zoom_by_frame (drag_info.last_pointer_frame, drag_info.grab_frame, "mouse zoom");
|
|
}
|
|
} else {
|
|
temporal_zoom_to_frame (false, drag_info.grab_frame);
|
|
/*
|
|
temporal_zoom_step (false);
|
|
center_screen (drag_info.grab_frame);
|
|
*/
|
|
}
|
|
|
|
zoom_rect->hide();
|
|
}
|
|
|
|
void
|
|
Editor::reposition_zoom_rect (nframes64_t start, nframes64_t end)
|
|
{
|
|
double x1 = frame_to_pixel (start);
|
|
double x2 = frame_to_pixel (end);
|
|
double y2 = full_canvas_height - 1.0;
|
|
|
|
zoom_rect->property_x1() = x1;
|
|
zoom_rect->property_y1() = 1.0;
|
|
zoom_rect->property_x2() = x2;
|
|
zoom_rect->property_y2() = y2;
|
|
}
|
|
|
|
void
|
|
Editor::start_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::drag_rubberband_select;
|
|
drag_info.finished_callback = &Editor::end_rubberband_select;
|
|
|
|
start_grab (event, cross_hair_cursor);
|
|
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::drag_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
nframes64_t start;
|
|
nframes64_t end;
|
|
double y1;
|
|
double y2;
|
|
|
|
/* use a bigger drag threshold than the default */
|
|
|
|
if (abs ((int) (drag_info.current_pointer_frame - drag_info.grab_frame)) < 8) {
|
|
return;
|
|
}
|
|
|
|
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);
|
|
}
|
|
snap_to (drag_info.current_pointer_frame);
|
|
}
|
|
|
|
/* base start and end on initial click position */
|
|
|
|
if (drag_info.current_pointer_frame < drag_info.grab_frame) {
|
|
start = drag_info.current_pointer_frame;
|
|
end = drag_info.grab_frame;
|
|
} else {
|
|
end = drag_info.current_pointer_frame;
|
|
start = drag_info.grab_frame;
|
|
}
|
|
|
|
if (drag_info.current_pointer_y < drag_info.grab_y) {
|
|
y1 = drag_info.current_pointer_y;
|
|
y2 = drag_info.grab_y;
|
|
} else {
|
|
y2 = drag_info.current_pointer_y;
|
|
y1 = drag_info.grab_y;
|
|
}
|
|
|
|
|
|
if (start != end || y1 != y2) {
|
|
|
|
double x1 = frame_to_pixel (start);
|
|
double x2 = frame_to_pixel (end);
|
|
|
|
rubberband_rect->property_x1() = x1;
|
|
rubberband_rect->property_y1() = y1;
|
|
rubberband_rect->property_x2() = x2;
|
|
rubberband_rect->property_y2() = y2;
|
|
|
|
rubberband_rect->show();
|
|
rubberband_rect->raise_to_top();
|
|
|
|
drag_info.last_pointer_frame = drag_info.current_pointer_frame;
|
|
drag_info.first_move = false;
|
|
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::end_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
if (!drag_info.first_move) {
|
|
|
|
drag_rubberband_select (item, event);
|
|
|
|
double y1,y2;
|
|
if (drag_info.current_pointer_y < drag_info.grab_y) {
|
|
y1 = drag_info.current_pointer_y;
|
|
y2 = drag_info.grab_y;
|
|
} else {
|
|
y2 = drag_info.current_pointer_y;
|
|
y1 = drag_info.grab_y;
|
|
}
|
|
|
|
|
|
Selection::Operation op = Keyboard::selection_type (event->button.state);
|
|
bool commit;
|
|
|
|
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, track_views, op);
|
|
} else {
|
|
commit = select_all_within (drag_info.last_pointer_frame, drag_info.grab_frame, y1, y2, track_views, op);
|
|
}
|
|
|
|
if (commit) {
|
|
commit_reversible_command ();
|
|
}
|
|
|
|
} else {
|
|
if (!getenv("ARDOUR_SAE")) {
|
|
selection->clear_tracks();
|
|
}
|
|
selection->clear_regions();
|
|
selection->clear_points ();
|
|
selection->clear_lines ();
|
|
}
|
|
|
|
rubberband_rect->hide();
|
|
}
|
|
|
|
|
|
gint
|
|
Editor::mouse_rename_region (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
using namespace Gtkmm2ext;
|
|
|
|
ArdourPrompter prompter (false);
|
|
|
|
prompter.set_prompt (_("Name for region:"));
|
|
prompter.set_initial_text (clicked_regionview->region()->name());
|
|
prompter.add_button (_("Rename"), Gtk::RESPONSE_ACCEPT);
|
|
prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
|
|
prompter.show_all ();
|
|
switch (prompter.run ()) {
|
|
case Gtk::RESPONSE_ACCEPT:
|
|
string str;
|
|
prompter.get_result(str);
|
|
if (str.length()) {
|
|
clicked_regionview->region()->set_name (str);
|
|
}
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void
|
|
Editor::start_time_fx (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
drag_info.item = item;
|
|
drag_info.motion_callback = &Editor::time_fx_motion;
|
|
drag_info.finished_callback = &Editor::end_time_fx;
|
|
|
|
start_grab (event);
|
|
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::time_fx_motion (ArdourCanvas::Item *item, GdkEvent* event)
|
|
{
|
|
RegionView* rv = clicked_regionview;
|
|
|
|
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
|
|
snap_to (drag_info.current_pointer_frame);
|
|
}
|
|
|
|
if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) {
|
|
return;
|
|
}
|
|
|
|
if (drag_info.current_pointer_frame > rv->region()->position()) {
|
|
rv->get_time_axis_view().show_timestretch (rv->region()->position(), drag_info.current_pointer_frame);
|
|
}
|
|
|
|
drag_info.last_pointer_frame = drag_info.current_pointer_frame;
|
|
drag_info.first_move = false;
|
|
|
|
show_verbose_time_cursor (drag_info.current_pointer_frame, 10);
|
|
}
|
|
|
|
void
|
|
Editor::end_time_fx (ArdourCanvas::Item* item, GdkEvent* event)
|
|
{
|
|
clicked_regionview->get_time_axis_view().hide_timestretch ();
|
|
|
|
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;
|
|
}
|
|
|
|
nframes64_t newlen = drag_info.last_pointer_frame - clicked_regionview->region()->position();
|
|
|
|
float percentage = (double) newlen / (double) clicked_regionview->region()->length();
|
|
|
|
#ifndef USE_RUBBERBAND
|
|
// Soundtouch uses percentage / 100 instead of normal (/ 1)
|
|
if (clicked_regionview->region()->data_type() == DataType::AUDIO) {
|
|
percentage = (float) ((double) newlen - (double) clicked_regionview->region()->length()) / ((double) newlen) * 100.0f;
|
|
}
|
|
#endif
|
|
|
|
begin_reversible_command (_("timestretch"));
|
|
|
|
// XXX how do timeFX on multiple regions ?
|
|
|
|
RegionSelection rs;
|
|
rs.add (clicked_regionview);
|
|
|
|
if (time_stretch (rs, percentage) == 0) {
|
|
session->commit_reversible_command ();
|
|
}
|
|
}
|
|
|
|
void
|
|
Editor::mouse_brush_insert_region (RegionView* rv, nframes64_t pos)
|
|
{
|
|
/* no brushing without a useful snap setting */
|
|
|
|
switch (snap_mode) {
|
|
case SnapMagnetic:
|
|
return; /* can't work because it allows region to be placed anywhere */
|
|
default:
|
|
break; /* OK */
|
|
}
|
|
|
|
switch (snap_type) {
|
|
case SnapToMark:
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* don't brush a copy over the original */
|
|
|
|
if (pos == rv->region()->position()) {
|
|
return;
|
|
}
|
|
|
|
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&rv->get_time_axis_view());
|
|
|
|
if (rtv == 0 || !rtv->is_track()) {
|
|
return;
|
|
}
|
|
|
|
boost::shared_ptr<Playlist> playlist = rtv->playlist();
|
|
double speed = rtv->get_diskstream()->speed();
|
|
|
|
XMLNode &before = playlist->get_state();
|
|
playlist->add_region (RegionFactory::create (rv->region()), (nframes64_t) (pos * speed));
|
|
XMLNode &after = playlist->get_state();
|
|
session->add_command(new MementoCommand<Playlist>(*playlist.get(), &before, &after));
|
|
|
|
// playlist is frozen, so we have to update manually
|
|
|
|
playlist->Modified(); /* EMIT SIGNAL */
|
|
}
|
|
|
|
gint
|
|
Editor::track_height_step_timeout ()
|
|
{
|
|
if (get_microseconds() - last_track_height_step_timestamp < 250000) {
|
|
current_stepping_trackview = 0;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|