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