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