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)
 873 {
 874         boost::shared_ptr<Route> route;
 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                         if ((route = session->new_midi_track (/*mode*/)) == 0) {
 884                                 error << _("could not create new midi track") << endmsg;
 885                         }
 886                 } else {
 887                         if ((route = session->new_midi_route ()) == 0) {
 888                                 error << _("could not create new midi bus") << endmsg;
 889                         }
 890                 }
 891         }
 892
 893         catch (...) {
 894                 MessageDialog msg (*editor,
 895                                    _("There are insufficient JACK ports available\n\
 896 to create a new track or bus.\n\
 897 You should save Ardour, exit and\n\
 898 restart JACK with more ports."));
 899                 msg.run ();
 900         }
 901 }
 902
 903
 904 void
 905 ARDOUR_UI::session_add_audio_route (bool disk, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode)
 906 {
 907         boost::shared_ptr<Route> route;
 908
 909         if (session == 0) {
 910                 warning << _("You cannot add a track without a session already loaded.") << endmsg;
 911                 return;
 912         }
 913
 914         try {
 915                 if (disk) {
 916                         if ((route = session->new_audio_track (input_channels, output_channels, mode)) == 0) {
 917                                 error << _("could not create new audio track") << endmsg;
 918                         }
 919                 } else {
 920                         if ((route = session->new_audio_route (input_channels, output_channels)) == 0) {
 921                                 error << _("could not create new audio bus") << endmsg;
 922                         }
 923                 }
 924
 925 #if CONTROLOUTS
 926                 if (need_control_room_outs) {
 927                         pan_t pans[2];
 928
 929                         pans[0] = 0.5;
 930                         pans[1] = 0.5;
 931
 932                         route->set_stereo_control_outs (control_lr_channels);
 933                         route->control_outs()->set_stereo_pan (pans, this);
 934                 }
 935 #endif /* CONTROLOUTS */
 936         }
 937
 938         catch (...) {
 939                 MessageDialog msg (*editor,
 940                                    _("There are insufficient JACK ports available\n\
 941 to create a new track or bus.\n\
 942 You should save Ardour, exit and\n\
 943 restart JACK with more ports."));
 944                 msg.run ();
 945         }
 946 }
 947
 948 void
 949 ARDOUR_UI::diskstream_added (Diskstream* ds)
 950 {
 951 }
 952
 953 void
 954 ARDOUR_UI::do_transport_locate (jack_nframes_t new_position)
 955 {
 956         jack_nframes_t _preroll;
 957
 958         if (session) {
 959                 _preroll = session->convert_to_frames_at (new_position, session->preroll);
 960
 961                 if (new_position > _preroll) {
 962                         new_position -= _preroll;
 963                 } else {
 964                         new_position = 0;
 965                 }
 966
 967                 session->request_locate (new_position);
 968         }
 969 }
 970
 971 void
 972 ARDOUR_UI::transport_goto_start ()
 973 {
 974         if (session) {
 975                 session->goto_start();
 976
 977
 978                 /* force displayed area in editor to start no matter
 979                    what "follow playhead" setting is.
 980                 */
 981
 982                 if (editor) {
 983                         editor->reposition_x_origin (session->current_start_frame());
 984                 }
 985         }
 986 }
 987
 988 void
 989 ARDOUR_UI::transport_goto_zero ()
 990 {
 991         if (session) {
 992                 session->request_locate (0);
 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 (0);
1001                 }
1002         }
1003 }
1004
1005 void
1006 ARDOUR_UI::transport_goto_end ()
1007 {
1008         if (session) {
1009                 jack_nframes_t frame = session->current_end_frame();
1010                 session->request_locate (frame);
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 (frame);
1018                 }
1019         }
1020 }
1021
1022 void
1023 ARDOUR_UI::transport_stop ()
1024 {
1025         if (!session) {
1026                 return;
1027         }
1028
1029         if (session->is_auditioning()) {
1030                 session->cancel_audition ();
1031                 return;
1032         }
1033
1034         if (session->get_auto_loop()) {
1035                 session->request_auto_loop (false);
1036         }
1037
1038         session->request_stop ();
1039 }
1040
1041 void
1042 ARDOUR_UI::transport_stop_and_forget_capture ()
1043 {
1044         if (session) {
1045                 session->request_stop (true);
1046         }
1047 }
1048
1049 void
1050 ARDOUR_UI::remove_last_capture()
1051 {
1052         if (editor) {
1053                 editor->remove_last_capture();
1054         }
1055 }
1056
1057 void
1058 ARDOUR_UI::transport_record ()
1059 {
1060         if (session) {
1061                 switch (session->record_status()) {
1062                 case Session::Disabled:
1063                         if (session->ntracks() == 0) {
1064                                 string txt = _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu.");
1065                                 MessageDialog msg (*editor, txt);
1066                                 msg.run ();
1067                                 return;
1068                         }
1069                         session->maybe_enable_record ();
1070                         break;
1071                 case Session::Recording:
1072                 case Session::Enabled:
1073                         session->disable_record (true);
1074                 }
1075         }
1076 }
1077
1078 void
1079 ARDOUR_UI::transport_roll ()
1080 {
1081         bool rolling;
1082
1083         if (!session) {
1084                 return;
1085         }
1086
1087         rolling = session->transport_rolling ();
1088
1089         if (session->get_auto_loop()) {
1090                 session->request_auto_loop (false);
1091                 auto_loop_button.set_active (false);
1092                 roll_button.set_active (true);
1093         } else if (session->get_play_range ()) {
1094                 session->request_play_range (false);
1095                 play_selection_button.set_active (false);
1096         } else if (rolling) {
1097                 session->request_locate (session->last_transport_start(), true);
1098         }
1099
1100         session->request_transport_speed (1.0f);
1101 }
1102
1103 void
1104 ARDOUR_UI::transport_loop()
1105 {
1106         if (session) {
1107                 if (session->get_auto_loop()) {
1108                         if (session->transport_rolling()) {
1109                                 Location * looploc = session->locations()->auto_loop_location();
1110                                 if (looploc) {
1111                                         session->request_locate (looploc->start(), true);
1112                                 }
1113                         }
1114                 }
1115                 else {
1116                         session->request_auto_loop (true);
1117                 }
1118         }
1119 }
1120
1121 void
1122 ARDOUR_UI::transport_play_selection ()
1123 {
1124         if (!session) {
1125                 return;
1126         }
1127
1128         if (!session->get_play_range()) {
1129                 session->request_stop ();
1130         }
1131
1132         editor->play_selection ();
1133 }
1134
1135 void
1136 ARDOUR_UI::transport_rewind (int option)
1137 {
1138         float current_transport_speed;
1139
1140         if (session) {
1141                 current_transport_speed = session->transport_speed();
1142
1143                 if (current_transport_speed >= 0.0f) {
1144                         switch (option) {
1145                         case 0:
1146                                 session->request_transport_speed (-1.0f);
1147                                 break;
1148                         case 1:
1149                                 session->request_transport_speed (-4.0f);
1150                                 break;
1151                         case -1:
1152                                 session->request_transport_speed (-0.5f);
1153                                 break;
1154                         }
1155                 } else {
1156                         /* speed up */
1157                         session->request_transport_speed (current_transport_speed * 1.5f);
1158                 }
1159         }
1160 }
1161
1162 void
1163 ARDOUR_UI::transport_forward (int option)
1164 {
1165         float current_transport_speed;
1166
1167         if (session) {
1168                 current_transport_speed = session->transport_speed();
1169
1170                 if (current_transport_speed <= 0.0f) {
1171                         switch (option) {
1172                         case 0:
1173                                 session->request_transport_speed (1.0f);
1174                                 break;
1175                         case 1:
1176                                 session->request_transport_speed (4.0f);
1177                                 break;
1178                         case -1:
1179                                 session->request_transport_speed (0.5f);
1180                                 break;
1181                         }
1182                 } else {
1183                         /* speed up */
1184                         session->request_transport_speed (current_transport_speed * 1.5f);
1185                 }
1186         }
1187 }
1188
1189 void
1190 ARDOUR_UI::toggle_record_enable (uint32_t dstream)
1191 {
1192         if (session == 0) {
1193                 return;
1194         }
1195
1196         boost::shared_ptr<Route> r;
1197
1198         if ((r = session->route_by_remote_id (dstream)) != 0) {
1199
1200                 Track* t;
1201
1202                 if ((t = dynamic_cast<Track*>(r.get())) != 0) {
1203                         t->diskstream().set_record_enabled (!t->diskstream().record_enabled());
1204                 }
1205         }
1206         if (session == 0) {
1207                 return;
1208         }
1209 }
1210
1211 void
1212 ARDOUR_UI::queue_transport_change ()
1213 {
1214         Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &ARDOUR_UI::map_transport_state));
1215 }
1216
1217 void
1218 ARDOUR_UI::map_transport_state ()
1219 {
1220         float sp = session->transport_speed();
1221
1222         if (sp == 1.0f) {
1223                 transport_rolling ();
1224         } else if (sp < 0.0f) {
1225                 transport_rewinding ();
1226         } else if (sp > 0.0f) {
1227                 transport_forwarding ();
1228         } else {
1229                 transport_stopped ();
1230         }
1231 }
1232
1233 void
1234 ARDOUR_UI::allow_local_only ()
1235 {
1236
1237 }
1238
1239 void
1240 ARDOUR_UI::allow_mmc_only ()
1241 {
1242
1243 }
1244
1245 void
1246 ARDOUR_UI::allow_mmc_and_local ()
1247 {
1248
1249 }
1250
1251 void
1252 ARDOUR_UI::GlobalClickBox::printer (char buf[32], Adjustment &adj, void *arg)
1253 {
1254         snprintf (buf, sizeof(buf), "%s", ((GlobalClickBox *) arg)->strings[
1255                 (int) adj.get_value()].c_str());
1256 }
1257
1258 void
1259 ARDOUR_UI::engine_stopped ()
1260 {
1261         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_stopped));
1262         ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
1263         ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
1264 }
1265
1266
1267 void
1268 ARDOUR_UI::engine_running ()
1269 {
1270         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_running));
1271         ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
1272         ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
1273 }
1274
1275 void
1276 ARDOUR_UI::engine_halted ()
1277 {
1278         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::engine_halted));
1279
1280         ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
1281         ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
1282
1283         update_sample_rate (0);
1284
1285         MessageDialog msg (*editor,
1286                            _("\
1287 JACK has either been shutdown or it\n\
1288 disconnected Ardour because Ardour\n\
1289 was not fast enough. You can save the\n\
1290 session and/or try to reconnect to JACK ."));
1291         msg.run ();
1292 }
1293
1294 int32_t
1295 ARDOUR_UI::do_engine_start ()
1296 {
1297         try {
1298                 engine->start();
1299         }
1300
1301         catch (AudioEngine::PortRegistrationFailure& err) {
1302                 engine->stop ();
1303                 error << _("Unable to create all required ports")
1304                       << endmsg;
1305                 unload_session ();
1306                 return -1;
1307         }
1308
1309         catch (...) {
1310                 engine->stop ();
1311                 error << _("Unable to start the session running")
1312                       << endmsg;
1313                 unload_session ();
1314                 return -2;
1315         }
1316
1317         return 0;
1318 }
1319
1320 gint
1321 ARDOUR_UI::start_engine ()
1322 {
1323         if (do_engine_start () == 0) {
1324                 if (session && _session_is_new) {
1325                         /* we need to retain initial visual
1326                            settings for a new session
1327                         */
1328                         session->save_state ("");
1329                 }
1330
1331                 /* there is too much going on, in too many threads, for us to
1332                    end up with a clean session. So wait 1 second after loading,
1333                    and fix it up. its ugly, but until i come across a better
1334                    solution, its what we have.
1335                 */
1336
1337                 Glib::signal_timeout().connect (mem_fun(*this, &ARDOUR_UI::make_session_clean), 1000);
1338         }
1339
1340         return FALSE;
1341 }
1342
1343 void
1344 ARDOUR_UI::update_clocks ()
1345 {
1346          Clock (session->audible_frame()); /* EMIT_SIGNAL */
1347 }
1348
1349 void
1350 ARDOUR_UI::start_clocking ()
1351 {
1352         clock_signal_connection = RapidScreenUpdate.connect (mem_fun(*this, &ARDOUR_UI::update_clocks));
1353 }
1354
1355 void
1356 ARDOUR_UI::stop_clocking ()
1357 {
1358         clock_signal_connection.disconnect ();
1359 }
1360
1361 void
1362 ARDOUR_UI::toggle_clocking ()
1363 {
1364 #if 0
1365         if (clock_button.get_active()) {
1366                 start_clocking ();
1367         } else {
1368                 stop_clocking ();
1369         }
1370 #endif
1371 }
1372
1373 gint
1374 ARDOUR_UI::_blink (void *arg)
1375
1376 {
1377         ((ARDOUR_UI *) arg)->blink ();
1378         return TRUE;
1379 }
1380
1381 void
1382 ARDOUR_UI::blink ()
1383 {
1384          Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
1385 }
1386
1387 void
1388 ARDOUR_UI::start_blinking ()
1389 {
1390         /* Start the blink signal. Everybody with a blinking widget
1391            uses Blink to drive the widget's state.
1392         */
1393
1394         if (blink_timeout_tag < 0) {
1395                 blink_on = false;
1396                 blink_timeout_tag = gtk_timeout_add (240, _blink, this);
1397         }
1398 }
1399
1400 void
1401 ARDOUR_UI::stop_blinking ()
1402 {
1403         if (blink_timeout_tag >= 0) {
1404                 gtk_timeout_remove (blink_timeout_tag);
1405                 blink_timeout_tag = -1;
1406         }
1407 }
1408
1409 void
1410 ARDOUR_UI::name_io_setup (AudioEngine& engine,
1411                           string& buf,
1412                           IO& io,
1413                           bool in)
1414 {
1415         if (in) {
1416                 if (io.n_inputs() == 0) {
1417                         buf = _("none");
1418                         return;
1419                 }
1420
1421                 /* XXX we're not handling multiple ports yet. */
1422
1423                 const char **connections = io.input(0)->get_connections();
1424
1425                 if (connections == 0 || connections[0] == '\0') {
1426                         buf = _("off");
1427                 } else {
1428                         buf = connections[0];
1429                 }
1430
1431                 free (connections);
1432
1433         } else {
1434
1435                 if (io.n_outputs() == 0) {
1436                         buf = _("none");
1437                         return;
1438                 }
1439
1440                 /* XXX we're not handling multiple ports yet. */
1441
1442                 const char **connections = io.output(0)->get_connections();
1443
1444                 if (connections == 0 || connections[0] == '\0') {
1445                         buf = _("off");
1446                 } else {
1447                         buf = connections[0];
1448                 }
1449
1450                 free (connections);
1451         }
1452 }
1453
1454 void
1455 ARDOUR_UI::snapshot_session ()
1456 {
1457         ArdourPrompter prompter (true);
1458         string snapname;
1459         string now;
1460         time_t n;
1461
1462         time (&n);
1463         now = ctime (&n);
1464         now = now.substr (20, 4) + now.substr (3, 16) + " (" + now.substr (0, 3) + ")";
1465
1466         prompter.set_name ("Prompter");
1467         prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
1468         prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1469         prompter.set_prompt (_("Name of New Snapshot"));
1470         prompter.set_initial_text (now);
1471
1472         switch (prompter.run()) {
1473         case RESPONSE_ACCEPT:
1474                 prompter.get_result (snapname);
1475                 if (snapname.length()){
1476                         save_state (snapname);
1477                 }
1478                 break;
1479
1480         default:
1481                 break;
1482         }
1483 }
1484
1485 void
1486 ARDOUR_UI::save_state (const string & name)
1487 {
1488         (void) save_state_canfail (name);
1489 }
1490
1491 int
1492 ARDOUR_UI::save_state_canfail (string name)
1493 {
1494         if (session) {
1495                 int ret;
1496
1497                 if (name.length() == 0) {
1498                         name = session->snap_name();
1499                 }
1500
1501                 if ((ret = session->save_state (name)) != 0) {
1502                         return ret;
1503                 }
1504         }
1505         save_ardour_state (); /* XXX cannot fail? yeah, right ... */
1506         return 0;
1507 }
1508
1509 void
1510 ARDOUR_UI::restore_state (string name)
1511 {
1512         if (session) {
1513                 if (name.length() == 0) {
1514                         name = session->name();
1515                 }
1516                 session->restore_state (name);
1517         }
1518 }
1519
1520 void
1521 ARDOUR_UI::primary_clock_value_changed ()
1522 {
1523         if (session) {
1524                 session->request_locate (primary_clock.current_time ());
1525         }
1526 }
1527
1528 void
1529 ARDOUR_UI::secondary_clock_value_changed ()
1530 {
1531         if (session) {
1532                 session->request_locate (secondary_clock.current_time ());
1533         }
1534 }
1535
1536 void
1537 ARDOUR_UI::rec_enable_button_blink (bool onoff, AudioDiskstream *dstream, Widget *w)
1538 {
1539         if (session && dstream && dstream->record_enabled()) {
1540
1541                 Session::RecordState rs;
1542
1543                 rs = session->record_status ();
1544
1545                 switch (rs) {
1546                 case Session::Disabled:
1547                 case Session::Enabled:
1548                         if (w->get_state() != STATE_SELECTED) {
1549                                 w->set_state (STATE_SELECTED);
1550                         }
1551                         break;
1552
1553                 case Session::Recording:
1554                         if (w->get_state() != STATE_ACTIVE) {
1555                                 w->set_state (STATE_ACTIVE);
1556                         }
1557                         break;
1558                 }
1559
1560         } else {
1561                 if (w->get_state() != STATE_NORMAL) {
1562                         w->set_state (STATE_NORMAL);
1563                 }
1564         }
1565 }
1566
1567 void
1568 ARDOUR_UI::transport_rec_enable_blink (bool onoff)
1569 {
1570         if (session == 0) {
1571                 return;
1572         }
1573
1574         switch (session->record_status()) {
1575         case Session::Enabled:
1576                 if (onoff) {
1577                         rec_button.set_state (1);
1578                 } else {
1579                         rec_button.set_state (0);
1580                 }
1581                 break;
1582
1583         case Session::Recording:
1584                 rec_button.set_state (2);
1585                 break;
1586
1587         default:
1588                 rec_button.set_state (0);
1589                 break;
1590         }
1591 }
1592
1593 gint
1594 ARDOUR_UI::hide_and_quit (GdkEventAny *ev, ArdourDialog *window)
1595 {
1596         window->hide();
1597         Gtk::Main::quit ();
1598         return TRUE;
1599 }
1600
1601 void
1602 ARDOUR_UI::start_keyboard_prefix ()
1603 {
1604         keyboard->start_prefix();
1605 }
1606
1607 void
1608 ARDOUR_UI::save_template ()
1609
1610 {
1611         ArdourPrompter prompter (true);
1612         string name;
1613
1614         prompter.set_name (X_("Prompter"));
1615         prompter.set_prompt (_("Name for mix template:"));
1616         prompter.set_initial_text(session->name() + _("-template"));
1617         prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
1618         prompter.set_response_sensitive (Gtk::RESPONSE_ACCEPT, false);
1619
1620         switch (prompter.run()) {
1621         case RESPONSE_ACCEPT:
1622                 prompter.get_result (name);
1623
1624                 if (name.length()) {
1625                         session->save_template (name);
1626                 }
1627                 break;
1628
1629         default:
1630                 break;
1631         }
1632 }
1633
1634 void
1635 ARDOUR_UI::new_session (bool startup, std::string predetermined_path)
1636 {
1637         m_new_session_dialog->show();
1638         m_new_session_dialog->set_modal(true);
1639         m_new_session_dialog->set_name(predetermined_path);
1640         m_new_session_dialog->reset_recent();
1641
1642         int response = Gtk::RESPONSE_CANCEL;
1643
1644         do {
1645                 response = m_new_session_dialog->run ();
1646                 if(response == Gtk::RESPONSE_CANCEL || response == Gtk::RESPONSE_DELETE_EVENT) {
1647                   quit();
1648                   return;
1649
1650                 } else if (response == Gtk::RESPONSE_NONE) {
1651                   /* Clear was pressed */
1652                   m_new_session_dialog->reset();
1653
1654                 } else if (response == Gtk::RESPONSE_YES) {
1655                   /* YES  == OPEN, but there's no enum for that */
1656                   std::string session_name = m_new_session_dialog->session_name();
1657                   std::string session_path = m_new_session_dialog->session_folder();
1658                   load_session (session_path, session_name);
1659
1660
1661                 } else if (response == Gtk::RESPONSE_OK) {
1662                   if (m_new_session_dialog->get_current_page() == 1) {
1663
1664                     /* XXX this is a bit of a hack..
1665                        i really want the new sesion dialog to return RESPONSE_YES
1666                        if we're on page 1 (the load page)
1667                        Unfortunately i can't see how atm..
1668                     */
1669                         std::string session_name = m_new_session_dialog->session_name();
1670                         std::string session_path = m_new_session_dialog->session_folder();
1671                         load_session (session_path, session_name);
1672
1673                   } else {
1674
1675                         _session_is_new = true;
1676
1677                         std::string session_name = m_new_session_dialog->session_name();
1678                         std::string session_path = m_new_session_dialog->session_folder();
1679
1680
1681                           //XXX This is needed because session constructor wants a
1682                           //non-existant path. hopefully this will be fixed at some point.
1683
1684                         session_path = Glib::build_filename(session_path, session_name);
1685
1686                         std::string template_name = m_new_session_dialog->session_template_name();
1687
1688                         if (m_new_session_dialog->use_session_template()) {
1689
1690                                 load_session (session_path, session_name, &template_name);
1691
1692                         } else {
1693
1694                                 uint32_t cchns;
1695                                 uint32_t mchns;
1696                                 Session::AutoConnectOption iconnect;
1697                                 Session::AutoConnectOption oconnect;
1698
1699                                 if (m_new_session_dialog->create_control_bus()) {
1700                                         cchns = (uint32_t) m_new_session_dialog->control_channel_count();
1701                                 } else {
1702                                         cchns = 0;
1703                                 }
1704
1705                                 if (m_new_session_dialog->create_master_bus()) {
1706                                         mchns = (uint32_t) m_new_session_dialog->master_channel_count();
1707                                 } else {
1708                                         mchns = 0;
1709                                 }
1710
1711                                 if (m_new_session_dialog->connect_inputs()) {
1712                                         iconnect = Session::AutoConnectPhysical;
1713                                 } else {
1714                                         iconnect = Session::AutoConnectOption (0);
1715                                 }
1716
1717                                 /// @todo some minor tweaks.
1718
1719                                 if (m_new_session_dialog->connect_outs_to_master()) {
1720                                         oconnect = Session::AutoConnectMaster;
1721                                 } else if (m_new_session_dialog->connect_outs_to_physical()) {
1722                                         oconnect = Session::AutoConnectPhysical;
1723                                 } else {
1724                                         oconnect = Session::AutoConnectOption (0);
1725                                 }
1726
1727                                 uint32_t nphysin = (uint32_t) m_new_session_dialog->input_limit_count();
1728                                 uint32_t nphysout = (uint32_t) m_new_session_dialog->output_limit_count();
1729
1730                                 build_session (session_path,
1731                                                session_name,
1732                                                cchns,
1733                                                mchns,
1734                                                iconnect,
1735                                                oconnect,
1736                                                nphysin,
1737                                                nphysout,
1738                                                engine->frame_rate() * 60 * 5);
1739                         }
1740                   }
1741                 }
1742
1743         } while (response == Gtk::RESPONSE_NONE);
1744         m_new_session_dialog->hide();
1745         show();
1746
1747 }
1748
1749 void
1750 ARDOUR_UI::close_session()
1751 {
1752   unload_session();
1753   new_session ();
1754 }
1755
1756 int
1757 ARDOUR_UI::load_session (const string & path, const string & snap_name, string* mix_template)
1758 {
1759         Session *new_session;
1760         int x;
1761         session_loaded = false;
1762         x = unload_session ();
1763
1764         if (x < 0) {
1765                 return -1;
1766         } else if (x > 0) {
1767                 return 0;
1768         }
1769
1770         /* if it already exists, we must have write access */
1771
1772         if (::access (path.c_str(), F_OK) == 0 && ::access (path.c_str(), W_OK)) {
1773                 MessageDialog msg (*editor, _("\
1774 You do not have write access to this session.\n\
1775 This prevents the session from being loaded."));
1776                 msg.run ();
1777                 return -1;
1778         }
1779
1780         try {
1781                 new_session = new Session (*engine, path, snap_name, mix_template);
1782         }
1783
1784         catch (...) {
1785
1786                 error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
1787                 return -1;
1788         }
1789
1790         connect_to_session (new_session);
1791
1792         //if (engine->running()) {
1793         //mixer->show_window();
1794         //}
1795         session_loaded = true;
1796         return 0;
1797 }
1798
1799 int
1800 ARDOUR_UI::make_session_clean ()
1801 {
1802         if (session) {
1803                 session->set_clean ();
1804         }
1805
1806         show ();
1807
1808         return FALSE;
1809 }
1810
1811 int
1812 ARDOUR_UI::build_session (const string & path, const string & snap_name,
1813                           uint32_t control_channels,
1814                           uint32_t master_channels,
1815                           Session::AutoConnectOption input_connect,
1816                           Session::AutoConnectOption output_connect,
1817                           uint32_t nphysin,
1818                           uint32_t nphysout,
1819                           jack_nframes_t initial_length)
1820 {
1821         Session *new_session;
1822         int x;
1823
1824         session_loaded = false;
1825         x = unload_session ();
1826         if (x < 0) {
1827                 return -1;
1828         } else if (x > 0) {
1829                 return 0;
1830         }
1831
1832         _session_is_new = true;
1833
1834         try {
1835                 new_session = new Session (*engine, path, snap_name, input_connect, output_connect,
1836                                            control_channels, master_channels, nphysin, nphysout, initial_length);
1837         }
1838
1839         catch (...) {
1840
1841                 error << string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"), path, snap_name) << endmsg;
1842                 return -1;
1843         }
1844
1845         connect_to_session (new_session);
1846
1847         //if (engine->running()) {
1848         //mixer->show_window();
1849         //}
1850         session_loaded = true;
1851         return 0;
1852 }
1853
1854 void
1855 ARDOUR_UI::show ()
1856 {
1857         if (editor) {
1858                 editor->show_window ();
1859                 shown_flag = true;
1860         }
1861
1862         if (session && mixer) {
1863                 // mixer->show_window ();
1864         }
1865
1866         if (about) {
1867                 about->present ();
1868         }
1869 }
1870
1871 void
1872 ARDOUR_UI::show_splash ()
1873 {
1874         if (about == 0) {
1875                 about = new About();
1876         }
1877         about->present();
1878 }
1879
1880 void
1881 ARDOUR_UI::hide_splash ()
1882 {
1883         if (about) {
1884                 // about->hide();
1885         }
1886 }
1887
1888 void
1889 ARDOUR_UI::display_cleanup_results (Session::cleanup_report& rep, const gchar* list_title, const string & msg)
1890 {
1891         size_t removed;
1892
1893         removed = rep.paths.size();
1894
1895         if (removed == 0) {
1896                 MessageDialog msgd (*editor,
1897                                     _("No audio files were ready for cleanup"),
1898                                     true,
1899                                     Gtk::MESSAGE_INFO,
1900                                     (Gtk::ButtonsType)(Gtk::BUTTONS_CLOSE)  );
1901                 msgd.set_secondary_text (_("If this seems suprising, \n\
1902 check for any existing snapshots.\n\
1903 These may still include regions that\n\
1904 require some unused files to continue to exist."));
1905
1906                 msgd.run ();
1907                 return;
1908         }
1909
1910         ArdourDialog results (_("ardour: cleanup"), true, false);
1911
1912         struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
1913             CleanupResultsModelColumns() {
1914                     add (visible_name);
1915                     add (fullpath);
1916             }
1917             Gtk::TreeModelColumn<Glib::ustring> visible_name;
1918             Gtk::TreeModelColumn<Glib::ustring> fullpath;
1919         };
1920
1921
1922         CleanupResultsModelColumns results_columns;
1923         Glib::RefPtr<Gtk::ListStore> results_model;
1924         Gtk::TreeView results_display;
1925
1926         results_model = ListStore::create (results_columns);
1927         results_display.set_model (results_model);
1928         results_display.append_column (list_title, results_columns.visible_name);
1929
1930         results_display.set_name ("CleanupResultsList");
1931         results_display.set_headers_visible (true);
1932         results_display.set_headers_clickable (false);
1933         results_display.set_reorderable (false);
1934
1935         Gtk::ScrolledWindow list_scroller;
1936         Gtk::Label txt;
1937         Gtk::VBox dvbox;
1938         Gtk::HBox dhbox;  // the hbox for the image and text
1939         Gtk::HBox ddhbox; // the hbox we eventually pack into the dialog's vbox
1940         Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_INFO,  Gtk::ICON_SIZE_DIALOG));
1941
1942         dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
1943
1944         if (rep.space < 1048576.0f) {
1945                 if (removed > 1) {
1946                   txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
1947                 } else {
1948                         txt.set_text (string_compose (msg, removed, _("file was"), session->path() + "dead_sounds", (float) rep.space / 1024.0f, "kilo"));
1949                 }
1950         } else {
1951                 if (removed > 1) {
1952                         txt.set_text (string_compose (msg, removed, _("files were"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
1953                 } else {
1954                         txt.set_text (string_compose (msg, removed, _("file was"), session->path() + "dead_sounds", (float) rep.space / 1048576.0f, "mega"));
1955                 }
1956         }
1957
1958         dhbox.pack_start (*dimage, true, false, 5);
1959         dhbox.pack_start (txt, true, false, 5);
1960
1961         for (vector<string>::iterator i = rep.paths.begin(); i != rep.paths.end(); ++i) {
1962                 TreeModel::Row row = *(results_model->append());
1963                 row[results_columns.visible_name] = *i;
1964                 row[results_columns.fullpath] = *i;
1965         }
1966
1967         list_scroller.add (results_display);
1968         list_scroller.set_size_request (-1, 150);
1969         list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1970
1971         dvbox.pack_start (dhbox, true, false, 5);
1972         dvbox.pack_start (list_scroller, true, false, 5);
1973         ddhbox.pack_start (dvbox, true, false, 5);
1974
1975         results.get_vbox()->pack_start (ddhbox, true, false, 5);
1976         results.add_button (Stock::CLOSE, RESPONSE_CLOSE);
1977         results.set_default_response (RESPONSE_CLOSE);
1978         results.set_position (Gtk::WIN_POS_MOUSE);
1979         results.show_all_children ();
1980         results.set_resizable (false);
1981
1982         results.run ();
1983
1984 }
1985
1986 void
1987 ARDOUR_UI::cleanup ()
1988 {
1989         if (session == 0) {
1990                 /* shouldn't happen: menu item is insensitive */
1991                 return;
1992         }
1993
1994
1995         MessageDialog  checker (_("Are you sure you want to cleanup?"),
1996                                 true,
1997                                 Gtk::MESSAGE_QUESTION,
1998                                 (Gtk::ButtonsType)(Gtk::BUTTONS_NONE));
1999
2000         checker.set_secondary_text(_("Cleanup is a destructive operation.\n\
2001 ALL undo/redo information will be lost if you cleanup.\n\
2002 After cleanup, unused audio files will be moved to a \
2003 \"dead sounds\" location."));
2004
2005         checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
2006         checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
2007         checker.set_default_response (RESPONSE_CANCEL);
2008
2009         checker.set_name (_("CleanupDialog"));
2010         checker.set_wmclass (_("ardour_cleanup"), "Ardour");
2011         checker.set_position (Gtk::WIN_POS_MOUSE);
2012
2013         switch (checker.run()) {
2014         case RESPONSE_ACCEPT:
2015                 break;
2016         default:
2017                 return;
2018         }
2019
2020         Session::cleanup_report rep;
2021
2022         editor->prepare_for_cleanup ();
2023
2024         if (session->cleanup_sources (rep)) {
2025                 return;
2026         }
2027         checker.hide();
2028         display_cleanup_results (rep,
2029                                  _("cleaned files"),
2030                                  _("\
2031 The following %1 %2 not in use and \n\
2032 have been moved to:\n\
2033 %3. \n\n\
2034 Flushing the wastebasket will \n\
2035 release an additional\n\
2036 %4 %5bytes of disk space.\n"
2037                                          ));
2038 }
2039
2040 void
2041 ARDOUR_UI::flush_trash ()
2042 {
2043         if (session == 0) {
2044                 /* shouldn't happen: menu item is insensitive */
2045                 return;
2046         }
2047
2048         Session::cleanup_report rep;
2049
2050         if (session->cleanup_trash_sources (rep)) {
2051                 return;
2052         }
2053
2054         display_cleanup_results (rep,
2055                                  _("deleted file"),
2056                                  _("The following %1 %2 deleted from\n\
2057 %3,\n\
2058 releasing %4 %5bytes of disk space"));
2059 }
2060
2061 void
2062 ARDOUR_UI::add_route ()
2063 {
2064         int count;
2065
2066         if (!session) {
2067                 return;
2068         }
2069
2070         if (add_route_dialog == 0) {
2071                 add_route_dialog = new AddRouteDialog;
2072                 editor->ensure_float (*add_route_dialog);
2073         }
2074
2075         if (add_route_dialog->is_visible()) {
2076                 /* we're already doing this */
2077                 return;
2078         }
2079
2080         ResponseType r = (ResponseType) add_route_dialog->run ();
2081
2082         add_route_dialog->hide();
2083
2084         switch (r) {
2085         case RESPONSE_ACCEPT:
2086                 break;
2087         default:
2088                 return;
2089                 break;
2090         }
2091
2092         if ((count = add_route_dialog->count()) <= 0) {
2093                 return;
2094         }
2095
2096         uint32_t input_chan = add_route_dialog->channels ();
2097         uint32_t output_chan;
2098         string name_template = add_route_dialog->name_template ();
2099         bool track = add_route_dialog->track ();
2100
2101         Session::AutoConnectOption oac = session->get_output_auto_connect();
2102
2103         if (oac & Session::AutoConnectMaster) {
2104                 output_chan = (session->master_out() ? session->master_out()->n_inputs() : input_chan);
2105         } else {
2106                 output_chan = input_chan;
2107         }
2108
2109         /* XXX do something with name template */
2110
2111         while (count) {
2112                 if (track && add_route_dialog->midi()) {
2113                         session_add_midi_track();
2114                 } else if (add_route_dialog->midi()) {
2115                         session_add_midi_bus();
2116                 } else if (track) {
2117                         session_add_audio_track (input_chan, output_chan, add_route_dialog->mode());
2118                 } else {
2119                         session_add_audio_bus (input_chan, output_chan);
2120                 }
2121                 --count;
2122
2123                 while (Main::events_pending()) {
2124                         Main::iteration ();
2125                 }
2126         }
2127 }
2128
2129 XMLNode*
2130 ARDOUR_UI::mixer_settings () const
2131 {
2132         XMLNode* node = 0;
2133
2134         if (session) {
2135                 node = session->instant_xml(X_("Mixer"), session->path());
2136         } else {
2137                 node = Config->instant_xml(X_("Mixer"), get_user_ardour_path());
2138         }
2139
2140         if (!node) {
2141                 node = new XMLNode (X_("Mixer"));
2142         }
2143
2144         return node;
2145 }
2146
2147 XMLNode*
2148 ARDOUR_UI::editor_settings () const
2149 {
2150         XMLNode* node = 0;
2151
2152         if (session) {
2153                 node = session->instant_xml(X_("Editor"), session->path());
2154         } else {
2155                 node = Config->instant_xml(X_("Editor"), get_user_ardour_path());
2156         }
2157
2158         if (!node) {
2159                 node = new XMLNode (X_("Editor"));
2160         }
2161         return node;
2162 }
2163
2164 XMLNode*
2165 ARDOUR_UI::keyboard_settings () const
2166 {
2167         XMLNode* node = 0;
2168
2169         node = Config->extra_xml(X_("Keyboard"));
2170
2171         if (!node) {
2172                 node = new XMLNode (X_("Keyboard"));
2173         }
2174         return node;
2175 }
2176
2177 void
2178 ARDOUR_UI::halt_on_xrun_message ()
2179 {
2180         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::halt_on_xrun_message));
2181
2182         MessageDialog msg (*editor,
2183                            _("Recording was stopped because your system could not keep up."));
2184         msg.run ();
2185 }
2186
2187 void
2188 ARDOUR_UI::delete_sources_in_the_right_thread (list<ARDOUR::Source*>* deletion_list)
2189 {
2190         ENSURE_GUI_THREAD (bind (mem_fun(*this, &ARDOUR_UI::delete_sources_in_the_right_thread), deletion_list));
2191
2192         for (list<Source*>::iterator i = deletion_list->begin(); i != deletion_list->end(); ++i) {
2193                 delete *i;
2194         }
2195
2196         delete deletion_list;
2197 }
2198
2199 void
2200 ARDOUR_UI::disk_overrun_handler ()
2201 {
2202         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
2203
2204         if (!have_disk_overrun_displayed) {
2205                 have_disk_overrun_displayed = true;
2206                 MessageDialog msg (*editor, X_("diskrate dialog"), _("\
2207 The disk system on your computer\n\
2208 was not able to keep up with Ardour.\n\
2209 \n\
2210 Specifically, it failed to write data to disk\n\
2211 quickly enough to keep up with recording.\n"));
2212                 msg.run ();
2213                 have_disk_overrun_displayed = false;
2214         }
2215 }
2216
2217 void
2218 ARDOUR_UI::disk_underrun_handler ()
2219 {
2220         ENSURE_GUI_THREAD (mem_fun(*this, &ARDOUR_UI::disk_underrun_handler));
2221
2222         if (!have_disk_underrun_displayed) {
2223                 have_disk_underrun_displayed = true;
2224                 MessageDialog msg (*editor,
2225                         (_("The disk system on your computer\n\
2226 was not able to keep up with Ardour.\n\
2227 \n\
2228 Specifically, it failed to read data from disk\n\
2229 quickly enough to keep up with playback.\n")));
2230                 msg.run ();
2231                 have_disk_underrun_displayed = false;
2232         }
2233 }
2234
2235 void
2236 ARDOUR_UI::disk_underrun_message_gone ()
2237 {
2238         have_disk_underrun_displayed = false;
2239 }
2240
2241 void
2242 ARDOUR_UI::disk_overrun_message_gone ()
2243 {
2244         have_disk_underrun_displayed = false;
2245 }
2246
2247 int
2248 ARDOUR_UI::pending_state_dialog ()
2249 {
2250         ArdourDialog dialog ("pending state dialog");
2251         Label  message (_("\
2252 This session appears to have been in\n\
2253 middle of recording when ardour or\n\
2254 the computer was shutdown.\n\
2255 \n\
2256 Ardour can recover any captured audio for\n\
2257 you, or it can ignore it. Please decide\n\
2258 what you would like to do.\n"));
2259
2260         dialog.get_vbox()->pack_start (message);
2261         dialog.add_button (_("Recover from crash"), RESPONSE_ACCEPT);
2262         dialog.add_button (_("Ignore crash data"), RESPONSE_REJECT);
2263
2264         dialog.set_position (WIN_POS_CENTER);
2265         dialog.show_all ();
2266
2267         switch (dialog.run ()) {
2268         case RESPONSE_ACCEPT:
2269                 return 1;
2270         default:
2271                 return 0;
2272         }
2273 }
2274
2275 void
2276 ARDOUR_UI::disconnect_from_jack ()
2277 {
2278         if (engine) {
2279                 if( engine->disconnect_from_jack ()) {
2280                         MessageDialog msg (*editor, _("Could not disconnect from JACK"));
2281                         msg.run ();
2282                 }
2283
2284                 update_sample_rate (0);
2285         }
2286 }
2287
2288 void
2289 ARDOUR_UI::reconnect_to_jack ()
2290 {
2291         if (engine) {
2292                 if (engine->reconnect_to_jack ()) {
2293                         MessageDialog msg (*editor,  _("Could not reconnect to JACK"));
2294                         msg.run ();
2295                 }
2296
2297                 update_sample_rate (0);
2298         }
2299 }
2300
2301 void
2302 ARDOUR_UI::set_jack_buffer_size (jack_nframes_t nframes)
2303 {
2304         engine->request_buffer_size (nframes);
2305         update_sample_rate (0);
2306 }
2307
2308 int
2309 ARDOUR_UI::cmdline_new_session (string path)
2310 {
2311         if (path[0] != '/') {
2312                 char buf[PATH_MAX+1];
2313                 string str;
2314
2315                 getcwd (buf, sizeof (buf));
2316                 str = buf;
2317                 str += '/';
2318                 str += path;
2319                 path = str;
2320         }
2321
2322         new_session (false, path);
2323
2324         _will_create_new_session_automatically = false; /* done it */
2325         return FALSE; /* don't call it again */
2326 }
2327
2328 void
2329 ARDOUR_UI::set_native_file_header_format (HeaderFormat hf)
2330 {
2331         Glib::RefPtr<Action> act;
2332
2333         switch (hf) {
2334         case BWF:
2335                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
2336                 break;
2337         case WAVE:
2338                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
2339                 break;
2340         case WAVE64:
2341                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
2342                 break;
2343         case iXML:
2344                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
2345                 break;
2346         case RF64:
2347                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
2348                 break;
2349         case CAF:
2350                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
2351                 break;
2352         case AIFF:
2353                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
2354                 break;
2355         }
2356
2357         if (act) {
2358                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2359                 if (ract && ract->get_active() && Config->get_native_file_header_format() != hf) {
2360                         Config->set_native_file_header_format (hf);
2361                         if (session) {
2362                                 session->reset_native_file_format ();
2363                         }
2364                 }
2365         }
2366 }
2367
2368 void
2369 ARDOUR_UI::set_native_file_data_format (SampleFormat sf)
2370 {
2371         Glib::RefPtr<Action> act;
2372
2373         switch (sf) {
2374         case FormatFloat:
2375                 act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
2376                 break;
2377         case FormatInt24:
2378                 act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
2379                 break;
2380         }
2381
2382         if (act) {
2383                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2384
2385                 if (ract && ract->get_active() && Config->get_native_file_data_format() != sf) {
2386                         Config->set_native_file_data_format (sf);
2387                         if (session) {
2388                                 session->reset_native_file_format ();
2389                         }
2390                 }
2391         }
2392 }
2393
2394 void
2395 ARDOUR_UI::use_config ()
2396 {
2397         Glib::RefPtr<Action> act;
2398
2399         switch (Config->get_native_file_data_format ()) {
2400         case FormatFloat:
2401                 act = ActionManager::get_action (X_("options"), X_("FileDataFormatFloat"));
2402                 break;
2403         case FormatInt24:
2404                 act = ActionManager::get_action (X_("options"), X_("FileDataFormat24bit"));
2405                 break;
2406         }
2407
2408         if (act) {
2409                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2410                 ract->set_active ();
2411         }
2412
2413         switch (Config->get_native_file_header_format ()) {
2414         case BWF:
2415                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatBWF"));
2416                 break;
2417         case WAVE:
2418                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE"));
2419                 break;
2420         case WAVE64:
2421                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatWAVE64"));
2422                 break;
2423         case iXML:
2424                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatiXML"));
2425                 break;
2426         case RF64:
2427                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatRF64"));
2428                 break;
2429         case CAF:
2430                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatCAF"));
2431                 break;
2432         case AIFF:
2433                 act = ActionManager::get_action (X_("options"), X_("FileHeaderFormatAIFF"));
2434                 break;
2435         }
2436
2437         if (act) {
2438                 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic(act);
2439                 ract->set_active ();
2440         }
2441 }