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         /* load colors */
 141
 142         color_manager = new ColorManager();
 143
 144         std::string color_file = ARDOUR::find_config_file("ardour.colors");
 145
 146         color_manager->load (color_file);
 147
 148         editor = 0;
 149         mixer = 0;
 150         session = 0;
 151         _session_is_new = false;
 152         big_clock_window = 0;
 153         session_selector_window = 0;
 154         last_key_press_time = 0;
 155         connection_editor = 0;
 156         add_route_dialog = 0;
 157         route_params = 0;
 158         option_editor = 0;
 159         location_ui = 0;
 160         sfdb = 0;
 161         open_session_selector = 0;
 162         have_configure_timeout = false;
 163         have_disk_overrun_displayed = false;
 164         have_disk_underrun_displayed = false;
 165         _will_create_new_session_automatically = false;
 166         session_loaded = false;
 167         last_speed_displayed = -1.0f;
 168
 169         last_configure_time.tv_sec = 0;
 170         last_configure_time.tv_usec = 0;
 171
 172         shuttle_grabbed = false;
 173         shuttle_fract = 0.0;
 174         shuttle_max_speed = 8.0f;
 175
 176         set_shuttle_units (Percentage);
 177         set_shuttle_behaviour (Sprung);
 178
 179         shuttle_style_menu = 0;
 180         shuttle_unit_menu = 0;
 181
 182         gettimeofday (&last_peak_grab, 0);
 183         gettimeofday (&last_shuttle_request, 0);
 184
 185         ARDOUR::AudioDiskstream::DeleteSources.connect (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread));
 186         ARDOUR::Diskstream::DiskOverrun.connect (mem_fun(*this, &ARDOUR_UI::disk_overrun_handler));
 187         ARDOUR::Diskstream::DiskUnderrun.connect (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
 188
 189         /* handle pending state with a dialog */
 190
 191         ARDOUR::Session::AskAboutPendingState.connect (mem_fun(*this, &ARDOUR_UI::pending_state_dialog));
 192
 193         /* have to wait for AudioEngine and Configuration before proceeding */
 194 }
 195
 196 void
 197 ARDOUR_UI::set_engine (AudioEngine& e)
 198 {
 199         engine = &e;
 200
 201         engine->Stopped.connect (mem_fun(*this, &ARDOUR_UI::engine_stopped));
 202         engine->Running.connect (mem_fun(*this, &ARDOUR_UI::engine_running));
 203         engine->Halted.connect (mem_fun(*this, &ARDOUR_UI::engine_halted));
 204         engine->SampleRateChanged.connect (mem_fun(*this, &ARDOUR_UI::update_sample_rate));
 205
 206         ActionManager::init ();
 207         new_session_dialog = new NewSessionDialog();
 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 = g_timeout_add (240, _blink, this);
1414         }
1415 }
1416
1417 void
1418 ARDOUR_UI::stop_blinking ()
1419 {
1420         if (blink_timeout_tag >= 0) {
1421                 g_source_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         int response = Gtk::RESPONSE_NONE;
1655
1656         new_session_dialog->set_modal(true);
1657         new_session_dialog->set_name(predetermined_path);
1658         new_session_dialog->reset_recent();
1659         new_session_dialog->show();
1660
1661         //Glib::RefPtr<Gdk::Window> nsd_window = new_session_dialog->get_window();
1662
1663         do {
1664                 response = new_session_dialog->run ();
1665                 //nsd_window ->set_cursor(Gdk::Cursor(Gdk::WATCH));
1666                 if(response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
1667                         quit();
1668                         return;
1669
1670                 } else if (response == Gtk::RESPONSE_NONE) {
1671                         /* Clear was pressed */
1672                         new_session_dialog->reset();
1673
1674                 } else if (response == Gtk::RESPONSE_YES) {
1675                         /* YES  == OPEN, but there's no enum for that */
1676
1677                         std::string session_name = new_session_dialog->session_name();
1678                         std::string session_path = new_session_dialog->session_folder();
1679                         load_session (session_path, session_name);
1680
1681
1682                 } else if (response == Gtk::RESPONSE_OK) {
1683                         if (new_session_dialog->get_current_page() == 1) {
1684
1685                                 /* XXX this is a bit of a hack..
1686                                    i really want the new sesion dialog to return RESPONSE_YES
1687                                    if we're on page 1 (the load page)
1688                                    Unfortunately i can't see how atm..
1689                                 */
1690
1691                                 std::string session_name = new_session_dialog->session_name();
1692                                 std::string session_path = new_session_dialog->session_folder();
1693                                 load_session (session_path, session_name);
1694
1695                         } else {
1696
1697                                 _session_is_new = true;
1698
1699                                 std::string session_name = new_session_dialog->session_name();
1700                                 std::string session_path = new_session_dialog->session_folder();
1701
1702
1703                                 //XXX This is needed because session constructor wants a
1704                                 //non-existant path. hopefully this will be fixed at some point.
1705
1706                                 session_path = Glib::build_filename(session_path, session_name);
1707
1708                                 std::string template_name = new_session_dialog->session_template_name();
1709
1710                                 if (new_session_dialog->use_session_template()) {
1711
1712                                         load_session (session_path, session_name, &template_name);
1713
1714                                 } else {
1715
1716                                         uint32_t cchns;
1717                                         uint32_t mchns;
1718                                         Session::AutoConnectOption iconnect;
1719                                         Session::AutoConnectOption oconnect;
1720
1721                                         if (new_session_dialog->create_control_bus()) {
1722                                                 cchns = (uint32_t) new_session_dialog->control_channel_count();
1723                                         } else {
1724                                                 cchns = 0;
1725                                         }
1726
1727                                         if (new_session_dialog->create_master_bus()) {
1728                                                 mchns = (uint32_t) new_session_dialog->master_channel_count();
1729                                         } else {
1730                                                 mchns = 0;
1731                                         }
1732
1733                                         if (new_session_dialog->connect_inputs()) {
1734                                                 iconnect = Session::AutoConnectPhysical;
1735                                         } else {
1736                                                 iconnect = Session::AutoConnectOption (0);
1737                                         }
1738
1739                                         /// @todo some minor tweaks.
1740
1741                                         if (new_session_dialog->connect_outs_to_master()) {
1742                                                 oconnect = Session::AutoConnectMaster;
1743                                         } else if (new_session_dialog->connect_outs_to_physical()) {
1744                                                 oconnect = Session::AutoConnectPhysical;
1745                                         } else {
1746                                                 oconnect = Session::AutoConnectOption (0);
1747                                         }
1748
1749                                         uint32_t nphysin = (uint32_t) new_session_dialog->input_limit_count();
1750                                         uint32_t nphysout = (uint32_t) new_session_dialog->output_limit_count();
1751
1752                                         build_session (session_path,
1753                                                session_name,
1754                                                cchns,
1755                                                mchns,
1756                                                iconnect,
1757                                                oconnect,
1758                                                nphysin,
1759                                                nphysout,
1760                                                engine->frame_rate() * 60 * 5);
1761                                 }
1762                         }
1763                 }
1764
1765         } while (response == Gtk::RESPONSE_NONE);
1766         show();
1767         new_session_dialog->get_window()->set_cursor();
1768
1769         new_session_dialog->hide();
1770 }
1771
1772 void
1773 ARDOUR_UI::close_session()
1774 {
1775   unload_session();
1776   new_session ();
1777 }
1778
1779 int
1780 ARDOUR_UI::load_session (const string & path, const string & snap_name, string* mix_template)
1781 {
1782         Session *new_session;
1783         int x;
1784         session_loaded = false;
1785         x = unload_session ();
1786
1787         if (x < 0) {
1788                 return -1;
1789         } else if (x > 0) {
1790                 return 0;
1791         }
1792
1793         /* if it already exists, we must have write access */
1794
1795         if (::access (path.c_str(), F_OK) == 0 && ::access (path.c_str(), W_OK)) {
1796                 MessageDialog msg (*editor, _("\
1797 You do not have write access to this session.\n\
1798 This prevents the session from being loaded."));
1799                 msg.run ();
1800                 return -1;
1801         }
1802
1803         try {
1804                 new_session = new Session (*engine, path, snap_name, mix_template);
1805         }
1806
1807         catch (...) {
1808
1809                 error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
1810                 return -1;
1811         }
1812
1813         connect_to_session (new_session);
1814
1815         session_loaded = true;
1816         return 0;
1817 }
1818
1819 int
1820 ARDOUR_UI::make_session_clean ()
1821 {
1822         if (session) {
1823                 session->set_clean ();
1824         }
1825
1826         show ();
1827
1828         return FALSE;
1829 }
1830
1831 int
1832 ARDOUR_UI::build_session (const string & path, const string & snap_name,
1833                           uint32_t control_channels,
1834                           uint32_t master_channels,
1835                           Session::AutoConnectOption input_connect,
1836                           Session::AutoConnectOption output_connect,
1837                           uint32_t nphysin,
1838                           uint32_t nphysout,
1839                           jack_nframes_t initial_length)
1840 {
1841         Session *new_session;
1842         int x;
1843
1844         session_loaded = false;
1845         x = unload_session ();
1846         if (x < 0) {
1847                 return -1;
1848         } else if (x > 0) {
1849                 return 0;
1850         }
1851
1852         _session_is_new = true;
1853
1854         try {
1855                 new_session = new Session (*engine, path, snap_name, input_connect, output_connect,
1856                                            control_channels, master_channels, nphysin, nphysout, initial_length);
1857         }
1858
1859         catch (...) {
1860
1861                 error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
1862                 return -1;
1863         }
1864
1865         connect_to_session (new_session);
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 (about) {
1880                 about->present ();
1881         }
1882 }
1883
1884 void
1885 ARDOUR_UI::show_splash ()
1886 {
1887         if (about == 0) {
1888                 about = new About();
1889         }
1890         about->present();
1891 }
1892
1893 void
1894 ARDOUR_UI::hide_splash ()
1895 {
1896         if (about) {
1897                 about->get_window()->set_cursor ();
1898                 about->hide();
1899         }
1900 }
1901
1902 void
1903 ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title, const string & msg)
1904 {
1905         size_t removed;
1906
1907         removed = rep.paths.size();
1908
1909         if (removed == 0) {
1910                 MessageDialog msgd (*editor,
1911                                     _("No audio files were ready for cleanup"),
1912                                     true,
1913                                     Gtk::MESSAGE_INFO,
1914                                     (Gtk::ButtonsType)(Gtk::BUTTONS_CLOSE)  );
1915                 msgd.set_secondary_text (_("If this seems suprising, \n\
1916 check for any existing snapshots.\n\
1917 These may still include regions that\n\
1918 require some unused files to continue to exist."));
1919
1920                 msgd.run ();
1921                 return;
1922         }
1923
1924         ArdourDialog results (_("ardour: cleanup"), true, false);
1925
1926         struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
1927             CleanupResultsModelColumns() {
1928                     add (visible_name);
1929                     add (fullpath);
1930             }
1931             Gtk::TreeModelColumn<Glib::ustring> visible_name;
1932             Gtk::TreeModelColumn<Glib::ustring> fullpath;
1933         };
1934
1935
1936         CleanupResultsModelColumns results_columns;
1937         Glib::RefPtr<Gtk::ListStore> results_model;
1938         Gtk::TreeView results_display;
1939
1940         results_model = ListStore::create (results_columns);
1941         results_display.set_model (results_model);
1942         results_display.append_column (list_title, results_columns.visible_name);
1943
1944         results_display.set_name ("CleanupResultsList");
1945         results_display.set_headers_visible (true);
1946         results_display.set_headers_clickable (false);
1947         results_display.set_reorderable (false);
1948
1949         Gtk::ScrolledWindow list_scroller;
1950         Gtk::Label txt;
1951         Gtk::VBox dvbox;
1952         Gtk::HBox dhbox;  // the hbox for the image and text
1953         Gtk::HBox ddhbox; // the hbox we eventually pack into the dialog's vbox
1954         Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_INFO,  Gtk::ICON_SIZE_DIALOG));
1955
1956         dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
1957
1958         if (rep.space < 1048576.0f) {
1959                 if (removed > 1) {
1960                   txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
1961                 } else {
1962                         txt.set_text (string_compose (msg, removed, _("file was"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
1963                 }
1964         } else {
1965                 if (removed > 1) {
1966                         txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
1967                 } else {
1968                         txt.set_text (string_compose (msg, removed, _("file was"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
1969                 }
1970         }
1971
1972         dhbox.pack_start (*dimage, true, false, 5);
1973         dhbox.pack_start (txt, true, false, 5);
1974
1975         for (vector<string>::iterator i = rep.paths.begin(); i != rep.paths.end(); ++i) {
1976                 TreeModel::Row row = *(results_model->append());
1977                 row[results_columns.visible_name] = *i;
1978                 row[results_columns.fullpath] = *i;
1979         }
1980
1981         list_scroller.add (results_display);
1982         list_scroller.set_size_request (-1, 150);
1983         list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1984
1985         dvbox.pack_start (dhbox, true, false, 5);
1986         dvbox.pack_start (list_scroller, true, false, 5);
1987         ddhbox.pack_start (dvbox, true, false, 5);
1988
1989         results.get_vbox()->pack_start (ddhbox, true, false, 5);
1990         results.add_button (Stock::CLOSE, RESPONSE_CLOSE);
1991         results.set_default_response (RESPONSE_CLOSE);
1992         results.set_position (Gtk::WIN_POS_MOUSE);
1993         results.show_all_children ();
1994         results.set_resizable (false);
1995
1996         results.run ();
1997
1998 }
1999
2000 void
2001 ARDOUR_UI::cleanup ()
2002 {
2003         if (session == 0) {
2004                 /* shouldn't happen: menu item is insensitive */
2005                 return;
2006         }
2007
2008
2009         MessageDialog  checker (_("Are you sure you want to cleanup?"),
2010                                 true,
2011                                 Gtk::MESSAGE_QUESTION,
2012                                 (Gtk::ButtonsType)(Gtk::BUTTONS_NONE));
2013
2014         checker.set_secondary_text(_("Cleanup is a destructive operation.\n\
2015 ALL undo/redo information will be lost if you cleanup.\n\
2016 After cleanup, unused audio files will be moved to a \
2017 \"dead sounds\" location."));
2018
2019         checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
2020         checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
2021         checker.set_default_response (RESPONSE_CANCEL);
2022
2023         checker.set_name (_("CleanupDialog"));
2024         checker.set_wmclass (_("ardour_cleanup"), "Ardour");
2025         checker.set_position (Gtk::WIN_POS_MOUSE);
2026
2027         switch (checker.run()) {
2028         case RESPONSE_ACCEPT:
2029                 break;
2030         default:
2031                 return;
2032         }
2033
2034         Session::cleanup_report rep;
2035
2036         editor->prepare_for_cleanup ();
2037
2038         if (session->cleanup_sources (rep)) {
2039                 return;
2040         }
2041         checker.hide();
2042         display_cleanup_results (rep,
2043                                  _("cleaned files"),
2044                                  _("\
2045 The following %1 %2 not in use and \n\
2046 have been moved to:\n\
2047 %3. \n\n\
2048 Flushing the wastebasket will \n\
2049 release an additional\n\
2050 %4 %5bytes of disk space.\n"
2051                                          ));
2052 }
2053
2054 void
2055 ARDOUR_UI::flush_trash ()
2056 {
2057         if (session == 0) {
2058                 /* shouldn't happen: menu item is insensitive */
2059                 return;
2060         }
2061
2062         Session::cleanup_report rep;
2063
2064         if (session->cleanup_trash_sources (rep)) {
2065                 return;
2066         }
2067
2068         display_cleanup_results (rep,
2069                                  _("deleted file"),
2070                                  _("The following %1 %2 deleted from\n\
2071 %3,\n\
2072 releasing %4 %5bytes of disk space"));
2073 }
2074
2075 void
2076 ARDOUR_UI::add_route ()
2077 {
2078         int count;
2079
2080         if (!session) {
2081                 return;
2082         }
2083
2084         if (add_route_dialog == 0) {
2085                 add_route_dialog = new AddRouteDialog;
2086                 editor->ensure_float (*add_route_dialog);
2087         }
2088
2089         if (add_route_dialog->is_visible()) {
2090                 /* we're already doing this */
2091                 return;
2092         }
2093
2094         ResponseType r = (ResponseType) add_route_dialog->run ();
2095
2096         add_route_dialog->hide();
2097
2098         switch (r) {
2099                 case RESPONSE_ACCEPT:
2100                         break;
2101                 default:
2102                         return;
2103                         break;
2104         }
2105
2106         if ((count = add_route_dialog->count()) <= 0) {
2107                 return;
2108         }
2109
2110         uint32_t input_chan = add_route_dialog->channels ();
2111         uint32_t output_chan;
2112         string name_template = add_route_dialog->name_template ();
2113         bool track = add_route_dialog->track ();
2114
2115         Session::AutoConnectOption oac = session->get_output_auto_connect();
2116
2117         if (oac & Session::AutoConnectMaster) {
2118                 output_chan = (session->master_out() ? session->master_out()->n_inputs().get(DataType::AUDIO) : input_chan);
2119         } else {
2120                 output_chan = input_chan;
2121         }
2122
2123         /* XXX do something with name template */
2124
2125         if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
2126                 if (track) {
2127                         session_add_midi_track(count);
2128                 } else  {
2129                         MessageDialog msg (*editor,
2130                                         _("Sorry, MIDI Busses are not supported at this time."));
2131                         msg.run ();
2132                         //session_add_midi_bus();
2133                 }
2134         } else {
2135                 if (track) {
2136                         session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), count);
2137                 } else {
2138                         session_add_audio_bus (input_chan, output_chan, count);
2139                 }
2140         }
2141 }
2142
2143 XMLNode*
2144 ARDOUR_UI::mixer_settings () const
2145 {
2146         XMLNode* node = 0;
2147
2148         if (session) {
2149                 node = session->instant_xml(X_("Mixer"), session->path());
2150         } else {
2151                 node = Config->instant_xml(X_("Mixer"), get_user_ardour_path());
2152         }
2153
2154         if (!node) {
2155                 node = new XMLNode (X_("Mixer"));
2156         }
2157
2158         return node;
2159 }
2160
2161 XMLNode*
2162 ARDOUR_UI::editor_settings () const
2163 {
2164         XMLNode* node = 0;
2165
2166         if (session) {
2167                 node = session->instant_xml(X_("Editor"), session->path());
2168         } else {
2169                 node = Config->instant_xml(X_("Editor"), get_user_ardour_path());
2170         }
2171
2172         if (!node) {
2173                 node = new XMLNode (X_("Editor"));
2174         }
2175         return node;
2176 }
2177
2178 XMLNode*
2179 ARDOUR_UI::keyboard_settings () const
2180 {
2181         XMLNode* node = 0;
2182
2183         node = Config->extra_xml(X_("Keyboard"));
2184
2185         if (!node) {
2186                 node = new XMLNode (X_("Keyboard"));
2187         }
2188         return node;
2189 }
2190
2191 void
2192 ARDOUR_UI::halt_on_xrun_message ()
2193 {
2194         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::halt_on_xrun_message));
2195
2196         MessageDialog msg (*editor,
2197                            _("Recording was stopped because your system could not keep up."));
2198         msg.run ();
2199 }
2200
2201 void
2202 ARDOUR_UI::delete_sources_in_the_right_thread (list<boost::shared_ptr<ARDOUR::Source> >* deletion_list)
2203 {
2204         ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread), deletion_list));
2205
2206         for (list<boost::shared_ptr<Source> >::iterator i = deletion_list->begin(); i != deletion_list->end(); ++i) {
2207                 (*i)->drop_references ();
2208         }
2209
2210         delete deletion_list;
2211 }
2212
2213 void
2214 ARDOUR_UI::disk_overrun_handler ()
2215 {
2216         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
2217
2218         if (!have_disk_overrun_displayed) {
2219                 have_disk_overrun_displayed = true;
2220                 MessageDialog msg (*editor, X_("diskrate dialog"), _("\
2221 The disk system on your computer\n\
2222 was not able to keep up with Ardour.\n\
2223 \n\
2224 Specifically, it failed to write data to disk\n\
2225 quickly enough to keep up with recording.\n"));
2226                 msg.run ();
2227                 have_disk_overrun_displayed = false;
2228         }
2229 }
2230
2231 void
2232 ARDOUR_UI::disk_underrun_handler ()
2233 {
2234         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
2235
2236         if (!have_disk_underrun_displayed) {
2237                 have_disk_underrun_displayed = true;
2238                 MessageDialog msg (*editor,
2239                         (_("The disk system on your computer\n\
2240 was not able to keep up with Ardour.\n\
2241 \n\
2242 Specifically, it failed to read data from disk\n\
2243 quickly enough to keep up with playback.\n")));
2244                 msg.run ();
2245                 have_disk_underrun_displayed = false;
2246         }
2247 }
2248
2249 void
2250 ARDOUR_UI::disk_underrun_message_gone ()
2251 {
2252         have_disk_underrun_displayed = false;
2253 }
2254
2255 void
2256 ARDOUR_UI::disk_overrun_message_gone ()
2257 {
2258         have_disk_underrun_displayed = false;
2259 }
2260
2261 int
2262 ARDOUR_UI::pending_state_dialog ()
2263 {
2264         ArdourDialog dialog ("pending state dialog");
2265         Label  message (_("\
2266 This session appears to have been in\n\
2267 middle of recording when ardour or\n\
2268 the computer was shutdown.\n\
2269 \n\
2270 Ardour can recover any captured audio for\n\
2271 you, or it can ignore it. Please decide\n\
2272 what you would like to do.\n"));
2273
2274         dialog.get_vbox()->pack_start (message);
2275         dialog.add_button (_("Recover from crash"), RESPONSE_ACCEPT);
2276         dialog.add_button (_("Ignore crash data"), RESPONSE_REJECT);
2277
2278         dialog.set_position (WIN_POS_CENTER);
2279         dialog.show_all ();
2280
2281         switch (dialog.run ()) {
2282         case RESPONSE_ACCEPT:
2283                 return 1;
2284         default:
2285                 return 0;
2286         }
2287 }
2288
2289 void
2290 ARDOUR_UI::disconnect_from_jack ()
2291 {
2292         if (engine) {
2293                 if( engine->disconnect_from_jack ()) {
2294                         MessageDialog msg (*editor, _("Could not disconnect from JACK"));
2295                         msg.run ();
2296                 }
2297
2298                 update_sample_rate (0);
2299         }
2300 }
2301
2302 void
2303 ARDOUR_UI::reconnect_to_jack ()
2304 {
2305         if (engine) {
2306                 if (engine->reconnect_to_jack ()) {
2307                         MessageDialog msg (*editor,  _("Could not reconnect to JACK"));
2308                         msg.run ();
2309                 }
2310
2311                 update_sample_rate (0);
2312         }
2313 }
2314
2315 void
2316 ARDOUR_UI::set_jack_buffer_size (jack_nframes_t nframes)
2317 {
2318         engine->request_buffer_size (nframes);
2319         update_sample_rate (0);
2320 }
2321
2322 int
2323 ARDOUR_UI::cmdline_new_session (string path)
2324 {
2325         if (path[0] != '/') {
2326                 char buf[PATH_MAX+1];
2327                 string str;
2328
2329                 getcwd (buf, sizeof (buf));
2330                 str = buf;
2331                 str += '/';
2332                 str += path;
2333                 path = str;
2334         }
2335
2336         new_session (false, path);
2337
2338         _will_create_new_session_automatically = false; /* done it */
2339         return FALSE; /* don't call it again */
2340 }
2341
2342 void
2343 ARDOUR_UI::set_native_file_header_format (HeaderFormat hf)
2344 {
2345         Glib::RefPtr<Action> act;
2346
2347         switch (hf) {
2348         case BWF:
2349                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
2350                 break;
2351         case WAVE:
2352                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
2353                 break;
2354         case WAVE64:
2355                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
2356                 break;
2357         case iXML:
2358                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
2359                 break;
2360         case RF64:
2361                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
2362                 break;
2363         case CAF:
2364                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
2365                 break;
2366         case AIFF:
2367                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
2368                 break;
2369         }
2370
2371         if (act) {
2372                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2373                 if (ract && ract->get_active() && Config->get_native_file_header_format() != hf) {
2374                         Config->set_native_file_header_format (hf);
2375                         if (session) {
2376                                 session->reset_native_file_format ();
2377                         }
2378                 }
2379         }
2380 }
2381
2382 void
2383 ARDOUR_UI::set_native_file_data_format (SampleFormat sf)
2384 {
2385         Glib::RefPtr<Action> act;
2386
2387         switch (sf) {
2388         case FormatFloat:
2389                 act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
2390                 break;
2391         case FormatInt24:
2392                 act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
2393                 break;
2394         }
2395
2396         if (act) {
2397                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2398
2399                 if (ract && ract->get_active() && Config->get_native_file_data_format() != sf) {
2400                         Config->set_native_file_data_format (sf);
2401                         if (session) {
2402                                 session->reset_native_file_format ();
2403                         }
2404                 }
2405         }
2406 }
2407
2408 void
2409 ARDOUR_UI::use_config ()
2410 {
2411         Glib::RefPtr<Action> act;
2412
2413         switch (Config->get_native_file_data_format ()) {
2414         case FormatFloat:
2415                 act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
2416                 break;
2417         case FormatInt24:
2418                 act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
2419                 break;
2420         }
2421
2422         if (act) {
2423                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2424                 ract->set_active ();
2425         }
2426
2427         switch (Config->get_native_file_header_format ()) {
2428         case BWF:
2429                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
2430                 break;
2431         case WAVE:
2432                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
2433                 break;
2434         case WAVE64:
2435                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
2436                 break;
2437         case iXML:
2438                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
2439                 break;
2440         case RF64:
2441                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
2442                 break;
2443         case CAF:
2444                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
2445                 break;
2446         case AIFF:
2447                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
2448                 break;
2449         }
2450
2451         if (act) {
2452                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2453                 ract->set_active ();
2454         }
2455 }