_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
}
void
-RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred)
+RegionMoveDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
{
- bool nocommit = true;
vector<RegionView*> copies;
boost::shared_ptr<Diskstream> ds;
boost::shared_ptr<Playlist> from_playlist;
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 */
- goto out;
+ return;
}
- nocommit = false;
-
if (Config->get_edit_mode() == Splice && !_editor->pre_drag_region_selection.empty()) {
_editor->selection->set (_editor->pre_drag_region_selection);
_editor->pre_drag_region_selection.clear ();
}
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;
/* get the playlist where this drag started. we can't use rv->region()->playlist()
because we may have copied the region and it has not been attached to a playlist.
*/
+
+ source_tv = dynamic_cast<RouteTimeAxisView*> (&rv->get_time_axis_view());
+ ds = source_tv->get_diskstream();
+ from_playlist = ds->playlist();
- assert ((source_tv = boost::dynamic_pointer_cast<RouteTimeAxisView> (rv->get_time_axis_view())));
- assert ((ds = source_tv->get_diskstream()));
- assert ((from_playlist = ds->playlist()));
+ assert (source_tv);
+ assert (ds);
+ assert (from_playlist);
/* moved to a different audio track, without copying */
}
out:
- if (!nocommit) {
- for (set<boost::shared_ptr<Playlist> >::iterator p = modified_playlists.begin(); p != modified_playlists.end(); ++p) {
- _editor->session->add_command (new MementoCommand<Playlist>(*(*p), 0, &(*p)->get_state()));
- }
-
- _editor->commit_reversible_command ();
+ for (set<boost::shared_ptr<Playlist> >::iterator p = modified_playlists.begin(); p != modified_playlists.end(); ++p) {
+ _editor->session->add_command (new MementoCommand<Playlist>(*(*p), 0, &(*p)->get_state()));
}
+
+ _editor->commit_reversible_command ();
for (vector<RegionView*>::iterator x = copies.begin(); x != copies.end(); ++x) {
delete *x;
}
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;
void
-RegionInsertDrag::finished (GdkEvent* event, bool movement_occurred)
+RegionInsertDrag::finished (GdkEvent* /*event*/, bool /*movement_occurred*/)
{
_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)
+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;
}
void
-RegionSpliceDrag::finished (GdkEvent* event, bool)
+RegionSpliceDrag::finished (GdkEvent* /*event*/, bool)
{
}
-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::motion (GdkEvent* event, bool first_move)
+RegionCreateDrag::motion (GdkEvent* /*event*/, bool first_move)
{
if (first_move) {
// TODO: create region-create-drag region view here
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;
void
-RegionGainDrag::motion (GdkEvent* event, bool)
+RegionGainDrag::motion (GdkEvent* /*event*/, bool)
{
}
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()) {
}
}
- _pointer_frame_offset = _grab_frame - _cursor->current_frame;
-
_editor->show_verbose_time_cursor (_cursor->current_frame, 10);
}
void
-ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
+ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
{
Drag::start_grab (event, _editor->fader_cursor);
}
void
-LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
+LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
{
_line = reinterpret_cast<AutomationLine*> (_item->get_data ("line"));
assert (_line);
Selection::Operation op = Keyboard::selection_type (event->button.state);
- bool commit;
+ bool committed;
_editor->begin_reversible_command (_("rubberband selection"));
if (_grab_frame < _last_pointer_frame) {
- commit = _editor->select_all_within (_grab_frame, _last_pointer_frame, y1, y2, _editor->track_views, op);
+ committed = _editor->select_all_within (_grab_frame, _last_pointer_frame, y1, y2, _editor->track_views, op);
} else {
- commit = _editor->select_all_within (_last_pointer_frame, _grab_frame, y1, y2, _editor->track_views, op);
+ committed = _editor->select_all_within (_last_pointer_frame, _grab_frame, y1, y2, _editor->track_views, op);
}
- if (commit) {
+ if (!committed) {
_editor->commit_reversible_command ();
}
}
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)
+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;
}
void
-ScrubDrag::motion (GdkEvent* event, bool)
+ScrubDrag::motion (GdkEvent* /*event*/, bool)
{
_editor->scrub ();
}
void
-ScrubDrag::finished (GdkEvent* event, bool movement_occurred)
+ScrubDrag::finished (GdkEvent* /*event*/, bool movement_occurred)
{
if (movement_occurred && _editor->session) {
/* make sure we stop */
if (movement_occurred) {
motion (event, false);
+ _drag_rect->hide();
switch (_operation) {
case CreateRangeMarker:
XMLNode &after = _editor->session->locations()->get_state();
_editor->session->add_command(new MementoCommand<Locations>(*(_editor->session->locations()), &before, &after));
_editor->commit_reversible_command ();
-
- _drag_rect->hide();
break;
}
case CreateTransportMarker:
// popup menu to pick loop or punch
_editor->new_transport_marker_context_menu (&event->button, _item);
-
break;
}
} else {
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:
projects / ardour.git / blobdiff