gtk2_ardour/startup.cc

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