X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fautomation_line.cc;h=5a7f6ddd2156259b85fe95425b834767ac628088;hb=23973bae24b7f569e26c7f869a103aacbaf66ab2;hp=128cfb5148e22ee758dec9d24123456aa6a4b3f9;hpb=de4c9d47505ffde8f95e2ef5adbd8afa6ebba1ef;p=ardour.git diff --git a/gtk2_ardour/automation_line.cc b/gtk2_ardour/automation_line.cc index 128cfb5148..5a7f6ddd21 100644 --- a/gtk2_ardour/automation_line.cc +++ b/gtk2_ardour/automation_line.cc @@ -41,7 +41,6 @@ #include "selection.h" #include "time_axis_view.h" #include "point_selection.h" -#include "automation_selectable.h" #include "automation_time_axis.h" #include "public_editor.h" @@ -56,23 +55,34 @@ using namespace PBD; using namespace Editing; using namespace Gnome; // for Canvas -static const Evoral::IdentityConverter default_converter; - +/** @param converter A TimeConverter whose origin_b is the start time of the AutomationList in session frames. + * This will not be deleted by AutomationLine. + */ AutomationLine::AutomationLine (const string& name, TimeAxisView& tv, ArdourCanvas::Group& parent, boost::shared_ptr al, - const Evoral::TimeConverter* converter) + Evoral::TimeConverter* converter) : trackview (tv) , _name (name) , alist (al) + , _time_converter (converter ? converter : new Evoral::IdentityConverter) , _parent_group (parent) - , _time_converter (converter ? (*converter) : default_converter) + , _offset (0) + , _maximum_time (max_framepos) { - _interpolation = al->interpolation(); + if (converter) { + _time_converter = converter; + _our_time_converter = false; + } else { + _time_converter = new Evoral::IdentityConverter; + _our_time_converter = true; + } + points_visible = false; update_pending = false; _uses_gain_mapping = false; no_draw = false; _visible = true; + _is_boolean = false; terminal_points_can_slide = true; _height = 0; @@ -86,8 +96,6 @@ AutomationLine::AutomationLine (const string& name, TimeAxisView& tv, ArdourCanv line->signal_event().connect (sigc::mem_fun (*this, &AutomationLine::event_handler)); - alist->StateChanged.connect (_state_connection, boost::bind (&AutomationLine::list_changed, this), gui_context()); - trackview.session()->register_with_memento_command_factory(alist->id(), this); if (alist->parameter().type() == GainAutomation || @@ -95,13 +103,19 @@ AutomationLine::AutomationLine (const string& name, TimeAxisView& tv, ArdourCanv set_uses_gain_mapping (true); } - set_interpolation(alist->interpolation()); + interpolation_changed (alist->interpolation ()); + + connect_to_list (); } AutomationLine::~AutomationLine () { vector_delete (&control_points); delete group; + + if (_our_time_converter) { + delete _time_converter; + } } bool @@ -115,14 +129,14 @@ AutomationLine::queue_reset () { if (!update_pending) { update_pending = true; - Gtkmm2ext::UI::instance()->call_slot (boost::bind (&AutomationLine::reset, this)); + Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&AutomationLine::reset, this)); } } void AutomationLine::show () { - if (_interpolation != AutomationList::Discrete) { + if (alist->interpolation() != AutomationList::Discrete) { line->show(); } @@ -148,14 +162,14 @@ AutomationLine::hide () double AutomationLine::control_point_box_size () { - if (_interpolation == AutomationList::Discrete) { + if (alist->interpolation() == AutomationList::Discrete) { return max((_height*4.0) / (double)(alist->parameter().max() - alist->parameter().min()), 4.0); } - if (_height > TimeAxisView::hLarger) { + if (_height > TimeAxisView::preset_height (HeightLarger)) { return 8.0; - } else if (_height > (guint32) TimeAxisView::hNormal) { + } else if (_height > (guint32) TimeAxisView::preset_height (HeightNormal)) { return 6.0; } return 4.0; @@ -203,6 +217,16 @@ AutomationLine::nth (uint32_t n) } } +ControlPoint const * +AutomationLine::nth (uint32_t n) const +{ + if (n < control_points.size()) { + return control_points[n]; + } else { + return 0; + } +} + void AutomationLine::modify_point_y (ControlPoint& cp, double y) { @@ -214,12 +238,15 @@ AutomationLine::modify_point_y (ControlPoint& cp, double y) y = min (1.0, y); y = _height - (y * _height); - double const x = trackview.editor().frame_to_unit (_time_converter.to((*cp.model())->when)); + double const x = trackview.editor().frame_to_unit (_time_converter->to((*cp.model())->when) - _offset); trackview.editor().session()->begin_reversible_command (_("automation event move")); - trackview.editor().session()->add_command (new MementoCommand(*alist.get(), &get_state(), 0)); + trackview.editor().session()->add_command ( + new MementoCommand (memento_command_binder(), &get_state(), 0) + ); cp.move_to (x, y, ControlPoint::Full); + reset_line_coords (cp); if (line_points.size() > 1) { @@ -232,126 +259,14 @@ AutomationLine::modify_point_y (ControlPoint& cp, double y) update_pending = false; - trackview.editor().session()->add_command (new MementoCommand(*alist.get(), 0, &alist->get_state())); + trackview.editor().session()->add_command ( + new MementoCommand (memento_command_binder(), 0, &alist->get_state()) + ); + trackview.editor().session()->commit_reversible_command (); trackview.editor().session()->set_dirty (); } - -void -AutomationLine::modify_view_point (ControlPoint& cp, double x, double y, bool with_push) -{ - double delta = 0.0; - uint32_t last_movable = UINT_MAX; - double x_limit = DBL_MAX; - - /* this just changes the current view. it does not alter - the model in any way at all. - */ - - /* clamp y-coord appropriately. y is supposed to be a normalized fraction (0.0-1.0), - and needs to be converted to a canvas unit distance. - */ - - y = max (0.0, y); - y = min (1.0, y); - y = _height - (y * _height); - - if (cp.can_slide()) { - - /* x-coord cannot move beyond adjacent points or the start/end, and is - already in frames. it needs to be converted to canvas units. - */ - - x = trackview.editor().frame_to_unit (x); - - /* clamp x position using view coordinates */ - - ControlPoint *before; - ControlPoint *after; - - if (cp.view_index()) { - before = nth (cp.view_index() - 1); - x = max (x, before->get_x()+1.0); - } else { - before = &cp; - } - - - if (!with_push) { - if (cp.view_index() < control_points.size() - 1) { - - after = nth (cp.view_index() + 1); - - /*if it is a "spike" leave the x alone */ - - if (after->get_x() - before->get_x() < 2) { - x = cp.get_x(); - - } else { - x = min (x, after->get_x()-1.0); - } - } else { - after = &cp; - } - - } else { - - ControlPoint* after; - - /* find the first point that can't move */ - - for (uint32_t n = cp.view_index() + 1; (after = nth (n)) != 0; ++n) { - if (!after->can_slide()) { - x_limit = after->get_x() - 1.0; - last_movable = after->view_index(); - break; - } - } - - delta = x - cp.get_x(); - } - - } else { - - /* leave the x-coordinate alone */ - - x = trackview.editor().frame_to_unit (_time_converter.to((*cp.model())->when)); - - } - - if (!with_push) { - - cp.move_to (x, y, ControlPoint::Full); - reset_line_coords (cp); - - } else { - - uint32_t limit = min (control_points.size(), (size_t)last_movable); - - /* move the current point to wherever the user told it to go, subject - to x_limit. - */ - - cp.move_to (min (x, x_limit), y, ControlPoint::Full); - reset_line_coords (cp); - - /* now move all subsequent control points, to reflect the motion. - */ - - for (uint32_t i = cp.view_index() + 1; i < limit; ++i) { - ControlPoint *p = nth (i); - double new_x; - - if (p->can_slide()) { - new_x = min (p->get_x() + delta, x_limit); - p->move_to (new_x, p->get_y(), ControlPoint::Full); - reset_line_coords (*p); - } - } - } -} - void AutomationLine::reset_line_coords (ControlPoint& cp) { @@ -362,232 +277,13 @@ AutomationLine::reset_line_coords (ControlPoint& cp) } void -AutomationLine::sync_model_with_view_line (uint32_t start, uint32_t end) +AutomationLine::sync_model_with_view_points (list cp, bool did_push, int64_t distance) { - ControlPoint *p; - update_pending = true; - for (uint32_t i = start; i <= end; ++i) { - p = nth(i); - sync_model_with_view_point (*p, false, 0); - } -} - -void -AutomationLine::model_representation (ControlPoint& cp, ModelRepresentation& mr) -{ - /* part one: find out where the visual control point is. - initial results are in canvas units. ask the - line to convert them to something relevant. - */ - - mr.xval = cp.get_x(); - mr.yval = 1.0 - (cp.get_y() / _height); - - /* if xval has not changed, set it directly from the model to avoid rounding errors */ - - if (mr.xval == trackview.editor().frame_to_unit(_time_converter.to((*cp.model())->when))) { - mr.xval = (*cp.model())->when; - } else { - mr.xval = trackview.editor().unit_to_frame (mr.xval); - } - - /* convert to model units - */ - - view_to_model_coord (mr.xval, mr.yval); - - /* part 2: find out where the model point is now - */ - - mr.xpos = (*cp.model())->when; - mr.ypos = (*cp.model())->value; - - /* part 3: get the position of the visual control - points before and after us. - */ - - ControlPoint* before; - ControlPoint* after; - - if (cp.view_index()) { - before = nth (cp.view_index() - 1); - } else { - before = 0; - } - - after = nth (cp.view_index() + 1); - - if (before) { - mr.xmin = (*before->model())->when; - mr.ymin = (*before->model())->value; - mr.start = before->model(); - ++mr.start; - } else { - mr.xmin = mr.xpos; - mr.ymin = mr.ypos; - mr.start = cp.model(); - } - - if (after) { - mr.end = after->model(); - } else { - mr.xmax = mr.xpos; - mr.ymax = mr.ypos; - mr.end = cp.model(); - ++mr.end; - } -} - -void -AutomationLine::determine_visible_control_points (ALPoints& points) -{ - uint32_t view_index, pi, n; - AutomationList::iterator model; - uint32_t npoints; - uint32_t this_rx = 0; - uint32_t prev_rx = 0; - uint32_t this_ry = 0; - uint32_t prev_ry = 0; - double* slope; - uint32_t box_size; - - /* hide all existing points, and the line */ - - for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - (*i)->hide(); - } - - line->hide (); - - if (points.empty()) { - return; - } - - npoints = points.size(); - - /* compute derivative/slope for the entire line */ - - slope = new double[npoints]; - - for (n = 0; n < npoints - 1; ++n) { - double xdelta = points[n+1].x - points[n].x; - double ydelta = points[n+1].y - points[n].y; - slope[n] = ydelta/xdelta; - } - - box_size = (uint32_t) control_point_box_size (); - - /* read all points and decide which ones to show as control points */ - - view_index = 0; - - for (model = alist->begin(), pi = 0; pi < npoints; ++model, ++pi) { - - double tx = points[pi].x; - double ty = points[pi].y; - - if (isnan (tx) || isnan (ty)) { - warning << string_compose (_("Ignoring illegal points on AutomationLine \"%1\""), - _name) << endmsg; - continue; - } - - /* now ensure that the control_points vector reflects the current curve - state, but don't plot control points too close together. also, don't - plot a series of points all with the same value. - - always plot the first and last points, of course. - */ - - if (invalid_point (points, pi)) { - /* for some reason, we are supposed to ignore this point, - but still keep track of the model index. - */ - continue; - } - - if (pi > 0 && pi < npoints - 1) { - if (slope[pi] == slope[pi-1]) { - - /* no reason to display this point */ - - continue; - } - } - - /* need to round here. the ultimate coordinates are integer - pixels, so tiny deltas in the coords will be eliminated - and we end up with "colinear" line segments. since the - line rendering code in libart doesn't like this very - much, we eliminate them here. don't do this for the first and last - points. - */ - - this_rx = (uint32_t) rint (tx); - this_ry = (uint32_t) rint (ty); - - if (view_index && pi != npoints && /* not the first, not the last */ - (((this_rx == prev_rx) && (this_ry == prev_ry)) || /* same point */ - (((this_rx - prev_rx) < (box_size + 2)) && /* not identical, but still too close horizontally */ - (abs ((int)(this_ry - prev_ry)) < (int) (box_size + 2))))) { /* too close vertically */ - continue; - } - - /* ok, we should display this point */ - - add_visible_control_point (view_index, pi, tx, ty, model, npoints); - - prev_rx = this_rx; - prev_ry = this_ry; - - view_index++; - } - - /* discard extra CP's to avoid confusing ourselves */ - - while (control_points.size() > view_index) { - ControlPoint* cp = control_points.back(); - control_points.pop_back (); - delete cp; - } - - if (!terminal_points_can_slide) { - control_points.back()->set_can_slide(false); - } - - delete [] slope; - - if (view_index > 1) { - - npoints = view_index; - - /* reset the line coordinates */ - - while (line_points.size() < npoints) { - line_points.push_back (Art::Point (0,0)); - } - - while (line_points.size() > npoints) { - line_points.pop_back (); - } - - for (view_index = 0; view_index < npoints; ++view_index) { - line_points[view_index].set_x (control_points[view_index]->get_x()); - line_points[view_index].set_y (control_points[view_index]->get_y()); - } - - line->property_points() = line_points; - - if (_visible && _interpolation != AutomationList::Discrete) { - line->show(); - } - + for (list::iterator i = cp.begin(); i != cp.end(); ++i) { + sync_model_with_view_point (**i, did_push, distance); } - - set_selected_points (trackview.editor().get_selection().points); - } string @@ -614,11 +310,10 @@ AutomationLine::fraction_to_string (double fraction) const if (fraction == 0.0) { snprintf (buf, sizeof (buf), "-inf"); } else { - snprintf (buf, sizeof (buf), "%.1f", accurate_coefficient_to_dB (slider_position_to_gain (fraction))); + snprintf (buf, sizeof (buf), "%.1f", accurate_coefficient_to_dB (slider_position_to_gain_with_max (fraction, Config->get_max_gain()))); } } else { - double dummy = 0.0; - view_to_model_coord (dummy, fraction); + view_to_model_coord_y (fraction); if (EventTypeMap::instance().is_integer (alist->parameter())) { snprintf (buf, sizeof (buf), "%d", (int)fraction); } else { @@ -645,7 +340,7 @@ AutomationLine::string_to_fraction (string const & s) const sscanf (s.c_str(), "%lf", &v); if (_uses_gain_mapping) { - v = gain_to_slider_position (dB_to_coefficient (v)); + v = gain_to_slider_position_with_max (dB_to_coefficient (v), Config->get_max_gain()); } else { double dummy = 0.0; model_to_view_coord (dummy, v); @@ -654,100 +349,197 @@ AutomationLine::string_to_fraction (string const & s) const return v; } -bool -AutomationLine::invalid_point (ALPoints& p, uint32_t index) +/** Start dragging a single point, possibly adding others if the supplied point is selected and there + * are other selected points. + * + * @param cp Point to drag. + * @param x Initial x position (units). + * @param fraction Initial y position (as a fraction of the track height, where 0 is the bottom and 1 the top) + */ +void +AutomationLine::start_drag_single (ControlPoint* cp, double x, float fraction) { - return p[index].x == max_frames && p[index].y == DBL_MAX; + trackview.editor().session()->begin_reversible_command (_("automation event move")); + trackview.editor().session()->add_command ( + new MementoCommand (memento_command_binder(), &get_state(), 0) + ); + + _drag_points.clear (); + _drag_points.push_back (cp); + + if (cp->get_selected ()) { + for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { + if (*i != cp && (*i)->get_selected()) { + _drag_points.push_back (*i); + } + } + } + + start_drag_common (x, fraction); } +/** Start dragging a line vertically (with no change in x) + * @param i1 Control point index of the `left' point on the line. + * @param i2 Control point index of the `right' point on the line. + * @param fraction Initial y position (as a fraction of the track height, where 0 is the bottom and 1 the top) + */ void -AutomationLine::invalidate_point (ALPoints& p, uint32_t index) +AutomationLine::start_drag_line (uint32_t i1, uint32_t i2, float fraction) { - p[index].x = max_frames; - p[index].y = DBL_MAX; + trackview.editor().session()->begin_reversible_command (_("automation range move")); + trackview.editor().session()->add_command ( + new MementoCommand (memento_command_binder (), &get_state(), 0) + ); + + _drag_points.clear (); + for (uint32_t i = i1; i <= i2; i++) { + _drag_points.push_back (nth (i)); + } + + start_drag_common (0, fraction); } +/** Start dragging multiple points (with no change in x) + * @param cp Points to drag. + * @param fraction Initial y position (as a fraction of the track height, where 0 is the bottom and 1 the top) + */ void -AutomationLine::start_drag (ControlPoint* cp, nframes_t x, float fraction) +AutomationLine::start_drag_multiple (list cp, float fraction, XMLNode* state) { - if (trackview.editor().session() == 0) { /* how? */ - return; - } + trackview.editor().session()->begin_reversible_command (_("automation range move")); + trackview.editor().session()->add_command ( + new MementoCommand (memento_command_binder(), state, 0) + ); - string str; + _drag_points = cp; + start_drag_common (0, fraction); +} - if (cp) { - str = _("automation event move"); - } else { - str = _("automation range drag"); - } - trackview.editor().session()->begin_reversible_command (str); - trackview.editor().session()->add_command (new MementoCommand(*alist.get(), &get_state(), 0)); +struct ControlPointSorter +{ + bool operator() (ControlPoint const * a, ControlPoint const * b) { + return a->get_x() < b->get_x(); + } +}; - drag_x = x; - drag_distance = 0; - first_drag_fraction = fraction; - last_drag_fraction = fraction; - drags = 0; +/** Common parts of starting a drag. + * @param x Starting x position in units, or 0 if x is being ignored. + * @param fraction Starting y position (as a fraction of the track height, where 0 is the bottom and 1 the top) + */ +void +AutomationLine::start_drag_common (double x, float fraction) +{ + _drag_x = x; + _drag_distance = 0; + _last_drag_fraction = fraction; + _drag_had_movement = false; did_push = false; + + _drag_points.sort (ControlPointSorter ()); + + /* find the additional points that will be dragged when the user is holding + the "push" modifier + */ + + uint32_t i = _drag_points.back()->view_index () + 1; + ControlPoint* p = 0; + _push_points.clear (); + while ((p = nth (i)) != 0 && p->can_slide()) { + _push_points.push_back (p); + ++i; + } } -void -AutomationLine::point_drag (ControlPoint& cp, nframes_t x, float fraction, bool with_push) +/** Should be called to indicate motion during a drag. + * @param x New x position of the drag in units, or undefined if ignore_x == true. + * @param fraction New y fraction. + * @return x position and y fraction that were actually used (once clamped). + */ +pair +AutomationLine::drag_motion (double x, float fraction, bool ignore_x, bool with_push) { - if (x > drag_x) { - drag_distance += (x - drag_x); - } else { - drag_distance -= (drag_x - x); + /* setup the points that are to be moved this time round */ + list points = _drag_points; + if (with_push) { + copy (_push_points.begin(), _push_points.end(), back_inserter (points)); + points.sort (ControlPointSorter ()); } - drag_x = x; + double dx = ignore_x ? 0 : (x - _drag_x); + double dy = fraction - _last_drag_fraction; - modify_view_point (cp, x, fraction, with_push); + /* find x limits */ + ControlPoint* before = 0; + ControlPoint* after = 0; - if (line_points.size() > 1) { - line->property_points() = line_points; + for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { + if ((*i)->get_x() < points.front()->get_x()) { + before = *i; + } + if ((*i)->get_x() > points.back()->get_x() && after == 0) { + after = *i; + } } - drags++; - did_push = with_push; -} - -void -AutomationLine::line_drag (uint32_t i1, uint32_t i2, float fraction, bool with_push) -{ - double ydelta = fraction - last_drag_fraction; + double const before_x = before ? before->get_x() : 0; + double const after_x = after ? after->get_x() : DBL_MAX; - did_push = with_push; + /* clamp x */ + for (list::iterator i = points.begin(); i != points.end(); ++i) { - last_drag_fraction = fraction; + if ((*i)->can_slide() && !ignore_x) { - line_drag_cp1 = i1; - line_drag_cp2 = i2; + /* clamp min x */ + double const a = (*i)->get_x() + dx; + double const b = before_x + 1; + if (a < b) { + dx += b - a; + } - //check if one of the control points on the line is in a selected range - bool range_found = false; - ControlPoint *cp; + /* clamp max x */ + if (after) { - for (uint32_t i = i1 ; i <= i2; i++) { - cp = nth (i); - if (cp->selected()) { - range_found = true; + if (after_x - before_x < 2) { + /* after and before are very close, so just leave this alone */ + dx = 0; + } else { + double const a = (*i)->get_x() + dx; + double const b = after_x - 1; + if (a > b) { + dx -= a - b; + } + } + } } } - if (range_found) { - for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - if ((*i)->selected()) { - modify_view_point (*(*i), trackview.editor().unit_to_frame ((*i)->get_x()), ((_height - (*i)->get_y()) /_height) + ydelta, with_push); - } + /* clamp y */ + for (list::iterator i = points.begin(); i != points.end(); ++i) { + double const y = ((_height - (*i)->get_y()) / _height) + dy; + if (y < 0) { + dy -= y; } - } else { - ControlPoint *cp; - for (uint32_t i = i1 ; i <= i2; i++) { - cp = nth (i); - modify_view_point (*cp, trackview.editor().unit_to_frame (cp->get_x()), ((_height - cp->get_y()) /_height) + ydelta, with_push); + if (y > 1) { + dy -= (y - 1); + } + } + + pair const clamped (_drag_x + dx, _last_drag_fraction + dy); + _drag_distance += dx; + _drag_x = x; + _last_drag_fraction = fraction; + + for (list::iterator i = _drag_points.begin(); i != _drag_points.end(); ++i) { + (*i)->move_to ((*i)->get_x() + dx, (*i)->get_y() - _height * dy, ControlPoint::Full); + reset_line_coords (**i); + } + + if (with_push) { + /* move push points, preserving their y */ + for (list::iterator i = _push_points.begin(); i != _push_points.end(); ++i) { + (*i)->move_to ((*i)->get_x() + dx, (*i)->get_y(), ControlPoint::Full); + reset_line_coords (**i); } } @@ -755,101 +547,75 @@ AutomationLine::line_drag (uint32_t i1, uint32_t i2, float fraction, bool with_p line->property_points() = line_points; } - drags++; + _drag_had_movement = true; + did_push = with_push; + + return clamped; } +/** Should be called to indicate the end of a drag */ void -AutomationLine::end_drag (ControlPoint* cp) +AutomationLine::end_drag () { - if (!drags) { + if (!_drag_had_movement) { return; } alist->freeze (); - if (cp) { - sync_model_with_view_point (*cp, did_push, drag_distance); - } else { - sync_model_with_view_line (line_drag_cp1, line_drag_cp2); + /* set up the points that were moved this time round */ + list points = _drag_points; + if (did_push) { + copy (_push_points.begin(), _push_points.end(), back_inserter (points)); + points.sort (ControlPointSorter ()); } + sync_model_with_view_points (points, did_push, rint (_drag_distance * trackview.editor().get_current_zoom ())); + alist->thaw (); update_pending = false; - trackview.editor().session()->add_command (new MementoCommand(*alist.get(), 0, &alist->get_state())); - trackview.editor().session()->commit_reversible_command (); + trackview.editor().session()->add_command ( + new MementoCommand(memento_command_binder (), 0, &alist->get_state()) + ); + trackview.editor().session()->set_dirty (); } - void AutomationLine::sync_model_with_view_point (ControlPoint& cp, bool did_push, int64_t distance) { - ModelRepresentation mr; - double ydelta; - - model_representation (cp, mr); - - /* how much are we changing the central point by */ - - ydelta = mr.yval - mr.ypos; - - /* - apply the full change to the central point, and interpolate - on both axes to cover all model points represented - by the control point. + /* find out where the visual control point is. + initial results are in canvas units. ask the + line to convert them to something relevant. */ - /* change all points before the primary point */ - - for (AutomationList::iterator i = mr.start; i != cp.model(); ++i) { + double view_x = cp.get_x(); + double view_y = 1.0 - (cp.get_y() / _height); - double fract = ((*i)->when - mr.xmin) / (mr.xpos - mr.xmin); - double y_delta = ydelta * fract; - double x_delta = distance * fract; - - /* interpolate */ + /* if xval has not changed, set it directly from the model to avoid rounding errors */ - if (y_delta || x_delta) { - alist->modify (i, (*i)->when + x_delta, mr.ymin + y_delta); - } + if (view_x == trackview.editor().frame_to_unit (_time_converter->to ((*cp.model())->when)) - _offset) { + view_x = (*cp.model())->when - _offset; + } else { + view_x = trackview.editor().unit_to_frame (view_x); + view_x = _time_converter->from (view_x + _offset); } - /* change the primary point */ - update_pending = true; - alist->modify (cp.model(), mr.xval, mr.yval); - - - /* change later points */ - - AutomationList::iterator i = cp.model(); - - ++i; - - while (i != mr.end) { - - double delta = ydelta * (mr.xmax - (*i)->when) / (mr.xmax - mr.xpos); - - /* all later points move by the same distance along the x-axis as the main point */ - if (delta) { - alist->modify (i, (*i)->when + distance, (*i)->value + delta); - } + view_to_model_coord_y (view_y); - ++i; - } + alist->modify (cp.model(), view_x, view_y); if (did_push) { - /* move all points after the range represented by the view by the same distance - as the main point moved. + /* move all points after cp by the same distance */ - alist->slide (mr.end, drag_distance); + alist->slide (cp.model()++, distance); } - } bool @@ -883,13 +649,16 @@ AutomationLine::control_points_adjacent (double xval, uint32_t & before, uint32_ bool AutomationLine::is_last_point (ControlPoint& cp) { - ModelRepresentation mr; + // If the list is not empty, and the point is the last point in the list - model_representation (cp, mr); + if (alist->empty()) { + return false; + } - // If the list is not empty, and the point is the last point in the list + AutomationList::const_iterator i = alist->end(); + --i; - if (!alist->empty() && mr.end == alist->end()) { + if (cp.model() == i) { return true; } @@ -899,13 +668,9 @@ AutomationLine::is_last_point (ControlPoint& cp) bool AutomationLine::is_first_point (ControlPoint& cp) { - ModelRepresentation mr; - - model_representation (cp, mr); - // If the list is not empty, and the point is the first point in the list - if (!alist->empty() && mr.start == alist->begin()) { + if (!alist->empty() && cp.model() == alist->begin()) { return true; } @@ -916,70 +681,48 @@ AutomationLine::is_first_point (ControlPoint& cp) void AutomationLine::remove_point (ControlPoint& cp) { - ModelRepresentation mr; - - model_representation (cp, mr); - trackview.editor().session()->begin_reversible_command (_("remove control point")); XMLNode &before = alist->get_state(); - alist->erase (mr.start, mr.end); + alist->erase (cp.model()); + + trackview.editor().session()->add_command( + new MementoCommand (memento_command_binder (), &before, &alist->get_state()) + ); - trackview.editor().session()->add_command(new MementoCommand( - *alist.get(), &before, &alist->get_state())); trackview.editor().session()->commit_reversible_command (); trackview.editor().session()->set_dirty (); } +/** Get selectable points within an area. + * @param start Start position in session frames. + * @param end End position in session frames. + * @param bot Bottom y range, as a fraction of line height, where 0 is the bottom of the line. + * @param top Top y range, as a fraction of line height, where 0 is the bottom of the line. + * @param result Filled in with selectable things; in this case, ControlPoints. + */ void -AutomationLine::get_selectables (nframes_t& start, nframes_t& end, - double botfrac, double topfrac, list& results) +AutomationLine::get_selectables ( + framepos_t start, framepos_t end, double botfrac, double topfrac, list& results + ) { - - double top; - double bot; - double nstart; - double nend; - bool collecting = false; - - /* Curse X11 and its inverted coordinate system! */ - - bot = (1.0 - topfrac) * _height; - top = (1.0 - botfrac) * _height; - - nstart = max_frames; - nend = 0; + /* convert fractions to display coordinates with 0 at the top of the track */ + double const bot_track = (1 - topfrac) * trackview.current_height (); + double const top_track = (1 - botfrac) * trackview.current_height (); for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - double when = (*(*i)->model())->when; - - if (when >= start && when <= end) { - - if ((*i)->get_y() >= bot && (*i)->get_y() <= top) { + double const model_when = (*(*i)->model())->when; - (*i)->show(); - (*i)->set_visible(true); - collecting = true; - nstart = min (nstart, when); - nend = max (nend, when); - - } else { - - if (collecting) { + /* model_when is relative to the start of the source, so we just need to add on the origin_b here + (as it is the session frame position of the start of the source) + */ + + framepos_t const session_frames_when = _time_converter->to (model_when) + _time_converter->origin_b (); - results.push_back (new AutomationSelectable (nstart, nend, botfrac, topfrac, &trackview)); - collecting = false; - nstart = max_frames; - nend = 0; - } - } + if (session_frames_when >= start && session_frames_when <= end && (*i)->get_y() >= bot_track && (*i)->get_y() <= top_track) { + results.push_back (*i); } } - - if (collecting) { - results.push_back (new AutomationSelectable (nstart, nend, botfrac, topfrac, &trackview)); - } - } void @@ -988,92 +731,61 @@ AutomationLine::get_inverted_selectables (Selection&, list& /*resul // hmmm .... } -void -AutomationLine::set_selected_points (PointSelection& points) +/** Take a PointSelection and find ControlPoints that fall within it */ +list +AutomationLine::point_selection_to_control_points (PointSelection const & s) { - double top; - double bot; + list cp; - for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - (*i)->set_selected(false); - } - - if (points.empty()) { - goto out; - } + for (PointSelection::const_iterator i = s.begin(); i != s.end(); ++i) { - for (PointSelection::iterator r = points.begin(); r != points.end(); ++r) { - - if ((*r).track != &trackview) { + if (i->track != &trackview) { continue; } - /* Curse X11 and its inverted coordinate system! */ - - bot = (1.0 - (*r).high_fract) * _height; - top = (1.0 - (*r).low_fract) * _height; - - for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { + double const bot = (1 - i->high_fract) * trackview.current_height (); + double const top = (1 - i->low_fract) * trackview.current_height (); - double rstart, rend; + for (vector::iterator j = control_points.begin(); j != control_points.end(); ++j) { - rstart = trackview.editor().frame_to_unit ((*r).start); - rend = trackview.editor().frame_to_unit ((*r).end); + double const rstart = trackview.editor().frame_to_unit (_time_converter->to (i->start) - _offset); + double const rend = trackview.editor().frame_to_unit (_time_converter->to (i->end) - _offset); - if ((*i)->get_x() >= rstart && (*i)->get_x() <= rend) { - - if ((*i)->get_y() >= bot && (*i)->get_y() <= top) { - - (*i)->set_selected(true); + if ((*j)->get_x() >= rstart && (*j)->get_x() <= rend) { + if ((*j)->get_y() >= bot && (*j)->get_y() <= top) { + cp.push_back (*j); } } - } - } - out: - for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - (*i)->show_color (false, !points_visible); } -} - -void AutomationLine::set_colors() { - set_line_color( ARDOUR_UI::config()->canvasvar_AutomationLine.get() ); - for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - (*i)->show_color (false, !points_visible); - } + return cp; } void -AutomationLine::show_selection () +AutomationLine::set_selected_points (PointSelection const & points) { - TimeSelection& time (trackview.editor().get_selection().time); - for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { + (*i)->set_selected (false); + } - (*i)->set_selected(false); - - for (list::iterator r = time.begin(); r != time.end(); ++r) { - double rstart, rend; - - rstart = trackview.editor().frame_to_unit ((*r).start); - rend = trackview.editor().frame_to_unit ((*r).end); - - if ((*i)->get_x() >= rstart && (*i)->get_x() <= rend) { - (*i)->set_selected(true); - break; - } + if (!points.empty()) { + list cp = point_selection_to_control_points (points); + for (list::iterator i = cp.begin(); i != cp.end(); ++i) { + (*i)->set_selected (true); } - - (*i)->show_color (false, !points_visible); } + + set_colors (); } -void -AutomationLine::hide_selection () +void AutomationLine::set_colors () { -// show_selection (); + set_line_color (ARDOUR_UI::config()->canvasvar_AutomationLine.get()); + for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { + (*i)->set_color (); + } } void @@ -1085,10 +797,11 @@ AutomationLine::list_changed () void AutomationLine::reset_callback (const Evoral::ControlList& events) { - ALPoints tmp_points; - uint32_t npoints = events.size(); + uint32_t vp = 0; + uint32_t pi = 0; + uint32_t np; - if (npoints == 0) { + if (events.empty()) { for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { delete *i; } @@ -1097,26 +810,89 @@ AutomationLine::reset_callback (const Evoral::ControlList& events) return; } - AutomationList::const_iterator ai; + /* hide all existing points, and the line */ + + for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { + (*i)->hide(); + } + + line->hide (); + np = events.size(); + + Evoral::ControlList& e = const_cast (events); + + for (AutomationList::iterator ai = e.begin(); ai != e.end(); ++ai, ++pi) { - for (ai = events.begin(); ai != events.end(); ++ai) { + double tx = (*ai)->when; + double ty = (*ai)->value; + + /* convert from model coordinates to canonical view coordinates */ + + model_to_view_coord (tx, ty); + + if (std::isnan (tx) || std::isnan (ty)) { + warning << string_compose (_("Ignoring illegal points on AutomationLine \"%1\""), + _name) << endmsg; + continue; + } + + if (tx >= max_framepos || tx < 0 || tx >= _maximum_time) { + continue; + } + + /* convert x-coordinate to a canvas unit coordinate (this takes + * zoom and scroll into account). + */ + + tx = trackview.editor().frame_to_unit (tx); + + /* convert from canonical view height (0..1.0) to actual + * height coordinates (using X11's top-left rooted system) + */ - double translated_x = (*ai)->when; - double translated_y = (*ai)->value; - model_to_view_coord (translated_x, translated_y); + ty = _height - (ty * _height); - add_model_point (tmp_points, (*ai)->when, translated_y); + add_visible_control_point (vp, pi, tx, ty, ai, np); + vp++; } - determine_visible_control_points (tmp_points); -} + /* discard extra CP's to avoid confusing ourselves */ + while (control_points.size() > vp) { + ControlPoint* cp = control_points.back(); + control_points.pop_back (); + delete cp; + } -void -AutomationLine::add_model_point (ALPoints& tmp_points, double frame, double yfract) -{ - tmp_points.push_back (ALPoint (trackview.editor().frame_to_unit (_time_converter.to(frame)), - _height - (yfract * _height))); + if (!terminal_points_can_slide) { + control_points.back()->set_can_slide(false); + } + + if (vp > 1) { + + /* reset the line coordinates given to the CanvasLine */ + + while (line_points.size() < vp) { + line_points.push_back (Art::Point (0,0)); + } + + while (line_points.size() > vp) { + line_points.pop_back (); + } + + for (uint32_t n = 0; n < vp; ++n) { + line_points[n].set_x (control_points[n]->get_x()); + line_points[n].set_y (control_points[n]->get_y()); + } + + line->property_points() = line_points; + + if (_visible && alist->interpolation() != AutomationList::Discrete) { + line->show(); + } + } + + set_selected_points (trackview.editor().get_selection().points); } void @@ -1134,13 +910,13 @@ AutomationLine::reset () void AutomationLine::clear () { - /* parent must create command */ - XMLNode &before = get_state(); + /* parent must create and commit command */ + XMLNode &before = alist->get_state(); alist->clear(); + trackview.editor().session()->add_command ( - new MementoCommand(*this, &before, &get_state())); - trackview.editor().session()->commit_reversible_command (); - trackview.editor().session()->set_dirty (); + new MementoCommand (memento_command_binder (), &before, &alist->get_state()) + ); } void @@ -1149,21 +925,28 @@ AutomationLine::change_model (AutomationList::iterator /*i*/, double /*x*/, doub } void -AutomationLine::set_list(boost::shared_ptr list) +AutomationLine::set_list (boost::shared_ptr list) { alist = list; - queue_reset(); + queue_reset (); + connect_to_list (); } void AutomationLine::show_all_control_points () { + if (_is_boolean) { + // show the line but don't allow any control points + return; + } + points_visible = true; for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - (*i)->show_color((_interpolation != AutomationList::Discrete), false); - (*i)->show (); - (*i)->set_visible (true); + if (!(*i)->visible()) { + (*i)->show (); + (*i)->set_visible (true); + } } } @@ -1177,7 +960,7 @@ AutomationLine::hide_all_but_selected_control_points () points_visible = false; for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - if (!(*i)->selected()) { + if (!(*i)->get_selected()) { (*i)->set_visible (false); } } @@ -1215,23 +998,29 @@ AutomationLine::set_state (const XMLNode &node, int version) void AutomationLine::view_to_model_coord (double& x, double& y) const +{ + x = _time_converter->from (x); + view_to_model_coord_y (y); +} + +void +AutomationLine::view_to_model_coord_y (double& y) const { /* TODO: This should be more generic ... */ if (alist->parameter().type() == GainAutomation || alist->parameter().type() == EnvelopeAutomation) { - y = slider_position_to_gain (y); + y = slider_position_to_gain_with_max (y, Config->get_max_gain()); y = max (0.0, y); y = min (2.0, y); - } else if (alist->parameter().type() == PanAutomation) { - // vertical coordinate axis reversal + } else if (alist->parameter().type() == PanAzimuthAutomation || + alist->parameter().type() == PanElevationAutomation || + alist->parameter().type() == PanWidthAutomation) { y = 1.0 - y; } else if (alist->parameter().type() == PluginAutomation) { y = y * (double)(alist->get_max_y()- alist->get_min_y()) + alist->get_min_y(); } else { - y = (int)(y * alist->parameter().max()); + y = rint (y * alist->parameter().max()); } - - x = _time_converter.from(x); } void @@ -1240,8 +1029,10 @@ AutomationLine::model_to_view_coord (double& x, double& y) const /* TODO: This should be more generic ... */ if (alist->parameter().type() == GainAutomation || alist->parameter().type() == EnvelopeAutomation) { - y = gain_to_slider_position (y); - } else if (alist->parameter().type() == PanAutomation) { + y = gain_to_slider_position_with_max (y, Config->get_max_gain()); + } else if (alist->parameter().type() == PanAzimuthAutomation || + alist->parameter().type() == PanElevationAutomation || + alist->parameter().type() == PanWidthAutomation) { // vertical coordinate axis reversal y = 1.0 - y; } else if (alist->parameter().type() == PluginAutomation) { @@ -1250,15 +1041,13 @@ AutomationLine::model_to_view_coord (double& x, double& y) const y = y / (double)alist->parameter().max(); /* ... like this */ } - x = _time_converter.to(x); + x = _time_converter->to (x) - _offset; } - +/** Called when our list has announced that its interpolation style has changed */ void -AutomationLine::set_interpolation(AutomationList::InterpolationStyle style) +AutomationLine::interpolation_changed (AutomationList::InterpolationStyle style) { - _interpolation = style; - if (style == AutomationList::Discrete) { show_all_control_points(); line->hide(); @@ -1269,8 +1058,11 @@ AutomationLine::set_interpolation(AutomationList::InterpolationStyle style) } void -AutomationLine::add_visible_control_point (uint32_t view_index, uint32_t pi, double tx, double ty, AutomationList::iterator model, uint32_t npoints) +AutomationLine::add_visible_control_point (uint32_t view_index, uint32_t pi, double tx, double ty, + AutomationList::iterator model, uint32_t npoints) { + ControlPoint::ShapeType shape; + if (view_index >= control_points.size()) { /* make sure we have enough control points */ @@ -1281,32 +1073,30 @@ AutomationLine::add_visible_control_point (uint32_t view_index, uint32_t pi, dou control_points.push_back (ncp); } - ControlPoint::ShapeType shape; - if (!terminal_points_can_slide) { if (pi == 0) { - control_points[view_index]->set_can_slide(false); + control_points[view_index]->set_can_slide (false); if (tx == 0) { shape = ControlPoint::Start; } else { shape = ControlPoint::Full; } } else if (pi == npoints - 1) { - control_points[view_index]->set_can_slide(false); + control_points[view_index]->set_can_slide (false); shape = ControlPoint::End; } else { - control_points[view_index]->set_can_slide(true); + control_points[view_index]->set_can_slide (true); shape = ControlPoint::Full; } } else { - control_points[view_index]->set_can_slide(true); + control_points[view_index]->set_can_slide (true); shape = ControlPoint::Full; } - + control_points[view_index]->reset (tx, ty, model, view_index, shape); /* finally, control visibility */ - + if (_visible && points_visible) { control_points[view_index]->show (); control_points[view_index]->set_visible (true); @@ -1316,3 +1106,75 @@ AutomationLine::add_visible_control_point (uint32_t view_index, uint32_t pi, dou } } } + +void +AutomationLine::add_always_in_view (double x) +{ + _always_in_view.push_back (x); + alist->apply_to_points (*this, &AutomationLine::reset_callback); +} + +void +AutomationLine::clear_always_in_view () +{ + _always_in_view.clear (); + alist->apply_to_points (*this, &AutomationLine::reset_callback); +} + +void +AutomationLine::connect_to_list () +{ + _list_connections.drop_connections (); + + alist->StateChanged.connect (_list_connections, invalidator (*this), boost::bind (&AutomationLine::list_changed, this), gui_context()); + + alist->InterpolationChanged.connect ( + _list_connections, invalidator (*this), boost::bind (&AutomationLine::interpolation_changed, this, _1), gui_context() + ); +} + +MementoCommandBinder* +AutomationLine::memento_command_binder () +{ + return new SimpleMementoCommandBinder (*alist.get()); +} + +/** Set the maximum time that points on this line can be at, relative + * to the start of the track or region that it is on. + */ +void +AutomationLine::set_maximum_time (framecnt_t t) +{ + if (_maximum_time == t) { + return; + } + + _maximum_time = t; + reset (); +} + + +/** @return min and max x positions of points that are in the list, in session frames */ +pair +AutomationLine::get_point_x_range () const +{ + pair r (max_framepos, 0); + + for (AutomationList::const_iterator i = the_list()->begin(); i != the_list()->end(); ++i) { + r.first = min (r.first, _time_converter->to ((*i)->when) + _offset + _time_converter->origin_b ()); + r.second = max (r.second, _time_converter->to ((*i)->when) + _offset + _time_converter->origin_b ()); + } + + return r; +} + +void +AutomationLine::set_offset (framepos_t off) +{ + if (_offset == off) { + return; + } + + _offset = off; + reset (); +}