2 Copyright (C) 2010 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "gtk2ardour-config.h"
27 #include <gtkmm/main.h>
28 #include <gtkmm/filechooser.h>
30 #include "pbd/failed_constructor.h"
31 #include "pbd/file_utils.h"
32 #include "pbd/filesystem.h"
33 #include "pbd/replace_all.h"
34 #include "pbd/whitespace.h"
36 #include "ardour/filesystem_paths.h"
37 #include "ardour/recent_sessions.h"
38 #include "ardour/session.h"
39 #include "ardour/session_state_utils.h"
40 #include "ardour/template_utils.h"
42 #include "ardour_ui.h"
45 #include "engine_dialog.h"
54 using namespace ARDOUR;
56 ArdourStartup* ArdourStartup::the_startup = 0;
58 static string poor_mans_glob (string path)
61 replace_all (copy, "~", Glib::get_home_dir());
66 ArdourStartup::ArdourStartup ()
67 : _response (RESPONSE_OK)
68 , ic_new_session_button (_("Create a new session"))
69 , ic_existing_session_button (_("Open an existing session"))
70 , monitor_via_hardware_button (_("Use an external mixer or the hardware mixer of your audio interface.\n\
71 Ardour will play NO role in monitoring"))
72 , monitor_via_ardour_button (string_compose (_("Ask %1 to play back material as it is being recorded"), PROGRAM_NAME))
73 , new_folder_chooser (FILE_CHOOSER_ACTION_SELECT_FOLDER)
74 , more_new_session_options_button (_("I'd like more options for this session"))
75 , _output_limit_count_adj (1, 0, 100, 1, 10, 0)
76 , _input_limit_count_adj (1, 0, 100, 1, 10, 0)
77 , _master_bus_channel_count_adj (2, 0, 100, 1, 10, 0)
78 , _existing_session_chooser_used (false)
80 audio_page_index = -1;
81 initial_choice_index = -1;
82 new_user_page_index = -1;
83 default_folder_page_index = -1;
84 monitoring_page_index = -1;
85 session_page_index = -1;
86 final_page_index = -1;
87 session_options_page_index = -1;
91 config_modified = false;
92 default_dir_chooser = 0;
94 use_template_button.set_group (session_template_group);
95 use_session_as_template_button.set_group (session_template_group);
97 set_keep_above (true);
98 set_resizable (false);
99 set_position (WIN_POS_CENTER);
100 set_border_width (12);
102 if ((icon_pixbuf = ::get_icon ("ardour_icon_48px")) == 0) {
103 throw failed_constructor();
106 list<Glib::RefPtr<Gdk::Pixbuf> > window_icons;
107 Glib::RefPtr<Gdk::Pixbuf> icon;
109 if ((icon = ::get_icon ("ardour_icon_16px")) != 0) {
110 window_icons.push_back (icon);
112 if ((icon = ::get_icon ("ardour_icon_22px")) != 0) {
113 window_icons.push_back (icon);
115 if ((icon = ::get_icon ("ardour_icon_32px")) != 0) {
116 window_icons.push_back (icon);
118 if ((icon = ::get_icon ("ardour_icon_48px")) != 0) {
119 window_icons.push_back (icon);
121 if (!window_icons.empty ()) {
122 set_default_icon_list (window_icons);
125 new_user = !exists (been_here_before_path ());
127 bool need_audio_setup = !EngineControl::engine_running();
129 setup_prerelease_page ();
133 /* Create the config directory so that we have somewhere to put the
134 been_here_before file.
137 sys::create_directories (user_config_directory ());
139 catch (const sys::filesystem_error& ex) {
140 error << "Could not create user configuration directory" << endmsg;
143 setup_new_user_page ();
144 setup_first_time_config_page ();
145 setup_monitoring_choice_page ();
146 setup_monitor_section_choice_page ();
148 if (need_audio_setup) {
152 ic_new_session_button.set_active (true); // always create new session on first run
156 if (need_audio_setup) {
160 setup_initial_choice_page ();
163 setup_session_page ();
164 setup_more_options_page ();
173 ArdourStartup::~ArdourStartup ()
178 ArdourStartup::setup_prerelease_page ()
180 VBox* vbox = manage (new VBox);
181 Label* label = manage (new Label);
182 label->set_markup (_("<b>Welcome to this BETA release of Ardour 3.0</b>\n\n\
183 There are still several issues and bugs to be worked on,\n\
184 as well as general workflow improvements, before this can be considered\n\
185 release software. So, a few guidelines:\n\
187 1) Please do <b>NOT</b> use this software with the expectation that it is stable or reliable\n\
188 though it may be so, depending on your workflow.\n\
189 2) Please see http://ardour.org/a3_features for a guide to new features.\n\
190 3) <b>Please do NOT use the forums at ardour.org to report issues</b>.\n\
191 4) Please <b>DO</b> use the bugtracker at http://tracker.ardour.org/ to report issues\n\
192 making sure to note the product version number as 3.0-beta.\n\
193 5) Please <b>DO</b> use the ardour-users mailing list to discuss ideas and pass on comments.\n\
194 6) Please <b>DO</b> join us on IRC for real time discussions about ardour3. You\n\
195 can get there directly from Ardour via the Help->Chat menu option.\n\
197 Full information on all the above can be found on the support page at\n\
199 http://ardour.org/support\n\
202 vbox->set_border_width (12);
203 vbox->pack_start (*label, false, false, 12);
207 set_page_type (*vbox, ASSISTANT_PAGE_CONTENT);
208 set_page_title (*vbox, _("This is a BETA RELEASE"));
209 set_page_complete (*vbox, true);
213 ArdourStartup::set_new_only (bool yn)
225 ArdourStartup::set_load_template (string load_template)
227 use_template_button.set_active (false);
228 load_template_override = load_template;
232 ArdourStartup::use_session_template ()
234 if (!load_template_override.empty()) {
238 if (use_template_button.get_active()) {
239 return template_chooser.get_active_row_number() > 0;
241 return !session_template_chooser.get_filename().empty();
246 ArdourStartup::session_template_name ()
248 if (!load_template_override.empty()) {
249 string the_path = (ARDOUR::user_template_directory()/ (load_template_override + ".template")).to_string();
253 if (ic_existing_session_button.get_active()) {
257 if (use_template_button.get_active()) {
258 TreeModel::iterator iter = template_chooser.get_active ();
259 TreeModel::Row row = (*iter);
260 string s = row[session_template_columns.path];
263 return session_template_chooser.get_filename();
269 ArdourStartup::session_name (bool& should_be_new)
271 if (ic_new_session_button.get_active()) {
272 should_be_new = true;
273 string val = new_name_entry.get_text ();
274 strip_whitespace_edges (val);
276 } else if (_existing_session_chooser_used) {
277 /* existing session chosen from file chooser */
278 should_be_new = false;
279 return existing_session_chooser.get_filename ();
281 /* existing session chosen from recent list */
282 should_be_new = false;
284 TreeIter iter = recent_session_display.get_selection()->get_selected();
287 return (*iter)[recent_session_columns.visible_name];
295 ArdourStartup::session_folder ()
297 if (ic_new_session_button.get_active()) {
298 std::string legal_session_folder_name = legalize_for_path (new_name_entry.get_text());
299 return Glib::build_filename (new_folder_chooser.get_current_folder(), legal_session_folder_name);
300 } else if (_existing_session_chooser_used) {
301 /* existing session chosen from file chooser */
302 return existing_session_chooser.get_current_folder ();
304 /* existing session chosen from recent list */
305 TreeIter iter = recent_session_display.get_selection()->get_selected();
308 return (*iter)[recent_session_columns.fullpath];
315 ArdourStartup::setup_audio_page ()
317 engine_dialog = manage (new EngineControl);
319 engine_dialog->set_border_width (12);
321 engine_dialog->show_all ();
323 audio_page_index = append_page (*engine_dialog);
324 set_page_type (*engine_dialog, ASSISTANT_PAGE_CONTENT);
325 set_page_title (*engine_dialog, _("Audio / MIDI Setup"));
327 /* the default parameters should work, so the page is potentially complete */
329 set_page_complete (*engine_dialog, true);
333 ArdourStartup::setup_new_user_page ()
335 Label* foomatic = manage (new Label);
337 foomatic->set_markup (string_compose (_("\
338 <span size=\"larger\">%1 is a digital audio workstation. You can use it to \
339 record, edit and mix multi-track audio. You can produce your \
340 own CDs, mix video soundtracks, or experiment with new \
341 ideas about music and sound. \
343 There are a few things that need to be configured before you start \
344 using the program.</span> \
346 foomatic->set_justify (JUSTIFY_FILL);
347 foomatic->set_line_wrap ();
349 HBox* hbox = manage (new HBox);
350 HBox* vbox = manage (new HBox);
352 vbox->set_border_width (24);
354 hbox->pack_start (*foomatic, true, true);
355 vbox->pack_start (*hbox, true, true);
361 new_user_page_index = append_page (*vbox);
362 set_page_type (*vbox, ASSISTANT_PAGE_INTRO);
363 set_page_title (*vbox, string_compose (_("Welcome to %1"), PROGRAM_NAME));
364 set_page_header_image (*vbox, icon_pixbuf);
365 set_page_complete (*vbox, true);
369 ArdourStartup::default_dir_changed ()
371 Config->set_default_session_parent_dir (default_dir_chooser->get_filename());
372 // make new session folder chooser point to the new default
373 new_folder_chooser.set_current_folder (Config->get_default_session_parent_dir());
378 ArdourStartup::config_changed ()
380 config_modified = true;
384 ArdourStartup::setup_first_time_config_page ()
386 default_dir_chooser = manage (new FileChooserButton (string_compose (_("Default folder for %1 sessions"), PROGRAM_NAME),
387 FILE_CHOOSER_ACTION_SELECT_FOLDER));
388 Gtk::Label* txt = manage (new Label);
389 HBox* hbox = manage (new HBox);
390 VBox* vbox = manage (new VBox);
392 txt->set_markup (string_compose (_("\
393 Each project that you work on with %1 has its own folder.\n\
394 These can require a lot of disk space if you are recording audio.\n\
396 Where would you like new %1 sessions to be stored by default?\n\n\
397 <i>(You can put new sessions anywhere, this is just a default)</i>"), PROGRAM_NAME));
398 txt->set_alignment (0.0, 0.0);
400 vbox->set_spacing (18);
401 vbox->set_border_width (24);
403 hbox->pack_start (*default_dir_chooser, false, true, 8);
404 vbox->pack_start (*txt, false, false);
405 vbox->pack_start (*hbox, false, true);
407 default_dir_chooser->set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
408 default_dir_chooser->signal_current_folder_changed().connect (sigc::mem_fun (*this, &ArdourStartup::default_dir_changed));
409 default_dir_chooser->show ();
413 default_folder_page_index = append_page (*vbox);
414 set_page_title (*vbox, _("Default folder for new sessions"));
415 set_page_header_image (*vbox, icon_pixbuf);
416 set_page_type (*vbox, ASSISTANT_PAGE_CONTENT);
418 /* user can just skip all these settings if they want to */
420 set_page_complete (*vbox, true);
424 ArdourStartup::setup_monitoring_choice_page ()
426 mon_vbox.set_spacing (18);
427 mon_vbox.set_border_width (24);
429 HBox* hbox = manage (new HBox);
430 VBox* vbox = manage (new VBox);
431 RadioButton::Group g (monitor_via_hardware_button.get_group());
432 monitor_via_ardour_button.set_group (g);
434 monitor_label.set_markup(_("\
435 While recording instruments or vocals, you probably want to listen to the\n\
436 signal as well as record it. This is called \"monitoring\". There are\n\
437 different ways to do this depending on the equipment you have and the\n\
438 configuration of that equipment. The two most common are presented here.\n\
439 Please choose whichever one is right for your setup.\n\n\
440 <i>(You can change this preference at any time, via the Preferences dialog)</i>\n\n\
441 <i>If you do not understand what this is about, just accept the default.</i>"));
442 monitor_label.set_alignment (0.0, 0.0);
444 vbox->set_spacing (6);
446 vbox->pack_start (monitor_via_hardware_button, false, true);
447 vbox->pack_start (monitor_via_ardour_button, false, true);
448 hbox->pack_start (*vbox, true, true, 8);
449 mon_vbox.pack_start (monitor_label, false, false);
450 mon_vbox.pack_start (*hbox, false, false);
452 mon_vbox.show_all ();
454 monitoring_page_index = append_page (mon_vbox);
455 set_page_title (mon_vbox, _("Monitoring Choices"));
456 set_page_header_image (mon_vbox, icon_pixbuf);
458 /* user could just click on "Forward" if default
462 set_page_complete (mon_vbox, true);
466 ArdourStartup::setup_monitor_section_choice_page ()
468 mon_sec_vbox.set_spacing (18);
469 mon_sec_vbox.set_border_width (24);
471 HBox* hbox = manage (new HBox);
472 VBox* main_vbox = manage (new VBox);
474 Label* l = manage (new Label);
476 main_vbox->set_spacing (32);
478 no_monitor_section_button.set_label (_("Use a Master bus directly"));
479 l->set_alignment (0.0, 1.0);
480 l->set_markup(_("Connect the Master bus directly to your hardware outputs. This is preferable for simple usage."));
482 vbox = manage (new VBox);
483 vbox->set_spacing (6);
484 vbox->pack_start (no_monitor_section_button, false, true);
485 vbox->pack_start (*l, false, true);
487 main_vbox->pack_start (*vbox, false, false);
489 use_monitor_section_button.set_label (_("Use an additional Monitor bus"));
490 l = manage (new Label);
491 l->set_alignment (0.0, 1.0);
492 l->set_text (_("Use a Monitor bus between Master bus and hardware outputs for \n\
493 greater control in monitoring without affecting the mix."));
495 vbox = manage (new VBox);
496 vbox->set_spacing (6);
497 vbox->pack_start (use_monitor_section_button, false, true);
498 vbox->pack_start (*l, false, true);
500 main_vbox->pack_start (*vbox, false, false);
502 RadioButton::Group g (use_monitor_section_button.get_group());
503 no_monitor_section_button.set_group (g);
505 if (Config->get_use_monitor_bus()) {
506 use_monitor_section_button.set_active (true);
508 no_monitor_section_button.set_active (true);
511 use_monitor_section_button.signal_toggled().connect (sigc::mem_fun (*this, &ArdourStartup::config_changed));
512 no_monitor_section_button.signal_toggled().connect (sigc::mem_fun (*this, &ArdourStartup::config_changed));
514 monitor_section_label.set_markup(_("<i>You can change this preference at any time via the Preferences dialog.\nYou can also add or remove the monitor section to/from any session.</i>\n\n\
515 <i>If you do not understand what this is about, just accept the default.</i>"));
516 monitor_section_label.set_alignment (0.0, 0.0);
518 hbox->pack_start (*main_vbox, true, true, 8);
519 mon_sec_vbox.pack_start (*hbox, false, false);
520 mon_sec_vbox.pack_start (monitor_section_label, false, false);
522 mon_sec_vbox.show_all ();
524 monitor_section_page_index = append_page (mon_sec_vbox);
525 set_page_title (mon_sec_vbox, _("Monitor Section"));
526 set_page_header_image (mon_sec_vbox, icon_pixbuf);
528 /* user could just click on "Forward" if default
532 set_page_complete (mon_sec_vbox, true);
536 ArdourStartup::setup_initial_choice_page ()
538 ic_vbox.set_spacing (6);
539 ic_vbox.set_border_width (24);
541 RadioButton::Group g (ic_new_session_button.get_group());
542 ic_existing_session_button.set_group (g);
544 HBox* centering_hbox = manage (new HBox);
545 VBox* centering_vbox = manage (new VBox);
547 centering_vbox->set_spacing (6);
549 centering_vbox->pack_start (ic_new_session_button, false, true);
550 centering_vbox->pack_start (ic_existing_session_button, false, true);
552 ic_new_session_button.signal_clicked().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_clicked));
553 ic_new_session_button.signal_activate().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_activated), false);
555 ic_existing_session_button.signal_clicked().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_clicked));
556 ic_existing_session_button.signal_activate().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_activated), false);
558 centering_hbox->pack_start (*centering_vbox, true, true);
560 ic_vbox.pack_start (*centering_hbox, true, true);
564 initial_choice_index = append_page (ic_vbox);
565 set_page_title (ic_vbox, _("What would you like to do ?"));
566 set_page_header_image (ic_vbox, icon_pixbuf);
568 /* user could just click on "Forward" if default
572 set_page_complete (ic_vbox, true);
576 ArdourStartup::initial_button_clicked ()
578 if (session_page_index != -1) {
579 set_current_page(session_page_index);
584 ArdourStartup::initial_button_activated ()
586 if (session_page_index != -1) {
587 set_current_page(session_page_index);
592 ArdourStartup::setup_session_page ()
594 session_vbox.set_border_width (24);
596 session_vbox.pack_start (session_hbox, true, true);
597 session_vbox.show_all ();
599 session_page_index = append_page (session_vbox);
600 /* initial setting */
601 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
605 ArdourStartup::setup_final_page ()
607 final_page.set_text (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
609 final_page_index = append_page (final_page);
610 set_page_complete (final_page, true);
611 set_page_header_image (final_page, icon_pixbuf);
612 set_page_type (final_page, ASSISTANT_PAGE_CONFIRM);
616 ArdourStartup::on_cancel ()
618 _response = RESPONSE_CANCEL;
623 ArdourStartup::on_delete_event (GdkEventAny*)
625 _response = RESPONSE_CLOSE;
631 ArdourStartup::on_apply ()
634 engine_dialog->setup_engine ();
637 if (config_modified) {
639 if (default_dir_chooser) {
640 Config->set_default_session_parent_dir (default_dir_chooser->get_filename());
643 if (monitor_via_hardware_button.get_active()) {
644 Config->set_monitoring_model (ExternalMonitoring);
645 } else if (monitor_via_ardour_button.get_active()) {
646 Config->set_monitoring_model (SoftwareMonitoring);
649 Config->set_use_monitor_bus (use_monitor_section_button.get_active());
651 /* "touch" the been-here-before path now that we're about to save Config */
652 ofstream fout (been_here_before_path().to_string().c_str());
654 Config->save_state ();
657 _response = RESPONSE_OK;
662 ArdourStartup::on_prepare (Gtk::Widget* page)
664 if (page == &session_vbox) {
666 if (ic_new_session_button.get_active()) {
667 /* new session requested */
668 setup_new_session_page ();
670 /* existing session requested */
671 setup_existing_session_page ();
675 /* HACK HACK HACK ... change the "Apply" button label
679 Gtk::Widget* tl = session_vbox.get_toplevel();
681 if ((win = dynamic_cast<Gtk::Window*>(tl)) != 0) {
682 /* ::get_default_widget() is not wrapped in gtkmm */
683 Gtk::Widget* def = wrap (gtk_window_get_default_widget (win->gobj()));
685 if ((button = dynamic_cast<Gtk::Button*>(def)) != 0) {
686 if (more_new_session_options_button.get_active()) {
687 button->set_label (_("Forward"));
689 button->set_label (_("Open"));
697 ArdourStartup::populate_session_templates ()
699 vector<TemplateInfo> templates;
701 find_session_templates (templates);
703 template_model->clear ();
705 for (vector<TemplateInfo>::iterator x = templates.begin(); x != templates.end(); ++x) {
708 row = *(template_model->append ());
710 row[session_template_columns.name] = (*x).name;
711 row[session_template_columns.path] = (*x).path;
716 lost_name_entry_focus (GdkEventFocus*)
718 cerr << "lost focus\n";
723 ArdourStartup::setup_new_session_page ()
725 if (!session_hbox.get_children().empty()) {
726 session_hbox.remove (**session_hbox.get_children().begin());
729 session_new_vbox.set_spacing (18);
731 if (session_new_vbox.get_children().empty()) {
732 VBox *vbox1 = manage (new VBox);
733 HBox* hbox1 = manage (new HBox);
734 Label* label1 = manage (new Label);
736 vbox1->set_spacing (6);
738 hbox1->set_spacing (6);
739 hbox1->pack_start (*label1, false, false);
740 hbox1->pack_start (new_name_entry, true, true);
742 label1->set_text (_("Session name:"));
745 if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
746 new_name_entry.set_text (Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name));
747 /* name provided - they can move right along */
748 set_page_complete (session_vbox, true);
751 new_name_entry.signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::new_name_changed));
752 new_name_entry.signal_activate().connect (sigc::mem_fun (*this, &ArdourStartup::move_along_now));
754 vbox1->pack_start (*hbox1, true, true);
758 HBox* hbox2 = manage (new HBox);
759 Label* label2 = manage (new Label);
761 hbox2->set_spacing (6);
762 hbox2->pack_start (*label2, false, false);
763 hbox2->pack_start (new_folder_chooser, true, true);
765 label2->set_text (_("Create session folder in:"));
767 if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
768 new_folder_chooser.set_current_folder (poor_mans_glob (Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name)));
769 } else if (ARDOUR_UI::instance()->session_loaded) {
770 // point the new session file chooser at the parent directory of the current session
771 string session_parent_dir = Glib::path_get_dirname(ARDOUR_UI::instance()->the_session()->path());
772 string::size_type last_dir_sep = session_parent_dir.rfind(G_DIR_SEPARATOR);
773 session_parent_dir = session_parent_dir.substr(0, last_dir_sep);
774 new_folder_chooser.set_current_folder (session_parent_dir);
775 new_folder_chooser.add_shortcut_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
777 new_folder_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
779 new_folder_chooser.set_title (_("Select folder for session"));
782 new_folder_chooser.add_shortcut_folder ("/Volumes");
785 vbox1->pack_start (*hbox2, false, false);
787 session_new_vbox.pack_start (*vbox1, false, false);
791 VBox *vbox2 = manage (new VBox);
792 HBox* hbox3 = manage (new HBox);
793 Label* label3 = manage (new Label);
794 template_model = ListStore::create (session_template_columns);
795 populate_session_templates ();
797 vbox2->set_spacing (6);
799 label3->set_markup (_("<b>Options</b>"));
800 label3->set_alignment (0.0, 0.0);
802 vbox2->pack_start (*label3, false, true);
804 VBox *vbox3 = manage (new VBox);
806 vbox3->set_spacing (6);
808 if (!template_model->children().empty()) {
810 HBox* hbox4a = manage (new HBox);
811 use_template_button.set_label (_("Use this template"));
813 TreeModel::Row row = *template_model->prepend ();
814 row[session_template_columns.name] = (_("no template"));
815 row[session_template_columns.path] = string();
817 hbox4a->set_spacing (6);
818 hbox4a->pack_start (use_template_button, false, false);
819 hbox4a->pack_start (template_chooser, true, true);
821 template_chooser.set_model (template_model);
823 Gtk::CellRendererText* text_renderer = Gtk::manage (new Gtk::CellRendererText);
824 text_renderer->property_editable() = false;
826 template_chooser.pack_start (*text_renderer);
827 template_chooser.add_attribute (text_renderer->property_text(), session_template_columns.name);
828 template_chooser.set_active (0);
830 use_template_button.show();
831 template_chooser.show ();
833 vbox3->pack_start (*hbox4a, false, false);
839 session_template_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
841 HBox* hbox4b = manage (new HBox);
842 use_session_as_template_button.set_label (_("Use an existing session as a template:"));
844 hbox4b->set_spacing (6);
845 hbox4b->pack_start (use_session_as_template_button, false, false);
846 hbox4b->pack_start (session_template_chooser, true, true);
848 use_session_as_template_button.show ();
849 session_template_chooser.show ();
851 Gtk::FileFilter* session_filter = manage (new (Gtk::FileFilter));
852 session_filter->add_pattern (X_("*.ardour"));
853 session_template_chooser.set_filter (*session_filter);
854 session_template_chooser.set_title (_("Select template"));
856 vbox3->pack_start (*hbox4b, false, false);
861 HBox* hbox5 = manage (new HBox);
863 hbox5->set_spacing (6);
864 hbox5->pack_start (more_new_session_options_button, false, false);
866 more_new_session_options_button.show ();
867 more_new_session_options_button.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::more_new_session_options_button_clicked));
869 vbox3->pack_start (*hbox5, false, false);
870 hbox3->pack_start (*vbox3, true, true, 8);
871 vbox2->pack_start (*hbox3, false, false);
875 session_new_vbox.pack_start (*vbox2, false, false);
878 session_new_vbox.show_all ();
879 session_hbox.pack_start (session_new_vbox, true, true);
880 set_page_title (session_vbox, _("New Session"));
881 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
883 if (more_new_session_options_button.get_active()) {
884 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
887 new_name_entry.signal_map().connect (sigc::mem_fun (*this, &ArdourStartup::new_name_mapped));
888 new_name_entry.signal_focus_out_event().connect (sigc::ptr_fun (lost_name_entry_focus));
892 ArdourStartup::new_name_mapped ()
894 cerr << "Grab new name focus\n";
895 new_name_entry.grab_focus ();
899 ArdourStartup::new_name_changed ()
901 if (!new_name_entry.get_text().empty()) {
902 set_page_complete (session_vbox, true);
904 set_page_complete (session_vbox, false);
909 ArdourStartup::redisplay_recent_sessions ()
911 std::vector<sys::path> session_directories;
912 RecentSessionsSorter cmp;
914 recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
915 recent_session_model->clear ();
917 ARDOUR::RecentSessions rs;
918 ARDOUR::read_recent_sessions (rs);
921 recent_session_display.set_model (recent_session_model);
925 // sort them alphabetically
926 sort (rs.begin(), rs.end(), cmp);
928 for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
929 session_directories.push_back ((*i).second);
932 for (vector<sys::path>::const_iterator i = session_directories.begin(); i != session_directories.end(); ++i)
934 std::vector<sys::path> state_file_paths;
936 // now get available states for this session
938 get_state_files_in_directory (*i, state_file_paths);
940 vector<string*>* states;
941 vector<const gchar*> item;
942 string fullpath = (*i).to_string();
944 /* remove any trailing / */
946 if (fullpath[fullpath.length()-1] == '/') {
947 fullpath = fullpath.substr (0, fullpath.length()-1);
950 /* check whether session still exists */
951 if (!Glib::file_test(fullpath.c_str(), Glib::FILE_TEST_EXISTS)) {
952 /* session doesn't exist */
956 /* now get available states for this session */
958 if ((states = Session::possible_states (fullpath)) == 0) {
963 std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
965 Gtk::TreeModel::Row row = *(recent_session_model->append());
967 row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
968 row[recent_session_columns.fullpath] = fullpath;
970 if (state_file_names.size() > 1) {
974 for (std::vector<std::string>::iterator i2 = state_file_names.begin();
975 i2 != state_file_names.end(); ++i2)
978 Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
980 child_row[recent_session_columns.visible_name] = *i2;
981 child_row[recent_session_columns.fullpath] = fullpath;
986 recent_session_display.set_tooltip_column(1); // recent_session_columns.fullpath
987 recent_session_display.set_model (recent_session_model);
992 ArdourStartup::recent_session_row_selected ()
994 if (recent_session_display.get_selection()->count_selected_rows() > 0) {
995 set_page_complete (session_vbox, true);
997 set_page_complete (session_vbox, false);
1002 ArdourStartup::setup_existing_session_page ()
1004 recent_session_model = TreeStore::create (recent_session_columns);
1005 redisplay_recent_sessions ();
1007 if (!session_hbox.get_children().empty()) {
1008 session_hbox.remove (**session_hbox.get_children().begin());
1011 if (session_existing_vbox.get_children().empty()) {
1013 recent_session_display.set_model (recent_session_model);
1014 recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
1015 recent_session_display.set_headers_visible (false);
1016 recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
1018 recent_session_display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::recent_session_row_selected));
1020 recent_scroller.add (recent_session_display);
1021 recent_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1022 recent_scroller.set_shadow_type (Gtk::SHADOW_IN);
1024 recent_session_display.show();
1026 recent_scroller.show();
1027 int cnt = redisplay_recent_sessions ();
1028 recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ArdourStartup::recent_row_activated));
1031 recent_scroller.set_size_request (-1, 300);
1034 session_existing_vbox.set_spacing (8);
1035 session_existing_vbox.pack_start (recent_scroller, true, true);
1037 existing_session_chooser.set_title (_("Select session file"));
1038 existing_session_chooser.signal_file_set().connect (sigc::mem_fun (*this, &ArdourStartup::existing_session_selected));
1039 cerr << "Set existing chooser to " << Config->get_default_session_parent_dir() << endl;
1040 existing_session_chooser.set_current_folder(poor_mans_glob (Config->get_default_session_parent_dir()));
1043 existing_session_chooser.add_shortcut_folder ("/Volumes");
1046 HBox* hbox = manage (new HBox);
1047 hbox->set_spacing (4);
1048 hbox->pack_start (*manage (new Label (_("Browse:"))), PACK_SHRINK);
1049 hbox->pack_start (existing_session_chooser);
1050 session_existing_vbox.pack_start (*hbox, false, false);
1054 session_existing_vbox.show_all ();
1055 session_hbox.pack_start (session_existing_vbox, true, true);
1057 set_page_title (session_vbox, _("Select a session"));
1058 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1062 ArdourStartup::more_new_session_options_button_clicked ()
1064 if (more_new_session_options_button.get_active()) {
1065 more_options_vbox.show_all ();
1066 set_page_type (more_options_vbox, ASSISTANT_PAGE_CONFIRM);
1067 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
1069 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1070 more_options_vbox.hide ();
1075 ArdourStartup::setup_more_options_page ()
1077 more_options_vbox.set_border_width (24);
1079 _output_limit_count.set_adjustment (_output_limit_count_adj);
1080 _input_limit_count.set_adjustment (_input_limit_count_adj);
1081 _master_bus_channel_count.set_adjustment (_master_bus_channel_count_adj);
1083 chan_count_label_1.set_text (_("channels"));
1084 chan_count_label_3.set_text (_("channels"));
1085 chan_count_label_4.set_text (_("channels"));
1087 chan_count_label_1.set_alignment(0,0.5);
1088 chan_count_label_1.set_padding(0,0);
1089 chan_count_label_1.set_line_wrap(false);
1091 chan_count_label_3.set_alignment(0,0.5);
1092 chan_count_label_3.set_padding(0,0);
1093 chan_count_label_3.set_line_wrap(false);
1095 chan_count_label_4.set_alignment(0,0.5);
1096 chan_count_label_4.set_padding(0,0);
1097 chan_count_label_4.set_line_wrap(false);
1099 bus_label.set_markup (_("<b>Busses</b>"));
1100 input_label.set_markup (_("<b>Inputs</b>"));
1101 output_label.set_markup (_("<b>Outputs</b>"));
1103 _master_bus_channel_count.set_flags(Gtk::CAN_FOCUS);
1104 _master_bus_channel_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1105 _master_bus_channel_count.set_numeric(true);
1106 _master_bus_channel_count.set_digits(0);
1107 _master_bus_channel_count.set_wrap(false);
1109 _create_master_bus.set_label (_("Create master bus"));
1110 _create_master_bus.set_flags(Gtk::CAN_FOCUS);
1111 _create_master_bus.set_relief(Gtk::RELIEF_NORMAL);
1112 _create_master_bus.set_mode(true);
1113 _create_master_bus.set_active(true);
1114 _create_master_bus.set_border_width(0);
1116 advanced_table.set_row_spacings(0);
1117 advanced_table.set_col_spacings(0);
1119 _connect_inputs.set_label (_("Automatically connect to physical_inputs"));
1120 _connect_inputs.set_flags(Gtk::CAN_FOCUS);
1121 _connect_inputs.set_relief(Gtk::RELIEF_NORMAL);
1122 _connect_inputs.set_mode(true);
1123 _connect_inputs.set_active(Config->get_input_auto_connect() != ManualConnect);
1124 _connect_inputs.set_border_width(0);
1126 _limit_input_ports.set_label (_("Use only"));
1127 _limit_input_ports.set_flags(Gtk::CAN_FOCUS);
1128 _limit_input_ports.set_relief(Gtk::RELIEF_NORMAL);
1129 _limit_input_ports.set_mode(true);
1130 _limit_input_ports.set_sensitive(true);
1131 _limit_input_ports.set_border_width(0);
1133 _input_limit_count.set_flags(Gtk::CAN_FOCUS);
1134 _input_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1135 _input_limit_count.set_numeric(true);
1136 _input_limit_count.set_digits(0);
1137 _input_limit_count.set_wrap(false);
1138 _input_limit_count.set_sensitive(false);
1140 bus_hbox.pack_start (bus_table, Gtk::PACK_SHRINK, 18);
1142 bus_label.set_alignment(0, 0.5);
1143 bus_label.set_padding(0,0);
1144 bus_label.set_line_wrap(false);
1145 bus_label.set_selectable(false);
1146 bus_label.set_use_markup(true);
1147 bus_frame.set_shadow_type(Gtk::SHADOW_NONE);
1148 bus_frame.set_label_align(0,0.5);
1149 bus_frame.add(bus_hbox);
1150 bus_frame.set_label_widget(bus_label);
1152 bus_table.set_row_spacings (0);
1153 bus_table.set_col_spacings (0);
1154 bus_table.attach (_create_master_bus, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1155 bus_table.attach (_master_bus_channel_count, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1156 bus_table.attach (chan_count_label_1, 2, 3, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 0);
1158 input_port_limit_hbox.pack_start(_limit_input_ports, Gtk::PACK_SHRINK, 6);
1159 input_port_limit_hbox.pack_start(_input_limit_count, Gtk::PACK_SHRINK, 0);
1160 input_port_limit_hbox.pack_start(chan_count_label_3, Gtk::PACK_SHRINK, 6);
1161 input_port_vbox.pack_start(_connect_inputs, Gtk::PACK_SHRINK, 0);
1162 input_port_vbox.pack_start(input_port_limit_hbox, Gtk::PACK_EXPAND_PADDING, 0);
1163 input_table.set_row_spacings(0);
1164 input_table.set_col_spacings(0);
1165 input_table.attach(input_port_vbox, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 6);
1167 input_hbox.pack_start (input_table, Gtk::PACK_SHRINK, 18);
1169 input_label.set_alignment(0, 0.5);
1170 input_label.set_padding(0,0);
1171 input_label.set_line_wrap(false);
1172 input_label.set_selectable(false);
1173 input_label.set_use_markup(true);
1174 input_frame.set_shadow_type(Gtk::SHADOW_NONE);
1175 input_frame.set_label_align(0,0.5);
1176 input_frame.add(input_hbox);
1177 input_frame.set_label_widget(input_label);
1179 _connect_outputs.set_label (_("Automatically connect outputs"));
1180 _connect_outputs.set_flags(Gtk::CAN_FOCUS);
1181 _connect_outputs.set_relief(Gtk::RELIEF_NORMAL);
1182 _connect_outputs.set_mode(true);
1183 _connect_outputs.set_active(Config->get_output_auto_connect() != ManualConnect);
1184 _connect_outputs.set_border_width(0);
1185 _limit_output_ports.set_label (_("Use only"));
1186 _limit_output_ports.set_flags(Gtk::CAN_FOCUS);
1187 _limit_output_ports.set_relief(Gtk::RELIEF_NORMAL);
1188 _limit_output_ports.set_mode(true);
1189 _limit_output_ports.set_sensitive(true);
1190 _limit_output_ports.set_border_width(0);
1191 _output_limit_count.set_flags(Gtk::CAN_FOCUS);
1192 _output_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1193 _output_limit_count.set_numeric(false);
1194 _output_limit_count.set_digits(0);
1195 _output_limit_count.set_wrap(false);
1196 _output_limit_count.set_sensitive(false);
1197 output_port_limit_hbox.pack_start(_limit_output_ports, Gtk::PACK_SHRINK, 6);
1198 output_port_limit_hbox.pack_start(_output_limit_count, Gtk::PACK_SHRINK, 0);
1199 output_port_limit_hbox.pack_start(chan_count_label_4, Gtk::PACK_SHRINK, 6);
1201 _connect_outputs_to_master.set_label (_("... to master bus"));
1202 _connect_outputs_to_master.set_flags(Gtk::CAN_FOCUS);
1203 _connect_outputs_to_master.set_relief(Gtk::RELIEF_NORMAL);
1204 _connect_outputs_to_master.set_mode(true);
1205 _connect_outputs_to_master.set_active(Config->get_output_auto_connect() == AutoConnectMaster);
1206 _connect_outputs_to_master.set_border_width(0);
1208 _connect_outputs_to_master.set_group (connect_outputs_group);
1209 _connect_outputs_to_physical.set_group (connect_outputs_group);
1211 _connect_outputs_to_physical.set_label (_("... to physical outputs"));
1212 _connect_outputs_to_physical.set_flags(Gtk::CAN_FOCUS);
1213 _connect_outputs_to_physical.set_relief(Gtk::RELIEF_NORMAL);
1214 _connect_outputs_to_physical.set_mode(true);
1215 _connect_outputs_to_physical.set_active(Config->get_output_auto_connect() == AutoConnectPhysical);
1216 _connect_outputs_to_physical.set_border_width(0);
1218 output_conn_vbox.pack_start(_connect_outputs, Gtk::PACK_SHRINK, 0);
1219 output_conn_vbox.pack_start(_connect_outputs_to_master, Gtk::PACK_SHRINK, 0);
1220 output_conn_vbox.pack_start(_connect_outputs_to_physical, Gtk::PACK_SHRINK, 0);
1221 output_vbox.set_border_width(6);
1223 output_port_vbox.pack_start(output_port_limit_hbox, Gtk::PACK_SHRINK, 0);
1225 output_vbox.pack_start(output_conn_vbox);
1226 output_vbox.pack_start(output_port_vbox);
1228 output_label.set_alignment(0, 0.5);
1229 output_label.set_padding(0,0);
1230 output_label.set_line_wrap(false);
1231 output_label.set_selectable(false);
1232 output_label.set_use_markup(true);
1233 output_frame.set_shadow_type(Gtk::SHADOW_NONE);
1234 output_frame.set_label_align(0,0.5);
1236 output_hbox.pack_start (output_vbox, Gtk::PACK_SHRINK, 18);
1238 output_frame.add(output_hbox);
1239 output_frame.set_label_widget(output_label);
1241 more_options_vbox.pack_start(advanced_table, Gtk::PACK_SHRINK, 0);
1242 more_options_vbox.pack_start(bus_frame, Gtk::PACK_SHRINK, 6);
1243 more_options_vbox.pack_start(input_frame, Gtk::PACK_SHRINK, 6);
1244 more_options_vbox.pack_start(output_frame, Gtk::PACK_SHRINK, 0);
1248 _connect_inputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_inputs_clicked));
1249 _connect_outputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_outputs_clicked));
1250 _limit_input_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_inputs_clicked));
1251 _limit_output_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_outputs_clicked));
1252 _create_master_bus.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::master_bus_button_clicked));
1254 /* note that more_options_vbox is NOT visible by
1255 * default. this is entirely by design - this page
1256 * should be skipped unless explicitly requested.
1259 session_options_page_index = append_page (more_options_vbox);
1260 set_page_title (more_options_vbox, _("Advanced Session Options"));
1261 set_page_complete (more_options_vbox, true);
1265 ArdourStartup::create_master_bus() const
1267 return _create_master_bus.get_active();
1271 ArdourStartup::master_channel_count() const
1273 return _master_bus_channel_count.get_value_as_int();
1277 ArdourStartup::connect_inputs() const
1279 return _connect_inputs.get_active();
1283 ArdourStartup::limit_inputs_used_for_connection() const
1285 return _limit_input_ports.get_active();
1289 ArdourStartup::input_limit_count() const
1291 return _input_limit_count.get_value_as_int();
1295 ArdourStartup::connect_outputs() const
1297 return _connect_outputs.get_active();
1301 ArdourStartup::limit_outputs_used_for_connection() const
1303 return _limit_output_ports.get_active();
1307 ArdourStartup::output_limit_count() const
1309 return _output_limit_count.get_value_as_int();
1313 ArdourStartup::connect_outs_to_master() const
1315 return _connect_outputs_to_master.get_active();
1319 ArdourStartup::connect_outs_to_physical() const
1321 return _connect_outputs_to_physical.get_active();
1325 ArdourStartup::connect_inputs_clicked ()
1327 _limit_input_ports.set_sensitive(_connect_inputs.get_active());
1329 if (_connect_inputs.get_active() && _limit_input_ports.get_active()) {
1330 _input_limit_count.set_sensitive(true);
1332 _input_limit_count.set_sensitive(false);
1337 ArdourStartup::connect_outputs_clicked ()
1339 _limit_output_ports.set_sensitive(_connect_outputs.get_active());
1341 if (_connect_outputs.get_active() && _limit_output_ports.get_active()) {
1342 _output_limit_count.set_sensitive(true);
1344 _output_limit_count.set_sensitive(false);
1349 ArdourStartup::limit_inputs_clicked ()
1351 _input_limit_count.set_sensitive(_limit_input_ports.get_active());
1355 ArdourStartup::limit_outputs_clicked ()
1357 _output_limit_count.set_sensitive(_limit_output_ports.get_active());
1361 ArdourStartup::master_bus_button_clicked ()
1363 bool yn = _create_master_bus.get_active();
1365 _master_bus_channel_count.set_sensitive(yn);
1369 ArdourStartup::move_along_now ()
1371 gint cur = get_current_page ();
1373 if (cur == session_page_index) {
1374 if (more_new_session_options_button.get_active()) {
1375 set_current_page (session_options_page_index);
1383 ArdourStartup::recent_row_activated (const Gtk::TreePath&, Gtk::TreeViewColumn*)
1385 set_page_complete (session_vbox, true);
1390 ArdourStartup::existing_session_selected ()
1392 _existing_session_chooser_used = true;
1394 set_page_complete (session_vbox, true);
1399 ArdourStartup::been_here_before_path () const
1401 sys::path b = user_config_directory();
1402 b /= ".a3"; // XXXX use more specific version so we can catch upgrades