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, _("Welcome to Ardour"));
 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 (_("\
 325 Each project that you work on with Ardour 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 Ardour sessions to be stored by default?\n\n\
 329 <i>(You can put new sessions anywhere, this is just a default)</i>"));
 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                 vbox1->pack_start (*hbox2, false, false);
 685
 686                 session_new_vbox.pack_start (*vbox1, false, false);
 687
 688                 /* --- */
 689
 690                 VBox *vbox2 = manage (new VBox);
 691                 HBox* hbox3 = manage (new HBox);
 692                 Label* label3 = manage (new Label);
 693                 template_model = ListStore::create (session_template_columns);
 694                 populate_session_templates ();
 695
 696                 vbox2->set_spacing (6);
 697
 698                 label3->set_markup (_("<b>Options</b>"));
 699                 label3->set_alignment (0.0, 0.0);
 700
 701                 vbox2->pack_start (*label3, false, true);
 702
 703                 VBox *vbox3 = manage (new VBox);
 704
 705                 vbox3->set_spacing (6);
 706
 707                 if (!template_model->children().empty()) {
 708
 709                         HBox* hbox4a = manage (new HBox);
 710                         use_template_button.set_label (_("Use this template"));
 711
 712                         TreeModel::Row row = *template_model->prepend ();
 713                         row[session_template_columns.name] = (_("no template"));
 714                         row[session_template_columns.path] = string();
 715
 716                         hbox4a->set_spacing (6);
 717                         hbox4a->pack_start (use_template_button, false, false);
 718                         hbox4a->pack_start (template_chooser, true, true);
 719
 720                         template_chooser.set_model (template_model);
 721
 722                         Gtk::CellRendererText* text_renderer = Gtk::manage (new Gtk::CellRendererText);
 723                         text_renderer->property_editable() = false;
 724
 725                         template_chooser.pack_start (*text_renderer);
 726                         template_chooser.add_attribute (text_renderer->property_text(), session_template_columns.name);
 727                         template_chooser.set_active (0);
 728
 729                         use_template_button.show();
 730                         template_chooser.show ();
 731
 732                         vbox3->pack_start (*hbox4a, false, false);
 733                 }
 734
 735                 /* --- */
 736
 737                 if (!new_user) {
 738                         session_template_chooser.set_current_folder (poor_mans_glob (Config->get_default_session_parent_dir()));
 739
 740                         HBox* hbox4b = manage (new HBox);
 741                         use_session_as_template_button.set_label (_("Use an existing session as a template:"));
 742
 743                         hbox4b->set_spacing (6);
 744                         hbox4b->pack_start (use_session_as_template_button, false, false);
 745                         hbox4b->pack_start (session_template_chooser, true, true);
 746
 747                         use_session_as_template_button.show ();
 748                         session_template_chooser.show ();
 749
 750                         Gtk::FileFilter* template_filter = manage (new (Gtk::FileFilter));
 751                         template_filter->add_pattern(X_("*.template"));
 752                         session_template_chooser.set_filter (*template_filter);
 753                         session_template_chooser.set_title (_("Select template"));
 754
 755                         vbox3->pack_start (*hbox4b, false, false);
 756                 }
 757
 758                 /* --- */
 759
 760                 HBox* hbox5 = manage (new HBox);
 761
 762                 hbox5->set_spacing (6);
 763                 hbox5->pack_start (more_new_session_options_button, false, false);
 764
 765                 more_new_session_options_button.show ();
 766                 more_new_session_options_button.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::more_new_session_options_button_clicked));
 767
 768                 vbox3->pack_start (*hbox5, false, false);
 769                 hbox3->pack_start (*vbox3, true, true, 8);
 770                 vbox2->pack_start (*hbox3, false, false);
 771
 772                 /* --- */
 773
 774                 session_new_vbox.pack_start (*vbox2, false, false);
 775         }
 776
 777         session_new_vbox.show_all ();
 778         session_hbox.pack_start (session_new_vbox, true, true);
 779         set_page_title (session_vbox, _("New Session"));
 780         set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
 781
 782         new_name_entry.signal_map().connect (sigc::mem_fun (*this, &ArdourStartup::new_name_mapped));
 783         new_name_entry.signal_focus_out_event().connect (sigc::ptr_fun (lost_name_entry_focus));
 784 }
 785
 786 void
 787 ArdourStartup::new_name_mapped ()
 788 {
 789         cerr << "Grab new name focus\n";
 790         new_name_entry.grab_focus ();
 791 }
 792
 793 void
 794 ArdourStartup::new_name_changed ()
 795 {
 796         if (!new_name_entry.get_text().empty()) {
 797                 set_page_complete (session_vbox, true);
 798         } else {
 799                 set_page_complete (session_vbox, false);
 800         }
 801 }
 802
 803 int
 804 ArdourStartup::redisplay_recent_sessions ()
 805 {
 806         std::vector<sys::path> session_directories;
 807         RecentSessionsSorter cmp;
 808
 809         recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
 810         recent_session_model->clear ();
 811
 812         ARDOUR::RecentSessions rs;
 813         ARDOUR::read_recent_sessions (rs);
 814
 815         if (rs.empty()) {
 816                 recent_session_display.set_model (recent_session_model);
 817                 return 0;
 818         }
 819         //
 820         // sort them alphabetically
 821         sort (rs.begin(), rs.end(), cmp);
 822
 823         for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
 824                 session_directories.push_back ((*i).second);
 825         }
 826
 827         for (vector<sys::path>::const_iterator i = session_directories.begin(); i != session_directories.end(); ++i)
 828         {
 829                 std::vector<sys::path> state_file_paths;
 830
 831                 // now get available states for this session
 832
 833                 get_state_files_in_directory (*i, state_file_paths);
 834
 835                 vector<string*>* states;
 836                 vector<const gchar*> item;
 837                 string fullpath = (*i).to_string();
 838
 839                 /* remove any trailing / */
 840
 841                 if (fullpath[fullpath.length()-1] == '/') {
 842                         fullpath = fullpath.substr (0, fullpath.length()-1);
 843                 }
 844
 845                 /* check whether session still exists */
 846                 if (!Glib::file_test(fullpath.c_str(), Glib::FILE_TEST_EXISTS)) {
 847                         /* session doesn't exist */
 848                         continue;
 849                 }
 850
 851                 /* now get available states for this session */
 852
 853                 if ((states = Session::possible_states (fullpath)) == 0) {
 854                         /* no state file? */
 855                         continue;
 856                 }
 857
 858                 std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
 859
 860                 Gtk::TreeModel::Row row = *(recent_session_model->append());
 861
 862                 row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
 863                 row[recent_session_columns.fullpath] = fullpath;
 864
 865                 if (state_file_names.size() > 1) {
 866
 867                         // add the children
 868
 869                         for (std::vector<std::string>::iterator i2 = state_file_names.begin();
 870                                         i2 != state_file_names.end(); ++i2)
 871                         {
 872
 873                                 Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
 874
 875                                 child_row[recent_session_columns.visible_name] = *i2;
 876                                 child_row[recent_session_columns.fullpath] = fullpath;
 877                         }
 878                 }
 879         }
 880
 881         recent_session_display.set_model (recent_session_model);
 882         return rs.size();
 883 }
 884
 885 void
 886 ArdourStartup::recent_session_row_selected ()
 887 {
 888         if (recent_session_display.get_selection()->count_selected_rows() > 0) {
 889                 set_page_complete (session_vbox, true);
 890         } else {
 891                 set_page_complete (session_vbox, false);
 892         }
 893 }
 894
 895 void
 896 ArdourStartup::setup_existing_session_page ()
 897 {
 898         recent_session_model = TreeStore::create (recent_session_columns);
 899         redisplay_recent_sessions ();
 900
 901         if (_have_setup_existing_session_page) {
 902                 return;
 903         }
 904
 905         recent_session_display.set_model (recent_session_model);
 906         recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
 907         recent_session_display.set_headers_visible (false);
 908         recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
 909
 910         recent_session_display.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &ArdourStartup::recent_session_row_selected));
 911
 912         recent_scroller.add (recent_session_display);
 913         recent_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 914         recent_scroller.set_shadow_type (Gtk::SHADOW_IN);
 915
 916         recent_session_display.show();
 917
 918         recent_scroller.show();
 919         int cnt = redisplay_recent_sessions ();
 920         recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ArdourStartup::recent_row_activated));
 921
 922         if (cnt > 4) {
 923                 recent_scroller.set_size_request (-1, 300);
 924         }
 925
 926         VBox* vbox = manage (new VBox);
 927         vbox->set_spacing (8);
 928         vbox->pack_start (recent_scroller, true, true);
 929
 930         existing_session_chooser.set_title (_("Select session file"));
 931         existing_session_chooser.signal_file_set().connect (sigc::mem_fun (*this, &ArdourStartup::existing_session_selected));
 932
 933         HBox* hbox = manage (new HBox);
 934         hbox->set_spacing (4);
 935         hbox->pack_start (*manage (new Label (_("Browse:"))), PACK_SHRINK);
 936         hbox->pack_start (existing_session_chooser);
 937         vbox->pack_start (*hbox);
 938         hbox->show_all ();
 939
 940         vbox->show_all ();
 941         session_hbox.pack_start (*vbox, true, true);
 942
 943         set_page_title (session_vbox, _("Select a session"));
 944         set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
 945
 946         _have_setup_existing_session_page = true;
 947 }
 948
 949 void
 950 ArdourStartup::more_new_session_options_button_clicked ()
 951 {
 952         if (more_new_session_options_button.get_active()) {
 953                 more_options_vbox.show_all ();
 954                 set_page_type (more_options_vbox, ASSISTANT_PAGE_CONFIRM);
 955                 set_page_type (session_vbox, ASSISTANT_PAGE_CONTENT);
 956         } else {
 957                 set_page_type (session_vbox, ASSISTANT_PAGE_CONFIRM);
 958                 more_options_vbox.hide ();
 959         }
 960 }
 961
 962 void
 963 ArdourStartup::setup_more_options_page ()
 964 {
 965         more_options_vbox.set_border_width (24);
 966
 967         _output_limit_count.set_adjustment (_output_limit_count_adj);
 968         _input_limit_count.set_adjustment (_input_limit_count_adj);
 969         _master_bus_channel_count.set_adjustment (_master_bus_channel_count_adj);
 970
 971         chan_count_label_1.set_text (_("channels"));
 972         chan_count_label_3.set_text (_("channels"));
 973         chan_count_label_4.set_text (_("channels"));
 974
 975         chan_count_label_1.set_alignment(0,0.5);
 976         chan_count_label_1.set_padding(0,0);
 977         chan_count_label_1.set_line_wrap(false);
 978
 979         chan_count_label_3.set_alignment(0,0.5);
 980         chan_count_label_3.set_padding(0,0);
 981         chan_count_label_3.set_line_wrap(false);
 982
 983         chan_count_label_4.set_alignment(0,0.5);
 984         chan_count_label_4.set_padding(0,0);
 985         chan_count_label_4.set_line_wrap(false);
 986
 987         bus_label.set_markup (_("<b>Busses</b>"));
 988         input_label.set_markup (_("<b>Inputs</b>"));
 989         output_label.set_markup (_("<b>Outputs</b>"));
 990
 991         _master_bus_channel_count.set_flags(Gtk::CAN_FOCUS);
 992         _master_bus_channel_count.set_update_policy(Gtk::UPDATE_ALWAYS);
 993         _master_bus_channel_count.set_numeric(true);
 994         _master_bus_channel_count.set_digits(0);
 995         _master_bus_channel_count.set_wrap(false);
 996
 997         _create_master_bus.set_label (_("Create master bus"));
 998         _create_master_bus.set_flags(Gtk::CAN_FOCUS);
 999         _create_master_bus.set_relief(Gtk::RELIEF_NORMAL);
1000         _create_master_bus.set_mode(true);
1001         _create_master_bus.set_active(true);
1002         _create_master_bus.set_border_width(0);
1003
1004         advanced_table.set_row_spacings(0);
1005         advanced_table.set_col_spacings(0);
1006
1007         _connect_inputs.set_label (_("Automatically connect to physical_inputs"));
1008         _connect_inputs.set_flags(Gtk::CAN_FOCUS);
1009         _connect_inputs.set_relief(Gtk::RELIEF_NORMAL);
1010         _connect_inputs.set_mode(true);
1011         _connect_inputs.set_active(true);
1012         _connect_inputs.set_border_width(0);
1013
1014         _limit_input_ports.set_label (_("Use only"));
1015         _limit_input_ports.set_flags(Gtk::CAN_FOCUS);
1016         _limit_input_ports.set_relief(Gtk::RELIEF_NORMAL);
1017         _limit_input_ports.set_mode(true);
1018         _limit_input_ports.set_sensitive(true);
1019         _limit_input_ports.set_border_width(0);
1020
1021         _input_limit_count.set_flags(Gtk::CAN_FOCUS);
1022         _input_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1023         _input_limit_count.set_numeric(true);
1024         _input_limit_count.set_digits(0);
1025         _input_limit_count.set_wrap(false);
1026         _input_limit_count.set_sensitive(false);
1027
1028         bus_hbox.pack_start (bus_table, Gtk::PACK_SHRINK, 18);
1029
1030         bus_label.set_alignment(0, 0.5);
1031         bus_label.set_padding(0,0);
1032         bus_label.set_line_wrap(false);
1033         bus_label.set_selectable(false);
1034         bus_label.set_use_markup(true);
1035         bus_frame.set_shadow_type(Gtk::SHADOW_NONE);
1036         bus_frame.set_label_align(0,0.5);
1037         bus_frame.add(bus_hbox);
1038         bus_frame.set_label_widget(bus_label);
1039
1040         bus_table.set_row_spacings (0);
1041         bus_table.set_col_spacings (0);
1042         bus_table.attach (_create_master_bus, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1043         bus_table.attach (_master_bus_channel_count, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1044         bus_table.attach (chan_count_label_1, 2, 3, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 0);
1045
1046         input_port_limit_hbox.pack_start(_limit_input_ports, Gtk::PACK_SHRINK, 6);
1047         input_port_limit_hbox.pack_start(_input_limit_count, Gtk::PACK_SHRINK, 0);
1048         input_port_limit_hbox.pack_start(chan_count_label_3, Gtk::PACK_SHRINK, 6);
1049         input_port_vbox.pack_start(_connect_inputs, Gtk::PACK_SHRINK, 0);
1050         input_port_vbox.pack_start(input_port_limit_hbox, Gtk::PACK_EXPAND_PADDING, 0);
1051         input_table.set_row_spacings(0);
1052         input_table.set_col_spacings(0);
1053         input_table.attach(input_port_vbox, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 6, 6);
1054
1055         input_hbox.pack_start (input_table, Gtk::PACK_SHRINK, 18);
1056
1057         input_label.set_alignment(0, 0.5);
1058         input_label.set_padding(0,0);
1059         input_label.set_line_wrap(false);
1060         input_label.set_selectable(false);
1061         input_label.set_use_markup(true);
1062         input_frame.set_shadow_type(Gtk::SHADOW_NONE);
1063         input_frame.set_label_align(0,0.5);
1064         input_frame.add(input_hbox);
1065         input_frame.set_label_widget(input_label);
1066
1067         _connect_outputs.set_label (_("Automatically connect outputs"));
1068         _connect_outputs.set_flags(Gtk::CAN_FOCUS);
1069         _connect_outputs.set_relief(Gtk::RELIEF_NORMAL);
1070         _connect_outputs.set_mode(true);
1071         _connect_outputs.set_active(true);
1072         _connect_outputs.set_border_width(0);
1073         _limit_output_ports.set_label (_("Use only"));
1074         _limit_output_ports.set_flags(Gtk::CAN_FOCUS);
1075         _limit_output_ports.set_relief(Gtk::RELIEF_NORMAL);
1076         _limit_output_ports.set_mode(true);
1077         _limit_output_ports.set_sensitive(true);
1078         _limit_output_ports.set_border_width(0);
1079         _output_limit_count.set_flags(Gtk::CAN_FOCUS);
1080         _output_limit_count.set_update_policy(Gtk::UPDATE_ALWAYS);
1081         _output_limit_count.set_numeric(false);
1082         _output_limit_count.set_digits(0);
1083         _output_limit_count.set_wrap(false);
1084         _output_limit_count.set_sensitive(false);
1085         output_port_limit_hbox.pack_start(_limit_output_ports, Gtk::PACK_SHRINK, 6);
1086         output_port_limit_hbox.pack_start(_output_limit_count, Gtk::PACK_SHRINK, 0);
1087         output_port_limit_hbox.pack_start(chan_count_label_4, Gtk::PACK_SHRINK, 6);
1088
1089         _connect_outputs_to_master.set_label (_("... to master bus"));
1090         _connect_outputs_to_master.set_flags(Gtk::CAN_FOCUS);
1091         _connect_outputs_to_master.set_relief(Gtk::RELIEF_NORMAL);
1092         _connect_outputs_to_master.set_mode(true);
1093         _connect_outputs_to_master.set_active(false);
1094         _connect_outputs_to_master.set_border_width(0);
1095
1096         _connect_outputs_to_master.set_group (connect_outputs_group);
1097         _connect_outputs_to_physical.set_group (connect_outputs_group);
1098
1099         _connect_outputs_to_physical.set_label (_("... to physical outputs"));
1100         _connect_outputs_to_physical.set_flags(Gtk::CAN_FOCUS);
1101         _connect_outputs_to_physical.set_relief(Gtk::RELIEF_NORMAL);
1102         _connect_outputs_to_physical.set_mode(true);
1103         _connect_outputs_to_physical.set_active(false);
1104         _connect_outputs_to_physical.set_border_width(0);
1105
1106         output_conn_vbox.pack_start(_connect_outputs, Gtk::PACK_SHRINK, 0);
1107         output_conn_vbox.pack_start(_connect_outputs_to_master, Gtk::PACK_SHRINK, 0);
1108         output_conn_vbox.pack_start(_connect_outputs_to_physical, Gtk::PACK_SHRINK, 0);
1109         output_vbox.set_border_width(6);
1110
1111         output_port_vbox.pack_start(output_port_limit_hbox, Gtk::PACK_SHRINK, 0);
1112
1113         output_vbox.pack_start(output_conn_vbox);
1114         output_vbox.pack_start(output_port_vbox);
1115
1116         output_label.set_alignment(0, 0.5);
1117         output_label.set_padding(0,0);
1118         output_label.set_line_wrap(false);
1119         output_label.set_selectable(false);
1120         output_label.set_use_markup(true);
1121         output_frame.set_shadow_type(Gtk::SHADOW_NONE);
1122         output_frame.set_label_align(0,0.5);
1123
1124         output_hbox.pack_start (output_vbox, Gtk::PACK_SHRINK, 18);
1125
1126         output_frame.add(output_hbox);
1127         output_frame.set_label_widget(output_label);
1128
1129         more_options_vbox.pack_start(advanced_table, Gtk::PACK_SHRINK, 0);
1130         more_options_vbox.pack_start(bus_frame, Gtk::PACK_SHRINK, 6);
1131         more_options_vbox.pack_start(input_frame, Gtk::PACK_SHRINK, 6);
1132         more_options_vbox.pack_start(output_frame, Gtk::PACK_SHRINK, 0);
1133
1134         /* signals */
1135
1136         _connect_inputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_inputs_clicked));
1137         _connect_outputs.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::connect_outputs_clicked));
1138         _limit_input_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_inputs_clicked));
1139         _limit_output_ports.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::limit_outputs_clicked));
1140         _create_master_bus.signal_clicked().connect (sigc::mem_fun (*this, &ArdourStartup::master_bus_button_clicked));
1141
1142         /* note that more_options_vbox is NOT visible by
1143          * default. this is entirely by design - this page
1144          * should be skipped unless explicitly requested.
1145          */
1146
1147         session_options_page_index = append_page (more_options_vbox);
1148         set_page_title (more_options_vbox, _("Advanced Session Options"));
1149         set_page_complete (more_options_vbox, true);
1150 }
1151
1152 bool
1153 ArdourStartup::create_master_bus() const
1154 {
1155         return _create_master_bus.get_active();
1156 }
1157
1158 int
1159 ArdourStartup::master_channel_count() const
1160 {
1161         return _master_bus_channel_count.get_value_as_int();
1162 }
1163
1164 bool
1165 ArdourStartup::connect_inputs() const
1166 {
1167         return _connect_inputs.get_active();
1168 }
1169
1170 bool
1171 ArdourStartup::limit_inputs_used_for_connection() const
1172 {
1173         return _limit_input_ports.get_active();
1174 }
1175
1176 int
1177 ArdourStartup::input_limit_count() const
1178 {
1179         return _input_limit_count.get_value_as_int();
1180 }
1181
1182 bool
1183 ArdourStartup::connect_outputs() const
1184 {
1185         return _connect_outputs.get_active();
1186 }
1187
1188 bool
1189 ArdourStartup::limit_outputs_used_for_connection() const
1190 {
1191         return _limit_output_ports.get_active();
1192 }
1193
1194 int
1195 ArdourStartup::output_limit_count() const
1196 {
1197         return _output_limit_count.get_value_as_int();
1198 }
1199
1200 bool
1201 ArdourStartup::connect_outs_to_master() const
1202 {
1203         return _connect_outputs_to_master.get_active();
1204 }
1205
1206 bool
1207 ArdourStartup::connect_outs_to_physical() const
1208 {
1209         return _connect_outputs_to_physical.get_active();
1210 }
1211
1212 void
1213 ArdourStartup::connect_inputs_clicked ()
1214 {
1215         _limit_input_ports.set_sensitive(_connect_inputs.get_active());
1216
1217         if (_connect_inputs.get_active() && _limit_input_ports.get_active()) {
1218                 _input_limit_count.set_sensitive(true);
1219         } else {
1220                 _input_limit_count.set_sensitive(false);
1221         }
1222 }
1223
1224 void
1225 ArdourStartup::connect_outputs_clicked ()
1226 {
1227         _limit_output_ports.set_sensitive(_connect_outputs.get_active());
1228
1229         if (_connect_outputs.get_active() && _limit_output_ports.get_active()) {
1230                 _output_limit_count.set_sensitive(true);
1231         } else {
1232                 _output_limit_count.set_sensitive(false);
1233         }
1234 }
1235
1236 void
1237 ArdourStartup::limit_inputs_clicked ()
1238 {
1239         _input_limit_count.set_sensitive(_limit_input_ports.get_active());
1240 }
1241
1242 void
1243 ArdourStartup::limit_outputs_clicked ()
1244 {
1245         _output_limit_count.set_sensitive(_limit_output_ports.get_active());
1246 }
1247
1248 void
1249 ArdourStartup::master_bus_button_clicked ()
1250 {
1251         bool yn = _create_master_bus.get_active();
1252
1253         _master_bus_channel_count.set_sensitive(yn);
1254 }
1255
1256 void
1257 ArdourStartup::move_along_now ()
1258 {
1259         gint cur = get_current_page ();
1260
1261         if (cur == session_page_index) {
1262                 if (more_new_session_options_button.get_active()) {
1263                         set_current_page (session_options_page_index);
1264                 } else {
1265                         on_apply ();
1266                 }
1267         }
1268 }
1269
1270 void
1271 ArdourStartup::recent_row_activated (const Gtk::TreePath&, Gtk::TreeViewColumn*)
1272 {
1273         set_page_complete (session_vbox, true);
1274         move_along_now ();
1275 }
1276
1277 void
1278 ArdourStartup::existing_session_selected ()
1279 {
1280         _existing_session_chooser_used = true;
1281
1282         set_page_complete (session_vbox, true);
1283         move_along_now ();
1284 }