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