+/*
+ Copyright (C) 2010 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 <fstream>
#include <algorithm>
#include "pbd/file_utils.h"
#include "pbd/filesystem.h"
#include "pbd/replace_all.h"
+#include "pbd/whitespace.h"
#include "ardour/filesystem_paths.h"
#include "ardour/recent_sessions.h"
#include "opts.h"
#include "engine_dialog.h"
#include "i18n.h"
+#include "utils.h"
using namespace std;
using namespace Gtk;
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))
, 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)
-
+ , _existing_session_chooser_used (false)
{
audio_page_index = -1;
initial_choice_index = -1;
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)) {
- throw failed_constructor();
- }
-
- try {
- icon_pixbuf = Gdk::Pixbuf::create_from_file (icon_file.to_string());
- }
-
- catch (...) {
+ if ((icon_pixbuf = ::get_icon ("ardour_icon_48px")) == 0) {
throw failed_constructor();
}
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 ();
}
}
+void
+ArdourStartup::set_load_template( string load_template )
+{
+ use_template_button.set_active( false );
+ load_template_override = load_template;
+}
+
bool
ArdourStartup::use_session_template ()
{
+ if (!load_template_override.empty())
+ return true;
+
if (use_template_button.get_active()) {
return template_chooser.get_active_row_number() > 0;
} else {
}
}
-Glib::ustring
+std::string
ArdourStartup::session_template_name ()
{
+ if (!load_template_override.empty()) {
+ string the_path = (ARDOUR::user_template_directory()/ (load_template_override + ".template")).to_string();
+ return the_path;
+ }
+
if (ic_existing_session_button.get_active()) {
- return ustring();
+ return string();
}
if (use_template_button.get_active()) {
}
}
-Glib::ustring
+std::string
ArdourStartup::session_name (bool& should_be_new)
{
if (ic_new_session_button.get_active()) {
should_be_new = true;
- return new_name_entry.get_text ();
+ string val = new_name_entry.get_text ();
+ strip_whitespace_edges (val);
+ return val;
+ } else if (_existing_session_chooser_used) {
+ /* existing session chosen from file chooser */
+ should_be_new = false;
+ return existing_session_chooser.get_filename ();
} else {
+ /* existing session chosen from recent list */
should_be_new = false;
TreeIter iter = recent_session_display.get_selection()->get_selected();
}
}
-Glib::ustring
+std::string
ArdourStartup::session_folder ()
{
if (ic_new_session_button.get_active()) {
- Glib::ustring legal_session_folder_name = legalize_for_path (new_name_entry.get_text());
+ std::string 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 if (_existing_session_chooser_used) {
+ /* existing session chosen from file chooser */
+ return existing_session_chooser.get_current_folder ();
} else {
+ /* existing session chosen from recent list */
TreeIter iter = recent_session_display.get_selection()->get_selected();
if (iter) {
audio_page_index = append_page (*engine_dialog);
set_page_type (*engine_dialog, ASSISTANT_PAGE_CONTENT);
- set_page_title (*engine_dialog, _("Audio Setup"));
+ set_page_title (*engine_dialog, _("Audio / MIDI Setup"));
/* the default parameters should work, so the page is potentially complete */
{
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);
new_user_page_index = append_page (*vbox);
set_page_type (*vbox, ASSISTANT_PAGE_INTRO);
- set_page_title (*vbox, _("Welcome to Ardour"));
+ set_page_title (*vbox, string_compose (_("Welcome to %1"), PROGRAM_NAME));
set_page_header_image (*vbox, icon_pixbuf);
set_page_complete (*vbox, true);
}
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\
+ txt->set_markup (string_compose (_("\
+Each project that you work on with %1 has its own folder.\n\
These can require a lot of disk space if you are recording audio.\n\
\n\
-Where would you like new Ardour sessions to be stored by default?\n\n\
-<i>(You can put new sessions anywhere, this is just a default)</i>"));
+Where would you like new %1 sessions to be stored by default?\n\n\
+<i>(You can put new sessions anywhere, this is just a default)</i>"), PROGRAM_NAME));
txt->set_alignment (0.0, 0.0);
vbox->set_spacing (18);
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 ();
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* main_vbox = manage (new VBox);
+ VBox* vbox;
+ Label* l = manage (new Label);
+
+ main_vbox->set_spacing (32);
+
+ no_monitor_section_button.set_label (_("Use a Master bus directly"));
+ l->set_alignment (0.0, 1.0);
+ l->set_markup(_("Connect the Master bus directly to your hardware outputs.\n\
+<i>Preferable for simple use</i>."));
+
+ vbox = manage (new VBox);
+ vbox->set_spacing (6);
+ vbox->pack_start (no_monitor_section_button, false, true);
+ vbox->pack_start (*l, false, true);
+
+ main_vbox->pack_start (*vbox, false, false);
+
+ use_monitor_section_button.set_label (_("Use an additional Monitor bus"));
+ l = manage (new Label);
+ l->set_alignment (0.0, 1.0);
+ l->set_text (_("Use a Monitor bus between Master bus and hardware outputs for \n\
+greater control in monitoring without affecting the mix."));
+
+ vbox = manage (new VBox);
+ vbox->set_spacing (6);
+ vbox->pack_start (use_monitor_section_button, false, true);
+ vbox->pack_start (*l, false, true);
+
+ main_vbox->pack_start (*vbox, false, false);
+
+ 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(_("<i><small>(You can change this preference at any time, via the Preferences dialog)</small></i>"));
+ monitor_section_label.set_alignment (0.0, 0.0);
+
+ hbox->pack_start (*main_vbox, true, true, 8);
+ mon_sec_vbox.pack_start (*hbox, false, false);
+ mon_sec_vbox.pack_start (monitor_section_label, 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 ()
{
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(mem_fun(*this, &ArdourStartup::initial_choice_activated), false);
- ic_existing_session_button.signal_button_press_event().connect(mem_fun(*this, &ArdourStartup::initial_choice_activated), false);
+
+ 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);
}
bool
-ArdourStartup::initial_choice_activated(GdkEventButton *event)
+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;
+ 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
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 ()
{
+ _response = RESPONSE_CANCEL;
gtk_main_quit ();
}
-void
-ArdourStartup::on_close ()
+bool
+ArdourStartup::on_delete_event (GdkEventAny*)
{
+ _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 ();
}
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 ();
}
}
}
+static bool
+lost_name_entry_focus (GdkEventFocus*)
+{
+ cerr << "lost focus\n";
+ return false;
+}
+
void
ArdourStartup::setup_new_session_page ()
{
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);
}
new_folder_chooser.set_title (_("Select folder for session"));
+#ifdef GTKOSX
+ new_folder_chooser->add_shortcut_folder ("/Volumes");
+#endif
+
vbox1->pack_start (*hbox2, false, false);
session_new_vbox.pack_start (*vbox1, false, false);
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;
if (rs.empty()) {
recent_session_display.set_model (recent_session_model);
- return;
+ return 0;
}
//
// sort them alphabetically
}
recent_session_display.set_model (recent_session_model);
+ return rs.size();
}
void
void
ArdourStartup::setup_existing_session_page ()
{
+ recent_session_model = TreeStore::create (recent_session_columns);
+ redisplay_recent_sessions ();
+
if (!session_hbox.get_children().empty()) {
session_hbox.remove (**session_hbox.get_children().begin());
}
- if (recent_scroller.get_children().empty()) {
+ if (session_existing_vbox.get_children().empty()) {
- recent_session_model = TreeStore::create (recent_session_columns);
recent_session_display.set_model (recent_session_model);
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();
+ 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);
+ }
- recent_scroller.show();
- redisplay_recent_sessions ();
- recent_session_display.signal_row_activated().connect (mem_fun (*this, &ArdourStartup::recent_row_activated));
+ session_existing_vbox.set_spacing (8);
+ session_existing_vbox.pack_start (recent_scroller, true, true);
+
+ existing_session_chooser.set_title (_("Select session file"));
+ existing_session_chooser.signal_file_set().connect (sigc::mem_fun (*this, &ArdourStartup::existing_session_selected));
+
+#ifdef GTKOSX
+ existing_session_chooser->add_shortcut_folder ("/Volumes");
+#endif
+
+ HBox* hbox = manage (new HBox);
+ hbox->set_spacing (4);
+ hbox->pack_start (*manage (new Label (_("Browse:"))), PACK_SHRINK);
+ hbox->pack_start (existing_session_chooser);
+ session_existing_vbox.pack_start (*hbox);
+ hbox->show_all ();
+ }
+
+ session_existing_vbox.show_all ();
+ session_hbox.pack_start (session_existing_vbox, true, true);
- session_hbox.pack_start (recent_scroller, true, true);
set_page_title (session_vbox, _("Select a session"));
set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
}
_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);
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
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
set_page_complete (session_vbox, true);
move_along_now ();
}
+
+void
+ArdourStartup::existing_session_selected ()
+{
+ _existing_session_chooser_used = true;
+
+ set_page_complete (session_vbox, true);
+ move_along_now ();
+}
projects / ardour.git / blobdiff