X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fsfdb_ui.cc;h=42d304e8f4cfae8d9a2ce78effd48b90bfa59806;hb=99766494f89a5a6aa5cffbff4612f4afe0868c9b;hp=ae8209e9da471f4692f05fb6bd76f6d911379629;hpb=b01bdb7e70f021da764e81a4b55722e746e4885d;p=ardour.git

diff --git a/gtk2_ardour/sfdb_ui.cc b/gtk2_ardour/sfdb_ui.cc
index ae8209e9da..42d304e8f4 100644
--- a/gtk2_ardour/sfdb_ui.cc
+++ b/gtk2_ardour/sfdb_ui.cc
@@ -17,6 +17,10 @@
 
 */
 
+#ifdef WAF_BUILD
+#include "gtk2ardour-config.h"
+#endif
+
 #include <map>
 #include <cerrno>
 #include <sstream>
@@ -29,21 +33,25 @@
 #include <gtkmm/stock.h>
 #include <glibmm/fileutils.h>
 
-#include <pbd/convert.h>
-#include <pbd/tokenizer.h>
-#include <pbd/enumwriter.h>
+#include "pbd/convert.h"
+#include "pbd/tokenizer.h"
+#include "pbd/enumwriter.h"
+#include "pbd/pthread_utils.h"
+#include "pbd/xml++.h"
 
 #include <gtkmm2ext/utils.h>
 
-#include <ardour/audio_library.h>
-#include <ardour/auditioner.h>
-#include <ardour/audioregion.h>
-#include <ardour/audiofilesource.h>
-#include <ardour/region_factory.h>
-#include <ardour/source_factory.h>
-#include <ardour/session.h>
-#include <ardour/session_directory.h>
-#include <ardour/profile.h>
+#include "evoral/SMF.hpp"
+
+#include "ardour/audio_library.h"
+#include "ardour/auditioner.h"
+#include "ardour/audioregion.h"
+#include "ardour/audiofilesource.h"
+#include "ardour/smf_source.h"
+#include "ardour/region_factory.h"
+#include "ardour/source_factory.h"
+#include "ardour/session.h"
+#include "ardour/session_directory.h"
 
 #include "ardour_ui.h"
 #include "editing.h"
@@ -53,6 +61,11 @@
 #include "editing.h"
 #include "utils.h"
 #include "gain_meter.h"
+#include "main_clock.h"
+
+#ifdef FREESOUND
+#include "sfdb_freesound_mootcher.h"
+#endif
 
 #include "i18n.h"
 
@@ -63,25 +76,25 @@ using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace Editing;
 
-using Glib::ustring;
+using std::string;
 
-ustring SoundFileBrowser::persistent_folder;
+string SoundFileBrowser::persistent_folder;
 
 static ImportMode
 string2importmode (string str)
 {
-	if (str == "as new tracks") {
+	if (str == _("as new tracks")) {
 		return ImportAsTrack;
-	} else if (str == "to selected tracks") {
+	} else if (str == _("to selected tracks")) {
 		return ImportToTrack;
-	} else if (str == "to region list") {
+	} else if (str == _("to region list")) {
 		return ImportAsRegion;
-	} else if (str == "as new tape tracks") {
+	} else if (str == _("as new tape tracks")) {
 		return ImportAsTapeTrack;
 	}
 
 	warning << string_compose (_("programming error: unknown import mode string %1"), str) << endmsg;
-	
+
 	return ImportAsTrack;
 }
 
@@ -103,21 +116,17 @@ importmode2string (ImportMode mode)
 }
 
 SoundFileBox::SoundFileBox (bool persistent)
-	: _session(0),
-	  table (6, 2),
-	  length_clock ("sfboxLengthClock", !persistent, "EditCursorClock", false, true, false),
-	  timecode_clock ("sfboxTimecodeClock", !persistent, "EditCursorClock", false, false, false),
+	: table (6, 2),
+	  length_clock ("sfboxLengthClock", !persistent, "", false, false, true, false),
+	  timecode_clock ("sfboxTimecodeClock", !persistent, "", false, false, false, false),
 	  main_box (false, 6),
 	  autoplay_btn (_("Auto-play"))
-	
-{
-	HBox* hbox;
-	VBox* vbox;
 
+{
 	set_name (X_("SoundFileBox"));
 	set_size_request (300, -1);
 
-	preview_label.set_markup (_("<b>Soundfile Info</b>"));
+	preview_label.set_markup (_("<b>Sound File Information</b>"));
 
 	border_frame.set_label_widget (preview_label);
 	border_frame.add (main_box);
@@ -126,73 +135,71 @@ SoundFileBox::SoundFileBox (bool persistent)
 	set_border_width (6);
 
 	main_box.set_border_width (6);
-	main_box.set_spacing (12);
 
 	length.set_text (_("Length:"));
+	length.set_alignment (1, 0.5);
 	timecode.set_text (_("Timestamp:"));
+	timecode.set_alignment (1, 0.5);
 	format.set_text (_("Format:"));
+	format.set_alignment (1, 0.5);
 	channels.set_text (_("Channels:"));
+	channels.set_alignment (1, 0.5);
 	samplerate.set_text (_("Sample rate:"));
+	samplerate.set_alignment (1, 0.5);
+
+        preview_label.set_max_width_chars (50);
+	preview_label.set_ellipsize (Pango::ELLIPSIZE_END);
+
+	format_text.set_max_width_chars (20);
+	format_text.set_ellipsize (Pango::ELLIPSIZE_END);
+	format_text.set_alignment (0, 1);
 
 	table.set_col_spacings (6);
 	table.set_homogeneous (false);
 	table.set_row_spacings (6);
 
-	table.attach (channels, 0, 1, 0, 1, FILL|EXPAND, (AttachOptions) 0);
-	table.attach (samplerate, 0, 1, 1, 2, FILL|EXPAND, (AttachOptions) 0);
-	table.attach (format, 0, 1, 2, 4, FILL|EXPAND, (AttachOptions) 0);
-	table.attach (length, 0, 1, 4, 5, FILL|EXPAND, (AttachOptions) 0);
-	table.attach (timecode, 0, 1, 5, 6, FILL|EXPAND, (AttachOptions) 0);
+	table.attach (channels, 0, 1, 0, 1, FILL, FILL);
+	table.attach (samplerate, 0, 1, 1, 2, FILL, FILL);
+	table.attach (format, 0, 1, 2, 4, FILL, FILL);
+	table.attach (length, 0, 1, 4, 5, FILL, FILL);
+	table.attach (timecode, 0, 1, 5, 6, FILL, FILL);
 
-	table.attach (channels_value, 1, 2, 0, 1, FILL, (AttachOptions) 0);
-	table.attach (samplerate_value, 1, 2, 1, 2, FILL, (AttachOptions) 0);
-	table.attach (format_text, 1, 2, 2, 4, FILL, AttachOptions (0));
-	table.attach (length_clock, 1, 2, 4, 5, FILL, (AttachOptions) 0);
-	table.attach (timecode_clock, 1, 2, 5, 6, FILL, (AttachOptions) 0);
+	table.attach (channels_value, 1, 2, 0, 1, FILL, FILL);
+	table.attach (samplerate_value, 1, 2, 1, 2, FILL, FILL);
+	table.attach (format_text, 1, 2, 2, 4, FILL, FILL);
+	table.attach (length_clock, 1, 2, 4, 5, FILL, FILL);
+	table.attach (timecode_clock, 1, 2, 5, 6, FILL, FILL);
 
-	length_clock.set_mode (ARDOUR_UI::instance()->secondary_clock.mode());
-	timecode_clock.set_mode (AudioClock::SMPTE);
+	length_clock.set_mode (ARDOUR_UI::instance()->secondary_clock->mode());
+	timecode_clock.set_mode (AudioClock::Timecode);
 
-	hbox = manage (new HBox);
-	hbox->pack_start (table, false, false);
-	main_box.pack_start (*hbox, false, false);
+	main_box.pack_start (table, false, false);
 
 	tags_entry.set_editable (true);
-	tags_entry.signal_focus_out_event().connect (mem_fun (*this, &SoundFileBox::tags_entry_left));
-	hbox = manage (new HBox);
-	hbox->pack_start (tags_entry, true, true);
-
-	vbox = manage (new VBox);
+	tags_entry.set_wrap_mode(Gtk::WRAP_WORD);
+	tags_entry.signal_focus_out_event().connect (sigc::mem_fun (*this, &SoundFileBox::tags_entry_left));
 
 	Label* label = manage (new Label (_("Tags:")));
 	label->set_alignment (0.0f, 0.5f);
-	vbox->set_spacing (6);
-	vbox->pack_start(*label, false, false);
-	vbox->pack_start(*hbox, true, true);
+	main_box.pack_start (*label, false, false);
+	main_box.pack_start (tags_entry, true, true);
+
+	main_box.pack_start (bottom_box, false, false);
 
-	main_box.pack_start(*vbox, true, true);
-	main_box.pack_start(bottom_box, false, false);
-	
 	play_btn.set_image (*(manage (new Image (Stock::MEDIA_PLAY, ICON_SIZE_BUTTON))));
-	play_btn.set_label (_("Play (double click)"));
+//	play_btn.set_label (_("Play"));
 
 	stop_btn.set_image (*(manage (new Image (Stock::MEDIA_STOP, ICON_SIZE_BUTTON))));
-	stop_btn.set_label (_("Stop"));
-	
+//	stop_btn.set_label (_("Stop"));
+
 	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);
 
-	play_btn.signal_clicked().connect (mem_fun (*this, &SoundFileBox::audition));
-	stop_btn.signal_clicked().connect (mem_fun (*this, &SoundFileBox::stop_audition));
-
-	length.set_alignment (0.0f, 0.5f);
-	format.set_alignment (0.0f, 0.5f);
-	channels.set_alignment (0.0f, 0.5f);
-	samplerate.set_alignment (0.0f, 0.5f);
-	timecode.set_alignment (0.0f, 0.5f);
+	play_btn.signal_clicked().connect (sigc::mem_fun (*this, &SoundFileBox::audition));
+	stop_btn.signal_clicked().connect (sigc::mem_fun (*this, &SoundFileBox::stop_audition));
 
 	channels_value.set_alignment (0.0f, 0.5f);
 	samplerate_value.set_alignment (0.0f, 0.5f);
@@ -201,20 +208,19 @@ SoundFileBox::SoundFileBox (bool persistent)
 void
 SoundFileBox::set_session(Session* s)
 {
-	_session = s;
+	SessionHandlePtr::set_session (s);
+
+	length_clock.set_session (s);
+	timecode_clock.set_session (s);
 
 	if (!_session) {
 		play_btn.set_sensitive (false);
 		stop_btn.set_sensitive (false);
-	} 
-
-
-	length_clock.set_session (s);
-	timecode_clock.set_session (s);
+	}
 }
 
 bool
-SoundFileBox::setup_labels (const ustring& filename) 
+SoundFileBox::setup_labels (const string& filename)
 {
 	if (!path.empty()) {
 		// save existing tags
@@ -227,23 +233,27 @@ SoundFileBox::setup_labels (const ustring& filename)
 
 	if(!AudioFileSource::get_soundfile_info (filename, sf_info, error_msg)) {
 
-		preview_label.set_markup (_("<b>Soundfile Info</b>"));
-		format_text.set_text (_("n/a"));
-		channels_value.set_text (_("n/a"));
-		samplerate_value.set_text (_("n/a"));
+		preview_label.set_markup (_("<b>Sound File Information</b>"));
+		format_text.set_text ("");
+		channels_value.set_text ("");
+		samplerate_value.set_text ("");
 		tags_entry.get_buffer()->set_text ("");
 
 		length_clock.set (0);
 		timecode_clock.set (0);
-		
+
 		tags_entry.set_sensitive (false);
 		play_btn.set_sensitive (false);
-		
+
 		return false;
 	}
 
-	preview_label.set_markup (string_compose ("<b>%1</b>", Glib::path_get_basename (filename)));
-	format_text.set_text (sf_info.format_name);
+	preview_label.set_markup (string_compose ("<b>%1</b>", Glib::Markup::escape_text (Glib::path_get_basename (filename))));
+	std::string n = sf_info.format_name;
+	if (n.substr (0, 8) == X_("Format: ")) {
+		n = n.substr (8);
+	}
+	format_text.set_text (n);
 	channels_value.set_text (to_string (sf_info.channels, std::dec));
 
 	if (_session && sf_info.samplerate != _session->frame_rate()) {
@@ -258,13 +268,16 @@ SoundFileBox::setup_labels (const ustring& filename)
 		samplerate.set_name ("NewSessionSR2Label");
 	}
 
-	length_clock.set (sf_info.length, true);
-	timecode_clock.set (sf_info.timecode, true);
+	framecnt_t const nfr = _session ? _session->nominal_frame_rate() : 25;
+	double src_coef = (double) nfr / sf_info.samplerate;
+
+	length_clock.set (sf_info.length * src_coef + 0.5, true);
+	timecode_clock.set (sf_info.timecode * src_coef + 0.5, true);
 
 	// this is a hack that is fixed in trunk, i think (august 26th, 2007)
 
 	vector<string> tags = Library->get_tags (string ("//") + filename);
-	
+
 	stringstream tag_string;
 	for (vector<string>::iterator i = tags.begin(); i != tags.end(); ++i) {
 		if (i != tags.begin()) {
@@ -273,12 +286,12 @@ SoundFileBox::setup_labels (const ustring& filename)
 		tag_string << *i;
 	}
 	tags_entry.get_buffer()->set_text (tag_string.str());
-	
+
 	tags_entry.set_sensitive (true);
 	if (_session) {
 		play_btn.set_sensitive (true);
 	}
-	
+
 	return true;
 }
 
@@ -301,7 +314,12 @@ SoundFileBox::audition ()
 	if (!_session) {
 		return;
 	}
-	
+
+	if (SMFSource::safe_midi_file_extension (path)) {
+		error << _("Auditioning of MIDI files is not yet supported") << endmsg;
+		return;
+	}
+
 	_session->cancel_audition();
 
 	if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
@@ -320,11 +338,12 @@ SoundFileBox::audition ()
 
 	for (int n = 0; n < sf_info.channels; ++n) {
 		try {
-			afs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createReadable (DataType::AUDIO, *_session, path, 
-													   n, AudioFileSource::Flag (0), false));
-			
+			afs = boost::dynamic_pointer_cast<AudioFileSource> (
+					SourceFactory::createReadable (DataType::AUDIO, *_session,
+							path, n, Source::Flag (0), false));
+
 			srclist.push_back(afs);
-			
+
 		} catch (failed_constructor& err) {
 			error << _("Could not access soundfile: ") << path << endmsg;
 			AudioSource::set_build_peakfiles (old_sbp);
@@ -333,14 +352,22 @@ SoundFileBox::audition ()
 	}
 
 	AudioSource::set_build_peakfiles (old_sbp);
-			
+
 	if (srclist.empty()) {
 		return;
 	}
-	
+
 	afs = boost::dynamic_pointer_cast<AudioFileSource> (srclist[0]);
 	string rname = region_name_from_path (afs->path(), false);
-	r = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (srclist, 0, srclist[0]->length(), rname, 0, Region::DefaultFlags, false));
+
+	PropertyList plist;
+
+	plist.add (ARDOUR::Properties::start, 0);
+	plist.add (ARDOUR::Properties::length, srclist[0]->length(srclist[0]->timeline_position()));
+	plist.add (ARDOUR::Properties::name, rname);
+	plist.add (ARDOUR::Properties::layer, 0);
+
+	r = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (srclist, plist, false));
 
 	_session->audition_region(r);
 }
@@ -354,7 +381,7 @@ SoundFileBox::stop_audition ()
 }
 
 bool
-SoundFileBox::tags_entry_left (GdkEventFocus *ev)
+SoundFileBox::tags_entry_left (GdkEventFocus *)
 {
 	tags_changed ();
 	return false;
@@ -389,70 +416,182 @@ SoundFileBox::save_tags (const vector<string>& tags)
 SoundFileBrowser::SoundFileBrowser (Gtk::Window& parent, string title, ARDOUR::Session* s, bool persistent)
 	: ArdourDialog (parent, title, false, false),
 	  found_list (ListStore::create(found_list_columns)),
+	  freesound_list (ListStore::create(freesound_list_columns)),
 	  chooser (FILE_CHOOSER_ACTION_OPEN),
-	  found_list_view (found_list),
 	  preview (persistent),
-	  found_search_btn (_("Search"))
-
+	  found_search_btn (_("Search")),
+	  found_list_view (found_list),
+	  freesound_search_btn (_("Search")),
+	  freesound_list_view (freesound_list)
 {
-	VBox* vbox;
-	HBox* hbox;
-
+	resetting_ourselves = false;
 	gm = 0;
 
-	set_session (s);
 	resetting_ourselves = false;
-	
+	gm = 0;
+
+#ifdef GTKOSX
+        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");
+
+        chooser.add_shortcut_folder_uri("file:///Volumes");
+#endif
+
+#ifdef FREESOUND
+	mootcher = new Mootcher();
+#endif
+
+	//add the file chooser
+	{
+		chooser.set_border_width (12);
+
+		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"));
+
+		audio_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun(*this, &SoundFileBrowser::on_audio_filter));
+		audio_filter.set_name (_("Audio files"));
+
+		midi_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun(*this, &SoundFileBrowser::on_midi_filter));
+		midi_filter.set_name (_("MIDI files"));
+
+		matchall_filter.add_pattern ("*.*");
+		matchall_filter.set_name (_("All files"));
+
+		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));
+#ifdef GTKOSX
+                /* some broken redraw behaviour - this is a bandaid */
+                chooser.signal_selection_changed().connect (mem_fun (chooser, &Widget::queue_draw));
+#endif
+
+		if (!persistent_folder.empty()) {
+			chooser.set_current_folder (persistent_folder);
+		}
+		notebook.append_page (chooser, _("Browse Files"));
+	}
+
 	hpacker.set_spacing (6);
 	hpacker.pack_start (notebook, true, true);
 	hpacker.pack_start (preview, false, false);
 
 	get_vbox()->pack_start (hpacker, true, true);
 
-	hbox = manage(new HBox);
-	hbox->pack_start (found_entry);
-	hbox->pack_start (found_search_btn);
-	
-	vbox = manage(new VBox);
-	vbox->pack_start (*hbox, PACK_SHRINK);
-	vbox->pack_start (found_list_view);
-	found_list_view.append_column(_("Paths"), found_list_columns.pathname);
-	
-	chooser.set_border_width (12);
+	//add tag search
+	{
+		VBox* vbox;
+		HBox* hbox;
 
-	notebook.append_page (chooser, _("Browse Files"));
-	notebook.append_page (*vbox, _("Search Tags"));
 
-	notebook.set_size_request (500, -1);
+		hbox = manage(new HBox);
+		hbox->pack_start (found_entry);
+		hbox->pack_start (found_search_btn);
+
+		Gtk::ScrolledWindow *scroll = manage(new ScrolledWindow);
+		scroll->add(found_list_view);
+		scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+
+		vbox = manage(new VBox);
+		vbox->pack_start (*hbox, PACK_SHRINK);
+		vbox->pack_start (*scroll);
 
-	found_list_view.get_selection()->set_mode (SELECTION_MULTIPLE);
-	found_list_view.signal_row_activated().connect (mem_fun (*this, &SoundFileBrowser::found_list_view_activated));
+		found_list_view.append_column(_("Paths"), found_list_columns.pathname);
 
-	custom_filter.add_custom (FILE_FILTER_FILENAME, mem_fun(*this, &SoundFileBrowser::on_custom));
-	custom_filter.set_name (_("Audio files"));
+		found_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_list_view_selected));
 
-	matchall_filter.add_pattern ("*.*");
-	matchall_filter.set_name (_("All files"));
+		found_list_view.signal_row_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::found_list_view_activated));
 
-	chooser.add_filter (custom_filter);
-	chooser.add_filter (matchall_filter);
-	chooser.set_select_multiple (true);
-	chooser.signal_update_preview().connect(mem_fun(*this, &SoundFileBrowser::update_preview));
-	chooser.signal_file_activated().connect (mem_fun (*this, &SoundFileBrowser::chooser_file_activated));
+		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));
 
-	if (!persistent_folder.empty()) {
-		chooser.set_current_folder (persistent_folder);
+		freesound_stop_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_stop_clicked));
+
+		notebook.append_page (*vbox, _("Search Tags"));
 	}
 
-	found_list_view.get_selection()->signal_changed().connect(mem_fun(*this, &SoundFileBrowser::found_list_view_selected));
-	
-	found_search_btn.signal_clicked().connect(mem_fun(*this, &SoundFileBrowser::found_search_clicked));
-	found_entry.signal_activate().connect(mem_fun(*this, &SoundFileBrowser::found_search_clicked));
+	//add freesound search
+#ifdef FREESOUND
+	{
+		VBox* vbox;
+		HBox* passbox;
+		Label* label;
+
+		passbox = manage(new HBox);
+		passbox->set_border_width (12);
+		passbox->set_spacing (6);
+
+		label = manage (new Label);
+		label->set_text (_("Tags:"));
+		passbox->pack_start (*label, false, false);
+		passbox->pack_start (freesound_entry, false, false);
+
+		label = manage (new Label);
+		label->set_text (_("Sort:"));
+		passbox->pack_start (*label, false, false);
+		passbox->pack_start (freesound_sort, false, false);
+		freesound_sort.clear_items();
+		
+		// Order of the following must correspond with enum sortMethod
+		// in sfdb_freesound_mootcher.h	
+		freesound_sort.append_text(_("None"));
+		freesound_sort.append_text(_("Longest"));
+		freesound_sort.append_text(_("Shortest"));
+		freesound_sort.append_text(_("Newest"));
+		freesound_sort.append_text(_("Oldest"));
+		freesound_sort.append_text(_("Most downloaded"));
+		freesound_sort.append_text(_("Least downloaded"));
+		freesound_sort.append_text(_("Highest rated"));
+		freesound_sort.append_text(_("Lowest rated"));
+		freesound_sort.set_active(0);
+
+		passbox->pack_start (freesound_search_btn, false, false);
+		passbox->pack_start (freesound_progress_bar);
+		passbox->pack_end   (freesound_stop_btn, false, false);
+		freesound_stop_btn.set_label(_("Stop"));
+		
+		Gtk::ScrolledWindow *scroll = manage(new ScrolledWindow);
+		scroll->add(freesound_list_view);
+		scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+
+		vbox = manage(new VBox);
+		vbox->pack_start (*passbox, PACK_SHRINK);
+		vbox->pack_start (*scroll);
+
+		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(_("URI")     , freesound_list_columns.uri);
+		freesound_list_view.append_column(_("Duration"), freesound_list_columns.duration);
+		freesound_list_view.get_column(1)->set_expand(true);
+
+		freesound_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_list_view_selected));
+
+		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));
+		freesound_stop_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_stop_clicked));
+		notebook.append_page (*vbox, _("Search Freesound"));
+	}
+
+#endif
+
+
+	notebook.set_size_request (500, -1);
+	notebook.signal_switch_page().connect (
+		sigc::hide_return (sigc::hide (sigc::hide (sigc::mem_fun (*this, &SoundFileBrowser::reset_options))))
+		);
+
+	set_session (s);
 
 	add_button (Stock::CANCEL, RESPONSE_CANCEL);
 	add_button (Stock::APPLY, RESPONSE_APPLY);
 	add_button (Stock::OK, RESPONSE_OK);
-	
+
 }
 
 SoundFileBrowser::~SoundFileBrowser ()
@@ -482,7 +621,13 @@ SoundFileBrowser::chooser_file_activated ()
 }
 
 void
-SoundFileBrowser::found_list_view_activated (const TreeModel::Path& path, TreeViewColumn* col)
+SoundFileBrowser::found_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
+{
+	preview.audition ();
+}
+
+void
+SoundFileBrowser::freesound_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
 {
 	preview.audition ();
 }
@@ -492,7 +637,8 @@ SoundFileBrowser::set_session (Session* s)
 {
 	ArdourDialog::set_session (s);
 	preview.set_session (s);
-	if (s) {
+
+	if (_session) {
 		add_gain_meter ();
 	} else {
 		remove_gain_meter ();
@@ -502,11 +648,13 @@ SoundFileBrowser::set_session (Session* s)
 void
 SoundFileBrowser::add_gain_meter ()
 {
-	if (gm) {
-		delete gm;
-	}
+	delete gm;
+
+	gm = new GainMeter (_session, 250);
 
-	gm = new GainMeter (session->the_auditioner(), *session);
+	boost::shared_ptr<Route> r = _session->the_auditioner ();
+
+	gm->set_controls (r, r->shared_peak_meter(), r->amp());
 
 	meter_packer.set_border_width (12);
 	meter_packer.pack_start (*gm, false, true);
@@ -529,7 +677,7 @@ SoundFileBrowser::remove_gain_meter ()
 void
 SoundFileBrowser::start_metering ()
 {
-	metering_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (mem_fun(*this, &SoundFileBrowser::meter));
+	metering_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (sigc::mem_fun(*this, &SoundFileBrowser::meter));
 }
 
 void
@@ -541,23 +689,35 @@ SoundFileBrowser::stop_metering ()
 void
 SoundFileBrowser::meter ()
 {
-	if (is_mapped () && session && gm) {
+	if (is_mapped () && _session && gm) {
 		gm->update_meters ();
 	}
 }
 
 bool
-SoundFileBrowser::on_custom (const FileFilter::Info& filter_info)
+SoundFileBrowser::on_audio_filter (const FileFilter::Info& filter_info)
 {
-	return AudioFileSource::safe_file_extension (filter_info.filename);
+	return AudioFileSource::safe_audio_file_extension (filter_info.filename);
+}
+
+bool
+SoundFileBrowser::on_midi_filter (const FileFilter::Info& filter_info)
+{
+	return SMFSource::safe_midi_file_extension (filter_info.filename);
+}
+
+bool
+SoundFileBrowser::on_audio_and_midi_filter (const FileFilter::Info& filter_info)
+{
+	return on_audio_filter (filter_info) || on_midi_filter (filter_info);
 }
 
 void
 SoundFileBrowser::update_preview ()
 {
-	if (preview.setup_labels (chooser.get_filename())) {
+	if (preview.setup_labels (chooser.get_preview_filename())) {
 		if (preview.autoplay()) {
-			Glib::signal_idle().connect (mem_fun (preview, &SoundFileBox::audition_oneshot));
+			Glib::signal_idle().connect (sigc::mem_fun (preview, &SoundFileBox::audition_oneshot));
 		}
 	}
 }
@@ -568,10 +728,10 @@ SoundFileBrowser::found_list_view_selected ()
 	if (!reset_options ()) {
 		set_response_sensitive (RESPONSE_OK, false);
 	} else {
-		ustring file;
+		string file;
 
 		TreeView::Selection::ListHandle_Path rows = found_list_view.get_selection()->get_selected_rows ();
-		
+
 		if (!rows.empty()) {
 			TreeIter iter = found_list->get_iter(*rows.begin());
 			file = (*iter)[found_list_columns.pathname];
@@ -580,11 +740,55 @@ SoundFileBrowser::found_list_view_selected ()
 		} else {
 			set_response_sensitive (RESPONSE_OK, false);
 		}
-		
+
 		preview.setup_labels (file);
 	}
 }
 
+void
+SoundFileBrowser::freesound_list_view_selected ()
+{
+	freesound_download_cancel = false;
+
+#ifdef FREESOUND
+	if (!reset_options ()) {
+		set_response_sensitive (RESPONSE_OK, false);
+	} else {
+
+		string file;
+
+		TreeView::Selection::ListHandle_Path rows = freesound_list_view.get_selection()->get_selected_rows ();
+
+		if (!rows.empty()) {
+			TreeIter iter = freesound_list->get_iter(*rows.begin());
+
+			string id  = (*iter)[freesound_list_columns.id];
+			string uri = (*iter)[freesound_list_columns.uri];
+			string ofn = (*iter)[freesound_list_columns.filename];
+
+			// download the sound file			
+			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();
+
+			file = mootcher->getAudioFile(ofn, id, uri, this);
+
+			gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
+
+			if (file != "") {
+				chooser.set_filename (file);
+				set_response_sensitive (RESPONSE_OK, true);
+			}
+		} else {
+			set_response_sensitive (RESPONSE_OK, false);
+		}
+
+		preview.setup_labels (file);
+	}
+#endif
+}
+
 void
 SoundFileBrowser::found_search_clicked ()
 {
@@ -596,10 +800,10 @@ SoundFileBrowser::found_search_clicked ()
 		warning << _("SoundFileBrowser: Could not tokenize string: ") << tag_string << endmsg;
 		return;
 	}
-	
+
 	vector<string> results;
 	Library->search_members_and (results, tags);
-	
+
 	found_list->clear();
 	for (vector<string>::iterator i = results.begin(); i != results.end(); ++i) {
 		TreeModel::iterator new_row = found_list->append();
@@ -609,16 +813,145 @@ SoundFileBrowser::found_search_clicked ()
 	}
 }
 
-vector<ustring>
-SoundFileBrowser::get_paths ()
+void
+SoundFileBrowser::freesound_search_clicked ()
+{
+	freesound_search_cancel = false;
+	freesound_search();
+}
+
+void
+SoundFileBrowser::freesound_stop_clicked ()
 {
-	vector<ustring> results;
+	freesound_download_cancel = true;
+	freesound_search_cancel = true;
+}
+
+
+void
+SoundFileBrowser::freesound_search()
+{
+#ifdef FREESOUND
+	freesound_list->clear();
+
+	string search_string = freesound_entry.get_text ();
+	enum sortMethod sort_method = (enum sortMethod) freesound_sort.get_active_row_number();
+
+	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();
+	for (int page = 1; page <= 99; page++ ) {
+		
+		std::string prog;
+		prog = string_compose (_("Page %1, [Stop]->"), page);
+		freesound_progress_bar.set_text(prog);
+		while (Glib::MainContext::get_default()->iteration (false)) {
+			/* do nothing */
+		}
+
+		std::string theString = mootcher->searchText(
+			search_string, 
+			page,
+			"", // filter, could do, e.g. "type:wav"
+			sort_method
+		);
+
+		XMLTree doc;
+		doc.read_buffer( theString );
+		XMLNode *root = doc.root();
+
+		if (!root) {
+			error << "no root XML node!" << endmsg;
+			break;
+		}
+
+		if ( strcmp(root->name().c_str(), "response") != 0) {
+			error << string_compose ("root node name == %1 != \"response\"", root->name()) << endmsg;
+			break;
+		}
+
+		XMLNode *sounds_root = root->child("sounds");
+		
+		if (!sounds_root) {
+			error << "no child node \"sounds\" found!" << endmsg;
+			break;
+		}
+		
+		XMLNodeList sounds = sounds_root->children();
+		XMLNodeConstIterator niter;
+		XMLNode *node;
+		for (niter = sounds.begin(); niter != sounds.end(); ++niter) {
+			node = *niter;
+			if( strcmp( node->name().c_str(), "resource") != 0 ){
+				error << string_compose ("node->name()=%1 != \"resource\"", node->name()) << endmsg;
+				freesound_search_cancel = true;
+				break;
+			}
+
+			// node->dump(cerr, "node:");
+			
+			XMLNode *id_node  = node->child ("id");
+			XMLNode *uri_node = node->child ("serve");
+			XMLNode *ofn_node = node->child ("original_filename");
+			XMLNode *dur_node = node->child ("duration");
+
+			if (id_node && uri_node && ofn_node && dur_node) {
+				
+				std::string  id =  id_node->child("text")->content();
+				std::string uri = uri_node->child("text")->content();
+				std::string ofn = ofn_node->child("text")->content();
+				std::string dur = dur_node->child("text")->content();
+
+				std::string r;
+				// cerr << "id=" << id << ",uri=" << uri << ",ofn=" << ofn << ",dur=" << dur << endl;
+				
+				double duration_seconds = atof(dur.c_str());
+				double h, m, s;
+				char duration_hhmmss[16];
+				if (duration_seconds >= 99 * 60 * 60) {
+					strcpy(duration_hhmmss, ">99h");
+				} else {
+					s = modf(duration_seconds/60, &m) * 60;
+					m = modf(m/60, &h) * 60;
+					sprintf(duration_hhmmss, "%02.fh:%02.fm:%04.1fs",
+						h, m, s
+					);
+				}
+
+ 				TreeModel::iterator new_row = freesound_list->append();
+				TreeModel::Row row = *new_row;
+				
+				row[freesound_list_columns.id      ] = id;
+				row[freesound_list_columns.uri     ] = uri;
+				row[freesound_list_columns.filename] = ofn;
+				row[freesound_list_columns.duration] = duration_hhmmss;
+
+			}
+		}
 	
+		if (freesound_search_cancel)
+			break;
+
+	}  //page "for" loop
+
+	gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
+
+	freesound_progress_bar.set_text("");
+
+#endif
+}
+
+vector<string>
+SoundFileBrowser::get_paths ()
+{
+	vector<string> results;
+
 	int n = notebook.get_current_page ();
-	
+
 	if (n == 0) {
-		vector<ustring> filenames = chooser.get_filenames();
-		vector<ustring>::iterator i;
+		vector<string> filenames = chooser.get_filenames();
+		vector<string>::iterator i;
 
 		for (i = filenames.begin(); i != filenames.end(); ++i) {
 			struct stat buf;
@@ -626,18 +959,43 @@ SoundFileBrowser::get_paths ()
 				results.push_back (*i);
 			}
 		}
-		
-	} else {
-		
+
+	} else if (n==1){
+
 		typedef TreeView::Selection::ListHandle_Path ListPath;
-		
+
 		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);
-			ustring str = (*iter)[found_list_columns.pathname];
-			
+			string str = (*iter)[found_list_columns.pathname];
+
 			results.push_back (str);
 		}
+	} else {
+#ifdef FREESOUND
+		typedef TreeView::Selection::ListHandle_Path ListPath;
+
+		ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
+		for (ListPath::iterator i = rows.begin() ; i != rows.end(); ++i) {
+			TreeIter iter = freesound_list->get_iter(*i);
+			string id  = (*iter)[freesound_list_columns.id];
+			string uri = (*iter)[freesound_list_columns.uri];
+			string ofn = (*iter)[freesound_list_columns.filename];
+
+			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();
+
+			string str = mootcher->getAudioFile(ofn, id, uri, this);
+			if (str != "") {
+				results.push_back (str);
+			}
+			
+			gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
+
+		}
+#endif
 	}
 
 	return results;
@@ -654,13 +1012,14 @@ SoundFileOmega::reset_options_noret ()
 bool
 SoundFileOmega::reset_options ()
 {
-	vector<ustring> paths = get_paths ();
+	vector<string> paths = get_paths ();
 
 	if (paths.empty()) {
 
 		channel_combo.set_sensitive (false);
 		action_combo.set_sensitive (false);
 		where_combo.set_sensitive (false);
+		copy_files_btn.set_active (true);
 		copy_files_btn.set_sensitive (false);
 
 		return false;
@@ -673,7 +1032,7 @@ SoundFileOmega::reset_options ()
 
 		/* if we get through this function successfully, this may be
 		   reset at the end, once we know if we can use hard links
-		   to do embedding
+		   to do embedding (or if we are importing a MIDI file).
 		*/
 
 		if (Config->get_only_copy_imported_files()) {
@@ -686,48 +1045,68 @@ SoundFileOmega::reset_options ()
 	bool same_size;
 	bool src_needed;
 	bool selection_includes_multichannel;
-	bool selection_can_be_embedded_with_links = check_link_status (*session, paths);
+	bool selection_can_be_embedded_with_links = check_link_status (_session, paths);
 	ImportMode mode;
 
+	/* See if we are thinking about importing any MIDI files */
+	vector<string>::iterator i = paths.begin ();
+	while (i != paths.end() && SMFSource::safe_midi_file_extension (*i) == false) {
+		++i;
+	}
+	bool const have_a_midi_file = (i != paths.end ());
+
 	if (check_info (paths, same_size, src_needed, selection_includes_multichannel)) {
-		Glib::signal_idle().connect (mem_fun (*this, &SoundFileOmega::bad_file_message));
+		Glib::signal_idle().connect (sigc::mem_fun (*this, &SoundFileOmega::bad_file_message));
 		return false;
 	}
 
-	ustring existing_choice;
+	string existing_choice;
 	vector<string> action_strings;
 
-	if (selected_track_cnt > 0) {
-		if (channel_combo.get_active_text().length()) {
-			ImportDisposition id = get_channel_disposition();
-			
-			switch (id) {
-			case Editing::ImportDistinctFiles:
-				if (selected_track_cnt == paths.size()) {
+	resetting_ourselves = true;
+
+	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();
+				
+				switch (id) {
+				case Editing::ImportDistinctFiles:
+					if (selected_audio_track_cnt == paths.size()) {
+						action_strings.push_back (importmode2string (ImportToTrack));
+					}
+					break;
+					
+				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;
+					
+				default:
 					action_strings.push_back (importmode2string (ImportToTrack));
+					break;
 				}
-				break;
-				
-			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;
-				
-			default:
-				action_strings.push_back (importmode2string (ImportToTrack));
-				break;
 			}
-		} 
+		}
+		
+	}  else {
+
+		/* MIDI ONLY */
+
+		if (selected_midi_track_cnt > 0) {
+			action_strings.push_back (importmode2string (ImportToTrack));
+		}
 	}
 
 	action_strings.push_back (importmode2string (ImportAsTrack));
 	action_strings.push_back (importmode2string (ImportAsRegion));
 	action_strings.push_back (importmode2string (ImportAsTapeTrack));
 
-	resetting_ourselves = true;
-
 	existing_choice = action_combo.get_active_text();
 
 	set_popdown_strings (action_combo, action_strings);
@@ -759,7 +1138,7 @@ SoundFileOmega::reset_options ()
 	}
 
 	vector<string> channel_strings;
-	
+
 	if (mode == ImportAsTrack || mode == ImportAsTapeTrack || mode == ImportToTrack) {
 		channel_strings.push_back (_("one track per file"));
 
@@ -775,9 +1154,10 @@ SoundFileOmega::reset_options ()
 				channel_strings.push_back (_("sequence files"));
 			}
 			if (same_size) {
-				channel_strings.push_back (_("all files in one region"));
+				channel_strings.push_back (_("all files in one track"));
+				channel_strings.push_back (_("merge files"));
 			}
-			
+
 		}
 
 	} else {
@@ -794,6 +1174,8 @@ SoundFileOmega::reset_options ()
 		}
 	}
 
+	resetting_ourselves = true;
+
 	existing_choice = channel_combo.get_active_text();
 
 	set_popdown_strings (channel_combo, channel_strings);
@@ -815,34 +1197,45 @@ SoundFileOmega::reset_options ()
 		channel_combo.set_active_text (channel_strings.front());
 	}
 
+	resetting_ourselves = false;
+
 	if (src_needed) {
 		src_combo.set_sensitive (true);
 	} else {
 		src_combo.set_sensitive (false);
 	}
+
+	/* We must copy MIDI files or those from Freesound */
+	bool const must_copy = have_a_midi_file || notebook.get_current_page() == 2;
 	
 	if (Config->get_only_copy_imported_files()) {
 
-		if (selection_can_be_embedded_with_links) {
+		if (selection_can_be_embedded_with_links && !must_copy) {
 			copy_files_btn.set_sensitive (true);
 		} else {
+			if (must_copy) {
+				copy_files_btn.set_active (true);
+			}
 			copy_files_btn.set_sensitive (false);
 		}
 
 	}  else {
 
-		copy_files_btn.set_sensitive (true);
+		if (must_copy) {
+			copy_files_btn.set_active (true);
+		}			
+		copy_files_btn.set_sensitive (!must_copy);
 	}
-	
+
 	return true;
-}	
+}
 
 
 bool
 SoundFileOmega::bad_file_message()
 {
-	MessageDialog msg (*this, 
-			   _("One or more of the selected files\ncannot be used by Ardour"),
+	MessageDialog msg (*this,
+			   string_compose (_("One or more of the selected files\ncannot be used by %1"), PROGRAM_NAME),
 			   true,
 			   Gtk::MESSAGE_INFO,
 			   Gtk::BUTTONS_OK);
@@ -855,40 +1248,47 @@ SoundFileOmega::bad_file_message()
 }
 
 bool
-SoundFileOmega::check_info (const vector<ustring>& paths, bool& same_size, bool& src_needed, bool& multichannel)
+SoundFileOmega::check_info (const vector<string>& paths, bool& same_size, bool& src_needed, bool& multichannel)
 {
-	SNDFILE* sf;
-	SF_INFO info;
-	nframes64_t sz = 0;
+	SoundFileInfo info;
+	framepos_t sz = 0;
 	bool err = false;
+	string errmsg;
 
 	same_size = true;
 	src_needed = false;
 	multichannel = false;
 
-	for (vector<ustring>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
-
-		info.format = 0; // libsndfile says to clear this before sf_open().
-		
-		if ((sf = sf_open ((char*) (*i).c_str(), SFM_READ, &info)) != 0) { 
-			sf_close (sf);
+	for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
 
+		if (AudioFileSource::get_soundfile_info (*i, info, errmsg)) {
 			if (info.channels > 1) {
 				multichannel = true;
 			}
-
 			if (sz == 0) {
-				sz = info.frames;
+				sz = info.length;
 			} else {
-				if (sz != info.frames) {
+				if (sz != info.length) {
 					same_size = false;
 				}
 			}
 
-			if ((nframes_t) info.samplerate != session->frame_rate()) {
+			if (info.samplerate != _session->frame_rate()) {
 				src_needed = true;
 			}
 
+		} else if (SMFSource::safe_midi_file_extension (*i)) {
+
+			Evoral::SMF reader;
+			reader.open(*i);
+			if (reader.num_tracks() > 1) {
+				multichannel = true; // "channel" == track here...
+			}
+
+			/* XXX we need err = true handling here in case
+			   we can't check the file
+			*/
+
 		} else {
 			err = true;
 		}
@@ -899,10 +1299,9 @@ SoundFileOmega::check_info (const vector<ustring>& paths, bool& same_size, bool&
 
 
 bool
-SoundFileOmega::check_link_status (const Session& s, const vector<ustring>& paths)
+SoundFileOmega::check_link_status (const Session* s, const vector<string>& paths)
 {
-	sys::path path = s.session_directory().sound_path() / "linktest";
-	string tmpdir = path.to_string();
+	std::string tmpdir(Glib::build_filename (s->session_directory().sound_path(), "linktest"));
 	bool ret = false;
 
 	if (mkdir (tmpdir.c_str(), 0744)) {
@@ -910,8 +1309,8 @@ SoundFileOmega::check_link_status (const Session& s, const vector<ustring>& path
 			return false;
 		}
 	}
-	
-	for (vector<ustring>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
+
+	for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
 
 		char tmpc[MAXPATHLEN+1];
 
@@ -922,7 +1321,7 @@ SoundFileOmega::check_link_status (const Session& s, const vector<ustring>& path
 		if (link ((*i).c_str(), tmpc)) {
 			goto out;
 		}
-		
+
 		unlink (tmpc);
 	}
 
@@ -938,6 +1337,7 @@ SoundFileChooser::SoundFileChooser (Gtk::Window& parent, string title, ARDOUR::S
 {
 	chooser.set_select_multiple (false);
 	found_list_view.get_selection()->set_mode (SELECTION_SINGLE);
+	freesound_list_view.get_selection()->set_mode (SELECTION_SINGLE);
 }
 
 void
@@ -946,68 +1346,72 @@ SoundFileChooser::on_hide ()
 	ArdourDialog::on_hide();
 	stop_metering ();
 
-	if (session) {
-		session->cancel_audition();
+	if (_session) {
+		_session->cancel_audition();
 	}
 }
 
-ustring
+string
 SoundFileChooser::get_filename ()
 {
-	vector<ustring> paths;
+	vector<string> paths;
 
 	paths = get_paths ();
 
 	if (paths.empty()) {
-		return ustring ();
+		return string ();
 	}
-	
+
 	if (!Glib::file_test (paths.front(), Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
-		return ustring();
+		return string();
 	}
 
 	return paths.front();
 }
 
-SoundFileOmega::SoundFileOmega (Gtk::Window& parent, string title, ARDOUR::Session* s, int selected_tracks, bool persistent,
+SoundFileOmega::SoundFileOmega (Gtk::Window& parent, string title, ARDOUR::Session* s, 
+				uint32_t selected_audio_tracks, 
+				uint32_t selected_midi_tracks, 
+				bool persistent,
 				Editing::ImportMode mode_hint)
-	: SoundFileBrowser (parent, title, s, persistent),
-	  copy_files_btn ( _("Copy files to session")),
-	  selected_track_cnt (selected_tracks)
+	: SoundFileBrowser (parent, title, s, persistent)
+	, copy_files_btn ( _("Copy files to session"))
+	, selected_audio_track_cnt (selected_audio_tracks)
+	, selected_midi_track_cnt (selected_midi_tracks)
 {
 	VBox* vbox;
 	HBox* hbox;
 	vector<string> str;
 
 	set_size_request (-1, 450);
-	
+
 	block_two.set_border_width (12);
 	block_three.set_border_width (12);
 	block_four.set_border_width (12);
-	
+
 	options.set_spacing (12);
 
 	str.clear ();
-	str.push_back (_("use file timestamp"));
-	str.push_back (_("at edit point"));
-	str.push_back (_("at playhead"));
-	str.push_back (_("at session start"));
+	str.push_back (_("file timestamp"));
+	str.push_back (_("edit point"));
+	str.push_back (_("playhead"));
+	str.push_back (_("session start"));
 	set_popdown_strings (where_combo, str);
 	where_combo.set_active_text (str.front());
 
 	Label* l = manage (new Label);
-	l->set_text (_("Add files:"));
-	
-	hbox = manage (new HBox);
-	hbox->set_border_width (12);
-	hbox->set_spacing (6);
-	hbox->pack_start (*l, false, false);
-	hbox->pack_start (action_combo, false, false);
+	l->set_markup (_("<b>Add files as ...</b>"));
+
 	vbox = manage (new VBox);
-	vbox->pack_start (*hbox, false, false);
-	options.pack_start (*vbox, false, false);
+	vbox->set_border_width (12);
+	vbox->set_spacing (6);
+	vbox->pack_start (*l, false, false);
+	vbox->pack_start (action_combo, false, false);
+	hbox = manage (new HBox);
+	hbox->pack_start (*vbox, false, false);
+	options.pack_start (*hbox, false, false);
 
-	/* dummy entry for action combo so that it doesn't look odd if we 
+	/* dummy entry for action combo so that it doesn't look odd if we
 	   come up with no tracks selected.
 	*/
 
@@ -1018,29 +1422,29 @@ SoundFileOmega::SoundFileOmega (Gtk::Window& parent, string title, ARDOUR::Sessi
 	action_combo.set_sensitive (false);
 
 	l = manage (new Label);
-	l->set_text (_("Insert:"));
+	l->set_markup (_("<b>Insert at</b>"));
 
-	hbox = manage (new HBox);
-	hbox->set_border_width (12);
-	hbox->set_spacing (6);
-	hbox->pack_start (*l, false, false);
-	hbox->pack_start (where_combo, false, false);
 	vbox = manage (new VBox);
-	vbox->pack_start (*hbox, false, false);
-	options.pack_start (*vbox, false, false);
+	vbox->set_border_width (12);
+	vbox->set_spacing (6);
+	vbox->pack_start (*l, false, false);
+	vbox->pack_start (where_combo, false, false);
+	hbox = manage (new HBox);
+	hbox->pack_start (*vbox, false, false);
+	options.pack_start (*hbox, false, false);
 
 
 	l = manage (new Label);
-	l->set_text (_("Mapping:"));
+	l->set_markup (_("<b>Mapping</b>"));
 
-	hbox = manage (new HBox);
-	hbox->set_border_width (12);
-	hbox->set_spacing (6);
-	hbox->pack_start (*l, false, false);
-	hbox->pack_start (channel_combo, false, false);
 	vbox = manage (new VBox);
-	vbox->pack_start (*hbox, false, false);
-	options.pack_start (*vbox, false, false);
+	vbox->set_border_width (12);
+	vbox->set_spacing (6);
+	vbox->pack_start (*l, false, false);
+	vbox->pack_start (channel_combo, false, false);
+	hbox = manage (new HBox);
+	hbox->pack_start (*vbox, false, false);
+	options.pack_start (*hbox, false, false);
 
 	str.clear ();
 	str.push_back (_("one track per file"));
@@ -1049,16 +1453,16 @@ SoundFileOmega::SoundFileOmega (Gtk::Window& parent, string title, ARDOUR::Sessi
 	channel_combo.set_sensitive (false);
 
 	l = manage (new Label);
-	l->set_text (_("Conversion Quality:"));
+	l->set_markup (_("<b>Conversion quality</b>"));
 
-	hbox = manage (new HBox);
-	hbox->set_border_width (12);
-	hbox->set_spacing (6);
-	hbox->pack_start (*l, false, false);
-	hbox->pack_start (src_combo, false, false);
 	vbox = manage (new VBox);
-	vbox->pack_start (*hbox, false, false);
-	options.pack_start (*vbox, false, false);
+	vbox->set_border_width (12);
+	vbox->set_spacing (6);
+	vbox->pack_start (*l, false, false);
+	vbox->pack_start (src_combo, false, false);
+	hbox = manage (new HBox);
+	hbox->pack_start (*vbox, false, false);
+	options.pack_start (*hbox, false, false);
 
 	str.clear ();
 	str.push_back (_("Best"));
@@ -1073,10 +1477,18 @@ SoundFileOmega::SoundFileOmega (Gtk::Window& parent, string title, ARDOUR::Sessi
 
 	reset_options ();
 
-	action_combo.signal_changed().connect (mem_fun (*this, &SoundFileOmega::reset_options_noret));
-	
+	action_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::reset_options_noret));
+	channel_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::reset_options_noret));
+
 	copy_files_btn.set_active (true);
 
+	Gtk::Label* copy_label = dynamic_cast<Gtk::Label*>(copy_files_btn.get_child());
+
+	if (copy_label) {
+		copy_label->set_size_request (175, -1);
+		copy_label->set_line_wrap (true);
+	}
+
 	block_four.pack_start (copy_files_btn, false, false);
 
 	options.pack_start (block_four, false, false);
@@ -1085,16 +1497,36 @@ SoundFileOmega::SoundFileOmega (Gtk::Window& parent, string title, ARDOUR::Sessi
 
 	/* setup disposition map */
 
-	disposition_map.insert (pair<ustring,ImportDisposition>(_("one track per file"), ImportDistinctFiles));
-	disposition_map.insert (pair<ustring,ImportDisposition>(_("one track per channel"), ImportDistinctChannels));
-	disposition_map.insert (pair<ustring,ImportDisposition>(_("merge files"), ImportMergeFiles));
-	disposition_map.insert (pair<ustring,ImportDisposition>(_("sequence files"), ImportSerializeFiles));
-
-	disposition_map.insert (pair<ustring,ImportDisposition>(_("one region per file"), ImportDistinctFiles));
-	disposition_map.insert (pair<ustring,ImportDisposition>(_("one region per channel"), ImportDistinctChannels));
-	disposition_map.insert (pair<ustring,ImportDisposition>(_("all files in one region"), ImportMergeFiles));
-
-	chooser.signal_selection_changed().connect (mem_fun (*this, &SoundFileOmega::file_selection_changed));
+	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));
+
+	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));
+
+	chooser.signal_selection_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::file_selection_changed));
+
+	/* 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. */
+
+	vector<string> t;
+	t.push_back (_("one track per file"));
+	t.push_back (_("one track per channel"));
+	t.push_back (_("sequence files"));
+	t.push_back (_("all files in one region"));
+	set_popdown_strings (channel_combo, t);
+
+	t.clear ();
+	t.push_back (importmode2string (ImportAsTrack));
+	t.push_back (importmode2string (ImportToTrack));
+	t.push_back (importmode2string (ImportAsRegion));
+	t.push_back (importmode2string (ImportAsTapeTrack));
+	set_popdown_strings (action_combo, t);
 }
 
 void
@@ -1113,21 +1545,21 @@ void
 SoundFileOmega::on_hide ()
 {
 	ArdourDialog::on_hide();
-	if (session) {
-		session->cancel_audition();
+	if (_session) {
+		_session->cancel_audition();
 	}
 }
 
 ImportPosition
 SoundFileOmega::get_position() const
 {
-	ustring str = where_combo.get_active_text();
+	string str = where_combo.get_active_text();
 
-	if (str == _("use file timestamp")) {
+	if (str == _("file timestamp")) {
 		return ImportAtTimestamp;
-	} else if (str == _("at edit point")) {
+	} else if (str == _("edit point")) {
 		return ImportAtEditPoint;
-	} else if (str == _("at playhead")) {
+	} else if (str == _("playhead")) {
 		return ImportAtPlayhead;
 	} else {
 		return ImportAtStart;
@@ -1137,7 +1569,7 @@ SoundFileOmega::get_position() const
 SrcQuality
 SoundFileOmega::get_src_quality() const
 {
-	ustring str = where_combo.get_active_text();
+	string str = where_combo.get_active_text();
 
 	if (str == _("Best")) {
 		return SrcBest;
@@ -1160,7 +1592,7 @@ SoundFileOmega::get_channel_disposition () const
 	   and the ImportDisposition enum that corresponds to it.
 	*/
 
-	ustring str = channel_combo.get_active_text();
+	string str = channel_combo.get_active_text();
 	DispositionMap::const_iterator x = disposition_map.find (str);
 
 	if (x == disposition_map.end()) {
@@ -1172,11 +1604,21 @@ SoundFileOmega::get_channel_disposition () const
 }
 
 void
-SoundFileOmega::reset (int selected_tracks)
+SoundFileOmega::reset (uint32_t selected_audio_tracks, uint32_t selected_midi_tracks)
 {
-	selected_track_cnt = selected_tracks;
+	selected_audio_track_cnt = selected_audio_tracks;
+	selected_midi_track_cnt = selected_midi_tracks;
+
+	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);
+	}
+
 	reset_options ();
-}	
+}
 
 void
 SoundFileOmega::file_selection_changed ()