X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fjob.cc;h=78a7a75776c8f9463c48b73cfd5b7eceb1be1804;hb=085d9d4966c32aa1f3661c597b4bc2b47eaefa40;hp=22754eb909659ffd8693b48c77a9c184b6c40f9b;hpb=c0ed407fb02891f0dd364e78b6192f0e6dbe1d8d;p=dcpomatic.git

diff --git a/src/lib/job.cc b/src/lib/job.cc
index 22754eb90..78a7a7577 100644
--- a/src/lib/job.cc
+++ b/src/lib/job.cc
@@ -27,23 +27,22 @@
 #include "job.h"
 #include "util.h"
 
-using namespace std;
-using namespace boost;
+#include "i18n.h"
 
-/** @param s FilmState for the film that we are operating on.
- *  @param o Options.
- *  @param l A log that we can write to.
+using std::string;
+using std::list;
+using std::stringstream;
+using boost::shared_ptr;
+
+/** @param s Film that we are operating on.
  */
-Job::Job (shared_ptr<const FilmState> s, shared_ptr<const Options> o, Log* l)
-	: _fs (s)
-	, _opt (o)
-	, _log (l)
+Job::Job (shared_ptr<Film> f)
+	: _film (f)
 	, _state (NEW)
 	, _start_time (0)
 	, _progress_unknown (false)
+	, _ran_for (0)
 {
-	assert (_log);
-	
 	descend (1);
 }
 
@@ -68,19 +67,50 @@ Job::run_wrapper ()
 		
 		set_progress (1);
 		set_state (FINISHED_ERROR);
-		stringstream s;
-		s << e.what() << "(" << filesystem::path (e.filename()).leaf() << ")";
-		set_error (s.str ());
 		
+		string m = String::compose (_("An error occurred whilst handling the file %1."), boost::filesystem::path (e.filename()).leaf());
+
+		try {
+			boost::filesystem::space_info const s = boost::filesystem::space (e.filename());
+			if (s.available < pow (1024, 3)) {
+				m += N_("\n\n");
+				m += _("The drive that the film is stored on is low in disc space.  Free some more space and try again.");
+			}
+		} catch (...) {
+
+		}
+
+		set_error (e.what(), m);
+ 		
 	} catch (std::exception& e) {
 
 		set_progress (1);
 		set_state (FINISHED_ERROR);
-		set_error (e.what ());
+		set_error (
+			e.what (),
+			_("It is not known what caused this error.  The best idea is to report the problem to the DVD-o-matic mailing list (dvdomatic@carlh.net)")
+			);
+
+	} catch (...) {
+
+		set_progress (1);
+		set_state (FINISHED_ERROR);
+		set_error (
+			_("Unknown error"),
+			_("It is not known what caused this error.  The best idea is to report the problem to the DVD-o-matic mailing list (dvdomatic@carlh.net)")
+			);
 
 	}
 }
 
+/** @return true if this job is new (ie has not started running) */
+bool
+Job::is_new () const
+{
+	boost::mutex::scoped_lock lm (_state_mutex);
+	return _state == NEW;
+}
+
 /** @return true if the job is running */
 bool
 Job::running () const
@@ -121,17 +151,10 @@ Job::set_state (State s)
 {
 	boost::mutex::scoped_lock lm (_state_mutex);
 	_state = s;
-}
 
-/** A hack to work around our lack of cross-thread
- *  signalling; this emits Finished, and listeners
- *  assume that it will be emitted in the GUI thread,
- *  so this method must be called from the GUI thread.
- */
-void
-Job::emit_finished ()
-{
-	Finished ();
+	if (_state == FINISHED_OK || _state == FINISHED_ERROR) {
+		_ran_for = elapsed_time ();
+	}
 }
 
 /** @return Time (in seconds) that this job has been running */
@@ -152,6 +175,7 @@ void
 Job::set_progress (float p)
 {
 	boost::mutex::scoped_lock lm (_progress_mutex);
+	_progress_unknown = false;
 	_stack.back().normalised = p;
 }
 
@@ -205,25 +229,33 @@ Job::descend (float a)
 	_stack.push_back (Level (a));
 }
 
-/** @return Any error string that the job has generated */
 string
-Job::error () const
+Job::error_details () const
+{
+	boost::mutex::scoped_lock lm (_state_mutex);
+	return _error_details;
+}
+
+/** @return A summary of any error that the job has generated */
+string
+Job::error_summary () const
 {
 	boost::mutex::scoped_lock lm (_state_mutex);
-	return _error;
+	return _error_summary;
 }
 
 /** Set the current error string.
  *  @param e New error string.
  */
 void
-Job::set_error (string e)
+Job::set_error (string s, string d)
 {
 	boost::mutex::scoped_lock lm (_state_mutex);
-	_error = e;
+	_error_summary = s;
+	_error_details = d;
 }
 
-/** Say that this job's progress will always be unknown */
+/** Say that this job's progress will be unknown until further notice */
 void
 Job::set_progress_unknown ()
 {
@@ -238,16 +270,25 @@ Job::status () const
 	float const p = overall_progress ();
 	int const t = elapsed_time ();
 	int const r = remaining_time ();
-	
+
+	int pc = rint (p * 100);
+	if (pc == 100) {
+		/* 100% makes it sound like we've finished when we haven't */
+		pc = 99;
+	}
+
 	stringstream s;
-	if (!finished () && p >= 0 && t > 10 && r > 0) {
-		s << rint (p * 100) << "%; " << seconds_to_approximate_hms (r) << " remaining";
-	} else if (!finished () && (t <= 10 || r == 0)) {
-		s << rint (p * 100) << "%";
+	if (!finished ()) {
+		s << pc << N_("%");
+		if (p >= 0 && t > 10 && r > 0) {
+			/// TRANSLATORS: remaining here follows an amount of time that is remaining
+			/// on an operation.
+			s << "; " << seconds_to_approximate_hms (r) << " " << _("remaining");
+		}
 	} else if (finished_ok ()) {
-		s << "OK (ran for " << seconds_to_hms (t) << ")";
+		s << String::compose (_("OK (ran for %1)"), seconds_to_hms (_ran_for));
 	} else if (finished_in_error ()) {
-		s << "Error (" << error() << ")";
+		s << String::compose (_("Error (%1)"), error_summary());
 	}
 
 	return s.str ();