gtk2_ardour/startup.cc

   1 /*
   2     Copyright (C) 2010 Paul Davis
   3
   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.
   8
   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.
  13
  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.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include <fstream>
  25 #include <algorithm>
  26
  27 #include <gtkmm/main.h>
  28 #include <gtkmm/filechooser.h>
  29
  30 #include "pbd/failed_constructor.h"
  31 #include "pbd/file_utils.h"
  32 #include "pbd/replace_all.h"
  33 #include "pbd/whitespace.h"
  34 #include "pbd/stacktrace.h"
  35
  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"
  41 #include "ardour/filename_extensions.h"
  42
  43 #include "ardour_ui.h"
  44 #include "startup.h"
  45 #include "opts.h"
  46 #include "engine_dialog.h"
  47 #include "i18n.h"
  48 #include "utils.h"
  49
  50 using namespace std;
  51 using namespace Gtk;
  52 using namespace Gdk;
  53 using namespace Glib;
  54 using namespace PBD;
  55 using namespace ARDOUR;
  56
  57 ArdourStartup* ArdourStartup::the_startup = 0;
  58
  59 static string poor_mans_glob (string path)
  60 {
  61         string copy = path;
  62         replace_all (copy, "~", Glib::get_home_dir());
  63         return copy;
  64 }
  65
  66 ArdourStartup::ArdourStartup (bool require_new, const std::string& session_name, const std::string& session_path, const std::string& template_name)
  67         : _response (RESPONSE_OK)
  68         , config_modified (false)
  69         , new_only (require_new)
  70         , default_dir_chooser (0)
  71         , ic_new_session_button (_("Create a new session"))
  72         , ic_existing_session_button (_("Open an existing session"))
  73         , monitor_via_hardware_button (_("Use an external mixer or the hardware mixer of your audio interface.\n\
  74 Ardour will play NO role in monitoring"))
  75         , monitor_via_ardour_button (string_compose (_("Ask %1 to play back material as it is being recorded"), PROGRAM_NAME))
  76         , engine_dialog (0)
  77         , new_folder_chooser (FILE_CHOOSER_ACTION_SELECT_FOLDER)
  78         , more_new_session_options_button (_("I'd like more options for this session"))
  79         , _output_limit_count_adj (1, 0, 100, 1, 10, 0)
  80         , _input_limit_count_adj (1, 0, 100, 1, 10, 0)
  81         , _master_bus_channel_count_adj (2, 0, 100, 1, 10, 0)
  82         , audio_page_index (-1)
  83         , new_user_page_index (-1)
  84         , default_folder_page_index (-1)
  85         , monitoring_page_index (-1)
  86         , session_page_index (-1)
  87         , initial_choice_index (-1)
  88         , final_page_index (-1)
  89         , session_options_page_index (-1)
  90         , _existing_session_chooser_used (false)
  91 {
  92         new_user = !Glib::file_test (been_here_before_path(), Glib::FILE_TEST_EXISTS);
  93         need_audio_setup = EngineControl::need_setup ();
  94         need_session_info = (session_name.empty() || require_new);
  95
  96         _provided_session_name = session_name;
  97         _provided_session_path = session_path;
  98
  99         if (need_audio_setup || need_session_info || new_user) {
 100
 101                 use_template_button.set_group (session_template_group);
 102                 use_session_as_template_button.set_group (session_template_group);
 103
 104                 set_keep_above (true);
 105                 set_position (WIN_POS_CENTER);
 106                 set_border_width (12);
 107
 108                 if ((icon_pixbuf = ::get_icon ("ardour_icon_48px")) == 0) {
 109                         throw failed_constructor();
 110                 }
 111
 112                 list<Glib::RefPtr<Gdk::Pixbuf> > window_icons;
 113                 Glib::RefPtr<Gdk::Pixbuf> icon;
 114
 115                 if ((icon = ::get_icon ("ardour_icon_16px")) != 0) {
 116                         window_icons.push_back (icon);
 117                 }
 118                 if ((icon = ::get_icon ("ardour_icon_22px")) != 0) {
 119                         window_icons.push_back (icon);
 120                 }
 121                 if ((icon = ::get_icon ("ardour_icon_32px")) != 0) {
 122                         window_icons.push_back (icon);
 123                 }
 124                 if ((icon = ::get_icon ("ardour_icon_48px")) != 0) {
 125                         window_icons.push_back (icon);
 126                 }
 127                 if (!window_icons.empty ()) {
 128                         set_default_icon_list (window_icons);
 129                 }
 130
 131                 set_type_hint(Gdk::WINDOW_TYPE_HINT_DIALOG);
 132
 133                 // setup_prerelease_page ();
 134
 135                 if (new_user) {
 136
 137                         setup_new_user_page ();
 138                         setup_first_time_config_page ();
 139                         setup_monitoring_choice_page ();
 140                         setup_monitor_section_choice_page ();
 141
 142                         if (need_audio_setup) {
 143                                 setup_audio_page ();
 144                         }
 145
 146                         ic_new_session_button.set_active (true); // always create new session on first run
 147
 148                 } else {
 149
 150                         if (need_audio_setup) {
 151                                 setup_audio_page ();
 152                         }
 153
 154                         setup_initial_choice_page ();
 155                 }
 156
 157                 setup_session_page ();
 158                 setup_more_options_page ();
 159
 160                 if (new_user) {
 161                         setup_final_page ();
 162                 }
 163
 164                 if (new_only) {
 165                         ic_vbox.hide ();
 166                 } else {
 167                         ic_vbox.show ();
 168                 }
 169
 170                 if (!template_name.empty()) {
 171                         use_template_button.set_active (false);
 172                         load_template_override = template_name;
 173                 }
 174         }
 175
 176         the_startup = this;
 177 }
 178
 179 ArdourStartup::~ArdourStartup ()
 180 {
 181 }
 182
 183 bool
 184 ArdourStartup::ready_without_display () const
 185 {
 186         return !new_user && !need_audio_setup && !need_session_info;
 187 }
 188
 189 void
 190 ArdourStartup::setup_prerelease_page ()
 191 {
 192         VBox* vbox = manage (new VBox);
 193         Label* label = manage (new Label);
 194         label->set_markup (_("<b>Welcome to this BETA release of Ardour 3.0</b>\n\n\
 195 There are still several issues and bugs to be worked on,\n\
 196 as well as general workflow improvements, before this can be considered\n\
 197 release software. So, a few guidelines:\n\
 198 \n\
 199 1) Please do <b>NOT</b> use this software with the expectation that it is stable or reliable\n\
 200    though it may be so, depending on your workflow.\n\
 201 2) Please see http://ardour.org/a3_features for a guide to new features.\n\
 202 3) <b>Please do NOT use the forums at ardour.org to report issues</b>.\n\
 203 4) Please <b>DO</b> use the bugtracker at http://tracker.ardour.org/ to report issues\n\
 204    making sure to note the product version number as 3.0-beta.\n\
 205 5) Please <b>DO</b> use the ardour-users mailing list to discuss ideas and pass on comments.\n\
 206 6) Please <b>DO</b> join us on IRC for real time discussions about ardour3. You\n\
 207    can get there directly from Ardour via the Help->Chat menu option.\n\
 208 \n\
 209 Full information on all the above can be found on the support page at\n\
 210 \n\
 211                 http://ardour.org/support\n\
 212 "));
 213
 214         vbox->set_border_width (12);
 215         vbox->pack_start (*label, false, false, 12);
 216         vbox->show_all ();
 217
 218         append_page (*vbox);
 219         set_page_type (*vbox, ASSISTANT_PAGE_CONTENT);
 220         set_page_title (*vbox, _("This is a BETA RELEASE"));
 221         set_page_complete (*vbox, true);
 222 }
 223
 224 bool
 225 ArdourStartup::use_session_template ()
 226 {
 227         if (!load_template_override.empty()) {
 228                 return true;
 229         }
 230
 231         if (use_template_button.get_active()) {
 232                 return template_chooser.get_active_row_number() > 0;
 233         } else {
 234                 return !session_template_chooser.get_filename().empty();
 235         }
 236 }
 237
 238 std::string
 239 ArdourStartup::session_template_name ()
 240 {
 241         if (!load_template_override.empty()) {
 242                 string the_path (ARDOUR::user_template_directory());
 243                 return Glib::build_filename (the_path, load_template_override + ARDOUR::template_suffix);
 244         }
 245
 246         if (ic_existing_session_button.get_active()) {
 247                 return string();
 248         }
 249
 250         if (use_template_button.get_active()) {
 251                 TreeModel::iterator iter = template_chooser.get_active ();
 252                 TreeModel::Row row = (*iter);
 253                 string s = row[session_template_columns.path];
 254                 return s;
 255         } else {
 256                 return session_template_chooser.get_filename();
 257
 258         }
 259 }
 260
 261 std::string
 262 ArdourStartup::session_name (bool& should_be_new)
 263 {
 264         if (ready_without_display()) {
 265                 return _provided_session_name;
 266         }
 267
 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);
 272                 return 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 ();
 277         } else {
 278                 /* existing session chosen from recent list */
 279                 should_be_new = false;
 280
 281                 TreeIter iter = recent_session_display.get_selection()->get_selected();
 282
 283                 if (iter) {
 284                         return (*iter)[recent_session_columns.visible_name];
 285                 }
 286
 287                 return "";
 288         }
 289 }
 290
 291 std::string
 292 ArdourStartup::session_folder ()
 293 {
 294         if (ready_without_display()) {
 295                 return _provided_session_path;
 296         }
 297
 298         if (ic_new_session_button.get_active()) {
 299                 std::string legal_session_folder_name = legalize_for_path (new_name_entry.get_text());
 300                 return Glib::build_filename (new_folder_chooser.get_current_folder(), legal_session_folder_name);
 301         } else if (_existing_session_chooser_used) {
 302                 /* existing session chosen from file chooser */
 303                 return existing_session_chooser.get_current_folder ();
 304         } else {
 305                 /* existing session chosen from recent list */
 306                 TreeIter iter = recent_session_display.get_selection()->get_selected();
 307
 308                 if (iter) {
 309                         return (*iter)[recent_session_columns.fullpath];
 310                 }
 311                 return "";
 312         }
 313 }
 314
 315 void
 316 ArdourStartup::setup_audio_page ()
 317 {
 318         engine_dialog = manage (new EngineControl);
 319
 320         engine_dialog->set_border_width (12);
 321
 322         engine_dialog->show_all ();
 323
 324         audio_page_index = append_page (*engine_dialog);
 325         set_page_type (*engine_dialog, ASSISTANT_PAGE_CONTENT);
 326         set_page_title (*engine_dialog, _("Audio / MIDI Setup"));
 327
 328         /* the default parameters should work, so the page is potentially complete */
 329
 330         set_page_complete (*engine_dialog, true);
 331 }
 332
 333 void
 334 ArdourStartup::setup_new_user_page ()
 335 {
 336         Label* foomatic = manage (new Label);
 337
 338         foomatic->set_markup (string_compose (_("\
 339 <span size=\"larger\">%1 is a digital audio workstation. You can use it to \
 340 record, edit and mix multi-track audio. You can produce your \
 341 own CDs, mix video soundtracks, or experiment with new \
 342 ideas about music and sound. \
 343 \n\n\
 344 There are a few things that need to be configured before you start \
 345 using the program.</span> \
 346 "), PROGRAM_NAME));
 347         foomatic->set_justify (JUSTIFY_FILL);
 348         foomatic->set_line_wrap ();
 349
 350         HBox* hbox = manage (new HBox);
 351         HBox* vbox = manage (new HBox);
 352
 353         vbox->set_border_width (24);
 354
 355         hbox->pack_start (*foomatic, true, true);
 356         vbox->pack_start (*hbox, true, true);
 357
 358         foomatic->show ();
 359         hbox->show ();
 360         vbox->show ();
 361
 362         new_user_page_index = append_page (*vbox);
 363         set_page_type (*vbox, ASSISTANT_PAGE_INTRO);
 364         set_page_title (*vbox, string_compose (_("Welcome to %1"), PROGRAM_NAME));
 365         set_page_header_image (*vbox, icon_pixbuf);
 366         set_page_complete (*vbox, true);
 367 }
 368
 369 void
 370 ArdourStartup::default_dir_changed ()
 371 {
 372         Config->set_default_session_parent_dir (default_dir_chooser->get_filename());
 373         // make new session folder chooser point to the new default
 374         new_folder_chooser.set_current_folder (Config->get_default_session_parent_dir());
 375         config_changed ();
 376 }
 377
 378 void
 379 ArdourStartup::config_changed ()
 380 {
 381         config_modified = true;
 382 }
 383
 384 void
 385 ArdourStartup::setup_first_time_config_page ()
 386 {
 387         default_dir_chooser = manage (new FileChooserButton (string_compose (_("Default folder for %1 sessions"), PROGRAM_NAME),
 388                                                              FILE_CHOOSER_ACTION_SELECT_FOLDER));
 389         Gtk::Label* txt = manage (new Label);
 390         HBox* hbox = manage (new HBox);
 391         VBox* vbox = manage (new VBox);
 392
 393         txt->set_markup (string_compose (_("\
 394 Each project that you work on with %1 has its own folder.\n\
 395 These can require a lot of disk space if you are recording audio.\n\
 396 \n\
 397 Where would you like new %1 sessions to be stored by default?\n\n\
 398 <i>(You can put new sessions anywhere, this is just a default)</i>"), PROGRAM_NAME));
 399         txt->set_alignment (0.0, 0.0);
 400
 401         vbox->set_spacing (18);
 402         vbox->set_border_width (24);
 403
 404         hbox->pack_start (*default_dir_chooser, false, true, 8);
 405         vbox->pack_start (*txt, false, false);
 406         vbox->pack_start (*hbox, false, true);
 407
 408         default_dir_chooser->set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
 409         default_dir_chooser->signal_current_folder_changed().connect (sigc::mem_fun (*this, &ArdourStartup::default_dir_changed));
 410         default_dir_chooser->show ();
 411
 412         vbox->show_all ();
 413
 414         default_folder_page_index = append_page (*vbox);
 415         set_page_title (*vbox, _("Default folder for new sessions"));
 416         set_page_header_image (*vbox, icon_pixbuf);
 417         set_page_type (*vbox, ASSISTANT_PAGE_CONTENT);
 418
 419         /* user can just skip all these settings if they want to */
 420
 421         set_page_complete (*vbox, true);
 422 }
 423
 424 void
 425 ArdourStartup::setup_monitoring_choice_page ()
 426 {
 427         mon_vbox.set_spacing (18);
 428         mon_vbox.set_border_width (24);
 429
 430         HBox* hbox = manage (new HBox);
 431         VBox* vbox = manage (new VBox);
 432         /* first button will be on by default */
 433         RadioButton::Group g (monitor_via_ardour_button.get_group());
 434         monitor_via_hardware_button.set_group (g);
 435
 436         monitor_label.set_markup(_("\
 437 While recording instruments or vocals, you probably want to listen to the\n\
 438 signal as well as record it. This is called \"monitoring\". There are\n\
 439 different ways to do this depending on the equipment you have and the\n\
 440 configuration of that equipment. The two most common are presented here.\n\
 441 Please choose whichever one is right for your setup.\n\n\
 442 <i>(You can change this preference at any time, via the Preferences dialog)</i>\n\n\
 443 <i>If you do not understand what this is about, just accept the default.</i>"));
 444         monitor_label.set_alignment (0.0, 0.0);
 445
 446         vbox->set_spacing (6);
 447
 448         vbox->pack_start (monitor_via_hardware_button, false, true);
 449         vbox->pack_start (monitor_via_ardour_button, false, true);
 450         hbox->pack_start (*vbox, true, true, 8);
 451         mon_vbox.pack_start (monitor_label, false, false);
 452         mon_vbox.pack_start (*hbox, false, false);
 453
 454         mon_vbox.show_all ();
 455
 456         monitoring_page_index = append_page (mon_vbox);
 457         set_page_title (mon_vbox, _("Monitoring Choices"));
 458         set_page_header_image (mon_vbox, icon_pixbuf);
 459
 460         /* user could just click on "Forward" if default
 461          * choice is correct.
 462          */
 463
 464         set_page_complete (mon_vbox, true);
 465 }
 466
 467 void
 468 ArdourStartup::setup_monitor_section_choice_page ()
 469 {
 470         mon_sec_vbox.set_spacing (18);
 471         mon_sec_vbox.set_border_width (24);
 472
 473         HBox* hbox = manage (new HBox);
 474         VBox* main_vbox = manage (new VBox);
 475         VBox* vbox;
 476         Label* l = manage (new Label);
 477
 478         main_vbox->set_spacing (32);
 479
 480         no_monitor_section_button.set_label (_("Use a Master bus directly"));
 481         l->set_alignment (0.0, 1.0);
 482         l->set_markup(_("Connect the Master bus directly to your hardware outputs. This is preferable for simple usage."));
 483
 484         vbox = manage (new VBox);
 485         vbox->set_spacing (6);
 486         vbox->pack_start (no_monitor_section_button, false, true);
 487         vbox->pack_start (*l, false, true);
 488
 489         main_vbox->pack_start (*vbox, false, false);
 490
 491         use_monitor_section_button.set_label (_("Use an additional Monitor bus"));
 492         l = manage (new Label);
 493         l->set_alignment (0.0, 1.0);
 494         l->set_text (_("Use a Monitor bus between Master bus and hardware outputs for \n\
 495 greater control in monitoring without affecting the mix."));
 496
 497         vbox = manage (new VBox);
 498         vbox->set_spacing (6);
 499         vbox->pack_start (use_monitor_section_button, false, true);
 500         vbox->pack_start (*l, false, true);
 501
 502         main_vbox->pack_start (*vbox, false, false);
 503
 504         RadioButton::Group g (use_monitor_section_button.get_group());
 505         no_monitor_section_button.set_group (g);
 506
 507         if (Config->get_use_monitor_bus()) {
 508                 use_monitor_section_button.set_active (true);
 509         } else {
 510                 no_monitor_section_button.set_active (true);
 511         }
 512
 513         use_monitor_section_button.signal_toggled().connect (sigc::mem_fun (*this, &ArdourStartup::config_changed));
 514         no_monitor_section_button.signal_toggled().connect (sigc::mem_fun (*this, &ArdourStartup::config_changed));
 515
 516         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\
 517 <i>If you do not understand what this is about, just accept the default.</i>"));
 518         monitor_section_label.set_alignment (0.0, 0.0);
 519
 520         hbox->pack_start (*main_vbox, true, true, 8);
 521         mon_sec_vbox.pack_start (*hbox, false, false);
 522         mon_sec_vbox.pack_start (monitor_section_label, false, false);
 523
 524         mon_sec_vbox.show_all ();
 525
 526         monitor_section_page_index = append_page (mon_sec_vbox);
 527         set_page_title (mon_sec_vbox, _("Monitor Section"));
 528         set_page_header_image (mon_sec_vbox, icon_pixbuf);
 529
 530         /* user could just click on "Forward" if default
 531          * choice is correct.
 532          */
 533
 534         set_page_complete (mon_sec_vbox, true);
 535 }
 536
 537 void
 538 ArdourStartup::setup_initial_choice_page ()
 539 {
 540         ic_vbox.set_spacing (6);
 541         ic_vbox.set_border_width (24);
 542
 543         RadioButton::Group g (ic_new_session_button.get_group());
 544         ic_existing_session_button.set_group (g);
 545
 546         HBox* centering_hbox = manage (new HBox);
 547         VBox* centering_vbox = manage (new VBox);
 548
 549         centering_vbox->set_spacing (6);
 550
 551         centering_vbox->pack_start (ic_new_session_button, false, true);
 552         centering_vbox->pack_start (ic_existing_session_button, false, true);
 553
 554         ic_new_session_button.signal_button_press_event().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_clicked), false);
 555         ic_new_session_button.signal_activate().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_activated), false);
 556
 557         ic_existing_session_button.signal_button_press_event().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_clicked), false);
 558         ic_existing_session_button.signal_activate().connect(sigc::mem_fun(*this, &ArdourStartup::initial_button_activated), false);
 559
 560         centering_hbox->pack_start (*centering_vbox, true, true);
 561
 562         ic_vbox.pack_start (*centering_hbox, true, true);
 563
 564         ic_vbox.show_all ();
 565
 566         initial_choice_index = append_page (ic_vbox);
 567         set_page_title (ic_vbox, _("What would you like to do ?"));
 568         set_page_header_image (ic_vbox, icon_pixbuf);
 569
 570         /* user could just click on "Forward" if default
 571          * choice is correct.
 572          */
 573
 574         set_page_complete (ic_vbox, true);
 575 }
 576
 577 bool
 578 ArdourStartup::initial_button_clicked (GdkEventButton* ev)
 579 {
 580         if (ev->type == GDK_2BUTTON_PRESS && session_page_index != -1) {
 581                 set_current_page(session_page_index);
 582         }
 583
 584         return false;
 585 }
 586
 587 void
 588 ArdourStartup::initial_button_activated ()
 589 {
 590         if (session_page_index != -1) {
 591                 set_current_page(session_page_index);
 592         }
 593 }
 594
 595 void
 596 ArdourStartup::setup_session_page ()
 597 {
 598         session_vbox.set_border_width (24);
 599
 600         session_vbox.pack_start (session_hbox, true, true);
 601         session_vbox.show_all ();
 602
 603         session_page_index = append_page (session_vbox);
 604         /* initial setting */
 605         set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
 606 }
 607
 608 void
 609 ArdourStartup::setup_final_page ()
 610 {
 611         final_page.set_text (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
 612         final_page.show ();
 613         final_page_index = append_page (final_page);
 614         set_page_complete (final_page, true);
 615         set_page_header_image (final_page, icon_pixbuf);
 616         set_page_type (final_page, ASSISTANT_PAGE_CONFIRM);
 617 }
 618
 619 void
 620 ArdourStartup::on_cancel ()
 621 {
 622         _response = RESPONSE_CANCEL;
 623         gtk_main_quit ();
 624 }
 625
 626 bool
 627 ArdourStartup::on_delete_event (GdkEventAny*)
 628 {
 629         _response = RESPONSE_CLOSE;
 630         gtk_main_quit ();
 631         return true;
 632 }
 633
 634 void
 635 ArdourStartup::on_apply ()
 636 {
 637         if (engine_dialog) {
 638                 if (engine_dialog->setup_engine ()) {
 639                         set_current_page (audio_page_index);
 640                         return;
 641                 }
 642         }
 643
 644         if (config_modified) {
 645
 646                 if (default_dir_chooser) {
 647                         Config->set_default_session_parent_dir (default_dir_chooser->get_filename());
 648                 }
 649
 650                 if (monitor_via_hardware_button.get_active()) {
 651                         Config->set_monitoring_model (ExternalMonitoring);
 652                 } else if (monitor_via_ardour_button.get_active()) {
 653                         Config->set_monitoring_model (SoftwareMonitoring);
 654                 }
 655
 656                 Config->set_use_monitor_bus (use_monitor_section_button.get_active());
 657
 658                 /* "touch" the been-here-before path now that we're about to save Config */
 659                 ofstream fout (been_here_before_path().c_str());
 660
 661                 Config->save_state ();
 662         }
 663
 664         _response = RESPONSE_OK;
 665         gtk_main_quit ();
 666 }
 667
 668 void
 669 ArdourStartup::on_prepare (Gtk::Widget* page)
 670 {
 671         if (page == &session_vbox) {
 672
 673                 if (ic_new_session_button.get_active()) {
 674                         /* new session requested */
 675                         setup_new_session_page ();
 676                 } else {
 677                         /* existing session requested */
 678                         setup_existing_session_page ();
 679
 680                 }
 681
 682                 /* HACK HACK HACK ... change the "Apply" button label
 683                    to say "Open"
 684                 */
 685
 686                 Gtk::Widget* tl = session_vbox.get_toplevel();
 687                 Gtk::Window* win;
 688                 if ((win = dynamic_cast<Gtk::Window*>(tl)) != 0) {
 689                         /* ::get_default_widget() is not wrapped in gtkmm */
 690                         Gtk::Widget* def = wrap (gtk_window_get_default_widget (win->gobj()));
 691                         Gtk::Button* button;
 692                         if ((button = dynamic_cast<Gtk::Button*>(def)) != 0) {
 693                                 if (more_new_session_options_button.get_active()) {
 694                                         button->set_label (_("Forward"));
 695                                 }else{
 696                                         button->set_label (_("Open"));
 697                                 }
 698                         }
 699                 }
 700         }
 701 }
 702
 703 void
 704 ArdourStartup::populate_session_templates ()
 705 {
 706         vector<TemplateInfo> templates;
 707
 708         find_session_templates (templates);
 709
 710         template_model->clear ();
 711
 712         for (vector<TemplateInfo>::iterator x = templates.begin(); x != templates.end(); ++x) {
 713                 TreeModel::Row row;
 714
 715                 row = *(template_model->append ());
 716
 717                 row[session_template_columns.name] = (*x).name;
 718                 row[session_template_columns.path] = (*x).path;
 719         }
 720 }
 721
 722 void
 723 ArdourStartup::setup_new_session_page ()
 724 {
 725         if (!session_hbox.get_children().empty()) {
 726                 session_hbox.remove (**session_hbox.get_children().begin());
 727         }
 728
 729         session_new_vbox.set_spacing (18);
 730
 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);
 735
 736                 vbox1->set_spacing (6);
 737
 738                 hbox1->set_spacing (6);
 739                 hbox1->pack_start (*label1, false, false);
 740                 hbox1->pack_start (new_name_entry, true, true);
 741
 742                 label1->set_text (_("Session name:"));
 743
 744
 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);
 749                 }
 750
 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));
 753
 754                 vbox1->pack_start (*hbox1, true, true);
 755
 756                 /* --- */
 757
 758                 HBox* hbox2 = manage (new HBox);
 759                 Label* label2 = manage (new Label);
 760
 761                 hbox2->set_spacing (6);
 762                 hbox2->pack_start (*label2, false, false);
 763                 hbox2->pack_start (new_folder_chooser, true, true);
 764
 765                 label2->set_text (_("Create session folder in:"));
 766
 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()));
 776                 } else {
 777                         new_folder_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
 778                 }
 779                 new_folder_chooser.set_title (_("Select folder for session"));
 780
 781 #ifdef GTKOSX
 782                 new_folder_chooser.add_shortcut_folder ("/Volumes");
 783 #endif
 784
 785                 vbox1->pack_start (*hbox2, false, false);
 786
 787                 session_new_vbox.pack_start (*vbox1, false, false);
 788
 789                 /* --- */
 790
 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 ();
 796
 797                 vbox2->set_spacing (6);
 798
 799                 label3->set_markup (_("<b>Options</b>"));
 800                 label3->set_alignment (0.0, 0.0);
 801
 802                 vbox2->pack_start (*label3, false, true);
 803
 804                 VBox *vbox3 = manage (new VBox);
 805
 806                 vbox3->set_spacing (6);
 807
 808                 if (!template_model->children().empty()) {
 809
 810                         HBox* hbox4a = manage (new HBox);
 811                         use_template_button.set_label (_("Use this template"));
 812
 813                         TreeModel::Row row = *template_model->prepend ();
 814                         row[session_template_columns.name] = (_("no template"));
 815                         row[session_template_columns.path] = string();
 816
 817                         hbox4a->set_spacing (6);
 818                         hbox4a->pack_start (use_template_button, false, false);
 819                         hbox4a->pack_start (template_chooser, true, true);
 820
 821                         template_chooser.set_model (template_model);
 822
 823                         Gtk::CellRendererText* text_renderer = Gtk::manage (new Gtk::CellRendererText);
 824                         text_renderer->property_editable() = false;
 825
 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);
 829
 830                         use_template_button.show();
 831                         template_chooser.show ();
 832
 833                         vbox3->pack_start (*hbox4a, false, false);
 834                 }
 835
 836                 /* --- */
 837
 838                 if (!new_user) {
 839                         session_template_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
 840
 841                         HBox* hbox4b = manage (new HBox);
 842                         use_session_as_template_button.set_label (_("Use an existing session as a template:"));
 843
 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);
 847
 848                         use_session_as_template_button.show ();
 849                         session_template_chooser.show ();
 850
 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"));
 855
 856                         vbox3->pack_start (*hbox4b, false, false);
 857                 }
 858
 859                 /* --- */
 860
 861                 HBox* hbox5 = manage (new HBox);
 862
 863                 hbox5->set_spacing (6);
 864                 hbox5->pack_start (more_new_session_options_button, false, false);
 865
 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));
 868
 869                 vbox3->pack_start (*hbox5, false, false);
 870                 hbox3->pack_start (*vbox3, true, true, 8);
 871                 vbox2->pack_start (*hbox3, false, false);
 872
 873                 /* --- */
 874
 875                 session_new_vbox.pack_start (*vbox2, false, false);
 876         }
 877
 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);
 882
 883         if (more_new_session_options_button.get_active()) {
 884                 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
 885         }
 886 }
 887
 888 void
 889 ArdourStartup::new_name_changed ()
 890 {
 891         if (!new_name_entry.get_text().empty()) {
 892                 set_page_complete (session_vbox, true);
 893         } else {
 894                 set_page_complete (session_vbox, false);
 895         }
 896 }
 897
 898 int
 899 ArdourStartup::redisplay_recent_sessions ()
 900 {
 901         std::vector<std::string> session_directories;
 902         RecentSessionsSorter cmp;
 903
 904         recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
 905         recent_session_model->clear ();
 906
 907         ARDOUR::RecentSessions rs;
 908         ARDOUR::read_recent_sessions (rs);
 909
 910         if (rs.empty()) {
 911                 recent_session_display.set_model (recent_session_model);
 912                 return 0;
 913         }
 914         //
 915         // sort them alphabetically
 916         sort (rs.begin(), rs.end(), cmp);
 917
 918         for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
 919                 session_directories.push_back ((*i).second);
 920         }
 921
 922         int session_snapshot_count = 0;
 923
 924         for (vector<std::string>::const_iterator i = session_directories.begin(); i != session_directories.end(); ++i)
 925         {
 926                 std::vector<std::string> state_file_paths;
 927
 928                 // now get available states for this session
 929
 930                 get_state_files_in_directory (*i, state_file_paths);
 931
 932                 vector<string*>* states;
 933                 vector<const gchar*> item;
 934                 string fullpath = *i;
 935
 936                 /* remove any trailing / */
 937
 938                 if (fullpath[fullpath.length()-1] == '/') {
 939                         fullpath = fullpath.substr (0, fullpath.length()-1);
 940                 }
 941
 942                 /* check whether session still exists */
 943                 if (!Glib::file_test(fullpath.c_str(), Glib::FILE_TEST_EXISTS)) {
 944                         /* session doesn't exist */
 945                         continue;
 946                 }
 947
 948                 /* now get available states for this session */
 949
 950                 if ((states = Session::possible_states (fullpath)) == 0) {
 951                         /* no state file? */
 952                         continue;
 953                 }
 954
 955                 std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
 956
 957                 Gtk::TreeModel::Row row = *(recent_session_model->append());
 958
 959                 row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
 960                 row[recent_session_columns.fullpath] = fullpath;
 961                 row[recent_session_columns.tip] = Glib::Markup::escape_text (fullpath);
 962
 963                 ++session_snapshot_count;
 964
 965                 if (state_file_names.size() > 1) {
 966
 967                         // add the children
 968
 969                         for (std::vector<std::string>::iterator i2 = state_file_names.begin();
 970                                         i2 != state_file_names.end(); ++i2) {
 971
 972                                 Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
 973
 974                                 child_row[recent_session_columns.visible_name] = *i2;
 975                                 child_row[recent_session_columns.fullpath] = fullpath;
 976                                 child_row[recent_session_columns.tip] = Glib::Markup::escape_text (fullpath);
 977                                 ++session_snapshot_count;
 978                         }
 979                 }
 980         }
 981
 982         recent_session_display.set_tooltip_column(1); // recent_session_columns.tip
 983         recent_session_display.set_model (recent_session_model);
 984         return session_snapshot_count;
 985         // return rs.size();
 986 }
 987
 988 void
 989 ArdourStartup::recent_session_row_selected ()
 990 {
 991         if (recent_session_display.get_selection()->count_selected_rows() > 0) {
 992                 set_page_complete (session_vbox, true);
 993         } else {
 994                 set_page_complete (session_vbox, false);
 995         }
 996 }
 997
 998 void
 999 ArdourStartup::setup_existing_session_page ()
1000 {
1001         recent_session_model = TreeStore::create (recent_session_columns);
1002         redisplay_recent_sessions ();
1003
1004         if (!session_hbox.get_children().empty()) {
1005                 session_hbox.remove (**session_hbox.get_children().begin());
1006         }
1007
1008         if (session_existing_vbox.get_children().empty()) {
1009
1010                 recent_session_display.set_model (recent_session_model);
1011                 recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
1012                 recent_session_display.set_headers_visible (false);
1013                 recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
1014
1015                 recent_session_display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::recent_session_row_selected));
1016
1017                 recent_scroller.add (recent_session_display);
1018                 recent_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1019                 recent_scroller.set_shadow_type (Gtk::SHADOW_IN);
1020
1021                 recent_session_display.show();
1022
1023                 recent_scroller.show();
1024                 int cnt = redisplay_recent_sessions ();
1025                 recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ArdourStartup::recent_row_activated));
1026
1027                 if (cnt > 4) {
1028                         recent_scroller.set_size_request (-1, 300);
1029                 }
1030
1031                 session_existing_vbox.set_spacing (8);
1032                 session_existing_vbox.pack_start (recent_scroller, true, true);
1033
1034                 existing_session_chooser.set_title (_("Select session file"));
1035                 existing_session_chooser.signal_file_set().connect (sigc::mem_fun (*this, &ArdourStartup::existing_session_selected));
1036                 existing_session_chooser.set_current_folder(poor_mans_glob (Config->get_default_session_parent_dir()));
1037
1038                 FileFilter session_filter;
1039                 session_filter.add_pattern ("*.ardour");
1040                 session_filter.set_name (string_compose (_("%1 sessions"), PROGRAM_NAME));
1041                 existing_session_chooser.add_filter (session_filter);
1042                 existing_session_chooser.set_filter (session_filter);
1043
1044 #ifdef GTKOSX
1045                 existing_session_chooser.add_shortcut_folder ("/Volumes");
1046 #endif
1047
1048                 HBox* hbox = manage (new HBox);
1049                 hbox->set_spacing (4);
1050                 hbox->pack_start (*manage (new Label (_("Browse:"))), PACK_SHRINK);
1051                 hbox->pack_start (existing_session_chooser);
1052                 session_existing_vbox.pack_start (*hbox, false, false);
1053                 hbox->show_all ();
1054         }
1055
1056         session_existing_vbox.show_all ();
1057         session_hbox.pack_start (session_existing_vbox, true, true);
1058
1059         set_page_title (session_vbox, _("Select a session"));
1060         set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1061 }
1062
1063 void
1064 ArdourStartup::more_new_session_options_button_clicked ()
1065 {
1066         if (more_new_session_options_button.get_active()) {
1067                 more_options_vbox.show_all ();
1068                 set_page_type (more_options_vbox, ASSISTANT_PAGE_CONFIRM);
1069                 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
1070         } else {
1071                 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1072                 more_options_vbox.hide ();
1073         }
1074 }
1075
1076 void
1077 ArdourStartup::setup_more_options_page ()
1078 {
1079         more_options_vbox.set_border_width (24);
1080
1081         _output_limit_count.set_adjustment (_output_limit_count_adj);
1082         _input_limit_count.set_adjustment (_input_limit_count_adj);
1083         _master_bus_channel_count.set_adjustment (_master_bus_channel_count_adj);
1084
1085         chan_count_label_1.set_text (_("channels"));
1086         chan_count_label_3.set_text (_("channels"));
1087         chan_count_label_4.set_text (_("channels"));
1088
1089         chan_count_label_1.set_alignment(0,0.5);
1090         chan_count_label_1.set_padding(0,0);
1091         chan_count_label_1.set_line_wrap(false);
1092
1093         chan_count_label_3.set_alignment(0,0.5);
1094         chan_count_label_3.set_padding(0,0);
1095         chan_count_label_3.set_line_wrap(false);
1096
1097         chan_count_label_4.set_alignment(0,0.5);
1098         chan_count_label_4.set_padding(0,0);
1099         chan_count_label_4.set_line_wrap(false);
1100
1101         bus_label.set_markup (_("<b>Busses</b>"));
1102         input_label.set_markup (_("<b>Inputs</b>"));
1103         output_label.set_markup (_("<b>Outputs</b>"));
1104
1105         _master_bus_channel_count.set_flags(Gtk::CAN_FOCUS);
1106         _master_bus_channel_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1107         _master_bus_channel_count.set_numeric(true);
1108         _master_bus_channel_count.set_digits(0);
1109         _master_bus_channel_count.set_wrap(false);
1110
1111         _create_master_bus.set_label (_("Create master bus"));
1112         _create_master_bus.set_flags(Gtk::CAN_FOCUS);
1113         _create_master_bus.set_relief(Gtk::RELIEF_NORMAL);
1114         _create_master_bus.set_mode(true);
1115         _create_master_bus.set_active(true);
1116         _create_master_bus.set_border_width(0);
1117
1118         advanced_table.set_row_spacings(0);
1119         advanced_table.set_col_spacings(0);
1120
1121         _connect_inputs.set_label (_("Automatically connect to physical inputs"));
1122         _connect_inputs.set_flags(Gtk::CAN_FOCUS);
1123         _connect_inputs.set_relief(Gtk::RELIEF_NORMAL);
1124         _connect_inputs.set_mode(true);
1125         _connect_inputs.set_active(Config->get_input_auto_connect() != ManualConnect);
1126         _connect_inputs.set_border_width(0);
1127
1128         _limit_input_ports.set_label (_("Use only"));
1129         _limit_input_ports.set_flags(Gtk::CAN_FOCUS);
1130         _limit_input_ports.set_relief(Gtk::RELIEF_NORMAL);
1131         _limit_input_ports.set_mode(true);
1132         _limit_input_ports.set_sensitive(true);
1133         _limit_input_ports.set_border_width(0);
1134
1135         _input_limit_count.set_flags(Gtk::CAN_FOCUS);
1136         _input_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1137         _input_limit_count.set_numeric(true);
1138         _input_limit_count.set_digits(0);
1139         _input_limit_count.set_wrap(false);
1140         _input_limit_count.set_sensitive(false);
1141
1142         bus_hbox.pack_start (bus_table, Gtk::PACK_SHRINK, 18);
1143
1144         bus_label.set_alignment(0, 0.5);
1145         bus_label.set_padding(0,0);
1146         bus_label.set_line_wrap(false);
1147         bus_label.set_selectable(false);
1148         bus_label.set_use_markup(true);
1149         bus_frame.set_shadow_type(Gtk::SHADOW_NONE);
1150         bus_frame.set_label_align(0,0.5);
1151         bus_frame.add(bus_hbox);
1152         bus_frame.set_label_widget(bus_label);
1153
1154         bus_table.set_row_spacings (0);
1155         bus_table.set_col_spacings (0);
1156         bus_table.attach (_create_master_bus, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1157         bus_table.attach (_master_bus_channel_count, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1158         bus_table.attach (chan_count_label_1, 2, 3, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 0);
1159
1160         input_port_limit_hbox.pack_start(_limit_input_ports, Gtk::PACK_SHRINK, 6);
1161         input_port_limit_hbox.pack_start(_input_limit_count, Gtk::PACK_SHRINK, 0);
1162         input_port_limit_hbox.pack_start(chan_count_label_3, Gtk::PACK_SHRINK, 6);
1163         input_port_vbox.pack_start(_connect_inputs, Gtk::PACK_SHRINK, 0);
1164         input_port_vbox.pack_start(input_port_limit_hbox, Gtk::PACK_EXPAND_PADDING, 0);
1165         input_table.set_row_spacings(0);
1166         input_table.set_col_spacings(0);
1167         input_table.attach(input_port_vbox, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 6);
1168
1169         input_hbox.pack_start (input_table, Gtk::PACK_SHRINK, 18);
1170
1171         input_label.set_alignment(0, 0.5);
1172         input_label.set_padding(0,0);
1173         input_label.set_line_wrap(false);
1174         input_label.set_selectable(false);
1175         input_label.set_use_markup(true);
1176         input_frame.set_shadow_type(Gtk::SHADOW_NONE);
1177         input_frame.set_label_align(0,0.5);
1178         input_frame.add(input_hbox);
1179         input_frame.set_label_widget(input_label);
1180
1181         _connect_outputs.set_label (_("Automatically connect outputs"));
1182         _connect_outputs.set_flags(Gtk::CAN_FOCUS);
1183         _connect_outputs.set_relief(Gtk::RELIEF_NORMAL);
1184         _connect_outputs.set_mode(true);
1185         _connect_outputs.set_active(Config->get_output_auto_connect() != ManualConnect);
1186         _connect_outputs.set_border_width(0);
1187         _limit_output_ports.set_label (_("Use only"));
1188         _limit_output_ports.set_flags(Gtk::CAN_FOCUS);
1189         _limit_output_ports.set_relief(Gtk::RELIEF_NORMAL);
1190         _limit_output_ports.set_mode(true);
1191         _limit_output_ports.set_sensitive(true);
1192         _limit_output_ports.set_border_width(0);
1193         _output_limit_count.set_flags(Gtk::CAN_FOCUS);
1194         _output_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1195         _output_limit_count.set_numeric(false);
1196         _output_limit_count.set_digits(0);
1197         _output_limit_count.set_wrap(false);
1198         _output_limit_count.set_sensitive(false);
1199         output_port_limit_hbox.pack_start(_limit_output_ports, Gtk::PACK_SHRINK, 6);
1200         output_port_limit_hbox.pack_start(_output_limit_count, Gtk::PACK_SHRINK, 0);
1201         output_port_limit_hbox.pack_start(chan_count_label_4, Gtk::PACK_SHRINK, 6);
1202
1203         _connect_outputs_to_master.set_label (_("... to master bus"));
1204         _connect_outputs_to_master.set_flags(Gtk::CAN_FOCUS);
1205         _connect_outputs_to_master.set_relief(Gtk::RELIEF_NORMAL);
1206         _connect_outputs_to_master.set_mode(true);
1207         _connect_outputs_to_master.set_active(Config->get_output_auto_connect() == AutoConnectMaster);
1208         _connect_outputs_to_master.set_border_width(0);
1209
1210         _connect_outputs_to_master.set_group (connect_outputs_group);
1211         _connect_outputs_to_physical.set_group (connect_outputs_group);
1212
1213         _connect_outputs_to_physical.set_label (_("... to physical outputs"));
1214         _connect_outputs_to_physical.set_flags(Gtk::CAN_FOCUS);
1215         _connect_outputs_to_physical.set_relief(Gtk::RELIEF_NORMAL);
1216         _connect_outputs_to_physical.set_mode(true);
1217         _connect_outputs_to_physical.set_active(Config->get_output_auto_connect() == AutoConnectPhysical);
1218         _connect_outputs_to_physical.set_border_width(0);
1219
1220         output_conn_vbox.pack_start(_connect_outputs, Gtk::PACK_SHRINK, 0);
1221         output_conn_vbox.pack_start(_connect_outputs_to_master, Gtk::PACK_SHRINK, 0);
1222         output_conn_vbox.pack_start(_connect_outputs_to_physical, Gtk::PACK_SHRINK, 0);
1223         output_vbox.set_border_width(6);
1224
1225         output_port_vbox.pack_start(output_port_limit_hbox, Gtk::PACK_SHRINK, 0);
1226
1227         output_vbox.pack_start(output_conn_vbox);
1228         output_vbox.pack_start(output_port_vbox);
1229
1230         output_label.set_alignment(0, 0.5);
1231         output_label.set_padding(0,0);
1232         output_label.set_line_wrap(false);
1233         output_label.set_selectable(false);
1234         output_label.set_use_markup(true);
1235         output_frame.set_shadow_type(Gtk::SHADOW_NONE);
1236         output_frame.set_label_align(0,0.5);
1237
1238         output_hbox.pack_start (output_vbox, Gtk::PACK_SHRINK, 18);
1239
1240         output_frame.add(output_hbox);
1241         output_frame.set_label_widget(output_label);
1242
1243         more_options_vbox.pack_start(advanced_table, Gtk::PACK_SHRINK, 0);
1244         more_options_vbox.pack_start(bus_frame, Gtk::PACK_SHRINK, 6);
1245         more_options_vbox.pack_start(input_frame, Gtk::PACK_SHRINK, 6);
1246         more_options_vbox.pack_start(output_frame, Gtk::PACK_SHRINK, 0);
1247
1248         /* signals */
1249
1250         _connect_inputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_inputs_clicked));
1251         _connect_outputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_outputs_clicked));
1252         _limit_input_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_inputs_clicked));
1253         _limit_output_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_outputs_clicked));
1254         _create_master_bus.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::master_bus_button_clicked));
1255
1256         /* note that more_options_vbox is "visible" by default even
1257          * though it may not be displayed to the user, this is so the dialog
1258          * doesn't resize.
1259          */
1260         more_options_vbox.show_all ();
1261
1262         session_options_page_index = append_page (more_options_vbox);
1263         set_page_title (more_options_vbox, _("Advanced Session Options"));
1264         set_page_complete (more_options_vbox, true);
1265 }
1266
1267 bool
1268 ArdourStartup::create_master_bus() const
1269 {
1270         return _create_master_bus.get_active();
1271 }
1272
1273 int
1274 ArdourStartup::master_channel_count() const
1275 {
1276         return _master_bus_channel_count.get_value_as_int();
1277 }
1278
1279 bool
1280 ArdourStartup::connect_inputs() const
1281 {
1282         return _connect_inputs.get_active();
1283 }
1284
1285 bool
1286 ArdourStartup::limit_inputs_used_for_connection() const
1287 {
1288         return _limit_input_ports.get_active();
1289 }
1290
1291 int
1292 ArdourStartup::input_limit_count() const
1293 {
1294         return _input_limit_count.get_value_as_int();
1295 }
1296
1297 bool
1298 ArdourStartup::connect_outputs() const
1299 {
1300         return _connect_outputs.get_active();
1301 }
1302
1303 bool
1304 ArdourStartup::limit_outputs_used_for_connection() const
1305 {
1306         return _limit_output_ports.get_active();
1307 }
1308
1309 int
1310 ArdourStartup::output_limit_count() const
1311 {
1312         return _output_limit_count.get_value_as_int();
1313 }
1314
1315 bool
1316 ArdourStartup::connect_outs_to_master() const
1317 {
1318         return _connect_outputs_to_master.get_active();
1319 }
1320
1321 bool
1322 ArdourStartup::connect_outs_to_physical() const
1323 {
1324         return _connect_outputs_to_physical.get_active();
1325 }
1326
1327 void
1328 ArdourStartup::connect_inputs_clicked ()
1329 {
1330         _limit_input_ports.set_sensitive(_connect_inputs.get_active());
1331
1332         if (_connect_inputs.get_active() && _limit_input_ports.get_active()) {
1333                 _input_limit_count.set_sensitive(true);
1334         } else {
1335                 _input_limit_count.set_sensitive(false);
1336         }
1337 }
1338
1339 void
1340 ArdourStartup::connect_outputs_clicked ()
1341 {
1342         bool const co = _connect_outputs.get_active ();
1343         _limit_output_ports.set_sensitive(co);
1344         _connect_outputs_to_master.set_sensitive(co);
1345         _connect_outputs_to_physical.set_sensitive(co);
1346
1347         if (co && _limit_output_ports.get_active()) {
1348                 _output_limit_count.set_sensitive(true);
1349         } else {
1350                 _output_limit_count.set_sensitive(false);
1351         }
1352 }
1353
1354 void
1355 ArdourStartup::limit_inputs_clicked ()
1356 {
1357         _input_limit_count.set_sensitive(_limit_input_ports.get_active());
1358 }
1359
1360 void
1361 ArdourStartup::limit_outputs_clicked ()
1362 {
1363         _output_limit_count.set_sensitive(_limit_output_ports.get_active());
1364 }
1365
1366 void
1367 ArdourStartup::master_bus_button_clicked ()
1368 {
1369         bool const yn = _create_master_bus.get_active();
1370
1371         _master_bus_channel_count.set_sensitive(yn);
1372         _connect_outputs_to_master.set_sensitive(yn);
1373 }
1374
1375 void
1376 ArdourStartup::move_along_now ()
1377 {
1378         gint cur = get_current_page ();
1379
1380         if (cur == session_page_index) {
1381                 if (more_new_session_options_button.get_active()) {
1382                         set_current_page (session_options_page_index);
1383                 } else {
1384                         on_apply ();
1385                 }
1386         }
1387 }
1388
1389 void
1390 ArdourStartup::recent_row_activated (const Gtk::TreePath&, Gtk::TreeViewColumn*)
1391 {
1392         set_page_complete (session_vbox, true);
1393         move_along_now ();
1394 }
1395
1396 void
1397 ArdourStartup::existing_session_selected ()
1398 {
1399         _existing_session_chooser_used = true;
1400
1401         set_page_complete (session_vbox, true);
1402         move_along_now ();
1403 }
1404
1405 std::string
1406 ArdourStartup::been_here_before_path () const
1407 {
1408         // XXXX use more specific version so we can catch upgrades
1409         return Glib::build_filename (user_config_directory (), ".a3");
1410 }