764 lines
21 KiB
C++
764 lines
21 KiB
C++
/*
|
|
* Copyright (C) 2019 Paul Davis <paul@linuxaudiosystems.com>
|
|
*
|
|
* 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.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include <vector>
|
|
|
|
#include <gtkmm/dialog.h>
|
|
#include <gtkmm/liststore.h>
|
|
#include <gtkmm/messagedialog.h>
|
|
#include <gtkmm/stock.h>
|
|
|
|
#include "pbd/basename.h"
|
|
#include "pbd/file_archive.h"
|
|
#include "pbd/file_utils.h"
|
|
#include "pbd/i18n.h"
|
|
|
|
#include "ardour/audioengine.h"
|
|
#include "ardour/filename_extensions.h"
|
|
#include "ardour/filesystem_paths.h"
|
|
#include "ardour/profile.h"
|
|
#include "ardour/recent_sessions.h"
|
|
#include "ardour/rc_configuration.h"
|
|
#include "ardour/search_paths.h"
|
|
#include "ardour/session.h"
|
|
#include "ardour/session_utils.h"
|
|
#include "ardour/template_utils.h"
|
|
|
|
#include "gtkmm2ext/application.h"
|
|
#include <gtkmm2ext/doi.h>
|
|
|
|
#include "engine_dialog.h"
|
|
#include "new_user_wizard.h"
|
|
#include "opts.h"
|
|
#include "session_dialog.h"
|
|
#include "startup_fsm.h"
|
|
|
|
#ifdef WAF_BUILD
|
|
#include "gtk2ardour-version.h"
|
|
#endif
|
|
|
|
using namespace ARDOUR;
|
|
using namespace Gtk;
|
|
using namespace Gtkmm2ext;
|
|
using namespace PBD;
|
|
|
|
using std::string;
|
|
using std::vector;
|
|
|
|
StartupFSM::StartupFSM (EngineControl& amd)
|
|
: session_existing_sample_rate (0)
|
|
, session_is_new (false)
|
|
, new_user (NewUserWizard::required())
|
|
, new_session (true)
|
|
, _state (new_user ? NeedWizard : NeedSessionPath)
|
|
, new_user_wizard (0)
|
|
, audiomidi_dialog (amd)
|
|
, session_dialog (0)
|
|
, pre_release_dialog (0)
|
|
{
|
|
if (string (VERSIONSTRING).find (".pre") != string::npos) {
|
|
string fn = Glib::build_filename (user_config_directory(), ".i_swear_that_i_will_heed_the_guidelines_stated_in_the_pre_release_dialog");
|
|
if (!Glib::file_test (fn, Glib::FILE_TEST_EXISTS)) {
|
|
_state = NeedPreRelease;
|
|
}
|
|
}
|
|
|
|
Application* app = Application::instance ();
|
|
|
|
app->ShouldQuit.connect (sigc::mem_fun (*this, &StartupFSM::queue_finish));
|
|
app->ShouldLoad.connect (sigc::mem_fun (*this, &StartupFSM::load_from_application_api));
|
|
|
|
/* this may cause the delivery of ShouldLoad etc if we were invoked in
|
|
* particular ways. It will happen when the event loop runs again.
|
|
*/
|
|
|
|
app->ready ();
|
|
}
|
|
|
|
StartupFSM::~StartupFSM ()
|
|
{
|
|
delete session_dialog;
|
|
}
|
|
|
|
void
|
|
StartupFSM::queue_finish ()
|
|
{
|
|
_signal_response (ExitProgram);
|
|
}
|
|
|
|
void
|
|
StartupFSM::start ()
|
|
{
|
|
if (_state == NeedPreRelease) {
|
|
show_pre_release_dialog ();
|
|
} else if (new_user) {
|
|
show_new_user_wizard ();
|
|
} else {
|
|
/* pretend we just showed the new user wizard and we're done
|
|
with it
|
|
*/
|
|
dialog_response_handler (RESPONSE_OK, NewUserDialog);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
StartupFSM::end()
|
|
{
|
|
|
|
}
|
|
|
|
void
|
|
StartupFSM::dialog_response_handler (int response, StartupFSM::DialogID dialog_id)
|
|
{
|
|
const bool new_session_required = (ARDOUR_COMMAND_LINE::new_session || (!ARDOUR::Profile->get_mixbus() && new_user));
|
|
|
|
restart:
|
|
|
|
switch (_state) {
|
|
case NeedPreRelease:
|
|
switch (dialog_id) {
|
|
case PreReleaseDialog:
|
|
default:
|
|
/* any response value from the pre-release dialog means
|
|
"move along now"
|
|
*/
|
|
delete_when_idle (pre_release_dialog);
|
|
pre_release_dialog = 0;
|
|
_state = NeedSessionPath;
|
|
if (NewUserWizard::required()) {
|
|
show_new_user_wizard ();
|
|
} else {
|
|
/* act as if we had just finished with the new
|
|
user wizard. goto preferred over reentrancy.
|
|
*/
|
|
dialog_id = NewUserDialog;
|
|
response = RESPONSE_OK;
|
|
goto restart;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case NeedSessionPath:
|
|
switch (dialog_id) {
|
|
case NewUserDialog:
|
|
|
|
current_dialog_connection.disconnect ();
|
|
delete_when_idle (new_user_wizard);
|
|
|
|
switch (response) {
|
|
case RESPONSE_OK:
|
|
break;
|
|
default:
|
|
exit (1);
|
|
}
|
|
|
|
/* new user wizard done, now lets get session params
|
|
* either from the command line (if given) or a dialog
|
|
* (if nothing given on the command line or if the
|
|
* command line arguments don't work for some reason
|
|
*/
|
|
|
|
if (ARDOUR_COMMAND_LINE::session_name.empty()) {
|
|
|
|
/* nothing given on the command line ... show new session dialog */
|
|
|
|
session_path = string();
|
|
session_name = string();
|
|
session_template = string();
|
|
|
|
_state = NeedSessionPath;
|
|
show_session_dialog (new_session_required);
|
|
|
|
} else {
|
|
|
|
if (get_session_parameters_from_command_line (new_session_required)) {
|
|
|
|
/* command line arguments all OK. Get engine parameters */
|
|
|
|
_state = NeedEngineParams;
|
|
|
|
if (!new_session_required && session_existing_sample_rate > 0) {
|
|
audiomidi_dialog.set_desired_sample_rate (session_existing_sample_rate);
|
|
}
|
|
|
|
show_audiomidi_dialog ();
|
|
|
|
} else {
|
|
|
|
/* command line arguments not good. Use
|
|
* dialog, but prime the dialog with
|
|
* the information we set up in
|
|
* get_session_parameters_from_command_line()
|
|
*/
|
|
|
|
_state = NeedSessionPath;
|
|
show_session_dialog (new_session_required);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NewSessionDialog:
|
|
switch (response) {
|
|
case RESPONSE_OK:
|
|
case RESPONSE_ACCEPT:
|
|
switch (check_session_parameters (new_session_required)) {
|
|
case -1:
|
|
/* Unrecoverable error */
|
|
_signal_response (ExitProgram);
|
|
break;
|
|
case 1:
|
|
/* do nothing - keep dialog up for a
|
|
* retry. Errors were addressed by
|
|
* ::check_session_parameters()
|
|
*/
|
|
break;
|
|
case 0:
|
|
_state = NeedEngineParams;
|
|
session_dialog->hide ();
|
|
delete session_dialog;
|
|
session_dialog = 0;
|
|
current_dialog_connection.disconnect();
|
|
if (!session_is_new && session_existing_sample_rate > 0) {
|
|
audiomidi_dialog.set_desired_sample_rate (session_existing_sample_rate);
|
|
}
|
|
show_audiomidi_dialog ();
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
_signal_response (ExitProgram);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
/* ERROR */
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case NeedEngineParams:
|
|
switch (dialog_id) {
|
|
case AudioMIDISetup:
|
|
switch (response) {
|
|
case RESPONSE_OK:
|
|
case RESPONSE_ACCEPT:
|
|
if (AudioEngine::instance()->running()) {
|
|
audiomidi_dialog.hide ();
|
|
current_dialog_connection.disconnect();
|
|
_signal_response (LoadSession);
|
|
} else {
|
|
/* just keep going */
|
|
}
|
|
break;
|
|
default:
|
|
_signal_response (ExitProgram);
|
|
}
|
|
break;
|
|
default:
|
|
/* ERROR */
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case NeedWizard:
|
|
show_new_user_wizard ();
|
|
_state = NeedSessionPath;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
StartupFSM::show_new_user_wizard ()
|
|
{
|
|
new_user_wizard = new NewUserWizard;
|
|
current_dialog_connection = new_user_wizard->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &StartupFSM::dialog_response_handler), NewUserDialog));
|
|
new_user_wizard->set_position (WIN_POS_CENTER);
|
|
new_user_wizard->present ();
|
|
}
|
|
|
|
void
|
|
StartupFSM::show_session_dialog (bool new_session_required)
|
|
{
|
|
session_dialog = new SessionDialog (new_session_required, session_name, session_path, session_template, false);
|
|
current_dialog_connection = session_dialog->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &StartupFSM::dialog_response_handler), NewSessionDialog));
|
|
session_dialog->set_position (WIN_POS_CENTER);
|
|
session_dialog->present ();
|
|
}
|
|
|
|
void
|
|
StartupFSM::show_audiomidi_dialog ()
|
|
{
|
|
current_dialog_connection = audiomidi_dialog.signal_response().connect (sigc::bind (sigc::mem_fun (*this, &StartupFSM::dialog_response_handler), AudioMIDISetup));
|
|
audiomidi_dialog.set_position (WIN_POS_CENTER);
|
|
audiomidi_dialog.present ();
|
|
}
|
|
|
|
bool
|
|
StartupFSM::get_session_parameters_from_command_line (bool new_session_required)
|
|
{
|
|
return get_session_parameters_from_path (ARDOUR_COMMAND_LINE::session_name, ARDOUR_COMMAND_LINE::load_template, new_session_required);
|
|
}
|
|
|
|
bool
|
|
StartupFSM::get_session_parameters_from_path (string const & path, string const & template_name, bool new_session_required)
|
|
{
|
|
if (path.empty()) {
|
|
/* use GUI to ask the user */
|
|
return false;
|
|
}
|
|
|
|
if (Glib::file_test (path.c_str(), Glib::FILE_TEST_EXISTS)) {
|
|
|
|
session_is_new = false;
|
|
|
|
if (new_session_required) {
|
|
/* wait! it already exists */
|
|
|
|
if (!ask_about_loading_existing_session (path)) {
|
|
return false;
|
|
} else {
|
|
/* load it anyway */
|
|
}
|
|
}
|
|
|
|
session_name = basename_nosuffix (path);
|
|
|
|
if (Glib::file_test (path.c_str(), Glib::FILE_TEST_IS_REGULAR)) {
|
|
/* session/snapshot file, change path to be dir */
|
|
session_path = Glib::path_get_dirname (path);
|
|
} else {
|
|
session_path = path;
|
|
}
|
|
|
|
float sr;
|
|
SampleFormat fmt;
|
|
string program_version;
|
|
|
|
const string statefile_path = Glib::build_filename (session_path, session_name + ARDOUR::statefile_suffix);
|
|
if (Session::get_info_from_path (statefile_path, sr, fmt, program_version)) {
|
|
/* exists but we can't read it correctly */
|
|
error << string_compose (_("Cannot get existing session information from %1"), statefile_path) << endmsg;
|
|
return false;
|
|
}
|
|
|
|
session_existing_sample_rate = sr;
|
|
return true;
|
|
|
|
}
|
|
|
|
/* Everything after this involves a new session
|
|
*
|
|
* ... did the user give us a path or just a name?
|
|
*/
|
|
|
|
if (path.find (G_DIR_SEPARATOR) == string::npos) {
|
|
/* user gave session name with no path info, use
|
|
default session folder.
|
|
*/
|
|
session_name = ARDOUR_COMMAND_LINE::session_name;
|
|
session_path = Glib::build_filename (Config->get_default_session_parent_dir (), session_name);
|
|
} else {
|
|
session_name = basename_nosuffix (path);
|
|
session_path = path;
|
|
}
|
|
|
|
|
|
if (!template_name.empty()) {
|
|
|
|
/* Allow the user to specify a template via path or name on the
|
|
* command line
|
|
*/
|
|
|
|
bool have_resolved_template_name = false;
|
|
|
|
/* compare by name (path may or may not be UTF-8) */
|
|
|
|
vector<TemplateInfo> templates;
|
|
find_session_templates (templates, false);
|
|
for (vector<TemplateInfo>::iterator x = templates.begin(); x != templates.end(); ++x) {
|
|
if ((*x).name == template_name) {
|
|
session_template = (*x).path;
|
|
have_resolved_template_name = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* look up script by name */
|
|
LuaScriptList scripts (LuaScripting::instance ().scripts (LuaScriptInfo::SessionInit));
|
|
LuaScriptList& as (LuaScripting::instance ().scripts (LuaScriptInfo::EditorAction));
|
|
for (LuaScriptList::const_iterator s = as.begin(); s != as.end(); ++s) {
|
|
if ((*s)->subtype & LuaScriptInfo::SessionSetup) {
|
|
scripts.push_back (*s);
|
|
}
|
|
}
|
|
std::sort (scripts.begin(), scripts.end(), LuaScripting::Sorter());
|
|
for (LuaScriptList::const_iterator s = scripts.begin(); s != scripts.end(); ++s) {
|
|
if ((*s)->name == template_name) {
|
|
session_template = "urn:ardour:" + (*s)->path;
|
|
have_resolved_template_name = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!have_resolved_template_name) {
|
|
/* this will produce a more or less meaninful error later:
|
|
* "ERROR: Could not open session template [abs-path to user-config dir]"
|
|
*/
|
|
session_template = Glib::build_filename (ARDOUR::user_template_directory (), template_name);
|
|
}
|
|
}
|
|
|
|
/* We don't know what this is, because the session is new and the
|
|
* command line doesn't let us specify it. The user will get to decide
|
|
* in the audio/MIDI dialog.
|
|
*/
|
|
|
|
session_existing_sample_rate = 0;
|
|
session_is_new = true;
|
|
|
|
/* this is an arbitrary default value but since the user insists on
|
|
* starting a new session from the command line, it will do as well as
|
|
* any other possible value. I mean, seriously, what else could it be
|
|
* by default?
|
|
*/
|
|
|
|
bus_profile.master_out_channels = 2;
|
|
|
|
return true;
|
|
}
|
|
|
|
/** return values:
|
|
* -1: failure
|
|
* 1: failure but user can retry
|
|
* 0: success, seesion parameters ready for use
|
|
*/
|
|
int
|
|
StartupFSM::check_session_parameters (bool must_be_new)
|
|
{
|
|
bool requested_new = false;
|
|
|
|
session_name = session_dialog->session_name (requested_new);
|
|
session_path = session_dialog->session_folder ();
|
|
|
|
if (must_be_new) {
|
|
assert (requested_new);
|
|
}
|
|
|
|
if (!must_be_new) {
|
|
|
|
/* See if the specified session is a session archive */
|
|
|
|
int rv = ARDOUR::inflate_session (session_name, Config->get_default_session_parent_dir(), session_path, session_name);
|
|
if (rv < 0) {
|
|
MessageDialog msg (*session_dialog, string_compose (_("Extracting session-archive failed: %1"), inflate_error (rv)));
|
|
msg.run ();
|
|
|
|
return 1;
|
|
} else if (rv == 0) {
|
|
/* names are good (and session is unarchived/inflated */
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* check for ".ardour" in statefile name, because we don't want
|
|
* it
|
|
*
|
|
* XXX Note this wierd conflation of a
|
|
* file-name-without-a-suffix and the session name. It's not
|
|
* really a session name at all, but rather the suffix-free
|
|
* name of a statefile (snapshot).
|
|
*/
|
|
|
|
const string::size_type suffix_at = session_name.find (statefile_suffix);
|
|
|
|
if (suffix_at != string::npos) {
|
|
session_name = session_name.substr (0, suffix_at);
|
|
}
|
|
|
|
/* this shouldn't happen, but we catch it just in case it does */
|
|
|
|
if (session_name.empty()) {
|
|
return 1; /* keep running dialog */
|
|
}
|
|
|
|
if (session_dialog->use_session_template()) {
|
|
session_template = session_dialog->session_template_name();
|
|
}
|
|
|
|
if (session_name[0] == G_DIR_SEPARATOR ||
|
|
#ifdef PLATFORM_WINDOWS
|
|
// Windows file system .. detect absolute path
|
|
// C:/*
|
|
(session_name.length() > 3 && session_name[1] == ':' && session_name[2] == G_DIR_SEPARATOR)
|
|
#else
|
|
// Sensible file systems
|
|
// /* or ./* or ../*
|
|
(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)
|
|
#endif
|
|
)
|
|
{
|
|
|
|
/* user typed absolute path or cwd-relative path
|
|
specified into session name field. So ... infer
|
|
session path and name from what was given.
|
|
*/
|
|
|
|
session_path = Glib::path_get_dirname (session_name);
|
|
session_name = Glib::path_get_basename (session_name);
|
|
|
|
} else {
|
|
|
|
/* session name is just a name */
|
|
}
|
|
|
|
/* check if name is legal */
|
|
|
|
const char illegal = Session::session_name_is_legal (session_name);
|
|
|
|
if (illegal) {
|
|
MessageDialog msg (*session_dialog,
|
|
string_compose (_("To ensure compatibility with various systems\n"
|
|
"session names may not contain a '%1' character"),
|
|
illegal));
|
|
msg.run ();
|
|
ARDOUR_COMMAND_LINE::session_name = ""; // cancel that
|
|
return 1; /* keep running dialog */
|
|
}
|
|
|
|
|
|
/* check if the currently-exists status matches whether or not
|
|
* it should be new
|
|
*/
|
|
|
|
if (Glib::file_test (session_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) {
|
|
|
|
if (requested_new /*&& !nsm*/) {
|
|
|
|
std::string existing = Glib::build_filename (session_path, session_name);
|
|
|
|
if (!ask_about_loading_existing_session (existing)) {
|
|
session_dialog->clear_name ();
|
|
return 1; /* try again */
|
|
}
|
|
}
|
|
|
|
session_is_new = false;
|
|
|
|
} else {
|
|
|
|
/* does not exist at present */
|
|
|
|
if (!requested_new) {
|
|
// pop_back_splash (session_dialog);
|
|
MessageDialog msg (string_compose (_("There is no existing session at \"%1\""), session_path));
|
|
msg.run ();
|
|
session_dialog->clear_name();
|
|
return 1;
|
|
}
|
|
|
|
session_is_new = true;
|
|
}
|
|
|
|
float sr;
|
|
SampleFormat fmt;
|
|
string program_version;
|
|
const string statefile_path = Glib::build_filename (session_path, session_name + ARDOUR::statefile_suffix);
|
|
|
|
if (!session_is_new) {
|
|
|
|
if (Session::get_info_from_path (statefile_path, sr, fmt, program_version)) {
|
|
/* exists but we can't read it */
|
|
return -1;
|
|
}
|
|
|
|
session_existing_sample_rate = sr;
|
|
|
|
} else {
|
|
|
|
bus_profile.master_out_channels = session_dialog->master_channel_count ();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
StartupFSM::copy_demo_sessions ()
|
|
{
|
|
// TODO: maybe IFF brand_new_user
|
|
if (ARDOUR::Profile->get_mixbus () && Config->get_copy_demo_sessions ()) {
|
|
std::string dspd (Config->get_default_session_parent_dir());
|
|
Searchpath ds (ARDOUR::ardour_data_search_path());
|
|
ds.add_subdirectory_to_paths ("sessions");
|
|
vector<string> demos;
|
|
find_files_matching_pattern (demos, ds, ARDOUR::session_archive_suffix);
|
|
|
|
ARDOUR::RecentSessions rs;
|
|
ARDOUR::read_recent_sessions (rs);
|
|
|
|
for (vector<string>::iterator i = demos.begin(); i != demos.end (); ++i) {
|
|
/* "demo-session" must be inside "demo-session.<session_archive_suffix>" */
|
|
std::string name = basename_nosuffix (basename_nosuffix (*i));
|
|
std::string path = Glib::build_filename (dspd, name);
|
|
/* skip if session-dir already exists */
|
|
if (Glib::file_test(path.c_str(), Glib::FILE_TEST_IS_DIR)) {
|
|
continue;
|
|
}
|
|
/* skip sessions that are already in 'recent'.
|
|
* eg. a new user changed <session-default-dir> shorly after installation
|
|
*/
|
|
for (ARDOUR::RecentSessions::iterator r = rs.begin(); r != rs.end(); ++r) {
|
|
if ((*r).first == name) {
|
|
continue;
|
|
}
|
|
}
|
|
try {
|
|
PBD::FileArchive ar (*i);
|
|
if (0 == ar.inflate (dspd)) {
|
|
store_recent_sessions (name, path);
|
|
info << string_compose (_("Copied Demo Session %1."), name) << endmsg;
|
|
}
|
|
} catch (...) {
|
|
/* relax ? */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
StartupFSM::load_from_application_api (const std::string& path)
|
|
{
|
|
/* macOS El Capitan (and probably later) now somehow passes the command
|
|
line arguments to an app via the openFile delegate protocol. Ardour
|
|
already does its own command line processing, and having both
|
|
pathways active causes crashes. So, if the command line was already
|
|
set, do nothing here.
|
|
*/
|
|
|
|
if (!ARDOUR_COMMAND_LINE::session_name.empty()) {
|
|
return;
|
|
}
|
|
|
|
/* Cancel SessionDialog if it's visible to make macOS delegates work.
|
|
*
|
|
* there's a race condition here: we connect to app->ShouldLoad
|
|
* and then at some point (might) show a session dialog. The race is
|
|
* caused by the non-deterministic interaction between the macOS event
|
|
* loop(s) and the GDK one(s).
|
|
*
|
|
* - ShouldLoad does not arrive before we show the session dialog
|
|
* -> here we should hide the session dialog, then use the
|
|
* supplied path as if it was provided on the command line
|
|
* - ShouldLoad signal arrives before we show a session dialog
|
|
* -> don't bother showing the session dialog, just use the
|
|
* supplied path as if it was provided on the command line
|
|
*
|
|
*/
|
|
|
|
if (session_dialog) {
|
|
session_dialog->hide ();
|
|
delete_when_idle (session_dialog);
|
|
session_dialog = 0;
|
|
}
|
|
|
|
/* no command line argument given ... must just be via
|
|
* desktop/finder/window manager API (e.g. double click on "foo.ardour"
|
|
* icon)
|
|
*/
|
|
|
|
if (get_session_parameters_from_path (path, string(), false)) {
|
|
_signal_response (LoadSession);
|
|
return;
|
|
}
|
|
|
|
/* given parameters failed for some reason. This is probably true
|
|
* anyway, but force it to be true and then carry on with whatever the
|
|
* main event loop is doing.
|
|
*/
|
|
|
|
_state = NeedSessionPath;
|
|
}
|
|
|
|
bool
|
|
StartupFSM::ask_about_loading_existing_session (const std::string& session_path)
|
|
{
|
|
std::string str = string_compose (_("This session\n%1\nalready exists. Do you want to open it?"), session_path);
|
|
|
|
MessageDialog msg (str,
|
|
false,
|
|
Gtk::MESSAGE_WARNING,
|
|
Gtk::BUTTONS_YES_NO,
|
|
true);
|
|
|
|
|
|
msg.set_name (X_("OpenExistingDialog"));
|
|
msg.set_title (_("Open Existing Session"));
|
|
msg.set_wmclass (X_("existing_session"), PROGRAM_NAME);
|
|
msg.set_position (Gtk::WIN_POS_CENTER);
|
|
// pop_back_splash (msg);
|
|
|
|
switch (msg.run()) {
|
|
case RESPONSE_YES:
|
|
return true;
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
StartupFSM::show_pre_release_dialog ()
|
|
{
|
|
pre_release_dialog = new ArdourDialog (_("Pre-Release Warning"), true, false);
|
|
pre_release_dialog->add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
|
|
|
|
Label* label = manage (new Label);
|
|
label->set_markup (string_compose (_("<span size=\"x-large\" weight=\"bold\">Welcome to this pre-release build of %1 %2</span>\n\n\
|
|
<span size=\"large\">There are still several issues and bugs to be worked on,\n\
|
|
as well as general workflow improvements, before this can be considered\n\
|
|
release software. So, a few guidelines:\n\
|
|
\n\
|
|
1) Please do <b>NOT</b> use this software with the expectation that it is stable or reliable\n\
|
|
though it may be so, depending on your workflow.\n\
|
|
2) Please wait for a helpful writeup of new features.\n\
|
|
3) <b>Please do NOT use the forums at ardour.org to report issues</b>.\n\
|
|
4) <b>Please do NOT file bugs for this alpha-development versions at this point in time</b>.\n\
|
|
There is no bug triaging before the initial development concludes and\n\
|
|
reporting issue for incomplete, ongoing work-in-progress is mostly useless.\n\
|
|
5) Please <b>DO</b> join us on IRC for real time discussions about %1 %2. You\n\
|
|
can get there directly from within the program via the Help->Chat menu option.\n\
|
|
6) Please <b>DO</b> submit patches for issues after discussing them on IRC.\n\
|
|
\n\
|
|
Full information on all the above can be found on the support page at\n\
|
|
\n\
|
|
http://ardour.org/support</span>\n\
|
|
"), PROGRAM_NAME, VERSIONSTRING));
|
|
|
|
|
|
pre_release_dialog->signal_response().connect (sigc::bind (sigc::mem_fun (this, &StartupFSM::dialog_response_handler), PreReleaseDialog));
|
|
|
|
pre_release_dialog->get_vbox()->set_border_width (12);
|
|
pre_release_dialog->get_vbox()->pack_start (*label, false, false, 12);
|
|
pre_release_dialog->get_vbox()->show_all ();
|
|
pre_release_dialog->set_position (WIN_POS_CENTER);
|
|
pre_release_dialog->present ();
|
|
}
|