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"
44 #include "engine_dialog.h"
53 using namespace ARDOUR;
55 ArdourStartup* ArdourStartup::the_startup = 0;
57 static string poor_mans_glob (string path)
60 replace_all (copy, "~", Glib::get_home_dir());
65 ArdourStartup::ArdourStartup ()
66 : _response (RESPONSE_OK)
67 , ic_new_session_button (_("Open a new session"))
68 , ic_existing_session_button (_("Open an existing session"))
69 , monitor_via_hardware_button (_("Use an external mixer or the hardware mixer of your audio interface.\n\
70 Ardour will play NO role in monitoring"))
71 , monitor_via_ardour_button (string_compose (_("Ask %1 to playback material as it is being recorded"), PROGRAM_NAME))
72 , new_folder_chooser (FILE_CHOOSER_ACTION_SELECT_FOLDER)
73 , more_new_session_options_button (_("I'd like more options for this session"))
74 , _output_limit_count_adj (1, 0, 100, 1, 10, 0)
75 , _input_limit_count_adj (1, 0, 100, 1, 10, 0)
76 , _master_bus_channel_count_adj (2, 0, 100, 1, 10, 0)
77 , _existing_session_chooser_used (false)
79 audio_page_index = -1;
80 initial_choice_index = -1;
81 new_user_page_index = -1;
82 default_folder_page_index = -1;
83 monitoring_page_index = -1;
84 session_page_index = -1;
85 final_page_index = -1;
86 session_options_page_index = -1;
90 config_modified = false;
91 default_dir_chooser = 0;
93 use_template_button.set_group (session_template_group);
94 use_session_as_template_button.set_group (session_template_group);
96 set_keep_above (true);
97 set_resizable (false);
98 set_position (WIN_POS_CENTER);
99 set_border_width (12);
101 if ((icon_pixbuf = ::get_icon ("ardour_icon_48px")) == 0) {
102 throw failed_constructor();
105 list<Glib::RefPtr<Gdk::Pixbuf> > window_icons;
106 Glib::RefPtr<Gdk::Pixbuf> icon;
108 if ((icon = ::get_icon ("ardour_icon_16px")) != 0) {
109 window_icons.push_back (icon);
111 if ((icon = ::get_icon ("ardour_icon_22px")) != 0) {
112 window_icons.push_back (icon);
114 if ((icon = ::get_icon ("ardour_icon_32px")) != 0) {
115 window_icons.push_back (icon);
117 if ((icon = ::get_icon ("ardour_icon_48px")) != 0) {
118 window_icons.push_back (icon);
120 if (!window_icons.empty ()) {
121 set_default_icon_list (window_icons);
124 new_user = !exists (been_here_before_path ());
126 bool need_audio_setup = !EngineControl::engine_running();
128 setup_prerelease_page ();
132 /* Create the config directory so that we have somewhere to put the
133 been_here_before file.
136 sys::create_directories (user_config_directory ());
138 catch (const sys::filesystem_error& ex) {
139 error << "Could not create user configuration directory" << endmsg;
142 setup_new_user_page ();
143 setup_first_time_config_page ();
144 setup_monitoring_choice_page ();
145 setup_monitor_section_choice_page ();
147 if (need_audio_setup) {
153 if (need_audio_setup) {
157 setup_initial_choice_page ();
160 setup_session_page ();
161 setup_more_options_page ();
170 ArdourStartup::~ArdourStartup ()
175 ArdourStartup::setup_prerelease_page ()
177 VBox* vbox = manage (new VBox);
178 Label* label = manage (new Label);
179 label->set_markup (_("<b>Welcome to this BETA release of Ardour 3.0</b>\n\n\
180 There are still several issues and bugs to be worked on,\n\
181 as well as general workflow improvements, before this can be considered\n\
182 release software. So, a few guidelines:\n\
184 1) Please do <b>NOT</b> use this software with the expectation that it is stable or reliable\n\
185 though it may be so, depending on your workflow.\n\
186 2) Please see http://ardour.org/a3_features for a guide to new features.\n\
187 3) <b>Please do NOT use the forums at ardour.org to report issues</b>.\n\
188 4) Please <b>DO</b> use the bugtracker at http://tracker.ardour.org/ to report issues\n\
189 making sure to note the product version number as 3.0-beta.\n\
190 5) Please <b>DO</b> use the ardour-users mailing list to discuss ideas and pass on comments.\n\
191 6) Please <b>DO</b> join us on IRC for real time discussions about ardour3. You\n\
192 can get there directly from Ardour via the Help->Chat menu option.\n\
194 Full information on all the above can be found on the support page at\n\
196 http://ardour.org/support\n\
199 vbox->set_border_width (12);
200 vbox->pack_start (*label, false, false, 12);
204 set_page_type (*vbox, ASSISTANT_PAGE_CONTENT);
205 set_page_title (*vbox, _("This is a BETA RELEASE"));
206 set_page_complete (*vbox, true);
210 ArdourStartup::set_new_only (bool yn)
222 ArdourStartup::set_load_template (string load_template)
224 use_template_button.set_active (false);
225 load_template_override = load_template;
229 ArdourStartup::use_session_template ()
231 if (!load_template_override.empty()) {
235 if (use_template_button.get_active()) {
236 return template_chooser.get_active_row_number() > 0;
238 return !session_template_chooser.get_filename().empty();
243 ArdourStartup::session_template_name ()
245 if (!load_template_override.empty()) {
246 string the_path = (ARDOUR::user_template_directory()/ (load_template_override + ".template")).to_string();
250 if (ic_existing_session_button.get_active()) {
254 if (use_template_button.get_active()) {
255 TreeModel::iterator iter = template_chooser.get_active ();
256 TreeModel::Row row = (*iter);
257 string s = row[session_template_columns.path];
260 return session_template_chooser.get_filename();
266 ArdourStartup::session_name (bool& should_be_new)
268 if (ic_new_session_button.get_active()) {
269 should_be_new = true;
270 string val = new_name_entry.get_text ();
271 strip_whitespace_edges (val);
273 } else if (_existing_session_chooser_used) {
274 /* existing session chosen from file chooser */
275 should_be_new = false;
276 return existing_session_chooser.get_filename ();
278 /* existing session chosen from recent list */
279 should_be_new = false;
281 TreeIter iter = recent_session_display.get_selection()->get_selected();
284 return (*iter)[recent_session_columns.visible_name];
292 ArdourStartup::session_folder ()
294 if (ic_new_session_button.get_active()) {
295 std::string legal_session_folder_name = legalize_for_path (new_name_entry.get_text());
296 return Glib::build_filename (new_folder_chooser.get_current_folder(), legal_session_folder_name);
297 } else if (_existing_session_chooser_used) {
298 /* existing session chosen from file chooser */
299 return existing_session_chooser.get_current_folder ();
301 /* existing session chosen from recent list */
302 TreeIter iter = recent_session_display.get_selection()->get_selected();
305 return (*iter)[recent_session_columns.fullpath];
312 ArdourStartup::setup_audio_page ()
314 engine_dialog = manage (new EngineControl);
316 engine_dialog->set_border_width (12);
318 engine_dialog->show_all ();
320 audio_page_index = append_page (*engine_dialog);
321 set_page_type (*engine_dialog, ASSISTANT_PAGE_CONTENT);
322 set_page_title (*engine_dialog, _("Audio / MIDI Setup"));
324 /* the default parameters should work, so the page is potentially complete */
326 set_page_complete (*engine_dialog, true);
330 ArdourStartup::setup_new_user_page ()
332 Label* foomatic = manage (new Label);
334 foomatic->set_markup (string_compose (_("\
335 <span size=\"larger\">%1 is a digital audio workstation. You can use it to\n\
336 record, edit and mix multi-track audio. You can produce your\n\
337 own CDs, mix video soundtracks, or just experiment with new\n\
338 ideas about music and sound.\n\
340 There are a few things that need to configured before you start\n\
341 using the program.</span>\
344 HBox* hbox = manage (new HBox);
345 HBox* vbox = manage (new HBox);
347 vbox->set_border_width (24);
349 hbox->pack_start (*foomatic, true, true);
350 vbox->pack_start (*hbox, true, true);
356 new_user_page_index = append_page (*vbox);
357 set_page_type (*vbox, ASSISTANT_PAGE_INTRO);
358 set_page_title (*vbox, string_compose (_("Welcome to %1"), PROGRAM_NAME));
359 set_page_header_image (*vbox, icon_pixbuf);
360 set_page_complete (*vbox, true);
364 ArdourStartup::default_dir_changed ()
366 Config->set_default_session_parent_dir (default_dir_chooser->get_filename());
371 ArdourStartup::config_changed ()
373 config_modified = true;
377 ArdourStartup::setup_first_time_config_page ()
379 default_dir_chooser = manage (new FileChooserButton (string_compose (_("Default folder for %1 sessions"), PROGRAM_NAME),
380 FILE_CHOOSER_ACTION_SELECT_FOLDER));
381 Gtk::Label* txt = manage (new Label);
382 HBox* hbox = manage (new HBox);
383 VBox* vbox = manage (new VBox);
385 txt->set_markup (string_compose (_("\
386 Each project that you work on with %1 has its own folder.\n\
387 These can require a lot of disk space if you are recording audio.\n\
389 Where would you like new %1 sessions to be stored by default?\n\n\
390 <i>(You can put new sessions anywhere, this is just a default)</i>"), PROGRAM_NAME));
391 txt->set_alignment (0.0, 0.0);
393 vbox->set_spacing (18);
394 vbox->set_border_width (24);
396 hbox->pack_start (*default_dir_chooser, false, true, 8);
397 vbox->pack_start (*txt, false, false);
398 vbox->pack_start (*hbox, false, true);
400 default_dir_chooser->set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
401 default_dir_chooser->signal_current_folder_changed().connect (sigc::mem_fun (*this, &ArdourStartup::default_dir_changed));
402 default_dir_chooser->show ();
406 default_folder_page_index = append_page (*vbox);
407 set_page_title (*vbox, _("Default folder for new sessions"));
408 set_page_header_image (*vbox, icon_pixbuf);
409 set_page_type (*vbox, ASSISTANT_PAGE_CONTENT);
411 /* user can just skip all these settings if they want to */
413 set_page_complete (*vbox, true);
417 ArdourStartup::setup_monitoring_choice_page ()
419 mon_vbox.set_spacing (18);
420 mon_vbox.set_border_width (24);
422 HBox* hbox = manage (new HBox);
423 VBox* vbox = manage (new VBox);
424 RadioButton::Group g (monitor_via_hardware_button.get_group());
425 monitor_via_ardour_button.set_group (g);
427 monitor_label.set_markup(_("\
428 While recording instruments or vocals, you probably want to listen to the\n\
429 signal as well as record it. This is called \"monitoring\". There are\n\
430 different ways to do this depending on the equipment you have and the\n\
431 configuration of that equipment. The two most common are presented here.\n\
432 Please choose whichever one is right for your setup.\n\n\
433 <i>(You can change this preference at any time, via the Preferences dialog)</i>"));
434 monitor_label.set_alignment (0.0, 0.0);
436 vbox->set_spacing (6);
438 vbox->pack_start (monitor_via_hardware_button, false, true);
439 vbox->pack_start (monitor_via_ardour_button, false, true);
440 hbox->pack_start (*vbox, true, true, 8);
441 mon_vbox.pack_start (monitor_label, false, false);
442 mon_vbox.pack_start (*hbox, false, false);
444 mon_vbox.show_all ();
446 monitoring_page_index = append_page (mon_vbox);
447 set_page_title (mon_vbox, _("Monitoring Choices"));
448 set_page_header_image (mon_vbox, icon_pixbuf);
450 /* user could just click on "Forward" if default
454 set_page_complete (mon_vbox, true);
458 ArdourStartup::setup_monitor_section_choice_page ()
460 mon_sec_vbox.set_spacing (18);
461 mon_sec_vbox.set_border_width (24);
463 HBox* hbox = manage (new HBox);
464 VBox* main_vbox = manage (new VBox);
466 Label* l = manage (new Label);
468 main_vbox->set_spacing (32);
470 no_monitor_section_button.set_label (_("Use a Master bus directly"));
471 l->set_alignment (0.0, 1.0);
472 l->set_markup(_("Connect the Master bus directly to your hardware outputs.\n\
473 <i>Preferable for simple use</i>."));
475 vbox = manage (new VBox);
476 vbox->set_spacing (6);
477 vbox->pack_start (no_monitor_section_button, false, true);
478 vbox->pack_start (*l, false, true);
480 main_vbox->pack_start (*vbox, false, false);
482 use_monitor_section_button.set_label (_("Use an additional Monitor bus"));
483 l = manage (new Label);
484 l->set_alignment (0.0, 1.0);
485 l->set_text (_("Use a Monitor bus between Master bus and hardware outputs for \n\
486 greater control in monitoring without affecting the mix."));
488 vbox = manage (new VBox);
489 vbox->set_spacing (6);
490 vbox->pack_start (use_monitor_section_button, false, true);
491 vbox->pack_start (*l, false, true);
493 main_vbox->pack_start (*vbox, false, false);
495 RadioButton::Group g (use_monitor_section_button.get_group());
496 no_monitor_section_button.set_group (g);
498 if (Config->get_use_monitor_bus()) {
499 use_monitor_section_button.set_active (true);
501 no_monitor_section_button.set_active (true);
504 use_monitor_section_button.signal_toggled().connect (sigc::mem_fun (*this, &ArdourStartup::config_changed));
505 no_monitor_section_button.signal_toggled().connect (sigc::mem_fun (*this, &ArdourStartup::config_changed));
507 monitor_section_label.set_markup(_("<i><small>(You can change this preference at any time, via the Preferences dialog)</small></i>"));
508 monitor_section_label.set_alignment (0.0, 0.0);
510 hbox->pack_start (*main_vbox, true, true, 8);
511 mon_sec_vbox.pack_start (*hbox, false, false);
512 mon_sec_vbox.pack_start (monitor_section_label, false, false);
514 mon_sec_vbox.show_all ();
516 monitor_section_page_index = append_page (mon_sec_vbox);
517 set_page_title (mon_sec_vbox, _("Monitor Section"));
518 set_page_header_image (mon_sec_vbox, icon_pixbuf);
520 /* user could just click on "Forward" if default
524 set_page_complete (mon_sec_vbox, true);
528 ArdourStartup::setup_initial_choice_page ()
530 ic_vbox.set_spacing (6);
531 ic_vbox.set_border_width (24);
533 RadioButton::Group g (ic_new_session_button.get_group());
534 ic_existing_session_button.set_group (g);
536 HBox* centering_hbox = manage (new HBox);
537 VBox* centering_vbox = manage (new VBox);
539 centering_vbox->set_spacing (6);
541 centering_vbox->pack_start (ic_new_session_button, false, true);
542 centering_vbox->pack_start (ic_existing_session_button, false, true);
544 ic_new_session_button.signal_button_press_event().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_press), false);
545 ic_new_session_button.signal_activate().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_activated), false);
547 ic_existing_session_button.signal_button_press_event().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_press), false);
548 ic_existing_session_button.signal_activate().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_activated), false);
550 centering_hbox->pack_start (*centering_vbox, true, true);
552 ic_vbox.pack_start (*centering_hbox, true, true);
556 initial_choice_index = append_page (ic_vbox);
557 set_page_title (ic_vbox, _("What would you like to do ?"));
558 set_page_header_image (ic_vbox, icon_pixbuf);
560 /* user could just click on "Forward" if default
564 set_page_complete (ic_vbox, true);
568 ArdourStartup::initial_button_press (GdkEventButton *event)
570 if (event && event->type == GDK_2BUTTON_PRESS && session_page_index != -1) {
571 set_current_page(session_page_index);
579 ArdourStartup::initial_button_activated ()
581 set_current_page(session_page_index);
585 ArdourStartup::setup_session_page ()
587 session_vbox.set_border_width (24);
589 session_vbox.pack_start (session_hbox, true, true);
590 session_vbox.show_all ();
592 session_page_index = append_page (session_vbox);
593 /* initial setting */
594 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
598 ArdourStartup::setup_final_page ()
600 final_page.set_text (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
602 final_page_index = append_page (final_page);
603 set_page_complete (final_page, true);
604 set_page_header_image (final_page, icon_pixbuf);
605 set_page_type (final_page, ASSISTANT_PAGE_CONFIRM);
609 ArdourStartup::on_cancel ()
611 _response = RESPONSE_CANCEL;
616 ArdourStartup::on_delete_event (GdkEventAny*)
618 _response = RESPONSE_CLOSE;
624 ArdourStartup::on_apply ()
627 engine_dialog->setup_engine ();
630 if (config_modified) {
632 if (default_dir_chooser) {
633 Config->set_default_session_parent_dir (default_dir_chooser->get_filename());
636 if (monitor_via_hardware_button.get_active()) {
637 Config->set_monitoring_model (ExternalMonitoring);
638 } else if (monitor_via_ardour_button.get_active()) {
639 Config->set_monitoring_model (SoftwareMonitoring);
642 Config->set_use_monitor_bus (use_monitor_section_button.get_active());
644 /* "touch" the been-here-before path now that we're about to save Config */
645 ofstream fout (been_here_before_path().to_string().c_str());
647 Config->save_state ();
650 _response = RESPONSE_OK;
655 ArdourStartup::on_prepare (Gtk::Widget* page)
657 if (page == &session_vbox) {
659 if (ic_new_session_button.get_active()) {
660 /* new session requested */
661 setup_new_session_page ();
663 /* existing session requested */
664 setup_existing_session_page ();
668 /* HACK HACK HACK ... change the "Apply" button label
672 Gtk::Widget* tl = session_vbox.get_toplevel();
674 if ((win = dynamic_cast<Gtk::Window*>(tl)) != 0) {
675 /* ::get_default_widget() is not wrapped in gtkmm */
676 Gtk::Widget* def = wrap (gtk_window_get_default_widget (win->gobj()));
678 if ((button = dynamic_cast<Gtk::Button*>(def)) != 0) {
679 if (more_new_session_options_button.get_active()) {
680 button->set_label (_("Forward"));
682 button->set_label (_("Open"));
690 ArdourStartup::populate_session_templates ()
692 vector<TemplateInfo> templates;
694 find_session_templates (templates);
696 template_model->clear ();
698 for (vector<TemplateInfo>::iterator x = templates.begin(); x != templates.end(); ++x) {
701 row = *(template_model->append ());
703 row[session_template_columns.name] = (*x).name;
704 row[session_template_columns.path] = (*x).path;
709 lost_name_entry_focus (GdkEventFocus*)
711 cerr << "lost focus\n";
716 ArdourStartup::setup_new_session_page ()
718 if (!session_hbox.get_children().empty()) {
719 session_hbox.remove (**session_hbox.get_children().begin());
722 session_new_vbox.set_spacing (18);
724 if (session_new_vbox.get_children().empty()) {
725 VBox *vbox1 = manage (new VBox);
726 HBox* hbox1 = manage (new HBox);
727 Label* label1 = manage (new Label);
729 vbox1->set_spacing (6);
731 hbox1->set_spacing (6);
732 hbox1->pack_start (*label1, false, false);
733 hbox1->pack_start (new_name_entry, true, true);
735 label1->set_text (_("Session name:"));
738 if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
739 new_name_entry.set_text (Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name));
740 /* name provided - they can move right along */
741 set_page_complete (session_vbox, true);
744 new_name_entry.signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::new_name_changed));
745 new_name_entry.signal_activate().connect (sigc::mem_fun (*this, &ArdourStartup::move_along_now));
747 vbox1->pack_start (*hbox1, true, true);
751 HBox* hbox2 = manage (new HBox);
752 Label* label2 = manage (new Label);
754 hbox2->set_spacing (6);
755 hbox2->pack_start (*label2, false, false);
756 hbox2->pack_start (new_folder_chooser, true, true);
758 label2->set_text (_("Create session folder in:"));
760 if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
761 new_folder_chooser.set_current_folder (poor_mans_glob (Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name)));
763 new_folder_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
765 new_folder_chooser.set_title (_("Select folder for session"));
768 new_folder_chooser.add_shortcut_folder ("/Volumes");
771 vbox1->pack_start (*hbox2, false, false);
773 session_new_vbox.pack_start (*vbox1, false, false);
777 VBox *vbox2 = manage (new VBox);
778 HBox* hbox3 = manage (new HBox);
779 Label* label3 = manage (new Label);
780 template_model = ListStore::create (session_template_columns);
781 populate_session_templates ();
783 vbox2->set_spacing (6);
785 label3->set_markup (_("<b>Options</b>"));
786 label3->set_alignment (0.0, 0.0);
788 vbox2->pack_start (*label3, false, true);
790 VBox *vbox3 = manage (new VBox);
792 vbox3->set_spacing (6);
794 if (!template_model->children().empty()) {
796 HBox* hbox4a = manage (new HBox);
797 use_template_button.set_label (_("Use this template"));
799 TreeModel::Row row = *template_model->prepend ();
800 row[session_template_columns.name] = (_("no template"));
801 row[session_template_columns.path] = string();
803 hbox4a->set_spacing (6);
804 hbox4a->pack_start (use_template_button, false, false);
805 hbox4a->pack_start (template_chooser, true, true);
807 template_chooser.set_model (template_model);
809 Gtk::CellRendererText* text_renderer = Gtk::manage (new Gtk::CellRendererText);
810 text_renderer->property_editable() = false;
812 template_chooser.pack_start (*text_renderer);
813 template_chooser.add_attribute (text_renderer->property_text(), session_template_columns.name);
814 template_chooser.set_active (0);
816 use_template_button.show();
817 template_chooser.show ();
819 vbox3->pack_start (*hbox4a, false, false);
825 session_template_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
827 HBox* hbox4b = manage (new HBox);
828 use_session_as_template_button.set_label (_("Use an existing session as a template:"));
830 hbox4b->set_spacing (6);
831 hbox4b->pack_start (use_session_as_template_button, false, false);
832 hbox4b->pack_start (session_template_chooser, true, true);
834 use_session_as_template_button.show ();
835 session_template_chooser.show ();
837 Gtk::FileFilter* session_filter = manage (new (Gtk::FileFilter));
838 session_filter->add_pattern (X_("*.ardour"));
839 session_template_chooser.set_filter (*session_filter);
840 session_template_chooser.set_title (_("Select template"));
842 vbox3->pack_start (*hbox4b, false, false);
847 HBox* hbox5 = manage (new HBox);
849 hbox5->set_spacing (6);
850 hbox5->pack_start (more_new_session_options_button, false, false);
852 more_new_session_options_button.show ();
853 more_new_session_options_button.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::more_new_session_options_button_clicked));
855 vbox3->pack_start (*hbox5, false, false);
856 hbox3->pack_start (*vbox3, true, true, 8);
857 vbox2->pack_start (*hbox3, false, false);
861 session_new_vbox.pack_start (*vbox2, false, false);
864 session_new_vbox.show_all ();
865 session_hbox.pack_start (session_new_vbox, true, true);
866 set_page_title (session_vbox, _("New Session"));
867 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
869 if (more_new_session_options_button.get_active()) {
870 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
873 new_name_entry.signal_map().connect (sigc::mem_fun (*this, &ArdourStartup::new_name_mapped));
874 new_name_entry.signal_focus_out_event().connect (sigc::ptr_fun (lost_name_entry_focus));
878 ArdourStartup::new_name_mapped ()
880 cerr << "Grab new name focus\n";
881 new_name_entry.grab_focus ();
885 ArdourStartup::new_name_changed ()
887 if (!new_name_entry.get_text().empty()) {
888 set_page_complete (session_vbox, true);
890 set_page_complete (session_vbox, false);
895 ArdourStartup::redisplay_recent_sessions ()
897 std::vector<sys::path> session_directories;
898 RecentSessionsSorter cmp;
900 recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
901 recent_session_model->clear ();
903 ARDOUR::RecentSessions rs;
904 ARDOUR::read_recent_sessions (rs);
907 recent_session_display.set_model (recent_session_model);
911 // sort them alphabetically
912 sort (rs.begin(), rs.end(), cmp);
914 for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
915 session_directories.push_back ((*i).second);
918 for (vector<sys::path>::const_iterator i = session_directories.begin(); i != session_directories.end(); ++i)
920 std::vector<sys::path> state_file_paths;
922 // now get available states for this session
924 get_state_files_in_directory (*i, state_file_paths);
926 vector<string*>* states;
927 vector<const gchar*> item;
928 string fullpath = (*i).to_string();
930 /* remove any trailing / */
932 if (fullpath[fullpath.length()-1] == '/') {
933 fullpath = fullpath.substr (0, fullpath.length()-1);
936 /* check whether session still exists */
937 if (!Glib::file_test(fullpath.c_str(), Glib::FILE_TEST_EXISTS)) {
938 /* session doesn't exist */
942 /* now get available states for this session */
944 if ((states = Session::possible_states (fullpath)) == 0) {
949 std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
951 Gtk::TreeModel::Row row = *(recent_session_model->append());
953 row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
954 row[recent_session_columns.fullpath] = fullpath;
956 if (state_file_names.size() > 1) {
960 for (std::vector<std::string>::iterator i2 = state_file_names.begin();
961 i2 != state_file_names.end(); ++i2)
964 Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
966 child_row[recent_session_columns.visible_name] = *i2;
967 child_row[recent_session_columns.fullpath] = fullpath;
972 recent_session_display.set_model (recent_session_model);
977 ArdourStartup::recent_session_row_selected ()
979 if (recent_session_display.get_selection()->count_selected_rows() > 0) {
980 set_page_complete (session_vbox, true);
982 set_page_complete (session_vbox, false);
987 ArdourStartup::setup_existing_session_page ()
989 recent_session_model = TreeStore::create (recent_session_columns);
990 redisplay_recent_sessions ();
992 if (!session_hbox.get_children().empty()) {
993 session_hbox.remove (**session_hbox.get_children().begin());
996 if (session_existing_vbox.get_children().empty()) {
998 recent_session_display.set_model (recent_session_model);
999 recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
1000 recent_session_display.set_headers_visible (false);
1001 recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
1003 recent_session_display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::recent_session_row_selected));
1005 recent_scroller.add (recent_session_display);
1006 recent_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1007 recent_scroller.set_shadow_type (Gtk::SHADOW_IN);
1009 recent_session_display.show();
1011 recent_scroller.show();
1012 int cnt = redisplay_recent_sessions ();
1013 recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ArdourStartup::recent_row_activated));
1016 recent_scroller.set_size_request (-1, 300);
1019 session_existing_vbox.set_spacing (8);
1020 session_existing_vbox.pack_start (recent_scroller, true, true);
1022 existing_session_chooser.set_title (_("Select session file"));
1023 existing_session_chooser.signal_file_set().connect (sigc::mem_fun (*this, &ArdourStartup::existing_session_selected));
1026 existing_session_chooser.add_shortcut_folder ("/Volumes");
1029 HBox* hbox = manage (new HBox);
1030 hbox->set_spacing (4);
1031 hbox->pack_start (*manage (new Label (_("Browse:"))), PACK_SHRINK);
1032 hbox->pack_start (existing_session_chooser);
1033 session_existing_vbox.pack_start (*hbox, false, false);
1037 session_existing_vbox.show_all ();
1038 session_hbox.pack_start (session_existing_vbox, true, true);
1040 set_page_title (session_vbox, _("Select a session"));
1041 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1045 ArdourStartup::more_new_session_options_button_clicked ()
1047 if (more_new_session_options_button.get_active()) {
1048 more_options_vbox.show_all ();
1049 set_page_type (more_options_vbox, ASSISTANT_PAGE_CONFIRM);
1050 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
1052 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1053 more_options_vbox.hide ();
1058 ArdourStartup::setup_more_options_page ()
1060 more_options_vbox.set_border_width (24);
1062 _output_limit_count.set_adjustment (_output_limit_count_adj);
1063 _input_limit_count.set_adjustment (_input_limit_count_adj);
1064 _master_bus_channel_count.set_adjustment (_master_bus_channel_count_adj);
1066 chan_count_label_1.set_text (_("channels"));
1067 chan_count_label_3.set_text (_("channels"));
1068 chan_count_label_4.set_text (_("channels"));
1070 chan_count_label_1.set_alignment(0,0.5);
1071 chan_count_label_1.set_padding(0,0);
1072 chan_count_label_1.set_line_wrap(false);
1074 chan_count_label_3.set_alignment(0,0.5);
1075 chan_count_label_3.set_padding(0,0);
1076 chan_count_label_3.set_line_wrap(false);
1078 chan_count_label_4.set_alignment(0,0.5);
1079 chan_count_label_4.set_padding(0,0);
1080 chan_count_label_4.set_line_wrap(false);
1082 bus_label.set_markup (_("<b>Busses</b>"));
1083 input_label.set_markup (_("<b>Inputs</b>"));
1084 output_label.set_markup (_("<b>Outputs</b>"));
1086 _master_bus_channel_count.set_flags(Gtk::CAN_FOCUS);
1087 _master_bus_channel_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1088 _master_bus_channel_count.set_numeric(true);
1089 _master_bus_channel_count.set_digits(0);
1090 _master_bus_channel_count.set_wrap(false);
1092 _create_master_bus.set_label (_("Create master bus"));
1093 _create_master_bus.set_flags(Gtk::CAN_FOCUS);
1094 _create_master_bus.set_relief(Gtk::RELIEF_NORMAL);
1095 _create_master_bus.set_mode(true);
1096 _create_master_bus.set_active(true);
1097 _create_master_bus.set_border_width(0);
1099 advanced_table.set_row_spacings(0);
1100 advanced_table.set_col_spacings(0);
1102 _connect_inputs.set_label (_("Automatically connect to physical_inputs"));
1103 _connect_inputs.set_flags(Gtk::CAN_FOCUS);
1104 _connect_inputs.set_relief(Gtk::RELIEF_NORMAL);
1105 _connect_inputs.set_mode(true);
1106 _connect_inputs.set_active(Config->get_input_auto_connect() != ManualConnect);
1107 _connect_inputs.set_border_width(0);
1109 _limit_input_ports.set_label (_("Use only"));
1110 _limit_input_ports.set_flags(Gtk::CAN_FOCUS);
1111 _limit_input_ports.set_relief(Gtk::RELIEF_NORMAL);
1112 _limit_input_ports.set_mode(true);
1113 _limit_input_ports.set_sensitive(true);
1114 _limit_input_ports.set_border_width(0);
1116 _input_limit_count.set_flags(Gtk::CAN_FOCUS);
1117 _input_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1118 _input_limit_count.set_numeric(true);
1119 _input_limit_count.set_digits(0);
1120 _input_limit_count.set_wrap(false);
1121 _input_limit_count.set_sensitive(false);
1123 bus_hbox.pack_start (bus_table, Gtk::PACK_SHRINK, 18);
1125 bus_label.set_alignment(0, 0.5);
1126 bus_label.set_padding(0,0);
1127 bus_label.set_line_wrap(false);
1128 bus_label.set_selectable(false);
1129 bus_label.set_use_markup(true);
1130 bus_frame.set_shadow_type(Gtk::SHADOW_NONE);
1131 bus_frame.set_label_align(0,0.5);
1132 bus_frame.add(bus_hbox);
1133 bus_frame.set_label_widget(bus_label);
1135 bus_table.set_row_spacings (0);
1136 bus_table.set_col_spacings (0);
1137 bus_table.attach (_create_master_bus, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1138 bus_table.attach (_master_bus_channel_count, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1139 bus_table.attach (chan_count_label_1, 2, 3, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 0);
1141 input_port_limit_hbox.pack_start(_limit_input_ports, Gtk::PACK_SHRINK, 6);
1142 input_port_limit_hbox.pack_start(_input_limit_count, Gtk::PACK_SHRINK, 0);
1143 input_port_limit_hbox.pack_start(chan_count_label_3, Gtk::PACK_SHRINK, 6);
1144 input_port_vbox.pack_start(_connect_inputs, Gtk::PACK_SHRINK, 0);
1145 input_port_vbox.pack_start(input_port_limit_hbox, Gtk::PACK_EXPAND_PADDING, 0);
1146 input_table.set_row_spacings(0);
1147 input_table.set_col_spacings(0);
1148 input_table.attach(input_port_vbox, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 6);
1150 input_hbox.pack_start (input_table, Gtk::PACK_SHRINK, 18);
1152 input_label.set_alignment(0, 0.5);
1153 input_label.set_padding(0,0);
1154 input_label.set_line_wrap(false);
1155 input_label.set_selectable(false);
1156 input_label.set_use_markup(true);
1157 input_frame.set_shadow_type(Gtk::SHADOW_NONE);
1158 input_frame.set_label_align(0,0.5);
1159 input_frame.add(input_hbox);
1160 input_frame.set_label_widget(input_label);
1162 _connect_outputs.set_label (_("Automatically connect outputs"));
1163 _connect_outputs.set_flags(Gtk::CAN_FOCUS);
1164 _connect_outputs.set_relief(Gtk::RELIEF_NORMAL);
1165 _connect_outputs.set_mode(true);
1166 _connect_outputs.set_active(Config->get_output_auto_connect() != ManualConnect);
1167 _connect_outputs.set_border_width(0);
1168 _limit_output_ports.set_label (_("Use only"));
1169 _limit_output_ports.set_flags(Gtk::CAN_FOCUS);
1170 _limit_output_ports.set_relief(Gtk::RELIEF_NORMAL);
1171 _limit_output_ports.set_mode(true);
1172 _limit_output_ports.set_sensitive(true);
1173 _limit_output_ports.set_border_width(0);
1174 _output_limit_count.set_flags(Gtk::CAN_FOCUS);
1175 _output_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1176 _output_limit_count.set_numeric(false);
1177 _output_limit_count.set_digits(0);
1178 _output_limit_count.set_wrap(false);
1179 _output_limit_count.set_sensitive(false);
1180 output_port_limit_hbox.pack_start(_limit_output_ports, Gtk::PACK_SHRINK, 6);
1181 output_port_limit_hbox.pack_start(_output_limit_count, Gtk::PACK_SHRINK, 0);
1182 output_port_limit_hbox.pack_start(chan_count_label_4, Gtk::PACK_SHRINK, 6);
1184 _connect_outputs_to_master.set_label (_("... to master bus"));
1185 _connect_outputs_to_master.set_flags(Gtk::CAN_FOCUS);
1186 _connect_outputs_to_master.set_relief(Gtk::RELIEF_NORMAL);
1187 _connect_outputs_to_master.set_mode(true);
1188 _connect_outputs_to_master.set_active(Config->get_output_auto_connect() == AutoConnectMaster);
1189 _connect_outputs_to_master.set_border_width(0);
1191 _connect_outputs_to_master.set_group (connect_outputs_group);
1192 _connect_outputs_to_physical.set_group (connect_outputs_group);
1194 _connect_outputs_to_physical.set_label (_("... to physical outputs"));
1195 _connect_outputs_to_physical.set_flags(Gtk::CAN_FOCUS);
1196 _connect_outputs_to_physical.set_relief(Gtk::RELIEF_NORMAL);
1197 _connect_outputs_to_physical.set_mode(true);
1198 _connect_outputs_to_physical.set_active(Config->get_output_auto_connect() == AutoConnectPhysical);
1199 _connect_outputs_to_physical.set_border_width(0);
1201 output_conn_vbox.pack_start(_connect_outputs, Gtk::PACK_SHRINK, 0);
1202 output_conn_vbox.pack_start(_connect_outputs_to_master, Gtk::PACK_SHRINK, 0);
1203 output_conn_vbox.pack_start(_connect_outputs_to_physical, Gtk::PACK_SHRINK, 0);
1204 output_vbox.set_border_width(6);
1206 output_port_vbox.pack_start(output_port_limit_hbox, Gtk::PACK_SHRINK, 0);
1208 output_vbox.pack_start(output_conn_vbox);
1209 output_vbox.pack_start(output_port_vbox);
1211 output_label.set_alignment(0, 0.5);
1212 output_label.set_padding(0,0);
1213 output_label.set_line_wrap(false);
1214 output_label.set_selectable(false);
1215 output_label.set_use_markup(true);
1216 output_frame.set_shadow_type(Gtk::SHADOW_NONE);
1217 output_frame.set_label_align(0,0.5);
1219 output_hbox.pack_start (output_vbox, Gtk::PACK_SHRINK, 18);
1221 output_frame.add(output_hbox);
1222 output_frame.set_label_widget(output_label);
1224 more_options_vbox.pack_start(advanced_table, Gtk::PACK_SHRINK, 0);
1225 more_options_vbox.pack_start(bus_frame, Gtk::PACK_SHRINK, 6);
1226 more_options_vbox.pack_start(input_frame, Gtk::PACK_SHRINK, 6);
1227 more_options_vbox.pack_start(output_frame, Gtk::PACK_SHRINK, 0);
1231 _connect_inputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_inputs_clicked));
1232 _connect_outputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_outputs_clicked));
1233 _limit_input_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_inputs_clicked));
1234 _limit_output_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_outputs_clicked));
1235 _create_master_bus.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::master_bus_button_clicked));
1237 /* note that more_options_vbox is NOT visible by
1238 * default. this is entirely by design - this page
1239 * should be skipped unless explicitly requested.
1242 session_options_page_index = append_page (more_options_vbox);
1243 set_page_title (more_options_vbox, _("Advanced Session Options"));
1244 set_page_complete (more_options_vbox, true);
1248 ArdourStartup::create_master_bus() const
1250 return _create_master_bus.get_active();
1254 ArdourStartup::master_channel_count() const
1256 return _master_bus_channel_count.get_value_as_int();
1260 ArdourStartup::connect_inputs() const
1262 return _connect_inputs.get_active();
1266 ArdourStartup::limit_inputs_used_for_connection() const
1268 return _limit_input_ports.get_active();
1272 ArdourStartup::input_limit_count() const
1274 return _input_limit_count.get_value_as_int();
1278 ArdourStartup::connect_outputs() const
1280 return _connect_outputs.get_active();
1284 ArdourStartup::limit_outputs_used_for_connection() const
1286 return _limit_output_ports.get_active();
1290 ArdourStartup::output_limit_count() const
1292 return _output_limit_count.get_value_as_int();
1296 ArdourStartup::connect_outs_to_master() const
1298 return _connect_outputs_to_master.get_active();
1302 ArdourStartup::connect_outs_to_physical() const
1304 return _connect_outputs_to_physical.get_active();
1308 ArdourStartup::connect_inputs_clicked ()
1310 _limit_input_ports.set_sensitive(_connect_inputs.get_active());
1312 if (_connect_inputs.get_active() && _limit_input_ports.get_active()) {
1313 _input_limit_count.set_sensitive(true);
1315 _input_limit_count.set_sensitive(false);
1320 ArdourStartup::connect_outputs_clicked ()
1322 _limit_output_ports.set_sensitive(_connect_outputs.get_active());
1324 if (_connect_outputs.get_active() && _limit_output_ports.get_active()) {
1325 _output_limit_count.set_sensitive(true);
1327 _output_limit_count.set_sensitive(false);
1332 ArdourStartup::limit_inputs_clicked ()
1334 _input_limit_count.set_sensitive(_limit_input_ports.get_active());
1338 ArdourStartup::limit_outputs_clicked ()
1340 _output_limit_count.set_sensitive(_limit_output_ports.get_active());
1344 ArdourStartup::master_bus_button_clicked ()
1346 bool yn = _create_master_bus.get_active();
1348 _master_bus_channel_count.set_sensitive(yn);
1352 ArdourStartup::move_along_now ()
1354 gint cur = get_current_page ();
1356 if (cur == session_page_index) {
1357 if (more_new_session_options_button.get_active()) {
1358 set_current_page (session_options_page_index);
1366 ArdourStartup::recent_row_activated (const Gtk::TreePath&, Gtk::TreeViewColumn*)
1368 set_page_complete (session_vbox, true);
1373 ArdourStartup::existing_session_selected ()
1375 _existing_session_chooser_used = true;
1377 set_page_complete (session_vbox, true);
1382 ArdourStartup::been_here_before_path () const
1384 sys::path b = user_config_directory();
1385 b /= ".a3"; // XXXX use more specific version so we can catch upgrades