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