if (!pl)
continue;
- boost::shared_ptr<RouteUI> rui = boost::dynamic_pointer_cast<RouteUI>(*i);
+ RouteUI *rui = dynamic_cast<RouteUI *>(*i);
int n_inputs = rui->route()->n_inputs().n_audio(); // FFT is audio only
// Busses don't have playlists, so we need to check that we actually are working with a playlist
} else if (source_selection_regions_rb.get_active()) {
// cerr << "Analyzing selected regions on track " << *&rui->route().name() << endl;
- TimeAxisViewPtr current_axis = (*i);
+ TimeAxisView *current_axis = (*i);
for (RegionSelection::iterator j = ars.begin(); j != ars.end(); ++j) {
// Check that the region is actually audio (so we can analyze it)
continue;
// Check that the region really is selected on _this_ track/solo
- if (arv->get_time_axis_view() != current_axis)
+ if ( &arv->get_time_axis_view() != current_axis)
continue;
// cerr << " - " << (*j)->region().name() << ": " << (*j)->region().length() << " samples starting at " << (*j)->region().position() << endl;
static const int32_t sync_mark_width = 9;
-AudioRegionView::AudioRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView
Ptr tv, boost::shared_ptr<AudioRegion> r, double spu,
+AudioRegionView::AudioRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView
&tv, boost::shared_ptr<AudioRegion> r, double spu,
Gdk::Color const & basic_color)
: RegionView (parent, tv, r, spu, basic_color)
, sync_mark(0)
}
-AudioRegionView::AudioRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView
Ptr tv, boost::shared_ptr<AudioRegion> r, double spu,
+AudioRegionView::AudioRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView
&tv, boost::shared_ptr<AudioRegion> r, double spu,
Gdk::Color const & basic_color, bool recording, TimeAxisViewItem::Visibility visibility)
: RegionView (parent, tv, r, spu, basic_color, recording, visibility)
, sync_mark(0)
store_flags ();
}
- if (trackview->editor().new_regionviews_display_gain()) {
+ if (trackview.editor().new_regionviews_display_gain()) {
_flags |= EnvelopeVisible;
}
setup_fade_handle_positions ();
- if (!trackview->session().config.get_show_region_fades()) {
+ if (!trackview.session().config.get_show_region_fades()) {
set_fade_visibility (false);
}
const string line_name = _region->name() + ":gain";
if (!Profile->get_sae()) {
- gain_line = new AudioRegionGainLine (line_name, trackview->session(), *this, *group,
+ gain_line = new AudioRegionGainLine (line_name, trackview.session(), *this, *group,
audio_region()->envelope());
}
gain_line->reset ();
- set_height (trackview->current_height());
+ set_height (trackview.current_height());
region_muted ();
region_sync_changed ();
{
Glib::ustring str = RegionView::make_name ();
- if (audio_region()->speed_mismatch (trackview->session().frame_rate())) {
+ if (audio_region()->speed_mismatch (trackview.session().frame_rate())) {
str = string ("*") + str;
}
fade_in_handle->hide();
fade_out_handle->hide();
} else {
- if (trackview->session().config.get_show_region_fades()) {
+ if (trackview.session().config.get_show_region_fades()) {
fade_in_handle->show();
fade_out_handle->show();
}
return;
}
- if (trackview->session().config.get_show_region_fades()) {
+ if (trackview.session().config.get_show_region_fades()) {
fade_in_shape->show();
}
return;
}
- if (trackview->session().config.get_show_region_fades()) {
+ if (trackview.session().config.get_show_region_fades()) {
fade_out_shape->show();
}
AudioRegionView::show_region_editor ()
{
if (editor == 0) {
- editor = new AudioRegionEditor (trackview->session(), audio_region(), *this);
+ editor = new AudioRegionEditor (trackview.session(), audio_region(), *this);
// GTK2FIX : how to ensure float without realizing
// editor->realize ();
- // trackview->editor.ensure_float (*editor);
+ // trackview.editor.ensure_float (*editor);
}
editor->present ();
AudioRegionView::create_waves ()
{
// cerr << "AudioRegionView::create_waves() called on " << this << endl;//DEBUG
- RouteTimeAxisViewPtr atv = boost::dynamic_pointer_cast<RouteTimeAxisView> (trackview); // ick
+ RouteTimeAxisView& atv (*(dynamic_cast<RouteTimeAxisView*>(&trackview))); // ick
- if (!atv->get_diskstream()) {
+ if (!atv.get_diskstream()) {
return;
}
- ChanCount nchans = atv->get_diskstream()->n_channels();
+ ChanCount nchans = atv.get_diskstream()->n_channels();
// cerr << "creating waves for " << _region->name() << " with wfd = " << wait_for_data
// << " and channels = " << nchans.n_audio() << endl;
AudioRegionView::create_one_wave (uint32_t which, bool direct)
{
//cerr << "AudioRegionView::create_one_wave() called which: " << which << " this: " << this << endl;//DEBUG
- RouteTimeAxisViewPtr atv = boost::dynamic_pointer_cast<RouteTimeAxisView> (trackview); // ick
- uint32_t nchans = atv->get_diskstream()->n_channels().n_audio();
+ RouteTimeAxisView& atv (*(dynamic_cast<RouteTimeAxisView*>(&trackview))); // ick
+ uint32_t nchans = atv.get_diskstream()->n_channels().n_audio();
uint32_t n;
uint32_t nwaves = std::min (nchans, audio_region()->n_channels());
gdouble ht;
- if (trackview->current_height() < NAME_HIGHLIGHT_THRESH) {
- ht = ((trackview->current_height()) / (double) nchans);
+ if (trackview.current_height() < NAME_HIGHLIGHT_THRESH) {
+ ht = ((trackview.current_height()) / (double) nchans);
} else {
- ht = ((trackview->current_height() - NAME_HIGHLIGHT_SIZE) / (double) nchans);
+ ht = ((trackview.current_height() - NAME_HIGHLIGHT_SIZE) / (double) nchans);
}
gdouble yoff = which * ht;
item->w2i (x, y);
- nframes_t fx = trackview->editor().pixel_to_frame (x);
+ nframes_t fx = trackview.editor().pixel_to_frame (x);
if (fx > _region->length()) {
return;
gain_line->view_to_model_coord (x, y);
- trackview->session().begin_reversible_command (_("add gain control point"));
+ trackview.session().begin_reversible_command (_("add gain control point"));
XMLNode &before = audio_region()->envelope()->get_state();
if (!audio_region()->envelope_active()) {
XMLNode ®ion_before = audio_region()->get_state();
audio_region()->set_envelope_active(true);
XMLNode ®ion_after = audio_region()->get_state();
- trackview
->session().add_command (new MementoCommand<AudioRegion>(*(audio_region().get()), ®ion_before, ®ion_after));
+ trackview
.session().add_command (new MementoCommand<AudioRegion>(*(audio_region().get()), ®ion_before, ®ion_after));
}
audio_region()->envelope()->add (fx, y);
XMLNode &after = audio_region()->envelope()->get_state();
- trackview
->session().add_command (new MementoCommand<AutomationList>(*audio_region()->envelope().get(), &before, &after));
- trackview->session().commit_reversible_command ();
+ trackview
.session().add_command (new MementoCommand<AutomationList>(*audio_region()->envelope().get(), &before, &after));
+ trackview.session().commit_reversible_command ();
}
void
GhostRegion*
-AudioRegionView::add_ghost (TimeAxisViewPtr tv)
+AudioRegionView::add_ghost (TimeAxisView& tv)
{
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (trackview);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&trackview);
assert(rtv);
double unit_position = _region->position () / samples_per_unit;
{
public:
AudioRegionView (ArdourCanvas::Group *,
- RouteTimeAxisViewPtr,
+ RouteTimeAxisView&,
boost::shared_ptr<ARDOUR::AudioRegion>,
double initial_samples_per_unit,
Gdk::Color const & basic_color);
AudioRegionView (ArdourCanvas::Group *,
- RouteTimeAxisViewPtr,
+ RouteTimeAxisView&,
boost::shared_ptr<ARDOUR::AudioRegion>,
double samples_per_unit,
Gdk::Color const & basic_color,
void region_changed (ARDOUR::Change);
void envelope_active_changed ();
- GhostRegion* add_ghost (TimeAxisViewPtr);
+ GhostRegion* add_ghost (TimeAxisView&);
void reset_fade_in_shape_width (nframes_t);
void reset_fade_out_shape_width (nframes_t);
using namespace PBD;
using namespace Editing;
-AudioStreamView::AudioStreamView (AudioTimeAxisViewPtr tv)
+AudioStreamView::AudioStreamView (AudioTimeAxisView& tv)
: StreamView (tv)
{
crossfades_visible = true;
color_handler ();
_amplitude_above_axis = 1.0;
- use_rec_regions = tv->editor().show_waveforms_recording ();
+ use_rec_regions = tv.editor().show_waveforms_recording ();
Config->ParameterChanged.connect (sigc::mem_fun (*this, &AudioStreamView::parameter_changed));
}
return 0;
}
- switch (_trackview->audio_track()->mode()) {
+ switch (_trackview.audio_track()->mode()) {
case NonLayered:
case Normal:
return;
}
- if (!_trackview->session().deletion_in_progress()) {
+ if (!_trackview.session().deletion_in_progress()) {
for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end();) {
list<CrossfadeView*>::iterator tmp;
}
}
- CrossfadeView *cv = new CrossfadeView (_trackview->canvas_display (),
+ CrossfadeView *cv = new CrossfadeView (_trackview.canvas_display (),
_trackview,
crossfade,
_samples_per_unit,
cv->set_valid (true);
crossfade->Invalidated.connect (mem_fun (*this, &AudioStreamView::remove_crossfade));
crossfade_views.push_back (cv);
- if (!_trackview->session().config.get_xfades_visible() || !crossfades_visible || _layer_display == Stacked) {
+ if (!_trackview.session().config.get_xfades_visible() || !crossfades_visible || _layer_display == Stacked) {
cv->hide ();
}
}
// Add and display region and crossfade views, and flag them as valid
- if (_trackview->is_audio_track()) {
- _trackview->get_diskstream()->playlist()->foreach_region(
+ if (_trackview.is_audio_track()) {
+ _trackview.get_diskstream()->playlist()->foreach_region(
sigc::hide_return (sigc::mem_fun (*this, &StreamView::add_region_view))
);
boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(
- _trackview->get_diskstream()->playlist()
+ _trackview.get_diskstream()->playlist()
);
if (apl) {
void
AudioStreamView::setup_rec_box ()
{
- //cerr << _trackview->name() << " streamview SRB region_views.size() = " << region_views.size() << endl;
+ //cerr << _trackview.name() << " streamview SRB region_views.size() = " << region_views.size() << endl;
- if (_trackview->session().transport_rolling()) {
+ if (_trackview.session().transport_rolling()) {
// cerr << "\trolling\n";
if (!rec_active &&
- _trackview->session().record_status() == Session::Recording &&
- _trackview->get_diskstream()->record_enabled()) {
- if (_trackview->audio_track()->mode() == Normal && use_rec_regions && rec_regions.size() == rec_rects.size()) {
+ _trackview.session().record_status() == Session::Recording &&
+ _trackview.get_diskstream()->record_enabled()) {
+ if (_trackview.audio_track()->mode() == Normal && use_rec_regions && rec_regions.size() == rec_rects.size()) {
/* add a new region, but don't bother if they set use_rec_regions mid-record */
rec_data_ready_connections.clear();
// FIXME
- boost::shared_ptr<AudioDiskstream> ads = boost::dynamic_pointer_cast<AudioDiskstream>(_trackview->get_diskstream());
+ boost::shared_ptr<AudioDiskstream> ads = boost::dynamic_pointer_cast<AudioDiskstream>(_trackview.get_diskstream());
assert(ads);
for (uint32_t n=0; n < ads->n_channels().n_audio(); ++n) {
nframes_t start = 0;
if (rec_regions.size() > 0) {
- start = rec_regions.back().first->start() + _trackview->get_diskstream()->get_captured_frames(rec_regions.size()-1);
+ start = rec_regions.back().first->start() + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1);
}
boost::shared_ptr<AudioRegion> region (boost::dynamic_pointer_cast<AudioRegion>
(RegionFactory::create (sources, start, 1 , "", 0, (Region::Flag)(Region::DefaultFlags), false)));
assert(region);
region->block_property_changes ();
- region->set_position (_trackview->session().transport_frame(), this);
+ region->set_position (_trackview.session().transport_frame(), this);
rec_regions.push_back (make_pair(region, (RegionView*)0));
}
boost::shared_ptr<AudioTrack> at;
- at = _trackview->audio_track(); /* we know what it is already */
+ at = _trackview.audio_track(); /* we know what it is already */
boost::shared_ptr<AudioDiskstream> ds = at->audio_diskstream();
nframes_t frame_pos = ds->current_capture_start ();
- gdouble xstart = _trackview->editor().frame_to_pixel (frame_pos);
+ gdouble xstart = _trackview.editor().frame_to_pixel (frame_pos);
gdouble xend;
uint32_t fill_color;
- switch (_trackview->audio_track()->mode()) {
+ switch (_trackview.audio_track()->mode()) {
case Normal:
case NonLayered:
xend = xstart;
RecBoxInfo recbox;
recbox.rectangle = rec_rect;
- recbox.start = _trackview->session().transport_frame();
+ recbox.start = _trackview.session().transport_frame();
recbox.length = 0;
rec_rects.push_back (recbox);
rec_active = true;
} else if (rec_active &&
- (_trackview->session().record_status() != Session::Recording ||
- !_trackview->get_diskstream()->record_enabled())) {
+ (_trackview.session().record_status() != Session::Recording ||
+ !_trackview.get_diskstream()->record_enabled())) {
screen_update_connection.disconnect();
rec_active = false;
rec_updating = false;
rec_data_ready_map[src] = true;
- if (rec_data_ready_map.size() == _trackview->get_diskstream()->n_channels().n_audio()) {
+ if (rec_data_ready_map.size() == _trackview.get_diskstream()->n_channels().n_audio()) {
this->update_rec_regions ();
rec_data_ready_map.clear();
}
if (nlen != region->length()) {
region->freeze ();
- region->set_position (_trackview->get_diskstream()->get_capture_start_frame(n), this);
+ region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
region->set_length (nlen, this);
region->thaw ("updated");
/* also update rect */
ArdourCanvas::SimpleRect * rect = rec_rects[n].rectangle;
- gdouble xend = _trackview->editor().frame_to_pixel (region->position() + region->length());
+ gdouble xend = _trackview.editor().frame_to_pixel (region->position() + region->length());
rect->property_x2() = xend;
}
}
} else {
- nframes_t nlen = _trackview->get_diskstream()->get_captured_frames(n);
+ nframes_t nlen = _trackview.get_diskstream()->get_captured_frames(n);
if (nlen != region->length()) {
if (region->source_length(0) >= region->start() + nlen) {
region->freeze ();
- region->set_position (_trackview->get_diskstream()->get_capture_start_frame(n), this);
+ region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
region->set_length (nlen, this);
region->thaw ("updated");
AudioStreamView::color_handler ()
{
//case cAudioTrackBase:
- if (_trackview->is_track()) {
+ if (_trackview.is_track()) {
canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_AudioTrackBase.get();
}
//case cAudioBusBase:
- if (!_trackview->is_track()) {
- if (Profile->get_sae() && _trackview->route()->is_master()) {
+ if (!_trackview.is_track()) {
+ if (Profile->get_sae() && _trackview.route()->is_master()) {
canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_AudioMasterBusBase.get();
} else {
canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_AudioBusBase.get();
class AudioStreamView : public StreamView
{
public:
- AudioStreamView (AudioTimeAxisViewPtr);
+ AudioStreamView (AudioTimeAxisView&);
~AudioStreamView ();
int set_samples_per_unit (gdouble spp);
AudioTimeAxisView::AudioTimeAxisView (PublicEditor& ed, Session& sess, boost::shared_ptr<Route> rt, Canvas& canvas)
: AxisView(sess)
, RouteTimeAxisView(ed, sess, rt, canvas)
-{
-
-}
-
-AudioTimeAxisViewPtr
-AudioTimeAxisView::create (PublicEditor& ed, Session& sess, boost::shared_ptr<Route> rt, Canvas& canvas)
-{
- AudioTimeAxisViewPtr v (new AudioTimeAxisView (ed, sess, rt, canvas));
- v->init (ed, sess, rt, canvas);
- return v;
-}
-
-void
-AudioTimeAxisView::init (PublicEditor& ed, Session& sess, boost::shared_ptr<Route> rt, Canvas& canvas)
{
// Make sure things are sane...
assert(!is_track() || is_audio_track());
subplugin_menu.set_name ("ArdourContextMenu");
- _view = new AudioStreamView (boost::dynamic_pointer_cast<AudioTimeAxisView> (shared_from_this ()));
+ _view = new AudioStreamView (*this);
ignore_toggle = false;
}
boost::shared_ptr<AutomationTimeAxisView>
- gain_track = AutomationTimeAxisView::create (_session,
- _route, _route->amp(), c,
- _editor,
- shared_from_this (),
- false,
- parent_canvas,
- _route->amp()->describe_parameter(param));
+ gain_track(new AutomationTimeAxisView (_session,
+ _route, _route->amp(), c,
+ _editor,
+ *this,
+ false,
+ parent_canvas,
+ _route->amp()->describe_parameter(param)));
add_automation_child(Evoral::Parameter(GainAutomation), gain_track, show);
std::string const name = _route->panner()->describe_parameter (pan_control->parameter ());
- boost::shared_ptr<AutomationTimeAxisView> pan_track =
- AutomationTimeAxisView::create (_session,
- _route, _route->panner(), pan_control,
- _editor,
- shared_from_this (),
- false,
- parent_canvas,
- name);
+ boost::shared_ptr<AutomationTimeAxisView> pan_track (
+ new AutomationTimeAxisView (_session,
+ _route, _route->panner(), pan_control,
+ _editor,
+ *this,
+ false,
+ parent_canvas,
+ name));
add_automation_child (*p, pan_track, show);
}
#include "editing.h"
#include "route_time_axis.h"
#include "canvas.h"
-#include "shared_ptrs.h"
namespace ARDOUR {
class Session;
class AudioTimeAxisView : public RouteTimeAxisView
{
public:
- static AudioTimeAxisViewPtr
- create (PublicEditor&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, ArdourCanvas::Canvas& canvas);
-
+ AudioTimeAxisView (PublicEditor&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, ArdourCanvas::Canvas& canvas);
virtual ~AudioTimeAxisView ();
AudioStreamView* audio_view();
private:
friend class AudioStreamView;
friend class AudioRegionView;
-
- AudioTimeAxisView (PublicEditor&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, ArdourCanvas::Canvas& canvas);
- void init (PublicEditor&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, ArdourCanvas::Canvas& canvas);
void route_active_changed ();
static const Evoral::IdentityConverter<double, sframes_t> default_converter;
-AutomationLine::AutomationLine (const string& name, TimeAxisViewPtr tv, ArdourCanvas::Group& parent,
+AutomationLine::AutomationLine (const string& name, TimeAxisView& tv, ArdourCanvas::Group& parent,
boost::shared_ptr<AutomationList> al,
const Evoral::TimeConverter<double, sframes_t>* converter)
: trackview (tv)
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) {
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));
- trackview->editor().current_session()->begin_reversible_command (_("automation event move"));
- trackview
->editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), &get_state(), 0));
+ trackview.editor().current_session()->begin_reversible_command (_("automation event move"));
+ trackview
.editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), &get_state(), 0));
cp.move_to (x, y, ControlPoint::Full);
reset_line_coords (cp);
update_pending = false;
- trackview
->editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), 0, &alist->get_state()));
- trackview->editor().current_session()->commit_reversible_command ();
- trackview->editor().current_session()->set_dirty ();
+ trackview
.editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), 0, &alist->get_state()));
+ trackview.editor().current_session()->commit_reversible_command ();
+ trackview.editor().current_session()->set_dirty ();
}
already in frames. it needs to be converted to canvas units.
*/
- x = trackview->editor().frame_to_unit (x);
+ x = trackview.editor().frame_to_unit (x);
/* clamp x position using view coordinates */
/* leave the x-coordinate alone */
- x = trackview->editor().frame_to_unit (_time_converter.to((*cp.model())->when));
+ x = trackview.editor().frame_to_unit (_time_converter.to((*cp.model())->when));
}
/* 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))) {
+ 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);
+ mr.xval = trackview.editor().unit_to_frame (mr.xval);
}
/* convert to model units
}
- set_selected_points (trackview->editor().get_selection().points);
+ set_selected_points (trackview.editor().get_selection().points);
}
void
AutomationLine::start_drag (ControlPoint* cp, nframes_t x, float fraction)
{
- if (trackview->editor().current_session() == 0) { /* how? */
+ if (trackview.editor().current_session() == 0) { /* how? */
return;
}
str = _("automation range drag");
}
- trackview->editor().current_session()->begin_reversible_command (str);
- trackview
->editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), &get_state(), 0));
+ trackview.editor().current_session()->begin_reversible_command (str);
+ trackview
.editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), &get_state(), 0));
drag_x = x;
drag_distance = 0;
if (range_found) {
for (vector<ControlPoint*>::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);
+ modify_view_point (*(*i), trackview.editor().unit_to_frame ((*i)->get_x()), ((_height - (*i)->get_y()) /_height) + ydelta, with_push);
}
}
} 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);
+ modify_view_point (*cp, trackview.editor().unit_to_frame (cp->get_x()), ((_height - cp->get_y()) /_height) + ydelta, with_push);
}
}
update_pending = false;
- trackview
->editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), 0, &alist->get_state()));
- trackview->editor().current_session()->commit_reversible_command ();
- trackview->editor().current_session()->set_dirty ();
+ trackview
.editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), 0, &alist->get_state()));
+ trackview.editor().current_session()->commit_reversible_command ();
+ trackview.editor().current_session()->set_dirty ();
}
ControlPoint *acp = 0;
double unit_xval;
- unit_xval = trackview->editor().frame_to_unit (xval);
+ unit_xval = trackview.editor().frame_to_unit (xval);
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
model_representation (cp, mr);
- trackview->editor().current_session()->begin_reversible_command (_("remove control point"));
+ trackview.editor().current_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<AutomationList>(
+ trackview
.editor().current_session()->add_command(new MementoCommand<AutomationList>(
*alist.get(), &before, &alist->get_state()));
- trackview->editor().current_session()->commit_reversible_command ();
- trackview->editor().current_session()->set_dirty ();
+ trackview.editor().current_session()->commit_reversible_command ();
+ trackview.editor().current_session()->set_dirty ();
}
void
for (PointSelection::iterator r = points.begin(); r != points.end(); ++r) {
- if (r->track != trackview) {
+ if (&(*r).track != &trackview) {
continue;
}
double rstart, rend;
- rstart = trackview->editor().frame_to_unit ((*r).start);
- rend = trackview->editor().frame_to_unit ((*r).end);
+ 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) {
void
AutomationLine::show_selection ()
{
- TimeSelection& time (trackview->editor().get_selection().time);
+ TimeSelection& time (trackview.editor().get_selection().time);
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
for (list<AudioRange>::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);
+ 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);
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)),
+ tmp_points.push_back (ALPoint (trackview.editor().frame_to_unit (_time_converter.to(frame)),
_height - (yfract * _height)));
}
/* parent must create command */
XMLNode &before = get_state();
alist->clear();
- trackview->editor().current_session()->add_command (
+ trackview.editor().current_session()->add_command (
new MementoCommand<AutomationLine>(*this, &before, &get_state()));
- trackview->editor().current_session()->commit_reversible_command ();
- trackview->editor().current_session()->set_dirty ();
+ trackview.editor().current_session()->commit_reversible_command ();
+ trackview.editor().current_session()->set_dirty ();
}
void
#include <sigc++/signal.h>
#include "canvas.h"
#include "simplerect.h"
-#include "shared_ptrs.h"
#include "evoral/TimeConverter.hpp"
class AutomationLine : public sigc::trackable, public PBD::StatefulThingWithGoingAway
{
public:
- AutomationLine (const std::string& name, TimeAxisViewPtr, ArdourCanvas::Group&,
+ AutomationLine (const std::string& name, TimeAxisView&, ArdourCanvas::Group&,
boost::shared_ptr<ARDOUR::AutomationList>,
const Evoral::TimeConverter<double, ARDOUR::sframes_t>* converter = 0);
virtual ~AutomationLine ();
void set_uses_gain_mapping (bool yn);
bool get_uses_gain_mapping () const { return _uses_gain_mapping; }
- TimeAxisViewPtr trackview;
+ TimeAxisView& trackview;
ArdourCanvas::Group& canvas_group() const { return *group; }
ArdourCanvas::Item& parent_group() const { return _parent_group; }
#include "i18n.h"
AutomationRegionView::AutomationRegionView(ArdourCanvas::Group* parent,
- AutomationTimeAxisViewPtr time_axis,
+ AutomationTimeAxisView& time_axis,
boost::shared_ptr<ARDOUR::Region> region,
const Evoral::Parameter& param,
boost::shared_ptr<ARDOUR::AutomationList> list,
reset_width_dependent_items ((double) _region->length() / samples_per_unit);
- set_height (trackview->current_height());
+ set_height (trackview.current_height());
_region->StateChanged.connect (mem_fun(*this, &AutomationRegionView::region_changed));
_line->set_interpolation(list->interpolation());
_line->show();
_line->show_all_control_points();
- _line->set_height ((uint32_t)rint(trackview->current_height() - NAME_HIGHLIGHT_SIZE));
+ _line->set_height ((uint32_t)rint(trackview.current_height() - NAME_HIGHLIGHT_SIZE));
}
bool
{
if (ev->type == GDK_BUTTON_RELEASE) {
- const nframes_t when = trackview->editor().pixel_to_frame((nframes_t)ev->button.x)
+ const nframes_t when = trackview.editor().pixel_to_frame((nframes_t)ev->button.x)
- _region->position();
add_automation_event(ev, when, ev->button.y);
}
assert(_line);
double x = 0;
- AutomationTimeAxisViewPtr view = automation_view();
+ AutomationTimeAxisView* const view = automation_view();
view->canvas_display()->w2i (x, y);
/* compute vertical fractional position */
- const double h = trackview->current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE - 2;
+ const double h = trackview.current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE - 2;
y = 1.0 - (y / h);
/* map using line */
{
public:
AutomationRegionView(ArdourCanvas::Group*,
- AutomationTimeAxisViewPtr,
+ AutomationTimeAxisView&,
boost::shared_ptr<ARDOUR::Region>,
const Evoral::Parameter& parameter,
boost::shared_ptr<ARDOUR::AutomationList>,
void init (Gdk::Color const & basic_color, bool wfd);
- inline AutomationTimeAxisViewPtr automation_view() const {
- return boost::dynamic_pointer_cast<AutomationTimeAxisView> (trackview);
- }
+ inline AutomationTimeAxisView* automation_view() const
+ { return dynamic_cast<AutomationTimeAxisView*>(&trackview); }
void set_line(boost::shared_ptr<AutomationLine> line) { _line = line; }
boost::shared_ptr<AutomationLine> line() { return _line; }
// We are a ghost. Meta ghosts? Crazy talk.
- virtual GhostRegion* add_ghost(TimeAxisViewPtr) { return 0; }
+ virtual GhostRegion* add_ghost(TimeAxisView&) { return NULL; }
void set_height (double);
void reset_width_dependent_items(double pixel_width);
nframes_t end;
double low_fract;
double high_fract;
- TimeAxisViewPtr track;
+ TimeAxisView& track;
- AutomationSelectable (nframes_t s, nframes_t e, double l, double h, TimeAxisViewPtr atv)
+ AutomationSelectable (nframes_t s, nframes_t e, double l, double h, TimeAxisView& atv)
: start (s), end (e), low_fract (l), high_fract (h), track (atv) {}
bool operator== (const AutomationSelectable& other) {
end == other.end &&
low_fract == other.low_fract &&
high_fract == other.high_fract &&
- track == other.track;
+ &track == &other.track;
}
};
using namespace PBD;
using namespace Editing;
-AutomationStreamView::AutomationStreamView (AutomationTimeAxisViewPtr tv)
- : StreamView (boost::dynamic_pointer_cast<RouteTimeAxisView> (tv->get_parent()),
- new ArdourCanvas::Group(*tv->canvas_display()))
- , _controller(tv->controller())
+AutomationStreamView::AutomationStreamView (AutomationTimeAxisView& tv)
+ : StreamView (*dynamic_cast<RouteTimeAxisView*>(tv.get_parent()),
+ new ArdourCanvas::Group(*tv.canvas_display()))
+ , _controller(tv.controller())
, _automation_view(tv)
{
//canvas_rect->property_fill_color_rgba() = stream_base_color;
canvas_rect->property_outline_color_rgba() = RGBA_BLACK;
- use_rec_regions = tv->editor().show_waveforms_recording ();
+ use_rec_regions = tv.editor().show_waveforms_recording ();
}
AutomationStreamView::~AutomationStreamView ()
}
// Add and display region views, and flag them as valid
- if (_trackview->is_track()) {
- _trackview->get_diskstream()->playlist()->foreach_region (
+ if (_trackview.is_track()) {
+ _trackview.get_diskstream()->playlist()->foreach_region (
sigc::hide_return (sigc::mem_fun (*this, &StreamView::add_region_view))
);
}
void
AutomationStreamView::color_handler ()
{
- /*if (_trackview->is_midi_track()) {
+ /*if (_trackview.is_midi_track()) {
canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiTrackBase.get();
}
- if (!_trackview->is_midi_track()) {
+ if (!_trackview.is_midi_track()) {
canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiBusBase.get();;
}*/
}
class AutomationStreamView : public StreamView
{
public:
- AutomationStreamView (AutomationTimeAxisViewPtr tv);
+ AutomationStreamView (AutomationTimeAxisView& tv);
~AutomationStreamView ();
void set_automation_state (ARDOUR::AutoState state);
void redisplay_diskstream ();
inline double contents_height() const {
- return (_trackview->current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE - 2);
+ return (_trackview.current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE - 2);
}
private:
boost::shared_ptr<AutomationController> _controller;
- AutomationTimeAxisViewPtr _automation_view;
+ AutomationTimeAxisView& _automation_view;
};
#endif /* __ardour_automation_streamview_h__ */
* For region automation (e.g. MIDI CC), pass null for \a.
*/
AutomationTimeAxisView::AutomationTimeAxisView (Session& s, boost::shared_ptr<Route> r,
-
boost::shared_ptr<Automatable> a, boost::shared_ptr<AutomationControl> c,
- PublicEditor& e, TimeAxisViewPtr parent, bool show_regions,
- ArdourCanvas::Canvas& canvas, const string & nom, const string & nomparent)
+ boost::shared_ptr<Automatable> a, boost::shared_ptr<AutomationControl> c,
+ PublicEditor& e, TimeAxisView& parent, bool show_regions,
+ ArdourCanvas::Canvas& canvas, const string & nom, const string & nomparent)
: AxisView (s),
- TimeAxisView (s, e, parent, canvas),
+ TimeAxisView (s, e, &parent, canvas),
_route (r),
_control (c),
_automatable (a),
_controller(AutomationController::create(a, c->parameter(), c)),
_base_rect (0),
+ _view (show_regions ? new AutomationStreamView(*this) : NULL),
_name (nom),
auto_button (X_("")) /* force addition of a label */
{
-
-}
-
-AutomationTimeAxisViewPtr
-AutomationTimeAxisView::create (Session& s, boost::shared_ptr<Route> r,
- boost::shared_ptr<Automatable> a, boost::shared_ptr<AutomationControl> c,
- PublicEditor& e, TimeAxisViewPtr parent, bool show_regions,
- ArdourCanvas::Canvas& canvas, const string & nom, const string & nomparent)
-{
- AutomationTimeAxisViewPtr v (new AutomationTimeAxisView (s, r, a, c, e, parent, show_regions, canvas, nom, nomparent));
- v->init (s, r, a, c, e, parent, show_regions, canvas, nom, nomparent);
- return v;
-}
-
-
-void
-AutomationTimeAxisView::init (Session& s, boost::shared_ptr<Route> r,
- boost::shared_ptr<Automatable> a, boost::shared_ptr<AutomationControl> c,
- PublicEditor& e, TimeAxisViewPtr parent, bool show_regions,
- ArdourCanvas::Canvas& canvas, const string & nom, const string & nomparent)
-{
- if (show_regions) {
- _view = new AutomationStreamView (boost::dynamic_pointer_cast<AutomationTimeAxisView> (shared_from_this()));
- } else {
- _view = 0;
- }
-
if (!have_name_font) {
name_font = get_font_for_style (X_("AutomationTrackName"));
have_name_font = true;
_base_rect->set_data ("trackview", this);
- _base_rect->signal_event().connect (
- bind (
+ _base_rect->signal_event().connect (bind (
mem_fun (_editor, &PublicEditor::canvas_automation_track_event),
- _base_rect,
- boost::weak_ptr<AutomationTimeAxisView> (
- boost::dynamic_pointer_cast<AutomationTimeAxisView> (shared_from_this ())
- )
- )
- );
+ _base_rect, this));
// _base_rect->lower_to_bottom();
} else {
boost::shared_ptr<AutomationLine> line(new AutomationLine (
ARDOUR::EventTypeMap::instance().to_symbol(_control->parameter()),
- boost::dynamic_pointer_cast<AutomationTimeAxisView> (shared_from_this ()),
+ *this,
*_canvas_display,
_control->alist()));
(height < hNormal && h >= hNormal)
|| (height >= hNormal || h < hNormal) );
- TimeAxisViewPtr state_parent = get_parent_with_state ();
+ TimeAxisView* state_parent = get_parent_with_state ();
assert(state_parent);
XMLNode* xml_node = state_parent->get_automation_child_xml_node (_control->parameter());
for (PointSelection::iterator i = selection.begin(); i != selection.end(); ++i) {
- if (i->track != shared_from_this ()) {
+ if (&(*i).track != this) {
continue;
}
for (PointSelection::iterator i = selection.begin(); i != selection.end(); ++i) {
- if (i->track != shared_from_this ()) {
+ if (&(*i).track != this) {
continue;
}
XMLNode*
AutomationTimeAxisView::get_state_node ()
{
- TimeAxisViewPtr state_parent = get_parent_with_state ();
+ TimeAxisView* state_parent = get_parent_with_state ();
if (state_parent) {
return state_parent->get_automation_child_xml_node (_control->parameter());
#include "time_axis_view.h"
#include "simplerect.h"
#include "automation_controller.h"
-#include "shared_ptrs.h"
namespace ARDOUR {
class Session;
class AutomationTimeAxisView : public TimeAxisView {
public:
-
- static AutomationTimeAxisViewPtr
- create (ARDOUR::Session&,
- boost::shared_ptr<ARDOUR::Route>,
- boost::shared_ptr<ARDOUR::Automatable>,
- boost::shared_ptr<ARDOUR::AutomationControl>,
- PublicEditor&,
- TimeAxisViewPtr parent,
- bool show_regions,
- ArdourCanvas::Canvas& canvas,
- const std::string & name, /* translatable */
- const std::string & plug_name = "");
+ AutomationTimeAxisView (ARDOUR::Session&,
+ boost::shared_ptr<ARDOUR::Route>,
+ boost::shared_ptr<ARDOUR::Automatable>,
+ boost::shared_ptr<ARDOUR::AutomationControl>,
+ PublicEditor&,
+ TimeAxisView& parent,
+ bool show_regions,
+ ArdourCanvas::Canvas& canvas,
+ const std::string & name, /* translatable */
+ const std::string & plug_name = "");
~AutomationTimeAxisView();
static Pango::FontDescription* name_font;
static bool have_name_font;
-
-private:
-
- AutomationTimeAxisView (ARDOUR::Session&,
- boost::shared_ptr<ARDOUR::Route>,
- boost::shared_ptr<ARDOUR::Automatable>,
- boost::shared_ptr<ARDOUR::AutomationControl>,
- PublicEditor&,
- TimeAxisViewPtr parent,
- bool show_regions,
- ArdourCanvas::Canvas& canvas,
- const std::string & name, /* translatable */
- const std::string & plug_name = "");
-
- void
- init (ARDOUR::Session&,
- boost::shared_ptr<ARDOUR::Route>,
- boost::shared_ptr<ARDOUR::Automatable>,
- boost::shared_ptr<ARDOUR::AutomationControl>,
- PublicEditor&,
- TimeAxisViewPtr parent,
- bool show_regions,
- ArdourCanvas::Canvas& canvas,
- const std::string & name, /* translatable */
- const std::string & plug_name);
-
};
#endif /* __ardour_gtk_automation_time_axis_h__ */
bool select_mod;
uint8_t d_velocity = 10;
- if (_region.get_time_axis_view()->editor().current_mouse_mode() != Editing::MouseNote) {
+ if (_region.get_time_axis_view().editor().current_mouse_mode() != Editing::MouseNote) {
return false;
}
static double middle_point, last_x;
Gdk::Cursor cursor;
static NoteEnd note_end;
- Editing::MidiEditMode edit_mode = _region.get_trackview()->editor().current_midi_edit_mode();
+ Editing::MidiEditMode edit_mode = _region.get_trackview().editor().current_midi_edit_mode();
switch (ev->type) {
case GDK_BUTTON_PRESS:
sigc::signal<void,CrossfadeView*> CrossfadeView::GoingAway;
CrossfadeView::CrossfadeView (ArdourCanvas::Group *parent,
- RouteTimeAxisViewPtr tv,
+ RouteTimeAxisView &tv,
boost::shared_ptr<Crossfade> xf,
double spu,
Gdk::Color& basic_color,
fade_out->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_CrossfadeLine.get();
fade_out->property_width_pixels() = 1;
- set_height (get_time_axis_view()->current_height());
+ set_height (get_time_axis_view().current_height());
/* no frame around the xfade or overlap rects */
vestigial_frame->hide();
show_vestigial = false;
- group->signal_event().connect (bind (mem_fun (tv->editor(), &PublicEditor::canvas_crossfade_view_event), group, this));
+ group->signal_event().connect (bind (mem_fun (tv.editor(), &PublicEditor::canvas_crossfade_view_event), group, this));
crossfade_changed (Change (~0));
track is either Small or Smaller.
*/
- double tav_height = get_time_axis_view()->current_height();
+ double tav_height = get_time_axis_view().current_height();
if (tav_height == TimeAxisView::hSmaller ||
tav_height == TimeAxisView::hSmall) {
h = tav_height - 3.0;
return;
}
- npoints = get_time_axis_view()->editor().frame_to_pixel (crossfade->length());
+ npoints = get_time_axis_view().editor().frame_to_pixel (crossfade->length());
// npoints = std::min (gdk_screen_width(), npoints);
if (!_visible || !crossfade->active() || npoints < 3) {
struct CrossfadeView : public TimeAxisViewItem
{
CrossfadeView (ArdourCanvas::Group*,
- RouteTimeAxisViewPtr,
+ RouteTimeAxisView&,
boost::shared_ptr<ARDOUR::Crossfade>,
double initial_samples_per_unit,
Gdk::Color& basic_color,
cut_buffer = new Selection (this);
clicked_regionview = 0;
+ clicked_axisview = 0;
+ clicked_routeview = 0;
clicked_crossfadeview = 0;
clicked_control_point = 0;
last_update_frame = 0;
leftmost_frame = 0;
ignore_mouse_mode_toggle = false;
ignore_midi_edit_mode_toggle = false;
+ current_stepping_trackview = 0;
+ entered_track = 0;
entered_regionview = 0;
entered_marker = 0;
clear_entered_track = false;
}
void
-Editor::set_entered_track (TimeAxisViewPtr tav)
+Editor::set_entered_track (TimeAxisView* tav)
{
if (entered_track) {
entered_track->exited ();
to be re-hidden
*/
- TimeAxisViewPtr tv;
+ TimeAxisView *tv;
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- tv = (static_cast<TimeAxisViewPtr>(*i));
+ tv = (static_cast<TimeAxisView*>(*i));
tv->reset_height ();
}
}
session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks);
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- (static_cast<TimeAxisViewPtr>(*i))->set_samples_per_unit (frames_per_unit);
+ (static_cast<TimeAxisView*>(*i))->set_samples_per_unit (frames_per_unit);
}
start_scrolling ();
MenuList& edit_items = track_region_context_menu.items();
edit_items.clear();
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (clicked_axisview);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (clicked_axisview);
if (rtv) {
boost::shared_ptr<Diskstream> ds;
MenuList& edit_items = track_crossfade_context_menu.items();
edit_items.clear ();
- AudioTimeAxisViewPtr atv = boost::dynamic_pointer_cast<AudioTimeAxisView> (clicked_axisview);
+ AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (clicked_axisview);
if (atv) {
boost::shared_ptr<Diskstream> ds;
* TimeAxisView may be 0. Layer index is the layer number if the TimeAxisView is valid and is
* in stacked region display mode, otherwise 0.
*/
-std::pair<TimeAxisViewPtr, layer_t>
+std::pair<TimeAxisView *, layer_t>
Editor::trackview_by_y_position (double y)
{
for (TrackViewList::iterator iter = track_views.begin(); iter != track_views.end(); ++iter) {
- std::pair<TimeAxisViewPtr, int> const r = (*iter)->covers_y_position (y);
+ std::pair<TimeAxisView*, int> const r = (*iter)->covers_y_position (y);
if (r.first) {
return r;
}
}
- return std::make_pair (TimeAxisViewPtr (), 0);
+ return std::make_pair ( (TimeAxisView *) 0, 0);
}
void
}
Editor::TrackViewList *
-Editor::get_valid_views (TimeAxisViewPtr track, RouteGroup* group)
+Editor::get_valid_views (TimeAxisView* track, RouteGroup* group)
{
TrackViewList::iterator i;
*/
void
-Editor::new_playlists (boost::weak_ptr<TimeAxisView> w)
+Editor::new_playlists (TimeAxisView* v)
{
- TimeAxisViewPtr v = w.lock ();
- if (!v) {
- return;
- }
-
begin_reversible_command (_("new playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
session->get_playlists(playlists);
*/
void
-Editor::copy_playlists (boost::weak_ptr<TimeAxisView> w)
+Editor::copy_playlists (TimeAxisView* v)
{
- TimeAxisViewPtr v = w.lock ();
- if (!v) {
- return;
- }
-
begin_reversible_command (_("copy playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
session->get_playlists(playlists);
*/
void
-Editor::clear_playlists (boost::weak_ptr<TimeAxisView> w)
+Editor::clear_playlists (TimeAxisView* v)
{
- TimeAxisViewPtr v = w.lock ();
- if (!v) {
- return;
- }
-
begin_reversible_command (_("clear playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
session->get_playlists(playlists);
}
void
-Editor::mapped_use_new_playlist (RouteTimeAxisView
Ptr atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
+Editor::mapped_use_new_playlist (RouteTimeAxisView
& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
{
- atv->use_new_playlist (sz > 1 ? false : true, playlists);
+ atv.use_new_playlist (sz > 1 ? false : true, playlists);
}
void
-Editor::mapped_use_copy_playlist (RouteTimeAxisView
Ptr atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
+Editor::mapped_use_copy_playlist (RouteTimeAxisView
& atv, uint32_t sz, vector<boost::shared_ptr<ARDOUR::Playlist> > const & playlists)
{
- atv->use_copy_playlist (sz > 1 ? false : true, playlists);
+ atv.use_copy_playlist (sz > 1 ? false : true, playlists);
}
void
-Editor::mapped_clear_playlist (RouteTimeAxisViewPtr atv, uint32_t sz)
+Editor::mapped_clear_playlist (RouteTimeAxisView& atv, uint32_t sz)
{
- atv->clear_playlist ();
+ atv.clear_playlist ();
}
bool
}
struct EditorOrderTimeAxisSorter {
- bool operator() (const TimeAxisViewPtr a, const TimeAxisViewPtr b) const {
+ bool operator() (const TimeAxisView* a, const TimeAxisView* b) const {
return a->order () < b->order ();
}
};
}
for (TrackSelection::const_iterator t = tracks->begin(); t != tracks->end(); ++t) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView>(*t);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*t);
if (rtv) {
boost::shared_ptr<Diskstream> ds;
boost::shared_ptr<Playlist> pl;
}
for (TrackSelection::const_iterator t = tracks->begin(); t != tracks->end(); ++t) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView>(*t);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*t);
if (rtv) {
boost::shared_ptr<Diskstream> ds;
boost::shared_ptr<Playlist> pl;
for (RegionSelection::iterator i = to_map.begin (); i != to_map.end(); ++i) {
- RouteGroup* g = (*i)->get_time_axis_view()->route_group ();
+ RouteGroup* g = (*i)->get_time_axis_view().route_group ();
if (g && g->active_property (RouteGroup::Edit)) {
tracks.add (axis_views_from_routes (g->route_list()));
}
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- RouteTimeAxisViewPtr tatv;
+ RouteTimeAxisView* tatv;
- if ((tatv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i)) != 0) {
+ if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
boost::shared_ptr<Playlist> pl;
vector<boost::shared_ptr<Region> > results;
}
void
-Editor::add_to_idle_resize (TimeAxisViewPtr view, int32_t h)
+Editor::add_to_idle_resize (TimeAxisView* view, int32_t h)
{
if (resize_idle_id < 0) {
resize_idle_id = g_idle_add (_idle_resizer, this);
{
_pending_resize_view->idle_resize (_pending_resize_view->current_height() + _pending_resize_amount);
- if (boost::dynamic_pointer_cast<AutomationTimeAxisView> (_pending_resize_view) == 0 &&
+ if (dynamic_cast<AutomationTimeAxisView*> (_pending_resize_view) == 0 &&
selection->tracks.contains (_pending_resize_view)) {
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
for (list<Route*>::const_iterator i = r.begin(); i != r.end(); ++i) {
TrackViewList::const_iterator j = track_views.begin ();
while (j != track_views.end()) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*j);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*j);
if (rtv && rtv->route().get() == *i) {
t.push_back (rtv);
}
{
ENSURE_GUI_THREAD (bind (mem_fun (*this, &Editor::handle_new_route), routes));
- RouteTimeAxisViewPtr rtv;
- list<RouteTimeAxisViewPtr> new_views;
+ RouteTimeAxisView *rtv;
+ list<RouteTimeAxisView*> new_views;
for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
boost::shared_ptr<Route> route = (*x);
DataType dt = route->input()->default_type();
if (dt == ARDOUR::DataType::AUDIO) {
- rtv = AudioTimeAxisView::create (*this, *session, route, *track_canvas);
+ rtv = new AudioTimeAxisView (*this, *session, route, *track_canvas);
} else if (dt == ARDOUR::DataType::MIDI) {
- rtv = MidiTimeAxisView::create (*this, *session, route, *track_canvas);
+ rtv = new MidiTimeAxisView (*this, *session, route, *track_canvas);
} else {
throw unknown_type();
}
}
void
-Editor::remove_route (TimeAxisViewPtr tv)
+Editor::remove_route (TimeAxisView *tv)
{
- ENSURE_GUI_THREAD (bind (mem_fun(*this, &Editor::remove_route), tv));
+ ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::remove_route), tv));
TrackViewList::iterator i;
boost::shared_ptr<Route> route;
- TimeAxisViewPtr next_tv;
+ TimeAxisView* next_tv;
if (tv == entered_track) {
- entered_track.reset ();
+ entered_track = 0;
}
if ((i = find (track_views.begin(), track_views.end(), tv)) != track_views.end()) {
i = track_views.erase (i);
if (track_views.empty()) {
- next_tv.reset ();
+ next_tv = 0;
} else if (i == track_views.end()) {
next_tv = track_views.front();
} else {
if (current_mixer_strip && current_mixer_strip->route() == route) {
if (next_tv) {
- set_selected_mixer_strip (next_tv);
+ set_selected_mixer_strip (*next_tv);
} else {
/* make the editor mixer strip go away setting the
* button to inactive (which also unticks the menu option)
}
void
-Editor::hide_track_in_display (TimeAxisViewPtr tv, bool temponly)
+Editor::hide_track_in_display (TimeAxisView& tv, bool temponly)
{
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (tv);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&tv);
if (rtv && current_mixer_strip && (rtv->route() == current_mixer_strip->route())) {
// this will hide the mixer strip
}
void
-Editor::foreach_time_axis_view (sigc::slot<void,TimeAxisViewPtr> theslot)
+Editor::foreach_time_axis_view (sigc::slot<void,TimeAxisView&> theslot)
{
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- theslot (*i);
+ theslot (**i);
}
}
-RouteTimeAxisViewPtr
+RouteTimeAxisView*
Editor::get_route_view_by_id (PBD::ID& id)
{
- RouteTimeAxisViewPtr v;
+ RouteTimeAxisView* v;
for(TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- if((v = boost::dynamic_pointer_cast<RouteTimeAxisView>(*i)) != 0) {
+ if((v = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
if(v->route()->id() == id) {
return v;
}
}
}
- return RouteTimeAxisViewPtr ();
+ return 0;
}
void
_regions->selection_mapover (mem_fun (*this, &Editor::hide_a_region));
}
-TimeAxisViewPtr
-Editor::find_time_axis (TimeAxisView* v)
-{
- TrackViewList::iterator i = track_views.begin ();
- while (i != track_views.end()) {
- if (i->get() == v) {
- return *i;
- }
-
- TimeAxisViewPtr p = (*i)->find_time_axis (v);
- if (p) {
- return p;
- }
-
- ++i;
- }
-
- return TimeAxisViewPtr ();
-}
#ifdef WITH_CMT
void add_imageframe_time_axis(const std::string & track_name, void*) ;
- void add_imageframe_marker_time_axis(const std::string & track_name, TimeAxisViewPtr marked_track, void*) ;
+ void add_imageframe_marker_time_axis(const std::string & track_name, TimeAxisView* marked_track, void*) ;
void connect_to_image_compositor() ;
void scroll_timeaxis_to_imageframe_item(const TimeAxisViewItem* item) ;
#endif
- TimeAxisViewPtr get_named_time_axis(const std::string & name) ;
- void foreach_time_axis_view (sigc::slot<void,TimeAxisViewPtr>);
- void add_to_idle_resize (TimeAxisViewPtr, int32_t);
+ TimeAxisView* get_named_time_axis(const std::string & name) ;
+ void foreach_time_axis_view (sigc::slot<void,TimeAxisView&>);
+ void add_to_idle_resize (TimeAxisView*, int32_t);
- RouteTimeAxisViewPtr get_route_view_by_id (PBD::ID& id);
+ RouteTimeAxisView* get_route_view_by_id (PBD::ID& id);
void consider_auditioning (boost::shared_ptr<ARDOUR::Region>);
void hide_a_region (boost::shared_ptr<ARDOUR::Region>);
Selection& get_selection() const { return *selection; }
Selection& get_cut_buffer() const { return *cut_buffer; }
- bool extend_selection_to_track (TimeAxisViewPtr);
+ bool extend_selection_to_track (TimeAxisView&);
void play_selection ();
void select_all_in_track (Selection::Operation op);
PlaylistSelector& playlist_selector() const;
void clear_playlist (boost::shared_ptr<ARDOUR::Playlist>);
- void new_playlists (boost::weak_ptr<TimeAxisView>);
- void copy_playlists (boost::weak_ptr<TimeAxisView>);
- void clear_playlists (boost::weak_ptr<TimeAxisView>);
+ void new_playlists (TimeAxisView* v);
+ void copy_playlists (TimeAxisView* v);
+ void clear_playlists (TimeAxisView* v);
- TrackViewList* get_valid_views (TimeAxisViewPtr, ARDOUR::RouteGroup* grp = 0);
+ TrackViewList* get_valid_views (TimeAxisView*, ARDOUR::RouteGroup* grp = 0);
void get_onscreen_tracks (TrackViewList&);
Width editor_mixer_strip_width;
void show_editor_mixer (bool yn);
void create_editor_mixer ();
void show_editor_list (bool yn);
- void set_selected_mixer_strip (TimeAxisViewPtr);
- void hide_track_in_display (TimeAxisViewPtr tv, bool temporary = false);
+ void set_selected_mixer_strip (TimeAxisView&);
+ void hide_track_in_display (TimeAxisView& tv, bool temporary = false);
/* nudge is initiated by transport controls owned by ARDOUR_UI */
PlaylistSelector* _playlist_selector;
- typedef std::pair<TimeAxisViewPtr,XMLNode*> TAVState;
+ typedef std::pair<TimeAxisView*,XMLNode*> TAVState;
struct VisualState {
double y_position;
void update_cd_marker_display ();
void ensure_cd_marker_updated (LocationMarkers * lam, ARDOUR::Location * location);
- TimeAxisViewPtr clicked_axisview;
- RouteTimeAxisViewPtr clicked_routeview;
+ TimeAxisView* clicked_axisview;
+ RouteTimeAxisView* clicked_routeview;
/** The last RegionView that was clicked on, or 0 if the last click was not
* on a RegionView. This is set up by the canvas event handlers in
* editor_canvas_events.cc
void sort_track_selection (TrackSelection* sel = 0);
- void get_relevant_tracks (std::set<RouteTimeAxisViewPtr>& relevant_tracks) const;
- void get_equivalent_tracks (RouteTimeAxisViewPtr, std::set<RouteTimeAxisViewPtr> &, ARDOUR::RouteGroup::Property) const;
+ void get_relevant_tracks (std::set<RouteTimeAxisView*>& relevant_tracks) const;
+ void get_equivalent_tracks (RouteTimeAxisView*, std::set<RouteTimeAxisView*> &, ARDOUR::RouteGroup::Property) const;
void get_equivalent_regions (RegionView* rv, std::vector<RegionView*> &, ARDOUR::RouteGroup::Property) const;
RegionSelection get_equivalent_regions (RegionSelection &, ARDOUR::RouteGroup::Property) const;
- void mapover_tracks (sigc::slot<void,RouteTimeAxisViewPtr,uint32_t> sl, TimeAxisViewPtr, ARDOUR::RouteGroup::Property) const;
+ void mapover_tracks (sigc::slot<void,RouteTimeAxisView&,uint32_t> sl, TimeAxisView*, ARDOUR::RouteGroup::Property) const;
/* functions to be passed to mapover_tracks(), possibly with sigc::bind()-supplied arguments */
- void mapped_get_equivalent_regions (RouteTimeAxisViewPtr, uint32_t, RegionView *, std::vector<RegionView*>*) const;
- void mapped_use_new_playlist (RouteTimeAxisView
Ptr, uint32_t, std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
- void mapped_use_copy_playlist (RouteTimeAxisView
Ptr, uint32_t, std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
- void mapped_clear_playlist (RouteTimeAxisViewPtr, uint32_t);
+ void mapped_get_equivalent_regions (RouteTimeAxisView&, uint32_t, RegionView *, std::vector<RegionView*>*) const;
+ void mapped_use_new_playlist (RouteTimeAxisView
&, uint32_t, std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
+ void mapped_use_copy_playlist (RouteTimeAxisView
&, uint32_t, std::vector<boost::shared_ptr<ARDOUR::Playlist> > const &);
+ void mapped_clear_playlist (RouteTimeAxisView&, uint32_t);
/* end */
void catch_vanishing_regionview (RegionView *);
- void set_selected_track (TimeAxisViewPtr, Selection::Operation op = Selection::Set, bool no_remove=false);
+ void set_selected_track (TimeAxisView&, Selection::Operation op = Selection::Set, bool no_remove=false);
void select_all_tracks ();
bool set_selected_control_point_from_click (Selection::Operation op = Selection::Set, bool no_remove=false);
void add_selection_context_items (Gtk::Menu_Helpers::MenuList&);
void handle_new_route (ARDOUR::RouteList&);
- void remove_route (TimeAxisViewPtr);
+ void remove_route (TimeAxisView *);
bool route_removal;
Gtk::HBox global_hpacker;
void select_all_selectables_between (bool within);
void select_range_between ();
- boost::shared_ptr<ARDOUR::Region> find_next_region (nframes64_t, ARDOUR::RegionPoint, int32_t dir, TrackViewList&, TimeAxisViewPtr * = 0);
+ boost::shared_ptr<ARDOUR::Region> find_next_region (nframes64_t, ARDOUR::RegionPoint, int32_t dir, TrackViewList&, TimeAxisView ** = 0);
nframes64_t find_next_region_boundary (nframes64_t, int32_t dir, const TrackViewList&);
std::vector<nframes64_t> region_boundary_cache;
/* track views */
TrackViewList track_views;
- std::pair<TimeAxisViewPtr, ARDOUR::layer_t> trackview_by_y_position (double);
+ std::pair<TimeAxisView*, ARDOUR::layer_t> trackview_by_y_position (double);
TrackSelection axis_views_from_routes (std::list<ARDOUR::Route *>) const;
static Gdk::Cursor* cross_hair_cursor;
bool have_pending_keyboard_selection;
nframes64_t pending_keyboard_selection_start;
- boost::shared_ptr<ARDOUR::Region> select_region_for_operation (int dir, TimeAxisViewPtr *tv);
+ boost::shared_ptr<ARDOUR::Region> select_region_for_operation (int dir, TimeAxisView **tv);
void extend_selection_to_end_of_region (bool next);
void extend_selection_to_start_of_region (bool previous);
bool canvas_region_view_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*);
bool canvas_region_view_name_highlight_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*);
bool canvas_region_view_name_event (GdkEvent* event,ArdourCanvas::Item*, RegionView*);
- bool canvas_stream_view_event (GdkEvent* event,ArdourCanvas::Item*, boost::weak_ptr<TimeAxisView>);
+ bool canvas_stream_view_event (GdkEvent* event,ArdourCanvas::Item*, RouteTimeAxisView*);
bool canvas_marker_event (GdkEvent* event,ArdourCanvas::Item*, Marker*);
bool canvas_zoom_rect_event (GdkEvent* event,ArdourCanvas::Item*);
bool canvas_tempo_marker_event (GdkEvent* event,ArdourCanvas::Item*, TempoMarker*);
bool canvas_meter_marker_event (GdkEvent* event,ArdourCanvas::Item*, MeterMarker*);
- bool canvas_automation_track_event(GdkEvent* event, ArdourCanvas::Item*, boost::weak_ptr<AutomationTimeAxisView>);
+ bool canvas_automation_track_event(GdkEvent* event, ArdourCanvas::Item*, AutomationTimeAxisView*) ;
bool canvas_tempo_bar_event (GdkEvent* event, ArdourCanvas::Item*);
bool canvas_meter_bar_event (GdkEvent* event, ArdourCanvas::Item*);
#ifdef WITH_CMT
void handle_new_imageframe_time_axis_view(const std::string & track_name, void* src) ;
- void handle_new_imageframe_marker_time_axis_view(const std::string & track_name, TimeAxisViewPtr marked_track) ;
+ void handle_new_imageframe_marker_time_axis_view(const std::string & track_name, TimeAxisView* marked_track) ;
void start_imageframe_grab(ArdourCanvas::Item*, GdkEvent*) ;
void start_markerview_grab(ArdourCanvas::Item*, GdkEvent*) ;
/* tracking step changes of track height */
- TimeAxisViewPtr current_stepping_trackview;
+ TimeAxisView* current_stepping_trackview;
ARDOUR::microseconds_t last_track_height_step_timestamp;
gint track_height_step_timeout();
sigc::connection step_timeout;
- TimeAxisViewPtr entered_track;
+ TimeAxisView* entered_track;
RegionView* entered_regionview;
bool clear_entered_track;
bool left_track_canvas (GdkEventCrossing*);
bool entered_track_canvas (GdkEventCrossing*);
- void set_entered_track (TimeAxisViewPtr);
+ void set_entered_track (TimeAxisView*);
void set_entered_regionview (RegionView*);
- void ensure_track_visible (TimeAxisViewPtr);
+ void ensure_track_visible (TimeAxisView*);
gint left_automation_track ();
bool _new_regionviews_show_envelope;
bool idle_resize();
friend gboolean _idle_resize (gpointer);
int32_t _pending_resize_amount;
- TimeAxisViewPtr _pending_resize_view;
+ TimeAxisView* _pending_resize_view;
void visible_order_range (int*, int*) const;
EditorGroupTabs* _group_tabs;
void fit_route_group (ARDOUR::RouteGroup *);
- TimeAxisViewPtr find_time_axis (TimeAxisView *);
-
friend class Drag;
friend class RegionDrag;
friend class RegionMoveDrag;
track_cnt = 0;
for (TrackSelection::iterator x = selection->tracks.begin(); x != selection->tracks.end(); ++x) {
- AudioTimeAxisViewPtr atv = boost::dynamic_pointer_cast<AudioTimeAxisView>(*x);
+ AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*>(*x);
if (!atv) {
continue;
boost::shared_ptr<AudioTrack>
Editor::get_nth_selected_audio_track (int nth) const
{
- AudioTimeAxisViewPtr atv;
+ AudioTimeAxisView* atv;
TrackSelection::iterator x;
for (x = selection->tracks.begin(); nth > 0 && x != selection->tracks.end(); ++x) {
- atv = boost::dynamic_pointer_cast<AudioTimeAxisView>(*x);
+ atv = dynamic_cast<AudioTimeAxisView*>(*x);
if (!atv) {
continue;
}
if (x == selection->tracks.end()) {
- atv = boost::dynamic_pointer_cast<AudioTimeAxisView>(selection->tracks.back());
+ atv = dynamic_cast<AudioTimeAxisView*>(selection->tracks.back());
} else {
- atv = boost::dynamic_pointer_cast<AudioTimeAxisView>(*x);
+ atv = dynamic_cast<AudioTimeAxisView*>(*x);
}
if (!atv || !atv->is_audio_track()) {
boost::shared_ptr<MidiTrack>
Editor::get_nth_selected_midi_track (int nth) const
{
- MidiTimeAxisViewPtr mtv;
+ MidiTimeAxisView* mtv;
TrackSelection::iterator x;
for (x = selection->tracks.begin(); nth > 0 && x != selection->tracks.end(); ++x) {
- mtv = boost::dynamic_pointer_cast<MidiTimeAxisView>(*x);
+ mtv = dynamic_cast<MidiTimeAxisView*>(*x);
if (!mtv) {
continue;
}
if (x == selection->tracks.end()) {
- mtv = boost::dynamic_pointer_cast<MidiTimeAxisView>(selection->tracks.back());
+ mtv = dynamic_cast<MidiTimeAxisView*>(selection->tracks.back());
} else {
- mtv = boost::dynamic_pointer_cast<MidiTimeAxisView>(*x);
+ mtv = dynamic_cast<MidiTimeAxisView*>(*x);
}
if (!mtv || !mtv->is_midi_track()) {
void
Editor::set_show_waveforms_recording (bool yn)
{
- AudioTimeAxisViewPtr atv;
+ AudioTimeAxisView* atv;
if (_show_waveforms_recording != yn) {
_show_waveforms_recording = yn;
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- if ((atv = boost::dynamic_pointer_cast<AudioTimeAxisView>(*i)) != 0) {
+ if ((atv = dynamic_cast<AudioTimeAxisView*>(*i)) != 0) {
atv->set_show_waveforms_recording (yn);
}
}
gint
Editor::start_updating ()
{
- RouteTimeAxisViewPtr rtv;
+ RouteTimeAxisView* rtv;
//cerr << "Editor::start_updating () called" << endl;//DEBUG
if (is_mapped() && session) {
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView>(*i)) != 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
rtv->reset_meter ();
}
}
gint
Editor::stop_updating ()
{
- RouteTimeAxisViewPtr rtv;
+ RouteTimeAxisView* rtv;
meters_running = false;
fast_screen_update_connection.disconnect();
//cerr << "Editor::stop_updating () called" << endl;//DEBUG
if (is_mapped() && session) {
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView>(*i)) != 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
rtv->hide_meter ();
}
}
void
Editor::fast_update_strips ()
{
- RouteTimeAxisViewPtr rtv;
+ RouteTimeAxisView* rtv;
if (is_mapped() && session) {
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView>(*i)) != 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
rtv->fast_update ();
}
}
void
Editor::drop_paths_part_two (const vector<ustring>& paths, nframes64_t frame, double ypos)
{
- RouteTimeAxisViewPtr tv;
+ RouteTimeAxisView* tv;
- std::pair<TimeAxisViewPtr, int> const tvp = trackview_by_y_position (ypos);
+ std::pair<TimeAxisView*, int> const tvp = trackview_by_y_position (ypos);
if (tvp.first == 0) {
/* drop onto canvas background: create new tracks */
do_embed (paths, Editing::ImportDistinctFiles, ImportAsTrack, frame);
}
- } else if ((tv = boost::dynamic_pointer_cast<RouteTimeAxisView> (tvp.first)) != 0) {
+ } else if ((tv = dynamic_cast<RouteTimeAxisView*> (tvp.first)) != 0) {
/* check that its an audio track, not a bus */
if (tv->get_diskstream()) {
/* select the track, then embed/import */
- selection->set (boost::static_pointer_cast<TimeAxisView> (tv));
+ selection->set (tv);
if (Profile->get_sae() || Config->get_only_copy_imported_files()) {
do_import (paths, Editing::ImportSerializeFiles, Editing::ImportToTrack, SrcBest, frame);
bool
Editor::left_track_canvas (GdkEventCrossing *ev)
{
- set_entered_track (TimeAxisViewPtr ());
+ set_entered_track (0);
set_entered_regionview (0);
reset_canvas_action_sensitivity (false);
return false;
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
if (!current_stepping_trackview) {
step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
- std::pair<TimeAxisViewPtr, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
+ std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
current_stepping_trackview = p.first;
if (!current_stepping_trackview) {
return false;
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
if (!current_stepping_trackview) {
step_timeout = Glib::signal_timeout().connect (mem_fun(*this, &Editor::track_height_step_timeout), 500);
- std::pair<TimeAxisViewPtr, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
+ std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
current_stepping_trackview = p.first;
if (!current_stepping_trackview) {
return false;
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
- clicked_axisview = rv->get_time_axis_view();
- clicked_routeview = boost::dynamic_pointer_cast<RouteTimeAxisView> (clicked_axisview);
+ clicked_axisview = &rv->get_time_axis_view();
+ clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, RegionItem);
break;
break;
case GDK_ENTER_NOTIFY:
- set_entered_track (rv->get_time_axis_view ());
+ set_entered_track (&rv->get_time_axis_view ());
set_entered_regionview (rv);
break;
case GDK_LEAVE_NOTIFY:
- set_entered_track (TimeAxisViewPtr ());
+ set_entered_track (0);
set_entered_regionview (0);
break;
}
bool
-Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, boost::weak_ptr<TimeAxisView> w)
+Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, RouteTimeAxisView *tv)
{
- boost::shared_ptr<TimeAxisView> tv = w.lock ();
- if (!tv) {
- return false;
- }
-
bool ret = FALSE;
switch (event->type) {
clicked_regionview = 0;
clicked_control_point = 0;
clicked_axisview = tv;
- clicked_routeview = boost::dynamic_pointer_cast<RouteTimeAxisView>(tv);
+ clicked_routeview = dynamic_cast<RouteTimeAxisView*>(tv);
ret = button_press_handler (item, event, StreamItem);
break;
break;
case GDK_LEAVE_NOTIFY:
- set_entered_track (TimeAxisViewPtr ());
+ set_entered_track (0);
break;
default:
}
bool
-Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, boost::weak_ptr<AutomationTimeAxisView> v)
+Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
{
- boost::shared_ptr<AutomationTimeAxisView> atv = v.lock ();
- if (!atv) {
- return false;
- }
-
bool ret = false;
switch (event->type) {
case GDK_3BUTTON_PRESS:
clicked_regionview = 0;
clicked_control_point = 0;
- clicked_axisview.reset ();
- clicked_routeview.reset ();
+ clicked_axisview = atv;
+ clicked_routeview = 0;
ret = button_press_handler (item, event, AutomationTrackItem);
break;
case GDK_BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
- clicked_axisview = rv->get_time_axis_view();
- clicked_routeview = boost::dynamic_pointer_cast<RouteTimeAxisView>(clicked_axisview);
+ clicked_axisview = &rv->get_time_axis_view();
+ clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
if (event->button.button == 3) {
return button_press_handler (item, event, FadeInItem);
}
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
- clicked_axisview = rv->get_time_axis_view();
- clicked_routeview = boost::dynamic_pointer_cast<RouteTimeAxisView>(clicked_axisview);
+ clicked_axisview = &rv->get_time_axis_view();
+ clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, FadeInHandleItem);
break;
case GDK_BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
- clicked_axisview = rv->get_time_axis_view();
- clicked_routeview = boost::dynamic_pointer_cast<RouteTimeAxisView> (clicked_axisview);
+ clicked_axisview = &rv->get_time_axis_view();
+ clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
if (event->button.button == 3) {
return button_press_handler (item, event, FadeOutItem);
}
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
- clicked_axisview = rv->get_time_axis_view();
- clicked_routeview = boost::dynamic_pointer_cast<RouteTimeAxisView>(clicked_axisview);
+ clicked_axisview = &rv->get_time_axis_view();
+ clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, FadeOutHandleItem);
break;
switch (event->type) {
case GDK_BUTTON_PRESS:
clicked_crossfadeview = xfv;
- clicked_axisview = clicked_crossfadeview->get_time_axis_view();
+ clicked_axisview = &clicked_crossfadeview->get_time_axis_view();
if (event->button.button == 3) {
return button_press_handler (item, event, CrossfadeViewItem);
}
and proxy to that when required.
*/
- TimeAxisViewPtr tv (xfv->get_time_axis_view());
- AudioTimeAxisViewPtr atv;
+ TimeAxisView& tv (xfv->get_time_axis_view());
+ AudioTimeAxisView* atv;
- if ((atv = boost::dynamic_pointer_cast<AudioTimeAxisView>(tv)) != 0) {
+ if ((atv = dynamic_cast<AudioTimeAxisView*>(&tv)) != 0) {
if (atv->is_audio_track()) {
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_control_point = cp;
- clicked_axisview = cp->line().trackview;
- clicked_routeview = boost::dynamic_pointer_cast<RouteTimeAxisView>(clicked_axisview);
+ clicked_axisview = &cp->line().trackview;
+ clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
clicked_regionview = 0;
break;
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
- clicked_axisview = clicked_regionview->get_time_axis_view();
- clicked_routeview = boost::dynamic_pointer_cast<RouteTimeAxisView>(clicked_axisview);
+ clicked_axisview = &clicked_regionview->get_time_axis_view();
+ clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, RegionViewNameHighlight);
break;
case GDK_BUTTON_RELEASE:
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
- clicked_axisview = clicked_regionview->get_time_axis_view();
- clicked_routeview = boost::dynamic_pointer_cast<RouteTimeAxisView>(clicked_axisview);
+ clicked_axisview = &clicked_regionview->get_time_axis_view();
+ clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, RegionViewName);
break;
case GDK_BUTTON_RELEASE:
double py;
nframes64_t const pos = event_frame (&event, &px, &py);
- std::pair<TimeAxisViewPtr, int> const tv = trackview_by_y_position (py);
+ std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py);
if (tv.first == 0) {
return true;
}
- RouteTimeAxisViewPtr rtav = boost::dynamic_pointer_cast<RouteTimeAxisView> (tv.first);
+ RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
if (rtav == 0 || !rtav->is_track ()) {
return true;
}
boost::shared_ptr<Region> region_copy = RegionFactory::create (region);
if (boost::dynamic_pointer_cast<AudioRegion> (region_copy) != 0 &&
- boost::dynamic_pointer_cast<AudioTimeAxisView> (tv.first) == 0) {
+ dynamic_cast<AudioTimeAxisView*> (tv.first) == 0) {
/* audio -> non-audio */
return true;
}
if (boost::dynamic_pointer_cast<MidiRegion> (region_copy) == 0 &&
- boost::dynamic_pointer_cast<MidiTimeAxisView> (tv.first) != 0) {
+ dynamic_cast<MidiTimeAxisView*> (tv.first) != 0) {
/* MIDI -> non-MIDI */
return true;
_grab_frame (0),
_last_pointer_frame (0),
_current_pointer_frame (0),
- _ending (false),
_had_movement (false),
_move_threshold_passed (false)
{
RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b)
: RegionDrag (e, i, p, v),
+ _dest_trackview (0),
_dest_layer (0),
_brushing (b)
{
/* get a bitmask representing the visible tracks */
for (Editor::TrackViewList::iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
TimeAxisView::Children children_list;
/* zeroes are audio/MIDI tracks. ones are other types. */
bool
RegionMotionDrag::compute_y_delta (
- TimeAxisViewConstPtr last_pointer_view, TimeAxisViewPtr current_pointer_view,
+ TimeAxisView const * last_pointer_view, TimeAxisView* current_pointer_view,
int32_t last_pointer_layer, int32_t current_pointer_layer,
TimeAxisViewSummary const & tavs,
int32_t* pointer_order_span, int32_t* pointer_layer_span,
iy1 += _editor->vertical_adjustment.get_value() - _editor->canvas_timebars_vsize;
/* get the new trackview for this particular region */
- pair<TimeAxisViewPtr, int> const tvp = _editor->trackview_by_y_position (iy1);
+ pair<TimeAxisView*, int> const tvp = _editor->trackview_by_y_position (iy1);
assert (tvp.first);
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (tvp.first);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
/* XXX: not sure that we should be passing canvas_pointer_order_span in here,
as surely this is a per-region thing... */
current_pointer_layer the current layer on that TimeAxisView; in this code layer numbers
are with respect to how the view's layers are displayed; if we are in Overlaid mode, layer
is always 0 regardless of what the region's "real" layer is */
- RouteTimeAxisViewPtr current_pointer_view;
+ RouteTimeAxisView* current_pointer_view;
layer_t current_pointer_layer;
if (!check_possible (¤t_pointer_view, ¤t_pointer_layer)) {
return;
}
/* TimeAxisView that we were pointing at last time we entered this method */
- TimeAxisViewConstPtr const last_pointer_view = _dest_trackview;
+ TimeAxisView const * const last_pointer_view = _dest_trackview;
/* the order of the track that we were pointing at last time we entered this method */
int32_t const last_pointer_order = last_pointer_view->order ();
/* the layer that we were pointing at last time we entered this method */
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
RegionView* rv = (*i);
-
+
if (rv->region()->locked()) {
continue;
}
// hide any dependent views
- rv->get_time_axis_view()->hide_dependent_views (*rv);
+ rv->get_time_axis_view().hide_dependent_views (*rv);
/*
reparent to a non scrolling group so that we can keep the
}
/* current view for this particular region */
- pair<TimeAxisViewPtr, int> pos = _editor->trackview_by_y_position (iy1);
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (pos.first);
+ pair<TimeAxisView*, int> pos = _editor->trackview_by_y_position (iy1);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (pos.first);
if (pointer_order_span != 0 && !clamp_y_axis) {
/* find out where we'll be when we move and set height accordingly */
- pair<TimeAxisViewPtr, int> const pos = _editor->trackview_by_y_position (iy1 + y_delta);
- RouteTimeAxisViewConstPtr temp_rtv = boost::dynamic_pointer_cast<const RouteTimeAxisView> (pos.first);
+ pair<TimeAxisView*, int> const pos = _editor->trackview_by_y_position (iy1 + y_delta);
+ RouteTimeAxisView const * temp_rtv = dynamic_cast<RouteTimeAxisView*> (pos.first);
rv->set_height (temp_rtv->view()->child_height());
/* if you un-comment the following, the region colours will follow
pair<PlaylistSet::iterator,bool> insert_result, frozen_insert_result;
nframes64_t drag_delta;
bool changed_tracks, changed_position;
- map<RegionView*, RouteTimeAxisViewPtr> final;
- RouteTimeAxisViewPtr source_tv;
+ map<RegionView*, RouteTimeAxisView*> final;
+ RouteTimeAxisView* source_tv;
if (!movement_occurred) {
/* just a click */
}
changed_position = (_last_frame_position != (nframes64_t) (_primary->region()->position()));
- changed_tracks = (_dest_trackview != _primary->get_time_axis_view());
+ changed_tracks = (_dest_trackview != &_primary->get_time_axis_view());
drag_delta = _primary->region()->position() - _last_frame_position;
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ) {
RegionView* rv = (*i);
- RouteTimeAxisViewPtr dest_rtv = final[*i];
+ RouteTimeAxisView* dest_rtv = final[*i];
nframes64_t where;
because we may have copied the region and it has not been attached to a playlist.
*/
- assert ((source_tv = boost::dynamic_pointer_cast<RouteTimeAxisView> (rv->get_time_axis_view())));
+ assert ((source_tv = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view())));
assert ((ds = source_tv->get_diskstream()));
assert ((from_playlist = ds->playlist()));
}
bool
-RegionMotionDrag::check_possible (RouteTimeAxisViewPtr* tv, layer_t* layer)
+RegionMotionDrag::check_possible (RouteTimeAxisView** tv, layer_t* layer)
{
/* Which trackview is this ? */
- pair<TimeAxisViewPtr, int> const tvp = _editor->trackview_by_y_position (current_pointer_y ());
- (*tv) = boost::dynamic_pointer_cast<RouteTimeAxisView> (tvp.first);
+ pair<TimeAxisView*, int> const tvp = _editor->trackview_by_y_position (current_pointer_y ());
+ (*tv) = dynamic_cast<RouteTimeAxisView*> (tvp.first);
(*layer) = tvp.second;
if (*tv && (*tv)->layer_display() == Overlaid) {
: RegionMotionDrag (e, i, p, v, b),
_copy (c)
{
- TimeAxisViewPtr const tv = _primary->get_time_axis_view ();
+ TimeAxisView* const tv = &_primary->get_time_axis_view ();
_dest_trackview = tv;
if (tv->layer_display() == Overlaid) {
}
double speed = 1;
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (tv);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
if (rtv && rtv->is_track()) {
speed = rtv->get_diskstream()->speed ();
}
_pointer_frame_offset = _grab_frame - _last_frame_position;
}
-RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisViewPtr v, nframes64_t pos)
+RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, nframes64_t pos)
: RegionMotionDrag (e, 0, 0, list<RegionView*> (), false)
{
- assert ((boost::dynamic_pointer_cast<AudioRegion> (r) && boost::dynamic_pointer_cast<AudioTimeAxisView> (v)) ||
- (boost::dynamic_pointer_cast<MidiRegion> (r) && boost::dynamic_pointer_cast<MidiTimeAxisView> (v)));
+ assert ((boost::dynamic_pointer_cast<AudioRegion> (r) && dynamic_cast<AudioTimeAxisView*> (v)) ||
+ (boost::dynamic_pointer_cast<MidiRegion> (r) && dynamic_cast<MidiTimeAxisView*> (v)));
_primary = v->view()->create_region_view (r, false, false);
_dest_layer = _primary->region()->layer ();
}
-map<RegionView*, RouteTimeAxisViewPtr>
+map<RegionView*, RouteTimeAxisView*>
RegionMotionDrag::find_time_axis_views ()
{
- map<RegionView*, RouteTimeAxisViewPtr> tav;
+ map<RegionView*, RouteTimeAxisView*> tav;
for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
(*i)->get_canvas_frame()->i2w (ix1, iy1);
iy1 += _editor->vertical_adjustment.get_value() - _editor->canvas_timebars_vsize;
- pair<TimeAxisViewPtr, int> tv = _editor->trackview_by_y_position (iy1);
- tav[*i] = boost::dynamic_pointer_cast<RouteTimeAxisView> (tv.first);
+ pair<TimeAxisView*, int> tv = _editor->trackview_by_y_position (iy1);
+ tav[*i] = dynamic_cast<RouteTimeAxisView*> (tv.first);
}
return tav;
{
_editor->update_canvas_now ();
- map<RegionView*, RouteTimeAxisViewPtr> final = find_time_axis_views ();
+ map<RegionView*, RouteTimeAxisView*> final = find_time_axis_views ();
- RouteTimeAxisViewPtr dest_rtv = final[_primary];
+ RouteTimeAxisView* dest_rtv = final[_primary];
_primary->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
_primary->get_canvas_group()->property_y() = 0;
void
RegionSpliceDrag::motion (GdkEvent* event, bool)
{
- RouteTimeAxisViewPtr tv;
+ RouteTimeAxisView* tv;
layer_t layer;
if (!check_possible (&tv, &layer)) {
for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
- RouteTimeAxisViewPtr atv = boost::dynamic_pointer_cast<RouteTimeAxisView> ((*i)->get_time_axis_view());
+ RouteTimeAxisView* atv = dynamic_cast<RouteTimeAxisView*> (&(*i)->get_time_axis_view());
if (!atv) {
continue;
}
-RegionCreateDrag::RegionCreateDrag (Editor* e, ArdourCanvas::Item* i, TimeAxisViewPtr v)
+RegionCreateDrag::RegionCreateDrag (Editor* e, ArdourCanvas::Item* i, TimeAxisView* v)
: Drag (e, i),
_view (v)
{
void
RegionCreateDrag::finished (GdkEvent* event, bool movement_occurred)
{
- MidiTimeAxisViewPtr mtv = boost::dynamic_pointer_cast<MidiTimeAxisView> (_dest_trackview);
+ MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*> (_dest_trackview);
if (!mtv) {
return;
}
const boost::shared_ptr<MidiDiskstream> diskstream =
- boost::dynamic_pointer_cast<MidiDiskstream>(mtv->view()->trackview()->track()->diskstream());
+ boost::dynamic_pointer_cast<MidiDiskstream>(mtv->view()->trackview().track()->diskstream());
if (!diskstream) {
warning << "Cannot create non-MIDI region" << endl;
TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
{
double speed = 1.0;
- TimeAxisViewPtr tvp = _primary->get_time_axis_view ();
- RouteTimeAxisViewPtr tv = boost::dynamic_pointer_cast<RouteTimeAxisView>(tvp);
+ TimeAxisView* tvp = &_primary->get_time_axis_view ();
+ RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
if (tv && tv->is_track()) {
speed = tv->get_diskstream()->speed();
*/
double speed = 1.0;
- TimeAxisViewPtr tvp = _primary->get_time_axis_view ();
- RouteTimeAxisViewPtr tv = boost::dynamic_pointer_cast<RouteTimeAxisView>(tvp);
+ TimeAxisView* tvp = &_primary->get_time_axis_view ();
+ RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
if (tv && tv->is_track()) {
}
if (_current_pointer_frame > rv->region()->position()) {
- rv->get_time_axis_view()->show_timestretch (rv->region()->position(), _current_pointer_frame);
+ rv->get_time_axis_view().show_timestretch (rv->region()->position(), _current_pointer_frame);
}
_last_pointer_frame = _current_pointer_frame;
void
TimeFXDrag::finished (GdkEvent* event, bool movement_occurred)
{
- _primary->get_time_axis_view()->hide_timestretch ();
+ _primary->get_time_axis_view().hide_timestretch ();
if (!movement_occurred) {
return;
case MouseRange:
/* find the two markers on either side of the click and make the range out of it */
- _editor->selection->set (TimeAxisViewPtr (), start, end);
+ _editor->selection->set (0, start, end);
break;
default:
void copy_regions (GdkEvent *);
bool y_movement_disallowed (int, int, int, TimeAxisViewSummary const &) const;
- std::map<RegionView*, RouteTimeAxisViewPtr> find_time_axis_views ();
+ std::map<RegionView*, RouteTimeAxisView*> find_time_axis_views ();
double compute_x_delta (GdkEvent const *, nframes64_t *);
bool compute_y_delta (
- TimeAxisViewConstPtr, TimeAxisViewPtr, int32_t, int32_t, TimeAxisViewSummary const &,
+ TimeAxisView const *, TimeAxisView*, int32_t, int32_t, TimeAxisViewSummary const &,
int32_t *, int32_t *, int32_t *
);
TimeAxisViewSummary get_time_axis_view_summary ();
virtual bool x_move_allowed () const = 0;
- TimeAxisViewPtr _dest_trackview;
+ TimeAxisView* _dest_trackview;
ARDOUR::layer_t _dest_layer;
- bool check_possible (RouteTimeAxisViewPtr *, ARDOUR::layer_t *);
+ bool check_possible (RouteTimeAxisView **, ARDOUR::layer_t *);
bool _brushing;
};
class RegionInsertDrag : public RegionMotionDrag
{
public:
- RegionInsertDrag (Editor *, boost::shared_ptr<ARDOUR::Region>, RouteTimeAxisViewPtr, nframes64_t);
+ RegionInsertDrag (Editor *, boost::shared_ptr<ARDOUR::Region>, RouteTimeAxisView*, nframes64_t);
void finished (GdkEvent *, bool);
class RegionCreateDrag : public Drag
{
public:
- RegionCreateDrag (Editor *, ArdourCanvas::Item *, TimeAxisViewPtr);
+ RegionCreateDrag (Editor *, ArdourCanvas::Item *, TimeAxisView *);
void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
void motion (GdkEvent *, bool);
void finished (GdkEvent *, bool);
private:
- TimeAxisViewPtr _view;
- TimeAxisViewPtr _dest_trackview;
+ TimeAxisView* _view;
+ TimeAxisView* _dest_trackview;
};
/** Drag of region gain */
boost::shared_ptr<Region> r = selection->regions.front()->region();
AudioRegion & region (dynamic_cast<AudioRegion &> (*r));
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (selection->regions.front()->get_time_axis_view());
- AudioTrack & track (dynamic_cast<AudioTrack &> (*rtv->route()));
+ RouteTimeAxisView & rtv (dynamic_cast<RouteTimeAxisView &> (selection->regions.front()->get_time_axis_view()));
+ AudioTrack & track (dynamic_cast<AudioTrack &> (*rtv.route()));
ExportRegionDialog dialog (*this, region, track);
dialog.set_session (session);
for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
boost::shared_ptr<Region> region ((*i)->region());
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView>((*i)->get_time_axis_view());
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&(*i)->get_time_axis_view());
Track* track = dynamic_cast<Track*>(rtv->route().get());
InterThreadInfo itt;
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
- AudioTimeAxisViewPtr atv;
+ AudioTimeAxisView* atv;
- if ((atv = boost::dynamic_pointer_cast<AudioTimeAxisView>(*i)) == 0) {
+ if ((atv = dynamic_cast<AudioTimeAxisView*>(*i)) == 0) {
continue;
}
continue;
}
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
if (rtv) {
if (j == tabs.end()) {
if (add) {
selection->add (pending_keyboard_selection_start, end);
} else {
- selection->set (TimeAxisViewPtr (), pending_keyboard_selection_start, end);
+ selection->set (0, pending_keyboard_selection_start, end);
}
have_pending_keyboard_selection = false;
}
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- RouteTimeAxisViewPtr atv;
+ RouteTimeAxisView* atv;
- if ((atv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i)) != 0) {
+ if ((atv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
r = atv->route();
break;
}
sort_track_selection ();
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
- RouteTimeAxisViewPtr atv;
+ RouteTimeAxisView* atv;
- if ((atv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i)) != 0) {
+ if ((atv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
r = atv->route();
break;
}
}
void
-Editor::set_selected_mixer_strip (TimeAxisViewPtr view)
+Editor::set_selected_mixer_strip (TimeAxisView& view)
{
- RouteTimeAxisViewPtr at;
+ RouteTimeAxisView* at;
bool created;
- if (!session || (at = boost::dynamic_pointer_cast<RouteTimeAxisView> (view)) == 0) {
+ if (!session || (at = dynamic_cast<RouteTimeAxisView*>(&view)) == 0) {
return;
}
{
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- RouteTimeAxisViewPtr tmp;
+ RouteTimeAxisView* tmp;
- if ((tmp = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i)) != 0) {
+ if ((tmp = dynamic_cast<RouteTimeAxisView*>(*i)) != 0) {
if (tmp->route() == current_mixer_strip->route()) {
(*i)->set_selected (false);
break;
cut_buffer->clear ();
clicked_regionview = 0;
- clicked_axisview.reset ();
- clicked_routeview.reset ();
+ clicked_axisview = 0;
+ clicked_routeview = 0;
clicked_crossfadeview = 0;
entered_regionview = 0;
- entered_track.reset ();
+ entered_track = 0;
last_update_frame = 0;
_drag = 0;
Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
nframes64_t where = event_frame (event, 0, 0);
- AutomationTimeAxisViewPtr atv;
+ AutomationTimeAxisView* atv = 0;
/* no action if we're recording */
case MouseObject:
switch (item_type) {
case AutomationTrackItem:
- atv = boost::dynamic_pointer_cast<AutomationTimeAxisView>(clicked_axisview);
+ atv = dynamic_cast<AutomationTimeAxisView*>(clicked_axisview);
if (atv) {
atv->add_automation_event (item, event, where, event->button.y);
}
break;
case AutomationTrackItem:
- boost::dynamic_pointer_cast<AutomationTimeAxisView> (clicked_axisview)->
+ dynamic_cast<AutomationTimeAxisView*>(clicked_axisview)->
add_automation_event (item, event, where, event->button.y);
return true;
break;
track_canvas->get_window()->set_cursor (*cursor);
- AutomationTimeAxisViewPtr atv = boost::dynamic_pointer_cast<AutomationTimeAxisView> (
- find_time_axis (
- static_cast<TimeAxisView*> (item->get_data ("trackview"))
- )
- );
-
- if (atv) {
+ AutomationTimeAxisView* atv;
+ if ((atv = static_cast<AutomationTimeAxisView*>(item->get_data ("trackview"))) != 0) {
clear_entered_track = false;
set_entered_track (atv);
}
break;
default:
- set_entered_track (TimeAxisViewPtr ());
+ set_entered_track (0);
break;
}
Editor::left_automation_track ()
{
if (clear_entered_track) {
- set_entered_track (TimeAxisViewPtr ());
+ set_entered_track (0);
clear_entered_track = false;
}
return false;
if (current_stepping_trackview) {
/* don't keep the persistent stepped trackview if the mouse moves */
- current_stepping_trackview.reset ();
+ current_stepping_trackview = 0;
step_timeout.disconnect ();
}
for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
if (!rtv->hidden()) {
*/
if (Keyboard::modifier_state_contains (event->state, Keyboard::PrimaryModifier)) {
- TimeAxisViewPtr tv = rv.get_time_axis_view();
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (tv);
+ TimeAxisView* tv = &rv.get_time_axis_view();
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(tv);
double speed = 1.0;
if (rtv && rtv->is_track()) {
speed = rtv->get_diskstream()->speed();
nframes64_t new_bound;
double speed = 1.0;
- TimeAxisViewPtr tvp = clicked_axisview;
- RouteTimeAxisViewPtr tv = boost::dynamic_pointer_cast<RouteTimeAxisView>(tvp);
+ TimeAxisView* tvp = clicked_axisview;
+ RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
if (tv && tv->is_track()) {
speed = tv->get_diskstream()->speed();
nframes64_t new_bound;
double speed = 1.0;
- TimeAxisViewPtr tvp = clicked_axisview;
- RouteTimeAxisViewPtr tv = boost::dynamic_pointer_cast<RouteTimeAxisView>(tvp);
+ TimeAxisView* tvp = clicked_axisview;
+ RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
if (tv && tv->is_track()) {
speed = tv->get_diskstream()->speed();
nframes64_t new_bound;
double speed = 1.0;
- TimeAxisViewPtr tvp = clicked_axisview;
- RouteTimeAxisViewPtr tv = boost::dynamic_pointer_cast<RouteTimeAxisView>(tvp);
+ TimeAxisView* tvp = clicked_axisview;
+ RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
if (tv && tv->is_track()) {
speed = tv->get_diskstream()->speed();
return;
}
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (rv->get_time_axis_view());
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&rv->get_time_axis_view());
if (rtv == 0 || !rtv->is_track()) {
return;
Editor::track_height_step_timeout ()
{
if (get_microseconds() - last_track_height_step_timestamp < 250000) {
- current_stepping_trackview.reset ();
+ current_stepping_trackview = 0;
return false;
}
return true;
}
boost::shared_ptr<Region>
-Editor::select_region_for_operation (int dir, TimeAxisViewPtr *tv)
+Editor::select_region_for_operation (int dir, TimeAxisView **tv)
{
RegionView* rv;
boost::shared_ptr<Region> region;
if (!selection->regions.empty()) {
rv = *(selection->regions.begin());
- (*tv) = rv->get_time_axis_view();
+ (*tv) = &rv->get_time_axis_view();
region = rv->region();
} else if (!selection->tracks.empty()) {
(*tv) = selection->tracks.front();
- RouteTimeAxisViewPtr rtv;
+ RouteTimeAxisView* rtv;
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*tv)) != 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*> (*tv)) != 0) {
boost::shared_ptr<Playlist> pl;
if ((pl = rtv->playlist()) == 0) {
void
Editor::extend_selection_to_end_of_region (bool next)
{
- TimeAxisViewPtr tv;
+ TimeAxisView *tv;
boost::shared_ptr<Region> region;
nframes64_t start;
void
Editor::extend_selection_to_start_of_region (bool previous)
{
- TimeAxisViewPtr tv;
+ TimeAxisView *tv;
boost::shared_ptr<Region> region;
nframes64_t end;
return;
}
- TimeAxisViewPtr ontrack;
+ TimeAxisView *ontrack = 0;
TrackViewList tlist;
if (!selection->tracks.empty()) {
}
float speed = 1.0f;
- RouteTimeAxisViewPtr rtav;
+ RouteTimeAxisView *rtav;
- if (ontrack != 0 && (rtav = boost::dynamic_pointer_cast<RouteTimeAxisView>(ontrack)) != 0 ) {
+ if (ontrack != 0 && (rtav = dynamic_cast<RouteTimeAxisView*>(ontrack)) != 0 ) {
if (rtav->get_diskstream() != 0) {
speed = rtav->get_diskstream()->speed();
}
}
boost::shared_ptr<Region>
-Editor::find_next_region (nframes64_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisViewPtr *ontrack)
+Editor::find_next_region (nframes64_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisView **ontrack)
{
TrackViewList::iterator i;
nframes64_t closest = max_frames;
float track_speed;
nframes64_t track_frame;
- RouteTimeAxisViewPtr rtav;
+ RouteTimeAxisView *rtav;
for (i = tracks.begin(); i != tracks.end(); ++i) {
boost::shared_ptr<Region> r;
track_speed = 1.0f;
- if ( (rtav = boost::dynamic_pointer_cast<RouteTimeAxisView>(*i)) != 0 ) {
+ if ( (rtav = dynamic_cast<RouteTimeAxisView*>(*i)) != 0 ) {
if (rtav->get_diskstream()!=0)
track_speed = rtav->get_diskstream()->speed();
}
nframes64_t contender;
nframes64_t d;
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
if (!rtv) {
continue;
return;
}
- TimeAxisViewPtr ontrack;
+ TimeAxisView *ontrack = 0;
// so we don't find the current region again..
if (dir>0 || pos>0)
}
float speed = 1.0f;
- RouteTimeAxisViewPtr rtav;
+ RouteTimeAxisView *rtav;
- if ( ontrack != 0 && (rtav = boost::dynamic_pointer_cast<RouteTimeAxisView>(ontrack)) != 0 ) {
+ if ( ontrack != 0 && (rtav = dynamic_cast<RouteTimeAxisView*>(ontrack)) != 0 ) {
if (rtav->get_diskstream() != 0) {
speed = rtav->get_diskstream()->speed();
}
return;
}
- TimeAxisViewPtr ontrack;
+ TimeAxisView *ontrack = 0;
pos = loc->start();
}
float speed = 1.0f;
- RouteTimeAxisViewPtr rtav;
+ RouteTimeAxisView *rtav;
- if (ontrack != 0 && (rtav = boost::dynamic_pointer_cast<RouteTimeAxisView>(ontrack)) != 0) {
+ if (ontrack != 0 && (rtav = dynamic_cast<RouteTimeAxisView*>(ontrack)) != 0) {
if (rtav->get_diskstream() != 0) {
speed = rtav->get_diskstream()->speed();
}
nframes64_t start = max_frames;
nframes64_t end = 0;
RegionSelection rs;
- set<TimeAxisViewPtr> tracks;
+ set<TimeAxisView*> tracks;
get_regions_for_action (rs);
end = (*i)->region()->last_frame() + 1;
}
- tracks.insert ((*i)->get_time_axis_view());
+ tracks.insert (&((*i)->get_time_axis_view()));
}
/* now comes an "interesting" hack ... make sure we leave a little space
/* set visible track heights appropriately */
- for (set<TimeAxisViewPtr>::iterator t = tracks.begin(); t != tracks.end(); ++t) {
+ for (set<TimeAxisView*>::iterator t = tracks.begin(); t != tracks.end(); ++t) {
(*t)->set_height (per_track_height);
}
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
if (find (tracks.begin(), tracks.end(), (*i)) == tracks.end()) {
- hide_track_in_display (*i, true);
+ hide_track_in_display (**i, true);
}
}
double wx, wy;
double cx, cy;
nframes64_t where;
- RouteTimeAxisViewPtr rtv;
+ RouteTimeAxisView *rtv = 0;
boost::shared_ptr<Playlist> playlist;
track_canvas->window_to_world (x, y, wx, wy);
return;
}
- std::pair<TimeAxisViewPtr, int> tv = trackview_by_y_position (cy);
+ std::pair<TimeAxisView*, int> tv = trackview_by_y_position (cy);
if (tv.first == 0) {
return;
}
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (tv.first)) == 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*> (tv.first)) == 0) {
return;
}
double wx, wy;
double cx, cy;
nframes_t where;
- RouteTimeAxisViewPtr dest_rtv;
- RouteTimeAxisViewPtr source_rtv;
+ RouteTimeAxisView *dest_rtv = 0;
+ RouteTimeAxisView *source_rtv = 0;
track_canvas->window_to_world (x, y, wx, wy);
wx += horizontal_adjustment.get_value();
where = event_frame (&event, &cx, &cy);
- std::pair<TimeAxisViewPtr, int> const tv = trackview_by_y_position (cy);
+ std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (cy);
if (tv.first == 0) {
return;
}
- if ((dest_rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (tv.first)) == 0) {
+ if ((dest_rtv = dynamic_cast<RouteTimeAxisView*> (tv.first)) == 0) {
return;
}
/* use this drag source to add underlay to a track. But we really don't care
about the Route, only the view of the route, so find it first */
for(TrackViewList::iterator it = track_views.begin(); it != track_views.end(); ++it) {
- if((source_rtv = boost::dynamic_pointer_cast<RouteTimeAxisView>(*it)) == 0) {
+ if((source_rtv = dynamic_cast<RouteTimeAxisView*>(*it)) == 0) {
continue;
}
void
Editor::insert_region_list_selection (float times)
{
- RouteTimeAxisViewPtr tv;
+ RouteTimeAxisView *tv = 0;
boost::shared_ptr<Playlist> playlist;
if (clicked_routeview != 0) {
tv = clicked_routeview;
} else if (!selection->tracks.empty()) {
- if ((tv = boost::dynamic_pointer_cast<RouteTimeAxisView>(selection->tracks.front())) == 0) {
+ if ((tv = dynamic_cast<RouteTimeAxisView*>(selection->tracks.front())) == 0) {
return;
}
} else if (entered_track != 0) {
- if ((tv = boost::dynamic_pointer_cast<RouteTimeAxisView>(entered_track)) == 0) {
+ if ((tv = dynamic_cast<RouteTimeAxisView*>(entered_track)) == 0) {
return;
}
} else {
get_regions_for_action (rs);
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
- TimeAxisViewPtr tv = (*i)->get_time_axis_view();
+ TimeAxisView* tv = &(*i)->get_time_axis_view();
if (find (tmptracks.begin(), tmptracks.end(), tv) == tmptracks.end()) {
tmptracks.push_back (tv);
for (TrackSelection::iterator i = tmptracks.begin(); i != tmptracks.end(); ++i) {
- RouteTimeAxisViewPtr rtv;
+ RouteTimeAxisView* rtv;
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> ((*i))) != 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
if (rtv->is_track()) {
for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
- RouteTimeAxisViewPtr rtv;
+ RouteTimeAxisView* rtv;
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> ((*i))) != 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*> ((*i))) != 0) {
boost::shared_ptr<Track> t = rtv->track();
continue;
}
- RouteTimeAxisViewPtr tav = boost::dynamic_pointer_cast<RouteTimeAxisView> (rv->get_time_axis_view());
+ RouteTimeAxisView* tav = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view());
if (!tav) {
return;
}
continue;
}
- RouteTimeAxisViewPtr tav = boost::dynamic_pointer_cast<RouteTimeAxisView> (rv->get_time_axis_view());
+ RouteTimeAxisView* tav = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view());
if (!tav) {
return;
}
continue;
}
- RouteTimeAxisViewPtr tav = boost::dynamic_pointer_cast<RouteTimeAxisView> (rv->get_time_axis_view());
+ RouteTimeAxisView* tav = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view());
if (!tav) {
return;
}
continue;
}
- AudioTimeAxisViewPtr atav = boost::dynamic_pointer_cast<AudioTimeAxisView> (arv->get_time_axis_view());
+ AudioTimeAxisView* atav = dynamic_cast<AudioTimeAxisView*> (&arv->get_time_axis_view());
if (!atav) {
return;
for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
- RouteTimeAxisViewPtr rtv;
+ RouteTimeAxisView* rtv;
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i)) == 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*> (*i)) == 0) {
continue;
}
if (!get_edit_op_range (start, end)) {
return;
}
- selection->set (TimeAxisViewPtr (), start, end);
+ selection->set ((TimeAxisView*) 0, start, end);
}
begin_reversible_command (opname + _(" range"));
{
for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
- AutomationTimeAxisViewPtr atv = boost::dynamic_pointer_cast<AutomationTimeAxisView>(i->track);
+ AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
if (atv) {
atv->cut_copy_clear_objects (selection->points, op);
};
struct PlaylistMapping {
- TimeAxisViewPtr tv;
+ TimeAxisView* tv;
boost::shared_ptr<Playlist> pl;
- PlaylistMapping (TimeAxisViewPtr tvp) : tv (tvp) {}
+ PlaylistMapping (TimeAxisView* tvp) : tv (tvp) {}
};
/** Remove `clicked_regionview' */
}
}
- TimeAxisViewPtr tv = (*x)->get_trackview();
+ TimeAxisView* tv = &(*x)->get_trackview();
vector<PlaylistMapping>::iterator z;
for (z = pmap.begin(); z != pmap.end(); ++z) {
continue;
}
- TimeAxisViewPtr tv = (*x)->get_trackview();
+ TimeAxisView& tv = (*x)->get_trackview();
boost::shared_ptr<Playlist> npl;
RegionSelection::iterator tmp;
vector<PlaylistMapping>::iterator z;
for (z = pmap.begin(); z != pmap.end(); ++z) {
- if (z->tv == tv) {
+ if ((*z).tv == &tv) {
break;
}
}
for (t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
- RouteTimeAxisViewPtr rtv;
+ RouteTimeAxisView* rtv;
boost::shared_ptr<Playlist> pl;
boost::shared_ptr<AudioPlaylist> apl;
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*t)) == 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*> (*t)) == 0) {
continue;
}
boost::shared_ptr<Region> r ((*i)->region());
- TimeAxisViewPtr tv = (*i)->get_time_axis_view();
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (tv);
+ TimeAxisView& tv = (*i)->get_time_axis_view();
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&tv);
latest_regionviews.clear ();
sigc::connection c = rtv->view()->RegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
- AutomationTimeAxisViewPtr atv = boost::dynamic_pointer_cast<AutomationTimeAxisView> (i->track);
+ AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>(&(*i).track);
if (atv) {
atv->reset_objects (selection->points);
bool new_state = false;
bool first = true;
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
- RouteTimeAxisViewPtr rtav = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i);
+ RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
if (!rtav)
continue;
if (!rtav->is_track())
bool _fade_visibility = session->config.get_show_region_fades ();
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- AudioTimeAxisViewPtr v = boost::dynamic_pointer_cast<AudioTimeAxisView> (*i);
+ AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
if (v) {
if (_fade_visibility) {
v->audio_view()->show_all_fades ();
_xfade_visibility = session->config.get_xfades_visible ();
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- AudioTimeAxisViewPtr v = boost::dynamic_pointer_cast<AudioTimeAxisView> (*i);
+ AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
if (v) {
if (_xfade_visibility) {
v->show_all_xfades ();
return;
}
- TimeAxisViewPtr current = selection->tracks.front();
+ TimeAxisView* current = selection->tracks.front();
- boost::shared_ptr<RouteUI> rui;
+ RouteUI *rui;
do {
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
if (*i == current) {
break;
}
}
- rui = boost::dynamic_pointer_cast<RouteUI> (current);
- } while ( current->hidden() || (rui && !rui->route()->active()));
+ rui = dynamic_cast<RouteUI *>(current);
+ } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
selection->set(current);
return;
}
- TimeAxisViewPtr current = selection->tracks.front();
+ TimeAxisView* current = selection->tracks.front();
- boost::shared_ptr<RouteUI> rui;
+ RouteUI *rui;
do {
for (TrackViewList::reverse_iterator i = track_views.rbegin(); i != track_views.rend(); ++i) {
if (*i == current) {
break;
}
}
- rui = boost::dynamic_pointer_cast<RouteUI> (current);
- } while ( current->hidden() || (rui && !rui->route()->active()));
+ rui = dynamic_cast<RouteUI *>(current);
+ } while ( current->hidden() || (rui != NULL && !rui->route()->active()));
selection->set (current);
}
void
-Editor::ensure_track_visible(TimeAxisViewPtr track)
+Editor::ensure_track_visible(TimeAxisView *track)
{
if (track->hidden())
return;
for (TrackSelection::iterator t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*t);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*t);
if (rtv) {
boost::shared_ptr<Diskstream> ds = rtv->get_diskstream();
}
for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView>(*x);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*x);
if (rtv) {
if (first) {
vector<boost::shared_ptr<Route> > routes;
for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*x);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*x);
if (rtv) {
if (rtv->is_track()) {
ntracks++;
}
/* automation */
- RouteTimeAxisViewPtr rtav = boost::dynamic_pointer_cast<RouteTimeAxisView> (*x);
+ RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*x);
if (rtav) {
rtav->route ()->shift (pos, frames);
commit = true;
first_y_pos = std::min ((*t)->y_position (), first_y_pos);
} else {
if (prev_was_selected && next_is_selected) {
- hide_track_in_display (*t);
+ hide_track_in_display (**t);
}
}
_session->add_route_group (g);
for (TrackSelection::iterator i = _editor->get_selection().tracks.begin(); i != _editor->get_selection().tracks.end(); ++i) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
if (rtv) {
rtv->route()->set_route_group (g, this);
}
_session->add_route_group (g);
for (Editor::TrackViewList::const_iterator i = _editor->get_track_views().begin(); i != _editor->get_track_views().end(); ++i) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
if (rtv && rtv->route()->record_enabled()) {
rtv->route()->set_route_group (g, this);
}
_session->add_route_group (g);
for (Editor::TrackViewList::const_iterator i = _editor->get_track_views().begin(); i != _editor->get_track_views().end(); ++i) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
if (rtv && !rtv->route()->is_master() && rtv->route()->soloed()) {
rtv->route()->set_route_group (g, this);
}
if ((*iter)[_columns.is_visible]) {
for (Editor::TrackViewList::const_iterator j = _editor->get_track_views().begin(); j != _editor->get_track_views().end(); ++j) {
if ((*j)->route_group() == group) {
- _editor->_routes->show_track_in_display (*j);
+ _editor->_routes->show_track_in_display (**j);
}
}
} else {
for (Editor::TrackViewList::const_iterator j = _editor->get_track_views().begin(); j != _editor->get_track_views().end(); ++j) {
if ((*j)->route_group() == group) {
- _editor->hide_track_in_display (*j);
+ _editor->hide_track_in_display (**j);
}
}
}
int coll = -1;
while (i != routes.end() && j != _editor->get_track_views().end()) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*j);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*j);
if (rtv) {
boost::shared_ptr<Route> r = rtv->route ();
// Get the model row that has been toggled.
Gtk::TreeModel::Row row = *_model->get_iter (Gtk::TreeModel::Path (path_string));
- TimeAxisViewPtr tv = row[_columns.tv];
- AudioTimeAxisViewPtr atv = boost::dynamic_pointer_cast<AudioTimeAxisView> (tv);
+ TimeAxisView *tv = row[_columns.tv];
+ AudioTimeAxisView *atv = dynamic_cast<AudioTimeAxisView*> (tv);
if (atv != 0 && atv->is_audio_track()){
atv->get_diskstream()->set_record_enabled(!atv->get_diskstream()->record_enabled());
}
for (n = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) {
- TimeAxisViewPtr tv = (*i)[_columns.tv];
+ TimeAxisView *tv = (*i)[_columns.tv];
boost::shared_ptr<Route> route = (*i)[_columns.route];
if (tv == 0) {
bool visible = (*i)[_columns.visible];
- /* show or hide the TimeAxisViewPtr */
+ /* show or hide the TimeAxisView */
if (visible) {
tv->set_marked_for_display (true);
position += tv->show_at (position, n, &_editor->edit_controls_vbox);
}
void
-EditorRoutes::routes_added (list<RouteTimeAxisViewPtr> routes)
+EditorRoutes::routes_added (list<RouteTimeAxisView*> routes)
{
TreeModel::Row row;
_redisplay_does_not_sync_order_keys = true;
suspend_redisplay ();
- for (list<RouteTimeAxisViewPtr>::iterator x = routes.begin(); x != routes.end(); ++x) {
+ for (list<RouteTimeAxisView*>::iterator x = routes.begin(); x != routes.end(); ++x) {
row = *(_model->append ());
}
void
-EditorRoutes::route_removed (TimeAxisViewPtr tv)
+EditorRoutes::route_removed (TimeAxisView *tv)
{
ENSURE_GUI_THREAD (bind (mem_fun(*this, &EditorRoutes::route_removed), tv));
_redisplay_does_not_sync_order_keys = true;
for (ri = rows.begin(); ri != rows.end(); ++ri) {
- TimeAxisViewPtr t = (*ri)[_columns.tv];
- if (t == tv) {
+ if ((*ri)[_columns.tv] == tv) {
_model->erase (ri);
break;
}
suspend_redisplay ();
for (i = rows.begin(); i != rows.end(); ++i) {
- TimeAxisViewPtr tv = (*i)[_columns.tv];
+ TimeAxisView *tv = (*i)[_columns.tv];
(*i)[_columns.visible] = tv->marked_for_display ();
cerr << "marked " << tv->name() << " for display = " << tv->marked_for_display() << endl;
}
}
void
-EditorRoutes::hide_track_in_display (TimeAxisViewPtr tv)
+EditorRoutes::hide_track_in_display (TimeAxisView& tv)
{
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator i;
for (i = rows.begin(); i != rows.end(); ++i) {
- TimeAxisViewPtr t = (*i)[_columns.tv];
- if (t == tv) {
+ if ((*i)[_columns.tv] == &tv) {
(*i)[_columns.visible] = false;
break;
}
}
void
-EditorRoutes::show_track_in_display (TimeAxisViewPtr tv)
+EditorRoutes::show_track_in_display (TimeAxisView& tv)
{
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator i;
for (i = rows.begin(); i != rows.end(); ++i) {
- TimeAxisViewPtr t = (*i)[_columns.tv];
- if (t == tv) {
+ if ((*i)[_columns.tv] == &tv) {
(*i)[_columns.visible] = true;
break;
}
for (i = rows.begin(); i != rows.end(); ++i) {
TreeModel::Row row = (*i);
- TimeAxisViewPtr tv = row[_columns.tv];
+ TimeAxisView *tv = row[_columns.tv];
if (tv == 0) {
continue;
for (i = rows.begin(); i != rows.end(); ++i) {
TreeModel::Row row = (*i);
- TimeAxisViewPtr tv = row[_columns.tv];
+ TimeAxisView* tv = row[_columns.tv];
if (tv == 0) {
continue;
for (i = rows.begin(); i != rows.end(); ++i) {
TreeModel::Row row = (*i);
- TimeAxisViewPtr tv = row[_columns.tv];
- AudioTimeAxisViewPtr atv;
+ TimeAxisView* tv = row[_columns.tv];
+ AudioTimeAxisView* atv;
if (tv == 0) {
continue;
}
- if ((atv = boost::dynamic_pointer_cast<AudioTimeAxisView>(tv)) != 0) {
+ if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) != 0) {
switch (tracks) {
case 0:
(*i)[_columns.visible] = yn;
return false;
case 1:
if ((iter = _model->get_iter (path))) {
- TimeAxisViewPtr tv = (*iter)[_columns.tv];
+ TimeAxisView* tv = (*iter)[_columns.tv];
if (tv) {
bool visible = (*iter)[_columns.visible];
(*iter)[_columns.visible] = !visible;
_no_redisplay = true;
for (i = rows.begin(); i != rows.end(); ++i) {
- TimeAxisViewPtr tv = (*i)[_columns.tv];
- RouteTimeAxisViewPtr rtv;
+ TimeAxisView *tv = (*i)[_columns.tv];
+ RouteTimeAxisView *rtv;
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView>(tv)) != 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*>(tv)) != 0) {
if (rtv->route()->is_master()) {
_display.get_selection()->unselect (i);
}
return;
}
- typedef std::pair<TimeAxisViewPtr,boost::shared_ptr<Route> > ViewRoute;
+ typedef std::pair<TimeAxisView*,boost::shared_ptr<Route> > ViewRoute;
std::list<ViewRoute> view_routes;
std::vector<int> neworder;
TreeModel::Children rows = _model->children();
TreeModel::Children::iterator ri;
for (ri = rows.begin(); ri != rows.end(); ++ri) {
- TimeAxisViewPtr tv = (*ri)[_columns.tv];
+ TimeAxisView* tv = (*ri)[_columns.tv];
boost::shared_ptr<Route> route = (*ri)[_columns.route];
view_routes.push_back (ViewRoute (tv, route));
}
}
-list<TimeAxisViewPtr>
+list<TimeAxisView*>
EditorRoutes::views () const
{
- list<TimeAxisViewPtr> v;
+ list<TimeAxisView*> v;
for (TreeModel::Children::iterator i = _model->children().begin(); i != _model->children().end(); ++i) {
v.push_back ((*i)[_columns.tv]);
}
}
void move_selected_tracks (bool);
- void show_track_in_display (TimeAxisViewPtr);
+ void show_track_in_display (TimeAxisView &);
void suspend_redisplay () {
_no_redisplay = true;
}
}
void redisplay ();
void update_visibility ();
- void routes_added (std::list<RouteTimeAxisViewPtr> routes);
- void hide_track_in_display (TimeAxisViewPtr);
- std::list<TimeAxisViewPtr> views () const;
+ void routes_added (std::list<RouteTimeAxisView*> routes);
+ void hide_track_in_display (TimeAxisView &);
+ std::list<TimeAxisView*> views () const;
void hide_all_tracks (bool);
void clear ();
void sync_order_keys (std::string const &);
void reordered (Gtk::TreeModel::Path const &, Gtk::TreeModel::iterator const &, int *);
bool button_press (GdkEventButton *);
void route_name_changed (boost::weak_ptr<ARDOUR::Route>);
- void route_removed (TimeAxisViewPtr);
+ void route_removed (TimeAxisView *);
void handle_gui_changes (std::string const &, void *);
void update_rec_display ();
void set_all_tracks_visibility (bool);
Gtk::TreeModelColumn<bool> visible;
Gtk::TreeModelColumn<bool> rec_enabled;
Gtk::TreeModelColumn<bool> is_track;
- Gtk::TreeModelColumn<TimeAxisViewPtr> tv;
+ Gtk::TreeModelColumn<TimeAxisView*> tv;
Gtk::TreeModelColumn<boost::shared_ptr<ARDOUR::Route> > route;
};
}
gdouble bottom_track_pos = vertical_adjustment.get_value() + _canvas_height - canvas_timebars_vsize;
- std::pair<TimeAxisViewPtr, int> const p = trackview_by_y_position (bottom_track_pos);
+ std::pair<TimeAxisView*, int> const p = trackview_by_y_position (bottom_track_pos);
if (p.first) {
p.first->clip_to_viewport ();
}
struct TrackViewByPositionSorter
{
- bool operator() (const TimeAxisViewPtr a, const TimeAxisViewPtr b) {
+ bool operator() (const TimeAxisView* a, const TimeAxisView *b) {
return a->y_position() < b->y_position();
}
};
bool
-Editor::extend_selection_to_track (TimeAxisViewPtr view)
+Editor::extend_selection_to_track (TimeAxisView& view)
{
- if (selection->selected (view)) {
+ if (selection->selected (&view)) {
/* already selected, do nothing */
return false;
}
if (selection->tracks.empty()) {
- if (!selection->selected (view)) {
- selection->set (view);
+ if (!selection->selected (&view)) {
+ selection->set (&view);
return true;
} else {
return false;
sorted.sort (cmp);
- if (!selection->selected (view)) {
- to_be_added.push_back (view);
+ if (!selection->selected (&view)) {
+ to_be_added.push_back (&view);
}
/* figure out if we should go forward or backwards */
for (TrackViewList::iterator i = sorted.begin(); i != sorted.end(); ++i) {
- if (*i == view) {
+ if ((*i) == &view) {
passed_clicked = true;
}
for (TrackViewList::iterator i = sorted.begin(); i != sorted.end(); ++i) {
- if (*i == view) {
+ if ((*i) == &view) {
passed_clicked = true;
continue;
}
for (TrackViewList::reverse_iterator r = sorted.rbegin(); r != sorted.rend(); ++r) {
- if (*r == view) {
+ if ((*r) == &view) {
passed_clicked = true;
continue;
}
if (!selection->tracks.empty()) {
if (!selection->selected (clicked_routeview)) {
- selection->add (boost::static_pointer_cast<TimeAxisView> (clicked_routeview));
+ selection->add (clicked_routeview);
}
} else if (force) {
- selection->set (boost::static_pointer_cast<TimeAxisView> (clicked_routeview));
+ selection->set (clicked_routeview);
}
}
void
-Editor::set_selected_track (TimeAxisViewPtr view, Selection::Operation op, bool no_remove)
+Editor::set_selected_track (TimeAxisView& view, Selection::Operation op, bool no_remove)
{
switch (op) {
case Selection::Toggle:
- if (selection->selected (view)) {
+ if (selection->selected (&view)) {
if (!no_remove) {
- selection->remove (view);
+ selection->remove (&view);
}
} else {
- selection->add (view);
+ selection->add (&view);
}
break;
case Selection::Add:
- if (!selection->selected (view)) {
- selection->add (view);
+ if (!selection->selected (&view)) {
+ selection->add (&view);
}
break;
case Selection::Set:
- selection->set (view);
+ selection->set (&view);
break;
case Selection::Extend:
return;
}
- set_selected_track (clicked_routeview, op, no_remove);
+ set_selected_track (*clicked_routeview, op, no_remove);
}
bool
*/
void
-Editor::get_equivalent_tracks (RouteTimeAxisViewPtr basis, set<RouteTimeAxisViewPtr> & equivs, RouteGroup::Property prop) const
+Editor::get_equivalent_tracks (RouteTimeAxisView* basis, set<RouteTimeAxisView*> & equivs, RouteGroup::Property prop) const
{
equivs.insert (basis);
properties; find other members */
for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
- RouteTimeAxisViewPtr v = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i);
+ RouteTimeAxisView* v = dynamic_cast<RouteTimeAxisView*> (*i);
if (v && v->route()->route_group() == group) {
equivs.insert (v);
}
*/
void
-Editor::get_relevant_tracks (set<RouteTimeAxisViewPtr>& relevant_tracks) const
+Editor::get_relevant_tracks (set<RouteTimeAxisView*>& relevant_tracks) const
{
for (TrackSelection::iterator ti = selection->tracks.begin(); ti != selection->tracks.end(); ++ti) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*ti);
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*ti);
if (rtv) {
get_equivalent_tracks (rtv, relevant_tracks, RouteGroup::Select);
}
*/
void
-Editor::mapover_tracks (slot<void, RouteTimeAxisViewPtr, uint32_t> sl, TimeAxisViewPtr basis, RouteGroup::Property prop) const
+Editor::mapover_tracks (slot<void, RouteTimeAxisView&, uint32_t> sl, TimeAxisView* basis, RouteGroup::Property prop) const
{
- RouteTimeAxisViewPtr route_basis = boost::dynamic_pointer_cast<RouteTimeAxisView> (basis);
+ RouteTimeAxisView* route_basis = dynamic_cast<RouteTimeAxisView*> (basis);
if (route_basis == 0) {
return;
}
- set<RouteTimeAxisViewPtr> tracks;
+ set<RouteTimeAxisView*> tracks;
get_equivalent_tracks (route_basis, tracks, prop);
/* call the slots */
uint32_t const sz = tracks.size ();
- for (set<RouteTimeAxisViewPtr>::iterator i = tracks.begin(); i != tracks.end(); ++i) {
- sl (*i, sz);
+ for (set<RouteTimeAxisView*>::iterator i = tracks.begin(); i != tracks.end(); ++i) {
+ sl (**i, sz);
}
}
void
-Editor::mapped_get_equivalent_regions (RouteTimeAxisViewPtr tv, uint32_t ignored, RegionView * basis, vector<RegionView*>* all_equivs) const
+Editor::mapped_get_equivalent_regions (RouteTimeAxisView& tv, uint32_t ignored, RegionView * basis, vector<RegionView*>* all_equivs) const
{
boost::shared_ptr<Playlist> pl;
vector<boost::shared_ptr<Region> > results;
RegionView* marv;
boost::shared_ptr<Diskstream> ds;
- if ((ds = tv->get_diskstream()) == 0) {
+ if ((ds = tv.get_diskstream()) == 0) {
/* bus */
return;
}
- if (tv == basis->get_time_axis_view()) {
+ if (&tv == &basis->get_time_axis_view()) {
/* looking in same track as the original */
return;
}
}
for (vector<boost::shared_ptr<Region> >::iterator ir = results.begin(); ir != results.end(); ++ir) {
- if ((marv = tv->view()->find_view (*ir)) != 0) {
+ if ((marv = tv.view()->find_view (*ir)) != 0) {
all_equivs->push_back (marv);
}
}
void
Editor::get_equivalent_regions (RegionView* basis, vector<RegionView*>& equivalent_regions, RouteGroup::Property prop) const
{
- mapover_tracks (bind (mem_fun (*this, &Editor::mapped_get_equivalent_regions), basis, &equivalent_regions), basis->get_trackview(), prop);
+ mapover_tracks (bind (mem_fun (*this, &Editor::mapped_get_equivalent_regions), basis, &equivalent_regions), &basis->get_trackview(), prop);
/* add clicked regionview since we skipped all other regions in the same track as the one it was in */
for (RegionSelection::const_iterator i = basis.begin(); i != basis.end(); ++i) {
vector<RegionView*> eq;
-
+
mapover_tracks (
- bind (mem_fun (*this, &Editor::mapped_get_equivalent_regions), *i, &eq), (*i)->get_trackview(), prop
+ bind (mem_fun (*this, &Editor::mapped_get_equivalent_regions), *i, &eq),
+ &(*i)->get_trackview(), prop
);
for (vector<RegionView*>::iterator j = eq.begin(); j != eq.end(); ++j) {
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- RouteTimeAxisViewPtr tatv;
+ RouteTimeAxisView* tatv;
- if ((tatv = boost::dynamic_pointer_cast<RouteTimeAxisView> (*i)) != 0) {
+ if ((tatv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
boost::shared_ptr<Playlist> pl;
vector<boost::shared_ptr<Region> > results;
first_frame = max_frames;
for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
- if ((*x)->get_time_axis_view() == clicked_regionview->get_time_axis_view()) {
+ if (&(*x)->get_time_axis_view() == &clicked_regionview->get_time_axis_view()) {
if ((*x)->region()->last_frame() > last_frame) {
last_frame = (*x)->region()->last_frame();
/* 2. find all the tracks we should select in */
- set<RouteTimeAxisViewPtr> relevant_tracks;
- set<RouteTimeAxisViewPtr> already_in_selection;
+ set<RouteTimeAxisView*> relevant_tracks;
+ set<RouteTimeAxisView*> already_in_selection;
get_relevant_tracks (relevant_tracks);
if (!selection->selected (entered_regionview)) {
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (entered_regionview->get_time_axis_view());
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&entered_regionview->get_time_axis_view());
if (rtv) {
already a selected region.
*/
- RouteTimeAxisViewPtr closest;
+ RouteTimeAxisView* closest = 0;
int distance = INT_MAX;
int key = rtv->route()->order_key ("editor");
for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
- RouteTimeAxisViewPtr artv = boost::dynamic_pointer_cast<RouteTimeAxisView>((*x)->get_time_axis_view());
+ RouteTimeAxisView* artv = dynamic_cast<RouteTimeAxisView*>(&(*x)->get_time_axis_view());
if (artv && artv != rtv) {
- pair<set<RouteTimeAxisViewPtr>::iterator,bool> result;
+ pair<set<RouteTimeAxisView*>::iterator,bool> result;
result = already_in_selection.insert (artv);
}
for (TrackViewList::iterator x = track_views.begin(); x != track_views.end(); ++x) {
- RouteTimeAxisViewPtr artv = boost::dynamic_pointer_cast<RouteTimeAxisView>(*x);
+ RouteTimeAxisView* artv = dynamic_cast<RouteTimeAxisView*>(*x);
if (artv && artv != rtv) {
int k = artv->route()->order_key ("editor");
get_relevant_tracks (relevant_tracks);
- for (set<RouteTimeAxisViewPtr>::iterator t = relevant_tracks.begin(); t != relevant_tracks.end(); ++t) {
+ for (set<RouteTimeAxisView*>::iterator t = relevant_tracks.begin(); t != relevant_tracks.end(); ++t) {
(*t)->get_selectables (first_frame, last_frame, -1.0, -1.0, results);
}
case 0:
break;
default:
- set_selected_mixer_strip (selection->tracks.front());
+ set_selected_mixer_strip (*(selection->tracks.front()));
break;
}
return;
}
- selection->set (TimeAxisViewPtr (), selection->regions.start(), selection->regions.end_frame());
+ selection->set (0, selection->regions.start(), selection->regions.end_frame());
if (!Profile->get_sae()) {
set_mouse_mode (Editing::MouseRange, false);
}
Editor::set_selection_from_range (Location& loc)
{
begin_reversible_command (_("set selection from range"));
- selection->set (TimeAxisViewPtr (), loc.start(), loc.end());
+ selection->set (0, loc.start(), loc.end());
commit_reversible_command ();
if (!Profile->get_sae()) {
}
set_mouse_mode (MouseRange);
- selection->set (TimeAxisViewPtr (), start, end);
+ selection->set ((TimeAxisView*) 0, start, end);
}
bool
return time_fx (regions, fraction, false);
} else {
// MIDI, just stretch
- RouteTimeAxisViewPtr rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (regions.front()->get_time_axis_view());
- if (!rtv) {
+ RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (®ions.front()->get_time_axis_view());
+ if (!rtv)
return -1;
- }
boost::shared_ptr<Playlist> playlist
= rtv->track()->diskstream()->playlist();
}
boost::shared_ptr<AudioRegion> region (arv->audio_region());
- TimeAxisViewPtr tv = arv->get_time_axis_view();
- RouteTimeAxisViewPtr rtv;
+ TimeAxisView* tv = &(arv->get_time_axis_view());
+ RouteTimeAxisView* rtv;
RegionSelection::iterator tmp;
tmp = i;
++tmp;
- if ((rtv = boost::dynamic_pointer_cast<RouteTimeAxisView> (tv)) == 0) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*> (tv)) == 0) {
i = tmp;
continue;
}
using namespace ArdourCanvas;
using namespace ARDOUR;
-GhostRegion::GhostRegion (ArdourCanvas::Group* parent, TimeAxisViewPtr tv, TimeAxisViewPtr source_tv, double initial_pos)
+GhostRegion::GhostRegion (ArdourCanvas::Group* parent, TimeAxisView& tv, TimeAxisView& source_tv, double initial_pos)
: trackview (tv)
, source_trackview (source_tv)
{
base_rect = new ArdourCanvas::SimpleRect (*group);
base_rect->property_x1() = (double) 0.0;
base_rect->property_y1() = (double) 0.0;
- base_rect->property_y2() = (double) trackview->current_height();
+ base_rect->property_y2() = (double) trackview.current_height();
base_rect->property_outline_what() = (guint32) 0;
if (!is_automation_ghost()) {
void
GhostRegion::set_height ()
{
- base_rect->property_y2() = (double) trackview->current_height();
+ base_rect->property_y2() = (double) trackview.current_height();
}
void
guint
GhostRegion::source_track_color(unsigned char alpha) {
- Gdk::Color color = source_trackview->color();
+ Gdk::Color color = source_trackview.color();
unsigned char r,g,b ;
r = color.get_red()/256;
g = color.get_green()/256;
bool
GhostRegion::is_automation_ghost() {
- return (boost::dynamic_pointer_cast<AutomationTimeAxisViewPtr> (trackview)) != 0;
+ return (dynamic_cast<AutomationTimeAxisView*>(&trackview)) != 0;
}
-AudioGhostRegion::AudioGhostRegion(TimeAxisViewPtr tv, TimeAxisViewPtr source_tv, double initial_unit_pos)
- : GhostRegion(tv->ghost_group(), tv, source_tv, initial_unit_pos) {
+AudioGhostRegion::AudioGhostRegion(TimeAxisView& tv, TimeAxisView& source_tv, double initial_unit_pos)
+ : GhostRegion(tv.ghost_group(), tv, source_tv, initial_unit_pos) {
}
void
GhostRegion::set_height();
- ht = ((trackview->current_height()) / (double) waves.size());
+ ht = ((trackview.current_height()) / (double) waves.size());
for (n = 0, i = waves.begin(); i != waves.end(); ++i, ++n) {
- gdouble const yoff = n * ht;
+ gdouble yoff = n * ht;
(*i)->property_height() = ht;
(*i)->property_y() = yoff;
}
* a midistreamview. But what to do when positioning the midi ghost here? For example, there is
* no range controller in these tracks. maybe show the whole range.
*/
-MidiGhostRegion::MidiGhostRegion(TimeAxisViewPtr tv, TimeAxisViewPtr source_tv, double initial_unit_pos)
- : GhostRegion (tv->ghost_group(), tv, source_tv, initial_unit_pos)
+MidiGhostRegion::MidiGhostRegion(TimeAxisView& tv, TimeAxisView& source_tv, double initial_unit_pos)
+ : GhostRegion(tv.ghost_group(), tv, source_tv, initial_unit_pos)
{
base_rect->lower_to_bottom();
}
-MidiGhostRegion::MidiGhostRegion(MidiStreamView& msv, TimeAxisViewPtr source_tv, double initial_unit_pos)
+MidiGhostRegion::MidiGhostRegion(MidiStreamView& msv, TimeAxisView& source_tv, double initial_unit_pos)
: GhostRegion(msv.midi_underlay_group, msv.trackview(), source_tv, initial_unit_pos)
{
base_rect->lower_to_bottom();
MidiStreamView*
MidiGhostRegion::midi_view()
{
- MidiTimeAxisViewPtr mtv;
+ MidiTimeAxisView* mtv;
- if ((mtv = boost::dynamic_pointer_cast<MidiTimeAxisView> (trackview)) != 0) {
+ if ((mtv = dynamic_cast<MidiTimeAxisView*>(&trackview)) != 0) {
return mtv->midi_view();
}
else {
class GhostRegion : public sigc::trackable
{
public:
- GhostRegion(ArdourCanvas::Group* parent, TimeAxisViewPtr tv, TimeAxisViewPtr source_tv, double initial_unit_pos);
+ GhostRegion(ArdourCanvas::Group* parent, TimeAxisView& tv, TimeAxisView& source_tv, double initial_unit_pos);
virtual ~GhostRegion();
virtual void set_samples_per_unit(double spu) = 0;
sigc::signal<void,GhostRegion*> GoingAway;
- TimeAxisViewPtr trackview;
- TimeAxisViewPtr source_trackview;
+ TimeAxisView& trackview;
+ TimeAxisView& source_trackview;
ArdourCanvas::Group* group;
ArdourCanvas::SimpleRect* base_rect;
};
class AudioGhostRegion : public GhostRegion {
public:
- AudioGhostRegion(TimeAxisViewPtr tv, TimeAxisViewPtr source_tv, double initial_unit_pos);
+ AudioGhostRegion(TimeAxisView& tv, TimeAxisView& source_tv, double initial_unit_pos);
void set_samples_per_unit(double spu);
void set_height();
ArdourCanvas::Diamond* diamond;
};
- MidiGhostRegion(TimeAxisViewPtr tv, TimeAxisViewPtr source_tv, double initial_unit_pos);
- MidiGhostRegion(MidiStreamView& msv, TimeAxisViewPtr source_tv, double initial_unit_pos);
+ MidiGhostRegion(TimeAxisView& tv, TimeAxisView& source_tv, double initial_unit_pos);
+ MidiGhostRegion(MidiStreamView& msv, TimeAxisView& source_tv, double initial_unit_pos);
~MidiGhostRegion();
MidiStreamView* midi_view();
using namespace Editing;
using namespace ArdourCanvas;
-MidiRegionView::MidiRegionView (ArdourCanvas::Group *parent, RouteTimeAxisViewPtr tv,
+MidiRegionView::MidiRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView &tv,
boost::shared_ptr<MidiRegion> r, double spu, Gdk::Color const & basic_color)
: RegionView (parent, tv, r, spu, basic_color)
, _force_channel(-1)
_note_group->raise_to_top();
}
-MidiRegionView::MidiRegionView (ArdourCanvas::Group *parent, RouteTimeAxisViewPtr tv,
+MidiRegionView::MidiRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView &tv,
boost::shared_ptr<MidiRegion> r, double spu, Gdk::Color& basic_color,
TimeAxisViewItem::Visibility visibility)
: RegionView (parent, tv, r, spu, basic_color, false, visibility)
compute_colors (basic_color);
- set_height (trackview->current_height());
+ set_height (trackview.current_height());
region_muted ();
region_sync_changed ();
static ArdourCanvas::SimpleRect* drag_rect = NULL;
- if (trackview->editor().current_mouse_mode() != MouseNote)
+ if (trackview.editor().current_mouse_mode() != MouseNote)
return false;
- const Editing::MidiEditMode midi_edit_mode = trackview->editor().current_midi_edit_mode();
+ const Editing::MidiEditMode midi_edit_mode = trackview.editor().current_midi_edit_mode();
switch (ev->type) {
case GDK_KEY_PRESS:
group->w2i(event_x, event_y);
// convert event_x to global frame
- event_frame = trackview->editor().pixel_to_frame(event_x) + _region->position();
- trackview->editor().snap_to(event_frame);
+ event_frame = trackview.editor().pixel_to_frame(event_x) + _region->position();
+ trackview.editor().snap_to(event_frame);
// convert event_frame back to local coordinates relative to position
event_frame -= _region->position();
drag_start_y = event_y;
drag_rect = new ArdourCanvas::SimpleRect(*group);
- drag_rect->property_x1() = trackview->editor().frame_to_pixel(event_frame);
+ drag_rect->property_x1() = trackview.editor().frame_to_pixel(event_frame);
drag_rect->property_y1() = midi_stream_view()->note_to_y(
midi_stream_view()->y_to_note(event_y));
}
if (_mouse_state == AddDragging)
- event_x = trackview->editor().frame_to_pixel(event_frame);
+ event_x = trackview.editor().frame_to_pixel(event_frame);
if (drag_rect) {
if (event_x > drag_start_x)
event_y = ev->motion.y;
group->w2i(event_x, event_y);
group->ungrab(ev->button.time);
- event_frame = trackview->editor().pixel_to_frame(event_x);
+ event_frame = trackview.editor().pixel_to_frame(event_x);
if (_pressed_button != 1) {
return false;
_mouse_state = None;
if (drag_rect->property_x2() > drag_rect->property_x1() + 2) {
const double x = drag_rect->property_x1();
- const double length = trackview->editor().pixel_to_frame(
+ const double length = trackview.editor().pixel_to_frame(
drag_rect->property_x2() - drag_rect->property_x1());
create_note_at(x, drag_rect->property_y1(), frames_to_beats(length));
void
MidiRegionView::create_note_at(double x, double y, double length)
{
- MidiTimeAxisViewPtr mtv = boost::dynamic_pointer_cast<MidiTimeAxisView> (trackview);
+ MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
MidiStreamView* const view = mtv->midi_view();
double note = midi_stream_view()->y_to_note(y);
assert(note <= 127.0);
// Start of note in frames relative to region start
- nframes64_t start_frames = snap_frame_to_frame(trackview->editor().pixel_to_frame(x));
+ nframes64_t start_frames = snap_frame_to_frame(trackview.editor().pixel_to_frame(x));
assert(start_frames >= 0);
// Snap length
MidiModel::DeltaCommand* cmd = _model->new_delta_command("add note");
cmd->add(new_note);
- _model->apply_command(trackview->session(), cmd);
+ _model->apply_command(trackview.session(), cmd);
}
_marked_for_selection.insert((*i)->note());
}
- _model->apply_command(trackview->session(), _delta_command);
+ _model->apply_command(trackview.session(), _delta_command);
_delta_command = NULL;
midi_view()->midi_track()->diskstream()->playlist_modified();
string text = str.str();
ArdourCanvas::Group* const group = (ArdourCanvas::Group*)get_canvas_group();
- const double x = trackview->editor().frame_to_pixel(beats_to_frames(time));
+ const double x = trackview.editor().frame_to_pixel(beats_to_frames(time));
double height = midi_stream_view()->contents_height();
note->property_y1() = y1;
note->property_y2() = y2;
} else if (CanvasHit* hit = dynamic_cast<CanvasHit*>(event)) {
- double x = trackview->editor().frame_to_pixel(
+ double x = trackview.editor().frame_to_pixel(
beats_to_frames(event->note()->time()) - _region->start());
const double diamond_size = midi_stream_view()->note_height() / 2.0;
double y = midi_stream_view()->note_to_y(event->note()->note())
}
GhostRegion*
-MidiRegionView::add_ghost (TimeAxisViewPtr tv)
+MidiRegionView::add_ghost (TimeAxisView& tv)
{
CanvasNote* note;
double unit_position = _region->position () / samples_per_unit;
- MidiTimeAxisViewPtr mtv = boost::dynamic_pointer_cast<MidiTimeAxisView> (tv);
+ MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&tv);
MidiGhostRegion* ghost;
if (mtv && mtv->midi_view()) {
if (_active_notes && _active_notes[note]) {
const nframes64_t end_time_frames = beats_to_frames(end_time);
- _active_notes[note]->property_x2() = trackview->editor().frame_to_pixel(end_time_frames);
+ _active_notes[note]->property_x2() = trackview.editor().frame_to_pixel(end_time_frames);
_active_notes[note]->property_outline_what() = (guint32) 0xF; // all edges
_active_notes[note] = NULL;
}
for (unsigned i=0; i < 128; ++i) {
if (_active_notes[i]) {
- _active_notes[i]->property_x2() = trackview->editor().frame_to_pixel(_region->length());
+ _active_notes[i]->property_x2() = trackview.editor().frame_to_pixel(_region->length());
}
}
}
void
MidiRegionView::play_midi_note(boost::shared_ptr<NoteType> note)
{
- if (!trackview->editor().sound_notes()) {
+ if (!trackview.editor().sound_notes()) {
return;
}
- boost::shared_ptr<RouteUI> route_ui = boost::dynamic_pointer_cast<RouteUI> (trackview);
+ RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
assert(route_ui);
route_ui->midi_track()->write_immediate_event(
bool
MidiRegionView::play_midi_note_off(boost::shared_ptr<NoteType> note)
{
- boost::shared_ptr<RouteUI> route_ui = boost::dynamic_pointer_cast<RouteUI> (trackview);
+ RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
assert(route_ui);
route_ui->midi_track()->write_immediate_event(
CanvasNoteEvent* event = 0;
- const double x = trackview->editor().frame_to_pixel(note_start_frames - _region->start());
+ const double x = trackview.editor().frame_to_pixel(note_start_frames - _region->start());
if (midi_view()->note_mode() == Sustained) {
const double y1 = midi_stream_view()->note_to_y(note->note());
const double note_endpixel =
- trackview->editor().frame_to_pixel(note_end_frames - _region->start());
+ trackview.editor().frame_to_pixel(note_end_frames - _region->start());
CanvasNote* ev_rect = new CanvasNote(*this, *group, note);
ev_rect->property_x1() = x;
if (note->length() > 0) {
ev_rect->property_x2() = note_endpixel;
} else {
- ev_rect->property_x2() = trackview->editor().frame_to_pixel(_region->length());
+ ev_rect->property_x2() = trackview.editor().frame_to_pixel(_region->length());
}
ev_rect->property_y2() = y1 + floor(midi_stream_view()->note_height());
assert(program.time >= 0);
ArdourCanvas::Group* const group = (ArdourCanvas::Group*)get_canvas_group();
- const double x = trackview->editor().frame_to_pixel(beats_to_frames(program.time));
+ const double x = trackview.editor().frame_to_pixel(beats_to_frames(program.time));
double height = midi_stream_view()->contents_height();
nframes64_t start_frames = beats_to_frames((*i)->note()->time());
if (dt >= 0) {
- start_frames += snap_frame_to_frame(trackview->editor().pixel_to_frame(dt));
+ start_frames += snap_frame_to_frame(trackview.editor().pixel_to_frame(dt));
} else {
- start_frames -= snap_frame_to_frame(trackview->editor().pixel_to_frame(-dt));
+ start_frames -= snap_frame_to_frame(trackview.editor().pixel_to_frame(-dt));
}
copy->set_time(frames_to_beats(start_frames));
nframes64_t
MidiRegionView::snap_pixel_to_frame(double x)
{
- PublicEditor& editor = trackview->editor();
+ PublicEditor& editor = trackview.editor();
// x is region relative, convert it to global absolute frames
nframes64_t frame = editor.pixel_to_frame(x) + _region->position();
editor.snap_to(frame);
nframes64_t
MidiRegionView::snap_frame_to_frame(nframes64_t x)
{
- PublicEditor& editor = trackview->editor();
+ PublicEditor& editor = trackview.editor();
// x is region relative, convert it to global absolute frames
nframes64_t frame = x + _region->position();
editor.snap_to(frame);
double
MidiRegionView::snap_to_pixel(double x)
{
- return (double) trackview->editor().frame_to_pixel(snap_pixel_to_frame(x));
+ return (double) trackview.editor().frame_to_pixel(snap_pixel_to_frame(x));
}
double
MidiRegionView::get_position_pixels()
{
nframes64_t region_frame = get_position();
- return trackview->editor().frame_to_pixel(region_frame);
+ return trackview.editor().frame_to_pixel(region_frame);
}
nframes64_t
typedef Evoral::Note<ARDOUR::MidiModel::TimeType> NoteType;
MidiRegionView (ArdourCanvas::Group *,
- RouteTimeAxisViewPtr,
+ RouteTimeAxisView&,
boost::shared_ptr<ARDOUR::MidiRegion>,
double initial_samples_per_unit,
Gdk::Color const & basic_color);
inline const boost::shared_ptr<ARDOUR::MidiRegion> midi_region() const
{ return boost::dynamic_pointer_cast<ARDOUR::MidiRegion>(_region); }
- inline MidiTimeAxisViewPtr midi_view() const {
- return boost::dynamic_pointer_cast<MidiTimeAxisView> (trackview);
- }
+ inline MidiTimeAxisView* midi_view() const
+ { return dynamic_cast<MidiTimeAxisView*>(&trackview); }
inline MidiStreamView* midi_stream_view() const
{ return midi_view()->midi_view(); }
void redisplay_model();
- GhostRegion* add_ghost (TimeAxisViewPtr);
+ GhostRegion* add_ghost (TimeAxisView&);
void add_note(const boost::shared_ptr<NoteType> note);
void resolve_note(uint8_t note_num, double end_time);
* to the TimeAxisViewItem parent class.
*/
MidiRegionView (ArdourCanvas::Group *,
- RouteTimeAxisViewPtr,
+ RouteTimeAxisView&,
boost::shared_ptr<ARDOUR::MidiRegion>,
double samples_per_unit,
Gdk::Color& basic_color,
using namespace PBD;
using namespace Editing;
-MidiStreamView::MidiStreamView (MidiTimeAxisViewPtr tv)
+MidiStreamView::MidiStreamView (MidiTimeAxisView& tv)
: StreamView (tv)
, note_range_adjustment(0.0f, 0.0f, 0.0f)
, _range_dirty(false)
, _data_note_min(60)
, _data_note_max(71)
{
- if (tv->is_track()) {
+ if (tv.is_track()) {
stream_base_color = ARDOUR_UI::config()->canvasvar_MidiTrackBase.get();
} else {
stream_base_color = ARDOUR_UI::config()->canvasvar_MidiBusBase.get();
}
- use_rec_regions = tv->editor().show_waveforms_recording ();
+ use_rec_regions = tv.editor().show_waveforms_recording ();
/* use a group dedicated to MIDI underlays. Audio underlays are not in this group. */
midi_underlay_group = new ArdourCanvas::Group (*canvas_group);
_note_lines->property_x1() = 0;
_note_lines->property_y1() = 0;
- _note_lines->property_x2() = trackview()->editor().frame_to_pixel (max_frames);
+ _note_lines->property_x2() = trackview().editor().frame_to_pixel (max_frames);
_note_lines->property_y2() = 0;
- TimeAxisViewPtr w (_trackview);
- _note_lines->signal_event().connect(
- bind(
- mem_fun(_trackview->editor(), &PublicEditor::canvas_stream_view_event),
- _note_lines, w
- )
- );
+ _note_lines->signal_event().connect(bind(
+ mem_fun(_trackview.editor(), &PublicEditor::canvas_stream_view_event),
+ _note_lines, &_trackview));
_note_lines->lower_to_bottom();
void
MidiStreamView::redisplay_diskstream ()
{
- if (!_trackview->is_midi_track()) {
+ if (!_trackview.is_midi_track()) {
return;
}
_range_dirty = false;
_data_note_min = 127;
_data_note_max = 0;
- _trackview->get_diskstream()->playlist()->foreach_region(
+ _trackview.get_diskstream()->playlist()->foreach_region(
sigc::mem_fun (*this, &StreamView::update_contents_metrics)
);
}
// Add and display region views, and flag them as valid
- _trackview->get_diskstream()->playlist()->foreach_region(
+ _trackview.get_diskstream()->playlist()->foreach_region(
sigc::hide_return (sigc::mem_fun (*this, &StreamView::add_region_view))
);
{
// cerr << _trackview.name() << " streamview SRB\n";
- if (_trackview->session().transport_rolling()) {
+ if (_trackview.session().transport_rolling()) {
if (!rec_active &&
- _trackview->session().record_status() == Session::Recording &&
- _trackview->get_diskstream()->record_enabled()) {
+ _trackview.session().record_status() == Session::Recording &&
+ _trackview.get_diskstream()->record_enabled()) {
if (use_rec_regions && rec_regions.size() == rec_rects.size()) {
rec_data_ready_connections.clear();
// FIXME
- boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream>(_trackview->get_diskstream());
+ boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream>(_trackview.get_diskstream());
assert(mds);
sources.push_back(mds->write_source());
jack_nframes_t start = 0;
if (rec_regions.size() > 0) {
- start = rec_regions.back().first->position() + _trackview->get_diskstream()->get_captured_frames(rec_regions.size()-1);
+ start = rec_regions.back().first->position() + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1);
}
boost::shared_ptr<MidiRegion> region (boost::dynamic_pointer_cast<MidiRegion>
(RegionFactory::create (sources, start, 1 , "", 0, Region::DefaultFlags, false)));
assert(region);
region->block_property_changes ();
- region->set_position (_trackview->session().transport_frame(), this);
+ region->set_position (_trackview.session().transport_frame(), this);
rec_regions.push_back (make_pair(region, (RegionView*)0));
// rec regions are destroyed in setup_rec_box
/* start a new rec box */
- boost::shared_ptr<MidiTrack> mt = _trackview->midi_track(); /* we know what it is already */
+ boost::shared_ptr<MidiTrack> mt = _trackview.midi_track(); /* we know what it is already */
boost::shared_ptr<MidiDiskstream> ds = mt->midi_diskstream();
jack_nframes_t frame_pos = ds->current_capture_start ();
- gdouble xstart = _trackview->editor().frame_to_pixel (frame_pos);
+ gdouble xstart = _trackview.editor().frame_to_pixel (frame_pos);
gdouble xend;
uint32_t fill_color;
- assert(_trackview->midi_track()->mode() == Normal);
+ assert(_trackview.midi_track()->mode() == Normal);
xend = xstart;
fill_color = ARDOUR_UI::config()->canvasvar_RecordingRect.get();
rec_rect->property_x1() = xstart;
rec_rect->property_y1() = 1.0;
rec_rect->property_x2() = xend;
- rec_rect->property_y2() = (double) _trackview->current_height() - 1;
+ rec_rect->property_y2() = (double) _trackview.current_height() - 1;
rec_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_RecordingRect.get();
rec_rect->property_fill_color_rgba() = fill_color;
rec_rect->lower_to_bottom();
RecBoxInfo recbox;
recbox.rectangle = rec_rect;
- recbox.start = _trackview->session().transport_frame();
+ recbox.start = _trackview.session().transport_frame();
recbox.length = 0;
rec_rects.push_back (recbox);
rec_active = true;
} else if (rec_active &&
- (_trackview->session().record_status() != Session::Recording ||
- !_trackview->get_diskstream()->record_enabled())) {
+ (_trackview.session().record_status() != Session::Recording ||
+ !_trackview.get_diskstream()->record_enabled())) {
screen_update_connection.disconnect();
rec_active = false;
if (nlen != region->length()) {
region->freeze ();
- region->set_position (_trackview->get_diskstream()->get_capture_start_frame(n), this);
+ region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
region->set_length (start + dur - region->position(), this);
region->thaw ("updated");
/* also update rect */
ArdourCanvas::SimpleRect * rect = rec_rects[n].rectangle;
- gdouble xend = _trackview->editor().frame_to_pixel (region->position() + region->length());
+ gdouble xend = _trackview.editor().frame_to_pixel (region->position() + region->length());
rect->property_x2() = xend;
/* draw events */
} else {
- nframes_t nlen = _trackview->get_diskstream()->get_captured_frames(n);
+ nframes_t nlen = _trackview.get_diskstream()->get_captured_frames(n);
if (nlen != region->length()) {
if (region->source_length(0) >= region->position() + nlen) {
region->freeze ();
- region->set_position (_trackview->get_diskstream()->get_capture_start_frame(n), this);
+ region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
region->set_length (nlen, this);
region->thaw ("updated");
MidiStreamView::color_handler ()
{
//case cMidiTrackBase:
- if (_trackview->is_midi_track()) {
+ if (_trackview.is_midi_track()) {
//canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiTrackBase.get();
}
//case cMidiBusBase:
- if (!_trackview->is_midi_track()) {
+ if (!_trackview.is_midi_track()) {
//canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiBusBase.get();;
}
}
class MidiStreamView : public StreamView
{
public:
- MidiStreamView (MidiTimeAxisViewPtr);
+ MidiStreamView (MidiTimeAxisView&);
~MidiStreamView ();
void set_selected_regionviews (RegionSelection&);
void redisplay_diskstream ();
inline double contents_height() const
- { return (_trackview->current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE - 2); }
+ { return (_trackview.current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE - 2); }
inline double note_to_y(uint8_t note) const
{ return contents_height()
static const uint32_t KEYBOARD_MIN_HEIGHT = 140;
MidiTimeAxisView::MidiTimeAxisView (PublicEditor& ed, Session& sess,
- boost::shared_ptr<Route> rt, Canvas& canvas)
+ boost::shared_ptr<Route> rt, Canvas& canvas)
: AxisView(sess) // virtually inherited
, RouteTimeAxisView(ed, sess, rt, canvas)
, _ignore_signals(false)
, _channel_color_mode_item(0)
, _track_color_mode_item(0)
{
-
-}
-
-
-MidiTimeAxisViewPtr
-MidiTimeAxisView::create (PublicEditor& ed, Session& sess,
- boost::shared_ptr<Route> rt, Canvas& canvas)
-{
- MidiTimeAxisViewPtr v (new MidiTimeAxisView (ed, sess, rt, canvas));
- v->init (ed, sess, rt, canvas);
- return v;
-}
-
-
-void
-MidiTimeAxisView::init (PublicEditor& ed, Session& sess,
- boost::shared_ptr<Route> rt, Canvas& canvas)
-{
subplugin_menu.set_name ("ArdourContextMenu");
- _view = new MidiStreamView (boost::dynamic_pointer_cast<MidiTimeAxisView> (shared_from_this ()));
+ _view = new MidiStreamView (*this);
ignore_toggle = false;
assert(c);
- boost::shared_ptr<AutomationTimeAxisView> track =
- AutomationTimeAxisView::create (
- _session,
+ boost::shared_ptr<AutomationTimeAxisView> track(new AutomationTimeAxisView (_session,
_route, boost::shared_ptr<ARDOUR::Automatable>(), c,
_editor,
- shared_from_this (),
+ *this,
true,
parent_canvas,
- _route->describe_parameter(param)
- );
+ _route->describe_parameter(param)));
add_automation_child(param, track, show);
}
class MidiTimeAxisView : public RouteTimeAxisView
{
public:
- static MidiTimeAxisViewPtr
- create (PublicEditor&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, ArdourCanvas::Canvas& canvas);
-
+ MidiTimeAxisView (PublicEditor&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, ArdourCanvas::Canvas& canvas);
virtual ~MidiTimeAxisView ();
MidiStreamView* midi_view();
private:
sigc::signal<void, std::string, std::string> _midi_patch_settings_changed;
-
- MidiTimeAxisView (PublicEditor&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, ArdourCanvas::Canvas& canvas);
- void init (PublicEditor&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, ArdourCanvas::Canvas& canvas);
-
+
void model_changed();
void custom_device_mode_changed();
void
PianoRollHeader::send_note_on(uint8_t note)
{
- boost::shared_ptr<ARDOUR::MidiTrack> track = _view.trackview()->midi_track();
+ boost::shared_ptr<ARDOUR::MidiTrack> track = _view.trackview().midi_track();
//cerr << "note on: " << (int) note << endl;
void
PianoRollHeader::send_note_off(uint8_t note)
{
- boost::shared_ptr<ARDOUR::MidiTrack> track = _view.trackview()->midi_track();
+ boost::shared_ptr<ARDOUR::MidiTrack> track = _view.trackview().midi_track();
if (track) {
_event[0] = MIDI_CMD_NOTE_OFF;
virtual gulong frame_to_pixel (nframes64_t frame) const = 0;
virtual Selection& get_selection () const = 0;
virtual Selection& get_cut_buffer () const = 0;
- virtual bool extend_selection_to_track (TimeAxisViewPtr) = 0;
+ virtual bool extend_selection_to_track (TimeAxisView&) = 0;
virtual void play_selection () = 0;
virtual void set_show_measures (bool yn) = 0;
virtual bool show_measures () const = 0;
virtual gdouble get_current_zoom () const = 0;
virtual PlaylistSelector& playlist_selector() const = 0;
virtual void clear_playlist (boost::shared_ptr<ARDOUR::Playlist>) = 0;
- virtual void new_playlists (boost::weak_ptr<TimeAxisView>) = 0;
- virtual void copy_playlists (boost::weak_ptr<TimeAxisView>) = 0;
- virtual void clear_playlists (boost::weak_ptr<TimeAxisView>) = 0;
+ virtual void new_playlists (TimeAxisView*) = 0;
+ virtual void copy_playlists (TimeAxisView*) = 0;
+ virtual void clear_playlists (TimeAxisView*) = 0;
virtual void select_all_tracks () = 0;
- virtual void set_selected_track (TimeAxisViewPtr, Selection::Operation op = Selection::Set, bool no_remove = false) = 0;
- virtual void set_selected_mixer_strip (TimeAxisViewPtr) = 0;
- virtual void hide_track_in_display (TimeAxisViewPtr tv, bool temporary = false) = 0;
+ virtual void set_selected_track (TimeAxisView&, Selection::Operation op = Selection::Set, bool no_remove = false) = 0;
+ virtual void set_selected_mixer_strip (TimeAxisView&) = 0;
+ virtual void hide_track_in_display (TimeAxisView& tv, bool temporary = false) = 0;
/** Set whether the editor should follow the playhead.
* @param yn true to follow playhead, otherwise false.
virtual double get_physical_screen_width() const = 0;
virtual void ensure_float (Gtk::Window&) = 0;
virtual void show_window () = 0;
- virtual TrackViewList* get_valid_views (TimeAxisViewPtr, ARDOUR::RouteGroup* grp = 0) = 0;
+ virtual TrackViewList* get_valid_views (TimeAxisView*, ARDOUR::RouteGroup* grp = 0) = 0;
virtual nframes64_t leftmost_position() const = 0;
virtual nframes64_t current_page_frames() const = 0;
virtual void temporal_zoom_step (bool coarser) = 0;
virtual void toggle_meter_updating() = 0;
virtual void split_region_at_points (boost::shared_ptr<ARDOUR::Region>, ARDOUR::AnalysisFeatureList&, bool can_ferret) = 0;
virtual void mouse_add_new_marker (nframes64_t where, bool is_cd=false, bool is_xrun=false) = 0;
- virtual void foreach_time_axis_view (sigc::slot<void,TimeAxisViewPtr>) = 0;
- virtual void add_to_idle_resize (TimeAxisViewPtr, int32_t) = 0;
+ virtual void foreach_time_axis_view (sigc::slot<void,TimeAxisView&>) = 0;
+ virtual void add_to_idle_resize (TimeAxisView*, int32_t) = 0;
#ifdef WITH_CMT
virtual void add_imageframe_time_axis(const std::string & track_name, void*) = 0;
- virtual void add_imageframe_marker_time_axis(const std::string & track_name, TimeAxisViewPtr marked_track, void*) = 0;
+ virtual void add_imageframe_marker_time_axis(const std::string & track_name, TimeAxisView* marked_track, void*) = 0;
virtual void connect_to_image_compositor() = 0;
virtual void scroll_timeaxis_to_imageframe_item(const TimeAxisViewItem* item) = 0;
- virtual TimeAxisViewPtr get_named_time_axis(const std::string & name) = 0;
+ virtual TimeAxisView* get_named_time_axis(const std::string & name) = 0;
#endif
- virtual RouteTimeAxisViewPtr get_route_view_by_id (PBD::ID& id) = 0;
+ virtual RouteTimeAxisView* get_route_view_by_id (PBD::ID& id) = 0;
virtual void get_equivalent_regions (RegionView* rv, std::vector<RegionView*>&, ARDOUR::RouteGroup::Property) const = 0;
virtual bool canvas_region_view_event (GdkEvent* event, ArdourCanvas::Item*, RegionView*) = 0;
virtual bool canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item*, RegionView*) = 0;
virtual bool canvas_region_view_name_event (GdkEvent* event, ArdourCanvas::Item*, RegionView*) = 0;
- virtual bool canvas_stream_view_event (GdkEvent* event, ArdourCanvas::Item*, boost::weak_ptr<TimeAxisView>) = 0;
+ virtual bool canvas_stream_view_event (GdkEvent* event, ArdourCanvas::Item*, RouteTimeAxisView*) = 0;
virtual bool canvas_marker_event (GdkEvent* event, ArdourCanvas::Item*, Marker*) = 0;
virtual bool canvas_zoom_rect_event (GdkEvent* event, ArdourCanvas::Item*) = 0;
virtual bool canvas_tempo_marker_event (GdkEvent* event, ArdourCanvas::Item*, TempoMarker*) = 0;
virtual bool canvas_meter_marker_event (GdkEvent* event, ArdourCanvas::Item*, MeterMarker*) = 0;
- virtual bool canvas_automation_track_event(GdkEvent* event, ArdourCanvas::Item*, boost::weak_ptr<AutomationTimeAxisView>) = 0;
+ virtual bool canvas_automation_track_event(GdkEvent* event, ArdourCanvas::Item*, AutomationTimeAxisView*) = 0;
virtual bool canvas_tempo_bar_event (GdkEvent* event, ArdourCanvas::Item*) = 0;
virtual bool canvas_meter_bar_event (GdkEvent* event, ArdourCanvas::Item*) = 0;
{
AutomationLine::start_drag (cp, x, fraction);
if (!rv.audio_region()->envelope_active()) {
- trackview
->session().add_command(new MementoCommand<AudioRegion>(*(rv.audio_region().get()), &rv.audio_region()->get_state(), 0));
+ trackview
.session().add_command(new MementoCommand<AudioRegion>(*(rv.audio_region().get()), &rv.audio_region()->get_state(), 0));
rv.audio_region()->set_envelope_active(false);
}
}
model_representation (cp, mr);
- trackview->editor().current_session()->begin_reversible_command (_("remove control point"));
+ trackview.editor().current_session()->begin_reversible_command (_("remove control point"));
XMLNode &before = alist->get_state();
if (!rv.audio_region()->envelope_active()) {
XMLNode ®ion_before = rv.audio_region()->get_state();
rv.audio_region()->set_envelope_active(true);
XMLNode ®ion_after = rv.audio_region()->get_state();
- trackview
->session().add_command(new MementoCommand<AudioRegion>(*(rv.audio_region().get()), ®ion_before, ®ion_after));
+ trackview
.session().add_command(new MementoCommand<AudioRegion>(*(rv.audio_region().get()), ®ion_before, ®ion_after));
}
alist->erase (mr.start, mr.end);
- trackview
->editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), &before, &alist->get_state()));
- trackview->editor().current_session()->commit_reversible_command ();
- trackview->editor().current_session()->set_dirty ();
+ trackview
.editor().current_session()->add_command (new MementoCommand<AutomationList>(*alist.get(), &before, &alist->get_state()));
+ trackview.editor().current_session()->commit_reversible_command ();
+ trackview.editor().current_session()->set_dirty ();
}
void
{
if (!rv.audio_region()->envelope_active()) {
rv.audio_region()->set_envelope_active(true);
- trackview
->session().add_command(new MementoCommand<AudioRegion>(*(rv.audio_region().get()), 0, &rv.audio_region()->get_state()));
+ trackview
.session().add_command(new MementoCommand<AudioRegion>(*(rv.audio_region().get()), 0, &rv.audio_region()->get_state()));
}
AutomationLine::end_drag(cp);
/* really, track and position */
- if (a->get_trackview()->order() == b->get_trackview()->order()) {
+ if (a->get_trackview().order() == b->get_trackview().order()) {
return a->region()->position() < b->region()->position();
} else {
- return a->get_trackview()->order() < b->get_trackview()->order();
+ return a->get_trackview().order() < b->get_trackview().order();
}
}
};
* @return true if any of the selection's regions are on tv.
*/
bool
-RegionSelection::involves (TimeAxisViewPtr tv) const
+RegionSelection::involves (const TimeAxisView& tv) const
{
for (RegionSelection::const_iterator i = begin(); i != end(); ++i) {
- if ((*i)->get_trackview() == tv) {
+ if (&(*i)->get_trackview() == &tv) {
return true;
}
}
#include <list>
#include <sigc++/signal.h>
#include "ardour/types.h"
-#include "shared_ptrs.h"
class RegionView;
class TimeAxisView;
void sort_by_position_and_track ();
bool contains (RegionView*) const;
- bool involves (TimeAxisViewPtr) const;
+ bool involves (const TimeAxisView&) const;
void clear_all();
sigc::signal<void,RegionView*> RegionView::RegionViewGoingAway;
RegionView::RegionView (ArdourCanvas::Group* parent,
- TimeAxisViewPtr tv,
+ TimeAxisView& tv,
boost::shared_ptr<ARDOUR::Region> r,
double spu,
Gdk::Color const & basic_color)
}
RegionView::RegionView (ArdourCanvas::Group* parent,
- TimeAxisViewPtr tv,
+ TimeAxisView& tv,
boost::shared_ptr<ARDOUR::Region> r,
double spu,
Gdk::Color const & basic_color,
if (wfd)
_enable_display = true;
- set_height (trackview->current_height());
+ set_height (trackview.current_height());
_region->StateChanged.connect (mem_fun(*this, &RegionView::region_changed));
points.clear ();
points.push_back (Gnome::Art::Point (offset, 0));
- points.push_back (Gnome::Art::Point (offset, trackview->current_height() - NAME_HIGHLIGHT_SIZE));
+ points.push_back (Gnome::Art::Point (offset, trackview.current_height() - NAME_HIGHLIGHT_SIZE));
sync_line->property_points().set_value (points);
sync_line->show ();
}
void
-RegionView::remove_ghost_in (TimeAxisViewPtr tv)
+RegionView::remove_ghost_in (TimeAxisView& tv)
{
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
- if ((*i)->trackview == tv) {
+ if (&(*i)->trackview == &tv) {
delete *i;
break;
}
/* finish off any old rect, if required */
if (cr && me != new_me) {
- cr->property_x2() = trackview->editor().frame_to_pixel (t - position);
+ cr->property_x2() = trackview.editor().frame_to_pixel (t - position);
}
/* start off any new rect, if required */
if (cr == 0 || me != new_me) {
cr = new ArdourCanvas::SimpleRect (*group);
_coverage_frames.push_back (cr);
- cr->property_x1() = trackview->editor().frame_to_pixel (t - position);
+ cr->property_x1() = trackview.editor().frame_to_pixel (t - position);
cr->property_y1() = 1;
cr->property_y2() = _height + 1;
cr->property_outline_pixels() = 0;
if (cr) {
/* finish off the last rectangle */
- cr->property_x2() = trackview->editor().frame_to_pixel (end - position);
+ cr->property_x2() = trackview.editor().frame_to_pixel (end - position);
}
}
{
public:
RegionView (ArdourCanvas::Group* parent,
- TimeAxisViewPtr time_view,
+ TimeAxisView& time_view,
boost::shared_ptr<ARDOUR::Region> region,
double samples_per_unit,
Gdk::Color const & basic_color);
virtual void region_changed (ARDOUR::Change);
- virtual GhostRegion* add_ghost (TimeAxisViewPtr) = 0;
- void remove_ghost_in (TimeAxisViewPtr);
+ virtual GhostRegion* add_ghost (TimeAxisView&) = 0;
+ void remove_ghost_in (TimeAxisView&);
void remove_ghost (GhostRegion*);
uint32_t get_fill_color ();
* to the TimeAxisViewItem parent class
*/
RegionView (ArdourCanvas::Group *,
- TimeAxisViewPtr,
+ TimeAxisView&,
boost::shared_ptr<ARDOUR::Region>,
double samples_per_unit,
Gdk::Color const & basic_color,
}
for (RegionSelection::iterator i = regions.begin(); i != regions.end(); ++i) {
- (*i)->get_time_axis_view()->show_feature_lines (current_results);
+ (*i)->get_time_axis_view().show_feature_lines (current_results);
}
}
tmp = i;
++tmp;
- (*i)->get_time_axis_view()->hide_feature_lines ();
+ (*i)->get_time_axis_view().hide_feature_lines ();
editor.split_region_at_points ((*i)->region(), current_results, false);
current_results.clear ();
}
-static void hide_time_axis_features (TimeAxisViewPtr tav)
+static void hide_time_axis_features (TimeAxisView& tav)
{
- tav->hide_feature_lines ();
+ tav.hide_feature_lines ();
}
void
RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::shared_ptr<Route> rt, Canvas& canvas)
: AxisView(sess)
, RouteUI(rt, sess)
- , TimeAxisView (sess, ed, TimeAxisViewPtr (), canvas)
+ , TimeAxisView(sess,ed,(TimeAxisView*) 0, canvas)
, parent_canvas (canvas)
, button_table (3, 3)
, route_group_button (_("g"))
if (Keyboard::modifier_state_equals (ev->state, (Keyboard::TertiaryModifier|Keyboard::PrimaryModifier))) {
/* special case: select/deselect all tracks */
- if (_editor.get_selection().selected (shared_from_this ())) {
+ if (_editor.get_selection().selected (this)) {
_editor.get_selection().clear_tracks ();
} else {
_editor.select_all_tracks ();
return;
}
- PublicEditor::TrackViewList* tracks = _editor.get_valid_views (shared_from_this(), _route->route_group());
+ PublicEditor::TrackViewList* tracks = _editor.get_valid_views (this, _route->route_group());
switch (Keyboard::selection_type (ev->state)) {
case Selection::Toggle:
_editor.get_selection().add (*tracks);
} else {
/* extend to the single track */
- _editor.extend_selection_to_track (tracks->front());
+ _editor.extend_selection_to_track (*tracks->front());
}
break;
// LAME fix for hide_button refresh fix
hide_button.set_sensitive(false);
- _editor.hide_track_in_display (shared_from_this ());
+ _editor.hide_track_in_display (*this);
hide_button.set_sensitive(true);
}
playlist_items.push_back (MenuElem (_("Rename"), mem_fun(*this, &RouteTimeAxisView::rename_current_playlist)));
playlist_items.push_back (SeparatorElem());
- boost::weak_ptr<TimeAxisView> v (shared_from_this ());
-
if (!route_group() || !route_group()->is_active()) {
- playlist_items.push_back (MenuElem (_("New"), bind(mem_fun(_editor, &PublicEditor::new_playlists), v)));
- playlist_items.push_back (MenuElem (_("New Copy"), bind(mem_fun(_editor, &PublicEditor::copy_playlists), v)));
+ playlist_items.push_back (MenuElem (_("New"), bind(mem_fun(_editor, &PublicEditor::new_playlists), this)));
+ playlist_items.push_back (MenuElem (_("New Copy"), bind(mem_fun(_editor, &PublicEditor::copy_playlists), this)));
} else {
// Use a label which tells the user what is happening
- playlist_items.push_back (MenuElem (_("New Take"), bind(mem_fun(_editor, &PublicEditor::new_playlists), v)));
- playlist_items.push_back (MenuElem (_("Copy Take"), bind(mem_fun(_editor, &PublicEditor::copy_playlists), v)));
+ playlist_items.push_back (MenuElem (_("New Take"), bind(mem_fun(_editor, &PublicEditor::new_playlists), this)));
+ playlist_items.push_back (MenuElem (_("Copy Take"), bind(mem_fun(_editor, &PublicEditor::copy_playlists), this)));
}
playlist_items.push_back (SeparatorElem());
- playlist_items.push_back (MenuElem (_("Clear Current"), bind(mem_fun(_editor, &PublicEditor::clear_playlists), v)));
+ playlist_items.push_back (MenuElem (_("Clear Current"), bind(mem_fun(_editor, &PublicEditor::clear_playlists), this)));
playlist_items.push_back (SeparatorElem());
playlist_items.push_back (MenuElem(_("Select from all ..."), mem_fun(*this, &RouteTimeAxisView::show_playlist_selector)));
boost::shared_ptr<AutomationControl> control
= boost::dynamic_pointer_cast<AutomationControl>(processor->data().control(what, true));
- pan->view = AutomationTimeAxisView::create (
- _session, _route, processor, control,
- _editor, shared_from_this(), false, parent_canvas, name, state_name
- );
+ pan->view = boost::shared_ptr<AutomationTimeAxisView>(
+ new AutomationTimeAxisView (_session, _route, processor, control,
+ _editor, *this, false, parent_canvas, name, state_name));
pan->view->Hiding.connect (bind (mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), pan, processor));
parent_items.push_back (MenuElem (_("Underlays"), *gs_menu));
for(UnderlayList::iterator it = _underlay_streams.begin(); it != _underlay_streams.end(); ++it) {
- gs_items.push_back(MenuElem(string_compose(_("Remove \"%1\""), (*it)->trackview()->name()),
+ gs_items.push_back(MenuElem(string_compose(_("Remove \"%1\""), (*it)->trackview().name()),
bind(mem_fun(*this, &RouteTimeAxisView::remove_underlay), *it)));
}
}
if (prop) {
PBD::ID id (prop->value());
- RouteTimeAxisViewPtr v = _editor.get_route_view_by_id (id);
+ RouteTimeAxisView* v = _editor.get_route_view_by_id (id);
if (v) {
add_underlay(v->view(), false);
return;
}
- RouteTimeAxisViewPtr other = v->trackview();
+ RouteTimeAxisView& other = v->trackview();
- if (find (_underlay_streams.begin(), _underlay_streams.end(), v) == _underlay_streams.end()) {
- if (find (other->_underlay_mirrors.begin(), other->_underlay_mirrors.end(), this) != other->_underlay_mirrors.end()) {
+ if(find(_underlay_streams.begin(), _underlay_streams.end(), v) == _underlay_streams.end()) {
+ if(find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this) != other._underlay_mirrors.end()) {
fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
/*NOTREACHED*/
}
_underlay_streams.push_back(v);
- other->_underlay_mirrors.push_back(this);
+ other._underlay_mirrors.push_back(this);
v->foreach_regionview(mem_fun(*this, &RouteTimeAxisView::add_ghost));
XMLNode* node = underlay_xml_node->add_child("Underlay");
XMLProperty* prop = node->add_property("id");
- prop->set_value(v->trackview()->route()->id().to_s());
+ prop->set_value(v->trackview().route()->id().to_s());
}
}
}
}
UnderlayList::iterator it = find(_underlay_streams.begin(), _underlay_streams.end(), v);
- RouteTimeAxisViewPtr other = v->trackview();
+ RouteTimeAxisView& other = v->trackview();
if(it != _underlay_streams.end()) {
- UnderlayMirrorList::iterator gm = find (other->_underlay_mirrors.begin(), other->_underlay_mirrors.end(), this);
+ UnderlayMirrorList::iterator gm = find(other._underlay_mirrors.begin(), other._underlay_mirrors.end(), this);
- if (gm == other->_underlay_mirrors.end()) {
+ if(gm == other._underlay_mirrors.end()) {
fatal << _("programming error: underlay reference pointer pairs are inconsistent!") << endmsg;
/*NOTREACHED*/
}
v->foreach_regionview(mem_fun(*this, &RouteTimeAxisView::remove_ghost));
_underlay_streams.erase(it);
- other->_underlay_mirrors.erase(gm);
+ other._underlay_mirrors.erase(gm);
- if (underlay_xml_node) {
- underlay_xml_node->remove_nodes_and_delete("id", v->trackview()->route()->id().to_s());
+ if(underlay_xml_node) {
+ underlay_xml_node->remove_nodes_and_delete("id", v->trackview().route()->id().to_s());
}
}
}
void
Selection::clear_time ()
{
- time.track.reset ();
+ time.track = 0;
time.group = 0;
time.clear();
}
void
-Selection::toggle (const list<TimeAxisViewPtr>& track_list)
+Selection::toggle (const list<TimeAxisView*>& track_list)
{
- for (list<TimeAxisViewPtr>::const_iterator i = track_list.begin(); i != track_list.end(); ++i) {
+ for (list<TimeAxisView*>::const_iterator i = track_list.begin(); i != track_list.end(); ++i) {
toggle ( (*i) );
}
}
void
-Selection::toggle (TimeAxisViewPtr track)
+Selection::toggle (TimeAxisView* track)
{
TrackSelection::iterator i;
if ((i = find (tracks.begin(), tracks.end(), track)) == tracks.end()) {
- void (Selection::*pmf)(boost::weak_ptr<TimeAxisView>) = &Selection::remove;
- boost::weak_ptr<TimeAxisView> w (track);
- track->GoingAway.connect (sigc::bind (mem_fun (*this, pmf), w));
+ void (Selection::*pmf)(TimeAxisView*) = &Selection::remove;
+ track->GoingAway.connect (sigc::bind (mem_fun (*this, pmf), track));
tracks.push_back (track);
} else {
tracks.erase (i);
}
void
-Selection::add (const list<TimeAxisViewPtr>& track_list)
+Selection::add (const list<TimeAxisView*>& track_list)
{
- list<TimeAxisViewPtr> added = tracks.add (track_list);
+ list<TimeAxisView*> added = tracks.add (track_list);
- for (list<TimeAxisViewPtr>::const_iterator i = added.begin(); i != added.end(); ++i) {
- void (Selection::*pmf)(boost::weak_ptr<TimeAxisView>) = &Selection::remove;
- boost::weak_ptr<TimeAxisView> w (*i);
- (*i)->GoingAway.connect (sigc::bind (mem_fun (*this, pmf), w));
+ for (list<TimeAxisView*>::const_iterator i = added.begin(); i != added.end(); ++i) {
+ void (Selection::*pmf)(TimeAxisView*) = &Selection::remove;
+ (*i)->GoingAway.connect (sigc::bind (mem_fun (*this, pmf), (*i)));
}
if (!added.empty()) {
}
void
-Selection::add (TimeAxisViewPtr track)
+Selection::add (TimeAxisView* track)
{
if (find (tracks.begin(), tracks.end(), track) == tracks.end()) {
- void (Selection::*pmf)(TimeAxisViewPtr) = &Selection::remove;
+ void (Selection::*pmf)(TimeAxisView*) = &Selection::remove;
track->GoingAway.connect (sigc::bind (mem_fun (*this, pmf), track));
tracks.push_back (track);
TracksChanged();
if (find (regions.begin(), regions.end(), (*i)) == regions.end()) {
changed = regions.add ((*i));
if (Config->get_link_region_and_track_selection() && changed) {
- add ((*i)->get_trackview());
+ add (&(*i)->get_trackview());
}
}
}
if (find (regions.begin(), regions.end(), (*i)) == regions.end()) {
changed = regions.add ((*i));
if (Config->get_link_region_and_track_selection() && changed) {
- add ((*i)->get_trackview());
+ add (&(*i)->get_trackview());
}
}
}
if (find (regions.begin(), regions.end(), r) == regions.end()) {
regions.add (r);
if (Config->get_link_region_and_track_selection()) {
- add (r->get_trackview());
+ add (&r->get_trackview());
}
RegionsChanged ();
}
}
void
-Selection::remove (TimeAxisViewPtr track)
+Selection::remove (TimeAxisView* track)
{
- list<TimeAxisViewPtr>::iterator i;
+ list<TimeAxisView*>::iterator i;
if ((i = find (tracks.begin(), tracks.end(), track)) != tracks.end()) {
tracks.erase (i);
TracksChanged();
}
void
-Selection::remove (boost::weak_ptr<TimeAxisView> w)
-{
- boost::shared_ptr<TimeAxisView> t = w.lock ();
- if (t) {
- remove (t);
- }
-}
-
-void
-Selection::remove (const list<TimeAxisViewPtr>& track_list)
+Selection::remove (const list<TimeAxisView*>& track_list)
{
bool changed = false;
- for (list<TimeAxisViewPtr>::const_iterator i = track_list.begin(); i != track_list.end(); ++i) {
+ for (list<TimeAxisView*>::const_iterator i = track_list.begin(); i != track_list.end(); ++i) {
- list<TimeAxisViewPtr>::iterator x;
+ list<TimeAxisView*>::iterator x;
if ((x = find (tracks.begin(), tracks.end(), (*i))) != tracks.end()) {
tracks.erase (x);
}
if (Config->get_link_region_and_track_selection() && !regions.involves (r->get_trackview())) {
- remove (r->get_trackview());
+ remove (&r->get_trackview());
}
}
}
void
-Selection::set (TimeAxisViewPtr track)
+Selection::set (TimeAxisView* track)
{
clear_tracks ();
add (track);
}
void
-Selection::set (const list<TimeAxisViewPtr>& track_list)
+Selection::set (const list<TimeAxisView*>& track_list)
{
clear_tracks ();
add (track_list);
}
long
-Selection::set (TimeAxisViewPtr track, nframes_t start, nframes_t end)
+Selection::set (TimeAxisView* track, nframes_t start, nframes_t end)
{
if ((start == 0 && end == 0) || end < start) {
return 0;
time.track = track;
time.group = track->route_group();
} else {
- time.track.reset ();
+ time.track = 0;
time.group = 0;
}
}
bool
-Selection::selected (TimeAxisViewPtr tv)
+Selection::selected (TimeAxisView* tv)
{
return find (tracks.begin(), tracks.end(), tv) != tracks.end();
}
void dump_region_layers();
- bool selected (TimeAxisViewPtr);
+ bool selected (TimeAxisView*);
bool selected (RegionView*);
bool selected (Marker*);
void add (std::list<Selectable*>&);
void toggle (std::list<Selectable*>&);
- void set (TimeAxisViewPtr);
- void set (const std::list<TimeAxisViewPtr>&);
+ void set (TimeAxisView*);
+ void set (const std::list<TimeAxisView*>&);
void set (RegionView*, bool also_clear_tracks = true);
void set (std::vector<RegionView*>&);
- long set (TimeAxisViewPtr, nframes_t, nframes_t);
+ long set (TimeAxisView*, nframes_t, nframes_t);
void set (boost::shared_ptr<Evoral::ControlList>);
void set (boost::shared_ptr<ARDOUR::Playlist>);
void set (const std::list<boost::shared_ptr<ARDOUR::Playlist> >&);
void set (Marker*);
void set (const RegionSelection&);
- void toggle (TimeAxisViewPtr);
- void toggle (const std::list<TimeAxisViewPtr>&);
+ void toggle (TimeAxisView*);
+ void toggle (const std::list<TimeAxisView*>&);
void toggle (RegionView*);
void toggle (std::vector<RegionView*>&);
long toggle (nframes_t, nframes_t);
void toggle (const std::vector<AutomationSelectable*>&);
void toggle (Marker*);
- void add (TimeAxisViewPtr);
- void add (const std::list<TimeAxisViewPtr>&);
+ void add (TimeAxisView*);
+ void add (const std::list<TimeAxisView*>&);
void add (RegionView*);
void add (std::vector<RegionView*>&);
long add (nframes_t, nframes_t);
void add (const std::list<Marker*>&);
void add (const RegionSelection&);
- void remove (TimeAxisViewPtr);
- void remove (const std::list<TimeAxisViewPtr>&);
- void remove (boost::weak_ptr<TimeAxisView>);
+ void remove (TimeAxisView*);
+ void remove (const std::list<TimeAxisView*>&);
void remove (RegionView*);
void remove (uint32_t selection_id);
void remove (nframes_t, nframes_t);
+++ /dev/null
-#include <boost/shared_ptr.hpp>
-
-class TimeAxisView;
-
-typedef boost::shared_ptr<TimeAxisView> TimeAxisViewPtr;
-typedef boost::shared_ptr<const TimeAxisView> TimeAxisViewConstPtr;
-
-class RouteTimeAxisView;
-
-typedef boost::shared_ptr<RouteTimeAxisView> RouteTimeAxisViewPtr;
-typedef boost::shared_ptr<const RouteTimeAxisView> RouteTimeAxisViewConstPtr;
-
-class AutomationTimeAxisView;
-
-typedef boost::shared_ptr<AutomationTimeAxisView> AutomationTimeAxisViewPtr;
-typedef boost::shared_ptr<const AutomationTimeAxisView> AutomationTimeAxisViewConstPtr;
-
-class AudioTimeAxisView;
-
-typedef boost::shared_ptr<AudioTimeAxisView> AudioTimeAxisViewPtr;
-
-class MidiTimeAxisView;
-
-typedef boost::shared_ptr<MidiTimeAxisView> MidiTimeAxisViewPtr;
-typedef boost::shared_ptr<const MidiTimeAxisView> MidiTimeAxisViewConstPtr;
using namespace PBD;
using namespace Editing;
-StreamView::StreamView (RouteTimeAxisViewPtr tv, ArdourCanvas::Group* group)
+StreamView::StreamView (RouteTimeAxisView& tv, ArdourCanvas::Group* group)
: _trackview (tv)
, owns_canvas_group(group == 0)
- , _background_group (new ArdourCanvas::Group (*_trackview->canvas_background()))
- , canvas_group(group ? group : new ArdourCanvas::Group(*_trackview->canvas_display()))
- , _samples_per_unit (_trackview->editor().get_current_zoom ())
+ , _background_group (new ArdourCanvas::Group (*_trackview.canvas_background()))
+ , canvas_group(group ? group : new ArdourCanvas::Group(*_trackview.canvas_display()))
+ , _samples_per_unit (_trackview.editor().get_current_zoom ())
, rec_updating(false)
, rec_active(false)
- , use_rec_regions (tv->editor().show_waveforms_recording ())
- , region_color(_trackview->color())
+ , use_rec_regions (tv.editor().show_waveforms_recording ())
+ , region_color(_trackview.color())
, stream_base_color(0xFFFFFFFF)
, _layers (1)
, _layer_display (Overlaid)
- , height(tv->height)
+ , height(tv.height)
, last_rec_data_frame(0)
{
/* set_position() will position the group */
canvas_rect = new ArdourCanvas::SimpleRect (*_background_group);
canvas_rect->property_x1() = 0.0;
canvas_rect->property_y1() = 0.0;
- canvas_rect->property_x2() = _trackview->editor().get_physical_screen_width ();
- canvas_rect->property_y2() = (double) tv->current_height();
+ canvas_rect->property_x2() = _trackview.editor().get_physical_screen_width ();
+ canvas_rect->property_y2() = (double) tv.current_height();
canvas_rect->raise(1); // raise above tempo lines
canvas_rect->property_outline_what() = (guint32) (0x2|0x8); // outline RHS and bottom
- boost::weak_ptr<TimeAxisView> w (_trackview);
canvas_rect->signal_event().connect (bind (
- mem_fun (_trackview->editor(), &PublicEditor::canvas_stream_view_event),
- canvas_rect, w));
+ mem_fun (_trackview.editor(), &PublicEditor::canvas_stream_view_event),
+ canvas_rect, &_trackview));
- if (_trackview->is_track()) {
- _trackview->track()->DiskstreamChanged.connect (
+ if (_trackview.is_track()) {
+ _trackview.track()->DiskstreamChanged.connect (
mem_fun (*this, &StreamView::diskstream_changed));
- _trackview->session().TransportStateChange.connect (
+ _trackview.session().TransportStateChange.connect (
mem_fun (*this, &StreamView::transport_changed));
- _trackview->session().TransportLooped.connect (
+ _trackview.session().TransportLooped.connect (
mem_fun (*this, &StreamView::transport_looped));
- _trackview->get_diskstream()->RecordEnableChanged.connect (
+ _trackview.get_diskstream()->RecordEnableChanged.connect (
mem_fun (*this, &StreamView::rec_enable_changed));
- _trackview->session().RecordStateChanged.connect (
+ _trackview.session().RecordStateChanged.connect (
mem_fun (*this, &StreamView::sess_rec_enable_changed));
}
void
StreamView::attach ()
{
- if (_trackview->is_track()) {
- display_diskstream (_trackview->get_diskstream());
+ if (_trackview.is_track()) {
+ display_diskstream (_trackview.get_diskstream());
}
}
for (vector<RecBoxInfo>::iterator xi = rec_rects.begin(); xi != rec_rects.end(); ++xi) {
RecBoxInfo &recbox = (*xi);
- gdouble xstart = _trackview->editor().frame_to_pixel (recbox.start);
- gdouble xend = _trackview->editor().frame_to_pixel (recbox.start + recbox.length);
+ gdouble xstart = _trackview.editor().frame_to_pixel (recbox.start);
+ gdouble xend = _trackview.editor().frame_to_pixel (recbox.start + recbox.length);
recbox.rectangle->property_x1() = xstart;
recbox.rectangle->property_x2() = xend;
{
boost::shared_ptr<Track> t;
- if ((t = _trackview->track()) != 0) {
+ if ((t = _trackview.track()) != 0) {
Gtkmm2ext::UI::instance()->call_slot (bind (
mem_fun (*this, &StreamView::display_diskstream),
t->diskstream()));
if (rec_active && rec_rects.size() > 0) {
/* only update the last box */
RecBoxInfo & rect = rec_rects.back();
- nframes_t at = _trackview->get_diskstream()->current_capture_end();
+ nframes_t at = _trackview.get_diskstream()->current_capture_end();
double xstart;
double xend;
- switch (_trackview->track()->mode()) {
+ switch (_trackview.track()->mode()) {
case NonLayered:
case Normal:
rect.length = at - rect.start;
- xstart = _trackview->editor().frame_to_pixel (rect.start);
- xend = _trackview->editor().frame_to_pixel (at);
+ xstart = _trackview.editor().frame_to_pixel (rect.start);
+ xend = _trackview.editor().frame_to_pixel (at);
break;
case Destructive:
rect.length = 2;
- xstart = _trackview->editor().frame_to_pixel (_trackview->get_diskstream()->current_capture_start());
- xend = _trackview->editor().frame_to_pixel (at);
+ xstart = _trackview.editor().frame_to_pixel (_trackview.get_diskstream()->current_capture_start());
+ xend = _trackview.editor().frame_to_pixel (at);
break;
}
#include "enums.h"
#include "simplerect.h"
#include "canvas.h"
-#include "shared_ptrs.h"
namespace Gdk {
class Color;
public:
virtual ~StreamView ();
- RouteTimeAxisViewPtr trackview() { return _trackview; }
- const RouteTimeAxisViewPtr trackview() const { return _trackview; }
+ RouteTimeAxisView& trackview() { return _trackview; }
+ const RouteTimeAxisView& trackview() const { return _trackview; }
void attach ();
sigc::signal<void> HeightChanged;
protected:
- StreamView (RouteTimeAxisViewPtr, ArdourCanvas::Group* group = NULL);
+ StreamView (RouteTimeAxisView&, ArdourCanvas::Group* group = NULL);
void transport_changed();
void transport_looped();
virtual void color_handler () = 0;
- RouteTimeAxisViewPtr _trackview;
+ RouteTimeAxisView& _trackview;
bool owns_canvas_group;
ArdourCanvas::Group* _background_group;
ArdourCanvas::Group* canvas_group;
TimeAxisViewItem::HideFrameRight |
TimeAxisViewItem::FullWidthNameHighlight);
-TapeAudioRegionView::TapeAudioRegionView (ArdourCanvas::Group *parent, RouteTimeAxisViewPtr tv,
+TapeAudioRegionView::TapeAudioRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView &tv,
boost::shared_ptr<AudioRegion> r,
double spu,
Gdk::Color const & basic_color)
{
public:
TapeAudioRegionView (ArdourCanvas::Group *,
- RouteTimeAxisViewPtr,
+ RouteTimeAxisView&,
boost::shared_ptr<ARDOUR::AudioRegion>,
double initial_samples_per_unit,
Gdk::Color const & base_color);
bool TimeAxisView::need_size_info = true;
int const TimeAxisView::_max_order = 512;
-TimeAxisView::TimeAxisView (ARDOUR::Session& sess, PublicEditor& ed, TimeAxisViewPtr rent, Canvas& canvas)
+TimeAxisView::TimeAxisView (ARDOUR::Session& sess, PublicEditor& ed, TimeAxisView* rent, Canvas& canvas)
: AxisView (sess),
controls_table (2, 8),
_y_position (0),
TimeAxisView::selection_click (GdkEventButton* ev)
{
Selection::Operation op = Keyboard::selection_type (ev->state);
- _editor.set_selected_track (shared_from_this (), op, false);
+ _editor.set_selected_track (*this, op, false);
}
void
/* if its hidden, it cannot be selected */
- _editor.get_selection().remove (shared_from_this ());
+ _editor.get_selection().remove (this);
Hiding ();
}
case GDK_ISO_Left_Tab:
case GDK_Tab:
name_entry_changed ();
- allviews = _editor.get_valid_views (TimeAxisViewPtr ());
+ allviews = _editor.get_valid_views (0);
if (allviews != 0) {
- i = find (allviews->begin(), allviews->end(), shared_from_this ());
+ i = find (allviews->begin(), allviews->end(), this);
if (ev->keyval == GDK_Tab) {
if (i != allviews->end()) {
do {
{
Selection& s (_editor.get_selection ());
- if (!s.selected (shared_from_this ())) {
- _editor.set_selected_track (shared_from_this (), Selection::Set);
+ if (!s.selected (this)) {
+ _editor.set_selected_track (*this, Selection::Set);
}
}
return rect;
}
+struct null_deleter { void operator()(void const *) const {} };
+
bool
-TimeAxisView::is_child (TimeAxisViewPtr tav)
+TimeAxisView::is_child (TimeAxisView* tav)
{
- return find (children.begin(), children.end(), tav) != children.end();
+ return find (children.begin(), children.end(), boost::shared_ptr<TimeAxisView>(tav, null_deleter())) != children.end();
}
void
void
TimeAxisView::add_ghost (RegionView* rv)
{
- GhostRegion* gr = rv->add_ghost (shared_from_this ());
+ GhostRegion* gr = rv->add_ghost (*this);
if(gr) {
ghosts.push_back(gr);
}
void
-TimeAxisView::remove_ghost (RegionView* rv)
-{
- rv->remove_ghost_in (shared_from_this ());
+TimeAxisView::remove_ghost (RegionView* rv) {
+ rv->remove_ghost_in (*this);
}
void
}
void
-TimeAxisView::set_parent (TimeAxisViewPtr p)
+TimeAxisView::set_parent (TimeAxisView& p)
{
- parent = p;
+ parent = &p;
}
bool
return _has_state;
}
-TimeAxisViewPtr
+TimeAxisView*
TimeAxisView::get_parent_with_state ()
{
- if (parent == 0 || parent->has_state()) {
- return parent;
+ if (parent == 0) {
+ return 0;
}
+ if (parent->has_state()) {
+ return parent;
+ }
+
return parent->get_parent_with_state ();
}
* Layer index is the layer number if the TimeAxisView is valid and is in stacked
* region display mode, otherwise 0.
*/
-std::pair<TimeAxisViewPtr, layer_t>
+std::pair<TimeAxisView*, layer_t>
TimeAxisView::covers_y_position (double y)
{
if (hidden()) {
- return std::make_pair (TimeAxisViewPtr (), 0);
+ return std::make_pair ( (TimeAxisView *) 0, 0);
}
if (_y_position <= y && y < (_y_position + height)) {
}
}
- return std::make_pair (shared_from_this (), l);
+ return std::make_pair (this, l);
}
for (Children::const_iterator i = children.begin(); i != children.end(); ++i) {
- std::pair<TimeAxisViewPtr, int> const r = (*i)->covers_y_position (y);
+ std::pair<TimeAxisView*, int> const r = (*i)->covers_y_position (y);
if (r.first) {
return r;
}
}
- return std::make_pair (TimeAxisViewPtr (), 0);
+ return std::make_pair ( (TimeAxisView *) 0, 0);
}
void
}
int32_t const delta = (int32_t) floor (ev->y_root - _resize_drag_start);
- _editor.add_to_idle_resize (shared_from_this (), delta);
+ _editor.add_to_idle_resize (this, delta);
_resize_drag_start = ev->y_root;
return true;
return true;
}
-TimeAxisViewPtr
-TimeAxisView::find_time_axis (TimeAxisView* v)
-{
- Children::iterator i = children.begin ();
- while (i != children.end() && i->get() != v) {
- ++i;
- }
-
- if (i == children.end()) {
- return TimeAxisViewPtr ();
- }
-
- return *i;
-}
#include <vector>
#include <list>
-#include <boost/enable_shared_from_this.hpp>
-
#include <gtkmm/box.h>
#include <gtkmm/frame.h>
#include <gtkmm/drawingarea.h>
#include "enums.h"
#include "editing.h"
#include "canvas.h"
-#include "shared_ptrs.h"
namespace ARDOUR {
class Session;
* This class provides the basic LHS controls and display methods. This should be
* extended to create functional time-axis based views.
*/
-class TimeAxisView : public virtual AxisView, public PBD::Stateful, public boost::enable_shared_from_this<TimeAxisView>
+class TimeAxisView : public virtual AxisView, public PBD::Stateful
{
private:
enum NamePackingBits {
static uint32_t hSmaller;
static uint32_t hSmall;
- TimeAxisView(ARDOUR::Session& sess, PublicEditor& ed, TimeAxisViewPtr parent, ArdourCanvas::Canvas& canvas);
+ TimeAxisView(ARDOUR::Session& sess, PublicEditor& ed, TimeAxisView* parent, ArdourCanvas::Canvas& canvas);
virtual ~TimeAxisView ();
XMLNode& get_state ();
virtual void set_height (uint32_t h);
void reset_height();
- std::pair<TimeAxisViewPtr, ARDOUR::layer_t> covers_y_position (double);
+ std::pair<TimeAxisView*, ARDOUR::layer_t> covers_y_position (double);
/**
* Steps through the defined heights for this TrackView.
expensive data loading/redisplay code in here. */
virtual void first_idle () {}
- TimeAxisViewPtr get_parent () { return parent; }
- void set_parent (TimeAxisViewPtr p);
+ TimeAxisView* get_parent () { return parent; }
+ void set_parent (TimeAxisView& p);
bool has_state () const;
/* call this on the parent */
virtual LayerDisplay layer_display () const { return Overlaid; }
virtual StreamView* view () const { return 0; }
-
- TimeAxisViewPtr find_time_axis (TimeAxisView *);
typedef std::vector<boost::shared_ptr<TimeAxisView> > Children;
Gtk::Label name_label;
- TimeAxisViewPtr parent;
+ TimeAxisView* parent;
/** Find the parent with state */
- TimeAxisViewPtr get_parent_with_state();
+ TimeAxisView* get_parent_with_state();
Children children;
- bool is_child (TimeAxisViewPtr);
+ bool is_child (TimeAxisView*);
- void remove_child (TimeAxisViewPtr);
- void add_child (TimeAxisViewPtr);
+ void remove_child (boost::shared_ptr<TimeAxisView>);
+ void add_child (boost::shared_ptr<TimeAxisView>);
/* selection display */
* @param start the start point of this item
* @param duration the duration of this item
*/
-TimeAxisViewItem::TimeAxisViewItem(const string & it_name, ArdourCanvas::Group& parent, TimeAxisViewPtr tv, double spu, Gdk::Color const & base_color,
+TimeAxisViewItem::TimeAxisViewItem(const string & it_name, ArdourCanvas::Group& parent, TimeAxisView& tv, double spu, Gdk::Color const & base_color,
nframes_t start, nframes_t duration, bool recording,
Visibility vis)
: trackview (tv), _recregion(recording)
warning << "Time Axis Item Duration == 0" << endl ;
}
- vestigial_frame = new ArdourCanvas::SimpleRect (*group, 0.0, 1.0, 2.0, trackview->current_height());
+ vestigial_frame = new ArdourCanvas::SimpleRect (*group, 0.0, 1.0, 2.0, trackview.current_height());
vestigial_frame->hide ();
vestigial_frame->property_outline_what() = 0xF;
vestigial_frame->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_VestigialFrame.get();
vestigial_frame->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_VestigialFrame.get();
if (visibility & ShowFrame) {
- frame = new ArdourCanvas::SimpleRect (*group, 0.0, 1.0, trackview->editor().frame_to_pixel(duration), trackview->current_height());
+ frame = new ArdourCanvas::SimpleRect (*group, 0.0, 1.0, trackview.editor().frame_to_pixel(duration), trackview.current_height());
frame->property_outline_pixels() = 1;
frame->property_outline_what() = 0xF;
frame->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_TimeAxisFrame.get();
if (visibility & ShowNameHighlight) {
if (visibility & FullWidthNameHighlight) {
- name_highlight = new ArdourCanvas::SimpleRect (*group, 0.0, trackview->editor().frame_to_pixel(item_duration), trackview->current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE, trackview->current_height() - 1);
+ name_highlight = new ArdourCanvas::SimpleRect (*group, 0.0, trackview.editor().frame_to_pixel(item_duration), trackview.current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE, trackview.current_height() - 1);
} else {
- name_highlight = new ArdourCanvas::SimpleRect (*group, 1.0, trackview->editor().frame_to_pixel(item_duration) - 1, trackview->current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE, trackview->current_height() - 1);
+ name_highlight = new ArdourCanvas::SimpleRect (*group, 1.0, trackview.editor().frame_to_pixel(item_duration) - 1, trackview.current_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE, trackview.current_height() - 1);
}
name_highlight->set_data ("timeaxisviewitem", this);
if (visibility & ShowNameText) {
name_pixbuf = new ArdourCanvas::Pixbuf(*group);
name_pixbuf->property_x() = NAME_X_OFFSET;
- name_pixbuf->property_y() = trackview->current_height() - 1.0 - NAME_Y_OFFSET;
+ name_pixbuf->property_y() = trackview.current_height() - 1.0 - NAME_Y_OFFSET;
} else {
name_pixbuf = 0;
frame_handle_start = new ArdourCanvas::SimpleRect (*group, 0.0, TimeAxisViewItem::GRAB_HANDLE_LENGTH, 1.0, TimeAxisViewItem::GRAB_HANDLE_LENGTH+1);
frame_handle_start->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_FrameHandle.get();
- frame_handle_end = new ArdourCanvas::SimpleRect (*group, trackview->editor().frame_to_pixel(get_duration()) - TimeAxisViewItem::GRAB_HANDLE_LENGTH, trackview->editor().frame_to_pixel(get_duration()), 1.0, TimeAxisViewItem::GRAB_HANDLE_LENGTH + 1);
+ frame_handle_end = new ArdourCanvas::SimpleRect (*group, trackview.editor().frame_to_pixel(get_duration()) - TimeAxisViewItem::GRAB_HANDLE_LENGTH, trackview.editor().frame_to_pixel(get_duration()), 1.0, TimeAxisViewItem::GRAB_HANDLE_LENGTH + 1);
frame_handle_end->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_FrameHandle.get();
} else {
item_duration = dur;
- reset_width_dependent_items (trackview->editor().frame_to_pixel (dur));
+ reset_width_dependent_items (trackview.editor().frame_to_pixel (dur));
DurationChanged (dur, src) ; /* EMIT_SIGNAL */
return true;
*
* @return the timeAxisView that this item is placed upon
*/
-TimeAxisViewPtr
-TimeAxisViewItem::get_time_axis_view ()
+TimeAxisView&
+TimeAxisViewItem::get_time_axis_view()
{
return trackview;
}
double font_size;
font_size = NAME_FONT->get_size() / Pango::SCALE;
- it_width = trackview->editor().frame_to_pixel(item_duration);
+ it_width = trackview.editor().frame_to_pixel(item_duration);
pb_width = new_name.length() * font_size;
if (pb_width > it_width - NAME_X_OFFSET) {
#include "selectable.h"
#include "simplerect.h"
#include "canvas.h"
-#include "shared_ptrs.h"
class TimeAxisView;
*
* @return the timeAxisView that this item is placed upon
*/
- TimeAxisViewPtr get_time_axis_view() ;
+ TimeAxisView& get_time_axis_view() ;
//---------------------------------------------------------------------------------------//
// ui methods & data
/**
* Returns the time axis that this item is upon
*/
- TimeAxisViewPtr get_trackview() const { return trackview; }
+ TimeAxisView& get_trackview() const { return trackview; }
/**
* Sets the samples per unit of this item.
* @param start the start point of this item
* @param duration the duration of this item
*/
- TimeAxisViewItem(const std::string & it_name, ArdourCanvas::Group& parent, TimeAxisViewPtr tv, double spu, Gdk::Color const & base_color,
+ TimeAxisViewItem(const std::string & it_name, ArdourCanvas::Group& parent, TimeAxisView& tv, double spu, Gdk::Color const & base_color,
nframes_t start, nframes_t duration, bool recording = false, Visibility v = Visibility (0));
TimeAxisViewItem (const TimeAxisViewItem& other);
static gint idle_remove_this_item(TimeAxisViewItem* item, void* src) ;
/** The time axis that this item is upon */
- TimeAxisViewPtr trackview ;
+ TimeAxisView& trackview ;
/** indicates whether this item is locked to its current position */
bool position_locked ;
#include <list>
#include "ardour/types.h"
-#include "shared_ptrs.h"
namespace ARDOUR {
class RouteGroup;
the group.
*/
- TimeAxisViewPtr track;
+ TimeAxisView* track;
ARDOUR::RouteGroup* group;
ARDOUR::AudioRange& operator[](uint32_t);
using namespace std;
-TrackSelection::TrackSelection (list<TimeAxisViewPtr> const &t)
- : list<TimeAxisViewPtr> (t)
+TrackSelection::TrackSelection (list<TimeAxisView*> const &t)
+ : list<TimeAxisView*> (t)
{
}
-list<TimeAxisViewPtr>
-TrackSelection::add (list<TimeAxisViewPtr> const & t)
+list<TimeAxisView*>
+TrackSelection::add (list<TimeAxisView*> const & t)
{
- list<TimeAxisViewPtr> added;
+ list<TimeAxisView*> added;
for (TrackSelection::const_iterator i = t.begin(); i != t.end(); ++i) {
if (!contains (*i)) {
}
bool
-TrackSelection::contains (TimeAxisViewConstPtr t) const
+TrackSelection::contains (TimeAxisView const * t) const
{
return find (begin(), end(), t) != end();
}
#define __ardour_gtk_track_selection_h__
#include <list>
-#include "shared_ptrs.h"
class TimeAxisView;
-class TrackSelection : public std::list<TimeAxisViewPtr>
+class TrackSelection : public std::list<TimeAxisView*>
{
public:
TrackSelection () {}
- TrackSelection (std::list<TimeAxisViewPtr> const &);
- std::list<TimeAxisViewPtr> add (std::list<TimeAxisViewPtr> const &);
- bool contains (TimeAxisViewConstPtr) const;
+ TrackSelection (std::list<TimeAxisView*> const &);
+ std::list<TimeAxisView*> add (std::list<TimeAxisView*> const &);
+ bool contains (TimeAxisView const *) const;
};
#endif /* __ardour_gtk_track_selection_h__ */
projects / ardour.git / commitdiff