#include "ardour/lmath.h"
#include "ardour/location.h"
#include "ardour/profile.h"
+#include "ardour/route.h"
#include "ardour/route_group.h"
#include "ardour/session_playlists.h"
#include "ardour/tempo.h"
#include "ardour/utils.h"
+#include "ardour/vca_manager.h"
+#include "ardour/vca.h"
#include "canvas/debug.h"
#include "canvas/text.h"
#include "region_layering_order_editor.h"
#include "rgb_macros.h"
#include "rhythm_ferret.h"
+#include "route_sorter.h"
#include "selection.h"
#include "simple_progress_dialog.h"
#include "sfdb_ui.h"
#include "tooltips.h"
#include "ui_config.h"
#include "utils.h"
+#include "vca_time_axis.h"
#include "verbose_cursor.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
#define COMBO_TRIANGLE_WIDTH 25 // ArdourButton _diameter (11) + 2 * arrow-padding (2*2) + 2 * text-padding (2*5)
-static void
-pane_size_watcher (Paned* pane)
-{
- /* if the handle of a pane vanishes into (at least) the tabs of a notebook,
- it is:
-
- X: hard to access
- Quartz: impossible to access
-
- so stop that by preventing it from ever getting too narrow. 35
- pixels is basically a rough guess at the tab width.
-
- ugh.
- */
-
- int max_width_of_lhs = GTK_WIDGET(pane->gobj())->allocation.width - 35;
-
- gint pos = pane->get_position ();
-
- if (pos > max_width_of_lhs) {
- pane->set_position (max_width_of_lhs);
- }
-}
-
Editor::Editor ()
: PublicEditor (global_hpacker)
, editor_mixer_strip_width (Wide)
_notebook_shrunk = false;
- editor_summary_pane.pack1(edit_packer);
+
+ /* Pick up some settings we need to cache, early */
+
+ XMLNode* settings = ARDOUR_UI::instance()->editor_settings();
+ XMLProperty* prop;
+
+ if (settings && (prop = settings->property ("notebook-shrunk"))) {
+ _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);
summary_arrows_left_left->add (*manage (new Arrow (ARROW_LEFT, SHADOW_NONE)));
_summary_hbox.pack_start (*summary_arrows_right, false, false);
if (!ARDOUR::Profile->get_trx()) {
- editor_summary_pane.pack2 (_summary_hbox);
+ editor_summary_pane.add (_summary_hbox);
}
- edit_pane.pack1 (editor_summary_pane, true, true);
+ edit_pane.set_check_divider_position (true);
+ edit_pane.add (editor_summary_pane);
if (!ARDOUR::Profile->get_trx()) {
- edit_pane.pack2 (_the_notebook, false, true);
+ edit_pane.add (_the_notebook);
}
- editor_summary_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun (*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&editor_summary_pane)));
+ edit_pane.set_drag_cursor (*_cursors->expand_left_right);
+ edit_pane.set_child_minsize (_the_notebook, 30); /* rough guess at width of notebook tabs */
+ editor_summary_pane.set_drag_cursor (*_cursors->expand_up_down);
- /* XXX: editor_summary_pane might need similar to the edit_pane */
+ float fract;
- edit_pane.signal_size_allocate().connect (sigc::bind (sigc::mem_fun(*this, &Editor::pane_allocation_handler), static_cast<Paned*> (&edit_pane)));
+ {
+ LocaleGuard lg;
- Glib::PropertyProxy<int> proxy = edit_pane.property_position();
- proxy.signal_changed().connect (bind (sigc::ptr_fun (pane_size_watcher), static_cast<Paned*> (&edit_pane)));
+ if (!settings || ((prop = settings->property ("edit-horizontal-pane-pos")) == 0) || ((fract = atof (prop->value())) > 1.0)) {
+ /* initial allocation is 90% to canvas, 10% to notebook */
+ edit_pane.set_divider (0, 0.90);
+ } else {
+ edit_pane.set_divider (0, fract);
+ }
+
+ if (!settings || ((prop = settings->property ("edit-vertical-pane-pos")) == 0) || ((fract = atof (prop->value())) > 1.0)) {
+ /* initial allocation is 90% to canvas, 10% to summary */
+ editor_summary_pane.set_divider (0, 0.90);
+ } else {
+
+ editor_summary_pane.set_divider (0, fract);
+ }
+ }
top_hbox.pack_start (toolbar_frame);
BasicUI::AccessAction.connect (*this, invalidator (*this), boost::bind (&Editor::access_action, this, _1, _2), gui_context());
+ /* handle escape */
+
+ ARDOUR_UI::instance()->Escape.connect (*this, invalidator (*this), boost::bind (&Editor::escape, this), gui_context());
+
/* problematic: has to return a value and thus cannot be x-thread */
Session::AskAboutPlaylistDeletion.connect_same_thread (*this, boost::bind (&Editor::playlist_deletion_dialog, this, _1));
}
void
-Editor::control_select (PresentationInfo::global_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 pi (global_order, PresentationInfo::Flag (0));
- boost::shared_ptr<Stripable> s = _session->get_remote_nth_stripable (pi.group_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) {
_session->StepEditStatusChange.connect (_session_connections, invalidator (*this), boost::bind (&Editor::step_edit_status_change, this, _1), gui_context());
_session->TransportStateChange.connect (_session_connections, invalidator (*this), boost::bind (&Editor::map_transport_state, this), gui_context());
_session->PositionChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::map_position_change, this, _1), gui_context());
+ _session->vca_manager().VCAAdded.connect (_session_connections, invalidator (*this), boost::bind (&Editor::add_vcas, this, _1), gui_context());
_session->RouteAdded.connect (_session_connections, invalidator (*this), boost::bind (&Editor::add_routes, this, _1), gui_context());
_session->DirtyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::update_title, this), gui_context());
_session->tempo_map().PropertyChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::tempo_map_changed, this, _1), gui_context());
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);
XMLProperty const * prop;
set_id (node);
PBD::Unwinder<bool> nsi (no_save_instant, true);
+ LocaleGuard lg;
Tabbable::set_state (node, version);
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"))) {
{
XMLNode* node = new XMLNode (X_("Editor"));
char buf[32];
+ LocaleGuard lg;
id().print (buf, sizeof (buf));
node->add_property ("id", buf);
node->add_child_nocopy (Tabbable::get_state());
- snprintf(buf,sizeof(buf), "%f", paned_position_as_fraction (edit_pane, false));
+ snprintf(buf,sizeof(buf), "%f", edit_pane.get_divider ());
node->add_property("edit-horizontal-pane-pos", string(buf));
node->add_property("notebook-shrunk", _notebook_shrunk ? "1" : "0");
- snprintf(buf,sizeof(buf), "%f", paned_position_as_fraction (editor_summary_pane, true));
+ snprintf(buf,sizeof(buf), "%f", editor_summary_pane.get_divider());
node->add_property("edit-vertical-pane-pos", string(buf));
maybe_add_mixer_strip_width (*node);
}
}
-void
-Editor::pane_allocation_handler (Allocation &alloc, Paned* which)
-{
- /* recover or initialize pane positions. do this here rather than earlier because
- we don't want the positions to change the child allocations, which they seem to do.
-
- See comments in mixer_ui.cc about how this works.
- */
-
- float pos;
- XMLProperty* prop;
- XMLNode* geometry = ARDOUR_UI::instance()->editor_settings();
-
- enum Pane {
- Horizontal = 0x1,
- Vertical = 0x2
- };
-
- static Pane done;
-
- if (which == static_cast<Paned*> (&edit_pane)) {
-
- if (done & Horizontal) {
- return;
- }
-
- if (geometry && (prop = geometry->property ("notebook-shrunk"))) {
- _notebook_shrunk = string_is_affirmative (prop->value ());
- }
-
- if (!geometry || (prop = geometry->property ("edit-horizontal-pane-pos")) == 0) {
- /* initial allocation is 90% to canvas, 10% to notebook */
- pos = (int) floor (alloc.get_width() * 0.90f);
- } else {
- pos = atof (prop->value());
- }
-
- if (pos > 1.0f) {
- /* older versions of Ardour stored absolute position */
- if (alloc.get_width() > pos) {
- edit_pane.set_position (pos);
- done = (Pane) (done | Horizontal);
- }
- } else {
- if (alloc.get_width() > 1.0/pos) {
- paned_set_position_as_fraction (edit_pane, pos, false);
- done = (Pane) (done | Horizontal);
- }
- }
-
- } else if (which == static_cast<Paned*> (&editor_summary_pane)) {
-
- if (done & Vertical) {
- return;
- }
-
- if (!geometry || (prop = geometry->property ("edit-vertical-pane-pos")) == 0) {
- /* initial allocation is 90% to canvas, 10% to summary */
- pos = (int) floor (alloc.get_height() * 0.90f);
- } else {
-
- pos = atof (prop->value());
- }
-
- if (pos > 1.0f) {
- /* older versions of Ardour stored absolute position */
- if (alloc.get_height() > pos) {
- editor_summary_pane.set_position (pos);
- done = (Pane) (done | Vertical);
- }
- } else {
- if (alloc.get_height() > 1.0/pos) {
- paned_set_position_as_fraction (editor_summary_pane, pos, true);
- done = (Pane) (done | Vertical);
- }
- }
- }
-}
-
void
Editor::set_show_measures (bool yn)
{
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.
+*/
+unsigned
+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)
{
begin_reversible_command (_("new playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
_session->playlists->get (playlists);
- mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_new_playlist), playlists), v, ARDOUR::Properties::select.property_id);
+ mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_new_playlist), playlists), v, ARDOUR::Properties::group_select.property_id);
commit_reversible_command ();
}
begin_reversible_command (_("copy playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
_session->playlists->get (playlists);
- mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_copy_playlist), playlists), v, ARDOUR::Properties::select.property_id);
+ mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_copy_playlist), playlists), v, ARDOUR::Properties::group_select.property_id);
commit_reversible_command ();
}
begin_reversible_command (_("clear playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
_session->playlists->get (playlists);
- mapover_tracks (sigc::mem_fun (*this, &Editor::mapped_clear_playlist), v, ARDOUR::Properties::select.property_id);
+ mapover_tracks (sigc::mem_fun (*this, &Editor::mapped_clear_playlist), v, ARDOUR::Properties::group_select.property_id);
commit_reversible_command ();
}
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();
_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);
}
}
void
-Editor::add_routes (RouteList& routes)
+Editor::add_vcas (VCAList& vlist)
{
- ENSURE_GUI_THREAD (*this, &Editor::handle_new_route, routes)
+ StripableList sl;
+
+ for (VCAList::iterator v = vlist.begin(); v != vlist.end(); ++v) {
+ sl.push_back (boost::dynamic_pointer_cast<Stripable> (*v));
+ }
+
+ add_stripables (sl);
+}
+
+void
+Editor::add_routes (RouteList& rlist)
+{
+ StripableList sl;
+
+ for (RouteList::iterator r = rlist.begin(); r != rlist.end(); ++r) {
+ sl.push_back (*r);
+ }
+
+ add_stripables (sl);
+}
- RouteTimeAxisView *rtv;
- list<RouteTimeAxisView*> new_views;
+void
+Editor::add_stripables (StripableList& sl)
+{
+ list<TimeAxisView*> new_views;
+ boost::shared_ptr<VCA> v;
+ boost::shared_ptr<Route> r;
TrackViewList new_selection;
bool from_scratch = (track_views.size() == 0);
- for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
- boost::shared_ptr<Route> route = (*x);
+ sl.sort (StripablePresentationInfoSorter());
- if (route->is_auditioner() || route->is_monitor()) {
- continue;
- }
+ for (StripableList::iterator s = sl.begin(); s != sl.end(); ++s) {
- DataType dt = route->input()->default_type();
+ if ((v = boost::dynamic_pointer_cast<VCA> (*s)) != 0) {
- if (dt == ARDOUR::DataType::AUDIO) {
- rtv = new AudioTimeAxisView (*this, _session, *_track_canvas);
- rtv->set_route (route);
- } else if (dt == ARDOUR::DataType::MIDI) {
- rtv = new MidiTimeAxisView (*this, _session, *_track_canvas);
- rtv->set_route (route);
- } else {
- throw unknown_type();
- }
+ VCATimeAxisView* vtv = new VCATimeAxisView (*this, _session, *_track_canvas);
+ vtv->set_vca (v);
+ new_views.push_back (vtv);
+
+ } else if ((r = boost::dynamic_pointer_cast<Route> (*s)) != 0) {
- new_views.push_back (rtv);
- track_views.push_back (rtv);
- new_selection.push_back (rtv);
+ if (r->is_auditioner() || r->is_monitor()) {
+ continue;
+ }
- rtv->effective_gain_display ();
+ RouteTimeAxisView* rtv;
+ DataType dt = r->input()->default_type();
- rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
- rtv->view()->RegionViewRemoved.connect (sigc::mem_fun (*this, &Editor::region_view_removed));
+ if (dt == ARDOUR::DataType::AUDIO) {
+ rtv = new AudioTimeAxisView (*this, _session, *_track_canvas);
+ rtv->set_route (r);
+ } else if (dt == ARDOUR::DataType::MIDI) {
+ rtv = new MidiTimeAxisView (*this, _session, *_track_canvas);
+ rtv->set_route (r);
+ } else {
+ throw unknown_type();
+ }
+
+ new_views.push_back (rtv);
+ track_views.push_back (rtv);
+ new_selection.push_back (rtv);
+
+ rtv->effective_gain_display ();
+
+ rtv->view()->RegionViewAdded.connect (sigc::mem_fun (*this, &Editor::region_view_added));
+ rtv->view()->RegionViewRemoved.connect (sigc::mem_fun (*this, &Editor::region_view_removed));
+ }
}
if (new_views.size() > 0) {
- _routes->routes_added (new_views);
- _summary->routes_added (new_views);
+ _routes->time_axis_views_added (new_views);
+ //_summary->routes_added (new_selection); /* XXX requires RouteTimeAxisViewList */
}
- if (!from_scratch) {
+ /* note: !new_selection.empty() means that we got some routes rather
+ * than just VCAs
+ */
+
+ if (!from_scratch && !new_selection.empty()) {
selection->tracks.clear();
selection->add (new_selection);
begin_selection_op_history();
}
- if (show_editor_mixer_when_tracks_arrive) {
+ if (show_editor_mixer_when_tracks_arrive && !new_selection.empty()) {
show_editor_mixer (true);
}
if (_notebook_shrunk) {
if (pre_notebook_shrink_pane_width) {
- edit_pane.set_position (*pre_notebook_shrink_pane_width);
+ edit_pane.set_divider (0, *pre_notebook_shrink_pane_width);
}
_notebook_shrunk = false;
} else {
- pre_notebook_shrink_pane_width = edit_pane.get_position();
+ pre_notebook_shrink_pane_width = edit_pane.get_divider();
/* this expands the LHS of the edit pane to cover the notebook
PAGE but leaves the tabs visible.
*/
- edit_pane.set_position (edit_pane.get_position() + page->get_width());
+ edit_pane.set_divider (0, edit_pane.get_divider() + page->get_width());
_notebook_shrunk = true;
}
}
}
_cursors->set_cursor_set (UIConfiguration::instance().get_icon_set());
_cursor_stack.push_back(_cursors->grabber);
+ edit_pane.set_drag_cursor (*_cursors->expand_left_right);
+ editor_summary_pane.set_drag_cursor (*_cursors->expand_up_down);
+
} else if (parameter == "draggable-playhead") {
if (_verbose_cursor) {
playhead_cursor->set_sensitive (UIConfiguration::instance().get_draggable_playhead());
projects / ardour.git / blobdiff