X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_audio_import.cc;h=dd706496e372c7d3ac3d790e6030780982ac441d;hb=b4dd5b737fe7c6c8c01c37ca8f78ad7624262cb7;hp=201659d7b4246ca5df18ec3097224917d8b78d05;hpb=17088ee3ea5af1e6174b098bb5bcfdaec6ebf9b0;p=ardour.git

diff --git a/gtk2_ardour/editor_audio_import.cc b/gtk2_ardour/editor_audio_import.cc
index 201659d7b4..dd706496e3 100644
--- a/gtk2_ardour/editor_audio_import.cc
+++ b/gtk2_ardour/editor_audio_import.cc
@@ -33,20 +33,16 @@
 
 #include <gtkmm2ext/choice.h>
 
-#include "ardour/session.h"
-#include "ardour/session_directory.h"
-#include "ardour/audioplaylist.h"
-#include "ardour/audioregion.h"
-#include "ardour/audio_diskstream.h"
-#include "ardour/midi_track.h"
-#include "ardour/midi_region.h"
-#include "ardour/utils.h"
 #include "ardour/audio_track.h"
-#include "ardour/audioplaylist.h"
 #include "ardour/audiofilesource.h"
+#include "ardour/audioregion.h"
+#include "ardour/midi_region.h"
+#include "ardour/midi_track.h"
+#include "ardour/operations.h"
 #include "ardour/region_factory.h"
+#include "ardour/smf_source.h"
 #include "ardour/source_factory.h"
-#include "ardour/session.h"
+#include "ardour/utils.h"
 #include "pbd/memento_command.h"
 
 #include "ardour_ui.h"
@@ -58,6 +54,9 @@
 #include "session_import_dialog.h"
 #include "utils.h"
 #include "gui_thread.h"
+#include "interthread_progress_window.h"
+#include "mouse_cursors.h"
+#include "editor_cursors.h"
 
 #include "i18n.h"
 
@@ -67,7 +66,7 @@ using namespace PBD;
 using namespace Gtk;
 using namespace Gtkmm2ext;
 using namespace Editing;
-using Glib::ustring;
+using std::string;
 
 /* Functions supporting the incorporation of external (non-captured) audio material into ardour */
 
@@ -79,9 +78,9 @@ Editor::add_external_audio_action (ImportMode mode_hint)
 		msg.run ();
 		return;
 	}
-	
+
 	if (sfbrowser == 0) {
-		sfbrowser = new SoundFileOmega (*this, _("Add Existing Media"), _session, 0, true, mode_hint);
+		sfbrowser = new SoundFileOmega (_("Add Existing Media"), _session, 0, true, mode_hint);
 	} else {
 		sfbrowser->set_mode (mode_hint);
 	}
@@ -92,8 +91,9 @@ Editor::add_external_audio_action (ImportMode mode_hint)
 void
 Editor::external_audio_dialog ()
 {
-	vector<Glib::ustring> paths;
-	uint32_t track_cnt;
+	vector<string> paths;
+	uint32_t audio_track_cnt;
+	uint32_t midi_track_cnt;
 
 	if (_session == 0) {
 		MessageDialog msg (_("You can't import or embed an audiofile until you have a session loaded."));
@@ -101,88 +101,35 @@ Editor::external_audio_dialog ()
 		return;
 	}
 
-	track_cnt = 0;
+	audio_track_cnt = 0;
+	midi_track_cnt = 0;
 
 	for (TrackSelection::iterator x = selection->tracks.begin(); x != selection->tracks.end(); ++x) {
 		AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*>(*x);
 
-		if (!atv) {
-			continue;
-		} else if (atv->is_audio_track()) {
-			track_cnt++;
+		if (atv) {
+			if (atv->is_audio_track()) {
+				audio_track_cnt++;
+			} 
+
+		} else {
+			MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(*x);
+
+			if (mtv) {
+				if (mtv->is_midi_track()) {
+					midi_track_cnt++;
+				}
+			}
 		}
 	}
 
 	if (sfbrowser == 0) {
-		sfbrowser = new SoundFileOmega (*this, _("Add Existing Media"), _session, track_cnt, true);
+		sfbrowser = new SoundFileOmega (_("Add Existing Media"), _session, audio_track_cnt, midi_track_cnt, true);
 	} else {
-		sfbrowser->reset (track_cnt);
+		sfbrowser->reset (audio_track_cnt, midi_track_cnt);
 	}
 
 	sfbrowser->show_all ();
-
-
-	bool keepRunning;
-
-	do {
-		keepRunning = false;
-
-		int response = sfbrowser->run ();
-
-		switch (response) {
-			case RESPONSE_APPLY:
-				// leave the dialog open
-				break;
-
-			case RESPONSE_OK:
-				sfbrowser->hide ();
-				break;
-
-			default:
-				// cancel from the browser - we are done
-				sfbrowser->hide ();
-				return;
-		}
-
-		/* lets do it */
-
-		paths = sfbrowser->get_paths ();
-
-		ImportPosition pos = sfbrowser->get_position ();
-		ImportMode mode = sfbrowser->get_mode ();
-		ImportDisposition chns = sfbrowser->get_channel_disposition ();
-		nframes64_t where;
-
-		switch (pos) {
-			case ImportAtEditPoint:
-				where = get_preferred_edit_position ();
-				break;
-			case ImportAtTimestamp:
-				where = -1;
-				break;
-			case ImportAtPlayhead:
-				where = playhead_cursor->current_frame;
-				break;
-			case ImportAtStart:
-				where = _session->current_start_frame();
-				break;
-		}
-
-		SrcQuality quality = sfbrowser->get_src_quality();
-
-
-		if (sfbrowser->copy_files_btn.get_active()) {
-			do_import (paths, chns, mode, quality, where);
-		} else {
-			do_embed (paths, chns, mode, where);
-		}
-
-		if (response == RESPONSE_APPLY) {
-			sfbrowser->clear_selection ();
-			keepRunning = true;
-		}
-
-	} while (keepRunning);
 }
 
 void
@@ -196,7 +143,7 @@ Editor::session_import_dialog ()
 typedef std::map<PBD::ID,boost::shared_ptr<ARDOUR::Source> > SourceMap;
 
 /**
- * Updating is still disabled, see note in libs/ardour/import.cc Session::import_audiofiles()
+ * Updating is still disabled, see note in libs/ardour/import.cc Session::import_files()
  *
  * all_or_nothing:
  *   true  = show "Update", "Import" and "Skip"
@@ -212,20 +159,16 @@ Editor::check_whether_and_how_to_import(string path, bool all_or_nothing)
 {
 	string wave_name (Glib::path_get_basename(path));
 
-	SourceMap all_sources = _session->get_sources();
-	bool wave_name_exists = false;
+	bool already_exists = false;
+	uint32_t existing;
 
-	for (SourceMap::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
-		string tmp (Glib::path_get_basename (i->second->path()));
-		if (tmp == wave_name) {
-			wave_name_exists = true;
-			break;
-		}
+	if ((existing = _session->count_sources_by_origin (path)) > 0) {
+		already_exists = true;
 	}
 
 	int function = 1;
 
-	if (wave_name_exists) {
+	if (already_exists) {
 		string message;
 		if (all_or_nothing) {
 			// updating is still disabled
@@ -320,24 +263,30 @@ Editor::get_nth_selected_midi_track (int nth) const
 }
 
 void
-Editor::do_import (vector<ustring> paths, ImportDisposition chns, ImportMode mode, SrcQuality quality, nframes64_t& pos)
+Editor::do_import (vector<string> paths, ImportDisposition disposition, ImportMode mode, SrcQuality quality, framepos_t& pos)
 {
 	boost::shared_ptr<Track> track;
-	vector<ustring> to_import;
+	vector<string> to_import;
 	int nth = 0;
+	bool use_timestamp = (pos == -1);
 
-	if (interthread_progress_window == 0) {
-		build_interthread_progress_window ();
-	}
+	current_interthread_info = &import_status;
+	import_status.current = 1;
+	import_status.total = paths.size ();
+	import_status.all_done = false;
 
-	if (chns == Editing::ImportMergeFiles) {
+	ImportProgressWindow ipw (&import_status, _("Import"), _("Cancel Import"));
+
+	bool ok = true;
+
+	if (disposition == Editing::ImportMergeFiles) {
 
 		/* create 1 region from all paths, add to 1 track,
 		   ignore "track"
 		*/
 
 		bool cancel = false;
-		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+		for (vector<string>::iterator a = paths.begin(); a != paths.end(); ++a) {
 			int check = check_whether_and_how_to_import(*a, false);
 			if (check == 2) {
 				cancel = true;
@@ -345,63 +294,107 @@ Editor::do_import (vector<ustring> paths, ImportDisposition chns, ImportMode mod
 			}
 		}
 
-		if (!cancel) {
-			import_sndfiles (paths, mode, quality, pos, 1, 1, track, false, paths.size());
+		if (cancel) {
+			ok = false;
+		} else {
+			ipw.show ();
+			ok = (import_sndfiles (paths, disposition, mode, quality, pos, 1, 1, track, false) == 0);
 		}
 
 	} else {
 
-		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+		bool replace = false;
 
-			int const check = check_whether_and_how_to_import (*a, true);
+		for (vector<string>::iterator a = paths.begin(); a != paths.end(); ++a) {
 
-			if (check != 2) {
-				to_import.push_back (*a);
-			}
-		}
+			const int check = check_whether_and_how_to_import (*a, true);
 
-		bool ok = true;
+			switch (check) {
+			case 2:
+				// user said skip
+				continue;
+			case 0:
+				fatal << "Updating existing sources should be disabled!" << endmsg;
+				/* NOTREACHED*/
+				break;
+			case 1:
+				replace = false;
+				break;
+			default:
+				fatal << "Illegal return " << check <<  " from check_whether_and_how_to_import()!" << endmsg;
+				/* NOTREACHED*/
+			}
 
-		switch (chns) {
-		case Editing::ImportDistinctFiles:
+			/* have to reset this for every file we handle */
 
-			if (mode == Editing::ImportToTrack) {
-				track = get_nth_selected_audio_track (nth++);
+			if (use_timestamp) {
+				pos = -1;
 			}
 
-			ok = (import_sndfiles (to_import, mode, quality, pos, 1, -1, track, false, to_import.size()) == 0);
-			break;
+			ipw.show ();
+
+			switch (disposition) {
+			case Editing::ImportDistinctFiles:
+
+				to_import.clear ();
+				to_import.push_back (*a);
+
+				if (mode == Editing::ImportToTrack) {
+					track = get_nth_selected_audio_track (nth++);
+				}
+
+				ok = (import_sndfiles (to_import, disposition, mode, quality, pos, 1, -1, track, replace) == 0);
+				break;
 
-		case Editing::ImportDistinctChannels:
-			ok = (import_sndfiles (to_import, mode, quality, pos, -1, -1, track, false, to_import.size()) == 0);
-			break;
+			case Editing::ImportDistinctChannels:
 
-		case Editing::ImportSerializeFiles:
-			ok = (import_sndfiles (to_import, mode, quality, pos, 1, 1, track, false, to_import.size()) == 0);
-			break;
+				to_import.clear ();
+				to_import.push_back (*a);
 
-		case Editing::ImportMergeFiles:
-			// Not entered, handled in earlier if() branch
-			break;
+				ok = (import_sndfiles (to_import, disposition, mode, quality, pos, -1, -1, track, replace) == 0);
+				break;
+
+			case Editing::ImportSerializeFiles:
+
+				to_import.clear ();
+				to_import.push_back (*a);
+
+				ok = (import_sndfiles (to_import, disposition, mode, quality, pos, 1, 1, track, replace) == 0);
+				break;
+
+			case Editing::ImportMergeFiles:
+				// Not entered, handled in earlier if() branch
+				break;
+			}
 		}
 	}
 
-	interthread_progress_window->hide_all ();
+	if (ok) {
+		_session->save_state ("");
+	}
+
+	import_status.all_done = true;
 }
 
 void
-Editor::do_embed (vector<ustring> paths, ImportDisposition chns, ImportMode mode, nframes64_t& pos)
+Editor::do_embed (vector<string> paths, ImportDisposition import_as, ImportMode mode, framepos_t& pos)
 {
 	boost::shared_ptr<Track> track;
 	bool check_sample_rate = true;
 	bool ok = false;
-	vector<ustring> to_embed;
+	vector<string> to_embed;
 	bool multi = paths.size() > 1;
 	int nth = 0;
+	bool use_timestamp = (pos == -1);
 
-	switch (chns) {
+	switch (import_as) {
 	case Editing::ImportDistinctFiles:
-		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+		for (vector<string>::iterator a = paths.begin(); a != paths.end(); ++a) {
+
+			/* have to reset this for every file we handle */
+			if (use_timestamp) {
+				pos = -1;
+			}
 
 			to_embed.clear ();
 			to_embed.push_back (*a);
@@ -410,37 +403,47 @@ Editor::do_embed (vector<ustring> paths, ImportDisposition chns, ImportMode mode
 				track = get_nth_selected_audio_track (nth++);
 			}
 
-			if (embed_sndfiles (to_embed, multi, check_sample_rate, mode, pos, 1, -1, track) < -1) {
+			if (embed_sndfiles (to_embed, multi, check_sample_rate, import_as, mode, pos, 1, -1, track) < -1) {
 				goto out;
 			}
 		}
 		break;
 
 	case Editing::ImportDistinctChannels:
-		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+		for (vector<string>::iterator a = paths.begin(); a != paths.end(); ++a) {
+
+			/* have to reset this for every file we handle */
+			if (use_timestamp) {
+				pos = -1;
+			}
 
 			to_embed.clear ();
 			to_embed.push_back (*a);
 
-			if (embed_sndfiles (to_embed, multi, check_sample_rate, mode, pos, -1, -1, track) < -1) {
+			if (embed_sndfiles (to_embed, multi, check_sample_rate, import_as, mode, pos, -1, -1, track) < -1) {
 				goto out;
 			}
 		}
 		break;
 
 	case Editing::ImportMergeFiles:
-		if (embed_sndfiles (paths, multi, check_sample_rate, mode, pos, 1, 1, track) < -1) {
+		if (embed_sndfiles (paths, multi, check_sample_rate, import_as, mode, pos, 1, 1, track) < -1) {
 			goto out;
 		}
-	break;
+		break;
 
 	case Editing::ImportSerializeFiles:
-		for (vector<ustring>::iterator a = paths.begin(); a != paths.end(); ++a) {
+		for (vector<string>::iterator a = paths.begin(); a != paths.end(); ++a) {
+
+			/* have to reset this for every file we handle */
+			if (use_timestamp) {
+				pos = -1;
+			}
 
 			to_embed.clear ();
 			to_embed.push_back (*a);
 
-			if (embed_sndfiles (to_embed, multi, check_sample_rate, mode, pos, 1, 1, track) < -1) {
+			if (embed_sndfiles (to_embed, multi, check_sample_rate, import_as, mode, pos, 1, 1, track) < -1) {
 				goto out;
 			}
 		}
@@ -456,23 +459,15 @@ Editor::do_embed (vector<ustring> paths, ImportDisposition chns, ImportMode mode
 }
 
 int
-Editor::import_sndfiles (vector<ustring> paths, ImportMode mode, SrcQuality quality, nframes64_t& pos,
-			 int target_regions, int target_tracks, boost::shared_ptr<Track> track, bool replace, uint32_t total)
+Editor::import_sndfiles (vector<string> paths, ImportDisposition disposition, ImportMode mode, SrcQuality quality, framepos_t& pos,
+			 int target_regions, int target_tracks, boost::shared_ptr<Track>& track, bool replace)
 {
-	interthread_progress_window->set_title (string_compose (_("Importing %1"), paths.front()));
-	interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
-	interthread_progress_bar.set_fraction (0.0f);
-	interthread_cancel_label.set_text (_("Cancel Import"));
- 	current_interthread_info = &import_status;
-
 	import_status.paths = paths;
 	import_status.done = false;
 	import_status.cancel = false;
 	import_status.freeze = false;
-	import_status.done = 0.0;
 	import_status.quality = quality;
 	import_status.replace_existing_source = replace;
-	import_status.total = total;
 
 	import_status.mode = mode;
 	import_status.pos = pos;
@@ -480,13 +475,11 @@ Editor::import_sndfiles (vector<ustring> paths, ImportMode mode, SrcQuality qual
 	import_status.target_regions = target_regions;
 	import_status.track = track;
 	import_status.replace = replace;
-	interthread_progress_connection = Glib::signal_timeout().connect
-		(sigc::bind (sigc::mem_fun(*this, &Editor::import_progress_timeout), (gpointer) 0), 500);
 
-	track_canvas->get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
+	set_canvas_cursor (_cursors->wait);
 	gdk_flush ();
 
-	/* start import thread for this spec. this will ultimately call Session::import_audiofiles()
+	/* start import thread for this spec. this will ultimately call Session::import_files()
 	   which, if successful, will add the files as regions to the region list. its up to us
 	   (the GUI) to direct additional steps after that.
 	*/
@@ -498,34 +491,35 @@ Editor::import_sndfiles (vector<ustring> paths, ImportMode mode, SrcQuality qual
 		gtk_main_iteration ();
 	}
 
-	interthread_progress_window->hide ();
 	import_status.done = true;
-	interthread_progress_connection.disconnect ();
+
+	int result = -1;
 
 	if (!import_status.cancel && !import_status.sources.empty()) {
-		if (add_sources (import_status.paths,
-				 import_status.sources,
-				 import_status.pos,
-				 import_status.mode,
-				 import_status.target_regions,
-				 import_status.target_tracks,
-				 import_status.track, false) == 0) {
-			_session->save_state ("");
-		}
+		result = add_sources (
+			import_status.paths,
+			import_status.sources,
+			import_status.pos,
+			disposition,
+			import_status.mode,
+			import_status.target_regions,
+			import_status.target_tracks,
+			track, false
+			);
 
 		/* update position from results */
 
 		pos = import_status.pos;
 	}
 
-
-	track_canvas->get_window()->set_cursor (*current_canvas_cursor);
-	return 0;
+	set_canvas_cursor (current_canvas_cursor);
+	return result;
 }
 
 int
-Editor::embed_sndfiles (vector<Glib::ustring> paths, bool multifile,
-			bool& check_sample_rate, ImportMode mode, nframes64_t& pos, int target_regions, int target_tracks,
+Editor::embed_sndfiles (vector<string> paths, bool multifile,
+			bool& check_sample_rate, ImportDisposition disposition, ImportMode mode, 
+			framepos_t& pos, int target_regions, int target_tracks,
 			boost::shared_ptr<Track>& track)
 {
 	boost::shared_ptr<AudioFileSource> source;
@@ -533,56 +527,17 @@ Editor::embed_sndfiles (vector<Glib::ustring> paths, bool multifile,
 	string linked_path;
 	SoundFileInfo finfo;
 	int ret = 0;
-	Glib::ustring path_to_use;
 
-	track_canvas->get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
+	set_canvas_cursor (_cursors->wait);
 	gdk_flush ();
 
-	for (vector<Glib::ustring>::iterator p = paths.begin(); p != paths.end(); ++p) {
-
-		ustring path = *p;
-
-		if (Config->get_try_link_for_embed()) {
+	for (vector<string>::iterator p = paths.begin(); p != paths.end(); ++p) {
 
-			/* lets see if we can link it into the session */
-			
-			sys::path tmp = _session->session_directory().sound_path() / Glib::path_get_basename(path);
-			linked_path = tmp.to_string();
-			
-			path_to_use = linked_path;
-			
-			if (link (path.c_str(), linked_path.c_str()) == 0) {
-				
-				/* there are many reasons why link(2) might have failed.
-				   but if it succeeds, we now have a link in the
-				   session sound dir that will protect against
-				   unlinking of the original path. nice.
-				*/
-				
-				path = linked_path;
-				path_to_use = Glib::path_get_basename (path);
-				
-			} else {
-
-				/* one possible reason is that its already linked */
-				
-				if (errno == EEXIST) {
-					struct stat sb;
-					
-					if (stat (linked_path.c_str(), &sb) == 0) {
-						if (sb.st_nlink > 1) { // its a hard link, assume its the one we want
-							path = linked_path;
-							path_to_use = Glib::path_get_basename (path);
-						}
-					}
-				}
-			}
-		}
+		string path = *p;
+		string error_msg;
 
 		/* note that we temporarily truncated _id at the colon */
 
-		string error_msg;
-
 		if (!AudioFileSource::get_soundfile_info (path, finfo, error_msg)) {
 			error << string_compose(_("Editor: cannot open file \"%1\", (%2)"), path, error_msg ) << endmsg;
 			goto out;
@@ -646,20 +601,21 @@ Editor::embed_sndfiles (vector<Glib::ustring> paths, bool multifile,
 			}
 		}
 
-		track_canvas->get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH));
+		set_canvas_cursor (_cursors->wait);
 
 		for (int n = 0; n < finfo.channels; ++n) {
+
 			try {
 
 				/* check if we have this thing embedded already */
 
 				boost::shared_ptr<Source> s;
 
-				if ((s = _session->source_by_path_and_channel (path, n)) == 0) {
+				if ((s = _session->audio_source_by_path_and_channel (path, n)) == 0) {
 
 					source = boost::dynamic_pointer_cast<AudioFileSource> (
-						SourceFactory::createReadable (DataType::AUDIO, *_session,
-									       path_to_use, n,
+						SourceFactory::createExternal (DataType::AUDIO, *_session,
+									       path, n, 
 									       (mode == ImportAsTapeTrack
 										? Source::Destructive
 										: Source::Flag (0)),
@@ -676,7 +632,7 @@ Editor::embed_sndfiles (vector<Glib::ustring> paths, bool multifile,
 				goto out;
 			}
 
-			ARDOUR_UI::instance()->flush_pending ();
+			gtk_main_iteration();
 		}
 	}
 
@@ -684,36 +640,30 @@ Editor::embed_sndfiles (vector<Glib::ustring> paths, bool multifile,
 		goto out;
 	}
 
-	ret = add_sources (paths, sources, pos, mode, target_regions, target_tracks, track, true);
+
+	ret = add_sources (paths, sources, pos, disposition, mode, target_regions, target_tracks, track, true);
 
   out:
-	track_canvas->get_window()->set_cursor (*current_canvas_cursor);
+	set_canvas_cursor (current_canvas_cursor);
 	return ret;
 }
 
 int
-Editor::add_sources (vector<Glib::ustring> paths, SourceList& sources, nframes64_t& pos, ImportMode mode,
+Editor::add_sources (vector<string> paths, SourceList& sources, framepos_t& pos, ImportDisposition disposition, ImportMode mode,
 		     int target_regions, int target_tracks, boost::shared_ptr<Track>& track, bool /*add_channel_suffix*/)
 {
 	vector<boost::shared_ptr<Region> > regions;
-	ustring region_name;
+	string region_name;
 	uint32_t input_chan = 0;
 	uint32_t output_chan = 0;
 	bool use_timestamp;
-
+	
 	use_timestamp = (pos == -1);
 
-	if (use_timestamp) {
-		if (sources[0]->natural_position() != 0) {
-			pos = sources[0]->natural_position();
-		} else {
-			pos = get_preferred_edit_position ();
-		}
-	}
-
 	// kludge (for MIDI we're abusing "channel" for "track" here)
-	if (paths.front().rfind(".mid") != Glib::ustring::npos)
+	if (SMFSource::safe_midi_file_extension (paths.front())) {
 		target_regions = -1;
+	}
 
 	if (target_regions == 1) {
 
@@ -721,8 +671,14 @@ Editor::add_sources (vector<Glib::ustring> paths, SourceList& sources, nframes64
 
 		region_name = region_name_from_path (paths.front(), (sources.size() > 1), false);
 
-		PropertyList plist; 
-		
+		/* we checked in import_sndfiles() that there were not too many */
+
+		while (RegionFactory::region_by_name (region_name)) {
+			region_name = bump_name_once (region_name, '.');
+		}
+
+		PropertyList plist;
+
 		plist.add (ARDOUR::Properties::start, 0);
 		plist.add (ARDOUR::Properties::length, sources[0]->length (pos));
 		plist.add (ARDOUR::Properties::name, region_name);
@@ -752,12 +708,61 @@ Editor::add_sources (vector<Glib::ustring> paths, SourceList& sources, nframes64
 			just_one.clear ();
 			just_one.push_back (*x);
 
-			region_name = region_name_from_path ((*x)->path(), false, false, sources.size(), n);
+			boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (*x);
+
+			if (sources.size() > 1 && disposition == ImportDistinctChannels) {
+
+				/* generate a per-channel region name so that things work as
+				 * intended
+				 */
+				
+				string path;
+
+				if (fs) {
+					region_name = basename_nosuffix (fs->path());
+				} else {
+					region_name = (*x)->name();
+				}
+				
+				switch (sources.size()) {
+					/* zero and one channel handled
+					   by previous if() condition
+					*/
+				case 2:
+					if (n == 0) {
+						region_name += "-L";
+					} else {
+						region_name += "-R";
+					}
+					break;
+				default:
+					region_name += (char) '-';
+					region_name += (char) ('1' + n);
+					break;
+				}
+				
+			} else {
+				if (fs) {
+					region_name = region_name_from_path (fs->path(), false, false, sources.size(), n);
+				} else{
+					region_name = (*x)->name();
+				}
+			}
+
+			PropertyList plist;
+
+			/* Fudge region length to ensure it is non-zero; make it 1 beat at 120bpm
+			   for want of a better idea.  It can't be too small, otherwise if this
+			   is a MIDI region the conversion from frames -> beats -> frames will
+			   round it back down to 0 again.
+			*/
+			framecnt_t len = (*x)->length (pos);
+			if (len == 0) {
+				len = (60.0 / 120.0) * _session->frame_rate ();
+			}
 
-			PropertyList plist; 
-			
 			plist.add (ARDOUR::Properties::start, 0);
-			plist.add (ARDOUR::Properties::length, (*x)->length (pos));
+			plist.add (ARDOUR::Properties::length, len);
 			plist.add (ARDOUR::Properties::name, region_name);
 			plist.add (ARDOUR::Properties::layer, 0);
 			plist.add (ARDOUR::Properties::whole_file, true);
@@ -790,18 +795,59 @@ Editor::add_sources (vector<Glib::ustring> paths, SourceList& sources, nframes64
 	}
 
 	int n = 0;
+	framepos_t rlen = 0;
 
+	begin_reversible_command (Operations::insert_file);
+	
 	for (vector<boost::shared_ptr<Region> >::iterator r = regions.begin(); r != regions.end(); ++r, ++n) {
+		boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion> (*r);
+
+		if (use_timestamp) {
+                        if (ar) {
+
+                                /* get timestamp for this region */
+
+                                const boost::shared_ptr<Source> s (ar->sources().front());
+                                const boost::shared_ptr<AudioSource> as = boost::dynamic_pointer_cast<AudioSource> (s);
+
+                                assert (as);
+
+                                if (as->natural_position() != 0) {
+                                        pos = as->natural_position();
+                                } else if (target_tracks == 1) {
+                                        /* hmm, no timestamp available, put it after the previous region
+                                         */
+                                        if (n == 0) {
+                                                pos = get_preferred_edit_position ();
+                                        } else {
+                                                pos += rlen;
+                                        }
+                                } else {
+                                        pos = get_preferred_edit_position ();
+                                }
+                        } else {
+                                /* should really get first position in MIDI file, but for now, use edit position*/
+                                pos = get_preferred_edit_position ();
+                        }
+                }
+
 
 		finish_bringing_in_material (*r, input_chan, output_chan, pos, mode, track);
 
+		rlen = (*r)->length();
+
 		if (target_tracks != 1) {
 			track.reset ();
 		} else {
-			pos += (*r)->length();
+			if (!use_timestamp || !ar) {
+				/* line each one up right after the other */
+				pos += (*r)->length();
+			}
 		}
 	}
 
+	commit_reversible_command ();
+	
 	/* setup peak file building in another thread */
 
 	for (SourceList::iterator x = sources.begin(); x != sources.end(); ++x) {
@@ -812,8 +858,8 @@ Editor::add_sources (vector<Glib::ustring> paths, SourceList& sources, nframes64
 }
 
 int
-Editor::finish_bringing_in_material (boost::shared_ptr<Region> region, uint32_t in_chans, uint32_t out_chans, nframes64_t& pos,
-				  ImportMode mode, boost::shared_ptr<Track>& existing_track)
+Editor::finish_bringing_in_material (boost::shared_ptr<Region> region, uint32_t in_chans, uint32_t out_chans, framepos_t& pos,
+				     ImportMode mode, boost::shared_ptr<Track>& existing_track)
 {
 	boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(region);
 	boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(region);
@@ -838,13 +884,11 @@ Editor::finish_bringing_in_material (boost::shared_ptr<Region> region, uint32_t
 			}
 		}
 
-		boost::shared_ptr<Playlist> playlist = existing_track->diskstream()->playlist();
+		boost::shared_ptr<Playlist> playlist = existing_track->playlist();
 		boost::shared_ptr<Region> copy (RegionFactory::create (region, region->properties()));
-		begin_reversible_command (_("insert file"));
-                playlist->clear_history ();
+		playlist->clear_changes ();
 		playlist->add_region (copy, pos);
 		_session->add_command (new StatefulDiffCommand (playlist));
-		commit_reversible_command ();
 		break;
 	}
 
@@ -860,7 +904,10 @@ Editor::finish_bringing_in_material (boost::shared_ptr<Region> region, uint32_t
 
 				existing_track = at.front();
 			} else if (mr) {
-				list<boost::shared_ptr<MidiTrack> > mt (_session->new_midi_track (Normal, 0, 1));
+				list<boost::shared_ptr<MidiTrack> > mt (_session->new_midi_track (ChanCount (DataType::MIDI, 1),
+												  ChanCount (DataType::MIDI, 1),
+												  boost::shared_ptr<PluginInfo>(), 
+												  Normal, 0, 1));
 
 				if (mt.empty()) {
 					return -1;
@@ -872,22 +919,27 @@ Editor::finish_bringing_in_material (boost::shared_ptr<Region> region, uint32_t
 			existing_track->set_name (region->name());
 		}
 
-		boost::shared_ptr<Region> copy (RegionFactory::create (region));
-		existing_track->diskstream()->playlist()->add_region (copy, pos);
+		boost::shared_ptr<Playlist> playlist = existing_track->playlist();
+		boost::shared_ptr<Region> copy (RegionFactory::create (region, true));
+		playlist->clear_changes ();
+		playlist->add_region (copy, pos);
+		_session->add_command (new StatefulDiffCommand (playlist));
 		break;
 	}
 
-
 	case ImportAsTapeTrack:
 	{
-		if (!ar)
+		if (!ar) {
 			return -1;
+		}
 
 		list<boost::shared_ptr<AudioTrack> > at (_session->new_audio_track (in_chans, out_chans, Destructive));
 		if (!at.empty()) {
-			boost::shared_ptr<Region> copy (RegionFactory::create (region));
-			at.front()->set_name (basename_nosuffix (copy->name()));
-			at.front()->diskstream()->playlist()->add_region (copy, pos);
+			boost::shared_ptr<Playlist> playlist = at.front()->playlist();
+			boost::shared_ptr<Region> copy (RegionFactory::create (region, true));
+			playlist->clear_changes ();
+			playlist->add_region (copy, pos);
+			_session->add_command (new StatefulDiffCommand (playlist));
 		}
 		break;
 	}
@@ -908,48 +960,6 @@ Editor::_import_thread (void *arg)
 void *
 Editor::import_thread ()
 {
-	_session->import_audiofiles (import_status);
-	pthread_exit_pbd (0);
-	/*NOTREACHED*/
+	_session->import_files (import_status);
 	return 0;
 }
-
-gint
-Editor::import_progress_timeout (void */*arg*/)
-{
-	bool reset = false;
-
-	if (!interthread_progress_window->is_visible()) {
-		interthread_progress_window->show_all ();
-		reset = true;
-	}
-
-	interthread_progress_label.set_text (import_status.doing_what);
-
-	if (import_status.freeze) {
-		interthread_cancel_button.set_sensitive(false);
-	} else {
-		interthread_cancel_button.set_sensitive(true);
-	}
-
-	if (import_status.doing_what == "building peak files") {
-		interthread_progress_bar.pulse ();
-		return FALSE;
-	} else {
-		float val = import_status.progress;
-		interthread_progress_bar.set_fraction (min (max (0.0f, val), 1.0f));
-	}
-
-	if (reset) {
-
-		/* the window is now visible, speed up the updates */
-
-		interthread_progress_connection.disconnect ();
-		interthread_progress_connection = Glib::signal_timeout().connect
-			(sigc::bind (sigc::mem_fun(*this, &Editor::import_progress_timeout), (gpointer) 0), 100);
-		return false;
-	} else {
-		return !(import_status.done || import_status.cancel);
-	}
-}
-