gtk2_ardour/ardour_ui.cc

   1 /*
   2     Copyright (C) 1999-2002 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     $Id$
  19 */
  20
  21 #include <algorithm>
  22 #include <cmath>
  23 #include <fcntl.h>
  24 #include <signal.h>
  25 #include <unistd.h>
  26 #include <cerrno>
  27 #include <fstream>
  28
  29 #include <iostream>
  30
  31 #include <gtkmm/messagedialog.h>
  32 #include <gtkmm/accelmap.h>
  33
  34 #include <pbd/error.h>
  35 #include <pbd/compose.h>
  36 #include <pbd/pathscanner.h>
  37 #include <pbd/failed_constructor.h>
  38 #include <gtkmm2ext/gtk_ui.h>
  39 #include <gtkmm2ext/utils.h>
  40 #include <gtkmm2ext/click_box.h>
  41 #include <gtkmm2ext/fastmeter.h>
  42 #include <gtkmm2ext/stop_signal.h>
  43 #include <gtkmm2ext/popup.h>
  44
  45 #include <midi++/port.h>
  46 #include <midi++/mmc.h>
  47
  48 #include <ardour/ardour.h>
  49 #include <ardour/port.h>
  50 #include <ardour/audioengine.h>
  51 #include <ardour/playlist.h>
  52 #include <ardour/utils.h>
  53 #include <ardour/audio_diskstream.h>
  54 #include <ardour/audiofilesource.h>
  55 #include <ardour/recent_sessions.h>
  56 #include <ardour/session_route.h>
  57 #include <ardour/port.h>
  58 #include <ardour/audio_track.h>
  59 #include <ardour/midi_track.h>
  60
  61 #include "actions.h"
  62 #include "ardour_ui.h"
  63 #include "public_editor.h"
  64 #include "audio_clock.h"
  65 #include "keyboard.h"
  66 #include "mixer_ui.h"
  67 #include "prompter.h"
  68 #include "opts.h"
  69 #include "keyboard_target.h"
  70 #include "add_route_dialog.h"
  71 #include "new_session_dialog.h"
  72 #include "about.h"
  73 #include "utils.h"
  74 #include "gui_thread.h"
  75 #include "color_manager.h"
  76
  77 #include "i18n.h"
  78
  79 using namespace ARDOUR;
  80 using namespace PBD;
  81 using namespace Gtkmm2ext;
  82 using namespace Gtk;
  83 using namespace sigc;
  84
  85 ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
  86
  87 sigc::signal<void,bool> ARDOUR_UI::Blink;
  88 sigc::signal<void>      ARDOUR_UI::RapidScreenUpdate;
  89 sigc::signal<void>      ARDOUR_UI::SuperRapidScreenUpdate;
  90 sigc::signal<void,jack_nframes_t> ARDOUR_UI::Clock;
  91
  92 ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
  93
  94         : Gtkmm2ext::UI ("ardour", argcp, argvp, rcfile),
  95
  96           primary_clock (X_("TransportClockDisplay"), true, false, true),
  97           secondary_clock (X_("SecondaryClockDisplay"), true, false, true),
  98           preroll_clock (X_("PreRollClock"), true, true),
  99           postroll_clock (X_("PostRollClock"), true, true),
 100
 101           /* adjuster table */
 102
 103           adjuster_table (3, 3),
 104
 105           /* preroll stuff */
 106
 107           preroll_button (_("pre\nroll")),
 108           postroll_button (_("post\nroll")),
 109
 110           /* big clock */
 111
 112           big_clock ("BigClockDisplay", true),
 113
 114           /* transport */
 115
 116           time_master_button (_("time\nmaster")),
 117
 118           shuttle_units_button (_("% ")),
 119
 120           punch_in_button (_("Punch In")),
 121           punch_out_button (_("Punch Out")),
 122           auto_return_button (_("Auto Return")),
 123           auto_play_button (_("Autuo Play")),
 124           auto_input_button (_("Auto Input")),
 125           click_button (_("Click")),
 126           auditioning_alert_button (_("AUDITION")),
 127           solo_alert_button (_("SOLO")),
 128           shown_flag (false)
 129 {
 130         using namespace Gtk::Menu_Helpers;
 131
 132         Gtkmm2ext::init();
 133
 134         about = 0;
 135
 136         if (theArdourUI == 0) {
 137                 theArdourUI = this;
 138         }
 139
 140         ActionManager::init ();
 141
 142         /* load colors */
 143
 144         color_manager = new ColorManager();
 145
 146         std::string color_file = ARDOUR::find_config_file("ardour.colors");
 147
 148         color_manager->load (color_file);
 149
 150         m_new_session_dialog = new NewSessionDialog();
 151         editor = 0;
 152         mixer = 0;
 153         session = 0;
 154         _session_is_new = false;
 155         big_clock_window = 0;
 156         session_selector_window = 0;
 157         last_key_press_time = 0;
 158         connection_editor = 0;
 159         add_route_dialog = 0;
 160         route_params = 0;
 161         option_editor = 0;
 162         location_ui = 0;
 163         sfdb = 0;
 164         open_session_selector = 0;
 165         have_configure_timeout = false;
 166         have_disk_overrun_displayed = false;
 167         have_disk_underrun_displayed = false;
 168         _will_create_new_session_automatically = false;
 169         session_loaded = false;
 170         last_speed_displayed = -1.0f;
 171
 172         last_configure_time.tv_sec = 0;
 173         last_configure_time.tv_usec = 0;
 174
 175         shuttle_grabbed = false;
 176         shuttle_fract = 0.0;
 177         shuttle_max_speed = 8.0f;
 178
 179         set_shuttle_units (Percentage);
 180         set_shuttle_behaviour (Sprung);
 181
 182         shuttle_style_menu = 0;
 183         shuttle_unit_menu = 0;
 184
 185         gettimeofday (&last_peak_grab, 0);
 186         gettimeofday (&last_shuttle_request, 0);
 187
 188         ARDOUR::AudioDiskstream::DeleteSources.connect (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread));
 189         ARDOUR::Diskstream::DiskOverrun.connect (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
 190         ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
 191
 192         /* handle pending state with a dialog */
 193
 194         ARDOUR::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
 195
 196         /* have to wait for AudioEngine and Configuration before proceeding */
 197 }
 198
 199 void
 200 ARDOUR_UI::set_engine (AudioEngine& e)
 201 {
 202         engine = &e;
 203
 204         engine->Stopped.connect (mem_fun(*this, &ARDOUR_UI::engine_stopped));
 205         engine->Running.connect (mem_fun(*this, &ARDOUR_UI::engine_running));
 206         engine->Halted.connect (mem_fun(*this, &ARDOUR_UI::engine_halted));
 207         engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate));
 208
 209         _tooltips.enable();
 210
 211         keyboard = new Keyboard;
 212
 213         if (setup_windows ()) {
 214                 throw failed_constructor ();
 215         }
 216
 217         if (GTK_ARDOUR::show_key_actions) {
 218                 vector<string> names;
 219                 vector<string> paths;
 220                 vector<string> keys;
 221                 vector<AccelKey> bindings;
 222
 223                 ActionManager::get_all_actions (names, paths, keys, bindings);
 224
 225                 vector<string>::iterator n;
 226                 vector<string>::iterator k;
 227                 for (n = names.begin(), k = keys.begin(); n != names.end(); ++n, ++k) {
 228                         cerr << "Action: " << (*n) << " bound to " << (*k) << endl;
 229                 }
 230
 231                 exit (0);
 232         }
 233
 234         /* start with timecode, metering enabled
 235         */
 236
 237         blink_timeout_tag = -1;
 238
 239         /* the global configuration object is now valid */
 240
 241         use_config ();
 242
 243         /* this being a GUI and all, we want peakfiles */
 244
 245         AudioFileSource::set_build_peakfiles (true);
 246         AudioFileSource::set_build_missing_peakfiles (true);
 247
 248         if (AudioSource::start_peak_thread ()) {
 249                 throw failed_constructor();
 250         }
 251
 252         /* start the time-of-day-clock */
 253
 254         update_wall_clock ();
 255         Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
 256
 257         update_disk_space ();
 258         update_cpu_load ();
 259         update_sample_rate (engine->frame_rate());
 260
 261         starting.connect (mem_fun(*this, &ARDOUR_UI::startup));
 262         stopping.connect (mem_fun(*this, &ARDOUR_UI::shutdown));
 263 }
 264
 265 ARDOUR_UI::~ARDOUR_UI ()
 266 {
 267         save_ardour_state ();
 268
 269         if (keyboard) {
 270                 delete keyboard;
 271         }
 272
 273         if (editor) {
 274                 delete editor;
 275         }
 276
 277         if (mixer) {
 278                 delete mixer;
 279         }
 280
 281         if (add_route_dialog) {
 282                 delete add_route_dialog;
 283         }
 284
 285         AudioSource::stop_peak_thread ();
 286 }
 287
 288 gint
 289 ARDOUR_UI::configure_timeout ()
 290 {
 291         struct timeval now;
 292         struct timeval diff;
 293
 294         if (last_configure_time.tv_sec == 0 && last_configure_time.tv_usec == 0) {
 295                 /* no configure events yet */
 296                 return TRUE;
 297         }
 298
 299         gettimeofday (&now, 0);
 300         timersub (&now, &last_configure_time, &diff);
 301
 302         /* force a gap of 0.5 seconds since the last configure event
 303          */
 304
 305         if (diff.tv_sec == 0 && diff.tv_usec < 500000) {
 306                 return TRUE;
 307         } else {
 308                 have_configure_timeout = false;
 309                 save_ardour_state ();
 310                 return FALSE;
 311         }
 312 }
 313
 314 gboolean
 315 ARDOUR_UI::configure_handler (GdkEventConfigure* conf)
 316 {
 317         if (have_configure_timeout) {
 318                 gettimeofday (&last_configure_time, 0);
 319         } else {
 320                 Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
 321                 have_configure_timeout = true;
 322         }
 323
 324         return FALSE;
 325 }
 326
 327 void
 328 ARDOUR_UI::save_ardour_state ()
 329 {
 330         if (!keyboard || !mixer || !editor) {
 331                 return;
 332         }
 333
 334         /* XXX this is all a bit dubious. add_extra_xml() uses
 335            a different lifetime model from add_instant_xml().
 336         */
 337
 338         XMLNode* node = new XMLNode (keyboard->get_state());
 339         Config->add_extra_xml (*node);
 340         Config->save_state();
 341
 342         XMLNode enode(static_cast<Stateful*>(editor)->get_state());
 343         XMLNode mnode(mixer->get_state());
 344
 345         if (session) {
 346                 session->add_instant_xml (enode, session->path());
 347                 session->add_instant_xml (mnode, session->path());
 348         } else {
 349                 Config->add_instant_xml (enode, get_user_ardour_path());
 350                 Config->add_instant_xml (mnode, get_user_ardour_path());
 351         }
 352
 353         /* keybindings */
 354
 355         AccelMap::save ("ardour.saved_bindings");
 356 }
 357
 358 void
 359 ARDOUR_UI::startup ()
 360 {
 361         /* Once the UI is up and running, start the audio engine. Doing
 362            this before the UI is up and running can cause problems
 363            when not running with SCHED_FIFO, because the amount of
 364            CPU and disk work needed to get the UI started can interfere
 365            with the scheduling of the audio thread.
 366         */
 367
 368         Glib::signal_idle().connect (mem_fun(*this, &ARDOUR_UI::start_engine));
 369 }
 370
 371 void
 372 ARDOUR_UI::finish()
 373 {
 374         if (session && session->dirty()) {
 375                 switch (ask_about_saving_session(_("quit"))) {
 376                 case -1:
 377                         return;
 378                         break;
 379                 case 1:
 380                         /* use the default name */
 381                         if (save_state_canfail ("")) {
 382                                 /* failed - don't quit */
 383                                 MessageDialog msg (*editor,
 384                                                _("\
 385 Ardour was unable to save your session.\n\n\
 386 If you still wish to quit, please use the\n\n\
 387 \"Just quit\" option."));
 388                                 msg.run ();
 389                                 return;
 390                         }
 391                         break;
 392                 case 0:
 393                         break;
 394                 }
 395         }
 396         Config->save_state();
 397         quit ();
 398 }
 399
 400 int
 401 ARDOUR_UI::ask_about_saving_session (const string & what)
 402 {
 403         ArdourDialog window (_("ardour: save session?"));
 404         Gtk::HBox dhbox;  // the hbox for the image and text
 405         Gtk::Label  prompt_label;
 406         Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_WARNING,  Gtk::ICON_SIZE_DIALOG));
 407
 408         string msg;
 409
 410         msg = string_compose(_("Don't %1"), what);
 411         window.add_button (msg, RESPONSE_REJECT);
 412         msg = string_compose(_("Just %1"), what);
 413         window.add_button (msg, RESPONSE_APPLY);
 414         msg = string_compose(_("Save and %1"), what);
 415         window.add_button (msg, RESPONSE_ACCEPT);
 416
 417         window.set_default_response (RESPONSE_ACCEPT);
 418
 419         Gtk::Button noquit_button (msg);
 420         noquit_button.set_name ("EditorGTKButton");
 421
 422         string prompt;
 423         string type;
 424
 425         if (session->snap_name() == session->name()) {
 426                 type = _("session");
 427         } else {
 428                 type = _("snapshot");
 429         }
 430         prompt = string_compose(_("The %1\"%2\"\nhas not been saved.\n\nAny changes made this time\nwill be lost unless you save it.\n\nWhat do you want to do?"),
 431                          type, session->snap_name());
 432
 433         prompt_label.set_text (prompt);
 434         prompt_label.set_name (X_("PrompterLabel"));
 435         prompt_label.set_alignment(ALIGN_LEFT, ALIGN_TOP);
 436
 437         dimage->set_alignment(ALIGN_CENTER, ALIGN_TOP)
 438 ;
 439         dhbox.set_homogeneous (false);
 440         dhbox.pack_start (*dimage, false, false, 5);
 441         dhbox.pack_start (prompt_label, true, false, 5);
 442         window.get_vbox()->pack_start (dhbox);
 443
 444         window.set_name (_("Prompter"));
 445         window.set_position (Gtk::WIN_POS_MOUSE);
 446         window.set_modal (true);
 447         window.set_resizable (false);
 448         window.show_all ();
 449
 450         save_the_session = 0;
 451
 452         editor->ensure_float (window);
 453
 454         ResponseType r = (ResponseType) window.run();
 455
 456         window.hide ();
 457
 458         switch (r) {
 459         case RESPONSE_ACCEPT: // save and get out of here
 460                 return 1;
 461         case RESPONSE_APPLY:  // get out of here
 462                 return 0;
 463         default:
 464                 break;
 465         }
 466
 467         return -1;
 468 }
 469
 470 gint
 471 ARDOUR_UI::every_second ()
 472 {
 473         update_cpu_load ();
 474         update_buffer_load ();
 475         update_disk_space ();
 476         return TRUE;
 477 }
 478
 479 gint
 480 ARDOUR_UI::every_point_one_seconds ()
 481 {
 482         update_speed_display ();
 483         RapidScreenUpdate(); /* EMIT_SIGNAL */
 484         return TRUE;
 485 }
 486
 487 gint
 488 ARDOUR_UI::every_point_zero_one_seconds ()
 489 {
 490         SuperRapidScreenUpdate(); /* EMIT_SIGNAL */
 491         return TRUE;
 492 }
 493
 494 void
 495 ARDOUR_UI::update_sample_rate (jack_nframes_t ignored)
 496 {
 497         char buf[32];
 498
 499         ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::update_sample_rate), ignored));
 500
 501         if (!engine->connected()) {
 502
 503                 snprintf (buf, sizeof (buf), _("disconnected"));
 504
 505         } else {
 506
 507                 jack_nframes_t rate = engine->frame_rate();
 508
 509                 if (fmod (rate, 1000.0) != 0.0) {
 510                         snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f msecs"),
 511                                   (float) rate/1000.0f,
 512                                   (engine->frames_per_cycle() / (float) rate) * 1000.0f);
 513                 } else {
 514                         snprintf (buf, sizeof (buf), _("%u kHz / %4.1f msecs"),
 515                                   rate/1000,
 516                                   (engine->frames_per_cycle() / (float) rate) * 1000.0f);
 517                 }
 518         }
 519
 520         sample_rate_label.set_text (buf);
 521 }
 522
 523 void
 524 ARDOUR_UI::update_cpu_load ()
 525 {
 526         char buf[32];
 527         snprintf (buf, sizeof (buf), _("DSP: %.1f%%"), engine->get_cpu_load());
 528         cpu_load_label.set_text (buf);
 529 }
 530
 531 void
 532 ARDOUR_UI::update_buffer_load ()
 533 {
 534         char buf[64];
 535
 536         if (session) {
 537                 snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
 538                           session->playback_load(), session->capture_load());
 539                 buffer_load_label.set_text (buf);
 540         } else {
 541                 buffer_load_label.set_text ("");
 542         }
 543 }
 544
 545 void
 546 ARDOUR_UI::count_recenabled_diskstreams (Route& route)
 547 {
 548         Track* track = dynamic_cast<Track*>(&route);
 549         if (track && track->diskstream()->record_enabled()) {
 550                 rec_enabled_diskstreams++;
 551         }
 552 }
 553
 554 void
 555 ARDOUR_UI::update_disk_space()
 556 {
 557         if (session == 0) {
 558                 return;
 559         }
 560
 561         jack_nframes_t frames = session->available_capture_duration();
 562         char buf[64];
 563
 564         if (frames == max_frames) {
 565                 strcpy (buf, _("Disk: 24hrs+"));
 566         } else {
 567                 int hrs;
 568                 int mins;
 569                 int secs;
 570                 jack_nframes_t fr = session->frame_rate();
 571
 572                 if (session->actively_recording()){
 573
 574                         rec_enabled_diskstreams = 0;
 575                         session->foreach_route (this, &ARDOUR_UI::count_recenabled_diskstreams);
 576
 577                         if (rec_enabled_diskstreams) {
 578                                 frames /= rec_enabled_diskstreams;
 579                         }
 580
 581                 } else {
 582
 583                         /* hmmm. shall we divide by the route count? or the diskstream count?
 584                            or what? for now, do nothing ...
 585                         */
 586
 587                 }
 588
 589                 hrs  = frames / (fr * 3600);
 590                 frames -= hrs * fr * 3600;
 591                 mins = frames / (fr * 60);
 592                 frames -= mins * fr * 60;
 593                 secs = frames / fr;
 594
 595                 snprintf (buf, sizeof(buf), _("Disk: %02dh:%02dm:%02ds"), hrs, mins, secs);
 596         }
 597
 598         disk_space_label.set_text (buf);
 599 }
 600
 601 gint
 602 ARDOUR_UI::update_wall_clock ()
 603 {
 604         time_t now;
 605         struct tm *tm_now;
 606         char buf[16];
 607
 608         time (&now);
 609         tm_now = localtime (&now);
 610
 611         sprintf (buf, "%02d:%02d", tm_now->tm_hour, tm_now->tm_min);
 612         wall_clock_label.set_text (buf);
 613
 614         return TRUE;
 615 }
 616 void
 617 ARDOUR_UI::control_methods_adjusted ()
 618
 619 {
 620         int which_method;
 621
 622         which_method = (int) online_control_button->adjustment.get_value();
 623         switch (which_method) {
 624         case 0:
 625                 allow_mmc_and_local ();
 626                 break;
 627         case 1:
 628                 allow_mmc_only ();
 629                 break;
 630         case 2:
 631                 allow_local_only ();
 632                 break;
 633         default:
 634                 fatal << _("programming error: impossible control method") << endmsg;
 635         }
 636 }
 637
 638
 639 void
 640 ARDOUR_UI::mmc_device_id_adjusted ()
 641
 642 {
 643 #if 0
 644         if (mmc) {
 645                 int dev_id = (int) mmc_id_button->adjustment.get_value();
 646                 mmc->set_device_id (dev_id);
 647         }
 648 #endif
 649 }
 650
 651 gint
 652 ARDOUR_UI::session_menu (GdkEventButton *ev)
 653 {
 654         session_popup_menu->popup (0, 0);
 655         return TRUE;
 656 }
 657
 658 void
 659 ARDOUR_UI::redisplay_recent_sessions ()
 660 {
 661         vector<string *> *sessions;
 662         vector<string *>::iterator i;
 663         RecentSessionsSorter cmp;
 664
 665         recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
 666         recent_session_model->clear ();
 667
 668         RecentSessions rs;
 669         ARDOUR::read_recent_sessions (rs);
 670
 671         if (rs.empty()) {
 672                 recent_session_display.set_model (recent_session_model);
 673                 return;
 674         }
 675
 676         /* sort them alphabetically */
 677         sort (rs.begin(), rs.end(), cmp);
 678         sessions = new vector<string*>;
 679
 680         for (RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
 681                 sessions->push_back (new string ((*i).second));
 682         }
 683
 684         for (i = sessions->begin(); i != sessions->end(); ++i) {
 685
 686                 vector<string*>* states;
 687                 vector<const gchar*> item;
 688                 string fullpath = *(*i);
 689
 690                 /* remove any trailing / */
 691
 692                 if (fullpath[fullpath.length()-1] == '/') {
 693                         fullpath = fullpath.substr (0, fullpath.length()-1);
 694                 }
 695
 696                 /* now get available states for this session */
 697
 698                 if ((states = Session::possible_states (fullpath)) == 0) {
 699                         /* no state file? */
 700                         continue;
 701                 }
 702
 703                 TreeModel::Row row = *(recent_session_model->append());
 704
 705                 row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
 706                 row[recent_session_columns.fullpath] = fullpath;
 707
 708                 if (states->size() > 1) {
 709
 710                         /* add the children */
 711
 712                         for (vector<string*>::iterator i2 = states->begin(); i2 != states->end(); ++i2) {
 713
 714                                 TreeModel::Row child_row = *(recent_session_model->append (row.children()));
 715
 716                                 child_row[recent_session_columns.visible_name] = **i2;
 717                                 child_row[recent_session_columns.fullpath] = fullpath;
 718
 719                                 delete *i2;
 720                         }
 721                 }
 722
 723                 delete states;
 724         }
 725
 726         recent_session_display.set_model (recent_session_model);
 727         delete sessions;
 728 }
 729
 730 void
 731 ARDOUR_UI::build_session_selector ()
 732 {
 733         session_selector_window = new ArdourDialog ("session selector");
 734
 735         Gtk::ScrolledWindow *scroller = manage (new Gtk::ScrolledWindow);
 736
 737         session_selector_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
 738         session_selector_window->add_button (Stock::OPEN, RESPONSE_ACCEPT);
 739         session_selector_window->set_default_response (RESPONSE_ACCEPT);
 740         recent_session_model = TreeStore::create (recent_session_columns);
 741         recent_session_display.set_model (recent_session_model);
 742         recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
 743         recent_session_display.set_headers_visible (false);
 744         recent_session_display.get_selection()->set_mode (SELECTION_SINGLE);
 745
 746         recent_session_display.signal_row_activated().connect (mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));
 747
 748         scroller->add (recent_session_display);
 749         scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 750
 751         session_selector_window->set_name ("SessionSelectorWindow");
 752         session_selector_window->set_size_request (200, 400);
 753         session_selector_window->get_vbox()->pack_start (*scroller);
 754         session_selector_window->show_all_children();
 755 }
 756
 757 void
 758 ARDOUR_UI::recent_session_row_activated (const TreePath& path, TreeViewColumn* col)
 759 {
 760         session_selector_window->response (RESPONSE_ACCEPT);
 761 }
 762
 763 void
 764 ARDOUR_UI::open_recent_session ()
 765 {
 766         /* popup selector window */
 767
 768         if (session_selector_window == 0) {
 769                 build_session_selector ();
 770         }
 771
 772         redisplay_recent_sessions ();
 773
 774         ResponseType r = (ResponseType) session_selector_window->run ();
 775
 776         session_selector_window->hide();
 777
 778         switch (r) {
 779         case RESPONSE_ACCEPT:
 780                 break;
 781         default:
 782                 return;
 783         }
 784
 785         Gtk::TreeModel::iterator i = recent_session_display.get_selection()->get_selected();
 786
 787         if (i == recent_session_model->children().end()) {
 788                 return;
 789         }
 790
 791         Glib::ustring path = (*i)[recent_session_columns.fullpath];
 792         Glib::ustring state = (*i)[recent_session_columns.visible_name];
 793
 794         _session_is_new = false;
 795
 796         load_session (path, state);
 797 }
 798
 799 bool
 800 ARDOUR_UI::filter_ardour_session_dirs (const FileFilter::Info& info)
 801 {
 802         struct stat statbuf;
 803
 804         if (stat (info.filename.c_str(), &statbuf) != 0) {
 805                 return false;
 806         }
 807
 808         if (!S_ISDIR(statbuf.st_mode)) {
 809                 return false;
 810         }
 811
 812         // XXX Portability
 813
 814         string session_file = info.filename;
 815         session_file += '/';
 816         session_file += Glib::path_get_basename (info.filename);
 817         session_file += ".ardour";
 818
 819         if (stat (session_file.c_str(), &statbuf) != 0) {
 820                 return false;
 821         }
 822
 823         return S_ISREG (statbuf.st_mode);
 824 }
 825
 826 void
 827 ARDOUR_UI::open_session ()
 828 {
 829         /* popup selector window */
 830
 831         if (open_session_selector == 0) {
 832
 833                 /* ardour sessions are folders */
 834
 835                 open_session_selector = new Gtk::FileChooserDialog (_("open session"), FILE_CHOOSER_ACTION_OPEN);
 836                 open_session_selector->add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 837                 open_session_selector->add_button (Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
 838
 839                 FileFilter session_filter;
 840                 session_filter.add_pattern ("*.ardour");
 841                 session_filter.set_name (_("Ardour sessions"));
 842                 open_session_selector->add_filter (session_filter);
 843                 open_session_selector->set_filter (session_filter);
 844         }
 845
 846         int response = open_session_selector->run();
 847         open_session_selector->hide ();
 848
 849         switch (response) {
 850         case RESPONSE_ACCEPT:
 851                 break;
 852         default:
 853                 open_session_selector->hide();
 854                 return;
 855         }
 856
 857         open_session_selector->hide();
 858         string session_path = open_session_selector->get_filename();
 859         string path, name;
 860         bool isnew;
 861
 862         if (session_path.length() > 0) {
 863                 if (Session::find_session (session_path, path, name, isnew) == 0) {
 864                         _session_is_new = isnew;
 865                         load_session (path, name);
 866                 }
 867         }
 868 }
 869
 870
 871 void
 872 ARDOUR_UI::session_add_midi_route (bool disk, uint32_t how_many)
 873 {
 874         list<boost::shared_ptr<MidiTrack> > tracks;
 875
 876         if (session == 0) {
 877                 warning << _("You cannot add a track without a session already loaded.") << endmsg;
 878                 return;
 879         }
 880
 881         try {
 882                 if (disk) {
 883
 884                         tracks = session->new_midi_track (ARDOUR::Normal, how_many);
 885
 886                         if (tracks.size() != how_many) {
 887                                 if (how_many == 1) {
 888                                         error << _("could not create a new midi track") << endmsg;
 889                                 } else {
 890                                         error << string_compose (_("could not create %1 new midi tracks"), how_many) << endmsg;
 891                                 }
 892                         }
 893                 } /*else {
 894                         if ((route = session->new_midi_route ()) == 0) {
 895                                 error << _("could not create new midi bus") << endmsg;
 896                         }
 897                 }*/
 898         }
 899
 900         catch (...) {
 901                 MessageDialog msg (*editor,
 902                                    _("There are insufficient JACK ports available\n\
 903 to create a new track or bus.\n\
 904 You should save Ardour, exit and\n\
 905 restart JACK with more ports."));
 906                 msg.run ();
 907         }
 908 }
 909
 910
 911 void
 912 ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, uint32_t how_many)
 913 {
 914         list<boost::shared_ptr<AudioTrack> > tracks;
 915         Session::RouteList routes;
 916
 917         if (session == 0) {
 918                 warning << _("You cannot add a track or bus without a session already loaded.") << endmsg;
 919                 return;
 920         }
 921
 922         try {
 923                 if (track) {
 924                         tracks = session->new_audio_track (input_channels, output_channels, mode, how_many);
 925
 926                         if (tracks.size() != how_many) {
 927                                 if (how_many == 1) {
 928                                         error << _("could not create a new audio track") << endmsg;
 929                                 } else {
 930                                         error << string_compose (_("could not create %1 new audio tracks"), how_many) << endmsg;
 931                                 }
 932                         }
 933
 934                 } else {
 935
 936                         routes = session->new_audio_route (input_channels, output_channels, how_many);
 937
 938                         if (routes.size() != how_many) {
 939                                 if (how_many == 1) {
 940                                         error << _("could not create a new audio track") << endmsg;
 941                                 } else {
 942                                         error << string_compose (_("could not create %1 new audio tracks"), how_many) << endmsg;
 943                                 }
 944                         }
 945                 }
 946
 947 #if CONTROLOUTS
 948                 if (need_control_room_outs) {
 949                         pan_t pans[2];
 950
 951                         pans[0] = 0.5;
 952                         pans[1] = 0.5;
 953
 954                         route->set_stereo_control_outs (control_lr_channels);
 955                         route->control_outs()->set_stereo_pan (pans, this);
 956                 }
 957 #endif /* CONTROLOUTS */
 958         }
 959
 960         catch (...) {
 961                 MessageDialog msg (*editor,
 962                                    _("There are insufficient JACK ports available\n\
 963 to create a new track or bus.\n\
 964 You should save Ardour, exit and\n\
 965 restart JACK with more ports."));
 966                 msg.run ();
 967         }
 968 }
 969
 970 void
 971 ARDOUR_UI::do_transport_locate (jack_nframes_t new_position)
 972 {
 973         jack_nframes_t _preroll;
 974
 975         if (session) {
 976                 _preroll = session->convert_to_frames_at (new_position, session->preroll);
 977
 978                 if (new_position > _preroll) {
 979                         new_position -= _preroll;
 980                 } else {
 981                         new_position = 0;
 982                 }
 983
 984                 session->request_locate (new_position);
 985         }
 986 }
 987
 988 void
 989 ARDOUR_UI::transport_goto_start ()
 990 {
 991         if (session) {
 992                 session->goto_start();
 993
 994
 995                 /* force displayed area in editor to start no matter
 996                    what "follow playhead" setting is.
 997                 */
 998
 999                 if (editor) {
1000                         editor->reposition_x_origin (session->current_start_frame());
1001                 }
1002         }
1003 }
1004
1005 void
1006 ARDOUR_UI::transport_goto_zero ()
1007 {
1008         if (session) {
1009                 session->request_locate (0);
1010
1011
1012                 /* force displayed area in editor to start no matter
1013                    what "follow playhead" setting is.
1014                 */
1015
1016                 if (editor) {
1017                         editor->reposition_x_origin (0);
1018                 }
1019         }
1020 }
1021
1022 void
1023 ARDOUR_UI::transport_goto_end ()
1024 {
1025         if (session) {
1026                 jack_nframes_t frame = session->current_end_frame();
1027                 session->request_locate (frame);
1028
1029                 /* force displayed area in editor to start no matter
1030                    what "follow playhead" setting is.
1031                 */
1032
1033                 if (editor) {
1034                         editor->reposition_x_origin (frame);
1035                 }
1036         }
1037 }
1038
1039 void
1040 ARDOUR_UI::transport_stop ()
1041 {
1042         if (!session) {
1043                 return;
1044         }
1045
1046         if (session->is_auditioning()) {
1047                 session->cancel_audition ();
1048                 return;
1049         }
1050
1051         if (session->get_auto_loop()) {
1052                 session->request_auto_loop (false);
1053         }
1054
1055         session->request_stop ();
1056 }
1057
1058 void
1059 ARDOUR_UI::transport_stop_and_forget_capture ()
1060 {
1061         if (session) {
1062                 session->request_stop (true);
1063         }
1064 }
1065
1066 void
1067 ARDOUR_UI::remove_last_capture()
1068 {
1069         if (editor) {
1070                 editor->remove_last_capture();
1071         }
1072 }
1073
1074 void
1075 ARDOUR_UI::transport_record ()
1076 {
1077         if (session) {
1078                 switch (session->record_status()) {
1079                 case Session::Disabled:
1080                         if (session->ntracks() == 0) {
1081                                 string txt = _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu.");
1082                                 MessageDialog msg (*editor, txt);
1083                                 msg.run ();
1084                                 return;
1085                         }
1086                         session->maybe_enable_record ();
1087                         break;
1088                 case Session::Recording:
1089                 case Session::Enabled:
1090                         session->disable_record (true);
1091                 }
1092         }
1093 }
1094
1095 void
1096 ARDOUR_UI::transport_roll ()
1097 {
1098         bool rolling;
1099
1100         if (!session) {
1101                 return;
1102         }
1103
1104         rolling = session->transport_rolling ();
1105
1106         if (session->get_auto_loop()) {
1107                 session->request_auto_loop (false);
1108                 auto_loop_button.set_active (false);
1109                 roll_button.set_active (true);
1110         } else if (session->get_play_range ()) {
1111                 session->request_play_range (false);
1112                 play_selection_button.set_active (false);
1113         } else if (rolling) {
1114                 session->request_locate (session->last_transport_start(), true);
1115         }
1116
1117         session->request_transport_speed (1.0f);
1118 }
1119
1120 void
1121 ARDOUR_UI::transport_loop()
1122 {
1123         if (session) {
1124                 if (session->get_auto_loop()) {
1125                         if (session->transport_rolling()) {
1126                                 Location * looploc = session->locations()->auto_loop_location();
1127                                 if (looploc) {
1128                                         session->request_locate (looploc->start(), true);
1129                                 }
1130                         }
1131                 }
1132                 else {
1133                         session->request_auto_loop (true);
1134                 }
1135         }
1136 }
1137
1138 void
1139 ARDOUR_UI::transport_play_selection ()
1140 {
1141         if (!session) {
1142                 return;
1143         }
1144
1145         if (!session->get_play_range()) {
1146                 session->request_stop ();
1147         }
1148
1149         editor->play_selection ();
1150 }
1151
1152 void
1153 ARDOUR_UI::transport_rewind (int option)
1154 {
1155         float current_transport_speed;
1156
1157         if (session) {
1158                 current_transport_speed = session->transport_speed();
1159
1160                 if (current_transport_speed >= 0.0f) {
1161                         switch (option) {
1162                         case 0:
1163                                 session->request_transport_speed (-1.0f);
1164                                 break;
1165                         case 1:
1166                                 session->request_transport_speed (-4.0f);
1167                                 break;
1168                         case -1:
1169                                 session->request_transport_speed (-0.5f);
1170                                 break;
1171                         }
1172                 } else {
1173                         /* speed up */
1174                         session->request_transport_speed (current_transport_speed * 1.5f);
1175                 }
1176         }
1177 }
1178
1179 void
1180 ARDOUR_UI::transport_forward (int option)
1181 {
1182         float current_transport_speed;
1183
1184         if (session) {
1185                 current_transport_speed = session->transport_speed();
1186
1187                 if (current_transport_speed <= 0.0f) {
1188                         switch (option) {
1189                         case 0:
1190                                 session->request_transport_speed (1.0f);
1191                                 break;
1192                         case 1:
1193                                 session->request_transport_speed (4.0f);
1194                                 break;
1195                         case -1:
1196                                 session->request_transport_speed (0.5f);
1197                                 break;
1198                         }
1199                 } else {
1200                         /* speed up */
1201                         session->request_transport_speed (current_transport_speed * 1.5f);
1202                 }
1203         }
1204 }
1205
1206 void
1207 ARDOUR_UI::toggle_record_enable (uint32_t dstream)
1208 {
1209         if (session == 0) {
1210                 return;
1211         }
1212
1213         boost::shared_ptr<Route> r;
1214
1215         if ((r = session->route_by_remote_id (dstream)) != 0) {
1216
1217                 Track* t;
1218
1219                 if ((t = dynamic_cast<Track*>(r.get())) != 0) {
1220                         t->diskstream()->set_record_enabled (!t->diskstream()->record_enabled());
1221                 }
1222         }
1223         if (session == 0) {
1224                 return;
1225         }
1226 }
1227
1228 void
1229 ARDOUR_UI::queue_transport_change ()
1230 {
1231         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &ARDOUR_UI::map_transport_state));
1232 }
1233
1234 void
1235 ARDOUR_UI::map_transport_state ()
1236 {
1237         float sp = session->transport_speed();
1238
1239         if (sp == 1.0f) {
1240                 transport_rolling ();
1241         } else if (sp < 0.0f) {
1242                 transport_rewinding ();
1243         } else if (sp > 0.0f) {
1244                 transport_forwarding ();
1245         } else {
1246                 transport_stopped ();
1247         }
1248 }
1249
1250 void
1251 ARDOUR_UI::allow_local_only ()
1252 {
1253
1254 }
1255
1256 void
1257 ARDOUR_UI::allow_mmc_only ()
1258 {
1259
1260 }
1261
1262 void
1263 ARDOUR_UI::allow_mmc_and_local ()
1264 {
1265
1266 }
1267
1268 void
1269 ARDOUR_UI::GlobalClickBox::printer (char buf[32], Adjustment &adj, void *arg)
1270 {
1271         snprintf (buf, sizeof(buf), "%s", ((GlobalClickBox *) arg)->strings[
1272                 (int) adj.get_value()].c_str());
1273 }
1274
1275 void
1276 ARDOUR_UI::engine_stopped ()
1277 {
1278         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_stopped));
1279         ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
1280         ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
1281 }
1282
1283
1284 void
1285 ARDOUR_UI::engine_running ()
1286 {
1287         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running));
1288         ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
1289         ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
1290 }
1291
1292 void
1293 ARDOUR_UI::engine_halted ()
1294 {
1295         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_halted));
1296
1297         ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
1298         ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
1299
1300         update_sample_rate (0);
1301
1302         MessageDialog msg (*editor,
1303                            _("\
1304 JACK has either been shutdown or it\n\
1305 disconnected Ardour because Ardour\n\
1306 was not fast enough. You can save the\n\
1307 session and/or try to reconnect to JACK ."));
1308         msg.run ();
1309 }
1310
1311 int32_t
1312 ARDOUR_UI::do_engine_start ()
1313 {
1314         try {
1315                 engine->start();
1316         }
1317
1318         catch (AudioEngine::PortRegistrationFailure& err) {
1319                 engine->stop ();
1320                 error << _("Unable to create all required ports")
1321                       << endmsg;
1322                 unload_session ();
1323                 return -1;
1324         }
1325
1326         catch (...) {
1327                 engine->stop ();
1328                 error << _("Unable to start the session running")
1329                       << endmsg;
1330                 unload_session ();
1331                 return -2;
1332         }
1333
1334         return 0;
1335 }
1336
1337 gint
1338 ARDOUR_UI::start_engine ()
1339 {
1340         if (do_engine_start () == 0) {
1341                 if (session && _session_is_new) {
1342                         /* we need to retain initial visual
1343                            settings for a new session
1344                         */
1345                         session->save_state ("");
1346                 }
1347
1348                 /* there is too much going on, in too many threads, for us to
1349                    end up with a clean session. So wait 1 second after loading,
1350                    and fix it up. its ugly, but until i come across a better
1351                    solution, its what we have.
1352                 */
1353
1354                 Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::make_session_clean), 1000);
1355         }
1356
1357         return FALSE;
1358 }
1359
1360 void
1361 ARDOUR_UI::update_clocks ()
1362 {
1363          Clock (session->audible_frame()); /* EMIT_SIGNAL */
1364 }
1365
1366 void
1367 ARDOUR_UI::start_clocking ()
1368 {
1369         clock_signal_connection = RapidScreenUpdate.connect (mem_fun(*this, &ARDOUR_UI::update_clocks));
1370 }
1371
1372 void
1373 ARDOUR_UI::stop_clocking ()
1374 {
1375         clock_signal_connection.disconnect ();
1376 }
1377
1378 void
1379 ARDOUR_UI::toggle_clocking ()
1380 {
1381 #if 0
1382         if (clock_button.get_active()) {
1383                 start_clocking ();
1384         } else {
1385                 stop_clocking ();
1386         }
1387 #endif
1388 }
1389
1390 gint
1391 ARDOUR_UI::_blink (void *arg)
1392
1393 {
1394         ((ARDOUR_UI *) arg)->blink ();
1395         return TRUE;
1396 }
1397
1398 void
1399 ARDOUR_UI::blink ()
1400 {
1401          Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
1402 }
1403
1404 void
1405 ARDOUR_UI::start_blinking ()
1406 {
1407         /* Start the blink signal. Everybody with a blinking widget
1408            uses Blink to drive the widget's state.
1409         */
1410
1411         if (blink_timeout_tag < 0) {
1412                 blink_on = false;
1413                 blink_timeout_tag = gtk_timeout_add (240, _blink, this);
1414         }
1415 }
1416
1417 void
1418 ARDOUR_UI::stop_blinking ()
1419 {
1420         if (blink_timeout_tag >= 0) {
1421                 gtk_timeout_remove (blink_timeout_tag);
1422                 blink_timeout_tag = -1;
1423         }
1424 }
1425
1426 void
1427 ARDOUR_UI::name_io_setup (AudioEngine& engine,
1428                           string& buf,
1429                           IO& io,
1430                           bool in)
1431 {
1432         if (in) {
1433                 if (io.n_inputs().get_total() == 0) {
1434                         buf = _("none");
1435                         return;
1436                 }
1437
1438                 /* XXX we're not handling multiple ports yet. */
1439
1440                 const char **connections = io.input(0)->get_connections();
1441
1442                 if (connections == 0 || connections[0] == '\0') {
1443                         buf = _("off");
1444                 } else {
1445                         buf = connections[0];
1446                 }
1447
1448                 free (connections);
1449
1450         } else {
1451
1452                 if (io.n_outputs().get_total() == 0) {
1453                         buf = _("none");
1454                         return;
1455                 }
1456
1457                 /* XXX we're not handling multiple ports yet. */
1458
1459                 const char **connections = io.output(0)->get_connections();
1460
1461                 if (connections == 0 || connections[0] == '\0') {
1462                         buf = _("off");
1463                 } else {
1464                         buf = connections[0];
1465                 }
1466
1467                 free (connections);
1468         }
1469 }
1470
1471 void
1472 ARDOUR_UI::snapshot_session ()
1473 {
1474         ArdourPrompter prompter (true);
1475         string snapname;
1476         string now;
1477         time_t n;
1478
1479         time (&n);
1480         now = ctime (&n);
1481         now = now.substr (20, 4) + now.substr (3, 16) + " (" + now.substr (0, 3) + ")";
1482
1483         prompter.set_name ("Prompter");
1484         prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
1485         prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1486         prompter.set_prompt (_("Name of New Snapshot"));
1487         prompter.set_initial_text (now);
1488
1489         switch (prompter.run()) {
1490         case RESPONSE_ACCEPT:
1491                 prompter.get_result (snapname);
1492                 if (snapname.length()){
1493                         save_state (snapname);
1494                 }
1495                 break;
1496
1497         default:
1498                 break;
1499         }
1500 }
1501
1502 void
1503 ARDOUR_UI::save_state (const string & name)
1504 {
1505         (void) save_state_canfail (name);
1506 }
1507
1508 int
1509 ARDOUR_UI::save_state_canfail (string name)
1510 {
1511         if (session) {
1512                 int ret;
1513
1514                 if (name.length() == 0) {
1515                         name = session->snap_name();
1516                 }
1517
1518                 if ((ret = session->save_state (name)) != 0) {
1519                         return ret;
1520                 }
1521         }
1522         save_ardour_state (); /* XXX cannot fail? yeah, right ... */
1523         return 0;
1524 }
1525
1526 void
1527 ARDOUR_UI::restore_state (string name)
1528 {
1529         if (session) {
1530                 if (name.length() == 0) {
1531                         name = session->name();
1532                 }
1533                 session->restore_state (name);
1534         }
1535 }
1536
1537 void
1538 ARDOUR_UI::primary_clock_value_changed ()
1539 {
1540         if (session) {
1541                 session->request_locate (primary_clock.current_time ());
1542         }
1543 }
1544
1545 void
1546 ARDOUR_UI::secondary_clock_value_changed ()
1547 {
1548         if (session) {
1549                 session->request_locate (secondary_clock.current_time ());
1550         }
1551 }
1552
1553 void
1554 ARDOUR_UI::rec_enable_button_blink (bool onoff, AudioDiskstream *dstream, Widget *w)
1555 {
1556         if (session && dstream && dstream->record_enabled()) {
1557
1558                 Session::RecordState rs;
1559
1560                 rs = session->record_status ();
1561
1562                 switch (rs) {
1563                 case Session::Disabled:
1564                 case Session::Enabled:
1565                         if (w->get_state() != STATE_SELECTED) {
1566                                 w->set_state (STATE_SELECTED);
1567                         }
1568                         break;
1569
1570                 case Session::Recording:
1571                         if (w->get_state() != STATE_ACTIVE) {
1572                                 w->set_state (STATE_ACTIVE);
1573                         }
1574                         break;
1575                 }
1576
1577         } else {
1578                 if (w->get_state() != STATE_NORMAL) {
1579                         w->set_state (STATE_NORMAL);
1580                 }
1581         }
1582 }
1583
1584 void
1585 ARDOUR_UI::transport_rec_enable_blink (bool onoff)
1586 {
1587         if (session == 0) {
1588                 return;
1589         }
1590
1591         switch (session->record_status()) {
1592         case Session::Enabled:
1593                 if (onoff) {
1594                         rec_button.set_state (1);
1595                 } else {
1596                         rec_button.set_state (0);
1597                 }
1598                 break;
1599
1600         case Session::Recording:
1601                 rec_button.set_state (2);
1602                 break;
1603
1604         default:
1605                 rec_button.set_state (0);
1606                 break;
1607         }
1608 }
1609
1610 gint
1611 ARDOUR_UI::hide_and_quit (GdkEventAny *ev, ArdourDialog *window)
1612 {
1613         window->hide();
1614         Gtk::Main::quit ();
1615         return TRUE;
1616 }
1617
1618 void
1619 ARDOUR_UI::start_keyboard_prefix ()
1620 {
1621         keyboard->start_prefix();
1622 }
1623
1624 void
1625 ARDOUR_UI::save_template ()
1626
1627 {
1628         ArdourPrompter prompter (true);
1629         string name;
1630
1631         prompter.set_name (X_("Prompter"));
1632         prompter.set_prompt (_("Name for mix template:"));
1633         prompter.set_initial_text(session->name() + _("-template"));
1634         prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
1635         prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1636
1637         switch (prompter.run()) {
1638         case RESPONSE_ACCEPT:
1639                 prompter.get_result (name);
1640
1641                 if (name.length()) {
1642                         session->save_template (name);
1643                 }
1644                 break;
1645
1646         default:
1647                 break;
1648         }
1649 }
1650
1651 void
1652 ARDOUR_UI::new_session (bool startup, std::string predetermined_path)
1653 {
1654         m_new_session_dialog->show();
1655         m_new_session_dialog->set_modal(true);
1656         m_new_session_dialog->set_name(predetermined_path);
1657         m_new_session_dialog->reset_recent();
1658
1659         int response = Gtk::RESPONSE_CANCEL;
1660
1661         do {
1662                 response = m_new_session_dialog->run ();
1663                 if(response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
1664                   quit();
1665                   return;
1666
1667                 } else if (response == Gtk::RESPONSE_NONE) {
1668                   /* Clear was pressed */
1669                   m_new_session_dialog->reset();
1670
1671                 } else if (response == Gtk::RESPONSE_YES) {
1672                   /* YES  == OPEN, but there's no enum for that */
1673                   std::string session_name = m_new_session_dialog->session_name();
1674                   std::string session_path = m_new_session_dialog->session_folder();
1675                   load_session (session_path, session_name);
1676
1677
1678                 } else if (response == Gtk::RESPONSE_OK) {
1679                   if (m_new_session_dialog->get_current_page() == 1) {
1680
1681                     /* XXX this is a bit of a hack..
1682                        i really want the new sesion dialog to return RESPONSE_YES
1683                        if we're on page 1 (the load page)
1684                        Unfortunately i can't see how atm..
1685                     */
1686                         std::string session_name = m_new_session_dialog->session_name();
1687                         std::string session_path = m_new_session_dialog->session_folder();
1688                         load_session (session_path, session_name);
1689
1690                   } else {
1691
1692                         _session_is_new = true;
1693
1694                         std::string session_name = m_new_session_dialog->session_name();
1695                         std::string session_path = m_new_session_dialog->session_folder();
1696
1697
1698                           //XXX This is needed because session constructor wants a
1699                           //non-existant path. hopefully this will be fixed at some point.
1700
1701                         session_path = Glib::build_filename(session_path, session_name);
1702
1703                         std::string template_name = m_new_session_dialog->session_template_name();
1704
1705                         if (m_new_session_dialog->use_session_template()) {
1706
1707                                 load_session (session_path, session_name, &template_name);
1708
1709                         } else {
1710
1711                                 uint32_t cchns;
1712                                 uint32_t mchns;
1713                                 Session::AutoConnectOption iconnect;
1714                                 Session::AutoConnectOption oconnect;
1715
1716                                 if (m_new_session_dialog->create_control_bus()) {
1717                                         cchns = (uint32_t) m_new_session_dialog->control_channel_count();
1718                                 } else {
1719                                         cchns = 0;
1720                                 }
1721
1722                                 if (m_new_session_dialog->create_master_bus()) {
1723                                         mchns = (uint32_t) m_new_session_dialog->master_channel_count();
1724                                 } else {
1725                                         mchns = 0;
1726                                 }
1727
1728                                 if (m_new_session_dialog->connect_inputs()) {
1729                                         iconnect = Session::AutoConnectPhysical;
1730                                 } else {
1731                                         iconnect = Session::AutoConnectOption (0);
1732                                 }
1733
1734                                 /// @todo some minor tweaks.
1735
1736                                 if (m_new_session_dialog->connect_outs_to_master()) {
1737                                         oconnect = Session::AutoConnectMaster;
1738                                 } else if (m_new_session_dialog->connect_outs_to_physical()) {
1739                                         oconnect = Session::AutoConnectPhysical;
1740                                 } else {
1741                                         oconnect = Session::AutoConnectOption (0);
1742                                 }
1743
1744                                 uint32_t nphysin = (uint32_t) m_new_session_dialog->input_limit_count();
1745                                 uint32_t nphysout = (uint32_t) m_new_session_dialog->output_limit_count();
1746
1747                                 build_session (session_path,
1748                                                session_name,
1749                                                cchns,
1750                                                mchns,
1751                                                iconnect,
1752                                                oconnect,
1753                                                nphysin,
1754                                                nphysout,
1755                                                engine->frame_rate() * 60 * 5);
1756                         }
1757                   }
1758                 }
1759
1760         } while (response == Gtk::RESPONSE_NONE);
1761         m_new_session_dialog->hide();
1762         show();
1763
1764 }
1765
1766 void
1767 ARDOUR_UI::close_session()
1768 {
1769   unload_session();
1770   new_session ();
1771 }
1772
1773 int
1774 ARDOUR_UI::load_session (const string & path, const string & snap_name, string* mix_template)
1775 {
1776         Session *new_session;
1777         int x;
1778         session_loaded = false;
1779         x = unload_session ();
1780
1781         if (x < 0) {
1782                 return -1;
1783         } else if (x > 0) {
1784                 return 0;
1785         }
1786
1787         /* if it already exists, we must have write access */
1788
1789         if (::access (path.c_str(), F_OK) == 0 && ::access (path.c_str(), W_OK)) {
1790                 MessageDialog msg (*editor, _("\
1791 You do not have write access to this session.\n\
1792 This prevents the session from being loaded."));
1793                 msg.run ();
1794                 return -1;
1795         }
1796
1797         try {
1798                 new_session = new Session (*engine, path, snap_name, mix_template);
1799         }
1800
1801         catch (...) {
1802
1803                 error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
1804                 return -1;
1805         }
1806
1807         connect_to_session (new_session);
1808
1809         //if (engine->running()) {
1810         //mixer->show_window();
1811         //}
1812         session_loaded = true;
1813         return 0;
1814 }
1815
1816 int
1817 ARDOUR_UI::make_session_clean ()
1818 {
1819         if (session) {
1820                 session->set_clean ();
1821         }
1822
1823         show ();
1824
1825         return FALSE;
1826 }
1827
1828 int
1829 ARDOUR_UI::build_session (const string & path, const string & snap_name,
1830                           uint32_t control_channels,
1831                           uint32_t master_channels,
1832                           Session::AutoConnectOption input_connect,
1833                           Session::AutoConnectOption output_connect,
1834                           uint32_t nphysin,
1835                           uint32_t nphysout,
1836                           jack_nframes_t initial_length)
1837 {
1838         Session *new_session;
1839         int x;
1840
1841         session_loaded = false;
1842         x = unload_session ();
1843         if (x < 0) {
1844                 return -1;
1845         } else if (x > 0) {
1846                 return 0;
1847         }
1848
1849         _session_is_new = true;
1850
1851         try {
1852                 new_session = new Session (*engine, path, snap_name, input_connect, output_connect,
1853                                            control_channels, master_channels, nphysin, nphysout, initial_length);
1854         }
1855
1856         catch (...) {
1857
1858                 error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
1859                 return -1;
1860         }
1861
1862         connect_to_session (new_session);
1863
1864         //if (engine->running()) {
1865         //mixer->show_window();
1866         //}
1867         session_loaded = true;
1868         return 0;
1869 }
1870
1871 void
1872 ARDOUR_UI::show ()
1873 {
1874         if (editor) {
1875                 editor->show_window ();
1876                 shown_flag = true;
1877         }
1878
1879         if (session && mixer) {
1880                 // mixer->show_window ();
1881         }
1882
1883         if (about) {
1884                 about->present ();
1885         }
1886 }
1887
1888 void
1889 ARDOUR_UI::show_splash ()
1890 {
1891         if (about == 0) {
1892                 about = new About();
1893         }
1894         about->present();
1895 }
1896
1897 void
1898 ARDOUR_UI::hide_splash ()
1899 {
1900         if (about) {
1901                 // about->hide();
1902         }
1903 }
1904
1905 void
1906 ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title, const string & msg)
1907 {
1908         size_t removed;
1909
1910         removed = rep.paths.size();
1911
1912         if (removed == 0) {
1913                 MessageDialog msgd (*editor,
1914                                     _("No audio files were ready for cleanup"),
1915                                     true,
1916                                     Gtk::MESSAGE_INFO,
1917                                     (Gtk::ButtonsType)(Gtk::BUTTONS_CLOSE)  );
1918                 msgd.set_secondary_text (_("If this seems suprising, \n\
1919 check for any existing snapshots.\n\
1920 These may still include regions that\n\
1921 require some unused files to continue to exist."));
1922
1923                 msgd.run ();
1924                 return;
1925         }
1926
1927         ArdourDialog results (_("ardour: cleanup"), true, false);
1928
1929         struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
1930             CleanupResultsModelColumns() {
1931                     add (visible_name);
1932                     add (fullpath);
1933             }
1934             Gtk::TreeModelColumn<Glib::ustring> visible_name;
1935             Gtk::TreeModelColumn<Glib::ustring> fullpath;
1936         };
1937
1938
1939         CleanupResultsModelColumns results_columns;
1940         Glib::RefPtr<Gtk::ListStore> results_model;
1941         Gtk::TreeView results_display;
1942
1943         results_model = ListStore::create (results_columns);
1944         results_display.set_model (results_model);
1945         results_display.append_column (list_title, results_columns.visible_name);
1946
1947         results_display.set_name ("CleanupResultsList");
1948         results_display.set_headers_visible (true);
1949         results_display.set_headers_clickable (false);
1950         results_display.set_reorderable (false);
1951
1952         Gtk::ScrolledWindow list_scroller;
1953         Gtk::Label txt;
1954         Gtk::VBox dvbox;
1955         Gtk::HBox dhbox;  // the hbox for the image and text
1956         Gtk::HBox ddhbox; // the hbox we eventually pack into the dialog's vbox
1957         Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_INFO,  Gtk::ICON_SIZE_DIALOG));
1958
1959         dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
1960
1961         if (rep.space < 1048576.0f) {
1962                 if (removed > 1) {
1963                   txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
1964                 } else {
1965                         txt.set_text (string_compose (msg, removed, _("file was"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
1966                 }
1967         } else {
1968                 if (removed > 1) {
1969                         txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
1970                 } else {
1971                         txt.set_text (string_compose (msg, removed, _("file was"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
1972                 }
1973         }
1974
1975         dhbox.pack_start (*dimage, true, false, 5);
1976         dhbox.pack_start (txt, true, false, 5);
1977
1978         for (vector<string>::iterator i = rep.paths.begin(); i != rep.paths.end(); ++i) {
1979                 TreeModel::Row row = *(results_model->append());
1980                 row[results_columns.visible_name] = *i;
1981                 row[results_columns.fullpath] = *i;
1982         }
1983
1984         list_scroller.add (results_display);
1985         list_scroller.set_size_request (-1, 150);
1986         list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1987
1988         dvbox.pack_start (dhbox, true, false, 5);
1989         dvbox.pack_start (list_scroller, true, false, 5);
1990         ddhbox.pack_start (dvbox, true, false, 5);
1991
1992         results.get_vbox()->pack_start (ddhbox, true, false, 5);
1993         results.add_button (Stock::CLOSE, RESPONSE_CLOSE);
1994         results.set_default_response (RESPONSE_CLOSE);
1995         results.set_position (Gtk::WIN_POS_MOUSE);
1996         results.show_all_children ();
1997         results.set_resizable (false);
1998
1999         results.run ();
2000
2001 }
2002
2003 void
2004 ARDOUR_UI::cleanup ()
2005 {
2006         if (session == 0) {
2007                 /* shouldn't happen: menu item is insensitive */
2008                 return;
2009         }
2010
2011
2012         MessageDialog  checker (_("Are you sure you want to cleanup?"),
2013                                 true,
2014                                 Gtk::MESSAGE_QUESTION,
2015                                 (Gtk::ButtonsType)(Gtk::BUTTONS_NONE));
2016
2017         checker.set_secondary_text(_("Cleanup is a destructive operation.\n\
2018 ALL undo/redo information will be lost if you cleanup.\n\
2019 After cleanup, unused audio files will be moved to a \
2020 \"dead sounds\" location."));
2021
2022         checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
2023         checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
2024         checker.set_default_response (RESPONSE_CANCEL);
2025
2026         checker.set_name (_("CleanupDialog"));
2027         checker.set_wmclass (_("ardour_cleanup"), "Ardour");
2028         checker.set_position (Gtk::WIN_POS_MOUSE);
2029
2030         switch (checker.run()) {
2031         case RESPONSE_ACCEPT:
2032                 break;
2033         default:
2034                 return;
2035         }
2036
2037         Session::cleanup_report rep;
2038
2039         editor->prepare_for_cleanup ();
2040
2041         if (session->cleanup_sources (rep)) {
2042                 return;
2043         }
2044         checker.hide();
2045         display_cleanup_results (rep,
2046                                  _("cleaned files"),
2047                                  _("\
2048 The following %1 %2 not in use and \n\
2049 have been moved to:\n\
2050 %3. \n\n\
2051 Flushing the wastebasket will \n\
2052 release an additional\n\
2053 %4 %5bytes of disk space.\n"
2054                                          ));
2055 }
2056
2057 void
2058 ARDOUR_UI::flush_trash ()
2059 {
2060         if (session == 0) {
2061                 /* shouldn't happen: menu item is insensitive */
2062                 return;
2063         }
2064
2065         Session::cleanup_report rep;
2066
2067         if (session->cleanup_trash_sources (rep)) {
2068                 return;
2069         }
2070
2071         display_cleanup_results (rep,
2072                                  _("deleted file"),
2073                                  _("The following %1 %2 deleted from\n\
2074 %3,\n\
2075 releasing %4 %5bytes of disk space"));
2076 }
2077
2078 void
2079 ARDOUR_UI::add_route ()
2080 {
2081         int count;
2082
2083         if (!session) {
2084                 return;
2085         }
2086
2087         if (add_route_dialog == 0) {
2088                 add_route_dialog = new AddRouteDialog;
2089                 editor->ensure_float (*add_route_dialog);
2090         }
2091
2092         if (add_route_dialog->is_visible()) {
2093                 /* we're already doing this */
2094                 return;
2095         }
2096
2097         ResponseType r = (ResponseType) add_route_dialog->run ();
2098
2099         add_route_dialog->hide();
2100
2101         switch (r) {
2102                 case RESPONSE_ACCEPT:
2103                         break;
2104                 default:
2105                         return;
2106                         break;
2107         }
2108
2109         if ((count = add_route_dialog->count()) <= 0) {
2110                 return;
2111         }
2112
2113         uint32_t input_chan = add_route_dialog->channels ();
2114         uint32_t output_chan;
2115         string name_template = add_route_dialog->name_template ();
2116         bool track = add_route_dialog->track ();
2117
2118         Session::AutoConnectOption oac = session->get_output_auto_connect();
2119
2120         if (oac & Session::AutoConnectMaster) {
2121                 output_chan = (session->master_out() ? session->master_out()->n_inputs().get(DataType::AUDIO) : input_chan);
2122         } else {
2123                 output_chan = input_chan;
2124         }
2125
2126         /* XXX do something with name template */
2127
2128         if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
2129                 if (track) {
2130                         session_add_midi_track(count);
2131                 } else  {
2132                         MessageDialog msg (*editor,
2133                                         _("Sorry, MIDI Busses are not supported at this time."));
2134                         msg.run ();
2135                         //session_add_midi_bus();
2136                 }
2137         } else {
2138                 if (track) {
2139                         session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), count);
2140                 } else {
2141                         session_add_audio_bus (input_chan, output_chan, count);
2142                 }
2143         }
2144 }
2145
2146 XMLNode*
2147 ARDOUR_UI::mixer_settings () const
2148 {
2149         XMLNode* node = 0;
2150
2151         if (session) {
2152                 node = session->instant_xml(X_("Mixer"), session->path());
2153         } else {
2154                 node = Config->instant_xml(X_("Mixer"), get_user_ardour_path());
2155         }
2156
2157         if (!node) {
2158                 node = new XMLNode (X_("Mixer"));
2159         }
2160
2161         return node;
2162 }
2163
2164 XMLNode*
2165 ARDOUR_UI::editor_settings () const
2166 {
2167         XMLNode* node = 0;
2168
2169         if (session) {
2170                 node = session->instant_xml(X_("Editor"), session->path());
2171         } else {
2172                 node = Config->instant_xml(X_("Editor"), get_user_ardour_path());
2173         }
2174
2175         if (!node) {
2176                 node = new XMLNode (X_("Editor"));
2177         }
2178         return node;
2179 }
2180
2181 XMLNode*
2182 ARDOUR_UI::keyboard_settings () const
2183 {
2184         XMLNode* node = 0;
2185
2186         node = Config->extra_xml(X_("Keyboard"));
2187
2188         if (!node) {
2189                 node = new XMLNode (X_("Keyboard"));
2190         }
2191         return node;
2192 }
2193
2194 void
2195 ARDOUR_UI::halt_on_xrun_message ()
2196 {
2197         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::halt_on_xrun_message));
2198
2199         MessageDialog msg (*editor,
2200                            _("Recording was stopped because your system could not keep up."));
2201         msg.run ();
2202 }
2203
2204 void
2205 ARDOUR_UI::delete_sources_in_the_right_thread (list<ARDOUR::Source*>* deletion_list)
2206 {
2207         ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread), deletion_list));
2208
2209         for (list<Source*>::iterator i = deletion_list->begin(); i != deletion_list->end(); ++i) {
2210                 delete *i;
2211         }
2212
2213         delete deletion_list;
2214 }
2215
2216 void
2217 ARDOUR_UI::disk_overrun_handler ()
2218 {
2219         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
2220
2221         if (!have_disk_overrun_displayed) {
2222                 have_disk_overrun_displayed = true;
2223                 MessageDialog msg (*editor, X_("diskrate dialog"), _("\
2224 The disk system on your computer\n\
2225 was not able to keep up with Ardour.\n\
2226 \n\
2227 Specifically, it failed to write data to disk\n\
2228 quickly enough to keep up with recording.\n"));
2229                 msg.run ();
2230                 have_disk_overrun_displayed = false;
2231         }
2232 }
2233
2234 void
2235 ARDOUR_UI::disk_underrun_handler ()
2236 {
2237         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
2238
2239         if (!have_disk_underrun_displayed) {
2240                 have_disk_underrun_displayed = true;
2241                 MessageDialog msg (*editor,
2242                         (_("The disk system on your computer\n\
2243 was not able to keep up with Ardour.\n\
2244 \n\
2245 Specifically, it failed to read data from disk\n\
2246 quickly enough to keep up with playback.\n")));
2247                 msg.run ();
2248                 have_disk_underrun_displayed = false;
2249         }
2250 }
2251
2252 void
2253 ARDOUR_UI::disk_underrun_message_gone ()
2254 {
2255         have_disk_underrun_displayed = false;
2256 }
2257
2258 void
2259 ARDOUR_UI::disk_overrun_message_gone ()
2260 {
2261         have_disk_underrun_displayed = false;
2262 }
2263
2264 int
2265 ARDOUR_UI::pending_state_dialog ()
2266 {
2267         ArdourDialog dialog ("pending state dialog");
2268         Label  message (_("\
2269 This session appears to have been in\n\
2270 middle of recording when ardour or\n\
2271 the computer was shutdown.\n\
2272 \n\
2273 Ardour can recover any captured audio for\n\
2274 you, or it can ignore it. Please decide\n\
2275 what you would like to do.\n"));
2276
2277         dialog.get_vbox()->pack_start (message);
2278         dialog.add_button (_("Recover from crash"), RESPONSE_ACCEPT);
2279         dialog.add_button (_("Ignore crash data"), RESPONSE_REJECT);
2280
2281         dialog.set_position (WIN_POS_CENTER);
2282         dialog.show_all ();
2283
2284         switch (dialog.run ()) {
2285         case RESPONSE_ACCEPT:
2286                 return 1;
2287         default:
2288                 return 0;
2289         }
2290 }
2291
2292 void
2293 ARDOUR_UI::disconnect_from_jack ()
2294 {
2295         if (engine) {
2296                 if( engine->disconnect_from_jack ()) {
2297                         MessageDialog msg (*editor, _("Could not disconnect from JACK"));
2298                         msg.run ();
2299                 }
2300
2301                 update_sample_rate (0);
2302         }
2303 }
2304
2305 void
2306 ARDOUR_UI::reconnect_to_jack ()
2307 {
2308         if (engine) {
2309                 if (engine->reconnect_to_jack ()) {
2310                         MessageDialog msg (*editor,  _("Could not reconnect to JACK"));
2311                         msg.run ();
2312                 }
2313
2314                 update_sample_rate (0);
2315         }
2316 }
2317
2318 void
2319 ARDOUR_UI::set_jack_buffer_size (jack_nframes_t nframes)
2320 {
2321         engine->request_buffer_size (nframes);
2322         update_sample_rate (0);
2323 }
2324
2325 int
2326 ARDOUR_UI::cmdline_new_session (string path)
2327 {
2328         if (path[0] != '/') {
2329                 char buf[PATH_MAX+1];
2330                 string str;
2331
2332                 getcwd (buf, sizeof (buf));
2333                 str = buf;
2334                 str += '/';
2335                 str += path;
2336                 path = str;
2337         }
2338
2339         new_session (false, path);
2340
2341         _will_create_new_session_automatically = false; /* done it */
2342         return FALSE; /* don't call it again */
2343 }
2344
2345 void
2346 ARDOUR_UI::set_native_file_header_format (HeaderFormat hf)
2347 {
2348         Glib::RefPtr<Action> act;
2349
2350         switch (hf) {
2351         case BWF:
2352                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
2353                 break;
2354         case WAVE:
2355                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
2356                 break;
2357         case WAVE64:
2358                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
2359                 break;
2360         case iXML:
2361                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
2362                 break;
2363         case RF64:
2364                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
2365                 break;
2366         case CAF:
2367                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
2368                 break;
2369         case AIFF:
2370                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
2371                 break;
2372         }
2373
2374         if (act) {
2375                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2376                 if (ract && ract->get_active() && Config->get_native_file_header_format() != hf) {
2377                         Config->set_native_file_header_format (hf);
2378                         if (session) {
2379                                 session->reset_native_file_format ();
2380                         }
2381                 }
2382         }
2383 }
2384
2385 void
2386 ARDOUR_UI::set_native_file_data_format (SampleFormat sf)
2387 {
2388         Glib::RefPtr<Action> act;
2389
2390         switch (sf) {
2391         case FormatFloat:
2392                 act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
2393                 break;
2394         case FormatInt24:
2395                 act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
2396                 break;
2397         }
2398
2399         if (act) {
2400                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2401
2402                 if (ract && ract->get_active() && Config->get_native_file_data_format() != sf) {
2403                         Config->set_native_file_data_format (sf);
2404                         if (session) {
2405                                 session->reset_native_file_format ();
2406                         }
2407                 }
2408         }
2409 }
2410
2411 void
2412 ARDOUR_UI::use_config ()
2413 {
2414         Glib::RefPtr<Action> act;
2415
2416         switch (Config->get_native_file_data_format ()) {
2417         case FormatFloat:
2418                 act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
2419                 break;
2420         case FormatInt24:
2421                 act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
2422                 break;
2423         }
2424
2425         if (act) {
2426                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2427                 ract->set_active ();
2428         }
2429
2430         switch (Config->get_native_file_header_format ()) {
2431         case BWF:
2432                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
2433                 break;
2434         case WAVE:
2435                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
2436                 break;
2437         case WAVE64:
2438                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
2439                 break;
2440         case iXML:
2441                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
2442                 break;
2443         case RF64:
2444                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
2445                 break;
2446         case CAF:
2447                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
2448                 break;
2449         case AIFF:
2450                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
2451                 break;
2452         }
2453
2454         if (act) {
2455                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2456                 ract->set_active ();
2457         }
2458 }