#include "vca_time_axis.h"
#include "verbose_cursor.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
initialize_canvas ();
- CairoWidget::set_focus_handler (sigc::mem_fun (*this, &Editor::reset_focus));
+ CairoWidget::set_focus_handler (sigc::mem_fun (ARDOUR_UI::instance(), &ARDOUR_UI::reset_focus));
_summary = new EditorSummary (this);
_notebook_shrunk = string_is_affirmative (prop->value ());
}
+ editor_summary_pane.set_check_divider_position (true);
editor_summary_pane.add (edit_packer);
Button* summary_arrows_left_left = manage (new Button);
editor_summary_pane.add (_summary_hbox);
}
+ edit_pane.set_check_divider_position (true);
edit_pane.add (editor_summary_pane);
if (!ARDOUR::Profile->get_trx()) {
edit_pane.add (_the_notebook);
Editor::~Editor()
{
- delete button_bindings;
+ delete button_bindings;
delete _routes;
delete _route_groups;
delete _track_canvas_viewport;
delete _drags;
delete nudge_clock;
+ delete _verbose_cursor;
delete quantize_dialog;
delete _summary;
delete _group_tabs;
}
void
-Editor::control_select (PresentationInfo::order_t global_order, Selection::Operation op)
+Editor::control_select (boost::shared_ptr<Stripable> s, Selection::Operation op)
{
- /* handles the (static) signal from the ControlProtocol class that
- * requests setting the selected track to a given RID
- */
-
- if (!_session) {
- return;
- }
-
- PresentationInfo::Flag select_flags;
-
- if (global_order & ~0xffffffff) {
- /* some flags are set, so the PresentationInfo constructor
- * will use them
- */
- select_flags = PresentationInfo::Flag (0);
- } else {
- /* no type flags set in the global order ID, so assume caller
- * wants to select a Route
- */
- select_flags = PresentationInfo::Route;
- }
-
- PresentationInfo pi (global_order, select_flags);
- boost::shared_ptr<Stripable> s = _session->get_remote_nth_stripable (pi.order(), pi.flags());
-
- /* selected object may not be a Route */
-
- boost::shared_ptr<Route> r = boost::dynamic_pointer_cast<Route> (s);
-
- if (!r) {
- return;
- }
-
- TimeAxisView* tav = axis_view_from_route (r);
+ TimeAxisView* tav = axis_view_from_stripable (s);
if (tav) {
switch (op) {
/* leaving window, so reset focus, thus ending any and
all text entry operations.
*/
- reset_focus (&contents());
+ ARDOUR_UI::instance()->reset_focus (&contents());
break;
}
break;
break;
}
+ /* catch up on selection of stripables (other selection state is lost
+ * when a session is closed
+ */
+
+ StripableList sl;
+ TrackViewList tl;
+ _session->get_stripables (sl);
+ for (StripableList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
+ if ((*s)->presentation_info().selected()) {
+ RouteTimeAxisView* rtav = get_route_view_by_route_id ((*s)->id());
+ if (rtav) {
+ tl.push_back (rtav);
+ }
+ }
+ }
+ if (!tl.empty()) {
+ selection->set (tl);
+ }
+
/* register for undo history */
_session->register_with_memento_command_factory(id(), this);
_session->register_with_memento_command_factory(_selection_memento->id(), _selection_memento);
case SnapToBeatDiv4:
case SnapToBeatDiv3:
case SnapToBeatDiv2: {
- std::vector<TempoMap::BBTPoint> grid;
- compute_current_bbt_points (grid, leftmost_frame, leftmost_frame + current_page_samples());
- compute_bbt_ruler_scale (grid, leftmost_frame, leftmost_frame + current_page_samples());
- update_tempo_based_rulers (grid);
+ compute_bbt_ruler_scale (leftmost_frame, leftmost_frame + current_page_samples());
+ update_tempo_based_rulers ();
break;
}
if ((prop = node.property ("zoom-focus"))) {
zoom_focus_selection_done ((ZoomFocus) string_2_enum (prop->value(), zoom_focus));
+ } else {
+ zoom_focus_selection_done (zoom_focus);
}
if ((prop = node.property ("zoom"))) {
if ((prop = node.property ("snap-to"))) {
snap_type_selection_done ((SnapType) string_2_enum (prop->value(), _snap_type));
set_snap_to ((SnapType) string_2_enum (prop->value(), _snap_type));
+ } else {
+ set_snap_to (_snap_type);
}
if ((prop = node.property ("snap-mode"))) {
* which does not trigger set_text().
*/
set_snap_mode ((SnapMode) string_2_enum (prop->value(), _snap_mode));
+ } else {
+ set_snap_mode (_snap_mode);
}
if ((prop = node.property ("internal-snap-to"))) {
if ((prop = node.property ("edit-point"))) {
set_edit_point_preference ((EditPoint) string_2_enum (prop->value(), _edit_point), true);
+ } else {
+ set_edit_point_preference (_edit_point);
}
if ((prop = node.property ("show-measures"))) {
break;
case SnapToBeatDiv128:
- start = _session->tempo_map().round_to_beat_subdivision (start, 128, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 128, direction);
break;
case SnapToBeatDiv64:
- start = _session->tempo_map().round_to_beat_subdivision (start, 64, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 64, direction);
break;
case SnapToBeatDiv32:
- start = _session->tempo_map().round_to_beat_subdivision (start, 32, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 32, direction);
break;
case SnapToBeatDiv28:
- start = _session->tempo_map().round_to_beat_subdivision (start, 28, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 28, direction);
break;
case SnapToBeatDiv24:
- start = _session->tempo_map().round_to_beat_subdivision (start, 24, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 24, direction);
break;
case SnapToBeatDiv20:
- start = _session->tempo_map().round_to_beat_subdivision (start, 20, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 20, direction);
break;
case SnapToBeatDiv16:
- start = _session->tempo_map().round_to_beat_subdivision (start, 16, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 16, direction);
break;
case SnapToBeatDiv14:
- start = _session->tempo_map().round_to_beat_subdivision (start, 14, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 14, direction);
break;
case SnapToBeatDiv12:
- start = _session->tempo_map().round_to_beat_subdivision (start, 12, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 12, direction);
break;
case SnapToBeatDiv10:
- start = _session->tempo_map().round_to_beat_subdivision (start, 10, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 10, direction);
break;
case SnapToBeatDiv8:
- start = _session->tempo_map().round_to_beat_subdivision (start, 8, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 8, direction);
break;
case SnapToBeatDiv7:
- start = _session->tempo_map().round_to_beat_subdivision (start, 7, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 7, direction);
break;
case SnapToBeatDiv6:
- start = _session->tempo_map().round_to_beat_subdivision (start, 6, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 6, direction);
break;
case SnapToBeatDiv5:
- start = _session->tempo_map().round_to_beat_subdivision (start, 5, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 5, direction);
break;
case SnapToBeatDiv4:
- start = _session->tempo_map().round_to_beat_subdivision (start, 4, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 4, direction);
break;
case SnapToBeatDiv3:
- start = _session->tempo_map().round_to_beat_subdivision (start, 3, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 3, direction);
break;
case SnapToBeatDiv2:
- start = _session->tempo_map().round_to_beat_subdivision (start, 2, direction);
+ start = _session->tempo_map().round_to_quarter_note_subdivision (start, 2, direction);
break;
case SnapToMark:
return 0;
}
+/** returns the current musical grid divisiions using the supplied modifier mask from a GtkEvent.
+ if the grid is non-musical, returns 0.
+ if the grid is snapped to bars, returns -1.
+ @param event_state the current keyboard modifier mask.
+*/
+int32_t
+Editor::get_grid_music_divisions (uint32_t event_state)
+{
+ if (snap_mode() == Editing::SnapOff && !ArdourKeyboard::indicates_snap (event_state)) {
+ return 0;
+ }
+
+ if (snap_mode() != Editing::SnapOff && ArdourKeyboard::indicates_snap (event_state)) {
+ return 0;
+ }
+
+ switch (_snap_type) {
+ case SnapToBeatDiv128: return 128;
+ case SnapToBeatDiv64: return 64;
+ case SnapToBeatDiv32: return 32;
+ case SnapToBeatDiv28: return 28;
+ case SnapToBeatDiv24: return 24;
+ case SnapToBeatDiv20: return 20;
+ case SnapToBeatDiv16: return 16;
+ case SnapToBeatDiv14: return 14;
+ case SnapToBeatDiv12: return 12;
+ case SnapToBeatDiv10: return 10;
+ case SnapToBeatDiv8: return 8;
+ case SnapToBeatDiv7: return 7;
+ case SnapToBeatDiv6: return 6;
+ case SnapToBeatDiv5: return 5;
+ case SnapToBeatDiv4: return 4;
+ case SnapToBeatDiv3: return 3;
+ case SnapToBeatDiv2: return 2;
+ case SnapToBeat: return 1;
+ case SnapToBar : return -1;
+ default: return 0;
+ }
+ return 0;
+}
+
Evoral::Beats
Editor::get_grid_type_as_beats (bool& success, framepos_t position)
{
switch (_snap_type) {
case SnapToBeat:
- return Evoral::Beats(1.0);
+ return Evoral::Beats(4.0 / _session->tempo_map().meter_at_frame (position).note_divisor());
case SnapToBar:
if (_session) {
- return Evoral::Beats(_session->tempo_map().meter_at_frame (position).divisions_per_bar());
+ const Meter& m = _session->tempo_map().meter_at_frame (position);
+ return Evoral::Beats((4.0 * m.divisions_per_bar()) / m.note_divisor());
}
break;
default:
vs->zoom_focus = zoom_focus;
if (with_tracks) {
- *vs->gui_state = *ARDOUR_UI::instance()->gui_object_state;
+ vs->gui_state->set_state (ARDOUR_UI::instance()->gui_object_state->get_state());
}
return vs;
reposition_and_zoom (vs.leftmost_frame, vs.samples_per_pixel);
if (vs.gui_state) {
- *ARDOUR_UI::instance()->gui_object_state = *vs.gui_state;
+ ARDOUR_UI::instance()->gui_object_state->set_state (vs.gui_state->get_state());
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
(*i)->clear_property_cache();
compute_fixed_ruler_scale ();
- std::vector<TempoMap::BBTPoint> grid;
- compute_current_bbt_points (grid, vc.time_origin, pending_visual_change.time_origin + current_page_samples());
- compute_bbt_ruler_scale (grid, vc.time_origin, pending_visual_change.time_origin + current_page_samples());
- update_tempo_based_rulers (grid);
+ compute_bbt_ruler_scale (vc.time_origin, pending_visual_change.time_origin + current_page_samples());
+ update_tempo_based_rulers ();
update_video_timeline();
}
true
);
dialog->present ();
- ARDOUR_UI::instance()->flush_pending ();
+ ARDOUR_UI::instance()->flush_pending (60);
}
for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (rv);
if (mrv) {
- list<pair<PBD::ID const, list<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >::iterator rnote;
+ list<pair<PBD::ID const, list<Evoral::event_id_t> > >::iterator rnote;
for (rnote = selection->pending_midi_note_selection.begin(); rnote != selection->pending_midi_note_selection.end(); ++rnote) {
if (rv->region()->id () == (*rnote).first) {
mrv->select_notes ((*rnote).second);
_summary->set_background_dirty ();
}
-RouteTimeAxisView*
-Editor::axis_view_from_route (boost::shared_ptr<Route> r) const
+TimeAxisView*
+Editor::axis_view_from_stripable (boost::shared_ptr<Stripable> s) const
{
- TrackViewList::const_iterator j = track_views.begin ();
- while (j != track_views.end()) {
- RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*j);
- if (rtv && rtv->route() == r) {
- return rtv;
+ for (TrackViewList::const_iterator j = track_views.begin (); j != track_views.end(); ++j) {
+ if ((*j)->stripable() == s) {
+ return *j;
}
- ++j;
}
return 0;
TrackViewList t;
for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
- TimeAxisView* tv = axis_view_from_route (*i);
+ TimeAxisView* tv = axis_view_from_stripable (*i);
if (tv) {
t.push_back (tv);
}
projects / ardour.git / blobdiff