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