]> git.lyx.org Git - lyx.git/blobdiff - src/graphics/GraphicsConverter.C
Fix InsetInclude properly. Data is now stored in an InsetCommandParams
[lyx.git] / src / graphics / GraphicsConverter.C
index 583f1bbc684cb03baa9bff7eeb945fa3daab9093..b75095ecd0fca4d1514d0be53f2f3638d6183334 100644 (file)
-/*
+/**
  * \file GraphicsConverter.C
- * Copyright 2002 the LyX Team
- * Read the file COPYING
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
- * \author Angus Leeming <a.leeming@ic.ac.uk>
+ * \author Angus Leeming
+ *
+ * Full author contact details are available in file CREDITS.
  */
 
 #include <config.h>
 
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
 #include "GraphicsConverter.h"
 
 #include "converter.h"
 #include "debug.h"
-#include "gettext.h"
+#include "format.h"
 
 #include "support/filetools.h"
-#include "support/forkedcall.h"
-#include "support/path.h"
+#include "support/forkedcallqueue.h"
+#include "support/tostr.h"
+#include "support/lstrings.h"
+#include "support/lyxlib.h"
 
 #include <boost/bind.hpp>
 
+#include "support/std_sstream.h"
 #include <fstream>
 
-namespace {
+namespace support = lyx::support;
+
+using support::ChangeExtension;
+using support::Forkedcall;
+using support::ForkedCallQueue;
+using support::LibFileSearch;
+using support::LibScriptSearch;
+using support::OnlyPath;
+using support::OnlyFilename;
+using support::QuoteName;
+using support::subst;
+using support::tempName;
+using support::unlink;
+
+using std::endl;
+using std::ostream;
+using std::ostringstream;
+
+
+namespace lyx {
+namespace graphics {
+
+struct Converter::Impl : public boost::signals::trackable {
+       ///
+       Impl(string const &, string const &, string const &, string const &);
+
+       ///
+       void startConversion();
+
+       /** This method is connected to a signal passed to the forked call
+        *  class, passing control back here when the conversion is completed.
+        *  Cleans-up the temporary files, emits the finishedConversion
+        *  signal and removes the Converter from the list of all processes.
+        */
+       void converted(pid_t pid, int retval);
+
+       /** At the end of the conversion process inform the outside world
+        *  by emitting a signal.
+        */
+       typedef boost::signal1<void, bool> SignalType;
+       ///
+       SignalType finishedConversion;
+
+       ///
+       string script_command_;
+       ///
+       string script_file_;
+       ///
+       string to_file_;
+       ///
+       bool valid_process_;
+       ///
+       bool finished_;
+};
 
-string const move_file(string const & from_file, string const & to_file)
+
+bool Converter::isReachable(string const & from_format_name,
+                           string const & to_format_name)
 {
-       if (from_file == to_file)
-               return string();
+       return converters.isReachable(from_format_name, to_format_name);
+}
 
-       ostringstream command;
-       command << "fromfile=" << from_file << "\n"
-               << "tofile="   << to_file << "\n\n"
-               << "'mv' -f ${fromfile} ${tofile}\n"
-               << "if [ $? -ne 0 ]; then\n"
-               << "\t'cp' -f ${fromfile} ${tofile}\n"
-               << "\tif [ $? -ne 0 ]; then\n"
-               << "\t\texit 1\n"
-               << "\tfi\n"
-               << "\t'rm' -f ${fromfile}\n"
-               << "fi\n";
 
-       return command.str().c_str();
-}
+Converter::Converter(string const & from_file,   string const & to_file_base,
+                    string const & from_format, string const & to_format)
+       : pimpl_(new Impl(from_file, to_file_base, from_format, to_format))
+{}
 
-} // namespace anon
 
+// Empty d-tor out-of-line to keep boost::scoped_ptr happy.
+Converter::~Converter()
+{}
 
-namespace grfx {
 
-GConverter & GConverter::get()
+void Converter::startConversion() const
 {
-       static GConverter singleton;
-       return singleton;
+       pimpl_->startConversion();
 }
 
 
-bool GConverter::isReachable(string const & from_format_name,
-                            string const & to_format_name) const
+boost::signals::connection Converter::connect(slot_type const & slot) const
 {
-       return converters.isReachable(from_format_name, to_format_name);
+       return pimpl_->finishedConversion.connect(slot);
+}
+
+
+string const & Converter::convertedFile() const
+{
+       static string const empty;
+       return pimpl_->finished_ ? pimpl_->to_file_ : empty;
 }
 
+} // namespace graphics
+} // namespace lyx
 
-void GConverter::convert(string const & from_file, string const & to_file_base,
-                        string const & from_format, string const & to_format,
-                        SignalTypePtr on_finish)
+
+//------------------------------
+// Implementation details follow
+//------------------------------
+
+namespace {
+
+/** Build the conversion script, returning true if able to build it.
+ *  The script is output to the ostringstream 'script'.
+ */
+bool build_script(string const & from_file, string const & to_file_base,
+                 string const & from_format, string const & to_format,
+                 ostream & script);
+
+} // namespace anon
+
+
+namespace lyx {
+namespace graphics {
+
+Converter::Impl::Impl(string const & from_file,   string const & to_file_base,
+                     string const & from_format, string const & to_format)
+       : valid_process_(false), finished_(false)
 {
+       lyxerr[Debug::GRAPHICS] << "Converter c-tor:\n"
+               << "\tfrom_file:      " << from_file
+               << "\n\tto_file_base: " << to_file_base
+               << "\n\tfrom_format:  " << from_format
+               << "\n\tto_format:    " << to_format << endl;
+
+       // The converted image is to be stored in this file (we do not
+       // use ChangeExtension because this is a basename which may
+       // nevertheless contain a '.')
+       to_file_ = to_file_base + '.' +  formats.extension(to_format);
+
        // The conversion commands are stored in a stringstream
        ostringstream script;
        script << "#!/bin/sh\n";
-
        bool const success = build_script(from_file, to_file_base,
                                          from_format, to_format, script);
 
        if (!success) {
+               script_command_ =
+                       "sh " + LibFileSearch("scripts", "convertDefault.sh") +
+                       ' ' + from_format + ':' + from_file + ' ' +
+                       to_format + ':' + to_file_;
+
                lyxerr[Debug::GRAPHICS]
-                       << "Unable to build the conversion script" << std::endl;
-               on_finish->operator()(string());
-               return;
+                       << "\tNo converter defined! I use convertDefault.sh\n\t"
+                       << script_command_ << endl;
+
+       } else {
+
+               lyxerr[Debug::GRAPHICS] << "\tConversion script:"
+                       << "\n--------------------------------------\n"
+                       << script.str()
+                       << "\n--------------------------------------\n";
+
+               // Output the script to file.
+               static int counter = 0;
+               script_file_ = OnlyPath(to_file_base) + "lyxconvert" +
+                       tostr(counter++) + ".sh";
+
+               std::ofstream fs(script_file_.c_str());
+               if (!fs.good())
+                       return;
+
+               fs << script.str();
+               fs.close();
+
+               // The command needed to run the conversion process
+               // We create a dummy command for ease of understanding of the
+               // list of forked processes.
+               // Note: 'sh ' is absolutely essential, or execvp will fail.
+               script_command_ = "sh " + script_file_ + ' ' +
+                       OnlyFilename(from_file) + ' ' + to_format;
        }
+       // All is ready to go
+       valid_process_ = true;
+}
 
-       lyxerr[Debug::GRAPHICS] << "Conversion script:\n\n"
-                               << script.str().c_str() << "\n" << std::endl;
 
-       // Output the script to file.
-       static int counter = 0;
-       string const script_file = OnlyPath(to_file_base) + "lyxconvert" +
-               tostr(counter++) + ".sh";
-
-       std::ofstream fs(script_file.c_str());
-       if (!fs.good()) {
-               // Unable to output the conversion script to file.
-               on_finish->operator()(string());
+void Converter::Impl::startConversion()
+{
+       if (!valid_process_) {
+               converted(0, 1);
                return;
        }
 
-       fs << script.str().c_str();
-       fs.close();
-
-       // Create a dummy command for ease of understanding of the
-       // list of forked processes.
-       // Note that 'sh ' is absolutely essential, or execvp will fail.
-       string const script_command =
-               "sh " + script_file + " " +
-               OnlyFilename(from_file) + " " + to_format;
+       Forkedcall::SignalTypePtr
+               ptr = ForkedCallQueue::get().add(script_command_);
 
-       string const to_file =
-               ChangeExtension(to_file_base, formats.extension(to_format));
+       ptr->connect(boost::bind(&Impl::converted, this, _1, _2));
 
-       // Launch the conversion process.
-       ConvProcessPtr shared_ptr;
-       shared_ptr.reset(new ConvProcess(script_file, script_command,
-                                        to_file, on_finish));
-       all_processes_.push_back(shared_ptr);
 }
 
+void Converter::Impl::converted(pid_t /* pid */, int retval)
+{
+       if (finished_)
+               // We're done already!
+               return;
 
-namespace {
-
-typedef boost::shared_ptr<ConvProcess> ConvProcessPtr;
-
-class Find_Ptr {
-public:
-       Find_Ptr(ConvProcess * ptr) : ptr_(ptr) {}
+       finished_ = true;
+       // Clean-up behind ourselves
+       unlink(script_file_);
 
-       bool operator()(ConvProcessPtr const & ptr)
-       {
-               return ptr.get() == ptr_;
+       if (retval > 0) {
+               unlink(to_file_);
+               to_file_.erase();
+               finishedConversion(false);
+       } else {
+               finishedConversion(true);
        }
+}
 
-private:
-       ConvProcess * ptr_;
-};
-
-} // namespace anon
+} // namespace graphics
+} // namespace lyx
 
+namespace {
 
-void GConverter::erase(ConvProcess * process)
+string const move_file(string const & from_file, string const & to_file)
 {
-       std::list<ConvProcessPtr>::iterator begin = all_processes_.begin();
-       std::list<ConvProcessPtr>::iterator end   = all_processes_.end();
-       std::list<ConvProcessPtr>::iterator it =
-               std::find_if(begin, end, Find_Ptr(process));
+       if (from_file == to_file)
+               return string();
 
-       if (it == end)
-               return;
+       ostringstream command;
+       command << "fromfile=" << from_file << "\n"
+               << "tofile="   << to_file << "\n\n"
+               << "'mv' -f ${fromfile} ${tofile} ||\n"
+               << "{\n"
+               << "\t'cp' -f ${fromfile} ${tofile} ||\n"
+               << "\t{\n"
+               << "\t\texit 1\n"
+               << "\t}\n"
+               << "\t'rm' -f ${fromfile}\n"
+               << "}\n";
 
-       all_processes_.erase(it);
+       return command.str();
 }
 
 
-bool GConverter::build_script(string const & from_file,
-                             string const & to_file_base,
-                             string const & from_format,
-                             string const & to_format,
-                             ostringstream & script) const
+bool build_script(string const & from_file,
+                 string const & to_file_base,
+                 string const & from_format,
+                 string const & to_format,
+                 ostream & script)
 {
+       lyxerr[Debug::GRAPHICS] << "build_script ... ";
        typedef Converters::EdgePath EdgePath;
 
-       string const to_file = ChangeExtension(to_file_base,
-                                              formats.extension(to_format));
+       // we do not use ChangeExtension because this is a basename
+       // which may nevertheless contain a '.'
+       string const to_file = to_file_base + '.'
+               + formats.extension(to_format);
 
        if (from_format == to_format) {
                script << move_file(QuoteName(from_file), QuoteName(to_file));
+               lyxerr[Debug::GRAPHICS] << "ready (from == to)" << endl;
                return true;
        }
 
        EdgePath edgepath = converters.getPath(from_format, to_format);
 
        if (edgepath.empty()) {
+               lyxerr[Debug::GRAPHICS] << "ready (edgepath.empty())" << endl;
                return false;
        }
 
@@ -181,8 +294,8 @@ bool GConverter::build_script(string const & from_file,
        // Remember to remove the temp file because we only want the name...
        static int counter = 0;
        string const tmp = "gconvert" + tostr(counter++);
-       string const to_base = lyx::tempName(string(), tmp);
-       lyx::unlink(to_base);
+       string const to_base = tempName(string(), tmp);
+       unlink(to_base);
 
        string outfile = from_file;
 
@@ -194,8 +307,9 @@ bool GConverter::build_script(string const & from_file,
 
        EdgePath::const_iterator it  = edgepath.begin();
        EdgePath::const_iterator end = edgepath.end();
+
        for (; it != end; ++it) {
-               Converter const & conv = converters.get(*it);
+               ::Converter const & conv = converters.get(*it);
 
                // Build the conversion command
                string const infile      = outfile;
@@ -211,16 +325,17 @@ bool GConverter::build_script(string const & from_file,
                command = subst(command, token_from, "${infile}");
                command = subst(command, token_base, "${infile_base}");
                command = subst(command, token_to,   "${outfile}");
+               command = LibScriptSearch(command);
 
                // Store in the shell script
-               script << "\n" << command << "\n\n";
+               script << "\n" << command << " ||\n";
 
                // Test that this was successful. If not, remove
                // ${outfile} and exit the shell script
-               script << "if [ $? -ne 0 ]; then\n"
+               script << "{\n"
                       << "\t'rm' -f ${outfile}\n"
                       << "\texit 1\n"
-                      << "fi\n\n";
+                      << "}\n\n";
 
                // Test that the outfile exists.
                // ImageMagick's convert will often create ${outfile}.0,
@@ -244,47 +359,9 @@ bool GConverter::build_script(string const & from_file,
 
        // Move the final outfile to to_file
        script << move_file("${outfile}", QuoteName(to_file));
+       lyxerr[Debug::GRAPHICS] << "ready!" << endl;
 
        return true;
 }
 
-
-ConvProcess::ConvProcess(string const & script_file,
-                        string const & script_command,
-                        string const & to_file, SignalTypePtr on_finish)
-       : script_file_(script_file), to_file_(to_file), on_finish_(on_finish)
-{
-       Forkedcall::SignalTypePtr convert_ptr;
-       convert_ptr.reset(new Forkedcall::SignalType);
-
-       convert_ptr->connect(boost::bind(&ConvProcess::converted, this, _1, _2, _3));
-
-       Forkedcall call;
-       int retval = call.startscript(script_command, convert_ptr);
-       if (retval > 0) {
-               // Unable to even start the script, so clean-up the mess!
-               converted(string(), 0, 1);
-       }
-}
-
-
-void ConvProcess::converted(string const &/* cmd */,
-                           pid_t /* pid */, int retval)
-{
-       // Clean-up behind ourselves
-       lyx::unlink(script_file_);
-
-       if (retval > 0) {
-               lyx::unlink(to_file_);
-               to_file_.erase();
-       }
-
-       if (on_finish_.get()) {
-               on_finish_->operator()(to_file_);
-       }
-
-       grfx::GConverter::get().erase(this);
-}
-
-
-} // namespace grfx
+} // namespace anon