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                 if (engine_dialog->setup_engine ()) {
 627                         set_current_page (audio_page_index);
 628                         return;
 629                 }
 630         }
 631
 632         if (config_modified) {
 633
 634                 if (default_dir_chooser) {
 635                         Config->set_default_session_parent_dir (default_dir_chooser->get_filename());
 636                 }
 637
 638                 if (monitor_via_hardware_button.get_active()) {
 639                         Config->set_monitoring_model (ExternalMonitoring);
 640                 } else if (monitor_via_ardour_button.get_active()) {
 641                         Config->set_monitoring_model (SoftwareMonitoring);
 642                 }
 643
 644                 Config->set_use_monitor_bus (use_monitor_section_button.get_active());
 645
 646                 /* "touch" the been-here-before path now that we're about to save Config */
 647                 ofstream fout (been_here_before_path().c_str());
 648
 649                 Config->save_state ();
 650         }
 651
 652         _response = RESPONSE_OK;
 653         gtk_main_quit ();
 654 }
 655
 656 void
 657 ArdourStartup::on_prepare (Gtk::Widget* page)
 658 {
 659         if (page == &session_vbox) {
 660
 661                 if (ic_new_session_button.get_active()) {
 662                         /* new session requested */
 663                         setup_new_session_page ();
 664                 } else {
 665                         /* existing session requested */
 666                         setup_existing_session_page ();
 667
 668                 }
 669
 670                 /* HACK HACK HACK ... change the "Apply" button label
 671                    to say "Open"
 672                 */
 673
 674                 Gtk::Widget* tl = session_vbox.get_toplevel();
 675                 Gtk::Window* win;
 676                 if ((win = dynamic_cast<Gtk::Window*>(tl)) != 0) {
 677                         /* ::get_default_widget() is not wrapped in gtkmm */
 678                         Gtk::Widget* def = wrap (gtk_window_get_default_widget (win->gobj()));
 679                         Gtk::Button* button;
 680                         if ((button = dynamic_cast<Gtk::Button*>(def)) != 0) {
 681                                 if (more_new_session_options_button.get_active()) {
 682                                         button->set_label (_("Forward"));
 683                                 }else{
 684                                         button->set_label (_("Open"));
 685                                 }
 686                         }
 687                 }
 688         }
 689 }
 690
 691 void
 692 ArdourStartup::populate_session_templates ()
 693 {
 694         vector<TemplateInfo> templates;
 695
 696         find_session_templates (templates);
 697
 698         template_model->clear ();
 699
 700         for (vector<TemplateInfo>::iterator x = templates.begin(); x != templates.end(); ++x) {
 701                 TreeModel::Row row;
 702
 703                 row = *(template_model->append ());
 704
 705                 row[session_template_columns.name] = (*x).name;
 706                 row[session_template_columns.path] = (*x).path;
 707         }
 708 }
 709
 710 static bool
 711 lost_name_entry_focus (GdkEventFocus*)
 712 {
 713         // cerr << "lost focus\n";
 714         return false;
 715 }
 716
 717 void
 718 ArdourStartup::setup_new_session_page ()
 719 {
 720         if (!session_hbox.get_children().empty()) {
 721                 session_hbox.remove (**session_hbox.get_children().begin());
 722         }
 723
 724         session_new_vbox.set_spacing (18);
 725
 726         if (session_new_vbox.get_children().empty()) {
 727                 VBox *vbox1 = manage (new VBox);
 728                 HBox* hbox1 = manage (new HBox);
 729                 Label* label1 = manage (new Label);
 730
 731                 vbox1->set_spacing (6);
 732
 733                 hbox1->set_spacing (6);
 734                 hbox1->pack_start (*label1, false, false);
 735                 hbox1->pack_start (new_name_entry, true, true);
 736
 737                 label1->set_text (_("Session name:"));
 738
 739
 740                 if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
 741                         new_name_entry.set_text  (Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name));
 742                         /* name provided - they can move right along */
 743                         set_page_complete (session_vbox, true);
 744                 }
 745
 746                 new_name_entry.signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::new_name_changed));
 747                 new_name_entry.signal_activate().connect (sigc::mem_fun (*this, &ArdourStartup::move_along_now));
 748
 749                 vbox1->pack_start (*hbox1, true, true);
 750
 751                 /* --- */
 752
 753                 HBox* hbox2 = manage (new HBox);
 754                 Label* label2 = manage (new Label);
 755
 756                 hbox2->set_spacing (6);
 757                 hbox2->pack_start (*label2, false, false);
 758                 hbox2->pack_start (new_folder_chooser, true, true);
 759
 760                 label2->set_text (_("Create session folder in:"));
 761
 762                 if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
 763                         new_folder_chooser.set_current_folder (poor_mans_glob (Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name)));
 764                 } else if (ARDOUR_UI::instance()->session_loaded) {
 765                         // point the new session file chooser at the parent directory of the current session
 766                         string session_parent_dir = Glib::path_get_dirname(ARDOUR_UI::instance()->the_session()->path());
 767                         string::size_type last_dir_sep = session_parent_dir.rfind(G_DIR_SEPARATOR);
 768                         session_parent_dir = session_parent_dir.substr(0, last_dir_sep);
 769                         new_folder_chooser.set_current_folder (session_parent_dir);
 770                         new_folder_chooser.add_shortcut_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
 771                 } else {
 772                         new_folder_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
 773                 }
 774                 new_folder_chooser.set_title (_("Select folder for session"));
 775
 776 #ifdef GTKOSX
 777                 new_folder_chooser.add_shortcut_folder ("/Volumes");
 778 #endif
 779
 780                 vbox1->pack_start (*hbox2, false, false);
 781
 782                 session_new_vbox.pack_start (*vbox1, false, false);
 783
 784                 /* --- */
 785
 786                 VBox *vbox2 = manage (new VBox);
 787                 HBox* hbox3 = manage (new HBox);
 788                 Label* label3 = manage (new Label);
 789                 template_model = ListStore::create (session_template_columns);
 790                 populate_session_templates ();
 791
 792                 vbox2->set_spacing (6);
 793
 794                 label3->set_markup (_("<b>Options</b>"));
 795                 label3->set_alignment (0.0, 0.0);
 796
 797                 vbox2->pack_start (*label3, false, true);
 798
 799                 VBox *vbox3 = manage (new VBox);
 800
 801                 vbox3->set_spacing (6);
 802
 803                 if (!template_model->children().empty()) {
 804
 805                         HBox* hbox4a = manage (new HBox);
 806                         use_template_button.set_label (_("Use this template"));
 807
 808                         TreeModel::Row row = *template_model->prepend ();
 809                         row[session_template_columns.name] = (_("no template"));
 810                         row[session_template_columns.path] = string();
 811
 812                         hbox4a->set_spacing (6);
 813                         hbox4a->pack_start (use_template_button, false, false);
 814                         hbox4a->pack_start (template_chooser, true, true);
 815
 816                         template_chooser.set_model (template_model);
 817
 818                         Gtk::CellRendererText* text_renderer = Gtk::manage (new Gtk::CellRendererText);
 819                         text_renderer->property_editable() = false;
 820
 821                         template_chooser.pack_start (*text_renderer);
 822                         template_chooser.add_attribute (text_renderer->property_text(), session_template_columns.name);
 823                         template_chooser.set_active (0);
 824
 825                         use_template_button.show();
 826                         template_chooser.show ();
 827
 828                         vbox3->pack_start (*hbox4a, false, false);
 829                 }
 830
 831                 /* --- */
 832
 833                 if (!new_user) {
 834                         session_template_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
 835
 836                         HBox* hbox4b = manage (new HBox);
 837                         use_session_as_template_button.set_label (_("Use an existing session as a template:"));
 838
 839                         hbox4b->set_spacing (6);
 840                         hbox4b->pack_start (use_session_as_template_button, false, false);
 841                         hbox4b->pack_start (session_template_chooser, true, true);
 842
 843                         use_session_as_template_button.show ();
 844                         session_template_chooser.show ();
 845
 846                         Gtk::FileFilter* session_filter = manage (new (Gtk::FileFilter));
 847                         session_filter->add_pattern (X_("*.ardour"));
 848                         session_template_chooser.set_filter (*session_filter);
 849                         session_template_chooser.set_title (_("Select template"));
 850
 851                         vbox3->pack_start (*hbox4b, false, false);
 852                 }
 853
 854                 /* --- */
 855
 856                 HBox* hbox5 = manage (new HBox);
 857
 858                 hbox5->set_spacing (6);
 859                 hbox5->pack_start (more_new_session_options_button, false, false);
 860
 861                 more_new_session_options_button.show ();
 862                 more_new_session_options_button.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::more_new_session_options_button_clicked));
 863
 864                 vbox3->pack_start (*hbox5, false, false);
 865                 hbox3->pack_start (*vbox3, true, true, 8);
 866                 vbox2->pack_start (*hbox3, false, false);
 867
 868                 /* --- */
 869
 870                 session_new_vbox.pack_start (*vbox2, false, false);
 871         }
 872
 873         session_new_vbox.show_all ();
 874         session_hbox.pack_start (session_new_vbox, true, true);
 875         set_page_title (session_vbox, _("New Session"));
 876         set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
 877
 878         if (more_new_session_options_button.get_active()) {
 879                 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
 880         }
 881
 882         new_name_entry.signal_map().connect (sigc::mem_fun (*this, &ArdourStartup::new_name_mapped));
 883         new_name_entry.signal_focus_out_event().connect (sigc::ptr_fun (lost_name_entry_focus));
 884 }
 885
 886 void
 887 ArdourStartup::new_name_mapped ()
 888 {
 889         // cerr << "Grab new name focus\n";
 890         new_name_entry.grab_focus ();
 891 }
 892
 893 void
 894 ArdourStartup::new_name_changed ()
 895 {
 896         if (!new_name_entry.get_text().empty()) {
 897                 set_page_complete (session_vbox, true);
 898         } else {
 899                 set_page_complete (session_vbox, false);
 900         }
 901 }
 902
 903 int
 904 ArdourStartup::redisplay_recent_sessions ()
 905 {
 906         std::vector<std::string> session_directories;
 907         RecentSessionsSorter cmp;
 908
 909         recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
 910         recent_session_model->clear ();
 911
 912         ARDOUR::RecentSessions rs;
 913         ARDOUR::read_recent_sessions (rs);
 914
 915         if (rs.empty()) {
 916                 recent_session_display.set_model (recent_session_model);
 917                 return 0;
 918         }
 919         //
 920         // sort them alphabetically
 921         sort (rs.begin(), rs.end(), cmp);
 922
 923         for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
 924                 session_directories.push_back ((*i).second);
 925         }
 926
 927         for (vector<std::string>::const_iterator i = session_directories.begin(); i != session_directories.end(); ++i)
 928         {
 929                 std::vector<std::string> state_file_paths;
 930
 931                 // now get available states for this session
 932
 933                 get_state_files_in_directory (*i, state_file_paths);
 934
 935                 vector<string*>* states;
 936                 vector<const gchar*> item;
 937                 string fullpath = *i;
 938
 939                 /* remove any trailing / */
 940
 941                 if (fullpath[fullpath.length()-1] == '/') {
 942                         fullpath = fullpath.substr (0, fullpath.length()-1);
 943                 }
 944
 945                 /* check whether session still exists */
 946                 if (!Glib::file_test(fullpath.c_str(), Glib::FILE_TEST_EXISTS)) {
 947                         /* session doesn't exist */
 948                         continue;
 949                 }
 950
 951                 /* now get available states for this session */
 952
 953                 if ((states = Session::possible_states (fullpath)) == 0) {
 954                         /* no state file? */
 955                         continue;
 956                 }
 957
 958                 std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
 959
 960                 Gtk::TreeModel::Row row = *(recent_session_model->append());
 961
 962                 row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
 963                 row[recent_session_columns.fullpath] = fullpath;
 964
 965                 if (state_file_names.size() > 1) {
 966
 967                         // add the children
 968
 969                         for (std::vector<std::string>::iterator i2 = state_file_names.begin();
 970                                         i2 != state_file_names.end(); ++i2)
 971                         {
 972
 973                                 Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
 974
 975                                 child_row[recent_session_columns.visible_name] = *i2;
 976                                 child_row[recent_session_columns.fullpath] = fullpath;
 977                         }
 978                 }
 979         }
 980
 981         recent_session_display.set_tooltip_column(1); // recent_session_columns.fullpath
 982         recent_session_display.set_model (recent_session_model);
 983         return rs.size();
 984 }
 985
 986 void
 987 ArdourStartup::recent_session_row_selected ()
 988 {
 989         if (recent_session_display.get_selection()->count_selected_rows() > 0) {
 990                 set_page_complete (session_vbox, true);
 991         } else {
 992                 set_page_complete (session_vbox, false);
 993         }
 994 }
 995
 996 void
 997 ArdourStartup::setup_existing_session_page ()
 998 {
 999         recent_session_model = TreeStore::create (recent_session_columns);
1000         redisplay_recent_sessions ();
1001
1002         if (!session_hbox.get_children().empty()) {
1003                 session_hbox.remove (**session_hbox.get_children().begin());
1004         }
1005
1006         if (session_existing_vbox.get_children().empty()) {
1007
1008                 recent_session_display.set_model (recent_session_model);
1009                 recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
1010                 recent_session_display.set_headers_visible (false);
1011                 recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
1012
1013                 recent_session_display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::recent_session_row_selected));
1014
1015                 recent_scroller.add (recent_session_display);
1016                 recent_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1017                 recent_scroller.set_shadow_type (Gtk::SHADOW_IN);
1018
1019                 recent_session_display.show();
1020
1021                 recent_scroller.show();
1022                 int cnt = redisplay_recent_sessions ();
1023                 recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ArdourStartup::recent_row_activated));
1024
1025                 if (cnt > 4) {
1026                         recent_scroller.set_size_request (-1, 300);
1027                 }
1028
1029                 session_existing_vbox.set_spacing (8);
1030                 session_existing_vbox.pack_start (recent_scroller, true, true);
1031
1032                 existing_session_chooser.set_title (_("Select session file"));
1033                 existing_session_chooser.signal_file_set().connect (sigc::mem_fun (*this, &ArdourStartup::existing_session_selected));
1034                 existing_session_chooser.set_current_folder(poor_mans_glob (Config->get_default_session_parent_dir()));
1035
1036                 FileFilter session_filter;
1037                 session_filter.add_pattern ("*.ardour");
1038                 session_filter.set_name (string_compose (_("%1 sessions"), PROGRAM_NAME));
1039                 existing_session_chooser.add_filter (session_filter);
1040                 existing_session_chooser.set_filter (session_filter);
1041
1042 #ifdef GTKOSX
1043                 existing_session_chooser.add_shortcut_folder ("/Volumes");
1044 #endif
1045
1046                 HBox* hbox = manage (new HBox);
1047                 hbox->set_spacing (4);
1048                 hbox->pack_start (*manage (new Label (_("Browse:"))), PACK_SHRINK);
1049                 hbox->pack_start (existing_session_chooser);
1050                 session_existing_vbox.pack_start (*hbox, false, false);
1051                 hbox->show_all ();
1052         }
1053
1054         session_existing_vbox.show_all ();
1055         session_hbox.pack_start (session_existing_vbox, true, true);
1056
1057         set_page_title (session_vbox, _("Select a session"));
1058         set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1059 }
1060
1061 void
1062 ArdourStartup::more_new_session_options_button_clicked ()
1063 {
1064         if (more_new_session_options_button.get_active()) {
1065                 more_options_vbox.show_all ();
1066                 set_page_type (more_options_vbox, ASSISTANT_PAGE_CONFIRM);
1067                 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
1068         } else {
1069                 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
1070                 more_options_vbox.hide ();
1071         }
1072 }
1073
1074 void
1075 ArdourStartup::setup_more_options_page ()
1076 {
1077         more_options_vbox.set_border_width (24);
1078
1079         _output_limit_count.set_adjustment (_output_limit_count_adj);
1080         _input_limit_count.set_adjustment (_input_limit_count_adj);
1081         _master_bus_channel_count.set_adjustment (_master_bus_channel_count_adj);
1082
1083         chan_count_label_1.set_text (_("channels"));
1084         chan_count_label_3.set_text (_("channels"));
1085         chan_count_label_4.set_text (_("channels"));
1086
1087         chan_count_label_1.set_alignment(0,0.5);
1088         chan_count_label_1.set_padding(0,0);
1089         chan_count_label_1.set_line_wrap(false);
1090
1091         chan_count_label_3.set_alignment(0,0.5);
1092         chan_count_label_3.set_padding(0,0);
1093         chan_count_label_3.set_line_wrap(false);
1094
1095         chan_count_label_4.set_alignment(0,0.5);
1096         chan_count_label_4.set_padding(0,0);
1097         chan_count_label_4.set_line_wrap(false);
1098
1099         bus_label.set_markup (_("<b>Busses</b>"));
1100         input_label.set_markup (_("<b>Inputs</b>"));
1101         output_label.set_markup (_("<b>Outputs</b>"));
1102
1103         _master_bus_channel_count.set_flags(Gtk::CAN_FOCUS);
1104         _master_bus_channel_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1105         _master_bus_channel_count.set_numeric(true);
1106         _master_bus_channel_count.set_digits(0);
1107         _master_bus_channel_count.set_wrap(false);
1108
1109         _create_master_bus.set_label (_("Create master bus"));
1110         _create_master_bus.set_flags(Gtk::CAN_FOCUS);
1111         _create_master_bus.set_relief(Gtk::RELIEF_NORMAL);
1112         _create_master_bus.set_mode(true);
1113         _create_master_bus.set_active(true);
1114         _create_master_bus.set_border_width(0);
1115
1116         advanced_table.set_row_spacings(0);
1117         advanced_table.set_col_spacings(0);
1118
1119         _connect_inputs.set_label (_("Automatically connect to physical_inputs"));
1120         _connect_inputs.set_flags(Gtk::CAN_FOCUS);
1121         _connect_inputs.set_relief(Gtk::RELIEF_NORMAL);
1122         _connect_inputs.set_mode(true);
1123         _connect_inputs.set_active(Config->get_input_auto_connect() != ManualConnect);
1124         _connect_inputs.set_border_width(0);
1125
1126         _limit_input_ports.set_label (_("Use only"));
1127         _limit_input_ports.set_flags(Gtk::CAN_FOCUS);
1128         _limit_input_ports.set_relief(Gtk::RELIEF_NORMAL);
1129         _limit_input_ports.set_mode(true);
1130         _limit_input_ports.set_sensitive(true);
1131         _limit_input_ports.set_border_width(0);
1132
1133         _input_limit_count.set_flags(Gtk::CAN_FOCUS);
1134         _input_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1135         _input_limit_count.set_numeric(true);
1136         _input_limit_count.set_digits(0);
1137         _input_limit_count.set_wrap(false);
1138         _input_limit_count.set_sensitive(false);
1139
1140         bus_hbox.pack_start (bus_table, Gtk::PACK_SHRINK, 18);
1141
1142         bus_label.set_alignment(0, 0.5);
1143         bus_label.set_padding(0,0);
1144         bus_label.set_line_wrap(false);
1145         bus_label.set_selectable(false);
1146         bus_label.set_use_markup(true);
1147         bus_frame.set_shadow_type(Gtk::SHADOW_NONE);
1148         bus_frame.set_label_align(0,0.5);
1149         bus_frame.add(bus_hbox);
1150         bus_frame.set_label_widget(bus_label);
1151
1152         bus_table.set_row_spacings (0);
1153         bus_table.set_col_spacings (0);
1154         bus_table.attach (_create_master_bus, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1155         bus_table.attach (_master_bus_channel_count, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1156         bus_table.attach (chan_count_label_1, 2, 3, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 0);
1157
1158         input_port_limit_hbox.pack_start(_limit_input_ports, Gtk::PACK_SHRINK, 6);
1159         input_port_limit_hbox.pack_start(_input_limit_count, Gtk::PACK_SHRINK, 0);
1160         input_port_limit_hbox.pack_start(chan_count_label_3, Gtk::PACK_SHRINK, 6);
1161         input_port_vbox.pack_start(_connect_inputs, Gtk::PACK_SHRINK, 0);
1162         input_port_vbox.pack_start(input_port_limit_hbox, Gtk::PACK_EXPAND_PADDING, 0);
1163         input_table.set_row_spacings(0);
1164         input_table.set_col_spacings(0);
1165         input_table.attach(input_port_vbox, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 6);
1166
1167         input_hbox.pack_start (input_table, Gtk::PACK_SHRINK, 18);
1168
1169         input_label.set_alignment(0, 0.5);
1170         input_label.set_padding(0,0);
1171         input_label.set_line_wrap(false);
1172         input_label.set_selectable(false);
1173         input_label.set_use_markup(true);
1174         input_frame.set_shadow_type(Gtk::SHADOW_NONE);
1175         input_frame.set_label_align(0,0.5);
1176         input_frame.add(input_hbox);
1177         input_frame.set_label_widget(input_label);
1178
1179         _connect_outputs.set_label (_("Automatically connect outputs"));
1180         _connect_outputs.set_flags(Gtk::CAN_FOCUS);
1181         _connect_outputs.set_relief(Gtk::RELIEF_NORMAL);
1182         _connect_outputs.set_mode(true);
1183         _connect_outputs.set_active(Config->get_output_auto_connect() != ManualConnect);
1184         _connect_outputs.set_border_width(0);
1185         _limit_output_ports.set_label (_("Use only"));
1186         _limit_output_ports.set_flags(Gtk::CAN_FOCUS);
1187         _limit_output_ports.set_relief(Gtk::RELIEF_NORMAL);
1188         _limit_output_ports.set_mode(true);
1189         _limit_output_ports.set_sensitive(true);
1190         _limit_output_ports.set_border_width(0);
1191         _output_limit_count.set_flags(Gtk::CAN_FOCUS);
1192         _output_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1193         _output_limit_count.set_numeric(false);
1194         _output_limit_count.set_digits(0);
1195         _output_limit_count.set_wrap(false);
1196         _output_limit_count.set_sensitive(false);
1197         output_port_limit_hbox.pack_start(_limit_output_ports, Gtk::PACK_SHRINK, 6);
1198         output_port_limit_hbox.pack_start(_output_limit_count, Gtk::PACK_SHRINK, 0);
1199         output_port_limit_hbox.pack_start(chan_count_label_4, Gtk::PACK_SHRINK, 6);
1200
1201         _connect_outputs_to_master.set_label (_("... to master bus"));
1202         _connect_outputs_to_master.set_flags(Gtk::CAN_FOCUS);
1203         _connect_outputs_to_master.set_relief(Gtk::RELIEF_NORMAL);
1204         _connect_outputs_to_master.set_mode(true);
1205         _connect_outputs_to_master.set_active(Config->get_output_auto_connect() == AutoConnectMaster);
1206         _connect_outputs_to_master.set_border_width(0);
1207
1208         _connect_outputs_to_master.set_group (connect_outputs_group);
1209         _connect_outputs_to_physical.set_group (connect_outputs_group);
1210
1211         _connect_outputs_to_physical.set_label (_("... to physical outputs"));
1212         _connect_outputs_to_physical.set_flags(Gtk::CAN_FOCUS);
1213         _connect_outputs_to_physical.set_relief(Gtk::RELIEF_NORMAL);
1214         _connect_outputs_to_physical.set_mode(true);
1215         _connect_outputs_to_physical.set_active(Config->get_output_auto_connect() == AutoConnectPhysical);
1216         _connect_outputs_to_physical.set_border_width(0);
1217
1218         output_conn_vbox.pack_start(_connect_outputs, Gtk::PACK_SHRINK, 0);
1219         output_conn_vbox.pack_start(_connect_outputs_to_master, Gtk::PACK_SHRINK, 0);
1220         output_conn_vbox.pack_start(_connect_outputs_to_physical, Gtk::PACK_SHRINK, 0);
1221         output_vbox.set_border_width(6);
1222
1223         output_port_vbox.pack_start(output_port_limit_hbox, Gtk::PACK_SHRINK, 0);
1224
1225         output_vbox.pack_start(output_conn_vbox);
1226         output_vbox.pack_start(output_port_vbox);
1227
1228         output_label.set_alignment(0, 0.5);
1229         output_label.set_padding(0,0);
1230         output_label.set_line_wrap(false);
1231         output_label.set_selectable(false);
1232         output_label.set_use_markup(true);
1233         output_frame.set_shadow_type(Gtk::SHADOW_NONE);
1234         output_frame.set_label_align(0,0.5);
1235
1236         output_hbox.pack_start (output_vbox, Gtk::PACK_SHRINK, 18);
1237
1238         output_frame.add(output_hbox);
1239         output_frame.set_label_widget(output_label);
1240
1241         more_options_vbox.pack_start(advanced_table, Gtk::PACK_SHRINK, 0);
1242         more_options_vbox.pack_start(bus_frame, Gtk::PACK_SHRINK, 6);
1243         more_options_vbox.pack_start(input_frame, Gtk::PACK_SHRINK, 6);
1244         more_options_vbox.pack_start(output_frame, Gtk::PACK_SHRINK, 0);
1245
1246         /* signals */
1247
1248         _connect_inputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_inputs_clicked));
1249         _connect_outputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_outputs_clicked));
1250         _limit_input_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_inputs_clicked));
1251         _limit_output_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_outputs_clicked));
1252         _create_master_bus.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::master_bus_button_clicked));
1253
1254         /* note that more_options_vbox is NOT visible by
1255          * default. this is entirely by design - this page
1256          * should be skipped unless explicitly requested.
1257          */
1258
1259         session_options_page_index = append_page (more_options_vbox);
1260         set_page_title (more_options_vbox, _("Advanced Session Options"));
1261         set_page_complete (more_options_vbox, true);
1262 }
1263
1264 bool
1265 ArdourStartup::create_master_bus() const
1266 {
1267         return _create_master_bus.get_active();
1268 }
1269
1270 int
1271 ArdourStartup::master_channel_count() const
1272 {
1273         return _master_bus_channel_count.get_value_as_int();
1274 }
1275
1276 bool
1277 ArdourStartup::connect_inputs() const
1278 {
1279         return _connect_inputs.get_active();
1280 }
1281
1282 bool
1283 ArdourStartup::limit_inputs_used_for_connection() const
1284 {
1285         return _limit_input_ports.get_active();
1286 }
1287
1288 int
1289 ArdourStartup::input_limit_count() const
1290 {
1291         return _input_limit_count.get_value_as_int();
1292 }
1293
1294 bool
1295 ArdourStartup::connect_outputs() const
1296 {
1297         return _connect_outputs.get_active();
1298 }
1299
1300 bool
1301 ArdourStartup::limit_outputs_used_for_connection() const
1302 {
1303         return _limit_output_ports.get_active();
1304 }
1305
1306 int
1307 ArdourStartup::output_limit_count() const
1308 {
1309         return _output_limit_count.get_value_as_int();
1310 }
1311
1312 bool
1313 ArdourStartup::connect_outs_to_master() const
1314 {
1315         return _connect_outputs_to_master.get_active();
1316 }
1317
1318 bool
1319 ArdourStartup::connect_outs_to_physical() const
1320 {
1321         return _connect_outputs_to_physical.get_active();
1322 }
1323
1324 void
1325 ArdourStartup::connect_inputs_clicked ()
1326 {
1327         _limit_input_ports.set_sensitive(_connect_inputs.get_active());
1328
1329         if (_connect_inputs.get_active() && _limit_input_ports.get_active()) {
1330                 _input_limit_count.set_sensitive(true);
1331         } else {
1332                 _input_limit_count.set_sensitive(false);
1333         }
1334 }
1335
1336 void
1337 ArdourStartup::connect_outputs_clicked ()
1338 {
1339         _limit_output_ports.set_sensitive(_connect_outputs.get_active());
1340
1341         if (_connect_outputs.get_active() && _limit_output_ports.get_active()) {
1342                 _output_limit_count.set_sensitive(true);
1343         } else {
1344                 _output_limit_count.set_sensitive(false);
1345         }
1346 }
1347
1348 void
1349 ArdourStartup::limit_inputs_clicked ()
1350 {
1351         _input_limit_count.set_sensitive(_limit_input_ports.get_active());
1352 }
1353
1354 void
1355 ArdourStartup::limit_outputs_clicked ()
1356 {
1357         _output_limit_count.set_sensitive(_limit_output_ports.get_active());
1358 }
1359
1360 void
1361 ArdourStartup::master_bus_button_clicked ()
1362 {
1363         bool yn = _create_master_bus.get_active();
1364
1365         _master_bus_channel_count.set_sensitive(yn);
1366 }
1367
1368 void
1369 ArdourStartup::move_along_now ()
1370 {
1371         gint cur = get_current_page ();
1372
1373         if (cur == session_page_index) {
1374                 if (more_new_session_options_button.get_active()) {
1375                         set_current_page (session_options_page_index);
1376                 } else {
1377                         on_apply ();
1378                 }
1379         }
1380 }
1381
1382 void
1383 ArdourStartup::recent_row_activated (const Gtk::TreePath&, Gtk::TreeViewColumn*)
1384 {
1385         set_page_complete (session_vbox, true);
1386         move_along_now ();
1387 }
1388
1389 void
1390 ArdourStartup::existing_session_selected ()
1391 {
1392         _existing_session_chooser_used = true;
1393
1394         set_page_complete (session_vbox, true);
1395         move_along_now ();
1396 }
1397
1398 std::string
1399 ArdourStartup::been_here_before_path () const
1400 {
1401         // XXXX use more specific version so we can catch upgrades
1402         return Glib::build_filename (user_config_directory (), ".a3");
1403 }