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