replace_all (copy, "~", Glib::get_home_dir());
return copy;
}
-
+
ArdourStartup::ArdourStartup ()
- : applying (false)
+ : _response (RESPONSE_OK)
, ic_new_session_button (_("Open a new session"))
, ic_existing_session_button (_("Open an existing session"))
, monitor_via_hardware_button (_("Use an external mixer or the hardware mixer of your audio interface.\n\
Ardour will play NO role in monitoring"))
- , monitor_via_ardour_button (_("Ask Ardour to playback material as it is being recorded"))
+ , monitor_via_ardour_button (string_compose (_("Ask %1 to playback material as it is being recorded"), PROGRAM_NAME))
+ , use_monitor_section_button (_("Use a monitor bus in new sessions (more complex, more control)"))
+ , no_monitor_section_button (_("Just use the master out bus (simpler, less control)"))
, new_folder_chooser (FILE_CHOOSER_ACTION_SELECT_FOLDER)
, more_new_session_options_button (_("I'd like more options for this session"))
, _output_limit_count_adj (1, 0, 100, 1, 10, 0)
, _input_limit_count_adj (1, 0, 100, 1, 10, 0)
- , _control_bus_channel_count_adj (2, 0, 100, 1, 10, 0)
, _master_bus_channel_count_adj (2, 0, 100, 1, 10, 0)
{
set_resizable (false);
set_position (WIN_POS_CENTER);
set_border_width (12);
-
+
sys::path icon_file;
if (!find_file_in_search_path (ardour_search_path() + system_data_search_path().add_subdirectory_to_paths("icons"), "ardour_icon_48px.png", icon_file)) {
setup_new_user_page ();
setup_first_time_config_page ();
setup_monitoring_choice_page ();
+ setup_monitor_section_choice_page ();
if (need_audio_setup) {
setup_audio_page ();
should_be_new = false;
TreeIter iter = recent_session_display.get_selection()->get_selected();
-
+
if (iter) {
return (*iter)[recent_session_columns.visible_name];
}
ArdourStartup::session_folder ()
{
if (ic_new_session_button.get_active()) {
- return Glib::build_filename (new_folder_chooser.get_current_folder(), new_name_entry.get_text());
+ Glib::ustring legal_session_folder_name = legalize_for_path (new_name_entry.get_text());
+ return Glib::build_filename (new_folder_chooser.get_current_folder(), legal_session_folder_name);
} else {
TreeIter iter = recent_session_display.get_selection()->get_selected();
if (iter) {
return (*iter)[recent_session_columns.fullpath];
- }
+ }
return "";
}
}
audio_page_index = append_page (*engine_dialog);
set_page_type (*engine_dialog, ASSISTANT_PAGE_CONTENT);
set_page_title (*engine_dialog, _("Audio Setup"));
-
+
/* the default parameters should work, so the page is potentially complete */
set_page_complete (*engine_dialog, true);
{
Label* foomatic = manage (new Label);
- foomatic->set_markup (_("\
-<span size=\"larger\">Ardour is a digital audio workstation. You can use it to\n\
+ foomatic->set_markup (string_compose (_("\
+<span size=\"larger\">%1 is a digital audio workstation. You can use it to\n\
record, edit and mix multi-track audio. You can produce your\n\
own CDs, mix video soundtracks, or just experiment with new\n\
ideas about music and sound.\n\
\n\
There are a few things that need to configured before you start\n\
using the program.</span>\
-"));
-
+"), PROGRAM_NAME));
+
HBox* hbox = manage (new HBox);
HBox* vbox = manage (new HBox);
ArdourStartup::default_dir_changed ()
{
Config->set_default_session_parent_dir (default_dir_chooser->get_current_folder());
+ config_changed ();
+}
+
+void
+ArdourStartup::config_changed ()
+{
config_modified = true;
}
void
ArdourStartup::setup_first_time_config_page ()
{
- default_dir_chooser = manage (new FileChooserButton (_("Default folder for Ardour sessions"),
+ default_dir_chooser = manage (new FileChooserButton (string_compose (_("Default folder for %1 sessions"), PROGRAM_NAME),
FILE_CHOOSER_ACTION_SELECT_FOLDER));
Gtk::Label* txt = manage (new Label);
HBox* hbox = manage (new HBox);
VBox* vbox = manage (new VBox);
-
+
txt->set_markup (_("\
Each project that you work on with Ardour has its own folder.\n\
These can require a lot of disk space if you are recording audio.\n\
vbox->pack_start (*hbox, false, true);
default_dir_chooser->set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
- default_dir_chooser->signal_current_folder_changed().connect (mem_fun (*this, &ArdourStartup::default_dir_changed));
+ default_dir_chooser->signal_current_folder_changed().connect (sigc::mem_fun (*this, &ArdourStartup::default_dir_changed));
default_dir_chooser->show ();
vbox->show_all ();
{
mon_vbox.set_spacing (18);
mon_vbox.set_border_width (24);
-
+
HBox* hbox = manage (new HBox);
VBox* vbox = manage (new VBox);
RadioButton::Group g (monitor_via_hardware_button.get_group());
different ways to do this depending on the equipment you have and the\n\
configuration of that equipment. The two most common are presented here.\n\
Please choose whichever one is right for your setup.\n\n\
-<i>(You can change this preference at any time, via the Options menu)</i>");
+<i>(You can change this preference at any time, via the Preferences dialog)</i>");
monitor_label.set_alignment (0.0, 0.0);
vbox->set_spacing (6);
set_page_complete (mon_vbox, true);
}
+void
+ArdourStartup::setup_monitor_section_choice_page ()
+{
+ mon_sec_vbox.set_spacing (18);
+ mon_sec_vbox.set_border_width (24);
+
+ HBox* hbox = manage (new HBox);
+ VBox* vbox = manage (new VBox);
+ RadioButton::Group g (use_monitor_section_button.get_group());
+ no_monitor_section_button.set_group (g);
+
+ if (Config->get_use_monitor_bus()) {
+ use_monitor_section_button.set_active (true);
+ } else {
+ no_monitor_section_button.set_active (true);
+ }
+
+ use_monitor_section_button.signal_toggled().connect (sigc::mem_fun (*this, &ArdourStartup::config_changed));
+ no_monitor_section_button.signal_toggled().connect (sigc::mem_fun (*this, &ArdourStartup::config_changed));
+
+ monitor_section_label.set_markup("\
+When connecting speakers to Ardour, would you prefer to use a monitor bus,\n\
+which will offer various kinds of control at the last stage of output\n\
+or would you prefer to just connect directly to the master outs?\n\n\
+Most home studio users will probably want to start <i>without</i> a monitor bus.\n\
+Those with experience of traditional mixing consoles may prefer to use one.\n\
+Please choose whichever one is right for your setup.\n\n\
+<i>(You can change this preference at any time, via the Preferences dialog)</i>");
+ monitor_section_label.set_alignment (0.0, 0.0);
+
+ vbox->set_spacing (6);
+
+ vbox->pack_start (no_monitor_section_button, false, true);
+ vbox->pack_start (use_monitor_section_button, false, true);
+ hbox->pack_start (*vbox, true, true, 8);
+ mon_sec_vbox.pack_start (monitor_section_label, false, false);
+ mon_sec_vbox.pack_start (*hbox, false, false);
+
+ mon_sec_vbox.show_all ();
+
+ monitor_section_page_index = append_page (mon_sec_vbox);
+ set_page_title (mon_sec_vbox, _("Monitor Section"));
+ set_page_header_image (mon_sec_vbox, icon_pixbuf);
+
+ /* user could just click on "Forward" if default
+ * choice is correct.
+ */
+
+ set_page_complete (mon_sec_vbox, true);
+}
+
void
ArdourStartup::setup_initial_choice_page ()
{
HBox* centering_hbox = manage (new HBox);
VBox* centering_vbox = manage (new VBox);
-
+
centering_vbox->set_spacing (6);
centering_vbox->pack_start (ic_new_session_button, false, true);
centering_vbox->pack_start (ic_existing_session_button, false, true);
+ ic_new_session_button.signal_button_press_event().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_press), false);
+ ic_new_session_button.signal_activate().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_activated), false);
+
+ ic_existing_session_button.signal_button_press_event().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_press), false);
+ ic_existing_session_button.signal_activate().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_activated), false);
+
centering_hbox->pack_start (*centering_vbox, true, true);
ic_vbox.pack_start (*centering_hbox, true, true);
set_page_complete (ic_vbox, true);
}
+bool
+ArdourStartup::initial_button_press (GdkEventButton *event)
+{
+ if (event && event->type == GDK_2BUTTON_PRESS && session_page_index != -1)
+ {
+ set_current_page(session_page_index);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+void
+ArdourStartup::initial_button_activated ()
+{
+ set_current_page(session_page_index);
+}
+
void
ArdourStartup::setup_session_page ()
{
void
ArdourStartup::setup_final_page ()
{
- final_page.set_text ("Ardour is ready for use");
+ final_page.set_text (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
final_page.show ();
final_page_index = append_page (final_page);
set_page_complete (final_page, true);
void
ArdourStartup::on_cancel ()
{
- exit (1);
+ _response = RESPONSE_CANCEL;
+ gtk_main_quit ();
}
-void
-ArdourStartup::on_close ()
+bool
+ArdourStartup::on_delete_event (GdkEventAny*)
{
- if (!applying) {
- exit (1);
- }
+ _response = RESPONSE_CLOSE;
+ gtk_main_quit ();
+ return true;
}
void
ArdourStartup::on_apply ()
{
- applying = true;
-
- // XXX do stuff and then ....
-
if (engine_dialog) {
engine_dialog->setup_engine ();
}
if (default_dir_chooser) {
Config->set_default_session_parent_dir (default_dir_chooser->get_current_folder());
}
-
+
if (monitor_via_hardware_button.get_active()) {
Config->set_monitoring_model (ExternalMonitoring);
} else if (monitor_via_ardour_button.get_active()) {
Config->set_monitoring_model (SoftwareMonitoring);
}
-
+
+ Config->set_use_monitor_bus (use_monitor_section_button.get_active());
+
Config->save_state ();
}
+ _response = RESPONSE_OK;
gtk_main_quit ();
}
ArdourStartup::on_prepare (Gtk::Widget* page)
{
if (page == &session_vbox) {
-
+
if (ic_new_session_button.get_active()) {
/* new session requested */
setup_new_session_page ();
/* existing session requested */
setup_existing_session_page ();
}
- }
+ }
}
void
ArdourStartup::populate_session_templates ()
{
vector<TemplateInfo> templates;
-
+
find_session_templates (templates);
template_model->clear ();
TreeModel::Row row;
row = *(template_model->append ());
-
+
row[session_template_columns.name] = (*x).name;
row[session_template_columns.path] = (*x).path;
}
}
+static bool
+lost_name_entry_focus (GdkEventFocus* ev)
+{
+ cerr << "lost focus\n";
+ return false;
+}
+
void
ArdourStartup::setup_new_session_page ()
{
VBox *vbox1 = manage (new VBox);
HBox* hbox1 = manage (new HBox);
Label* label1 = manage (new Label);
-
+
vbox1->set_spacing (6);
hbox1->set_spacing (6);
hbox1->pack_start (*label1, false, false);
hbox1->pack_start (new_name_entry, true, true);
-
+
label1->set_text (_("Session name:"));
-
+
if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
new_name_entry.set_text (Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name));
/* name provided - they can move right along */
set_page_complete (session_vbox, true);
}
-
- new_name_entry.signal_changed().connect (mem_fun (*this, &ArdourStartup::new_name_changed));
- new_name_entry.signal_activate().connect (mem_fun (*this, &ArdourStartup::move_along_now));
-
+
+ new_name_entry.signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::new_name_changed));
+ new_name_entry.signal_activate().connect (sigc::mem_fun (*this, &ArdourStartup::move_along_now));
+
vbox1->pack_start (*hbox1, true, true);
/* --- */
HBox* hbox2 = manage (new HBox);
Label* label2 = manage (new Label);
-
+
hbox2->set_spacing (6);
hbox2->pack_start (*label2, false, false);
hbox2->pack_start (new_folder_chooser, true, true);
-
+
label2->set_text (_("Create session folder in:"));
-
+
if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
new_folder_chooser.set_current_folder (poor_mans_glob (Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name)));
} else {
populate_session_templates ();
vbox2->set_spacing (6);
-
+
label3->set_markup (_("<b>Options</b>"));
label3->set_alignment (0.0, 0.0);
hbox4a->set_spacing (6);
hbox4a->pack_start (use_template_button, false, false);
hbox4a->pack_start (template_chooser, true, true);
-
+
template_chooser.set_model (template_model);
-
+
Gtk::CellRendererText* text_renderer = Gtk::manage (new Gtk::CellRendererText);
text_renderer->property_editable() = false;
-
+
template_chooser.pack_start (*text_renderer);
template_chooser.add_attribute (text_renderer->property_text(), session_template_columns.name);
template_chooser.set_active (0);
-
+
use_template_button.show();
template_chooser.show ();
vbox3->pack_start (*hbox4a, false, false);
}
-
+
/* --- */
if (!new_user) {
session_template_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
-
+
HBox* hbox4b = manage (new HBox);
use_session_as_template_button.set_label (_("Use an existing session as a template:"));
-
+
hbox4b->set_spacing (6);
hbox4b->pack_start (use_session_as_template_button, false, false);
hbox4b->pack_start (session_template_chooser, true, true);
-
+
use_session_as_template_button.show ();
session_template_chooser.show ();
-
+
Gtk::FileFilter* template_filter = manage (new (Gtk::FileFilter));
template_filter->add_pattern(X_("*.template"));
session_template_chooser.set_filter (*template_filter);
}
/* --- */
-
+
HBox* hbox5 = manage (new HBox);
-
+
hbox5->set_spacing (6);
hbox5->pack_start (more_new_session_options_button, false, false);
-
+
more_new_session_options_button.show ();
- more_new_session_options_button.signal_clicked().connect (mem_fun (*this, &ArdourStartup::more_new_session_options_button_clicked));
+ more_new_session_options_button.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::more_new_session_options_button_clicked));
vbox3->pack_start (*hbox5, false, false);
hbox3->pack_start (*vbox3, true, true, 8);
set_page_title (session_vbox, _("New Session"));
set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
+ new_name_entry.signal_map().connect (sigc::mem_fun (*this, &ArdourStartup::new_name_mapped));
+ new_name_entry.signal_focus_out_event().connect (sigc::ptr_fun (lost_name_entry_focus));
+}
+
+void
+ArdourStartup::new_name_mapped ()
+{
+ cerr << "Grab new name focus\n";
new_name_entry.grab_focus ();
}
}
}
-void
+int
ArdourStartup::redisplay_recent_sessions ()
{
std::vector<sys::path> session_directories;
RecentSessionsSorter cmp;
-
+
recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
recent_session_model->clear ();
if (rs.empty()) {
recent_session_display.set_model (recent_session_model);
- return;
+ return 0;
}
//
// sort them alphabetically
sort (rs.begin(), rs.end(), cmp);
-
+
for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
session_directories.push_back ((*i).second);
}
-
+
for (vector<sys::path>::const_iterator i = session_directories.begin(); i != session_directories.end(); ++i)
{
std::vector<sys::path> state_file_paths;
vector<string*>* states;
vector<const gchar*> item;
string fullpath = (*i).to_string();
-
+
/* remove any trailing / */
if (fullpath[fullpath.length()-1] == '/') {
if (!Glib::file_test(fullpath.c_str(), Glib::FILE_TEST_EXISTS)) {
/* session doesn't exist */
continue;
- }
-
+ }
+
/* now get available states for this session */
if ((states = Session::possible_states (fullpath)) == 0) {
/* no state file? */
continue;
}
-
+
std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
Gtk::TreeModel::Row row = *(recent_session_model->append());
row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
row[recent_session_columns.fullpath] = fullpath;
-
+
if (state_file_names.size() > 1) {
// add the children
}
recent_session_display.set_model (recent_session_model);
+ return rs.size();
}
void
recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
recent_session_display.set_headers_visible (false);
recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
-
- recent_session_display.get_selection()->signal_changed().connect (mem_fun (*this, &ArdourStartup::recent_session_row_selected));
-
+
+ recent_session_display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::recent_session_row_selected));
+
recent_scroller.add (recent_session_display);
recent_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
recent_scroller.set_shadow_type (Gtk::SHADOW_IN);
-
+
recent_session_display.show();
}
recent_scroller.show();
- redisplay_recent_sessions ();
- recent_session_display.signal_row_activated().connect (mem_fun (*this, &ArdourStartup::recent_row_activated));
+ int cnt = redisplay_recent_sessions ();
+ recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ArdourStartup::recent_row_activated));
+
+ if (cnt > 4) {
+ recent_scroller.set_size_request (-1, 300);
+ }
session_hbox.pack_start (recent_scroller, true, true);
set_page_title (session_vbox, _("Select a session"));
_output_limit_count.set_adjustment (_output_limit_count_adj);
_input_limit_count.set_adjustment (_input_limit_count_adj);
- _control_bus_channel_count.set_adjustment (_control_bus_channel_count_adj);
_master_bus_channel_count.set_adjustment (_master_bus_channel_count_adj);
-
+
chan_count_label_1.set_text (_("channels"));
- chan_count_label_2.set_text (_("channels"));
chan_count_label_3.set_text (_("channels"));
chan_count_label_4.set_text (_("channels"));
chan_count_label_1.set_padding(0,0);
chan_count_label_1.set_line_wrap(false);
- chan_count_label_2.set_alignment(0,0.5);
- chan_count_label_2.set_padding(0,0);
- chan_count_label_2.set_line_wrap(false);
-
chan_count_label_3.set_alignment(0,0.5);
chan_count_label_3.set_padding(0,0);
chan_count_label_3.set_line_wrap(false);
input_label.set_markup (_("<b>Inputs</b>"));
output_label.set_markup (_("<b>Outputs</b>"));
- _create_control_bus.set_label (_("Create monitor bus"));
- _create_control_bus.set_flags(Gtk::CAN_FOCUS);
- _create_control_bus.set_relief(Gtk::RELIEF_NORMAL);
- _create_control_bus.set_mode(true);
- _create_control_bus.set_active(false);
- _create_control_bus.set_border_width(0);
-
- _control_bus_channel_count.set_flags(Gtk::CAN_FOCUS);
- _control_bus_channel_count.set_update_policy(Gtk::UPDATE_ALWAYS);
- _control_bus_channel_count.set_numeric(true);
- _control_bus_channel_count.set_digits(0);
- _control_bus_channel_count.set_wrap(false);
- _control_bus_channel_count.set_sensitive(false);
-
_master_bus_channel_count.set_flags(Gtk::CAN_FOCUS);
_master_bus_channel_count.set_update_policy(Gtk::UPDATE_ALWAYS);
_master_bus_channel_count.set_numeric(true);
advanced_table.set_row_spacings(0);
advanced_table.set_col_spacings(0);
-
+
_connect_inputs.set_label (_("Automatically connect to physical_inputs"));
_connect_inputs.set_flags(Gtk::CAN_FOCUS);
_connect_inputs.set_relief(Gtk::RELIEF_NORMAL);
_connect_inputs.set_mode(true);
_connect_inputs.set_active(true);
_connect_inputs.set_border_width(0);
-
+
_limit_input_ports.set_label (_("Use only"));
_limit_input_ports.set_flags(Gtk::CAN_FOCUS);
_limit_input_ports.set_relief(Gtk::RELIEF_NORMAL);
bus_frame.set_label_align(0,0.5);
bus_frame.add(bus_hbox);
bus_frame.set_label_widget(bus_label);
-
+
bus_table.set_row_spacings (0);
bus_table.set_col_spacings (0);
bus_table.attach (_create_master_bus, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
bus_table.attach (_master_bus_channel_count, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
bus_table.attach (chan_count_label_1, 2, 3, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 0);
- bus_table.attach (_create_control_bus, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
- bus_table.attach (_control_bus_channel_count, 1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
- bus_table.attach (chan_count_label_2, 2, 3, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 0);
input_port_limit_hbox.pack_start(_limit_input_ports, Gtk::PACK_SHRINK, 6);
input_port_limit_hbox.pack_start(_input_limit_count, Gtk::PACK_SHRINK, 0);
/* signals */
- _connect_inputs.signal_clicked().connect (mem_fun (*this, &ArdourStartup::connect_inputs_clicked));
- _connect_outputs.signal_clicked().connect (mem_fun (*this, &ArdourStartup::connect_outputs_clicked));
- _limit_input_ports.signal_clicked().connect (mem_fun (*this, &ArdourStartup::limit_inputs_clicked));
- _limit_output_ports.signal_clicked().connect (mem_fun (*this, &ArdourStartup::limit_outputs_clicked));
- _create_master_bus.signal_clicked().connect (mem_fun (*this, &ArdourStartup::master_bus_button_clicked));
- _create_control_bus.signal_clicked().connect (mem_fun (*this, &ArdourStartup::monitor_bus_button_clicked));
+ _connect_inputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_inputs_clicked));
+ _connect_outputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_outputs_clicked));
+ _limit_input_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_inputs_clicked));
+ _limit_output_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_outputs_clicked));
+ _create_master_bus.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::master_bus_button_clicked));
/* note that more_options_vbox is NOT visible by
* default. this is entirely by design - this page
* should be skipped unless explicitly requested.
*/
-
+
session_options_page_index = append_page (more_options_vbox);
set_page_title (more_options_vbox, _("Advanced Session Options"));
set_page_complete (more_options_vbox, true);
return _master_bus_channel_count.get_value_as_int();
}
-bool
-ArdourStartup::create_control_bus() const
-{
- return _create_control_bus.get_active();
-}
-
-int
-ArdourStartup::control_channel_count() const
-{
- return _control_bus_channel_count.get_value_as_int();
-}
-
bool
ArdourStartup::connect_inputs() const
{
void
ArdourStartup::master_bus_button_clicked ()
{
- _master_bus_channel_count.set_sensitive(_create_master_bus.get_active());
-}
+ bool yn = _create_master_bus.get_active();
-void
-ArdourStartup::monitor_bus_button_clicked ()
-{
- _control_bus_channel_count.set_sensitive(_create_control_bus.get_active());
+ _master_bus_channel_count.set_sensitive(yn);
}
void
}
void
-ArdourStartup::recent_row_activated (const Gtk::TreePath& path, Gtk::TreeViewColumn* col)
+ArdourStartup::recent_row_activated (const Gtk::TreePath&, Gtk::TreeViewColumn*)
{
set_page_complete (session_vbox, true);
move_along_now ();
projects / ardour.git / blobdiff