2005-09-25 14:42:24 -04:00
/*
2013-03-12 17:19:39 -04:00
Copyright ( C ) 1999 - 2013 Paul Davis
2005-09-25 14:42:24 -04:00
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
along with this program ; if not , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
2010-11-13 00:14:48 -05:00
# ifdef WAF_BUILD
# include "gtk2ardour-config.h"
2014-09-06 11:59:53 -04:00
# include "gtk2ardour-version.h"
2010-11-13 00:14:48 -05:00
# endif
2005-09-25 14:42:24 -04:00
# include <algorithm>
# include <cmath>
2013-05-04 22:02:05 -04:00
# include <iostream>
# include <cerrno>
# include <fstream>
2013-10-14 12:05:42 -04:00
# ifndef PLATFORM_WINDOWS
2013-07-11 15:29:28 -04:00
# include <sys/resource.h>
2013-07-11 15:18:31 -04:00
# endif
2013-05-04 22:02:05 -04:00
# include <stdint.h>
2005-09-25 14:42:24 -04:00
# include <fcntl.h>
# include <signal.h>
# include <unistd.h>
2008-09-10 11:03:30 -04:00
# include <time.h>
2005-09-25 14:42:24 -04:00
2013-07-17 02:41:48 -04:00
# include <glib.h>
# include <glib/gstdio.h>
2007-03-18 02:07:08 -04:00
2006-03-05 14:39:16 -05:00
# include <gtkmm/messagedialog.h>
2006-03-29 22:38:33 -05:00
# include <gtkmm/accelmap.h>
2006-03-05 14:39:16 -05:00
2009-02-25 13:26:51 -05:00
# include "pbd/error.h"
# include "pbd/basename.h"
# include "pbd/compose.h"
# include "pbd/failed_constructor.h"
# include "pbd/enumwriter.h"
# include "pbd/memento_command.h"
2010-03-16 11:33:04 -04:00
# include "pbd/openuri.h"
2014-06-14 22:09:48 -04:00
# include "pbd/stl_delete.h"
2009-02-25 13:26:51 -05:00
# include "pbd/file_utils.h"
2013-07-11 15:23:12 -04:00
# include "pbd/localtime_r.h"
2014-07-15 08:19:33 -04:00
# include "pbd/pthread_utils.h"
2007-05-14 10:13:59 -04:00
2010-08-20 18:36:35 -04:00
# include "gtkmm2ext/application.h"
2011-03-03 22:10:48 -05:00
# include "gtkmm2ext/bindings.h"
2009-12-04 15:52:04 -05:00
# include "gtkmm2ext/gtk_ui.h"
# include "gtkmm2ext/utils.h"
# include "gtkmm2ext/click_box.h"
# include "gtkmm2ext/fastmeter.h"
# include "gtkmm2ext/popup.h"
# include "gtkmm2ext/window_title.h"
2005-09-25 14:42:24 -04:00
2009-02-25 13:26:51 -05:00
# include "ardour/ardour.h"
2013-08-03 11:57:56 -04:00
# include "ardour/audio_backend.h"
2012-05-24 02:09:29 -04:00
# include "ardour/audioengine.h"
# include "ardour/audiofilesource.h"
2012-07-13 17:05:45 -04:00
# include "ardour/automation_watch.h"
2012-05-24 02:09:29 -04:00
# include "ardour/diskstream.h"
# include "ardour/filename_extensions.h"
2013-03-08 11:41:45 -05:00
# include "ardour/filesystem_paths.h"
2012-05-24 02:09:29 -04:00
# include "ardour/port.h"
2014-02-23 21:53:53 -05:00
# include "ardour/plugin_manager.h"
2012-05-24 02:09:29 -04:00
# include "ardour/process_thread.h"
2009-02-25 13:26:51 -05:00
# include "ardour/profile.h"
2012-05-24 02:09:29 -04:00
# include "ardour/recent_sessions.h"
2009-02-25 13:26:51 -05:00
# include "ardour/session_directory.h"
# include "ardour/session_route.h"
# include "ardour/session_state_utils.h"
# include "ardour/session_utils.h"
2012-10-12 18:04:21 -04:00
# include "ardour/slave.h"
2014-03-13 11:50:44 -04:00
# include "ardour/system_exec.h"
2005-09-25 14:42:24 -04:00
2014-02-21 20:44:34 -05:00
# ifdef WINDOWS_VST_SUPPORT
# include <fst.h>
# endif
2014-11-11 22:57:03 -05:00
# ifdef AUDIOUNIT_SUPPORT
# include "ardour/audio_unit.h"
# endif
2014-02-21 20:44:34 -05:00
2012-10-12 12:25:57 -04:00
# include "timecode/time.h"
2008-09-10 11:03:30 -04:00
typedef uint64_t microseconds_t ;
2011-02-16 23:45:49 -05:00
# include "about.h"
2005-11-25 19:06:46 -05:00
# include "actions.h"
2011-02-16 23:45:49 -05:00
# include "add_route_dialog.h"
# include "ambiguous_file_dialog.h"
2005-09-25 14:42:24 -04:00
# include "ardour_ui.h"
# include "audio_clock.h"
2013-05-04 22:02:05 -04:00
# include "big_clock_window.h"
2011-02-16 23:45:49 -05:00
# include "bundle_manager.h"
# include "engine_dialog.h"
# include "gain_meter.h"
# include "global_port_matrix.h"
2011-07-06 20:37:13 -04:00
# include "gui_object.h"
2011-02-16 23:45:49 -05:00
# include "gui_thread.h"
2005-09-25 14:42:24 -04:00
# include "keyboard.h"
2013-05-04 22:02:05 -04:00
# include "keyeditor.h"
2011-02-16 23:45:49 -05:00
# include "location_ui.h"
2012-05-31 19:14:03 -04:00
# include "main_clock.h"
2011-02-16 23:45:49 -05:00
# include "missing_file_dialog.h"
# include "missing_plugin_dialog.h"
2005-09-25 14:42:24 -04:00
# include "mixer_ui.h"
2012-12-12 09:55:01 -05:00
# include "mouse_cursors.h"
2013-08-15 06:35:33 -04:00
# include "nsm.h"
2005-09-25 14:42:24 -04:00
# include "opts.h"
2013-03-08 11:41:45 -05:00
# include "pingback.h"
2011-02-16 23:45:49 -05:00
# include "processor_box.h"
# include "prompter.h"
# include "public_editor.h"
2013-05-04 22:02:05 -04:00
# include "rc_option_editor.h"
2008-09-10 11:03:30 -04:00
# include "route_time_axis.h"
2013-05-04 22:02:05 -04:00
# include "route_params_ui.h"
2013-09-23 14:41:52 -04:00
# include "session_dialog.h"
2011-02-16 23:45:49 -05:00
# include "session_metadata_dialog.h"
2013-05-04 22:02:05 -04:00
# include "session_option_editor.h"
2011-04-19 22:48:20 -04:00
# include "shuttle_control.h"
2011-02-16 23:45:49 -05:00
# include "speaker_dialog.h"
# include "splash.h"
2009-03-04 18:06:18 -05:00
# include "startup.h"
2011-02-16 23:45:49 -05:00
# include "theme_manager.h"
2010-06-03 11:57:31 -04:00
# include "time_axis_view_item.h"
2014-12-25 10:02:00 -05:00
# include "timers.h"
2011-02-16 23:45:49 -05:00
# include "utils.h"
2013-03-12 17:00:09 -04:00
# include "video_server_dialog.h"
# include "add_video_dialog.h"
# include "transcode_video_dialog.h"
2007-06-29 13:13:09 -04:00
2005-09-25 14:42:24 -04:00
# include "i18n.h"
using namespace ARDOUR ;
2014-06-25 15:27:37 -04:00
using namespace ARDOUR_UI_UTILS ;
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
using namespace PBD ;
2005-09-25 16:33:00 -04:00
using namespace Gtkmm2ext ;
2005-09-25 14:42:24 -04:00
using namespace Gtk ;
2012-05-24 02:09:29 -04:00
using namespace std ;
2005-09-25 14:42:24 -04:00
ARDOUR_UI * ARDOUR_UI : : theArdourUI = 0 ;
2010-12-03 17:26:29 -05:00
sigc : : signal < void , framepos_t , bool , framepos_t > ARDOUR_UI : : Clock ;
2013-05-02 21:13:36 -04:00
sigc : : signal < void > ARDOUR_UI : : CloseAllDialogs ;
2005-09-25 14:42:24 -04:00
2013-01-21 18:14:00 -05:00
ARDOUR_UI : : ARDOUR_UI ( int * argcp , char * * argvp [ ] , const char * localedir )
2005-09-25 14:42:24 -04:00
2011-06-02 13:50:37 -04:00
: Gtkmm2ext : : UI ( PROGRAM_NAME , argcp , argvp )
2014-12-07 13:12:21 -05:00
, ui_config ( new UIConfiguration )
2011-07-06 20:37:13 -04:00
, gui_object_state ( new GUIObjectState )
2013-05-07 13:01:18 -04:00
2012-05-31 19:14:03 -04:00
, primary_clock ( new MainClock ( X_ ( " primary " ) , false , X_ ( " transport " ) , true , true , true , false , true ) )
, secondary_clock ( new MainClock ( X_ ( " secondary " ) , false , X_ ( " secondary " ) , true , true , false , false , true ) )
2014-12-22 18:52:40 -05:00
2005-09-25 14:42:24 -04:00
/* big clock */
2011-11-17 17:49:13 -05:00
, big_clock ( new AudioClock ( X_ ( " bigclock " ) , false , " big " , true , true , false , false ) )
2013-07-06 22:14:41 -04:00
, video_timeline ( 0 )
2005-09-25 14:42:24 -04:00
2013-05-07 18:09:12 -04:00
/* start of private members */
2014-12-22 18:52:40 -05:00
, editor ( 0 )
, mixer ( 0 )
2013-05-07 18:09:12 -04:00
, nsm ( 0 )
, _was_dirty ( false )
, _mixer_on_top ( false )
2013-08-08 16:31:08 -04:00
, first_time_engine_run ( true )
2013-05-07 18:09:12 -04:00
2005-09-25 14:42:24 -04:00
/* transport */
2011-06-02 13:50:37 -04:00
, roll_controllable ( new TransportControllable ( " transport roll " , * this , TransportControllable : : Roll ) )
, stop_controllable ( new TransportControllable ( " transport stop " , * this , TransportControllable : : Stop ) )
, goto_start_controllable ( new TransportControllable ( " transport goto start " , * this , TransportControllable : : GotoStart ) )
, goto_end_controllable ( new TransportControllable ( " transport goto end " , * this , TransportControllable : : GotoEnd ) )
, auto_loop_controllable ( new TransportControllable ( " transport auto loop " , * this , TransportControllable : : AutoLoop ) )
, play_selection_controllable ( new TransportControllable ( " transport play selection " , * this , TransportControllable : : PlaySelection ) )
, rec_controllable ( new TransportControllable ( " transport rec-enable " , * this , TransportControllable : : RecordEnable ) )
2007-03-18 02:07:08 -04:00
2011-11-09 09:38:58 -05:00
, auto_return_button ( ArdourButton : : led_default_elements )
2012-11-20 14:43:43 -05:00
, follow_edits_button ( ArdourButton : : led_default_elements )
2011-11-09 09:38:58 -05:00
, auto_input_button ( ArdourButton : : led_default_elements )
2014-08-01 15:31:18 -04:00
, auditioning_alert_button ( _ ( " Audition " ) )
, solo_alert_button ( _ ( " Solo " ) )
, feedback_alert_button ( _ ( " Feedback " ) )
2011-06-01 13:00:29 -04:00
2013-07-24 16:04:46 -04:00
, editor_meter ( 0 )
2013-08-03 07:59:22 -04:00
, editor_meter_peak_display ( )
2013-07-24 16:04:46 -04:00
2013-05-04 22:02:05 -04:00
, speaker_config_window ( X_ ( " speaker-config " ) , _ ( " Speaker Configuration " ) )
, key_editor ( X_ ( " key-editor " ) , _ ( " Key Bindings " ) )
, rc_option_editor ( X_ ( " rc-options-editor " ) , _ ( " Preferences " ) )
, add_route_dialog ( X_ ( " add-routes " ) , _ ( " Add Tracks/Busses " ) )
, about ( X_ ( " about " ) , _ ( " About " ) )
, location_ui ( X_ ( " locations " ) , _ ( " Locations " ) )
, route_params ( X_ ( " inspector " ) , _ ( " Tracks and Busses " ) )
2013-09-22 19:22:56 -04:00
, audio_midi_setup ( X_ ( " audio-midi-setup " ) , _ ( " Audio/MIDI Setup " ) )
2013-05-04 22:02:05 -04:00
, session_option_editor ( X_ ( " session-options-editor " ) , _ ( " Properties " ) , boost : : bind ( & ARDOUR_UI : : create_session_option_editor , this ) )
, add_video_dialog ( X_ ( " add-video " ) , _ ( " Add Tracks/Busses " ) , boost : : bind ( & ARDOUR_UI : : create_add_video_dialog , this ) )
, bundle_manager ( X_ ( " bundle-manager " ) , _ ( " Bundle Manager " ) , boost : : bind ( & ARDOUR_UI : : create_bundle_manager , this ) )
, big_clock_window ( X_ ( " big-clock " ) , _ ( " Big Clock " ) , boost : : bind ( & ARDOUR_UI : : create_big_clock_window , this ) )
, audio_port_matrix ( X_ ( " audio-connection-manager " ) , _ ( " Audio Connections " ) , boost : : bind ( & ARDOUR_UI : : create_global_port_matrix , this , ARDOUR : : DataType : : AUDIO ) )
, midi_port_matrix ( X_ ( " midi-connection-manager " ) , _ ( " MIDI Connections " ) , boost : : bind ( & ARDOUR_UI : : create_global_port_matrix , this , ARDOUR : : DataType : : MIDI ) )
2011-06-02 13:50:37 -04:00
, error_log_button ( _ ( " Errors " ) )
2007-10-11 18:07:47 -04:00
2011-10-29 16:07:00 -04:00
, _status_bar_visibility ( X_ ( " status-bar " ) )
2011-11-11 08:52:27 -05:00
, _feedback_exists ( false )
2005-09-25 14:42:24 -04:00
{
2013-01-21 18:14:00 -05:00
Gtkmm2ext : : init ( localedir ) ;
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
splash = 0 ;
2005-09-25 14:42:24 -04:00
2014-07-03 18:50:14 -04:00
_numpad_locate_happening = false ;
2005-09-25 14:42:24 -04:00
if ( theArdourUI = = 0 ) {
theArdourUI = this ;
}
2005-11-25 19:06:46 -05:00
2013-06-21 17:15:56 -04:00
ui_config - > ParameterChanged . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : parameter_changed ) ) ;
boost : : function < void ( string ) > pc ( boost : : bind ( & ARDOUR_UI : : parameter_changed , this , _1 ) ) ;
ui_config - > map_parameters ( pc ) ;
2011-05-25 06:17:16 -04:00
2005-09-25 14:42:24 -04:00
editor = 0 ;
mixer = 0 ;
2013-07-01 14:42:26 -04:00
meterbridge = 0 ;
2007-10-23 08:02:36 -04:00
editor = 0 ;
2005-09-25 14:42:24 -04:00
_session_is_new = false ;
session_selector_window = 0 ;
last_key_press_time = 0 ;
2013-03-12 17:00:09 -04:00
video_server_process = 0 ;
2005-09-25 14:42:24 -04:00
open_session_selector = 0 ;
have_configure_timeout = false ;
2007-03-18 02:07:08 -04:00
have_disk_speed_dialog_displayed = false ;
2005-09-25 14:42:24 -04:00
session_loaded = false ;
2008-03-17 16:54:03 -04:00
ignore_dual_punch = false ;
2008-12-12 09:43:24 -05:00
2011-11-07 12:23:27 -05:00
roll_button . set_controllable ( roll_controllable ) ;
stop_button . set_controllable ( stop_controllable ) ;
goto_start_button . set_controllable ( goto_start_controllable ) ;
goto_end_button . set_controllable ( goto_end_controllable ) ;
auto_loop_button . set_controllable ( auto_loop_controllable ) ;
play_selection_button . set_controllable ( play_selection_controllable ) ;
rec_button . set_controllable ( rec_controllable ) ;
roll_button . set_name ( " transport button " ) ;
stop_button . set_name ( " transport button " ) ;
goto_start_button . set_name ( " transport button " ) ;
goto_end_button . set_name ( " transport button " ) ;
auto_loop_button . set_name ( " transport button " ) ;
play_selection_button . set_name ( " transport button " ) ;
rec_button . set_name ( " transport recenable button " ) ;
2011-11-10 13:04:34 -05:00
midi_panic_button . set_name ( " transport button " ) ;
2011-11-07 14:15:13 -05:00
2008-09-10 11:03:30 -04:00
last_configure_time = 0 ;
2011-04-19 22:48:20 -04:00
last_peak_grab = 0 ;
2009-10-14 12:10:01 -04:00
2010-03-30 11:18:43 -04:00
ARDOUR : : Diskstream : : DiskOverrun . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : disk_overrun_handler , this ) , gui_context ( ) ) ;
ARDOUR : : Diskstream : : DiskUnderrun . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : disk_underrun_handler , this ) , gui_context ( ) ) ;
2005-09-25 14:42:24 -04:00
2013-03-04 16:57:29 -05:00
ARDOUR : : Session : : VersionMismatch . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : session_format_mismatch , this , _1 , _2 ) , gui_context ( ) ) ;
2008-04-11 10:06:50 -04:00
/* handle dialog requests */
2012-04-25 08:58:19 -04:00
ARDOUR : : Session : : Dialog . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : session_dialog , this , _1 ) , gui_context ( ) ) ;
2008-04-11 10:06:50 -04:00
2009-12-21 13:23:07 -05:00
/* handle pending state with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
2005-09-25 14:42:24 -04:00
2009-12-21 13:23:07 -05:00
ARDOUR : : Session : : AskAboutPendingState . connect_same_thread ( forever_connections , boost : : bind ( & ARDOUR_UI : : pending_state_dialog , this ) ) ;
2005-09-25 14:42:24 -04:00
2013-09-09 13:17:53 -04:00
/* handle Audio/MIDI setup when session requires it */
2013-09-10 15:41:19 -04:00
ARDOUR : : Session : : AudioEngineSetupRequired . connect_same_thread ( forever_connections , boost : : bind ( & ARDOUR_UI : : do_audio_midi_setup , this , _1 ) ) ;
2013-09-09 13:17:53 -04:00
2009-12-21 13:23:07 -05:00
/* handle sr mismatch with a dialog (PROBLEM: needs to return a value and thus cannot be x-thread) */
2008-02-02 12:22:04 -05:00
2009-12-21 13:23:07 -05:00
ARDOUR : : Session : : AskAboutSampleRateMismatch . connect_same_thread ( forever_connections , boost : : bind ( & ARDOUR_UI : : sr_mismatch_dialog , this , _1 , _2 ) ) ;
2008-02-02 12:22:04 -05:00
2010-10-07 08:12:16 -04:00
/* handle requests to quit (coming from JACK session) */
2011-06-01 13:00:29 -04:00
2012-04-25 08:58:19 -04:00
ARDOUR : : Session : : Quit . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : finish , this ) , gui_context ( ) ) ;
2010-10-07 08:12:16 -04:00
2011-11-09 12:44:39 -05:00
/* tell the user about feedback */
2012-04-25 08:58:19 -04:00
ARDOUR : : Session : : FeedbackDetected . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : feedback_detected , this ) , gui_context ( ) ) ;
ARDOUR : : Session : : SuccessfulGraphSort . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : successful_graph_sort , this ) , gui_context ( ) ) ;
2011-11-09 12:44:39 -05:00
2010-11-25 15:37:39 -05:00
/* handle requests to deal with missing files */
2010-11-09 01:03:51 -05:00
ARDOUR : : Session : : MissingFile . connect_same_thread ( forever_connections , boost : : bind ( & ARDOUR_UI : : missing_file , this , _1 , _2 , _3 ) ) ;
2010-12-13 21:45:41 -05:00
/* and ambiguous files */
2013-07-15 08:05:37 -04:00
ARDOUR : : FileSource : : AmbiguousFileName . connect_same_thread ( forever_connections , boost : : bind ( & ARDOUR_UI : : ambiguous_file , this , _1 , _2 ) ) ;
2010-12-13 21:45:41 -05:00
2014-02-23 21:53:53 -05:00
/* also plugin scan messages */
2014-02-25 08:52:57 -05:00
ARDOUR : : PluginScanMessage . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : plugin_scan_dialog , this , _1 , _2 , _3 ) , gui_context ( ) ) ;
2014-03-09 11:33:58 -04:00
ARDOUR : : PluginScanTimeout . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : plugin_scan_timeout , this , _1 ) , gui_context ( ) ) ;
2014-02-23 21:53:53 -05:00
2014-02-25 06:56:20 -05:00
ARDOUR : : GUIIdle . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : gui_idle_handler , this ) , gui_context ( ) ) ;
2014-08-27 11:55:01 -04:00
Config - > ParameterChanged . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : set_flat_buttons , this ) , gui_context ( ) ) ;
set_flat_buttons ( ) ;
2007-10-11 18:07:47 -04:00
/* lets get this party started */
2013-08-09 07:47:16 -04:00
setup_gtk_ardour_enums ( ) ;
setup_profile ( ) ;
2008-01-15 12:23:57 -05:00
2013-08-09 07:47:16 -04:00
SessionEvent : : create_per_thread_pool ( " GUI " , 512 ) ;
2007-10-11 18:07:47 -04:00
/* we like keyboards */
2010-02-08 19:50:24 -05:00
keyboard = new ArdourKeyboard ( * this ) ;
2009-12-04 17:51:32 -05:00
XMLNode * node = ARDOUR_UI : : instance ( ) - > keyboard_settings ( ) ;
if ( node ) {
keyboard - > set_state ( * node , Stateful : : loading_state_version ) ;
}
2007-10-11 18:07:47 -04:00
2011-03-14 17:53:10 -04:00
/* we don't like certain modifiers */
Bindings : : set_ignored_state ( GDK_LOCK_MASK | GDK_MOD2_MASK | GDK_MOD3_MASK ) ;
2011-03-03 22:10:48 -05:00
2008-03-17 16:54:03 -04:00
reset_dpi ( ) ;
2010-11-25 15:37:39 -05:00
TimeAxisViewItem : : set_constant_heights ( ) ;
2010-06-03 11:57:31 -04:00
2013-05-08 11:43:33 -04:00
/* Set this up so that our window proxies can register actions */
2010-08-17 22:20:15 -04:00
2013-05-04 22:02:05 -04:00
ActionManager : : init ( ) ;
2010-08-17 22:20:15 -04:00
2013-05-04 22:02:05 -04:00
/* The following must happen after ARDOUR::init() so that Config is set up */
2011-06-01 13:00:29 -04:00
2013-05-04 22:02:05 -04:00
const XMLNode * ui_xml = Config - > extra_xml ( X_ ( " UI " ) ) ;
if ( ui_xml ) {
key_editor . set_state ( * ui_xml ) ;
rc_option_editor . set_state ( * ui_xml ) ;
session_option_editor . set_state ( * ui_xml ) ;
speaker_config_window . set_state ( * ui_xml ) ;
about . set_state ( * ui_xml ) ;
add_route_dialog . set_state ( * ui_xml ) ;
add_video_dialog . set_state ( * ui_xml ) ;
route_params . set_state ( * ui_xml ) ;
bundle_manager . set_state ( * ui_xml ) ;
location_ui . set_state ( * ui_xml ) ;
big_clock_window . set_state ( * ui_xml ) ;
audio_port_matrix . set_state ( * ui_xml ) ;
midi_port_matrix . set_state ( * ui_xml ) ;
}
2013-05-07 22:09:16 -04:00
WM : : Manager : : instance ( ) . register_window ( & key_editor ) ;
WM : : Manager : : instance ( ) . register_window ( & rc_option_editor ) ;
WM : : Manager : : instance ( ) . register_window ( & session_option_editor ) ;
WM : : Manager : : instance ( ) . register_window ( & speaker_config_window ) ;
WM : : Manager : : instance ( ) . register_window ( & about ) ;
WM : : Manager : : instance ( ) . register_window ( & add_route_dialog ) ;
WM : : Manager : : instance ( ) . register_window ( & add_video_dialog ) ;
WM : : Manager : : instance ( ) . register_window ( & route_params ) ;
2013-09-22 19:22:56 -04:00
WM : : Manager : : instance ( ) . register_window ( & audio_midi_setup ) ;
2013-05-07 22:09:16 -04:00
WM : : Manager : : instance ( ) . register_window ( & bundle_manager ) ;
WM : : Manager : : instance ( ) . register_window ( & location_ui ) ;
WM : : Manager : : instance ( ) . register_window ( & big_clock_window ) ;
WM : : Manager : : instance ( ) . register_window ( & audio_port_matrix ) ;
WM : : Manager : : instance ( ) . register_window ( & midi_port_matrix ) ;
2013-05-04 22:02:05 -04:00
2014-12-15 12:32:41 -05:00
/* Trigger setting up the color scheme and loading the GTK RC file */
ARDOUR_UI : : config ( ) - > load_rc_file ( false ) ;
2013-05-04 22:02:05 -04:00
2011-11-01 19:19:03 -04:00
_process_thread = new ProcessThread ( ) ;
_process_thread - > init ( ) ;
2011-11-14 06:31:27 -05:00
DPIReset . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : resize_text_widgets ) ) ;
2013-08-03 11:57:56 -04:00
attach_to_engine ( ) ;
2005-09-25 14:42:24 -04:00
}
2013-05-04 22:02:05 -04:00
GlobalPortMatrixWindow *
ARDOUR_UI : : create_global_port_matrix ( ARDOUR : : DataType type )
{
if ( ! _session ) {
return 0 ;
}
return new GlobalPortMatrixWindow ( _session , type ) ;
}
2012-12-13 08:44:11 -05:00
2013-08-03 11:57:56 -04:00
void
ARDOUR_UI : : attach_to_engine ( )
2005-09-25 14:42:24 -04:00
{
2013-09-09 13:17:53 -04:00
AudioEngine : : instance ( ) - > Running . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : engine_running , this ) , gui_context ( ) ) ;
2010-11-25 15:37:39 -05:00
ARDOUR : : Port : : set_connecting_blocked ( ARDOUR_COMMAND_LINE : : no_connect_ports ) ;
2007-10-11 18:07:47 -04:00
}
2013-08-08 16:31:08 -04:00
void
ARDOUR_UI : : engine_stopped ( )
{
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : engine_stopped )
2013-09-04 12:49:52 -04:00
ActionManager : : set_sensitive ( ActionManager : : engine_sensitive_actions , false ) ;
ActionManager : : set_sensitive ( ActionManager : : engine_opposite_sensitive_actions , true ) ;
2013-08-08 16:31:08 -04:00
}
void
ARDOUR_UI : : engine_running ( )
{
if ( first_time_engine_run ) {
post_engine ( ) ;
first_time_engine_run = false ;
2013-09-19 15:03:20 -04:00
}
2013-08-08 16:31:08 -04:00
2013-09-17 22:25:21 -04:00
update_disk_space ( ) ;
update_cpu_load ( ) ;
update_sample_rate ( AudioEngine : : instance ( ) - > sample_rate ( ) ) ;
update_timecode_format ( ) ;
2013-08-08 16:31:08 -04:00
}
void
ARDOUR_UI : : engine_halted ( const char * reason , bool free_reason )
{
if ( ! Gtkmm2ext : : UI : : instance ( ) - > caller_is_ui_thread ( ) ) {
/* we can't rely on the original string continuing to exist when we are called
again in the GUI thread , so make a copy and note that we need to
free it later .
*/
char * copy = strdup ( reason ) ;
Gtkmm2ext : : UI : : instance ( ) - > call_slot ( invalidator ( * this ) , boost : : bind ( & ARDOUR_UI : : engine_halted , this , copy , true ) ) ;
return ;
2007-10-11 18:07:47 -04:00
}
2005-09-25 14:42:24 -04:00
2013-09-04 12:49:52 -04:00
ActionManager : : set_sensitive ( ActionManager : : engine_sensitive_actions , false ) ;
ActionManager : : set_sensitive ( ActionManager : : engine_opposite_sensitive_actions , true ) ;
2005-09-25 14:42:24 -04:00
2013-08-08 16:31:08 -04:00
update_sample_rate ( 0 ) ;
2010-04-20 22:24:38 -04:00
2013-08-08 16:31:08 -04:00
string msgstr ;
2010-06-02 12:21:02 -04:00
2013-08-08 16:31:08 -04:00
/* if the reason is a non-empty string, it means that the backend was shutdown
rather than just Ardour .
*/
2006-08-30 22:28:42 -04:00
2013-08-08 16:31:08 -04:00
if ( strlen ( reason ) ) {
2013-09-17 22:25:21 -04:00
msgstr = string_compose ( _ ( " The audio backend was shutdown because: \n \n %1 " ) , reason ) ;
2013-08-08 16:31:08 -04:00
} else {
msgstr = string_compose ( _ ( " \
2013-10-12 09:59:33 -04:00
The audio backend has either been shutdown or it \ n \
2013-08-08 16:31:08 -04:00
disconnected % 1 because % 1 \ n \
was not fast enough . Try to restart \ n \
2013-09-17 22:25:21 -04:00
the audio backend and save the session . " ), PROGRAM_NAME);
2013-08-08 16:31:08 -04:00
}
MessageDialog msg ( * editor , msgstr ) ;
pop_back_splash ( msg ) ;
msg . set_keep_above ( true ) ;
msg . run ( ) ;
if ( free_reason ) {
free ( const_cast < char * > ( reason ) ) ;
}
2007-10-11 18:07:47 -04:00
}
2005-09-25 14:42:24 -04:00
2007-10-11 18:07:47 -04:00
void
ARDOUR_UI : : post_engine ( )
{
2013-08-08 16:31:08 -04:00
/* Things to be done once (and once ONLY) after we have a backend running in the AudioEngine
2007-10-11 18:07:47 -04:00
*/
2014-11-11 22:57:03 -05:00
# ifdef AUDIOUNIT_SUPPORT
std : : string au_msg ;
if ( AUPluginInfo : : au_get_crashlog ( au_msg ) ) {
popup_error ( _ ( " Audio Unit Plugin Scan Failed. Automatic AU scanning has been disabled. Please see the log window for further details. " ) ) ;
error < < _ ( " Audio Unit Plugin Scan Failed: " ) < < endmsg ;
info < < au_msg < < endmsg ;
}
# endif
2007-10-11 18:07:47 -04:00
2009-10-06 21:55:32 -04:00
ARDOUR : : init_post_engine ( ) ;
2013-09-12 16:28:51 -04:00
/* connect to important signals */
AudioEngine : : instance ( ) - > Stopped . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : engine_stopped , this ) , gui_context ( ) ) ;
AudioEngine : : instance ( ) - > SampleRateChanged . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : update_sample_rate , this , _1 ) , gui_context ( ) ) ;
AudioEngine : : instance ( ) - > Halted . connect_same_thread ( halt_connection , boost : : bind ( & ARDOUR_UI : : engine_halted , this , _1 , false ) ) ;
2009-10-06 21:55:32 -04:00
2007-10-11 18:07:47 -04:00
_tooltips . enable ( ) ;
2005-09-25 14:42:24 -04:00
if ( setup_windows ( ) ) {
throw failed_constructor ( ) ;
}
2011-06-01 13:00:29 -04:00
2011-10-29 16:07:00 -04:00
/* Do this after setup_windows (), as that's when the _status_bar_visibility is created */
XMLNode * n = Config - > extra_xml ( X_ ( " UI " ) ) ;
if ( n ) {
_status_bar_visibility . set_state ( * n ) ;
}
2007-10-14 01:45:31 -04:00
check_memory_locking ( ) ;
2005-09-25 14:42:24 -04:00
2007-10-11 18:07:47 -04:00
/* this is the first point at which all the keybindings are available */
if ( ARDOUR_COMMAND_LINE : : show_key_actions ) {
2005-12-06 01:23:50 -05:00
vector < string > names ;
vector < string > paths ;
2011-02-20 12:29:52 -05:00
vector < string > tooltips ;
2005-12-06 01:23:50 -05:00
vector < string > keys ;
vector < AccelKey > bindings ;
2011-02-20 12:29:52 -05:00
ActionManager : : get_all_actions ( names , paths , tooltips , keys , bindings ) ;
2005-12-06 01:23:50 -05:00
vector < string > : : iterator n ;
vector < string > : : iterator k ;
2014-02-10 23:52:39 -05:00
vector < string > : : iterator p ;
for ( n = names . begin ( ) , k = keys . begin ( ) , p = paths . begin ( ) ; n ! = names . end ( ) ; + + n , + + k , + + p ) {
cout < < " Action: ' " < < ( * n ) < < " ' bound to ' " < < ( * k ) < < " ' Path: ' " < < ( * p ) < < " ' " < < endl ;
2005-12-06 01:23:50 -05:00
}
2014-02-10 23:52:07 -05:00
halt_connection . disconnect ( ) ;
AudioEngine : : instance ( ) - > stop ( ) ;
2005-09-25 14:42:24 -04:00
exit ( 0 ) ;
}
/* this being a GUI and all, we want peakfiles */
2006-06-14 21:34:54 -04:00
AudioFileSource : : set_build_peakfiles ( true ) ;
AudioFileSource : : set_build_missing_peakfiles ( true ) ;
2005-09-25 14:42:24 -04:00
2007-01-11 14:50:49 -05:00
/* set default clock modes */
2007-01-09 18:24:54 -05:00
2008-02-16 17:43:18 -05:00
if ( Profile - > get_sae ( ) ) {
2011-06-02 13:50:37 -04:00
primary_clock - > set_mode ( AudioClock : : BBT ) ;
secondary_clock - > set_mode ( AudioClock : : MinSec ) ;
2008-02-16 17:43:18 -05:00
} else {
2011-06-02 13:50:37 -04:00
primary_clock - > set_mode ( AudioClock : : Timecode ) ;
secondary_clock - > set_mode ( AudioClock : : BBT ) ;
2008-02-16 17:43:18 -05:00
}
2007-01-09 18:24:54 -05:00
2005-09-25 14:42:24 -04:00
/* start the time-of-day-clock */
2009-10-14 12:10:01 -04:00
2007-10-11 18:07:47 -04:00
# ifndef GTKOSX
2010-03-18 22:49:01 -04:00
/* OS X provides a nearly-always visible wallclock, so don't be stupid */
2005-09-25 14:42:24 -04:00
update_wall_clock ( ) ;
2012-12-26 11:57:34 -05:00
Glib : : signal_timeout ( ) . connect_seconds ( sigc : : mem_fun ( * this , & ARDOUR_UI : : update_wall_clock ) , 1 ) ;
2007-10-11 18:07:47 -04:00
# endif
2005-09-25 14:42:24 -04:00
2014-09-06 06:52:29 -04:00
{
DisplaySuspender ds ;
Config - > ParameterChanged . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : parameter_changed , this , _1 ) , gui_context ( ) ) ;
boost : : function < void ( string ) > pc ( boost : : bind ( & ARDOUR_UI : : parameter_changed , this , _1 ) ) ;
Config - > map_parameters ( pc ) ;
2014-12-22 13:39:41 -05:00
ui_config - > map_parameters ( pc ) ;
2014-09-06 06:52:29 -04:00
}
2005-09-25 14:42:24 -04:00
}
ARDOUR_UI : : ~ ARDOUR_UI ( )
{
2014-12-08 18:19:11 -05:00
ui_config - > save_state ( ) ;
2013-10-07 20:27:54 -04:00
2013-03-12 17:00:09 -04:00
stop_video_server ( ) ;
2014-09-10 20:37:42 -04:00
if ( getenv ( " ARDOUR_RUNNING_UNDER_VALGRIND " ) ) {
// don't bother at 'real' exit. the OS cleans up for us.
delete big_clock ;
delete primary_clock ;
delete secondary_clock ;
delete _process_thread ;
delete gui_object_state ;
2014-09-10 20:40:18 -04:00
FastMeter : : flush_pattern_cache ( ) ;
2014-09-10 20:37:42 -04:00
}
2005-09-25 14:42:24 -04:00
}
2008-02-02 12:22:04 -05:00
void
2012-01-10 13:21:39 -05:00
ARDOUR_UI : : pop_back_splash ( Gtk : : Window & win )
2008-02-02 12:22:04 -05:00
{
if ( Splash : : instance ( ) ) {
2012-01-10 13:21:39 -05:00
Splash : : instance ( ) - > pop_back_for ( win ) ;
2008-02-02 12:22:04 -05:00
}
}
2005-09-25 14:42:24 -04:00
gint
ARDOUR_UI : : configure_timeout ( )
{
2008-09-10 11:03:30 -04:00
if ( last_configure_time = = 0 ) {
2005-09-25 14:42:24 -04:00
/* no configure events yet */
2010-03-18 22:49:01 -04:00
return true ;
2005-09-25 14:42:24 -04:00
}
/* force a gap of 0.5 seconds since the last configure event
*/
2008-09-10 11:03:30 -04:00
if ( get_microseconds ( ) - last_configure_time < 500000 ) {
2010-03-18 22:49:01 -04:00
return true ;
2005-09-25 14:42:24 -04:00
} else {
have_configure_timeout = false ;
save_ardour_state ( ) ;
2010-03-18 22:49:01 -04:00
return false ;
2005-09-25 14:42:24 -04:00
}
}
gboolean
2009-07-21 11:55:17 -04:00
ARDOUR_UI : : configure_handler ( GdkEventConfigure * /*conf*/ )
2005-09-25 14:42:24 -04:00
{
if ( have_configure_timeout ) {
2008-09-10 11:03:30 -04:00
last_configure_time = get_microseconds ( ) ;
2005-09-25 14:42:24 -04:00
} else {
2009-12-11 18:29:48 -05:00
Glib : : signal_timeout ( ) . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : configure_timeout ) , 100 ) ;
2005-09-25 14:42:24 -04:00
have_configure_timeout = true ;
}
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
return FALSE ;
}
2007-03-18 02:07:08 -04:00
void
ARDOUR_UI : : set_transport_controllable_state ( const XMLNode & node )
{
const XMLProperty * prop ;
if ( ( prop = node . property ( " roll " ) ) ! = 0 ) {
2008-09-10 11:03:30 -04:00
roll_controllable - > set_id ( prop - > value ( ) ) ;
2007-03-18 02:07:08 -04:00
}
if ( ( prop = node . property ( " stop " ) ) ! = 0 ) {
2008-09-10 11:03:30 -04:00
stop_controllable - > set_id ( prop - > value ( ) ) ;
2007-03-18 02:07:08 -04:00
}
2008-10-05 19:14:48 -04:00
if ( ( prop = node . property ( " goto-start " ) ) ! = 0 ) {
2008-09-10 11:03:30 -04:00
goto_start_controllable - > set_id ( prop - > value ( ) ) ;
2007-03-18 02:07:08 -04:00
}
2008-10-05 19:14:48 -04:00
if ( ( prop = node . property ( " goto-end " ) ) ! = 0 ) {
2008-09-10 11:03:30 -04:00
goto_end_controllable - > set_id ( prop - > value ( ) ) ;
2007-03-18 02:07:08 -04:00
}
2008-10-05 19:14:48 -04:00
if ( ( prop = node . property ( " auto-loop " ) ) ! = 0 ) {
2008-09-10 11:03:30 -04:00
auto_loop_controllable - > set_id ( prop - > value ( ) ) ;
2007-03-18 02:07:08 -04:00
}
2008-10-05 19:14:48 -04:00
if ( ( prop = node . property ( " play-selection " ) ) ! = 0 ) {
2008-09-10 11:03:30 -04:00
play_selection_controllable - > set_id ( prop - > value ( ) ) ;
2007-03-18 02:07:08 -04:00
}
if ( ( prop = node . property ( " rec " ) ) ! = 0 ) {
2008-09-10 11:03:30 -04:00
rec_controllable - > set_id ( prop - > value ( ) ) ;
2007-03-18 02:07:08 -04:00
}
if ( ( prop = node . property ( " shuttle " ) ) ! = 0 ) {
2011-04-20 01:07:41 -04:00
shuttle_box - > controllable ( ) - > set_id ( prop - > value ( ) ) ;
2007-03-18 02:07:08 -04:00
}
}
XMLNode &
ARDOUR_UI : : get_transport_controllable_state ( )
{
XMLNode * node = new XMLNode ( X_ ( " TransportControllables " ) ) ;
char buf [ 64 ] ;
2008-09-10 11:03:30 -04:00
roll_controllable - > id ( ) . print ( buf , sizeof ( buf ) ) ;
2007-03-18 02:07:08 -04:00
node - > add_property ( X_ ( " roll " ) , buf ) ;
2008-09-10 11:03:30 -04:00
stop_controllable - > id ( ) . print ( buf , sizeof ( buf ) ) ;
2007-03-18 02:07:08 -04:00
node - > add_property ( X_ ( " stop " ) , buf ) ;
2008-09-10 11:03:30 -04:00
goto_start_controllable - > id ( ) . print ( buf , sizeof ( buf ) ) ;
2007-03-18 02:07:08 -04:00
node - > add_property ( X_ ( " goto_start " ) , buf ) ;
2008-09-10 11:03:30 -04:00
goto_end_controllable - > id ( ) . print ( buf , sizeof ( buf ) ) ;
2007-03-18 02:07:08 -04:00
node - > add_property ( X_ ( " goto_end " ) , buf ) ;
2008-09-10 11:03:30 -04:00
auto_loop_controllable - > id ( ) . print ( buf , sizeof ( buf ) ) ;
2007-03-18 02:07:08 -04:00
node - > add_property ( X_ ( " auto_loop " ) , buf ) ;
2008-09-10 11:03:30 -04:00
play_selection_controllable - > id ( ) . print ( buf , sizeof ( buf ) ) ;
2007-03-18 02:07:08 -04:00
node - > add_property ( X_ ( " play_selection " ) , buf ) ;
2008-09-10 11:03:30 -04:00
rec_controllable - > id ( ) . print ( buf , sizeof ( buf ) ) ;
2007-03-18 02:07:08 -04:00
node - > add_property ( X_ ( " rec " ) , buf ) ;
2011-04-20 01:07:41 -04:00
shuttle_box - > controllable ( ) - > id ( ) . print ( buf , sizeof ( buf ) ) ;
2007-03-18 02:07:08 -04:00
node - > add_property ( X_ ( " shuttle " ) , buf ) ;
return * node ;
}
2005-09-25 14:42:24 -04:00
2007-04-22 14:01:10 -04:00
gint
ARDOUR_UI : : autosave_session ( )
{
2008-09-10 11:03:30 -04:00
if ( g_main_depth ( ) > 1 ) {
/* inside a recursive main loop,
2009-10-14 12:10:01 -04:00
give up because we may not be able to
2008-09-10 11:03:30 -04:00
take a lock .
*/
2007-05-17 22:41:16 -04:00
return 1 ;
2008-09-10 11:03:30 -04:00
}
2007-05-17 22:41:16 -04:00
2010-11-25 15:37:39 -05:00
if ( ! Config - > get_periodic_safety_backups ( ) ) {
return 1 ;
2007-05-17 22:41:16 -04:00
}
2007-04-22 14:01:10 -04:00
2010-11-25 15:37:39 -05:00
if ( _session ) {
_session - > maybe_write_autosave ( ) ;
}
2008-09-10 11:03:30 -04:00
2007-05-17 22:41:16 -04:00
return 1 ;
2007-04-22 14:01:10 -04:00
}
void
ARDOUR_UI : : update_autosave ( )
{
2009-12-11 18:29:48 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : update_autosave )
2007-04-22 14:01:10 -04:00
2009-12-17 13:24:23 -05:00
if ( _session & & _session - > dirty ( ) ) {
2007-05-17 22:41:16 -04:00
if ( _autosave_connection . connected ( ) ) {
_autosave_connection . disconnect ( ) ;
}
2009-12-11 18:29:48 -05:00
_autosave_connection = Glib : : signal_timeout ( ) . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : autosave_session ) ,
2007-05-17 22:41:16 -04:00
Config - > get_periodic_safety_backup_interval ( ) * 1000 ) ;
2007-04-22 14:01:10 -04:00
2007-05-17 22:41:16 -04:00
} else {
if ( _autosave_connection . connected ( ) ) {
_autosave_connection . disconnect ( ) ;
2009-10-14 12:10:01 -04:00
}
2007-05-17 22:41:16 -04:00
}
2007-04-22 14:01:10 -04:00
}
2013-03-08 11:41:45 -05:00
void
ARDOUR_UI : : check_announcements ( )
{
# ifdef PHONE_HOME
string _annc_filename ;
# ifdef __APPLE__
_annc_filename = PROGRAM_NAME " _announcements_osx_ " ;
# else
_annc_filename = PROGRAM_NAME " _announcements_linux_ " ;
# endif
_annc_filename . append ( VERSIONSTRING ) ;
std : : string path = Glib : : build_filename ( user_config_directory ( ) , _annc_filename ) ;
std : : ifstream announce_file ( path . c_str ( ) ) ;
if ( announce_file . fail ( ) )
_announce_string = " " ;
else {
std : : stringstream oss ;
oss < < announce_file . rdbuf ( ) ;
_announce_string = oss . str ( ) ;
}
pingback ( VERSIONSTRING , path ) ;
# endif
}
2013-10-07 20:27:54 -04:00
int
ARDOUR_UI : : starting ( )
2005-09-25 14:42:24 -04:00
{
2010-11-25 15:37:39 -05:00
Application * app = Application : : instance ( ) ;
2013-10-27 20:48:48 -04:00
const char * nsm_url ;
2013-10-15 12:37:13 -04:00
bool brand_new_user = ArdourStartup : : required ( ) ;
2013-08-01 18:49:40 -04:00
2010-11-25 15:37:39 -05:00
app - > ShouldQuit . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : queue_finish ) ) ;
app - > ShouldLoad . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : idle_load ) ) ;
2010-08-05 15:39:49 -04:00
2013-03-08 11:41:45 -05:00
if ( ARDOUR_COMMAND_LINE : : check_announcements ) {
check_announcements ( ) ;
}
2010-08-05 15:39:49 -04:00
2010-11-25 15:37:39 -05:00
app - > ready ( ) ;
2010-08-20 18:36:35 -04:00
2013-10-27 20:48:48 -04:00
/* we need to create this early because it may need to set the
* audio backend end up .
*/
try {
audio_midi_setup . get ( true ) ;
} catch ( . . . ) {
2014-06-14 10:25:18 -04:00
std : : cerr < < " audio-midi engine setup failed. " < < std : : endl ;
2013-10-27 20:48:48 -04:00
return - 1 ;
}
2013-03-21 16:16:48 -04:00
2013-10-27 20:48:48 -04:00
if ( ( nsm_url = g_getenv ( " NSM_URL " ) ) ! = 0 ) {
2013-03-21 16:16:48 -04:00
nsm = new NSM_Client ;
if ( ! nsm - > init ( nsm_url ) ) {
nsm - > announce ( PROGRAM_NAME , " :dirty: " , " ardour3 " ) ;
2013-04-03 10:18:42 -04:00
unsigned int i = 0 ;
2013-03-30 21:46:07 -04:00
// wait for announce reply from nsm server
2013-04-03 10:18:42 -04:00
for ( i = 0 ; i < 5000 ; + + i ) {
2013-03-30 21:46:07 -04:00
nsm - > check ( ) ;
2014-01-10 16:07:57 -05:00
2013-10-03 04:34:52 -04:00
Glib : : usleep ( i ) ;
2013-10-27 20:32:33 -04:00
if ( nsm - > is_active ( ) ) {
2013-04-03 10:18:42 -04:00
break ;
2013-10-27 20:32:33 -04:00
}
}
if ( i = = 5000 ) {
error < < _ ( " NSM server did not announce itself " ) < < endmsg ;
return - 1 ;
2013-04-03 10:18:42 -04:00
}
2013-03-30 21:46:07 -04:00
// wait for open command from nsm server
2013-04-03 10:18:42 -04:00
for ( i = 0 ; i < 5000 ; + + i ) {
2013-03-21 16:16:48 -04:00
nsm - > check ( ) ;
2013-10-03 04:34:52 -04:00
Glib : : usleep ( 1000 ) ;
2013-10-27 20:32:33 -04:00
if ( nsm - > client_id ( ) ) {
2013-04-03 10:18:42 -04:00
break ;
2013-10-27 20:32:33 -04:00
}
}
if ( i = = 5000 ) {
error < < _ ( " NSM: no client ID provided " ) < < endmsg ;
return - 1 ;
2013-04-03 10:18:42 -04:00
}
2013-03-21 16:16:48 -04:00
2013-03-30 21:46:07 -04:00
if ( _session & & nsm ) {
_session - > set_nsm_state ( nsm - > is_active ( ) ) ;
2013-10-27 20:32:33 -04:00
} else {
error < < _ ( " NSM: no session created " ) < < endmsg ;
return - 1 ;
2013-03-30 21:46:07 -04:00
}
2013-03-31 09:28:29 -04:00
// nsm requires these actions disabled
vector < string > action_names ;
action_names . push_back ( " SaveAs " ) ;
action_names . push_back ( " Rename " ) ;
action_names . push_back ( " New " ) ;
action_names . push_back ( " Open " ) ;
action_names . push_back ( " Recent " ) ;
action_names . push_back ( " Close " ) ;
for ( vector < string > : : const_iterator n = action_names . begin ( ) ; n ! = action_names . end ( ) ; + + n ) {
2013-04-01 19:46:24 -04:00
Glib : : RefPtr < Action > act = ActionManager : : get_action ( X_ ( " Main " ) , ( * n ) . c_str ( ) ) ;
2013-03-31 09:28:29 -04:00
if ( act ) {
act - > set_sensitive ( false ) ;
}
}
2013-10-27 20:32:33 -04:00
} else {
2013-03-21 16:16:48 -04:00
delete nsm ;
nsm = 0 ;
2013-10-27 20:32:33 -04:00
error < < _ ( " NSM: initialization failed " ) < < endmsg ;
return - 1 ;
2013-03-21 16:16:48 -04:00
}
2013-09-23 14:41:52 -04:00
} else {
2013-10-15 12:37:13 -04:00
if ( brand_new_user ) {
2013-09-23 14:41:52 -04:00
ArdourStartup s ;
s . present ( ) ;
main ( ) . run ( ) ;
s . hide ( ) ;
switch ( s . response ( ) ) {
2013-10-15 12:37:13 -04:00
case Gtk : : RESPONSE_OK :
2013-09-23 14:41:52 -04:00
break ;
2013-10-15 12:37:13 -04:00
default :
return - 1 ;
2013-09-23 14:41:52 -04:00
}
}
/* go get a session */
2013-10-15 12:37:13 -04:00
const bool new_session_required = ( ARDOUR_COMMAND_LINE : : new_session | | brand_new_user ) ;
if ( get_session_parameters ( false , new_session_required , ARDOUR_COMMAND_LINE : : load_template ) ) {
2014-06-14 10:25:18 -04:00
std : : cerr < < " Cannot get session parameters. " < < std : : endl ;
2013-10-07 20:27:54 -04:00
return - 1 ;
2013-09-23 14:41:52 -04:00
}
2007-10-11 18:07:47 -04:00
}
2009-04-21 21:35:31 -04:00
2009-05-13 20:13:27 -04:00
use_config ( ) ;
2009-04-21 21:35:31 -04:00
goto_editor_window ( ) ;
2009-10-14 12:10:01 -04:00
2013-05-07 22:09:16 -04:00
WM : : Manager : : instance ( ) . show_visible ( ) ;
2011-06-01 13:00:29 -04:00
2011-10-23 17:31:28 -04:00
/* We have to do this here since goto_editor_window() ends up calling show_all() on the
* editor window , and we may want stuff to be hidden .
*/
2011-10-29 16:07:00 -04:00
_status_bar_visibility . update ( ) ;
2011-10-23 17:31:28 -04:00
2010-03-14 22:31:27 -04:00
BootMessage ( string_compose ( _ ( " %1 is ready for use " ) , PROGRAM_NAME ) ) ;
2013-10-07 20:27:54 -04:00
return 0 ;
2007-03-18 02:07:08 -04:00
}
void
ARDOUR_UI : : check_memory_locking ( )
{
2013-10-14 12:05:42 -04:00
# if defined(__APPLE__) || defined(PLATFORM_WINDOWS)
2007-03-18 02:07:08 -04:00
/* OS X doesn't support mlockall(2), and so testing for memory locking capability there is pointless */
return ;
# else // !__APPLE__
2007-06-16 20:47:40 -04:00
XMLNode * memory_warning_node = Config - > instant_xml ( X_ ( " no-memory-warning " ) ) ;
2007-03-18 02:07:08 -04:00
2013-09-09 13:17:53 -04:00
if ( AudioEngine : : instance ( ) - > is_realtime ( ) & & memory_warning_node = = 0 ) {
2007-03-18 02:07:08 -04:00
struct rlimit limits ;
int64_t ram ;
long pages , page_size ;
2013-01-04 12:36:52 -05:00
# ifdef __FreeBSD__
size_t pages_len = sizeof ( pages ) ;
if ( ( page_size = getpagesize ( ) ) < 0 | |
sysctlbyname ( " hw.availpages " , & pages , & pages_len , NULL , 0 ) )
# else
if ( ( page_size = sysconf ( _SC_PAGESIZE ) ) < 0 | | ( pages = sysconf ( _SC_PHYS_PAGES ) ) < 0 )
# endif
{
2007-03-18 02:07:08 -04:00
ram = 0 ;
} else {
ram = ( int64_t ) pages * ( int64_t ) page_size ;
}
if ( getrlimit ( RLIMIT_MEMLOCK , & limits ) ) {
return ;
}
2009-10-14 12:10:01 -04:00
2007-03-18 02:07:08 -04:00
if ( limits . rlim_cur ! = RLIM_INFINITY ) {
if ( ram = = 0 | | ( ( double ) limits . rlim_cur / ram ) < 0.75 ) {
2009-10-14 12:10:01 -04:00
2010-11-25 15:37:39 -05:00
MessageDialog msg (
2011-03-14 17:53:10 -04:00
string_compose (
_ ( " WARNING: Your system has a limit for maximum amount of locked memory. "
" This might cause %1 to run out of memory before your system "
" runs out of memory. \n \n "
" You can view the memory limit with 'ulimit -l', "
2013-01-04 12:36:52 -05:00
" and it is normally controlled by %2 " ) ,
2013-05-12 18:40:15 -04:00
PROGRAM_NAME ,
2013-01-04 12:36:52 -05:00
# ifdef __FreeBSD__
2013-05-12 18:40:15 -04:00
X_ ( " /etc/login.conf " )
2013-01-04 12:36:52 -05:00
# else
2013-05-12 18:40:15 -04:00
X_ ( " /etc/security/limits.conf " )
2013-01-04 12:36:52 -05:00
# endif
2013-05-12 18:40:15 -04:00
) . c_str ( ) ) ;
2011-03-14 17:53:10 -04:00
2012-12-19 17:16:58 -05:00
msg . set_default_response ( RESPONSE_OK ) ;
2007-03-18 02:07:08 -04:00
VBox * vbox = msg . get_vbox ( ) ;
HBox hbox ;
CheckButton cb ( _ ( " Do not show this window again " ) ) ;
hbox . pack_start ( cb , true , false ) ;
vbox - > pack_start ( hbox ) ;
2007-07-06 17:54:30 -04:00
cb . show ( ) ;
vbox - > show ( ) ;
hbox . show ( ) ;
2008-02-02 12:22:04 -05:00
2012-01-10 13:21:39 -05:00
pop_back_splash ( msg ) ;
2009-10-14 12:10:01 -04:00
2007-03-18 02:07:08 -04:00
editor - > ensure_float ( msg ) ;
msg . run ( ) ;
2013-07-31 05:53:28 -04:00
if ( cb . get_active ( ) ) {
XMLNode node ( X_ ( " no-memory-warning " ) ) ;
Config - > add_instant_xml ( node ) ;
}
2007-03-18 02:07:08 -04:00
}
}
}
# endif // !__APPLE__
2005-09-25 14:42:24 -04:00
}
2007-03-18 02:07:08 -04:00
2010-08-16 15:58:34 -04:00
void
ARDOUR_UI : : queue_finish ( )
{
Glib : : signal_idle ( ) . connect ( mem_fun ( * this , & ARDOUR_UI : : idle_finish ) ) ;
}
bool
ARDOUR_UI : : idle_finish ( )
{
finish ( ) ;
return false ; /* do not call again */
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : finish ( )
{
2013-04-08 22:05:07 -04:00
if ( _session ) {
ARDOUR_UI : : instance ( ) - > video_timeline - > sync_session_state ( ) ;
2008-01-10 17:22:29 -05:00
2009-12-17 13:24:23 -05:00
if ( _session - > dirty ( ) ) {
2011-05-22 16:02:50 -04:00
vector < string > actions ;
actions . push_back ( _ ( " Don't quit " ) ) ;
actions . push_back ( _ ( " Just quit " ) ) ;
actions . push_back ( _ ( " Save and quit " ) ) ;
switch ( ask_about_saving_session ( actions ) ) {
2008-01-10 17:22:29 -05:00
case - 1 :
return ;
break ;
case 1 :
/* use the default name */
if ( save_state_canfail ( " " ) ) {
/* failed - don't quit */
2009-10-14 12:10:01 -04:00
MessageDialog msg ( * editor ,
2012-04-22 21:02:33 -04:00
string_compose ( _ ( " \
% 1 was unable to save your session . \ n \ n \
2005-09-25 14:42:24 -04:00
If you still wish to quit , please use the \ n \ n \
2012-04-22 21:02:33 -04:00
\ " Just quit \" option. " ) , PROGRAM_NAME ) ) ;
2012-01-10 13:21:39 -05:00
pop_back_splash ( msg ) ;
2008-01-10 17:22:29 -05:00
msg . run ( ) ;
return ;
}
break ;
case 0 :
break ;
2005-09-25 14:42:24 -04:00
}
}
2009-10-14 12:10:01 -04:00
2009-11-26 08:26:30 -05:00
second_connection . disconnect ( ) ;
point_one_second_connection . disconnect ( ) ;
2013-07-11 08:50:33 -04:00
point_zero_something_second_connection . disconnect ( ) ;
2014-08-30 14:57:22 -04:00
fps_connection . disconnect ( ) ;
2010-08-17 22:20:15 -04:00
}
2013-03-12 17:00:09 -04:00
delete ARDOUR_UI : : instance ( ) - > video_timeline ;
2013-07-06 22:14:41 -04:00
ARDOUR_UI : : instance ( ) - > video_timeline = NULL ;
2013-03-12 17:00:09 -04:00
stop_video_server ( ) ;
2010-08-17 22:20:15 -04:00
/* Save state before deleting the session, as that causes some
windows to be destroyed before their visible state can be
saved .
*/
save_ardour_state ( ) ;
2013-05-04 22:02:05 -04:00
close_all_dialogs ( ) ;
2010-08-17 22:20:15 -04:00
if ( _session ) {
2009-12-17 13:24:23 -05:00
// _session->set_deletion_in_progress ();
2010-11-25 15:37:39 -05:00
_session - > set_clean ( ) ;
2009-12-17 13:24:23 -05:00
_session - > remove_pending_capture_state ( ) ;
delete _session ;
_session = 0 ;
2007-01-09 18:24:54 -05:00
}
2008-01-10 17:22:29 -05:00
2013-08-08 22:28:31 -04:00
halt_connection . disconnect ( ) ;
2013-09-09 13:17:53 -04:00
AudioEngine : : instance ( ) - > stop ( ) ;
2014-02-21 20:44:34 -05:00
# ifdef WINDOWS_VST_SUPPORT
fst_stop_threading ( ) ;
# endif
2005-12-02 14:18:26 -05:00
quit ( ) ;
2005-09-25 14:42:24 -04:00
}
int
2011-05-22 16:02:50 -04:00
ARDOUR_UI : : ask_about_saving_session ( const vector < string > & actions )
2005-09-25 14:42:24 -04:00
{
2010-04-29 20:16:45 -04:00
ArdourDialog window ( _ ( " Unsaved Session " ) ) ;
2006-04-20 16:41:05 -04:00
Gtk : : HBox dhbox ; // the hbox for the image and text
2005-09-25 14:42:24 -04:00
Gtk : : Label prompt_label ;
2006-04-20 16:41:05 -04:00
Gtk : : Image * dimage = manage ( new Gtk : : Image ( Stock : : DIALOG_WARNING , Gtk : : ICON_SIZE_DIALOG ) ) ;
2005-09-25 14:42:24 -04:00
string msg ;
2011-05-22 16:02:50 -04:00
assert ( actions . size ( ) > = 3 ) ;
window . add_button ( actions [ 0 ] , RESPONSE_REJECT ) ;
window . add_button ( actions [ 1 ] , RESPONSE_APPLY ) ;
window . add_button ( actions [ 2 ] , RESPONSE_ACCEPT ) ;
2006-04-20 16:41:05 -04:00
window . set_default_response ( RESPONSE_ACCEPT ) ;
2005-09-25 14:42:24 -04:00
Gtk : : Button noquit_button ( msg ) ;
noquit_button . set_name ( " EditorGTKButton " ) ;
string prompt ;
2009-12-17 13:24:23 -05:00
if ( _session - > snap_name ( ) = = _session - > name ( ) ) {
2011-05-22 16:47:21 -04:00
prompt = string_compose ( _ ( " The session \" %1 \" \n has not been saved. \n \n Any changes made this time \n will be lost unless you save it. \n \n What do you want to do? " ) ,
_session - > snap_name ( ) ) ;
2005-09-25 14:42:24 -04:00
} else {
2011-05-22 16:47:21 -04:00
prompt = string_compose ( _ ( " The snapshot \" %1 \" \n has not been saved. \n \n Any changes made this time \n will be lost unless you save it. \n \n What do you want to do? " ) ,
_session - > snap_name ( ) ) ;
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
prompt_label . set_text ( prompt ) ;
prompt_label . set_name ( X_ ( " PrompterLabel " ) ) ;
2006-04-20 16:41:05 -04:00
prompt_label . set_alignment ( ALIGN_LEFT , ALIGN_TOP ) ;
2006-04-24 20:51:30 -04:00
2008-09-10 11:03:30 -04:00
dimage - > set_alignment ( ALIGN_CENTER , ALIGN_TOP ) ;
2006-04-22 11:28:59 -04:00
dhbox . set_homogeneous ( false ) ;
2006-04-24 17:34:23 -04:00
dhbox . pack_start ( * dimage , false , false , 5 ) ;
2006-04-20 16:41:05 -04:00
dhbox . pack_start ( prompt_label , true , false , 5 ) ;
window . get_vbox ( ) - > pack_start ( dhbox ) ;
2005-09-25 14:42:24 -04:00
window . set_name ( _ ( " Prompter " ) ) ;
window . set_modal ( true ) ;
2006-04-20 16:41:05 -04:00
window . set_resizable ( false ) ;
2007-07-06 17:54:30 -04:00
dhbox . show ( ) ;
prompt_label . show ( ) ;
dimage - > show ( ) ;
window . show ( ) ;
2007-01-09 18:24:54 -05:00
window . set_keep_above ( true ) ;
window . present ( ) ;
2005-09-25 14:42:24 -04:00
2005-11-27 16:17:41 -05:00
ResponseType r = ( ResponseType ) window . run ( ) ;
window . hide ( ) ;
2005-09-25 14:42:24 -04:00
2005-11-27 16:17:41 -05:00
switch ( r ) {
2005-12-02 14:18:26 -05:00
case RESPONSE_ACCEPT : // save and get out of here
return 1 ;
case RESPONSE_APPLY : // get out of here
2005-11-27 16:17:41 -05:00
return 0 ;
default :
break ;
}
return - 1 ;
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
2012-07-13 17:05:45 -04:00
2014-12-25 10:02:00 -05:00
void
2005-09-25 14:42:24 -04:00
ARDOUR_UI : : every_second ( )
{
update_cpu_load ( ) ;
update_buffer_load ( ) ;
update_disk_space ( ) ;
2012-10-12 12:25:57 -04:00
update_timecode_format ( ) ;
2013-03-21 16:16:48 -04:00
2013-04-02 14:33:39 -04:00
if ( nsm & & nsm - > is_active ( ) ) {
2013-03-21 16:16:48 -04:00
nsm - > check ( ) ;
if ( ! _was_dirty & & _session - > dirty ( ) ) {
nsm - > is_dirty ( ) ;
_was_dirty = true ;
}
else if ( _was_dirty & & ! _session - > dirty ( ) ) {
nsm - > is_clean ( ) ;
_was_dirty = false ;
}
}
2005-09-25 14:42:24 -04:00
}
2014-12-25 10:02:00 -05:00
void
2005-09-25 14:42:24 -04:00
ARDOUR_UI : : every_point_one_seconds ( )
{
2011-04-19 22:48:20 -04:00
shuttle_box - > update_speed_display ( ) ;
2005-09-25 14:42:24 -04:00
}
2014-12-25 10:02:00 -05:00
void
2013-07-11 08:50:33 -04:00
ARDOUR_UI : : every_point_zero_something_seconds ( )
2005-09-25 14:42:24 -04:00
{
2013-07-11 08:50:33 -04:00
// august 2007: actual update frequency: 25Hz (40ms), not 100Hz
2007-10-11 18:07:47 -04:00
2014-12-22 13:39:41 -05:00
if ( editor_meter & & ARDOUR_UI : : config ( ) - > get_show_editor_meter ( ) ) {
2013-08-03 07:59:22 -04:00
float mpeak = editor_meter - > update_meters ( ) ;
if ( mpeak > editor_meter_max_peak ) {
2014-12-22 13:39:41 -05:00
if ( mpeak > = ARDOUR_UI : : config ( ) - > get_meter_peak ( ) ) {
2014-08-22 12:45:34 -04:00
editor_meter_peak_display . set_active_state ( Gtkmm2ext : : ExplicitActive ) ;
2013-08-03 07:59:22 -04:00
}
}
2013-07-24 16:04:46 -04:00
}
2014-08-30 14:57:22 -04:00
}
void
ARDOUR_UI : : set_fps_timeout_connection ( )
{
unsigned int interval = 40 ;
if ( ! _session ) return ;
if ( _session - > timecode_frames_per_second ( ) ! = 0 ) {
/* ideally we'll use a select() to sleep and not accumulate
* idle time to provide a regular periodic signal .
* See linux_vst_gui_support . cc ' elapsed_time_ms ' .
* However , that ' ll require a dedicated thread and cross - thread
* signals to the GUI Thread . .
*/
interval = floor ( 500. /* update twice per FPS, since Glib::signal_timeout is very irregular */
* _session - > frame_rate ( ) / _session - > nominal_frame_rate ( )
/ _session - > timecode_frames_per_second ( )
) ;
2014-10-25 13:21:15 -04:00
# ifdef PLATFORM_WINDOWS
// the smallest windows scheduler time-slice is ~15ms.
// periodic GUI timeouts shorter than that will cause
// WaitForSingleObject to spinlock (100% of one CPU Core)
// and gtk never enters idle mode.
// also changing timeBeginPeriod(1) does not affect that in
// any beneficial way, so we just limit the max rate for now.
interval = std : : max ( 30u , interval ) ; // at most ~33Hz.
# else
2014-08-30 14:57:22 -04:00
interval = std : : max ( 8u , interval ) ; // at most 120Hz.
2014-10-25 13:21:15 -04:00
# endif
2014-08-30 14:57:22 -04:00
}
fps_connection . disconnect ( ) ;
2014-12-25 10:02:00 -05:00
Timers : : set_fps_interval ( interval ) ;
2014-08-30 14:57:22 -04:00
}
2005-09-25 14:42:24 -04:00
void
2010-12-03 17:26:29 -05:00
ARDOUR_UI : : update_sample_rate ( framecnt_t )
2005-09-25 14:42:24 -04:00
{
2011-10-22 20:15:35 -04:00
char buf [ 64 ] ;
2005-09-25 14:42:24 -04:00
2009-12-11 18:29:48 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : update_sample_rate , ignored )
2005-09-25 14:42:24 -04:00
2013-09-09 13:17:53 -04:00
if ( ! AudioEngine : : instance ( ) - > connected ( ) ) {
2005-09-25 14:42:24 -04:00
2013-08-08 16:31:08 -04:00
snprintf ( buf , sizeof ( buf ) , _ ( " Audio: <span foreground= \" red \" >none</span> " ) ) ;
2005-09-25 14:42:24 -04:00
} else {
2013-09-09 13:17:53 -04:00
framecnt_t rate = AudioEngine : : instance ( ) - > sample_rate ( ) ;
2009-10-14 12:10:01 -04:00
2013-08-07 22:22:11 -04:00
if ( rate = = 0 ) {
/* no sample rate available */
2013-08-07 22:24:30 -04:00
snprintf ( buf , sizeof ( buf ) , _ ( " Audio: <span foreground= \" red \" >none</span> " ) ) ;
2005-09-25 14:42:24 -04:00
} else {
2013-08-07 22:22:11 -04:00
if ( fmod ( rate , 1000.0 ) ! = 0.0 ) {
snprintf ( buf , sizeof ( buf ) , _ ( " Audio: <span foreground= \" green \" >%.1f kHz / %4.1f ms</span> " ) ,
( float ) rate / 1000.0f ,
2013-09-09 13:17:53 -04:00
( AudioEngine : : instance ( ) - > usecs_per_cycle ( ) / 1000.0f ) ) ;
2013-08-07 22:22:11 -04:00
} else {
snprintf ( buf , sizeof ( buf ) , _ ( " Audio: <span foreground= \" green \" >% " PRId64 " kHz / %4.1f ms</span> " ) ,
rate / 1000 ,
2013-09-09 13:17:53 -04:00
( AudioEngine : : instance ( ) - > usecs_per_cycle ( ) / 1000.0f ) ) ;
2013-08-07 22:22:11 -04:00
}
2005-09-25 14:42:24 -04:00
}
}
2011-10-22 20:15:35 -04:00
sample_rate_label . set_markup ( buf ) ;
2005-09-25 14:42:24 -04:00
}
2011-07-02 20:45:15 -04:00
void
ARDOUR_UI : : update_format ( )
{
if ( ! _session ) {
format_label . set_text ( " " ) ;
return ;
}
stringstream s ;
2011-11-22 07:35:25 -05:00
s < < _ ( " File: " ) < < X_ ( " <span foreground= \" green \" > " ) ;
2011-07-02 20:45:15 -04:00
switch ( _session - > config . get_native_file_header_format ( ) ) {
case BWF :
2011-11-22 07:35:25 -05:00
s < < _ ( " BWF " ) ;
2011-07-02 20:45:15 -04:00
break ;
case WAVE :
2011-11-22 07:35:25 -05:00
s < < _ ( " WAV " ) ;
2011-07-02 20:45:15 -04:00
break ;
case WAVE64 :
2011-11-22 07:35:25 -05:00
s < < _ ( " WAV64 " ) ;
2011-07-02 20:45:15 -04:00
break ;
case CAF :
2011-11-22 07:35:25 -05:00
s < < _ ( " CAF " ) ;
2011-07-02 20:45:15 -04:00
break ;
case AIFF :
2011-11-22 07:35:25 -05:00
s < < _ ( " AIFF " ) ;
2011-07-02 20:45:15 -04:00
break ;
case iXML :
2011-11-22 07:35:25 -05:00
s < < _ ( " iXML " ) ;
2011-07-02 20:45:15 -04:00
break ;
case RF64 :
2011-11-22 07:35:25 -05:00
s < < _ ( " RF64 " ) ;
2011-07-02 20:45:15 -04:00
break ;
}
s < < " " ;
switch ( _session - > config . get_native_file_data_format ( ) ) {
case FormatFloat :
2011-11-22 07:35:25 -05:00
s < < _ ( " 32-float " ) ;
2011-07-02 20:45:15 -04:00
break ;
case FormatInt24 :
2011-11-22 07:35:25 -05:00
s < < _ ( " 24-int " ) ;
2011-07-02 20:45:15 -04:00
break ;
case FormatInt16 :
2011-11-22 07:35:25 -05:00
s < < _ ( " 16-int " ) ;
2011-07-02 20:45:15 -04:00
break ;
}
2011-11-22 07:35:25 -05:00
s < < X_ ( " </span> " ) ;
2011-10-22 20:15:35 -04:00
format_label . set_markup ( s . str ( ) ) ;
2011-07-02 20:45:15 -04:00
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : update_cpu_load ( )
{
2011-10-22 20:15:35 -04:00
char buf [ 64 ] ;
2011-11-14 06:31:27 -05:00
/* If this text is changed, the set_size_request_to_display_given_text call in ARDOUR_UI::resize_text_widgets
2011-10-23 17:31:09 -04:00
should also be changed .
*/
2014-11-26 04:57:14 -05:00
double const c = AudioEngine : : instance ( ) - > get_dsp_load ( ) ;
2011-10-22 20:26:19 -04:00
snprintf ( buf , sizeof ( buf ) , _ ( " DSP: <span foreground= \" %s \" >%5.1f%%</span> " ) , c > = 90 ? X_ ( " red " ) : X_ ( " green " ) , c ) ;
2011-10-22 20:15:35 -04:00
cpu_load_label . set_markup ( buf ) ;
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : update_buffer_load ( )
{
2011-10-22 20:15:35 -04:00
char buf [ 256 ] ;
uint32_t const playback = _session ? _session - > playback_load ( ) : 100 ;
uint32_t const capture = _session ? _session - > capture_load ( ) : 100 ;
2005-09-25 14:42:24 -04:00
2011-11-14 06:31:27 -05:00
/* If this text is changed, the set_size_request_to_display_given_text call in ARDOUR_UI::resize_text_widgets
2011-10-23 17:31:09 -04:00
should also be changed .
*/
2009-12-17 13:24:23 -05:00
if ( _session ) {
2011-10-22 20:15:35 -04:00
snprintf (
buf , sizeof ( buf ) ,
_ ( " Buffers: <span foreground= \" green \" >p:</span><span foreground= \" %s \" >% " PRIu32 " %%</span> "
" <span foreground= \" green \" >c:</span><span foreground= \" %s \" >% " PRIu32 " %%</span> " ) ,
playback < = 5 ? X_ ( " red " ) : X_ ( " green " ) ,
playback ,
capture < = 5 ? X_ ( " red " ) : X_ ( " green " ) ,
capture
) ;
buffer_load_label . set_markup ( buf ) ;
2005-09-25 14:42:24 -04:00
} else {
buffer_load_label . set_text ( " " ) ;
}
}
void
2006-11-19 11:45:16 -05:00
ARDOUR_UI : : count_recenabled_streams ( Route & route )
2005-09-25 14:42:24 -04:00
{
2006-07-27 21:08:57 -04:00
Track * track = dynamic_cast < Track * > ( & route ) ;
2010-04-21 16:42:22 -04:00
if ( track & & track - > record_enabled ( ) ) {
2007-06-03 20:05:33 -04:00
rec_enabled_streams + = track - > n_inputs ( ) . n_total ( ) ;
2005-09-25 14:42:24 -04:00
}
}
void
ARDOUR_UI : : update_disk_space ( )
{
2009-12-17 13:24:23 -05:00
if ( _session = = 0 ) {
2005-09-25 14:42:24 -04:00
return ;
}
2012-06-12 12:41:29 -04:00
boost : : optional < framecnt_t > opt_frames = _session - > available_capture_duration ( ) ;
2005-09-25 14:42:24 -04:00
char buf [ 64 ] ;
2010-12-03 17:26:29 -05:00
framecnt_t fr = _session - > frame_rate ( ) ;
2009-10-14 12:10:01 -04:00
2013-08-07 22:22:11 -04:00
if ( fr = = 0 ) {
/* skip update - no SR available */
return ;
}
2012-06-12 12:41:29 -04:00
if ( ! opt_frames ) {
/* Available space is unknown */
snprintf ( buf , sizeof ( buf ) , " %s " , _ ( " Disk: <span foreground= \" green \" >Unknown</span> " ) ) ;
} else if ( opt_frames . get_value_or ( 0 ) = = max_framecnt ) {
2012-05-02 16:29:46 -04:00
snprintf ( buf , sizeof ( buf ) , " %s " , _ ( " Disk: <span foreground= \" green \" >24hrs+</span> " ) ) ;
2005-09-25 14:42:24 -04:00
} else {
2006-11-19 11:45:16 -05:00
rec_enabled_streams = 0 ;
2009-12-17 13:24:23 -05:00
_session - > foreach_route ( this , & ARDOUR_UI : : count_recenabled_streams ) ;
2009-10-14 12:10:01 -04:00
2012-06-12 12:41:29 -04:00
framecnt_t frames = opt_frames . get_value_or ( 0 ) ;
2006-11-19 11:45:16 -05:00
if ( rec_enabled_streams ) {
frames / = rec_enabled_streams ;
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
2008-09-19 10:38:46 -04:00
int hrs ;
int mins ;
int secs ;
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
hrs = frames / ( fr * 3600 ) ;
2009-10-14 12:10:01 -04:00
2011-11-09 12:29:23 -05:00
if ( hrs > 24 ) {
2012-05-02 16:29:46 -04:00
snprintf ( buf , sizeof ( buf ) , " %s " , _ ( " Disk: <span foreground= \" green \" >>24 hrs</span> " ) ) ;
2011-11-09 12:29:23 -05:00
} else {
frames - = hrs * fr * 3600 ;
mins = frames / ( fr * 60 ) ;
frames - = mins * fr * 60 ;
secs = frames / fr ;
bool const low = ( hrs = = 0 & & mins < = 30 ) ;
snprintf (
buf , sizeof ( buf ) ,
_ ( " Disk: <span foreground= \" %s \" >%02dh:%02dm:%02ds</span> " ) ,
low ? X_ ( " red " ) : X_ ( " green " ) ,
hrs , mins , secs
) ;
}
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
2011-10-22 20:15:35 -04:00
disk_space_label . set_markup ( buf ) ;
2009-10-14 12:10:01 -04:00
}
2005-09-25 14:42:24 -04:00
2012-10-12 12:25:57 -04:00
void
ARDOUR_UI : : update_timecode_format ( )
{
char buf [ 64 ] ;
if ( _session ) {
2012-10-12 18:04:21 -04:00
bool matching ;
TimecodeSlave * tcslave ;
2012-11-11 18:11:53 -05:00
SyncSource sync_src = Config - > get_sync_source ( ) ;
2012-10-12 18:04:21 -04:00
2012-11-11 18:11:53 -05:00
if ( ( sync_src = = LTC | | sync_src = = MTC ) & & ( tcslave = dynamic_cast < TimecodeSlave * > ( _session - > slave ( ) ) ) ! = 0 ) {
2012-10-12 18:04:21 -04:00
matching = ( tcslave - > apparent_timecode_format ( ) = = _session - > config . get_timecode_format ( ) ) ;
} else {
matching = true ;
}
2012-11-09 09:24:31 -05:00
snprintf ( buf , sizeof ( buf ) , S_ ( " Timecode|TC: <span foreground= \" %s \" >%s</span> " ) ,
2012-10-14 12:17:33 -04:00
matching ? X_ ( " green " ) : X_ ( " red " ) ,
2012-10-12 12:25:57 -04:00
Timecode : : timecode_format_name ( _session - > config . get_timecode_format ( ) ) . c_str ( ) ) ;
} else {
snprintf ( buf , sizeof ( buf ) , " TC: n/a " ) ;
}
timecode_format_label . set_markup ( buf ) ;
}
2005-09-25 14:42:24 -04:00
gint
ARDOUR_UI : : update_wall_clock ( )
{
time_t now ;
struct tm * tm_now ;
2012-12-26 11:44:09 -05:00
static int last_min = - 1 ;
2005-09-25 14:42:24 -04:00
time ( & now ) ;
tm_now = localtime ( & now ) ;
2012-12-26 11:44:09 -05:00
if ( last_min ! = tm_now - > tm_min ) {
char buf [ 16 ] ;
sprintf ( buf , " %02d:%02d " , tm_now - > tm_hour , tm_now - > tm_min ) ;
wall_clock_label . set_text ( buf ) ;
last_min = tm_now - > tm_min ;
}
2005-09-25 14:42:24 -04:00
return TRUE ;
}
void
ARDOUR_UI : : redisplay_recent_sessions ( )
{
2012-06-23 01:09:46 -04:00
std : : vector < std : : string > session_directories ;
2005-09-25 14:42:24 -04:00
RecentSessionsSorter cmp ;
2009-10-14 12:10:01 -04:00
2005-10-06 14:24:23 -04:00
recent_session_display . set_model ( Glib : : RefPtr < TreeModel > ( 0 ) ) ;
recent_session_model - > clear ( ) ;
2005-09-25 14:42:24 -04:00
2007-09-04 01:26:28 -04:00
ARDOUR : : RecentSessions rs ;
2005-09-25 14:42:24 -04:00
ARDOUR : : read_recent_sessions ( rs ) ;
if ( rs . empty ( ) ) {
2005-10-06 14:24:23 -04:00
recent_session_display . set_model ( recent_session_model ) ;
2005-09-25 14:42:24 -04:00
return ;
}
2012-04-22 21:13:34 -04:00
2007-09-04 01:26:28 -04:00
// sort them alphabetically
2005-10-06 14:24:23 -04:00
sort ( rs . begin ( ) , rs . end ( ) , cmp ) ;
2009-10-14 12:10:01 -04:00
2007-09-04 01:26:28 -04:00
for ( ARDOUR : : RecentSessions : : iterator i = rs . begin ( ) ; i ! = rs . end ( ) ; + + i ) {
2010-11-25 15:37:39 -05:00
session_directories . push_back ( ( * i ) . second ) ;
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
2012-06-23 01:09:46 -04:00
for ( vector < std : : string > : : const_iterator i = session_directories . begin ( ) ;
2007-09-04 01:26:28 -04:00
i ! = session_directories . end ( ) ; + + i )
{
2012-06-23 01:06:54 -04:00
std : : vector < std : : string > state_file_paths ;
2009-10-14 12:10:01 -04:00
2007-09-04 01:26:28 -04:00
// now get available states for this session
2005-09-25 14:42:24 -04:00
2012-06-23 01:09:46 -04:00
get_state_files_in_directory ( * i , state_file_paths ) ;
2005-09-25 14:42:24 -04:00
2014-06-16 06:39:45 -04:00
vector < string > states ;
2008-02-02 12:22:04 -05:00
vector < const gchar * > item ;
2012-06-23 01:09:46 -04:00
string fullpath = * i ;
2009-10-14 12:10:01 -04:00
2008-02-02 12:22:04 -05:00
/* remove any trailing / */
2012-04-22 21:13:34 -04:00
if ( fullpath [ fullpath . length ( ) - 1 ] = = ' / ' ) {
fullpath = fullpath . substr ( 0 , fullpath . length ( ) - 1 ) ;
2008-02-02 12:22:04 -05:00
}
/* check whether session still exists */
if ( ! Glib : : file_test ( fullpath . c_str ( ) , Glib : : FILE_TEST_EXISTS ) ) {
/* session doesn't exist */
continue ;
2009-10-14 12:10:01 -04:00
}
2008-02-02 12:22:04 -05:00
/* now get available states for this session */
2014-06-16 06:39:45 -04:00
states = Session : : possible_states ( fullpath ) ;
2008-02-02 12:22:04 -05:00
2014-06-16 06:39:45 -04:00
if ( states . empty ( ) ) {
2008-02-02 12:22:04 -05:00
/* no state file? */
2005-09-25 14:42:24 -04:00
continue ;
}
2009-10-14 12:10:01 -04:00
2007-09-04 01:26:28 -04:00
std : : vector < string > state_file_names ( get_file_names_no_extension ( state_file_paths ) ) ;
2005-09-25 14:42:24 -04:00
2007-09-04 01:26:28 -04:00
Gtk : : TreeModel : : Row row = * ( recent_session_model - > append ( ) ) ;
2005-09-25 14:42:24 -04:00
2005-10-06 14:24:23 -04:00
row [ recent_session_columns . fullpath ] = fullpath ;
2013-01-22 13:27:13 -05:00
row [ recent_session_columns . tip ] = Glib : : Markup : : escape_text ( fullpath ) ;
2009-10-14 12:10:01 -04:00
2007-09-04 01:26:28 -04:00
if ( state_file_names . size ( ) > 1 ) {
2014-06-06 08:25:13 -04:00
// multiple session files in the session directory - show the directory name.
row [ recent_session_columns . visible_name ] = Glib : : path_get_basename ( fullpath ) ;
2005-09-25 14:42:24 -04:00
2007-09-04 01:26:28 -04:00
// add the children
for ( std : : vector < std : : string > : : iterator i2 = state_file_names . begin ( ) ;
i2 ! = state_file_names . end ( ) ; + + i2 )
{
2005-10-06 14:24:23 -04:00
2007-09-04 01:26:28 -04:00
Gtk : : TreeModel : : Row child_row = * ( recent_session_model - > append ( row . children ( ) ) ) ;
2005-10-06 14:24:23 -04:00
2007-09-04 01:26:28 -04:00
child_row [ recent_session_columns . visible_name ] = * i2 ;
child_row [ recent_session_columns . fullpath ] = fullpath ;
2013-01-22 13:27:13 -05:00
child_row [ recent_session_columns . tip ] = Glib : : Markup : : escape_text ( fullpath ) ;
2005-09-25 14:42:24 -04:00
}
2014-06-06 08:25:13 -04:00
} else {
// only a single session file in the directory - show its actual name.
row [ recent_session_columns . visible_name ] = state_file_names . front ( ) ;
2005-09-25 14:42:24 -04:00
}
}
2013-01-22 13:27:13 -05:00
recent_session_display . set_tooltip_column ( 1 ) ; // recent_session_columns.tip
2005-10-06 14:24:23 -04:00
recent_session_display . set_model ( recent_session_model ) ;
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : build_session_selector ( )
{
2009-08-20 17:33:48 -04:00
session_selector_window = new ArdourDialog ( _ ( " Recent Sessions " ) ) ;
2009-10-14 12:10:01 -04:00
2005-10-06 14:24:23 -04:00
Gtk : : ScrolledWindow * scroller = manage ( new Gtk : : ScrolledWindow ) ;
2009-10-14 12:10:01 -04:00
2005-11-27 16:17:41 -05:00
session_selector_window - > add_button ( Stock : : CANCEL , RESPONSE_CANCEL ) ;
2006-04-19 04:14:39 -04:00
session_selector_window - > add_button ( Stock : : OPEN , RESPONSE_ACCEPT ) ;
2006-04-19 16:42:17 -04:00
session_selector_window - > set_default_response ( RESPONSE_ACCEPT ) ;
2005-10-06 14:24:23 -04:00
recent_session_model = TreeStore : : create ( recent_session_columns ) ;
recent_session_display . set_model ( recent_session_model ) ;
recent_session_display . append_column ( _ ( " Recent Sessions " ) , recent_session_columns . visible_name ) ;
recent_session_display . set_headers_visible ( false ) ;
2008-01-10 17:22:29 -05:00
recent_session_display . get_selection ( ) - > set_mode ( SELECTION_BROWSE ) ;
2009-12-11 18:29:48 -05:00
recent_session_display . signal_row_activated ( ) . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : recent_session_row_activated ) ) ;
2005-10-06 14:24:23 -04:00
scroller - > add ( recent_session_display ) ;
scroller - > set_policy ( Gtk : : POLICY_NEVER , Gtk : : POLICY_AUTOMATIC ) ;
2005-09-25 14:42:24 -04:00
session_selector_window - > set_name ( " SessionSelectorWindow " ) ;
2005-09-25 16:33:00 -04:00
session_selector_window - > set_size_request ( 200 , 400 ) ;
2005-11-27 16:17:41 -05:00
session_selector_window - > get_vbox ( ) - > pack_start ( * scroller ) ;
2007-07-06 17:54:30 -04:00
recent_session_display . show ( ) ;
scroller - > show ( ) ;
2005-10-06 14:24:23 -04:00
}
2006-03-29 22:38:33 -05:00
void
2009-07-21 11:55:17 -04:00
ARDOUR_UI : : recent_session_row_activated ( const TreePath & /*path*/ , TreeViewColumn * /*col*/ )
2006-03-29 22:38:33 -05:00
{
session_selector_window - > response ( RESPONSE_ACCEPT ) ;
}
2005-10-06 14:24:23 -04:00
void
ARDOUR_UI : : open_recent_session ( )
{
2009-12-17 13:24:23 -05:00
bool can_return = ( _session ! = 0 ) ;
2005-10-06 14:24:23 -04:00
if ( session_selector_window = = 0 ) {
build_session_selector ( ) ;
}
2009-10-14 12:10:01 -04:00
2005-10-06 14:24:23 -04:00
redisplay_recent_sessions ( ) ;
2008-01-10 17:22:29 -05:00
while ( true ) {
2009-10-14 12:10:01 -04:00
2008-01-10 17:22:29 -05:00
ResponseType r = ( ResponseType ) session_selector_window - > run ( ) ;
2009-10-14 12:10:01 -04:00
2008-01-10 17:22:29 -05:00
switch ( r ) {
case RESPONSE_ACCEPT :
break ;
default :
if ( can_return ) {
session_selector_window - > hide ( ) ;
return ;
} else {
exit ( 1 ) ;
}
}
2005-10-06 14:24:23 -04:00
2008-01-10 17:22:29 -05:00
if ( recent_session_display . get_selection ( ) - > count_selected_rows ( ) = = 0 ) {
continue ;
}
2009-10-14 12:10:01 -04:00
2008-01-10 17:22:29 -05:00
session_selector_window - > hide ( ) ;
2005-10-06 14:24:23 -04:00
2008-01-10 17:22:29 -05:00
Gtk : : TreeModel : : iterator i = recent_session_display . get_selection ( ) - > get_selected ( ) ;
2009-10-14 12:10:01 -04:00
2008-01-10 17:22:29 -05:00
if ( i = = recent_session_model - > children ( ) . end ( ) ) {
return ;
}
2009-10-14 12:10:01 -04:00
2010-09-14 12:51:02 -04:00
std : : string path = ( * i ) [ recent_session_columns . fullpath ] ;
std : : string state = ( * i ) [ recent_session_columns . visible_name ] ;
2009-10-14 12:10:01 -04:00
2008-01-10 17:22:29 -05:00
_session_is_new = false ;
2009-10-14 12:10:01 -04:00
2008-01-10 17:22:29 -05:00
if ( load_session ( path , state ) = = 0 ) {
break ;
}
2005-10-06 14:24:23 -04:00
2008-01-10 17:22:29 -05:00
can_return = false ;
2005-10-06 14:24:23 -04:00
}
2005-09-25 14:42:24 -04:00
}
2007-04-29 13:23:11 -04:00
bool
ARDOUR_UI : : check_audioengine ( )
{
2013-09-09 13:17:53 -04:00
if ( ! AudioEngine : : instance ( ) - > connected ( ) ) {
MessageDialog msg ( string_compose (
_ ( " %1 is not connected to any audio backend. \n "
" You cannot open or close sessions in this condition " ) ,
PROGRAM_NAME ) ) ;
pop_back_splash ( msg ) ;
msg . run ( ) ;
2007-04-29 13:23:11 -04:00
return false ;
}
2013-09-09 13:17:53 -04:00
return true ;
2007-04-29 13:23:11 -04:00
}
2005-09-25 14:42:24 -04:00
void
2005-10-06 14:24:23 -04:00
ARDOUR_UI : : open_session ( )
2005-09-25 14:42:24 -04:00
{
2007-04-29 13:23:11 -04:00
if ( ! check_audioengine ( ) ) {
return ;
2009-10-14 12:10:01 -04:00
2007-04-29 13:23:11 -04:00
}
2005-10-06 14:24:23 -04:00
/* popup selector window */
if ( open_session_selector = = 0 ) {
2005-12-06 01:23:50 -05:00
/* ardour sessions are folders */
2009-10-19 13:25:37 -04:00
open_session_selector = new Gtk : : FileChooserDialog ( _ ( " Open Session " ) , FILE_CHOOSER_ACTION_OPEN ) ;
2005-10-06 14:24:23 -04:00
open_session_selector - > add_button ( Gtk : : Stock : : CANCEL , Gtk : : RESPONSE_CANCEL ) ;
2005-12-06 01:23:50 -05:00
open_session_selector - > add_button ( Gtk : : Stock : : OPEN , Gtk : : RESPONSE_ACCEPT ) ;
2007-10-11 18:07:47 -04:00
open_session_selector - > set_default_response ( Gtk : : RESPONSE_ACCEPT ) ;
2012-03-15 08:04:00 -04:00
if ( _session ) {
string session_parent_dir = Glib : : path_get_dirname ( _session - > path ( ) ) ;
string : : size_type last_dir_sep = session_parent_dir . rfind ( G_DIR_SEPARATOR ) ;
session_parent_dir = session_parent_dir . substr ( 0 , last_dir_sep ) ;
open_session_selector - > set_current_folder ( session_parent_dir ) ;
} else {
open_session_selector - > set_current_folder ( Config - > get_default_session_parent_dir ( ) ) ;
}
2013-07-19 07:04:58 -04:00
string default_session_folder = Config - > get_default_session_parent_dir ( ) ;
try {
/* add_shortcut_folder throws an exception if the folder being added already has a shortcut */
open_session_selector - > add_shortcut_folder ( default_session_folder ) ;
}
catch ( Glib : : Error & e ) {
std : : cerr < < " open_session_selector->add_shortcut_folder ( " < < default_session_folder < < " ) threw Glib::Error " < < e . what ( ) < < std : : endl ;
}
2005-12-06 01:23:50 -05:00
FileFilter session_filter ;
2015-01-06 02:02:31 -05:00
session_filter . add_pattern ( string_compose ( X_ ( " *%1 " ) , ARDOUR : : statefile_suffix ) ) ;
2010-03-14 22:31:27 -04:00
session_filter . set_name ( string_compose ( _ ( " %1 sessions " ) , PROGRAM_NAME ) ) ;
2005-12-06 01:23:50 -05:00
open_session_selector - > add_filter ( session_filter ) ;
open_session_selector - > set_filter ( session_filter ) ;
2005-10-06 14:24:23 -04:00
}
2005-12-06 01:23:50 -05:00
int response = open_session_selector - > run ( ) ;
open_session_selector - > hide ( ) ;
switch ( response ) {
case RESPONSE_ACCEPT :
2005-10-06 14:24:23 -04:00
break ;
default :
2005-12-05 07:07:34 -05:00
open_session_selector - > hide ( ) ;
2005-10-06 14:24:23 -04:00
return ;
}
2005-12-05 07:07:34 -05:00
open_session_selector - > hide ( ) ;
2005-09-25 14:42:24 -04:00
string session_path = open_session_selector - > get_filename ( ) ;
string path , name ;
bool isnew ;
if ( session_path . length ( ) > 0 ) {
2007-05-17 22:41:44 -04:00
if ( ARDOUR : : find_session ( session_path , path , name , isnew ) = = 0 ) {
2005-09-25 14:42:24 -04:00
_session_is_new = isnew ;
load_session ( path , name ) ;
}
}
}
void
2012-06-21 21:45:16 -04:00
ARDOUR_UI : : session_add_mixed_track ( const ChanCount & input , const ChanCount & output , RouteGroup * route_group ,
uint32_t how_many , const string & name_template , PluginInfoPtr instrument )
2005-09-25 14:42:24 -04:00
{
2006-08-24 03:37:17 -04:00
list < boost : : shared_ptr < MidiTrack > > tracks ;
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
2009-12-17 13:24:23 -05:00
if ( _session = = 0 ) {
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
warning < < _ ( " You cannot add a track without a session already loaded. " ) < < endmsg ;
return ;
}
2009-10-14 12:10:01 -04:00
try {
2012-06-21 21:45:16 -04:00
tracks = _session - > new_midi_track ( input , output , instrument , ARDOUR : : Normal , route_group , how_many , name_template ) ;
if ( tracks . size ( ) ! = how_many ) {
2013-01-05 07:54:30 -05:00
error < < string_compose ( P_ ( " could not create %1 new mixed track " , " could not create %1 new mixed tracks " , how_many ) , how_many ) < < endmsg ;
2012-04-22 21:13:34 -04:00
}
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
}
catch ( . . . ) {
2009-10-14 12:10:01 -04:00
MessageDialog msg ( * editor ,
2014-04-10 10:21:47 -04:00
string_compose ( _ ( " There are insufficient ports available \n \
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
to create a new track or bus . \ n \
2010-08-16 20:28:20 -04:00
You should save % 1 , exit and \ n \
2014-04-10 10:21:47 -04:00
restart with more ports . " ), PROGRAM_NAME));
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
msg . run ( ) ;
}
2005-09-25 14:42:24 -04:00
}
2012-06-21 21:45:16 -04:00
2005-09-25 14:42:24 -04:00
2012-06-21 21:45:16 -04:00
void
ARDOUR_UI : : session_add_midi_route ( bool disk , RouteGroup * route_group , uint32_t how_many , const string & name_template , PluginInfoPtr instrument )
{
ChanCount one_midi_channel ;
one_midi_channel . set ( DataType : : MIDI , 1 ) ;
if ( disk ) {
session_add_mixed_track ( one_midi_channel , one_midi_channel , route_group , how_many , name_template , instrument ) ;
}
}
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
2005-09-25 14:42:24 -04:00
void
2011-02-26 20:59:04 -05:00
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 ,
string const & name_template
)
2005-09-25 14:42:24 -04:00
{
2006-08-24 03:37:17 -04:00
list < boost : : shared_ptr < AudioTrack > > tracks ;
2009-01-30 02:40:13 -05:00
RouteList routes ;
2005-09-25 14:42:24 -04:00
2009-12-17 13:24:23 -05:00
if ( _session = = 0 ) {
2006-08-24 03:37:17 -04:00
warning < < _ ( " You cannot add a track or bus without a session already loaded. " ) < < endmsg ;
2005-09-25 14:42:24 -04:00
return ;
}
2009-10-14 12:10:01 -04:00
try {
2006-08-24 03:37:17 -04:00
if ( track ) {
2011-02-26 20:59:04 -05:00
tracks = _session - > new_audio_track ( input_channels , output_channels , mode , route_group , how_many , name_template ) ;
2006-08-24 03:37:17 -04:00
if ( tracks . size ( ) ! = how_many ) {
2013-01-04 11:49:21 -05:00
error < < string_compose ( P_ ( " could not create %1 new audio track " , " could not create %1 new audio tracks " , how_many ) , how_many )
2013-01-03 09:19:31 -05:00
< < endmsg ;
2005-09-25 14:42:24 -04:00
}
2006-08-24 03:37:17 -04:00
2005-09-25 14:42:24 -04:00
} else {
2006-08-24 03:37:17 -04:00
2011-02-26 20:59:04 -05:00
routes = _session - > new_audio_route ( input_channels , output_channels , route_group , how_many , name_template ) ;
2006-08-24 03:37:17 -04:00
if ( routes . size ( ) ! = how_many ) {
2013-01-04 11:49:21 -05:00
error < < string_compose ( P_ ( " could not create %1 new audio bus " , " could not create %1 new audio busses " , how_many ) , how_many )
2013-01-03 09:19:31 -05:00
< < endmsg ;
2005-09-25 14:42:24 -04:00
}
}
}
catch ( . . . ) {
2009-10-14 12:10:01 -04:00
MessageDialog msg ( * editor ,
2014-04-10 10:21:47 -04:00
string_compose ( _ ( " There are insufficient ports available \n \
2005-09-25 14:42:24 -04:00
to create a new track or bus . \ n \
2010-08-16 20:28:20 -04:00
You should save % 1 , exit and \ n \
2014-04-10 10:21:47 -04:00
restart with more ports . " ), PROGRAM_NAME));
2012-01-10 13:21:39 -05:00
pop_back_splash ( msg ) ;
2006-03-05 14:39:16 -05:00
msg . run ( ) ;
2005-09-25 14:42:24 -04:00
}
}
void
2009-10-14 12:10:01 -04:00
ARDOUR_UI : : transport_goto_start ( )
2006-03-11 11:01:06 -05:00
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
_session - > goto_start ( ) ;
2006-03-11 11:01:06 -05:00
/* force displayed area in editor to start no matter
what " follow playhead " setting is .
*/
2009-10-14 12:10:01 -04:00
2006-03-11 11:01:06 -05:00
if ( editor ) {
2009-12-17 13:24:23 -05:00
editor - > center_screen ( _session - > current_start_frame ( ) ) ;
2006-03-11 11:01:06 -05:00
}
}
}
void
ARDOUR_UI : : transport_goto_zero ( )
2005-09-25 14:42:24 -04:00
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
_session - > request_locate ( 0 ) ;
2005-09-25 14:42:24 -04:00
/* force displayed area in editor to start no matter
what " follow playhead " setting is .
*/
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
if ( editor ) {
2007-01-11 15:36:35 -05:00
editor - > reset_x_origin ( 0 ) ;
2005-09-25 14:42:24 -04:00
}
}
}
2008-09-10 11:03:30 -04:00
void
ARDOUR_UI : : transport_goto_wallclock ( )
{
2009-12-17 13:24:23 -05:00
if ( _session & & editor ) {
2008-09-10 11:03:30 -04:00
time_t now ;
struct tm tmnow ;
2010-09-17 14:20:37 -04:00
framepos_t frames ;
2009-10-14 12:10:01 -04:00
2008-09-10 11:03:30 -04:00
time ( & now ) ;
localtime_r ( & now , & tmnow ) ;
2013-08-07 22:22:11 -04:00
int frame_rate = _session - > frame_rate ( ) ;
if ( frame_rate = = 0 ) {
/* no frame rate available */
return ;
}
2009-10-14 12:10:01 -04:00
2013-08-07 22:22:11 -04:00
frames = tmnow . tm_hour * ( 60 * 60 * frame_rate ) ;
frames + = tmnow . tm_min * ( 60 * frame_rate ) ;
frames + = tmnow . tm_sec * frame_rate ;
2008-09-10 11:03:30 -04:00
2010-08-17 09:55:09 -04:00
_session - > request_locate ( frames , _session - > transport_rolling ( ) ) ;
2008-09-10 11:03:30 -04:00
/* force displayed area in editor to start no matter
what " follow playhead " setting is .
*/
2009-10-14 12:10:01 -04:00
2008-09-10 11:03:30 -04:00
if ( editor ) {
2009-11-25 20:51:50 -05:00
editor - > center_screen ( frames ) ;
2008-09-10 11:03:30 -04:00
}
}
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : transport_goto_end ( )
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
2010-12-03 17:26:29 -05:00
framepos_t const frame = _session - > current_end_frame ( ) ;
2009-12-17 13:24:23 -05:00
_session - > request_locate ( frame ) ;
2005-09-25 14:42:24 -04:00
/* force displayed area in editor to start no matter
what " follow playhead " setting is .
*/
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
if ( editor ) {
2009-11-25 20:51:50 -05:00
editor - > center_screen ( frame ) ;
2005-09-25 14:42:24 -04:00
}
}
}
void
ARDOUR_UI : : transport_stop ( )
{
2009-12-17 13:24:23 -05:00
if ( ! _session ) {
2005-09-25 14:42:24 -04:00
return ;
}
2009-12-17 13:24:23 -05:00
if ( _session - > is_auditioning ( ) ) {
_session - > cancel_audition ( ) ;
2005-09-25 14:42:24 -04:00
return ;
}
2009-10-14 12:10:01 -04:00
2010-04-20 22:24:38 -04:00
_session - > request_stop ( false , true ) ;
2005-09-25 14:42:24 -04:00
}
2014-07-10 08:14:41 -04:00
/** Check if any tracks are record enabled. If none are, record enable all of them.
* @ return true if track record - enabled status was changed , false otherwise .
*/
2014-07-09 12:07:05 -04:00
bool
ARDOUR_UI : : trx_record_enable_all_tracks ( )
{
if ( ! _session ) {
return false ;
}
boost : : shared_ptr < RouteList > rl = _session - > get_tracks ( ) ;
bool none_record_enabled = true ;
for ( RouteList : : iterator r = rl - > begin ( ) ; r ! = rl - > end ( ) ; + + r ) {
boost : : shared_ptr < Track > t = boost : : dynamic_pointer_cast < Track > ( * r ) ;
assert ( t ) ;
if ( t - > record_enabled ( ) ) {
none_record_enabled = false ;
break ;
}
}
if ( none_record_enabled ) {
_session - > set_record_enabled ( rl , true , Session : : rt_cleanup ) ;
}
return none_record_enabled ;
}
2005-09-25 14:42:24 -04:00
void
2008-01-10 16:20:59 -05:00
ARDOUR_UI : : transport_record ( bool roll )
2005-09-25 14:42:24 -04:00
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
switch ( _session - > record_status ( ) ) {
2005-09-25 14:42:24 -04:00
case Session : : Disabled :
2009-12-17 13:24:23 -05:00
if ( _session - > ntracks ( ) = = 0 ) {
2011-11-14 21:06:09 -05:00
MessageDialog msg ( * editor , _ ( " Please create one or more tracks before trying to record. \n You can do this with the \" Add Track or Bus \" option in the Session menu. " ) ) ;
2006-03-05 14:39:16 -05:00
msg . run ( ) ;
2005-09-25 14:42:24 -04:00
return ;
}
2014-07-09 12:07:05 -04:00
if ( Profile - > get_trx ( ) ) {
roll = trx_record_enable_all_tracks ( ) ;
}
2009-12-17 13:24:23 -05:00
_session - > maybe_enable_record ( ) ;
2008-01-10 16:20:59 -05:00
if ( roll ) {
transport_roll ( ) ;
}
2005-09-25 14:42:24 -04:00
break ;
case Session : : Recording :
2008-01-10 16:20:59 -05:00
if ( roll ) {
2009-12-17 13:24:23 -05:00
_session - > request_stop ( ) ;
2008-01-10 16:20:59 -05:00
} else {
2009-12-17 13:24:23 -05:00
_session - > disable_record ( false , true ) ;
2008-01-10 16:20:59 -05:00
}
break ;
2005-09-25 14:42:24 -04:00
case Session : : Enabled :
2009-12-17 13:24:23 -05:00
_session - > disable_record ( false , true ) ;
2005-09-25 14:42:24 -04:00
}
}
}
2011-06-01 13:00:29 -04:00
void
2005-09-25 14:42:24 -04:00
ARDOUR_UI : : transport_roll ( )
{
2009-12-17 13:24:23 -05:00
if ( ! _session ) {
2005-09-25 14:42:24 -04:00
return ;
}
2009-12-17 13:24:23 -05:00
if ( _session - > is_auditioning ( ) ) {
2009-10-30 14:14:25 -04:00
return ;
}
2010-12-14 15:27:54 -05:00
#if 0
2009-12-17 13:24:23 -05:00
if ( _session - > config . get_external_sync ( ) ) {
2012-10-10 23:10:18 -04:00
switch ( Config - > get_sync_source ( ) ) {
2013-09-19 17:34:23 -04:00
case Engine :
2009-11-09 15:05:18 -05:00
break ;
default :
/* transport controlled by the master */
return ;
}
2009-10-30 14:14:25 -04:00
}
2010-12-14 15:27:54 -05:00
# endif
2005-09-25 14:42:24 -04:00
2009-12-17 13:24:23 -05:00
bool rolling = _session - > transport_rolling ( ) ;
2008-04-11 10:06:50 -04:00
2009-12-17 13:24:23 -05:00
if ( _session - > get_play_loop ( ) ) {
2014-04-17 09:47:06 -04:00
/* If loop playback is not a mode, then we should cancel
it when this action is requested . If it is a mode
we just leave it in place .
2010-04-20 22:24:38 -04:00
*/
2014-04-17 09:47:06 -04:00
if ( ! Config - > get_loop_is_mode ( ) ) {
/* XXX it is not possible to just leave seamless loop and keep
playing at present ( nov 4 th 2009 )
*/
if ( ! Config - > get_seamless_loop ( ) ) {
/* stop loop playback and stop rolling */
_session - > request_play_loop ( false , true ) ;
} else if ( rolling ) {
/* stop loop playback but keep rolling */
_session - > request_play_loop ( false , false ) ;
}
}
2014-07-03 13:25:35 -04:00
} else if ( _session - > get_play_range ( ) ) {
2010-01-01 17:11:15 -05:00
/* stop playing a range if we currently are */
_session - > request_play_range ( 0 , true ) ;
}
2009-10-30 14:14:25 -04:00
if ( ! rolling ) {
2009-12-17 13:24:23 -05:00
_session - > request_transport_speed ( 1.0f ) ;
2009-10-30 14:14:25 -04:00
}
}
2012-11-20 14:43:43 -05:00
bool
ARDOUR_UI : : get_smart_mode ( ) const
{
return ( editor - > get_smart_mode ( ) ) ;
}
2009-10-30 14:14:25 -04:00
void
2009-11-08 11:28:21 -05:00
ARDOUR_UI : : toggle_roll ( bool with_abort , bool roll_out_of_bounded_mode )
2009-10-30 14:14:25 -04:00
{
2011-06-01 13:00:29 -04:00
2009-12-17 13:24:23 -05:00
if ( ! _session ) {
2009-10-30 14:14:25 -04:00
return ;
}
2009-12-17 13:24:23 -05:00
if ( _session - > is_auditioning ( ) ) {
_session - > cancel_audition ( ) ;
2009-10-30 14:14:25 -04:00
return ;
}
2010-08-02 17:52:21 -04:00
2009-12-17 13:24:23 -05:00
if ( _session - > config . get_external_sync ( ) ) {
2012-10-10 23:10:18 -04:00
switch ( Config - > get_sync_source ( ) ) {
2013-09-19 17:34:23 -04:00
case Engine :
2009-11-09 15:05:18 -05:00
break ;
default :
/* transport controlled by the master */
return ;
}
2009-10-30 14:14:25 -04:00
}
2009-12-17 13:24:23 -05:00
bool rolling = _session - > transport_rolling ( ) ;
2009-10-30 14:14:25 -04:00
bool affect_transport = true ;
2009-11-08 11:28:21 -05:00
if ( rolling & & roll_out_of_bounded_mode ) {
2009-10-30 14:14:25 -04:00
/* drop out of loop/range playback but leave transport rolling */
2009-12-17 13:24:23 -05:00
if ( _session - > get_play_loop ( ) ) {
2009-11-08 11:28:21 -05:00
if ( Config - > get_seamless_loop ( ) ) {
2011-06-01 13:00:29 -04:00
/* the disk buffers contain copies of the loop - we can't
2009-11-08 11:28:21 -05:00
just keep playing , so stop the transport . the user
can restart as they wish .
*/
affect_transport = true ;
} else {
/* disk buffers are normal, so we can keep playing */
affect_transport = false ;
}
2014-04-17 09:47:06 -04:00
_session - > request_play_loop ( false , affect_transport ) ;
2009-12-17 13:24:23 -05:00
} else if ( _session - > get_play_range ( ) ) {
2009-10-30 14:14:25 -04:00
affect_transport = false ;
2010-11-25 15:37:39 -05:00
_session - > request_play_range ( 0 , true ) ;
2011-06-01 13:00:29 -04:00
}
}
2005-09-25 14:42:24 -04:00
2009-10-30 14:14:25 -04:00
if ( affect_transport ) {
if ( rolling ) {
2009-12-17 13:24:23 -05:00
_session - > request_stop ( with_abort , true ) ;
2009-10-30 14:14:25 -04:00
} else {
2014-12-22 13:39:41 -05:00
if ( ARDOUR_UI : : config ( ) - > get_follow_edits ( ) & & ( editor - > get_selection ( ) . time . front ( ) . start = = _session - > transport_frame ( ) ) ) { //if playhead is exactly at the start of a range, we can assume it was placed there by follow_edits
2010-01-01 17:11:15 -05:00
_session - > request_play_range ( & editor - > get_selection ( ) . time , true ) ;
2014-07-03 13:25:35 -04:00
_session - > set_requested_return_frame ( editor - > get_selection ( ) . time . front ( ) . start ) ; //force an auto-return here
2010-01-01 17:11:15 -05:00
}
2009-12-17 13:24:23 -05:00
_session - > request_transport_speed ( 1.0f ) ;
2009-10-30 14:14:25 -04:00
}
}
2005-09-25 14:42:24 -04:00
}
void
2009-10-30 14:14:25 -04:00
ARDOUR_UI : : toggle_session_auto_loop ( )
2005-09-25 14:42:24 -04:00
{
2012-03-06 17:56:56 -05:00
Location * looploc = _session - > locations ( ) - > auto_loop_location ( ) ;
if ( ! _session | | ! looploc ) {
2011-01-09 18:14:47 -05:00
return ;
}
2011-06-01 13:00:29 -04:00
2011-01-09 18:14:47 -05:00
if ( _session - > get_play_loop ( ) ) {
2014-04-17 09:47:06 -04:00
/* looping enabled, our job is to disable it */
_session - > request_play_loop ( false ) ;
} else {
2011-06-01 13:00:29 -04:00
2014-04-17 09:47:06 -04:00
/* looping not enabled, our job is to enable it.
2011-06-01 13:00:29 -04:00
2014-04-17 09:47:06 -04:00
loop - is - NOT - mode : this action always starts the transport rolling .
loop - IS - mode : this action simply sets the loop play mechanism , but
does not start transport .
*/
if ( Config - > get_loop_is_mode ( ) ) {
_session - > request_play_loop ( true , false ) ;
2011-01-09 18:14:47 -05:00
} else {
2014-04-17 09:47:06 -04:00
_session - > request_play_loop ( true , true ) ;
2011-01-09 18:14:47 -05:00
}
2005-09-25 14:42:24 -04:00
}
2012-03-06 17:56:56 -05:00
//show the loop markers
looploc - > set_hidden ( false , this ) ;
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : transport_play_selection ( )
{
2009-12-17 13:24:23 -05:00
if ( ! _session ) {
2005-09-25 14:42:24 -04:00
return ;
}
editor - > play_selection ( ) ;
}
2012-11-20 14:43:43 -05:00
void
ARDOUR_UI : : transport_play_preroll ( )
{
if ( ! _session ) {
return ;
}
editor - > play_with_preroll ( ) ;
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : transport_rewind ( int option )
{
float current_transport_speed ;
2009-10-14 12:10:01 -04:00
2009-12-17 13:24:23 -05:00
if ( _session ) {
current_transport_speed = _session - > transport_speed ( ) ;
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
if ( current_transport_speed > = 0.0f ) {
switch ( option ) {
case 0 :
2009-12-17 13:24:23 -05:00
_session - > request_transport_speed ( - 1.0f ) ;
2005-09-25 14:42:24 -04:00
break ;
case 1 :
2009-12-17 13:24:23 -05:00
_session - > request_transport_speed ( - 4.0f ) ;
2005-09-25 14:42:24 -04:00
break ;
case - 1 :
2009-12-17 13:24:23 -05:00
_session - > request_transport_speed ( - 0.5f ) ;
2005-09-25 14:42:24 -04:00
break ;
}
} else {
/* speed up */
2009-12-17 13:24:23 -05:00
_session - > request_transport_speed ( current_transport_speed * 1.5f ) ;
2005-09-25 14:42:24 -04:00
}
}
}
void
ARDOUR_UI : : transport_forward ( int option )
{
2012-04-22 21:13:34 -04:00
if ( ! _session ) {
return ;
}
float current_transport_speed = _session - > transport_speed ( ) ;
if ( current_transport_speed < = 0.0f ) {
switch ( option ) {
case 0 :
_session - > request_transport_speed ( 1.0f ) ;
break ;
case 1 :
_session - > request_transport_speed ( 4.0f ) ;
break ;
case - 1 :
_session - > request_transport_speed ( 0.5f ) ;
break ;
2005-09-25 14:42:24 -04:00
}
2012-04-22 21:13:34 -04:00
} else {
/* speed up */
_session - > request_transport_speed ( current_transport_speed * 1.5f ) ;
2005-09-25 14:42:24 -04:00
}
}
void
2010-07-24 12:40:56 -04:00
ARDOUR_UI : : toggle_record_enable ( uint32_t rid )
2005-09-25 14:42:24 -04:00
{
2012-04-22 21:13:34 -04:00
if ( ! _session ) {
2005-09-25 14:42:24 -04:00
return ;
}
2006-07-27 21:08:57 -04:00
boost : : shared_ptr < Route > r ;
2009-10-14 12:10:01 -04:00
2010-07-24 12:40:56 -04:00
if ( ( r = _session - > route_by_remote_id ( rid ) ) ! = 0 ) {
2006-07-13 23:43:32 -04:00
2006-07-19 01:44:23 -04:00
Track * t ;
2005-09-25 14:42:24 -04:00
2006-07-27 21:08:57 -04:00
if ( ( t = dynamic_cast < Track * > ( r . get ( ) ) ) ! = 0 ) {
2010-07-24 12:40:56 -04:00
t - > set_record_enabled ( ! t - > record_enabled ( ) , this ) ;
Large nasty commit in the form of a 5000 line patch chock-full of completely
unecessary changes. (Sorry, doing a "sprint" based thing, this is the end of the first one)
Achieved MIDI track and bus creation, associated Jack port and diskstream creation, and minimal GUI stuff for creating them. Should be set to start work on actually recording and playing midi to/from disk now.
Relevant (significant) changes:
- Creation of a Buffer class. Base class is type agnostic so things can point to a buffer but not care what kind it is (otherwise it'd be a template). Derived into AudioBuffer and MidiBuffer, with a type tag because checking type is necessary in parts of the code where dynamic_cast wouldn't be wise. Originally I considered this a hack, but passing around a type proved to be a very good solution to all the other problems (below). There is a 1:1 mapping between jack port data types and ardour Buffer types (with a conversion function), but that's easily removed if it ever becomes necessary. Having the type scoped in the Buffer class is maybe not the best spot for it, but whatever (this is proof of concept kinda stuff right now...)
- IO now has a "default" port type (passed to the constructor and stored as a member), used by ensure_io (and similar) to create n ports. IO::register_***_port has a type argument that defaults to the default type if not passed. Rationale: previous IO API is identical, no changes needed to existing code, but path is paved for multiple port types in one IO, which we will need for eg synth plugin inserts, among other things. This is not quite ideal (best would be to only have the two port register functions and have them take a type), but the alternative is a lot of work (namely destroying the 'ensure' functions and everything that uses them) for very little gain. (I am convinced after quite a few tries at the whiteboard that subclassing IO in any way is not a feasible option, look at it's inheritance diagram in Doxygen and you can see why)
- AudioEngine::register_audio_input_port is now register_input_port and takes a type argument. Ditto for output.
- (Most significant change) AudioDiskstream abstracted into Distream, and sibling MidiDiskstream created. Very much still a work in progress, but Diskstream is there to switch references over to (most already are), which is the important part. It is still unclear what the MIDI diskstream's relation to channels is, but I'm pretty sure they will be single channel only (so SMF Type 0) since noone can come up with a reason otherwise.
- MidiTrack creation. Same thing as AudioTrack but with a different default type basically. No big deal here.
- Random cleanups and variable renamings etc. because I have OCD and can't help myself. :)
Known broken: Loading of sessions containing MIDI tracks.
git-svn-id: svn://localhost/ardour2/branches/midi@641 d708f5d6-7413-0410-9779-e7cbd77b26cf
2006-06-26 12:01:34 -04:00
}
2005-09-25 14:42:24 -04:00
}
}
void
ARDOUR_UI : : map_transport_state ( )
{
2009-12-17 13:24:23 -05:00
if ( ! _session ) {
2011-11-07 12:23:27 -05:00
auto_loop_button . unset_active_state ( ) ;
play_selection_button . unset_active_state ( ) ;
roll_button . unset_active_state ( ) ;
2012-02-07 12:43:55 -05:00
stop_button . set_active_state ( Gtkmm2ext : : ExplicitActive ) ;
2009-10-30 14:14:25 -04:00
return ;
}
2011-04-19 22:48:20 -04:00
shuttle_box - > map_transport_state ( ) ;
2005-09-25 14:42:24 -04:00
2011-04-19 22:48:20 -04:00
float sp = _session - > transport_speed ( ) ;
2009-10-30 14:14:25 -04:00
2011-04-19 22:48:20 -04:00
if ( sp ! = 0.0f ) {
2009-10-30 14:14:25 -04:00
2010-01-01 17:11:15 -05:00
/* we're rolling */
2009-12-17 13:24:23 -05:00
if ( _session - > get_play_range ( ) ) {
2009-10-30 14:14:25 -04:00
2012-02-07 12:43:55 -05:00
play_selection_button . set_active_state ( Gtkmm2ext : : ExplicitActive ) ;
2011-11-07 12:23:27 -05:00
roll_button . unset_active_state ( ) ;
auto_loop_button . unset_active_state ( ) ;
2010-01-01 17:11:15 -05:00
2009-12-17 13:24:23 -05:00
} else if ( _session - > get_play_loop ( ) ) {
2011-06-01 13:00:29 -04:00
2012-02-07 12:43:55 -05:00
auto_loop_button . set_active ( true ) ;
play_selection_button . set_active ( false ) ;
2014-04-17 09:47:06 -04:00
if ( Config - > get_loop_is_mode ( ) ) {
roll_button . set_active ( true ) ;
} else {
roll_button . set_active ( false ) ;
}
2009-10-30 14:14:25 -04:00
} else {
2011-06-01 13:00:29 -04:00
2012-02-07 12:43:55 -05:00
roll_button . set_active ( true ) ;
play_selection_button . set_active ( false ) ;
auto_loop_button . set_active ( false ) ;
2009-10-30 14:14:25 -04:00
}
2014-12-22 13:39:41 -05:00
if ( ARDOUR_UI : : config ( ) - > get_follow_edits ( ) ) {
2010-01-01 17:11:15 -05:00
/* light up both roll and play-selection if they are joined */
2012-02-07 12:43:55 -05:00
roll_button . set_active ( true ) ;
play_selection_button . set_active ( true ) ;
2010-01-01 17:11:15 -05:00
}
2012-02-07 12:43:55 -05:00
stop_button . set_active ( false ) ;
2009-10-30 14:14:25 -04:00
2005-09-25 14:42:24 -04:00
} else {
2009-10-30 14:14:25 -04:00
2012-02-07 12:43:55 -05:00
stop_button . set_active ( true ) ;
roll_button . set_active ( false ) ;
play_selection_button . set_active ( false ) ;
2014-04-17 09:47:06 -04:00
if ( Config - > get_loop_is_mode ( ) ) {
auto_loop_button . set_active ( _session - > get_play_loop ( ) ) ;
} else {
auto_loop_button . set_active ( false ) ;
}
2011-04-19 22:48:20 -04:00
update_disk_space ( ) ;
2005-09-25 14:42:24 -04:00
}
}
2014-12-25 10:02:00 -05:00
void
ARDOUR_UI : : blink_handler ( bool blink_on )
{
transport_rec_enable_blink ( blink_on ) ;
solo_blink ( blink_on ) ;
sync_blink ( blink_on ) ;
audition_blink ( blink_on ) ;
feedback_blink ( blink_on ) ;
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : update_clocks ( )
{
2014-12-25 10:02:00 -05:00
if ( ! _session ) return ;
2015-01-02 10:07:50 -05:00
if ( editor & & ! editor - > dragging_playhead ( ) ) {
2009-12-17 13:24:23 -05:00
Clock ( _session - > audible_frame ( ) , false , editor - > get_preferred_edit_position ( ) ) ; /* EMIT_SIGNAL */
2007-01-09 18:24:54 -05:00
}
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : start_clocking ( )
{
2014-12-22 13:39:41 -05:00
if ( ui_config - > get_super_rapid_clock_update ( ) ) {
2014-12-25 10:02:00 -05:00
clock_signal_connection = Timers : : fps_connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : update_clocks ) ) ;
2013-03-03 08:45:32 -05:00
} else {
2014-12-25 10:02:00 -05:00
clock_signal_connection = Timers : : rapid_connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : update_clocks ) ) ;
2013-03-03 08:45:32 -05:00
}
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : stop_clocking ( )
{
clock_signal_connection . disconnect ( ) ;
}
2009-10-14 12:10:01 -04:00
2011-12-09 10:20:14 -05:00
/** Ask the user for the name of a new snapshot and then take it.
2007-04-12 19:20:37 -04:00
*/
2010-04-20 22:24:38 -04:00
2005-09-25 14:42:24 -04:00
void
2010-04-20 22:24:38 -04:00
ARDOUR_UI : : snapshot_session ( bool switch_to_it )
2005-09-25 14:42:24 -04:00
{
ArdourPrompter prompter ( true ) ;
2005-10-06 14:24:23 -04:00
string snapname ;
2005-09-25 14:42:24 -04:00
prompter . set_name ( " Prompter " ) ;
2006-04-19 16:42:17 -04:00
prompter . add_button ( Gtk : : Stock : : SAVE , Gtk : : RESPONSE_ACCEPT ) ;
2013-11-19 09:51:27 -05:00
if ( switch_to_it ) {
prompter . set_title ( _ ( " Save as... " ) ) ;
prompter . set_prompt ( _ ( " New session name " ) ) ;
} else {
prompter . set_title ( _ ( " Take Snapshot " ) ) ;
prompter . set_prompt ( _ ( " Name of new snapshot " ) ) ;
}
2010-04-20 22:24:38 -04:00
2010-11-25 15:37:39 -05:00
if ( ! switch_to_it ) {
char timebuf [ 128 ] ;
time_t n ;
struct tm local_time ;
2011-06-01 13:00:29 -04:00
2010-11-25 15:37:39 -05:00
time ( & n ) ;
localtime_r ( & n , & local_time ) ;
2011-10-17 16:36:01 -04:00
strftime ( timebuf , sizeof ( timebuf ) , " %FT%H.%M.%S " , & local_time ) ;
2010-11-25 15:37:39 -05:00
prompter . set_initial_text ( timebuf ) ;
}
2009-10-14 12:10:01 -04:00
2010-03-16 11:33:04 -04:00
again :
2005-10-06 14:24:23 -04:00
switch ( prompter . run ( ) ) {
case RESPONSE_ACCEPT :
2009-05-07 08:24:03 -04:00
{
2005-09-25 14:42:24 -04:00
prompter . get_result ( snapname ) ;
2009-05-07 08:24:03 -04:00
bool do_save = ( snapname . length ( ) ! = 0 ) ;
2010-11-25 15:37:39 -05:00
if ( do_save ) {
2011-12-09 10:20:14 -05:00
char illegal = Session : : session_name_is_legal ( snapname ) ;
if ( illegal ) {
MessageDialog msg ( string_compose ( _ ( " To ensure compatibility with various systems \n "
" snapshot names may not contain a '%1' character " ) , illegal ) ) ;
2011-10-17 16:36:01 -04:00
msg . run ( ) ;
goto again ;
}
2010-11-25 15:37:39 -05:00
}
2010-03-16 11:33:04 -04:00
2012-06-23 01:06:54 -04:00
vector < std : : string > p ;
2009-12-17 13:24:23 -05:00
get_state_files_in_directory ( _session - > session_directory ( ) . root_path ( ) , p ) ;
2009-05-07 08:24:03 -04:00
vector < string > n = get_file_names_no_extension ( p ) ;
if ( find ( n . begin ( ) , n . end ( ) , snapname ) ! = n . end ( ) ) {
2010-05-02 19:54:25 -04:00
ArdourDialog confirm ( _ ( " Confirm Snapshot Overwrite " ) , true ) ;
2009-05-07 08:24:03 -04:00
Label m ( _ ( " A snapshot already exists with that name. Do you want to overwrite it? " ) ) ;
confirm . get_vbox ( ) - > pack_start ( m , true , true ) ;
confirm . add_button ( Gtk : : Stock : : CANCEL , Gtk : : RESPONSE_CANCEL ) ;
confirm . add_button ( _ ( " Overwrite " ) , Gtk : : RESPONSE_ACCEPT ) ;
confirm . show_all ( ) ;
switch ( confirm . run ( ) ) {
case RESPONSE_CANCEL :
do_save = false ;
}
}
2009-10-14 12:10:01 -04:00
2009-05-07 08:24:03 -04:00
if ( do_save ) {
2010-04-20 22:24:38 -04:00
save_state ( snapname , switch_to_it ) ;
2005-09-25 14:42:24 -04:00
}
2005-10-06 14:24:23 -04:00
break ;
2009-05-07 08:24:03 -04:00
}
2005-10-06 14:24:23 -04:00
2011-07-14 13:41:06 -04:00
default :
break ;
}
}
2011-12-09 10:20:14 -05:00
/** Ask the user for a new session name and then rename the session to it.
2011-07-14 13:41:06 -04:00
*/
void
ARDOUR_UI : : rename_session ( )
{
if ( ! _session ) {
return ;
}
ArdourPrompter prompter ( true ) ;
string name ;
prompter . set_name ( " Prompter " ) ;
prompter . add_button ( Gtk : : Stock : : SAVE , Gtk : : RESPONSE_ACCEPT ) ;
prompter . set_title ( _ ( " Rename Session " ) ) ;
prompter . set_prompt ( _ ( " New session name " ) ) ;
again :
switch ( prompter . run ( ) ) {
case RESPONSE_ACCEPT :
{
prompter . get_result ( name ) ;
bool do_rename = ( name . length ( ) ! = 0 ) ;
if ( do_rename ) {
2011-12-08 22:06:58 -05:00
char illegal = Session : : session_name_is_legal ( name ) ;
if ( illegal ) {
MessageDialog msg ( string_compose ( _ ( " To ensure compatibility with various systems \n "
" session names may not contain a '%1' character " ) , illegal ) ) ;
2011-07-14 13:41:06 -04:00
msg . run ( ) ;
goto again ;
}
switch ( _session - > rename ( name ) ) {
case - 1 : {
MessageDialog msg ( _ ( " That name is already in use by another directory/folder. Please try again. " ) ) ;
msg . set_position ( WIN_POS_MOUSE ) ;
msg . run ( ) ;
goto again ;
break ;
}
case 0 :
break ;
default : {
MessageDialog msg ( _ ( " Renaming this session failed. \n Things could be seriously messed up at this point " ) ) ;
msg . set_position ( WIN_POS_MOUSE ) ;
msg . run ( ) ;
break ;
}
}
}
break ;
}
2005-10-06 14:24:23 -04:00
default :
break ;
2005-09-25 14:42:24 -04:00
}
}
void
2010-04-20 22:24:38 -04:00
ARDOUR_UI : : save_state ( const string & name , bool switch_to_it )
2005-09-25 14:42:24 -04:00
{
2010-08-17 23:17:07 -04:00
XMLNode * node = new XMLNode ( X_ ( " UI " ) ) ;
2013-05-07 22:09:16 -04:00
WM : : Manager : : instance ( ) . add_state ( * node ) ;
2010-08-17 23:17:07 -04:00
2011-07-06 20:37:13 -04:00
node - > add_child_nocopy ( gui_object_state - > get_state ( ) ) ;
2010-08-17 23:17:07 -04:00
_session - > add_extra_xml ( * node ) ;
2011-06-01 13:00:29 -04:00
2010-04-20 22:24:38 -04:00
save_state_canfail ( name , switch_to_it ) ;
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
int
2010-04-20 22:24:38 -04:00
ARDOUR_UI : : save_state_canfail ( string name , bool switch_to_it )
2005-09-25 14:42:24 -04:00
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
2005-09-25 14:42:24 -04:00
int ret ;
if ( name . length ( ) = = 0 ) {
2009-12-17 13:24:23 -05:00
name = _session - > snap_name ( ) ;
2005-09-25 14:42:24 -04:00
}
2010-04-20 22:24:38 -04:00
if ( ( ret = _session - > save_state ( name , false , switch_to_it ) ) ! = 0 ) {
2005-09-25 14:42:24 -04:00
return ret ;
}
}
2011-05-04 07:32:35 -04:00
2005-09-25 14:42:24 -04:00
save_ardour_state ( ) ; /* XXX cannot fail? yeah, right ... */
return 0 ;
}
void
ARDOUR_UI : : primary_clock_value_changed ( )
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
2011-06-02 13:50:37 -04:00
_session - > request_locate ( primary_clock - > current_time ( ) ) ;
2005-09-25 14:42:24 -04:00
}
}
2008-01-10 16:20:59 -05:00
void
ARDOUR_UI : : big_clock_value_changed ( )
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
2011-06-02 13:50:37 -04:00
_session - > request_locate ( big_clock - > current_time ( ) ) ;
2008-01-10 16:20:59 -05:00
}
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : secondary_clock_value_changed ( )
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
2011-06-02 13:50:37 -04:00
_session - > request_locate ( secondary_clock - > current_time ( ) ) ;
2005-09-25 14:42:24 -04:00
}
}
void
2009-10-14 12:10:01 -04:00
ARDOUR_UI : : transport_rec_enable_blink ( bool onoff )
2005-09-25 14:42:24 -04:00
{
2009-12-17 13:24:23 -05:00
if ( _session = = 0 ) {
2005-09-25 14:42:24 -04:00
return ;
}
2009-04-29 13:30:35 -04:00
2010-11-25 15:37:39 -05:00
if ( _session - > step_editing ( ) ) {
return ;
}
2010-07-24 12:40:56 -04:00
2009-12-17 13:24:23 -05:00
Session : : RecordState const r = _session - > record_status ( ) ;
2010-04-21 16:42:22 -04:00
bool const h = _session - > have_rec_enabled_track ( ) ;
2009-10-14 12:10:01 -04:00
2009-04-29 13:30:35 -04:00
if ( r = = Session : : Enabled | | ( r = = Session : : Recording & & ! h ) ) {
2005-09-25 14:42:24 -04:00
if ( onoff ) {
2012-02-07 12:43:55 -05:00
rec_button . set_active_state ( Gtkmm2ext : : ExplicitActive ) ;
2005-09-25 14:42:24 -04:00
} else {
2014-08-22 12:45:34 -04:00
rec_button . set_active_state ( Gtkmm2ext : : Off ) ;
2005-09-25 14:42:24 -04:00
}
2009-04-29 13:30:35 -04:00
} else if ( r = = Session : : Recording & & h ) {
2012-02-07 13:28:09 -05:00
rec_button . set_active_state ( Gtkmm2ext : : ExplicitActive ) ;
2009-04-29 13:30:35 -04:00
} else {
2011-11-07 12:23:27 -05:00
rec_button . unset_active_state ( ) ;
2005-09-25 14:42:24 -04:00
}
}
void
ARDOUR_UI : : save_template ( )
{
ArdourPrompter prompter ( true ) ;
2005-10-06 14:24:23 -04:00
string name ;
2007-08-06 13:50:23 -04:00
if ( ! check_audioengine ( ) ) {
return ;
}
2005-10-06 14:24:23 -04:00
prompter . set_name ( X_ ( " Prompter " ) ) ;
2011-02-17 09:06:14 -05:00
prompter . set_title ( _ ( " Save Template " ) ) ;
prompter . set_prompt ( _ ( " Name for template: " ) ) ;
2009-12-17 13:24:23 -05:00
prompter . set_initial_text ( _session - > name ( ) + _ ( " -template " ) ) ;
2006-04-19 16:42:17 -04:00
prompter . add_button ( Gtk : : Stock : : SAVE , Gtk : : RESPONSE_ACCEPT ) ;
2006-04-22 11:28:59 -04:00
2005-10-06 14:24:23 -04:00
switch ( prompter . run ( ) ) {
case RESPONSE_ACCEPT :
2005-09-25 14:42:24 -04:00
prompter . get_result ( name ) ;
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
if ( name . length ( ) ) {
2009-12-17 13:24:23 -05:00
_session - > save_template ( name ) ;
2005-09-25 14:42:24 -04:00
}
2005-10-06 14:24:23 -04:00
break ;
default :
break ;
2005-09-25 14:42:24 -04:00
}
}
2008-09-17 04:44:51 -04:00
void
ARDOUR_UI : : edit_metadata ( )
{
SessionMetadataEditor dialog ;
2009-12-17 13:24:23 -05:00
dialog . set_session ( _session ) ;
2008-09-17 04:44:51 -04:00
editor - > ensure_float ( dialog ) ;
2015-01-07 20:56:39 -05:00
Keyboard : : magic_widget_grab_focus ( ) ;
dialog . grab_focus ( ) ;
2008-09-17 04:44:51 -04:00
dialog . run ( ) ;
2015-01-07 20:56:39 -05:00
Keyboard : : magic_widget_drop_focus ( ) ;
2008-09-17 04:44:51 -04:00
}
void
ARDOUR_UI : : import_metadata ( )
{
SessionMetadataImporter dialog ;
2009-12-17 13:24:23 -05:00
dialog . set_session ( _session ) ;
2008-09-17 04:44:51 -04:00
editor - > ensure_float ( dialog ) ;
dialog . run ( ) ;
}
2007-03-18 02:07:08 -04:00
bool
2010-09-14 12:51:02 -04:00
ARDOUR_UI : : ask_about_loading_existing_session ( const std : : string & session_path )
2008-01-18 22:49:52 -05:00
{
2010-09-14 12:51:02 -04:00
std : : string str = string_compose ( _ ( " This session \n %1 \n already exists. Do you want to open it? " ) , session_path ) ;
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
MessageDialog msg ( str ,
false ,
Gtk : : MESSAGE_WARNING ,
Gtk : : BUTTONS_YES_NO ,
true ) ;
2009-10-14 12:10:01 -04:00
2009-11-23 15:20:01 -05:00
msg . set_name ( X_ ( " OpenExistingDialog " ) ) ;
msg . set_title ( _ ( " Open Existing Session " ) ) ;
2010-08-16 20:28:20 -04:00
msg . set_wmclass ( X_ ( " existing_session " ) , PROGRAM_NAME ) ;
2008-01-18 22:49:52 -05:00
msg . set_position ( Gtk : : WIN_POS_MOUSE ) ;
2012-01-10 13:21:39 -05:00
pop_back_splash ( msg ) ;
2008-02-02 12:22:04 -05:00
2008-01-18 22:49:52 -05:00
switch ( msg . run ( ) ) {
case RESPONSE_YES :
return true ;
break ;
}
return false ;
}
int
2013-09-23 14:41:52 -04:00
ARDOUR_UI : : build_session_from_dialog ( SessionDialog & sd , const std : : string & session_path , const std : : string & session_name )
2008-01-18 22:49:52 -05:00
{
2010-11-25 15:37:39 -05:00
BusProfile bus_profile ;
2009-10-14 12:10:01 -04:00
2013-03-30 13:15:57 -04:00
if ( nsm | | Profile - > get_sae ( ) ) {
2009-10-14 12:10:01 -04:00
2010-03-23 08:19:21 -04:00
bus_profile . master_out_channels = 2 ;
bus_profile . input_ac = AutoConnectPhysical ;
bus_profile . output_ac = AutoConnectMaster ;
bus_profile . requested_physical_in = 0 ; // use all available
bus_profile . requested_physical_out = 0 ; // use all available
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
} else {
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
/* get settings from advanced section of NSD */
2009-10-14 12:10:01 -04:00
2013-09-23 14:41:52 -04:00
if ( sd . create_master_bus ( ) ) {
bus_profile . master_out_channels = ( uint32_t ) sd . master_channel_count ( ) ;
2008-01-18 22:49:52 -05:00
} else {
2010-03-23 08:19:21 -04:00
bus_profile . master_out_channels = 0 ;
2008-01-18 22:49:52 -05:00
}
2009-10-14 12:10:01 -04:00
2013-09-23 14:41:52 -04:00
if ( sd . connect_inputs ( ) ) {
2010-03-23 08:19:21 -04:00
bus_profile . input_ac = AutoConnectPhysical ;
2008-01-18 22:49:52 -05:00
} else {
2010-03-23 08:19:21 -04:00
bus_profile . input_ac = AutoConnectOption ( 0 ) ;
2008-01-18 22:49:52 -05:00
}
2009-10-14 12:10:01 -04:00
2010-03-23 08:19:21 -04:00
bus_profile . output_ac = AutoConnectOption ( 0 ) ;
2009-10-19 16:30:09 -04:00
2013-09-23 14:41:52 -04:00
if ( sd . connect_outputs ( ) ) {
if ( sd . connect_outs_to_master ( ) ) {
2010-03-23 08:19:21 -04:00
bus_profile . output_ac = AutoConnectMaster ;
2013-09-23 14:41:52 -04:00
} else if ( sd . connect_outs_to_physical ( ) ) {
2010-03-23 08:19:21 -04:00
bus_profile . output_ac = AutoConnectPhysical ;
2009-10-19 16:30:09 -04:00
}
2009-10-14 12:10:01 -04:00
}
2013-09-23 14:41:52 -04:00
bus_profile . requested_physical_in = ( uint32_t ) sd . input_limit_count ( ) ;
bus_profile . requested_physical_out = ( uint32_t ) sd . output_limit_count ( ) ;
2008-01-18 22:49:52 -05:00
}
2009-10-14 12:10:01 -04:00
2010-03-23 08:19:21 -04:00
if ( build_session ( session_path , session_name , bus_profile ) ) {
2008-01-18 22:49:52 -05:00
return - 1 ;
}
return 0 ;
}
2009-08-08 18:36:32 -04:00
void
2010-09-14 12:51:02 -04:00
ARDOUR_UI : : idle_load ( const std : : string & path )
2009-08-08 18:36:32 -04:00
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
2009-08-08 18:36:32 -04:00
if ( Glib : : file_test ( path , Glib : : FILE_TEST_IS_DIR ) ) {
/* /path/to/foo => /path/to/foo, foo */
load_session ( path , basename_nosuffix ( path ) ) ;
} else {
/* /path/to/foo/foo.ardour => /path/to/foo, foo */
load_session ( Glib : : path_get_dirname ( path ) , basename_nosuffix ( path ) ) ;
}
2012-04-22 21:13:34 -04:00
} else {
2009-08-08 18:36:32 -04:00
ARDOUR_COMMAND_LINE : : session_name = path ;
}
}
2009-10-19 14:12:20 -04:00
/** @param quit_on_cancel true if exit() should be called if the user clicks `cancel' in the new session dialog */
2009-04-21 21:35:31 -04:00
int
2010-06-02 10:36:10 -04:00
ARDOUR_UI : : get_session_parameters ( bool quit_on_cancel , bool should_be_new , string load_template )
2005-09-25 14:42:24 -04:00
{
2010-09-14 11:45:21 -04:00
string session_name ;
string session_path ;
string template_name ;
2009-04-21 21:35:31 -04:00
int ret = - 1 ;
bool likely_new = false ;
2013-09-23 23:13:07 -04:00
bool cancel_not_quit ;
2006-09-18 23:29:16 -04:00
2012-10-18 09:43:25 -04:00
/* deal with any existing DIRTY session now, rather than later. don't
* treat a non - dirty session this way , so that it stays visible
* as we bring up the new session dialog .
*/
2013-04-11 13:49:29 -04:00
2013-03-12 17:00:09 -04:00
if ( _session & & ARDOUR_UI : : instance ( ) - > video_timeline ) {
2013-04-08 22:05:07 -04:00
ARDOUR_UI : : instance ( ) - > video_timeline - > sync_session_state ( ) ;
2013-03-12 17:00:09 -04:00
}
2013-04-11 13:49:29 -04:00
2013-09-23 23:13:07 -04:00
/* if there is already a session, relabel the button
on the SessionDialog so that we don ' t Quit directly
*/
cancel_not_quit = ( _session ! = 0 ) ;
2012-10-18 09:43:25 -04:00
if ( _session & & _session - > dirty ( ) ) {
if ( unload_session ( false ) ) {
/* unload cancelled by user */
return 0 ;
}
ARDOUR_COMMAND_LINE : : session_name = " " ;
}
2011-05-04 07:32:35 -04:00
if ( ! load_template . empty ( ) ) {
2010-11-25 15:37:39 -05:00
should_be_new = true ;
template_name = load_template ;
}
2010-06-02 10:36:10 -04:00
2013-10-06 16:32:02 -04:00
session_name = basename_nosuffix ( ARDOUR_COMMAND_LINE : : session_name ) ;
session_path = ARDOUR_COMMAND_LINE : : session_name ;
if ( ! session_path . empty ( ) ) {
if ( Glib : : file_test ( session_path . c_str ( ) , Glib : : FILE_TEST_EXISTS ) ) {
if ( Glib : : file_test ( session_path . c_str ( ) , Glib : : FILE_TEST_IS_REGULAR ) ) {
/* session/snapshot file, change path to be dir */
session_path = Glib : : path_get_dirname ( session_path ) ;
}
}
}
2013-09-23 23:13:07 -04:00
SessionDialog session_dialog ( should_be_new , session_name , session_path , load_template , cancel_not_quit ) ;
2013-09-23 14:41:52 -04:00
2009-04-21 21:35:31 -04:00
while ( ret ! = 0 ) {
2008-01-18 22:49:52 -05:00
2012-11-08 10:54:16 -05:00
if ( ! ARDOUR_COMMAND_LINE : : session_name . empty ( ) ) {
2008-01-18 22:49:52 -05:00
2009-10-14 12:10:01 -04:00
/* if they named a specific statefile, use it, otherwise they are
2009-04-23 15:41:14 -04:00
just giving a session folder , and we want to use it as is
to find the session .
*/
2011-05-04 07:32:35 -04:00
string : : size_type suffix = ARDOUR_COMMAND_LINE : : session_name . find ( statefile_suffix ) ;
if ( suffix ! = string : : npos ) {
2009-04-23 15:41:14 -04:00
session_path = Glib : : path_get_dirname ( ARDOUR_COMMAND_LINE : : session_name ) ;
2011-05-04 07:32:35 -04:00
session_name = ARDOUR_COMMAND_LINE : : session_name . substr ( 0 , suffix ) ;
session_name = Glib : : path_get_basename ( session_name ) ;
2009-04-23 15:41:14 -04:00
} else {
session_path = ARDOUR_COMMAND_LINE : : session_name ;
2011-05-04 07:32:35 -04:00
session_name = Glib : : path_get_basename ( ARDOUR_COMMAND_LINE : : session_name ) ;
2009-04-23 15:41:14 -04:00
}
2012-12-11 12:57:54 -05:00
} else {
session_path = " " ;
session_name = " " ;
2013-10-08 12:18:27 -04:00
session_dialog . clear_given ( ) ;
2012-11-08 10:54:16 -05:00
}
2013-09-23 14:41:52 -04:00
if ( should_be_new | | session_name . empty ( ) ) {
/* need the dialog to get info from user */
2013-10-08 12:18:27 -04:00
cerr < < " run dialog \n " ;
2013-09-23 14:41:52 -04:00
switch ( session_dialog . run ( ) ) {
case RESPONSE_ACCEPT :
break ;
default :
if ( quit_on_cancel ) {
2014-07-15 08:19:33 -04:00
// JE - Currently (July 2014) this section can only get reached if the
// user quits from the main 'Session Setup' dialog (i.e. reaching this
// point does NOT indicate an abnormal termination). Therefore, let's
// behave gracefully (i.e. let's do some cleanup) before we call exit()
ARDOUR : : cleanup ( ) ;
pthread_cancel_all ( ) ;
2013-09-23 14:41:52 -04:00
exit ( 1 ) ;
} else {
return ret ;
}
2011-09-27 21:27:54 -04:00
}
2013-09-23 14:41:52 -04:00
session_dialog . hide ( ) ;
2012-11-08 10:54:16 -05:00
}
2011-09-27 21:27:54 -04:00
2012-11-08 10:54:16 -05:00
/* if we run the startup dialog again, offer more than just "new session" */
should_be_new = false ;
2013-09-23 14:41:52 -04:00
session_name = session_dialog . session_name ( likely_new ) ;
2013-10-07 20:27:54 -04:00
session_path = session_dialog . session_folder ( ) ;
2013-10-06 16:32:02 -04:00
2013-03-30 13:15:57 -04:00
if ( nsm ) {
likely_new = true ;
}
2012-11-08 10:54:16 -05:00
string : : size_type suffix = session_name . find ( statefile_suffix ) ;
if ( suffix ! = string : : npos ) {
session_name = session_name . substr ( 0 , suffix ) ;
}
/* this shouldn't happen, but we catch it just in case it does */
if ( session_name . empty ( ) ) {
continue ;
}
2013-09-23 14:41:52 -04:00
if ( session_dialog . use_session_template ( ) ) {
template_name = session_dialog . session_template_name ( ) ;
2012-11-08 10:54:16 -05:00
_session_is_new = true ;
}
if ( session_name [ 0 ] = = G_DIR_SEPARATOR | |
2014-10-22 09:22:55 -04:00
# ifdef PLATFORM_WINDOWS
( session_name . length ( ) > 3 & & session_name [ 1 ] = = ' : ' & & session_name [ 2 ] = = G_DIR_SEPARATOR )
# else
2012-11-08 10:54:16 -05:00
( session_name . length ( ) > 2 & & session_name [ 0 ] = = ' . ' & & session_name [ 1 ] = = G_DIR_SEPARATOR ) | |
2014-10-22 09:22:55 -04:00
( session_name . length ( ) > 3 & & session_name [ 0 ] = = ' . ' & & session_name [ 1 ] = = ' . ' & & session_name [ 2 ] = = G_DIR_SEPARATOR )
# endif
)
{
2012-11-08 10:54:16 -05:00
/* absolute path or cwd-relative path specified for session name: infer session folder
from what was given .
*/
session_path = Glib : : path_get_dirname ( session_name ) ;
session_name = Glib : : path_get_basename ( session_name ) ;
} else {
2009-10-14 12:10:01 -04:00
2013-09-23 14:41:52 -04:00
session_path = session_dialog . session_folder ( ) ;
2012-11-08 10:54:16 -05:00
char illegal = Session : : session_name_is_legal ( session_name ) ;
if ( illegal ) {
2013-09-23 14:41:52 -04:00
MessageDialog msg ( session_dialog ,
2012-11-08 10:54:16 -05:00
string_compose ( _ ( " To ensure compatibility with various systems \n "
" session names may not contain a '%1' character " ) ,
illegal ) ) ;
msg . run ( ) ;
ARDOUR_COMMAND_LINE : : session_name = " " ; // cancel that
2010-09-14 11:45:21 -04:00
continue ;
2009-10-14 12:10:01 -04:00
}
2009-04-21 21:35:31 -04:00
}
2012-11-08 10:54:16 -05:00
2009-04-20 14:41:46 -04:00
if ( Glib : : file_test ( session_path , Glib : : FileTest ( G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR ) ) ) {
2009-04-21 21:35:31 -04:00
2013-10-06 16:32:02 -04:00
2013-03-30 13:15:57 -04:00
if ( likely_new & & ! nsm ) {
2009-04-23 15:28:17 -04:00
2010-09-14 12:51:02 -04:00
std : : string existing = Glib : : build_filename ( session_path , session_name ) ;
2009-10-14 12:10:01 -04:00
2009-04-23 15:28:17 -04:00
if ( ! ask_about_loading_existing_session ( existing ) ) {
ARDOUR_COMMAND_LINE : : session_name = " " ; // cancel that
2009-04-21 21:35:31 -04:00
continue ;
2009-10-14 12:10:01 -04:00
}
}
2008-01-18 22:49:52 -05:00
2009-04-21 21:35:31 -04:00
_session_is_new = false ;
2009-04-20 14:41:46 -04:00
} else {
2009-04-21 21:35:31 -04:00
if ( ! likely_new ) {
2013-09-23 14:41:52 -04:00
pop_back_splash ( session_dialog ) ;
2009-04-23 15:28:17 -04:00
MessageDialog msg ( string_compose ( _ ( " There is no existing session at \" %1 \" " ) , session_path ) ) ;
2009-04-21 21:35:31 -04:00
msg . run ( ) ;
ARDOUR_COMMAND_LINE : : session_name = " " ; // cancel that
continue ;
2008-01-18 22:49:52 -05:00
}
2009-04-21 21:35:31 -04:00
2012-03-15 08:04:00 -04:00
char illegal = Session : : session_name_is_legal ( session_name ) ;
2013-10-08 12:18:27 -04:00
2012-03-15 08:04:00 -04:00
if ( illegal ) {
2013-09-23 14:41:52 -04:00
pop_back_splash ( session_dialog ) ;
MessageDialog msg ( session_dialog , string_compose ( _ ( " To ensure compatibility with various systems \n "
2013-10-08 12:18:27 -04:00
" session names may not contain a '%1' character " ) , illegal ) ) ;
2010-11-25 15:37:39 -05:00
msg . run ( ) ;
2010-03-16 11:33:04 -04:00
ARDOUR_COMMAND_LINE : : session_name = " " ; // cancel that
2010-11-25 15:37:39 -05:00
continue ;
}
2010-03-16 11:33:04 -04:00
2009-04-21 21:35:31 -04:00
_session_is_new = true ;
2008-01-10 16:20:59 -05:00
}
2008-01-18 22:49:52 -05:00
2009-04-21 21:35:31 -04:00
if ( likely_new & & template_name . empty ( ) ) {
2009-10-14 12:10:01 -04:00
2013-09-23 14:41:52 -04:00
ret = build_session_from_dialog ( session_dialog , session_path , session_name ) ;
2009-04-21 21:35:31 -04:00
} else {
ret = load_session ( session_path , session_name , template_name ) ;
2011-02-20 12:29:23 -05:00
if ( ret = = - 2 ) {
/* not connected to the AudioEngine, so quit to avoid an infinite loop */
exit ( 1 ) ;
}
2011-06-01 13:00:29 -04:00
2009-10-14 20:57:55 -04:00
if ( ! ARDOUR_COMMAND_LINE : : immediate_save . empty ( ) ) {
2009-12-17 13:24:23 -05:00
_session - > save_state ( ARDOUR_COMMAND_LINE : : immediate_save , false ) ;
2009-10-14 20:57:55 -04:00
exit ( 1 ) ;
}
2013-10-08 12:18:27 -04:00
/* clear this to avoid endless attempts to load the
same session .
*/
ARDOUR_COMMAND_LINE : : session_name = " " ;
2009-04-21 21:35:31 -04:00
}
2009-04-20 14:41:46 -04:00
}
2009-10-14 12:10:01 -04:00
2009-04-21 21:35:31 -04:00
return ret ;
2009-10-14 12:10:01 -04:00
}
2006-04-24 17:34:23 -04:00
void
ARDOUR_UI : : close_session ( )
{
2007-04-29 13:23:11 -04:00
if ( ! check_audioengine ( ) ) {
return ;
}
2010-03-16 11:33:04 -04:00
if ( unload_session ( true ) ) {
2010-11-25 15:37:39 -05:00
return ;
}
2007-10-11 18:07:47 -04:00
2009-09-02 18:19:50 -04:00
ARDOUR_COMMAND_LINE : : session_name = " " ;
2010-07-19 21:16:50 -04:00
if ( get_session_parameters ( true , false ) ) {
exit ( 1 ) ;
}
goto_editor_window ( ) ;
2005-09-25 14:42:24 -04:00
}
2011-05-04 07:32:35 -04:00
/** @param snap_name Snapshot name (without .ardour suffix).
* @ return - 2 if the load failed because we are not connected to the AudioEngine .
*/
2005-09-25 14:42:24 -04:00
int
2010-09-14 12:51:02 -04:00
ARDOUR_UI : : load_session ( const std : : string & path , const std : : string & snap_name , std : : string mix_template )
2005-09-25 14:42:24 -04:00
{
Session * new_session ;
2007-10-11 18:07:47 -04:00
int unload_status ;
int retval = - 1 ;
2013-09-09 13:17:53 -04:00
if ( _session ) {
unload_status = unload_session ( ) ;
if ( unload_status < 0 ) {
goto out ;
} else if ( unload_status > 0 ) {
retval = 0 ;
goto out ;
}
2007-04-29 13:23:11 -04:00
}
2013-09-09 13:17:53 -04:00
session_loaded = false ;
2005-09-25 14:42:24 -04:00
2011-02-25 14:12:09 -05:00
loading_message ( string_compose ( _ ( " Please wait while %1 loads your session " ) , PROGRAM_NAME ) ) ;
2007-10-11 18:07:47 -04:00
2005-09-25 14:42:24 -04:00
try {
2013-09-09 13:17:53 -04:00
new_session = new Session ( * AudioEngine : : instance ( ) , path , snap_name , 0 , mix_template ) ;
2005-09-25 14:42:24 -04:00
}
2008-01-10 16:20:59 -05:00
/* this one is special */
catch ( AudioEngine : : PortRegistrationFailure & err ) {
MessageDialog msg ( err . what ( ) ,
true ,
Gtk : : MESSAGE_INFO ,
2008-12-12 09:43:24 -05:00
Gtk : : BUTTONS_CLOSE ) ;
2009-10-14 12:10:01 -04:00
2008-12-12 09:43:24 -05:00
msg . set_title ( _ ( " Port Registration Error " ) ) ;
msg . set_secondary_text ( _ ( " Click the Close button to try again. " ) ) ;
2008-01-10 16:20:59 -05:00
msg . set_position ( Gtk : : WIN_POS_CENTER ) ;
2012-01-10 13:21:39 -05:00
pop_back_splash ( msg ) ;
2008-01-10 16:20:59 -05:00
msg . present ( ) ;
int response = msg . run ( ) ;
msg . hide ( ) ;
switch ( response ) {
case RESPONSE_CANCEL :
exit ( 1 ) ;
default :
break ;
}
goto out ;
}
2005-09-25 14:42:24 -04:00
catch ( . . . ) {
2008-01-10 17:22:29 -05:00
2011-03-14 17:53:10 -04:00
MessageDialog msg ( string_compose (
_ ( " Session \" %1 (snapshot %2) \" did not load successfully " ) ,
path , snap_name ) ,
2010-11-25 15:37:39 -05:00
true ,
Gtk : : MESSAGE_INFO ,
BUTTONS_OK ) ;
2009-10-14 12:10:01 -04:00
2013-09-23 14:41:52 -04:00
msg . set_keep_above ( true ) ;
2008-01-10 16:20:59 -05:00
msg . set_title ( _ ( " Loading Error " ) ) ;
msg . set_position ( Gtk : : WIN_POS_CENTER ) ;
2012-01-10 13:21:39 -05:00
pop_back_splash ( msg ) ;
2008-01-10 16:20:59 -05:00
msg . present ( ) ;
2013-09-23 14:41:52 -04:00
( void ) msg . run ( ) ;
2008-01-10 16:20:59 -05:00
msg . hide ( ) ;
2007-10-11 18:07:47 -04:00
goto out ;
2005-09-25 14:42:24 -04:00
}
2010-11-26 18:30:48 -05:00
{
list < string > const u = new_session - > unknown_processors ( ) ;
if ( ! u . empty ( ) ) {
MissingPluginDialog d ( _session , u ) ;
d . run ( ) ;
}
}
2013-10-12 11:58:22 -04:00
if ( ! new_session - > writable ( ) ) {
MessageDialog msg ( _ ( " This session has been opened in read-only mode. \n \n You will not be able to record or save. " ) ,
true ,
Gtk : : MESSAGE_INFO ,
BUTTONS_OK ) ;
msg . set_keep_above ( true ) ;
msg . set_title ( _ ( " Read-only Session " ) ) ;
msg . set_position ( Gtk : : WIN_POS_CENTER ) ;
pop_back_splash ( msg ) ;
msg . present ( ) ;
( void ) msg . run ( ) ;
msg . hide ( ) ;
}
2010-08-16 22:48:24 -04:00
/* Now the session been created, add the transport controls */
new_session - > add_controllable ( roll_controllable ) ;
new_session - > add_controllable ( stop_controllable ) ;
new_session - > add_controllable ( goto_start_controllable ) ;
new_session - > add_controllable ( goto_end_controllable ) ;
new_session - > add_controllable ( auto_loop_controllable ) ;
new_session - > add_controllable ( play_selection_controllable ) ;
new_session - > add_controllable ( rec_controllable ) ;
2009-12-17 13:24:23 -05:00
set_session ( new_session ) ;
2005-09-25 14:42:24 -04:00
session_loaded = true ;
2009-10-14 12:10:01 -04:00
2006-11-19 11:45:16 -05:00
goto_editor_window ( ) ;
2009-12-17 13:24:23 -05:00
if ( _session ) {
_session - > set_clean ( ) ;
2005-09-25 14:42:24 -04:00
}
2014-02-21 20:44:34 -05:00
# ifdef WINDOWS_VST_SUPPORT
fst_stop_threading ( ) ;
2014-04-11 11:48:12 -04:00
# endif
2007-10-11 18:07:47 -04:00
flush_pending ( ) ;
2014-04-11 11:48:12 -04:00
2014-02-21 20:44:34 -05:00
# ifdef WINDOWS_VST_SUPPORT
fst_start_threading ( ) ;
# endif
2007-10-11 18:07:47 -04:00
retval = 0 ;
out :
return retval ;
2005-09-25 14:42:24 -04:00
}
2007-10-11 18:07:47 -04:00
int
2010-09-14 12:51:02 -04:00
ARDOUR_UI : : build_session ( const std : : string & path , const std : : string & snap_name , BusProfile & bus_profile )
2005-09-25 14:42:24 -04:00
{
Session * new_session ;
2007-10-11 18:07:47 -04:00
int x ;
2005-09-25 14:42:24 -04:00
session_loaded = false ;
2007-10-11 18:07:47 -04:00
x = unload_session ( ) ;
if ( x < 0 ) {
return - 1 ;
} else if ( x > 0 ) {
return 0 ;
}
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
_session_is_new = true ;
try {
2013-09-09 13:17:53 -04:00
new_session = new Session ( * AudioEngine : : instance ( ) , path , snap_name , & bus_profile ) ;
2005-09-25 14:42:24 -04:00
}
catch ( . . . ) {
2007-03-18 02:07:08 -04:00
MessageDialog msg ( string_compose ( _ ( " Could not create session in \" %1 \" " ) , path ) ) ;
2012-01-10 13:21:39 -05:00
pop_back_splash ( msg ) ;
2007-03-18 02:07:08 -04:00
msg . run ( ) ;
2007-10-11 18:07:47 -04:00
return - 1 ;
2005-09-25 14:42:24 -04:00
}
2010-09-15 10:51:53 -04:00
/* Give the new session the default GUI state, if such things exist */
2010-11-25 15:37:39 -05:00
XMLNode * n ;
n = Config - > instant_xml ( X_ ( " Editor " ) ) ;
if ( n ) {
new_session - > add_instant_xml ( * n , false ) ;
}
n = Config - > instant_xml ( X_ ( " Mixer " ) ) ;
if ( n ) {
new_session - > add_instant_xml ( * n , false ) ;
}
2010-08-29 07:15:40 -04:00
2011-01-30 07:48:00 -05:00
/* Put the playhead at 0 and scroll fully left */
2011-02-05 10:27:11 -05:00
n = new_session - > instant_xml ( X_ ( " Editor " ) ) ;
if ( n ) {
n - > add_property ( X_ ( " playhead " ) , X_ ( " 0 " ) ) ;
n - > add_property ( X_ ( " left-frame " ) , X_ ( " 0 " ) ) ;
}
2011-01-30 07:48:00 -05:00
2009-12-17 13:24:23 -05:00
set_session ( new_session ) ;
2005-09-25 14:42:24 -04:00
session_loaded = true ;
2008-12-12 09:43:24 -05:00
new_session - > save_state ( new_session - > name ( ) ) ;
2007-10-11 18:07:47 -04:00
return 0 ;
2005-09-25 14:42:24 -04:00
}
2010-03-16 11:33:04 -04:00
void
ARDOUR_UI : : launch_chat ( )
{
# ifdef __APPLE__
2010-11-25 15:37:39 -05:00
open_uri ( " http://webchat.freenode.net/?channels=ardour-osx " ) ;
2014-10-27 21:40:04 -04:00
# elif defined PLATFORM_WINDOWS
open_uri ( " http://webchat.freenode.net/?channels=ardour-windows " ) ;
2010-03-16 11:33:04 -04:00
# else
2010-11-25 15:37:39 -05:00
open_uri ( " http://webchat.freenode.net/?channels=ardour " ) ;
2010-03-16 11:33:04 -04:00
# endif
}
2010-08-16 22:48:24 -04:00
void
ARDOUR_UI : : launch_manual ( )
{
2013-03-09 08:44:22 -05:00
PBD : : open_uri ( Config - > get_tutorial_manual_url ( ) ) ;
2010-08-16 22:48:24 -04:00
}
void
ARDOUR_UI : : launch_reference ( )
{
2013-03-09 08:44:22 -05:00
PBD : : open_uri ( Config - > get_reference_manual_url ( ) ) ;
2010-08-16 22:48:24 -04:00
}
2014-12-18 11:09:10 -05:00
void
ARDOUR_UI : : launch_tracker ( )
{
PBD : : open_uri ( " http://tracker.ardour.org/bug_report_page.php " ) ;
}
void
ARDOUR_UI : : launch_cheat_sheet ( )
{
# ifdef __APPLE__
PBD : : open_uri ( " http://manual.ardour.org/files/a3_mnemonic_cheat_sheet_osx.pdf " ) ;
# else
PBD : : open_uri ( " http://manual.ardour.org/files/a3_mnemonic_cheatsheet.pdf " ) ;
# endif
}
void
ARDOUR_UI : : launch_website ( )
{
PBD : : open_uri ( " http://ardour.org " ) ;
}
void
ARDOUR_UI : : launch_website_dev ( )
{
PBD : : open_uri ( " http://ardour.org/development.html " ) ;
}
void
ARDOUR_UI : : launch_forums ( )
{
PBD : : open_uri ( " https://community.ardour.org/forums " ) ;
}
void
ARDOUR_UI : : launch_howto_report ( )
{
PBD : : open_uri ( " http://ardour.org/reporting_bugs " ) ;
}
2012-07-09 21:04:36 -04:00
void
ARDOUR_UI : : loading_message ( const std : : string & msg )
{
if ( ARDOUR_COMMAND_LINE : : no_splash ) {
return ;
}
if ( ! splash ) {
show_splash ( ) ;
}
splash - > message ( msg ) ;
}
2008-01-18 22:49:52 -05:00
void
ARDOUR_UI : : show_splash ( )
{
if ( splash = = 0 ) {
try {
splash = new Splash ;
} catch ( . . . ) {
return ;
}
}
2012-07-09 17:54:21 -04:00
splash - > display ( ) ;
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : hide_splash ( )
{
2012-06-01 18:26:22 -04:00
delete splash ;
splash = 0 ;
2005-09-25 14:42:24 -04:00
}
void
2013-01-05 08:58:37 -05:00
ARDOUR_UI : : display_cleanup_results ( ARDOUR : : CleanupReport & rep , const gchar * list_title , const bool msg_delete )
2005-09-25 14:42:24 -04:00
{
size_t removed ;
removed = rep . paths . size ( ) ;
if ( removed = = 0 ) {
2006-04-19 04:14:39 -04:00
MessageDialog msgd ( * editor ,
2011-05-02 19:21:53 -04:00
_ ( " No files were ready for clean-up " ) ,
2006-04-20 16:41:05 -04:00
true ,
2006-04-19 04:14:39 -04:00
Gtk : : MESSAGE_INFO ,
2011-11-18 15:22:49 -05:00
Gtk : : BUTTONS_OK ) ;
2011-05-02 19:21:53 -04:00
msgd . set_title ( _ ( " Clean-up " ) ) ;
2006-04-19 09:42:57 -04:00
msgd . set_secondary_text ( _ ( " If this seems suprising, \n \
check for any existing snapshots . \ n \
These may still include regions that \ n \
2005-09-25 14:42:24 -04:00
require some unused files to continue to exist . " ));
2009-10-14 12:10:01 -04:00
2006-04-19 04:14:39 -04:00
msgd . run ( ) ;
2005-09-25 14:42:24 -04:00
return ;
2009-10-14 12:10:01 -04:00
}
2005-09-25 14:42:24 -04:00
2010-04-29 20:16:45 -04:00
ArdourDialog results ( _ ( " Clean-up " ) , true , false ) ;
2009-10-14 12:10:01 -04:00
2005-10-06 14:24:23 -04:00
struct CleanupResultsModelColumns : public Gtk : : TreeModel : : ColumnRecord {
2009-10-14 12:10:01 -04:00
CleanupResultsModelColumns ( ) {
2005-10-06 14:24:23 -04:00
add ( visible_name ) ;
add ( fullpath ) ;
}
2010-09-14 12:51:02 -04:00
Gtk : : TreeModelColumn < std : : string > visible_name ;
Gtk : : TreeModelColumn < std : : string > fullpath ;
2005-09-25 14:42:24 -04:00
} ;
2005-10-06 14:24:23 -04:00
2009-10-14 12:10:01 -04:00
2005-10-06 14:24:23 -04:00
CleanupResultsModelColumns results_columns ;
2006-04-19 04:14:39 -04:00
Glib : : RefPtr < Gtk : : ListStore > results_model ;
2005-10-06 14:24:23 -04:00
Gtk : : TreeView results_display ;
2009-10-14 12:10:01 -04:00
2005-10-06 14:24:23 -04:00
results_model = ListStore : : create ( results_columns ) ;
results_display . set_model ( results_model ) ;
results_display . append_column ( list_title , results_columns . visible_name ) ;
2006-04-19 04:14:39 -04:00
results_display . set_name ( " CleanupResultsList " ) ;
2005-10-06 14:24:23 -04:00
results_display . set_headers_visible ( true ) ;
2006-04-19 04:14:39 -04:00
results_display . set_headers_clickable ( false ) ;
2006-04-20 16:41:05 -04:00
results_display . set_reorderable ( false ) ;
2005-10-06 14:24:23 -04:00
2005-09-25 14:42:24 -04:00
Gtk : : ScrolledWindow list_scroller ;
Gtk : : Label txt ;
2006-04-19 09:42:57 -04:00
Gtk : : VBox dvbox ;
2006-04-20 16:41:05 -04:00
Gtk : : HBox dhbox ; // the hbox for the image and text
Gtk : : HBox ddhbox ; // the hbox we eventually pack into the dialog's vbox
Gtk : : Image * dimage = manage ( new Gtk : : Image ( Stock : : DIALOG_INFO , Gtk : : ICON_SIZE_DIALOG ) ) ;
dimage - > set_alignment ( ALIGN_LEFT , ALIGN_TOP ) ;
2005-09-25 14:42:24 -04:00
2012-06-23 01:06:54 -04:00
const string dead_directory = _session - > session_directory ( ) . dead_path ( ) ;
2007-06-16 20:47:18 -04:00
2009-07-20 23:23:57 -04:00
/* subst:
% 1 - number of files removed
2011-03-01 16:53:21 -05:00
% 2 - location of " dead "
2009-07-20 23:23:57 -04:00
% 3 - size of files affected
% 4 - prefix for " bytes " to produce sensible results ( e . g . mega , kilo , giga )
*/
const char * bprefix ;
2010-11-25 15:37:39 -05:00
double space_adjusted = 0 ;
2009-07-20 23:23:57 -04:00
2011-03-01 16:53:21 -05:00
if ( rep . space < 1000 ) {
2013-01-03 08:32:11 -05:00
bprefix = X_ ( " " ) ;
2011-03-01 16:53:21 -05:00
space_adjusted = rep . space ;
2011-03-14 17:53:10 -04:00
} else if ( rep . space < 1000000 ) {
2012-11-12 12:41:31 -05:00
bprefix = _ ( " kilo " ) ;
2013-10-03 04:32:08 -04:00
space_adjusted = floorf ( ( float ) rep . space / 1000.0 ) ;
2011-03-01 16:53:21 -05:00
} else if ( rep . space < 1000000 * 1000 ) {
2012-11-12 12:41:31 -05:00
bprefix = _ ( " mega " ) ;
2013-10-03 04:32:08 -04:00
space_adjusted = floorf ( ( float ) rep . space / ( 1000.0 * 1000.0 ) ) ;
2005-09-25 14:42:24 -04:00
} else {
2012-11-12 12:41:31 -05:00
bprefix = _ ( " giga " ) ;
2013-10-03 04:32:08 -04:00
space_adjusted = floorf ( ( float ) rep . space / ( 1000.0 * 1000 * 1000.0 ) ) ;
2009-07-20 23:23:57 -04:00
}
2013-01-05 08:58:37 -05:00
if ( msg_delete ) {
txt . set_markup ( string_compose ( P_ ( " \
The following file was deleted from % 2 , \ n \
releasing % 3 % 4 bytes of disk space " , " \
The following % 1 files were deleted from % 2 , \ n \
releasing % 3 % 4 bytes of disk space " , removed),
removed , Glib : : Markup : : escape_text ( dead_directory ) , space_adjusted , bprefix , PROGRAM_NAME ) ) ;
2009-07-20 23:23:57 -04:00
} else {
2013-01-05 08:58:37 -05:00
txt . set_markup ( string_compose ( P_ ( " \
The following file was not in use and \ n \
has been moved to : % 2 \ n \ n \
After a restart of % 5 \ n \ n \
< span face = \ " mono \" >Session -> Clean-up -> Flush Wastebasket</span> \n \n \
will release an additional % 3 % 4 bytes of disk space . \ n " , " \
The following % 1 files were not in use and \ n \
have been moved to : % 2 \ n \ n \
After a restart of % 5 \ n \ n \
< span face = \ " mono \" >Session -> Clean-up -> Flush Wastebasket</span> \n \n \
will release an additional % 3 % 4 bytes of disk space . \ n " , removed),
removed , Glib : : Markup : : escape_text ( dead_directory ) , space_adjusted , bprefix , PROGRAM_NAME ) ) ;
2005-09-25 14:42:24 -04:00
}
2006-04-19 09:42:57 -04:00
2006-04-20 16:41:05 -04:00
dhbox . pack_start ( * dimage , true , false , 5 ) ;
dhbox . pack_start ( txt , true , false , 5 ) ;
2006-04-19 09:42:57 -04:00
2005-09-25 14:42:24 -04:00
for ( vector < string > : : iterator i = rep . paths . begin ( ) ; i ! = rep . paths . end ( ) ; + + i ) {
2005-10-06 14:24:23 -04:00
TreeModel : : Row row = * ( results_model - > append ( ) ) ;
row [ results_columns . visible_name ] = * i ;
row [ results_columns . fullpath ] = * i ;
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
2005-10-06 14:24:23 -04:00
list_scroller . add ( results_display ) ;
2006-04-19 09:42:57 -04:00
list_scroller . set_size_request ( - 1 , 150 ) ;
2005-10-06 14:24:23 -04:00
list_scroller . set_policy ( Gtk : : POLICY_NEVER , Gtk : : POLICY_AUTOMATIC ) ;
2006-04-19 09:42:57 -04:00
2006-04-20 16:41:05 -04:00
dvbox . pack_start ( dhbox , true , false , 5 ) ;
dvbox . pack_start ( list_scroller , true , false , 5 ) ;
ddhbox . pack_start ( dvbox , true , false , 5 ) ;
results . get_vbox ( ) - > pack_start ( ddhbox , true , false , 5 ) ;
2006-04-19 04:14:39 -04:00
results . add_button ( Stock : : CLOSE , RESPONSE_CLOSE ) ;
2006-04-19 16:42:17 -04:00
results . set_default_response ( RESPONSE_CLOSE ) ;
2006-04-20 16:41:05 -04:00
results . set_position ( Gtk : : WIN_POS_MOUSE ) ;
2007-07-06 17:54:30 -04:00
results_display . show ( ) ;
list_scroller . show ( ) ;
txt . show ( ) ;
dvbox . show ( ) ;
dhbox . show ( ) ;
ddhbox . show ( ) ;
dimage - > show ( ) ;
//results.get_vbox()->show();
2006-04-20 16:41:05 -04:00
results . set_resizable ( false ) ;
2005-10-06 14:24:23 -04:00
2005-09-25 14:42:24 -04:00
results . run ( ) ;
2006-04-19 04:14:39 -04:00
2011-03-14 17:53:10 -04:00
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : cleanup ( )
{
2009-12-17 13:24:23 -05:00
if ( _session = = 0 ) {
2005-09-25 14:42:24 -04:00
/* shouldn't happen: menu item is insensitive */
return ;
}
2006-04-19 04:14:39 -04:00
2011-05-02 19:21:53 -04:00
MessageDialog checker ( _ ( " Are you sure you want to clean-up? " ) ,
2006-04-20 16:41:05 -04:00
true ,
2006-04-19 04:14:39 -04:00
Gtk : : MESSAGE_QUESTION ,
2011-11-18 15:22:49 -05:00
Gtk : : BUTTONS_NONE ) ;
2006-04-19 04:14:39 -04:00
2011-05-02 19:21:53 -04:00
checker . set_title ( _ ( " Clean-up " ) ) ;
2011-06-01 13:00:29 -04:00
2011-05-02 19:21:53 -04:00
checker . set_secondary_text ( _ ( " Clean-up is a destructive operation. \n \
ALL undo / redo information will be lost if you clean - up . \ n \
Clean - up will move all unused files to a \ " dead \" location. " ) ) ;
2009-10-14 12:10:01 -04:00
2005-11-27 16:17:41 -05:00
checker . add_button ( Stock : : CANCEL , RESPONSE_CANCEL ) ;
2011-05-02 19:21:53 -04:00
checker . add_button ( _ ( " Clean-up " ) , RESPONSE_ACCEPT ) ;
2006-04-19 16:42:17 -04:00
checker . set_default_response ( RESPONSE_CANCEL ) ;
2005-11-27 16:17:41 -05:00
2005-09-25 14:42:24 -04:00
checker . set_name ( _ ( " CleanupDialog " ) ) ;
2010-08-16 20:28:20 -04:00
checker . set_wmclass ( X_ ( " ardour_cleanup " ) , PROGRAM_NAME ) ;
2006-04-20 16:41:05 -04:00
checker . set_position ( Gtk : : WIN_POS_MOUSE ) ;
2005-09-25 14:42:24 -04:00
2005-11-27 16:17:41 -05:00
switch ( checker . run ( ) ) {
case RESPONSE_ACCEPT :
2005-10-06 14:24:23 -04:00
break ;
default :
2005-09-25 14:42:24 -04:00
return ;
}
2009-10-30 11:30:22 -04:00
ARDOUR : : CleanupReport rep ;
2005-09-25 14:42:24 -04:00
editor - > prepare_for_cleanup ( ) ;
2007-03-18 02:07:08 -04:00
/* do not allow flush until a session is reloaded */
Glib : : RefPtr < Action > act = ActionManager : : get_action ( X_ ( " Main " ) , X_ ( " FlushWastebasket " ) ) ;
if ( act ) {
act - > set_sensitive ( false ) ;
}
2009-12-17 13:24:23 -05:00
if ( _session - > cleanup_sources ( rep ) ) {
2008-09-10 11:03:30 -04:00
editor - > finish_cleanup ( ) ;
2005-09-25 14:42:24 -04:00
return ;
}
2009-10-14 12:10:01 -04:00
2008-09-10 11:03:30 -04:00
editor - > finish_cleanup ( ) ;
2007-03-18 02:07:08 -04:00
2006-04-19 04:14:39 -04:00
checker . hide ( ) ;
2013-01-05 08:58:37 -05:00
display_cleanup_results ( rep , _ ( " Cleaned Files " ) , false ) ;
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : flush_trash ( )
{
2009-12-17 13:24:23 -05:00
if ( _session = = 0 ) {
2005-09-25 14:42:24 -04:00
/* shouldn't happen: menu item is insensitive */
return ;
}
2009-10-30 11:30:22 -04:00
ARDOUR : : CleanupReport rep ;
2005-09-25 14:42:24 -04:00
2009-12-17 13:24:23 -05:00
if ( _session - > cleanup_trash_sources ( rep ) ) {
2005-09-25 14:42:24 -04:00
return ;
}
2013-01-05 08:58:37 -05:00
display_cleanup_results ( rep , _ ( " deleted file " ) , true ) ;
2005-09-25 14:42:24 -04:00
}
2013-10-23 10:27:13 -04:00
void
ARDOUR_UI : : setup_order_hint ( )
{
uint32_t order_hint = 0 ;
/*
we want the new routes to have their order keys set starting from
the highest order key in the selection + 1 ( if available ) .
*/
2013-10-25 11:37:45 -04:00
if ( add_route_dialog - > get_transient_for ( ) = = mixer - > get_toplevel ( ) ) {
for ( RouteUISelection : : iterator s = mixer - > selection ( ) . routes . begin ( ) ; s ! = mixer - > selection ( ) . routes . end ( ) ; + + s ) {
if ( ( * s ) - > route ( ) - > order_key ( ) > order_hint ) {
order_hint = ( * s ) - > route ( ) - > order_key ( ) ;
}
2013-10-23 10:27:13 -04:00
}
2013-10-28 11:04:26 -04:00
if ( ! mixer - > selection ( ) . routes . empty ( ) ) {
order_hint + + ;
}
2013-10-25 11:37:45 -04:00
} else {
for ( TrackSelection : : iterator s = editor - > get_selection ( ) . tracks . begin ( ) ; s ! = editor - > get_selection ( ) . tracks . end ( ) ; + + s ) {
RouteTimeAxisView * tav = dynamic_cast < RouteTimeAxisView * > ( * s ) ;
2014-01-27 20:36:09 -05:00
if ( tav & & tav - > route ( ) & & tav - > route ( ) - > order_key ( ) > order_hint ) {
2013-10-25 11:37:45 -04:00
order_hint = tav - > route ( ) - > order_key ( ) ;
}
2013-10-23 10:27:13 -04:00
}
2013-10-28 11:04:26 -04:00
if ( ! editor - > get_selection ( ) . tracks . empty ( ) ) {
order_hint + + ;
}
2013-10-23 10:27:13 -04:00
}
_session - > set_order_hint ( order_hint ) ;
/* create a gap in the existing route order keys to accomodate new routes.*/
boost : : shared_ptr < RouteList > rd = _session - > get_routes ( ) ;
for ( RouteList : : iterator ri = rd - > begin ( ) ; ri ! = rd - > end ( ) ; + + ri ) {
boost : : shared_ptr < Route > rt ( * ri ) ;
if ( rt - > is_monitor ( ) ) {
continue ;
}
if ( rt - > order_key ( ) > = order_hint ) {
rt - > set_order_key ( rt - > order_key ( ) + add_route_dialog - > count ( ) ) ;
}
}
}
2005-09-25 14:42:24 -04:00
void
2007-03-18 02:07:08 -04:00
ARDOUR_UI : : add_route ( Gtk : : Window * float_window )
2005-09-25 14:42:24 -04:00
{
int count ;
2009-12-17 13:24:23 -05:00
if ( ! _session ) {
2005-09-25 14:42:24 -04:00
return ;
}
if ( add_route_dialog - > is_visible ( ) ) {
/* we're already doing this */
return ;
}
2013-05-04 22:02:05 -04:00
if ( float_window ) {
2013-10-25 11:37:45 -04:00
add_route_dialog - > unset_transient_for ( ) ;
2013-05-04 22:02:05 -04:00
add_route_dialog - > set_transient_for ( * float_window ) ;
}
2005-11-27 16:17:41 -05:00
ResponseType r = ( ResponseType ) add_route_dialog - > run ( ) ;
2006-08-24 03:37:17 -04:00
2005-11-27 16:17:41 -05:00
add_route_dialog - > hide ( ) ;
2005-09-25 14:42:24 -04:00
2005-11-27 16:17:41 -05:00
switch ( r ) {
2006-08-24 03:37:17 -04:00
case RESPONSE_ACCEPT :
break ;
default :
return ;
break ;
2005-09-25 14:42:24 -04:00
}
if ( ( count = add_route_dialog - > count ( ) ) < = 0 ) {
return ;
}
2013-10-23 10:27:13 -04:00
setup_order_hint ( ) ;
2009-03-02 13:08:15 -05:00
string template_path = add_route_dialog - > track_template ( ) ;
2014-06-28 20:52:56 -04:00
DisplaySuspender ds ;
2009-10-14 12:10:01 -04:00
2009-03-02 13:08:15 -05:00
if ( ! template_path . empty ( ) ) {
2013-04-01 20:45:57 -04:00
if ( add_route_dialog - > name_template_is_default ( ) ) {
_session - > new_route_from_template ( count , template_path , string ( ) ) ;
} else {
_session - > new_route_from_template ( count , template_path , add_route_dialog - > name_template ( ) ) ;
}
2009-03-02 13:08:15 -05:00
return ;
}
2012-06-21 21:45:16 -04:00
ChanCount input_chan = add_route_dialog - > channels ( ) ;
ChanCount output_chan ;
2005-09-25 14:42:24 -04:00
string name_template = add_route_dialog - > name_template ( ) ;
2012-02-01 23:12:23 -05:00
PluginInfoPtr instrument = add_route_dialog - > requested_instrument ( ) ;
2009-06-21 15:59:56 -04:00
RouteGroup * route_group = add_route_dialog - > route_group ( ) ;
2006-10-21 15:01:50 -04:00
AutoConnectOption oac = Config - > get_output_auto_connect ( ) ;
2005-09-25 14:42:24 -04:00
2006-10-21 15:01:50 -04:00
if ( oac & AutoConnectMaster ) {
2012-06-21 21:45:16 -04:00
output_chan . set ( DataType : : AUDIO , ( _session - > master_out ( ) ? _session - > master_out ( ) - > n_inputs ( ) . n_audio ( ) : input_chan . n_audio ( ) ) ) ;
output_chan . set ( DataType : : MIDI , 0 ) ;
2005-09-25 14:42:24 -04:00
} else {
output_chan = input_chan ;
}
/* XXX do something with name template */
2009-10-14 12:10:01 -04:00
2012-06-21 21:45:16 -04:00
switch ( add_route_dialog - > type_wanted ( ) ) {
case AddRouteDialog : : AudioTrack :
session_add_audio_track ( input_chan . n_audio ( ) , output_chan . n_audio ( ) , add_route_dialog - > mode ( ) , route_group , count , name_template ) ;
break ;
case AddRouteDialog : : MidiTrack :
2012-02-01 23:12:23 -05:00
session_add_midi_track ( route_group , count , name_template , instrument ) ;
2012-06-21 21:45:16 -04:00
break ;
case AddRouteDialog : : MixedTrack :
session_add_mixed_track ( input_chan , output_chan , route_group , count , name_template , instrument ) ;
break ;
case AddRouteDialog : : AudioBus :
session_add_audio_bus ( input_chan . n_audio ( ) , output_chan . n_audio ( ) , route_group , count , name_template ) ;
break ;
2005-09-25 14:42:24 -04:00
}
}
2013-03-12 17:00:09 -04:00
void
ARDOUR_UI : : stop_video_server ( bool ask_confirm )
{
if ( ! video_server_process & & ask_confirm ) {
2014-02-10 10:53:01 -05:00
warning < < string_compose ( _ ( " Video-Server was not launched by %1. The request to stop it is ignored. " ) , PROGRAM_NAME ) < < endmsg ;
2013-03-12 17:00:09 -04:00
}
if ( video_server_process ) {
if ( ask_confirm ) {
ArdourDialog confirm ( _ ( " Stop Video-Server " ) , true ) ;
Label m ( _ ( " Do you really want to stop the Video Server? " ) ) ;
confirm . get_vbox ( ) - > pack_start ( m , true , true ) ;
confirm . add_button ( Gtk : : Stock : : CANCEL , Gtk : : RESPONSE_CANCEL ) ;
confirm . add_button ( _ ( " Yes, Stop It " ) , Gtk : : RESPONSE_ACCEPT ) ;
confirm . show_all ( ) ;
if ( confirm . run ( ) = = RESPONSE_CANCEL ) {
return ;
}
}
delete video_server_process ;
video_server_process = 0 ;
}
}
void
ARDOUR_UI : : start_video_server_menu ( Gtk : : Window * float_window )
{
ARDOUR_UI : : start_video_server ( float_window , true ) ;
}
bool
ARDOUR_UI : : start_video_server ( Gtk : : Window * float_window , bool popup_msg )
{
if ( ! _session ) {
return false ;
}
if ( popup_msg ) {
if ( ARDOUR_UI : : instance ( ) - > video_timeline - > check_server ( ) ) {
if ( video_server_process ) {
popup_error ( _ ( " The Video Server is already started. " ) ) ;
} else {
popup_error ( _ ( " An external Video Server is configured and can be reached. Not starting a new instance. " ) ) ;
}
}
}
int firsttime = 0 ;
while ( ! ARDOUR_UI : : instance ( ) - > video_timeline - > check_server ( ) ) {
if ( firsttime + + ) {
warning < < _ ( " Could not connect to the Video Server. Start it or configure its access URL in Edit -> Preferences. " ) < < endmsg ;
}
VideoServerDialog * video_server_dialog = new VideoServerDialog ( _session ) ;
if ( float_window ) {
video_server_dialog - > set_transient_for ( * float_window ) ;
}
if ( ! Config - > get_show_video_server_dialog ( ) & & firsttime < 2 ) {
video_server_dialog - > hide ( ) ;
} else {
ResponseType r = ( ResponseType ) video_server_dialog - > run ( ) ;
video_server_dialog - > hide ( ) ;
if ( r ! = RESPONSE_ACCEPT ) { return false ; }
if ( video_server_dialog - > show_again ( ) ) {
Config - > set_show_video_server_dialog ( false ) ;
}
}
std : : string icsd_exec = video_server_dialog - > get_exec_path ( ) ;
std : : string icsd_docroot = video_server_dialog - > get_docroot ( ) ;
2014-12-23 19:36:46 -05:00
if ( icsd_docroot . empty ( ) ) {
# ifndef PLATFORM_WINDOWS
icsd_docroot = X_ ( " / " ) ;
# else
icsd_docroot = X_ ( " C: \\ " ) ;
# endif
}
2013-03-12 17:00:09 -04:00
2013-10-03 04:27:40 -04:00
GStatBuf sb ;
2014-10-22 23:11:10 -04:00
if ( g_lstat ( icsd_docroot . c_str ( ) , & sb ) ! = 0 | | ! S_ISDIR ( sb . st_mode ) ) {
2013-03-12 17:00:09 -04:00
warning < < _ ( " Specified docroot is not an existing directory. " ) < < endmsg ;
continue ;
}
2013-10-14 12:05:42 -04:00
# ifndef PLATFORM_WINDOWS
2014-10-22 21:32:14 -04:00
if ( ( g_lstat ( icsd_exec . c_str ( ) , & sb ) ! = 0 )
2013-03-12 17:00:09 -04:00
| | ( sb . st_mode & ( S_IXUSR | S_IXGRP | S_IXOTH ) ) = = 0 ) {
warning < < _ ( " Given Video Server is not an executable file. " ) < < endmsg ;
continue ;
}
2013-07-17 02:45:00 -04:00
# else
2014-10-22 21:32:14 -04:00
if ( ( g_lstat ( icsd_exec . c_str ( ) , & sb ) ! = 0 )
2013-07-17 02:45:00 -04:00
| | ( sb . st_mode & ( S_IXUSR ) ) = = 0 ) {
warning < < _ ( " Given Video Server is not an executable file. " ) < < endmsg ;
continue ;
}
# endif
2013-03-12 17:00:09 -04:00
char * * argp ;
argp = ( char * * ) calloc ( 9 , sizeof ( char * ) ) ;
argp [ 0 ] = strdup ( icsd_exec . c_str ( ) ) ;
argp [ 1 ] = strdup ( " -P " ) ;
argp [ 2 ] = ( char * ) calloc ( 16 , sizeof ( char ) ) ; snprintf ( argp [ 2 ] , 16 , " %s " , video_server_dialog - > get_listenaddr ( ) . c_str ( ) ) ;
argp [ 3 ] = strdup ( " -p " ) ;
argp [ 4 ] = ( char * ) calloc ( 6 , sizeof ( char ) ) ; snprintf ( argp [ 4 ] , 6 , " %i " , video_server_dialog - > get_listenport ( ) ) ;
argp [ 5 ] = strdup ( " -C " ) ;
argp [ 6 ] = ( char * ) calloc ( 6 , sizeof ( char ) ) ; snprintf ( argp [ 6 ] , 6 , " %i " , video_server_dialog - > get_cachesize ( ) ) ;
argp [ 7 ] = strdup ( icsd_docroot . c_str ( ) ) ;
argp [ 8 ] = 0 ;
stop_video_server ( ) ;
2014-12-23 19:36:46 -05:00
if ( icsd_docroot = = X_ ( " / " ) | | icsd_docroot = = X_ ( " C: \\ " ) ) {
2013-03-28 08:41:36 -04:00
Config - > set_video_advanced_setup ( false ) ;
} else {
std : : ostringstream osstream ;
osstream < < " http://localhost: " < < video_server_dialog - > get_listenport ( ) < < " / " ;
Config - > set_video_server_url ( osstream . str ( ) ) ;
Config - > set_video_server_docroot ( icsd_docroot ) ;
Config - > set_video_advanced_setup ( true ) ;
}
2013-06-07 14:12:39 -04:00
if ( video_server_process ) {
delete video_server_process ;
}
2014-03-13 11:50:44 -04:00
video_server_process = new ARDOUR : : SystemExec ( icsd_exec , argp ) ;
2013-06-09 09:51:31 -04:00
if ( video_server_process - > start ( ) ) {
warning < < _ ( " Cannot launch the video-server " ) < < endmsg ;
continue ;
}
int timeout = 120 ; // 6 sec
2013-06-07 14:12:39 -04:00
while ( ! ARDOUR_UI : : instance ( ) - > video_timeline - > check_server ( ) ) {
2013-10-03 04:34:52 -04:00
Glib : : usleep ( 50000 ) ;
2014-04-19 20:50:38 -04:00
gui_idle_handler ( ) ;
2013-06-09 09:51:31 -04:00
if ( - - timeout < = 0 | | ! video_server_process - > is_running ( ) ) break ;
}
if ( timeout < = 0 ) {
warning < < _ ( " Video-server was started but does not respond to requests... " ) < < endmsg ;
2013-06-12 18:55:04 -04:00
} else {
if ( ! ARDOUR_UI : : instance ( ) - > video_timeline - > check_server_docroot ( ) ) {
delete video_server_process ;
video_server_process = 0 ;
}
2013-06-07 14:12:39 -04:00
}
2013-03-12 17:00:09 -04:00
}
return true ;
}
void
ARDOUR_UI : : add_video ( Gtk : : Window * float_window )
{
if ( ! _session ) {
return ;
}
if ( ! start_video_server ( float_window , false ) ) {
warning < < _ ( " Could not connect to the Video Server. Start it or configure its access URL in Edit -> Preferences. " ) < < endmsg ;
return ;
}
2013-05-04 22:02:05 -04:00
if ( float_window ) {
add_video_dialog - > set_transient_for ( * float_window ) ;
2013-03-12 17:00:09 -04:00
}
if ( add_video_dialog - > is_visible ( ) ) {
/* we're already doing this */
return ;
}
2013-05-04 22:02:05 -04:00
2013-03-12 17:00:09 -04:00
ResponseType r = ( ResponseType ) add_video_dialog - > run ( ) ;
add_video_dialog - > hide ( ) ;
if ( r ! = RESPONSE_ACCEPT ) { return ; }
2013-06-17 03:46:01 -04:00
bool local_file , orig_local_file ;
2013-03-12 17:00:09 -04:00
std : : string path = add_video_dialog - > file_name ( local_file ) ;
2013-06-17 03:46:01 -04:00
std : : string orig_path = path ;
orig_local_file = local_file ;
2013-03-12 17:00:09 -04:00
bool auto_set_session_fps = add_video_dialog - > auto_set_session_fps ( ) ;
if ( local_file & & ! Glib : : file_test ( path , Glib : : FILE_TEST_EXISTS ) ) {
warning < < string_compose ( _ ( " could not open %1 " ) , path ) < < endmsg ;
return ;
}
if ( ! local_file & & path . length ( ) = = 0 ) {
warning < < _ ( " no video-file selected " ) < < endmsg ;
return ;
}
switch ( add_video_dialog - > import_option ( ) ) {
case VTL_IMPORT_TRANSCODE :
2013-03-29 07:20:09 -04:00
{
TranscodeVideoDialog * transcode_video_dialog ;
transcode_video_dialog = new TranscodeVideoDialog ( _session , path ) ;
ResponseType r = ( ResponseType ) transcode_video_dialog - > run ( ) ;
transcode_video_dialog - > hide ( ) ;
if ( r ! = RESPONSE_ACCEPT ) {
delete transcode_video_dialog ;
return ;
}
if ( ! transcode_video_dialog - > get_audiofile ( ) . empty ( ) ) {
2013-08-04 11:23:58 -04:00
editor - > embed_audio_from_video (
transcode_video_dialog - > get_audiofile ( ) ,
2013-12-23 04:28:32 -05:00
video_timeline - > get_offset ( ) ,
( transcode_video_dialog - > import_option ( ) ! = VTL_IMPORT_NO_VIDEO )
2013-08-04 11:23:58 -04:00
) ;
2013-03-29 07:20:09 -04:00
}
switch ( transcode_video_dialog - > import_option ( ) ) {
case VTL_IMPORT_TRANSCODED :
path = transcode_video_dialog - > get_filename ( ) ;
local_file = true ;
break ;
case VTL_IMPORT_REFERENCE :
break ;
default :
delete transcode_video_dialog ;
return ;
}
delete transcode_video_dialog ;
2013-03-12 17:00:09 -04:00
}
break ;
default :
case VTL_IMPORT_NONE :
break ;
}
/* strip _session->session_directory().video_path() from video file if possible */
if ( local_file & & ! path . compare ( 0 , _session - > session_directory ( ) . video_path ( ) . size ( ) , _session - > session_directory ( ) . video_path ( ) ) ) {
path = path . substr ( _session - > session_directory ( ) . video_path ( ) . size ( ) ) ;
if ( path . at ( 0 ) = = G_DIR_SEPARATOR ) {
path = path . substr ( 1 ) ;
}
}
video_timeline - > set_update_session_fps ( auto_set_session_fps ) ;
if ( video_timeline - > video_file_info ( path , local_file ) ) {
XMLNode * node = new XMLNode ( X_ ( " Videotimeline " ) ) ;
node - > add_property ( X_ ( " Filename " ) , path ) ;
node - > add_property ( X_ ( " AutoFPS " ) , auto_set_session_fps ? X_ ( " 1 " ) : X_ ( " 0 " ) ) ;
node - > add_property ( X_ ( " LocalFile " ) , local_file ? X_ ( " 1 " ) : X_ ( " 0 " ) ) ;
2013-06-17 03:46:01 -04:00
if ( orig_local_file ) {
node - > add_property ( X_ ( " OriginalVideoFile " ) , orig_path ) ;
} else {
node - > remove_property ( X_ ( " OriginalVideoFile " ) ) ;
}
2013-03-12 17:00:09 -04:00
_session - > add_extra_xml ( * node ) ;
_session - > set_dirty ( ) ;
2013-04-02 12:06:02 -04:00
_session - > maybe_update_session_range (
std : : max ( video_timeline - > get_offset ( ) , ( ARDOUR : : frameoffset_t ) 0 ) ,
std : : max ( video_timeline - > get_offset ( ) + video_timeline - > get_duration ( ) , ( ARDOUR : : frameoffset_t ) 0 ) ) ;
2013-03-12 17:00:09 -04:00
if ( add_video_dialog - > launch_xjadeo ( ) & & local_file ) {
editor - > set_xjadeo_sensitive ( true ) ;
editor - > toggle_xjadeo_proc ( 1 ) ;
} else {
editor - > toggle_xjadeo_proc ( 0 ) ;
}
editor - > toggle_ruler_video ( true ) ;
}
}
2013-03-29 04:46:29 -04:00
void
ARDOUR_UI : : remove_video ( )
{
video_timeline - > close_session ( ) ;
editor - > toggle_ruler_video ( false ) ;
2013-08-04 11:23:58 -04:00
/* reset state */
video_timeline - > set_offset_locked ( false ) ;
video_timeline - > set_offset ( 0 ) ;
2013-03-29 04:46:29 -04:00
/* delete session state */
XMLNode * node = new XMLNode ( X_ ( " Videotimeline " ) ) ;
_session - > add_extra_xml ( * node ) ;
node = new XMLNode ( X_ ( " Videomonitor " ) ) ;
_session - > add_extra_xml ( * node ) ;
2013-04-02 12:02:41 -04:00
stop_video_server ( ) ;
2013-03-29 04:46:29 -04:00
}
2013-03-12 17:00:09 -04:00
void
ARDOUR_UI : : flush_videotimeline_cache ( bool localcacheonly )
{
if ( localcacheonly ) {
video_timeline - > vmon_update ( ) ;
} else {
video_timeline - > flush_cache ( ) ;
}
editor - > queue_visual_videotimeline_update ( ) ;
}
2005-09-25 14:42:24 -04:00
XMLNode *
ARDOUR_UI : : mixer_settings ( ) const
{
XMLNode * node = 0 ;
2009-12-17 13:24:23 -05:00
if ( _session ) {
node = _session - > instant_xml ( X_ ( " Mixer " ) ) ;
2005-09-25 14:42:24 -04:00
} else {
2007-06-16 20:47:40 -04:00
node = Config - > instant_xml ( X_ ( " Mixer " ) ) ;
2005-09-25 14:42:24 -04:00
}
if ( ! node ) {
node = new XMLNode ( X_ ( " Mixer " ) ) ;
}
return node ;
}
XMLNode *
ARDOUR_UI : : editor_settings ( ) const
{
XMLNode * node = 0 ;
2009-12-17 13:24:23 -05:00
if ( _session ) {
node = _session - > instant_xml ( X_ ( " Editor " ) ) ;
2005-09-25 14:42:24 -04:00
} else {
2007-06-16 20:47:40 -04:00
node = Config - > instant_xml ( X_ ( " Editor " ) ) ;
2005-09-25 14:42:24 -04:00
}
2011-06-01 13:00:29 -04:00
2008-12-12 09:43:24 -05:00
if ( ! node ) {
if ( getenv ( " ARDOUR_INSTANT_XML_PATH " ) ) {
node = Config - > instant_xml ( getenv ( " ARDOUR_INSTANT_XML_PATH " ) ) ;
}
}
2005-09-25 14:42:24 -04:00
if ( ! node ) {
node = new XMLNode ( X_ ( " Editor " ) ) ;
}
2008-12-12 09:43:24 -05:00
2005-09-25 14:42:24 -04:00
return node ;
}
XMLNode *
ARDOUR_UI : : keyboard_settings ( ) const
{
XMLNode * node = 0 ;
node = Config - > extra_xml ( X_ ( " Keyboard " ) ) ;
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
if ( ! node ) {
node = new XMLNode ( X_ ( " Keyboard " ) ) ;
}
2011-03-03 22:10:48 -05:00
2005-09-25 14:42:24 -04:00
return node ;
}
void
2010-12-03 17:26:29 -05:00
ARDOUR_UI : : create_xrun_marker ( framepos_t where )
2005-09-25 14:42:24 -04:00
{
2008-02-16 17:43:18 -05:00
editor - > mouse_add_new_marker ( where , false , true ) ;
}
2005-09-25 14:42:24 -04:00
2008-02-16 17:43:18 -05:00
void
ARDOUR_UI : : halt_on_xrun_message ( )
{
2014-12-09 16:36:37 -05:00
cerr < < " HALT on xrun \n " ;
MessageDialog msg ( * editor , _ ( " Recording was stopped because your system could not keep up. " ) ) ;
2006-03-05 14:39:16 -05:00
msg . run ( ) ;
2005-09-25 14:42:24 -04:00
}
2008-02-16 17:43:18 -05:00
void
2010-12-03 17:26:29 -05:00
ARDOUR_UI : : xrun_handler ( framepos_t where )
2008-02-16 17:43:18 -05:00
{
2009-12-17 13:24:23 -05:00
if ( ! _session ) {
2008-12-12 09:43:24 -05:00
return ;
}
2009-12-11 18:29:48 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : xrun_handler , where )
2008-09-10 11:03:30 -04:00
2009-12-17 13:24:23 -05:00
if ( _session & & Config - > get_create_xrun_marker ( ) & & _session - > actively_recording ( ) ) {
2008-02-16 17:43:18 -05:00
create_xrun_marker ( where ) ;
}
2009-12-17 13:24:23 -05:00
if ( _session & & Config - > get_stop_recording_on_xrun ( ) & & _session - > actively_recording ( ) ) {
2008-02-16 17:43:18 -05:00
halt_on_xrun_message ( ) ;
}
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : disk_overrun_handler ( )
{
2009-12-11 18:29:48 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : disk_overrun_handler )
2005-09-25 14:42:24 -04:00
2007-03-18 02:07:08 -04:00
if ( ! have_disk_speed_dialog_displayed ) {
have_disk_speed_dialog_displayed = true ;
2010-08-16 20:28:20 -04:00
MessageDialog * msg = new MessageDialog ( * editor , string_compose ( _ ( " \
2005-09-25 14:42:24 -04:00
The disk system on your computer \ n \
2010-08-16 20:28:20 -04:00
was not able to keep up with % 1. \ n \
2005-09-25 14:42:24 -04:00
\ n \
Specifically , it failed to write data to disk \ n \
2010-08-16 20:28:20 -04:00
quickly enough to keep up with recording . \ n " ), PROGRAM_NAME));
2009-12-11 18:29:48 -05:00
msg - > signal_response ( ) . connect ( sigc : : bind ( sigc : : mem_fun ( * this , & ARDOUR_UI : : disk_speed_dialog_gone ) , msg ) ) ;
2007-07-06 17:54:30 -04:00
msg - > show ( ) ;
2005-09-25 14:42:24 -04:00
}
}
2014-03-09 11:33:58 -04:00
/* TODO: this is getting elaborate enough to warrant being split into a dedicated class */
static MessageDialog * scan_dlg = NULL ;
static ProgressBar * scan_pbar = NULL ;
static HBox * scan_tbox = NULL ;
2014-02-23 21:53:53 -05:00
void
ARDOUR_UI : : cancel_plugin_scan ( )
{
PluginManager : : instance ( ) . cancel_plugin_scan ( ) ;
}
2014-03-09 11:33:58 -04:00
void
ARDOUR_UI : : cancel_plugin_timeout ( )
{
PluginManager : : instance ( ) . cancel_plugin_timeout ( ) ;
scan_tbox - > hide ( ) ;
}
void
ARDOUR_UI : : plugin_scan_timeout ( int timeout )
{
if ( ! scan_dlg | | ! scan_dlg - > is_mapped ( ) | | ! scan_pbar ) {
return ;
}
if ( timeout > 0 ) {
scan_pbar - > set_fraction ( ( float ) timeout / ( float ) Config - > get_vst_scan_timeout ( ) ) ;
scan_tbox - > show ( ) ;
} else {
scan_tbox - > hide ( ) ;
}
gui_idle_handler ( ) ;
}
2014-02-23 21:53:53 -05:00
void
2014-02-25 08:52:57 -05:00
ARDOUR_UI : : plugin_scan_dialog ( std : : string type , std : : string plugin , bool can_cancel )
2014-02-23 21:53:53 -05:00
{
2014-02-27 17:41:48 -05:00
if ( type = = X_ ( " closeme " ) & & ! ( scan_dlg & & scan_dlg - > is_mapped ( ) ) ) {
return ;
}
const bool cancelled = PluginManager : : instance ( ) . cancelled ( ) ;
2014-12-22 13:39:41 -05:00
if ( type ! = X_ ( " closeme " ) & & ! ui_config - > get_show_plugin_scan_window ( ) ) {
2014-02-27 17:41:48 -05:00
if ( cancelled & & scan_dlg - > is_mapped ( ) ) {
scan_dlg - > hide ( ) ;
gui_idle_handler ( ) ;
return ;
}
if ( cancelled | | ! can_cancel ) {
return ;
}
}
2014-02-25 08:52:57 -05:00
static Gtk : : Button * cancel_button ;
2014-03-09 11:33:58 -04:00
static Gtk : : Button * timeout_button ;
2014-02-23 21:53:53 -05:00
if ( ! scan_dlg ) {
2014-03-09 11:33:58 -04:00
scan_dlg = new MessageDialog ( " " , false , MESSAGE_INFO , BUTTONS_NONE ) ; // TODO manage
2014-02-23 21:53:53 -05:00
VBox * vbox = scan_dlg - > get_vbox ( ) ;
vbox - > set_size_request ( 400 , - 1 ) ;
scan_dlg - > set_title ( _ ( " Scanning for plugins " ) ) ;
2014-02-25 08:52:57 -05:00
cancel_button = manage ( new Gtk : : Button ( _ ( " Cancel plugin scan " ) ) ) ;
2014-02-23 21:53:53 -05:00
cancel_button - > set_name ( " EditorGTKButton " ) ;
cancel_button - > signal_clicked ( ) . connect ( mem_fun ( * this , & ARDOUR_UI : : cancel_plugin_scan ) ) ;
2014-03-09 11:33:58 -04:00
cancel_button - > show ( ) ;
2014-02-23 21:53:53 -05:00
scan_dlg - > get_vbox ( ) - > pack_start ( * cancel_button , PACK_SHRINK ) ;
2014-03-09 11:33:58 -04:00
scan_tbox = manage ( new HBox ( ) ) ;
timeout_button = manage ( new Gtk : : Button ( _ ( " Stop Timeout " ) ) ) ;
timeout_button - > set_name ( " EditorGTKButton " ) ;
timeout_button - > signal_clicked ( ) . connect ( mem_fun ( * this , & ARDOUR_UI : : cancel_plugin_timeout ) ) ;
timeout_button - > show ( ) ;
scan_pbar = manage ( new ProgressBar ( ) ) ;
2014-03-09 14:34:53 -04:00
scan_pbar - > set_orientation ( Gtk : : PROGRESS_RIGHT_TO_LEFT ) ;
2014-03-09 11:33:58 -04:00
scan_pbar - > set_text ( _ ( " Scan Timeout " ) ) ;
scan_pbar - > show ( ) ;
scan_tbox - > pack_start ( * scan_pbar , PACK_EXPAND_WIDGET , 4 ) ;
scan_tbox - > pack_start ( * timeout_button , PACK_SHRINK , 4 ) ;
scan_dlg - > get_vbox ( ) - > pack_start ( * scan_tbox , PACK_SHRINK , 4 ) ;
2014-02-23 21:53:53 -05:00
}
2014-11-16 21:49:19 -05:00
assert ( scan_dlg & & scan_tbox & & cancel_button ) ;
2014-02-23 21:53:53 -05:00
if ( type = = X_ ( " closeme " ) ) {
scan_dlg - > hide ( ) ;
} else {
scan_dlg - > set_message ( type + " : " + Glib : : path_get_basename ( plugin ) ) ;
2014-03-09 11:33:58 -04:00
scan_dlg - > show ( ) ;
}
if ( ! can_cancel | | ! cancelled ) {
scan_tbox - > hide ( ) ;
2014-02-23 21:53:53 -05:00
}
2014-02-27 17:41:48 -05:00
cancel_button - > set_sensitive ( can_cancel & & ! cancelled ) ;
2014-02-23 21:53:53 -05:00
2014-02-27 17:41:48 -05:00
gui_idle_handler ( ) ;
2014-02-23 21:53:53 -05:00
}
2014-02-25 06:56:20 -05:00
void
ARDOUR_UI : : gui_idle_handler ( )
{
int timeout = 30 ;
2014-02-27 17:41:48 -05:00
/* due to idle calls, gtk_events_pending() may always return true */
2014-02-25 06:56:20 -05:00
while ( gtk_events_pending ( ) & & - - timeout ) {
gtk_main_iteration ( ) ;
}
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : disk_underrun_handler ( )
{
2009-12-11 18:29:48 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : disk_underrun_handler )
2005-09-25 14:42:24 -04:00
2007-03-18 02:07:08 -04:00
if ( ! have_disk_speed_dialog_displayed ) {
have_disk_speed_dialog_displayed = true ;
2011-03-14 17:53:10 -04:00
MessageDialog * msg = new MessageDialog (
* editor , string_compose ( _ ( " The disk system on your computer \n \
2010-08-16 20:28:20 -04:00
was not able to keep up with % 1. \ n \
2005-09-25 14:42:24 -04:00
\ n \
Specifically , it failed to read data from disk \ n \
2010-08-16 20:28:20 -04:00
quickly enough to keep up with playback . \ n " ), PROGRAM_NAME));
2009-12-11 18:29:48 -05:00
msg - > signal_response ( ) . connect ( sigc : : bind ( sigc : : mem_fun ( * this , & ARDOUR_UI : : disk_speed_dialog_gone ) , msg ) ) ;
2007-07-06 17:54:30 -04:00
msg - > show ( ) ;
2009-10-14 12:10:01 -04:00
}
2005-09-25 14:42:24 -04:00
}
void
2009-07-21 11:55:17 -04:00
ARDOUR_UI : : disk_speed_dialog_gone ( int /*ignored_response*/ , MessageDialog * msg )
2005-09-25 14:42:24 -04:00
{
2007-03-18 02:07:08 -04:00
have_disk_speed_dialog_displayed = false ;
delete msg ;
2005-09-25 14:42:24 -04:00
}
2008-04-11 10:06:50 -04:00
void
ARDOUR_UI : : session_dialog ( std : : string msg )
{
2009-12-11 18:29:48 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : session_dialog , msg )
2009-10-14 12:10:01 -04:00
2008-04-11 10:06:50 -04:00
MessageDialog * d ;
if ( editor ) {
d = new MessageDialog ( * editor , msg , false , MESSAGE_INFO , BUTTONS_OK , true ) ;
} else {
d = new MessageDialog ( msg , false , MESSAGE_INFO , BUTTONS_OK , true ) ;
}
d - > show_all ( ) ;
d - > run ( ) ;
delete d ;
2009-10-14 12:10:01 -04:00
}
2008-04-11 10:06:50 -04:00
2005-09-25 14:42:24 -04:00
int
ARDOUR_UI : : pending_state_dialog ( )
{
2013-07-31 05:38:32 -04:00
HBox * hbox = manage ( new HBox ( ) ) ;
Image * image = manage ( new Image ( Stock : : DIALOG_QUESTION , ICON_SIZE_DIALOG ) ) ;
2008-01-10 17:22:29 -05:00
ArdourDialog dialog ( _ ( " Crash Recovery " ) , true ) ;
2012-04-22 21:02:33 -04:00
Label message ( string_compose ( _ ( " \
2013-01-07 14:15:02 -05:00
This session appears to have been in the \ n \
middle of recording when % 1 or \ n \
2005-09-25 14:42:24 -04:00
the computer was shutdown . \ n \
\ n \
2012-04-22 21:02:33 -04:00
% 1 can recover any captured audio for \ n \
2005-09-25 14:42:24 -04:00
you , or it can ignore it . Please decide \ n \
2012-04-22 21:02:33 -04:00
what you would like to do . \ n " ), PROGRAM_NAME));
2008-01-10 17:22:29 -05:00
image - > set_alignment ( ALIGN_CENTER , ALIGN_TOP ) ;
2007-10-26 11:31:46 -04:00
hbox - > pack_start ( * image , PACK_EXPAND_WIDGET , 12 ) ;
hbox - > pack_end ( message , PACK_EXPAND_PADDING , 12 ) ;
dialog . get_vbox ( ) - > pack_start ( * hbox , PACK_EXPAND_PADDING , 6 ) ;
2005-11-27 16:17:41 -05:00
dialog . add_button ( _ ( " Ignore crash data " ) , RESPONSE_REJECT ) ;
2007-10-26 11:31:46 -04:00
dialog . add_button ( _ ( " Recover from crash " ) , RESPONSE_ACCEPT ) ;
dialog . set_default_response ( RESPONSE_ACCEPT ) ;
2005-10-06 14:24:23 -04:00
dialog . set_position ( WIN_POS_CENTER ) ;
2007-07-06 17:54:30 -04:00
message . show ( ) ;
2007-10-26 11:31:46 -04:00
image - > show ( ) ;
hbox - > show ( ) ;
2008-01-10 17:22:29 -05:00
2005-11-27 16:17:41 -05:00
switch ( dialog . run ( ) ) {
case RESPONSE_ACCEPT :
2005-09-25 14:42:24 -04:00
return 1 ;
2006-03-29 13:52:55 -05:00
default :
return 0 ;
2005-09-25 14:42:24 -04:00
}
}
2008-02-02 12:22:04 -05:00
int
2010-12-03 17:26:29 -05:00
ARDOUR_UI : : sr_mismatch_dialog ( framecnt_t desired , framecnt_t actual )
2008-02-02 12:22:04 -05:00
{
HBox * hbox = new HBox ( ) ;
2013-01-14 16:45:55 -05:00
Image * image = new Image ( Stock : : DIALOG_WARNING , ICON_SIZE_DIALOG ) ;
2008-02-02 12:22:04 -05:00
ArdourDialog dialog ( _ ( " Sample Rate Mismatch " ) , true ) ;
Label message ( string_compose ( _ ( " \
2012-04-22 21:02:33 -04:00
This session was created with a sample rate of % 1 Hz , but \ n \
% 2 is currently running at % 3 Hz . If you load this session , \ n \
audio may be played at the wrong sample rate . \ n " ), desired, PROGRAM_NAME, actual));
2008-02-02 12:22:04 -05:00
image - > set_alignment ( ALIGN_CENTER , ALIGN_TOP ) ;
hbox - > pack_start ( * image , PACK_EXPAND_WIDGET , 12 ) ;
hbox - > pack_end ( message , PACK_EXPAND_PADDING , 12 ) ;
dialog . get_vbox ( ) - > pack_start ( * hbox , PACK_EXPAND_PADDING , 6 ) ;
dialog . add_button ( _ ( " Do not load session " ) , RESPONSE_REJECT ) ;
2008-02-16 17:43:18 -05:00
dialog . add_button ( _ ( " Load session anyway " ) , RESPONSE_ACCEPT ) ;
2008-02-02 12:22:04 -05:00
dialog . set_default_response ( RESPONSE_ACCEPT ) ;
dialog . set_position ( WIN_POS_CENTER ) ;
message . show ( ) ;
image - > show ( ) ;
hbox - > show ( ) ;
2013-04-30 13:50:15 -04:00
switch ( dialog . run ( ) ) {
2008-02-02 12:22:04 -05:00
case RESPONSE_ACCEPT :
return 0 ;
default :
2013-04-30 13:50:15 -04:00
break ;
2008-02-02 12:22:04 -05:00
}
2013-04-30 13:50:15 -04:00
return 1 ;
2008-02-02 12:22:04 -05:00
}
2013-09-17 21:07:14 -04:00
int
2013-09-09 13:17:53 -04:00
ARDOUR_UI : : disconnect_from_engine ( )
2005-09-25 14:42:24 -04:00
{
2013-09-09 13:17:53 -04:00
/* drop connection to AudioEngine::Halted so that we don't act
* as if the engine unexpectedly shut down
*/
2013-10-07 20:27:54 -04:00
2013-09-09 13:17:53 -04:00
halt_connection . disconnect ( ) ;
if ( AudioEngine : : instance ( ) - > stop ( ) ) {
2013-09-17 21:07:14 -04:00
MessageDialog msg ( * editor , _ ( " Could not disconnect from Audio/MIDI engine " ) ) ;
2013-09-09 13:17:53 -04:00
msg . run ( ) ;
2013-09-17 21:07:14 -04:00
return - 1 ;
2013-09-09 13:17:53 -04:00
} else {
AudioEngine : : instance ( ) - > Halted . connect_same_thread ( halt_connection , boost : : bind ( & ARDOUR_UI : : engine_halted , this , _1 , false ) ) ;
2005-09-25 14:42:24 -04:00
}
2013-09-09 13:17:53 -04:00
update_sample_rate ( 0 ) ;
2013-09-17 21:07:14 -04:00
return 0 ;
2005-09-25 14:42:24 -04:00
}
2013-09-17 21:07:14 -04:00
int
2013-09-09 13:17:53 -04:00
ARDOUR_UI : : reconnect_to_engine ( )
2005-09-25 14:42:24 -04:00
{
2013-09-09 13:17:53 -04:00
if ( AudioEngine : : instance ( ) - > start ( ) ) {
2013-10-11 15:58:51 -04:00
if ( editor ) {
MessageDialog msg ( * editor , _ ( " Could not reconnect to the Audio/MIDI engine " ) ) ;
msg . run ( ) ;
} else {
MessageDialog msg ( _ ( " Could not reconnect to the Audio/MIDI engine " ) ) ;
msg . run ( ) ;
}
2013-09-17 21:07:14 -04:00
return - 1 ;
2005-09-25 14:42:24 -04:00
}
2013-09-09 13:17:53 -04:00
update_sample_rate ( 0 ) ;
2013-09-17 21:07:14 -04:00
return 0 ;
2005-09-25 14:42:24 -04:00
}
2006-03-28 14:22:29 -05:00
void
ARDOUR_UI : : use_config ( )
{
2007-03-18 02:07:08 -04:00
XMLNode * node = Config - > extra_xml ( X_ ( " TransportControllables " ) ) ;
if ( node ) {
set_transport_controllable_state ( * node ) ;
}
2006-03-28 14:22:29 -05:00
}
2007-01-09 18:24:54 -05:00
void
2010-12-03 17:26:29 -05:00
ARDOUR_UI : : update_transport_clocks ( framepos_t pos )
2007-01-09 18:24:54 -05:00
{
2014-12-22 13:39:41 -05:00
if ( ui_config - > get_primary_clock_delta_edit_cursor ( ) ) {
2011-11-18 13:06:16 -05:00
primary_clock - > set ( pos , false , editor - > get_preferred_edit_position ( ) ) ;
2007-05-13 22:48:28 -04:00
} else {
2011-11-18 13:06:16 -05:00
primary_clock - > set ( pos ) ;
2007-05-13 22:48:28 -04:00
}
2014-12-22 13:39:41 -05:00
if ( ui_config - > get_secondary_clock_delta_edit_cursor ( ) ) {
2011-11-18 13:06:16 -05:00
secondary_clock - > set ( pos , false , editor - > get_preferred_edit_position ( ) ) ;
2007-05-13 22:48:28 -04:00
} else {
2011-06-02 13:50:37 -04:00
secondary_clock - > set ( pos ) ;
2007-05-13 22:48:28 -04:00
}
2007-01-09 18:24:54 -05:00
2013-05-04 22:02:05 -04:00
if ( big_clock_window ) {
2011-06-02 13:50:37 -04:00
big_clock - > set ( pos ) ;
2007-01-09 18:24:54 -05:00
}
2013-03-12 17:00:09 -04:00
ARDOUR_UI : : instance ( ) - > video_timeline - > manual_seek_video_monitor ( pos ) ;
2007-01-09 18:24:54 -05:00
}
2010-07-24 12:40:56 -04:00
void
ARDOUR_UI : : step_edit_status_change ( bool yn )
{
2010-11-25 15:37:39 -05:00
// XXX should really store pre-step edit status of things
// we make insensitive
2010-07-24 12:40:56 -04:00
2010-11-25 15:37:39 -05:00
if ( yn ) {
2012-02-07 12:43:55 -05:00
rec_button . set_active_state ( Gtkmm2ext : : ImplicitActive ) ;
2010-11-25 15:37:39 -05:00
rec_button . set_sensitive ( false ) ;
} else {
2011-11-07 12:23:27 -05:00
rec_button . unset_active_state ( ) ; ;
2010-11-25 15:37:39 -05:00
rec_button . set_sensitive ( true ) ;
}
2010-07-24 12:40:56 -04:00
}
2007-01-09 18:24:54 -05:00
void
ARDOUR_UI : : record_state_changed ( )
{
2009-12-17 13:24:23 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : record_state_changed ) ;
2007-01-11 14:50:49 -05:00
2013-05-04 22:02:05 -04:00
if ( ! _session | | ! big_clock_window ) {
2007-01-09 18:24:54 -05:00
/* why bother - the clock isn't visible */
return ;
}
2011-11-17 17:49:13 -05:00
if ( _session - > record_status ( ) = = Session : : Recording & & _session - > have_rec_enabled_track ( ) ) {
big_clock - > set_active ( true ) ;
2009-10-22 13:33:36 -04:00
} else {
2011-11-17 17:49:13 -05:00
big_clock - > set_active ( false ) ;
2007-01-09 18:24:54 -05:00
}
}
bool
ARDOUR_UI : : first_idle ( )
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
_session - > allow_auto_play ( true ) ;
2007-04-12 19:20:37 -04:00
}
2008-03-17 16:54:03 -04:00
if ( editor ) {
editor - > first_idle ( ) ;
}
2008-02-16 17:43:18 -05:00
Keyboard : : set_can_save_keybindings ( true ) ;
2007-01-09 18:24:54 -05:00
return false ;
}
void
ARDOUR_UI : : store_clock_modes ( )
{
XMLNode * node = new XMLNode ( X_ ( " ClockModes " ) ) ;
for ( vector < AudioClock * > : : iterator x = AudioClock : : clocks . begin ( ) ; x ! = AudioClock : : clocks . end ( ) ; + + x ) {
2011-06-07 19:07:08 -04:00
XMLNode * child = new XMLNode ( X_ ( " Clock " ) ) ;
child - > add_property ( X_ ( " name " ) , ( * x ) - > name ( ) ) ;
child - > add_property ( X_ ( " mode " ) , enum_2_string ( ( * x ) - > mode ( ) ) ) ;
child - > add_property ( X_ ( " on " ) , ( ( * x ) - > off ( ) ? X_ ( " no " ) : X_ ( " yes " ) ) ) ;
node - > add_child_nocopy ( * child ) ;
2007-01-09 18:24:54 -05:00
}
2009-12-17 13:24:23 -05:00
_session - > add_extra_xml ( * node ) ;
_session - > set_dirty ( ) ;
2007-01-09 18:24:54 -05:00
}
2007-03-18 02:07:08 -04:00
ARDOUR_UI : : TransportControllable : : TransportControllable ( std : : string name , ARDOUR_UI & u , ToggleType tp )
2009-12-30 11:48:58 -05:00
: Controllable ( name ) , ui ( u ) , type ( tp )
2007-03-18 02:07:08 -04:00
{
2009-10-14 12:10:01 -04:00
2007-03-18 02:07:08 -04:00
}
void
2010-07-27 10:09:16 -04:00
ARDOUR_UI : : TransportControllable : : set_value ( double val )
2007-03-18 02:07:08 -04:00
{
2010-07-27 10:09:16 -04:00
if ( val < 0.5 ) {
2007-03-18 02:07:08 -04:00
/* do nothing: these are radio-style actions */
return ;
}
2007-09-05 22:30:39 -04:00
const char * action = 0 ;
2007-03-18 02:07:08 -04:00
switch ( type ) {
case Roll :
action = X_ ( " Roll " ) ;
break ;
case Stop :
action = X_ ( " Stop " ) ;
break ;
case GotoStart :
2012-07-23 09:31:51 -04:00
action = X_ ( " GotoStart " ) ;
2007-03-18 02:07:08 -04:00
break ;
case GotoEnd :
2012-07-23 09:31:51 -04:00
action = X_ ( " GotoEnd " ) ;
2007-03-18 02:07:08 -04:00
break ;
case AutoLoop :
action = X_ ( " Loop " ) ;
break ;
case PlaySelection :
2012-07-23 09:31:51 -04:00
action = X_ ( " PlaySelection " ) ;
2007-03-18 02:07:08 -04:00
break ;
case RecordEnable :
action = X_ ( " Record " ) ;
break ;
default :
break ;
}
if ( action = = 0 ) {
return ;
}
Glib : : RefPtr < Action > act = ActionManager : : get_action ( " Transport " , action ) ;
if ( act ) {
act - > activate ( ) ;
}
}
2010-07-27 10:09:16 -04:00
double
2007-03-18 02:07:08 -04:00
ARDOUR_UI : : TransportControllable : : get_value ( void ) const
{
2010-07-27 10:09:16 -04:00
float val = 0.0 ;
2009-10-14 12:10:01 -04:00
2007-03-18 02:07:08 -04:00
switch ( type ) {
case Roll :
break ;
case Stop :
break ;
case GotoStart :
break ;
case GotoEnd :
break ;
case AutoLoop :
break ;
case PlaySelection :
break ;
case RecordEnable :
break ;
default :
break ;
}
return val ;
}
2007-04-12 19:20:37 -04:00
void
ARDOUR_UI : : setup_profile ( )
{
2012-04-17 15:13:04 -04:00
if ( gdk_screen_width ( ) < 1200 | | getenv ( " ARDOUR_NARROW_SCREEN " ) ) {
2007-04-12 19:20:37 -04:00
Profile - > set_small_screen ( ) ;
}
2007-10-11 18:07:47 -04:00
2014-04-10 04:15:52 -04:00
if ( g_getenv ( " ARDOUR_SAE " ) ) {
2007-10-11 18:07:47 -04:00
Profile - > set_sae ( ) ;
Profile - > set_single_package ( ) ;
}
2014-04-10 04:15:52 -04:00
if ( g_getenv ( " TRX " ) ) {
Profile - > set_trx ( ) ;
}
2014-07-09 16:11:58 -04:00
if ( g_getenv ( " MIXBUS " ) ) {
Profile - > set_mixbus ( ) ;
}
2007-04-12 19:20:37 -04:00
}
2007-05-14 10:13:59 -04:00
2010-11-09 01:03:51 -05:00
int
ARDOUR_UI : : missing_file ( Session * s , std : : string str , DataType type )
{
2010-11-25 15:37:39 -05:00
MissingFileDialog dialog ( s , str , type ) ;
2010-11-09 01:03:51 -05:00
2010-11-25 15:37:39 -05:00
dialog . show ( ) ;
dialog . present ( ) ;
2010-11-09 01:03:51 -05:00
2010-11-25 15:37:39 -05:00
int result = dialog . run ( ) ;
dialog . hide ( ) ;
2010-11-09 01:03:51 -05:00
2010-11-25 15:37:39 -05:00
switch ( result ) {
case RESPONSE_OK :
break ;
default :
return 1 ; // quit entire session load
}
2010-11-09 01:03:51 -05:00
2010-11-25 15:37:39 -05:00
result = dialog . get_action ( ) ;
2010-11-09 01:03:51 -05:00
2010-11-25 15:37:39 -05:00
return result ;
2010-11-09 01:03:51 -05:00
}
2010-12-13 21:45:41 -05:00
int
2013-07-15 08:05:37 -04:00
ARDOUR_UI : : ambiguous_file ( std : : string file , std : : vector < std : : string > hits )
2010-12-13 21:45:41 -05:00
{
AmbiguousFileDialog dialog ( file , hits ) ;
dialog . show ( ) ;
dialog . present ( ) ;
dialog . run ( ) ;
return dialog . get_which ( ) ;
}
2011-11-01 19:19:03 -04:00
/** Allocate our thread-local buffers */
void
ARDOUR_UI : : get_process_buffers ( )
{
_process_thread - > get_buffers ( ) ;
}
/** Drop our thread-local buffers */
void
ARDOUR_UI : : drop_process_buffers ( )
{
_process_thread - > drop_buffers ( ) ;
}
2011-11-09 12:44:39 -05:00
void
ARDOUR_UI : : feedback_detected ( )
{
2011-11-11 08:52:27 -05:00
_feedback_exists = true ;
}
2011-11-09 12:44:39 -05:00
2011-11-11 08:52:27 -05:00
void
ARDOUR_UI : : successful_graph_sort ( )
{
_feedback_exists = false ;
2011-11-09 12:44:39 -05:00
}
2011-11-10 13:04:34 -05:00
void
ARDOUR_UI : : midi_panic ( )
{
if ( _session ) {
_session - > midi_panic ( ) ;
}
}
2013-03-04 16:57:29 -05:00
void
ARDOUR_UI : : session_format_mismatch ( std : : string xml_path , std : : string backup_path )
{
2013-03-04 17:16:48 -05:00
const char * start_big = " <span size= \" x-large \" weight= \" bold \" > " ;
const char * end_big = " </span> " ;
const char * start_mono = " <tt> " ;
const char * end_mono = " </tt> " ;
2013-03-05 07:41:15 -05:00
MessageDialog msg ( string_compose ( _ ( " %4This is a session from an older version of %3%5 \n \n "
" %3 has copied the old session file \n \n %6%1%7 \n \n to \n \n %6%2%7 \n \n "
2013-03-04 17:16:48 -05:00
" From now on, use the -2000 version with older versions of %3 " ) ,
xml_path , backup_path , PROGRAM_NAME ,
start_big , end_big ,
start_mono , end_mono ) , true ) ;
2013-03-04 16:57:29 -05:00
msg . run ( ) ;
}
2013-07-24 16:04:46 -04:00
void
ARDOUR_UI : : reset_peak_display ( )
{
if ( ! _session | | ! _session - > master_out ( ) | | ! editor_meter ) return ;
editor_meter - > clear_meters ( ) ;
2013-08-03 07:59:22 -04:00
editor_meter_max_peak = - INFINITY ;
2014-08-22 12:45:34 -04:00
editor_meter_peak_display . set_active_state ( Gtkmm2ext : : Off ) ;
2013-07-24 16:04:46 -04:00
}
void
ARDOUR_UI : : reset_group_peak_display ( RouteGroup * group )
{
if ( ! _session | | ! _session - > master_out ( ) ) return ;
if ( group = = _session - > master_out ( ) - > route_group ( ) ) {
reset_peak_display ( ) ;
}
}
void
ARDOUR_UI : : reset_route_peak_display ( Route * route )
{
if ( ! _session | | ! _session - > master_out ( ) ) return ;
if ( _session - > master_out ( ) . get ( ) = = route ) {
reset_peak_display ( ) ;
}
}
2013-09-05 14:21:25 -04:00
2013-09-09 13:17:53 -04:00
int
2013-09-10 15:41:19 -04:00
ARDOUR_UI : : do_audio_midi_setup ( uint32_t desired_sample_rate )
2013-09-09 13:17:53 -04:00
{
2013-09-22 19:22:56 -04:00
audio_midi_setup - > set_desired_sample_rate ( desired_sample_rate ) ;
2013-10-10 21:07:17 -04:00
audio_midi_setup - > set_position ( WIN_POS_CENTER ) ;
2013-09-09 13:17:53 -04:00
2013-09-22 19:22:56 -04:00
switch ( audio_midi_setup - > run ( ) ) {
2013-09-09 13:17:53 -04:00
case Gtk : : RESPONSE_OK :
return 0 ;
case Gtk : : RESPONSE_APPLY :
return 0 ;
default :
return - 1 ;
}
2013-09-05 14:21:25 -04:00
}
2013-10-07 20:27:54 -04:00
2014-07-03 18:50:14 -04:00
gint
ARDOUR_UI : : transport_numpad_timeout ( )
{
_numpad_locate_happening = false ;
if ( _numpad_timeout_connection . connected ( ) )
_numpad_timeout_connection . disconnect ( ) ;
return 1 ;
}
void
ARDOUR_UI : : transport_numpad_decimal ( )
{
_numpad_timeout_connection . disconnect ( ) ;
if ( _numpad_locate_happening ) {
if ( editor ) editor - > goto_nth_marker ( _pending_locate_num - 1 ) ;
_numpad_locate_happening = false ;
} else {
_pending_locate_num = 0 ;
_numpad_locate_happening = true ;
_numpad_timeout_connection = Glib : : signal_timeout ( ) . connect ( mem_fun ( * this , & ARDOUR_UI : : transport_numpad_timeout ) , 2 * 1000 ) ;
}
}
void
ARDOUR_UI : : transport_numpad_event ( int num )
{
if ( _numpad_locate_happening ) {
_pending_locate_num = _pending_locate_num * 10 + num ;
} else {
switch ( num ) {
case 0 : toggle_roll ( false , false ) ; break ;
case 1 : transport_rewind ( 1 ) ; break ;
case 2 : transport_forward ( 1 ) ; break ;
case 3 : transport_record ( true ) ; break ;
2014-09-15 13:44:45 -04:00
case 4 : toggle_session_auto_loop ( ) ; break ;
case 5 : transport_record ( false ) ; toggle_session_auto_loop ( ) ; break ;
case 6 : toggle_punch ( ) ; break ;
2014-07-03 18:50:14 -04:00
case 7 : toggle_click ( ) ; break ;
case 8 : toggle_auto_return ( ) ; break ;
case 9 : toggle_follow_edits ( ) ; break ;
}
}
}
2014-08-27 11:55:01 -04:00
void
ARDOUR_UI : : set_flat_buttons ( )
{
CairoWidget : : set_flat_buttons ( config ( ) - > get_flat_buttons ( ) ) ;
}