smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-16 03:36:32 +01:00
Code Issues Projects Releases Wiki Activity

Merge edit and mix groups to just being route groups. Add properties to route groups to decide what things their member routes will share. Allow edits to happen across a route group without its tracks necessarily being selected.

Browse source 
git-svn-id: svn://localhost/ardour2/branches/3.0@5236 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Carl Hetherington 2009-06-21 19:59:56 +00:00
parent 8cd536ab85
commit 955d731fa6
40 changed files with 794 additions and 805 deletions
Download patch file Download diff file Expand all files Collapse all files

18
gtk2_ardour/add_route_dialog.cc
View file

@ -84,12 +84,12 @@ AddRouteDialog::AddRouteDialog (Session & s)
refill_channel_setups ();
set_popdown_strings (track_mode_combo, track_mode_strings, true);
edit_group_combo.append_text (_("No group"));
_session.foreach_edit_group (mem_fun (*this, &AddRouteDialog::add_edit_group));
route_group_combo.append_text (_("No group"));
_session.foreach_route_group (mem_fun (*this, &AddRouteDialog::add_route_group));
channel_combo.set_active_text (channel_combo_strings.front());
track_mode_combo.set_active_text (track_mode_strings.front());
edit_group_combo.set_active (0);
route_group_combo.set_active (0);
RadioButton::Group g = track_button.get_group();
bus_button.set_group (g);
@ -134,7 +134,7 @@ AddRouteDialog::AddRouteDialog (Session & s)
l = manage (new Label (_("Add to edit group:")));
l->set_alignment (1, 0.5);
table->attach (*l, 0, 1, 4, 5);
table->attach (edit_group_combo, 1, 2, 4, 5, FILL | EXPAND);
table->attach (route_group_combo, 1, 2, 4, 5, FILL | EXPAND);
get_vbox()->pack_start (*table);
get_vbox()->set_spacing (6);
@ -325,17 +325,17 @@ AddRouteDialog::refill_channel_setups ()
}
void
AddRouteDialog::add_edit_group (RouteGroup* g)
AddRouteDialog::add_route_group (RouteGroup* g)
{
edit_group_combo.append_text (g->name ());
route_group_combo.append_text (g->name ());
}
RouteGroup*
AddRouteDialog::edit_group ()
AddRouteDialog::route_group ()
{
if (edit_group_combo.get_active_row_number () == 0) {
if (route_group_combo.get_active_row_number () == 0) {
return 0;
}
return _session.edit_group_by_name (edit_group_combo.get_active_text());
return _session.route_group_by_name (route_group_combo.get_active_text());
}

6
gtk2_ardour/add_route_dialog.h
View file

@ -50,7 +50,7 @@ class AddRouteDialog : public Gtk::Dialog
ARDOUR::DataType type();
ARDOUR::TrackMode mode();
ARDOUR::RouteGroup* edit_group ();
ARDOUR::RouteGroup* route_group ();
private:
ARDOUR::Session& _session;
@ -61,13 +61,13 @@ class AddRouteDialog : public Gtk::Dialog
Gtk::SpinButton routes_spinner;
Gtk::ComboBoxText channel_combo;
Gtk::ComboBoxText track_mode_combo;
Gtk::ComboBoxText edit_group_combo;
Gtk::ComboBoxText route_group_combo;
std::vector<ARDOUR::TemplateInfo> route_templates;
void track_type_chosen ();
void refill_channel_setups ();
void add_edit_group (ARDOUR::RouteGroup *);
void add_route_group (ARDOUR::RouteGroup *);
void reset_template_option_visibility ();

18
gtk2_ardour/ardour_ui.cc
View file

@ -1242,7 +1242,7 @@ ARDOUR_UI::open_session ()
void
ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* edit_group, uint32_t how_many)
ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many)
{
list<boost::shared_ptr<MidiTrack> > tracks;
@ -1254,7 +1254,7 @@ ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* edit_group, uint32_t h
try {
if (disk) {
tracks = session->new_midi_track (ARDOUR::Normal, edit_group, how_many);
tracks = session->new_midi_track (ARDOUR::Normal, route_group, how_many);
if (tracks.size() != how_many) {
if (how_many == 1) {
@ -1282,7 +1282,7 @@ restart JACK with more ports."));
void
ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* edit_group, uint32_t how_many)
ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* route_group, uint32_t how_many)
{
list<boost::shared_ptr<AudioTrack> > tracks;
RouteList routes;
@ -1294,7 +1294,7 @@ ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t
try {
if (track) {
tracks = session->new_audio_track (input_channels, output_channels, mode, edit_group, how_many);
tracks = session->new_audio_track (input_channels, output_channels, mode, route_group, how_many);
if (tracks.size() != how_many) {
if (how_many == 1) {
@ -1307,7 +1307,7 @@ ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t
} else {
routes = session->new_audio_route (input_channels, output_channels, edit_group, how_many);
routes = session->new_audio_route (input_channels, output_channels, route_group, how_many);
if (routes.size() != how_many) {
if (how_many == 1) {
@ -2802,7 +2802,7 @@ ARDOUR_UI::add_route (Gtk::Window* float_window)
uint32_t output_chan;
string name_template = add_route_dialog->name_template ();
bool track = add_route_dialog->track ();
RouteGroup* edit_group = add_route_dialog->edit_group ();
RouteGroup* route_group = add_route_dialog->route_group ();
AutoConnectOption oac = Config->get_output_auto_connect();
@ -2816,7 +2816,7 @@ ARDOUR_UI::add_route (Gtk::Window* float_window)
if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
if (track) {
session_add_midi_track(edit_group, count);
session_add_midi_track (route_group, count);
} else {
MessageDialog msg (*editor,
_("Sorry, MIDI Busses are not supported at this time."));
@ -2825,9 +2825,9 @@ ARDOUR_UI::add_route (Gtk::Window* float_window)
}
} else {
if (track) {
session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), edit_group, count);
session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count);
} else {
session_add_audio_bus (input_chan, output_chan, edit_group, count);
session_add_audio_bus (input_chan, output_chan, route_group, count);
}
}
}

12
gtk2_ardour/ardour_ui.h
View file

@ -198,16 +198,16 @@ class ARDOUR_UI : public Gtkmm2ext::UI
void add_route (Gtk::Window* float_window);
void session_add_audio_track (int input_channels, int32_t output_channels, ARDOUR::TrackMode mode, ARDOUR::RouteGroup* edit_group, uint32_t how_many) {
session_add_audio_route (true, input_channels, output_channels, mode, edit_group, how_many);
void session_add_audio_track (int input_channels, int32_t output_channels, ARDOUR::TrackMode mode, ARDOUR::RouteGroup* route_group, uint32_t how_many) {
session_add_audio_route (true, input_channels, output_channels, mode, route_group, how_many);
}
void session_add_audio_bus (int input_channels, int32_t output_channels, ARDOUR::RouteGroup* edit_group, uint32_t how_many) {
session_add_audio_route (false, input_channels, output_channels, ARDOUR::Normal, edit_group, how_many);
void session_add_audio_bus (int input_channels, int32_t output_channels, ARDOUR::RouteGroup* route_group, uint32_t how_many) {
session_add_audio_route (false, input_channels, output_channels, ARDOUR::Normal, route_group, how_many);
}
void session_add_midi_track (ARDOUR::RouteGroup* edit_group, uint32_t how_many) {
session_add_midi_route (true, edit_group, how_many);
void session_add_midi_track (ARDOUR::RouteGroup* route_group, uint32_t how_many) {
session_add_midi_route (true, route_group, how_many);
}
/*void session_add_midi_bus () {

169
gtk2_ardour/editor.cc
View file

@ -312,7 +312,7 @@ Editor::Editor ()
_xfade_visibility = true;
editor_ruler_menu = 0;
no_ruler_shown_update = false;
edit_group_list_menu = 0;
route_group_list_menu = 0;
route_list_menu = 0;
region_list_menu = 0;
marker_menu = 0;
@ -337,7 +337,7 @@ Editor::Editor ()
clear_entered_track = false;
_new_regionviews_show_envelope = false;
current_timefx = 0;
in_edit_group_row_change = false;
in_route_group_row_change = false;
playhead_cursor = 0;
button_release_can_deselect = true;
_dragging_playhead = false;
@ -575,73 +575,70 @@ Editor::Editor ()
route_list_scroller.set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
group_model = ListStore::create(group_columns);
edit_group_display.set_model (group_model);
edit_group_display.append_column (_("Name"), group_columns.text);
edit_group_display.append_column (_("Active"), group_columns.is_active);
edit_group_display.append_column (_("Show"), group_columns.is_visible);
edit_group_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
edit_group_display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
edit_group_display.get_column (2)->set_data (X_("colnum"), GUINT_TO_POINTER(2));
edit_group_display.get_column (0)->set_expand (true);
edit_group_display.get_column (1)->set_expand (false);
edit_group_display.get_column (2)->set_expand (false);
edit_group_display.set_headers_visible (true);
route_group_display.set_model (group_model);
route_group_display.append_column (_("Name"), group_columns.text);
route_group_display.append_column (_("Show"), group_columns.is_visible);
route_group_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
route_group_display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
route_group_display.get_column (0)->set_expand (true);
route_group_display.get_column (1)->set_expand (false);
route_group_display.set_headers_visible (true);
/* name is directly editable */
CellRendererText* name_cell = dynamic_cast<CellRendererText*>(edit_group_display.get_column_cell_renderer (0));
CellRendererText* name_cell = dynamic_cast<CellRendererText*>(route_group_display.get_column_cell_renderer (0));
name_cell->property_editable() = true;
name_cell->signal_edited().connect (mem_fun (*this, &Editor::edit_group_name_edit));
name_cell->signal_edited().connect (mem_fun (*this, &Editor::route_group_name_edit));
/* use checkbox for the active + visible columns */
CellRendererToggle* active_cell = dynamic_cast<CellRendererToggle*>(edit_group_display.get_column_cell_renderer (1));
CellRendererToggle* active_cell = dynamic_cast<CellRendererToggle*>(route_group_display.get_column_cell_renderer (1));
active_cell->property_activatable() = true;
active_cell->property_radio() = false;
active_cell = dynamic_cast<CellRendererToggle*>(edit_group_display.get_column_cell_renderer (1));
active_cell = dynamic_cast<CellRendererToggle*>(route_group_display.get_column_cell_renderer (1));
active_cell->property_activatable() = true;
active_cell->property_radio() = false;
group_model->signal_row_changed().connect (mem_fun (*this, &Editor::edit_group_row_change));
group_model->signal_row_changed().connect (mem_fun (*this, &Editor::route_group_row_change));
edit_group_display.set_name ("EditGroupList");
edit_group_display.get_selection()->set_mode (SELECTION_SINGLE);
edit_group_display.set_headers_visible (true);
edit_group_display.set_reorderable (false);
edit_group_display.set_rules_hint (true);
edit_group_display.set_size_request (75, -1);
route_group_display.set_name ("EditGroupList");
route_group_display.get_selection()->set_mode (SELECTION_SINGLE);
route_group_display.set_headers_visible (true);
route_group_display.set_reorderable (false);
route_group_display.set_rules_hint (true);
route_group_display.set_size_request (75, -1);
edit_group_display_scroller.add (edit_group_display);
edit_group_display_scroller.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC);
route_group_display_scroller.add (route_group_display);
route_group_display_scroller.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC);
edit_group_display.signal_button_press_event().connect (mem_fun(*this, &Editor::edit_group_list_button_press_event), false);
route_group_display.signal_button_press_event().connect (mem_fun(*this, &Editor::route_group_list_button_press_event), false);
VBox* edit_group_display_packer = manage (new VBox());
HBox* edit_group_display_button_box = manage (new HBox());
edit_group_display_button_box->set_homogeneous (true);
VBox* route_group_display_packer = manage (new VBox());
HBox* route_group_display_button_box = manage (new HBox());
route_group_display_button_box->set_homogeneous (true);
Button* edit_group_add_button = manage (new Button ());
Button* edit_group_remove_button = manage (new Button ());
Button* route_group_add_button = manage (new Button ());
Button* route_group_remove_button = manage (new Button ());
Widget* w;
w = manage (new Image (Stock::ADD, ICON_SIZE_BUTTON));
w->show();
edit_group_add_button->add (*w);
route_group_add_button->add (*w);
w = manage (new Image (Stock::REMOVE, ICON_SIZE_BUTTON));
w->show();
edit_group_remove_button->add (*w);
route_group_remove_button->add (*w);
edit_group_add_button->signal_clicked().connect (mem_fun (*this, &Editor::new_edit_group));
edit_group_remove_button->signal_clicked().connect (mem_fun (*this, &Editor::remove_selected_edit_group));
route_group_add_button->signal_clicked().connect (mem_fun (*this, &Editor::new_route_group));
route_group_remove_button->signal_clicked().connect (mem_fun (*this, &Editor::remove_selected_route_group));
edit_group_display_button_box->pack_start (*edit_group_add_button);
edit_group_display_button_box->pack_start (*edit_group_remove_button);
route_group_display_button_box->pack_start (*route_group_add_button);
route_group_display_button_box->pack_start (*route_group_remove_button);
edit_group_display_packer->pack_start (edit_group_display_scroller, true, true);
edit_group_display_packer->pack_start (*edit_group_display_button_box, false, false);
route_group_display_packer->pack_start (route_group_display_scroller, true, true);
route_group_display_packer->pack_start (*route_group_display_button_box, false, false);
region_list_display.set_size_request (100, -1);
region_list_display.set_name ("RegionListDisplay");
@ -752,9 +749,9 @@ Editor::Editor ()
nlabel = manage (new Label (_("Snapshots")));
nlabel->set_angle (-90);
the_notebook.append_page (snapshot_display_scroller, *nlabel);
nlabel = manage (new Label (_("Edit Groups")));
nlabel = manage (new Label (_("Route Groups")));
nlabel->set_angle (-90);
the_notebook.append_page (*edit_group_display_packer, *nlabel);
the_notebook.append_page (*route_group_display_packer, *nlabel);
if (!Profile->get_sae()) {
nlabel = manage (new Label (_("Chunks")));
@ -1293,8 +1290,8 @@ Editor::connect_to_session (Session *t)
session_connections.push_back (session->RegionsAdded.connect (mem_fun(*this, &Editor::handle_new_regions)));
session_connections.push_back (session->RegionRemoved.connect (mem_fun(*this, &Editor::handle_region_removed)));
session_connections.push_back (session->DurationChanged.connect (mem_fun(*this, &Editor::handle_new_duration)));
session_connections.push_back (session->edit_group_added.connect (mem_fun(*this, &Editor::add_edit_group)));
session_connections.push_back (session->edit_group_removed.connect (mem_fun(*this, &Editor::edit_groups_changed)));
session_connections.push_back (session->route_group_added.connect (mem_fun(*this, &Editor::add_route_group)));
session_connections.push_back (session->route_group_removed.connect (mem_fun(*this, &Editor::route_groups_changed)));
session_connections.push_back (session->NamedSelectionAdded.connect (mem_fun(*this, &Editor::handle_new_named_selection)));
session_connections.push_back (session->NamedSelectionRemoved.connect (mem_fun(*this, &Editor::handle_new_named_selection)));
session_connections.push_back (session->DirtyChanged.connect (mem_fun(*this, &Editor::update_title)));
@ -1309,7 +1306,7 @@ Editor::connect_to_session (Session *t)
session_connections.push_back (session->Located.connect (mem_fun (*this, &Editor::located)));
session_connections.push_back (session->config.ParameterChanged.connect (mem_fun (*this, &Editor::parameter_changed)));
edit_groups_changed ();
route_groups_changed ();
edit_point_clock.set_mode(AudioClock::BBT);
edit_point_clock.set_session (session);
@ -3560,24 +3557,24 @@ Editor::commit_reversible_command ()
}
void
Editor::set_edit_group_solo (Route& route, bool yn)
Editor::set_route_group_solo (Route& route, bool yn)
{
RouteGroup *edit_group;
RouteGroup *route_group;
if ((edit_group = route.edit_group()) != 0) {
edit_group->apply (&Route::set_solo, yn, this);
if ((route_group = route.route_group()) != 0) {
route_group->apply (&Route::set_solo, yn, this);
} else {
route.set_solo (yn, this);
}
}
void
Editor::set_edit_group_mute (Route& route, bool yn)
Editor::set_route_group_mute (Route& route, bool yn)
{
RouteGroup *edit_group = 0;
RouteGroup *route_group = 0;
if ((edit_group == route.edit_group()) != 0) {
edit_group->apply (&Route::set_mute, yn, this);
if ((route_group == route.route_group()) != 0) {
route_group->apply (&Route::set_mute, yn, this);
} else {
route.set_mute (yn, this);
}
@ -3966,11 +3963,11 @@ Editor::get_valid_views (TimeAxisView* track, RouteGroup* group)
} else {
/* views for all tracks in the edit group */
/* views for all tracks in the route group */
for (i = track_views.begin(); i != track_views.end (); ++i) {
if (group == 0 || (*i)->edit_group() == group) {
if (group == 0 || (*i)->route_group() == group) {
v->push_back (*i);
}
}
@ -5070,45 +5067,29 @@ Editor::get_regions_for_action (RegionSelection& rs, bool allow_entered)
{
if (selection->regions.empty()) {
if (selection->tracks.empty()) {
/* no regions or tracks selected
/* no regions selected; get all regions at the edit point across:
- tracks in the region's route's edit group, if it has the edit property
- selected tracks
*/
if (entered_regionview && mouse_mode == Editing::MouseObject) {
/* entered regionview is valid and we're in object mode -
just use entered regionview
*/
if (entered_regionview) {
rs.add (entered_regionview);
TrackSelection tracks = selection->tracks;
RouteGroup* g = entered_regionview->get_time_axis_view().route_group ();
if (g && g->active_property (RouteGroup::Edit)) {
tracks.add (axis_views_from_routes (g->route_list()));
}
return;
} else {
/* no regions selected, so get all regions at the edit point across
all selected tracks.
*/
nframes64_t where = get_preferred_edit_position();
get_regions_at (rs, where, selection->tracks);
/* if the entered regionview wasn't selected and neither was its track
then add it.
*/
if (entered_regionview != 0 &&
!selection->selected (entered_regionview) &&
!selection->selected (&entered_regionview->get_time_axis_view())) {
rs.add (entered_regionview);
}
nframes64_t const where = get_preferred_edit_position ();
get_regions_at (rs, where, tracks);
}
} else {
/* just use the selected regions */
/* use the selected regions */
rs = selection->regions;
@ -5289,3 +5270,23 @@ Editor::streamview_height_changed ()
{
_summary->set_dirty ();
}
TrackSelection
Editor::axis_views_from_routes (list<Route*> r) const
{
TrackSelection t;
for (list<Route*>::const_iterator i = r.begin(); i != r.end(); ++i) {
TrackViewList::const_iterator j = track_views.begin ();
while (j != track_views.end()) {
RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*j);
if (rtv && rtv->route().get() == *i) {
t.push_back (rtv);
}
++j;
}
}
return t;
}

41
gtk2_ardour/editor.h
View file

@ -1060,6 +1060,7 @@ class Editor : public PublicEditor
/* track views */
TrackViewList track_views;
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;
static Gdk::Cursor* trimmer_cursor;
@ -1842,12 +1843,10 @@ public:
struct GroupListModelColumns : public Gtk::TreeModel::ColumnRecord {
GroupListModelColumns () {
add (is_active);
add (is_visible);
add (text);
add (routegroup);
}
Gtk::TreeModelColumn<bool> is_active;
Gtk::TreeModelColumn<bool> is_visible;
Gtk::TreeModelColumn<std::string> text;
Gtk::TreeModelColumn<ARDOUR::RouteGroup*> routegroup;
@ -1857,23 +1856,23 @@ public:
Glib::RefPtr<Gtk::ListStore> group_model;
Glib::RefPtr<Gtk::TreeSelection> group_selection;
Gtk::TreeView edit_group_display;
Gtk::ScrolledWindow edit_group_display_scroller;
Gtk::Menu* edit_group_list_menu;
Gtk::TreeView route_group_display;
Gtk::ScrolledWindow route_group_display_scroller;
Gtk::Menu* route_group_list_menu;
void build_edit_group_list_menu ();
void activate_all_edit_groups ();
void disable_all_edit_groups ();
void build_route_group_list_menu ();
void activate_all_route_groups ();
void disable_all_route_groups ();
bool in_edit_group_row_change;
void edit_group_row_change (const Gtk::TreeModel::Path&,const Gtk::TreeModel::iterator&);
void edit_group_name_edit (const Glib::ustring&, const Glib::ustring&);
void new_edit_group ();
void edit_group_list_button_clicked ();
gint edit_group_list_button_press_event (GdkEventButton* ev);
void add_edit_group (ARDOUR::RouteGroup* group);
void remove_selected_edit_group ();
void edit_groups_changed ();
bool in_route_group_row_change;
void route_group_row_change (const Gtk::TreeModel::Path&,const Gtk::TreeModel::iterator&);
void route_group_name_edit (const Glib::ustring&, const Glib::ustring&);
void new_route_group ();
void route_group_list_button_clicked ();
gint route_group_list_button_press_event (GdkEventButton* ev);
void add_route_group (ARDOUR::RouteGroup* group);
void remove_selected_route_group ();
void route_groups_changed ();
void group_flags_changed (void*, ARDOUR::RouteGroup*);
Gtk::VBox list_vpacker;
@ -2018,10 +2017,10 @@ public:
void freeze_route ();
void unfreeze_route ();
/* edit-group solo + mute */
/* route-group solo + mute */
void set_edit_group_solo (ARDOUR::Route&, bool);
void set_edit_group_mute (ARDOUR::Route&, bool);
void set_route_group_solo (ARDOUR::Route&, bool);
void set_route_group_mute (ARDOUR::Route&, bool);
/* duplication */
@ -2244,6 +2243,8 @@ public:
EditorGroupTabs* _group_tabs;
void set_route_group_activation (ARDOUR::RouteGroup *, bool);
friend class Drag;
friend class RegionDrag;
friend class RegionMoveDrag;

114
gtk2_ardour/editor_edit_groups.cc
View file

@ -43,49 +43,49 @@ using namespace PBD;
using namespace Gtk;
void
Editor::build_edit_group_list_menu ()
Editor::build_route_group_list_menu ()
{
using namespace Gtk::Menu_Helpers;
edit_group_list_menu = new Menu;
edit_group_list_menu->set_name ("ArdourContextMenu");
MenuList& items = edit_group_list_menu->items();
route_group_list_menu = new Menu;
route_group_list_menu->set_name ("ArdourContextMenu");
MenuList& items = route_group_list_menu->items();
items.push_back (MenuElem (_("Activate All"), mem_fun(*this, &Editor::activate_all_edit_groups)));
items.push_back (MenuElem (_("Disable All"), mem_fun(*this, &Editor::disable_all_edit_groups)));
items.push_back (MenuElem (_("Activate All"), mem_fun(*this, &Editor::activate_all_route_groups)));
items.push_back (MenuElem (_("Disable All"), mem_fun(*this, &Editor::disable_all_route_groups)));
items.push_back (SeparatorElem());
items.push_back (MenuElem (_("Add group"), mem_fun(*this, &Editor::new_edit_group)));
items.push_back (MenuElem (_("Add group"), mem_fun(*this, &Editor::new_route_group)));
}
void
Editor::activate_all_edit_groups ()
Editor::activate_all_route_groups ()
{
Gtk::TreeModel::Children children = group_model->children();
for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
(*iter)[group_columns.is_active] = true;
}
session->foreach_route_group (bind (mem_fun (*this, &Editor::set_route_group_activation), true));
}
void
Editor::disable_all_edit_groups ()
Editor::disable_all_route_groups ()
{
Gtk::TreeModel::Children children = group_model->children();
for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
(*iter)[group_columns.is_active] = false;
}
session->foreach_route_group (bind (mem_fun (*this, &Editor::set_route_group_activation), false));
}
void
Editor::new_edit_group ()
Editor::set_route_group_activation (RouteGroup* g, bool a)
{
session->add_edit_group (new RouteGroup (*session, ""));
g->set_active (a, this);
}
void
Editor::remove_selected_edit_group ()
Editor::new_route_group ()
{
Glib::RefPtr<TreeSelection> selection = edit_group_display.get_selection();
session->add_route_group (new RouteGroup (*session, ""));
}
void
Editor::remove_selected_route_group ()
{
Glib::RefPtr<TreeSelection> selection = route_group_display.get_selection();
TreeView::Selection::ListHandle_Path rows = selection->get_selected_rows ();
if (rows.empty()) {
@ -102,25 +102,25 @@ Editor::remove_selected_edit_group ()
RouteGroup* rg = (*iter)[group_columns.routegroup];
if (rg) {
session->remove_edit_group (*rg);
session->remove_route_group (*rg);
}
}
}
void
Editor::edit_group_list_button_clicked ()
Editor::route_group_list_button_clicked ()
{
new_edit_group ();
new_route_group ();
}
gint
Editor::edit_group_list_button_press_event (GdkEventButton* ev)
Editor::route_group_list_button_press_event (GdkEventButton* ev)
{
if (Keyboard::is_context_menu_event (ev)) {
if (edit_group_list_menu == 0) {
build_edit_group_list_menu ();
if (route_group_list_menu == 0) {
build_route_group_list_menu ();
}
edit_group_list_menu->popup (1, ev->time);
route_group_list_menu->popup (1, ev->time);
return true;
}
@ -132,7 +132,7 @@ Editor::edit_group_list_button_press_event (GdkEventButton* ev)
int cellx;
int celly;
if (!edit_group_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
if (!route_group_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
return false;
}
@ -143,7 +143,7 @@ Editor::edit_group_list_button_press_event (GdkEventButton* ev)
if ((group = (*iter)[group_columns.routegroup]) != 0) {
// edit_route_group (group);
#ifdef GTKOSX
edit_group_display.queue_draw();
route_group_display.queue_draw();
#endif
return true;
}
@ -153,22 +153,11 @@ Editor::edit_group_list_button_press_event (GdkEventButton* ev)
break;
case 1:
if ((iter = group_model->get_iter (path))) {
bool active = (*iter)[group_columns.is_active];
(*iter)[group_columns.is_active] = !active;
#ifdef GTKOSX
edit_group_display.queue_draw();
#endif
return true;
}
break;
case 2:
if ((iter = group_model->get_iter (path))) {
bool visible = (*iter)[group_columns.is_visible];
(*iter)[group_columns.is_visible] = !visible;
#ifdef GTKOSX
edit_group_display.queue_draw();
route_group_display.queue_draw();
#endif
return true;
}
@ -182,11 +171,11 @@ Editor::edit_group_list_button_press_event (GdkEventButton* ev)
}
void
Editor::edit_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter)
Editor::route_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter)
{
RouteGroup* group;
if (in_edit_group_row_change) {
if (in_route_group_row_change) {
return;
}
@ -196,22 +185,18 @@ Editor::edit_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeM
if ((*iter)[group_columns.is_visible]) {
for (TrackViewList::iterator j = track_views.begin(); j != track_views.end(); ++j) {
if ((*j)->edit_group() == group) {
if ((*j)->route_group() == group) {
show_track_in_display (**j);
}
}
} else {
for (TrackViewList::iterator j = track_views.begin(); j != track_views.end(); ++j) {
if ((*j)->edit_group() == group) {
if ((*j)->route_group() == group) {
hide_track_in_display (**j);
}
}
}
bool active = (*iter)[group_columns.is_active];
group->set_active (active, this);
string name = (*iter)[group_columns.text];
if (name != group->name()) {
@ -220,16 +205,15 @@ Editor::edit_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeM
}
void
Editor::add_edit_group (RouteGroup* group)
Editor::add_route_group (RouteGroup* group)
{
ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::add_edit_group), group));
ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::add_route_group), group));
bool focus = false;
TreeModel::Row row = *(group_model->append());
row[group_columns.is_active] = group->is_active();
row[group_columns.is_visible] = !group->is_hidden();
in_edit_group_row_change = true;
in_route_group_row_change = true;
row[group_columns.routegroup] = group;
@ -243,20 +227,20 @@ Editor::add_edit_group (RouteGroup* group)
group->FlagsChanged.connect (bind (mem_fun(*this, &Editor::group_flags_changed), group));
if (focus) {
TreeViewColumn* col = edit_group_display.get_column (0);
CellRendererText* name_cell = dynamic_cast<CellRendererText*>(edit_group_display.get_column_cell_renderer (0));
edit_group_display.set_cursor (group_model->get_path (row), *col, *name_cell, true);
TreeViewColumn* col = route_group_display.get_column (0);
CellRendererText* name_cell = dynamic_cast<CellRendererText*>(route_group_display.get_column_cell_renderer (0));
route_group_display.set_cursor (group_model->get_path (row), *col, *name_cell, true);
}
in_edit_group_row_change = false;
in_route_group_row_change = false;
_group_tabs->set_dirty ();
}
void
Editor::edit_groups_changed ()
Editor::route_groups_changed ()
{
ENSURE_GUI_THREAD (mem_fun (*this, &Editor::edit_groups_changed));
ENSURE_GUI_THREAD (mem_fun (*this, &Editor::route_groups_changed));
/* just rebuild the while thing */
@ -265,13 +249,12 @@ Editor::edit_groups_changed ()
{
TreeModel::Row row;
row = *(group_model->append());
row[group_columns.is_active] = false;
row[group_columns.is_visible] = true;
row[group_columns.text] = (_("-all-"));
row[group_columns.routegroup] = 0;
}
session->foreach_edit_group (mem_fun (*this, &Editor::add_edit_group));
session->foreach_route_group (mem_fun (*this, &Editor::add_route_group));
}
void
@ -279,24 +262,23 @@ Editor::group_flags_changed (void* src, RouteGroup* group)
{
ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::group_flags_changed), src, group));
in_edit_group_row_change = true;
in_route_group_row_change = true;
Gtk::TreeModel::Children children = group_model->children();
for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
if (group == (*iter)[group_columns.routegroup]) {
(*iter)[group_columns.is_active] = group->is_active();
(*iter)[group_columns.is_visible] = !group->is_hidden();
(*iter)[group_columns.text] = group->name();
}
}
in_edit_group_row_change = false;
in_route_group_row_change = false;
_group_tabs->set_dirty ();
}
void
Editor::edit_group_name_edit (const Glib::ustring& path, const Glib::ustring& new_text)
Editor::route_group_name_edit (const Glib::ustring& path, const Glib::ustring& new_text)
{
RouteGroup* group;
TreeIter iter;

34
gtk2_ardour/editor_group_tabs.cc
View file

@ -32,25 +32,6 @@ EditorGroupTabs::EditorGroupTabs (Editor* e)
}
void
EditorGroupTabs::set_session (Session* s)
{
s->RouteEditGroupChanged.connect (mem_fun (*this, &EditorGroupTabs::set_dirty));
}
/** Handle a size request.
* @param req GTK requisition
*/
void
EditorGroupTabs::on_size_request (Gtk::Requisition *req)
{
/* Use a dummy, small height and the actual width that we want */
req->width = 16;
req->height = 16;
}
void
EditorGroupTabs::render (cairo_t* cr)
{
@ -71,7 +52,7 @@ EditorGroupTabs::render (cairo_t* cr)
continue;
}
RouteGroup* g = (*i)->edit_group ();
RouteGroup* g = (*i)->route_group ();
if (g != curr_group) {
if (curr_group) {
@ -122,8 +103,8 @@ EditorGroupTabs::draw_group (cairo_t* cr, int32_t y1, int32_t y2, RouteGroup* g,
cairo_restore (cr);
}
bool
EditorGroupTabs::on_button_press_event (GdkEventButton* ev)
RouteGroup*
EditorGroupTabs::click_to_route_group (GdkEventButton* ev)
{
int32_t y = 0;
Editor::TrackViewList::iterator i = _editor->track_views.begin();
@ -139,13 +120,8 @@ EditorGroupTabs::on_button_press_event (GdkEventButton* ev)
}
if (i == _editor->track_views.end()) {
return false;
return 0;
}
RouteGroup* g = (*i)->edit_group ();
if (g) {
g->set_active (!g->is_active (), this);
}
return true;
return (*i)->route_group ();
}

11
gtk2_ardour/editor_group_tabs.h
View file

@ -17,21 +17,20 @@
*/
#include "cairo_widget.h"
#include <gtkmm/menu.h>
#include "group_tabs.h"
class Editor;
class EditorGroupTabs : public CairoWidget
class EditorGroupTabs : public GroupTabs
{
public:
EditorGroupTabs (Editor *);
void set_session (ARDOUR::Session *);
private:
void on_size_request (Gtk::Requisition *);
bool on_button_press_event (GdkEventButton *);
ARDOUR::RouteGroup* click_to_route_group (GdkEventButton *);
void render (cairo_t *);
void draw_group (cairo_t *, int32_t, int32_t, ARDOUR::RouteGroup* , Gdk::Color const &);
Editor* _editor;

4
gtk2_ardour/editor_mixer.cc
View file

@ -370,7 +370,7 @@ Editor::session_going_away ()
region_list_display.set_model (Glib::RefPtr<Gtk::TreeStore>(0));
route_list_display.set_model (Glib::RefPtr<Gtk::TreeStore>(0));
named_selection_display.set_model (Glib::RefPtr<Gtk::TreeStore>(0));
edit_group_display.set_model (Glib::RefPtr<Gtk::TreeStore>(0));
route_group_display.set_model (Glib::RefPtr<Gtk::TreeStore>(0));
region_list_model->clear ();
route_display_model->clear ();
@ -380,7 +380,7 @@ Editor::session_going_away ()
region_list_display.set_model (region_list_model);
route_list_display.set_model (route_display_model);
named_selection_display.set_model (named_selection_model);
edit_group_display.set_model (group_model);
route_group_display.set_model (group_model);
edit_point_clock_connection_a.disconnect();
edit_point_clock_connection_b.disconnect();

15
gtk2_ardour/editor_selection.cc
View file

@ -274,7 +274,7 @@ Editor::get_relevant_tracks (set<RouteTimeAxisView*>& relevant_tracks)
continue;
}
RouteGroup* group = rtv->route()->edit_group();
RouteGroup* group = rtv->route()->route_group();
if (group && group->is_active()) {
@ -286,7 +286,7 @@ Editor::get_relevant_tracks (set<RouteTimeAxisView*>& relevant_tracks)
if ((trtv = dynamic_cast<RouteTimeAxisView*> (*i)) != 0) {
if (trtv->route()->edit_group() == group) {
if (trtv->route()->route_group() == group) {
relevant_tracks.insert (trtv);
}
}
@ -299,7 +299,7 @@ Editor::get_relevant_tracks (set<RouteTimeAxisView*>& relevant_tracks)
/**
* Call a slot for a given `basis' track and also for any track that is in the same
* active edit group.
* active route group with the `select' property.
* @param sl Slot to call.
* @param basis Basis track.
*/
@ -320,13 +320,13 @@ Editor::mapover_tracks (slot<void, RouteTimeAxisView&, uint32_t> sl, TimeAxisVie
/* always call for the basis */
tracks.insert (route_basis);
RouteGroup* group = route_basis->route()->edit_group();
if (group && group->is_active()) {
RouteGroup* group = route_basis->route()->route_group();
if (group && group->active_property (RouteGroup::Select)) {
/* the basis is a member of an active edit group; find other members */
for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
RouteTimeAxisView* v = dynamic_cast<RouteTimeAxisView*> (*i);
if (v && v->route()->edit_group() == group) {
if (v && v->route()->route_group() == group) {
tracks.insert (v);
}
}
@ -487,7 +487,8 @@ Editor::set_selected_regionview_from_click (bool press, Selection::Operation op,
case Selection::Set:
if (!selection->selected (clicked_regionview)) {
selection->set (clicked_regionview);
get_equivalent_regions (clicked_regionview, all_equivalent_regions);
selection->set (all_equivalent_regions);
commit = true;
} else {
/* no commit necessary: clicked on an already selected region */

6
gtk2_ardour/gain_meter.cc
View file

@ -274,7 +274,7 @@ GainMeterBase::peak_button_release (GdkEventButton* ev)
ResetAllPeakDisplays ();
} else if (ev->button == 1 && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
if (_route) {
ResetGroupPeakDisplays (_route->mix_group());
ResetGroupPeakDisplays (_route->route_group());
}
} else {
reset_peak_display ();
@ -296,7 +296,7 @@ GainMeterBase::reset_peak_display ()
void
GainMeterBase::reset_group_peak_display (RouteGroup* group)
{
if (_route && group == _route->mix_group()) {
if (_route && group == _route->route_group()) {
reset_peak_display ();
}
}
@ -542,7 +542,7 @@ GainMeterBase::set_mix_group_meter_point (Route& route, MeterPoint mp)
{
RouteGroup* mix_group;
if((mix_group = route.mix_group()) != 0){
if((mix_group = route.route_group()) != 0){
mix_group->apply (&Route::set_meter_point, mp, this);
} else {
route.set_meter_point (mp, this);

95
gtk2_ardour/group_tabs.cc Normal file
View file

@ -0,0 +1,95 @@
/*
Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <gtkmm/stock.h>
#include "ardour/session.h"
#include "ardour/route_group.h"
#include "route_group_dialog.h"
#include "group_tabs.h"
#include "i18n.h"
using namespace Gtk;
using namespace ARDOUR;
GroupTabs::GroupTabs ()
: _session (0),
_menu (0)
{
}
void
GroupTabs::set_session (Session* s)
{
_session = s;
s->RouteGroupChanged.connect (mem_fun (*this, &GroupTabs::set_dirty));
}
/** Handle a size request.
* @param req GTK requisition
*/
void
GroupTabs::on_size_request (Gtk::Requisition *req)
{
/* Use a dummy, small width and the actual height that we want */
req->width = 16;
req->height = 16;
}
bool
GroupTabs::on_button_press_event (GdkEventButton* ev)
{
using namespace Menu_Helpers;
RouteGroup* g = click_to_route_group (ev);
if (ev->button == 1 && g) {
g->set_active (!g->is_active (), this);
} else if (ev->button == 3 && g) {
if (!_menu) {
_menu = new Menu;
MenuList& items = _menu->items ();
items.push_back (MenuElem (_("Edit..."), bind (mem_fun (*this, &GroupTabs::edit_group), g)));
items.push_back (MenuElem (_("Remove"), bind (mem_fun (*this, &GroupTabs::remove_group), g)));
}
_menu->popup (ev->button, ev->time);
}
return true;
}
void
GroupTabs::edit_group (RouteGroup* g)
{
RouteGroupDialog d (g, Gtk::Stock::APPLY);
d.do_run ();
}
void
GroupTabs::remove_group (RouteGroup *g)
{
_session->remove_route_group (*g);
}

49
gtk2_ardour/group_tabs.h Normal file
View file

@ -0,0 +1,49 @@
/*
Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <gtkmm/menu.h>
#include "cairo_widget.h"
namespace ARDOUR {
class Session;
class RouteGroup;
}
class Editor;
class GroupTabs : public CairoWidget
{
public:
GroupTabs ();
void set_session (ARDOUR::Session *);
private:
virtual ARDOUR::RouteGroup* click_to_route_group (GdkEventButton* ev) = 0;
virtual void render (cairo_t *) = 0;
void on_size_request (Gtk::Requisition *);
bool on_button_press_event (GdkEventButton *);
void edit_group (ARDOUR::RouteGroup *);
void remove_group (ARDOUR::RouteGroup *);
ARDOUR::Session* _session;
Gtk::Menu* _menu;
};

33
gtk2_ardour/mixer_group_tabs.cc
View file

@ -33,24 +33,6 @@ MixerGroupTabs::MixerGroupTabs (Mixer_UI* m)
}
void
MixerGroupTabs::set_session (Session* s)
{
s->RouteMixGroupChanged.connect (mem_fun (*this, &MixerGroupTabs::set_dirty));
}
/** Handle a size request.
* @param req GTK requisition
*/
void
MixerGroupTabs::on_size_request (Gtk::Requisition *req)
{
/* Use a dummy, small width and the actual height that we want */
req->width = 16;
req->height = 16;
}
void
MixerGroupTabs::render (cairo_t* cr)
@ -72,7 +54,7 @@ MixerGroupTabs::render (cairo_t* cr)
continue;
}
RouteGroup* g = (*i)->mix_group ();
RouteGroup* g = (*i)->route_group ();
if (g != curr_group) {
if (curr_group) {
@ -121,8 +103,8 @@ MixerGroupTabs::draw_group (cairo_t* cr, int32_t x1, int32_t x2, RouteGroup* g,
cairo_restore (cr);
}
bool
MixerGroupTabs::on_button_press_event (GdkEventButton* ev)
RouteGroup*
MixerGroupTabs::click_to_route_group (GdkEventButton* ev)
{
int32_t x = 0;
list<MixerStrip*>::iterator i = _mixer->strips.begin();
@ -138,13 +120,8 @@ MixerGroupTabs::on_button_press_event (GdkEventButton* ev)
}
if (i == _mixer->strips.end()) {
return false;
return 0;
}
RouteGroup* g = (*i)->mix_group ();
if (g) {
g->set_active (!g->is_active (), this);
}
return true;
return (*i)->route_group ();
}

10
gtk2_ardour/mixer_group_tabs.h
View file

@ -17,21 +17,19 @@
*/
#include "cairo_widget.h"
#include "group_tabs.h"
class Mixer_UI;
class MixerGroupTabs : public CairoWidget
class MixerGroupTabs : public GroupTabs
{
public:
MixerGroupTabs (Mixer_UI *);
void set_session (ARDOUR::Session *);
private:
void on_size_request (Gtk::Requisition *);
bool on_button_press_event (GdkEventButton *);
ARDOUR::RouteGroup* click_to_route_group (GdkEventButton *);
void render (cairo_t *);
void draw_group (cairo_t *, int32_t, int32_t, ARDOUR::RouteGroup* , Gdk::Color const &);
Mixer_UI* _mixer;

46
gtk2_ardour/mixer_strip.cc
View file

@ -280,7 +280,7 @@ MixerStrip::init ()
show_sends_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::show_sends_release));
name_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::name_button_button_press), false);
group_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::select_mix_group), false);
group_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::select_route_group), false);
_width = (Width) -1;
@ -411,8 +411,8 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
mem_fun(*this, &MixerStrip::input_changed)));
connections.push_back (_route->output()->changed.connect (
mem_fun(*this, &MixerStrip::output_changed)));
connections.push_back (_route->mix_group_changed.connect (
mem_fun(*this, &MixerStrip::mix_group_changed)));
connections.push_back (_route->route_group_changed.connect (
mem_fun(*this, &MixerStrip::route_group_changed)));
if (_route->panner()) {
connections.push_back (_route->panner()->Changed.connect (
@ -441,7 +441,7 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
solo_changed (0);
name_changed ();
comment_changed (0);
mix_group_changed (0);
route_group_changed (0);
connect_to_pan ();
@ -611,7 +611,7 @@ MixerStrip::set_width_enum (Width w, void* owner)
}
update_input_display ();
update_output_display ();
mix_group_changed (0);
route_group_changed (0);
name_changed ();
#ifdef GTKOSX
WidthChanged();
@ -1065,27 +1065,27 @@ MixerStrip::comment_changed (void *src)
}
void
MixerStrip::set_mix_group (RouteGroup *rg)
MixerStrip::set_route_group (RouteGroup *rg)
{
_route->set_mix_group (rg, this);
_route->set_route_group (rg, this);
}
void
MixerStrip::add_mix_group_to_menu (RouteGroup *rg, RadioMenuItem::Group* group)
MixerStrip::add_route_group_to_menu (RouteGroup *rg, RadioMenuItem::Group* group)
{
using namespace Menu_Helpers;
MenuList& items = group_menu->items();
items.push_back (RadioMenuElem (*group, rg->name(), bind (mem_fun(*this, &MixerStrip::set_mix_group), rg)));
items.push_back (RadioMenuElem (*group, rg->name(), bind (mem_fun(*this, &MixerStrip::set_route_group), rg)));
if (_route->mix_group() == rg) {
if (_route->route_group() == rg) {
static_cast<RadioMenuItem*>(&items.back())->set_active ();
}
}
bool
MixerStrip::select_mix_group (GdkEventButton *ev)
MixerStrip::select_route_group (GdkEventButton *ev)
{
using namespace Menu_Helpers;
@ -1101,13 +1101,13 @@ MixerStrip::select_mix_group (GdkEventButton *ev)
items.clear ();
items.push_back (MenuElem (_("New group..."), mem_fun (*this, &MixerStrip::set_mix_group_to_new)));
items.push_back (MenuElem (_("New group..."), mem_fun (*this, &MixerStrip::set_route_group_to_new)));
items.push_back (SeparatorElem ());
items.push_back (RadioMenuElem (group, _("No group"), bind (mem_fun(*this, &MixerStrip::set_mix_group), (RouteGroup *) 0)));
items.push_back (RadioMenuElem (group, _("No group"), bind (mem_fun(*this, &MixerStrip::set_route_group), (RouteGroup *) 0)));
_session.foreach_mix_group (bind (mem_fun (*this, &MixerStrip::add_mix_group_to_menu), &group));
_session.foreach_route_group (bind (mem_fun (*this, &MixerStrip::add_route_group_to_menu), &group));
group_menu->popup (1, ev->time);
break;
@ -1120,11 +1120,11 @@ MixerStrip::select_mix_group (GdkEventButton *ev)
}
void
MixerStrip::mix_group_changed (void *ignored)
MixerStrip::route_group_changed (void *ignored)
{
ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::mix_group_changed), ignored));
ENSURE_GUI_THREAD(bind (mem_fun(*this, &MixerStrip::route_group_changed), ignored));
RouteGroup *rg = _route->mix_group();
RouteGroup *rg = _route->route_group();
if (rg) {
group_label.set_text (rg->name());
@ -1377,9 +1377,9 @@ MixerStrip::route_active_changed ()
}
RouteGroup*
MixerStrip::mix_group() const
MixerStrip::route_group() const
{
return _route->mix_group();
return _route->route_group();
}
void
@ -1484,17 +1484,17 @@ MixerStrip::revert_to_default_display ()
}
void
MixerStrip::set_mix_group_to_new ()
MixerStrip::set_route_group_to_new ()
{
RouteGroup* g = new RouteGroup (_session, "", RouteGroup::Active);
g->set_active (true, this);
RouteGroupDialog d (g);
RouteGroupDialog d (g, Gtk::Stock::NEW);
int const r = d.do_run ();
if (r == Gtk::RESPONSE_OK) {
_session.add_mix_group (g);
_route->set_mix_group (g, this);
_session.add_route_group (g);
_route->set_route_group (g, this);
} else {
delete g;
}

12
gtk2_ardour/mixer_strip.h
View file

@ -94,7 +94,7 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
void fast_update ();
void set_embedded (bool);
ARDOUR::RouteGroup* mix_group() const;
ARDOUR::RouteGroup* route_group() const;
void set_route (boost::shared_ptr<ARDOUR::Route>);
#ifdef GTKOSX
@ -226,10 +226,10 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
void comment_edited ();
bool ignore_comment_edit;
void set_mix_group (ARDOUR::RouteGroup *);
void add_mix_group_to_menu (ARDOUR::RouteGroup *, Gtk::RadioMenuItem::Group*);
bool select_mix_group (GdkEventButton *);
void mix_group_changed (void *);
void set_route_group (ARDOUR::RouteGroup *);
void add_route_group_to_menu (ARDOUR::RouteGroup *, Gtk::RadioMenuItem::Group*);
bool select_route_group (GdkEventButton *);
void route_group_changed (void *);
IOSelectorWindow *input_selector;
IOSelectorWindow *output_selector;
@ -257,7 +257,7 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
boost::shared_ptr<ARDOUR::Delivery> _current_delivery;
void revert_to_default_display ();
void set_mix_group_to_new ();
void set_route_group_to_new ();
static int scrollbar_height;
};

138
gtk2_ardour/mixer_ui.cc
View file

@ -66,7 +66,7 @@ Mixer_UI::Mixer_UI ()
session = 0;
_strip_width = Config->get_default_narrow_ms() ? Narrow : Wide;
track_menu = 0;
mix_group_context_menu = 0;
route_group_context_menu = 0;
no_track_list_redisplay = false;
in_group_row_change = false;
_visible = false;
@ -120,14 +120,11 @@ Mixer_UI::Mixer_UI ()
group_model = ListStore::create (group_columns);
group_display.set_model (group_model);
group_display.append_column (_("Group"), group_columns.text);
group_display.append_column (_("Active"), group_columns.active);
group_display.append_column (_("Show"), group_columns.visible);
group_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
group_display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
group_display.get_column (2)->set_data (X_("colnum"), GUINT_TO_POINTER(2));
group_display.get_column (0)->set_expand(true);
group_display.get_column (1)->set_expand(false);
group_display.get_column (2)->set_expand(false);
group_display.set_name ("MixerGroupList");
group_display.get_selection()->set_mode (Gtk::SELECTION_SINGLE);
group_display.set_reorderable (true);
@ -138,7 +135,7 @@ Mixer_UI::Mixer_UI ()
CellRendererText* name_cell = dynamic_cast<CellRendererText*>(group_display.get_column_cell_renderer (0));
name_cell->property_editable() = true;
name_cell->signal_edited().connect (mem_fun (*this, &Mixer_UI::mix_group_name_edit));
name_cell->signal_edited().connect (mem_fun (*this, &Mixer_UI::route_group_name_edit));
/* use checkbox for the active column */
@ -146,44 +143,38 @@ Mixer_UI::Mixer_UI ()
active_cell->property_activatable() = true;
active_cell->property_radio() = false;
/* use checkbox for the visible column */
active_cell = dynamic_cast<CellRendererToggle*>(group_display.get_column_cell_renderer (2));
active_cell->property_activatable() = true;
active_cell->property_radio() = false;
group_model->signal_row_changed().connect (mem_fun (*this, &Mixer_UI::mix_group_row_change));
group_model->signal_row_changed().connect (mem_fun (*this, &Mixer_UI::route_group_row_change));
group_display.signal_button_press_event().connect (mem_fun (*this, &Mixer_UI::group_display_button_press), false);
group_display_scroller.add (group_display);
group_display_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
HBox* mix_group_display_button_box = manage (new HBox());
HBox* route_group_display_button_box = manage (new HBox());
Button* mix_group_add_button = manage (new Button ());
Button* mix_group_remove_button = manage (new Button ());
Button* route_group_add_button = manage (new Button ());
Button* route_group_remove_button = manage (new Button ());
Widget* w;
w = manage (new Image (Stock::ADD, ICON_SIZE_BUTTON));
w->show();
mix_group_add_button->add (*w);
route_group_add_button->add (*w);
w = manage (new Image (Stock::REMOVE, ICON_SIZE_BUTTON));
w->show();
mix_group_remove_button->add (*w);
route_group_remove_button->add (*w);
mix_group_display_button_box->set_homogeneous (true);
route_group_display_button_box->set_homogeneous (true);
mix_group_add_button->signal_clicked().connect (mem_fun (*this, &Mixer_UI::new_mix_group));
mix_group_remove_button->signal_clicked().connect (mem_fun (*this, &Mixer_UI::remove_selected_mix_group));
route_group_add_button->signal_clicked().connect (mem_fun (*this, &Mixer_UI::new_route_group));
route_group_remove_button->signal_clicked().connect (mem_fun (*this, &Mixer_UI::remove_selected_route_group));
mix_group_display_button_box->add (*mix_group_remove_button);
mix_group_display_button_box->add (*mix_group_add_button);
route_group_display_button_box->add (*route_group_remove_button);
route_group_display_button_box->add (*route_group_add_button);
group_display_vbox.pack_start (group_display_scroller, true, true);
group_display_vbox.pack_start (*mix_group_display_button_box, false, false);
group_display_vbox.pack_start (*route_group_display_button_box, false, false);
track_display_frame.set_name("BaseFrame");
track_display_frame.set_shadow_type (Gtk::SHADOW_IN);
@ -235,9 +226,9 @@ Mixer_UI::Mixer_UI ()
_selection.RoutesChanged.connect (mem_fun(*this, &Mixer_UI::follow_strip_selection));
mix_group_display_button_box->show();
mix_group_add_button->show();
mix_group_remove_button->show();
route_group_display_button_box->show();
route_group_add_button->show();
route_group_remove_button->show();
global_hpacker.show();
global_vpacker.show();
@ -485,11 +476,11 @@ Mixer_UI::connect_to_session (Session* sess)
session->GoingAway.connect (mem_fun(*this, &Mixer_UI::disconnect_from_session));
session->RouteAdded.connect (mem_fun(*this, &Mixer_UI::add_strip));
session->mix_group_added.connect (mem_fun(*this, &Mixer_UI::add_mix_group));
session->mix_group_removed.connect (mem_fun(*this, &Mixer_UI::mix_groups_changed));
session->route_group_added.connect (mem_fun(*this, &Mixer_UI::add_route_group));
session->route_group_removed.connect (mem_fun(*this, &Mixer_UI::route_groups_changed));
session->config.ParameterChanged.connect (mem_fun (*this, &Mixer_UI::parameter_changed));
mix_groups_changed ();
route_groups_changed ();
_plugin_selector->set_session (session);
@ -1013,18 +1004,18 @@ Mixer_UI::strip_name_changed (MixerStrip* mx)
void
Mixer_UI::build_mix_group_context_menu ()
Mixer_UI::build_route_group_context_menu ()
{
using namespace Gtk::Menu_Helpers;
mix_group_context_menu = new Menu;
mix_group_context_menu->set_name ("ArdourContextMenu");
MenuList& items = mix_group_context_menu->items();
route_group_context_menu = new Menu;
route_group_context_menu->set_name ("ArdourContextMenu");
MenuList& items = route_group_context_menu->items();
items.push_back (MenuElem (_("Activate All"), mem_fun(*this, &Mixer_UI::activate_all_mix_groups)));
items.push_back (MenuElem (_("Disable All"), mem_fun(*this, &Mixer_UI::disable_all_mix_groups)));
items.push_back (MenuElem (_("Activate All"), mem_fun(*this, &Mixer_UI::activate_all_route_groups)));
items.push_back (MenuElem (_("Disable All"), mem_fun(*this, &Mixer_UI::disable_all_route_groups)));
items.push_back (SeparatorElem());
items.push_back (MenuElem (_("Add group"), mem_fun(*this, &Mixer_UI::new_mix_group)));
items.push_back (MenuElem (_("Add group"), mem_fun(*this, &Mixer_UI::new_route_group)));
}
@ -1032,10 +1023,10 @@ bool
Mixer_UI::group_display_button_press (GdkEventButton* ev)
{
if (Keyboard::is_context_menu_event (ev)) {
if (mix_group_context_menu == 0) {
build_mix_group_context_menu ();
if (route_group_context_menu == 0) {
build_route_group_context_menu ();
}
mix_group_context_menu->popup (1, ev->time);
route_group_context_menu->popup (1, ev->time);
return true;
}
@ -1056,7 +1047,7 @@ Mixer_UI::group_display_button_press (GdkEventButton* ev)
if (Keyboard::is_edit_event (ev)) {
if ((iter = group_model->get_iter (path))) {
if ((group = (*iter)[group_columns.group]) != 0) {
// edit_mix_group (group);
// edit_route_group (group);
#ifdef GTKOSX
group_display.queue_draw();
#endif
@ -1068,17 +1059,6 @@ Mixer_UI::group_display_button_press (GdkEventButton* ev)
break;
case 1:
if ((iter = group_model->get_iter (path))) {
bool active = (*iter)[group_columns.active];
(*iter)[group_columns.active] = !active;
#ifdef GTKOSX
group_display.queue_draw();
#endif
return true;
}
break;
case 2:
if ((iter = group_model->get_iter (path))) {
bool visible = (*iter)[group_columns.visible];
(*iter)[group_columns.visible] = !visible;
@ -1097,27 +1077,21 @@ Mixer_UI::group_display_button_press (GdkEventButton* ev)
}
void
Mixer_UI::activate_all_mix_groups ()
Mixer_UI::activate_all_route_groups ()
{
Gtk::TreeModel::Children children = group_model->children();
for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
(*iter)[group_columns.active] = true;
}
session->foreach_route_group (bind (mem_fun (*this, &Mixer_UI::set_route_group_activation), true));
}
void
Mixer_UI::disable_all_mix_groups ()
Mixer_UI::disable_all_route_groups ()
{
Gtk::TreeModel::Children children = group_model->children();
for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter) {
(*iter)[group_columns.active] = false;
}
session->foreach_route_group (bind (mem_fun (*this, &Mixer_UI::set_route_group_activation), false));
}
void
Mixer_UI::mix_groups_changed ()
Mixer_UI::route_groups_changed ()
{
ENSURE_GUI_THREAD (mem_fun (*this, &Mixer_UI::mix_groups_changed));
ENSURE_GUI_THREAD (mem_fun (*this, &Mixer_UI::route_groups_changed));
/* just rebuild the while thing */
@ -1126,23 +1100,22 @@ Mixer_UI::mix_groups_changed ()
{
TreeModel::Row row;
row = *(group_model->append());
row[group_columns.active] = false;
row[group_columns.visible] = true;
row[group_columns.text] = (_("-all-"));
row[group_columns.group] = 0;
}
session->foreach_mix_group (mem_fun (*this, &Mixer_UI::add_mix_group));
session->foreach_route_group (mem_fun (*this, &Mixer_UI::add_route_group));
}
void
Mixer_UI::new_mix_group ()
Mixer_UI::new_route_group ()
{
session->add_mix_group (new RouteGroup (*session, ""));
session->add_route_group (new RouteGroup (*session, ""));
}
void
Mixer_UI::remove_selected_mix_group ()
Mixer_UI::remove_selected_route_group ()
{
Glib::RefPtr<TreeSelection> selection = group_display.get_selection();
TreeView::Selection::ListHandle_Path rows = selection->get_selected_rows ();
@ -1161,7 +1134,7 @@ Mixer_UI::remove_selected_mix_group ()
RouteGroup* rg = (*iter)[group_columns.group];
if (rg) {
session->remove_mix_group (*rg);
session->remove_route_group (*rg);
}
}
}
@ -1180,8 +1153,8 @@ Mixer_UI::group_flags_changed (void* src, RouteGroup* group)
*/
for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
if ((*i)->mix_group() == group) {
(*i)->mix_group_changed(0);
if ((*i)->route_group() == group) {
(*i)->route_group_changed(0);
}
}
@ -1194,7 +1167,6 @@ Mixer_UI::group_flags_changed (void* src, RouteGroup* group)
for (i = rows.begin(); i != rows.end(); ++i) {
if ((*i)[group_columns.group] == group) {
(*i)[group_columns.visible] = !group->is_hidden ();
(*i)[group_columns.active] = group->is_active ();
(*i)[group_columns.text] = group->name ();
break;
}
@ -1206,7 +1178,7 @@ Mixer_UI::group_flags_changed (void* src, RouteGroup* group)
}
void
Mixer_UI::mix_group_name_edit (const Glib::ustring& path, const Glib::ustring& new_text)
Mixer_UI::route_group_name_edit (const Glib::ustring& path, const Glib::ustring& new_text)
{
RouteGroup* group;
TreeIter iter;
@ -1224,7 +1196,7 @@ Mixer_UI::mix_group_name_edit (const Glib::ustring& path, const Glib::ustring& n
}
void
Mixer_UI::mix_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter)
Mixer_UI::route_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter)
{
RouteGroup* group;
@ -1238,21 +1210,18 @@ Mixer_UI::mix_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::Tree
if ((*iter)[group_columns.visible]) {
for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
if ((*i)->mix_group() == group) {
if ((*i)->route_group() == group) {
show_strip (*i);
}
}
} else {
for (list<MixerStrip *>::iterator i = strips.begin(); i != strips.end(); ++i) {
if ((*i)->mix_group() == group) {
if ((*i)->route_group() == group) {
hide_strip (*i);
}
}
}
bool active = (*iter)[group_columns.active];
group->set_active (active, this);
Glib::ustring name = (*iter)[group_columns.text];
if (name != group->name()) {
@ -1262,15 +1231,14 @@ Mixer_UI::mix_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::Tree
}
void
Mixer_UI::add_mix_group (RouteGroup* group)
Mixer_UI::add_route_group (RouteGroup* group)
{
ENSURE_GUI_THREAD(bind (mem_fun(*this, &Mixer_UI::add_mix_group), group));
ENSURE_GUI_THREAD(bind (mem_fun(*this, &Mixer_UI::add_route_group), group));
bool focus = false;
in_group_row_change = true;
TreeModel::Row row = *(group_model->append());
row[group_columns.active] = group->is_active();
row[group_columns.visible] = true;
row[group_columns.group] = group;
if (!group->name().empty()) {
@ -1519,3 +1487,9 @@ Mixer_UI::parameter_changed (string const & p)
}
}
void
Mixer_UI::set_route_group_activation (RouteGroup* g, bool a)
{
g->set_active (a, this);
}

23
gtk2_ardour/mixer_ui.h
View file

@ -175,21 +175,21 @@ class Mixer_UI : public Gtk::Window
void show_all_audiotracks();
void hide_all_audiotracks ();
Gtk::Menu* mix_group_context_menu;
Gtk::Menu* route_group_context_menu;
bool in_group_row_change;
void group_selected (gint row, gint col, GdkEvent *ev);
void group_unselected (gint row, gint col, GdkEvent *ev);
void group_display_active_clicked();
void new_mix_group ();
void remove_selected_mix_group ();
void build_mix_group_context_menu ();
void activate_all_mix_groups ();
void disable_all_mix_groups ();
void add_mix_group (ARDOUR::RouteGroup *);
void mix_groups_changed ();
void mix_group_name_edit (const Glib::ustring&, const Glib::ustring&);
void mix_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter);
void new_route_group ();
void remove_selected_route_group ();
void build_route_group_context_menu ();
void activate_all_route_groups ();
void disable_all_route_groups ();
void add_route_group (ARDOUR::RouteGroup *);
void route_groups_changed ();
void route_group_name_edit (const Glib::ustring&, const Glib::ustring&);
void route_group_row_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter);
Gtk::Menu *track_menu;
void track_column_click (gint);
@ -218,12 +218,10 @@ class Mixer_UI : public Gtk::Window
struct GroupDisplayModelColumns : public Gtk::TreeModel::ColumnRecord {
GroupDisplayModelColumns() {
add (active);
add (visible);
add (text);
add (group);
}
Gtk::TreeModelColumn<bool> active;
Gtk::TreeModelColumn<bool> visible;
Gtk::TreeModelColumn<Glib::ustring> text;
Gtk::TreeModelColumn<ARDOUR::RouteGroup*> group;
@ -253,6 +251,7 @@ class Mixer_UI : public Gtk::Window
bool ignore_sync;
void parameter_changed (std::string const &);
void set_route_group_activation (ARDOUR::RouteGroup *, bool);
static const int32_t default_width = 478;
static const int32_t default_height = 765;

35
gtk2_ardour/route_group_dialog.cc
View file

@ -6,24 +6,44 @@
using namespace Gtk;
using namespace ARDOUR;
RouteGroupDialog::RouteGroupDialog (RouteGroup* g)
RouteGroupDialog::RouteGroupDialog (RouteGroup* g, StockID const & s)
: Dialog (_("Route group")),
_group (g),
_active (_("Active"))
_active (_("Active")),
_gain (_("Gain")),
_mute (_("Muting")),
_solo (_("Soloing")),
_rec_enable (_("Record enable")),
_select (_("Selection")),
_edit (_("Editing"))
{
_name.set_text (_group->name ());
_active.set_active (_group->is_active ());
_gain.set_active (_group->property (RouteGroup::Gain));
_mute.set_active (_group->property (RouteGroup::Mute));
_solo.set_active (_group->property (RouteGroup::Solo));
_rec_enable.set_active (_group->property (RouteGroup::RecEnable));
_select.set_active (_group->property (RouteGroup::Select));
_edit.set_active (_group->property (RouteGroup::Edit));
HBox* h = manage (new HBox);
h->pack_start (*manage (new Label (_("Name:"))));
h->pack_start (_name);
get_vbox()->pack_start (*h);
get_vbox()->pack_start (_active);
get_vbox()->pack_start (_gain);
get_vbox()->pack_start (_mute);
get_vbox()->pack_start (_solo);
get_vbox()->pack_start (_rec_enable);
get_vbox()->pack_start (_select);
get_vbox()->pack_start (_edit);
get_vbox()->set_border_width (8);
add_button (Stock::CANCEL, RESPONSE_CANCEL);
/* XXX: change this depending on context */
add_button (Stock::OK, RESPONSE_OK);
add_button (s, RESPONSE_OK);
show_all ();
}
@ -36,6 +56,13 @@ RouteGroupDialog::do_run ()
if (r == Gtk::RESPONSE_OK) {
_group->set_name (_name.get_text ());
_group->set_active (_active.get_active (), this);
_group->set_property (RouteGroup::Gain, _gain.get_active ());
_group->set_property (RouteGroup::Mute, _mute.get_active ());
_group->set_property (RouteGroup::Solo, _solo.get_active ());
_group->set_property (RouteGroup::RecEnable, _rec_enable.get_active ());
_group->set_property (RouteGroup::Select, _select.get_active ());
_group->set_property (RouteGroup::Edit, _edit.get_active ());
}
return r;

8
gtk2_ardour/route_group_dialog.h
View file

@ -8,7 +8,7 @@
class RouteGroupDialog : public Gtk::Dialog
{
public:
RouteGroupDialog (ARDOUR::RouteGroup *);
RouteGroupDialog (ARDOUR::RouteGroup *, Gtk::StockID const &);
int do_run ();
@ -16,6 +16,12 @@ private:
ARDOUR::RouteGroup* _group;
Gtk::Entry _name;
Gtk::CheckButton _active;
Gtk::CheckButton _gain;
Gtk::CheckButton _mute;
Gtk::CheckButton _solo;
Gtk::CheckButton _rec_enable;
Gtk::CheckButton _select;
Gtk::CheckButton _edit;
};

92
gtk2_ardour/route_time_axis.cc
View file

@ -105,7 +105,7 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
TimeAxisView(sess,ed,(TimeAxisView*) 0, canvas),
parent_canvas (canvas),
button_table (3, 3),
edit_group_button (_("g")), // group
route_group_button (_("g")), // group
playlist_button (_("p")),
size_button (_("h")), // height
automation_button (_("a")),
@ -134,14 +134,14 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
ignore_toggle = false;
edit_group_button.set_name ("TrackGroupButton");
route_group_button.set_name ("TrackGroupButton");
playlist_button.set_name ("TrackPlaylistButton");
automation_button.set_name ("TrackAutomationButton");
size_button.set_name ("TrackSizeButton");
visual_button.set_name ("TrackVisualButton");
hide_button.set_name ("TrackRemoveButton");
edit_group_button.unset_flags (Gtk::CAN_FOCUS);
route_group_button.unset_flags (Gtk::CAN_FOCUS);
playlist_button.unset_flags (Gtk::CAN_FOCUS);
automation_button.unset_flags (Gtk::CAN_FOCUS);
size_button.unset_flags (Gtk::CAN_FOCUS);
@ -151,7 +151,7 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
hide_button.add (*(manage (new Image (::get_icon("hide")))));
hide_button.show_all ();
edit_group_button.signal_button_release_event().connect (mem_fun(*this, &RouteTimeAxisView::edit_click), false);
route_group_button.signal_button_release_event().connect (mem_fun(*this, &RouteTimeAxisView::edit_click), false);
playlist_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::playlist_click));
automation_button.signal_clicked().connect (mem_fun(*this, &RouteTimeAxisView::automation_click));
size_button.signal_button_release_event().connect (mem_fun(*this, &RouteTimeAxisView::size_click), false);
@ -195,12 +195,12 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
controls_table.attach (*mute_button, 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
controls_table.attach (*solo_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
controls_table.attach (edit_group_button, 7, 8, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
controls_table.attach (route_group_button, 7, 8, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
controls_table.attach (gm.get_gain_slider(), 0, 5, 1, 2, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
ARDOUR_UI::instance()->tooltips().set_tip(*solo_button,_("Solo"));
ARDOUR_UI::instance()->tooltips().set_tip(*mute_button,_("Mute"));
ARDOUR_UI::instance()->tooltips().set_tip(edit_group_button,_("Edit Group"));
ARDOUR_UI::instance()->tooltips().set_tip(route_group_button, _("Route Group"));
ARDOUR_UI::instance()->tooltips().set_tip(size_button,_("Display Height"));
ARDOUR_UI::instance()->tooltips().set_tip(playlist_button,_("Playlist"));
ARDOUR_UI::instance()->tooltips().set_tip(automation_button, _("Automation"));
@ -311,51 +311,51 @@ gint
RouteTimeAxisView::edit_click (GdkEventButton *ev)
{
if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
_route->set_edit_group (0, this);
_route->set_route_group (0, this);
return FALSE;
}
using namespace Menu_Helpers;
MenuList& items = edit_group_menu.items ();
MenuList& items = route_group_menu.items ();
RadioMenuItem::Group group;
items.clear ();
items.push_back (MenuElem (_("New group..."), mem_fun (*this, &RouteTimeAxisView::set_edit_group_to_new)));
items.push_back (MenuElem (_("New group..."), mem_fun (*this, &RouteTimeAxisView::set_route_group_to_new)));
items.push_back (SeparatorElem ());
items.push_back (RadioMenuElem (group, _("No group"),
bind (mem_fun(*this, &RouteTimeAxisView::set_edit_group_from_menu), (RouteGroup *) 0)));
bind (mem_fun(*this, &RouteTimeAxisView::set_route_group_from_menu), (RouteGroup *) 0)));
if (_route->edit_group() == 0) {
if (_route->route_group() == 0) {
static_cast<RadioMenuItem*>(&items.back())->set_active ();
}
_session.foreach_edit_group (bind (mem_fun (*this, &RouteTimeAxisView::add_edit_group_menu_item), &group));
edit_group_menu.popup (ev->button, ev->time);
_session.foreach_route_group (bind (mem_fun (*this, &RouteTimeAxisView::add_route_group_menu_item), &group));
route_group_menu.popup (ev->button, ev->time);
return FALSE;
}
void
RouteTimeAxisView::add_edit_group_menu_item (RouteGroup *eg, RadioMenuItem::Group* group)
RouteTimeAxisView::add_route_group_menu_item (RouteGroup *eg, RadioMenuItem::Group* group)
{
using namespace Menu_Helpers;
MenuList &items = edit_group_menu.items();
MenuList &items = route_group_menu.items();
items.push_back (RadioMenuElem (*group, eg->name(), bind (mem_fun(*this, &RouteTimeAxisView::set_edit_group_from_menu), eg)));
if (_route->edit_group() == eg) {
items.push_back (RadioMenuElem (*group, eg->name(), bind (mem_fun(*this, &RouteTimeAxisView::set_route_group_from_menu), eg)));
if (_route->route_group() == eg) {
static_cast<RadioMenuItem*>(&items.back())->set_active ();
}
}
void
RouteTimeAxisView::set_edit_group_from_menu (RouteGroup *eg)
RouteTimeAxisView::set_route_group_from_menu (RouteGroup *eg)
{
_route->set_edit_group (eg, this);
_route->set_route_group (eg, this);
}
void
@ -733,18 +733,18 @@ RouteTimeAxisView::show_timestretch (nframes_t start, nframes_t end)
}
/* check that the time selection was made in our route, or our edit group.
remember that edit_group() == 0 implies the route is *not* in a edit group.
/* check that the time selection was made in our route, or our route group.
remember that route_group() == 0 implies the route is *not* in a edit group.
*/
if (!(ts.track == this || (ts.group != 0 && ts.group == _route->edit_group()))) {
if (!(ts.track == this || (ts.group != 0 && ts.group == _route->route_group()))) {
/* this doesn't apply to us */
return;
}
/* ignore it if our edit group is not active */
if ((ts.track != this) && _route->edit_group() && !_route->edit_group()->is_active()) {
if ((ts.track != this) && _route->route_group() && !_route->route_group()->is_active()) {
return;
}
#endif
@ -788,12 +788,12 @@ RouteTimeAxisView::show_selection (TimeSelection& ts)
#if 0
/* ignore it if our edit group is not active or if the selection was started
in some other track or edit group (remember that edit_group() == 0 means
that the track is not in an edit group).
in some other track or route group (remember that route_group() == 0 means
that the track is not in an route group).
*/
if (((ts.track != this && !is_child (ts.track)) && _route->edit_group() && !_route->edit_group()->is_active()) ||
(!(ts.track == this || is_child (ts.track) || (ts.group != 0 && ts.group == _route->edit_group())))) {
if (((ts.track != this && !is_child (ts.track)) && _route->route_group() && !_route->route_group()->is_active()) ||
(!(ts.track == this || is_child (ts.track) || (ts.group != 0 && ts.group == _route->route_group())))) {
hide_selection ();
return;
}
@ -836,7 +836,7 @@ RouteTimeAxisView::set_height (uint32_t h)
if (rec_enable_button)
rec_enable_button->show();
edit_group_button.show();
route_group_button.show();
hide_button.show();
visual_button.show();
size_button.show();
@ -862,7 +862,7 @@ RouteTimeAxisView::set_height (uint32_t h)
if (rec_enable_button)
rec_enable_button->show();
edit_group_button.hide ();
route_group_button.hide ();
hide_button.hide ();
visual_button.hide ();
size_button.hide ();
@ -895,7 +895,7 @@ RouteTimeAxisView::set_height (uint32_t h)
if (rec_enable_button)
rec_enable_button->hide();
edit_group_button.hide ();
route_group_button.hide ();
hide_button.hide ();
visual_button.hide ();
size_button.hide ();
@ -1018,9 +1018,9 @@ RouteTimeAxisView::rename_current_playlist ()
std::string
RouteTimeAxisView::resolve_new_group_playlist_name(std::string &basename, vector<boost::shared_ptr<Playlist> > const & playlists)
{
std::string ret(basename);
std::string ret (basename);
std::string group_string = "."+edit_group()->name()+".";
std::string const group_string = "." + route_group()->name() + ".";
// iterate through all playlists
int maxnumber = 0;
@ -1045,7 +1045,7 @@ RouteTimeAxisView::resolve_new_group_playlist_name(std::string &basename, vector
char buf[32];
snprintf (buf, sizeof(buf), "%d", maxnumber);
ret = this->name()+"."+edit_group()->name()+"."+buf;
ret = this->name() + "." + route_group()->name () + "." + buf;
return ret;
}
@ -1065,7 +1065,7 @@ RouteTimeAxisView::use_copy_playlist (bool prompt, vector<boost::shared_ptr<Play
name = pl->name();
if (edit_group() && edit_group()->is_active()) {
if (route_group() && route_group()->is_active()) {
name = resolve_new_group_playlist_name(name, playlists_before_op);
}
@ -1117,7 +1117,7 @@ RouteTimeAxisView::use_new_playlist (bool prompt, vector<boost::shared_ptr<Playl
name = pl->name();
if (edit_group() && edit_group()->is_active()) {
if (route_group() && route_group()->is_active()) {
name = resolve_new_group_playlist_name(name,playlists_before_op);
}
@ -1202,7 +1202,7 @@ RouteTimeAxisView::selection_click (GdkEventButton* ev)
return;
}
PublicEditor::TrackViewList* tracks = _editor.get_valid_views (this, _route->edit_group());
PublicEditor::TrackViewList* tracks = _editor.get_valid_views (this, _route->route_group());
switch (Keyboard::selection_type (ev->state)) {
case Selection::Toggle:
@ -1320,9 +1320,9 @@ RouteTimeAxisView::automation_track (AutomationType type)
}
RouteGroup*
RouteTimeAxisView::edit_group() const
RouteTimeAxisView::route_group () const
{
return _route->edit_group();
return _route->route_group();
}
string
@ -1552,7 +1552,7 @@ RouteTimeAxisView::build_playlist_menu (Gtk::Menu * menu)
playlist_items.push_back (MenuElem (_("Rename"), mem_fun(*this, &RouteTimeAxisView::rename_current_playlist)));
playlist_items.push_back (SeparatorElem());
if (!edit_group() || !edit_group()->is_active()) {
if (!route_group() || !route_group()->is_active()) {
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)));
@ -1592,9 +1592,9 @@ RouteTimeAxisView::use_playlist (boost::weak_ptr<Playlist> wpl)
get_diskstream()->use_playlist (apl);
if (edit_group() && edit_group()->is_active()) {
if (route_group() && route_group()->is_active()) {
//PBD::stacktrace(cerr, 20);
std::string group_string = "."+edit_group()->name()+".";
std::string group_string = "."+route_group()->name()+".";
std::string take_name = apl->name();
std::string::size_type idx = take_name.find(group_string);
@ -1604,7 +1604,7 @@ RouteTimeAxisView::use_playlist (boost::weak_ptr<Playlist> wpl)
take_name = take_name.substr(idx + group_string.length()); // find the bit containing the take number / name
for (list<Route*>::const_iterator i = edit_group()->route_list().begin(); i != edit_group()->route_list().end(); ++i) {
for (list<Route*>::const_iterator i = route_group()->route_list().begin(); i != route_group()->route_list().end(); ++i) {
if ( (*i) == this->route().get()) {
continue;
}
@ -2408,17 +2408,17 @@ RouteTimeAxisView::remove_underlay(StreamView* v)
}
void
RouteTimeAxisView::set_edit_group_to_new ()
RouteTimeAxisView::set_route_group_to_new ()
{
RouteGroup* g = new RouteGroup (_session, "", RouteGroup::Active);
g->set_active (true, this);
RouteGroupDialog d (g);
RouteGroupDialog d (g, Gtk::Stock::NEW);
int const r = d.do_run ();
if (r == Gtk::RESPONSE_OK) {
_session.add_edit_group (g);
_route->set_edit_group (g, this);
_session.add_route_group (g);
_route->set_route_group (g, this);
} else {
delete g;
}

12
gtk2_ardour/route_time_axis.h
View file

@ -138,7 +138,7 @@ public:
std::string name() const;
StreamView* view() const { return _view; }
ARDOUR::RouteGroup* edit_group() const;
ARDOUR::RouteGroup* route_group() const;
boost::shared_ptr<ARDOUR::Playlist> playlist() const;
void fast_update ();
@ -222,9 +222,9 @@ protected:
virtual void label_view ();
void add_edit_group_menu_item (ARDOUR::RouteGroup *, Gtk::RadioMenuItem::Group*);
void set_edit_group_from_menu (ARDOUR::RouteGroup *);
void set_edit_group_to_new ();
void add_route_group_menu_item (ARDOUR::RouteGroup *, Gtk::RadioMenuItem::Group*);
void set_route_group_from_menu (ARDOUR::RouteGroup *);
void set_route_group_to_new ();
void reset_samples_per_unit ();
@ -271,7 +271,7 @@ protected:
Gtk::HBox other_button_hbox;
Gtk::Table button_table;
Gtk::Button processor_button;
Gtk::Button edit_group_button;
Gtk::Button route_group_button;
Gtk::Button playlist_button;
Gtk::Button size_button;
Gtk::Button automation_button;
@ -280,7 +280,7 @@ protected:
Gtk::Menu subplugin_menu;
Gtk::Menu* automation_action_menu;
Gtk::Menu edit_group_menu;
Gtk::Menu route_group_menu;
Gtk::RadioMenuItem* align_existing_item;
Gtk::RadioMenuItem* align_capture_item;
Gtk::RadioMenuItem* normal_track_mode_item;

30
gtk2_ardour/route_ui.cc
View file

@ -284,7 +284,7 @@ RouteUI::mute_press(GdkEventButton* ev)
*/
if (ev->button == 1) {
set_mix_group_mute (_route, !_route->muted());
set_route_group_mute (_route, !_route->muted());
}
} else {
@ -417,7 +417,7 @@ RouteUI::solo_press(GdkEventButton* ev)
*/
if (ev->button == 1) {
set_mix_group_solo (_route, !_route->soloed());
set_route_group_solo (_route, !_route->soloed());
}
} else {
@ -500,7 +500,7 @@ RouteUI::rec_enable_press(GdkEventButton* ev)
NOTE: Primary-button2 is MIDI learn.
*/
set_mix_group_rec_enable (_route, !_route->record_enabled());
set_route_group_rec_enable (_route, !_route->record_enabled());
} else {
reversibly_apply_track_boolean ("rec-enable change", &Track::set_record_enable, !track()->record_enabled(), this);
@ -892,14 +892,14 @@ RouteUI::toggle_solo_isolated (Gtk::CheckMenuItem* check)
}
void
RouteUI::set_mix_group_solo(boost::shared_ptr<Route> route, bool yn)
RouteUI::set_route_group_solo(boost::shared_ptr<Route> route, bool yn)
{
RouteGroup* mix_group;
RouteGroup* route_group;
if((mix_group = route->mix_group()) != 0){
if((route_group = route->route_group()) != 0){
_session.begin_reversible_command (_("mix group solo change"));
Session::GlobalSoloStateCommand *cmd = new Session::GlobalSoloStateCommand(_session, this);
mix_group->apply(&Route::set_solo, yn, this);
route_group->apply(&Route::set_solo, yn, this);
cmd->mark();
_session.add_command (cmd);
_session.commit_reversible_command ();
@ -931,14 +931,14 @@ RouteUI::reversibly_apply_track_boolean (string name, void (Track::*func)(bool,
}
void
RouteUI::set_mix_group_mute(boost::shared_ptr<Route> route, bool yn)
RouteUI::set_route_group_mute(boost::shared_ptr<Route> route, bool yn)
{
RouteGroup* mix_group;
RouteGroup* route_group;
if((mix_group = route->mix_group()) != 0){
if((route_group = route->route_group()) != 0){
_session.begin_reversible_command (_("mix group mute change"));
Session::GlobalMuteStateCommand *cmd = new Session::GlobalMuteStateCommand (_session, this);
mix_group->apply(&Route::set_mute, yn, this);
route_group->apply(&Route::set_mute, yn, this);
cmd->mark();
_session.add_command(cmd);
_session.commit_reversible_command ();
@ -948,14 +948,14 @@ RouteUI::set_mix_group_mute(boost::shared_ptr<Route> route, bool yn)
}
void
RouteUI::set_mix_group_rec_enable(boost::shared_ptr<Route> route, bool yn)
RouteUI::set_route_group_rec_enable(boost::shared_ptr<Route> route, bool yn)
{
RouteGroup* mix_group;
RouteGroup* route_group;
if((mix_group = route->mix_group()) != 0){
if((route_group = route->route_group()) != 0){
_session.begin_reversible_command (_("mix group rec-enable change"));
Session::GlobalRecordEnableStateCommand *cmd = new Session::GlobalRecordEnableStateCommand(_session, this);
mix_group->apply (&Route::set_record_enable, yn, this);
route_group->apply (&Route::set_record_enable, yn, this);
cmd->mark();
_session.add_command(cmd);
_session.commit_reversible_command ();

6
gtk2_ardour/route_ui.h
View file

@ -138,9 +138,9 @@ class RouteUI : public virtual AxisView
void build_mute_menu(void);
void init_mute_menu(ARDOUR::MuteMaster::MutePoint, Gtk::CheckMenuItem*);
void set_mix_group_solo(boost::shared_ptr<ARDOUR::Route>, bool);
void set_mix_group_mute(boost::shared_ptr<ARDOUR::Route>, bool);
void set_mix_group_rec_enable(boost::shared_ptr<ARDOUR::Route>, bool);
void set_route_group_solo (boost::shared_ptr<ARDOUR::Route>, bool);
void set_route_group_mute (boost::shared_ptr<ARDOUR::Route>, bool);
void set_route_group_rec_enable (boost::shared_ptr<ARDOUR::Route>, bool);
int set_color_from_route ();

12
gtk2_ardour/selection.cc
View file

@ -270,18 +270,14 @@ Selection::add (const list<boost::shared_ptr<Playlist> >& pllist)
void
Selection::add (const list<TimeAxisView*>& track_list)
{
bool changed = false;
list<TimeAxisView*> added = tracks.add (track_list);
for (list<TimeAxisView*>::const_iterator i = track_list.begin(); i != track_list.end(); ++i) {
if (find (tracks.begin(), tracks.end(), (*i)) == tracks.end()) {
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)));
tracks.push_back (*i);
changed = true;
}
}
if (changed) {
if (!added.empty()) {
TracksChanged ();
}
}
@ -590,7 +586,7 @@ Selection::set (TimeAxisView* track, nframes_t start, nframes_t end)
if (track) {
time.track = track;
time.group = track->edit_group();
time.group = track->route_group();
} else {
time.track = 0;
time.group = 0;

2
gtk2_ardour/time_axis_view.h
View file

@ -163,7 +163,7 @@ class TimeAxisView : public virtual AxisView, public PBD::Stateful
*/
virtual void step_height (bool bigger);
virtual ARDOUR::RouteGroup* edit_group() const { return 0; }
virtual ARDOUR::RouteGroup* route_group() const { return 0; }
virtual boost::shared_ptr<ARDOUR::Playlist> playlist() const { return boost::shared_ptr<ARDOUR::Playlist> (); }
virtual void show_feature_lines (const ARDOUR::AnalysisFeatureList&);

19
gtk2_ardour/track_selection.cc Executable file
View file

@ -0,0 +1,19 @@
#include <algorithm>
#include "track_selection.h"
using namespace std;
list<TimeAxisView*>
TrackSelection::add (list<TimeAxisView*> const & t)
{
list<TimeAxisView*> added;
for (TrackSelection::const_iterator i = t.begin(); i != t.end(); ++i) {
if (find (begin(), end(), *i) == end()) {
added.push_back (*i);
push_back (*i);
}
}
return added;
}

6
gtk2_ardour/track_selection.h
View file

@ -24,6 +24,10 @@
class TimeAxisView;
struct TrackSelection : public std::list<TimeAxisView*> {};
class TrackSelection : public std::list<TimeAxisView*>
{
public:
std::list<TimeAxisView*> add (std::list<TimeAxisView*> const &);
};
#endif /* __ardour_gtk_track_selection_h__ */

2
gtk2_ardour/wscript
View file

@ -142,6 +142,7 @@ def build(bld):
generic_pluginui.cc
ghostregion.cc
global_port_matrix.cc
group_tabs.cc
gtk-custom-hruler.c
gtk-custom-ruler.c
io_selector.cc
@ -215,6 +216,7 @@ def build(bld):
time_axis_view_item.cc
time_fx_dialog.cc
time_selection.cc
track_selection.cc
ui_config.cc
utils.cc
version.cc

16
libs/ardour/ardour/route.h
View file

@ -139,13 +139,9 @@ class Route : public SessionObject, public AutomatableControls
void set_denormal_protection (bool yn);
bool denormal_protection() const;
void set_edit_group (RouteGroup *, void *);
void drop_edit_group (void *);
RouteGroup *edit_group () const { return _edit_group; }
void set_mix_group (RouteGroup *, void *);
void drop_mix_group (void *);
RouteGroup *mix_group () const { return _mix_group; }
void set_route_group (RouteGroup *, void *);
void drop_route_group (void *);
RouteGroup *route_group () const { return _route_group; }
virtual void set_meter_point (MeterPoint, void *src);
MeterPoint meter_point() const { return _meter_point; }
@ -243,8 +239,7 @@ class Route : public SessionObject, public AutomatableControls
sigc::signal<void,void*> main_outs_changed;
sigc::signal<void> processors_changed;
sigc::signal<void,void*> record_enable_changed;
sigc::signal<void,void*> edit_group_changed;
sigc::signal<void,void*> mix_group_changed;
sigc::signal<void,void*> route_group_changed;
sigc::signal<void,void*> meter_change;
sigc::signal<void> signal_latency_changed;
sigc::signal<void> initial_delay_changed;
@ -364,8 +359,7 @@ class Route : public SessionObject, public AutomatableControls
boost::shared_ptr<SoloControllable> _solo_control;
boost::shared_ptr<MuteMaster> _mute_master;
RouteGroup* _edit_group;
RouteGroup* _mix_group;
RouteGroup* _route_group;
std::string _comment;
bool _have_internal_generator;
bool _solo_safe;

31
libs/ardour/ardour/route_group.h
View file

@ -36,13 +36,22 @@ class AudioTrack;
class Session;
class RouteGroup : public PBD::Stateful, public sigc::trackable {
public:
public:
enum Flag {
Relative = 0x1,
Active = 0x2,
Hidden = 0x4
};
enum Property {
Gain = 0x1,
Mute = 0x2,
Solo = 0x4,
RecEnable = 0x8,
Select = 0x10,
Edit = 0x20
};
RouteGroup (Session& s, const std::string &n, Flag f = Flag(0));
const std::string& name() { return _name; }
@ -63,6 +72,21 @@ class RouteGroup : public PBD::Stateful, public sigc::trackable {
void set_relative (bool yn, void *src);
void set_hidden (bool yn, void *src);
bool property (Property p) const {
return ((_properties & p) != 0);
}
bool active_property (Property p) const {
return is_active() && property (p);
}
void set_property (Property p, bool v) {
_properties = (Property) (_properties & ~p);
if (v) {
_properties = (Property) (_properties | p);
}
}
int add (Route *);
int remove (Route *);
@ -103,15 +127,16 @@ class RouteGroup : public PBD::Stateful, public sigc::trackable {
sigc::signal<void> changed;
sigc::signal<void,void*> FlagsChanged;
XMLNode& get_state (void);
XMLNode& get_state ();
int set_state (const XMLNode&);
private:
private:
Session& _session;
std::list<Route *> routes;
std::string _name;
Flag _flags;
Property _properties;
void remove_when_going_away (Route*);
};

46
libs/ardour/ardour/session.h
View file

@ -377,8 +377,7 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
sigc::signal<void> Located;
sigc::signal<void,RouteList&> RouteAdded;
sigc::signal<void> RouteEditGroupChanged;
sigc::signal<void> RouteMixGroupChanged;
sigc::signal<void> RouteGroupChanged;
void request_roll_at_and_return (nframes_t start, nframes_t return_to);
void request_bounded_roll (nframes_t start, nframes_t end);
@ -487,28 +486,16 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
StateOfTheState state_of_the_state() const { return _state_of_the_state; }
void add_edit_group (RouteGroup *);
void add_mix_group (RouteGroup *);
void add_route_group (RouteGroup *);
void remove_route_group (RouteGroup&);
void remove_edit_group (RouteGroup&);
void remove_mix_group (RouteGroup&);
RouteGroup *route_group_by_name (std::string);
RouteGroup *mix_group_by_name (std::string);
RouteGroup *edit_group_by_name (std::string);
sigc::signal<void,RouteGroup*> route_group_added;
sigc::signal<void> route_group_removed;
sigc::signal<void,RouteGroup*> edit_group_added;
sigc::signal<void,RouteGroup*> mix_group_added;
sigc::signal<void> edit_group_removed;
sigc::signal<void> mix_group_removed;
void foreach_edit_group (sigc::slot<void,RouteGroup*> sl) {
for (std::list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); i++) {
sl (*i);
}
}
void foreach_mix_group (sigc::slot<void,RouteGroup*> sl) {
for (std::list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); i++) {
void foreach_route_group (sigc::slot<void,RouteGroup*> sl) {
for (std::list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); i++) {
sl (*i);
}
}
@ -516,13 +503,13 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
/* fundamental operations. duh. */
std::list<boost::shared_ptr<AudioTrack> > new_audio_track (
int input_channels, int output_channels, TrackMode mode = Normal, RouteGroup* edit_group = 0, uint32_t how_many = 1
int input_channels, int output_channels, TrackMode mode = Normal, RouteGroup* route_group = 0, uint32_t how_many = 1
);
RouteList new_audio_route (int input_channels, int output_channels, RouteGroup* edit_group, uint32_t how_many);
RouteList new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many);
std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
TrackMode mode = Normal, RouteGroup* edit_group = 0, uint32_t how_many = 1
TrackMode mode = Normal, RouteGroup* route_group = 0, uint32_t how_many = 1
);
void remove_route (boost::shared_ptr<Route>);
@ -1436,13 +1423,9 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
/* edit/mix groups */
int load_route_groups (const XMLNode&, bool is_edit);
int load_edit_groups (const XMLNode&);
int load_mix_groups (const XMLNode&);
int load_route_groups (const XMLNode&);
std::list<RouteGroup *> edit_groups;
std::list<RouteGroup *> mix_groups;
std::list<RouteGroup *> _route_groups;
/* disk-streams */
@ -1489,8 +1472,7 @@ class Session : public PBD::StatefulDestructible, public boost::noncopyable
int load_regions (const XMLNode& node);
void route_edit_group_changed ();
void route_mix_group_changed ();
void route_group_changed ();
/* SOURCES */

10
libs/ardour/enums.cc
View file

@ -89,6 +89,7 @@ setup_enum_writer ()
Diskstream::Flag _Diskstream_Flag;
Location::Flags _Location_Flags;
RouteGroup::Flag _RouteGroup_Flag;
RouteGroup::Property _RouteGroup_Property;
Region::Flag _Region_Flag;
Region::PositionLockStyle _Region_PositionLockStyle;
Track::FreezeState _Track_FreezeState;
@ -369,12 +370,19 @@ setup_enum_writer ()
REGISTER_CLASS_ENUM (Location, IsStart);
REGISTER_BITS (_Location_Flags);
REGISTER_CLASS_ENUM (RouteGroup, Relative);
REGISTER_CLASS_ENUM (RouteGroup, Active);
REGISTER_CLASS_ENUM (RouteGroup, Hidden);
REGISTER_BITS (_RouteGroup_Flag);
REGISTER_CLASS_ENUM (RouteGroup, Gain);
REGISTER_CLASS_ENUM (RouteGroup, Mute);
REGISTER_CLASS_ENUM (RouteGroup, Solo);
REGISTER_CLASS_ENUM (RouteGroup, RecEnable);
REGISTER_CLASS_ENUM (RouteGroup, Select);
REGISTER_CLASS_ENUM (RouteGroup, Edit);
REGISTER_BITS (_RouteGroup_Property);
REGISTER_CLASS_ENUM (Panner, SameDirection);
REGISTER_CLASS_ENUM (Panner, OppositeDirection);
REGISTER (_Panner_LinkDirection);

101
libs/ardour/route.cc
View file

@ -132,8 +132,7 @@ Route::init ()
_remote_control_id = 0;
_in_configure_processors = false;
_edit_group = 0;
_mix_group = 0;
_route_group = 0;
_phase_invert = 0;
_denormal_protection = false;
@ -260,9 +259,9 @@ Route::inc_gain (gain_t fraction, void *src)
void
Route::set_gain (gain_t val, void *src)
{
if (src != 0 && _mix_group && src != _mix_group && _mix_group->is_active()) {
if (src != 0 && _route_group && src != _route_group && _route_group->active_property (RouteGroup::Gain)) {
if (_mix_group->is_relative()) {
if (_route_group->is_relative()) {
gain_t usable_gain = _amp->gain();
if (usable_gain < 0.000001f) {
@ -282,24 +281,24 @@ Route::set_gain (gain_t val, void *src)
gain_t factor = delta / usable_gain;
if (factor > 0.0f) {
factor = _mix_group->get_max_factor(factor);
factor = _route_group->get_max_factor(factor);
if (factor == 0.0f) {
_amp->gain_control()->Changed(); /* EMIT SIGNAL */
return;
}
} else {
factor = _mix_group->get_min_factor(factor);
factor = _route_group->get_min_factor(factor);
if (factor == 0.0f) {
_amp->gain_control()->Changed(); /* EMIT SIGNAL */
return;
}
}
_mix_group->apply (&Route::inc_gain, factor, _mix_group);
_route_group->apply (&Route::inc_gain, factor, _route_group);
} else {
_mix_group->apply (&Route::set_gain, val, _mix_group);
_route_group->apply (&Route::set_gain, val, _route_group);
}
return;
@ -482,8 +481,8 @@ Route::set_solo (bool yn, void *src)
return;
}
if (_mix_group && src != _mix_group && _mix_group->is_active()) {
_mix_group->apply (&Route::set_solo, yn, _mix_group);
if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
_route_group->apply (&Route::set_solo, yn, _route_group);
return;
}
@ -539,8 +538,8 @@ Route::mod_solo_level (int32_t delta)
void
Route::set_solo_isolated (bool yn, void *src)
{
if (_mix_group && src != _mix_group && _mix_group->is_active()) {
_mix_group->apply (&Route::set_solo_isolated, yn, _mix_group);
if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
_route_group->apply (&Route::set_solo_isolated, yn, _route_group);
return;
}
@ -583,8 +582,8 @@ Route::solo_isolated () const
void
Route::set_mute (bool yn, void *src)
{
if (_mix_group && src != _mix_group && _mix_group->is_active()) {
_mix_group->apply (&Route::set_mute, yn, _mix_group);
if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Mute)) {
_route_group->apply (&Route::set_mute, yn, _route_group);
return;
}
@ -1480,11 +1479,8 @@ Route::state(bool full_state)
node->add_property("denormal-protection", _denormal_protection?"yes":"no");
node->add_property("meter-point", enum_2_string (_meter_point));
if (_edit_group) {
node->add_property("edit-group", _edit_group->name());
}
if (_mix_group) {
node->add_property("mix-group", _mix_group->name());
if (_route_group) {
node->add_property("route-group", _route_group->name());
}
string order_string;
@ -1630,12 +1626,12 @@ Route::_set_state (const XMLNode& node, bool call_base)
_meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
}
if ((prop = node.property (X_("edit-group"))) != 0) {
RouteGroup* edit_group = _session.edit_group_by_name(prop->value());
if(edit_group == 0) {
error << string_compose(_("Route %1: unknown edit group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
if ((prop = node.property (X_("route-group"))) != 0) {
RouteGroup* route_group = _session.route_group_by_name(prop->value());
if (route_group == 0) {
error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
} else {
set_edit_group(edit_group, this);
set_route_group (route_group, this);
}
}
@ -1703,15 +1699,6 @@ Route::_set_state (const XMLNode& node, bool call_base)
}
}
if ((prop = node.property (X_("mix-group"))) != 0) {
RouteGroup* mix_group = _session.mix_group_by_name(prop->value());
if (mix_group == 0) {
error << string_compose(_("Route %1: unknown mix group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
} else {
set_mix_group(mix_group, this);
}
}
return 0;
}
@ -1975,58 +1962,30 @@ Route::drop_listen (boost::shared_ptr<Route> route)
}
void
Route::set_edit_group (RouteGroup *eg, void *src)
Route::set_route_group (RouteGroup *rg, void *src)
{
if (eg == _edit_group) {
if (rg == _route_group) {
return;
}
if (_edit_group) {
_edit_group->remove (this);
if (_route_group) {
_route_group->remove (this);
}
if ((_edit_group = eg) != 0) {
_edit_group->add (this);
if ((_route_group = rg) != 0) {
_route_group->add (this);
}
_session.set_dirty ();
edit_group_changed (src); /* EMIT SIGNAL */
route_group_changed (src); /* EMIT SIGNAL */
}
void
Route::drop_edit_group (void *src)
Route::drop_route_group (void *src)
{
_edit_group = 0;
_route_group = 0;
_session.set_dirty ();
edit_group_changed (src); /* EMIT SIGNAL */
}
void
Route::set_mix_group (RouteGroup *mg, void *src)
{
if (mg == _mix_group) {
return;
}
if (_mix_group) {
_mix_group->remove (this);
}
if ((_mix_group = mg) != 0) {
_mix_group->add (this);
}
_session.set_dirty ();
mix_group_changed (src); /* EMIT SIGNAL */
}
void
Route::drop_mix_group (void *src)
{
_mix_group = 0;
_session.set_dirty ();
mix_group_changed (src); /* EMIT SIGNAL */
route_group_changed (src); /* EMIT SIGNAL */
}
void

7
libs/ardour/route_group.cc
View file

@ -39,7 +39,7 @@ using namespace sigc;
using namespace std;
RouteGroup::RouteGroup (Session& s, const string &n, Flag f)
: _session (s), _name (n), _flags (f)
: _session (s), _name (n), _flags (f), _properties (Property (0))
{
}
@ -130,6 +130,7 @@ RouteGroup::get_state (void)
XMLNode *node = new XMLNode ("RouteGroup");
node->add_property ("name", _name);
node->add_property ("flags", enum_2_string (_flags));
node->add_property ("properties", enum_2_string (_properties));
return *node;
}
@ -146,6 +147,10 @@ RouteGroup::set_state (const XMLNode& node)
_flags = Flag (string_2_enum (prop->value(), _flags));
}
if ((prop = node.property ("properties")) != 0) {
_properties = Property (string_2_enum (prop->value(), _properties));
}
return 0;
}

49
libs/ardour/session.cc
View file

@ -469,32 +469,12 @@ Session::destroy ()
}
sources.clear ();
#ifdef TRACK_DESTRUCTION
cerr << "delete mix groups\n";
#endif /* TRACK_DESTRUCTION */
for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); ) {
list<RouteGroup*>::iterator tmp;
tmp = i;
++tmp;
delete *i;
i = tmp;
}
#ifdef TRACK_DESTRUCTION
cerr << "delete edit groups\n";
cerr << "delete route groups\n";
#endif /* TRACK_DESTRUCTION */
for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ) {
list<RouteGroup*>::iterator tmp;
tmp = i;
++tmp;
for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ) {
delete *i;
i = tmp;
}
delete [] butler_mixdown_buffer;
@ -1480,7 +1460,7 @@ Session::resort_routes_using (shared_ptr<RouteList> r)
}
list<boost::shared_ptr<MidiTrack> >
Session::new_midi_track (TrackMode mode, RouteGroup* edit_group, uint32_t how_many)
Session::new_midi_track (TrackMode mode, RouteGroup* route_group, uint32_t how_many)
{
char track_name[32];
uint32_t track_id = 0;
@ -1589,7 +1569,7 @@ Session::new_midi_track (TrackMode mode, RouteGroup* edit_group, uint32_t how_ma
*/
track->midi_diskstream()->non_realtime_input_change();
track->set_edit_group (edit_group, 0);
track->set_route_group (route_group, 0);
track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
//track->set_remote_control_id (control_id);
@ -1646,7 +1626,7 @@ Session::new_midi_track (TrackMode mode, RouteGroup* edit_group, uint32_t how_ma
}
list<boost::shared_ptr<AudioTrack> >
Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* edit_group, uint32_t how_many)
Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many)
{
char track_name[32];
uint32_t track_id = 0;
@ -1758,7 +1738,7 @@ Session::new_audio_track (int input_channels, int output_channels, TrackMode mod
channels_used += track->n_inputs ().n_audio();
track->set_edit_group (edit_group, 0);
track->set_route_group (route_group, 0);
track->audio_diskstream()->non_realtime_input_change();
@ -1838,7 +1818,7 @@ Session::set_remote_control_ids ()
RouteList
Session::new_audio_route (int input_channels, int output_channels, RouteGroup* edit_group, uint32_t how_many)
Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many)
{
char bus_name[32];
uint32_t bus_id = 1;
@ -1937,7 +1917,7 @@ Session::new_audio_route (int input_channels, int output_channels, RouteGroup* e
channels_used += bus->n_inputs ().n_audio();
bus->set_edit_group (edit_group, 0);
bus->set_route_group (route_group, 0);
bus->set_remote_control_id (control_id);
++control_id;
@ -2082,8 +2062,7 @@ Session::add_routes (RouteList& new_routes, bool save)
(*x)->mute_changed.connect (mem_fun (*this, &Session::route_mute_changed));
(*x)->output()->changed.connect (mem_fun (*this, &Session::set_worst_io_latencies_x));
(*x)->processors_changed.connect (bind (mem_fun (*this, &Session::update_latency_compensation), false, false));
(*x)->edit_group_changed.connect (hide (mem_fun (*this, &Session::route_edit_group_changed)));
(*x)->mix_group_changed.connect (hide (mem_fun (*this, &Session::route_mix_group_changed)));
(*x)->route_group_changed.connect (hide (mem_fun (*this, &Session::route_group_changed)));
if ((*x)->is_master()) {
_master_out = (*x);
@ -4251,13 +4230,7 @@ Session::solo_model_changed ()
}
void
Session::route_edit_group_changed ()
Session::route_group_changed ()
{
RouteEditGroupChanged (); /* EMIT SIGNAL */
}
void
Session::route_mix_group_changed ()
{
RouteMixGroupChanged (); /* EMIT SIGNAL */
RouteGroupChanged (); /* EMIT SIGNAL */
}

101
libs/ardour/session_state.cc
View file

@ -1035,13 +1035,8 @@ Session::state(bool full_state)
}
child = node->add_child ("EditGroups");
for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ++i) {
child->add_child_nocopy ((*i)->get_state());
}
child = node->add_child ("MixGroups");
for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); ++i) {
child = node->add_child ("RouteGroups");
for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
child->add_child_nocopy ((*i)->get_state());
}
@ -1166,7 +1161,7 @@ Session::set_state (const XMLNode& node)
AudioDiskstreams
Connections
Routes
EditGroups
RouteGroups
MixGroups
Click
ControlProtocols
@ -1276,17 +1271,10 @@ Session::set_state (const XMLNode& node)
_bundle_xml_node = new XMLNode (*child);
}
if ((child = find_named_node (node, "EditGroups")) == 0) {
error << _("Session: XML state has no edit groups section") << endmsg;
if ((child = find_named_node (node, "RouteGroups")) == 0) {
error << _("Session: XML state has no route groups section") << endmsg;
goto out;
} else if (load_edit_groups (*child)) {
goto out;
}
if ((child = find_named_node (node, "MixGroups")) == 0) {
error << _("Session: XML state has no mix groups section") << endmsg;
goto out;
} else if (load_mix_groups (*child)) {
} else if (load_route_groups (*child)) {
goto out;
}
@ -2042,35 +2030,18 @@ Session::load_bundles (XMLNode const & node)
}
int
Session::load_edit_groups (const XMLNode& node)
{
return load_route_groups (node, true);
}
int
Session::load_mix_groups (const XMLNode& node)
{
return load_route_groups (node, false);
}
int
Session::load_route_groups (const XMLNode& node, bool edit)
Session::load_route_groups (const XMLNode& node)
{
XMLNodeList nlist = node.children();
XMLNodeConstIterator niter;
set_dirty();
set_dirty ();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
if ((*niter)->name() == "RouteGroup") {
RouteGroup* rg = new RouteGroup (*this, "");
if (edit) {
add_edit_group (rg);
add_route_group (rg);
rg->set_state (**niter);
} else {
add_mix_group (rg);
rg->set_state (**niter);
}
}
}
@ -2134,68 +2105,34 @@ Session::possible_states () const
}
void
Session::add_edit_group (RouteGroup* g)
Session::add_route_group (RouteGroup* g)
{
edit_groups.push_back (g);
edit_group_added (g); /* EMIT SIGNAL */
_route_groups.push_back (g);
route_group_added (g); /* EMIT SIGNAL */
set_dirty ();
}
void
Session::add_mix_group (RouteGroup* g)
{
mix_groups.push_back (g);
mix_group_added (g); /* EMIT SIGNAL */
set_dirty ();
}
void
Session::remove_edit_group (RouteGroup& rg)
Session::remove_route_group (RouteGroup& rg)
{
list<RouteGroup*>::iterator i;
if ((i = find (edit_groups.begin(), edit_groups.end(), &rg)) != edit_groups.end()) {
(*i)->apply (&Route::drop_edit_group, this);
edit_groups.erase (i);
edit_group_removed (); /* EMIT SIGNAL */
if ((i = find (_route_groups.begin(), _route_groups.end(), &rg)) != _route_groups.end()) {
(*i)->apply (&Route::drop_route_group, this);
_route_groups.erase (i);
route_group_removed (); /* EMIT SIGNAL */
}
delete &rg;
}
void
Session::remove_mix_group (RouteGroup& rg)
{
list<RouteGroup*>::iterator i;
if ((i = find (mix_groups.begin(), mix_groups.end(), &rg)) != mix_groups.end()) {
(*i)->apply (&Route::drop_mix_group, this);
mix_groups.erase (i);
mix_group_removed (); /* EMIT SIGNAL */
}
delete &rg;
}
RouteGroup *
Session::mix_group_by_name (string name)
Session::route_group_by_name (string name)
{
list<RouteGroup *>::iterator i;
for (i = mix_groups.begin(); i != mix_groups.end(); ++i) {
if ((*i)->name() == name) {
return* i;
}
}
return 0;
}
RouteGroup *
Session::edit_group_by_name (string name)
{
list<RouteGroup *>::iterator i;
for (i = edit_groups.begin(); i != edit_groups.end(); ++i) {
for (i = _route_groups.begin(); i != _route_groups.end(); ++i) {
if ((*i)->name() == name) {
return* i;
}

4
libs/ardour/track.cc
View file

@ -173,8 +173,8 @@ Track::set_record_enable (bool yn, void *src)
return;
}
if (_mix_group && src != _mix_group && _mix_group->is_active()) {
_mix_group->apply (&Track::set_record_enable, yn, _mix_group);
if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::RecEnable)) {
_route_group->apply (&Track::set_record_enable, yn, _route_group);
return;
}