X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fautomation_line.cc;h=7206f2dfdcd4aae7b02be40246bf9d45066ca14e;hb=5b45dc04dfba73846893a8c591c4175c20b3415f;hp=d141bafad1cb1cbd5b4e2f87cb629de27ac3cca0;hpb=8a28ea6154f78d491afe746b3a2b0230185afb91;p=ardour.git diff --git a/gtk2_ardour/automation_line.cc b/gtk2_ardour/automation_line.cc index d141bafad1..7206f2dfdc 100644 --- a/gtk2_ardour/automation_line.cc +++ b/gtk2_ardour/automation_line.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2002-2003 Paul Davis + Copyright (C) 2002-2003 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 @@ -22,17 +22,18 @@ #include #include -#include -#include -#include +#include "pbd/stl_delete.h" +#include "pbd/memento_command.h" +#include "pbd/stacktrace.h" -#include -#include -#include +#include "ardour/automation_list.h" +#include "ardour/dB.h" +#include "evoral/Curve.hpp" #include "simplerect.h" #include "automation_line.h" #include "control_point.h" +#include "gui_thread.h" #include "rgb_macros.h" #include "ardour_ui.h" #include "public_editor.h" @@ -40,39 +41,39 @@ #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" -#include -#include +#include "ardour/event_type_map.h" +#include "ardour/session.h" #include "i18n.h" using namespace std; -using namespace sigc; using namespace ARDOUR; using namespace PBD; using namespace Editing; using namespace Gnome; // for Canvas -static const Evoral::IdentityConverter default_converter; +static const Evoral::IdentityConverter default_converter; AutomationLine::AutomationLine (const string& name, TimeAxisView& tv, ArdourCanvas::Group& parent, boost::shared_ptr al, - const Evoral::TimeConverter* converter) + const Evoral::TimeConverter* converter) : trackview (tv) , _name (name) , alist (al) , _parent_group (parent) + , _offset (0) , _time_converter (converter ? (*converter) : default_converter) + , _maximum_time (max_framepos) { - _interpolation = al->interpolation(); 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; @@ -84,18 +85,18 @@ AutomationLine::AutomationLine (const string& name, TimeAxisView& tv, ArdourCanv line->property_width_pixels() = (guint)1; line->set_data ("line", this); - line->signal_event().connect (mem_fun (*this, &AutomationLine::event_handler)); + line->signal_event().connect (sigc::mem_fun (*this, &AutomationLine::event_handler)); - alist->StateChanged.connect (mem_fun(*this, &AutomationLine::list_changed)); - - trackview.session().register_with_memento_command_factory(alist->id(), this); + trackview.session()->register_with_memento_command_factory(alist->id(), this); if (alist->parameter().type() == GainAutomation || alist->parameter().type() == EnvelopeAutomation) { set_uses_gain_mapping (true); } - set_interpolation(alist->interpolation()); + interpolation_changed (alist->interpolation ()); + + connect_to_list (); } AutomationLine::~AutomationLine () @@ -115,14 +116,14 @@ AutomationLine::queue_reset () { if (!update_pending) { update_pending = true; - Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &AutomationLine::reset)); + Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&AutomationLine::reset, this)); } } void -AutomationLine::show () +AutomationLine::show () { - if (_interpolation != AutomationList::Discrete) { + if (alist->interpolation() != AutomationList::Discrete) { line->show(); } @@ -136,7 +137,7 @@ AutomationLine::show () } void -AutomationLine::hide () +AutomationLine::hide () { line->hide(); for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { @@ -148,16 +149,16 @@ 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 +204,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 +225,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().current_session()->begin_reversible_command (_("automation event move")); - trackview.editor().current_session()->add_command (new MementoCommand(*alist.get(), &get_state(), 0)); + trackview.editor().session()->begin_reversible_command (_("automation event move")); + 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,129 +246,17 @@ AutomationLine::modify_point_y (ControlPoint& cp, double y) update_pending = false; - trackview.editor().current_session()->add_command (new MementoCommand(*alist.get(), 0, &alist->get_state())); - trackview.editor().current_session()->commit_reversible_command (); - trackview.editor().current_session()->set_dirty (); -} - + trackview.editor().session()->add_command ( + new MementoCommand (memento_command_binder(), 0, &alist->get_state()) + ); -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); - } - } - } + trackview.editor().session()->commit_reversible_command (); + trackview.editor().session()->set_dirty (); } void AutomationLine::reset_line_coords (ControlPoint& cp) -{ +{ if (cp.view_index() < line_points.size()) { line_points[cp.view_index()].set_x (cp.get_x()); line_points[cp.view_index()].set_y (cp.get_y()); @@ -362,15 +264,12 @@ 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); + for (list::iterator i = cp.begin(); i != cp.end(); ++i) { + sync_model_with_view_point (**i, did_push, distance); } } @@ -381,27 +280,28 @@ AutomationLine::model_representation (ControlPoint& cp, ModelRepresentation& mr) 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; + if (mr.xval == trackview.editor().frame_to_unit(_time_converter.to((*cp.model())->when)) - _offset) { + mr.xval = (*cp.model())->when - _offset; } else { mr.xval = trackview.editor().unit_to_frame (mr.xval); + mr.xval = _time_converter.from (mr.xval + _offset); } - /* convert to model units + /* convert y to model units; the x was already done above */ - - view_to_model_coord (mr.xval, mr.yval); + + view_to_model_coord_y (mr.yval); /* part 2: find out where the model point is now */ - mr.xpos = (*cp.model())->when; + mr.xpos = (*cp.model())->when - _offset; mr.ypos = (*cp.model())->value; /* part 3: get the position of the visual control @@ -440,29 +340,31 @@ AutomationLine::model_representation (ControlPoint& cp, ModelRepresentation& mr) } } +/** @param points AutomationLine points to consider. These will correspond 1-to-1 to + * points in the AutomationList, but will have been transformed so that they are in pixels; + * the x coordinate being the pixel distance from the start of the line (0, or the start + * of the AutomationRegionView if we are in one). + * + * @param skipped Number of points in the AutomationList that were skipped before + * `points' starts. + */ + void -AutomationLine::determine_visible_control_points (ALPoints& points) +AutomationLine::determine_visible_control_points (ALPoints& points, int skipped) { uint32_t view_index, pi, n; - AutomationList::iterator model; uint32_t npoints; - double last_control_point_x = 0.0; - double last_control_point_y = 0.0; uint32_t this_rx = 0; uint32_t prev_rx = 0; uint32_t this_ry = 0; - uint32_t prev_ry = 0; + uint32_t prev_ry = 0; double* slope; uint32_t box_size; - uint32_t cpsize; /* hide all existing points, and the line */ - cpsize = 0; - for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { (*i)->hide(); - ++cpsize; } line->hide (); @@ -489,11 +391,27 @@ AutomationLine::determine_visible_control_points (ALPoints& points) view_index = 0; - for (model = alist->begin(), pi = 0; pi < npoints; ++model, ++pi) { + /* skip over unused AutomationList points before we start */ + + AutomationList::iterator model = alist->begin (); + for (int i = 0; i < skipped; ++i) { + ++model; + } + for (pi = 0; pi < npoints; ++model, ++pi) { + + /* If this line is in an AutomationRegionView, this is an offset from the region position, in pixels */ double tx = points[pi].x; double ty = points[pi].y; - + + if (find (_always_in_view.begin(), _always_in_view.end(), (*model)->when) != _always_in_view.end()) { + add_visible_control_point (view_index, pi, tx, ty, model, npoints); + prev_rx = this_rx; + prev_ry = this_ry; + ++view_index; + continue; + } + if (isnan (tx) || isnan (ty)) { warning << string_compose (_("Ignoring illegal points on AutomationLine \"%1\""), _name) << endmsg; @@ -518,11 +436,11 @@ AutomationLine::determine_visible_control_points (ALPoints& points) 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 @@ -532,73 +450,25 @@ AutomationLine::determine_visible_control_points (ALPoints& 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_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 */ - - if (view_index >= cpsize) { - - /* make sure we have enough control points */ - - ControlPoint* ncp = new ControlPoint (*this); - - ncp->set_size (box_size); - - control_points.push_back (ncp); - ++cpsize; - } - - ControlPoint::ShapeType shape; - - if (!terminal_points_can_slide) { - if (pi == 0) { - 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); - shape = ControlPoint::End; - } else { - control_points[view_index]->set_can_slide(true); - shape = ControlPoint::Full; - } - } else { - control_points[view_index]->set_can_slide(true); - shape = ControlPoint::Full; + continue; } - last_control_point_x = tx; - last_control_point_y = ty; + /* ok, we should display this point */ - control_points[view_index]->reset (tx, ty, model, view_index, shape); + add_visible_control_point (view_index, pi, tx, ty, model, npoints); prev_rx = this_rx; prev_ry = this_ry; - /* finally, control visibility */ - - if (_visible && points_visible) { - control_points[view_index]->show (); - control_points[view_index]->set_visible (true); - } else { - if (!points_visible) { - control_points[view_index]->set_visible (false); - } - } - view_index++; } - + /* discard extra CP's to avoid confusing ourselves */ while (control_points.size() > view_index) { @@ -616,7 +486,7 @@ AutomationLine::determine_visible_control_points (ALPoints& points) if (view_index > 1) { npoints = view_index; - + /* reset the line coordinates */ while (line_points.size() < npoints) { @@ -631,17 +501,16 @@ AutomationLine::determine_visible_control_points (ALPoints& points) 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) { + if (_visible && alist->interpolation() != AutomationList::Discrete) { line->show(); } - } + } set_selected_points (trackview.editor().get_selection().points); - } string @@ -668,11 +537,10 @@ AutomationLine::fraction_to_string (double fraction) const if (fraction == 0.0) { snprintf (buf, sizeof (buf), "-inf"); } else { - snprintf (buf, sizeof (buf), "%.1f", 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 { @@ -697,9 +565,9 @@ AutomationLine::string_to_fraction (string const & s) const double v; 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); @@ -711,115 +579,249 @@ AutomationLine::string_to_fraction (string const & s) const bool AutomationLine::invalid_point (ALPoints& p, uint32_t index) { - return p[index].x == max_frames && p[index].y == DBL_MAX; + return p[index].x == max_framepos && p[index].y == DBL_MAX; } void AutomationLine::invalidate_point (ALPoints& p, uint32_t index) { - p[index].x = max_frames; + p[index].x = max_framepos; p[index].y = DBL_MAX; } +/** 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 (ControlPoint* cp, nframes_t x, float fraction) +AutomationLine::start_drag_single (ControlPoint* cp, double x, float fraction) { - if (trackview.editor().current_session() == 0) { /* how? */ - return; - } + trackview.editor().session()->begin_reversible_command (_("automation event move")); + trackview.editor().session()->add_command ( + new MementoCommand (memento_command_binder(), &get_state(), 0) + ); - string str; + _drag_points.clear (); + _drag_points.push_back (cp); - if (cp) { - str = _("automation event move"); - } else { - str = _("automation range drag"); + 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); + } + } } - trackview.editor().current_session()->begin_reversible_command (str); - trackview.editor().current_session()->add_command (new MementoCommand(*alist.get(), &get_state(), 0)); - - drag_x = x; - drag_distance = 0; - first_drag_fraction = fraction; - last_drag_fraction = fraction; - drags = 0; - did_push = false; + 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::point_drag (ControlPoint& cp, nframes_t x, float fraction, bool with_push) +AutomationLine::start_drag_line (uint32_t i1, uint32_t i2, float fraction) { - if (x > drag_x) { - drag_distance += (x - drag_x); - } else { - drag_distance -= (drag_x - x); + 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)); } - drag_x = x; + start_drag_common (0, fraction); +} - modify_view_point (cp, x, fraction, with_push); +/** 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_multiple (list cp, float fraction, XMLNode* state) +{ + trackview.editor().session()->begin_reversible_command (_("automation range move")); + trackview.editor().session()->add_command ( + new MementoCommand (memento_command_binder(), state, 0) + ); - if (line_points.size() > 1) { - line->property_points() = line_points; + _drag_points = cp; + start_drag_common (0, fraction); +} + + +struct ControlPointSorter +{ + bool operator() (ControlPoint const * a, ControlPoint const * b) { + return a->get_x() < b->get_x(); } +}; - drags++; - did_push = with_push; +/** 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::line_drag (uint32_t i1, uint32_t i2, 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) { - double ydelta = fraction - last_drag_fraction; + /* 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 ()); + } - did_push = with_push; - - last_drag_fraction = fraction; + double dx = ignore_x ? 0 : (x - _drag_x); + double dy = fraction - _last_drag_fraction; + + /* find x limits */ + ControlPoint* before = 0; + ControlPoint* after = 0; + + 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; + } + } + + double const before_x = before ? before->get_x() : 0; + double const after_x = after ? after->get_x() : DBL_MAX; + + /* clamp x */ + for (list::iterator i = points.begin(); i != points.end(); ++i) { + + if ((*i)->can_slide() && !ignore_x) { + + /* clamp min x */ + double const a = (*i)->get_x() + dx; + double const b = before_x + 1; + if (a < b) { + dx += b - a; + } + + /* clamp max x */ + if (after) { + + 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; + } + } + } + } + } - line_drag_cp1 = i1; - line_drag_cp2 = i2; - - ControlPoint *cp; + /* 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; + } + 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 (uint32_t i = i1 ; i <= i2; i++) { - cp = nth (i); - modify_view_point (*cp, - trackview.editor().unit_to_frame (_time_converter.to(cp->get_x())), - ((_height - cp->get_y()) /_height) + ydelta, with_push); + 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); + } } if (line_points.size() > 1) { 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().current_session()->add_command (new MementoCommand(*alist.get(), 0, &alist->get_state())); - trackview.editor().current_session()->commit_reversible_command (); - trackview.editor().current_session()->set_dirty (); -} + 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) @@ -829,7 +831,7 @@ AutomationLine::sync_model_with_view_point (ControlPoint& cp, bool did_push, int model_representation (cp, mr); - /* how much are we changing the central point by */ + /* how much are we changing the central point by */ ydelta = mr.yval - mr.ypos; @@ -842,13 +844,13 @@ AutomationLine::sync_model_with_view_point (ControlPoint& cp, bool did_push, int /* change all points before the primary point */ for (AutomationList::iterator i = mr.start; i != cp.model(); ++i) { - + double fract = ((*i)->when - mr.xmin) / (mr.xpos - mr.xmin); double y_delta = ydelta * fract; double x_delta = distance * fract; /* interpolate */ - + if (y_delta || x_delta) { alist->modify (i, (*i)->when + x_delta, mr.ymin + y_delta); } @@ -859,38 +861,36 @@ AutomationLine::sync_model_with_view_point (ControlPoint& cp, bool did_push, int 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); } - + ++i; } - + if (did_push) { /* move all points after the range represented by the view by the same distance as the main point moved. */ - alist->slide (mr.end, drag_distance); + alist->slide (mr.end, distance); } - } -bool +bool AutomationLine::control_points_adjacent (double xval, uint32_t & before, uint32_t& after) { ControlPoint *bcp = 0; @@ -900,13 +900,13 @@ AutomationLine::control_points_adjacent (double xval, uint32_t & before, uint32_ unit_xval = trackview.editor().frame_to_unit (xval); for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - + if ((*i)->get_x() <= unit_xval) { if (!bcp || (*i)->get_x() > bcp->get_x()) { bcp = *i; before = bcp->view_index(); - } + } } else if ((*i)->get_x() > unit_xval) { acp = *i; @@ -930,7 +930,7 @@ AutomationLine::is_last_point (ControlPoint& cp) if (!alist->empty() && mr.end == alist->end()) { return true; } - + return false; } @@ -946,7 +946,7 @@ AutomationLine::is_first_point (ControlPoint& cp) if (!alist->empty() && mr.start == alist->begin()) { return true; } - + return false; } @@ -958,160 +958,111 @@ AutomationLine::remove_point (ControlPoint& cp) model_representation (cp, mr); - trackview.editor().current_session()->begin_reversible_command (_("remove control point")); + trackview.editor().session()->begin_reversible_command (_("remove control point")); XMLNode &before = alist->get_state(); alist->erase (mr.start, mr.end); - trackview.editor().current_session()->add_command(new MementoCommand( - *alist.get(), &before, &alist->get_state())); - trackview.editor().current_session()->commit_reversible_command (); - trackview.editor().current_session()->set_dirty (); + trackview.editor().session()->add_command( + new MementoCommand (memento_command_binder (), &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; + double const model_when = (*(*i)->model())->when; - if (when >= start && when <= end) { - - if ((*i)->get_y() >= bot && (*i)->get_y() <= top) { - - (*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 -AutomationLine::get_inverted_selectables (Selection&, list& results) +AutomationLine::get_inverted_selectables (Selection&, list& /*results*/) { // 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); - } + for (PointSelection::const_iterator i = s.begin(); i != s.end(); ++i) { - if (points.empty()) { - goto out; - } - - 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! */ + double const bot = (1 - i->high_fract) * trackview.current_height (); + double const top = (1 - i->low_fract) * trackview.current_height (); - bot = (1.0 - (*r).high_fract) * _height; - top = (1.0 - (*r).low_fract) * _height; + for (vector::iterator j = control_points.begin(); j != control_points.end(); ++j) { - for (vector::iterator i = control_points.begin(); i != control_points.end(); ++i) { - - 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) { - - if ((*i)->get_y() >= bot && (*i)->get_y() <= top) { - - (*i)->set_selected(true); + 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 ((*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); - - 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; - } + (*i)->set_selected (false); + } + + 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 @@ -1136,25 +1087,25 @@ AutomationLine::reset_callback (const Evoral::ControlList& events) } AutomationList::const_iterator ai; + int skipped = 0; for (ai = events.begin(); ai != events.end(); ++ai) { - + double translated_x = (*ai)->when; double translated_y = (*ai)->value; model_to_view_coord (translated_x, translated_y); - add_model_point (tmp_points, (*ai)->when, translated_y); + if (translated_x >= 0 && translated_x < _maximum_time) { + tmp_points.push_back (ALPoint ( + trackview.editor().frame_to_unit (translated_x), + _height - (translated_y * _height)) + ); + } else if (translated_x < 0) { + ++skipped; + } } - - determine_visible_control_points (tmp_points); -} - -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))); + determine_visible_control_points (tmp_points, skipped); } void @@ -1172,36 +1123,43 @@ 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().current_session()->add_command ( - new MementoCommand(*this, &before, &get_state())); - trackview.editor().current_session()->commit_reversible_command (); - trackview.editor().current_session()->set_dirty (); + + trackview.editor().session()->add_command ( + new MementoCommand (memento_command_binder (), &before, &alist->get_state()) + ); } void -AutomationLine::change_model (AutomationList::iterator i, double x, double y) +AutomationLine::change_model (AutomationList::iterator /*i*/, double /*x*/, double /*y*/) { } 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); + } } } @@ -1215,12 +1173,12 @@ 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); } } } - + void AutomationLine::track_entered() { @@ -1244,32 +1202,38 @@ AutomationLine::get_state (void) return alist->get_state(); } -int -AutomationLine::set_state (const XMLNode &node) +int +AutomationLine::set_state (const XMLNode &node, int version) { /* function as a proxy for the model */ - return alist->set_state (node); + return alist->set_state (node, 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 @@ -1278,8 +1242,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) { @@ -1287,16 +1253,14 @@ AutomationLine::model_to_view_coord (double& x, double& y) const } else { 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(); @@ -1306,3 +1270,123 @@ 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) +{ + if (view_index >= control_points.size()) { + + /* make sure we have enough control points */ + + ControlPoint* ncp = new ControlPoint (*this); + ncp->set_size (control_point_box_size ()); + + control_points.push_back (ncp); + } + + ControlPoint::ShapeType shape; + + if (!terminal_points_can_slide) { + if (pi == 0) { + 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); + shape = ControlPoint::End; + } else { + control_points[view_index]->set_can_slide(true); + shape = ControlPoint::Full; + } + } else { + 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); + } else { + if (!points_visible) { + control_points[view_index]->set_visible (false); + } + } +} + +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 (); +}