gtk2_ardour/ardour_ui.cc

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