/*
- 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.
-
-*/
+ * Copyright (C) 2005-2006 Taybin Rutkin <taybin@taybin.com>
+ * Copyright (C) 2005-2018 Paul Davis <paul@linuxaudiosystems.com>
+ * Copyright (C) 2006-2015 David Robillard <d@drobilla.net>
+ * Copyright (C) 2006-2016 Tim Mayberry <mojofunk@gmail.com>
+ * Copyright (C) 2006 Sampo Savolainen <v2@iki.fi>
+ * Copyright (C) 2007-2012 Carl Hetherington <carl@carlh.net>
+ * Copyright (C) 2007 Doug McLain <doug@nostar.net>
+ * Copyright (C) 2013-2014 Colin Fletcher <colin.m.fletcher@googlemail.com>
+ * Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org>
+ * Copyright (C) 2014-2017 Nick Mainsbridge <mainsbridge@gmail.com>
+ * Copyright (C) 2014-2018 Ben Loftis <ben@harrisonconsoles.com>
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
#include <cassert>
#include <cstdlib>
#include "gtkmm2ext/bindings.h"
#include "gtkmm2ext/utils.h"
-#include "gtkmm2ext/tearoff.h"
#include "canvas/canvas.h"
+#include "ardour/audioplaylist.h"
#include "ardour/audioregion.h"
#include "ardour/operations.h"
#include "ardour/playlist.h"
#include "ardour/session.h"
#include "ardour/types.h"
-#include "ardour_ui.h"
+#include "widgets/prompter.h"
+
#include "actions.h"
+#include "ardour_ui.h"
#include "editor.h"
#include "time_axis_view.h"
#include "audio_time_axis.h"
#include "marker.h"
#include "streamview.h"
#include "region_gain_line.h"
+#include "rc_option_editor.h"
#include "automation_time_axis.h"
#include "control_point.h"
-#include "prompter.h"
#include "selection.h"
#include "keyboard.h"
#include "editing.h"
#include "verbose_cursor.h"
#include "note.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
using Gtkmm2ext::Keyboard;
bool
-Editor::mouse_frame (framepos_t& where, bool& in_track_canvas) const
+Editor::mouse_sample (samplepos_t& where, bool& in_track_canvas) const
{
- /* gdk_window_get_pointer() has X11's XQueryPointer semantics in that it only
- pays attentions to subwindows. this means that menu windows are ignored, and
- if the pointer is in a menu, the return window from the call will be the
- the regular subwindow *under* the menu.
-
- this matters quite a lot if the pointer is moving around in a menu that overlaps
- the track canvas because we will believe that we are within the track canvas
- when we are not. therefore, we track enter/leave events for the track canvas
- and allow that to override the result of gdk_window_get_pointer().
- */
+ /* gdk_window_get_pointer() has X11's XQueryPointer semantics in that it only
+ * pays attentions to subwindows. this means that menu windows are ignored, and
+ * if the pointer is in a menu, the return window from the call will be the
+ * the regular subwindow *under* the menu.
+ *
+ * this matters quite a lot if the pointer is moving around in a menu that overlaps
+ * the track canvas because we will believe that we are within the track canvas
+ * when we are not. therefore, we track enter/leave events for the track canvas
+ * and allow that to override the result of gdk_window_get_pointer().
+ */
- if (!within_track_canvas) {
- return false;
- }
+ if (!within_track_canvas) {
+ return false;
+ }
int x, y;
Glib::RefPtr<Gdk::Window> canvas_window = const_cast<Editor*>(this)->_track_canvas->get_window();
return true;
}
-framepos_t
+samplepos_t
Editor::window_event_sample (GdkEvent const * event, double* pcx, double* pcy) const
{
ArdourCanvas::Duple d;
return pixel_to_sample (d.x);
}
-framepos_t
+samplepos_t
Editor::canvas_event_sample (GdkEvent const * event, double* pcx, double* pcy) const
{
double x;
/* note that pixel_to_sample_from_event() 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.
+ the sample location is always positive.
*/
return pixel_to_sample_from_event (x);
void
Editor::mouse_mode_object_range_toggled()
{
- MouseMode m = mouse_mode;
-
- Glib::RefPtr<Action> act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-range"));
- assert (act);
- Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic (act);
- assert (tact);
+ set_mouse_mode (mouse_mode, true); /* updates set-mouse-mode-range */
+}
- if (tact->get_active()) {
- m = MouseObject; //Smart mode turned to ON, force editing to Object mode
+bool
+Editor::snap_mode_button_clicked (GdkEventButton* ev)
+{
+ if (ev->button != 3) {
+ cycle_snap_mode();
+ return true;
}
- set_mouse_mode(m, true); //call this so the button styles can get updated
+ RCOptionEditor* rc_option_editor = ARDOUR_UI::instance()->get_rc_option_editor();
+ if (rc_option_editor) {
+ ARDOUR_UI::instance()->show_tabbable (rc_option_editor);
+ rc_option_editor->set_current_page (_("Editor/Snap"));
+ }
+
+ return true;
}
-static Glib::RefPtr<Action>
-get_mouse_mode_action(MouseMode m)
+
+
+Glib::RefPtr<Action>
+Editor::get_mouse_mode_action(MouseMode m) const
{
switch (m) {
case MouseRange:
}
if (ARDOUR::Profile->get_mixbus()) {
- if ( m == MouseCut) m = MouseObject;
+ if (m == MouseAudition) m = MouseRange;
}
Glib::RefPtr<Action> act = get_mouse_mode_action(m);
tact->set_active (false);
tact->set_active (true);
- //NOTE: this will result in a call to mouse_mode_toggled which does the heavy lifting
+ /* NOTE: this will result in a call to mouse_mode_toggled which does the heavy lifting */
}
void
Editor::mouse_mode_toggled (MouseMode m)
{
if (ARDOUR::Profile->get_mixbus()) {
- if ( m == MouseCut) m = MouseObject;
+ if (m == MouseAudition) m = MouseRange;
}
Glib::RefPtr<Action> act = get_mouse_mode_action(m);
_session->request_transport_speed (0.0, true);
}
- if (mouse_mode == m) {
- /* switch to the same mode, act like a toggle and switch back to previous mode */
- Glib::RefPtr<Action> pact = get_mouse_mode_action(previous_mouse_mode);
- Glib::RefPtr<ToggleAction> ptact = Glib::RefPtr<ToggleAction>::cast_dynamic(pact);
- ptact->set_active(true);
- return;
- }
-
const bool was_internal = internal_editing();
- previous_mouse_mode = mouse_mode;
mouse_mode = m;
- if (!was_internal && internal_editing()) {
- /* switched to internal, switch to internal snap settings */
- set_snap_to(internal_snap_type);
- set_snap_mode(internal_snap_mode);
+ /* Switch snap type/mode if we're moving to/from an internal tool. Note
+ this must toggle the actions and not call set_snap_*() directly,
+ otherwise things get out of sync and the combo box stops working. */
+ if (!UIConfiguration::instance().get_grid_follows_internal()) {
+ grid_type_action(pre_internal_grid_type)->set_active(true);
+ snap_mode_action(pre_internal_snap_mode)->set_active(true);
+ } else if (!was_internal && internal_editing()) {
+ grid_type_action(internal_grid_type)->set_active(true);
+ snap_mode_action(internal_snap_mode)->set_active(true);
} else if (was_internal && !internal_editing()) {
- /* switched out of internal, switch to non-internal snap settings */
- set_snap_to(pre_internal_snap_type);
- set_snap_mode(pre_internal_snap_mode);
+ grid_type_action(pre_internal_grid_type)->set_active(true);
+ snap_mode_action(pre_internal_snap_mode)->set_active(true);
}
instant_save ();
}
set_gain_envelope_visibility ();
-
+
update_time_selection_display ();
+ update_all_enter_cursors ();
+
MouseModeChanged (); /* EMIT SIGNAL */
}
void
Editor::update_time_selection_display ()
{
- if (smart_mode_action->get_active()) {
- /* not sure what to do here */
- if (mouse_mode == MouseObject) {
- } else {
- }
- } else {
- switch (mouse_mode) {
- case MouseRange:
- selection->clear_objects ();
- selection->ClearMidiNoteSelection(); //signal
- break;
- case MouseObject:
- selection->clear_objects ();
- selection->clear_time ();
- selection->clear_tracks ();
- selection->ClearMidiNoteSelection(); //signal
- break;
- case MouseContent:
- case MouseDraw:
- //if we go into internal editing, clear everything in the outside world
- selection->clear_objects ();
- selection->clear_time ();
- selection->clear_tracks ();
- break;
- default:
- //clear everything
- selection->clear_objects ();
- selection->clear_time ();
- selection->clear_tracks ();
- break;
- }
+ switch (mouse_mode) {
+ case MouseRange:
+ selection->clear_objects ();
+ selection->clear_midi_notes ();
+ break;
+ case MouseObject:
+ selection->clear_time ();
+ selection->clear_midi_notes ();
+ break;
+ case MouseDraw:
+ /* Clear regions, but not time or tracks, since that
+ would destroy the range selection rectangle, which we need to stick
+ around for AutomationRangeDrag. */
+ selection->clear_regions ();
+ selection->clear_playlists ();
+ break;
+ case MouseContent:
+ /* This handles internal edit.
+ Clear everything except points and notes.
+ */
+ selection->clear_regions();
+ selection->clear_lines();
+ selection->clear_playlists ();
+
+ selection->clear_time ();
+ selection->clear_tracks ();
+ break;
+
+ case MouseTimeFX:
+ /* We probably want to keep region selection */
+ selection->clear_points ();
+ selection->clear_lines();
+ selection->clear_playlists ();
+
+ selection->clear_time ();
+ selection->clear_tracks ();
+ break;
+
+ case MouseAudition:
+ /*Don't lose lines or points if no action in this mode */
+ selection->clear_regions ();
+ selection->clear_playlists ();
+ selection->clear_time ();
+ selection->clear_tracks ();
+ break;
+
+ default:
+ /*Clear everything */
+ selection->clear_objects();
+ selection->clear_time ();
+ selection->clear_tracks ();
+ break;
}
}
}
void
-Editor::button_selection (ArdourCanvas::Item* /*item*/, GdkEvent* event, ItemType item_type)
+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
-
- Also note that there is no region selection in internal edit mode, otherwise
- for operations operating on the selection (e.g. cut) it is not obvious whether
- to cut notes or regions.
- */
+ /* 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
+ *
+ * Also note that there is no region selection in internal edit mode, otherwise
+ * for operations operating on the selection (e.g. cut) it is not obvious whether
+ * to cut notes or regions.
+ */
MouseMode eff_mouse_mode = effective_mouse_mode ();
if (get_smart_mode() && eff_mouse_mode == MouseRange && event->button.button == 3 && item_type == RegionItem) {
/* context clicks are always about object properties, even if
- we're in range mode within smart mode.
- */
+ * we're in range mode within smart mode.
+ */
eff_mouse_mode = MouseObject;
}
/* special case: allow drag of region fade in/out in object mode with join object/range enabled */
if (get_smart_mode()) {
switch (item_type) {
- case FadeInHandleItem:
- case FadeInTrimHandleItem:
- case FadeOutHandleItem:
- case FadeOutTrimHandleItem:
- eff_mouse_mode = MouseObject;
- break;
- default:
- break;
+ case FadeInHandleItem:
+ case FadeInTrimHandleItem:
+ case FadeOutHandleItem:
+ case FadeOutTrimHandleItem:
+ eff_mouse_mode = MouseObject;
+ break;
+ default:
+ break;
}
}
if (((mouse_mode != MouseObject) &&
(mouse_mode != MouseAudition || item_type != RegionItem) &&
(mouse_mode != MouseTimeFX || item_type != RegionItem) &&
- (mouse_mode != MouseDraw)) ||
+ (mouse_mode != MouseDraw) &&
+ (mouse_mode != MouseContent || item_type == RegionItem)) ||
((event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE) || event->button.button > 3)) {
return;
}
/* almost no selection action on modified button-2 or button-3 events */
- if (item_type != RegionItem && event->button.button != 2) {
+ if ((item_type != RegionItem && event->button.button != 2)
+ /* for selection of control points prior to delete (shift-right click) */
+ && !(item_type == ControlPointItem && event->button.button == 3 && event->type == GDK_BUTTON_PRESS)) {
return;
}
}
Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
bool press = (event->type == GDK_BUTTON_PRESS);
+ if (press) {
+ _mouse_changed_selection = false;
+ }
+
switch (item_type) {
- case RegionItem:
- if (press) {
- if (eff_mouse_mode != MouseRange) {
- set_selected_regionview_from_click (press, op);
+ case RegionItem:
+ if (eff_mouse_mode == MouseDraw) {
+ break;
+ }
+ if (press) {
+ if (eff_mouse_mode != MouseRange) {
+ _mouse_changed_selection = set_selected_regionview_from_click (press, op);
+ } else {
+ /* don't change the selection unless the
+ * clicked track is not currently selected. if
+ * so, "collapse" the selection to just this track
+ */
+ if (!selection->selected (clicked_axisview)) {
+ set_selected_track_as_side_effect (Selection::Set);
+ }
+ }
} else {
- /* don't change the selection unless the
- clicked track is not currently selected. if
- so, "collapse" the selection to just this
- track
- */
- if (!selection->selected (clicked_axisview)) {
- set_selected_track_as_side_effect (Selection::Set);
+ if (eff_mouse_mode != MouseRange) {
+ _mouse_changed_selection |= set_selected_regionview_from_click (press, op);
}
}
- } else {
+ break;
+
+ case RegionViewNameHighlight:
+ case RegionViewName:
+ case LeftFrameHandle:
+ case RightFrameHandle:
+ case FadeInHandleItem:
+ case FadeInTrimHandleItem:
+ case FadeInItem:
+ case FadeOutHandleItem:
+ case FadeOutTrimHandleItem:
+ case FadeOutItem:
+ case StartCrossFadeItem:
+ case EndCrossFadeItem:
+ if (get_smart_mode() || eff_mouse_mode != MouseRange) {
+ _mouse_changed_selection |= set_selected_regionview_from_click (press, op);
+ } else if (event->type == GDK_BUTTON_PRESS) {
+ set_selected_track_as_side_effect (op);
+ }
+ break;
+
+ case ControlPointItem:
+ /* for object/track exclusivity, we don't call set_selected_track_as_side_effect (op); */
+
if (eff_mouse_mode != MouseRange) {
- set_selected_regionview_from_click (press, op);
+ if (event->button.button != 3) {
+ _mouse_changed_selection |= set_selected_control_point_from_click (press, op);
+ } else {
+ _mouse_changed_selection |= set_selected_control_point_from_click (press, Selection::Set);
+ }
}
- }
- break;
+ break;
- case RegionViewNameHighlight:
- case RegionViewName:
- case LeftFrameHandle:
- case RightFrameHandle:
- case FadeInHandleItem:
- case FadeInTrimHandleItem:
- case FadeInItem:
- case FadeOutHandleItem:
- case FadeOutTrimHandleItem:
- case FadeOutItem:
- case StartCrossFadeItem:
- case EndCrossFadeItem:
- if (get_smart_mode() || eff_mouse_mode != MouseRange) {
- set_selected_regionview_from_click (press, op);
- } else if (event->type == GDK_BUTTON_PRESS) {
- set_selected_track_as_side_effect (op);
- }
- break;
+ case GainLineItem:
+ if (eff_mouse_mode != MouseRange) {
+ AutomationLine* argl = reinterpret_cast<AutomationLine*> (item->get_data ("line"));
- case ControlPointItem:
- set_selected_track_as_side_effect (op);
- if (eff_mouse_mode != MouseRange) {
- set_selected_control_point_from_click (press, op);
- }
- break;
+ std::list<Selectable*> selectables;
+ uint32_t before, after;
+ samplecnt_t const where = (samplecnt_t) floor (event->button.x * samples_per_pixel) - clicked_regionview->region ()->position ();
- case StreamItem:
- /* for context click, select track */
- if (event->button.button == 3) {
- selection->clear_tracks ();
- set_selected_track_as_side_effect (op);
- }
- break;
+ if (!argl || !argl->control_points_adjacent (where, before, after)) {
+ break;
+ }
- case AutomationTrackItem:
- set_selected_track_as_side_effect (op);
- break;
+ selectables.push_back (argl->nth (before));
+ selectables.push_back (argl->nth (after));
- default:
- break;
+ switch (op) {
+ case Selection::Set:
+ if (press) {
+ selection->set (selectables);
+ _mouse_changed_selection = true;
+ }
+ break;
+ case Selection::Add:
+ if (press) {
+ selection->add (selectables);
+ _mouse_changed_selection = true;
+ }
+ break;
+ case Selection::Toggle:
+ if (press) {
+ selection->toggle (selectables);
+ _mouse_changed_selection = true;
+ }
+ break;
+
+ case Selection::Extend:
+ /* XXX */
+ break;
+ }
+ }
+ break;
+
+ case AutomationLineItem:
+ if (eff_mouse_mode != MouseRange) {
+ AutomationLine* al = reinterpret_cast<AutomationLine*> (item->get_data ("line"));
+ std::list<Selectable*> selectables;
+ double mx = event->button.x;
+ double my = event->button.y;
+
+ al->grab_item().canvas_to_item (mx, my);
+
+ uint32_t before, after;
+ samplecnt_t const where = (samplecnt_t) floor (mx * samples_per_pixel);
+
+ if (!al || !al->control_points_adjacent (where, before, after)) {
+ break;
+ }
+
+ selectables.push_back (al->nth (before));
+ selectables.push_back (al->nth (after));
+
+ switch (op) {
+ case Selection::Set:
+ if (press) {
+ selection->set (selectables);
+ _mouse_changed_selection = true;
+ }
+ break;
+ case Selection::Add:
+ if (press) {
+ selection->add (selectables);
+ _mouse_changed_selection = true;
+ }
+ break;
+ case Selection::Toggle:
+ if (press) {
+ selection->toggle (selectables);
+ _mouse_changed_selection = true;
+ }
+ break;
+
+ case Selection::Extend:
+ /* XXX */
+ break;
+ }
+ }
+ break;
+
+ case StreamItem:
+ /* for context click, select track */
+ if (event->button.button == 3) {
+ selection->clear_tracks ();
+ set_selected_track_as_side_effect (op);
+
+ /* We won't get a release.*/
+ begin_reversible_selection_op (X_("Button 3 Menu Select"));
+ commit_reversible_selection_op ();
+ }
+ break;
+
+ case AutomationTrackItem:
+ if (eff_mouse_mode != MouseDraw && op == Selection::Set) {
+ set_selected_track_as_side_effect (op);
+ }
+ break;
+
+ case NoteItem:
+ if (press && event->button.button == 3) {
+ NoteBase* cnote = reinterpret_cast<NoteBase*> (item->get_data ("notebase"));
+ assert (cnote);
+ if (cnote->region_view().selection_size() == 0 || !cnote->selected()) {
+ selection->clear_points();
+ cnote->region_view().unique_select (cnote);
+ /* we won't get the release, so store the selection change now */
+ begin_reversible_selection_op (X_("Button 3 Note Selection"));
+ commit_reversible_selection_op ();
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ if ((!press) && _mouse_changed_selection) {
+ begin_reversible_selection_op (X_("Button Selection"));
+ commit_reversible_selection_op ();
+ _mouse_changed_selection = false;
}
}
Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
/* 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.
- */
+ * independent of mouse mode, mostly because they are
+ * not on the main track canvas or because we want
+ * them to be modeless.
+ */
NoteBase* note = NULL;
case TempoMarkerItem:
{
- _drags->set (
- new TempoMarkerDrag (
- this,
- item,
- Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)
- ),
- event
- );
+ if (ArdourKeyboard::indicates_constraint (event->button.state)) {
+ _drags->set (
+ new TempoEndDrag (
+ this,
+ item
+ ),
+ event
+ );
+ } else {
+ _drags->set (
+ new TempoMarkerDrag (
+ this,
+ item,
+ ArdourKeyboard::indicates_copy (event->button.state)
+ ),
+ event
+ );
+ }
+
return true;
}
new MeterMarkerDrag (
this,
item,
- Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)
+ ArdourKeyboard::indicates_copy (event->button.state)
),
event
);
case MarkerBarItem:
case TempoBarItem:
+ case TempoCurveItem:
case MeterBarItem:
case TimecodeRulerItem:
case SamplesRulerItem:
case MinsecRulerItem:
case BBTRulerItem:
- if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
+ if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)
+ && !ArdourKeyboard::indicates_constraint (event->button.state)) {
_drags->set (new CursorDrag (this, *playhead_cursor, false), event);
+ } else if (ArdourKeyboard::indicates_constraint (event->button.state)
+ && Keyboard::modifier_state_contains (event->button.state, Keyboard::PrimaryModifier)) {
+ _drags->set (new TempoTwistDrag (this, item), event);
+ } else if (ArdourKeyboard::indicates_constraint (event->button.state)) {
+ _drags->set (new BBTRulerDrag (this, item), event);
}
return true;
break;
if (_join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) {
/* special case: allow trim of range selections in joined object mode;
- in theory eff should equal MouseRange in this case, but it doesn't
- because entering the range selection canvas item results in entered_regionview
- being set to 0, so update_join_object_range_location acts as if we aren't
- over a region.
- */
+ * in theory eff should equal MouseRange in this case, but it doesn't
+ * because entering the range selection canvas item results in entered_regionview
+ * being set to 0, so update_join_object_range_location acts as if we aren't
+ * over a region.
+ */
if (item_type == StartSelectionTrimItem) {
_drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionStartTrim), event);
} else if (item_type == EndSelectionTrimItem) {
Editing::MouseMode eff = effective_mouse_mode ();
/* special case: allow drag of region fade in/out in object mode with join object/range enabled */
- if (get_smart_mode()) {
+ if (get_smart_mode()) {
switch (item_type) {
case FadeInHandleItem:
case FadeInTrimHandleItem:
/* grab selection for moving */
_drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionMove), event);
} else {
- /* this was debated, but decided the more common action was to
- make a new selection */
+ /* this was debated, but decided the more common action was to make a new selection */
_drags->set (new SelectionDrag (this, item, SelectionDrag::CreateSelection), event);
}
break;
case RegionViewName:
case StreamItem:
case AutomationTrackItem:
- _drags->set (new RegionCutDrag (this, item, canvas_event_sample (event)), event, current_canvas_cursor);
+ _drags->set (new RegionCutDrag (this, item, canvas_event_sample (event)), event, get_canvas_cursor());
return true;
break;
default:
/* Existing note: allow trimming/motion */
if ((note = reinterpret_cast<NoteBase*> (item->get_data ("notebase")))) {
if (note->big_enough_to_trim() && note->mouse_near_ends()) {
- _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor);
+ _drags->set (new NoteResizeDrag (this, item), event, get_canvas_cursor());
} else {
_drags->set (new NoteDrag (this, item), event);
}
}
return true;
+ case GainLineItem:
+ _drags->set (new LineDrag (this, item), event);
+ return true;
+ break;
+
case ControlPointItem:
_drags->set (new ControlPointDrag (this, item), event);
return true;
break;
+ case AutomationLineItem:
+ _drags->set (new LineDrag (this, item), event);
+ return true;
+ break;
+
case StreamItem:
- if (dynamic_cast<MidiTimeAxisView*> (clicked_axisview)) {
- _drags->set (new RegionCreateDrag (this, item, clicked_axisview), event);
- return true;
- }
+ /* in the past, we created a new midi region here, but perhaps that is best left to the Draw mode */
break;
case AutomationTrackItem:
/* rubberband drag to select automation points */
_drags->set (new EditorRubberbandSelectDrag (this, item), event);
+ return true;
+ break;
+
+ case RegionItem:
+ if (dynamic_cast<AutomationRegionView*>(clicked_regionview)) {
+ /* rubberband drag to select automation points */
+ _drags->set (new EditorRubberbandSelectDrag (this, item), event);
+ return true;
+ }
break;
default:
case StartCrossFadeItem:
case EndCrossFadeItem:
- /* we might allow user to grab inside the fade to trim a region with preserve_fade_anchor. for not this is not fully implemented */
-// if (!clicked_regionview->region()->locked()) {
-// _drags->set (new TrimDrag (this, item, clicked_regionview, selection->regions.by_layer(), true), event);
-// return true;
-// }
+ /* we might allow user to grab inside the fade to trim a region with preserve_fade_anchor.
+ * For not this is not fully implemented */
+#if 0
+ if (!clicked_regionview->region()->locked()) {
+ _drags->set (new TrimDrag (this, item, clicked_regionview, selection->regions.by_layer(), true), event);
+ return true;
+ }
+#endif
break;
case FeatureLineItem:
}
/* click on a normal region view */
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
+ if (ArdourKeyboard::indicates_copy (event->button.state)) {
add_region_copy_drag (item, event, clicked_regionview);
} else if (Keyboard::the_keyboard().key_is_down (GDK_b)) {
add_region_brush_drag (item, event, clicked_regionview);
_drags->set (new RegionCreateDrag (this, item, parent), event);
} else {
/* See if there's a region before the click that we can extend, and extend it if so */
- framepos_t const t = canvas_event_sample (event);
+ samplepos_t const t = canvas_event_sample (event);
boost::shared_ptr<Region> prev = pl->find_next_region (t, End, -1);
if (!prev) {
_drags->set (new RegionCreateDrag (this, item, parent), event);
} else {
- prev->set_length (t - prev->position ());
+ prev->set_length (t - prev->position (), get_grid_music_divisions (event->button.state));
}
}
} else {
break;
case SelectionItem:
- {
- AudioRegionView* arv = dynamic_cast<AudioRegionView *> (clicked_regionview);
- if (arv) {
- _drags->set (new AutomationRangeDrag (this, arv, selection->time), event, _cursors->up_down);
- } else {
- double const y = event->button.y;
- pair<TimeAxisView*, int> tvp = trackview_by_y_position (y);
- if (tvp.first) {
- AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*> (tvp.first);
- if ( atv) {
- /* smart "join" mode: drag automation */
- _drags->set (new AutomationRangeDrag (this, atv, selection->time), event, _cursors->up_down);
+ {
+ if (selection->time.empty ()) {
+ /* nothing to do */
+ return true;
+ }
+ pair<TimeAxisView*, int> tvp = trackview_by_y_position (event->button.y, false);
+ if (!tvp.first) {
+ /* clicked outside of a track */
+ return true;
+ }
+ /* handle automation lanes first */
+ AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*> (tvp.first);
+ if (atv) {
+ /* smart "join" mode: drag automation */
+ _drags->set (new AutomationRangeDrag (this, atv, selection->time), event, _cursors->up_down);
+ return true;
+ }
+ if (dynamic_cast<AutomationRegionView*>(clicked_regionview)) {
+ /* MIDI CC or similar -- TODO handle multiple? */
+ list<RegionView*> rvl;
+ rvl.push_back (clicked_regionview);
+ _drags->set (new AutomationRangeDrag (this, rvl, selection->time,
+ clicked_regionview->get_time_axis_view().y_position(),
+ clicked_regionview->get_time_axis_view().current_height()),
+ event, _cursors->up_down);
+ return true;
+ }
+
+ /* shift+drag: only apply to clicked_regionview (if any) */
+ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::TertiaryModifier)) {
+ if (dynamic_cast<AudioRegionView*>(clicked_regionview) == 0) {
+ return true;
+ }
+ list<RegionView*> rvl;
+ rvl.push_back (clicked_regionview);
+ // TODO: handle layer_display() == Stacked
+ _drags->set (new AutomationRangeDrag (this, rvl, selection->time,
+ clicked_regionview->get_time_axis_view().y_position(),
+ clicked_regionview->get_time_axis_view().current_height()),
+ event, _cursors->up_down);
+ return true;
+ }
+
+ /* collect all audio regions-views in the given range selection */
+ list<RegionView*> rvl;
+ TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+ for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
+ RouteTimeAxisView* tatv;
+ boost::shared_ptr<Playlist> playlist;
+ if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) == 0) {
+ continue;
+ }
+ if ((playlist = (*i)->playlist()) == 0) {
+ continue;
+ }
+ if (boost::dynamic_pointer_cast<AudioPlaylist> (playlist) == 0) {
+ continue;
+ }
+ for (list<AudioRange>::const_iterator j = selection->time.begin(); j != selection->time.end(); ++j) {
+ boost::shared_ptr<RegionList> rl = playlist->regions_touched (j->start, j->end);
+ for (RegionList::iterator ir = rl->begin(); ir != rl->end(); ++ir) {
+ RegionView* rv;
+ if ((rv = tatv->view()->find_view (*ir)) != 0) {
+ rvl.push_back (rv);
+ }
+ }
}
}
+ /* region-gain drag */
+ if (!rvl.empty ()) {
+ double y_pos = tvp.first->y_position();
+ double height = tvp.first->current_height();
+ StreamView* cv = tvp.first->view ();
+ if (cv->layer_display() == Stacked && cv->layers() > 1) {
+ height /= cv->layers();
+ double yy = event->button.y - _trackview_group->canvas_origin().y;
+ y_pos += floor ((yy - y_pos) / height) * height;
+ }
+ _drags->set (new AutomationRangeDrag (this, rvl, selection->time, y_pos, height),
+ event, _cursors->up_down);
+ }
+ return true;
+ break;
}
- return true;
- break;
- }
case AutomationLineItem:
_drags->set (new LineDrag (this, item), event);
if ((note = reinterpret_cast<NoteBase*>(item->get_data ("notebase")))) {
if (note->big_enough_to_trim() && note->mouse_near_ends()) {
/* Note is big and pointer is near the end, trim */
- _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor);
+ _drags->set (new NoteResizeDrag (this, item), event, get_canvas_cursor());
} else {
/* Drag note */
_drags->set (new NoteDrag (this, item), event);
/* resize-drag notes */
if ((note = reinterpret_cast<NoteBase*>(item->get_data ("notebase")))) {
if (note->big_enough_to_trim()) {
- _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor);
+ _drags->set (new NoteResizeDrag (this, item), event, get_canvas_cursor());
}
}
return true;
break;
case MouseAudition:
- _drags->set (new ScrubDrag (this, item), event);
+ _drags->set (new ScrubDrag (this, item), event, _cursors->transparent);
scrub_reversals = 0;
scrub_reverse_distance = 0;
last_scrub_x = event->button.x;
scrubbing_direction = 0;
- push_canvas_cursor (_cursors->transparent);
return true;
break;
case MouseObject:
switch (item_type) {
case RegionItem:
- if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) {
+ if (ArdourKeyboard::indicates_copy (event->button.state)) {
add_region_copy_drag (item, event, clicked_regionview);
} else {
add_region_drag (item, event, clicked_regionview);
return false;
}
-
+
bool
Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
return false;
}
- pre_press_cursor = current_canvas_cursor;
-
_track_canvas->grab_focus();
if (_session && _session->actively_recording()) {
return true;
}
- //not rolling, range mode click + join_play_range : locate the PH here
- if ( !_drags->active () && !_session->transport_rolling() && ( effective_mouse_mode() == MouseRange ) && Config->get_follow_edits() ) {
- framepos_t where = canvas_event_sample (event);
- snap_to(where);
- _session->request_locate (where, false);
+ /* not rolling, effectively in range mode, follow edits enabled (likely
+ * to start range drag), not in a fade handle (since that means we are
+ * not starting a range drag): locate the PH here
+ */
+
+ if ((item_type != FadeInHandleItem) &&
+ (item_type != FadeOutHandleItem) &&
+ !_drags->active () &&
+ _session &&
+ !_session->transport_rolling() &&
+ (effective_mouse_mode() == MouseRange) &&
+ UIConfiguration::instance().get_follow_edits() &&
+ !_session->config.get_external_sync()) {
+
+ MusicSample where (canvas_event_sample (event), 0);
+ snap_to (where);
+ _session->request_locate (where.sample, false);
}
switch (event->button.button) {
break;
default:
- return button_press_dispatch (&event->button);
+ return button_press_dispatch (&event->button);
break;
}
bool
Editor::button_press_dispatch (GdkEventButton* ev)
{
- /* this function is intended only for buttons 4 and above.
- */
+ /* this function is intended only for buttons 4 and above. */
- Gtkmm2ext::MouseButton b (ev->state, ev->button);
- return button_bindings->activate (b, Gtkmm2ext::Bindings::Press);
+ Gtkmm2ext::MouseButton b (ev->state, ev->button);
+ return button_bindings->activate (b, Gtkmm2ext::Bindings::Press);
}
bool
Editor::button_release_dispatch (GdkEventButton* ev)
{
- /* this function is intended only for buttons 4 and above.
- */
+ /* this function is intended only for buttons 4 and above. */
- Gtkmm2ext::MouseButton b (ev->state, ev->button);
- return button_bindings->activate (b, Gtkmm2ext::Bindings::Release);
+ Gtkmm2ext::MouseButton b (ev->state, ev->button);
+ return button_bindings->activate (b, Gtkmm2ext::Bindings::Release);
}
bool
Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
- framepos_t where = canvas_event_sample (event);
+ MusicSample where (canvas_event_sample (event), 0);
AutomationTimeAxisView* atv = 0;
- if (pre_press_cursor) {
- set_canvas_cursor (pre_press_cursor);
- pre_press_cursor = 0;
- }
+ _press_cursor_ctx.reset();
/* no action if we're recording */
return true;
}
- /* see if we're finishing a drag */
-
bool were_dragging = false;
- if (_drags->active ()) {
- bool const r = _drags->end_grab (event);
- if (r) {
- /* grab dragged, so do nothing else */
- return true;
+
+ if (!Keyboard::is_context_menu_event (&event->button)) {
+
+ /* see if we're finishing a drag */
+
+ if (_drags->active ()) {
+ bool const r = _drags->end_grab (event);
+ if (r) {
+ /* grab dragged, so do nothing else */
+ return true;
+ }
+
+ were_dragging = true;
}
- were_dragging = true;
+ update_region_layering_order_editor ();
}
- update_region_layering_order_editor ();
-
/* edit events get handled here */
if (!_drags->active () && Keyboard::is_edit_event (&event->button)) {
case RegionItem:
show_region_properties ();
break;
-
case TempoMarkerItem: {
- Marker* marker;
+ ArdourMarker* marker;
TempoMarker* tempo_marker;
-
- if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
+
+ if ((marker = reinterpret_cast<ArdourMarker *> (item->get_data ("marker"))) == 0) {
fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg;
abort(); /*NOTREACHED*/
}
-
+
if ((tempo_marker = dynamic_cast<TempoMarker*> (marker)) == 0) {
fatal << _("programming error: marker for tempo is not a tempo marker!") << endmsg;
abort(); /*NOTREACHED*/
}
-
+
edit_tempo_marker (*tempo_marker);
break;
}
case MeterMarkerItem: {
- Marker* marker;
+ ArdourMarker* marker;
MeterMarker* meter_marker;
-
- if ((marker = reinterpret_cast<Marker *> (item->get_data ("marker"))) == 0) {
+
+ if ((marker = reinterpret_cast<ArdourMarker *> (item->get_data ("marker"))) == 0) {
fatal << _("programming error: tempo marker canvas item has no marker object pointer!") << endmsg;
abort(); /*NOTREACHED*/
}
-
+
if ((meter_marker = dynamic_cast<MeterMarker*> (marker)) == 0) {
fatal << _("programming error: marker for meter is not a meter marker!") << endmsg;
abort(); /*NOTREACHED*/
case SelectionItem:
popup_track_context_menu (1, event->button.time, item_type, true);
break;
-
+
case AutomationTrackItem:
popup_track_context_menu (1, event->button.time, item_type, false);
break;
case TransportMarkerBarItem:
case CdMarkerBarItem:
case TempoBarItem:
+ case TempoCurveItem:
case MeterBarItem:
case VideoBarItem:
case TimecodeRulerItem:
case SamplesRulerItem:
case MinsecRulerItem:
case BBTRulerItem:
- popup_ruler_menu (where, item_type);
+ popup_ruler_menu (where.sample, item_type);
break;
case MarkerItem:
popup_control_point_context_menu (item, event);
break;
+ case NoteItem:
+ if (internal_editing()) {
+ popup_note_context_menu (item, event);
+ }
+ break;
+
default:
break;
}
case MarkerBarItem:
if (!_dragging_playhead) {
- snap_to_with_modifier (where, event, RoundNearest, true);
- mouse_add_new_marker (where);
+ snap_to_with_modifier (where, event, RoundNearest, SnapToGrid_Scaled);
+ mouse_add_new_marker (where.sample);
}
return true;
case CdMarkerBarItem:
if (!_dragging_playhead) {
- // if we get here then a dragged range wasn't done
- snap_to_with_modifier (where, event, RoundNearest, true);
- mouse_add_new_marker (where, true);
+ /* if we get here then a dragged range wasn't done */
+ snap_to_with_modifier (where, event, RoundNearest, SnapToGrid_Scaled);
+ mouse_add_new_marker (where.sample, true);
}
return true;
-
case TempoBarItem:
- if (!_dragging_playhead) {
+ case TempoCurveItem:
+ if (!_dragging_playhead && Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
snap_to_with_modifier (where, event);
- mouse_add_new_tempo_event (where);
+ mouse_add_new_tempo_event (where.sample);
}
return true;
case MeterBarItem:
- if (!_dragging_playhead) {
+ if (!_dragging_playhead && Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) {
mouse_add_new_meter_event (pixel_to_sample (event->button.x));
}
return true;
bool with_guard_points = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
atv = dynamic_cast<AutomationTimeAxisView*>(clicked_axisview);
if (atv) {
- atv->add_automation_event (event, where, event->button.y, with_guard_points);
+ atv->add_automation_event (event, where.sample, event->button.y, with_guard_points);
}
return true;
break;
break;
case MouseAudition:
- pop_canvas_cursor ();
if (scrubbing_direction == 0) {
/* no drag, just a click */
switch (item_type) {
default:
break;
}
- } else {
+ } else if (_session) {
/* make sure we stop */
_session->request_transport_speed (0.0);
}
}
- /* do any (de)selection operations that should occur on button release */
- button_selection (item, event, item_type);
+ /* do any (de)selection operations that should occur on button release */
+ button_selection (item, event, item_type);
+
return true;
break;
} else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::ModifierMask (Keyboard::TertiaryModifier|Keyboard::SecondaryModifier))) {
lower_region ();
} else {
- // Button2 click is unused
+ /* Button2 click is unused */
}
return true;
case MouseDraw:
return true;
-
+
case MouseRange:
// x_style_paste (where, 1.0);
return true;
Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
ControlPoint* cp;
- Marker * marker;
+ ArdourMarker * marker;
+ MeterMarker* m_marker = 0;
+ TempoMarker* t_marker = 0;
double fraction;
- bool ret = true;
+ bool ret = true;
/* by the time we reach here, entered_regionview and entered trackview
- * will have already been set as appropriate. Things are done this
+ * will have already been set as appropriate. Things are done this
* way because this method isn't passed a pointer to a variable type of
* thing that is entered (which may or may not be canvas item).
* (e.g. the actual entered regionview)
*/
- choose_canvas_cursor_on_entry (&event->crossing, item_type);
+ choose_canvas_cursor_on_entry (item_type);
switch (item_type) {
case ControlPointItem:
- if (mouse_mode == MouseDraw || mouse_mode == MouseObject) {
+ if (mouse_mode == MouseDraw || mouse_mode == MouseObject || mouse_mode == MouseContent) {
cp = static_cast<ControlPoint*>(item->get_data ("control_point"));
cp->show ();
if (mouse_mode == MouseDraw) {
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
if (line) {
- line->set_outline_color (ARDOUR_UI::config()->color ("entered gain line"));
+ line->set_outline_color (UIConfiguration::instance().color ("entered gain line"));
}
}
break;
if (mouse_mode == MouseDraw || mouse_mode == MouseObject) {
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
if (line) {
- line->set_outline_color (ARDOUR_UI::config()->color ("entered automation line"));
+ line->set_outline_color (UIConfiguration::instance().color ("entered automation line"));
}
}
break;
break;
case MarkerItem:
- if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
+ if ((marker = static_cast<ArdourMarker *> (item->get_data ("marker"))) == 0) {
break;
}
entered_marker = marker;
- marker->set_color_rgba (ARDOUR_UI::config()->color ("entered marker"));
- // fall through
+ marker->set_color_rgba (UIConfiguration::instance().color ("entered marker"));
+ break;
+
case MeterMarkerItem:
+ if ((m_marker = static_cast<MeterMarker *> (item->get_data ("marker"))) == 0) {
+ break;
+ }
+ entered_marker = m_marker;
+ if (m_marker->meter().position_lock_style() == MusicTime) {
+ m_marker->set_color_rgba (UIConfiguration::instance().color ("meter marker"));
+ } else {
+ m_marker->set_color_rgba (UIConfiguration::instance().color ("meter marker music"));
+ }
+ break;
+
case TempoMarkerItem:
+ if ((t_marker = static_cast<TempoMarker *> (item->get_data ("marker"))) == 0) {
+ break;
+ }
+ entered_marker = t_marker;
+ if (t_marker->tempo().position_lock_style() == MusicTime) {
+ t_marker->set_color_rgba (UIConfiguration::instance().color ("tempo marker"));
+ } else {
+ t_marker->set_color_rgba (UIConfiguration::instance().color ("tempo marker music"));
+ }
break;
case FadeInHandleItem:
case SelectionItem:
break;
+ case WaveItem:
+ {
+ if (entered_regionview) {
+ entered_regionview->entered();
+ }
+ }
+ break;
+
default:
break;
}
Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent*, ItemType item_type)
{
AutomationLine* al;
- Marker *marker;
+ ArdourMarker *marker;
+ TempoMarker *t_marker;
+ MeterMarker *m_marker;
Location *loc;
bool is_start;
bool ret = true;
- reset_canvas_cursor ();
+ if (!_enter_stack.empty()) {
+ _enter_stack.pop_back();
+ }
switch (item_type) {
case ControlPointItem:
- _verbose_cursor->hide ();
+ _verbose_cursor->hide ();
break;
case GainLineItem:
break;
case MarkerItem:
- if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
+ if ((marker = static_cast<ArdourMarker *> (item->get_data ("marker"))) == 0) {
break;
}
entered_marker = 0;
if ((loc = find_location_from_marker (marker, is_start)) != 0) {
location_flags_changed (loc);
}
- // fall through
+ break;
+
case MeterMarkerItem:
+ if ((m_marker = static_cast<MeterMarker *> (item->get_data ("marker"))) == 0) {
+ break;
+ }
+ entered_marker = 0;
+ if (m_marker->meter().position_lock_style() == MusicTime) {
+ m_marker->set_color_rgba (UIConfiguration::instance().color ("meter marker music"));
+ } else {
+ m_marker->set_color_rgba (UIConfiguration::instance().color ("meter marker"));
+ }
+ break;
+
case TempoMarkerItem:
+ if ((t_marker = static_cast<TempoMarker *> (item->get_data ("marker"))) == 0) {
+ break;
+ }
+ entered_marker = 0;
+ if (t_marker->tempo().position_lock_style() == MusicTime) {
+ t_marker->set_color_rgba (UIConfiguration::instance().color ("tempo marker music"));
+ } else {
+ t_marker->set_color_rgba (UIConfiguration::instance().color ("tempo marker"));
+ }
break;
case FadeInTrimHandleItem:
{
ArdourCanvas::Rectangle *rect = dynamic_cast<ArdourCanvas::Rectangle *> (item);
if (rect) {
- rect->set_fill_color (ARDOUR_UI::config()->color ("inactive fade handle"));
+ rect->set_fill_color (UIConfiguration::instance().color ("inactive fade handle"));
}
}
break;
case FeatureLineItem:
{
ArdourCanvas::Line *line = dynamic_cast<ArdourCanvas::Line *> (item);
- line->set_outline_color (ARDOUR_UI::config()->color ("zero line"));
+ line->set_outline_color (UIConfiguration::instance().color ("zero line"));
}
break;
}
void
-Editor::scrub (framepos_t frame, double current_x)
+Editor::scrub (samplepos_t sample, double current_x)
{
double delta;
if (scrubbing_direction == 0) {
/* first move */
- _session->request_locate (frame, false);
+ _session->request_locate (sample, false);
_session->request_transport_speed (0.1);
scrubbing_direction = 1;
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.
- */
+ * 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);
}
current_stepping_trackview = 0;
step_timeout.disconnect ();
}
-
+
if (_session && _session->actively_recording()) {
/* Sorry. no dragging stuff around while we record */
return true;
}
-
+
update_join_object_range_location (event->motion.y);
-
+
if (_drags->active ()) {
- return _drags->motion_handler (event, from_autoscroll);
+ //drags change the snapped_cursor location, because we are snapping the thing being dragged, not the actual mouse cursor
+ return _drags->motion_handler (event, from_autoscroll);
+ } else {
+ //the snapped_cursor shows where an operation (like Split) is going to occur
+ bool ignored;
+ MusicSample where (0, 0);
+ if (mouse_sample (where.sample, ignored)) {
+ snap_to_with_modifier (where, event);
+ set_snapped_cursor_position (where.sample);
+ }
}
return false;
}
ControlPointDialog d (p);
- ensure_float (d);
if (d.run () != RESPONSE_ACCEPT) {
return;
}
void
-Editor::edit_notes (TimeAxisViewItem& tavi)
+Editor::edit_notes (MidiRegionView* mrv)
{
- MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(&tavi);
-
- if (!mrv) {
- return;
- }
-
MidiRegionView::Selection const & s = mrv->selection();
if (s.empty ()) {
return;
}
- EditNoteDialog* d = new EditNoteDialog (&(*s.begin())->region_view(), s);
+ EditNoteDialog* d = new EditNoteDialog (mrv, s);
d->show_all ();
- ensure_float (*d);
d->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &Editor::note_edit_done), d));
}
delete d;
}
+void
+Editor::edit_region (RegionView* rv)
+{
+ if (UIConfiguration::instance().get_use_double_click_to_zoom_to_selection()) {
+ temporal_zoom_selection (Both);
+ } else {
+ rv->show_region_editor ();
+ }
+}
+
void
Editor::visible_order_range (int* low, int* high) const
{
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
- if (!rtv->hidden()) {
+ if (rtv && !rtv->hidden()) {
if (*high < rtv->order()) {
*high = rtv->order ();
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)
- */
+ * 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->track()->speed();
- }
- framepos_t where = get_preferred_edit_position();
+ samplepos_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, (framepos_t) (where * speed));
+ align_region (rv.region(), SyncPoint, where);
} else if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::PrimaryModifier|Keyboard::TertiaryModifier))) {
- align_region (rv.region(), End, (framepos_t) (where * speed));
+ align_region (rv.region(), End, where);
} else {
- align_region (rv.region(), Start, (framepos_t) (where * speed));
+ align_region (rv.region(), Start, where);
}
}
}
}
selection->time.clear ();
clicked_selection = 0;
-}
+}
void
-Editor::point_trim (GdkEvent* event, framepos_t new_bound)
+Editor::point_trim (GdkEvent* event, samplepos_t new_bound)
{
RegionView* rv = clicked_regionview;
break;
case 2:
- begin_reversible_command (_("End point trim"));
+ begin_reversible_command (_("end point trim"));
if (selection->selected (rv)) {
void
Editor::hide_marker (ArdourCanvas::Item* item, GdkEvent* /*event*/)
{
- Marker* marker;
+ ArdourMarker* marker;
bool is_start;
- if ((marker = static_cast<Marker *> (item->get_data ("marker"))) == 0) {
+ if ((marker = static_cast<ArdourMarker *> (item->get_data ("marker"))) == 0) {
fatal << _("programming error: marker canvas item has no marker object pointer!") << endmsg;
abort(); /*NOTREACHED*/
}
{
using namespace Gtkmm2ext;
- ArdourPrompter prompter (false);
+ ArdourWidgets::Prompter prompter (false);
prompter.set_prompt (_("Name for region:"));
prompter.set_initial_text (clicked_regionview->region()->name());
void
-Editor::mouse_brush_insert_region (RegionView* rv, framepos_t pos)
+Editor::mouse_brush_insert_region (RegionView* rv, samplepos_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:
+ /* no brushing without a useful quantize setting */
+ if (_grid_type == GridTypeNone)
return;
- default:
- break;
- }
-
/* don't brush a copy over the original */
if (pos == rv->region()->position()) {
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&rv->get_time_axis_view());
- if (rtv == 0 || !rtv->is_track()) {
+ if (!rtv || !rtv->is_track()) {
return;
}
boost::shared_ptr<Playlist> playlist = rtv->playlist();
- double speed = rtv->track()->speed();
playlist->clear_changes ();
boost::shared_ptr<Region> new_region (RegionFactory::create (rv->region(), true));
- playlist->add_region (new_region, (framepos_t) (pos * speed));
+ playlist->add_region (new_region, pos);
_session->add_command (new StatefulDiffCommand (playlist));
- // playlist is frozen, so we have to update manually XXX this is disgusting
+ /* playlist is frozen, so we have to update manually XXX this is disgusting */
- playlist->RegionAdded (new_region); /* EMIT SIGNAL */
+ //playlist->RegionAdded (new_region); /* EMIT SIGNAL */
}
gint
}
_drags->add (new RegionMoveDrag (this, item, region_view, selection->regions.by_layer(), true, false));
-
- begin_reversible_command (Operations::drag_region_brush);
}
/** Start a grab where a time range is selected, track(s) are selected, and the
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.
- */
+ *
+ * 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 (sigc::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.
- */
-
+ * creating the new region and another for moving it.
+ */
begin_reversible_command (Operations::selection_grab);
boost::shared_ptr<Playlist> playlist = clicked_axisview->playlist();
if (latest_regionviews.empty()) {
/* something went wrong */
+ abort_reversible_command ();
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
- */
+ * i'm ignoring undo stuff, because the region creation will take care of it
+ */
selection->set (latest_regionviews);
{
if (_drags->active ()) {
_drags->abort ();
- } else {
+ } else if (_session) {
selection->clear ();
+
+ /* if session is playing a range, cancel that */
+ if (_session->get_play_range()) {
+ _session->request_cancel_play_range();
+ }
+
+ if (_session->solo_selection_active()) {
+ StripableList sl;
+ _session->solo_selection (sl, false);
+ }
}
- reset_focus ();
+ ARDOUR_UI::instance()->reset_focus (&contents());
}
/** Update _join_object_range_state which indicate whether we are over the top
if (entered_regionview) {
+ /* TODO: there is currently a bug here(?)
+ * when we are inside a region fade handle, it acts as though we are in range mode because it is in the top half of the region
+ * can it be fixed here?
+ */
+
ArdourCanvas::Duple const item_space = entered_regionview->get_canvas_group()->canvas_to_item (ArdourCanvas::Duple (0, y));
double const c = item_space.y / entered_regionview->height();
-
+
_join_object_range_state = c <= 0.5 ? JOIN_OBJECT_RANGE_RANGE : JOIN_OBJECT_RANGE_OBJECT;
-
- if (_join_object_range_state != old) {
- set_canvas_cursor (which_track_cursor ());
+
+ Editor::EnterContext* ctx = get_enter_context(RegionItem);
+ if (_join_object_range_state != old && ctx) {
+ ctx->cursor_ctx->change(which_track_cursor());
}
} else if (entered_track) {
RouteTimeAxisView* entered_route_view = dynamic_cast<RouteTimeAxisView*> (entered_track);
-
+
if (entered_route_view) {
double cx = 0;
entered_route_view->canvas_display()->canvas_to_item (cx, cy);
double track_height = entered_route_view->view()->child_height();
- if (Config->get_show_name_highlight()) {
+ if (UIConfiguration::instance().get_show_name_highlight()) {
track_height -= TimeAxisViewItem::NAME_HIGHLIGHT_SIZE;
}
double const c = cy / track_height;
_join_object_range_state = JOIN_OBJECT_RANGE_OBJECT;
}
- if (_join_object_range_state != old) {
- set_canvas_cursor (which_track_cursor ());
+ Editor::EnterContext* ctx = get_enter_context(StreamItem);
+ if (_join_object_range_state != old && ctx) {
+ ctx->cursor_ctx->change(which_track_cursor());
}
}
}