2 Copyright (C) 2005-2006 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "gtk2ardour-config.h"
30 #include <sys/param.h>
32 #include <gtkmm/box.h>
33 #include <gtkmm/stock.h>
34 #include <glibmm/fileutils.h>
36 #include "pbd/convert.h"
37 #include "pbd/tokenizer.h"
38 #include "pbd/enumwriter.h"
39 #include "pbd/pthread_utils.h"
40 #include "pbd/xml++.h"
42 #include <gtkmm2ext/utils.h>
44 #include "evoral/SMF.hpp"
46 #include "ardour/audio_library.h"
47 #include "ardour/auditioner.h"
48 #include "ardour/audioregion.h"
49 #include "ardour/audiofilesource.h"
50 #include "ardour/smf_source.h"
51 #include "ardour/region_factory.h"
52 #include "ardour/source_factory.h"
53 #include "ardour/session.h"
54 #include "ardour/session_directory.h"
56 #include "ardour_ui.h"
58 #include "gui_thread.h"
63 #include "gain_meter.h"
64 #include "main_clock.h"
65 #include "public_editor.h"
68 #include "sfdb_freesound_mootcher.h"
73 using namespace ARDOUR;
77 using namespace Gtkmm2ext;
78 using namespace Editing;
82 string SoundFileBrowser::persistent_folder;
85 string2importmode (string str)
87 if (str == _("as new tracks")) {
89 } else if (str == _("to selected tracks")) {
91 } else if (str == _("to region list")) {
92 return ImportAsRegion;
93 } else if (str == _("as new tape tracks")) {
94 return ImportAsTapeTrack;
97 warning << string_compose (_("programming error: unknown import mode string %1"), str) << endmsg;
103 importmode2string (ImportMode mode)
107 return _("as new tracks");
109 return _("to selected tracks");
111 return _("to region list");
112 case ImportAsTapeTrack:
113 return _("as new tape tracks");
116 return _("as new tracks");
119 SoundFileBox::SoundFileBox (bool persistent)
121 length_clock ("sfboxLengthClock", !persistent, "", false, false, true, false),
122 timecode_clock ("sfboxTimecodeClock", !persistent, "", false, false, false, false),
124 autoplay_btn (_("Auto-play"))
127 set_name (X_("SoundFileBox"));
128 set_size_request (300, -1);
130 preview_label.set_markup (_("<b>Sound File Information</b>"));
132 border_frame.set_label_widget (preview_label);
133 border_frame.add (main_box);
135 pack_start (border_frame, true, true);
136 set_border_width (6);
138 main_box.set_border_width (6);
140 length.set_text (_("Length:"));
141 length.set_alignment (1, 0.5);
142 timecode.set_text (_("Timestamp:"));
143 timecode.set_alignment (1, 0.5);
144 format.set_text (_("Format:"));
145 format.set_alignment (1, 0.5);
146 channels.set_text (_("Channels:"));
147 channels.set_alignment (1, 0.5);
148 samplerate.set_text (_("Sample rate:"));
149 samplerate.set_alignment (1, 0.5);
151 preview_label.set_max_width_chars (50);
152 preview_label.set_ellipsize (Pango::ELLIPSIZE_END);
154 format_text.set_max_width_chars (20);
155 format_text.set_ellipsize (Pango::ELLIPSIZE_END);
156 format_text.set_alignment (0, 1);
158 table.set_col_spacings (6);
159 table.set_homogeneous (false);
160 table.set_row_spacings (6);
162 table.attach (channels, 0, 1, 0, 1, FILL, FILL);
163 table.attach (samplerate, 0, 1, 1, 2, FILL, FILL);
164 table.attach (format, 0, 1, 2, 4, FILL, FILL);
165 table.attach (length, 0, 1, 4, 5, FILL, FILL);
166 table.attach (timecode, 0, 1, 5, 6, FILL, FILL);
168 table.attach (channels_value, 1, 2, 0, 1, FILL, FILL);
169 table.attach (samplerate_value, 1, 2, 1, 2, FILL, FILL);
170 table.attach (format_text, 1, 2, 2, 4, FILL, FILL);
171 table.attach (length_clock, 1, 2, 4, 5, FILL, FILL);
172 table.attach (timecode_clock, 1, 2, 5, 6, FILL, FILL);
174 length_clock.set_mode (ARDOUR_UI::instance()->secondary_clock->mode());
175 timecode_clock.set_mode (AudioClock::Timecode);
177 main_box.pack_start (table, false, false);
179 tags_entry.set_editable (true);
180 tags_entry.set_wrap_mode(Gtk::WRAP_WORD);
181 tags_entry.signal_focus_out_event().connect (sigc::mem_fun (*this, &SoundFileBox::tags_entry_left));
183 Label* label = manage (new Label (_("Tags:")));
184 label->set_alignment (0.0f, 0.5f);
185 main_box.pack_start (*label, false, false);
186 main_box.pack_start (tags_entry, true, true);
188 main_box.pack_start (bottom_box, false, false);
190 play_btn.set_image (*(manage (new Image (Stock::MEDIA_PLAY, ICON_SIZE_BUTTON))));
191 // play_btn.set_label (_("Play"));
193 stop_btn.set_image (*(manage (new Image (Stock::MEDIA_STOP, ICON_SIZE_BUTTON))));
194 // stop_btn.set_label (_("Stop"));
196 bottom_box.set_homogeneous (false);
197 bottom_box.set_spacing (6);
198 bottom_box.pack_start(play_btn, true, true);
199 bottom_box.pack_start(stop_btn, true, true);
200 bottom_box.pack_start(autoplay_btn, false, false);
202 play_btn.signal_clicked().connect (sigc::mem_fun (*this, &SoundFileBox::audition));
203 stop_btn.signal_clicked().connect (sigc::mem_fun (*this, &SoundFileBox::stop_audition));
205 channels_value.set_alignment (0.0f, 0.5f);
206 samplerate_value.set_alignment (0.0f, 0.5f);
210 SoundFileBox::set_session(Session* s)
212 SessionHandlePtr::set_session (s);
214 length_clock.set_session (s);
215 timecode_clock.set_session (s);
218 play_btn.set_sensitive (false);
219 stop_btn.set_sensitive (false);
224 SoundFileBox::setup_labels (const string& filename)
227 // save existing tags
235 if(!AudioFileSource::get_soundfile_info (filename, sf_info, error_msg)) {
237 preview_label.set_markup (_("<b>Sound File Information</b>"));
238 format_text.set_text ("");
239 channels_value.set_text ("");
240 samplerate_value.set_text ("");
241 tags_entry.get_buffer()->set_text ("");
243 length_clock.set (0);
244 timecode_clock.set (0);
246 tags_entry.set_sensitive (false);
247 play_btn.set_sensitive (false);
252 preview_label.set_markup (string_compose ("<b>%1</b>", Glib::Markup::escape_text (Glib::path_get_basename (filename))));
253 std::string n = sf_info.format_name;
254 if (n.substr (0, 8) == X_("Format: ")) {
257 format_text.set_text (n);
258 channels_value.set_text (to_string (sf_info.channels, std::dec));
260 if (_session && sf_info.samplerate != _session->frame_rate()) {
261 samplerate.set_markup (string_compose ("<b>%1</b>", _("Sample rate:")));
262 samplerate_value.set_markup (string_compose (X_("<b>%1 Hz</b>"), sf_info.samplerate));
263 samplerate_value.set_name ("NewSessionSR1Label");
264 samplerate.set_name ("NewSessionSR1Label");
266 samplerate.set_text (_("Sample rate:"));
267 samplerate_value.set_text (string_compose (X_("%1 Hz"), sf_info.samplerate));
268 samplerate_value.set_name ("NewSessionSR2Label");
269 samplerate.set_name ("NewSessionSR2Label");
272 framecnt_t const nfr = _session ? _session->nominal_frame_rate() : 25;
273 double src_coef = (double) nfr / sf_info.samplerate;
275 length_clock.set (sf_info.length * src_coef + 0.5, true);
276 timecode_clock.set (sf_info.timecode * src_coef + 0.5, true);
278 // this is a hack that is fixed in trunk, i think (august 26th, 2007)
280 vector<string> tags = Library->get_tags (string ("//") + filename);
282 stringstream tag_string;
283 for (vector<string>::iterator i = tags.begin(); i != tags.end(); ++i) {
284 if (i != tags.begin()) {
289 tags_entry.get_buffer()->set_text (tag_string.str());
291 tags_entry.set_sensitive (true);
293 play_btn.set_sensitive (true);
300 SoundFileBox::autoplay() const
302 return autoplay_btn.get_active();
306 SoundFileBox::audition_oneshot()
313 SoundFileBox::audition ()
319 if (SMFSource::safe_midi_file_extension (path)) {
320 error << _("Auditioning of MIDI files is not yet supported") << endmsg;
324 _session->cancel_audition();
326 if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
327 warning << string_compose(_("Could not read file: %1 (%2)."), path, strerror(errno)) << endmsg;
331 boost::shared_ptr<Region> r;
333 boost::shared_ptr<AudioFileSource> afs;
334 bool old_sbp = AudioSource::get_build_peakfiles ();
336 /* don't even think of building peakfiles for these files */
338 AudioSource::set_build_peakfiles (false);
340 for (int n = 0; n < sf_info.channels; ++n) {
342 afs = boost::dynamic_pointer_cast<AudioFileSource> (
343 SourceFactory::createReadable (DataType::AUDIO, *_session,
344 path, n, Source::Flag (0), false));
346 srclist.push_back(afs);
348 } catch (failed_constructor& err) {
349 error << _("Could not access soundfile: ") << path << endmsg;
350 AudioSource::set_build_peakfiles (old_sbp);
355 AudioSource::set_build_peakfiles (old_sbp);
357 if (srclist.empty()) {
361 afs = boost::dynamic_pointer_cast<AudioFileSource> (srclist[0]);
362 string rname = region_name_from_path (afs->path(), false);
366 plist.add (ARDOUR::Properties::start, 0);
367 plist.add (ARDOUR::Properties::length, srclist[0]->length(srclist[0]->timeline_position()));
368 plist.add (ARDOUR::Properties::name, rname);
369 plist.add (ARDOUR::Properties::layer, 0);
371 r = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (srclist, plist, false));
373 _session->audition_region(r);
377 SoundFileBox::stop_audition ()
380 _session->cancel_audition();
385 SoundFileBox::tags_entry_left (GdkEventFocus *)
392 SoundFileBox::tags_changed ()
394 string tag_string = tags_entry.get_buffer()->get_text ();
396 if (tag_string.empty()) {
402 if (!PBD::tokenize (tag_string, string(",\n"), std::back_inserter (tags), true)) {
403 warning << _("SoundFileBox: Could not tokenize string: ") << tag_string << endmsg;
411 SoundFileBox::save_tags (const vector<string>& tags)
413 Library->set_tags (string ("//") + path, tags);
414 Library->save_changes ();
417 SoundFileBrowser::SoundFileBrowser (string title, ARDOUR::Session* s, bool persistent)
418 : ArdourWindow (title)
419 , found_list (ListStore::create(found_list_columns))
420 , freesound_list (ListStore::create(freesound_list_columns))
421 , chooser (FILE_CHOOSER_ACTION_OPEN)
422 , preview (persistent)
423 , found_search_btn (_("Search"))
424 , found_list_view (found_list)
425 , freesound_search_btn (_("Search"))
426 , freesound_list_view (freesound_list)
427 , resetting_ourselves (false)
431 , ok_button (Stock::OK)
432 , cancel_button (Stock::CANCEL)
433 , apply_button (Stock::APPLY)
438 chooser.add_shortcut_folder_uri("file:///Library/GarageBand/Apple Loops");
439 chooser.add_shortcut_folder_uri("file:///Library/Audio/Apple Loops");
440 chooser.add_shortcut_folder_uri("file:///Library/Application Support/GarageBand/Instrument Library/Sampler/Sampler Files");
441 chooser.add_shortcut_folder_uri("file:///Volumes");
444 //add the file chooser
446 chooser.set_border_width (12);
448 audio_and_midi_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun (*this, &SoundFileBrowser::on_audio_and_midi_filter));
449 audio_and_midi_filter.set_name (_("Audio and MIDI files"));
451 audio_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun(*this, &SoundFileBrowser::on_audio_filter));
452 audio_filter.set_name (_("Audio files"));
454 midi_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun(*this, &SoundFileBrowser::on_midi_filter));
455 midi_filter.set_name (_("MIDI files"));
457 matchall_filter.add_pattern ("*.*");
458 matchall_filter.set_name (_("All files"));
460 chooser.add_filter (audio_and_midi_filter);
461 chooser.add_filter (audio_filter);
462 chooser.add_filter (midi_filter);
463 chooser.add_filter (matchall_filter);
464 chooser.set_select_multiple (true);
465 chooser.signal_update_preview().connect(sigc::mem_fun(*this, &SoundFileBrowser::update_preview));
466 chooser.signal_file_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::chooser_file_activated));
469 /* some broken redraw behaviour - this is a bandaid */
470 chooser.signal_selection_changed().connect (mem_fun (chooser, &Widget::queue_draw));
473 if (!persistent_folder.empty()) {
474 chooser.set_current_folder (persistent_folder);
477 notebook.append_page (chooser, _("Browse Files"));
479 hpacker.set_spacing (6);
480 hpacker.pack_start (notebook, true, true);
481 hpacker.pack_start (preview, false, false);
483 vpacker.set_spacing (6);
484 vpacker.pack_start (hpacker, true, true);
494 hbox = manage(new HBox);
495 hbox->pack_start (found_entry);
496 hbox->pack_start (found_search_btn);
498 Gtk::ScrolledWindow *scroll = manage(new ScrolledWindow);
499 scroll->add(found_list_view);
500 scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
502 vbox = manage(new VBox);
503 vbox->pack_start (*hbox, PACK_SHRINK);
504 vbox->pack_start (*scroll);
506 found_list_view.append_column(_("Paths"), found_list_columns.pathname);
508 found_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_list_view_selected));
510 found_list_view.signal_row_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::found_list_view_activated));
512 found_search_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_search_clicked));
513 found_entry.signal_activate().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_search_clicked));
515 freesound_stop_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_stop_clicked));
517 notebook.append_page (*vbox, _("Search Tags"));
521 //add freesound search
523 mootcher = new Mootcher();
528 passbox = manage(new HBox);
529 passbox->set_spacing (6);
531 label = manage (new Label);
532 label->set_text (_("Tags:"));
533 passbox->pack_start (*label, false, false);
534 passbox->pack_start (freesound_entry, true, true);
536 label = manage (new Label);
537 label->set_text (_("Sort:"));
538 passbox->pack_start (*label, false, false);
539 passbox->pack_start (freesound_sort, false, false);
540 freesound_sort.clear_items();
542 // Order of the following must correspond with enum sortMethod
543 // in sfdb_freesound_mootcher.h
544 freesound_sort.append_text(_("None"));
545 freesound_sort.append_text(_("Longest"));
546 freesound_sort.append_text(_("Shortest"));
547 freesound_sort.append_text(_("Newest"));
548 freesound_sort.append_text(_("Oldest"));
549 freesound_sort.append_text(_("Most downloaded"));
550 freesound_sort.append_text(_("Least downloaded"));
551 freesound_sort.append_text(_("Highest rated"));
552 freesound_sort.append_text(_("Lowest rated"));
553 freesound_sort.set_active(0);
555 passbox->pack_start (freesound_search_btn, false, false);
556 passbox->pack_end (freesound_stop_btn, false, false);
557 freesound_stop_btn.set_label(_("Stop"));
559 scroll = manage(new ScrolledWindow);
560 scroll->add(freesound_list_view);
561 scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
563 vbox = manage(new VBox);
564 vbox->set_spacing (3);
565 vbox->pack_start (*passbox, PACK_SHRINK);
566 vbox->pack_start (freesound_progress_bar, PACK_SHRINK);
567 vbox->pack_start (*scroll);
569 freesound_list_view.append_column(_("ID") , freesound_list_columns.id);
570 freesound_list_view.append_column(_("Filename"), freesound_list_columns.filename);
571 // freesound_list_view.append_column(_("URI") , freesound_list_columns.uri);
572 freesound_list_view.append_column(_("Duration"), freesound_list_columns.duration);
573 freesound_list_view.append_column(_("Size"), freesound_list_columns.filesize);
574 freesound_list_view.append_column(_("Samplerate"), freesound_list_columns.smplrate);
575 freesound_list_view.append_column(_("License"), freesound_list_columns.license);
576 freesound_list_view.get_column(0)->set_alignment(0.5);
577 freesound_list_view.get_column(1)->set_expand(true);
578 freesound_list_view.get_column(2)->set_alignment(0.5);
579 freesound_list_view.get_column(3)->set_alignment(0.5);
580 freesound_list_view.get_column(4)->set_alignment(0.5);
581 freesound_list_view.get_column(5)->set_alignment(0.5);
583 freesound_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_list_view_selected));
585 freesound_list_view.get_selection()->set_mode (SELECTION_MULTIPLE);
586 freesound_list_view.signal_row_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::freesound_list_view_activated));
587 freesound_search_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_search_clicked));
588 freesound_entry.signal_activate().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_search_clicked));
589 freesound_stop_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_stop_clicked));
590 notebook.append_page (*vbox, _("Search Freesound"));
593 notebook.set_size_request (500, -1);
594 notebook.signal_switch_page().connect (sigc::hide_return (sigc::hide (sigc::hide (sigc::mem_fun (*this, &SoundFileBrowser::reset_options)))));
598 Gtk::HButtonBox* button_box = manage (new HButtonBox);
600 button_box->set_layout (BUTTONBOX_END);
601 button_box->pack_start (cancel_button, false, false);
602 cancel_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*this, &SoundFileBrowser::do_something), RESPONSE_CANCEL));
604 button_box->pack_start (apply_button, false, false);
605 apply_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*this, &SoundFileBrowser::do_something), RESPONSE_APPLY));
608 button_box->pack_start (ok_button, false, false);
609 ok_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*this, &SoundFileBrowser::do_something), RESPONSE_OK));
611 Gtkmm2ext::UI::instance()->set_tip (ok_button, _("Press to import selected files and close this window"));
612 Gtkmm2ext::UI::instance()->set_tip (apply_button, _("Press to import selected files and leave this window open"));
613 Gtkmm2ext::UI::instance()->set_tip (cancel_button, _("Press to close this window without importing any files"));
615 vpacker.pack_end (*button_box, false, false);
617 set_wmclass (X_("import"), PROGRAM_NAME);
620 SoundFileBrowser::~SoundFileBrowser ()
622 persistent_folder = chooser.get_current_folder();
626 SoundFileBrowser::run ()
635 gtk_main_iteration ();
642 SoundFileBrowser::set_action_sensitive (bool yn)
644 ok_button.set_sensitive (yn);
645 apply_button.set_sensitive (yn);
649 SoundFileBrowser::do_something (int action)
656 SoundFileBrowser::on_show ()
658 ArdourWindow::on_show ();
663 SoundFileBrowser::clear_selection ()
665 chooser.unselect_all ();
666 found_list_view.get_selection()->unselect_all ();
670 SoundFileBrowser::chooser_file_activated ()
676 SoundFileBrowser::found_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
682 SoundFileBrowser::freesound_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
688 SoundFileBrowser::set_session (Session* s)
690 ArdourWindow::set_session (s);
691 preview.set_session (s);
696 remove_gain_meter ();
701 SoundFileBrowser::add_gain_meter ()
705 gm = new GainMeter (_session, 250);
707 boost::shared_ptr<Route> r = _session->the_auditioner ();
709 gm->set_controls (r, r->shared_peak_meter(), r->amp());
711 meter_packer.set_border_width (12);
712 meter_packer.pack_start (*gm, false, true);
713 hpacker.pack_end (meter_packer, false, false);
714 meter_packer.show_all ();
719 SoundFileBrowser::remove_gain_meter ()
722 meter_packer.remove (*gm);
723 hpacker.remove (meter_packer);
730 SoundFileBrowser::start_metering ()
732 metering_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (sigc::mem_fun(*this, &SoundFileBrowser::meter));
736 SoundFileBrowser::stop_metering ()
738 metering_connection.disconnect();
742 SoundFileBrowser::meter ()
744 if (is_mapped () && _session && gm) {
745 gm->update_meters ();
750 SoundFileBrowser::on_audio_filter (const FileFilter::Info& filter_info)
752 return AudioFileSource::safe_audio_file_extension (filter_info.filename);
756 SoundFileBrowser::on_midi_filter (const FileFilter::Info& filter_info)
758 return SMFSource::safe_midi_file_extension (filter_info.filename);
762 SoundFileBrowser::on_audio_and_midi_filter (const FileFilter::Info& filter_info)
764 return on_audio_filter (filter_info) || on_midi_filter (filter_info);
768 SoundFileBrowser::update_preview ()
770 if (preview.setup_labels (chooser.get_preview_filename())) {
771 if (preview.autoplay()) {
772 Glib::signal_idle().connect (sigc::mem_fun (preview, &SoundFileBox::audition_oneshot));
778 SoundFileBrowser::found_list_view_selected ()
780 if (!reset_options ()) {
781 set_action_sensitive (false);
785 TreeView::Selection::ListHandle_Path rows = found_list_view.get_selection()->get_selected_rows ();
788 TreeIter iter = found_list->get_iter(*rows.begin());
789 file = (*iter)[found_list_columns.pathname];
790 chooser.set_filename (file);
791 set_action_sensitive (true);
793 set_action_sensitive (false);
796 preview.setup_labels (file);
801 SoundFileBrowser::freesound_list_view_selected ()
803 freesound_download_cancel = false;
806 if (!reset_options ()) {
807 set_action_sensitive (false);
812 TreeView::Selection::ListHandle_Path rows = freesound_list_view.get_selection()->get_selected_rows ();
815 TreeIter iter = freesound_list->get_iter(*rows.begin());
817 string id = (*iter)[freesound_list_columns.id];
818 string uri = (*iter)[freesound_list_columns.uri];
819 string ofn = (*iter)[freesound_list_columns.filename];
821 // download the sound file
822 GdkCursor *prev_cursor;
823 prev_cursor = gdk_window_get_cursor (get_window()->gobj());
824 gdk_window_set_cursor (get_window()->gobj(), gdk_cursor_new(GDK_WATCH));
827 file = mootcher->getAudioFile(ofn, id, uri, this);
829 gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
832 chooser.set_filename (file);
833 set_action_sensitive (true);
836 set_action_sensitive (false);
839 freesound_progress_bar.set_text(
840 string_compose(P_("found %1 match", "found %1 matches", matches), matches));
842 preview.setup_labels (file);
848 SoundFileBrowser::found_search_clicked ()
850 string tag_string = found_entry.get_text ();
854 if (!PBD::tokenize (tag_string, string(","), std::back_inserter (tags), true)) {
855 warning << _("SoundFileBrowser: Could not tokenize string: ") << tag_string << endmsg;
859 vector<string> results;
860 Library->search_members_and (results, tags);
863 for (vector<string>::iterator i = results.begin(); i != results.end(); ++i) {
864 TreeModel::iterator new_row = found_list->append();
865 TreeModel::Row row = *new_row;
866 string path = Glib::filename_from_uri (string ("file:") + *i);
867 row[found_list_columns.pathname] = path;
872 SoundFileBrowser::freesound_search_clicked ()
874 freesound_search_cancel = false;
879 SoundFileBrowser::freesound_stop_clicked ()
881 freesound_download_cancel = true;
882 freesound_search_cancel = true;
887 SoundFileBrowser::freesound_search()
890 freesound_list->clear();
891 freesound_list_view.get_column(1)->set_sizing(TREE_VIEW_COLUMN_GROW_ONLY);
894 string search_string = freesound_entry.get_text ();
895 enum sortMethod sort_method = (enum sortMethod) freesound_sort.get_active_row_number();
897 GdkCursor *prev_cursor;
898 prev_cursor = gdk_window_get_cursor (get_window()->gobj());
899 gdk_window_set_cursor (get_window()->gobj(), gdk_cursor_new(GDK_WATCH));
900 freesound_progress_bar.set_fraction(0.0);
903 int freesound_n_pages = 1;
904 for (int page = 1; page <= 99 && page <= freesound_n_pages; page++ ) {
907 if (freesound_n_pages > 1) {
908 freesound_progress_bar.set_fraction(page/(float)freesound_n_pages);
909 prog = string_compose (_("Searching Page %1 of %2, click Stop to cancel"), page, freesound_n_pages);
911 prog = _("Searching, click Stop to cancel");
913 freesound_progress_bar.set_text(prog);
914 while (Glib::MainContext::get_default()->iteration (false)) {
918 std::string theString = mootcher->searchText(
922 "", // OSX eats anything incl mp3
924 "type:wav OR type:aiff OR type:flac OR type:aif OR type:ogg OR type:oga",
930 doc.read_buffer( theString );
931 XMLNode *root = doc.root();
934 error << "no root XML node!" << endmsg;
938 if ( strcmp(root->name().c_str(), "response") != 0) {
939 error << string_compose ("root node name == %1 != \"response\"", root->name()) << endmsg;
943 //find out how many pages are available to search
944 XMLNode *res = root->child("num_pages");
946 string result = res->child("text")->content();
947 freesound_n_pages = atoi(result.c_str());
950 XMLNode *sounds_root = root->child("sounds");
953 error << "no child node \"sounds\" found!" << endmsg;
957 XMLNodeList sounds = sounds_root->children();
958 if (sounds.size() == 0) {
963 XMLNodeConstIterator niter;
965 for (niter = sounds.begin(); niter != sounds.end(); ++niter) {
967 if( strcmp( node->name().c_str(), "resource") != 0 ){
968 error << string_compose ("node->name()=%1 != \"resource\"", node->name()) << endmsg;
969 freesound_search_cancel = true;
973 // node->dump(cerr, "node:");
975 XMLNode *id_node = node->child ("id");
976 XMLNode *uri_node = node->child ("serve");
977 XMLNode *ofn_node = node->child ("original_filename");
978 XMLNode *dur_node = node->child ("duration");
979 XMLNode *siz_node = node->child ("filesize");
980 XMLNode *srt_node = node->child ("samplerate");
981 XMLNode *lic_node = node->child ("license");
983 if (id_node && uri_node && ofn_node && dur_node && siz_node && srt_node) {
985 std::string id = id_node->child("text")->content();
986 std::string uri = uri_node->child("text")->content();
987 std::string ofn = ofn_node->child("text")->content();
988 std::string dur = dur_node->child("text")->content();
989 std::string siz = siz_node->child("text")->content();
990 std::string srt = srt_node->child("text")->content();
991 std::string lic = lic_node->child("text")->content();
994 // cerr << "id=" << id << ",uri=" << uri << ",ofn=" << ofn << ",dur=" << dur << endl;
996 double duration_seconds = atof(dur.c_str());
998 char duration_hhmmss[16];
999 if (duration_seconds >= 99 * 60 * 60) {
1000 strcpy(duration_hhmmss, ">99h");
1002 s = modf(duration_seconds/60, &m) * 60;
1003 m = modf(m/60, &h) * 60;
1004 sprintf(duration_hhmmss, "%02.fh:%02.fm:%04.1fs",
1009 double size_bytes = atof(siz.c_str());
1011 if (size_bytes < 1000) {
1012 sprintf(bsize, "%.0f %s", size_bytes, _("B"));
1013 } else if (size_bytes < 1000000 ) {
1014 sprintf(bsize, "%.1f %s", size_bytes / 1000.0, _("kB"));
1015 } else if (size_bytes < 10000000) {
1016 sprintf(bsize, "%.1f %s", size_bytes / 1000000.0, _("MB"));
1017 } else if (size_bytes < 1000000000) {
1018 sprintf(bsize, "%.2f %s", size_bytes / 1000000.0, _("MB"));
1020 sprintf(bsize, "%.2f %s", size_bytes / 1000000000.0, _("GB"));
1023 /* see http://www.freesound.org/help/faq/#licenses */
1024 char shortlicense[64];
1025 if(!lic.compare(0, 42, "http://creativecommons.org/licenses/by-nc/")){
1026 sprintf(shortlicense, "CC-BY-NC");
1027 } else if(!lic.compare(0, 39, "http://creativecommons.org/licenses/by/")) {
1028 sprintf(shortlicense, "CC-BY");
1029 } else if(!lic.compare("http://creativecommons.org/licenses/sampling+/1.0/")) {
1030 sprintf(shortlicense, "sampling+");
1031 } else if(!lic.compare(0, 40, "http://creativecommons.org/publicdomain/")) {
1032 sprintf(shortlicense, "PD");
1034 snprintf(shortlicense, 64, "%s", lic.c_str());
1035 shortlicense[63]= '\0';
1038 TreeModel::iterator new_row = freesound_list->append();
1039 TreeModel::Row row = *new_row;
1041 row[freesound_list_columns.id ] = id;
1042 row[freesound_list_columns.uri ] = uri;
1043 row[freesound_list_columns.filename] = ofn;
1044 row[freesound_list_columns.duration] = duration_hhmmss;
1045 row[freesound_list_columns.filesize] = bsize;
1046 row[freesound_list_columns.smplrate] = srt;
1047 row[freesound_list_columns.license ] = shortlicense;
1053 if (freesound_search_cancel)
1058 gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
1060 freesound_progress_bar.set_fraction(0.0);
1062 freesound_progress_bar.set_text(_("Search returned no results."));
1064 freesound_progress_bar.set_text(string_compose(P_("Found %1 match", "Found %1 matches", matches), matches));
1066 freesound_list_view.get_column(1)->set_sizing(TREE_VIEW_COLUMN_AUTOSIZE);
1071 SoundFileBrowser::get_paths ()
1073 vector<string> results;
1075 int n = notebook.get_current_page ();
1078 vector<string> filenames = chooser.get_filenames();
1079 vector<string>::iterator i;
1081 for (i = filenames.begin(); i != filenames.end(); ++i) {
1083 if ((!stat((*i).c_str(), &buf)) && S_ISREG(buf.st_mode)) {
1084 results.push_back (*i);
1090 typedef TreeView::Selection::ListHandle_Path ListPath;
1092 ListPath rows = found_list_view.get_selection()->get_selected_rows ();
1093 for (ListPath::iterator i = rows.begin() ; i != rows.end(); ++i) {
1094 TreeIter iter = found_list->get_iter(*i);
1095 string str = (*iter)[found_list_columns.pathname];
1097 results.push_back (str);
1101 typedef TreeView::Selection::ListHandle_Path ListPath;
1103 ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
1104 for (ListPath::iterator i = rows.begin() ; i != rows.end(); ++i) {
1105 TreeIter iter = freesound_list->get_iter(*i);
1106 string id = (*iter)[freesound_list_columns.id];
1107 string uri = (*iter)[freesound_list_columns.uri];
1108 string ofn = (*iter)[freesound_list_columns.filename];
1110 GdkCursor *prev_cursor;
1111 prev_cursor = gdk_window_get_cursor (get_window()->gobj());
1112 gdk_window_set_cursor (get_window()->gobj(), gdk_cursor_new(GDK_WATCH));
1115 string str = mootcher->getAudioFile(ofn, id, uri, this);
1117 results.push_back (str);
1120 gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
1130 SoundFileOmega::reset_options_noret ()
1132 if (!resetting_ourselves) {
1133 (void) reset_options ();
1138 SoundFileOmega::reset_options ()
1140 vector<string> paths = get_paths ();
1142 if (paths.empty()) {
1144 channel_combo.set_sensitive (false);
1145 action_combo.set_sensitive (false);
1146 where_combo.set_sensitive (false);
1147 copy_files_btn.set_active (true);
1148 copy_files_btn.set_sensitive (false);
1154 channel_combo.set_sensitive (true);
1155 action_combo.set_sensitive (true);
1156 where_combo.set_sensitive (true);
1158 /* if we get through this function successfully, this may be
1159 reset at the end, once we know if we can use hard links
1160 to do embedding (or if we are importing a MIDI file).
1163 if (Config->get_only_copy_imported_files()) {
1164 copy_files_btn.set_sensitive (false);
1166 copy_files_btn.set_sensitive (false);
1172 bool selection_includes_multichannel;
1173 bool selection_can_be_embedded_with_links = check_link_status (_session, paths);
1176 /* See if we are thinking about importing any MIDI files */
1177 vector<string>::iterator i = paths.begin ();
1178 while (i != paths.end() && SMFSource::safe_midi_file_extension (*i) == false) {
1181 bool const have_a_midi_file = (i != paths.end ());
1183 if (check_info (paths, same_size, src_needed, selection_includes_multichannel)) {
1184 Glib::signal_idle().connect (sigc::mem_fun (*this, &SoundFileOmega::bad_file_message));
1188 string existing_choice;
1189 vector<string> action_strings;
1191 resetting_ourselves = true;
1193 if (chooser.get_filter() == &audio_filter) {
1197 if (selected_audio_track_cnt > 0) {
1198 if (channel_combo.get_active_text().length()) {
1199 ImportDisposition id = get_channel_disposition();
1202 case Editing::ImportDistinctFiles:
1203 if (selected_audio_track_cnt == paths.size()) {
1204 action_strings.push_back (importmode2string (ImportToTrack));
1208 case Editing::ImportDistinctChannels:
1209 /* XXX it would be nice to allow channel-per-selected track
1210 but its too hard we don't want to deal with all the
1211 different per-file + per-track channel configurations.
1216 action_strings.push_back (importmode2string (ImportToTrack));
1226 if (selected_midi_track_cnt > 0) {
1227 action_strings.push_back (importmode2string (ImportToTrack));
1231 action_strings.push_back (importmode2string (ImportAsTrack));
1232 action_strings.push_back (importmode2string (ImportAsRegion));
1233 action_strings.push_back (importmode2string (ImportAsTapeTrack));
1235 existing_choice = action_combo.get_active_text();
1237 set_popdown_strings (action_combo, action_strings);
1239 /* preserve any existing choice, if possible */
1242 if (existing_choice.length()) {
1243 vector<string>::iterator x;
1244 for (x = action_strings.begin(); x != action_strings.end(); ++x) {
1245 if (*x == existing_choice) {
1246 action_combo.set_active_text (existing_choice);
1250 if (x == action_strings.end()) {
1251 action_combo.set_active_text (action_strings.front());
1254 action_combo.set_active_text (action_strings.front());
1257 resetting_ourselves = false;
1259 if ((mode = get_mode()) == ImportAsRegion) {
1260 where_combo.set_sensitive (false);
1262 where_combo.set_sensitive (true);
1265 vector<string> channel_strings;
1267 if (mode == ImportAsTrack || mode == ImportAsTapeTrack || mode == ImportToTrack) {
1268 channel_strings.push_back (_("one track per file"));
1270 if (selection_includes_multichannel) {
1271 channel_strings.push_back (_("one track per channel"));
1274 if (paths.size() > 1) {
1275 /* tape tracks are a single region per track, so we cannot
1276 sequence multiple files.
1278 if (mode != ImportAsTapeTrack) {
1279 channel_strings.push_back (_("sequence files"));
1282 channel_strings.push_back (_("all files in one track"));
1283 channel_strings.push_back (_("merge files"));
1289 channel_strings.push_back (_("one region per file"));
1291 if (selection_includes_multichannel) {
1292 channel_strings.push_back (_("one region per channel"));
1295 if (paths.size() > 1) {
1297 channel_strings.push_back (_("all files in one region"));
1302 resetting_ourselves = true;
1304 existing_choice = channel_combo.get_active_text();
1306 set_popdown_strings (channel_combo, channel_strings);
1308 /* preserve any existing choice, if possible */
1310 if (existing_choice.length()) {
1311 vector<string>::iterator x;
1312 for (x = channel_strings.begin(); x != channel_strings.end(); ++x) {
1313 if (*x == existing_choice) {
1314 channel_combo.set_active_text (existing_choice);
1318 if (x == channel_strings.end()) {
1319 channel_combo.set_active_text (channel_strings.front());
1322 channel_combo.set_active_text (channel_strings.front());
1325 resetting_ourselves = false;
1328 src_combo.set_sensitive (true);
1330 src_combo.set_sensitive (false);
1333 /* We must copy MIDI files or those from Freesound */
1334 bool const must_copy = have_a_midi_file || notebook.get_current_page() == 2;
1336 if (Config->get_only_copy_imported_files()) {
1338 if (selection_can_be_embedded_with_links && !must_copy) {
1339 copy_files_btn.set_sensitive (true);
1342 copy_files_btn.set_active (true);
1344 copy_files_btn.set_sensitive (false);
1350 copy_files_btn.set_active (true);
1352 copy_files_btn.set_sensitive (!must_copy);
1360 SoundFileOmega::bad_file_message()
1362 MessageDialog msg (*this,
1363 string_compose (_("One or more of the selected files\ncannot be used by %1"), PROGRAM_NAME),
1368 resetting_ourselves = true;
1369 chooser.unselect_uri (chooser.get_preview_uri());
1370 resetting_ourselves = false;
1376 SoundFileOmega::check_info (const vector<string>& paths, bool& same_size, bool& src_needed, bool& multichannel)
1385 multichannel = false;
1387 for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
1389 if (AudioFileSource::get_soundfile_info (*i, info, errmsg)) {
1390 if (info.channels > 1) {
1391 multichannel = true;
1396 if (sz != info.length) {
1401 if (info.samplerate != _session->frame_rate()) {
1405 } else if (SMFSource::safe_midi_file_extension (*i)) {
1409 if (reader.num_tracks() > 1) {
1410 multichannel = true; // "channel" == track here...
1413 /* XXX we need err = true handling here in case
1414 we can't check the file
1427 SoundFileOmega::check_link_status (const Session* s, const vector<string>& paths)
1429 std::string tmpdir(Glib::build_filename (s->session_directory().sound_path(), "linktest"));
1432 if (mkdir (tmpdir.c_str(), 0744)) {
1433 if (errno != EEXIST) {
1438 for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
1440 char tmpc[MAXPATHLEN+1];
1442 snprintf (tmpc, sizeof(tmpc), "%s/%s", tmpdir.c_str(), Glib::path_get_basename (*i).c_str());
1446 if (link ((*i).c_str(), tmpc)) {
1456 rmdir (tmpdir.c_str());
1460 SoundFileChooser::SoundFileChooser (string title, ARDOUR::Session* s)
1461 : SoundFileBrowser (title, s, false)
1463 chooser.set_select_multiple (false);
1464 found_list_view.get_selection()->set_mode (SELECTION_SINGLE);
1465 freesound_list_view.get_selection()->set_mode (SELECTION_SINGLE);
1469 SoundFileChooser::on_hide ()
1471 ArdourWindow::on_hide();
1475 _session->cancel_audition();
1480 SoundFileChooser::get_filename ()
1482 vector<string> paths;
1484 paths = get_paths ();
1486 if (paths.empty()) {
1490 if (!Glib::file_test (paths.front(), Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
1494 return paths.front();
1497 SoundFileOmega::SoundFileOmega (string title, ARDOUR::Session* s,
1498 uint32_t selected_audio_tracks,
1499 uint32_t selected_midi_tracks,
1501 Editing::ImportMode mode_hint)
1502 : SoundFileBrowser (title, s, persistent)
1503 , copy_files_btn ( _("Copy files to session"))
1504 , selected_audio_track_cnt (selected_audio_tracks)
1505 , selected_midi_track_cnt (selected_midi_tracks)
1511 set_size_request (-1, 450);
1513 block_two.set_border_width (12);
1514 block_three.set_border_width (12);
1515 block_four.set_border_width (12);
1517 options.set_spacing (12);
1520 str.push_back (_("file timestamp"));
1521 str.push_back (_("edit point"));
1522 str.push_back (_("playhead"));
1523 str.push_back (_("session start"));
1524 set_popdown_strings (where_combo, str);
1525 where_combo.set_active_text (str.front());
1527 Label* l = manage (new Label);
1528 l->set_markup (_("<b>Add files as ...</b>"));
1530 vbox = manage (new VBox);
1531 vbox->set_border_width (12);
1532 vbox->set_spacing (6);
1533 vbox->pack_start (*l, false, false);
1534 vbox->pack_start (action_combo, false, false);
1535 hbox = manage (new HBox);
1536 hbox->pack_start (*vbox, false, false);
1537 options.pack_start (*hbox, false, false);
1539 /* dummy entry for action combo so that it doesn't look odd if we
1540 come up with no tracks selected.
1544 str.push_back (importmode2string (mode_hint));
1545 set_popdown_strings (action_combo, str);
1546 action_combo.set_active_text (str.front());
1547 action_combo.set_sensitive (false);
1549 l = manage (new Label);
1550 l->set_markup (_("<b>Insert at</b>"));
1552 vbox = manage (new VBox);
1553 vbox->set_border_width (12);
1554 vbox->set_spacing (6);
1555 vbox->pack_start (*l, false, false);
1556 vbox->pack_start (where_combo, false, false);
1557 hbox = manage (new HBox);
1558 hbox->pack_start (*vbox, false, false);
1559 options.pack_start (*hbox, false, false);
1562 l = manage (new Label);
1563 l->set_markup (_("<b>Mapping</b>"));
1565 vbox = manage (new VBox);
1566 vbox->set_border_width (12);
1567 vbox->set_spacing (6);
1568 vbox->pack_start (*l, false, false);
1569 vbox->pack_start (channel_combo, false, false);
1570 hbox = manage (new HBox);
1571 hbox->pack_start (*vbox, false, false);
1572 options.pack_start (*hbox, false, false);
1575 str.push_back (_("one track per file"));
1576 set_popdown_strings (channel_combo, str);
1577 channel_combo.set_active_text (str.front());
1578 channel_combo.set_sensitive (false);
1580 l = manage (new Label);
1581 l->set_markup (_("<b>Conversion quality</b>"));
1583 vbox = manage (new VBox);
1584 vbox->set_border_width (12);
1585 vbox->set_spacing (6);
1586 vbox->pack_start (*l, false, false);
1587 vbox->pack_start (src_combo, false, false);
1588 hbox = manage (new HBox);
1589 hbox->pack_start (*vbox, false, false);
1590 options.pack_start (*hbox, false, false);
1593 str.push_back (_("Best"));
1594 str.push_back (_("Good"));
1595 str.push_back (_("Quick"));
1596 str.push_back (_("Fast"));
1597 str.push_back (_("Fastest"));
1599 set_popdown_strings (src_combo, str);
1600 src_combo.set_active_text (str.front());
1601 src_combo.set_sensitive (false);
1605 action_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::reset_options_noret));
1606 channel_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::reset_options_noret));
1608 copy_files_btn.set_active (true);
1610 Gtk::Label* copy_label = dynamic_cast<Gtk::Label*>(copy_files_btn.get_child());
1613 copy_label->set_size_request (175, -1);
1614 copy_label->set_line_wrap (true);
1617 block_four.pack_start (copy_files_btn, false, false);
1619 options.pack_start (block_four, false, false);
1621 vpacker.pack_start (options, false, false);
1623 /* setup disposition map */
1625 disposition_map.insert (pair<string,ImportDisposition>(_("one track per file"), ImportDistinctFiles));
1626 disposition_map.insert (pair<string,ImportDisposition>(_("one track per channel"), ImportDistinctChannels));
1627 disposition_map.insert (pair<string,ImportDisposition>(_("merge files"), ImportMergeFiles));
1628 disposition_map.insert (pair<string,ImportDisposition>(_("sequence files"), ImportSerializeFiles));
1630 disposition_map.insert (pair<string,ImportDisposition>(_("one region per file"), ImportDistinctFiles));
1631 disposition_map.insert (pair<string,ImportDisposition>(_("one region per channel"), ImportDistinctChannels));
1632 disposition_map.insert (pair<string,ImportDisposition>(_("all files in one region"), ImportMergeFiles));
1633 disposition_map.insert (pair<string,ImportDisposition>(_("all files in one track"), ImportMergeFiles));
1635 chooser.signal_selection_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::file_selection_changed));
1637 /* set size requests for a couple of combos to allow them to display the longest text
1638 they will ever be asked to display. This prevents them being resized when the user
1639 selects a file to import, which in turn prevents the size of the dialog from jumping
1643 t.push_back (_("one track per file"));
1644 t.push_back (_("one track per channel"));
1645 t.push_back (_("sequence files"));
1646 t.push_back (_("all files in one region"));
1647 set_popdown_strings (channel_combo, t);
1650 t.push_back (importmode2string (ImportAsTrack));
1651 t.push_back (importmode2string (ImportToTrack));
1652 t.push_back (importmode2string (ImportAsRegion));
1653 t.push_back (importmode2string (ImportAsTapeTrack));
1654 set_popdown_strings (action_combo, t);
1658 SoundFileOmega::set_mode (ImportMode mode)
1660 action_combo.set_active_text (importmode2string (mode));
1664 SoundFileOmega::get_mode () const
1666 return string2importmode (action_combo.get_active_text());
1670 SoundFileOmega::on_hide ()
1672 ArdourWindow::on_hide();
1674 _session->cancel_audition();
1679 SoundFileOmega::get_position() const
1681 string str = where_combo.get_active_text();
1683 if (str == _("file timestamp")) {
1684 return ImportAtTimestamp;
1685 } else if (str == _("edit point")) {
1686 return ImportAtEditPoint;
1687 } else if (str == _("playhead")) {
1688 return ImportAtPlayhead;
1690 return ImportAtStart;
1695 SoundFileOmega::get_src_quality() const
1697 string str = where_combo.get_active_text();
1699 if (str == _("Best")) {
1701 } else if (str == _("Good")) {
1703 } else if (str == _("Quick")) {
1705 } else if (str == _("Fast")) {
1713 SoundFileOmega::get_channel_disposition () const
1715 /* we use a map here because the channel combo can contain different strings
1716 depending on the state of the other combos. the map contains all possible strings
1717 and the ImportDisposition enum that corresponds to it.
1720 string str = channel_combo.get_active_text();
1721 DispositionMap::const_iterator x = disposition_map.find (str);
1723 if (x == disposition_map.end()) {
1724 fatal << string_compose (_("programming error: %1 (%2)"), "unknown string for import disposition", str) << endmsg;
1732 SoundFileOmega::reset (uint32_t selected_audio_tracks, uint32_t selected_midi_tracks)
1734 selected_audio_track_cnt = selected_audio_tracks;
1735 selected_midi_track_cnt = selected_midi_tracks;
1737 if (selected_audio_track_cnt == 0 && selected_midi_track_cnt > 0) {
1738 chooser.set_filter (midi_filter);
1739 } else if (selected_midi_track_cnt == 0 && selected_audio_track_cnt > 0) {
1740 chooser.set_filter (audio_filter);
1742 chooser.set_filter (audio_and_midi_filter);
1749 SoundFileOmega::file_selection_changed ()
1751 if (resetting_ourselves) {
1755 if (!reset_options ()) {
1756 set_action_sensitive (false);
1758 if (chooser.get_filenames().size() > 0) {
1759 set_action_sensitive (true);
1761 set_action_sensitive (false);
1767 SoundFileOmega::do_something (int action)
1769 SoundFileBrowser::do_something (action);
1771 if (action == RESPONSE_CANCEL) {
1778 vector<string> paths = get_paths ();
1779 ImportPosition pos = get_position ();
1780 ImportMode mode = get_mode ();
1781 ImportDisposition chns = get_channel_disposition ();
1785 case ImportAtEditPoint:
1786 where = PublicEditor::instance().get_preferred_edit_position ();
1788 case ImportAtTimestamp:
1791 case ImportAtPlayhead:
1792 where = _session->transport_frame();
1795 where = _session->current_start_frame();
1799 SrcQuality quality = get_src_quality();
1801 if (copy_files_btn.get_active()) {
1802 PublicEditor::instance().do_import (paths, chns, mode, quality, where);
1804 PublicEditor::instance().do_embed (paths, chns, mode, where);
1807 if (action == RESPONSE_OK) {