#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"
using namespace Editing;
using namespace Gnome; // for Canvas
-static const Evoral::IdentityConverter<double, sframes_t> default_converter;
+static const Evoral::IdentityConverter<double, framepos_t> default_converter;
AutomationLine::AutomationLine (const string& name, TimeAxisView& tv, ArdourCanvas::Group& parent,
boost::shared_ptr<AutomationList> al,
- const Evoral::TimeConverter<double, sframes_t>* converter)
+ const Evoral::TimeConverter<double, framepos_t>* converter)
: trackview (tv)
, _name (name)
, alist (al)
, _parent_group (parent)
+ , _offset (0)
, _time_converter (converter ? (*converter) : default_converter)
+ , _maximum_time (max_framepos)
{
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;
line->signal_event().connect (sigc::mem_fun (*this, &AutomationLine::event_handler));
- connect_to_list ();
-
trackview.session()->register_with_memento_command_factory(alist->id(), this);
if (alist->parameter().type() == GainAutomation ||
}
}
+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)
{
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 (
trackview.editor().session()->add_command (
new MementoCommand<AutomationList> (memento_command_binder(), 0, &alist->get_state())
);
-
+
trackview.editor().session()->commit_reversible_command ();
trackview.editor().session()->set_dirty ();
}
/* 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);
- view_to_model_coord_x (mr.xval);
+ mr.xval = _time_converter.from (mr.xval + _offset);
}
/* convert y to model units; the x was already done above
/* 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
}
}
+/** @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;
uint32_t this_rx = 0;
uint32_t prev_rx = 0;
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;
/* 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;
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 {
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);
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;
}
_drag_points.clear ();
_drag_points.push_back (cp);
- if (cp->selected ()) {
+ if (cp->get_selected ()) {
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
- if (*i != cp && (*i)->selected()) {
+ if (*i != cp && (*i)->get_selected()) {
_drag_points.push_back (*i);
}
}
}
-
+
start_drag_common (x, fraction);
}
copy (_push_points.begin(), _push_points.end(), back_inserter (points));
points.sort (ControlPointSorter ());
}
-
+
double dx = ignore_x ? 0 : (x - _drag_x);
double dy = fraction - _last_drag_fraction;
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 ();
trackview.editor().session()->add_command (
new MementoCommand<AutomationList>(memento_command_binder (), 0, &alist->get_state())
);
-
- trackview.editor().session()->commit_reversible_command ();
+
trackview.editor().session()->set_dirty ();
}
trackview.editor().session()->add_command(
new MementoCommand<AutomationList> (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<Selectable*>& results)
+AutomationLine::get_selectables (
+ framepos_t start, framepos_t end, double botfrac, double topfrac, list<Selectable*>& 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<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
- double when = (*(*i)->model())->when;
-
- if (when >= start && when <= end) {
+ double const model_when = (*(*i)->model())->when;
- 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::point_selection_to_control_points (PointSelection const & s)
{
list<ControlPoint*> cp;
-
+
for (PointSelection::const_iterator i = s.begin(); i != s.end(); ++i) {
if (i->track != &trackview) {
continue;
}
- /* Curse X11 and its inverted coordinate system! */
-
- double const bot = (1.0 - i->high_fract) * _height;
- double const top = (1.0 - i->low_fract) * _height;
+ double const bot = (1 - i->high_fract) * trackview.current_height ();
+ double const top = (1 - i->low_fract) * trackview.current_height ();
for (vector<ControlPoint*>::iterator j = control_points.begin(); j != control_points.end(); ++j) {
- double const rstart = trackview.editor().frame_to_unit (i->start);
- double const rend = trackview.editor().frame_to_unit (i->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 ((*j)->get_x() >= rstart && (*j)->get_x() <= rend) {
if ((*j)->get_y() >= bot && (*j)->get_y() <= top) {
}
void
-AutomationLine::set_selected_points (PointSelection& points)
+AutomationLine::set_selected_points (PointSelection const & points)
{
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
(*i)->set_selected (false);
}
AutomationList::const_iterator ai;
+ int skipped = 0;
for (ai = events.begin(); ai != events.end(); ++ai) {
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
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<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
points_visible = false;
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
- if (!(*i)->selected()) {
+ if (!(*i)->get_selected()) {
(*i)->set_visible (false);
}
}
void
AutomationLine::view_to_model_coord (double& x, double& y) const
{
- view_to_model_coord_x (x);
+ x = _time_converter.from (x);
view_to_model_coord_y (y);
}
-void
-AutomationLine::view_to_model_coord_x (double& x) const
-{
- x = _time_converter.from(x);
-}
-
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());
}
}
/* 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) {
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 */
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);
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()
);
{
return new SimpleMementoCommandBinder<AutomationList> (*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<framepos_t, framepos_t>
+AutomationLine::get_point_x_range () const
+{
+ pair<framepos_t, framepos_t> 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 ();
+}
projects / ardour.git / blobdiff