?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
prettification of vbap/2d panner GUI. lots of details still to fix. also signal place...
[ardour2.git] / gtk2_ardour / ardour_ui.cc
blob883071e725b3f5eb04c60dcb15bf3df44f26ece1
1 /*
2 Copyright (C) 1999-2007 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 */
19
20 #ifdef WAF_BUILD
21 #include "gtk2ardour-config.h"
22 #endif
23
24 #include <stdint.h>
25
26 #include <algorithm>
27 #include <cmath>
28 #include <fcntl.h>
29 #include <signal.h>
30 #include <unistd.h>
31 #include <time.h>
32 #include <cerrno>
33 #include <fstream>
34
35 #include <iostream>
36
37 #include <sys/resource.h>
38
39 #include <gtkmm/messagedialog.h>
40 #include <gtkmm/accelmap.h>
41
42 #include "pbd/error.h"
43 #include "pbd/basename.h"
44 #include "pbd/compose.h"
45 #include "pbd/failed_constructor.h"
46 #include "pbd/enumwriter.h"
47 #include "pbd/memento_command.h"
48 #include "pbd/openuri.h"
49 #include "pbd/file_utils.h"
50
51 #include "gtkmm2ext/application.h"
52 #include "gtkmm2ext/gtk_ui.h"
53 #include "gtkmm2ext/utils.h"
54 #include "gtkmm2ext/click_box.h"
55 #include "gtkmm2ext/fastmeter.h"
56 #include "gtkmm2ext/popup.h"
57 #include "gtkmm2ext/window_title.h"
58
59 #include "midi++/manager.h"
60
61 #include "ardour/ardour.h"
62 #include "ardour/callback.h"
63 #include "ardour/profile.h"
64 #include "ardour/session_directory.h"
65 #include "ardour/session_route.h"
66 #include "ardour/session_state_utils.h"
67 #include "ardour/session_utils.h"
68 #include "ardour/port.h"
69 #include "ardour/audioengine.h"
70 #include "ardour/playlist.h"
71 #include "ardour/utils.h"
72 #include "ardour/audio_diskstream.h"
73 #include "ardour/audiofilesource.h"
74 #include "ardour/recent_sessions.h"
75 #include "ardour/port.h"
76 #include "ardour/audio_track.h"
77 #include "ardour/midi_track.h"
78 #include "ardour/filesystem_paths.h"
79 #include "ardour/filename_extensions.h"
80
81 typedef uint64_t microseconds_t;
82
83 #include "about.h"
84 #include "actions.h"
85 #include "add_route_dialog.h"
86 #include "ambiguous_file_dialog.h"
87 #include "ardour_ui.h"
88 #include "audio_clock.h"
89 #include "bundle_manager.h"
90 #include "engine_dialog.h"
91 #include "gain_meter.h"
92 #include "global_port_matrix.h"
93 #include "gui_thread.h"
94 #include "keyboard.h"
95 #include "location_ui.h"
96 #include "missing_file_dialog.h"
97 #include "missing_plugin_dialog.h"
98 #include "mixer_ui.h"
99 #include "opts.h"
100 #include "processor_box.h"
101 #include "prompter.h"
102 #include "public_editor.h"
103 #include "route_time_axis.h"
104 #include "session_metadata_dialog.h"
105 #include "speaker_dialog.h"
106 #include "splash.h"
107 #include "startup.h"
108 #include "theme_manager.h"
109 #include "time_axis_view_item.h"
110 #include "utils.h"
111 #include "window_proxy.h"
112
113 #include "i18n.h"
114
115 using namespace ARDOUR;
116 using namespace PBD;
117 using namespace Gtkmm2ext;
118 using namespace Gtk;
119
120 ARDOUR_UI *ARDOUR_UI::theArdourUI = 0;
121 UIConfiguration *ARDOUR_UI::ui_config = 0;
122
123 sigc::signal<void,bool> ARDOUR_UI::Blink;
124 sigc::signal<void> ARDOUR_UI::RapidScreenUpdate;
125 sigc::signal<void> ARDOUR_UI::SuperRapidScreenUpdate;
126 sigc::signal<void, framepos_t, bool, framepos_t> ARDOUR_UI::Clock;
127
128 bool could_be_a_valid_path (const string& path);
129
130 ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
131
132 : Gtkmm2ext::UI (PROGRAM_NAME, argcp, argvp),
133
134 primary_clock (X_("primary"), false, X_("TransportClockDisplay"), true, true, false, true),
135 secondary_clock (X_("secondary"), false, X_("SecondaryClockDisplay"), true, true, false, true),
136 preroll_clock (X_("preroll"), false, X_("PreRollClock"), true, false, true),
137 postroll_clock (X_("postroll"), false, X_("PostRollClock"), true, false, true),
138
139 /* preroll stuff */
140
141 preroll_button (_("pre\nroll")),
142 postroll_button (_("post\nroll")),
143
144 /* big clock */
145
146 big_clock (X_("bigclock"), false, "BigClockNonRecording", true, true, false, false),
147
148 /* transport */
149
150 roll_controllable (new TransportControllable ("transport roll", *this, TransportControllable::Roll)),
151 stop_controllable (new TransportControllable ("transport stop", *this, TransportControllable::Stop)),
152 goto_start_controllable (new TransportControllable ("transport goto start", *this, TransportControllable::GotoStart)),
153 goto_end_controllable (new TransportControllable ("transport goto end", *this, TransportControllable::GotoEnd)),
154 auto_loop_controllable (new TransportControllable ("transport auto loop", *this, TransportControllable::AutoLoop)),
155 play_selection_controllable (new TransportControllable ("transport play selection", *this, TransportControllable::PlaySelection)),
156 rec_controllable (new TransportControllable ("transport rec-enable", *this, TransportControllable::RecordEnable)),
157 shuttle_controllable (new TransportControllable ("shuttle", *this, TransportControllable::ShuttleControl)),
158 shuttle_controller_binding_proxy (shuttle_controllable),
159
160 roll_button (roll_controllable),
161 stop_button (stop_controllable),
162 goto_start_button (goto_start_controllable),
163 goto_end_button (goto_end_controllable),
164 auto_loop_button (auto_loop_controllable),
165 play_selection_button (play_selection_controllable),
166 rec_button (rec_controllable),
167
168 shuttle_units_button (_("% ")),
169
170 punch_in_button (_("Punch In")),
171 punch_out_button (_("Punch Out")),
172 auto_return_button (_("Auto Return")),
173 auto_play_button (_("Auto Play")),
174 auto_input_button (_("Auto Input")),
175 click_button (_("Click")),
176 time_master_button (_("time\nmaster")),
177
178 auditioning_alert_button (_("AUDITION")),
179 solo_alert_button (_("SOLO")),
180
181 error_log_button (_("Errors"))
182
183 {
184 using namespace Gtk::Menu_Helpers;
185
186 Gtkmm2ext::init();
187
188
189 #ifdef TOP_MENUBAR
190 // _auto_display_errors = false;
191 /*
192 * This was commented out as it wasn't defined
193 * in A3 IIRC. If this is not needed it should
194 * be completely removed.
195 */
196 #endif
197
198 about = 0;
199 splash = 0;
200 _startup = 0;
201
202 if (theArdourUI == 0) {
203 theArdourUI = this;
204 }
205
206 ui_config = new UIConfiguration();
207 theme_manager = new ThemeManager();
208
209 editor = 0;
210 mixer = 0;
211 editor = 0;
212 engine = 0;
213 _session_is_new = false;
214 big_clock_window = 0;
215 big_clock_height = 0;
216 big_clock_resize_in_progress = false;
217 session_selector_window = 0;
218 last_key_press_time = 0;
219 _will_create_new_session_automatically = false;
220 add_route_dialog = 0;
221 route_params = 0;
222 rc_option_editor = 0;
223 session_option_editor = 0;
224 location_ui = 0;
225 open_session_selector = 0;
226 have_configure_timeout = false;
227 have_disk_speed_dialog_displayed = false;
228 session_loaded = false;
229 last_speed_displayed = -1.0f;
230 ignore_dual_punch = false;
231 original_big_clock_width = -1;
232 original_big_clock_height = -1;
233 original_big_clock_font_size = 0;
234
235 roll_button.unset_flags (Gtk::CAN_FOCUS);
236 stop_button.unset_flags (Gtk::CAN_FOCUS);
237 goto_start_button.unset_flags (Gtk::CAN_FOCUS);
238 goto_end_button.unset_flags (Gtk::CAN_FOCUS);
239 auto_loop_button.unset_flags (Gtk::CAN_FOCUS);
240 play_selection_button.unset_flags (Gtk::CAN_FOCUS);
241 rec_button.unset_flags (Gtk::CAN_FOCUS);
242
243 last_configure_time= 0;
244
245 shuttle_grabbed = false;
246 shuttle_fract = 0.0;
247 shuttle_max_speed = 8.0f;
248
249 shuttle_style_menu = 0;
250 shuttle_unit_menu = 0;
251
252 // We do not have jack linked in yet so;
253
254 last_shuttle_request = last_peak_grab = 0; // get_microseconds();
255
256 ARDOUR::Diskstream::DiskOverrun.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::disk_overrun_handler, this), gui_context());
257 ARDOUR::Diskstream::DiskUnderrun.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::disk_underrun_handler, this), gui_context());
258
259 /* handle dialog requests */
260
261 ARDOUR::Session::Dialog.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::session_dialog, this, _1), gui_context());
262
263 /* handle pending state with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
264
265 ARDOUR::Session::AskAboutPendingState.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::pending_state_dialog, this));
266
267 /* handle sr mismatch with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
268
269 ARDOUR::Session::AskAboutSampleRateMismatch.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::sr_mismatch_dialog, this, _1, _2));
270
271 /* handle requests to quit (coming from JACK session) */
272
273 ARDOUR::Session::Quit.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::finish, this), gui_context ());
274
275 /* handle requests to deal with missing files */
276
277 ARDOUR::Session::MissingFile.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::missing_file, this, _1, _2, _3));
278
279 /* and ambiguous files */
280
281 ARDOUR::FileSource::AmbiguousFileName.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::ambiguous_file, this, _1, _2, _3));
282
283 /* lets get this party started */
284
285 try {
286 if (ARDOUR::init (ARDOUR_COMMAND_LINE::use_vst, ARDOUR_COMMAND_LINE::try_hw_optimization)) {
287 throw failed_constructor ();
288 }
289
290 setup_gtk_ardour_enums ();
291 setup_profile ();
292
293 GainMeter::setup_slider_pix ();
294 RouteTimeAxisView::setup_slider_pix ();
295 SendProcessorEntry::setup_slider_pix ();
296 SessionEvent::create_per_thread_pool ("GUI", 512);
297
298 } catch (failed_constructor& err) {
299 error << string_compose (_("could not initialize %1."), PROGRAM_NAME) << endmsg;
300 // pass it on up
301 throw;
302 }
303
304 /* we like keyboards */
305
306 keyboard = new ArdourKeyboard(*this);
307
308 XMLNode* node = ARDOUR_UI::instance()->keyboard_settings();
309 if (node) {
310 keyboard->set_state (*node, Stateful::loading_state_version);
311 }
312
313 reset_dpi();
314
315 TimeAxisViewItem::set_constant_heights ();
316
317 /* The following must happen after ARDOUR::init() so that Config is set up */
318
319 location_ui = new ActionWindowProxy<LocationUIWindow> (X_("locations"), Config->extra_xml (X_("UI")), X_("ToggleLocations"));
320 big_clock_window = new ActionWindowProxy<Gtk::Window> (X_("bigclock"), Config->extra_xml (X_("UI")), X_("ToggleBigClock"));
321 speaker_config_window = new ActionWindowProxy<SpeakerDialog> (X_("speakerconf"), Config->extra_xml (X_("UI")), X_("toggle-speaker-config"));
322
323 for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) {
324 _global_port_matrix[*i] = new ActionWindowProxy<GlobalPortMatrixWindow> (
325 string_compose ("GlobalPortMatrix-%1", (*i).to_string()),
326 Config->extra_xml (X_("UI")),
327 string_compose ("toggle-%1-connection-manager", (*i).to_string())
328 );
329 }
330
331 setup_clock ();
332 speaker_config_window->set (new SpeakerDialog);
333
334 starting.connect (sigc::mem_fun(*this, &ARDOUR_UI::startup));
335 stopping.connect (sigc::mem_fun(*this, &ARDOUR_UI::shutdown));
336
337 platform_setup ();
338 }
339
340 /** @return true if a session was chosen and `apply' clicked, otherwise false if `cancel' was clicked */
341 bool
342 ARDOUR_UI::run_startup (bool should_be_new, string load_template)
343 {
344 delete _startup;
345 _startup = new ArdourStartup ();
346
347 XMLNode* audio_setup = Config->extra_xml ("AudioSetup");
348
349 if (audio_setup && _startup->engine_control()) {
350 _startup->engine_control()->set_state (*audio_setup);
351 }
352
353 _startup->set_new_only (should_be_new);
354 if (!load_template.empty()) {
355 _startup->set_load_template( load_template );
356 }
357 _startup->present ();
358
359 main().run();
360
361 _startup->hide ();
362
363 switch (_startup->response()) {
364 case RESPONSE_OK:
365 return true;
366 default:
367 return false;
368 }
369 }
370
371 int
372 ARDOUR_UI::create_engine ()
373 {
374 // this gets called every time by new_session()
375
376 if (engine) {
377 return 0;
378 }
379
380 loading_message (_("Starting audio engine"));
381
382 try {
383 engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::jack_client_name, ARDOUR_COMMAND_LINE::jack_session_uuid);
384
385 } catch (...) {
386
387 return -1;
388 }
389
390 engine->Stopped.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::engine_stopped, this), gui_context());
391 engine->Running.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::engine_running, this), gui_context());
392 engine->SampleRateChanged.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::update_sample_rate, this, _1), gui_context());
393
394 engine->Halted.connect_same_thread (forever_connections, boost::bind (&ARDOUR_UI::engine_halted, this, _1, false));
395
396 ARDOUR::Port::set_connecting_blocked (ARDOUR_COMMAND_LINE::no_connect_ports);
397
398 post_engine ();
399
400 return 0;
401 }
402
403 void
404 ARDOUR_UI::post_engine ()
405 {
406 /* Things to be done once we create the AudioEngine
407 */
408
409 ARDOUR::init_post_engine ();
410
411 ActionManager::init ();
412 _tooltips.enable();
413
414 if (setup_windows ()) {
415 throw failed_constructor ();
416 }
417
418 check_memory_locking();
419
420 /* this is the first point at which all the keybindings are available */
421
422 if (ARDOUR_COMMAND_LINE::show_key_actions) {
423 vector<string> names;
424 vector<string> paths;
425 vector<string> tooltips;
426 vector<string> keys;
427 vector<AccelKey> bindings;
428
429 ActionManager::get_all_actions (names, paths, tooltips, keys, bindings);
430
431 vector<string>::iterator n;
432 vector<string>::iterator k;
433 for (n = names.begin(), k = keys.begin(); n != names.end(); ++n, ++k) {
434 cerr << "Action: " << (*n) << " bound to " << (*k) << endl;
435 }
436
437 exit (0);
438 }
439
440 blink_timeout_tag = -1;
441
442 /* this being a GUI and all, we want peakfiles */
443
444 AudioFileSource::set_build_peakfiles (true);
445 AudioFileSource::set_build_missing_peakfiles (true);
446
447 /* set default clock modes */
448
449 if (Profile->get_sae()) {
450 primary_clock.set_mode (AudioClock::BBT);
451 secondary_clock.set_mode (AudioClock::MinSec);
452 } else {
453 primary_clock.set_mode (AudioClock::Timecode);
454 secondary_clock.set_mode (AudioClock::BBT);
455 }
456
457 /* start the time-of-day-clock */
458
459 #ifndef GTKOSX
460 /* OS X provides a nearly-always visible wallclock, so don't be stupid */
461 update_wall_clock ();
462 Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::update_wall_clock), 60000);
463 #endif
464
465 update_disk_space ();
466 update_cpu_load ();
467 update_sample_rate (engine->frame_rate());
468
469 Config->ParameterChanged.connect (forever_connections, MISSING_INVALIDATOR, ui_bind (&ARDOUR_UI::parameter_changed, this, _1), gui_context());
470 boost::function<void (string)> pc (boost::bind (&ARDOUR_UI::parameter_changed, this, _1));
471 Config->map_parameters (pc);
472
473 /* now start and maybe save state */
474
475 if (do_engine_start () == 0) {
476 if (_session && _session_is_new) {
477 /* we need to retain initial visual
478 settings for a new session
479 */
480 _session->save_state ("");
481 }
482 }
483 }
484
485 ARDOUR_UI::~ARDOUR_UI ()
486 {
487 delete keyboard;
488 delete editor;
489 delete mixer;
490 delete add_route_dialog;
491 }
492
493 void
494 ARDOUR_UI::pop_back_splash ()
495 {
496 if (Splash::instance()) {
497 // Splash::instance()->pop_back();
498 Splash::instance()->hide ();
499 }
500 }
501
502 gint
503 ARDOUR_UI::configure_timeout ()
504 {
505 if (last_configure_time == 0) {
506 /* no configure events yet */
507 return true;
508 }
509
510 /* force a gap of 0.5 seconds since the last configure event
511 */
512
513 if (get_microseconds() - last_configure_time < 500000) {
514 return true;
515 } else {
516 have_configure_timeout = false;
517 cerr << "config event-driven save\n";
518 save_ardour_state ();
519 return false;
520 }
521 }
522
523 gboolean
524 ARDOUR_UI::configure_handler (GdkEventConfigure* /*conf*/)
525 {
526 if (have_configure_timeout) {
527 last_configure_time = get_microseconds();
528 } else {
529 Glib::signal_timeout().connect (sigc::mem_fun(*this, &ARDOUR_UI::configure_timeout), 100);
530 have_configure_timeout = true;
531 }
532
533 return FALSE;
534 }
535
536 void
537 ARDOUR_UI::set_transport_controllable_state (const XMLNode& node)
538 {
539 const XMLProperty* prop;
540
541 if ((prop = node.property ("roll")) != 0) {
542 roll_controllable->set_id (prop->value());
543 }
544 if ((prop = node.property ("stop")) != 0) {
545 stop_controllable->set_id (prop->value());
546 }
547 if ((prop = node.property ("goto-start")) != 0) {
548 goto_start_controllable->set_id (prop->value());
549 }
550 if ((prop = node.property ("goto-end")) != 0) {
551 goto_end_controllable->set_id (prop->value());
552 }
553 if ((prop = node.property ("auto-loop")) != 0) {
554 auto_loop_controllable->set_id (prop->value());
555 }
556 if ((prop = node.property ("play-selection")) != 0) {
557 play_selection_controllable->set_id (prop->value());
558 }
559 if ((prop = node.property ("rec")) != 0) {
560 rec_controllable->set_id (prop->value());
561 }
562 if ((prop = node.property ("shuttle")) != 0) {
563 shuttle_controllable->set_id (prop->value());
564 }
565 }
566
567 XMLNode&
568 ARDOUR_UI::get_transport_controllable_state ()
569 {
570 XMLNode* node = new XMLNode(X_("TransportControllables"));
571 char buf[64];
572
573 roll_controllable->id().print (buf, sizeof (buf));
574 node->add_property (X_("roll"), buf);
575 stop_controllable->id().print (buf, sizeof (buf));
576 node->add_property (X_("stop"), buf);
577 goto_start_controllable->id().print (buf, sizeof (buf));
578 node->add_property (X_("goto_start"), buf);
579 goto_end_controllable->id().print (buf, sizeof (buf));
580 node->add_property (X_("goto_end"), buf);
581 auto_loop_controllable->id().print (buf, sizeof (buf));
582 node->add_property (X_("auto_loop"), buf);
583 play_selection_controllable->id().print (buf, sizeof (buf));
584 node->add_property (X_("play_selection"), buf);
585 rec_controllable->id().print (buf, sizeof (buf));
586 node->add_property (X_("rec"), buf);
587 shuttle_controllable->id().print (buf, sizeof (buf));
588 node->add_property (X_("shuttle"), buf);
589
590 return *node;
591 }
592
593
594 gint
595 ARDOUR_UI::autosave_session ()
596 {
597 if (g_main_depth() > 1) {
598 /* inside a recursive main loop,
599 give up because we may not be able to
600 take a lock.
601 */
602 return 1;
603 }
604
605 if (!Config->get_periodic_safety_backups()) {
606 return 1;
607 }
608
609 if (_session) {
610 _session->maybe_write_autosave();
611 }
612
613 return 1;
614 }
615
616 void
617 ARDOUR_UI::update_autosave ()
618 {
619 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_autosave)
620
621 if (_session && _session->dirty()) {
622 if (_autosave_connection.connected()) {
623 _autosave_connection.disconnect();
624 }
625
626 _autosave_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &ARDOUR_UI::autosave_session),
627 Config->get_periodic_safety_backup_interval() * 1000);
628
629 } else {
630 if (_autosave_connection.connected()) {
631 _autosave_connection.disconnect();
632 }
633 }
634 }
635
636 void
637 ARDOUR_UI::backend_audio_error (bool we_set_params, Gtk::Window* toplevel)
638 {
639 string title;
640 if (we_set_params) {
641 title = string_compose (_("%1 could not start JACK"), PROGRAM_NAME);
642 } else {
643 title = string_compose (_("%1 could not connect to JACK."), PROGRAM_NAME);
644 }
645
646 MessageDialog win (title,
647 false,
648 Gtk::MESSAGE_INFO,
649 Gtk::BUTTONS_NONE);
650
651 if (we_set_params) {
652 win.set_secondary_text(_("There are several possible reasons:\n\
653 \n\
654 1) You requested audio parameters that are not supported..\n\
655 2) JACK is running as another user.\n\
656 \n\
657 Please consider the possibilities, and perhaps try different parameters."));
658 } else {
659 win.set_secondary_text(_("There are several possible reasons:\n\
660 \n\
661 1) JACK is not running.\n\
662 2) JACK is running as another user, perhaps root.\n\
663 3) There is already another client called \"ardour\".\n\
664 \n\
665 Please consider the possibilities, and perhaps (re)start JACK."));
666 }
667
668 if (toplevel) {
669 win.set_transient_for (*toplevel);
670 }
671
672 if (we_set_params) {
673 win.add_button (Stock::OK, RESPONSE_CLOSE);
674 } else {
675 win.add_button (Stock::QUIT, RESPONSE_CLOSE);
676 }
677
678 win.set_default_response (RESPONSE_CLOSE);
679
680 win.show_all ();
681 win.set_position (Gtk::WIN_POS_CENTER);
682 pop_back_splash ();
683
684 /* we just don't care about the result, but we want to block */
685
686 win.run ();
687 }
688
689 void
690 ARDOUR_UI::startup ()
691 {
692 Application* app = Application::instance ();
693
694 app->ShouldQuit.connect (sigc::mem_fun (*this, &ARDOUR_UI::queue_finish));
695 app->ShouldLoad.connect (sigc::mem_fun (*this, &ARDOUR_UI::idle_load));
696
697 #ifdef PHONE_HOME
698 call_the_mothership (VERSIONSTRING);
699 #endif
700
701 app->ready ();
702
703 if (get_session_parameters (true, ARDOUR_COMMAND_LINE::new_session, ARDOUR_COMMAND_LINE::load_template)) {
704 exit (1);
705 }
706
707 use_config ();
708
709 goto_editor_window ();
710
711 /* Add the window proxies here; their addition may cause windows to be opened, and we want them
712 to be opened on top of the editor window that goto_editor_window() just opened.
713 */
714 add_window_proxy (location_ui);
715 add_window_proxy (big_clock_window);
716 for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) {
717 add_window_proxy (_global_port_matrix[*i]);
718 }
719
720 BootMessage (string_compose (_("%1 is ready for use"), PROGRAM_NAME));
721 }
722
723 void
724 ARDOUR_UI::no_memory_warning ()
725 {
726 XMLNode node (X_("no-memory-warning"));
727 Config->add_instant_xml (node);
728 }
729
730 void
731 ARDOUR_UI::check_memory_locking ()
732 {
733 #ifdef __APPLE__
734 /* OS X doesn't support mlockall(2), and so testing for memory locking capability there is pointless */
735 return;
736 #else // !__APPLE__
737
738 XMLNode* memory_warning_node = Config->instant_xml (X_("no-memory-warning"));
739
740 if (engine->is_realtime() && memory_warning_node == 0) {
741
742 struct rlimit limits;
743 int64_t ram;
744 long pages, page_size;
745
746 if ((page_size = sysconf (_SC_PAGESIZE)) < 0 ||(pages = sysconf (_SC_PHYS_PAGES)) < 0) {
747 ram = 0;
748 } else {
749 ram = (int64_t) pages * (int64_t) page_size;
750 }
751
752 if (getrlimit (RLIMIT_MEMLOCK, &limits)) {
753 return;
754 }
755
756 if (limits.rlim_cur != RLIM_INFINITY) {
757
758 if (ram == 0 || ((double) limits.rlim_cur / ram) < 0.75) {
759
760
761 MessageDialog msg (
762 string_compose (_("WARNING: Your system has a limit for maximum amount of locked memory. "
763 "This might cause %1 to run out of memory before your system "
764 "runs out of memory. \n\n"
765 "You can view the memory limit with 'ulimit -l', "
766 "and it is normally controlled by /etc/security/limits.conf"),
767 PROGRAM_NAME).c_str());
768
769 VBox* vbox = msg.get_vbox();
770 HBox hbox;
771 CheckButton cb (_("Do not show this window again"));
772
773 cb.signal_toggled().connect (sigc::mem_fun (*this, &ARDOUR_UI::no_memory_warning));
774
775 hbox.pack_start (cb, true, false);
776 vbox->pack_start (hbox);
777 cb.show();
778 vbox->show();
779 hbox.show ();
780
781 pop_back_splash ();
782
783 editor->ensure_float (msg);
784 msg.run ();
785 }
786 }
787 }
788 #endif // !__APPLE__
789 }
790
791
792 void
793 ARDOUR_UI::queue_finish ()
794 {
795 Glib::signal_idle().connect (mem_fun (*this, &ARDOUR_UI::idle_finish));
796 }
797
798 bool
799 ARDOUR_UI::idle_finish ()
800 {
801 finish ();
802 return false; /* do not call again */
803 }
804
805 void
806 ARDOUR_UI::finish()
807 {
808 if (_session) {
809 int tries = 0;
810
811 if (_session->transport_rolling() && (++tries < 8)) {
812 _session->request_stop (false, true);
813 usleep (10000);
814 }
815
816 if (_session->dirty()) {
817 switch (ask_about_saving_session(_("quit"))) {
818 case -1:
819 return;
820 break;
821 case 1:
822 /* use the default name */
823 if (save_state_canfail ("")) {
824 /* failed - don't quit */
825 MessageDialog msg (*editor,
826 _("\
827 Ardour was unable to save your session.\n\n\
828 If you still wish to quit, please use the\n\n\
829 \"Just quit\" option."));
830 pop_back_splash();
831 msg.run ();
832 return;
833 }
834 break;
835 case 0:
836 break;
837 }
838 }
839
840 second_connection.disconnect ();
841 point_one_second_connection.disconnect ();
842 point_oh_five_second_connection.disconnect ();
843 point_zero_one_second_connection.disconnect();
844 }
845
846 /* Save state before deleting the session, as that causes some
847 windows to be destroyed before their visible state can be
848 saved.
849 */
850 save_ardour_state ();
851
852 if (_session) {
853 // _session->set_deletion_in_progress ();
854 _session->set_clean ();
855 _session->remove_pending_capture_state ();
856 delete _session;
857 _session = 0;
858 }
859
860 ArdourDialog::close_all_dialogs ();
861 engine->stop (true);
862 quit ();
863 }
864
865 int
866 ARDOUR_UI::ask_about_saving_session (const string & what)
867 {
868 ArdourDialog window (_("Unsaved Session"));
869 Gtk::HBox dhbox; // the hbox for the image and text
870 Gtk::Label prompt_label;
871 Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_WARNING, Gtk::ICON_SIZE_DIALOG));
872
873 string msg;
874
875 msg = string_compose(_("Don't %1"), what);
876 window.add_button (msg, RESPONSE_REJECT);
877 msg = string_compose(_("Just %1"), what);
878 window.add_button (msg, RESPONSE_APPLY);
879 msg = string_compose(_("Save and %1"), what);
880 window.add_button (msg, RESPONSE_ACCEPT);
881
882 window.set_default_response (RESPONSE_ACCEPT);
883
884 Gtk::Button noquit_button (msg);
885 noquit_button.set_name ("EditorGTKButton");
886
887 string prompt;
888 string type;
889
890 if (_session->snap_name() == _session->name()) {
891 type = _("session");
892 } else {
893 type = _("snapshot");
894 }
895 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?"),
896 type, _session->snap_name());
897
898 prompt_label.set_text (prompt);
899 prompt_label.set_name (X_("PrompterLabel"));
900 prompt_label.set_alignment(ALIGN_LEFT, ALIGN_TOP);
901
902 dimage->set_alignment(ALIGN_CENTER, ALIGN_TOP);
903 dhbox.set_homogeneous (false);
904 dhbox.pack_start (*dimage, false, false, 5);
905 dhbox.pack_start (prompt_label, true, false, 5);
906 window.get_vbox()->pack_start (dhbox);
907
908 window.set_name (_("Prompter"));
909 window.set_position (Gtk::WIN_POS_MOUSE);
910 window.set_modal (true);
911 window.set_resizable (false);
912
913 dhbox.show();
914 prompt_label.show();
915 dimage->show();
916 window.show();
917 window.set_keep_above (true);
918 window.present ();
919
920 ResponseType r = (ResponseType) window.run();
921
922 window.hide ();
923
924 switch (r) {
925 case RESPONSE_ACCEPT: // save and get out of here
926 return 1;
927 case RESPONSE_APPLY: // get out of here
928 return 0;
929 default:
930 break;
931 }
932
933 return -1;
934 }
935
936 gint
937 ARDOUR_UI::every_second ()
938 {
939 update_cpu_load ();
940 update_buffer_load ();
941 update_disk_space ();
942 return TRUE;
943 }
944
945 gint
946 ARDOUR_UI::every_point_one_seconds ()
947 {
948 update_speed_display ();
949 RapidScreenUpdate(); /* EMIT_SIGNAL */
950 return TRUE;
951 }
952
953 gint
954 ARDOUR_UI::every_point_zero_one_seconds ()
955 {
956 // august 2007: actual update frequency: 40Hz, not 100Hz
957
958 SuperRapidScreenUpdate(); /* EMIT_SIGNAL */
959 return TRUE;
960 }
961
962 void
963 ARDOUR_UI::update_sample_rate (framecnt_t)
964 {
965 char buf[32];
966
967 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::update_sample_rate, ignored)
968
969 if (!engine->connected()) {
970
971 snprintf (buf, sizeof (buf), _("disconnected"));
972
973 } else {
974
975 framecnt_t rate = engine->frame_rate();
976
977 if (fmod (rate, 1000.0) != 0.0) {
978 snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f ms"),
979 (float) rate/1000.0f,
980 (engine->frames_per_cycle() / (float) rate) * 1000.0f);
981 } else {
982 snprintf (buf, sizeof (buf), _("%" PRId64 " kHz / %4.1f ms"),
983 rate/1000,
984 (engine->frames_per_cycle() / (float) rate) * 1000.0f);
985 }
986 }
987
988 sample_rate_label.set_text (buf);
989 }
990
991 void
992 ARDOUR_UI::update_cpu_load ()
993 {
994 char buf[32];
995 snprintf (buf, sizeof (buf), _("DSP: %5.1f%%"), engine->get_cpu_load());
996 cpu_load_label.set_text (buf);
997 }
998
999 void
1000 ARDOUR_UI::update_buffer_load ()
1001 {
1002 char buf[64];
1003 uint32_t c, p;
1004
1005 if (_session) {
1006 c = _session->capture_load ();
1007 p = _session->playback_load ();
1008
1009 snprintf (buf, sizeof (buf), _("Buffers p:%" PRIu32 "%% c:%" PRIu32 "%%"),
1010 _session->playback_load(), _session->capture_load());
1011 buffer_load_label.set_text (buf);
1012 } else {
1013 buffer_load_label.set_text ("");
1014 }
1015 }
1016
1017 void
1018 ARDOUR_UI::count_recenabled_streams (Route& route)
1019 {
1020 Track* track = dynamic_cast<Track*>(&route);
1021 if (track && track->record_enabled()) {
1022 rec_enabled_streams += track->n_inputs().n_total();
1023 }
1024 }
1025
1026 void
1027 ARDOUR_UI::update_disk_space()
1028 {
1029 if (_session == 0) {
1030 return;
1031 }
1032
1033 framecnt_t frames = _session->available_capture_duration();
1034 char buf[64];
1035 framecnt_t fr = _session->frame_rate();
1036
1037 if (frames == max_framecnt) {
1038 strcpy (buf, _("Disk: 24hrs+"));
1039 } else {
1040 rec_enabled_streams = 0;
1041 _session->foreach_route (this, &ARDOUR_UI::count_recenabled_streams);
1042
1043 if (rec_enabled_streams) {
1044 frames /= rec_enabled_streams;
1045 }
1046
1047 int hrs;
1048 int mins;
1049 int secs;
1050
1051 hrs = frames / (fr * 3600);
1052 frames -= hrs * fr * 3600;
1053 mins = frames / (fr * 60);
1054 frames -= mins * fr * 60;
1055 secs = frames / fr;
1056
1057 snprintf (buf, sizeof(buf), _("Disk: %02dh:%02dm:%02ds"), hrs, mins, secs);
1058 }
1059
1060 disk_space_label.set_text (buf);
1061
1062 // An attempt to make the disk space label flash red when space has run out.
1063
1064 if (frames < fr * 60 * 5) {
1065 /* disk_space_box.style ("disk_space_label_empty"); */
1066 } else {
1067 /* disk_space_box.style ("disk_space_label"); */
1068 }
1069
1070 }
1071
1072 gint
1073 ARDOUR_UI::update_wall_clock ()
1074 {
1075 time_t now;
1076 struct tm *tm_now;
1077 char buf[16];
1078
1079 time (&now);
1080 tm_now = localtime (&now);
1081
1082 sprintf (buf, "%02d:%02d", tm_now->tm_hour, tm_now->tm_min);
1083 wall_clock_label.set_text (buf);
1084
1085 return TRUE;
1086 }
1087
1088 gint
1089 ARDOUR_UI::session_menu (GdkEventButton */*ev*/)
1090 {
1091 session_popup_menu->popup (0, 0);
1092 return TRUE;
1093 }
1094
1095 void
1096 ARDOUR_UI::redisplay_recent_sessions ()
1097 {
1098 std::vector<sys::path> session_directories;
1099 RecentSessionsSorter cmp;
1100
1101 recent_session_display.set_model (Glib::RefPtr<TreeModel>(0));
1102 recent_session_model->clear ();
1103
1104 ARDOUR::RecentSessions rs;
1105 ARDOUR::read_recent_sessions (rs);
1106
1107 if (rs.empty()) {
1108 recent_session_display.set_model (recent_session_model);
1109 return;
1110 }
1111 //
1112 // sort them alphabetically
1113 sort (rs.begin(), rs.end(), cmp);
1114
1115 for (ARDOUR::RecentSessions::iterator i = rs.begin(); i != rs.end(); ++i) {
1116 session_directories.push_back ((*i).second);
1117 }
1118
1119 for (vector<sys::path>::const_iterator i = session_directories.begin();
1120 i != session_directories.end(); ++i)
1121 {
1122 std::vector<sys::path> state_file_paths;
1123
1124 // now get available states for this session
1125
1126 get_state_files_in_directory (*i, state_file_paths);
1127
1128 vector<string*>* states;
1129 vector<const gchar*> item;
1130 string fullpath = (*i).to_string();
1131
1132 /* remove any trailing / */
1133
1134 if (fullpath[fullpath.length()-1] == '/') {
1135 fullpath = fullpath.substr (0, fullpath.length()-1);
1136 }
1137
1138 /* check whether session still exists */
1139 if (!Glib::file_test(fullpath.c_str(), Glib::FILE_TEST_EXISTS)) {
1140 /* session doesn't exist */
1141 cerr << "skipping non-existent session " << fullpath << endl;
1142 continue;
1143 }
1144
1145 /* now get available states for this session */
1146
1147 if ((states = Session::possible_states (fullpath)) == 0) {
1148 /* no state file? */
1149 continue;
1150 }
1151
1152 std::vector<string> state_file_names(get_file_names_no_extension (state_file_paths));
1153
1154 Gtk::TreeModel::Row row = *(recent_session_model->append());
1155
1156 row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
1157 row[recent_session_columns.fullpath] = fullpath;
1158
1159 if (state_file_names.size() > 1) {
1160
1161 // add the children
1162
1163 for (std::vector<std::string>::iterator i2 = state_file_names.begin();
1164 i2 != state_file_names.end(); ++i2)
1165 {
1166
1167 Gtk::TreeModel::Row child_row = *(recent_session_model->append (row.children()));
1168
1169 child_row[recent_session_columns.visible_name] = *i2;
1170 child_row[recent_session_columns.fullpath] = fullpath;
1171 }
1172 }
1173 }
1174
1175 recent_session_display.set_model (recent_session_model);
1176 }
1177
1178 void
1179 ARDOUR_UI::build_session_selector ()
1180 {
1181 session_selector_window = new ArdourDialog (_("Recent Sessions"));
1182
1183 Gtk::ScrolledWindow *scroller = manage (new Gtk::ScrolledWindow);
1184
1185 session_selector_window->add_button (Stock::CANCEL, RESPONSE_CANCEL);
1186 session_selector_window->add_button (Stock::OPEN, RESPONSE_ACCEPT);
1187 session_selector_window->set_default_response (RESPONSE_ACCEPT);
1188 recent_session_model = TreeStore::create (recent_session_columns);
1189 recent_session_display.set_model (recent_session_model);
1190 recent_session_display.append_column (_("Recent Sessions"), recent_session_columns.visible_name);
1191 recent_session_display.set_headers_visible (false);
1192 recent_session_display.get_selection()->set_mode (SELECTION_BROWSE);
1193 recent_session_display.signal_row_activated().connect (sigc::mem_fun (*this, &ARDOUR_UI::recent_session_row_activated));
1194
1195 scroller->add (recent_session_display);
1196 scroller->set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1197
1198 session_selector_window->set_name ("SessionSelectorWindow");
1199 session_selector_window->set_size_request (200, 400);
1200 session_selector_window->get_vbox()->pack_start (*scroller);
1201
1202 recent_session_display.show();
1203 scroller->show();
1204 //session_selector_window->get_vbox()->show();
1205 }
1206
1207 void
1208 ARDOUR_UI::recent_session_row_activated (const TreePath& /*path*/, TreeViewColumn* /*col*/)
1209 {
1210 session_selector_window->response (RESPONSE_ACCEPT);
1211 }
1212
1213 void
1214 ARDOUR_UI::open_recent_session ()
1215 {
1216 bool can_return = (_session != 0);
1217
1218 if (session_selector_window == 0) {
1219 build_session_selector ();
1220 }
1221
1222 redisplay_recent_sessions ();
1223
1224 while (true) {
1225
1226 session_selector_window->set_position (WIN_POS_MOUSE);
1227
1228 ResponseType r = (ResponseType) session_selector_window->run ();
1229
1230 switch (r) {
1231 case RESPONSE_ACCEPT:
1232 break;
1233 default:
1234 if (can_return) {
1235 session_selector_window->hide();
1236 return;
1237 } else {
1238 exit (1);
1239 }
1240 }
1241
1242 if (recent_session_display.get_selection()->count_selected_rows() == 0) {
1243 continue;
1244 }
1245
1246 session_selector_window->hide();
1247
1248 Gtk::TreeModel::iterator i = recent_session_display.get_selection()->get_selected();
1249
1250 if (i == recent_session_model->children().end()) {
1251 return;
1252 }
1253
1254 std::string path = (*i)[recent_session_columns.fullpath];
1255 std::string state = (*i)[recent_session_columns.visible_name];
1256
1257 _session_is_new = false;
1258
1259 if (load_session (path, state) == 0) {
1260 break;
1261 }
1262
1263 can_return = false;
1264 }
1265 }
1266
1267 bool
1268 ARDOUR_UI::check_audioengine ()
1269 {
1270 if (engine) {
1271 if (!engine->connected()) {
1272 MessageDialog msg (string_compose (_("%1 is not connected to JACK\n"
1273 "You cannot open or close sessions in this condition"),
1274 PROGRAM_NAME));
1275 pop_back_splash ();
1276 msg.run ();
1277 return false;
1278 }
1279 return true;
1280 } else {
1281 return false;
1282 }
1283 }
1284
1285 void
1286 ARDOUR_UI::open_session ()
1287 {
1288 if (!check_audioengine()) {
1289 return;
1290
1291 }
1292
1293 /* popup selector window */
1294
1295 if (open_session_selector == 0) {
1296
1297 /* ardour sessions are folders */
1298
1299 open_session_selector = new Gtk::FileChooserDialog (_("Open Session"), FILE_CHOOSER_ACTION_OPEN);
1300 open_session_selector->add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1301 open_session_selector->add_button (Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
1302 open_session_selector->set_default_response(Gtk::RESPONSE_ACCEPT);
1303
1304 FileFilter session_filter;
1305 session_filter.add_pattern ("*.ardour");
1306 session_filter.set_name (string_compose (_("%1 sessions"), PROGRAM_NAME));
1307 open_session_selector->add_filter (session_filter);
1308 open_session_selector->set_filter (session_filter);
1309 }
1310
1311 int response = open_session_selector->run();
1312 open_session_selector->hide ();
1313
1314 switch (response) {
1315 case RESPONSE_ACCEPT:
1316 break;
1317 default:
1318 open_session_selector->hide();
1319 return;
1320 }
1321
1322 open_session_selector->hide();
1323 string session_path = open_session_selector->get_filename();
1324 string path, name;
1325 bool isnew;
1326
1327 if (session_path.length() > 0) {
1328 if (ARDOUR::find_session (session_path, path, name, isnew) == 0) {
1329 _session_is_new = isnew;
1330 load_session (path, name);
1331 }
1332 }
1333 }
1334
1335
1336 void
1337 ARDOUR_UI::session_add_midi_route (bool disk, RouteGroup* route_group, uint32_t how_many)
1338 {
1339 list<boost::shared_ptr<MidiTrack> > tracks;
1340
1341 if (_session == 0) {
1342 warning << _("You cannot add a track without a session already loaded.") << endmsg;
1343 return;
1344 }
1345
1346 try {
1347 if (disk) {
1348
1349 tracks = _session->new_midi_track (ARDOUR::Normal, route_group, how_many);
1350
1351 if (tracks.size() != how_many) {
1352 if (how_many == 1) {
1353 error << _("could not create a new midi track") << endmsg;
1354 } else {
1355 error << string_compose (_("could not create %1 new midi tracks"), how_many) << endmsg;
1356 }
1357 }
1358 } /*else {
1359 if ((route = _session->new_midi_route ()) == 0) {
1360 error << _("could not create new midi bus") << endmsg;
1361 }
1362 }*/
1363 }
1364
1365 catch (...) {
1366 MessageDialog msg (*editor,
1367 string_compose (_("There are insufficient JACK ports available\n\
1368 to create a new track or bus.\n\
1369 You should save %1, exit and\n\
1370 restart JACK with more ports."), PROGRAM_NAME));
1371 msg.run ();
1372 }
1373 }
1374
1375
1376 void
1377 ARDOUR_UI::session_add_audio_route (bool track, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode, RouteGroup* route_group, uint32_t how_many)
1378 {
1379 list<boost::shared_ptr<AudioTrack> > tracks;
1380 RouteList routes;
1381
1382 if (_session == 0) {
1383 warning << _("You cannot add a track or bus without a session already loaded.") << endmsg;
1384 return;
1385 }
1386
1387 try {
1388 if (track) {
1389 tracks = _session->new_audio_track (input_channels, output_channels, mode, route_group, how_many);
1390
1391 if (tracks.size() != how_many) {
1392 if (how_many == 1) {
1393 error << _("could not create a new audio track") << endmsg;
1394 } else {
1395 error << string_compose (_("could only create %1 of %2 new audio %3"),
1396 tracks.size(), how_many, (track ? _("tracks") : _("busses"))) << endmsg;
1397 }
1398 }
1399
1400 } else {
1401
1402 routes = _session->new_audio_route (input_channels, output_channels, route_group, how_many);
1403
1404 if (routes.size() != how_many) {
1405 if (how_many == 1) {
1406 error << _("could not create a new audio track") << endmsg;
1407 } else {
1408 error << string_compose (_("could not create %1 new audio tracks"), how_many) << endmsg;
1409 }
1410 }
1411 }
1412 }
1413
1414 catch (...) {
1415 MessageDialog msg (*editor,
1416 string_compose (_("There are insufficient JACK ports available\n\
1417 to create a new track or bus.\n\
1418 You should save %1, exit and\n\
1419 restart JACK with more ports."), PROGRAM_NAME));
1420 pop_back_splash ();
1421 msg.run ();
1422 }
1423 }
1424
1425 void
1426 ARDOUR_UI::do_transport_locate (framepos_t new_position, bool with_roll)
1427 {
1428 framecnt_t _preroll = 0;
1429
1430 if (_session) {
1431 // XXX CONFIG_CHANGE FIX - requires AnyTime handling
1432 // _preroll = _session->convert_to_frames_at (new_position, Config->get_preroll());
1433
1434 if (new_position > _preroll) {
1435 new_position -= _preroll;
1436 } else {
1437 new_position = 0;
1438 }
1439
1440 _session->request_locate (new_position, with_roll);
1441 }
1442 }
1443
1444 void
1445 ARDOUR_UI::transport_goto_start ()
1446 {
1447 if (_session) {
1448 _session->goto_start();
1449
1450 /* force displayed area in editor to start no matter
1451 what "follow playhead" setting is.
1452 */
1453
1454 if (editor) {
1455 editor->center_screen (_session->current_start_frame ());
1456 }
1457 }
1458 }
1459
1460 void
1461 ARDOUR_UI::transport_goto_zero ()
1462 {
1463 if (_session) {
1464 _session->request_locate (0);
1465
1466 /* force displayed area in editor to start no matter
1467 what "follow playhead" setting is.
1468 */
1469
1470 if (editor) {
1471 editor->reset_x_origin (0);
1472 }
1473 }
1474 }
1475
1476 void
1477 ARDOUR_UI::transport_goto_wallclock ()
1478 {
1479 if (_session && editor) {
1480
1481 time_t now;
1482 struct tm tmnow;
1483 framepos_t frames;
1484
1485 time (&now);
1486 localtime_r (&now, &tmnow);
1487
1488 frames = tmnow.tm_hour * (60 * 60 * _session->frame_rate());
1489 frames += tmnow.tm_min * (60 * _session->frame_rate());
1490 frames += tmnow.tm_sec * _session->frame_rate();
1491
1492 _session->request_locate (frames, _session->transport_rolling ());
1493
1494 /* force displayed area in editor to start no matter
1495 what "follow playhead" setting is.
1496 */
1497
1498 if (editor) {
1499 editor->center_screen (frames);
1500 }
1501 }
1502 }
1503
1504 void
1505 ARDOUR_UI::transport_goto_end ()
1506 {
1507 if (_session) {
1508 framepos_t const frame = _session->current_end_frame();
1509 _session->request_locate (frame);
1510
1511 /* force displayed area in editor to start no matter
1512 what "follow playhead" setting is.
1513 */
1514
1515 if (editor) {
1516 editor->center_screen (frame);
1517 }
1518 }
1519 }
1520
1521 void
1522 ARDOUR_UI::transport_stop ()
1523 {
1524 if (!_session) {
1525 return;
1526 }
1527
1528 if (_session->is_auditioning()) {
1529 _session->cancel_audition ();
1530 return;
1531 }
1532
1533 _session->request_stop (false, true);
1534 }
1535
1536 void
1537 ARDOUR_UI::transport_stop_and_forget_capture ()
1538 {
1539 if (_session) {
1540 _session->request_stop (true, true);
1541 }
1542 }
1543
1544 void
1545 ARDOUR_UI::remove_last_capture()
1546 {
1547 if (editor) {
1548 editor->remove_last_capture();
1549 }
1550 }
1551
1552 void
1553 ARDOUR_UI::transport_record (bool roll)
1554 {
1555
1556 if (_session) {
1557 switch (_session->record_status()) {
1558 case Session::Disabled:
1559 if (_session->ntracks() == 0) {
1560 MessageDialog msg (*editor, _("Please create 1 or more track\nbefore trying to record.\nCheck the Session menu."));
1561 msg.run ();
1562 return;
1563 }
1564 _session->maybe_enable_record ();
1565 if (roll) {
1566 transport_roll ();
1567 }
1568 break;
1569 case Session::Recording:
1570 if (roll) {
1571 _session->request_stop();
1572 } else {
1573 _session->disable_record (false, true);
1574 }
1575 break;
1576
1577 case Session::Enabled:
1578 _session->disable_record (false, true);
1579 }
1580 }
1581 //cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " _session->record_status() = " << _session->record_status() << endl;
1582 }
1583
1584 void
1585 ARDOUR_UI::transport_roll ()
1586 {
1587 if (!_session) {
1588 return;
1589 }
1590
1591 if (_session->is_auditioning()) {
1592 return;
1593 }
1594
1595 #if 0
1596 if (_session->config.get_external_sync()) {
1597 switch (_session->config.get_sync_source()) {
1598 case JACK:
1599 break;
1600 default:
1601 /* transport controlled by the master */
1602 return;
1603 }
1604 }
1605 #endif
1606
1607 bool rolling = _session->transport_rolling();
1608
1609 if (_session->get_play_loop()) {
1610 /* XXX it is not possible to just leave seamless loop and keep
1611 playing at present (nov 4th 2009)
1612 */
1613 if (!Config->get_seamless_loop()) {
1614 _session->request_play_loop (false, true);
1615 }
1616 } else if (_session->get_play_range () && !join_play_range_button.get_active()) {
1617 /* stop playing a range if we currently are */
1618 _session->request_play_range (0, true);
1619 }
1620
1621 if (join_play_range_button.get_active()) {
1622 _session->request_play_range (&editor->get_selection().time, true);
1623 }
1624
1625 if (!rolling) {
1626 _session->request_transport_speed (1.0f);
1627 }
1628 }
1629
1630 void
1631 ARDOUR_UI::toggle_roll (bool with_abort, bool roll_out_of_bounded_mode)
1632 {
1633
1634 if (!_session) {
1635 return;
1636 }
1637
1638 if (_session->is_auditioning()) {
1639 _session->cancel_audition ();
1640 return;
1641 }
1642
1643 #if 0
1644 if (_session->config.get_external_sync()) {
1645 switch (_session->config.get_sync_source()) {
1646 case JACK:
1647 break;
1648 default:
1649 /* transport controlled by the master */
1650 return;
1651 }
1652 }
1653 #endif
1654
1655 bool rolling = _session->transport_rolling();
1656 bool affect_transport = true;
1657
1658 if (rolling && roll_out_of_bounded_mode) {
1659 /* drop out of loop/range playback but leave transport rolling */
1660 if (_session->get_play_loop()) {
1661 if (Config->get_seamless_loop()) {
1662 /* the disk buffers contain copies of the loop - we can't
1663 just keep playing, so stop the transport. the user
1664 can restart as they wish.
1665 */
1666 affect_transport = true;
1667 } else {
1668 /* disk buffers are normal, so we can keep playing */
1669 affect_transport = false;
1670 }
1671 _session->request_play_loop (false, true);
1672 } else if (_session->get_play_range ()) {
1673 affect_transport = false;
1674 _session->request_play_range (0, true);
1675 }
1676 }
1677
1678 if (affect_transport) {
1679 if (rolling) {
1680 _session->request_stop (with_abort, true);
1681 } else {
1682 if (join_play_range_button.get_active()) {
1683 _session->request_play_range (&editor->get_selection().time, true);
1684 }
1685
1686 _session->request_transport_speed (1.0f);
1687 }
1688 }
1689 }
1690
1691 void
1692 ARDOUR_UI::toggle_session_auto_loop ()
1693 {
1694 if (!_session) {
1695 return;
1696 }
1697
1698 if (_session->get_play_loop()) {
1699
1700 if (_session->transport_rolling()) {
1701
1702 Location * looploc = _session->locations()->auto_loop_location();
1703
1704 if (looploc) {
1705 _session->request_locate (looploc->start(), true);
1706 _session->request_play_loop (false);
1707 }
1708
1709 } else {
1710 _session->request_play_loop (false);
1711 }
1712 } else {
1713
1714 Location * looploc = _session->locations()->auto_loop_location();
1715
1716 if (looploc) {
1717 _session->request_play_loop (true);
1718 }
1719 }
1720 }
1721
1722 void
1723 ARDOUR_UI::transport_play_selection ()
1724 {
1725 if (!_session) {
1726 return;
1727 }
1728
1729 editor->play_selection ();
1730 }
1731
1732 void
1733 ARDOUR_UI::transport_rewind (int option)
1734 {
1735 float current_transport_speed;
1736
1737 if (_session) {
1738 current_transport_speed = _session->transport_speed();
1739
1740 if (current_transport_speed >= 0.0f) {
1741 switch (option) {
1742 case 0:
1743 _session->request_transport_speed (-1.0f);
1744 break;
1745 case 1:
1746 _session->request_transport_speed (-4.0f);
1747 break;
1748 case -1:
1749 _session->request_transport_speed (-0.5f);
1750 break;
1751 }
1752 } else {
1753 /* speed up */
1754 _session->request_transport_speed (current_transport_speed * 1.5f);
1755 }
1756 }
1757 }
1758
1759 void
1760 ARDOUR_UI::transport_forward (int option)
1761 {
1762 float current_transport_speed;
1763
1764 if (_session) {
1765 current_transport_speed = _session->transport_speed();
1766
1767 if (current_transport_speed <= 0.0f) {
1768 switch (option) {
1769 case 0:
1770 _session->request_transport_speed (1.0f);
1771 break;
1772 case 1:
1773 _session->request_transport_speed (4.0f);
1774 break;
1775 case -1:
1776 _session->request_transport_speed (0.5f);
1777 break;
1778 }
1779 } else {
1780 /* speed up */
1781 _session->request_transport_speed (current_transport_speed * 1.5f);
1782 }
1783
1784 }
1785 }
1786
1787 void
1788 ARDOUR_UI::toggle_record_enable (uint32_t rid)
1789 {
1790 if (_session == 0) {
1791 return;
1792 }
1793
1794 boost::shared_ptr<Route> r;
1795
1796 if ((r = _session->route_by_remote_id (rid)) != 0) {
1797
1798 Track* t;
1799
1800 if ((t = dynamic_cast<Track*>(r.get())) != 0) {
1801 t->set_record_enabled (!t->record_enabled(), this);
1802 }
1803 }
1804 if (_session == 0) {
1805 return;
1806 }
1807 }
1808
1809 void
1810 ARDOUR_UI::map_transport_state ()
1811 {
1812 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::map_transport_state)
1813
1814 if (!_session) {
1815 auto_loop_button.set_visual_state (0);
1816 play_selection_button.set_visual_state (0);
1817 roll_button.set_visual_state (0);
1818 stop_button.set_visual_state (1);
1819 return;
1820 }
1821
1822 float sp = _session->transport_speed();
1823
1824 if (sp == 1.0f) {
1825 shuttle_fract = SHUTTLE_FRACT_SPEED1; /* speed = 1.0, believe it or not */
1826 shuttle_box.queue_draw ();
1827 } else if (sp == 0.0f) {
1828 shuttle_fract = 0;
1829 shuttle_box.queue_draw ();
1830 update_disk_space ();
1831 }
1832
1833 if (sp != 0.0) {
1834
1835 /* we're rolling */
1836
1837 if (_session->get_play_range()) {
1838
1839 play_selection_button.set_visual_state (1);
1840 roll_button.set_visual_state (0);
1841 auto_loop_button.set_visual_state (0);
1842
1843 } else if (_session->get_play_loop ()) {
1844
1845 auto_loop_button.set_visual_state (1);
1846 play_selection_button.set_visual_state (0);
1847 roll_button.set_visual_state (0);
1848
1849 } else {
1850
1851 roll_button.set_visual_state (1);
1852 play_selection_button.set_visual_state (0);
1853 auto_loop_button.set_visual_state (0);
1854 }
1855
1856 if (join_play_range_button.get_active()) {
1857 /* light up both roll and play-selection if they are joined */
1858 roll_button.set_visual_state (1);
1859 play_selection_button.set_visual_state (1);
1860 }
1861
1862 stop_button.set_visual_state (0);
1863
1864 } else {
1865
1866 stop_button.set_visual_state (1);
1867 roll_button.set_visual_state (0);
1868 play_selection_button.set_visual_state (0);
1869 auto_loop_button.set_visual_state (0);
1870 }
1871 }
1872
1873 void
1874 ARDOUR_UI::engine_stopped ()
1875 {
1876 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_stopped)
1877 ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
1878 ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
1879 }
1880
1881 void
1882 ARDOUR_UI::engine_running ()
1883 {
1884 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::engine_running)
1885 ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, true);
1886 ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, false);
1887
1888 Glib::RefPtr<Action> action;
1889 const char* action_name = 0;
1890
1891 switch (engine->frames_per_cycle()) {
1892 case 32:
1893 action_name = X_("JACKLatency32");
1894 break;
1895 case 64:
1896 action_name = X_("JACKLatency64");
1897 break;
1898 case 128:
1899 action_name = X_("JACKLatency128");
1900 break;
1901 case 512:
1902 action_name = X_("JACKLatency512");
1903 break;
1904 case 1024:
1905 action_name = X_("JACKLatency1024");
1906 break;
1907 case 2048:
1908 action_name = X_("JACKLatency2048");
1909 break;
1910 case 4096:
1911 action_name = X_("JACKLatency4096");
1912 break;
1913 case 8192:
1914 action_name = X_("JACKLatency8192");
1915 break;
1916 default:
1917 /* XXX can we do anything useful ? */
1918 break;
1919 }
1920
1921 if (action_name) {
1922
1923 action = ActionManager::get_action (X_("JACK"), action_name);
1924
1925 if (action) {
1926 Glib::RefPtr<RadioAction> ract = Glib::RefPtr<RadioAction>::cast_dynamic (action);
1927 ract->set_active ();
1928 }
1929 }
1930 }
1931
1932 void
1933 ARDOUR_UI::engine_halted (const char* reason, bool free_reason)
1934 {
1935 if (!Gtkmm2ext::UI::instance()->caller_is_ui_thread()) {
1936 /* we can't rely on the original string continuing to exist when we are called
1937 again in the GUI thread, so make a copy and note that we need to
1938 free it later.
1939 */
1940 char *copy = strdup (reason);
1941 Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&ARDOUR_UI::engine_halted, this, copy, true));
1942 return;
1943 }
1944
1945 ActionManager::set_sensitive (ActionManager::jack_sensitive_actions, false);
1946 ActionManager::set_sensitive (ActionManager::jack_opposite_sensitive_actions, true);
1947
1948 update_sample_rate (0);
1949
1950 string msgstr;
1951
1952 /* if the reason is a non-empty string, it means that the backend was shutdown
1953 rather than just Ardour.
1954 */
1955
1956 if (strlen (reason)) {
1957 msgstr = string_compose (_("The audio backend (JACK) was shutdown because:\n\n%1"), reason);
1958 } else {
1959 msgstr = string_compose (_("\
1960 JACK has either been shutdown or it\n\
1961 disconnected %1 because %1\n\
1962 was not fast enough. Try to restart\n\
1963 JACK, reconnect and save the session."), PROGRAM_NAME);
1964 }
1965
1966 MessageDialog msg (*editor, msgstr);
1967 pop_back_splash ();
1968 msg.run ();
1969
1970 if (free_reason) {
1971 free ((char*) reason);
1972 }
1973 }
1974
1975 int32_t
1976 ARDOUR_UI::do_engine_start ()
1977 {
1978 try {
1979 engine->start();
1980 }
1981
1982 catch (...) {
1983 engine->stop ();
1984 error << _("Unable to start the session running")
1985 << endmsg;
1986 unload_session ();
1987 return -2;
1988 }
1989
1990 return 0;
1991 }
1992
1993 void
1994 ARDOUR_UI::setup_theme ()
1995 {
1996 theme_manager->setup_theme();
1997 }
1998
1999 void
2000 ARDOUR_UI::update_clocks ()
2001 {
2002 if (!editor || !editor->dragging_playhead()) {
2003 Clock (_session->audible_frame(), false, editor->get_preferred_edit_position()); /* EMIT_SIGNAL */
2004 }
2005 }
2006
2007 void
2008 ARDOUR_UI::start_clocking ()
2009 {
2010 clock_signal_connection = RapidScreenUpdate.connect (sigc::mem_fun(*this, &ARDOUR_UI::update_clocks));
2011 }
2012
2013 void
2014 ARDOUR_UI::stop_clocking ()
2015 {
2016 clock_signal_connection.disconnect ();
2017 }
2018
2019 void
2020 ARDOUR_UI::toggle_clocking ()
2021 {
2022 #if 0
2023 if (clock_button.get_active()) {
2024 start_clocking ();
2025 } else {
2026 stop_clocking ();
2027 }
2028 #endif
2029 }
2030
2031 gint
2032 ARDOUR_UI::_blink (void *arg)
2033
2034 {
2035 ((ARDOUR_UI *) arg)->blink ();
2036 return TRUE;
2037 }
2038
2039 void
2040 ARDOUR_UI::blink ()
2041 {
2042 Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
2043 }
2044
2045 void
2046 ARDOUR_UI::start_blinking ()
2047 {
2048 /* Start the blink signal. Everybody with a blinking widget
2049 uses Blink to drive the widget's state.
2050 */
2051
2052 if (blink_timeout_tag < 0) {
2053 blink_on = false;
2054 blink_timeout_tag = g_timeout_add (240, _blink, this);
2055 }
2056 }
2057
2058 void
2059 ARDOUR_UI::stop_blinking ()
2060 {
2061 if (blink_timeout_tag >= 0) {
2062 g_source_remove (blink_timeout_tag);
2063 blink_timeout_tag = -1;
2064 }
2065 }
2066
2067
2068 /** Ask the user for the name of a new shapshot and then take it.
2069 */
2070
2071 void
2072 ARDOUR_UI::snapshot_session (bool switch_to_it)
2073 {
2074 ArdourPrompter prompter (true);
2075 string snapname;
2076
2077 prompter.set_name ("Prompter");
2078 prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
2079 prompter.set_title (_("Take Snapshot"));
2080 prompter.set_title (_("Take Snapshot"));
2081 prompter.set_prompt (_("Name of new snapshot"));
2082
2083 if (!switch_to_it) {
2084 char timebuf[128];
2085 time_t n;
2086 struct tm local_time;
2087
2088 time (&n);
2089 localtime_r (&n, &local_time);
2090 strftime (timebuf, sizeof(timebuf), "%FT%T", &local_time);
2091 prompter.set_initial_text (timebuf);
2092 }
2093
2094 again:
2095 switch (prompter.run()) {
2096 case RESPONSE_ACCEPT:
2097 {
2098 prompter.get_result (snapname);
2099
2100 bool do_save = (snapname.length() != 0);
2101
2102 if (do_save) {
2103 if (snapname.find ('/') != string::npos) {
2104 MessageDialog msg (_("To ensure compatibility with various systems\n"
2105 "snapshot names may not contain a '/' character"));
2106 msg.run ();
2107 goto again;
2108 }
2109 if (snapname.find ('\\') != string::npos) {
2110 MessageDialog msg (_("To ensure compatibility with various systems\n"
2111 "snapshot names may not contain a '\\' character"));
2112 msg.run ();
2113 goto again;
2114 }
2115 }
2116
2117 vector<sys::path> p;
2118 get_state_files_in_directory (_session->session_directory().root_path(), p);
2119 vector<string> n = get_file_names_no_extension (p);
2120 if (find (n.begin(), n.end(), snapname) != n.end()) {
2121
2122 ArdourDialog confirm (_("Confirm Snapshot Overwrite"), true);
2123 Label m (_("A snapshot already exists with that name. Do you want to overwrite it?"));
2124 confirm.get_vbox()->pack_start (m, true, true);
2125 confirm.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2126 confirm.add_button (_("Overwrite"), Gtk::RESPONSE_ACCEPT);
2127 confirm.show_all ();
2128 switch (confirm.run()) {
2129 case RESPONSE_CANCEL:
2130 do_save = false;
2131 }
2132 }
2133
2134 if (do_save) {
2135 save_state (snapname, switch_to_it);
2136 }
2137 break;
2138 }
2139
2140 default:
2141 break;
2142 }
2143 }
2144
2145 void
2146 ARDOUR_UI::save_state (const string & name, bool switch_to_it)
2147 {
2148 XMLNode* node = new XMLNode (X_("UI"));
2149
2150 for (list<WindowProxyBase*>::iterator i = _window_proxies.begin(); i != _window_proxies.end(); ++i) {
2151 if (!(*i)->rc_configured()) {
2152 node->add_child_nocopy (*((*i)->get_state ()));
2153 }
2154 }
2155
2156 _session->add_extra_xml (*node);
2157
2158 save_state_canfail (name, switch_to_it);
2159 }
2160
2161 int
2162 ARDOUR_UI::save_state_canfail (string name, bool switch_to_it)
2163 {
2164 if (_session) {
2165 int ret;
2166
2167 if (name.length() == 0) {
2168 name = _session->snap_name();
2169 }
2170
2171 if ((ret = _session->save_state (name, false, switch_to_it)) != 0) {
2172 return ret;
2173 }
2174 }
2175 cerr << "SS canfail\n";
2176 save_ardour_state (); /* XXX cannot fail? yeah, right ... */
2177 return 0;
2178 }
2179
2180 void
2181 ARDOUR_UI::primary_clock_value_changed ()
2182 {
2183 if (_session) {
2184 _session->request_locate (primary_clock.current_time ());
2185 }
2186 }
2187
2188 void
2189 ARDOUR_UI::big_clock_value_changed ()
2190 {
2191 if (_session) {
2192 _session->request_locate (big_clock.current_time ());
2193 }
2194 }
2195
2196 void
2197 ARDOUR_UI::secondary_clock_value_changed ()
2198 {
2199 if (_session) {
2200 _session->request_locate (secondary_clock.current_time ());
2201 }
2202 }
2203
2204 void
2205 ARDOUR_UI::transport_rec_enable_blink (bool onoff)
2206 {
2207 if (_session == 0) {
2208 return;
2209 }
2210
2211 if (_session->step_editing()) {
2212 return;
2213 }
2214
2215 Session::RecordState const r = _session->record_status ();
2216 bool const h = _session->have_rec_enabled_track ();
2217
2218 if (r == Session::Enabled || (r == Session::Recording && !h)) {
2219 if (onoff) {
2220 rec_button.set_visual_state (2);
2221 } else {
2222 rec_button.set_visual_state (0);
2223 }
2224 } else if (r == Session::Recording && h) {
2225 rec_button.set_visual_state (1);
2226 } else {
2227 rec_button.set_visual_state (0);
2228 }
2229 }
2230
2231 void
2232 ARDOUR_UI::save_template ()
2233 {
2234 ArdourPrompter prompter (true);
2235 string name;
2236
2237 if (!check_audioengine()) {
2238 return;
2239 }
2240
2241 prompter.set_name (X_("Prompter"));
2242 prompter.set_title (_("Save Template"));
2243 prompter.set_prompt (_("Name for template:"));
2244 prompter.set_initial_text(_session->name() + _("-template"));
2245 prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
2246
2247 switch (prompter.run()) {
2248 case RESPONSE_ACCEPT:
2249 prompter.get_result (name);
2250
2251 if (name.length()) {
2252 _session->save_template (name);
2253 }
2254 break;
2255
2256 default:
2257 break;
2258 }
2259 }
2260
2261 void
2262 ARDOUR_UI::edit_metadata ()
2263 {
2264 SessionMetadataEditor dialog;
2265 dialog.set_session (_session);
2266 editor->ensure_float (dialog);
2267 dialog.run ();
2268 }
2269
2270 void
2271 ARDOUR_UI::import_metadata ()
2272 {
2273 SessionMetadataImporter dialog;
2274 dialog.set_session (_session);
2275 editor->ensure_float (dialog);
2276 dialog.run ();
2277 }
2278
2279 void
2280 ARDOUR_UI::fontconfig_dialog ()
2281 {
2282 #ifdef GTKOSX
2283 /* X11 users will always have fontconfig info around, but new GTK-OSX users
2284 may not and it can take a while to build it. Warn them.
2285 */
2286
2287 std::string fontconfig = Glib::build_filename (Glib::get_home_dir(), ".fontconfig");
2288
2289 if (!Glib::file_test (fontconfig, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
2290 MessageDialog msg (*_startup,
2291 string_compose (_("Welcome to %1.\n\n"
2292 "The program will take a bit longer to start up\n"
2293 "while the system fonts are checked.\n\n"
2294 "This will only be done once, and you will\n"
2295 "not see this message again\n"), PROGRAM_NAME),
2296 true,
2297 Gtk::MESSAGE_INFO,
2298 Gtk::BUTTONS_OK);
2299 pop_back_splash ();
2300 msg.show_all ();
2301 msg.present ();
2302 msg.run ();
2303 }
2304 #endif
2305 }
2306
2307 void
2308 ARDOUR_UI::parse_cmdline_path (const std::string& cmdline_path, std::string& session_name, std::string& session_path, bool& existing_session)
2309 {
2310 existing_session = false;
2311
2312 if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_DIR)) {
2313 session_path = cmdline_path;
2314 existing_session = true;
2315 } else if (Glib::file_test (cmdline_path, Glib::FILE_TEST_IS_REGULAR)) {
2316 session_path = Glib::path_get_dirname (string (cmdline_path));
2317 existing_session = true;
2318 } else {
2319 /* it doesn't exist, assume the best */
2320 session_path = Glib::path_get_dirname (string (cmdline_path));
2321 }
2322
2323 session_name = basename_nosuffix (string (cmdline_path));
2324 }
2325
2326 int
2327 ARDOUR_UI::load_cmdline_session (const std::string& session_name, const std::string& session_path, bool& existing_session)
2328 {
2329 /* when this is called, the backend audio system must be running */
2330
2331 /* the main idea here is to deal with the fact that a cmdline argument for the session
2332 can be interpreted in different ways - it could be a directory or a file, and before
2333 we load, we need to know both the session directory and the snapshot (statefile) within it
2334 that we are supposed to use.
2335 */
2336
2337 if (session_name.length() == 0 || session_path.length() == 0) {
2338 return false;
2339 }
2340
2341 if (Glib::file_test (session_path, Glib::FILE_TEST_IS_DIR)) {
2342
2343 std::string predicted_session_file;
2344
2345 predicted_session_file = session_path;
2346 predicted_session_file += '/';
2347 predicted_session_file += session_name;
2348 predicted_session_file += ARDOUR::statefile_suffix;
2349
2350 if (Glib::file_test (predicted_session_file, Glib::FILE_TEST_EXISTS)) {
2351 existing_session = true;
2352 }
2353
2354 } else if (Glib::file_test (session_path, Glib::FILE_TEST_EXISTS)) {
2355
2356 if (session_path.find (ARDOUR::statefile_suffix) == session_path.length() - 7) {
2357 /* existing .ardour file */
2358 existing_session = true;
2359 }
2360
2361 } else {
2362 existing_session = false;
2363 }
2364
2365 /* lets just try to load it */
2366
2367 if (create_engine ()) {
2368 backend_audio_error (false, _startup);
2369 return -1;
2370 }
2371
2372 return load_session (session_path, session_name);
2373 }
2374
2375 bool
2376 ARDOUR_UI::ask_about_loading_existing_session (const std::string& session_path)
2377 {
2378 std::string str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
2379
2380 MessageDialog msg (str,
2381 false,
2382 Gtk::MESSAGE_WARNING,
2383 Gtk::BUTTONS_YES_NO,
2384 true);
2385
2386
2387 msg.set_name (X_("OpenExistingDialog"));
2388 msg.set_title (_("Open Existing Session"));
2389 msg.set_wmclass (X_("existing_session"), PROGRAM_NAME);
2390 msg.set_position (Gtk::WIN_POS_MOUSE);
2391 pop_back_splash ();
2392
2393 switch (msg.run()) {
2394 case RESPONSE_YES:
2395 return true;
2396 break;
2397 }
2398 return false;
2399 }
2400
2401 int
2402 ARDOUR_UI::build_session_from_nsd (const std::string& session_path, const std::string& session_name)
2403 {
2404 BusProfile bus_profile;
2405
2406 if (Profile->get_sae()) {
2407
2408 bus_profile.master_out_channels = 2;
2409 bus_profile.input_ac = AutoConnectPhysical;
2410 bus_profile.output_ac = AutoConnectMaster;
2411 bus_profile.requested_physical_in = 0; // use all available
2412 bus_profile.requested_physical_out = 0; // use all available
2413
2414 } else {
2415
2416 /* get settings from advanced section of NSD */
2417
2418 if (_startup->create_master_bus()) {
2419 bus_profile.master_out_channels = (uint32_t) _startup->master_channel_count();
2420 } else {
2421 bus_profile.master_out_channels = 0;
2422 }
2423
2424 if (_startup->connect_inputs()) {
2425 bus_profile.input_ac = AutoConnectPhysical;
2426 } else {
2427 bus_profile.input_ac = AutoConnectOption (0);
2428 }
2429
2430 /// @todo some minor tweaks.
2431
2432 bus_profile.output_ac = AutoConnectOption (0);
2433
2434 if (_startup->connect_outputs ()) {
2435 if (_startup->connect_outs_to_master()) {
2436 bus_profile.output_ac = AutoConnectMaster;
2437 } else if (_startup->connect_outs_to_physical()) {
2438 bus_profile.output_ac = AutoConnectPhysical;
2439 }
2440 }
2441
2442 bus_profile.requested_physical_in = (uint32_t) _startup->input_limit_count();
2443 bus_profile.requested_physical_out = (uint32_t) _startup->output_limit_count();
2444 }
2445
2446 if (build_session (session_path, session_name, bus_profile)) {
2447 return -1;
2448 }
2449
2450 return 0;
2451 }
2452
2453 void
2454 ARDOUR_UI::idle_load (const std::string& path)
2455 {
2456 if (_session) {
2457 if (Glib::file_test (path, Glib::FILE_TEST_IS_DIR)) {
2458 /* /path/to/foo => /path/to/foo, foo */
2459 load_session (path, basename_nosuffix (path));
2460 } else {
2461 /* /path/to/foo/foo.ardour => /path/to/foo, foo */
2462 load_session (Glib::path_get_dirname (path), basename_nosuffix (path));
2463 }
2464 } else {
2465
2466 ARDOUR_COMMAND_LINE::session_name = path;
2467
2468 /*
2469 * new_session_dialog doens't exist in A3
2470 * Try to remove all references to it to
2471 * see if it will compile. NOTE: this will
2472 * likely cause a runtime issue is my somewhat
2473 * uneducated guess.
2474 */
2475
2476 //if (new_session_dialog) {
2477
2478
2479 /* make it break out of Dialog::run() and
2480 start again.
2481 */
2482
2483 //new_session_dialog->response (1);
2484 //}
2485 }
2486 }
2487
2488 void
2489 ARDOUR_UI::end_loading_messages ()
2490 {
2491 // hide_splash ();
2492 }
2493
2494 void
2495 ARDOUR_UI::loading_message (const std::string& /*msg*/)
2496 {
2497 // show_splash ();
2498 // splash->message (msg);
2499 flush_pending ();
2500 }
2501
2502 /** @param quit_on_cancel true if exit() should be called if the user clicks `cancel' in the new session dialog */
2503 int
2504 ARDOUR_UI::get_session_parameters (bool quit_on_cancel, bool should_be_new, string load_template)
2505 {
2506 string session_name;
2507 string session_path;
2508 string template_name;
2509 int ret = -1;
2510 bool likely_new = false;
2511
2512 if (! load_template.empty()) {
2513 should_be_new = true;
2514 template_name = load_template;
2515 }
2516
2517 while (ret != 0) {
2518
2519 if (!should_be_new && !ARDOUR_COMMAND_LINE::session_name.empty()) {
2520
2521 /* if they named a specific statefile, use it, otherwise they are
2522 just giving a session folder, and we want to use it as is
2523 to find the session.
2524 */
2525
2526 if (ARDOUR_COMMAND_LINE::session_name.find (statefile_suffix) != string::npos) {
2527 session_path = Glib::path_get_dirname (ARDOUR_COMMAND_LINE::session_name);
2528 } else {
2529 session_path = ARDOUR_COMMAND_LINE::session_name;
2530 }
2531
2532 session_name = Glib::path_get_basename (ARDOUR_COMMAND_LINE::session_name);
2533
2534 } else {
2535
2536 bool const apply = run_startup (should_be_new, load_template);
2537
2538 if (!apply) {
2539 if (quit_on_cancel) {
2540 exit (1);
2541 } else {
2542 return ret;
2543 }
2544 }
2545
2546 /* if we run the startup dialog again, offer more than just "new session" */
2547
2548 should_be_new = false;
2549
2550 session_name = _startup->session_name (likely_new);
2551
2552 /* this shouldn't happen, but we catch it just in case it does */
2553
2554 if (session_name.empty()) {
2555 continue;
2556 }
2557
2558 if (_startup->use_session_template()) {
2559 template_name = _startup->session_template_name();
2560 _session_is_new = true;
2561 }
2562
2563 if (session_name[0] == G_DIR_SEPARATOR ||
2564 (session_name.length() > 2 && session_name[0] == '.' && session_name[1] == G_DIR_SEPARATOR) ||
2565 (session_name.length() > 3 && session_name[0] == '.' && session_name[1] == '.' && session_name[2] == G_DIR_SEPARATOR)) {
2566
2567 /* absolute path or cwd-relative path specified for session name: infer session folder
2568 from what was given.
2569 */
2570
2571 session_path = Glib::path_get_dirname (session_name);
2572 session_name = Glib::path_get_basename (session_name);
2573
2574 } else {
2575
2576 session_path = _startup->session_folder();
2577
2578 if (session_name.find ('/') != string::npos) {
2579 MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
2580 "session names may not contain a '/' character"));
2581 msg.run ();
2582 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
2583 continue;
2584 }
2585
2586 if (session_name.find ('\\') != string::npos) {
2587 MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
2588 "session names may not contain a '\\' character"));
2589 msg.run ();
2590 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
2591 continue;
2592 }
2593 }
2594 }
2595
2596 if (create_engine ()) {
2597 break;
2598 }
2599
2600 if (Glib::file_test (session_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
2601
2602 if (likely_new) {
2603
2604 std::string existing = Glib::build_filename (session_path, session_name);
2605
2606 if (!ask_about_loading_existing_session (existing)) {
2607 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
2608 continue;
2609 }
2610 }
2611
2612 _session_is_new = false;
2613
2614 } else {
2615
2616 if (!likely_new) {
2617 MessageDialog msg (string_compose (_("There is no existing session at \"%1\""), session_path));
2618 msg.run ();
2619 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
2620 continue;
2621 }
2622
2623 if (session_name.find ('/') != std::string::npos) {
2624 MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
2625 "session names may not contain a '/' character"));
2626 msg.run ();
2627 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
2628 continue;
2629 }
2630
2631 if (session_name.find ('\\') != std::string::npos) {
2632 MessageDialog msg (*_startup, _("To ensure compatibility with various systems\n"
2633 "session names may not contain a '\\' character"));
2634 msg.run ();
2635 ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
2636 continue;
2637 }
2638
2639 _session_is_new = true;
2640 }
2641
2642 if (likely_new && template_name.empty()) {
2643
2644 ret = build_session_from_nsd (session_path, session_name);
2645
2646 } else {
2647
2648 ret = load_session (session_path, session_name, template_name);
2649
2650 if (ret == -2) {
2651 /* not connected to the AudioEngine, so quit to avoid an infinite loop */
2652 exit (1);
2653 }
2654
2655 if (!ARDOUR_COMMAND_LINE::immediate_save.empty()) {
2656 _session->save_state (ARDOUR_COMMAND_LINE::immediate_save, false);
2657 exit (1);
2658 }
2659 }
2660 }
2661
2662 return ret;
2663 }
2664
2665 void
2666 ARDOUR_UI::close_session()
2667 {
2668 if (!check_audioengine()) {
2669 return;
2670 }
2671
2672 if (unload_session (true)) {
2673 return;
2674 }
2675
2676 ARDOUR_COMMAND_LINE::session_name = "";
2677
2678 if (get_session_parameters (true, false)) {
2679 exit (1);
2680 }
2681
2682 goto_editor_window ();
2683 }
2684
2685 /** @return -2 if the load failed because we are not connected to the AudioEngine */
2686 int
2687 ARDOUR_UI::load_session (const std::string& path, const std::string& snap_name, std::string mix_template)
2688 {
2689 Session *new_session;
2690 int unload_status;
2691 int retval = -1;
2692
2693 session_loaded = false;
2694
2695 if (!check_audioengine()) {
2696 return -2;
2697 }
2698
2699 unload_status = unload_session ();
2700
2701 if (unload_status < 0) {
2702 goto out;
2703 } else if (unload_status > 0) {
2704 retval = 0;
2705 goto out;
2706 }
2707
2708 loading_message (string_compose (_("Please wait while %1loads your session"), PROGRAM_NAME));
2709
2710 try {
2711 new_session = new Session (*engine, path, snap_name, 0, mix_template);
2712 }
2713
2714 /* this one is special */
2715
2716 catch (AudioEngine::PortRegistrationFailure& err) {
2717
2718 MessageDialog msg (err.what(),
2719 true,
2720 Gtk::MESSAGE_INFO,
2721 Gtk::BUTTONS_CLOSE);
2722
2723 msg.set_title (_("Port Registration Error"));
2724 msg.set_secondary_text (_("Click the Close button to try again."));
2725 msg.set_position (Gtk::WIN_POS_CENTER);
2726 pop_back_splash ();
2727 msg.present ();
2728
2729 int response = msg.run ();
2730
2731 msg.hide ();
2732
2733 switch (response) {
2734 case RESPONSE_CANCEL:
2735 exit (1);
2736 default:
2737 break;
2738 }
2739 goto out;
2740 }
2741
2742 catch (...) {
2743
2744 MessageDialog msg (string_compose(_("Session \"%1 (snapshot %2)\" did not load successfully"),path, snap_name),
2745 true,
2746 Gtk::MESSAGE_INFO,
2747 BUTTONS_OK);
2748
2749 msg.set_title (_("Loading Error"));
2750 msg.set_secondary_text (_("Click the Refresh button to try again."));
2751 msg.add_button (Stock::REFRESH, 1);
2752 msg.set_position (Gtk::WIN_POS_CENTER);
2753 pop_back_splash ();
2754 msg.present ();
2755
2756 int response = msg.run ();
2757
2758 switch (response) {
2759 case 1:
2760 break;
2761 default:
2762 exit (1);
2763 }
2764
2765 msg.hide ();
2766
2767 goto out;
2768 }
2769
2770 {
2771 list<string> const u = new_session->unknown_processors ();
2772 if (!u.empty()) {
2773 MissingPluginDialog d (_session, u);
2774 d.run ();
2775 }
2776 }
2777
2778 /* Now the session been created, add the transport controls */
2779 new_session->add_controllable(roll_controllable);
2780 new_session->add_controllable(stop_controllable);
2781 new_session->add_controllable(goto_start_controllable);
2782 new_session->add_controllable(goto_end_controllable);
2783 new_session->add_controllable(auto_loop_controllable);
2784 new_session->add_controllable(play_selection_controllable);
2785 new_session->add_controllable(rec_controllable);
2786
2787 set_session (new_session);
2788
2789 session_loaded = true;
2790
2791 goto_editor_window ();
2792
2793 if (_session) {
2794 _session->set_clean ();
2795 }
2796
2797 flush_pending ();
2798 retval = 0;
2799
2800 out:
2801 return retval;
2802 }
2803
2804 int
2805 ARDOUR_UI::build_session (const std::string& path, const std::string& snap_name, BusProfile& bus_profile)
2806 {
2807 Session *new_session;
2808 int x;
2809
2810 if (!check_audioengine()) {
2811 return -1;
2812 }
2813
2814 session_loaded = false;
2815
2816 x = unload_session ();
2817
2818 if (x < 0) {
2819 return -1;
2820 } else if (x > 0) {
2821 return 0;
2822 }
2823
2824 _session_is_new = true;
2825
2826 try {
2827 new_session = new Session (*engine, path, snap_name, &bus_profile);
2828 }
2829
2830 catch (...) {
2831
2832 MessageDialog msg (string_compose(_("Could not create session in \"%1\""), path));
2833 pop_back_splash ();
2834 msg.run ();
2835 return -1;
2836 }
2837
2838 /* Give the new session the default GUI state, if such things exist */
2839
2840 XMLNode* n;
2841 n = Config->instant_xml (X_("Editor"));
2842 if (n) {
2843 new_session->add_instant_xml (*n, false);
2844 }
2845 n = Config->instant_xml (X_("Mixer"));
2846 if (n) {
2847 new_session->add_instant_xml (*n, false);
2848 }
2849
2850 /* Put the playhead at 0 and scroll fully left */
2851 n = new_session->instant_xml (X_("Editor"));
2852 if (n) {
2853 n->add_property (X_("playhead"), X_("0"));
2854 n->add_property (X_("left-frame"), X_("0"));
2855 }
2856
2857 set_session (new_session);
2858
2859 session_loaded = true;
2860
2861 new_session->save_state(new_session->name());
2862
2863 return 0;
2864 }
2865
2866 void
2867 ARDOUR_UI::launch_chat ()
2868 {
2869 #ifdef __APPLE__
2870 open_uri("http://webchat.freenode.net/?channels=ardour-osx");
2871 #else
2872 open_uri("http://webchat.freenode.net/?channels=ardour");
2873 #endif
2874 }
2875
2876 void
2877 ARDOUR_UI::show_about ()
2878 {
2879 if (about == 0) {
2880 about = new About;
2881 about->signal_response().connect(sigc::mem_fun (*this, &ARDOUR_UI::about_signal_response) );
2882 }
2883
2884 about->set_transient_for(*editor);
2885 about->show_all ();
2886 }
2887
2888 void
2889 ARDOUR_UI::launch_manual ()
2890 {
2891 PBD::open_uri("http://ardour.org/flossmanual");
2892 }
2893
2894 void
2895 ARDOUR_UI::launch_reference ()
2896 {
2897 PBD::open_uri("http://ardour.org/refmanual");
2898 }
2899
2900 void
2901 ARDOUR_UI::hide_about ()
2902 {
2903 if (about) {
2904 about->get_window()->set_cursor ();
2905 about->hide ();
2906 }
2907 }
2908
2909 void
2910 ARDOUR_UI::about_signal_response (int /*response*/)
2911 {
2912 hide_about();
2913 }
2914
2915 void
2916 ARDOUR_UI::show_splash ()
2917 {
2918 if (splash == 0) {
2919 try {
2920 splash = new Splash;
2921 } catch (...) {
2922 return;
2923 }
2924 }
2925
2926 splash->show ();
2927 splash->present ();
2928 splash->queue_draw ();
2929 splash->get_window()->process_updates (true);
2930 flush_pending ();
2931 }
2932
2933 void
2934 ARDOUR_UI::hide_splash ()
2935 {
2936 if (splash) {
2937 splash->hide();
2938 }
2939 }
2940
2941 void
2942 ARDOUR_UI::display_cleanup_results (ARDOUR::CleanupReport& rep, const gchar* list_title,
2943 const string& plural_msg, const string& singular_msg)
2944 {
2945 size_t removed;
2946
2947 removed = rep.paths.size();
2948
2949 if (removed == 0) {
2950 MessageDialog msgd (*editor,
2951 _("No audio files were ready for cleanup"),
2952 true,
2953 Gtk::MESSAGE_INFO,
2954 (Gtk::ButtonsType)(Gtk::BUTTONS_OK) );
2955 msgd.set_secondary_text (_("If this seems suprising, \n\
2956 check for any existing snapshots.\n\
2957 These may still include regions that\n\
2958 require some unused files to continue to exist."));
2959
2960 msgd.run ();
2961 return;
2962 }
2963
2964 ArdourDialog results (_("Clean-up"), true, false);
2965
2966 struct CleanupResultsModelColumns : public Gtk::TreeModel::ColumnRecord {
2967 CleanupResultsModelColumns() {
2968 add (visible_name);
2969 add (fullpath);
2970 }
2971 Gtk::TreeModelColumn<std::string> visible_name;
2972 Gtk::TreeModelColumn<std::string> fullpath;
2973 };
2974
2975
2976 CleanupResultsModelColumns results_columns;
2977 Glib::RefPtr<Gtk::ListStore> results_model;
2978 Gtk::TreeView results_display;
2979
2980 results_model = ListStore::create (results_columns);
2981 results_display.set_model (results_model);
2982 results_display.append_column (list_title, results_columns.visible_name);
2983
2984 results_display.set_name ("CleanupResultsList");
2985 results_display.set_headers_visible (true);
2986 results_display.set_headers_clickable (false);
2987 results_display.set_reorderable (false);
2988
2989 Gtk::ScrolledWindow list_scroller;
2990 Gtk::Label txt;
2991 Gtk::VBox dvbox;
2992 Gtk::HBox dhbox; // the hbox for the image and text
2993 Gtk::HBox ddhbox; // the hbox we eventually pack into the dialog's vbox
2994 Gtk::Image* dimage = manage (new Gtk::Image(Stock::DIALOG_INFO, Gtk::ICON_SIZE_DIALOG));
2995
2996 dimage->set_alignment(ALIGN_LEFT, ALIGN_TOP);
2997
2998 const string dead_sound_directory = _session->session_directory().dead_sound_path().to_string();
2999
3000 /* subst:
3001 %1 - number of files removed
3002 %2 - location of "dead_sounds"
3003 %3 - size of files affected
3004 %4 - prefix for "bytes" to produce sensible results (e.g. mega, kilo, giga)
3005 */
3006
3007 const char* bprefix;
3008 double space_adjusted = 0;
3009
3010 if (rep.space < 100000.0f) {
3011 bprefix = X_("kilo");
3012 } else if (rep.space < 1000000.0f * 1000) {
3013 bprefix = X_("mega");
3014 space_adjusted = truncf((float)rep.space / 1000.0);
3015 } else {
3016 bprefix = X_("giga");
3017 space_adjusted = truncf((float)rep.space / (1000000.0 * 1000));
3018 }
3019
3020 if (removed > 1) {
3021 txt.set_text (string_compose (plural_msg, removed, _session->path() + "dead_sounds", space_adjusted, bprefix));
3022 } else {
3023 txt.set_text (string_compose (singular_msg, removed, _session->path() + "dead_sounds", space_adjusted, bprefix));
3024 }
3025
3026 dhbox.pack_start (*dimage, true, false, 5);
3027 dhbox.pack_start (txt, true, false, 5);
3028
3029 for (vector<string>::iterator i = rep.paths.begin(); i != rep.paths.end(); ++i) {
3030 TreeModel::Row row = *(results_model->append());
3031 row[results_columns.visible_name] = *i;
3032 row[results_columns.fullpath] = *i;
3033 }
3034
3035 list_scroller.add (results_display);
3036 list_scroller.set_size_request (-1, 150);
3037 list_scroller.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
3038
3039 dvbox.pack_start (dhbox, true, false, 5);
3040 dvbox.pack_start (list_scroller, true, false, 5);
3041 ddhbox.pack_start (dvbox, true, false, 5);
3042
3043 results.get_vbox()->pack_start (ddhbox, true, false, 5);
3044 results.add_button (Stock::CLOSE, RESPONSE_CLOSE);
3045 results.set_default_response (RESPONSE_CLOSE);
3046 results.set_position (Gtk::WIN_POS_MOUSE);
3047
3048 results_display.show();
3049 list_scroller.show();
3050 txt.show();
3051 dvbox.show();
3052 dhbox.show();
3053 ddhbox.show();
3054 dimage->show();
3055
3056 //results.get_vbox()->show();
3057 results.set_resizable (false);
3058
3059 results.run ();
3060
3061 }
3062
3063 void
3064 ARDOUR_UI::cleanup ()
3065 {
3066 if (_session == 0) {
3067 /* shouldn't happen: menu item is insensitive */
3068 return;
3069 }
3070
3071
3072 MessageDialog checker (_("Are you sure you want to cleanup?"),
3073 true,
3074 Gtk::MESSAGE_QUESTION,
3075 (Gtk::ButtonsType)(Gtk::BUTTONS_NONE));
3076
3077 checker.set_secondary_text(_("Cleanup is a destructive operation.\n\
3078 ALL undo/redo information will be lost if you cleanup.\n\
3079 After cleanup, unused audio files will be moved to a \
3080 \"dead sounds\" location."));
3081
3082 checker.add_button (Stock::CANCEL, RESPONSE_CANCEL);
3083 checker.add_button (_("Clean Up"), RESPONSE_ACCEPT);
3084 checker.set_default_response (RESPONSE_CANCEL);
3085
3086 checker.set_name (_("CleanupDialog"));
3087 checker.set_wmclass (X_("ardour_cleanup"), PROGRAM_NAME);
3088 checker.set_position (Gtk::WIN_POS_MOUSE);
3089
3090 switch (checker.run()) {
3091 case RESPONSE_ACCEPT:
3092 break;
3093 default:
3094 return;
3095 }
3096
3097 ARDOUR::CleanupReport rep;
3098
3099 editor->prepare_for_cleanup ();
3100
3101 /* do not allow flush until a session is reloaded */
3102
3103 Glib::RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("FlushWastebasket"));
3104 if (act) {
3105 act->set_sensitive (false);
3106 }
3107
3108 if (_session->cleanup_sources (rep)) {
3109 editor->finish_cleanup ();
3110 return;
3111 }
3112
3113 editor->finish_cleanup ();
3114
3115 checker.hide();
3116 display_cleanup_results (rep,
3117 _("cleaned files"),
3118 _("\
3119 The following %1 files were not in use and \n\
3120 have been moved to:\n\
3121 %2. \n\n\
3122 Flushing the wastebasket will \n\
3123 release an additional\n\
3124 %3 %4bytes of disk space.\n"),
3125 _("\
3126 The following file was not in use and \n \
3127 has been moved to:\n \
3128 %2. \n\n\
3129 Flushing the wastebasket will \n\
3130 release an additional\n\
3131 %3 %4bytes of disk space.\n"
3132 ));
3133
3134 }
3135
3136 void
3137 ARDOUR_UI::flush_trash ()
3138 {
3139 if (_session == 0) {
3140 /* shouldn't happen: menu item is insensitive */
3141 return;
3142 }
3143
3144 ARDOUR::CleanupReport rep;
3145
3146 if (_session->cleanup_trash_sources (rep)) {
3147 return;
3148 }
3149
3150 display_cleanup_results (rep,
3151 _("deleted file"),
3152 _("The following %1 files were deleted from\n\
3153 %2,\n\
3154 releasing %3 %4bytes of disk space"),
3155 _("The following file was deleted from\n\
3156 %2,\n\
3157 releasing %3 %4bytes of disk space"));
3158 }
3159
3160 void
3161 ARDOUR_UI::add_route (Gtk::Window* float_window)
3162 {
3163 int count;
3164
3165 if (!_session) {
3166 return;
3167 }
3168
3169 if (add_route_dialog == 0) {
3170 add_route_dialog = new AddRouteDialog (_session);
3171 if (float_window) {
3172 add_route_dialog->set_transient_for (*float_window);
3173 }
3174 }
3175
3176 if (add_route_dialog->is_visible()) {
3177 /* we're already doing this */
3178 return;
3179 }
3180
3181 ResponseType r = (ResponseType) add_route_dialog->run ();
3182
3183 add_route_dialog->hide();
3184
3185 switch (r) {
3186 case RESPONSE_ACCEPT:
3187 break;
3188 default:
3189 return;
3190 break;
3191 }
3192
3193 if ((count = add_route_dialog->count()) <= 0) {
3194 return;
3195 }
3196
3197 string template_path = add_route_dialog->track_template();
3198
3199 if (!template_path.empty()) {
3200 _session->new_route_from_template (count, template_path);
3201 return;
3202 }
3203
3204 uint32_t input_chan = add_route_dialog->channels ();
3205 uint32_t output_chan;
3206 string name_template = add_route_dialog->name_template ();
3207 bool track = add_route_dialog->track ();
3208 RouteGroup* route_group = add_route_dialog->route_group ();
3209
3210 AutoConnectOption oac = Config->get_output_auto_connect();
3211
3212 if (oac & AutoConnectMaster) {
3213 output_chan = (_session->master_out() ? _session->master_out()->n_inputs().n_audio() : input_chan);
3214 } else {
3215 output_chan = input_chan;
3216 }
3217
3218 /* XXX do something with name template */
3219
3220 if (add_route_dialog->type() == ARDOUR::DataType::MIDI) {
3221 if (track) {
3222 session_add_midi_track (route_group, count);
3223 } else {
3224 MessageDialog msg (*editor,
3225 _("Sorry, MIDI Busses are not supported at this time."));
3226 msg.run ();
3227 //session_add_midi_bus();
3228 }
3229 } else {
3230 if (track) {
3231 session_add_audio_track (input_chan, output_chan, add_route_dialog->mode(), route_group, count);
3232 } else {
3233 session_add_audio_bus (input_chan, output_chan, route_group, count);
3234 }
3235 }
3236 }
3237
3238 XMLNode*
3239 ARDOUR_UI::mixer_settings () const
3240 {
3241 XMLNode* node = 0;
3242
3243 if (_session) {
3244 node = _session->instant_xml(X_("Mixer"));
3245 } else {
3246 node = Config->instant_xml(X_("Mixer"));
3247 }
3248
3249 if (!node) {
3250 node = new XMLNode (X_("Mixer"));
3251 }
3252
3253 return node;
3254 }
3255
3256 XMLNode*
3257 ARDOUR_UI::editor_settings () const
3258 {
3259 XMLNode* node = 0;
3260
3261 if (_session) {
3262 node = _session->instant_xml(X_("Editor"));
3263 } else {
3264 node = Config->instant_xml(X_("Editor"));
3265 }
3266
3267 if (!node) {
3268 if (getenv("ARDOUR_INSTANT_XML_PATH")) {
3269 node = Config->instant_xml(getenv("ARDOUR_INSTANT_XML_PATH"));
3270 }
3271 }
3272
3273 if (!node) {
3274 node = new XMLNode (X_("Editor"));
3275 }
3276
3277 return node;
3278 }
3279
3280 XMLNode*
3281 ARDOUR_UI::keyboard_settings () const
3282 {
3283 XMLNode* node = 0;
3284
3285 node = Config->extra_xml(X_("Keyboard"));
3286
3287 if (!node) {
3288 node = new XMLNode (X_("Keyboard"));
3289 }
3290 return node;
3291 }
3292
3293 void
3294 ARDOUR_UI::create_xrun_marker (framepos_t where)
3295 {
3296 editor->mouse_add_new_marker (where, false, true);
3297 }
3298
3299 void
3300 ARDOUR_UI::halt_on_xrun_message ()
3301 {
3302 MessageDialog msg (*editor,
3303 _("Recording was stopped because your system could not keep up."));
3304 msg.run ();
3305 }
3306
3307 void
3308 ARDOUR_UI::xrun_handler (framepos_t where)
3309 {
3310 if (!_session) {
3311 return;
3312 }
3313
3314 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::xrun_handler, where)
3315
3316 if (_session && Config->get_create_xrun_marker() && _session->actively_recording()) {
3317 create_xrun_marker(where);
3318 }
3319
3320 if (_session && Config->get_stop_recording_on_xrun() && _session->actively_recording()) {
3321 halt_on_xrun_message ();
3322 }
3323 }
3324
3325 void
3326 ARDOUR_UI::disk_overrun_handler ()
3327 {
3328 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_overrun_handler)
3329
3330 if (!have_disk_speed_dialog_displayed) {
3331 have_disk_speed_dialog_displayed = true;
3332 MessageDialog* msg = new MessageDialog (*editor, string_compose (_("\
3333 The disk system on your computer\n\
3334 was not able to keep up with %1.\n\
3335 \n\
3336 Specifically, it failed to write data to disk\n\
3337 quickly enough to keep up with recording.\n"), PROGRAM_NAME));
3338 msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
3339 msg->show ();
3340 }
3341 }
3342
3343 void
3344 ARDOUR_UI::disk_underrun_handler ()
3345 {
3346 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::disk_underrun_handler)
3347
3348 if (!have_disk_speed_dialog_displayed) {
3349 have_disk_speed_dialog_displayed = true;
3350 MessageDialog* msg = new MessageDialog (*editor,
3351 string_compose (_("The disk system on your computer\n\
3352 was not able to keep up with %1.\n\
3353 \n\
3354 Specifically, it failed to read data from disk\n\
3355 quickly enough to keep up with playback.\n"), PROGRAM_NAME));
3356 msg->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ARDOUR_UI::disk_speed_dialog_gone), msg));
3357 msg->show ();
3358 }
3359 }
3360
3361 void
3362 ARDOUR_UI::disk_speed_dialog_gone (int /*ignored_response*/, MessageDialog* msg)
3363 {
3364 have_disk_speed_dialog_displayed = false;
3365 delete msg;
3366 }
3367
3368 void
3369 ARDOUR_UI::session_dialog (std::string msg)
3370 {
3371 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::session_dialog, msg)
3372
3373 MessageDialog* d;
3374
3375 if (editor) {
3376 d = new MessageDialog (*editor, msg, false, MESSAGE_INFO, BUTTONS_OK, true);
3377 } else {
3378 d = new MessageDialog (msg, false, MESSAGE_INFO, BUTTONS_OK, true);
3379 }
3380
3381 d->show_all ();
3382 d->run ();
3383 delete d;
3384 }
3385
3386 int
3387 ARDOUR_UI::pending_state_dialog ()
3388 {
3389 HBox* hbox = new HBox();
3390 Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG);
3391 ArdourDialog dialog (_("Crash Recovery"), true);
3392 Label message (_("\
3393 This session appears to have been in\n\
3394 middle of recording when ardour or\n\
3395 the computer was shutdown.\n\
3396 \n\
3397 Ardour can recover any captured audio for\n\
3398 you, or it can ignore it. Please decide\n\
3399 what you would like to do.\n"));
3400 image->set_alignment(ALIGN_CENTER, ALIGN_TOP);
3401 hbox->pack_start (*image, PACK_EXPAND_WIDGET, 12);
3402 hbox->pack_end (message, PACK_EXPAND_PADDING, 12);
3403 dialog.get_vbox()->pack_start(*hbox, PACK_EXPAND_PADDING, 6);
3404 dialog.add_button (_("Ignore crash data"), RESPONSE_REJECT);
3405 dialog.add_button (_("Recover from crash"), RESPONSE_ACCEPT);
3406 dialog.set_default_response (RESPONSE_ACCEPT);
3407 dialog.set_position (WIN_POS_CENTER);
3408 message.show();
3409 image->show();
3410 hbox->show();
3411
3412 switch (dialog.run ()) {
3413 case RESPONSE_ACCEPT:
3414 return 1;
3415 default:
3416 return 0;
3417 }
3418 }
3419
3420 int
3421 ARDOUR_UI::sr_mismatch_dialog (framecnt_t desired, framecnt_t actual)
3422 {
3423 HBox* hbox = new HBox();
3424 Image* image = new Image (Stock::DIALOG_QUESTION, ICON_SIZE_DIALOG);
3425 ArdourDialog dialog (_("Sample Rate Mismatch"), true);
3426 Label message (string_compose (_("\
3427 This session was created with a sample rate of %1 Hz\n\
3428 \n\
3429 The audioengine is currently running at %2 Hz\n"), desired, actual));
3430
3431 image->set_alignment(ALIGN_CENTER, ALIGN_TOP);
3432 hbox->pack_start (*image, PACK_EXPAND_WIDGET, 12);
3433 hbox->pack_end (message, PACK_EXPAND_PADDING, 12);
3434 dialog.get_vbox()->pack_start(*hbox, PACK_EXPAND_PADDING, 6);
3435 dialog.add_button (_("Do not load session"), RESPONSE_REJECT);
3436 dialog.add_button (_("Load session anyway"), RESPONSE_ACCEPT);
3437 dialog.set_default_response (RESPONSE_ACCEPT);
3438 dialog.set_position (WIN_POS_CENTER);
3439 message.show();
3440 image->show();
3441 hbox->show();
3442
3443 switch (dialog.run ()) {
3444 case RESPONSE_ACCEPT:
3445 return 0;
3446 default:
3447 return 1;
3448 }
3449 }
3450
3451
3452 void
3453 ARDOUR_UI::disconnect_from_jack ()
3454 {
3455 if (engine) {
3456 if( engine->disconnect_from_jack ()) {
3457 MessageDialog msg (*editor, _("Could not disconnect from JACK"));
3458 msg.run ();
3459 }
3460
3461 update_sample_rate (0);
3462 }
3463 }
3464
3465 void
3466 ARDOUR_UI::reconnect_to_jack ()
3467 {
3468 if (engine) {
3469 if (engine->reconnect_to_jack ()) {
3470 MessageDialog msg (*editor, _("Could not reconnect to JACK"));
3471 msg.run ();
3472 }
3473
3474 update_sample_rate (0);
3475 }
3476 }
3477
3478 void
3479 ARDOUR_UI::use_config ()
3480 {
3481 XMLNode* node = Config->extra_xml (X_("TransportControllables"));
3482 if (node) {
3483 set_transport_controllable_state (*node);
3484 }
3485 }
3486
3487 void
3488 ARDOUR_UI::update_transport_clocks (framepos_t pos)
3489 {
3490 if (Config->get_primary_clock_delta_edit_cursor()) {
3491 primary_clock.set (pos, false, editor->get_preferred_edit_position(), 1);
3492 } else {
3493 primary_clock.set (pos, 0, true);
3494 }
3495
3496 if (Config->get_secondary_clock_delta_edit_cursor()) {
3497 secondary_clock.set (pos, false, editor->get_preferred_edit_position(), 2);
3498 } else {
3499 secondary_clock.set (pos);
3500 }
3501
3502 if (big_clock_window->get()) {
3503 big_clock.set (pos);
3504 }
3505 }
3506
3507
3508 void
3509 ARDOUR_UI::step_edit_status_change (bool yn)
3510 {
3511 // XXX should really store pre-step edit status of things
3512 // we make insensitive
3513
3514 if (yn) {
3515 rec_button.set_visual_state (3);
3516 rec_button.set_sensitive (false);
3517 } else {
3518 rec_button.set_visual_state (0);
3519 rec_button.set_sensitive (true);
3520 }
3521 }
3522
3523 void
3524 ARDOUR_UI::record_state_changed ()
3525 {
3526 ENSURE_GUI_THREAD (*this, &ARDOUR_UI::record_state_changed);
3527
3528 if (!_session || !big_clock_window->get()) {
3529 /* why bother - the clock isn't visible */
3530 return;
3531 }
3532
3533 Session::RecordState const r = _session->record_status ();
3534 bool const h = _session->have_rec_enabled_track ();
3535
3536 if (r == Session::Recording && h) {
3537 big_clock.set_widget_name ("BigClockRecording");
3538 } else {
3539 big_clock.set_widget_name ("BigClockNonRecording");
3540 }
3541 }
3542
3543 bool
3544 ARDOUR_UI::first_idle ()
3545 {
3546 if (_session) {
3547 _session->allow_auto_play (true);
3548 }
3549
3550 if (editor) {
3551 editor->first_idle();
3552 }
3553
3554 Keyboard::set_can_save_keybindings (true);
3555 return false;
3556 }
3557
3558 void
3559 ARDOUR_UI::store_clock_modes ()
3560 {
3561 XMLNode* node = new XMLNode(X_("ClockModes"));
3562
3563 for (vector<AudioClock*>::iterator x = AudioClock::clocks.begin(); x != AudioClock::clocks.end(); ++x) {
3564 node->add_property ((*x)->name().c_str(), enum_2_string ((*x)->mode()));
3565 }
3566
3567 _session->add_extra_xml (*node);
3568 _session->set_dirty ();
3569 }
3570
3571
3572
3573 ARDOUR_UI::TransportControllable::TransportControllable (std::string name, ARDOUR_UI& u, ToggleType tp)
3574 : Controllable (name), ui (u), type(tp)
3575 {
3576
3577 }
3578
3579 void
3580 ARDOUR_UI::TransportControllable::set_value (double val)
3581 {
3582 if (type == ShuttleControl) {
3583 double fract;
3584
3585 if (val == 0.5) {
3586 fract = 0.0;
3587 } else {
3588 if (val < 0.5) {
3589 fract = -((0.5 - val)/0.5);
3590 } else {
3591 fract = ((val - 0.5)/0.5);
3592 }
3593 }
3594
3595 ui.set_shuttle_fract (fract);
3596 return;
3597 }
3598
3599 if (val < 0.5) {
3600 /* do nothing: these are radio-style actions */
3601 return;
3602 }
3603
3604 const char *action = 0;
3605
3606 switch (type) {
3607 case Roll:
3608 action = X_("Roll");
3609 break;
3610 case Stop:
3611 action = X_("Stop");
3612 break;
3613 case GotoStart:
3614 action = X_("Goto Start");
3615 break;
3616 case GotoEnd:
3617 action = X_("Goto End");
3618 break;
3619 case AutoLoop:
3620 action = X_("Loop");
3621 break;
3622 case PlaySelection:
3623 action = X_("Play Selection");
3624 break;
3625 case RecordEnable:
3626 action = X_("Record");
3627 break;
3628 default:
3629 break;
3630 }
3631
3632 if (action == 0) {
3633 return;
3634 }
3635
3636 Glib::RefPtr<Action> act = ActionManager::get_action ("Transport", action);
3637
3638 if (act) {
3639 act->activate ();
3640 }
3641 }
3642
3643 double
3644 ARDOUR_UI::TransportControllable::get_value (void) const
3645 {
3646 float val = 0.0;
3647
3648 switch (type) {
3649 case Roll:
3650 break;
3651 case Stop:
3652 break;
3653 case GotoStart:
3654 break;
3655 case GotoEnd:
3656 break;
3657 case AutoLoop:
3658 break;
3659 case PlaySelection:
3660 break;
3661 case RecordEnable:
3662 break;
3663 case ShuttleControl:
3664 break;
3665 default:
3666 break;
3667 }
3668
3669 return val;
3670 }
3671
3672 void
3673 ARDOUR_UI::TransportControllable::set_id (const string& str)
3674 {
3675 _id = str;
3676 }
3677
3678 void
3679 ARDOUR_UI::setup_profile ()
3680 {
3681 if (gdk_screen_width() < 1200) {
3682 Profile->set_small_screen ();
3683 }
3684
3685
3686 if (getenv ("ARDOUR_SAE")) {
3687 Profile->set_sae ();
3688 Profile->set_single_package ();
3689 }
3690 }
3691
3692 void
3693 ARDOUR_UI::toggle_translations ()
3694 {
3695 using namespace Glib;
3696
3697 RefPtr<Action> act = ActionManager::get_action (X_("Main"), X_("EnableTranslation"));
3698 if (act) {
3699 RefPtr<ToggleAction> ract = RefPtr<ToggleAction>::cast_dynamic (act);
3700 if (ract) {
3701
3702 string i18n_killer = ARDOUR::translation_kill_path();
3703
3704 bool already_enabled = !ARDOUR::translations_are_disabled ();
3705
3706 if (ract->get_active ()) {
3707 /* we don't care about errors */
3708 int fd = ::open (i18n_killer.c_str(), O_RDONLY|O_CREAT, 0644);
3709 close (fd);
3710 } else {
3711 /* we don't care about errors */
3712 unlink (i18n_killer.c_str());
3713 }
3714
3715 if (already_enabled != ract->get_active()) {
3716 MessageDialog win (already_enabled ? _("Translations disabled") : _("Translations enabled"),
3717 false,
3718 Gtk::MESSAGE_WARNING,
3719 Gtk::BUTTONS_OK);
3720 win.set_secondary_text (string_compose (_("You must restart %1 for this to take effect."), PROGRAM_NAME));
3721 win.set_position (Gtk::WIN_POS_CENTER);
3722 win.present ();
3723 win.run ();
3724 }
3725 }
3726 }
3727 }
3728
3729 /** Add a window proxy to our list, so that its state will be saved.
3730 * This call also causes the window to be created and opened if its
3731 * state was saved as `visible'.
3732 */
3733 void
3734 ARDOUR_UI::add_window_proxy (WindowProxyBase* p)
3735 {
3736 _window_proxies.push_back (p);
3737 p->maybe_show ();
3738 }
3739
3740 /** Remove a window proxy from our list. Must be called if a WindowProxy
3741 * is deleted, to prevent hanging pointers.
3742 */
3743 void
3744 ARDOUR_UI::remove_window_proxy (WindowProxyBase* p)
3745 {
3746 _window_proxies.remove (p);
3747 }
3748
3749 int
3750 ARDOUR_UI::missing_file (Session*s, std::string str, DataType type)
3751 {
3752 MissingFileDialog dialog (s, str, type);
3753
3754 dialog.show ();
3755 dialog.present ();
3756
3757 int result = dialog.run ();
3758 dialog.hide ();
3759
3760 switch (result) {
3761 case RESPONSE_OK:
3762 break;
3763 default:
3764 return 1; // quit entire session load
3765 }
3766
3767 result = dialog.get_action ();
3768
3769 return result;
3770 }
3771
3772 int
3773 ARDOUR_UI::ambiguous_file (std::string file, std::string path, std::vector<std::string> hits)
3774 {
3775 AmbiguousFileDialog dialog (file, hits);
3776
3777 dialog.show ();
3778 dialog.present ();
3779
3780 dialog.run ();
3781 return dialog.get_which ();
3782 }
Digital Audio Workstation