gtk2_ardour/startup.cc

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