} else {
--bbt.bars;
}
- const double beat = map.beat_at_bbt (bbt);
- const framepos_t frame = map.frame_at_beat (beat);
+ const framepos_t frame = map.frame_at_bbt (bbt);
_real_section = map.add_meter (Meter (_marker->meter().divisions_per_bar(), _marker->meter().note_divisor())
- , beat, bbt, frame, _real_section->position_lock_style());
+ , bbt, frame, _real_section->position_lock_style());
if (!_real_section) {
aborted (true);
return;
, _grab_qn (0.0)
, _tempo (0)
, _before_state (0)
+ , _drag_valid (true)
{
DEBUG_TRACE (DEBUG::Drags, "New BBTRulerDrag\n");
Drag::start_grab (event, cursor);
TempoMap& map (_editor->session()->tempo_map());
_tempo = const_cast<TempoSection*> (&map.tempo_section_at_frame (raw_grab_frame()));
+
+ if (adjusted_current_frame (event, false) <= _tempo->frame()) {
+ _drag_valid = false;
+ return;
+ }
+
_editor->tempo_curve_selected (_tempo, true);
ostringstream sstr;
if (_tempo->clamped()) {
TempoSection* prev = map.previous_tempo_section (_tempo);
if (prev) {
- _editor->tempo_curve_selected (prev, true);
sstr << "end: " << fixed << setprecision(3) << prev->end_note_types_per_minute() << "\n";
}
}
void
BBTRulerDrag::motion (GdkEvent* event, bool first_move)
{
- TempoMap& map (_editor->session()->tempo_map());
+ if (!_drag_valid) {
+ return;
+ }
if (first_move) {
_editor->begin_reversible_command (_("stretch tempo"));
}
+ TempoMap& map (_editor->session()->tempo_map());
framepos_t pf;
if (_editor->snap_musical()) {
if (ArdourKeyboard::indicates_constraint (event->button.state)) {
/* adjust previous tempo to match pointer frame */
- _editor->session()->tempo_map().gui_stretch_tempo (_tempo, map.frame_at_quarter_note (_grab_qn), pf);
+ _editor->session()->tempo_map().gui_stretch_tempo (_tempo, map.frame_at_quarter_note (_grab_qn), pf, _grab_qn, map.quarter_note_at_frame (pf));
}
ostringstream sstr;
TempoMap& map (_editor->session()->tempo_map());
- XMLNode &after = map.get_state();
- _editor->session()->add_command(new MementoCommand<TempoMap>(map, _before_state, &after));
- _editor->commit_reversible_command ();
_editor->tempo_curve_selected (_tempo, false);
-
if (_tempo->clamped()) {
TempoSection* prev_tempo = map.previous_tempo_section (_tempo);
if (prev_tempo) {
_editor->tempo_curve_selected (prev_tempo, false);
}
}
+
+ if (!movement_occurred || !_drag_valid) {
+ return;
+ }
+
+ XMLNode &after = map.get_state();
+ _editor->session()->add_command(new MementoCommand<TempoMap>(map, _before_state, &after));
+ _editor->commit_reversible_command ();
+
}
void
_before_state = &map.get_state();
_tempo = const_cast<TempoSection*> (&map.tempo_section_at_frame (raw_grab_frame()));
+ if (_tempo->locked_to_meter()) {
+ _drag_valid = false;
+ return;
+ }
+
_next_tempo = map.next_tempo_section (_tempo);
if (_next_tempo) {
if (!map.next_tempo_section (_next_tempo)) {
void
TempoTwistDrag::finished (GdkEvent* event, bool movement_occurred)
{
- TempoMap& map (_editor->session()->tempo_map());
-
if (!movement_occurred || !_drag_valid) {
return;
}
_editor->tempo_curve_selected (_tempo, false);
_editor->tempo_curve_selected (_next_tempo, false);
+ TempoMap& map (_editor->session()->tempo_map());
XMLNode &after = map.get_state();
_editor->session()->add_command(new MementoCommand<TempoMap>(map, _before_state, &after));
_editor->commit_reversible_command ();
, _grab_qn (0.0)
, _tempo (0)
, _before_state (0)
+ , _drag_valid (true)
{
DEBUG_TRACE (DEBUG::Drags, "New TempoEndDrag\n");
TempoMarker* marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
/* get current state */
_before_state = &tmap.get_state();
+ if (_tempo->locked_to_meter()) {
+ _drag_valid = false;
+ return;
+ }
ostringstream sstr;
void
TempoEndDrag::motion (GdkEvent* event, bool first_move)
{
+ if (!_drag_valid) {
+ return;
+ }
+
TempoMap& map (_editor->session()->tempo_map());
if (first_move) {
_editor->begin_reversible_command (_("stretch end tempo"));
}
-
-
framepos_t const pf = adjusted_current_frame (event, false);
map.gui_stretch_tempo_end (&map.tempo_section_at_frame (_tempo->frame() - 1), map.frame_at_quarter_note (_grab_qn), pf);
void
TempoEndDrag::finished (GdkEvent* event, bool movement_occurred)
{
- if (!movement_occurred) {
+ if (!movement_occurred || !_drag_valid) {
return;
}
}
fake_locate (where.frame - snap_delta (event->button.state));
+
+ _last_y_delta = 0;
}
void
if (where.frame != last_pointer_frame()) {
fake_locate (where.frame - snap_delta (event->button.state));
}
+
+ //maybe do zooming, too, if the option is enabled
+ if (UIConfiguration::instance ().get_use_time_rulers_to_zoom_with_vertical_drag () ) {
+
+ //To avoid accidental zooming, the mouse must move exactly vertical, not diagonal, to trigger a zoom step
+ //we use screen coordinates for this, not canvas-based grab_x
+ double mx = event->button.x;
+ double dx = fabs(mx - _last_mx);
+ double my = event->button.y;
+ double dy = fabs(my - _last_my);
+
+ {
+ //do zooming in windowed "steps" so it feels more reversible ?
+ const int stepsize = 2; //stepsize ==1 means "trigger on every pixel of movement"
+ int y_delta = grab_y() - current_pointer_y();
+ y_delta = y_delta / stepsize;
+
+ //if all requirements are met, do the actual zoom
+ const double scale = 1.2;
+ if ( (dy>dx) && (_last_dx ==0) && (y_delta != _last_y_delta) ) {
+ if ( _last_y_delta > y_delta ) {
+ _editor->temporal_zoom_step_mouse_focus_scale (true, scale);
+ } else {
+ _editor->temporal_zoom_step_mouse_focus_scale (false, scale);
+ }
+ _last_y_delta = y_delta;
+ }
+ }
+
+ _last_my = my;
+ _last_mx = mx;
+ _last_dx = dx;
+ }
}
void
void
MarkerDrag::update_item (Location*)
{
- /* noop */
+ /* noop */
}
ControlPointDrag::ControlPointDrag (Editor* e, ArdourCanvas::Item* i)
_editor->begin_reversible_command (_("automation event move"));
_point->line().start_drag_single (_point, _fixed_grab_x, initial_fraction);
}
- pair<double, float> result;
+ pair<float, float> result;
result = _point->line().drag_motion (_editor->sample_to_pixel_unrounded (cx_mf.frame), fraction, false, _pushing, _final_index);
-
- show_verbose_cursor_text (_point->line().get_verbose_cursor_string (result.second));
+ show_verbose_cursor_text (_point->line().get_verbose_cursor_relative_string (result.first, result.second));
}
void
}
/* we are ignoring x position for this drag, so we can just pass in anything */
- pair<double, float> result;
+ pair<float, float> result;
result = _line->drag_motion (0, fraction, true, false, ignored);
- show_verbose_cursor_text (_line->get_verbose_cursor_string (result.second));
+ show_verbose_cursor_text (_line->get_verbose_cursor_relative_string (result.first, result.second));
}
void
case CreateSkipMarker:
case CreateRangeMarker:
case CreateCDMarker:
- {
+ {
XMLNode &before = _editor->session()->locations()->get_state();
if (_operation == CreateSkipMarker) {
_editor->begin_reversible_command (_("new skip marker"));
_editor->session()->add_command(new MementoCommand<Locations>(*(_editor->session()->locations()), &before, &after));
_editor->commit_reversible_command ();
break;
- }
+ }
case CreateTransportMarker:
// popup menu to pick loop or punch
for (list<Line>::iterator l = _lines.begin(); l != _lines.end(); ++l) {
float const f = y_fraction (l->line, current_pointer_y());
/* we are ignoring x position for this drag, so we can just pass in anything */
- pair<double, float> result;
+ pair<float, float> result;
uint32_t ignored;
result = l->line->drag_motion (0, f, true, false, ignored);
- show_verbose_cursor_text (l->line->get_verbose_cursor_relative_string (l->original_fraction, result.second));
+ show_verbose_cursor_text (l->line->get_verbose_cursor_relative_string (result.first, result.second));
}
}
RegionCutDrag::aborted (bool)
{
}
-
-RulerZoomDrag::RulerZoomDrag (Editor* e, ArdourCanvas::Item* item)
- : Drag (e, item, true)
-{
-}
-
-void
-RulerZoomDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
-{
- Drag::start_grab (event, c);
-
- framepos_t where = _editor->canvas_event_sample(event);
-
- _editor->_dragging_playhead = true;
-
- _editor->playhead_cursor->set_position (where);
-}
-
-void
-RulerZoomDrag::motion (GdkEvent* event, bool)
-{
- framepos_t where = _editor->canvas_event_sample(event);
-
- _editor->playhead_cursor->set_position (where);
-
- const double movement_limit = 20.0;
- const double scale = 1.08;
- const double y_delta = last_pointer_y() - current_pointer_y();
-
- if (y_delta > 0 && y_delta < movement_limit) {
- _editor->temporal_zoom_step_mouse_focus_scale (true, scale);
- } else if (y_delta < 0 && y_delta > -movement_limit) {
- _editor->temporal_zoom_step_mouse_focus_scale (false, scale);
- }
-}
-
-void
-RulerZoomDrag::finished (GdkEvent*, bool)
-{
- _editor->_dragging_playhead = false;
-
- Session* s = _editor->session ();
- if (s) {
- s->request_locate (_editor->playhead_cursor->current_frame (), _was_rolling);
- _editor->_pending_locate_request = true;
- }
-
-}
-
-void
-RulerZoomDrag::aborted (bool)
-{
-}
projects / ardour.git / blobdiff