2005-09-25 14:42:24 -04:00
/*
2009-10-14 12:10:01 -04:00
Copyright ( C ) 1999 - 2007 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 .
*/
2006-10-21 15:01:50 -04:00
# define __STDC_FORMAT_MACROS 1
# include <stdint.h>
2005-09-25 14:42:24 -04:00
# include <algorithm>
# include <cmath>
# 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
# include <cerrno>
# include <fstream>
# include <iostream>
2007-03-18 02:07:08 -04:00
# include <sys/resource.h>
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"
2009-02-25 13:26:51 -05:00
# include "pbd/file_utils.h"
2007-05-14 10:13:59 -04:00
2010-08-20 18:36:35 -04:00
# include "gtkmm2ext/application.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 "midi++/manager.h"
2005-09-25 14:42:24 -04:00
2009-02-25 13:26:51 -05:00
# include "ardour/ardour.h"
2010-08-05 15:39:49 -04:00
# include "ardour/callback.h"
2009-02-25 13:26:51 -05:00
# include "ardour/profile.h"
# include "ardour/session_directory.h"
# include "ardour/session_route.h"
# include "ardour/session_state_utils.h"
# include "ardour/session_utils.h"
# include "ardour/port.h"
# include "ardour/audioengine.h"
# include "ardour/playlist.h"
# include "ardour/utils.h"
# include "ardour/audio_diskstream.h"
# include "ardour/audiofilesource.h"
# include "ardour/recent_sessions.h"
# include "ardour/port.h"
# include "ardour/audio_track.h"
# include "ardour/midi_track.h"
# include "ardour/filesystem_paths.h"
# include "ardour/filename_extensions.h"
2005-09-25 14:42:24 -04:00
2008-09-10 11:03:30 -04:00
typedef uint64_t microseconds_t ;
2005-11-25 19:06:46 -05:00
# include "actions.h"
2005-09-25 14:42:24 -04:00
# include "ardour_ui.h"
# include "public_editor.h"
# include "audio_clock.h"
# include "keyboard.h"
# include "mixer_ui.h"
# include "prompter.h"
# include "opts.h"
# include "add_route_dialog.h"
# include "about.h"
2008-01-18 22:49:52 -05:00
# include "splash.h"
2005-09-25 14:42:24 -04:00
# include "utils.h"
# include "gui_thread.h"
2007-05-25 16:29:12 -04:00
# include "theme_manager.h"
2007-10-19 09:30:07 -04:00
# include "bundle_manager.h"
2008-09-17 04:44:51 -04:00
# include "session_metadata_dialog.h"
2008-09-10 11:03:30 -04:00
# include "gain_meter.h"
# include "route_time_axis.h"
2009-03-04 18:06:18 -05:00
# include "startup.h"
2009-04-20 14:41:46 -04:00
# include "engine_dialog.h"
2009-11-25 09:37:20 -05:00
# include "processor_box.h"
2010-06-03 11:57:31 -04:00
# include "time_axis_view_item.h"
2010-08-17 22:20:15 -04:00
# include "window_proxy.h"
# include "global_port_matrix.h"
# include "location_ui.h"
2007-06-29 13:13:09 -04:00
2005-09-25 14:42:24 -04:00
# include "i18n.h"
using namespace ARDOUR ;
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 ;
ARDOUR_UI * ARDOUR_UI : : theArdourUI = 0 ;
2007-06-29 13:13:09 -04:00
UIConfiguration * ARDOUR_UI : : ui_config = 0 ;
2005-09-25 14:42:24 -04:00
2005-09-25 16:33:00 -04:00
sigc : : signal < void , bool > ARDOUR_UI : : Blink ;
sigc : : signal < void > ARDOUR_UI : : RapidScreenUpdate ;
sigc : : signal < void > ARDOUR_UI : : SuperRapidScreenUpdate ;
2007-05-13 22:48:28 -04:00
sigc : : signal < void , nframes_t , bool , nframes_t > ARDOUR_UI : : Clock ;
2005-09-25 14:42:24 -04:00
2010-09-14 11:45:21 -04:00
bool could_be_a_valid_path ( const string & path ) ;
2007-05-25 16:29:12 -04:00
ARDOUR_UI : : ARDOUR_UI ( int * argcp , char * * argvp [ ] )
2005-09-25 14:42:24 -04:00
2010-03-21 23:46:09 -04:00
: Gtkmm2ext : : UI ( PROGRAM_NAME , argcp , argvp ) ,
2009-10-14 12:10:01 -04:00
2009-11-25 21:15:44 -05:00
primary_clock ( X_ ( " primary " ) , false , X_ ( " TransportClockDisplay " ) , true , true , false , true ) ,
secondary_clock ( X_ ( " secondary " ) , false , X_ ( " SecondaryClockDisplay " ) , true , true , false , true ) ,
preroll_clock ( X_ ( " preroll " ) , false , X_ ( " PreRollClock " ) , true , false , true ) ,
postroll_clock ( X_ ( " postroll " ) , false , X_ ( " PostRollClock " ) , true , false , true ) ,
2005-09-25 14:42:24 -04:00
/* preroll stuff */
preroll_button ( _ ( " pre \n roll " ) ) ,
postroll_button ( _ ( " post \n roll " ) ) ,
/* big clock */
2010-03-04 21:09:37 -05:00
big_clock ( X_ ( " bigclock " ) , false , " BigClockNonRecording " , true , true , false , false ) ,
2005-09-25 14:42:24 -04:00
/* transport */
2008-09-10 11:03:30 -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 ) ) ,
shuttle_controllable ( new TransportControllable ( " shuttle " , * this , TransportControllable : : ShuttleControl ) ) ,
2007-03-18 02:07:08 -04:00
shuttle_controller_binding_proxy ( shuttle_controllable ) ,
roll_button ( roll_controllable ) ,
stop_button ( stop_controllable ) ,
goto_start_button ( goto_start_controllable ) ,
goto_end_button ( goto_end_controllable ) ,
auto_loop_button ( auto_loop_controllable ) ,
play_selection_button ( play_selection_controllable ) ,
rec_button ( rec_controllable ) ,
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
shuttle_units_button ( _ ( " % " ) ) ,
2005-12-04 23:11:08 -05:00
2006-06-28 03:08:10 -04:00
punch_in_button ( _ ( " Punch In " ) ) ,
punch_out_button ( _ ( " Punch Out " ) ) ,
auto_return_button ( _ ( " Auto Return " ) ) ,
2007-03-18 02:07:08 -04:00
auto_play_button ( _ ( " Auto Play " ) ) ,
2006-06-28 03:08:10 -04:00
auto_input_button ( _ ( " Auto Input " ) ) ,
click_button ( _ ( " Click " ) ) ,
2007-03-18 02:07:08 -04:00
time_master_button ( _ ( " time \n master " ) ) ,
2006-06-30 13:15:45 -04:00
auditioning_alert_button ( _ ( " AUDITION " ) ) ,
2005-09-25 14:42:24 -04:00
solo_alert_button ( _ ( " SOLO " ) ) ,
2007-10-11 18:07:47 -04:00
error_log_button ( _ ( " Errors " ) )
2005-09-25 14:42:24 -04:00
{
using namespace Gtk : : Menu_Helpers ;
2005-09-25 16:33:00 -04:00
Gtkmm2ext : : init ( ) ;
2009-10-14 12:10:01 -04:00
2007-10-11 18:07:47 -04:00
# ifdef TOP_MENUBAR
2009-08-08 18:36:32 -04:00
// _auto_display_errors = false;
/*
* This was commented out as it wasn ' t defined
* in A3 IIRC . If this is not needed it should
* be completely removed .
*/
2007-10-11 18:07:47 -04:00
# endif
2008-02-16 17:43:18 -05:00
2005-09-25 14:42:24 -04:00
about = 0 ;
2008-01-18 22:49:52 -05:00
splash = 0 ;
2009-03-04 18:06:18 -05:00
_startup = 0 ;
2005-09-25 14:42:24 -04:00
if ( theArdourUI = = 0 ) {
theArdourUI = this ;
}
2005-11-25 19:06:46 -05:00
2007-06-29 13:13:09 -04:00
ui_config = new UIConfiguration ( ) ;
2007-05-25 16:29:12 -04:00
theme_manager = new ThemeManager ( ) ;
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
editor = 0 ;
mixer = 0 ;
2007-10-23 08:02:36 -04:00
editor = 0 ;
2008-09-26 15:26:17 -04:00
engine = 0 ;
2005-09-25 14:42:24 -04:00
_session_is_new = false ;
big_clock_window = 0 ;
2010-01-15 09:42:19 -05:00
big_clock_height = 0 ;
big_clock_resize_in_progress = false ;
2005-09-25 14:42:24 -04:00
session_selector_window = 0 ;
last_key_press_time = 0 ;
2007-10-11 18:07:47 -04:00
_will_create_new_session_automatically = false ;
2005-09-25 14:42:24 -04:00
add_route_dialog = 0 ;
route_params = 0 ;
2009-05-13 20:13:27 -04:00
rc_option_editor = 0 ;
2009-05-15 21:22:43 -04:00
session_option_editor = 0 ;
2005-09-25 14:42:24 -04:00
location_ui = 0 ;
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 ;
2006-01-01 12:06:15 -05:00
last_speed_displayed = - 1.0f ;
2008-03-17 16:54:03 -04:00
ignore_dual_punch = false ;
2008-12-12 09:43:24 -05:00
_mixer_on_top = false ;
2010-03-05 16:51:31 -05:00
original_big_clock_width = - 1 ;
original_big_clock_height = - 1 ;
original_big_clock_font_size = 0 ;
2008-12-12 09:43:24 -05:00
roll_button . unset_flags ( Gtk : : CAN_FOCUS ) ;
stop_button . unset_flags ( Gtk : : CAN_FOCUS ) ;
goto_start_button . unset_flags ( Gtk : : CAN_FOCUS ) ;
goto_end_button . unset_flags ( Gtk : : CAN_FOCUS ) ;
auto_loop_button . unset_flags ( Gtk : : CAN_FOCUS ) ;
play_selection_button . unset_flags ( Gtk : : CAN_FOCUS ) ;
rec_button . unset_flags ( Gtk : : CAN_FOCUS ) ;
2007-06-27 08:12:36 -04:00
2008-09-10 11:03:30 -04:00
last_configure_time = 0 ;
2005-09-25 14:42:24 -04:00
shuttle_grabbed = false ;
shuttle_fract = 0.0 ;
2006-03-12 13:21:48 -05:00
shuttle_max_speed = 8.0f ;
2005-09-25 14:42:24 -04:00
2005-11-28 10:29:49 -05:00
shuttle_style_menu = 0 ;
shuttle_unit_menu = 0 ;
2005-10-06 00:59:20 -04:00
2008-09-10 11:03:30 -04:00
// We do not have jack linked in yet so;
2009-10-14 12:10:01 -04:00
2008-09-10 11:03:30 -04:00
last_shuttle_request = last_peak_grab = 0 ; // get_microseconds();
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
2008-04-11 10:06:50 -04:00
/* handle dialog requests */
2010-03-30 11:18:43 -04:00
ARDOUR : : Session : : Dialog . connect ( forever_connections , MISSING_INVALIDATOR , ui_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
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
2007-10-11 18:07:47 -04:00
/* lets get this party started */
2009-10-22 15:53:22 -04:00
try {
2008-01-15 12:23:57 -05:00
if ( ARDOUR : : init ( ARDOUR_COMMAND_LINE : : use_vst , ARDOUR_COMMAND_LINE : : try_hw_optimization ) ) {
throw failed_constructor ( ) ;
}
2007-10-11 18:07:47 -04:00
setup_gtk_ardour_enums ( ) ;
setup_profile ( ) ;
2008-09-10 11:03:30 -04:00
GainMeter : : setup_slider_pix ( ) ;
RouteTimeAxisView : : setup_slider_pix ( ) ;
2009-11-25 09:37:20 -05:00
SendProcessorEntry : : setup_slider_pix ( ) ;
2009-12-04 14:24:09 -05:00
SessionEvent : : create_per_thread_pool ( " GUI " , 512 ) ;
2008-09-10 11:03:30 -04:00
2007-10-11 18:07:47 -04:00
} catch ( failed_constructor & err ) {
2010-08-16 20:28:20 -04:00
error < < string_compose ( _ ( " could not initialize %1. " ) , PROGRAM_NAME ) < < endmsg ;
2007-10-11 18:07:47 -04:00
// pass it on up
2008-01-15 12:23:57 -05:00
throw ;
2009-10-14 12:10:01 -04:00
}
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
2008-03-17 16:54:03 -04:00
reset_dpi ( ) ;
2010-06-03 11:57:31 -04:00
TimeAxisViewItem : : set_constant_heights ( ) ;
2010-08-17 22:20:15 -04:00
/* The following must happen after ARDOUR::init() so that Config is set up */
location_ui = new ActionWindowProxy < LocationUIWindow > ( X_ ( " locations " ) , Config - > extra_xml ( X_ ( " UI " ) ) , X_ ( " ToggleLocations " ) ) ;
big_clock_window = new ActionWindowProxy < Gtk : : Window > ( X_ ( " bigclock " ) , Config - > extra_xml ( X_ ( " UI " ) ) , X_ ( " ToggleBigClock " ) ) ;
for ( ARDOUR : : DataType : : iterator i = ARDOUR : : DataType : : begin ( ) ; i ! = ARDOUR : : DataType : : end ( ) ; + + i ) {
_global_port_matrix [ * i ] = new ActionWindowProxy < GlobalPortMatrixWindow > (
string_compose ( " GlobalPortMatrix-%1 " , ( * i ) . to_string ( ) ) ,
Config - > extra_xml ( X_ ( " UI " ) ) ,
string_compose ( " toggle-%1-connection-manager " , ( * i ) . to_string ( ) )
) ;
}
setup_clock ( ) ;
2009-12-11 18:29:48 -05:00
starting . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : startup ) ) ;
stopping . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : shutdown ) ) ;
2007-10-11 18:07:47 -04:00
2008-01-10 16:20:59 -05:00
platform_setup ( ) ;
2005-09-25 14:42:24 -04:00
}
2009-10-19 14:12:20 -04:00
/** @return true if a session was chosen and `apply' clicked, otherwise false if `cancel' was clicked */
bool
2010-06-02 10:36:10 -04:00
ARDOUR_UI : : run_startup ( bool should_be_new , string load_template )
2009-03-04 18:06:18 -05:00
{
2010-07-20 20:15:43 -04:00
delete _startup ;
_startup = new ArdourStartup ( ) ;
2010-04-02 18:58:05 -04:00
2010-07-20 20:15:43 -04:00
XMLNode * audio_setup = Config - > extra_xml ( " AudioSetup " ) ;
2010-04-02 18:58:05 -04:00
if ( audio_setup & & _startup - > engine_control ( ) ) {
_startup - > engine_control ( ) - > set_state ( * audio_setup ) ;
}
2009-03-04 18:06:18 -05:00
2009-04-21 21:35:31 -04:00
_startup - > set_new_only ( should_be_new ) ;
2010-06-02 10:36:10 -04:00
if ( ! load_template . empty ( ) ) {
_startup - > set_load_template ( load_template ) ;
}
2009-03-04 18:06:18 -05:00
_startup - > present ( ) ;
2009-04-20 14:41:46 -04:00
2009-03-04 18:06:18 -05:00
main ( ) . run ( ) ;
2009-04-20 14:41:46 -04:00
_startup - > hide ( ) ;
2009-10-19 14:12:20 -04:00
2009-12-01 08:23:27 -05:00
switch ( _startup - > response ( ) ) {
case RESPONSE_OK :
return true ;
default :
return false ;
}
2009-03-04 18:06:18 -05:00
}
2007-10-11 18:07:47 -04:00
int
ARDOUR_UI : : create_engine ( )
2005-09-25 14:42:24 -04:00
{
2007-10-11 18:07:47 -04:00
// this gets called every time by new_session()
if ( engine ) {
return 0 ;
}
2008-01-19 00:06:33 -05:00
loading_message ( _ ( " Starting audio engine " ) ) ;
2008-01-18 22:49:52 -05:00
2009-10-14 12:10:01 -04:00
try {
2010-04-02 14:48:50 -04:00
engine = new ARDOUR : : AudioEngine ( ARDOUR_COMMAND_LINE : : jack_client_name , ARDOUR_COMMAND_LINE : : jack_session_uuid ) ;
2007-10-11 18:07:47 -04:00
} catch ( . . . ) {
return - 1 ;
}
2005-09-25 14:42:24 -04:00
2010-03-30 11:18:43 -04:00
engine - > Stopped . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : engine_stopped , this ) , gui_context ( ) ) ;
engine - > Running . connect ( forever_connections , MISSING_INVALIDATOR , boost : : bind ( & ARDOUR_UI : : engine_running , this ) , gui_context ( ) ) ;
engine - > SampleRateChanged . connect ( forever_connections , MISSING_INVALIDATOR , ui_bind ( & ARDOUR_UI : : update_sample_rate , this , _1 ) , gui_context ( ) ) ;
2005-09-25 14:42:24 -04:00
2010-04-20 22:24:38 -04:00
engine - > Halted . connect_same_thread ( forever_connections , boost : : bind ( & ARDOUR_UI : : engine_halted , this , _1 , false ) ) ;
2010-06-02 12:21:02 -04:00
ARDOUR : : Port : : set_connecting_blocked ( ARDOUR_COMMAND_LINE : : no_connect_ports ) ;
2007-10-11 18:07:47 -04:00
post_engine ( ) ;
2006-08-30 22:28:42 -04:00
2007-10-11 18:07:47 -04:00
return 0 ;
}
2005-09-25 14:42:24 -04:00
2007-10-11 18:07:47 -04:00
void
ARDOUR_UI : : post_engine ( )
{
/* Things to be done once we create the AudioEngine
*/
2009-10-06 21:55:32 -04:00
ARDOUR : : init_post_engine ( ) ;
2007-10-14 01:45:31 -04:00
ActionManager : : init ( ) ;
2007-10-11 18:07:47 -04:00
_tooltips . enable ( ) ;
2005-09-25 14:42:24 -04:00
if ( setup_windows ( ) ) {
throw failed_constructor ( ) ;
}
2009-11-09 15:05:18 -05:00
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 ;
vector < string > keys ;
vector < AccelKey > bindings ;
ActionManager : : get_all_actions ( names , paths , keys , bindings ) ;
vector < string > : : iterator n ;
vector < string > : : iterator k ;
for ( n = names . begin ( ) , k = keys . begin ( ) ; n ! = names . end ( ) ; + + n , + + k ) {
cerr < < " Action: " < < ( * n ) < < " bound to " < < ( * k ) < < endl ;
}
2005-09-25 14:42:24 -04:00
exit ( 0 ) ;
}
blink_timeout_tag = - 1 ;
/* 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 ( ) ) {
2008-12-12 09:43:24 -05:00
primary_clock . set_mode ( AudioClock : : BBT ) ;
secondary_clock . set_mode ( AudioClock : : MinSec ) ;
2008-02-16 17:43:18 -05:00
} else {
2009-10-26 10:38:58 -04:00
primary_clock . set_mode ( AudioClock : : Timecode ) ;
2008-12-12 09:43:24 -05:00
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 ( ) ;
2009-12-11 18:29:48 -05:00
Glib : : signal_timeout ( ) . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : update_wall_clock ) , 60000 ) ;
2007-10-11 18:07:47 -04:00
# endif
2005-09-25 14:42:24 -04:00
update_disk_space ( ) ;
update_cpu_load ( ) ;
update_sample_rate ( engine - > frame_rate ( ) ) ;
2010-03-30 11:18:43 -04:00
Config - > ParameterChanged . connect ( forever_connections , MISSING_INVALIDATOR , ui_bind ( & ARDOUR_UI : : parameter_changed , this , _1 ) , gui_context ( ) ) ;
2009-12-12 10:02:15 -05:00
boost : : function < void ( string ) > pc ( boost : : bind ( & ARDOUR_UI : : parameter_changed , this , _1 ) ) ;
Config - > map_parameters ( pc ) ;
2009-11-09 15:05:18 -05:00
2007-10-11 18:07:47 -04:00
/* now start and maybe save state */
if ( do_engine_start ( ) = = 0 ) {
2009-12-17 13:24:23 -05:00
if ( _session & & _session_is_new ) {
2009-10-14 12:10:01 -04:00
/* we need to retain initial visual
settings for a new session
2007-10-11 18:07:47 -04:00
*/
2009-12-17 13:24:23 -05:00
_session - > save_state ( " " ) ;
2007-10-11 18:07:47 -04:00
}
}
2005-09-25 14:42:24 -04:00
}
ARDOUR_UI : : ~ ARDOUR_UI ( )
{
2008-12-18 14:31:00 -05:00
delete keyboard ;
delete editor ;
delete mixer ;
delete add_route_dialog ;
2005-09-25 14:42:24 -04:00
}
2008-02-02 12:22:04 -05:00
void
ARDOUR_UI : : pop_back_splash ( )
{
if ( Splash : : instance ( ) ) {
// Splash::instance()->pop_back();
Splash : : instance ( ) - > hide ( ) ;
}
}
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 ;
2010-03-18 22:49:01 -04:00
cerr < < " config event-driven save \n " ;
2005-09-25 14:42:24 -04:00
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 ) {
2008-09-10 11:03:30 -04:00
shuttle_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 ) ;
2008-09-10 11:03:30 -04:00
shuttle_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
2008-09-10 11:03:30 -04: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
2009-12-17 13:24:23 -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
}
2007-10-11 18:07:47 -04:00
void
ARDOUR_UI : : backend_audio_error ( bool we_set_params , Gtk : : Window * toplevel )
{
string title ;
if ( we_set_params ) {
2010-03-14 22:31:27 -04:00
title = string_compose ( _ ( " %1 could not start JACK " ) , PROGRAM_NAME ) ;
2007-10-11 18:07:47 -04:00
} else {
2010-03-14 22:31:27 -04:00
title = string_compose ( _ ( " %1 could not connect to JACK. " ) , PROGRAM_NAME ) ;
2007-10-11 18:07:47 -04:00
}
MessageDialog win ( title ,
false ,
Gtk : : MESSAGE_INFO ,
Gtk : : BUTTONS_NONE ) ;
2009-10-14 12:10:01 -04:00
2007-10-11 18:07:47 -04:00
if ( we_set_params ) {
win . set_secondary_text ( _ ( " There are several possible reasons: \n \
\ n \
1 ) You requested audio parameters that are not supported . . \ n \
2 ) JACK is running as another user . \ n \
\ n \
Please consider the possibilities , and perhaps try different parameters . " ));
} else {
win . set_secondary_text ( _ ( " There are several possible reasons: \n \
\ n \
1 ) JACK is not running . \ n \
2 ) JACK is running as another user , perhaps root . \ n \
3 ) There is already another client called \ " ardour \" . \n \
\ n \
Please consider the possibilities , and perhaps ( re ) start JACK . " ));
}
if ( toplevel ) {
win . set_transient_for ( * toplevel ) ;
}
if ( we_set_params ) {
win . add_button ( Stock : : OK , RESPONSE_CLOSE ) ;
} else {
win . add_button ( Stock : : QUIT , RESPONSE_CLOSE ) ;
2009-10-22 13:33:36 -04:00
}
2007-10-11 18:07:47 -04:00
win . set_default_response ( RESPONSE_CLOSE ) ;
2009-10-14 12:10:01 -04:00
2007-10-11 18:07:47 -04:00
win . show_all ( ) ;
win . set_position ( Gtk : : WIN_POS_CENTER ) ;
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
2007-10-11 18:07:47 -04:00
/* we just don't care about the result, but we want to block */
win . run ( ) ;
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : startup ( )
{
2010-08-20 18:36:35 -04:00
Application * app = Application : : instance ( ) ;
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
# ifdef PHONE_HOME
call_the_mothership ( VERSIONSTRING ) ;
# endif
2010-08-20 18:36:35 -04:00
app - > ready ( ) ;
2010-06-02 10:36:10 -04:00
if ( get_session_parameters ( true , ARDOUR_COMMAND_LINE : : new_session , ARDOUR_COMMAND_LINE : : load_template ) ) {
2009-04-21 21:35:31 -04:00
exit ( 1 ) ;
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
2010-08-17 22:20:15 -04:00
/* Add the window proxies here; their addition may cause windows to be opened, and we want them
to be opened on top of the editor window that goto_editor_window ( ) just opened .
*/
add_window_proxy ( location_ui ) ;
add_window_proxy ( big_clock_window ) ;
for ( ARDOUR : : DataType : : iterator i = ARDOUR : : DataType : : begin ( ) ; i ! = ARDOUR : : DataType : : end ( ) ; + + i ) {
add_window_proxy ( _global_port_matrix [ * i ] ) ;
}
2010-03-14 22:31:27 -04:00
BootMessage ( string_compose ( _ ( " %1 is ready for use " ) , PROGRAM_NAME ) ) ;
2007-03-18 02:07:08 -04:00
}
void
ARDOUR_UI : : no_memory_warning ( )
{
XMLNode node ( X_ ( " no-memory-warning " ) ) ;
2007-06-16 20:47:40 -04:00
Config - > add_instant_xml ( node ) ;
2007-03-18 02:07:08 -04:00
}
void
ARDOUR_UI : : check_memory_locking ( )
{
# ifdef __APPLE__
/* 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
if ( engine - > is_realtime ( ) & & memory_warning_node = = 0 ) {
struct rlimit limits ;
int64_t ram ;
long pages , page_size ;
if ( ( page_size = sysconf ( _SC_PAGESIZE ) ) < 0 | | ( pages = sysconf ( _SC_PHYS_PAGES ) ) < 0 ) {
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
2007-03-18 02:07:08 -04:00
2010-03-14 22:31:27 -04:00
MessageDialog msg ( 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', "
" and it is normally controlled by /etc/security/limits.conf " ) ,
PROGRAM_NAME ) . c_str ( ) ) ;
2007-03-18 02:07:08 -04:00
VBox * vbox = msg . get_vbox ( ) ;
HBox hbox ;
CheckButton cb ( _ ( " Do not show this window again " ) ) ;
2009-10-14 12:10:01 -04:00
2009-12-11 18:29:48 -05:00
cb . signal_toggled ( ) . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : no_memory_warning ) ) ;
2009-10-14 12:10:01 -04:00
2007-03-18 02:07:08 -04:00
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
pop_back_splash ( ) ;
2009-10-14 12:10:01 -04:00
2007-03-18 02:07:08 -04:00
editor - > ensure_float ( msg ) ;
msg . run ( ) ;
}
}
}
# 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 ( )
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
2010-04-20 22:24:38 -04:00
int tries = 0 ;
2008-01-10 17:22:29 -05:00
2010-04-20 22:24:38 -04:00
if ( _session - > transport_rolling ( ) & & ( + + tries < 8 ) ) {
_session - > request_stop ( false , true ) ;
usleep ( 10000 ) ;
2008-01-10 17:22:29 -05:00
}
2009-12-17 13:24:23 -05:00
if ( _session - > dirty ( ) ) {
2008-01-10 17:22:29 -05:00
switch ( ask_about_saving_session ( _ ( " quit " ) ) ) {
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 ,
2008-01-10 17:22:29 -05:00
_ ( " \
2005-09-25 14:42:24 -04:00
Ardour was unable to save your session . \ n \ n \
If you still wish to quit , please use the \ n \ n \
\ " Just quit \" option. " ) ) ;
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
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 ( ) ;
point_oh_five_second_connection . disconnect ( ) ;
point_zero_one_second_connection . disconnect ( ) ;
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 ( ) ;
if ( _session ) {
2009-12-17 13:24:23 -05:00
// _session->set_deletion_in_progress ();
2010-08-17 22:20:15 -04: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
2010-05-08 12:47:57 -04:00
ArdourDialog : : close_all_dialogs ( ) ;
engine - > stop ( true ) ;
2005-12-02 14:18:26 -05:00
quit ( ) ;
2005-09-25 14:42:24 -04:00
}
int
2005-12-22 07:23:54 -05:00
ARDOUR_UI : : ask_about_saving_session ( const string & what )
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 ;
2005-10-06 15:10:57 -04:00
msg = string_compose ( _ ( " Don't %1 " ) , what ) ;
2005-11-27 16:17:41 -05:00
window . add_button ( msg , RESPONSE_REJECT ) ;
2006-04-20 16:41:05 -04:00
msg = string_compose ( _ ( " Just %1 " ) , what ) ;
window . add_button ( msg , RESPONSE_APPLY ) ;
msg = string_compose ( _ ( " Save and %1 " ) , what ) ;
window . add_button ( msg , RESPONSE_ACCEPT ) ;
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 ;
string type ;
2009-12-17 13:24:23 -05:00
if ( _session - > snap_name ( ) = = _session - > name ( ) ) {
2005-09-25 14:42:24 -04:00
type = _ ( " session " ) ;
} else {
type = _ ( " snapshot " ) ;
}
2009-10-14 12:10:01 -04:00
prompt = string_compose ( _ ( " The %1 \" %2 \" \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? " ) ,
2009-12-17 13:24:23 -05:00
type , _session - > snap_name ( ) ) ;
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 " ) ) ;
2005-09-25 16:33:00 -04:00
window . set_position ( Gtk : : WIN_POS_MOUSE ) ;
2005-09-25 14:42:24 -04:00
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
2005-09-25 14:42:24 -04:00
gint
ARDOUR_UI : : every_second ( )
{
update_cpu_load ( ) ;
update_buffer_load ( ) ;
update_disk_space ( ) ;
return TRUE ;
}
gint
ARDOUR_UI : : every_point_one_seconds ( )
{
update_speed_display ( ) ;
RapidScreenUpdate ( ) ; /* EMIT_SIGNAL */
return TRUE ;
}
gint
ARDOUR_UI : : every_point_zero_one_seconds ( )
{
2007-10-11 18:07:47 -04:00
// august 2007: actual update frequency: 40Hz, not 100Hz
2005-09-25 14:42:24 -04:00
SuperRapidScreenUpdate ( ) ; /* EMIT_SIGNAL */
return TRUE ;
}
void
2009-12-22 15:21:43 -05:00
ARDOUR_UI : : update_sample_rate ( nframes_t )
2005-09-25 14:42:24 -04:00
{
char buf [ 32 ] ;
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
if ( ! engine - > connected ( ) ) {
snprintf ( buf , sizeof ( buf ) , _ ( " disconnected " ) ) ;
} else {
2006-10-21 15:01:50 -04:00
nframes_t rate = engine - > frame_rate ( ) ;
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
if ( fmod ( rate , 1000.0 ) ! = 0.0 ) {
2009-10-14 12:10:01 -04:00
snprintf ( buf , sizeof ( buf ) , _ ( " %.1f kHz / %4.1f ms " ) ,
2005-09-25 14:42:24 -04:00
( float ) rate / 1000.0f ,
( engine - > frames_per_cycle ( ) / ( float ) rate ) * 1000.0f ) ;
} else {
2009-10-14 12:10:01 -04:00
snprintf ( buf , sizeof ( buf ) , _ ( " %u kHz / %4.1f ms " ) ,
2005-09-25 14:42:24 -04:00
rate / 1000 ,
( engine - > frames_per_cycle ( ) / ( float ) rate ) * 1000.0f ) ;
}
}
sample_rate_label . set_text ( buf ) ;
}
void
ARDOUR_UI : : update_cpu_load ( )
{
char buf [ 32 ] ;
2007-04-12 19:20:37 -04:00
snprintf ( buf , sizeof ( buf ) , _ ( " DSP: %5.1f%% " ) , engine - > get_cpu_load ( ) ) ;
2005-09-25 14:42:24 -04:00
cpu_load_label . set_text ( buf ) ;
}
void
ARDOUR_UI : : update_buffer_load ( )
{
char buf [ 64 ] ;
2009-04-30 11:03:55 -04:00
uint32_t c , p ;
2005-09-25 14:42:24 -04:00
2009-12-17 13:24:23 -05:00
if ( _session ) {
c = _session - > capture_load ( ) ;
p = _session - > playback_load ( ) ;
2009-10-14 12:10:01 -04:00
snprintf ( buf , sizeof ( buf ) , _ ( " Buffers p:% " PRIu32 " %% c:% " PRIu32 " %% " ) ,
2009-12-17 13:24:23 -05:00
_session - > playback_load ( ) , _session - > capture_load ( ) ) ;
2005-09-25 14:42:24 -04:00
buffer_load_label . set_text ( buf ) ;
} 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 ;
}
2010-09-17 12:24:22 -04:00
framecnt_t frames = _session - > available_capture_duration ( ) ;
2005-09-25 14:42:24 -04:00
char buf [ 64 ] ;
2009-12-17 13:24:23 -05:00
nframes_t fr = _session - > frame_rate ( ) ;
2009-10-14 12:10:01 -04:00
2010-09-17 12:24:22 -04:00
if ( frames = = max_framecnt ) {
2006-06-28 03:08:10 -04:00
strcpy ( buf , _ ( " Disk: 24hrs+ " ) ) ;
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
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 ) ;
frames - = hrs * fr * 3600 ;
mins = frames / ( fr * 60 ) ;
frames - = mins * fr * 60 ;
secs = frames / fr ;
2009-10-14 12:10:01 -04:00
2006-07-19 01:44:23 -04:00
snprintf ( buf , sizeof ( buf ) , _ ( " Disk: %02dh:%02dm:%02ds " ) , hrs , mins , secs ) ;
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
disk_space_label . set_text ( buf ) ;
2009-10-14 12:10:01 -04:00
2008-09-19 10:38:46 -04:00
// An attempt to make the disk space label flash red when space has run out.
2009-10-14 12:10:01 -04:00
2008-09-19 10:38:46 -04:00
if ( frames < fr * 60 * 5 ) {
/* disk_space_box.style ("disk_space_label_empty"); */
} else {
/* disk_space_box.style ("disk_space_label"); */
}
2009-10-14 12:10:01 -04:00
}
2005-09-25 14:42:24 -04:00
gint
ARDOUR_UI : : update_wall_clock ( )
{
time_t now ;
struct tm * tm_now ;
char buf [ 16 ] ;
time ( & now ) ;
tm_now = localtime ( & now ) ;
sprintf ( buf , " %02d:%02d " , tm_now - > tm_hour , tm_now - > tm_min ) ;
wall_clock_label . set_text ( buf ) ;
return TRUE ;
}
gint
2009-07-21 11:55:17 -04:00
ARDOUR_UI : : session_menu ( GdkEventButton */ * ev */ )
2005-09-25 14:42:24 -04:00
{
2005-10-06 14:24:23 -04:00
session_popup_menu - > popup ( 0 , 0 ) ;
2005-09-25 14:42:24 -04:00
return TRUE ;
}
void
ARDOUR_UI : : redisplay_recent_sessions ( )
{
2007-09-04 01:26:28 -04:00
std : : vector < sys : : path > 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 ;
}
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 ) {
session_directories . push_back ( ( * i ) . second ) ;
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
2007-09-04 01:26:28 -04:00
for ( vector < sys : : path > : : const_iterator i = session_directories . begin ( ) ;
i ! = session_directories . end ( ) ; + + i )
{
std : : vector < sys : : path > 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
2007-09-04 01:26:28 -04:00
get_state_files_in_directory ( * i , state_file_paths ) ;
2005-09-25 14:42:24 -04:00
2008-02-02 12:22:04 -05:00
vector < string * > * states ;
vector < const gchar * > item ;
string fullpath = ( * i ) . to_string ( ) ;
2009-10-14 12:10:01 -04:00
2008-02-02 12:22:04 -05:00
/* remove any trailing / */
if ( fullpath [ fullpath . length ( ) - 1 ] = = ' / ' ) {
fullpath = fullpath . substr ( 0 , fullpath . length ( ) - 1 ) ;
}
/* check whether session still exists */
if ( ! Glib : : file_test ( fullpath . c_str ( ) , Glib : : FILE_TEST_EXISTS ) ) {
/* session doesn't exist */
cerr < < " skipping non-existent session " < < fullpath < < endl ;
continue ;
2009-10-14 12:10:01 -04:00
}
2008-02-02 12:22:04 -05:00
/* now get available states for this session */
if ( ( states = Session : : possible_states ( fullpath ) ) = = 0 ) {
/* 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
2006-06-13 03:27:52 -04:00
row [ recent_session_columns . visible_name ] = Glib : : path_get_basename ( fullpath ) ;
2005-10-06 14:24:23 -04:00
row [ recent_session_columns . fullpath ] = fullpath ;
2009-10-14 12:10:01 -04:00
2007-09-04 01:26:28 -04:00
if ( state_file_names . size ( ) > 1 ) {
2005-09-25 14:42:24 -04:00
2007-09-04 01:26:28 -04:00
// add the children
2005-09-25 14:42:24 -04:00
2007-09-04 01:26:28 -04:00
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 ;
2005-09-25 14:42:24 -04:00
}
}
}
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 ( ) ;
//session_selector_window->get_vbox()->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
session_selector_window - > set_position ( WIN_POS_MOUSE ) ;
2005-10-06 14:24:23 -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 ( )
{
if ( engine ) {
if ( ! engine - > connected ( ) ) {
2010-03-14 22:31:27 -04:00
MessageDialog msg ( string_compose ( _ ( " %1 is not connected to JACK \n "
" You cannot open or close sessions in this condition " ) ,
PROGRAM_NAME ) ) ;
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
2007-04-29 13:23:11 -04:00
msg . run ( ) ;
return false ;
}
return true ;
} else {
return false ;
}
}
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 ) ;
2005-12-06 01:23:50 -05:00
FileFilter session_filter ;
session_filter . add_pattern ( " *.ardour " ) ;
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
2009-06-21 15:59:56 -04:00
ARDOUR_UI : : session_add_midi_route ( bool disk , RouteGroup * route_group , uint32_t how_many )
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 {
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
if ( disk ) {
2006-08-24 03:37:17 -04:00
2009-12-17 13:24:23 -05:00
tracks = _session - > new_midi_track ( ARDOUR : : Normal , route_group , how_many ) ;
2006-08-24 03:37:17 -04:00
if ( tracks . size ( ) ! = how_many ) {
if ( how_many = = 1 ) {
error < < _ ( " could not create a new midi track " ) < < endmsg ;
} else {
error < < string_compose ( _ ( " could not create %1 new midi tracks " ) , how_many ) < < endmsg ;
}
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
}
2006-08-24 03:37:17 -04:00
} /*else {
2009-12-17 13:24:23 -05:00
if ( ( route = _session - > new_midi_route ( ) ) = = 0 ) {
2006-07-27 21:08:57 -04:00
error < < _ ( " could not create new midi bus " ) < < endmsg ;
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
}
2006-08-24 03:37:17 -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 ,
2010-08-16 20:28:20 -04:00
string_compose ( _ ( " There are insufficient JACK 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 \
restart JACK 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
}
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
2009-11-18 23:25:46 -05:00
ARDOUR_UI : : session_add_audio_route ( bool track , bool aux , int32_t input_channels , int32_t output_channels , ARDOUR : : TrackMode mode , RouteGroup * route_group , uint32_t how_many )
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 ) {
2009-12-17 13:24:23 -05:00
tracks = _session - > new_audio_track ( input_channels , output_channels , mode , route_group , how_many ) ;
2006-08-24 03:37:17 -04:00
if ( tracks . size ( ) ! = how_many ) {
if ( how_many = = 1 ) {
error < < _ ( " could not create a new audio track " ) < < endmsg ;
} else {
2009-10-14 12:10:01 -04:00
error < < string_compose ( _ ( " could only create %1 of %2 new audio %3 " ) ,
2007-03-18 02:07:08 -04:00
tracks . size ( ) , how_many , ( track ? _ ( " tracks " ) : _ ( " busses " ) ) ) < < endmsg ;
2006-08-24 03:37:17 -04:00
}
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
2009-12-17 13:24:23 -05:00
routes = _session - > new_audio_route ( aux , input_channels , output_channels , route_group , how_many ) ;
2006-08-24 03:37:17 -04:00
if ( routes . size ( ) ! = how_many ) {
if ( how_many = = 1 ) {
error < < _ ( " could not create a new audio track " ) < < endmsg ;
} else {
error < < string_compose ( _ ( " could not create %1 new audio tracks " ) , how_many ) < < endmsg ;
}
2005-09-25 14:42:24 -04:00
}
}
}
catch ( . . . ) {
2009-10-14 12:10:01 -04:00
MessageDialog msg ( * editor ,
2010-08-16 20:28:20 -04:00
string_compose ( _ ( " There are insufficient JACK 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 \
restart JACK with more ports . " ), PROGRAM_NAME));
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
2006-03-05 14:39:16 -05:00
msg . run ( ) ;
2005-09-25 14:42:24 -04:00
}
}
void
2006-10-21 15:01:50 -04:00
ARDOUR_UI : : do_transport_locate ( nframes_t new_position )
2005-09-25 14:42:24 -04:00
{
2006-10-21 15:01:50 -04:00
nframes_t _preroll = 0 ;
2005-09-25 14:42:24 -04:00
2009-12-17 13:24:23 -05:00
if ( _session ) {
2006-10-21 15:01:50 -04:00
// XXX CONFIG_CHANGE FIX - requires AnyTime handling
2009-12-17 13:24:23 -05:00
// _preroll = _session->convert_to_frames_at (new_position, Config->get_preroll());
2005-09-25 14:42:24 -04:00
if ( new_position > _preroll ) {
new_position - = _preroll ;
} else {
new_position = 0 ;
}
2009-12-17 13:24:23 -05:00
_session - > request_locate ( new_position ) ;
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 ) ;
2009-10-14 12:10:01 -04:00
2009-12-17 13:24:23 -05:00
frames = tmnow . tm_hour * ( 60 * 60 * _session - > frame_rate ( ) ) ;
frames + = tmnow . tm_min * ( 60 * _session - > frame_rate ( ) ) ;
frames + = tmnow . tm_sec * _session - > 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 ) {
nframes_t const frame = _session - > current_end_frame ( ) ;
_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
}
void
ARDOUR_UI : : transport_stop_and_forget_capture ( )
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
2010-04-20 22:24:38 -04:00
_session - > request_stop ( true , true ) ;
2005-09-25 14:42:24 -04:00
}
}
void
ARDOUR_UI : : remove_last_capture ( )
{
if ( editor ) {
editor - > remove_last_capture ( ) ;
}
}
void
2008-01-10 16:20:59 -05:00
ARDOUR_UI : : transport_record ( bool roll )
2005-09-25 14:42:24 -04:00
{
2009-10-14 12:10:01 -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 ) {
2006-10-21 15:01:50 -04:00
MessageDialog msg ( * editor , _ ( " Please create 1 or more track \n before trying to record. \n Check the Session menu. " ) ) ;
2006-03-05 14:39:16 -05:00
msg . run ( ) ;
2005-09-25 14:42:24 -04:00
return ;
}
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
}
}
2009-12-17 13:24:23 -05:00
//cerr << "ARDOUR_UI::transport_record () called roll = " << roll << " _session->record_status() = " << _session->record_status() << endl;
2005-09-25 14:42:24 -04:00
}
2009-10-30 14:14:25 -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 ;
}
2009-12-17 13:24:23 -05:00
if ( _session - > config . get_external_sync ( ) ) {
switch ( _session - > config . get_sync_source ( ) ) {
2009-11-09 15:05:18 -05:00
case JACK :
break ;
default :
/* transport controlled by the master */
return ;
}
2009-10-30 14:14:25 -04:00
}
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 ( ) ) {
2010-04-20 22:24:38 -04:00
/* XXX it is not possible to just leave seamless loop and keep
playing at present ( nov 4 th 2009 )
*/
if ( ! Config - > get_seamless_loop ( ) ) {
_session - > request_play_loop ( false , true ) ;
}
2010-01-01 17:11:15 -05:00
} else if ( _session - > get_play_range ( ) & & ! join_play_range_button . get_active ( ) ) {
/* stop playing a range if we currently are */
_session - > request_play_range ( 0 , true ) ;
}
if ( join_play_range_button . get_active ( ) ) {
_session - > request_play_range ( & editor - > get_selection ( ) . time , 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
}
}
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
{
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 ( ) ) {
switch ( _session - > config . get_sync_source ( ) ) {
2009-11-09 15:05:18 -05:00
case JACK :
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 ( ) ) {
/* the disk buffers contain copies of the loop - we can't
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 ;
}
2009-12-17 13:24:23 -05:00
_session - > request_play_loop ( false , true ) ;
} else if ( _session - > get_play_range ( ) ) {
2009-10-30 14:14:25 -04:00
affect_transport = false ;
2010-04-20 22:24:38 -04:00
_session - > request_play_range ( 0 , true ) ;
2009-10-30 14:14:25 -04:00
}
2009-11-08 11:28:21 -05: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 {
2010-01-01 17:11:15 -05:00
if ( join_play_range_button . get_active ( ) ) {
_session - > request_play_range ( & editor - > get_selection ( ) . time , true ) ;
}
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
{
2009-12-17 13:24:23 -05:00
if ( _session ) {
if ( _session - > get_play_loop ( ) ) {
if ( _session - > transport_rolling ( ) ) {
Location * looploc = _session - > locations ( ) - > auto_loop_location ( ) ;
2005-09-25 14:42:24 -04:00
if ( looploc ) {
2009-12-17 13:24:23 -05:00
_session - > request_locate ( looploc - > start ( ) , true ) ;
2005-09-25 14:42:24 -04:00
}
2009-10-30 14:14:25 -04:00
} else {
2009-12-17 13:24:23 -05:00
_session - > request_play_loop ( false ) ;
2009-10-30 14:14:25 -04:00
}
} else {
2009-12-17 13:24:23 -05:00
Location * looploc = _session - > locations ( ) - > auto_loop_location ( ) ;
2009-10-30 14:14:25 -04:00
if ( looploc ) {
2009-12-17 13:24:23 -05:00
_session - > request_play_loop ( true ) ;
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 ( ) ;
}
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 )
{
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
}
2009-10-30 14:14:25 -04:00
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
{
2009-12-17 13:24:23 -05:00
if ( _session = = 0 ) {
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
}
2009-12-17 13:24:23 -05:00
if ( _session = = 0 ) {
2005-09-25 14:42:24 -04:00
return ;
}
}
void
ARDOUR_UI : : map_transport_state ( )
{
2009-12-11 18:29:48 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : map_transport_state )
2009-10-30 14:14:25 -04:00
2009-12-17 13:24:23 -05:00
if ( ! _session ) {
2009-10-30 14:14:25 -04:00
auto_loop_button . set_visual_state ( 0 ) ;
play_selection_button . set_visual_state ( 0 ) ;
roll_button . set_visual_state ( 0 ) ;
stop_button . set_visual_state ( 1 ) ;
return ;
}
2009-12-17 13:24:23 -05:00
float sp = _session - > transport_speed ( ) ;
2005-09-25 14:42:24 -04:00
if ( sp = = 1.0f ) {
2009-10-30 14:14:25 -04:00
shuttle_fract = SHUTTLE_FRACT_SPEED1 ; /* speed = 1.0, believe it or not */
shuttle_box . queue_draw ( ) ;
} else if ( sp = = 0.0f ) {
shuttle_fract = 0 ;
shuttle_box . queue_draw ( ) ;
update_disk_space ( ) ;
}
if ( sp ! = 0.0 ) {
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
play_selection_button . set_visual_state ( 1 ) ;
roll_button . set_visual_state ( 0 ) ;
auto_loop_button . set_visual_state ( 0 ) ;
2010-01-01 17:11:15 -05:00
2009-12-17 13:24:23 -05:00
} else if ( _session - > get_play_loop ( ) ) {
2009-10-30 14:14:25 -04:00
auto_loop_button . set_visual_state ( 1 ) ;
play_selection_button . set_visual_state ( 0 ) ;
roll_button . set_visual_state ( 0 ) ;
} else {
roll_button . set_visual_state ( 1 ) ;
play_selection_button . set_visual_state ( 0 ) ;
auto_loop_button . set_visual_state ( 0 ) ;
}
2010-01-01 17:11:15 -05:00
if ( join_play_range_button . get_active ( ) ) {
/* light up both roll and play-selection if they are joined */
roll_button . set_visual_state ( 1 ) ;
play_selection_button . set_visual_state ( 1 ) ;
}
2009-10-30 14:14:25 -04:00
stop_button . set_visual_state ( 0 ) ;
2005-09-25 14:42:24 -04:00
} else {
2009-10-30 14:14:25 -04:00
stop_button . set_visual_state ( 1 ) ;
roll_button . set_visual_state ( 0 ) ;
play_selection_button . set_visual_state ( 0 ) ;
auto_loop_button . set_visual_state ( 0 ) ;
2005-09-25 14:42:24 -04:00
}
}
void
ARDOUR_UI : : engine_stopped ( )
{
2009-12-11 18:29:48 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : engine_stopped )
2005-11-28 10:29:49 -05:00
ActionManager : : set_sensitive ( ActionManager : : jack_sensitive_actions , false ) ;
ActionManager : : set_sensitive ( ActionManager : : jack_opposite_sensitive_actions , true ) ;
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : engine_running ( )
{
2009-12-11 18:29:48 -05:00
ENSURE_GUI_THREAD ( * this , & ARDOUR_UI : : engine_running )
2005-11-28 10:29:49 -05:00
ActionManager : : set_sensitive ( ActionManager : : jack_sensitive_actions , true ) ;
ActionManager : : set_sensitive ( ActionManager : : jack_opposite_sensitive_actions , false ) ;
2007-03-18 02:07:08 -04:00
Glib : : RefPtr < Action > action ;
2007-09-05 22:30:39 -04:00
const char * action_name = 0 ;
2007-03-18 02:07:08 -04:00
switch ( engine - > frames_per_cycle ( ) ) {
case 32 :
action_name = X_ ( " JACKLatency32 " ) ;
break ;
case 64 :
action_name = X_ ( " JACKLatency64 " ) ;
break ;
case 128 :
action_name = X_ ( " JACKLatency128 " ) ;
break ;
case 512 :
action_name = X_ ( " JACKLatency512 " ) ;
break ;
case 1024 :
action_name = X_ ( " JACKLatency1024 " ) ;
break ;
case 2048 :
action_name = X_ ( " JACKLatency2048 " ) ;
break ;
case 4096 :
action_name = X_ ( " JACKLatency4096 " ) ;
break ;
case 8192 :
action_name = X_ ( " JACKLatency8192 " ) ;
break ;
default :
/* XXX can we do anything useful ? */
break ;
}
if ( action_name ) {
action = ActionManager : : get_action ( X_ ( " JACK " ) , action_name ) ;
2009-10-14 12:10:01 -04:00
2007-03-18 02:07:08 -04:00
if ( action ) {
Glib : : RefPtr < RadioAction > ract = Glib : : RefPtr < RadioAction > : : cast_dynamic ( action ) ;
ract - > set_active ( ) ;
}
}
2005-09-25 14:42:24 -04:00
}
void
2010-04-20 22:24:38 -04:00
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 ;
}
2005-09-25 14:42:24 -04:00
2005-11-28 10:29:49 -05:00
ActionManager : : set_sensitive ( ActionManager : : jack_sensitive_actions , false ) ;
ActionManager : : set_sensitive ( ActionManager : : jack_opposite_sensitive_actions , true ) ;
2005-09-25 14:42:24 -04:00
update_sample_rate ( 0 ) ;
2010-04-20 22:24:38 -04:00
string msgstr ;
/* if the reason is a non-empty string, it means that the backend was shutdown
rather than just Ardour .
*/
if ( strlen ( reason ) ) {
msgstr = string_compose ( _ ( " The audio backend (JACK) was shutdown because: \n \n %1 " ) , reason ) ;
} else {
2010-08-16 20:28:20 -04:00
msgstr = string_compose ( _ ( " \
2005-09-25 14:42:24 -04:00
JACK has either been shutdown or it \ n \
2010-08-16 20:28:20 -04:00
disconnected % 1 because % 1 \ n \
2008-12-08 11:07:28 -05:00
was not fast enough . Try to restart \ n \
2010-08-16 20:28:20 -04:00
JACK , reconnect and save the session . " ), PROGRAM_NAME);
2010-04-20 22:24:38 -04:00
}
MessageDialog msg ( * editor , msgstr ) ;
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
2006-03-05 14:39:16 -05:00
msg . run ( ) ;
2010-04-20 22:24:38 -04:00
if ( free_reason ) {
free ( ( char * ) reason ) ;
}
2005-09-25 14:42:24 -04:00
}
int32_t
ARDOUR_UI : : do_engine_start ( )
{
2009-10-14 12:10:01 -04:00
try {
2005-09-25 14:42:24 -04:00
engine - > start ( ) ;
}
catch ( . . . ) {
engine - > stop ( ) ;
error < < _ ( " Unable to start the session running " )
< < endmsg ;
unload_session ( ) ;
return - 2 ;
}
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
return 0 ;
}
2007-05-25 16:29:12 -04:00
void
ARDOUR_UI : : setup_theme ( )
{
2007-06-15 18:08:27 -04:00
theme_manager - > setup_theme ( ) ;
2007-05-25 16:29:12 -04:00
}
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : update_clocks ( )
{
2007-01-09 18:24:54 -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 ( )
{
2009-12-11 18:29:48 -05:00
clock_signal_connection = RapidScreenUpdate . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : update_clocks ) ) ;
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
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : toggle_clocking ( )
{
#if 0
if ( clock_button . get_active ( ) ) {
start_clocking ( ) ;
} else {
stop_clocking ( ) ;
}
# endif
}
gint
ARDOUR_UI : : _blink ( void * arg )
{
( ( ARDOUR_UI * ) arg ) - > blink ( ) ;
return TRUE ;
}
void
ARDOUR_UI : : blink ( )
{
2007-03-18 02:07:08 -04:00
Blink ( blink_on = ! blink_on ) ; /* EMIT_SIGNAL */
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : start_blinking ( )
{
/* Start the blink signal. Everybody with a blinking widget
uses Blink to drive the widget ' s state .
*/
if ( blink_timeout_tag < 0 ) {
2009-10-14 12:10:01 -04:00
blink_on = false ;
2006-08-30 22:28:42 -04:00
blink_timeout_tag = g_timeout_add ( 240 , _blink , this ) ;
2005-09-25 14:42:24 -04:00
}
}
void
ARDOUR_UI : : stop_blinking ( )
{
if ( blink_timeout_tag > = 0 ) {
2006-08-30 22:28:42 -04:00
g_source_remove ( blink_timeout_tag ) ;
2005-09-25 14:42:24 -04:00
blink_timeout_tag = - 1 ;
}
}
2007-04-12 19:20:37 -04:00
/** Ask the user for the name of a new shapshot and then take it.
*/
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 ) ;
2009-10-19 13:25:37 -04:00
prompter . set_title ( _ ( " Take Snapshot " ) ) ;
2010-04-20 22:24:38 -04:00
prompter . set_title ( _ ( " Take Snapshot " ) ) ;
2010-05-11 19:47:24 -04:00
prompter . set_prompt ( _ ( " Name of new snapshot " ) ) ;
2010-04-20 22:24:38 -04:00
if ( ! switch_to_it ) {
char timebuf [ 128 ] ;
time_t n ;
struct tm local_time ;
time ( & n ) ;
localtime_r ( & n , & local_time ) ;
strftime ( timebuf , sizeof ( timebuf ) , " %FT%T " , & local_time ) ;
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-03-16 11:33:04 -04:00
if ( do_save ) {
if ( snapname . find ( ' / ' ) ! = string : : npos ) {
MessageDialog msg ( _ ( " To ensure compatibility with various systems \n "
" snapshot names may not contain a '/' character " ) ) ;
msg . run ( ) ;
goto again ;
}
if ( snapname . find ( ' \\ ' ) ! = string : : npos ) {
MessageDialog msg ( _ ( " To ensure compatibility with various systems \n "
" snapshot names may not contain a ' \\ ' character " ) ) ;
msg . run ( ) ;
goto again ;
}
}
2009-05-07 08:24:03 -04:00
vector < sys : : path > 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
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 " ) ) ;
for ( list < WindowProxyBase * > : : iterator i = _window_proxies . begin ( ) ; i ! = _window_proxies . end ( ) ; + + i ) {
if ( ! ( * i ) - > rc_configured ( ) ) {
node - > add_child_nocopy ( * ( ( * i ) - > get_state ( ) ) ) ;
}
}
_session - > add_extra_xml ( * node ) ;
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 ;
}
}
2010-03-18 22:49:01 -04:00
cerr < < " SS canfail \n " ;
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 ) {
_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 ) {
_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 ) {
_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-07-24 12:40:56 -04:00
if ( _session - > step_editing ( ) ) {
return ;
}
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 ) {
2007-03-18 02:07:08 -04:00
rec_button . set_visual_state ( 2 ) ;
2005-09-25 14:42:24 -04:00
} else {
2007-03-18 02:07:08 -04:00
rec_button . set_visual_state ( 0 ) ;
2005-09-25 14:42:24 -04:00
}
2009-04-29 13:30:35 -04:00
} else if ( r = = Session : : Recording & & h ) {
2007-03-18 02:07:08 -04:00
rec_button . set_visual_state ( 1 ) ;
2009-04-29 13:30:35 -04:00
} else {
2007-03-18 02:07:08 -04:00
rec_button . set_visual_state ( 0 ) ;
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 " ) ) ;
2009-10-19 13:25:37 -04:00
prompter . set_title ( _ ( " Save Mix Template " ) ) ;
2005-09-25 14:42:24 -04:00
prompter . set_prompt ( _ ( " Name for mix 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 ) ;
dialog . run ( ) ;
}
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 ( ) ;
}
2008-01-10 16:20:59 -05:00
void
ARDOUR_UI : : fontconfig_dialog ( )
{
# ifdef GTKOSX
2009-10-14 12:10:01 -04:00
/* X11 users will always have fontconfig info around, but new GTK-OSX users
2008-01-10 16:20:59 -05:00
may not and it can take a while to build it . Warn them .
*/
2009-10-14 12:10:01 -04:00
2010-09-14 12:51:02 -04:00
std : : string fontconfig = Glib : : build_filename ( Glib : : get_home_dir ( ) , " .fontconfig " ) ;
2009-10-14 12:10:01 -04:00
2008-01-10 16:20:59 -05:00
if ( ! Glib : : file_test ( fontconfig , Glib : : FILE_TEST_EXISTS | Glib : : FILE_TEST_IS_DIR ) ) {
2009-04-20 14:41:46 -04:00
MessageDialog msg ( * _startup ,
2010-08-16 20:28:20 -04:00
string_compose ( _ ( " Welcome to %1. \n \n "
" The program will take a bit longer to start up \n "
" while the system fonts are checked. \n \n "
" This will only be done once, and you will \n "
" not see this message again \n " ) , PROGRAM_NAME ) ,
true ,
2008-01-10 16:20:59 -05:00
Gtk : : MESSAGE_INFO ,
Gtk : : BUTTONS_OK ) ;
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
2008-01-10 16:20:59 -05:00
msg . show_all ( ) ;
msg . present ( ) ;
msg . run ( ) ;
}
# endif
}
2008-01-18 22:49:52 -05:00
void
2010-09-14 12:51:02 -04:00
ARDOUR_UI : : parse_cmdline_path ( const std : : string & cmdline_path , std : : string & session_name , std : : string & session_path , bool & existing_session )
2008-01-18 22:49:52 -05:00
{
existing_session = false ;
if ( Glib : : file_test ( cmdline_path , Glib : : FILE_TEST_IS_DIR ) ) {
session_path = cmdline_path ;
existing_session = true ;
} else if ( Glib : : file_test ( cmdline_path , Glib : : FILE_TEST_IS_REGULAR ) ) {
session_path = Glib : : path_get_dirname ( string ( cmdline_path ) ) ;
existing_session = true ;
} else {
/* it doesn't exist, assume the best */
session_path = Glib : : path_get_dirname ( string ( cmdline_path ) ) ;
}
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
session_name = basename_nosuffix ( string ( cmdline_path ) ) ;
}
int
2010-09-14 12:51:02 -04:00
ARDOUR_UI : : load_cmdline_session ( const std : : string & session_name , const std : : string & session_path , bool & existing_session )
2008-01-18 22:49:52 -05:00
{
/* when this is called, the backend audio system must be running */
/* the main idea here is to deal with the fact that a cmdline argument for the session
can be interpreted in different ways - it could be a directory or a file , and before
we load , we need to know both the session directory and the snapshot ( statefile ) within it
that we are supposed to use .
*/
if ( session_name . length ( ) = = 0 | | session_path . length ( ) = = 0 ) {
return false ;
}
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
if ( Glib : : file_test ( session_path , Glib : : FILE_TEST_IS_DIR ) ) {
2010-09-14 12:51:02 -04:00
std : : string predicted_session_file ;
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
predicted_session_file = session_path ;
predicted_session_file + = ' / ' ;
predicted_session_file + = session_name ;
predicted_session_file + = ARDOUR : : statefile_suffix ;
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
if ( Glib : : file_test ( predicted_session_file , Glib : : FILE_TEST_EXISTS ) ) {
existing_session = true ;
}
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
} else if ( Glib : : file_test ( session_path , Glib : : FILE_TEST_EXISTS ) ) {
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
if ( session_path . find ( ARDOUR : : statefile_suffix ) = = session_path . length ( ) - 7 ) {
/* existing .ardour file */
existing_session = true ;
}
} else {
existing_session = false ;
}
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
/* lets just try to load it */
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
if ( create_engine ( ) ) {
2009-04-20 14:41:46 -04:00
backend_audio_error ( false , _startup ) ;
2008-01-18 22:49:52 -05:00
return - 1 ;
}
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
return load_session ( session_path , session_name ) ;
}
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 ) ;
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
2008-01-18 22:49:52 -05:00
switch ( msg . run ( ) ) {
case RESPONSE_YES :
return true ;
break ;
}
return false ;
}
int
2010-09-14 12:51:02 -04:00
ARDOUR_UI : : build_session_from_nsd ( const std : : string & session_path , const std : : string & session_name )
2008-01-18 22:49:52 -05:00
{
2010-03-23 08:19:21 -04:00
BusProfile bus_profile ;
2009-10-14 12:10:01 -04:00
2008-01-18 22:49:52 -05:00
if ( 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
2009-04-20 14:41:46 -04:00
if ( _startup - > create_master_bus ( ) ) {
2010-03-23 08:19:21 -04:00
bus_profile . master_out_channels = ( uint32_t ) _startup - > 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
2009-04-20 14:41:46 -04:00
if ( _startup - > 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
2008-01-18 22:49:52 -05:00
/// @todo some minor tweaks.
2010-03-23 08:19:21 -04:00
bus_profile . output_ac = AutoConnectOption ( 0 ) ;
2009-10-19 16:30:09 -04:00
if ( _startup - > connect_outputs ( ) ) {
if ( _startup - > connect_outs_to_master ( ) ) {
2010-03-23 08:19:21 -04:00
bus_profile . output_ac = AutoConnectMaster ;
2009-10-19 16:30:09 -04:00
} else if ( _startup - > 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
}
2010-03-23 08:19:21 -04:00
bus_profile . requested_physical_in = ( uint32_t ) _startup - > input_limit_count ( ) ;
bus_profile . requested_physical_out = ( uint32_t ) _startup - > 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 ) ) ;
}
} else {
ARDOUR_COMMAND_LINE : : session_name = path ;
/*
* new_session_dialog doens ' t exist in A3
* Try to remove all references to it to
* see if it will compile . NOTE : this will
* likely cause a runtime issue is my somewhat
* uneducated guess .
*/
//if (new_session_dialog) {
/* make it break out of Dialog::run() and
start again .
*/
//new_session_dialog->response (1);
//}
}
}
2008-01-19 00:06:33 -05:00
void
ARDOUR_UI : : end_loading_messages ( )
{
// hide_splash ();
}
void
2009-07-21 11:55:17 -04:00
ARDOUR_UI : : loading_message ( const std : : string & /*msg*/ )
2008-01-19 00:06:33 -05:00
{
2009-03-04 18:06:18 -05:00
// show_splash ();
// splash->message (msg);
2008-01-19 00:06:33 -05:00
flush_pending ( ) ;
}
2008-12-12 09:43:24 -05:00
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 ;
2006-09-18 23:29:16 -04:00
2010-06-02 10:36:10 -04:00
if ( ! load_template . empty ( ) ) {
should_be_new = true ;
template_name = load_template ;
}
2009-04-21 21:35:31 -04:00
while ( ret ! = 0 ) {
2008-01-18 22:49:52 -05:00
2009-04-21 21:35:31 -04:00
if ( ! should_be_new & & ! 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 .
*/
if ( ARDOUR_COMMAND_LINE : : session_name . find ( statefile_suffix ) ! = string : : npos ) {
session_path = Glib : : path_get_dirname ( ARDOUR_COMMAND_LINE : : session_name ) ;
} else {
session_path = ARDOUR_COMMAND_LINE : : session_name ;
}
2009-04-21 21:35:31 -04:00
session_name = Glib : : path_get_basename ( ARDOUR_COMMAND_LINE : : session_name ) ;
2009-04-23 15:41:14 -04:00
2009-04-21 21:35:31 -04:00
} else {
2008-01-10 16:20:59 -05:00
2010-06-02 10:36:10 -04:00
bool const apply = run_startup ( should_be_new , load_template ) ;
2010-09-14 11:45:21 -04:00
2009-10-19 14:12:20 -04:00
if ( ! apply ) {
if ( quit_on_cancel ) {
exit ( 1 ) ;
} else {
return ret ;
}
}
2009-10-14 12:10:01 -04:00
2009-04-21 21:35:31 -04:00
/* if we run the startup dialog again, offer more than just "new session" */
2009-10-14 12:10:01 -04:00
2009-04-21 21:35:31 -04:00
should_be_new = false ;
2009-10-14 12:10:01 -04:00
2009-04-21 21:35:31 -04:00
session_name = _startup - > session_name ( likely_new ) ;
2009-10-14 12:10:01 -04:00
2009-04-21 21:35:31 -04:00
/* this shouldn't happen, but we catch it just in case it does */
2009-10-14 12:10:01 -04:00
2009-04-21 21:35:31 -04:00
if ( session_name . empty ( ) ) {
2010-09-14 11:45:21 -04:00
continue ;
2009-10-14 12:10:01 -04:00
}
2010-09-14 11:45:21 -04:00
2009-04-21 21:35:31 -04:00
if ( _startup - > use_session_template ( ) ) {
template_name = _startup - > session_template_name ( ) ;
_session_is_new = true ;
2009-10-14 12:10:01 -04:00
}
2006-08-30 22:28:42 -04:00
2010-09-14 11:45:21 -04:00
if ( session_name [ 0 ] = = G_DIR_SEPARATOR | |
( session_name . length ( ) > 2 & & session_name [ 0 ] = = ' . ' & & session_name [ 1 ] = = G_DIR_SEPARATOR ) | |
( session_name . length ( ) > 3 & & session_name [ 0 ] = = ' . ' & & session_name [ 1 ] = = ' . ' & & session_name [ 2 ] = = G_DIR_SEPARATOR ) ) {
2009-10-14 12:10:01 -04:00
2010-03-16 11:33:04 -04:00
/* absolute path or cwd-relative path specified for session name: infer session folder
from what was given .
*/
2009-04-21 21:35:31 -04:00
session_path = Glib : : path_get_dirname ( session_name ) ;
session_name = Glib : : path_get_basename ( session_name ) ;
2009-10-14 12:10:01 -04:00
2009-04-21 21:35:31 -04:00
} else {
2009-10-14 12:10:01 -04:00
2009-04-21 21:35:31 -04:00
session_path = _startup - > session_folder ( ) ;
2010-09-14 11:45:21 -04:00
if ( session_name . find ( ' / ' ) ! = string : : npos ) {
MessageDialog msg ( * _startup , _ ( " To ensure compatibility with various systems \n "
" session names may not contain a '/' character " ) ) ;
msg . run ( ) ;
ARDOUR_COMMAND_LINE : : session_name = " " ; // cancel that
continue ;
}
if ( session_name . find ( ' \\ ' ) ! = string : : npos ) {
MessageDialog msg ( * _startup , _ ( " To ensure compatibility with various systems \n "
" session names may not contain a ' \\ ' character " ) ) ;
msg . run ( ) ;
ARDOUR_COMMAND_LINE : : session_name = " " ; // cancel that
continue ;
}
2009-04-21 21:35:31 -04:00
}
}
if ( create_engine ( ) ) {
break ;
}
2009-10-14 12:10:01 -04: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
if ( likely_new ) {
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 ) {
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
2010-09-14 12:51:02 -04:00
if ( session_name . find ( ' / ' ) ! = std : : string : : npos ) {
2010-03-16 11:33:04 -04:00
MessageDialog msg ( * _startup , _ ( " To ensure compatibility with various systems \n "
" session names may not contain a '/' character " ) ) ;
msg . run ( ) ;
ARDOUR_COMMAND_LINE : : session_name = " " ; // cancel that
continue ;
}
2010-09-14 12:51:02 -04:00
if ( session_name . find ( ' \\ ' ) ! = std : : string : : npos ) {
2010-03-16 11:33:04 -04:00
MessageDialog msg ( * _startup , _ ( " To ensure compatibility with various systems \n "
" session names may not contain a ' \\ ' character " ) ) ;
msg . run ( ) ;
ARDOUR_COMMAND_LINE : : session_name = " " ; // cancel that
continue ;
}
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
2009-04-21 21:35:31 -04:00
ret = build_session_from_nsd ( session_path , session_name ) ;
} else {
ret = load_session ( session_path , session_name , template_name ) ;
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 ) ;
}
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 ) ) {
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
}
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 ;
2005-09-25 14:42:24 -04:00
session_loaded = false ;
2007-10-11 18:07:47 -04:00
2007-04-29 13:23:11 -04:00
if ( ! check_audioengine ( ) ) {
return - 1 ;
}
2007-10-11 18:07:47 -04:00
unload_status = unload_session ( ) ;
if ( unload_status < 0 ) {
goto out ;
} else if ( unload_status > 0 ) {
retval = 0 ;
goto out ;
}
2005-09-25 14:42:24 -04:00
2010-03-14 22:31:27 -04:00
loading_message ( string_compose ( _ ( " Please wait while %1loads your session " ) , PROGRAM_NAME ) ) ;
2007-10-11 18:07:47 -04:00
2005-09-25 14:42:24 -04:00
try {
2010-03-23 08:19:21 -04:00
new_session = new Session ( * engine , 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 ) ;
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
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
2008-01-10 16:20:59 -05:00
MessageDialog msg ( string_compose ( _ ( " Session \" %1 (snapshot %2) \" did not load successfully " ) , path , snap_name ) ,
true ,
Gtk : : MESSAGE_INFO ,
2008-12-12 09:43:24 -05:00
Gtk : : BUTTONS_CLOSE ) ;
2009-10-14 12:10:01 -04:00
2008-01-10 16:20:59 -05:00
msg . set_title ( _ ( " Loading Error " ) ) ;
2008-12-12 09:43:24 -05:00
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 ) ;
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
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 ;
}
2007-10-11 18:07:47 -04:00
goto out ;
2005-09-25 14:42:24 -04:00
}
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
}
2007-10-11 18:07:47 -04:00
flush_pending ( ) ;
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
2007-04-29 13:23:11 -04:00
if ( ! check_audioengine ( ) ) {
2007-10-11 18:07:47 -04:00
return - 1 ;
2007-04-29 13:23:11 -04:00
}
2005-09-25 14:42:24 -04:00
session_loaded = false ;
2007-04-29 13:23:11 -04:00
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 {
2010-03-23 08:19:21 -04:00
new_session = new Session ( * engine , 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 ) ) ;
2008-02-02 12:22:04 -05:00
pop_back_splash ( ) ;
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 */
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
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__
open_uri ( " http://webchat.freenode.net/?channels=ardour-osx " ) ;
# else
open_uri ( " http://webchat.freenode.net/?channels=ardour " ) ;
# endif
}
2005-09-25 14:42:24 -04:00
void
2008-01-18 22:49:52 -05:00
ARDOUR_UI : : show_about ( )
2005-09-25 14:42:24 -04:00
{
if ( about = = 0 ) {
2008-01-18 22:49:52 -05:00
about = new About ;
2009-12-11 18:29:48 -05:00
about - > signal_response ( ) . connect ( sigc : : mem_fun ( * this , & ARDOUR_UI : : about_signal_response ) ) ;
2005-09-25 14:42:24 -04:00
}
2008-01-18 22:49:52 -05:00
2010-03-16 11:33:04 -04:00
about - > set_transient_for ( * editor ) ;
2008-01-18 22:49:52 -05:00
about - > show_all ( ) ;
}
2010-08-16 22:48:24 -04:00
void
ARDOUR_UI : : launch_manual ( )
{
PBD : : open_uri ( " http://ardour.org/flossmanual " ) ;
}
void
ARDOUR_UI : : launch_reference ( )
{
PBD : : open_uri ( " http://ardour.org/refmanual " ) ;
}
2008-01-18 22:49:52 -05:00
void
ARDOUR_UI : : hide_about ( )
{
if ( about ) {
about - > get_window ( ) - > set_cursor ( ) ;
about - > hide ( ) ;
}
2006-11-19 11:45:16 -05:00
}
void
2009-07-21 11:55:17 -04:00
ARDOUR_UI : : about_signal_response ( int /*response*/ )
2006-11-19 11:45:16 -05:00
{
2008-01-18 22:49:52 -05:00
hide_about ( ) ;
}
void
ARDOUR_UI : : show_splash ( )
{
if ( splash = = 0 ) {
try {
splash = new Splash ;
} catch ( . . . ) {
return ;
}
}
splash - > show ( ) ;
2008-02-01 22:57:35 -05:00
splash - > present ( ) ;
2008-01-19 00:06:33 -05:00
splash - > queue_draw ( ) ;
2008-01-18 22:49:52 -05:00
splash - > get_window ( ) - > process_updates ( true ) ;
flush_pending ( ) ;
2005-09-25 14:42:24 -04:00
}
void
ARDOUR_UI : : hide_splash ( )
{
2008-01-18 22:49:52 -05:00
if ( splash ) {
splash - > hide ( ) ;
2005-09-25 14:42:24 -04:00
}
}
void
2009-10-30 11:30:22 -04:00
ARDOUR_UI : : display_cleanup_results ( ARDOUR : : CleanupReport & rep , const gchar * list_title ,
2009-07-20 23:23:57 -04:00
const string & plural_msg , const string & singular_msg )
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 ,
2009-10-14 12:10:01 -04:00
_ ( " No audio files were ready for cleanup " ) ,
2006-04-20 16:41:05 -04:00
true ,
2006-04-19 04:14:39 -04:00
Gtk : : MESSAGE_INFO ,
2006-11-19 11:45:16 -05:00
( Gtk : : ButtonsType ) ( Gtk : : BUTTONS_OK ) ) ;
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
2009-12-17 13:24:23 -05:00
const string dead_sound_directory = _session - > session_directory ( ) . dead_sound_path ( ) . to_string ( ) ;
2007-06-16 20:47:18 -04:00
2009-07-20 23:23:57 -04:00
/* subst:
% 1 - number of files removed
% 2 - location of " dead_sounds "
% 3 - size of files affected
% 4 - prefix for " bytes " to produce sensible results ( e . g . mega , kilo , giga )
*/
const char * bprefix ;
2010-03-16 11:33:04 -04:00
double space_adjusted = 0 ;
2009-07-20 23:23:57 -04:00
2010-03-16 11:33:04 -04:00
if ( rep . space < 100000.0f ) {
2009-07-20 23:23:57 -04:00
bprefix = X_ ( " kilo " ) ;
2010-03-16 11:33:04 -04:00
} else if ( rep . space < 1000000.0f * 1000 ) {
2009-07-20 23:23:57 -04:00
bprefix = X_ ( " mega " ) ;
2010-03-16 11:33:04 -04:00
space_adjusted = truncf ( ( float ) rep . space / 1000.0 ) ;
2005-09-25 14:42:24 -04:00
} else {
2009-07-20 23:23:57 -04:00
bprefix = X_ ( " giga " ) ;
2010-03-16 11:33:04 -04:00
space_adjusted = truncf ( ( float ) rep . space / ( 1000000.0 * 1000 ) ) ;
2009-07-20 23:23:57 -04:00
}
if ( removed > 1 ) {
2010-03-16 11:33:04 -04:00
txt . set_text ( string_compose ( plural_msg , removed , _session - > path ( ) + " dead_sounds " , space_adjusted , bprefix ) ) ;
2009-07-20 23:23:57 -04:00
} else {
2010-03-16 11:33:04 -04:00
txt . set_text ( string_compose ( singular_msg , removed , _session - > path ( ) + " dead_sounds " , space_adjusted , bprefix ) ) ;
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
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
MessageDialog checker ( _ ( " Are you sure you want to cleanup? " ) ,
2006-04-20 16:41:05 -04:00
true ,
2006-04-19 04:14:39 -04:00
Gtk : : MESSAGE_QUESTION ,
( Gtk : : ButtonsType ) ( Gtk : : BUTTONS_NONE ) ) ;
checker . set_secondary_text ( _ ( " Cleanup is a destructive operation. \n \
2005-09-25 14:42:24 -04:00
ALL undo / redo information will be lost if you cleanup . \ n \
2006-04-19 04:14:39 -04:00
After cleanup , unused audio files will be moved to a \
\ " dead sounds \" location. " ) ) ;
2009-10-14 12:10:01 -04:00
2005-11-27 16:17:41 -05:00
checker . add_button ( Stock : : CANCEL , RESPONSE_CANCEL ) ;
2006-04-19 04:14:39 -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 ( ) ;
2009-10-14 12:10:01 -04:00
display_cleanup_results ( rep ,
2005-09-25 14:42:24 -04:00
_ ( " cleaned files " ) ,
_ ( " \
2009-07-20 23:23:57 -04:00
The following % 1 files were not in use and \ n \
2006-04-20 16:41:05 -04:00
have been moved to : \ n \
2009-07-20 23:23:57 -04:00
% 2. \ n \ n \
Flushing the wastebasket will \ n \
release an additional \ n \
% 3 % 4 bytes of disk space . \ n " ),
_ ( " \
The following file was not in use and \ n \
has been moved to : \ n \
% 2. \ n \ n \
2006-04-20 16:41:05 -04:00
Flushing the wastebasket will \ n \
release an additional \ n \
2009-07-20 23:23:57 -04:00
% 3 % 4 bytes of disk space . \ n "
2005-09-25 14:42:24 -04:00
) ) ;
2007-03-18 02:07:08 -04:00
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 ;
}
2009-10-14 12:10:01 -04:00
display_cleanup_results ( rep ,
2005-09-25 14:42:24 -04:00
_ ( " deleted file " ) ,
2009-07-20 23:23:57 -04:00
_ ( " The following %1 files were deleted from \n \
% 2 , \ n \
releasing % 3 % 4 bytes of disk space " ),
_ ( " The following file was deleted from \n \
% 2 , \ n \
releasing % 3 % 4 bytes of disk space " ));
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 = = 0 ) {
2009-12-17 13:24:23 -05:00
add_route_dialog = new AddRouteDialog ( _session ) ;
2007-03-18 02:07:08 -04:00
if ( float_window ) {
add_route_dialog - > set_transient_for ( * float_window ) ;
}
2005-09-25 14:42:24 -04:00
}
if ( add_route_dialog - > is_visible ( ) ) {
/* we're already doing this */
return ;
}
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 ;
}
2009-03-02 13:08:15 -05:00
string template_path = add_route_dialog - > track_template ( ) ;
2009-10-14 12:10:01 -04:00
2009-03-02 13:08:15 -05:00
if ( ! template_path . empty ( ) ) {
2009-12-17 13:24:23 -05:00
_session - > new_route_from_template ( count , template_path ) ;
2009-03-02 13:08:15 -05:00
return ;
}
2005-09-25 14:42:24 -04:00
uint32_t input_chan = add_route_dialog - > channels ( ) ;
uint32_t output_chan ;
string name_template = add_route_dialog - > name_template ( ) ;
bool track = add_route_dialog - > track ( ) ;
2009-11-18 23:25:46 -05:00
bool aux = ! track & & add_route_dialog - > aux ( ) ;
2009-06-21 15:59:56 -04:00
RouteGroup * route_group = add_route_dialog - > route_group ( ) ;
2005-09-25 14:42:24 -04:00
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 ) {
2009-12-17 13:24:23 -05:00
output_chan = ( _session - > master_out ( ) ? _session - > master_out ( ) - > n_inputs ( ) . n_audio ( ) : input_chan ) ;
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
2006-08-24 03:37:17 -04:00
if ( add_route_dialog - > type ( ) = = ARDOUR : : DataType : : MIDI ) {
if ( track ) {
2009-06-21 15:59:56 -04:00
session_add_midi_track ( route_group , count ) ;
2006-08-24 03:37:17 -04:00
} else {
MessageDialog msg ( * editor ,
_ ( " Sorry, MIDI Busses are not supported at this time. " ) ) ;
msg . run ( ) ;
//session_add_midi_bus();
2005-09-25 14:42:24 -04:00
}
2009-10-14 12:10:01 -04:00
} else {
2006-08-24 03:37:17 -04:00
if ( track ) {
2009-06-21 15:59:56 -04:00
session_add_audio_track ( input_chan , output_chan , add_route_dialog - > mode ( ) , route_group , count ) ;
2006-08-24 03:37:17 -04:00
} else {
2009-11-18 23:25:46 -05:00
session_add_audio_bus ( aux , input_chan , output_chan , route_group , count ) ;
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
}
2010-08-29 07:15:40 -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 " ) ) ;
}
return node ;
}
void
2008-02-16 17:43:18 -05:00
ARDOUR_UI : : create_xrun_marker ( nframes_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 ( )
{
2006-03-05 14:39:16 -05:00
MessageDialog msg ( * editor ,
2005-09-25 14:42:24 -04:00
_ ( " 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
ARDOUR_UI : : xrun_handler ( nframes_t where )
{
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
}
}
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 ;
MessageDialog * msg = new MessageDialog ( * editor ,
2010-08-16 20:28:20 -04:00
string_compose ( _ ( " The disk system on your computer \n \
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 ( )
{
2007-10-26 11:31:46 -04:00
HBox * hbox = new HBox ( ) ;
Image * image = new Image ( Stock : : DIALOG_QUESTION , ICON_SIZE_DIALOG ) ;
2008-01-10 17:22:29 -05:00
ArdourDialog dialog ( _ ( " Crash Recovery " ) , true ) ;
2005-09-25 14:42:24 -04:00
Label message ( _ ( " \
This session appears to have been in \ n \
middle of recording when ardour or \ n \
the computer was shutdown . \ n \
\ n \
Ardour can recover any captured audio for \ n \
you , or it can ignore it . Please decide \ n \
what you would like to do . \ n " ));
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
ARDOUR_UI : : sr_mismatch_dialog ( nframes_t desired , nframes_t actual )
{
HBox * hbox = new HBox ( ) ;
Image * image = new Image ( Stock : : DIALOG_QUESTION , ICON_SIZE_DIALOG ) ;
ArdourDialog dialog ( _ ( " Sample Rate Mismatch " ) , true ) ;
Label message ( string_compose ( _ ( " \
This session was created with a sample rate of % 1 Hz \ n \
\ n \
The audioengine is currently running at % 2 Hz \ n " ), desired, actual));
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 ( ) ;
switch ( dialog . run ( ) ) {
case RESPONSE_ACCEPT :
return 0 ;
default :
return 1 ;
}
}
2009-10-14 12:10:01 -04:00
2005-09-25 14:42:24 -04:00
void
ARDOUR_UI : : disconnect_from_jack ( )
{
if ( engine ) {
if ( engine - > disconnect_from_jack ( ) ) {
2006-03-05 14:39:16 -05:00
MessageDialog msg ( * editor , _ ( " Could not disconnect from JACK " ) ) ;
msg . run ( ) ;
2005-09-25 14:42:24 -04:00
}
update_sample_rate ( 0 ) ;
}
}
void
ARDOUR_UI : : reconnect_to_jack ( )
{
if ( engine ) {
if ( engine - > reconnect_to_jack ( ) ) {
2006-03-05 14:39:16 -05:00
MessageDialog msg ( * editor , _ ( " Could not reconnect to JACK " ) ) ;
msg . run ( ) ;
2005-09-25 14:42:24 -04:00
}
update_sample_rate ( 0 ) ;
}
}
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
ARDOUR_UI : : update_transport_clocks ( nframes_t pos )
{
2007-05-13 22:48:28 -04:00
if ( Config - > get_primary_clock_delta_edit_cursor ( ) ) {
2007-11-12 17:23:01 -05:00
primary_clock . set ( pos , false , editor - > get_preferred_edit_position ( ) , 1 ) ;
2007-05-13 22:48:28 -04:00
} else {
primary_clock . set ( pos , 0 , true ) ;
}
if ( Config - > get_secondary_clock_delta_edit_cursor ( ) ) {
2007-11-12 17:23:01 -05:00
secondary_clock . set ( pos , false , editor - > get_preferred_edit_position ( ) , 2 ) ;
2007-05-13 22:48:28 -04:00
} else {
secondary_clock . set ( pos ) ;
}
2007-01-09 18:24:54 -05:00
2010-08-17 22:20:15 -04:00
if ( big_clock_window - > get ( ) ) {
2007-01-09 18:24:54 -05:00
big_clock . set ( pos ) ;
}
}
2010-07-24 12:40:56 -04:00
void
ARDOUR_UI : : step_edit_status_change ( bool yn )
{
// XXX should really store pre-step edit status of things
// we make insensitive
if ( yn ) {
rec_button . set_visual_state ( 3 ) ;
rec_button . set_sensitive ( false ) ;
} else {
rec_button . set_visual_state ( 0 ) ;
rec_button . set_sensitive ( true ) ;
}
}
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
2010-08-17 22:20:15 -04:00
if ( ! _session | | ! big_clock_window - > get ( ) ) {
2007-01-09 18:24:54 -05:00
/* why bother - the clock isn't visible */
return ;
}
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 : : Recording & & h ) {
2007-01-11 14:50:49 -05:00
big_clock . set_widget_name ( " BigClockRecording " ) ;
2009-10-22 13:33:36 -04:00
} else {
2007-01-11 14:50:49 -05:00
big_clock . set_widget_name ( " BigClockNonRecording " ) ;
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 ) {
node - > add_property ( ( * x ) - > name ( ) . c_str ( ) , enum_2_string ( ( * x ) - > mode ( ) ) ) ;
}
2009-12-17 13:24:23 -05:00
_session - > add_extra_xml ( * node ) ;
_session - > set_dirty ( ) ;
2007-01-09 18:24:54 -05:00
}
2009-10-14 12:10:01 -04: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
{
if ( type = = ShuttleControl ) {
double fract ;
2010-07-27 10:09:16 -04:00
if ( val = = 0.5 ) {
2007-03-18 02:07:08 -04:00
fract = 0.0 ;
} else {
2010-07-27 10:09:16 -04:00
if ( val < 0.5 ) {
fract = - ( ( 0.5 - val ) / 0.5 ) ;
2007-03-18 02:07:08 -04:00
} else {
2010-07-27 10:09:16 -04:00
fract = ( ( val - 0.5 ) / 0.5 ) ;
2007-03-18 02:07:08 -04:00
}
}
2009-10-14 12:10:01 -04:00
2007-03-18 02:07:08 -04:00
ui . set_shuttle_fract ( fract ) ;
return ;
}
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 :
action = X_ ( " Goto Start " ) ;
break ;
case GotoEnd :
action = X_ ( " Goto End " ) ;
break ;
case AutoLoop :
action = X_ ( " Loop " ) ;
break ;
case PlaySelection :
action = X_ ( " Play Selection " ) ;
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 ;
case ShuttleControl :
break ;
default :
break ;
}
return val ;
}
void
ARDOUR_UI : : TransportControllable : : set_id ( const string & str )
{
_id = str ;
}
2007-04-12 19:20:37 -04:00
void
ARDOUR_UI : : setup_profile ( )
{
if ( gdk_screen_width ( ) < 1200 ) {
Profile - > set_small_screen ( ) ;
}
2007-10-11 18:07:47 -04:00
if ( getenv ( " ARDOUR_SAE " ) ) {
Profile - > set_sae ( ) ;
Profile - > set_single_package ( ) ;
}
2007-04-12 19:20:37 -04:00
}
2007-05-14 10:13:59 -04:00
2010-08-16 20:28:20 -04:00
void
ARDOUR_UI : : toggle_translations ( )
{
using namespace Glib ;
RefPtr < Action > act = ActionManager : : get_action ( X_ ( " Main " ) , X_ ( " EnableTranslation " ) ) ;
if ( act ) {
RefPtr < ToggleAction > ract = RefPtr < ToggleAction > : : cast_dynamic ( act ) ;
if ( ract ) {
string i18n_killer = ARDOUR : : translation_kill_path ( ) ;
bool already_enabled = ! ARDOUR : : translations_are_disabled ( ) ;
if ( ract - > get_active ( ) ) {
/* we don't care about errors */
int fd = : : open ( i18n_killer . c_str ( ) , O_RDONLY | O_CREAT , 0644 ) ;
close ( fd ) ;
} else {
/* we don't care about errors */
unlink ( i18n_killer . c_str ( ) ) ;
}
if ( already_enabled ! = ract - > get_active ( ) ) {
MessageDialog win ( already_enabled ? _ ( " Translations disabled " ) : _ ( " Translations enabled " ) ,
false ,
Gtk : : MESSAGE_WARNING ,
Gtk : : BUTTONS_OK ) ;
win . set_secondary_text ( string_compose ( _ ( " You must restart %1 for this to take effect. " ) , PROGRAM_NAME ) ) ;
win . set_position ( Gtk : : WIN_POS_CENTER ) ;
win . present ( ) ;
win . run ( ) ;
}
}
}
}
2010-08-17 22:20:15 -04:00
/** Add a window proxy to our list, so that its state will be saved.
* This call also causes the window to be created and opened if its
* state was saved as ` visible ' .
*/
void
ARDOUR_UI : : add_window_proxy ( WindowProxyBase * p )
{
_window_proxies . push_back ( p ) ;
p - > maybe_show ( ) ;
}
/** Remove a window proxy from our list. Must be called if a WindowProxy
* is deleted , to prevent hanging pointers .
*/
void
ARDOUR_UI : : remove_window_proxy ( WindowProxyBase * p )
{
_window_proxies . remove ( p ) ;
}