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