2005-10-27 15:46:27 -04:00
|
|
|
/*
|
2019-08-02 17:26:43 -04:00
|
|
|
* Copyright (C) 2005-2006 Taybin Rutkin <taybin@taybin.com>
|
|
|
|
* Copyright (C) 2006-2014 David Robillard <d@drobilla.net>
|
|
|
|
* Copyright (C) 2006-2018 Paul Davis <paul@linuxaudiosystems.com>
|
|
|
|
* Copyright (C) 2006 Doug McLain <doug@nostar.net>
|
|
|
|
* Copyright (C) 2006 Nick Mainsbridge <mainsbridge@gmail.com>
|
|
|
|
* Copyright (C) 2007-2012 Carl Hetherington <carl@carlh.net>
|
|
|
|
* Copyright (C) 2012-2017 Tim Mayberry <mojofunk@gmail.com>
|
|
|
|
* Copyright (C) 2012-2019 Robin Gareus <robin@gareus.org>
|
|
|
|
* Copyright (C) 2013-2015 John Emmas <john@creativepost.co.uk>
|
|
|
|
* Copyright (C) 2013 Colin Fletcher <colin.m.fletcher@googlemail.com>
|
|
|
|
* Copyright (C) 2019-2018 Ben Loftis <ben@harrisonconsoles.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.
|
|
|
|
*/
|
2005-10-27 15:46:27 -04:00
|
|
|
|
2010-11-13 00:14:48 -05:00
|
|
|
#ifdef WAF_BUILD
|
|
|
|
#include "gtk2ardour-config.h"
|
|
|
|
#endif
|
|
|
|
|
2019-06-12 15:34:39 -04:00
|
|
|
#ifdef PLATFORM_WINDOWS
|
|
|
|
#include <windows.h>
|
|
|
|
#endif
|
|
|
|
|
2006-01-11 16:27:59 -05:00
|
|
|
#include <map>
|
2006-01-13 14:48:55 -05:00
|
|
|
#include <cerrno>
|
2007-01-09 18:24:54 -05:00
|
|
|
#include <sstream>
|
2006-01-11 16:27:59 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
#include <unistd.h>
|
2013-10-04 12:46:31 -04:00
|
|
|
#include <limits.h>
|
2007-01-11 14:50:49 -05:00
|
|
|
|
2020-03-15 15:19:13 -04:00
|
|
|
#include <glib.h>
|
|
|
|
#include "pbd/gstdio_compat.h"
|
|
|
|
#include <glibmm/fileutils.h>
|
|
|
|
|
2005-10-12 23:48:57 -04:00
|
|
|
#include <gtkmm/box.h>
|
2017-07-16 21:48:18 -04:00
|
|
|
#include <gtkmm/scrolledwindow.h>
|
2005-10-12 23:48:57 -04:00
|
|
|
#include <gtkmm/stock.h>
|
2013-07-15 14:29:00 -04:00
|
|
|
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
#include "ardour/debug.h"
|
|
|
|
|
|
|
|
#include "pbd/convert.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/tokenizer.h"
|
|
|
|
#include "pbd/enumwriter.h"
|
2019-08-12 10:42:07 -04:00
|
|
|
#include "pbd/file_utils.h"
|
2022-09-12 18:50:49 -04:00
|
|
|
#include "pbd/natsort.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/pthread_utils.h"
|
2016-12-07 00:48:23 -05:00
|
|
|
#include "pbd/string_convert.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/xml++.h"
|
2006-03-22 12:03:00 -05:00
|
|
|
|
|
|
|
#include <gtkmm2ext/utils.h>
|
|
|
|
|
2019-10-25 15:13:51 -04:00
|
|
|
#include "evoral/SMF.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
|
|
|
|
#include "ardour/audio_library.h"
|
|
|
|
#include "ardour/auditioner.h"
|
|
|
|
#include "ardour/audioregion.h"
|
|
|
|
#include "ardour/audiofilesource.h"
|
2014-11-30 19:57:15 -05:00
|
|
|
#include "ardour/midi_region.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/smf_source.h"
|
|
|
|
#include "ardour/region_factory.h"
|
|
|
|
#include "ardour/source_factory.h"
|
|
|
|
#include "ardour/session.h"
|
|
|
|
#include "ardour/session_directory.h"
|
2014-01-18 06:31:25 -05:00
|
|
|
#include "ardour/srcfilesource.h"
|
2016-12-21 06:14:44 -05:00
|
|
|
#include "ardour/profile.h"
|
2005-10-12 23:48:57 -04:00
|
|
|
|
2006-04-11 23:09:25 -04:00
|
|
|
#include "ardour_ui.h"
|
2006-09-18 23:29:16 -04:00
|
|
|
#include "editing.h"
|
2006-01-11 16:27:59 -05:00
|
|
|
#include "gui_thread.h"
|
2006-01-13 14:48:55 -05:00
|
|
|
#include "sfdb_ui.h"
|
2007-10-11 18:07:47 -04:00
|
|
|
#include "editing.h"
|
|
|
|
#include "gain_meter.h"
|
2012-05-31 19:14:03 -04:00
|
|
|
#include "main_clock.h"
|
2012-12-23 13:25:26 -05:00
|
|
|
#include "public_editor.h"
|
2014-12-25 10:02:00 -05:00
|
|
|
#include "timers.h"
|
2015-01-02 09:44:54 -05:00
|
|
|
#include "ui_config.h"
|
2005-10-12 16:06:20 -04:00
|
|
|
|
2008-04-11 10:06:50 -04:00
|
|
|
#include "sfdb_freesound_mootcher.h"
|
|
|
|
|
2018-09-21 13:05:57 -04:00
|
|
|
#include "pbd/i18n.h"
|
|
|
|
|
2006-01-11 16:27:59 -05:00
|
|
|
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;
|
2006-03-22 12:03:00 -05:00
|
|
|
using namespace std;
|
2007-10-11 18:07:47 -04:00
|
|
|
using namespace Gtk;
|
|
|
|
using namespace Gtkmm2ext;
|
|
|
|
using namespace Editing;
|
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
using std::string;
|
2006-01-11 16:27:59 -05:00
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
string SoundFileBrowser::persistent_folder;
|
2013-06-14 14:17:24 -04:00
|
|
|
typedef TreeView::Selection::ListHandle_Path ListPath;
|
2007-03-18 02:07:08 -04:00
|
|
|
|
2016-12-14 07:31:16 -05:00
|
|
|
static MidiTrackNameSource
|
|
|
|
string2miditracknamesource (string const & str)
|
|
|
|
{
|
|
|
|
if (str == _("by track number")) {
|
|
|
|
return SMFTrackNumber;
|
|
|
|
} else if (str == _("by track name")) {
|
|
|
|
return SMFTrackName;
|
|
|
|
} else if (str == _("by instrument name")) {
|
|
|
|
return SMFInstrumentName;
|
|
|
|
}
|
|
|
|
|
|
|
|
warning << string_compose (_("programming error: unknown midi track name source string %1"), str) << endmsg;
|
|
|
|
|
|
|
|
return SMFTrackNumber;
|
|
|
|
}
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
static ImportMode
|
2016-12-14 07:31:16 -05:00
|
|
|
string2importmode (string const & str)
|
2005-12-07 17:57:47 -05:00
|
|
|
{
|
2008-04-11 10:06:50 -04:00
|
|
|
if (str == _("as new tracks")) {
|
2007-10-11 18:07:47 -04:00
|
|
|
return ImportAsTrack;
|
2008-04-11 10:06:50 -04:00
|
|
|
} else if (str == _("to selected tracks")) {
|
2007-10-11 18:07:47 -04:00
|
|
|
return ImportToTrack;
|
2019-12-10 15:10:11 -05:00
|
|
|
} else if (str == _("to source list")) {
|
2007-10-11 18:07:47 -04:00
|
|
|
return ImportAsRegion;
|
|
|
|
}
|
|
|
|
|
|
|
|
warning << string_compose (_("programming error: unknown import mode string %1"), str) << endmsg;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
return ImportAsTrack;
|
|
|
|
}
|
|
|
|
|
|
|
|
static string
|
|
|
|
importmode2string (ImportMode mode)
|
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case ImportAsTrack:
|
|
|
|
return _("as new tracks");
|
|
|
|
case ImportToTrack:
|
|
|
|
return _("to selected tracks");
|
|
|
|
case ImportAsRegion:
|
2019-12-10 15:10:11 -05:00
|
|
|
return _("to source list");
|
2022-01-03 17:51:33 -05:00
|
|
|
case ImportAsTrigger:
|
|
|
|
/* TODO: n/a */
|
|
|
|
break;
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
2014-11-14 04:47:43 -05:00
|
|
|
abort(); /*NOTREACHED*/
|
2007-10-11 18:07:47 -04:00
|
|
|
return _("as new tracks");
|
|
|
|
}
|
|
|
|
|
2014-01-27 13:52:48 -05:00
|
|
|
SoundFileBox::SoundFileBox (bool /*persistent*/)
|
2016-12-16 08:46:13 -05:00
|
|
|
: table (7, 2),
|
2014-01-21 16:20:44 -05:00
|
|
|
length_clock ("sfboxLengthClock", true, "", false, false, true, false),
|
|
|
|
timecode_clock ("sfboxTimecodeClock", true, "", false, false, false, false),
|
2007-10-11 18:07:47 -04:00
|
|
|
main_box (false, 6),
|
2014-01-16 18:20:58 -05:00
|
|
|
autoplay_btn (_("Auto-play")),
|
|
|
|
seek_slider(0,1000,1),
|
2017-02-28 10:28:44 -05:00
|
|
|
_seeking(false),
|
|
|
|
_src_quality (SrcBest),
|
|
|
|
_import_position (ImportAtTimestamp)
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
{
|
|
|
|
set_name (X_("SoundFileBox"));
|
|
|
|
|
2009-05-04 17:36:45 -04:00
|
|
|
preview_label.set_markup (_("<b>Sound File Information</b>"));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2017-09-18 14:45:56 -04:00
|
|
|
border_frame.set_label_widget (preview_label);
|
|
|
|
border_frame.add (main_box);
|
2005-12-07 17:57:47 -05:00
|
|
|
|
2017-09-18 14:45:56 -04:00
|
|
|
pack_start (border_frame, true, true);
|
2007-10-11 18:07:47 -04:00
|
|
|
set_border_width (6);
|
2007-01-11 14:50:49 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
main_box.set_border_width (6);
|
2005-12-07 17:57:47 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
length.set_text (_("Length:"));
|
2009-05-04 17:36:45 -04:00
|
|
|
length.set_alignment (1, 0.5);
|
2007-10-11 18:07:47 -04:00
|
|
|
timecode.set_text (_("Timestamp:"));
|
2009-05-04 17:36:45 -04:00
|
|
|
timecode.set_alignment (1, 0.5);
|
2007-10-11 18:07:47 -04:00
|
|
|
format.set_text (_("Format:"));
|
2009-05-04 17:36:45 -04:00
|
|
|
format.set_alignment (1, 0.5);
|
2007-10-11 18:07:47 -04:00
|
|
|
channels.set_text (_("Channels:"));
|
2009-05-04 17:36:45 -04:00
|
|
|
channels.set_alignment (1, 0.5);
|
2007-10-11 18:07:47 -04:00
|
|
|
samplerate.set_text (_("Sample rate:"));
|
2009-05-04 17:36:45 -04:00
|
|
|
samplerate.set_alignment (1, 0.5);
|
2016-12-16 08:46:13 -05:00
|
|
|
tempomap.set_text (_("Tempo Map:"));
|
|
|
|
tempomap.set_alignment (1, 0.5);
|
2009-05-04 17:36:45 -04:00
|
|
|
|
2010-11-05 12:18:40 -04:00
|
|
|
preview_label.set_max_width_chars (50);
|
|
|
|
preview_label.set_ellipsize (Pango::ELLIPSIZE_END);
|
|
|
|
|
|
|
|
format_text.set_max_width_chars (20);
|
2009-05-04 17:36:45 -04:00
|
|
|
format_text.set_ellipsize (Pango::ELLIPSIZE_END);
|
|
|
|
format_text.set_alignment (0, 1);
|
2005-12-07 17:57:47 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
table.set_col_spacings (6);
|
|
|
|
table.set_homogeneous (false);
|
|
|
|
table.set_row_spacings (6);
|
|
|
|
|
2021-11-13 17:22:40 -05:00
|
|
|
int row = 0;
|
|
|
|
table.attach (format, 0, 1, row, row+2, FILL, FILL); row+=2;
|
|
|
|
table.attach (channels, 0, 1, row, row+1, FILL, FILL); row+=1;
|
|
|
|
table.attach (samplerate, 0, 1, row, row+1, FILL, FILL); row+=1;
|
|
|
|
table.attach (length, 0, 1, row, row+1, FILL, FILL); row+=1;
|
|
|
|
table.attach (timecode, 0, 1, row, row+1, FILL, FILL); row+=1;
|
|
|
|
table.attach (tempomap, 0, 1, row, row+1, FILL, FILL);
|
|
|
|
|
|
|
|
row = 0;
|
|
|
|
table.attach (format_text, 1, 2, row, row+2, FILL, FILL); row+=2;
|
|
|
|
table.attach (channels_value, 1, 2, row, row+1, FILL, FILL); row+=1;
|
|
|
|
table.attach (samplerate_value,1, 2, row, row+1, FILL, FILL); row+=1;
|
|
|
|
table.attach (length_clock, 1, 2, row, row+1, FILL, FILL); row+=1;
|
|
|
|
table.attach (timecode_clock, 1, 2, row, row+1, FILL, FILL); row+=1;
|
|
|
|
table.attach (tempomap_value, 1, 2, row, row+1, FILL, FILL); row+=1;
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2020-10-05 00:52:17 -04:00
|
|
|
length_clock.set_is_duration (true, timepos_t());
|
2018-10-10 11:47:05 -04:00
|
|
|
length_clock.set_mode (ARDOUR_UI::instance()->primary_clock->mode());
|
2009-10-26 10:38:58 -04:00
|
|
|
timecode_clock.set_mode (AudioClock::Timecode);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2009-05-04 17:36:45 -04:00
|
|
|
main_box.pack_start (table, false, false);
|
2005-12-07 17:57:47 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
tags_entry.set_editable (true);
|
2012-03-09 17:02:48 -05:00
|
|
|
tags_entry.set_wrap_mode(Gtk::WRAP_WORD);
|
2009-12-11 18:29:48 -05:00
|
|
|
tags_entry.signal_focus_out_event().connect (sigc::mem_fun (*this, &SoundFileBox::tags_entry_left));
|
2005-12-07 17:57:47 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
Label* label = manage (new Label (_("Tags:")));
|
|
|
|
label->set_alignment (0.0f, 0.5f);
|
2009-05-04 17:36:45 -04:00
|
|
|
main_box.pack_start (*label, false, false);
|
|
|
|
main_box.pack_start (tags_entry, true, true);
|
2005-12-07 17:57:47 -05:00
|
|
|
|
2009-05-04 17:36:45 -04:00
|
|
|
main_box.pack_start (bottom_box, false, false);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
play_btn.set_image (*(manage (new Image (Stock::MEDIA_PLAY, ICON_SIZE_BUTTON))));
|
2012-04-05 17:31:55 -04:00
|
|
|
// play_btn.set_label (_("Play"));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
stop_btn.set_image (*(manage (new Image (Stock::MEDIA_STOP, ICON_SIZE_BUTTON))));
|
2012-04-05 17:31:55 -04:00
|
|
|
// stop_btn.set_label (_("Stop"));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
bottom_box.set_homogeneous (false);
|
|
|
|
bottom_box.set_spacing (6);
|
|
|
|
bottom_box.pack_start(play_btn, true, true);
|
|
|
|
bottom_box.pack_start(stop_btn, true, true);
|
|
|
|
bottom_box.pack_start(autoplay_btn, false, false);
|
|
|
|
|
2014-01-16 18:20:58 -05:00
|
|
|
seek_slider.set_draw_value(false);
|
|
|
|
|
|
|
|
seek_slider.add_events(Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
|
|
|
|
seek_slider.signal_button_press_event().connect(sigc::mem_fun(*this, &SoundFileBox::seek_button_press), false);
|
|
|
|
seek_slider.signal_button_release_event().connect(sigc::mem_fun(*this, &SoundFileBox::seek_button_release), false);
|
|
|
|
main_box.pack_start (seek_slider, false, false);
|
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
play_btn.signal_clicked().connect (sigc::mem_fun (*this, &SoundFileBox::audition));
|
|
|
|
stop_btn.signal_clicked().connect (sigc::mem_fun (*this, &SoundFileBox::stop_audition));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2017-06-12 09:59:11 -04:00
|
|
|
update_autoplay ();
|
|
|
|
autoplay_btn.signal_toggled().connect(sigc::mem_fun (*this, &SoundFileBox::autoplay_toggled));
|
|
|
|
|
2014-01-16 18:20:58 -05:00
|
|
|
stop_btn.set_sensitive (false);
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
channels_value.set_alignment (0.0f, 0.5f);
|
|
|
|
samplerate_value.set_alignment (0.0f, 0.5f);
|
2005-12-07 17:57:47 -05:00
|
|
|
}
|
|
|
|
|
2021-02-24 22:11:06 -05:00
|
|
|
void
|
|
|
|
SoundFileBox::on_size_request (Gtk::Requisition* req)
|
|
|
|
{
|
|
|
|
VBox::on_size_request (req);
|
|
|
|
req->width = std::max<gint> (req->width, 300 * UIConfiguration::instance().get_ui_scale ());
|
|
|
|
}
|
|
|
|
|
2006-01-04 00:53:51 -05:00
|
|
|
void
|
2006-01-11 16:27:59 -05:00
|
|
|
SoundFileBox::set_session(Session* s)
|
2006-01-04 00:53:51 -05:00
|
|
|
{
|
2009-12-17 13:24:23 -05:00
|
|
|
SessionHandlePtr::set_session (s);
|
|
|
|
|
|
|
|
length_clock.set_session (s);
|
|
|
|
timecode_clock.set_session (s);
|
2006-01-04 00:53:51 -05:00
|
|
|
|
2006-04-11 23:09:25 -04:00
|
|
|
if (!_session) {
|
2007-10-11 18:07:47 -04:00
|
|
|
play_btn.set_sensitive (false);
|
|
|
|
stop_btn.set_sensitive (false);
|
2014-01-16 18:20:58 -05:00
|
|
|
auditioner_connections.drop_connections();
|
|
|
|
} else {
|
|
|
|
auditioner_connections.drop_connections();
|
|
|
|
_session->AuditionActive.connect(auditioner_connections, invalidator (*this), boost::bind (&SoundFileBox::audition_active, this, _1), gui_context());
|
|
|
|
_session->the_auditioner()->AuditionProgress.connect(auditioner_connections, invalidator (*this), boost::bind (&SoundFileBox::audition_progress, this, _1, _2), gui_context());
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2006-01-04 00:53:51 -05:00
|
|
|
}
|
|
|
|
|
2014-01-16 18:20:58 -05:00
|
|
|
void
|
|
|
|
SoundFileBox::audition_active(bool active) {
|
|
|
|
stop_btn.set_sensitive (active);
|
|
|
|
seek_slider.set_sensitive (active);
|
|
|
|
if (!active) {
|
|
|
|
seek_slider.set_value(0);
|
2021-12-16 18:36:06 -05:00
|
|
|
_seeking = false;
|
2014-01-16 18:20:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-09-18 12:39:17 -04:00
|
|
|
SoundFileBox::audition_progress(ARDOUR::samplecnt_t pos, ARDOUR::samplecnt_t len) {
|
2014-01-16 18:20:58 -05:00
|
|
|
if (!_seeking) {
|
|
|
|
seek_slider.set_value( 1000.0 * pos / len);
|
|
|
|
seek_slider.set_sensitive (true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
SoundFileBox::seek_button_press(GdkEventButton*) {
|
|
|
|
_seeking = true;
|
|
|
|
return false; // pass on to slider
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
SoundFileBox::seek_button_release(GdkEventButton*) {
|
|
|
|
_seeking = false;
|
|
|
|
_session->the_auditioner()->seek_to_percent(seek_slider.get_value() / 10.0);
|
|
|
|
seek_slider.set_sensitive (false);
|
|
|
|
return false; // pass on to slider
|
|
|
|
}
|
|
|
|
|
2006-01-05 00:15:29 -05:00
|
|
|
bool
|
2010-09-14 12:51:02 -04:00
|
|
|
SoundFileBox::setup_labels (const string& filename)
|
2005-12-07 23:55:46 -05:00
|
|
|
{
|
2007-10-11 18:07:47 -04:00
|
|
|
if (!path.empty()) {
|
|
|
|
// save existing tags
|
|
|
|
tags_changed ();
|
|
|
|
}
|
|
|
|
|
2006-01-11 16:27:59 -05:00
|
|
|
path = filename;
|
|
|
|
|
2006-03-10 12:09:59 -05:00
|
|
|
string error_msg;
|
2006-11-19 11:45:16 -05:00
|
|
|
|
2014-04-28 16:44:40 -04:00
|
|
|
if (SMFSource::valid_midi_file (path)) {
|
2014-01-22 09:26:23 -05:00
|
|
|
|
2014-12-30 22:05:10 -05:00
|
|
|
boost::shared_ptr<SMFSource> ms;
|
|
|
|
try {
|
|
|
|
ms = boost::dynamic_pointer_cast<SMFSource> (
|
|
|
|
SourceFactory::createExternal (DataType::MIDI, *_session,
|
|
|
|
path, 0, Source::Flag (0), false));
|
|
|
|
} catch (const std::exception& e) {
|
|
|
|
error << string_compose(_("Could not read file: %1 (%2)."),
|
|
|
|
path, e.what()) << endmsg;
|
|
|
|
}
|
2014-01-22 09:26:23 -05:00
|
|
|
|
|
|
|
preview_label.set_markup (_("<b>Midi File Information</b>"));
|
|
|
|
|
|
|
|
samplerate_value.set_text ("-");
|
|
|
|
tags_entry.get_buffer()->set_text ("");
|
2020-10-05 00:52:17 -04:00
|
|
|
timecode_clock.set (timepos_t ());
|
2014-01-22 09:26:23 -05:00
|
|
|
tags_entry.set_sensitive (false);
|
|
|
|
|
|
|
|
if (ms) {
|
2021-11-13 17:22:40 -05:00
|
|
|
if (ms->smf_format()==0) {
|
|
|
|
format_text.set_text ("MIDI Type 0");
|
2016-10-05 15:01:21 -04:00
|
|
|
} else {
|
2021-11-13 17:22:40 -05:00
|
|
|
format_text.set_text (string_compose("%1 (%2 Tracks)", ms->smf_format()==2 ? "MIDI Type 2" : "MIDI Type 1", ms->num_tracks()));
|
2016-10-05 15:01:21 -04:00
|
|
|
}
|
2022-02-04 18:13:15 -05:00
|
|
|
channels_value.set_text (ARDOUR_UI_UTILS::midi_channels_as_string (ms->used_channels()));
|
2020-10-05 00:52:17 -04:00
|
|
|
length_clock.set_duration (timecnt_t (0));
|
2016-12-16 08:46:13 -05:00
|
|
|
switch (ms->num_tempos()) {
|
|
|
|
case 0:
|
|
|
|
tempomap_value.set_text (_("No tempo data"));
|
|
|
|
break;
|
|
|
|
case 1: {
|
|
|
|
Evoral::SMF::Tempo* t = ms->nth_tempo (0);
|
|
|
|
assert (t);
|
|
|
|
tempomap_value.set_text (string_compose (_("%1/%2 \u2669 = %3"),
|
|
|
|
t->numerator,
|
|
|
|
t->denominator,
|
2017-02-08 13:07:28 -05:00
|
|
|
t->tempo ()));
|
2016-12-16 08:46:13 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
tempomap_value.set_text (string_compose (_("map with %1 sections"),
|
|
|
|
ms->num_tempos()));
|
|
|
|
break;
|
|
|
|
}
|
2014-01-22 09:26:23 -05:00
|
|
|
} else {
|
|
|
|
channels_value.set_text ("");
|
2020-10-05 00:52:17 -04:00
|
|
|
length_clock.set (timepos_t());
|
2016-12-16 08:46:13 -05:00
|
|
|
tempomap_value.set_text (_("No tempo data"));
|
2014-01-22 09:26:23 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if (_session && ms) {
|
|
|
|
play_btn.set_sensitive (true);
|
|
|
|
} else {
|
|
|
|
play_btn.set_sensitive (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2006-06-14 21:34:54 -04:00
|
|
|
if(!AudioFileSource::get_soundfile_info (filename, sf_info, error_msg)) {
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2009-05-04 17:36:45 -04:00
|
|
|
preview_label.set_markup (_("<b>Sound File Information</b>"));
|
|
|
|
format_text.set_text ("");
|
|
|
|
channels_value.set_text ("");
|
|
|
|
samplerate_value.set_text ("");
|
2007-10-11 18:07:47 -04:00
|
|
|
tags_entry.get_buffer()->set_text ("");
|
|
|
|
|
2020-10-05 00:52:17 -04:00
|
|
|
length_clock.set (timepos_t());
|
|
|
|
timecode_clock.set (timepos_t());
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
tags_entry.set_sensitive (false);
|
|
|
|
play_btn.set_sensitive (false);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2006-03-08 17:24:51 -05:00
|
|
|
return false;
|
2005-12-07 23:55:46 -05:00
|
|
|
}
|
|
|
|
|
2015-10-15 05:24:15 -04:00
|
|
|
preview_label.set_markup (string_compose ("<b>%1</b>", Glib::Markup::escape_text (Glib::path_get_basename (filename))));
|
2009-05-04 17:36:45 -04:00
|
|
|
std::string n = sf_info.format_name;
|
|
|
|
if (n.substr (0, 8) == X_("Format: ")) {
|
|
|
|
n = n.substr (8);
|
|
|
|
}
|
|
|
|
format_text.set_text (n);
|
2016-12-07 00:48:23 -05:00
|
|
|
channels_value.set_text (to_string (sf_info.channels));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
if (_session && sf_info.samplerate != _session->sample_rate()) {
|
2007-10-11 18:07:47 -04:00
|
|
|
samplerate.set_markup (string_compose ("<b>%1</b>", _("Sample rate:")));
|
|
|
|
samplerate_value.set_markup (string_compose (X_("<b>%1 Hz</b>"), sf_info.samplerate));
|
|
|
|
samplerate_value.set_name ("NewSessionSR1Label");
|
|
|
|
samplerate.set_name ("NewSessionSR1Label");
|
|
|
|
} else {
|
|
|
|
samplerate.set_text (_("Sample rate:"));
|
|
|
|
samplerate_value.set_text (string_compose (X_("%1 Hz"), sf_info.samplerate));
|
|
|
|
samplerate_value.set_name ("NewSessionSR2Label");
|
|
|
|
samplerate.set_name ("NewSessionSR2Label");
|
|
|
|
}
|
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
samplecnt_t const nfr = _session ? _session->nominal_sample_rate() : 25;
|
2009-05-13 20:13:27 -04:00
|
|
|
double src_coef = (double) nfr / sf_info.samplerate;
|
2008-09-10 17:27:39 -04:00
|
|
|
|
2020-10-05 00:52:17 -04:00
|
|
|
length_clock.set_is_duration (true, timepos_t());
|
|
|
|
length_clock.set_duration (timecnt_t (samplecnt_t (llrint (sf_info.length * src_coef + 0.5))), true);
|
|
|
|
timecode_clock.set (timepos_t (samplepos_t (llrint (sf_info.timecode * src_coef + 0.5))), true);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
// this is a hack that is fixed in trunk, i think (august 26th, 2007)
|
2006-11-19 11:45:16 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
vector<string> tags = Library->get_tags (string ("//") + filename);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
stringstream tag_string;
|
|
|
|
for (vector<string>::iterator i = tags.begin(); i != tags.end(); ++i) {
|
|
|
|
if (i != tags.begin()) {
|
|
|
|
tag_string << ", ";
|
|
|
|
}
|
|
|
|
tag_string << *i;
|
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
tags_entry.get_buffer()->set_text (tag_string.str());
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
tags_entry.set_sensitive (true);
|
|
|
|
if (_session) {
|
|
|
|
play_btn.set_sensitive (true);
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2006-01-05 00:15:29 -05:00
|
|
|
return true;
|
2005-12-07 23:55:46 -05:00
|
|
|
}
|
2005-12-07 17:57:47 -05:00
|
|
|
|
2017-06-12 09:59:11 -04:00
|
|
|
void
|
|
|
|
SoundFileBox::update_autoplay ()
|
|
|
|
{
|
|
|
|
const bool config_autoplay = UIConfiguration::instance().get_autoplay_files();
|
|
|
|
|
|
|
|
if (autoplay_btn.get_active() != config_autoplay) {
|
|
|
|
autoplay_btn.set_active (config_autoplay);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBox::autoplay_toggled()
|
|
|
|
{
|
|
|
|
UIConfiguration::instance().set_autoplay_files(autoplay_btn.get_active());
|
|
|
|
}
|
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
bool
|
2007-10-11 18:07:47 -04:00
|
|
|
SoundFileBox::autoplay() const
|
|
|
|
{
|
|
|
|
return autoplay_btn.get_active();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
SoundFileBox::audition_oneshot()
|
|
|
|
{
|
|
|
|
audition ();
|
|
|
|
return false;
|
2006-01-11 16:27:59 -05:00
|
|
|
}
|
2005-12-07 17:57:47 -05:00
|
|
|
|
|
|
|
void
|
2007-10-11 18:07:47 -04:00
|
|
|
SoundFileBox::audition ()
|
2006-01-11 16:27:59 -05:00
|
|
|
{
|
|
|
|
if (!_session) {
|
|
|
|
return;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2006-01-11 16:27:59 -05:00
|
|
|
_session->cancel_audition();
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
|
2006-01-11 16:27:59 -05:00
|
|
|
warning << string_compose(_("Could not read file: %1 (%2)."), path, strerror(errno)) << endmsg;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
boost::shared_ptr<Region> r;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2014-04-28 16:44:40 -04:00
|
|
|
if (SMFSource::valid_midi_file (path)) {
|
2014-01-22 09:26:23 -05:00
|
|
|
|
|
|
|
boost::shared_ptr<SMFSource> ms =
|
|
|
|
boost::dynamic_pointer_cast<SMFSource> (
|
|
|
|
SourceFactory::createExternal (DataType::MIDI, *_session,
|
|
|
|
path, 0, Source::Flag (0), false));
|
|
|
|
|
|
|
|
string rname = region_name_from_path (ms->path(), false);
|
|
|
|
|
|
|
|
PropertyList plist;
|
|
|
|
|
2020-12-18 15:01:53 -05:00
|
|
|
plist.add (ARDOUR::Properties::start, timepos_t (Temporal::Beats()));
|
2020-10-05 00:52:17 -04:00
|
|
|
plist.add (ARDOUR::Properties::length, ms->length());
|
2014-01-22 09:26:23 -05:00
|
|
|
plist.add (ARDOUR::Properties::name, rname);
|
|
|
|
plist.add (ARDOUR::Properties::layer, 0);
|
|
|
|
|
|
|
|
r = boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (boost::dynamic_pointer_cast<Source>(ms), plist, false));
|
|
|
|
assert(r);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
SourceList srclist;
|
|
|
|
boost::shared_ptr<AudioFileSource> afs;
|
|
|
|
bool old_sbp = AudioSource::get_build_peakfiles ();
|
|
|
|
|
|
|
|
/* don't even think of building peakfiles for these files */
|
|
|
|
|
|
|
|
AudioSource::set_build_peakfiles (false);
|
|
|
|
|
|
|
|
for (int n = 0; n < sf_info.channels; ++n) {
|
|
|
|
try {
|
|
|
|
afs = boost::dynamic_pointer_cast<AudioFileSource> (
|
|
|
|
SourceFactory::createExternal (DataType::AUDIO, *_session,
|
|
|
|
path, n,
|
2015-04-02 12:53:05 -04:00
|
|
|
Source::Flag (ARDOUR::AudioFileSource::NoPeakFile), false));
|
2017-09-18 12:39:17 -04:00
|
|
|
if (afs->sample_rate() != _session->nominal_sample_rate()) {
|
2014-01-22 09:26:23 -05:00
|
|
|
boost::shared_ptr<SrcFileSource> sfs (new SrcFileSource(*_session, afs, _src_quality));
|
|
|
|
srclist.push_back(sfs);
|
|
|
|
} else {
|
|
|
|
srclist.push_back(afs);
|
|
|
|
}
|
|
|
|
|
|
|
|
} catch (failed_constructor& err) {
|
|
|
|
error << _("Could not access soundfile: ") << path << endmsg;
|
|
|
|
AudioSource::set_build_peakfiles (old_sbp);
|
|
|
|
return;
|
|
|
|
}
|
2006-01-11 16:27:59 -05:00
|
|
|
}
|
|
|
|
|
2014-01-22 09:26:23 -05:00
|
|
|
AudioSource::set_build_peakfiles (old_sbp);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2014-01-22 09:26:23 -05:00
|
|
|
if (srclist.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2014-01-22 09:26:23 -05:00
|
|
|
afs = boost::dynamic_pointer_cast<AudioFileSource> (srclist[0]);
|
|
|
|
string rname = region_name_from_path (afs->path(), false);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2014-01-22 09:26:23 -05:00
|
|
|
PropertyList plist;
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2020-12-18 15:01:53 -05:00
|
|
|
plist.add (ARDOUR::Properties::start, timepos_t (0));
|
2020-10-05 00:52:17 -04:00
|
|
|
plist.add (ARDOUR::Properties::length, srclist[0]->length());
|
2014-01-22 09:26:23 -05:00
|
|
|
plist.add (ARDOUR::Properties::name, rname);
|
|
|
|
plist.add (ARDOUR::Properties::layer, 0);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2014-01-22 09:26:23 -05:00
|
|
|
r = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (srclist, plist, false));
|
|
|
|
}
|
2006-11-19 11:45:16 -05:00
|
|
|
|
2020-10-05 00:52:17 -04:00
|
|
|
timepos_t audition_position;
|
|
|
|
|
|
|
|
switch (_import_position) {
|
2014-03-09 19:48:48 -04:00
|
|
|
case ImportAtTimestamp:
|
|
|
|
break;
|
|
|
|
case ImportAtPlayhead:
|
2020-10-05 00:52:17 -04:00
|
|
|
audition_position = timepos_t (_session->transport_sample());
|
2014-03-09 19:48:48 -04:00
|
|
|
break;
|
|
|
|
case ImportAtStart:
|
2020-10-05 00:52:17 -04:00
|
|
|
audition_position = timepos_t (_session->current_start_sample());
|
2014-03-09 19:48:48 -04:00
|
|
|
break;
|
|
|
|
case ImportAtEditPoint:
|
|
|
|
audition_position = PublicEditor::instance().get_preferred_edit_position ();
|
|
|
|
break;
|
|
|
|
}
|
2020-10-05 00:52:17 -04:00
|
|
|
|
2014-03-09 19:48:48 -04:00
|
|
|
r->set_position(audition_position);
|
|
|
|
|
2006-11-19 11:45:16 -05:00
|
|
|
_session->audition_region(r);
|
2006-01-11 16:27:59 -05:00
|
|
|
}
|
2005-12-07 17:57:47 -05:00
|
|
|
|
|
|
|
void
|
2007-10-11 18:07:47 -04:00
|
|
|
SoundFileBox::stop_audition ()
|
2006-01-11 16:27:59 -05:00
|
|
|
{
|
|
|
|
if (_session) {
|
|
|
|
_session->cancel_audition();
|
|
|
|
}
|
|
|
|
}
|
2005-12-07 17:57:47 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
bool
|
2009-07-21 11:55:17 -04:00
|
|
|
SoundFileBox::tags_entry_left (GdkEventFocus *)
|
2007-10-11 18:07:47 -04:00
|
|
|
{
|
|
|
|
tags_changed ();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-12-07 17:57:47 -05:00
|
|
|
void
|
2007-10-11 18:07:47 -04:00
|
|
|
SoundFileBox::tags_changed ()
|
2006-01-13 14:48:55 -05:00
|
|
|
{
|
2007-10-11 18:07:47 -04:00
|
|
|
string tag_string = tags_entry.get_buffer()->get_text ();
|
|
|
|
|
|
|
|
if (tag_string.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
2006-01-18 16:05:59 -05:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
vector<string> tags;
|
2006-01-18 16:05:59 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
if (!PBD::tokenize (tag_string, string(",\n"), std::back_inserter (tags), true)) {
|
2007-01-09 18:24:54 -05:00
|
|
|
warning << _("SoundFileBox: Could not tokenize string: ") << tag_string << endmsg;
|
|
|
|
return;
|
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
save_tags (tags);
|
2006-07-27 21:08:57 -04:00
|
|
|
}
|
|
|
|
|
2005-12-07 17:57:47 -05:00
|
|
|
void
|
2007-10-11 18:07:47 -04:00
|
|
|
SoundFileBox::save_tags (const vector<string>& tags)
|
2006-01-11 16:27:59 -05:00
|
|
|
{
|
2007-10-11 18:07:47 -04:00
|
|
|
Library->set_tags (string ("//") + path, tags);
|
|
|
|
Library->save_changes ();
|
2006-01-11 16:27:59 -05:00
|
|
|
}
|
2005-12-07 17:57:47 -05:00
|
|
|
|
2012-12-23 15:34:43 -05:00
|
|
|
SoundFileBrowser::SoundFileBrowser (string title, ARDOUR::Session* s, bool persistent)
|
|
|
|
: ArdourWindow (title)
|
2012-12-23 13:25:26 -05:00
|
|
|
, found_list (ListStore::create(found_list_columns))
|
|
|
|
, freesound_list (ListStore::create(freesound_list_columns))
|
|
|
|
, chooser (FILE_CHOOSER_ACTION_OPEN)
|
|
|
|
, preview (persistent)
|
|
|
|
, found_search_btn (_("Search"))
|
|
|
|
, found_list_view (found_list)
|
|
|
|
, freesound_search_btn (_("Search"))
|
|
|
|
, freesound_list_view (freesound_list)
|
|
|
|
, resetting_ourselves (false)
|
|
|
|
, matches (0)
|
|
|
|
, _status (0)
|
|
|
|
, _done (false)
|
2015-09-03 09:10:42 -04:00
|
|
|
, import_button (_("Import"))
|
2012-12-23 13:25:26 -05:00
|
|
|
, gm (0)
|
2005-10-12 23:48:57 -04:00
|
|
|
{
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2015-10-27 13:43:31 -04:00
|
|
|
#ifdef __APPLE__
|
2015-09-06 12:15:48 -04:00
|
|
|
try {
|
|
|
|
/* add_shortcut_folder throws an exception if the folder being added already has a shortcut */
|
|
|
|
chooser.add_shortcut_folder_uri("file:///Library/GarageBand/Apple Loops");
|
|
|
|
chooser.add_shortcut_folder_uri("file:///Library/Audio/Apple Loops");
|
|
|
|
chooser.add_shortcut_folder_uri("file:///Library/Application Support/GarageBand/Instrument Library/Sampler/Sampler Files");
|
|
|
|
}
|
|
|
|
catch (Glib::Error & e) {
|
|
|
|
std::cerr << "sfdb.add_shortcut_folder() threw Glib::Error " << e.what() << std::endl;
|
|
|
|
}
|
2010-04-15 16:42:05 -04:00
|
|
|
#endif
|
2015-10-16 13:07:25 -04:00
|
|
|
Gtkmm2ext::add_volume_shortcuts (chooser);
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2008-04-11 10:06:50 -04:00
|
|
|
//add the file chooser
|
2012-05-17 06:58:00 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
chooser.set_border_width (12);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
audio_and_midi_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun (*this, &SoundFileBrowser::on_audio_and_midi_filter));
|
|
|
|
audio_and_midi_filter.set_name (_("Audio and MIDI files"));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
audio_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun(*this, &SoundFileBrowser::on_audio_filter));
|
|
|
|
audio_filter.set_name (_("Audio files"));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
midi_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun(*this, &SoundFileBrowser::on_midi_filter));
|
|
|
|
midi_filter.set_name (_("MIDI files"));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
matchall_filter.add_pattern ("*.*");
|
|
|
|
matchall_filter.set_name (_("All files"));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
chooser.add_filter (audio_and_midi_filter);
|
|
|
|
chooser.add_filter (audio_filter);
|
|
|
|
chooser.add_filter (midi_filter);
|
|
|
|
chooser.add_filter (matchall_filter);
|
|
|
|
chooser.set_select_multiple (true);
|
|
|
|
chooser.signal_update_preview().connect(sigc::mem_fun(*this, &SoundFileBrowser::update_preview));
|
|
|
|
chooser.signal_file_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::chooser_file_activated));
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2015-10-27 13:43:31 -04:00
|
|
|
#ifdef __APPLE__
|
2012-12-23 13:25:26 -05:00
|
|
|
/* some broken redraw behaviour - this is a bandaid */
|
|
|
|
chooser.signal_selection_changed().connect (mem_fun (chooser, &Widget::queue_draw));
|
2010-03-16 11:33:04 -04:00
|
|
|
#endif
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
if (!persistent_folder.empty()) {
|
|
|
|
chooser.set_current_folder (persistent_folder);
|
2008-04-11 10:06:50 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
notebook.append_page (chooser, _("Browse Files"));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2008-09-22 13:24:39 -04:00
|
|
|
hpacker.set_spacing (6);
|
|
|
|
hpacker.pack_start (notebook, true, true);
|
|
|
|
hpacker.pack_start (preview, false, false);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
vpacker.set_spacing (6);
|
|
|
|
vpacker.pack_start (hpacker, true, true);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
add (vpacker);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
//add tag search
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
VBox* vbox;
|
|
|
|
HBox* hbox;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
hbox = manage(new HBox);
|
|
|
|
hbox->pack_start (found_entry);
|
|
|
|
hbox->pack_start (found_search_btn);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
Gtk::ScrolledWindow *scroll = manage(new ScrolledWindow);
|
|
|
|
scroll->add(found_list_view);
|
|
|
|
scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
vbox = manage(new VBox);
|
|
|
|
vbox->pack_start (*hbox, PACK_SHRINK);
|
|
|
|
vbox->pack_start (*scroll);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
found_list_view.append_column(_("Paths"), found_list_columns.pathname);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
found_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_list_view_selected));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
found_list_view.signal_row_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::found_list_view_activated));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
found_search_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_search_clicked));
|
|
|
|
found_entry.signal_activate().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_search_clicked));
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
notebook.append_page (*vbox, _("Search Tags"));
|
2012-04-05 17:31:55 -04:00
|
|
|
|
2008-04-11 10:06:50 -04:00
|
|
|
//add freesound search
|
2012-04-05 17:31:55 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
HBox* passbox;
|
|
|
|
Label* label;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
passbox = manage(new HBox);
|
|
|
|
passbox->set_spacing (6);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2022-05-23 11:26:21 -04:00
|
|
|
vbox = manage (new VBox);
|
2012-12-23 13:25:26 -05:00
|
|
|
label = manage (new Label);
|
2022-05-23 11:26:21 -04:00
|
|
|
label->set_alignment (Gtk::ALIGN_START);
|
2012-12-23 13:25:26 -05:00
|
|
|
label->set_text (_("Tags:"));
|
2022-05-23 11:26:21 -04:00
|
|
|
vbox->pack_start (*label, false, false);
|
|
|
|
vbox->pack_start (freesound_entry, true, true);
|
|
|
|
passbox->pack_start(*vbox, true, true);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2022-05-23 11:26:21 -04:00
|
|
|
vbox = manage (new VBox);
|
2012-12-23 13:25:26 -05:00
|
|
|
label = manage (new Label);
|
|
|
|
label->set_text (_("Sort:"));
|
2022-05-23 11:26:21 -04:00
|
|
|
label->set_alignment (Gtk::ALIGN_START);
|
|
|
|
vbox->pack_start (*label, false, false);
|
|
|
|
vbox->pack_start (freesound_sort, false, false);
|
2012-12-23 13:25:26 -05:00
|
|
|
freesound_sort.clear_items();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
// Order of the following must correspond with enum sortMethod
|
2015-10-05 10:17:49 -04:00
|
|
|
// in sfdb_freesound_mootcher.h
|
2022-01-26 15:11:15 -05:00
|
|
|
freesound_sort.append(_("None"));
|
|
|
|
freesound_sort.append(_("Longest"));
|
|
|
|
freesound_sort.append(_("Shortest"));
|
|
|
|
freesound_sort.append(_("Newest"));
|
|
|
|
freesound_sort.append(_("Oldest"));
|
|
|
|
freesound_sort.append(_("Most downloaded"));
|
|
|
|
freesound_sort.append(_("Least downloaded"));
|
|
|
|
freesound_sort.append(_("Highest rated"));
|
|
|
|
freesound_sort.append(_("Lowest rated"));
|
2012-12-23 13:25:26 -05:00
|
|
|
freesound_sort.set_active(0);
|
2022-05-23 11:26:21 -04:00
|
|
|
passbox->pack_start(*vbox, false, false);
|
|
|
|
|
|
|
|
vbox = manage (new VBox);
|
|
|
|
label = manage (new Label);
|
|
|
|
label->set_text (_("Licence:"));
|
|
|
|
label->set_alignment (Gtk::ALIGN_START);
|
|
|
|
vbox->pack_start (*label, false, false);
|
|
|
|
|
|
|
|
vbox->pack_start (freesound_licence, false, false);
|
|
|
|
freesound_licence.clear_items();
|
|
|
|
freesound_licence.append(_("Any"));
|
|
|
|
freesound_licence.append(_("CC-BY"));
|
|
|
|
freesound_licence.append(_("CC-BY-NC"));
|
|
|
|
freesound_licence.append(_("PD"));
|
|
|
|
freesound_licence.set_active(0);
|
|
|
|
|
|
|
|
passbox->pack_start(*vbox, false, false);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
passbox->pack_start (freesound_search_btn, false, false);
|
2013-03-15 15:59:19 -04:00
|
|
|
passbox->pack_start (freesound_more_btn, false, false);
|
|
|
|
freesound_more_btn.set_label(_("More"));
|
|
|
|
freesound_more_btn.set_sensitive(false);
|
|
|
|
|
2013-06-14 14:17:24 -04:00
|
|
|
passbox->pack_start (freesound_similar_btn, false, false);
|
|
|
|
freesound_similar_btn.set_label(_("Similar"));
|
|
|
|
freesound_similar_btn.set_sensitive(false);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
scroll = manage(new ScrolledWindow);
|
|
|
|
scroll->add(freesound_list_view);
|
|
|
|
scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
vbox = manage(new VBox);
|
|
|
|
vbox->set_spacing (3);
|
|
|
|
vbox->pack_start (*passbox, PACK_SHRINK);
|
|
|
|
vbox->pack_start (*scroll);
|
2013-06-14 14:17:24 -04:00
|
|
|
|
2022-05-27 07:09:49 -04:00
|
|
|
freesound_list_view.append_column(_("ID") , freesound_list_columns.id);
|
|
|
|
freesound_list_view.append_column(_("Filename"), freesound_list_columns.filename);
|
|
|
|
freesound_list_view.append_column(_("Duration"), freesound_list_columns.duration);
|
|
|
|
freesound_list_view.append_column(_("Size"), freesound_list_columns.filesize);
|
2022-05-16 13:10:34 -04:00
|
|
|
freesound_list_view.append_column(_("Sample rate"), freesound_list_columns.smplrate);
|
2022-05-27 07:09:49 -04:00
|
|
|
freesound_list_view.append_column(_("License"), freesound_list_columns.license);
|
|
|
|
|
|
|
|
// filename
|
|
|
|
freesound_list_view.get_column(1)->set_expand(true);
|
|
|
|
freesound_list_view.get_column(1)->set_resizable(true);
|
|
|
|
freesound_list_view.get_column(1)->set_sizing(Gtk::TREE_VIEW_COLUMN_FIXED);
|
|
|
|
|
|
|
|
// duration: justify contents right
|
|
|
|
CellRendererText* renderer = dynamic_cast<CellRendererText*> (freesound_list_view.get_column(2)->get_first_cell ());
|
|
|
|
if (renderer) {
|
|
|
|
renderer->property_xalign () = 1.0;
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
freesound_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_list_view_selected));
|
2022-05-27 07:09:49 -04:00
|
|
|
freesound_list_view.set_tooltip_column(7);
|
2012-12-23 13:25:26 -05:00
|
|
|
|
|
|
|
freesound_list_view.get_selection()->set_mode (SELECTION_MULTIPLE);
|
|
|
|
freesound_list_view.signal_row_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::freesound_list_view_activated));
|
|
|
|
freesound_search_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_search_clicked));
|
|
|
|
freesound_entry.signal_activate().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_search_clicked));
|
2022-05-27 07:09:49 -04:00
|
|
|
|
|
|
|
/* disable "More" button when search parameters change */
|
|
|
|
freesound_entry.signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_search_params_changed));
|
|
|
|
freesound_sort.signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_search_params_changed));
|
|
|
|
freesound_licence.signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_search_params_changed));
|
|
|
|
|
2013-03-15 15:59:19 -04:00
|
|
|
freesound_more_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_more_clicked));
|
2013-06-14 14:17:24 -04:00
|
|
|
freesound_similar_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_similar_clicked));
|
2012-12-23 13:25:26 -05:00
|
|
|
notebook.append_page (*vbox, _("Search Freesound"));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-04-11 10:06:50 -04:00
|
|
|
notebook.set_size_request (500, -1);
|
2012-12-23 13:25:26 -05:00
|
|
|
notebook.signal_switch_page().connect (sigc::hide_return (sigc::hide (sigc::hide (sigc::mem_fun (*this, &SoundFileBrowser::reset_options)))));
|
2008-04-11 10:06:50 -04:00
|
|
|
|
|
|
|
set_session (s);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
Gtk::HButtonBox* button_box = manage (new HButtonBox);
|
|
|
|
|
|
|
|
button_box->set_layout (BUTTONBOX_END);
|
2012-12-23 13:39:19 -05:00
|
|
|
|
2015-09-03 09:10:42 -04:00
|
|
|
button_box->pack_start (import_button, false, false);
|
|
|
|
import_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*this, &SoundFileBrowser::do_something), RESPONSE_OK));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2015-09-03 09:10:42 -04:00
|
|
|
Gtkmm2ext::UI::instance()->set_tip (import_button, _("Press to import selected files"));
|
2012-12-23 13:39:19 -05:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
vpacker.pack_end (*button_box, false, false);
|
2012-12-23 15:34:43 -05:00
|
|
|
|
|
|
|
set_wmclass (X_("import"), PROGRAM_NAME);
|
2006-01-04 00:53:51 -05:00
|
|
|
}
|
2005-12-02 17:12:56 -05:00
|
|
|
|
2007-03-18 02:07:08 -04:00
|
|
|
SoundFileBrowser::~SoundFileBrowser ()
|
|
|
|
{
|
|
|
|
persistent_folder = chooser.get_current_folder();
|
|
|
|
}
|
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
int
|
|
|
|
SoundFileBrowser::run ()
|
|
|
|
{
|
|
|
|
set_modal (true);
|
|
|
|
show_all ();
|
|
|
|
present ();
|
|
|
|
|
|
|
|
_done = false;
|
|
|
|
|
|
|
|
while (!_done) {
|
|
|
|
gtk_main_iteration ();
|
|
|
|
}
|
|
|
|
|
|
|
|
return _status;
|
|
|
|
}
|
|
|
|
|
2012-12-23 13:39:19 -05:00
|
|
|
void
|
|
|
|
SoundFileBrowser::set_action_sensitive (bool yn)
|
|
|
|
{
|
2015-09-03 09:10:42 -04:00
|
|
|
import_button.set_sensitive (yn);
|
2012-12-23 13:39:19 -05:00
|
|
|
}
|
|
|
|
|
2017-06-12 08:52:11 -04:00
|
|
|
bool
|
|
|
|
SoundFileBrowser::get_action_sensitive () const
|
|
|
|
{
|
|
|
|
return import_button.get_sensitive ();
|
|
|
|
}
|
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
void
|
|
|
|
SoundFileBrowser::do_something (int action)
|
|
|
|
{
|
|
|
|
_done = true;
|
|
|
|
_status = action;
|
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::on_show ()
|
|
|
|
{
|
2012-12-23 13:25:26 -05:00
|
|
|
ArdourWindow::on_show ();
|
2018-11-06 16:43:36 -05:00
|
|
|
reset_options ();
|
2007-10-11 18:07:47 -04:00
|
|
|
start_metering ();
|
|
|
|
}
|
|
|
|
|
2017-06-02 12:21:31 -04:00
|
|
|
bool
|
|
|
|
SoundFileBrowser::on_key_press_event (GdkEventKey* ev)
|
|
|
|
{
|
|
|
|
if (ev->keyval == GDK_Escape) {
|
|
|
|
do_something (RESPONSE_CLOSE);
|
|
|
|
return true;
|
|
|
|
}
|
2017-06-12 08:52:11 -04:00
|
|
|
if (ev->keyval == GDK_space && ev->type == GDK_KEY_PRESS) {
|
|
|
|
if (get_action_sensitive()) {
|
|
|
|
preview.audition();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2017-06-02 12:21:31 -04:00
|
|
|
return ArdourWindow::on_key_press_event (ev);
|
|
|
|
}
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
void
|
|
|
|
SoundFileBrowser::clear_selection ()
|
|
|
|
{
|
|
|
|
chooser.unselect_all ();
|
|
|
|
found_list_view.get_selection()->unselect_all ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::chooser_file_activated ()
|
|
|
|
{
|
2017-06-12 08:52:11 -04:00
|
|
|
do_something (RESPONSE_OK);
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-07-21 11:55:17 -04:00
|
|
|
SoundFileBrowser::found_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
|
2007-10-11 18:07:47 -04:00
|
|
|
{
|
|
|
|
preview.audition ();
|
|
|
|
}
|
|
|
|
|
2008-04-11 10:06:50 -04:00
|
|
|
void
|
2009-07-21 11:55:17 -04:00
|
|
|
SoundFileBrowser::freesound_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
|
2008-04-11 10:06:50 -04:00
|
|
|
{
|
|
|
|
preview.audition ();
|
|
|
|
}
|
|
|
|
|
2006-01-04 00:53:51 -05:00
|
|
|
void
|
2006-01-11 16:27:59 -05:00
|
|
|
SoundFileBrowser::set_session (Session* s)
|
2006-01-04 00:53:51 -05:00
|
|
|
{
|
2012-12-23 13:25:26 -05:00
|
|
|
ArdourWindow::set_session (s);
|
2007-10-11 18:07:47 -04:00
|
|
|
preview.set_session (s);
|
2009-12-17 13:24:23 -05:00
|
|
|
|
|
|
|
if (_session) {
|
2007-10-11 18:07:47 -04:00
|
|
|
add_gain_meter ();
|
|
|
|
} else {
|
|
|
|
remove_gain_meter ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::add_gain_meter ()
|
|
|
|
{
|
2008-12-18 14:31:00 -05:00
|
|
|
delete gm;
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
gm = new GainMeter (_session, 250);
|
2009-06-09 16:21:19 -04:00
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
boost::shared_ptr<Route> r = _session->the_auditioner ();
|
2009-06-09 16:21:19 -04:00
|
|
|
|
2016-01-25 11:47:44 -05:00
|
|
|
gm->set_controls (r, r->shared_peak_meter(), r->amp(), r->gain_control());
|
2014-01-05 07:07:31 -05:00
|
|
|
gm->set_fader_name (X_("GainFader"));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
meter_packer.set_border_width (12);
|
|
|
|
meter_packer.pack_start (*gm, false, true);
|
|
|
|
hpacker.pack_end (meter_packer, false, false);
|
|
|
|
meter_packer.show_all ();
|
|
|
|
start_metering ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::remove_gain_meter ()
|
|
|
|
{
|
|
|
|
if (gm) {
|
|
|
|
meter_packer.remove (*gm);
|
|
|
|
hpacker.remove (meter_packer);
|
|
|
|
delete gm;
|
|
|
|
gm = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::start_metering ()
|
|
|
|
{
|
2014-12-25 10:02:00 -05:00
|
|
|
metering_connection = Timers::super_rapid_connect (sigc::mem_fun(*this, &SoundFileBrowser::meter));
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::stop_metering ()
|
|
|
|
{
|
|
|
|
metering_connection.disconnect();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::meter ()
|
|
|
|
{
|
2022-01-26 15:17:53 -05:00
|
|
|
if (get_mapped () && _session && gm) {
|
2007-10-11 18:07:47 -04:00
|
|
|
gm->update_meters ();
|
|
|
|
}
|
2005-10-12 23:48:57 -04:00
|
|
|
}
|
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
bool
|
2008-02-18 14:45:52 -05:00
|
|
|
SoundFileBrowser::on_audio_filter (const FileFilter::Info& filter_info)
|
2007-01-09 18:24:54 -05:00
|
|
|
{
|
2009-02-16 21:11:49 -05:00
|
|
|
return AudioFileSource::safe_audio_file_extension (filter_info.filename);
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
|
|
|
|
2008-02-18 14:45:52 -05:00
|
|
|
bool
|
|
|
|
SoundFileBrowser::on_midi_filter (const FileFilter::Info& filter_info)
|
|
|
|
{
|
2009-02-16 21:11:49 -05:00
|
|
|
return SMFSource::safe_midi_file_extension (filter_info.filename);
|
2008-02-18 14:45:52 -05:00
|
|
|
}
|
|
|
|
|
2012-05-17 06:58:00 -04:00
|
|
|
bool
|
|
|
|
SoundFileBrowser::on_audio_and_midi_filter (const FileFilter::Info& filter_info)
|
|
|
|
{
|
|
|
|
return on_audio_filter (filter_info) || on_midi_filter (filter_info);
|
|
|
|
}
|
|
|
|
|
2005-12-07 17:57:47 -05:00
|
|
|
void
|
|
|
|
SoundFileBrowser::update_preview ()
|
|
|
|
{
|
2012-06-13 17:32:48 -04:00
|
|
|
if (preview.setup_labels (chooser.get_preview_filename())) {
|
2007-11-07 00:09:10 -05:00
|
|
|
if (preview.autoplay()) {
|
2009-12-11 18:29:48 -05:00
|
|
|
Glib::signal_idle().connect (sigc::mem_fun (preview, &SoundFileBox::audition_oneshot));
|
2007-11-07 00:09:10 -05:00
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::found_list_view_selected ()
|
|
|
|
{
|
2007-10-11 18:07:47 -04:00
|
|
|
if (!reset_options ()) {
|
2012-12-23 13:39:19 -05:00
|
|
|
set_action_sensitive (false);
|
2007-10-11 18:07:47 -04:00
|
|
|
} else {
|
2010-09-14 12:51:02 -04:00
|
|
|
string file;
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2013-06-14 14:17:24 -04:00
|
|
|
ListPath rows = found_list_view.get_selection()->get_selected_rows ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
if (!rows.empty()) {
|
|
|
|
TreeIter iter = found_list->get_iter(*rows.begin());
|
|
|
|
file = (*iter)[found_list_columns.pathname];
|
|
|
|
chooser.set_filename (file);
|
2012-12-23 13:39:19 -05:00
|
|
|
set_action_sensitive (true);
|
2007-10-11 18:07:47 -04:00
|
|
|
} else {
|
2012-12-23 13:39:19 -05:00
|
|
|
set_action_sensitive (false);
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
preview.setup_labels (file);
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::found_search_clicked ()
|
|
|
|
{
|
|
|
|
string tag_string = found_entry.get_text ();
|
|
|
|
|
|
|
|
vector<string> tags;
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
if (!PBD::tokenize (tag_string, string(","), std::back_inserter (tags), true)) {
|
2007-01-09 18:24:54 -05:00
|
|
|
warning << _("SoundFileBrowser: Could not tokenize string: ") << tag_string << endmsg;
|
|
|
|
return;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
vector<string> results;
|
|
|
|
Library->search_members_and (results, tags);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-01-09 18:24:54 -05:00
|
|
|
found_list->clear();
|
|
|
|
for (vector<string>::iterator i = results.begin(); i != results.end(); ++i) {
|
2007-10-11 18:07:47 -04:00
|
|
|
TreeModel::iterator new_row = found_list->append();
|
|
|
|
TreeModel::Row row = *new_row;
|
|
|
|
string path = Glib::filename_from_uri (string ("file:") + *i);
|
|
|
|
row[found_list_columns.pathname] = path;
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
2005-12-07 17:57:47 -05:00
|
|
|
}
|
|
|
|
|
2013-06-14 14:17:24 -04:00
|
|
|
|
|
|
|
std::string
|
|
|
|
SoundFileBrowser::freesound_get_audio_file(Gtk::TreeIter iter)
|
|
|
|
{
|
|
|
|
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
Mootcher *mootcher = new Mootcher(freesound_token);
|
2013-06-14 14:17:24 -04:00
|
|
|
std::string file;
|
|
|
|
|
|
|
|
string id = (*iter)[freesound_list_columns.id];
|
|
|
|
string uri = (*iter)[freesound_list_columns.uri];
|
2022-05-16 13:10:34 -04:00
|
|
|
string filename = ARDOUR::legalize_for_path((*iter)[freesound_list_columns.filename]);
|
2013-06-14 14:17:24 -04:00
|
|
|
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
if (mootcher->checkAudioFile(filename, id)) {
|
2013-06-14 14:17:24 -04:00
|
|
|
// file already exists, no need to download it again
|
|
|
|
file = mootcher->audioFileName;
|
|
|
|
delete mootcher;
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
(*iter)[freesound_list_columns.downloading] = false;
|
2013-06-14 14:17:24 -04:00
|
|
|
return file;
|
|
|
|
}
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
|
|
|
|
if (!(*iter)[freesound_list_columns.downloading]) {
|
2013-06-14 14:17:24 -04:00
|
|
|
// start downloading the sound file
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
DEBUG_TRACE(PBD::DEBUG::Freesound, string_compose("downloading %1 (id %2) from %3...\n", filename, id, uri));
|
|
|
|
(*iter)[freesound_list_columns.downloading] = true;
|
|
|
|
// if we don't already have a token, fetchAudioFile() will get
|
Fix various typos
Found via `codespell -q 3 -S *.po,./.git,./share/patchfiles,./libs,./msvc_extra_headers,./share/web_surfaces,*.patch -L ba,buss,busses,discreet,doubleclick,hsi,ontop,ro,scrollin,seh,siz,sord,sur,te,trough,ue`
2022-08-01 14:21:37 -04:00
|
|
|
// one: otherwise it'll return the one we already gave it.
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
if (!mootcher->fetchAudioFile(filename, id, uri, this, freesound_token)) {
|
|
|
|
// download cancelled or failed
|
|
|
|
(*iter)[freesound_list_columns.downloading] = false;
|
|
|
|
}
|
2013-06-14 14:17:24 -04:00
|
|
|
}
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
|
2013-06-14 14:17:24 -04:00
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::freesound_list_view_selected ()
|
|
|
|
{
|
|
|
|
|
|
|
|
if (!reset_options ()) {
|
|
|
|
set_action_sensitive (false);
|
|
|
|
} else {
|
|
|
|
std::string file;
|
|
|
|
ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
|
|
|
|
for (ListPath::iterator i = rows.begin() ; i != rows.end(); ++i) {
|
|
|
|
file = freesound_get_audio_file (freesound_list->get_iter(*i));
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (rows.size()) {
|
|
|
|
case 0:
|
|
|
|
// nothing selected
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
freesound_similar_btn.set_sensitive (false);
|
2013-06-14 14:17:24 -04:00
|
|
|
set_action_sensitive (false);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
// exactly one item selected
|
|
|
|
if (file != "") {
|
|
|
|
// file exists on disk already
|
|
|
|
chooser.set_filename (file);
|
|
|
|
preview.setup_labels (file);
|
|
|
|
set_action_sensitive (true);
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
} else {
|
|
|
|
// file doesn't exist yet, maybe still downloading:
|
|
|
|
// disable preview
|
|
|
|
preview.setup_labels ("");
|
2013-06-14 14:17:24 -04:00
|
|
|
}
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
freesound_similar_btn.set_sensitive (true);
|
2013-06-14 14:17:24 -04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// multiple items selected
|
|
|
|
preview.setup_labels ("");
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
freesound_similar_btn.set_sensitive (false);
|
2013-06-14 14:17:24 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::refresh_display(std::string ID, std::string file)
|
|
|
|
{
|
|
|
|
// called when the mootcher has finished downloading a file
|
|
|
|
ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
|
|
|
|
if (rows.size() == 1) {
|
|
|
|
// there's a single item selected in the freesound list
|
|
|
|
//XXX make a function to be used to construct the actual file name both here and in the mootcher
|
|
|
|
Gtk::TreeIter row = freesound_list->get_iter(*rows.begin());
|
2015-10-04 14:51:05 -04:00
|
|
|
std::string selected_ID = (*row)[freesound_list_columns.id];
|
2013-06-14 14:17:24 -04:00
|
|
|
if (ID == selected_ID) {
|
|
|
|
// the selected item in the freesound list is the item that has just finished downloading
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
chooser.set_filename (file);
|
2013-06-14 14:17:24 -04:00
|
|
|
preview.setup_labels (file);
|
|
|
|
set_action_sensitive (true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-11 10:06:50 -04:00
|
|
|
void
|
|
|
|
SoundFileBrowser::freesound_search_clicked ()
|
|
|
|
{
|
2013-03-15 15:59:19 -04:00
|
|
|
freesound_page = 1;
|
|
|
|
freesound_list->clear();
|
|
|
|
matches = 0;
|
|
|
|
freesound_search();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileBrowser::freesound_more_clicked ()
|
|
|
|
{
|
|
|
|
char row_path[21];
|
|
|
|
freesound_page++;
|
2011-11-14 17:04:14 -05:00
|
|
|
freesound_search();
|
2013-03-15 15:59:19 -04:00
|
|
|
snprintf(row_path, 21, "%d", (freesound_page - 1) * 100);
|
|
|
|
freesound_list_view.scroll_to_row(Gtk::TreePath(row_path), 0);
|
2008-04-11 10:06:50 -04:00
|
|
|
}
|
|
|
|
|
2022-05-27 07:09:49 -04:00
|
|
|
void
|
|
|
|
SoundFileBrowser::freesound_search_params_changed ()
|
|
|
|
{
|
|
|
|
freesound_page = 1;
|
|
|
|
freesound_more_btn.set_sensitive(false);
|
|
|
|
}
|
|
|
|
|
2012-01-18 13:43:43 -05:00
|
|
|
void
|
2013-06-14 14:17:24 -04:00
|
|
|
SoundFileBrowser::freesound_similar_clicked ()
|
2012-01-18 13:43:43 -05:00
|
|
|
{
|
2013-06-14 14:17:24 -04:00
|
|
|
ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
|
|
|
|
if (rows.size() == 1) {
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
Mootcher mootcher(""); // no need for oauth token when searching
|
2013-06-14 14:17:24 -04:00
|
|
|
string id;
|
|
|
|
Gtk::TreeIter iter = freesound_list->get_iter(*rows.begin());
|
|
|
|
id = (*iter)[freesound_list_columns.id];
|
|
|
|
freesound_list->clear();
|
|
|
|
|
|
|
|
GdkCursor *prev_cursor;
|
|
|
|
prev_cursor = gdk_window_get_cursor (get_window()->gobj());
|
|
|
|
gdk_window_set_cursor (get_window()->gobj(), gdk_cursor_new(GDK_WATCH));
|
|
|
|
gdk_flush();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2013-06-14 14:17:24 -04:00
|
|
|
std::string theString = mootcher.searchSimilar(id);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2013-06-14 14:17:24 -04:00
|
|
|
gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
|
|
|
|
handle_freesound_results(theString);
|
|
|
|
}
|
2012-01-18 13:43:43 -05:00
|
|
|
}
|
|
|
|
|
2022-05-23 11:26:21 -04:00
|
|
|
std::string SoundFileBrowser::freesound_licence_filter()
|
|
|
|
{
|
|
|
|
/* Return a filter string corresponding to the chosen licence filter
|
|
|
|
* type: see https://freesound.org/docs/api/resources_apiv2.html#text-search
|
|
|
|
* Note that values containing spaces need to be enclosed in
|
|
|
|
* double-quotes, though the documentation doesn't mention this.
|
|
|
|
*/
|
|
|
|
switch (freesound_licence.get_active_row_number()) {
|
|
|
|
case 1: return "license: Attribution"; // CC-BY
|
|
|
|
case 2: return "license: \"Attribution Noncommercial\""; // CC-BY-NC
|
|
|
|
case 3: return "license: \"Creative Commons 0\""; // PD
|
|
|
|
default: return "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-11 10:06:50 -04:00
|
|
|
void
|
2011-11-14 17:04:14 -05:00
|
|
|
SoundFileBrowser::freesound_search()
|
2008-04-11 10:06:50 -04:00
|
|
|
{
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
Mootcher mootcher(""); // no need for oauth token when searching
|
2008-04-11 10:06:50 -04:00
|
|
|
|
|
|
|
string search_string = freesound_entry.get_text ();
|
2011-11-14 17:04:14 -05:00
|
|
|
enum sortMethod sort_method = (enum sortMethod) freesound_sort.get_active_row_number();
|
2008-04-11 10:06:50 -04:00
|
|
|
|
2011-11-14 17:04:14 -05:00
|
|
|
GdkCursor *prev_cursor;
|
|
|
|
prev_cursor = gdk_window_get_cursor (get_window()->gobj());
|
|
|
|
gdk_window_set_cursor (get_window()->gobj(), gdk_cursor_new(GDK_WATCH));
|
|
|
|
gdk_flush();
|
2012-12-21 14:32:21 -05:00
|
|
|
|
2013-03-15 15:59:19 -04:00
|
|
|
std::string theString = mootcher.searchText(
|
2015-10-04 14:51:05 -04:00
|
|
|
search_string,
|
2013-03-15 15:59:19 -04:00
|
|
|
freesound_page,
|
2022-05-23 11:26:21 -04:00
|
|
|
freesound_licence_filter(),
|
2012-04-05 17:31:55 -04:00
|
|
|
sort_method
|
2013-03-15 15:59:19 -04:00
|
|
|
);
|
2011-11-14 17:04:14 -05:00
|
|
|
|
2013-03-15 15:59:19 -04:00
|
|
|
gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
|
2013-06-14 14:17:24 -04:00
|
|
|
handle_freesound_results(theString);
|
|
|
|
}
|
2008-04-11 10:06:50 -04:00
|
|
|
|
2013-06-14 14:17:24 -04:00
|
|
|
void
|
|
|
|
SoundFileBrowser::handle_freesound_results(std::string theString) {
|
2013-03-15 15:59:19 -04:00
|
|
|
XMLTree doc;
|
2020-04-22 20:26:27 -04:00
|
|
|
doc.read_buffer (theString.c_str());
|
2013-03-15 15:59:19 -04:00
|
|
|
XMLNode *root = doc.root();
|
2009-12-04 14:24:09 -05:00
|
|
|
|
2013-03-15 15:59:19 -04:00
|
|
|
if (!root) {
|
|
|
|
error << "no root XML node!" << endmsg;
|
|
|
|
return;
|
|
|
|
}
|
2011-11-14 17:04:14 -05:00
|
|
|
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
if ( strcmp(root->name().c_str(), "root") != 0) {
|
|
|
|
error << string_compose ("root node name == %1 != \"root\"", root->name()) << endmsg;
|
2013-03-15 15:59:19 -04:00
|
|
|
return;
|
|
|
|
}
|
2012-12-21 14:32:21 -05:00
|
|
|
|
2013-03-15 15:59:19 -04:00
|
|
|
// find out how many pages are available to search
|
|
|
|
int freesound_n_pages = 1;
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
XMLNode *res = root->child("count");
|
2013-03-15 15:59:19 -04:00
|
|
|
if (res) {
|
|
|
|
string result = res->child("text")->content();
|
2013-06-08 03:03:26 -04:00
|
|
|
freesound_n_pages = atoi(result);
|
2013-03-15 15:59:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int more_pages = freesound_n_pages - freesound_page;
|
|
|
|
|
|
|
|
if (more_pages > 0) {
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
freesound_more_btn.set_sensitive (true);
|
2013-03-15 15:59:19 -04:00
|
|
|
freesound_more_btn.set_tooltip_text(string_compose(P_(
|
|
|
|
"%1 more page of 100 results available",
|
|
|
|
"%1 more pages of 100 results available",
|
|
|
|
more_pages), more_pages));
|
|
|
|
} else {
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
freesound_more_btn.set_sensitive (false);
|
2013-03-15 15:59:19 -04:00
|
|
|
freesound_more_btn.set_tooltip_text(_("No more results available"));
|
|
|
|
}
|
|
|
|
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
XMLNode *sounds_root = root->child("results");
|
2013-03-15 15:59:19 -04:00
|
|
|
if (!sounds_root) {
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
error << "no child node \"results\" found!" << endmsg;
|
2013-03-15 15:59:19 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
XMLNodeList sounds = sounds_root->children();
|
|
|
|
if (sounds.size() == 0) {
|
|
|
|
/* nothing found */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
XMLNodeConstIterator niter;
|
|
|
|
XMLNode *node;
|
|
|
|
for (niter = sounds.begin(); niter != sounds.end(); ++niter) {
|
|
|
|
node = *niter;
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
if( strcmp( node->name().c_str(), "list-item") != 0 ) {
|
|
|
|
error << string_compose ("node->name()=%1 != \"list-item\"", node->name()) << endmsg;
|
2012-12-21 09:26:10 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-03-15 15:59:19 -04:00
|
|
|
// node->dump(cerr, "node:");
|
|
|
|
|
|
|
|
XMLNode *id_node = node->child ("id");
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
XMLNode *uri_node;
|
|
|
|
XMLNode *pre_node = node->child ("previews");
|
|
|
|
if (false && pre_node) {
|
|
|
|
uri_node = pre_node->child ("preview-hq-ogg");
|
|
|
|
} else {
|
|
|
|
uri_node = node->child ("download");
|
|
|
|
}
|
|
|
|
XMLNode *filename_node = node->child ("name");
|
|
|
|
XMLNode *duration_node = node->child ("duration");
|
|
|
|
XMLNode *filesize_node = node->child ("filesize");
|
|
|
|
XMLNode *samplerate_node = node->child ("samplerate");
|
|
|
|
XMLNode *licence_node = node->child ("license");
|
|
|
|
|
|
|
|
if (id_node && uri_node && filename_node && duration_node && filesize_node && samplerate_node) {
|
|
|
|
|
|
|
|
std::string id = id_node->child("text")->content();
|
|
|
|
std::string uri = uri_node->child("text")->content();
|
|
|
|
std::string filename = filename_node->child("text")->content();
|
|
|
|
std::string duration = duration_node->child("text")->content();
|
|
|
|
std::string filesize = filesize_node->child("text")->content();
|
|
|
|
std::string samplerate = samplerate_node->child("text")->content();
|
|
|
|
std::string licence = licence_node->child("text")->content();
|
|
|
|
|
|
|
|
DEBUG_TRACE(PBD::DEBUG::Freesound, string_compose(
|
|
|
|
"id=%1 ,uri=%2 ,filename=%3 ,duration=%4\n",
|
|
|
|
id, uri, filename, duration
|
|
|
|
));
|
|
|
|
|
|
|
|
double duration_seconds = atof (duration);
|
2013-03-15 15:59:19 -04:00
|
|
|
double h, m, s;
|
|
|
|
char duration_hhmmss[16];
|
2022-05-16 13:10:34 -04:00
|
|
|
if (duration_seconds > 99 * 60 * 60) {
|
2013-03-15 15:59:19 -04:00
|
|
|
strcpy(duration_hhmmss, ">99h");
|
|
|
|
} else {
|
|
|
|
s = modf(duration_seconds/60, &m) * 60;
|
|
|
|
m = modf(m/60, &h) * 60;
|
2022-05-27 07:09:49 -04:00
|
|
|
if (h > 0) {
|
|
|
|
sprintf(duration_hhmmss, "%2.fh:%02.fm:%04.1fs", h, m, s);
|
|
|
|
} else if (m > 0) {
|
|
|
|
sprintf(duration_hhmmss, "%2.fm:%04.1fs", m, s);
|
|
|
|
} else {
|
|
|
|
sprintf(duration_hhmmss, "%4.1fs", s);
|
|
|
|
}
|
2013-03-15 15:59:19 -04:00
|
|
|
}
|
2011-11-14 17:04:14 -05:00
|
|
|
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
double size_bytes = atof(filesize);
|
2013-03-15 15:59:19 -04:00
|
|
|
char bsize[32];
|
|
|
|
if (size_bytes < 1000) {
|
|
|
|
sprintf(bsize, "%.0f %s", size_bytes, _("B"));
|
|
|
|
} else if (size_bytes < 1000000 ) {
|
|
|
|
sprintf(bsize, "%.1f %s", size_bytes / 1000.0, _("kB"));
|
|
|
|
} else if (size_bytes < 10000000) {
|
|
|
|
sprintf(bsize, "%.1f %s", size_bytes / 1000000.0, _("MB"));
|
|
|
|
} else if (size_bytes < 1000000000) {
|
|
|
|
sprintf(bsize, "%.2f %s", size_bytes / 1000000.0, _("MB"));
|
|
|
|
} else {
|
|
|
|
sprintf(bsize, "%.2f %s", size_bytes / 1000000000.0, _("GB"));
|
2012-03-09 17:02:48 -05:00
|
|
|
}
|
2011-11-14 17:04:14 -05:00
|
|
|
|
2013-03-15 15:59:19 -04:00
|
|
|
/* see http://www.freesound.org/help/faq/#licenses */
|
|
|
|
char shortlicense[64];
|
2022-05-23 13:08:25 -04:00
|
|
|
if (licence.find("://creativecommons.org/licenses/by-nc/") != std::string::npos){
|
2013-03-15 15:59:19 -04:00
|
|
|
sprintf(shortlicense, "CC-BY-NC");
|
2022-05-23 13:08:25 -04:00
|
|
|
} else if (licence.find ("://creativecommons.org/licenses/by/") != std::string::npos) {
|
2013-03-15 15:59:19 -04:00
|
|
|
sprintf(shortlicense, "CC-BY");
|
2022-05-23 13:08:25 -04:00
|
|
|
} else if (licence.find ("://creativecommons.org/licenses/sampling+/1.0/") != std::string::npos) {
|
2013-03-15 15:59:19 -04:00
|
|
|
sprintf(shortlicense, "sampling+");
|
2022-05-23 13:08:25 -04:00
|
|
|
} else if (licence.find ("://creativecommons.org/publicdomain/") != std::string::npos) {
|
2013-03-15 15:59:19 -04:00
|
|
|
sprintf(shortlicense, "PD");
|
|
|
|
} else {
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
snprintf(shortlicense, 64, "%s", licence.c_str());
|
2013-03-15 15:59:19 -04:00
|
|
|
shortlicense[63]= '\0';
|
|
|
|
}
|
2012-04-05 17:31:55 -04:00
|
|
|
|
2013-03-15 15:59:19 -04:00
|
|
|
TreeModel::iterator new_row = freesound_list->append();
|
|
|
|
TreeModel::Row row = *new_row;
|
|
|
|
|
|
|
|
row[freesound_list_columns.id ] = id;
|
|
|
|
row[freesound_list_columns.uri ] = uri;
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
row[freesound_list_columns.filename] = filename;
|
2013-03-15 15:59:19 -04:00
|
|
|
row[freesound_list_columns.duration] = duration_hhmmss;
|
|
|
|
row[freesound_list_columns.filesize] = bsize;
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
row[freesound_list_columns.smplrate] = samplerate;
|
2013-03-15 15:59:19 -04:00
|
|
|
row[freesound_list_columns.license ] = shortlicense;
|
2022-05-27 07:09:49 -04:00
|
|
|
row[freesound_list_columns.tooltip ] = Gtkmm2ext::markup_escape_text(filename) + "\n" + licence;
|
2013-03-15 15:59:19 -04:00
|
|
|
matches++;
|
freesound: update to API v2
Add a new client id & token for Ardour 7, and update to Freesound's API
v2.
Implement OAuth authentication for Freesound downloads, as described at:
https://freesound.org/docs/api/authentication.html#oauth-authentication
Open the Freesound login page in the default browser, so that the user
can log in and get an authorization code, to copy-&-paste from the
browser. Exchange this authorization code for an access token, and use
it in a custom 'Authorization: Bearer $TOKEN' http header.
If logging in to Freesound to download a file fails or is cancelled,
clear the 'downloading' flag for that file in the list so that a
subsequent click on it will try to log in again.
Show login progress in download progress bar, and disable preview if
file hasn't yet been downloaded.
If a download fails for any reason (except the user cancelling it),
report an error in the Log window.
Use curl_free() for pointers returned by curl_easy_escape(), as per the
curl documentation, rather than plain free().
Also, don't use the www. sub-domain of freesound.org: although it
appears to work for most things, it returns an empty document from
https://freesound.org/apiv2/oauth2/access_token/
Remove default empty token value from Mootcher constructor, to make it
explicit when we construct a Mootcher that doesn't require
authorisation, by requiring an empty token parameter in that case.
2022-05-16 13:10:34 -04:00
|
|
|
} else {
|
|
|
|
error << _("Failed to retrieve XML for file") << std::endl;
|
2013-03-15 15:59:19 -04:00
|
|
|
}
|
|
|
|
}
|
2008-04-11 10:06:50 -04:00
|
|
|
}
|
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
vector<string>
|
2007-10-11 18:07:47 -04:00
|
|
|
SoundFileBrowser::get_paths ()
|
2005-10-12 23:48:57 -04:00
|
|
|
{
|
2010-09-14 12:51:02 -04:00
|
|
|
vector<string> results;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
int n = notebook.get_current_page ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
if (n == 0) {
|
2010-09-14 12:51:02 -04:00
|
|
|
vector<string> filenames = chooser.get_filenames();
|
|
|
|
vector<string>::iterator i;
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2022-09-12 18:50:49 -04:00
|
|
|
struct SortByName {
|
|
|
|
bool operator() (std::string const& a, std::string const& b) const {
|
|
|
|
return PBD::naturally_less (a.c_str (), b.c_str ());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
std::map<std::string, int64_t, SortByName> im;
|
2022-09-09 18:55:28 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
for (i = filenames.begin(); i != filenames.end(); ++i) {
|
2015-07-17 10:03:24 -04:00
|
|
|
GStatBuf buf;
|
|
|
|
if ((!g_stat((*i).c_str(), &buf)) && S_ISREG(buf.st_mode)) {
|
2007-10-11 18:07:47 -04:00
|
|
|
results.push_back (*i);
|
2022-09-09 18:55:28 -04:00
|
|
|
im[*i] = buf.st_mtime;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sort_order () == FileMtime) {
|
|
|
|
results.clear ();
|
|
|
|
std::multimap<int64_t, std::string> im2;
|
|
|
|
std::transform (im.begin (), im.end (),
|
|
|
|
std::inserter (im2, im2.begin ()),
|
|
|
|
[](std::pair<std::string, int64_t>i) {return std::pair<int64_t, std::string>(i.second, i.first);});
|
|
|
|
|
|
|
|
for (auto const& i : im2) {
|
|
|
|
results.push_back (i.second);
|
|
|
|
}
|
|
|
|
} else if (sort_order () == FileName) {
|
|
|
|
results.clear ();
|
|
|
|
for (auto const& i : im) {
|
|
|
|
results.push_back (i.first);
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2013-06-14 14:17:24 -04:00
|
|
|
} else if (n == 1) {
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
ListPath rows = found_list_view.get_selection()->get_selected_rows ();
|
|
|
|
for (ListPath::iterator i = rows.begin() ; i != rows.end(); ++i) {
|
|
|
|
TreeIter iter = found_list->get_iter(*i);
|
2010-09-14 12:51:02 -04:00
|
|
|
string str = (*iter)[found_list_columns.pathname];
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-04-11 10:06:50 -04:00
|
|
|
results.push_back (str);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
|
|
|
|
for (ListPath::iterator i = rows.begin() ; i != rows.end(); ++i) {
|
2013-06-14 14:17:24 -04:00
|
|
|
string str = freesound_get_audio_file (freesound_list->get_iter(*i));
|
2012-01-18 13:43:43 -05:00
|
|
|
if (str != "") {
|
|
|
|
results.push_back (str);
|
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return results;
|
2005-10-12 23:48:57 -04:00
|
|
|
}
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
void
|
|
|
|
SoundFileOmega::reset_options_noret ()
|
2007-01-09 18:24:54 -05:00
|
|
|
{
|
2007-10-11 18:07:47 -04:00
|
|
|
if (!resetting_ourselves) {
|
|
|
|
(void) reset_options ();
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
bool
|
|
|
|
SoundFileOmega::reset_options ()
|
2005-10-12 23:48:57 -04:00
|
|
|
{
|
2015-12-07 18:28:45 -05:00
|
|
|
if (_import_active) {
|
|
|
|
_reset_post_import = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
vector<string> paths = get_paths ();
|
2006-04-11 23:09:25 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
if (paths.empty()) {
|
2006-04-11 23:09:25 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
channel_combo.set_sensitive (false);
|
|
|
|
action_combo.set_sensitive (false);
|
2022-09-09 19:07:17 -04:00
|
|
|
sort_combo.set_sensitive (false);
|
2007-10-11 18:07:47 -04:00
|
|
|
where_combo.set_sensitive (false);
|
2012-06-19 17:40:06 -04:00
|
|
|
copy_files_btn.set_active (true);
|
2007-10-11 18:07:47 -04:00
|
|
|
copy_files_btn.set_sensitive (false);
|
2022-09-09 19:07:17 -04:00
|
|
|
midi_track_name_combo.set_sensitive (false);
|
|
|
|
smf_tempo_btn.set_sensitive (false);
|
|
|
|
smf_marker_btn.set_sensitive (false);
|
2006-04-11 23:09:25 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
return false;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
channel_combo.set_sensitive (true);
|
|
|
|
action_combo.set_sensitive (true);
|
|
|
|
where_combo.set_sensitive (true);
|
2022-09-09 19:07:17 -04:00
|
|
|
sort_combo.set_sensitive (paths.size () > 1 && (ImportAsTrack == get_mode () || ImportAsTrigger == get_mode ()));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
/* if we get through this function successfully, this may be
|
|
|
|
reset at the end, once we know if we can use hard links
|
2012-06-18 19:42:54 -04:00
|
|
|
to do embedding (or if we are importing a MIDI file).
|
2007-10-11 18:07:47 -04:00
|
|
|
*/
|
|
|
|
|
2020-04-14 11:37:06 -04:00
|
|
|
copy_files_btn.set_sensitive (false);
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
bool same_size;
|
|
|
|
bool src_needed;
|
2019-12-06 12:11:19 -05:00
|
|
|
bool must_copy;
|
2007-10-11 18:07:47 -04:00
|
|
|
bool selection_includes_multichannel;
|
2009-12-17 13:24:23 -05:00
|
|
|
bool selection_can_be_embedded_with_links = check_link_status (_session, paths);
|
2007-10-11 18:07:47 -04:00
|
|
|
ImportMode mode;
|
|
|
|
|
2012-06-18 19:42:54 -04:00
|
|
|
/* See if we are thinking about importing any MIDI files */
|
|
|
|
vector<string>::iterator i = paths.begin ();
|
2014-04-28 16:44:40 -04:00
|
|
|
while (i != paths.end() && SMFSource::valid_midi_file (*i) == false) {
|
2012-06-18 19:42:54 -04:00
|
|
|
++i;
|
|
|
|
}
|
|
|
|
bool const have_a_midi_file = (i != paths.end ());
|
|
|
|
|
2019-12-06 12:11:19 -05:00
|
|
|
if (check_info (paths, same_size, src_needed, selection_includes_multichannel, must_copy)) {
|
2009-12-11 18:29:48 -05:00
|
|
|
Glib::signal_idle().connect (sigc::mem_fun (*this, &SoundFileOmega::bad_file_message));
|
2007-10-11 18:07:47 -04:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-09-09 19:07:17 -04:00
|
|
|
midi_track_name_combo.set_sensitive (have_a_midi_file);
|
|
|
|
smf_tempo_btn.set_sensitive (have_a_midi_file);
|
|
|
|
smf_marker_btn.set_sensitive (have_a_midi_file);
|
2016-12-16 09:14:08 -05:00
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
string existing_choice;
|
2007-10-11 18:07:47 -04:00
|
|
|
vector<string> action_strings;
|
|
|
|
|
2012-05-21 05:13:59 -04:00
|
|
|
resetting_ourselves = true;
|
|
|
|
|
2011-07-26 13:22:10 -04:00
|
|
|
if (chooser.get_filter() == &audio_filter) {
|
|
|
|
|
|
|
|
/* AUDIO */
|
|
|
|
|
|
|
|
if (selected_audio_track_cnt > 0) {
|
|
|
|
if (channel_combo.get_active_text().length()) {
|
|
|
|
ImportDisposition id = get_channel_disposition();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-26 13:22:10 -04:00
|
|
|
switch (id) {
|
|
|
|
case Editing::ImportDistinctFiles:
|
|
|
|
if (selected_audio_track_cnt == paths.size()) {
|
|
|
|
action_strings.push_back (importmode2string (ImportToTrack));
|
|
|
|
}
|
|
|
|
break;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-26 13:22:10 -04:00
|
|
|
case Editing::ImportDistinctChannels:
|
|
|
|
/* XXX it would be nice to allow channel-per-selected track
|
|
|
|
but its too hard we don't want to deal with all the
|
|
|
|
different per-file + per-track channel configurations.
|
|
|
|
*/
|
|
|
|
break;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-26 13:22:10 -04:00
|
|
|
default:
|
2007-10-11 18:07:47 -04:00
|
|
|
action_strings.push_back (importmode2string (ImportToTrack));
|
2011-07-26 13:22:10 -04:00
|
|
|
break;
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
2011-07-26 13:22:10 -04:00
|
|
|
}
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-07-26 13:22:10 -04:00
|
|
|
} else {
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2012-05-21 05:13:59 -04:00
|
|
|
/* MIDI ONLY */
|
2011-07-26 13:22:10 -04:00
|
|
|
|
|
|
|
if (selected_midi_track_cnt > 0) {
|
|
|
|
action_strings.push_back (importmode2string (ImportToTrack));
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
action_strings.push_back (importmode2string (ImportAsTrack));
|
|
|
|
action_strings.push_back (importmode2string (ImportAsRegion));
|
|
|
|
|
|
|
|
existing_choice = action_combo.get_active_text();
|
|
|
|
|
|
|
|
set_popdown_strings (action_combo, action_strings);
|
|
|
|
|
|
|
|
/* preserve any existing choice, if possible */
|
|
|
|
if (existing_choice.length()) {
|
|
|
|
vector<string>::iterator x;
|
|
|
|
for (x = action_strings.begin(); x != action_strings.end(); ++x) {
|
|
|
|
if (*x == existing_choice) {
|
|
|
|
action_combo.set_active_text (existing_choice);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (x == action_strings.end()) {
|
|
|
|
action_combo.set_active_text (action_strings.front());
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
action_combo.set_active_text (action_strings.front());
|
|
|
|
}
|
|
|
|
|
|
|
|
resetting_ourselves = false;
|
|
|
|
|
|
|
|
if ((mode = get_mode()) == ImportAsRegion) {
|
|
|
|
where_combo.set_sensitive (false);
|
|
|
|
} else {
|
|
|
|
where_combo.set_sensitive (true);
|
|
|
|
}
|
|
|
|
|
|
|
|
vector<string> channel_strings;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2020-02-25 23:35:07 -05:00
|
|
|
if (mode == ImportAsTrack || mode == ImportToTrack) {
|
2016-12-13 11:48:20 -05:00
|
|
|
|
2019-08-14 19:30:17 -04:00
|
|
|
channel_strings.push_back (_("one track per file"));
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
if (selection_includes_multichannel) {
|
|
|
|
channel_strings.push_back (_("one track per channel"));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (paths.size() > 1) {
|
|
|
|
/* tape tracks are a single region per track, so we cannot
|
|
|
|
sequence multiple files.
|
|
|
|
*/
|
2020-02-25 23:35:07 -05:00
|
|
|
channel_strings.push_back (_("sequence files"));
|
2007-10-11 18:07:47 -04:00
|
|
|
if (same_size) {
|
2010-03-16 11:33:04 -04:00
|
|
|
channel_strings.push_back (_("all files in one track"));
|
2010-08-20 18:36:35 -04:00
|
|
|
channel_strings.push_back (_("merge files"));
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
channel_strings.push_back (_("one region per file"));
|
|
|
|
|
|
|
|
if (selection_includes_multichannel) {
|
|
|
|
channel_strings.push_back (_("one region per channel"));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (paths.size() > 1) {
|
|
|
|
if (same_size) {
|
|
|
|
channel_strings.push_back (_("all files in one region"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-29 20:54:02 -04:00
|
|
|
resetting_ourselves = true;
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
existing_choice = channel_combo.get_active_text();
|
|
|
|
|
|
|
|
set_popdown_strings (channel_combo, channel_strings);
|
|
|
|
|
|
|
|
/* preserve any existing choice, if possible */
|
|
|
|
|
|
|
|
if (existing_choice.length()) {
|
|
|
|
vector<string>::iterator x;
|
|
|
|
for (x = channel_strings.begin(); x != channel_strings.end(); ++x) {
|
|
|
|
if (*x == existing_choice) {
|
|
|
|
channel_combo.set_active_text (existing_choice);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (x == channel_strings.end()) {
|
|
|
|
channel_combo.set_active_text (channel_strings.front());
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
channel_combo.set_active_text (channel_strings.front());
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
2006-03-22 12:03:00 -05:00
|
|
|
|
2010-08-29 20:54:02 -04:00
|
|
|
resetting_ourselves = false;
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
if (src_needed) {
|
|
|
|
src_combo.set_sensitive (true);
|
|
|
|
} else {
|
|
|
|
src_combo.set_sensitive (false);
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2013-03-30 14:12:31 -04:00
|
|
|
/* We must copy MIDI files or those from Freesound
|
|
|
|
* or any file if we are under nsm control */
|
2019-12-06 12:11:19 -05:00
|
|
|
must_copy |= _session->get_nsm_state() || have_a_midi_file || notebook.get_current_page() == 2;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2020-04-14 11:37:06 -04:00
|
|
|
if (must_copy || !selection_can_be_embedded_with_links) {
|
|
|
|
copy_files_btn.set_active (true);
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
2020-04-14 11:37:06 -04:00
|
|
|
copy_files_btn.set_sensitive (!must_copy && selection_can_be_embedded_with_links);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
return true;
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
bool
|
|
|
|
SoundFileOmega::bad_file_message()
|
|
|
|
{
|
2009-10-14 12:10:01 -04:00
|
|
|
MessageDialog msg (*this,
|
2010-08-16 20:28:20 -04:00
|
|
|
string_compose (_("One or more of the selected files\ncannot be used by %1"), PROGRAM_NAME),
|
2007-10-11 18:07:47 -04:00
|
|
|
true,
|
|
|
|
Gtk::MESSAGE_INFO,
|
|
|
|
Gtk::BUTTONS_OK);
|
|
|
|
msg.run ();
|
|
|
|
resetting_ourselves = true;
|
|
|
|
chooser.unselect_uri (chooser.get_preview_uri());
|
|
|
|
resetting_ourselves = false;
|
|
|
|
|
|
|
|
return false;
|
2005-10-12 23:48:57 -04:00
|
|
|
}
|
|
|
|
|
2006-03-22 12:03:00 -05:00
|
|
|
bool
|
2019-12-06 12:11:19 -05:00
|
|
|
SoundFileOmega::check_info (const vector<string>& paths, bool& same_size, bool& src_needed, bool& multichannel, bool& must_copy)
|
2006-03-22 12:03:00 -05:00
|
|
|
{
|
2008-03-17 16:54:03 -04:00
|
|
|
SoundFileInfo info;
|
2017-09-18 12:39:17 -04:00
|
|
|
samplepos_t sz = 0;
|
2007-10-11 18:07:47 -04:00
|
|
|
bool err = false;
|
2008-03-17 16:54:03 -04:00
|
|
|
string errmsg;
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
same_size = true;
|
|
|
|
src_needed = false;
|
|
|
|
multichannel = false;
|
2019-12-06 12:11:19 -05:00
|
|
|
must_copy = false;
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2008-03-17 16:54:03 -04:00
|
|
|
if (AudioFileSource::get_soundfile_info (*i, info, errmsg)) {
|
2007-10-11 18:07:47 -04:00
|
|
|
if (info.channels > 1) {
|
|
|
|
multichannel = true;
|
|
|
|
}
|
|
|
|
if (sz == 0) {
|
2008-03-17 16:54:03 -04:00
|
|
|
sz = info.length;
|
2007-10-11 18:07:47 -04:00
|
|
|
} else {
|
2008-03-17 16:54:03 -04:00
|
|
|
if (sz != info.length) {
|
2007-10-11 18:07:47 -04:00
|
|
|
same_size = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
if (info.samplerate != _session->sample_rate()) {
|
2007-10-11 18:07:47 -04:00
|
|
|
src_needed = true;
|
|
|
|
}
|
2019-12-06 12:11:19 -05:00
|
|
|
if (!info.seekable) {
|
|
|
|
must_copy = true;
|
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2014-04-28 16:44:40 -04:00
|
|
|
} else if (SMFSource::valid_midi_file (*i)) {
|
2008-03-17 16:54:03 -04:00
|
|
|
|
2009-02-25 18:21:49 -05:00
|
|
|
Evoral::SMF reader;
|
2008-03-17 16:54:03 -04:00
|
|
|
|
2016-12-13 11:48:20 -05:00
|
|
|
if (reader.open (*i)) {
|
|
|
|
err = true;
|
|
|
|
} else {
|
2021-11-13 17:22:40 -05:00
|
|
|
if (reader.num_channels() > 1) {
|
|
|
|
multichannel = true;
|
2016-12-13 11:48:20 -05:00
|
|
|
}
|
|
|
|
}
|
2008-03-17 16:54:03 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
} else {
|
|
|
|
err = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
2006-03-22 12:03:00 -05:00
|
|
|
}
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
bool
|
2010-09-14 12:51:02 -04:00
|
|
|
SoundFileOmega::check_link_status (const Session* s, const vector<string>& paths)
|
2005-10-12 23:48:57 -04:00
|
|
|
{
|
2012-06-23 01:06:54 -04:00
|
|
|
std::string tmpdir(Glib::build_filename (s->session_directory().sound_path(), "linktest"));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2015-07-17 10:03:24 -04:00
|
|
|
if (g_mkdir (tmpdir.c_str(), 0744)) {
|
2007-10-11 18:07:47 -04:00
|
|
|
if (errno != EEXIST) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2013-10-04 12:46:31 -04:00
|
|
|
char tmpc[PATH_MAX+1];
|
2007-10-11 18:07:47 -04:00
|
|
|
snprintf (tmpc, sizeof(tmpc), "%s/%s", tmpdir.c_str(), Glib::path_get_basename (*i).c_str());
|
|
|
|
|
|
|
|
/* can we link ? */
|
2019-08-12 10:42:07 -04:00
|
|
|
if (PBD::hard_link (/*existing file*/(*i).c_str(), tmpc)) {
|
|
|
|
::g_unlink (tmpc);
|
2007-01-11 14:50:49 -05:00
|
|
|
}
|
2007-01-09 18:24:54 -05:00
|
|
|
}
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2015-07-17 10:03:24 -04:00
|
|
|
g_rmdir (tmpdir.c_str());
|
2019-10-10 17:25:13 -04:00
|
|
|
|
|
|
|
return true;
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
|
2012-12-23 15:34:43 -05:00
|
|
|
SoundFileChooser::SoundFileChooser (string title, ARDOUR::Session* s)
|
|
|
|
: SoundFileBrowser (title, s, false)
|
2007-10-11 18:07:47 -04:00
|
|
|
{
|
|
|
|
chooser.set_select_multiple (false);
|
|
|
|
found_list_view.get_selection()->set_mode (SELECTION_SINGLE);
|
2008-04-11 10:06:50 -04:00
|
|
|
freesound_list_view.get_selection()->set_mode (SELECTION_SINGLE);
|
2005-10-12 23:48:57 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-10-11 18:07:47 -04:00
|
|
|
SoundFileChooser::on_hide ()
|
2005-10-12 23:48:57 -04:00
|
|
|
{
|
2012-12-23 13:25:26 -05:00
|
|
|
ArdourWindow::on_hide();
|
2007-10-11 18:07:47 -04:00
|
|
|
stop_metering ();
|
2006-03-22 12:03:00 -05:00
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
if (_session) {
|
|
|
|
_session->cancel_audition();
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
string
|
2007-10-11 18:07:47 -04:00
|
|
|
SoundFileChooser::get_filename ()
|
|
|
|
{
|
2010-09-14 12:51:02 -04:00
|
|
|
vector<string> paths;
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
paths = get_paths ();
|
|
|
|
|
|
|
|
if (paths.empty()) {
|
2010-09-14 12:51:02 -04:00
|
|
|
return string ();
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
if (!Glib::file_test (paths.front(), Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
|
2010-09-14 12:51:02 -04:00
|
|
|
return string();
|
2006-03-22 12:03:00 -05:00
|
|
|
}
|
2005-12-07 23:55:46 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
return paths.front();
|
|
|
|
}
|
|
|
|
|
2015-10-04 14:51:05 -04:00
|
|
|
SoundFileOmega::SoundFileOmega (string title, ARDOUR::Session* s,
|
|
|
|
uint32_t selected_audio_tracks,
|
|
|
|
uint32_t selected_midi_tracks,
|
2011-07-26 13:22:10 -04:00
|
|
|
bool persistent,
|
2007-10-11 18:07:47 -04:00
|
|
|
Editing::ImportMode mode_hint)
|
2012-12-23 15:34:43 -05:00
|
|
|
: SoundFileBrowser (title, s, persistent)
|
2022-02-04 21:31:21 -05:00
|
|
|
, instrument_combo (InstrumentSelector::ForTrackSelector)
|
2011-07-26 13:22:10 -04:00
|
|
|
, copy_files_btn ( _("Copy files to session"))
|
2022-09-09 19:07:17 -04:00
|
|
|
, smf_tempo_btn (_("Use MIDI Tempo Map"))
|
|
|
|
, smf_marker_btn (_("Import MIDI markers"))
|
2011-07-26 13:22:10 -04:00
|
|
|
, selected_audio_track_cnt (selected_audio_tracks)
|
|
|
|
, selected_midi_track_cnt (selected_midi_tracks)
|
2015-12-07 18:28:45 -05:00
|
|
|
, _import_active (false)
|
|
|
|
, _reset_post_import (false)
|
2007-10-11 18:07:47 -04:00
|
|
|
{
|
|
|
|
vector<string> str;
|
|
|
|
|
2016-07-10 08:08:24 -04:00
|
|
|
set_size_request (-1, 550);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
str.clear ();
|
2009-07-12 20:26:28 -04:00
|
|
|
str.push_back (_("file timestamp"));
|
|
|
|
str.push_back (_("edit point"));
|
|
|
|
str.push_back (_("playhead"));
|
|
|
|
str.push_back (_("session start"));
|
2007-10-11 18:07:47 -04:00
|
|
|
set_popdown_strings (where_combo, str);
|
2016-05-22 16:13:03 -04:00
|
|
|
where_combo.set_active_text (str.back());
|
2014-03-09 19:48:48 -04:00
|
|
|
where_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::where_combo_changed));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2019-02-01 11:17:48 -05:00
|
|
|
instrument_combo_changed();
|
|
|
|
instrument_combo.signal_changed().connect(sigc::mem_fun(*this, &SoundFileOmega::instrument_combo_changed) );
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
Label* l = manage (new Label);
|
2015-10-08 20:05:41 -04:00
|
|
|
l->set_markup (_("<b>Add files ...</b>"));
|
2016-07-10 08:08:24 -04:00
|
|
|
options.attach (*l, 0, 1, 0, 1, FILL, SHRINK, 8, 0);
|
|
|
|
options.attach (action_combo, 0, 1, 1, 2, FILL, SHRINK, 8, 0);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
l = manage (new Label);
|
2012-10-22 11:31:42 -04:00
|
|
|
l->set_markup (_("<b>Insert at</b>"));
|
2022-09-09 19:07:17 -04:00
|
|
|
options.attach (*l, 0, 1, 2, 3, FILL, SHRINK, 8, 0);
|
|
|
|
options.attach (where_combo, 0, 1, 3, 4, FILL, SHRINK, 8, 0);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2016-07-10 08:08:24 -04:00
|
|
|
l = manage (new Label);
|
|
|
|
l->set_markup (_("<b>Mapping</b>"));
|
2022-09-09 19:07:17 -04:00
|
|
|
options.attach (*l, 0, 1, 4, 5, FILL, SHRINK, 8, 0);
|
|
|
|
options.attach (channel_combo, 0, 1, 5, 6, FILL, SHRINK, 8, 0);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2022-09-09 19:07:17 -04:00
|
|
|
/* 2nd col */
|
2016-07-10 08:08:24 -04:00
|
|
|
l = manage (new Label);
|
2022-09-09 19:07:17 -04:00
|
|
|
l->set_markup (_("<b>Sort order</b>"));
|
|
|
|
options.attach (*l, 1, 2, 0, 1, FILL, SHRINK, 8, 0);
|
|
|
|
options.attach (sort_combo, 1, 2, 1, 2, FILL, SHRINK, 8, 0);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
l = manage (new Label);
|
2022-09-09 19:07:17 -04:00
|
|
|
l->set_markup (_("<b>Conversion quality</b>"));
|
|
|
|
options.attach (*l, 1, 2, 2, 3, FILL, SHRINK, 8, 0);
|
|
|
|
options.attach (src_combo, 1, 2, 3, 4, FILL, SHRINK, 8, 0);
|
2016-12-16 08:46:13 -05:00
|
|
|
|
2022-09-09 19:07:17 -04:00
|
|
|
options.attach (copy_files_btn, 1, 2, 5, 6, FILL, SHRINK, 8, 0);
|
2016-12-14 07:31:16 -05:00
|
|
|
|
2022-09-09 19:07:17 -04:00
|
|
|
/* 3rd, 4th col: MIDI */
|
2016-12-14 07:31:16 -05:00
|
|
|
l = manage (new Label);
|
|
|
|
l->set_markup (_("<b>Instrument</b>"));
|
2022-09-09 19:07:17 -04:00
|
|
|
options.attach (*l, 2, 4, 0, 1, FILL, SHRINK, 8, 0);
|
|
|
|
options.attach (instrument_combo, 2, 4, 1, 2, FILL, SHRINK, 8, 0);
|
|
|
|
|
|
|
|
l = manage (new Label);
|
|
|
|
l->set_markup (_("<b>MIDI Track Names</b>"));
|
|
|
|
options.attach (*l, 2, 4, 2, 3, FILL, SHRINK, 8, 0);
|
|
|
|
options.attach (midi_track_name_combo, 2, 4, 3, 4, FILL, SHRINK, 8, 0);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2022-09-09 19:07:17 -04:00
|
|
|
options.attach (smf_tempo_btn, 2, 3, 5, 6, FILL, SHRINK, 8, 0);
|
|
|
|
options.attach (smf_marker_btn, 3, 4, 5, 6, FILL, SHRINK, 8, 0);
|
2016-07-10 08:08:24 -04:00
|
|
|
|
|
|
|
Alignment *vspace = manage (new Alignment ());
|
2016-07-10 09:59:50 -04:00
|
|
|
vspace->set_size_request (2, 2);
|
2022-09-09 19:07:17 -04:00
|
|
|
options.attach (*vspace, 0, 4, 6, 7, EXPAND, SHRINK, 0, 0);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2016-12-14 07:31:16 -05:00
|
|
|
str.clear ();
|
|
|
|
str.push_back (_("by track number"));
|
|
|
|
str.push_back (_("by track name"));
|
|
|
|
str.push_back (_("by instrument name"));
|
|
|
|
set_popdown_strings (midi_track_name_combo, str);
|
|
|
|
midi_track_name_combo.set_active_text (str.front());
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
str.clear ();
|
|
|
|
str.push_back (_("one track per file"));
|
|
|
|
set_popdown_strings (channel_combo, str);
|
|
|
|
channel_combo.set_active_text (str.front());
|
|
|
|
channel_combo.set_sensitive (false);
|
|
|
|
|
|
|
|
str.clear ();
|
|
|
|
str.push_back (_("Best"));
|
|
|
|
str.push_back (_("Good"));
|
|
|
|
str.push_back (_("Quick"));
|
|
|
|
str.push_back (_("Fast"));
|
|
|
|
str.push_back (_("Fastest"));
|
|
|
|
|
|
|
|
set_popdown_strings (src_combo, str);
|
|
|
|
src_combo.set_active_text (str.front());
|
|
|
|
src_combo.set_sensitive (false);
|
2014-01-18 18:45:08 -05:00
|
|
|
src_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::src_combo_changed));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2022-09-09 19:07:17 -04:00
|
|
|
str.clear ();
|
|
|
|
str.push_back (_("by file name"));
|
|
|
|
str.push_back (_("by modification time"));
|
|
|
|
str.push_back (_("by selection order"));
|
|
|
|
set_popdown_strings (sort_combo, str);
|
|
|
|
sort_combo.set_active_text (str.front());
|
|
|
|
sort_combo.set_sensitive (false);
|
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
action_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::reset_options_noret));
|
2010-08-29 20:54:02 -04:00
|
|
|
channel_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::reset_options_noret));
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
copy_files_btn.set_active (true);
|
|
|
|
|
2016-07-10 08:08:24 -04:00
|
|
|
vpacker.pack_start (options, false, true);
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
/* setup disposition map */
|
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
disposition_map.insert (pair<string,ImportDisposition>(_("one track per file"), ImportDistinctFiles));
|
|
|
|
disposition_map.insert (pair<string,ImportDisposition>(_("one track per channel"), ImportDistinctChannels));
|
|
|
|
disposition_map.insert (pair<string,ImportDisposition>(_("merge files"), ImportMergeFiles));
|
|
|
|
disposition_map.insert (pair<string,ImportDisposition>(_("sequence files"), ImportSerializeFiles));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
disposition_map.insert (pair<string,ImportDisposition>(_("one region per file"), ImportDistinctFiles));
|
|
|
|
disposition_map.insert (pair<string,ImportDisposition>(_("one region per channel"), ImportDistinctChannels));
|
|
|
|
disposition_map.insert (pair<string,ImportDisposition>(_("all files in one region"), ImportMergeFiles));
|
|
|
|
disposition_map.insert (pair<string,ImportDisposition>(_("all files in one track"), ImportMergeFiles));
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2009-12-11 18:29:48 -05:00
|
|
|
chooser.signal_selection_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::file_selection_changed));
|
2009-06-26 11:53:45 -04:00
|
|
|
|
|
|
|
/* set size requests for a couple of combos to allow them to display the longest text
|
|
|
|
they will ever be asked to display. This prevents them being resized when the user
|
|
|
|
selects a file to import, which in turn prevents the size of the dialog from jumping
|
|
|
|
around. */
|
|
|
|
|
2015-09-20 14:02:40 -04:00
|
|
|
str.clear ();
|
|
|
|
str.push_back (_("one track per file"));
|
|
|
|
str.push_back (_("one track per channel"));
|
|
|
|
str.push_back (_("sequence files"));
|
|
|
|
str.push_back (_("all files in one region"));
|
|
|
|
set_popdown_strings (channel_combo, str);
|
|
|
|
|
|
|
|
str.clear ();
|
|
|
|
str.push_back (importmode2string (ImportAsTrack));
|
|
|
|
str.push_back (importmode2string (ImportToTrack));
|
|
|
|
str.push_back (importmode2string (ImportAsRegion));
|
|
|
|
set_popdown_strings (action_combo, str);
|
|
|
|
action_combo.set_active_text (importmode2string(mode_hint));
|
|
|
|
|
|
|
|
reset (selected_audio_tracks, selected_midi_tracks);
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SoundFileOmega::set_mode (ImportMode mode)
|
|
|
|
{
|
|
|
|
action_combo.set_active_text (importmode2string (mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
ImportMode
|
|
|
|
SoundFileOmega::get_mode () const
|
|
|
|
{
|
|
|
|
return string2importmode (action_combo.get_active_text());
|
|
|
|
}
|
|
|
|
|
2022-09-09 19:07:17 -04:00
|
|
|
SoundFileBrowser::SortOrder
|
|
|
|
SoundFileOmega::sort_order () const
|
|
|
|
{
|
|
|
|
std::string const& str (sort_combo.get_active_text());
|
|
|
|
if (str == _("by file name")) {
|
|
|
|
return SoundFileBrowser::FileName;
|
|
|
|
} else if (str == _("by modification time")) {
|
|
|
|
return SoundFileBrowser::FileMtime;
|
|
|
|
} else if (str == _("by selection order")) {
|
|
|
|
return SoundFileBrowser::SelectionOrder;
|
|
|
|
}
|
|
|
|
warning << string_compose (_("programming error: unknown import sort string %1"), str) << endmsg;
|
|
|
|
return SelectionOrder;
|
|
|
|
}
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
void
|
|
|
|
SoundFileOmega::on_hide ()
|
|
|
|
{
|
2012-12-23 13:25:26 -05:00
|
|
|
ArdourWindow::on_hide();
|
2009-12-17 13:24:23 -05:00
|
|
|
if (_session) {
|
|
|
|
_session->cancel_audition();
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ImportPosition
|
|
|
|
SoundFileOmega::get_position() const
|
|
|
|
{
|
2010-09-14 12:51:02 -04:00
|
|
|
string str = where_combo.get_active_text();
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2009-07-12 20:26:28 -04:00
|
|
|
if (str == _("file timestamp")) {
|
2007-10-11 18:07:47 -04:00
|
|
|
return ImportAtTimestamp;
|
2009-07-12 20:26:28 -04:00
|
|
|
} else if (str == _("edit point")) {
|
2007-11-12 17:23:01 -05:00
|
|
|
return ImportAtEditPoint;
|
2009-07-12 20:26:28 -04:00
|
|
|
} else if (str == _("playhead")) {
|
2007-10-11 18:07:47 -04:00
|
|
|
return ImportAtPlayhead;
|
|
|
|
} else {
|
|
|
|
return ImportAtStart;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SrcQuality
|
|
|
|
SoundFileOmega::get_src_quality() const
|
|
|
|
{
|
2013-02-28 19:29:11 -05:00
|
|
|
string str = src_combo.get_active_text();
|
2007-10-11 18:07:47 -04:00
|
|
|
|
|
|
|
if (str == _("Best")) {
|
|
|
|
return SrcBest;
|
|
|
|
} else if (str == _("Good")) {
|
|
|
|
return SrcGood;
|
|
|
|
} else if (str == _("Quick")) {
|
|
|
|
return SrcQuick;
|
|
|
|
} else if (str == _("Fast")) {
|
|
|
|
return SrcFast;
|
|
|
|
} else {
|
|
|
|
return SrcFastest;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-18 18:45:08 -05:00
|
|
|
void
|
|
|
|
SoundFileOmega::src_combo_changed()
|
|
|
|
{
|
|
|
|
preview.set_src_quality(get_src_quality());
|
|
|
|
}
|
|
|
|
|
2014-03-09 19:48:48 -04:00
|
|
|
void
|
|
|
|
SoundFileOmega::where_combo_changed()
|
|
|
|
{
|
|
|
|
preview.set_import_position(get_position());
|
|
|
|
}
|
|
|
|
|
2019-02-01 11:17:48 -05:00
|
|
|
void
|
|
|
|
SoundFileOmega::instrument_combo_changed()
|
|
|
|
{
|
|
|
|
_session->the_auditioner()->set_audition_synth_info( instrument_combo.selected_instrument() );
|
|
|
|
}
|
|
|
|
|
2016-12-14 07:31:16 -05:00
|
|
|
MidiTrackNameSource
|
|
|
|
SoundFileOmega::get_midi_track_name_source () const
|
|
|
|
{
|
|
|
|
return string2miditracknamesource (midi_track_name_combo.get_active_text());
|
|
|
|
}
|
|
|
|
|
2016-12-16 09:14:08 -05:00
|
|
|
bool
|
|
|
|
SoundFileOmega::get_use_smf_tempo_map () const
|
|
|
|
{
|
|
|
|
return smf_tempo_btn.get_active ();
|
|
|
|
}
|
|
|
|
|
2021-05-07 16:57:41 -04:00
|
|
|
bool
|
|
|
|
SoundFileOmega::get_use_smf_markers () const
|
|
|
|
{
|
|
|
|
return smf_marker_btn.get_active ();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
ImportDisposition
|
|
|
|
SoundFileOmega::get_channel_disposition () const
|
|
|
|
{
|
|
|
|
/* we use a map here because the channel combo can contain different strings
|
|
|
|
depending on the state of the other combos. the map contains all possible strings
|
|
|
|
and the ImportDisposition enum that corresponds to it.
|
|
|
|
*/
|
|
|
|
|
2010-09-14 12:51:02 -04:00
|
|
|
string str = channel_combo.get_active_text();
|
2007-10-11 18:07:47 -04:00
|
|
|
DispositionMap::const_iterator x = disposition_map.find (str);
|
|
|
|
|
|
|
|
if (x == disposition_map.end()) {
|
|
|
|
fatal << string_compose (_("programming error: %1 (%2)"), "unknown string for import disposition", str) << endmsg;
|
2014-11-14 04:47:43 -05:00
|
|
|
abort(); /*NOTREACHED*/
|
2006-03-22 12:03:00 -05:00
|
|
|
}
|
2005-12-07 23:55:46 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
return x->second;
|
2005-12-07 23:55:46 -05:00
|
|
|
}
|
|
|
|
|
2006-03-22 12:03:00 -05:00
|
|
|
void
|
2011-07-26 13:22:10 -04:00
|
|
|
SoundFileOmega::reset (uint32_t selected_audio_tracks, uint32_t selected_midi_tracks)
|
2006-03-22 12:03:00 -05:00
|
|
|
{
|
2011-07-26 13:22:10 -04:00
|
|
|
selected_audio_track_cnt = selected_audio_tracks;
|
|
|
|
selected_midi_track_cnt = selected_midi_tracks;
|
2012-05-21 05:13:59 -04:00
|
|
|
|
|
|
|
if (selected_audio_track_cnt == 0 && selected_midi_track_cnt > 0) {
|
|
|
|
chooser.set_filter (midi_filter);
|
|
|
|
} else if (selected_midi_track_cnt == 0 && selected_audio_track_cnt > 0) {
|
|
|
|
chooser.set_filter (audio_filter);
|
|
|
|
} else {
|
|
|
|
chooser.set_filter (audio_and_midi_filter);
|
|
|
|
}
|
|
|
|
|
2022-01-26 15:21:06 -05:00
|
|
|
if (get_visible()) {
|
2018-11-06 16:43:36 -05:00
|
|
|
reset_options ();
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2006-03-22 12:03:00 -05:00
|
|
|
|
2007-10-11 18:07:47 -04:00
|
|
|
void
|
|
|
|
SoundFileOmega::file_selection_changed ()
|
|
|
|
{
|
2022-01-26 15:21:06 -05:00
|
|
|
if (resetting_ourselves || !get_visible ()) {
|
2007-10-11 18:07:47 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!reset_options ()) {
|
2012-12-23 13:39:19 -05:00
|
|
|
set_action_sensitive (false);
|
2007-10-11 18:07:47 -04:00
|
|
|
} else {
|
|
|
|
if (chooser.get_filenames().size() > 0) {
|
2012-12-23 13:39:19 -05:00
|
|
|
set_action_sensitive (true);
|
2007-10-11 18:07:47 -04:00
|
|
|
} else {
|
2012-12-23 13:39:19 -05:00
|
|
|
set_action_sensitive (false);
|
2007-10-11 18:07:47 -04:00
|
|
|
}
|
2006-03-22 12:03:00 -05:00
|
|
|
}
|
|
|
|
}
|
2007-03-18 02:07:08 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
void
|
|
|
|
SoundFileOmega::do_something (int action)
|
|
|
|
{
|
|
|
|
SoundFileBrowser::do_something (action);
|
|
|
|
|
2018-11-28 08:56:04 -05:00
|
|
|
if (action == RESPONSE_CLOSE || !ARDOUR_UI_UTILS::engine_is_running ()) {
|
2012-12-23 13:25:26 -05:00
|
|
|
hide ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* lets do it */
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
vector<string> paths = get_paths ();
|
|
|
|
ImportPosition pos = get_position ();
|
|
|
|
ImportMode mode = get_mode ();
|
|
|
|
ImportDisposition chns = get_channel_disposition ();
|
2014-12-24 20:07:10 -05:00
|
|
|
PluginInfoPtr instrument = instrument_combo.selected_instrument();
|
2020-10-05 00:52:17 -04:00
|
|
|
timepos_t where;
|
2016-12-14 07:31:16 -05:00
|
|
|
MidiTrackNameSource mts = get_midi_track_name_source ();
|
2016-12-16 09:57:14 -05:00
|
|
|
MidiTempoMapDisposition mtd = (get_use_smf_tempo_map () ? SMFTempoUse : SMFTempoIgnore);
|
2021-05-07 16:57:41 -04:00
|
|
|
bool with_midi_markers = get_use_smf_markers ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
switch (pos) {
|
|
|
|
case ImportAtEditPoint:
|
|
|
|
where = PublicEditor::instance().get_preferred_edit_position ();
|
|
|
|
break;
|
|
|
|
case ImportAtTimestamp:
|
2020-10-05 00:52:17 -04:00
|
|
|
where = timepos_t::max (Temporal::AudioTime);
|
2012-12-23 13:25:26 -05:00
|
|
|
break;
|
|
|
|
case ImportAtPlayhead:
|
2020-10-05 00:52:17 -04:00
|
|
|
where = timepos_t (_session->transport_sample());
|
2012-12-23 13:25:26 -05:00
|
|
|
break;
|
|
|
|
case ImportAtStart:
|
2020-10-05 00:52:17 -04:00
|
|
|
where = timepos_t (_session->current_start_sample());
|
2012-12-23 13:25:26 -05:00
|
|
|
break;
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
SrcQuality quality = get_src_quality();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2015-12-07 18:28:45 -05:00
|
|
|
_import_active = true;
|
|
|
|
|
2012-12-23 13:25:26 -05:00
|
|
|
if (copy_files_btn.get_active()) {
|
2021-07-07 23:24:02 -04:00
|
|
|
PublicEditor::instance().do_import (paths, chns, mode, quality, mts, mtd, where, instrument, with_midi_markers);
|
2012-12-23 13:25:26 -05:00
|
|
|
} else {
|
2021-07-07 23:24:02 -04:00
|
|
|
PublicEditor::instance().do_embed (paths, chns, mode, where, instrument);
|
2012-12-23 13:25:26 -05:00
|
|
|
}
|
2015-12-07 18:28:45 -05:00
|
|
|
|
|
|
|
_import_active = false;
|
|
|
|
|
|
|
|
if (_reset_post_import) {
|
|
|
|
_reset_post_import = false;
|
|
|
|
reset_options ();
|
|
|
|
}
|
2012-12-23 13:25:26 -05:00
|
|
|
}
|