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