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