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 ("/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 #ifdef GTKOSX
 938         existing_session_chooser->add_shortcut_folder ("/Volumes");
 939 #endif
 940
 941         HBox* hbox = manage (new HBox);
 942         hbox->set_spacing (4);
 943         hbox->pack_start (*manage (new Label (_("Browse:"))), PACK_SHRINK);
 944         hbox->pack_start (existing_session_chooser);
 945         vbox->pack_start (*hbox);
 946         hbox->show_all ();
 947
 948         vbox->show_all ();
 949         session_hbox.pack_start (*vbox, true, true);
 950
 951         set_page_title (session_vbox, _("Select a session"));
 952         set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
 953
 954         _have_setup_existing_session_page = true;
 955 }
 956
 957 void
 958 ArdourStartup::more_new_session_options_button_clicked ()
 959 {
 960         if (more_new_session_options_button.get_active()) {
 961                 more_options_vbox.show_all ();
 962                 set_page_type (more_options_vbox, ASSISTANT_PAGE_CONFIRM);
 963                 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
 964         } else {
 965                 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
 966                 more_options_vbox.hide ();
 967         }
 968 }
 969
 970 void
 971 ArdourStartup::setup_more_options_page ()
 972 {
 973         more_options_vbox.set_border_width (24);
 974
 975         _output_limit_count.set_adjustment (_output_limit_count_adj);
 976         _input_limit_count.set_adjustment (_input_limit_count_adj);
 977         _master_bus_channel_count.set_adjustment (_master_bus_channel_count_adj);
 978
 979         chan_count_label_1.set_text (_("channels"));
 980         chan_count_label_3.set_text (_("channels"));
 981         chan_count_label_4.set_text (_("channels"));
 982
 983         chan_count_label_1.set_alignment(0,0.5);
 984         chan_count_label_1.set_padding(0,0);
 985         chan_count_label_1.set_line_wrap(false);
 986
 987         chan_count_label_3.set_alignment(0,0.5);
 988         chan_count_label_3.set_padding(0,0);
 989         chan_count_label_3.set_line_wrap(false);
 990
 991         chan_count_label_4.set_alignment(0,0.5);
 992         chan_count_label_4.set_padding(0,0);
 993         chan_count_label_4.set_line_wrap(false);
 994
 995         bus_label.set_markup (_("<b>Busses</b>"));
 996         input_label.set_markup (_("<b>Inputs</b>"));
 997         output_label.set_markup (_("<b>Outputs</b>"));
 998
 999         _master_bus_channel_count.set_flags(Gtk::CAN_FOCUS);
1000         _master_bus_channel_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1001         _master_bus_channel_count.set_numeric(true);
1002         _master_bus_channel_count.set_digits(0);
1003         _master_bus_channel_count.set_wrap(false);
1004
1005         _create_master_bus.set_label (_("Create master bus"));
1006         _create_master_bus.set_flags(Gtk::CAN_FOCUS);
1007         _create_master_bus.set_relief(Gtk::RELIEF_NORMAL);
1008         _create_master_bus.set_mode(true);
1009         _create_master_bus.set_active(true);
1010         _create_master_bus.set_border_width(0);
1011
1012         advanced_table.set_row_spacings(0);
1013         advanced_table.set_col_spacings(0);
1014
1015         _connect_inputs.set_label (_("Automatically connect to physical_inputs"));
1016         _connect_inputs.set_flags(Gtk::CAN_FOCUS);
1017         _connect_inputs.set_relief(Gtk::RELIEF_NORMAL);
1018         _connect_inputs.set_mode(true);
1019         _connect_inputs.set_active(true);
1020         _connect_inputs.set_border_width(0);
1021
1022         _limit_input_ports.set_label (_("Use only"));
1023         _limit_input_ports.set_flags(Gtk::CAN_FOCUS);
1024         _limit_input_ports.set_relief(Gtk::RELIEF_NORMAL);
1025         _limit_input_ports.set_mode(true);
1026         _limit_input_ports.set_sensitive(true);
1027         _limit_input_ports.set_border_width(0);
1028
1029         _input_limit_count.set_flags(Gtk::CAN_FOCUS);
1030         _input_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1031         _input_limit_count.set_numeric(true);
1032         _input_limit_count.set_digits(0);
1033         _input_limit_count.set_wrap(false);
1034         _input_limit_count.set_sensitive(false);
1035
1036         bus_hbox.pack_start (bus_table, Gtk::PACK_SHRINK, 18);
1037
1038         bus_label.set_alignment(0, 0.5);
1039         bus_label.set_padding(0,0);
1040         bus_label.set_line_wrap(false);
1041         bus_label.set_selectable(false);
1042         bus_label.set_use_markup(true);
1043         bus_frame.set_shadow_type(Gtk::SHADOW_NONE);
1044         bus_frame.set_label_align(0,0.5);
1045         bus_frame.add(bus_hbox);
1046         bus_frame.set_label_widget(bus_label);
1047
1048         bus_table.set_row_spacings (0);
1049         bus_table.set_col_spacings (0);
1050         bus_table.attach (_create_master_bus, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1051         bus_table.attach (_master_bus_channel_count, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1052         bus_table.attach (chan_count_label_1, 2, 3, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 0);
1053
1054         input_port_limit_hbox.pack_start(_limit_input_ports, Gtk::PACK_SHRINK, 6);
1055         input_port_limit_hbox.pack_start(_input_limit_count, Gtk::PACK_SHRINK, 0);
1056         input_port_limit_hbox.pack_start(chan_count_label_3, Gtk::PACK_SHRINK, 6);
1057         input_port_vbox.pack_start(_connect_inputs, Gtk::PACK_SHRINK, 0);
1058         input_port_vbox.pack_start(input_port_limit_hbox, Gtk::PACK_EXPAND_PADDING, 0);
1059         input_table.set_row_spacings(0);
1060         input_table.set_col_spacings(0);
1061         input_table.attach(input_port_vbox, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 6);
1062
1063         input_hbox.pack_start (input_table, Gtk::PACK_SHRINK, 18);
1064
1065         input_label.set_alignment(0, 0.5);
1066         input_label.set_padding(0,0);
1067         input_label.set_line_wrap(false);
1068         input_label.set_selectable(false);
1069         input_label.set_use_markup(true);
1070         input_frame.set_shadow_type(Gtk::SHADOW_NONE);
1071         input_frame.set_label_align(0,0.5);
1072         input_frame.add(input_hbox);
1073         input_frame.set_label_widget(input_label);
1074
1075         _connect_outputs.set_label (_("Automatically connect outputs"));
1076         _connect_outputs.set_flags(Gtk::CAN_FOCUS);
1077         _connect_outputs.set_relief(Gtk::RELIEF_NORMAL);
1078         _connect_outputs.set_mode(true);
1079         _connect_outputs.set_active(true);
1080         _connect_outputs.set_border_width(0);
1081         _limit_output_ports.set_label (_("Use only"));
1082         _limit_output_ports.set_flags(Gtk::CAN_FOCUS);
1083         _limit_output_ports.set_relief(Gtk::RELIEF_NORMAL);
1084         _limit_output_ports.set_mode(true);
1085         _limit_output_ports.set_sensitive(true);
1086         _limit_output_ports.set_border_width(0);
1087         _output_limit_count.set_flags(Gtk::CAN_FOCUS);
1088         _output_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1089         _output_limit_count.set_numeric(false);
1090         _output_limit_count.set_digits(0);
1091         _output_limit_count.set_wrap(false);
1092         _output_limit_count.set_sensitive(false);
1093         output_port_limit_hbox.pack_start(_limit_output_ports, Gtk::PACK_SHRINK, 6);
1094         output_port_limit_hbox.pack_start(_output_limit_count, Gtk::PACK_SHRINK, 0);
1095         output_port_limit_hbox.pack_start(chan_count_label_4, Gtk::PACK_SHRINK, 6);
1096
1097         _connect_outputs_to_master.set_label (_("... to master bus"));
1098         _connect_outputs_to_master.set_flags(Gtk::CAN_FOCUS);
1099         _connect_outputs_to_master.set_relief(Gtk::RELIEF_NORMAL);
1100         _connect_outputs_to_master.set_mode(true);
1101         _connect_outputs_to_master.set_active(false);
1102         _connect_outputs_to_master.set_border_width(0);
1103
1104         _connect_outputs_to_master.set_group (connect_outputs_group);
1105         _connect_outputs_to_physical.set_group (connect_outputs_group);
1106
1107         _connect_outputs_to_physical.set_label (_("... to physical outputs"));
1108         _connect_outputs_to_physical.set_flags(Gtk::CAN_FOCUS);
1109         _connect_outputs_to_physical.set_relief(Gtk::RELIEF_NORMAL);
1110         _connect_outputs_to_physical.set_mode(true);
1111         _connect_outputs_to_physical.set_active(false);
1112         _connect_outputs_to_physical.set_border_width(0);
1113
1114         output_conn_vbox.pack_start(_connect_outputs, Gtk::PACK_SHRINK, 0);
1115         output_conn_vbox.pack_start(_connect_outputs_to_master, Gtk::PACK_SHRINK, 0);
1116         output_conn_vbox.pack_start(_connect_outputs_to_physical, Gtk::PACK_SHRINK, 0);
1117         output_vbox.set_border_width(6);
1118
1119         output_port_vbox.pack_start(output_port_limit_hbox, Gtk::PACK_SHRINK, 0);
1120
1121         output_vbox.pack_start(output_conn_vbox);
1122         output_vbox.pack_start(output_port_vbox);
1123
1124         output_label.set_alignment(0, 0.5);
1125         output_label.set_padding(0,0);
1126         output_label.set_line_wrap(false);
1127         output_label.set_selectable(false);
1128         output_label.set_use_markup(true);
1129         output_frame.set_shadow_type(Gtk::SHADOW_NONE);
1130         output_frame.set_label_align(0,0.5);
1131
1132         output_hbox.pack_start (output_vbox, Gtk::PACK_SHRINK, 18);
1133
1134         output_frame.add(output_hbox);
1135         output_frame.set_label_widget(output_label);
1136
1137         more_options_vbox.pack_start(advanced_table, Gtk::PACK_SHRINK, 0);
1138         more_options_vbox.pack_start(bus_frame, Gtk::PACK_SHRINK, 6);
1139         more_options_vbox.pack_start(input_frame, Gtk::PACK_SHRINK, 6);
1140         more_options_vbox.pack_start(output_frame, Gtk::PACK_SHRINK, 0);
1141
1142         /* signals */
1143
1144         _connect_inputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_inputs_clicked));
1145         _connect_outputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_outputs_clicked));
1146         _limit_input_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_inputs_clicked));
1147         _limit_output_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_outputs_clicked));
1148         _create_master_bus.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::master_bus_button_clicked));
1149
1150         /* note that more_options_vbox is NOT visible by
1151          * default. this is entirely by design - this page
1152          * should be skipped unless explicitly requested.
1153          */
1154
1155         session_options_page_index = append_page (more_options_vbox);
1156         set_page_title (more_options_vbox, _("Advanced Session Options"));
1157         set_page_complete (more_options_vbox, true);
1158 }
1159
1160 bool
1161 ArdourStartup::create_master_bus() const
1162 {
1163         return _create_master_bus.get_active();
1164 }
1165
1166 int
1167 ArdourStartup::master_channel_count() const
1168 {
1169         return _master_bus_channel_count.get_value_as_int();
1170 }
1171
1172 bool
1173 ArdourStartup::connect_inputs() const
1174 {
1175         return _connect_inputs.get_active();
1176 }
1177
1178 bool
1179 ArdourStartup::limit_inputs_used_for_connection() const
1180 {
1181         return _limit_input_ports.get_active();
1182 }
1183
1184 int
1185 ArdourStartup::input_limit_count() const
1186 {
1187         return _input_limit_count.get_value_as_int();
1188 }
1189
1190 bool
1191 ArdourStartup::connect_outputs() const
1192 {
1193         return _connect_outputs.get_active();
1194 }
1195
1196 bool
1197 ArdourStartup::limit_outputs_used_for_connection() const
1198 {
1199         return _limit_output_ports.get_active();
1200 }
1201
1202 int
1203 ArdourStartup::output_limit_count() const
1204 {
1205         return _output_limit_count.get_value_as_int();
1206 }
1207
1208 bool
1209 ArdourStartup::connect_outs_to_master() const
1210 {
1211         return _connect_outputs_to_master.get_active();
1212 }
1213
1214 bool
1215 ArdourStartup::connect_outs_to_physical() const
1216 {
1217         return _connect_outputs_to_physical.get_active();
1218 }
1219
1220 void
1221 ArdourStartup::connect_inputs_clicked ()
1222 {
1223         _limit_input_ports.set_sensitive(_connect_inputs.get_active());
1224
1225         if (_connect_inputs.get_active() && _limit_input_ports.get_active()) {
1226                 _input_limit_count.set_sensitive(true);
1227         } else {
1228                 _input_limit_count.set_sensitive(false);
1229         }
1230 }
1231
1232 void
1233 ArdourStartup::connect_outputs_clicked ()
1234 {
1235         _limit_output_ports.set_sensitive(_connect_outputs.get_active());
1236
1237         if (_connect_outputs.get_active() && _limit_output_ports.get_active()) {
1238                 _output_limit_count.set_sensitive(true);
1239         } else {
1240                 _output_limit_count.set_sensitive(false);
1241         }
1242 }
1243
1244 void
1245 ArdourStartup::limit_inputs_clicked ()
1246 {
1247         _input_limit_count.set_sensitive(_limit_input_ports.get_active());
1248 }
1249
1250 void
1251 ArdourStartup::limit_outputs_clicked ()
1252 {
1253         _output_limit_count.set_sensitive(_limit_output_ports.get_active());
1254 }
1255
1256 void
1257 ArdourStartup::master_bus_button_clicked ()
1258 {
1259         bool yn = _create_master_bus.get_active();
1260
1261         _master_bus_channel_count.set_sensitive(yn);
1262 }
1263
1264 void
1265 ArdourStartup::move_along_now ()
1266 {
1267         gint cur = get_current_page ();
1268
1269         if (cur == session_page_index) {
1270                 if (more_new_session_options_button.get_active()) {
1271                         set_current_page (session_options_page_index);
1272                 } else {
1273                         on_apply ();
1274                 }
1275         }
1276 }
1277
1278 void
1279 ArdourStartup::recent_row_activated (const Gtk::TreePath&, Gtk::TreeViewColumn*)
1280 {
1281         set_page_complete (session_vbox, true);
1282         move_along_now ();
1283 }
1284
1285 void
1286 ArdourStartup::existing_session_selected ()
1287 {
1288         _existing_session_chooser_used = true;
1289
1290         set_page_complete (session_vbox, true);
1291         move_along_now ();
1292 }