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
 962                 ++session_snapshot_count;
 963
 964                 if (state_file_names.size() > 1) {
 965
 966                         // add the children
 967
 968                         for (std::vector<std::string>::iterator i2 = state_file_names.begin();
 969                                         i2 != state_file_names.end(); ++i2) {
 970
 971                                 Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
 972
 973                                 child_row[recent_session_columns.visible_name] = *i2;
 974                                 child_row[recent_session_columns.fullpath] = fullpath;
 975                                 child_row[recent_session_columns.tip] = Glib::Markup::escape_text (fullpath);
 976                                 ++session_snapshot_count;
 977                         }
 978                 }
 979         }
 980
 981         recent_session_display.set_tooltip_column(1); // recent_session_columns.tip
 982         recent_session_display.set_model (recent_session_model);
 983         return session_snapshot_count;
 984         // return rs.size();
 985 }
 986
 987 void
 988 ArdourStartup::recent_session_row_selected ()
 989 {
 990         if (recent_session_display.get_selection()->count_selected_rows() > 0) {
 991                 set_page_complete (session_vbox, true);
 992         } else {
 993                 set_page_complete (session_vbox, false);
 994         }
 995 }
 996
 997 void
 998 ArdourStartup::setup_existing_session_page ()
 999 {
1000         recent_session_model = TreeStore::create (recent_session_columns);
1001         redisplay_recent_sessions ();
1002
1003         if (!session_hbox.get_children().empty()) {
1004                 session_hbox.remove (**session_hbox.get_children().begin());
1005         }
1006
1007         if (session_existing_vbox.get_children().empty()) {
1008
1009                 recent_session_display.set_model (recent_session_model);
1010                 recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
1011                 recent_session_display.set_headers_visible (false);
1012                 recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
1013
1014                 recent_session_display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::recent_session_row_selected));
1015
1016                 recent_scroller.add (recent_session_display);
1017                 recent_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1018                 recent_scroller.set_shadow_type (Gtk::SHADOW_IN);
1019
1020                 recent_session_display.show();
1021
1022                 recent_scroller.show();
1023                 int cnt = redisplay_recent_sessions ();
1024                 recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ArdourStartup::recent_row_activated));
1025
1026                 if (cnt > 4) {
1027                         recent_scroller.set_size_request (-1, 300);
1028                 }
1029
1030                 session_existing_vbox.set_spacing (8);
1031                 session_existing_vbox.pack_start (recent_scroller, true, true);
1032
1033                 existing_session_chooser.set_title (_("Select session file"));
1034                 existing_session_chooser.signal_file_set().connect (sigc::mem_fun (*this, &ArdourStartup::existing_session_selected));
1035                 existing_session_chooser.set_current_folder(poor_mans_glob (Config->get_default_session_parent_dir()));
1036
1037                 FileFilter session_filter;
1038                 session_filter.add_pattern ("*.ardour");
1039                 session_filter.set_name (string_compose (_("%1 sessions"), PROGRAM_NAME));
1040                 existing_session_chooser.add_filter (session_filter);
1041                 existing_session_chooser.set_filter (session_filter);
1042
1043 #ifdef GTKOSX
1044                 existing_session_chooser.add_shortcut_folder ("/Volumes");
1045 #endif
1046
1047                 HBox* hbox = manage (new HBox);
1048                 hbox->set_spacing (4);
1049                 hbox->pack_start (*manage (new Label (_("Browse:"))), PACK_SHRINK);
1050                 hbox->pack_start (existing_session_chooser);
1051                 session_existing_vbox.pack_start (*hbox, false, false);
1052                 hbox->show_all ();
1053         }
1054
1055         session_existing_vbox.show_all ();
1056         session_hbox.pack_start (session_existing_vbox, true, true);
1057
1058         set_page_title (session_vbox, _("Select a session"));
1059         set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1060 }
1061
1062 void
1063 ArdourStartup::more_new_session_options_button_clicked ()
1064 {
1065         if (more_new_session_options_button.get_active()) {
1066                 more_options_vbox.show_all ();
1067                 set_page_type (more_options_vbox, ASSISTANT_PAGE_CONFIRM);
1068                 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
1069         } else {
1070                 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1071                 more_options_vbox.hide ();
1072         }
1073 }
1074
1075 void
1076 ArdourStartup::setup_more_options_page ()
1077 {
1078         more_options_vbox.set_border_width (24);
1079
1080         _output_limit_count.set_adjustment (_output_limit_count_adj);
1081         _input_limit_count.set_adjustment (_input_limit_count_adj);
1082         _master_bus_channel_count.set_adjustment (_master_bus_channel_count_adj);
1083
1084         chan_count_label_1.set_text (_("channels"));
1085         chan_count_label_3.set_text (_("channels"));
1086         chan_count_label_4.set_text (_("channels"));
1087
1088         chan_count_label_1.set_alignment(0,0.5);
1089         chan_count_label_1.set_padding(0,0);
1090         chan_count_label_1.set_line_wrap(false);
1091
1092         chan_count_label_3.set_alignment(0,0.5);
1093         chan_count_label_3.set_padding(0,0);
1094         chan_count_label_3.set_line_wrap(false);
1095
1096         chan_count_label_4.set_alignment(0,0.5);
1097         chan_count_label_4.set_padding(0,0);
1098         chan_count_label_4.set_line_wrap(false);
1099
1100         bus_label.set_markup (_("<b>Busses</b>"));
1101         input_label.set_markup (_("<b>Inputs</b>"));
1102         output_label.set_markup (_("<b>Outputs</b>"));
1103
1104         _master_bus_channel_count.set_flags(Gtk::CAN_FOCUS);
1105         _master_bus_channel_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1106         _master_bus_channel_count.set_numeric(true);
1107         _master_bus_channel_count.set_digits(0);
1108         _master_bus_channel_count.set_wrap(false);
1109
1110         _create_master_bus.set_label (_("Create master bus"));
1111         _create_master_bus.set_flags(Gtk::CAN_FOCUS);
1112         _create_master_bus.set_relief(Gtk::RELIEF_NORMAL);
1113         _create_master_bus.set_mode(true);
1114         _create_master_bus.set_active(true);
1115         _create_master_bus.set_border_width(0);
1116
1117         advanced_table.set_row_spacings(0);
1118         advanced_table.set_col_spacings(0);
1119
1120         _connect_inputs.set_label (_("Automatically connect to physical inputs"));
1121         _connect_inputs.set_flags(Gtk::CAN_FOCUS);
1122         _connect_inputs.set_relief(Gtk::RELIEF_NORMAL);
1123         _connect_inputs.set_mode(true);
1124         _connect_inputs.set_active(Config->get_input_auto_connect() != ManualConnect);
1125         _connect_inputs.set_border_width(0);
1126
1127         _limit_input_ports.set_label (_("Use only"));
1128         _limit_input_ports.set_flags(Gtk::CAN_FOCUS);
1129         _limit_input_ports.set_relief(Gtk::RELIEF_NORMAL);
1130         _limit_input_ports.set_mode(true);
1131         _limit_input_ports.set_sensitive(true);
1132         _limit_input_ports.set_border_width(0);
1133
1134         _input_limit_count.set_flags(Gtk::CAN_FOCUS);
1135         _input_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1136         _input_limit_count.set_numeric(true);
1137         _input_limit_count.set_digits(0);
1138         _input_limit_count.set_wrap(false);
1139         _input_limit_count.set_sensitive(false);
1140
1141         bus_hbox.pack_start (bus_table, Gtk::PACK_SHRINK, 18);
1142
1143         bus_label.set_alignment(0, 0.5);
1144         bus_label.set_padding(0,0);
1145         bus_label.set_line_wrap(false);
1146         bus_label.set_selectable(false);
1147         bus_label.set_use_markup(true);
1148         bus_frame.set_shadow_type(Gtk::SHADOW_NONE);
1149         bus_frame.set_label_align(0,0.5);
1150         bus_frame.add(bus_hbox);
1151         bus_frame.set_label_widget(bus_label);
1152
1153         bus_table.set_row_spacings (0);
1154         bus_table.set_col_spacings (0);
1155         bus_table.attach (_create_master_bus, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1156         bus_table.attach (_master_bus_channel_count, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1157         bus_table.attach (chan_count_label_1, 2, 3, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 0);
1158
1159         input_port_limit_hbox.pack_start(_limit_input_ports, Gtk::PACK_SHRINK, 6);
1160         input_port_limit_hbox.pack_start(_input_limit_count, Gtk::PACK_SHRINK, 0);
1161         input_port_limit_hbox.pack_start(chan_count_label_3, Gtk::PACK_SHRINK, 6);
1162         input_port_vbox.pack_start(_connect_inputs, Gtk::PACK_SHRINK, 0);
1163         input_port_vbox.pack_start(input_port_limit_hbox, Gtk::PACK_EXPAND_PADDING, 0);
1164         input_table.set_row_spacings(0);
1165         input_table.set_col_spacings(0);
1166         input_table.attach(input_port_vbox, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 6);
1167
1168         input_hbox.pack_start (input_table, Gtk::PACK_SHRINK, 18);
1169
1170         input_label.set_alignment(0, 0.5);
1171         input_label.set_padding(0,0);
1172         input_label.set_line_wrap(false);
1173         input_label.set_selectable(false);
1174         input_label.set_use_markup(true);
1175         input_frame.set_shadow_type(Gtk::SHADOW_NONE);
1176         input_frame.set_label_align(0,0.5);
1177         input_frame.add(input_hbox);
1178         input_frame.set_label_widget(input_label);
1179
1180         _connect_outputs.set_label (_("Automatically connect outputs"));
1181         _connect_outputs.set_flags(Gtk::CAN_FOCUS);
1182         _connect_outputs.set_relief(Gtk::RELIEF_NORMAL);
1183         _connect_outputs.set_mode(true);
1184         _connect_outputs.set_active(Config->get_output_auto_connect() != ManualConnect);
1185         _connect_outputs.set_border_width(0);
1186         _limit_output_ports.set_label (_("Use only"));
1187         _limit_output_ports.set_flags(Gtk::CAN_FOCUS);
1188         _limit_output_ports.set_relief(Gtk::RELIEF_NORMAL);
1189         _limit_output_ports.set_mode(true);
1190         _limit_output_ports.set_sensitive(true);
1191         _limit_output_ports.set_border_width(0);
1192         _output_limit_count.set_flags(Gtk::CAN_FOCUS);
1193         _output_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1194         _output_limit_count.set_numeric(false);
1195         _output_limit_count.set_digits(0);
1196         _output_limit_count.set_wrap(false);
1197         _output_limit_count.set_sensitive(false);
1198         output_port_limit_hbox.pack_start(_limit_output_ports, Gtk::PACK_SHRINK, 6);
1199         output_port_limit_hbox.pack_start(_output_limit_count, Gtk::PACK_SHRINK, 0);
1200         output_port_limit_hbox.pack_start(chan_count_label_4, Gtk::PACK_SHRINK, 6);
1201
1202         _connect_outputs_to_master.set_label (_("... to master bus"));
1203         _connect_outputs_to_master.set_flags(Gtk::CAN_FOCUS);
1204         _connect_outputs_to_master.set_relief(Gtk::RELIEF_NORMAL);
1205         _connect_outputs_to_master.set_mode(true);
1206         _connect_outputs_to_master.set_active(Config->get_output_auto_connect() == AutoConnectMaster);
1207         _connect_outputs_to_master.set_border_width(0);
1208
1209         _connect_outputs_to_master.set_group (connect_outputs_group);
1210         _connect_outputs_to_physical.set_group (connect_outputs_group);
1211
1212         _connect_outputs_to_physical.set_label (_("... to physical outputs"));
1213         _connect_outputs_to_physical.set_flags(Gtk::CAN_FOCUS);
1214         _connect_outputs_to_physical.set_relief(Gtk::RELIEF_NORMAL);
1215         _connect_outputs_to_physical.set_mode(true);
1216         _connect_outputs_to_physical.set_active(Config->get_output_auto_connect() == AutoConnectPhysical);
1217         _connect_outputs_to_physical.set_border_width(0);
1218
1219         output_conn_vbox.pack_start(_connect_outputs, Gtk::PACK_SHRINK, 0);
1220         output_conn_vbox.pack_start(_connect_outputs_to_master, Gtk::PACK_SHRINK, 0);
1221         output_conn_vbox.pack_start(_connect_outputs_to_physical, Gtk::PACK_SHRINK, 0);
1222         output_vbox.set_border_width(6);
1223
1224         output_port_vbox.pack_start(output_port_limit_hbox, Gtk::PACK_SHRINK, 0);
1225
1226         output_vbox.pack_start(output_conn_vbox);
1227         output_vbox.pack_start(output_port_vbox);
1228
1229         output_label.set_alignment(0, 0.5);
1230         output_label.set_padding(0,0);
1231         output_label.set_line_wrap(false);
1232         output_label.set_selectable(false);
1233         output_label.set_use_markup(true);
1234         output_frame.set_shadow_type(Gtk::SHADOW_NONE);
1235         output_frame.set_label_align(0,0.5);
1236
1237         output_hbox.pack_start (output_vbox, Gtk::PACK_SHRINK, 18);
1238
1239         output_frame.add(output_hbox);
1240         output_frame.set_label_widget(output_label);
1241
1242         more_options_vbox.pack_start(advanced_table, Gtk::PACK_SHRINK, 0);
1243         more_options_vbox.pack_start(bus_frame, Gtk::PACK_SHRINK, 6);
1244         more_options_vbox.pack_start(input_frame, Gtk::PACK_SHRINK, 6);
1245         more_options_vbox.pack_start(output_frame, Gtk::PACK_SHRINK, 0);
1246
1247         /* signals */
1248
1249         _connect_inputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_inputs_clicked));
1250         _connect_outputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_outputs_clicked));
1251         _limit_input_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_inputs_clicked));
1252         _limit_output_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_outputs_clicked));
1253         _create_master_bus.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::master_bus_button_clicked));
1254
1255         /* note that more_options_vbox is "visible" by default even
1256          * though it may not be displayed to the user, this is so the dialog
1257          * doesn't resize.
1258          */
1259         more_options_vbox.show_all ();
1260
1261         session_options_page_index = append_page (more_options_vbox);
1262         set_page_title (more_options_vbox, _("Advanced Session Options"));
1263         set_page_complete (more_options_vbox, true);
1264 }
1265
1266 bool
1267 ArdourStartup::create_master_bus() const
1268 {
1269         return _create_master_bus.get_active();
1270 }
1271
1272 int
1273 ArdourStartup::master_channel_count() const
1274 {
1275         return _master_bus_channel_count.get_value_as_int();
1276 }
1277
1278 bool
1279 ArdourStartup::connect_inputs() const
1280 {
1281         return _connect_inputs.get_active();
1282 }
1283
1284 bool
1285 ArdourStartup::limit_inputs_used_for_connection() const
1286 {
1287         return _limit_input_ports.get_active();
1288 }
1289
1290 int
1291 ArdourStartup::input_limit_count() const
1292 {
1293         return _input_limit_count.get_value_as_int();
1294 }
1295
1296 bool
1297 ArdourStartup::connect_outputs() const
1298 {
1299         return _connect_outputs.get_active();
1300 }
1301
1302 bool
1303 ArdourStartup::limit_outputs_used_for_connection() const
1304 {
1305         return _limit_output_ports.get_active();
1306 }
1307
1308 int
1309 ArdourStartup::output_limit_count() const
1310 {
1311         return _output_limit_count.get_value_as_int();
1312 }
1313
1314 bool
1315 ArdourStartup::connect_outs_to_master() const
1316 {
1317         return _connect_outputs_to_master.get_active();
1318 }
1319
1320 bool
1321 ArdourStartup::connect_outs_to_physical() const
1322 {
1323         return _connect_outputs_to_physical.get_active();
1324 }
1325
1326 void
1327 ArdourStartup::connect_inputs_clicked ()
1328 {
1329         _limit_input_ports.set_sensitive(_connect_inputs.get_active());
1330
1331         if (_connect_inputs.get_active() && _limit_input_ports.get_active()) {
1332                 _input_limit_count.set_sensitive(true);
1333         } else {
1334                 _input_limit_count.set_sensitive(false);
1335         }
1336 }
1337
1338 void
1339 ArdourStartup::connect_outputs_clicked ()
1340 {
1341         bool const co = _connect_outputs.get_active ();
1342         _limit_output_ports.set_sensitive(co);
1343         _connect_outputs_to_master.set_sensitive(co);
1344         _connect_outputs_to_physical.set_sensitive(co);
1345
1346         if (co && _limit_output_ports.get_active()) {
1347                 _output_limit_count.set_sensitive(true);
1348         } else {
1349                 _output_limit_count.set_sensitive(false);
1350         }
1351 }
1352
1353 void
1354 ArdourStartup::limit_inputs_clicked ()
1355 {
1356         _input_limit_count.set_sensitive(_limit_input_ports.get_active());
1357 }
1358
1359 void
1360 ArdourStartup::limit_outputs_clicked ()
1361 {
1362         _output_limit_count.set_sensitive(_limit_output_ports.get_active());
1363 }
1364
1365 void
1366 ArdourStartup::master_bus_button_clicked ()
1367 {
1368         bool const yn = _create_master_bus.get_active();
1369
1370         _master_bus_channel_count.set_sensitive(yn);
1371         _connect_outputs_to_master.set_sensitive(yn);
1372 }
1373
1374 void
1375 ArdourStartup::move_along_now ()
1376 {
1377         gint cur = get_current_page ();
1378
1379         if (cur == session_page_index) {
1380                 if (more_new_session_options_button.get_active()) {
1381                         set_current_page (session_options_page_index);
1382                 } else {
1383                         on_apply ();
1384                 }
1385         }
1386 }
1387
1388 void
1389 ArdourStartup::recent_row_activated (const Gtk::TreePath&, Gtk::TreeViewColumn*)
1390 {
1391         set_page_complete (session_vbox, true);
1392         move_along_now ();
1393 }
1394
1395 void
1396 ArdourStartup::existing_session_selected ()
1397 {
1398         _existing_session_chooser_used = true;
1399
1400         set_page_complete (session_vbox, true);
1401         move_along_now ();
1402 }
1403
1404 std::string
1405 ArdourStartup::been_here_before_path () const
1406 {
1407         // XXXX use more specific version so we can catch upgrades
1408         return Glib::build_filename (user_config_directory (), ".a3");
1409 }