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