X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fsfdb_ui.cc;h=8916a53971af270b666d9178ef853d904179d1dc;hb=8630fd1703acb2f9a36d6db7e0d18963b461614f;hp=3328b7122511f38f92013f82a01036b6daa8f8df;hpb=12c97285305fba9c0edf2297128e978b0f2ccd67;p=ardour.git

diff --git a/gtk2_ardour/sfdb_ui.cc b/gtk2_ardour/sfdb_ui.cc
index 3328b71225..8916a53971 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>
@@ -39,7 +43,6 @@
 
 #include "evoral/SMF.hpp"
 
-#include "ardour/amp.h"
 #include "ardour/audio_library.h"
 #include "ardour/auditioner.h"
 #include "ardour/audioregion.h"
@@ -49,7 +52,6 @@
 #include "ardour/source_factory.h"
 #include "ardour/session.h"
 #include "ardour/session_directory.h"
-#include "ardour/profile.h"
 
 #include "ardour_ui.h"
 #include "editing.h"
@@ -59,6 +61,8 @@
 #include "editing.h"
 #include "utils.h"
 #include "gain_meter.h"
+#include "main_clock.h"
+#include "public_editor.h"
 
 #ifdef FREESOUND
 #include "sfdb_freesound_mootcher.h"
@@ -73,9 +77,9 @@ 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)
@@ -113,10 +117,9 @@ importmode2string (ImportMode mode)
 }
 
 SoundFileBox::SoundFileBox (bool persistent)
-	: _session(0),
-	  table (6, 2),
-	  length_clock ("sfboxLengthClock", !persistent, "EditCursorClock", false, false, true, false),
-	  timecode_clock ("sfboxTimecodeClock", !persistent, "EditCursorClock", false, 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"))
 
@@ -145,7 +148,10 @@ SoundFileBox::SoundFileBox (bool persistent)
 	samplerate.set_text (_("Sample rate:"));
 	samplerate.set_alignment (1, 0.5);
 
-	format_text.set_max_width_chars (8);
+        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);
 
@@ -165,13 +171,14 @@ SoundFileBox::SoundFileBox (bool persistent)
 	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());
+	length_clock.set_mode (ARDOUR_UI::instance()->secondary_clock->mode());
 	timecode_clock.set_mode (AudioClock::Timecode);
 
 	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));
+	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);
@@ -181,10 +188,10 @@ SoundFileBox::SoundFileBox (bool persistent)
 	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"));
+//	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);
@@ -192,8 +199,8 @@ SoundFileBox::SoundFileBox (bool persistent)
 	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));
+	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);
@@ -202,20 +209,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
@@ -243,7 +249,7 @@ SoundFileBox::setup_labels (const ustring& filename)
 		return false;
 	}
 
-	preview_label.set_markup (string_compose ("<b>%1</b>", Glib::path_get_basename (filename)));
+	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);
@@ -263,7 +269,7 @@ SoundFileBox::setup_labels (const ustring& filename)
 		samplerate.set_name ("NewSessionSR2Label");
 	}
 
-	nframes_t const nfr = _session ? _session->nominal_frame_rate() : 25;
+	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);
@@ -310,6 +316,11 @@ SoundFileBox::audition ()
 		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)) {
@@ -329,9 +340,9 @@ 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, Source::Flag (0), false));
-
+				SourceFactory::createExternal (DataType::AUDIO, *_session,
+							       path, n, Source::Flag (0), false));
+			
 			srclist.push_back(afs);
 
 		} catch (failed_constructor& err) {
@@ -349,9 +360,15 @@ SoundFileBox::audition ()
 
 	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(srclist[0]->timeline_position()),
-				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);
 }
@@ -397,146 +414,211 @@ SoundFileBox::save_tags (const vector<string>& tags)
 	Library->save_changes ();
 }
 
-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),
-	  preview (persistent),
-	  found_search_btn (_("Search")),
-	  found_list_view (found_list),
-	  freesound_search_btn (_("Start Downloading")),
-	  freesound_list_view (freesound_list)
+SoundFileBrowser::SoundFileBrowser (string title, ARDOUR::Session* s, bool persistent)
+	: ArdourWindow (title)
+	, found_list (ListStore::create(found_list_columns))
+	, freesound_list (ListStore::create(freesound_list_columns))
+	, chooser (FILE_CHOOSER_ACTION_OPEN)
+	, preview (persistent)
+	, found_search_btn (_("Search"))
+	, found_list_view (found_list)
+	, freesound_search_btn (_("Search"))
+	, freesound_list_view (freesound_list)
+	, resetting_ourselves (false)
+	, matches (0)
+	, _status (0)
+	, _done (false)
+	, ok_button (Stock::OK)
+	, cancel_button (Stock::CANCEL)
+	, apply_button (Stock::APPLY)
+	, gm (0)
 {
-	resetting_ourselves = false;
-	gm = 0;
-
-	resetting_ourselves = false;
-	gm = 0;
-
-	if (ARDOUR::Profile->get_sae()) {
-		chooser.add_shortcut_folder_uri("file:///Library/GarageBand/Apple Loops");
-		chooser.add_shortcut_folder_uri("file:///Library/Application Support/GarageBand/Instrument Library/Sampler/Sampler Files");
-	}
 
+#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
 
 	//add the file chooser
-	{
-		chooser.set_border_width (12);
 
-		audio_filter.add_custom (FILE_FILTER_FILENAME, mem_fun(*this, &SoundFileBrowser::on_audio_filter));
-		audio_filter.set_name (_("Audio files"));
-
-		midi_filter.add_custom (FILE_FILTER_FILENAME, 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_filter);
-		chooser.add_filter (midi_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));
-
-		if (!persistent_folder.empty()) {
-			chooser.set_current_folder (persistent_folder);
-		}
-		notebook.append_page (chooser, _("Browse Files"));
+	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);
-
-	//add tag search
-	{
-		VBox* vbox;
-		HBox* hbox;
+	vpacker.set_spacing (6);
+	vpacker.pack_start (hpacker, true, true);
 
+	add (vpacker);
 
-		hbox = manage(new HBox);
-		hbox->pack_start (found_entry);
-		hbox->pack_start (found_search_btn);
+	//add tag search
 
-		Gtk::ScrolledWindow *scroll = manage(new ScrolledWindow);
-		scroll->add(found_list_view);
-		scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+	VBox* vbox;
+	HBox* hbox;
+	
+	
+	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.append_column(_("Paths"), found_list_columns.pathname);
+	
+	found_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_list_view_selected));
+	
+	found_list_view.signal_row_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::found_list_view_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));
+	
+	freesound_stop_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_stop_clicked));
+	
+	notebook.append_page (*vbox, _("Search Tags"));
 
-		vbox = manage(new VBox);
-		vbox->pack_start (*hbox, PACK_SHRINK);
-		vbox->pack_start (*scroll);
+#ifdef FREESOUND
 
-		found_list_view.append_column(_("Paths"), found_list_columns.pathname);
+	//add freesound search
 
-		found_list_view.get_selection()->signal_changed().connect(mem_fun(*this, &SoundFileBrowser::found_list_view_selected));
+	HBox* passbox;
+	Label* label;
+	
+	passbox = manage(new HBox);
+	passbox->set_spacing (6);
+	
+	label = manage (new Label);
+	label->set_text (_("Tags:"));
+	passbox->pack_start (*label, false, false);
+	passbox->pack_start (freesound_entry, true, true);
+	
+	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_more_btn, false, false);
+	freesound_more_btn.set_label(_("More"));
+	freesound_more_btn.set_sensitive(false);
+
+	passbox->pack_end   (freesound_stop_btn, false, false);
+	freesound_stop_btn.set_label(_("Stop"));
+	freesound_stop_btn.set_sensitive(false);
+	
+	scroll = manage(new ScrolledWindow);
+	scroll->add(freesound_list_view);
+	scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+	
+	vbox = manage(new VBox);
+	vbox->set_spacing (3);
+	vbox->pack_start (*passbox, PACK_SHRINK);
+	vbox->pack_start (freesound_progress_bar, 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.append_column(_("Size"), freesound_list_columns.filesize);
+	freesound_list_view.append_column(_("Samplerate"), freesound_list_columns.smplrate);
+	freesound_list_view.append_column(_("License"), freesound_list_columns.license);
+	freesound_list_view.get_column(0)->set_alignment(0.5);
+	freesound_list_view.get_column(1)->set_expand(true);
+	freesound_list_view.get_column(2)->set_alignment(0.5);
+	freesound_list_view.get_column(3)->set_alignment(0.5);
+	freesound_list_view.get_column(4)->set_alignment(0.5);
+	freesound_list_view.get_column(5)->set_alignment(0.5);
+	
+	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_more_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_more_clicked));
+	freesound_stop_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_stop_clicked));
+	notebook.append_page (*vbox, _("Search Freesound"));
+#endif
 
-		found_list_view.signal_row_activated().connect (mem_fun (*this, &SoundFileBrowser::found_list_view_activated));
+	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)))));
 
-		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));
+	set_session (s);
 
-		notebook.append_page (*vbox, _("Search Tags"));
-	}
+	Gtk::HButtonBox* button_box = manage (new HButtonBox);
 
-	//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 (_("User:"));
-		passbox->pack_start (*label, false, false);
-		passbox->pack_start (freesound_name_entry);
-		label = manage (new Label);
-		label->set_text (_("Password:"));
-		passbox->pack_start (*label, false, false);
-		passbox->pack_start (freesound_pass_entry);
-		label = manage (new Label);
-		label->set_text (_("Tags:"));
-		passbox->pack_start (*label, false, false);
-		passbox->pack_start (freesound_entry, false, false);
-		passbox->pack_start (freesound_search_btn, false, false);
-
-		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);
-
-		//vbox->pack_start (freesound_list_view);
-
-		freesound_list_view.append_column(_("Paths"), freesound_list_columns.pathname);
-		freesound_list_view.get_selection()->signal_changed().connect(mem_fun(*this, &SoundFileBrowser::freesound_list_view_selected));
-
-		//freesound_list_view.get_selection()->set_mode (SELECTION_MULTIPLE);
-		freesound_list_view.signal_row_activated().connect (mem_fun (*this, &SoundFileBrowser::freesound_list_view_activated));
-		freesound_search_btn.signal_clicked().connect(mem_fun(*this, &SoundFileBrowser::freesound_search_clicked));
-		freesound_entry.signal_activate().connect(mem_fun(*this, &SoundFileBrowser::freesound_search_clicked));
-		notebook.append_page (*vbox, _("Search Freesound"));
+	button_box->set_layout (BUTTONBOX_END);
+	button_box->pack_start (cancel_button, false, false);
+	cancel_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*this, &SoundFileBrowser::do_something), RESPONSE_CANCEL));
+	if (persistent) {
+		button_box->pack_start (apply_button, false, false);
+		apply_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*this, &SoundFileBrowser::do_something), RESPONSE_APPLY));
 	}
-#endif
 
+	button_box->pack_start (ok_button, false, false);
+	ok_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*this, &SoundFileBrowser::do_something), RESPONSE_OK));
 
-	notebook.set_size_request (500, -1);
-
-	set_session (s);
+	Gtkmm2ext::UI::instance()->set_tip (ok_button, _("Press to import selected files and close this window"));
+	Gtkmm2ext::UI::instance()->set_tip (apply_button, _("Press to import selected files and leave this window open"));
+	Gtkmm2ext::UI::instance()->set_tip (cancel_button, _("Press to close this window without importing any files"));
 
-	add_button (Stock::CANCEL, RESPONSE_CANCEL);
-	add_button (Stock::APPLY, RESPONSE_APPLY);
-	add_button (Stock::OK, RESPONSE_OK);
+	vpacker.pack_end (*button_box, false, false);
 
+	set_wmclass (X_("import"), PROGRAM_NAME);
 }
 
 SoundFileBrowser::~SoundFileBrowser ()
@@ -544,11 +626,40 @@ SoundFileBrowser::~SoundFileBrowser ()
 	persistent_folder = chooser.get_current_folder();
 }
 
+int
+SoundFileBrowser::run ()
+{
+	set_modal (true);
+	show_all ();
+	present ();
+
+	_done = false;
+
+	while (!_done) {
+		gtk_main_iteration ();
+	}
+
+	return _status;
+}
+
+void
+SoundFileBrowser::set_action_sensitive (bool yn)
+{
+	ok_button.set_sensitive (yn);
+	apply_button.set_sensitive (yn);
+}
+
+void
+SoundFileBrowser::do_something (int action)
+{
+	_done = true;
+	_status = action;
+}
 
 void
 SoundFileBrowser::on_show ()
 {
-	ArdourDialog::on_show ();
+	ArdourWindow::on_show ();
 	start_metering ();
 }
 
@@ -580,9 +691,10 @@ SoundFileBrowser::freesound_list_view_activated (const TreeModel::Path&, TreeVie
 void
 SoundFileBrowser::set_session (Session* s)
 {
-	ArdourDialog::set_session (s);
+	ArdourWindow::set_session (s);
 	preview.set_session (s);
-	if (s) {
+
+	if (_session) {
 		add_gain_meter ();
 	} else {
 		remove_gain_meter ();
@@ -594,11 +706,12 @@ SoundFileBrowser::add_gain_meter ()
 {
 	delete gm;
 
-	gm = new GainMeter (*session, 250);
+	gm = new GainMeter (_session, 250);
 
-	boost::shared_ptr<Route> r = session->the_auditioner ();
+	boost::shared_ptr<Route> r = _session->the_auditioner ();
 
 	gm->set_controls (r, r->shared_peak_meter(), r->amp());
+	gm->set_fader_name (X_("AudioTrackFader"));
 
 	meter_packer.set_border_width (12);
 	meter_packer.pack_start (*gm, false, true);
@@ -621,7 +734,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
@@ -633,7 +746,7 @@ SoundFileBrowser::stop_metering ()
 void
 SoundFileBrowser::meter ()
 {
-	if (is_mapped () && session && gm) {
+	if (is_mapped () && _session && gm) {
 		gm->update_meters ();
 	}
 }
@@ -650,12 +763,18 @@ 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));
 		}
 	}
 }
@@ -664,9 +783,9 @@ void
 SoundFileBrowser::found_list_view_selected ()
 {
 	if (!reset_options ()) {
-		set_response_sensitive (RESPONSE_OK, false);
+		set_action_sensitive (false);
 	} else {
-		ustring file;
+		string file;
 
 		TreeView::Selection::ListHandle_Path rows = found_list_view.get_selection()->get_selected_rows ();
 
@@ -674,9 +793,9 @@ SoundFileBrowser::found_list_view_selected ()
 			TreeIter iter = found_list->get_iter(*rows.begin());
 			file = (*iter)[found_list_columns.pathname];
 			chooser.set_filename (file);
-			set_response_sensitive (RESPONSE_OK, true);
+			set_action_sensitive (true);
 		} else {
-			set_response_sensitive (RESPONSE_OK, false);
+			set_action_sensitive (false);
 		}
 
 		preview.setup_labels (file);
@@ -686,24 +805,50 @@ SoundFileBrowser::found_list_view_selected ()
 void
 SoundFileBrowser::freesound_list_view_selected ()
 {
+	freesound_download_cancel = false;
+	freesound_stop_btn.set_sensitive(true);
+
+#ifdef FREESOUND
 	if (!reset_options ()) {
-		set_response_sensitive (RESPONSE_OK, false);
+		set_action_sensitive (false);
 	} else {
-		ustring file;
+		Mootcher mootcher; 
+		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());
-			file = (*iter)[freesound_list_columns.pathname];
-			chooser.set_filename (file);
-			set_response_sensitive (RESPONSE_OK, true);
+
+			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_action_sensitive (true);
+			}
 		} else {
-			set_response_sensitive (RESPONSE_OK, false);
+			set_action_sensitive (false);
 		}
 
+		freesound_progress_bar.set_text(
+			string_compose(P_("found %1 match", "found %1 matches", matches), matches));
+
 		preview.setup_labels (file);
 	}
+#endif
+	freesound_stop_btn.set_sensitive(false);
 }
 
 void
@@ -730,98 +875,216 @@ SoundFileBrowser::found_search_clicked ()
 	}
 }
 
-void*
-freesound_search_thread_entry (void* arg)
+void
+SoundFileBrowser::freesound_search_clicked ()
 {
-	PBD::notify_gui_about_thread_creation (pthread_self(), X_("Freesound Search"));
+	freesound_page = 1;
+	freesound_list->clear();
+	matches = 0;
+	freesound_search();
+}
 
-	static_cast<SoundFileBrowser*>(arg)->freesound_search_thread ();
+void
+SoundFileBrowser::freesound_more_clicked ()
+{
+	char row_path[21];
+	freesound_page++;
+	freesound_search();
+	snprintf(row_path, 21, "%d", (freesound_page - 1) * 100);
+	freesound_list_view.scroll_to_row(Gtk::TreePath(row_path), 0);
+}
 
-	return 0;
+void
+SoundFileBrowser::freesound_stop_clicked ()
+{
+	freesound_download_cancel = true;
 }
 
-bool searching = false;
-bool canceling = false;
 
 void
-SoundFileBrowser::freesound_search_clicked ()
+SoundFileBrowser::freesound_search()
 {
-	if (canceling)  //already canceling, button does nothing
+#ifdef FREESOUND
+	Mootcher mootcher;
+	freesound_list_view.get_column(1)->set_sizing(TREE_VIEW_COLUMN_GROW_ONLY);
+
+	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));
+	freesound_progress_bar.set_fraction(0.0);
+	gdk_flush();
+
+	std::string theString = mootcher.searchText(
+			search_string, 
+			freesound_page,
+#ifdef GTKOSX
+			"", // OSX eats anything incl mp3
+#else
+			"type:wav OR type:aiff OR type:flac OR type:aif OR type:ogg OR type:oga",
+#endif
+			sort_method
+			);
+
+	gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
+
+	XMLTree doc;
+	doc.read_buffer( theString );
+	XMLNode *root = doc.root();
+
+	if (!root) {
+		error << "no root XML node!" << endmsg;
+		return;
+	}
+
+	if ( strcmp(root->name().c_str(), "response") != 0) {
+		error << string_compose ("root node name == %1 != \"response\"", root->name()) << endmsg;
 		return;
+	}
+
+	// find out how many pages are available to search
+	int freesound_n_pages = 1;
+	XMLNode *res = root->child("num_pages");
+	if (res) {
+		string result = res->child("text")->content();
+		freesound_n_pages = atoi(result.c_str());
+	}
 
-	if ( searching ) {
-		freesound_search_btn.set_label(_("Cancelling.."));
-		canceling = true;
+	int more_pages = freesound_n_pages - freesound_page;
+
+	if (more_pages > 0) {
+		freesound_more_btn.set_sensitive(true);
+		freesound_more_btn.set_tooltip_text(string_compose(P_(
+						"%1 more page of 100 results available",
+						"%1 more pages of 100 results available",
+						more_pages), more_pages));
 	} else {
-		searching = true;
-		freesound_search_btn.set_label(_("Cancel"));
-		pthread_t freesound_thr;
-		pthread_create_and_store ("freesound_search", &freesound_thr, 0, freesound_search_thread_entry, this);
+		freesound_more_btn.set_sensitive(false);
+		freesound_more_btn.set_tooltip_text(_("No more results available"));
 	}
-}
 
-void
-SoundFileBrowser::freesound_search_thread()
-{
-#ifdef FREESOUND
-	freesound_list->clear();
+	XMLNode *sounds_root = root->child("sounds");
+	if (!sounds_root) {
+		error << "no child node \"sounds\" found!" << endmsg;
+		return;
+	}
 
-	string path;
-	path = Glib::get_home_dir();
-	path += "/Freesound/";
-	Mootcher theMootcher(path.c_str());
+	XMLNodeList sounds = sounds_root->children();
+	if (sounds.size() == 0) {
+		/* nothing found */
+		return;
+	}
 
-	string name_string = freesound_name_entry.get_text ();
-	string pass_string = freesound_pass_entry.get_text ();
-	string search_string = freesound_entry.get_text ();
+	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;
+			break;
+		}
 
-	if ( theMootcher.doLogin( name_string, pass_string ) ) {
+		// node->dump(cerr, "node:");
 
-		string theString = theMootcher.searchText(search_string);
 
-		XMLTree doc;
-		doc.read_buffer( theString );
-		XMLNode *root = doc.root();
+		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");
+		XMLNode *siz_node = node->child ("filesize");
+		XMLNode *srt_node = node->child ("samplerate");
+		XMLNode *lic_node = node->child ("license");
 
-		if (root==NULL) return;
+		if (id_node && uri_node && ofn_node && dur_node && siz_node && srt_node) {
 
-		if ( strcmp(root->name().c_str(), "freesound") == 0) {
+			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 siz = siz_node->child("text")->content();
+			std::string srt = srt_node->child("text")->content();
+			std::string lic = lic_node->child("text")->content();
 
-			XMLNode *node = 0;
-			XMLNodeList children = root->children();
-			XMLNodeConstIterator niter;
-			for (niter = children.begin(); niter != children.end() && !canceling; ++niter) {
-				node = *niter;
-				if( strcmp( node->name().c_str(), "sample") == 0 ){
-					XMLProperty *prop=node->property ("id");
-					string filename = theMootcher.getFile( prop->value().c_str() );
-					if ( filename != "" ) {
-						TreeModel::iterator new_row = freesound_list->append();
-						TreeModel::Row row = *new_row;
-						string path = Glib::filename_from_uri (string ("file:") + filename);
-						row[freesound_list_columns.pathname] = path;
-					}
-				}
+			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
+				       );
+			}
+
+			double size_bytes = atof(siz.c_str());
+			char bsize[32];
+			if (size_bytes < 1000) {
+				sprintf(bsize, "%.0f %s", size_bytes, _("B"));
+			} else if (size_bytes < 1000000 ) {
+				sprintf(bsize, "%.1f %s", size_bytes / 1000.0, _("kB"));
+			} else if (size_bytes < 10000000) {
+				sprintf(bsize, "%.1f %s", size_bytes / 1000000.0, _("MB"));
+			} else if (size_bytes < 1000000000) {
+				sprintf(bsize, "%.2f %s", size_bytes / 1000000.0, _("MB"));
+			} else {
+				sprintf(bsize, "%.2f %s", size_bytes / 1000000000.0, _("GB"));
+			}
+
+			/* see http://www.freesound.org/help/faq/#licenses */
+			char shortlicense[64];
+			if(!lic.compare(0, 42, "http://creativecommons.org/licenses/by-nc/")){
+				sprintf(shortlicense, "CC-BY-NC");
+			} else if(!lic.compare(0, 39, "http://creativecommons.org/licenses/by/")) {
+				sprintf(shortlicense, "CC-BY");
+			} else if(!lic.compare("http://creativecommons.org/licenses/sampling+/1.0/")) {
+				sprintf(shortlicense, "sampling+");
+			} else if(!lic.compare(0, 40, "http://creativecommons.org/publicdomain/")) {
+				sprintf(shortlicense, "PD");
+			} else {
+				snprintf(shortlicense, 64, "%s", lic.c_str());
+				shortlicense[63]= '\0';
 			}
+
+			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;
+			row[freesound_list_columns.filesize] = bsize;
+			row[freesound_list_columns.smplrate] = srt;
+			row[freesound_list_columns.license ] = shortlicense;
+			matches++;
 		}
 	}
 
-	searching = false;
-	canceling = false;
-	freesound_search_btn.set_label(_("Start Downloading"));
+	if (matches == 0) {
+		freesound_progress_bar.set_text(_("Search returned no results."));
+	} else {
+		freesound_progress_bar.set_text(string_compose(P_("Found %1 match", "Found %1 matches", matches), matches));
+	}
+	freesound_list_view.get_column(1)->set_sizing(TREE_VIEW_COLUMN_AUTOSIZE);
 #endif
 }
 
-vector<ustring>
+vector<string>
 SoundFileBrowser::get_paths ()
 {
-	vector<ustring> results;
+	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;
@@ -837,21 +1100,36 @@ SoundFileBrowser::get_paths ()
 		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;
+		Mootcher mootcher;
 
 		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);
-			ustring str = (*iter)[freesound_list_columns.pathname];
+			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);
 
-			results.push_back (str);
 		}
+#endif
 	}
 
 	return results;
@@ -868,13 +1146,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;
@@ -887,7 +1166,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()) {
@@ -900,39 +1179,61 @@ 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();
+	resetting_ourselves = true;
+
+	if (chooser.get_filter() == &audio_filter) {
 
-			switch (id) {
-			case Editing::ImportDistinctFiles:
-				if (selected_track_cnt == paths.size()) {
+		/* 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;
+			}
+		}
+		
+	}  else {
 
-			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;
+		/* MIDI ONLY */
 
-			default:
-				action_strings.push_back (importmode2string (ImportToTrack));
-				break;
-			}
+		if (selected_midi_track_cnt > 0) {
+			action_strings.push_back (importmode2string (ImportToTrack));
 		}
 	}
 
@@ -940,8 +1241,6 @@ SoundFileOmega::reset_options ()
 	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);
@@ -989,7 +1288,8 @@ 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"));
 			}
 
 		}
@@ -1008,6 +1308,8 @@ SoundFileOmega::reset_options ()
 		}
 	}
 
+	resetting_ourselves = true;
+
 	existing_choice = channel_combo.get_active_text();
 
 	set_popdown_strings (channel_combo, channel_strings);
@@ -1029,23 +1331,35 @@ 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
+	 * or any file if we are under nsm control */
+	bool const must_copy = _session->get_nsm_state() || 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;
@@ -1056,7 +1370,7 @@ bool
 SoundFileOmega::bad_file_message()
 {
 	MessageDialog msg (*this,
-			   _("One or more of the selected files\ncannot be used by Ardour"),
+			   string_compose (_("One or more of the selected files\ncannot be used by %1"), PROGRAM_NAME),
 			   true,
 			   Gtk::MESSAGE_INFO,
 			   Gtk::BUTTONS_OK);
@@ -1069,10 +1383,10 @@ 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)
 {
 	SoundFileInfo info;
-	nframes64_t sz = 0;
+	framepos_t sz = 0;
 	bool err = false;
 	string errmsg;
 
@@ -1080,7 +1394,7 @@ SoundFileOmega::check_info (const vector<ustring>& paths, bool& same_size, bool&
 	src_needed = false;
 	multichannel = 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) {
 
 		if (AudioFileSource::get_soundfile_info (*i, info, errmsg)) {
 			if (info.channels > 1) {
@@ -1094,7 +1408,7 @@ SoundFileOmega::check_info (const vector<ustring>& paths, bool& same_size, bool&
 				}
 			}
 
-			if ((nframes_t) info.samplerate != session->frame_rate()) {
+			if (info.samplerate != _session->frame_rate()) {
 				src_needed = true;
 			}
 
@@ -1120,10 +1434,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)) {
@@ -1132,7 +1445,7 @@ SoundFileOmega::check_link_status (const Session& s, const vector<ustring>& path
 		}
 	}
 
-	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];
 
@@ -1154,8 +1467,8 @@ SoundFileOmega::check_link_status (const Session& s, const vector<ustring>& path
 	return ret;
 }
 
-SoundFileChooser::SoundFileChooser (Gtk::Window& parent, string title, ARDOUR::Session* s)
-	: SoundFileBrowser (parent, title, s, false)
+SoundFileChooser::SoundFileChooser (string title, ARDOUR::Session* s)
+	: SoundFileBrowser (title, s, false)
 {
 	chooser.set_select_multiple (false);
 	found_list_view.get_selection()->set_mode (SELECTION_SINGLE);
@@ -1165,37 +1478,41 @@ SoundFileChooser::SoundFileChooser (Gtk::Window& parent, string title, ARDOUR::S
 void
 SoundFileChooser::on_hide ()
 {
-	ArdourDialog::on_hide();
+	ArdourWindow::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 (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 (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;
@@ -1218,16 +1535,16 @@ SoundFileOmega::SoundFileOmega (Gtk::Window& parent, string title, ARDOUR::Sessi
 	where_combo.set_active_text (str.front());
 
 	Label* l = manage (new Label);
-	l->set_text (_("Add files:"));
+	l->set_markup (_("<b>Add files as ...</b>"));
 
-	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);
 	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
 	   come up with no tracks selected.
@@ -1240,29 +1557,29 @@ SoundFileOmega::SoundFileOmega (Gtk::Window& parent, string title, ARDOUR::Sessi
 	action_combo.set_sensitive (false);
 
 	l = manage (new Label);
-	l->set_text (_("Insert at:"));
+	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"));
@@ -1271,16 +1588,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"));
@@ -1295,28 +1612,37 @@ 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);
 
-	get_vbox()->pack_start (options, false, false);
+	vpacker.pack_start (options, false, false);
 
 	/* 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<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<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));
+	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 (mem_fun (*this, &SoundFileOmega::file_selection_changed));
+	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
@@ -1328,14 +1654,14 @@ SoundFileOmega::SoundFileOmega (Gtk::Window& parent, string title, ARDOUR::Sessi
 	t.push_back (_("one track per channel"));
 	t.push_back (_("sequence files"));
 	t.push_back (_("all files in one region"));
-	set_size_request_to_display_given_text (channel_combo, t, COMBO_FUDGE + 10, 15);
+	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_size_request_to_display_given_text (action_combo, t, COMBO_FUDGE + 10, 15);
+	set_popdown_strings (action_combo, t);
 }
 
 void
@@ -1353,16 +1679,16 @@ SoundFileOmega::get_mode () const
 void
 SoundFileOmega::on_hide ()
 {
-	ArdourDialog::on_hide();
-	if (session) {
-		session->cancel_audition();
+	ArdourWindow::on_hide();
+	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 == _("file timestamp")) {
 		return ImportAtTimestamp;
@@ -1378,7 +1704,7 @@ SoundFileOmega::get_position() const
 SrcQuality
 SoundFileOmega::get_src_quality() const
 {
-	ustring str = where_combo.get_active_text();
+	string str = src_combo.get_active_text();
 
 	if (str == _("Best")) {
 		return SrcBest;
@@ -1401,7 +1727,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()) {
@@ -1413,9 +1739,19 @@ 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 ();
 }
 
@@ -1427,13 +1763,59 @@ SoundFileOmega::file_selection_changed ()
 	}
 
 	if (!reset_options ()) {
-		set_response_sensitive (RESPONSE_OK, false);
+		set_action_sensitive (false);
 	} else {
 		if (chooser.get_filenames().size() > 0) {
-			set_response_sensitive (RESPONSE_OK, true);
+			set_action_sensitive (true);
 		} else {
-			set_response_sensitive (RESPONSE_OK, false);
+			set_action_sensitive (false);
 		}
 	}
 }
 
+void
+SoundFileOmega::do_something (int action)
+{
+	SoundFileBrowser::do_something (action);
+
+	if (action == RESPONSE_CANCEL) {
+		hide ();
+		return;
+	}
+
+	/* lets do it */
+	
+	vector<string> paths = get_paths ();
+	ImportPosition pos = get_position ();
+	ImportMode mode = get_mode ();
+	ImportDisposition chns = get_channel_disposition ();
+	framepos_t where;
+	
+	switch (pos) {
+	case ImportAtEditPoint:
+		where = PublicEditor::instance().get_preferred_edit_position ();
+		break;
+	case ImportAtTimestamp:
+		where = -1;
+		break;
+	case ImportAtPlayhead:
+		where = _session->transport_frame();
+		break;
+	case ImportAtStart:
+		where = _session->current_start_frame();
+		break;
+	}
+	
+	SrcQuality quality = get_src_quality();
+	
+	if (copy_files_btn.get_active()) {
+		PublicEditor::instance().do_import (paths, chns, mode, quality, where);
+	} else {
+		PublicEditor::instance().do_embed (paths, chns, mode, where);
+	}
+	
+	if (action == RESPONSE_OK) {
+		hide ();
+	}
+}
+