X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetExternal.cpp;h=6e0baff5d739556fb9437c5f78968c7606938389;hb=239b9919ffe28338d789e6dc9122228f77ab77a7;hp=a532a267a9f2d4541e7b16cc36fcd7586cb4b642;hpb=f0b51ef8c90bd0f163b142f52a6fae6352226372;p=lyx.git

diff --git a/src/insets/InsetExternal.cpp b/src/insets/InsetExternal.cpp
index a532a267a9..6e0baff5d7 100644
--- a/src/insets/InsetExternal.cpp
+++ b/src/insets/InsetExternal.cpp
@@ -12,12 +12,12 @@
 
 #include "InsetExternal.h"
 #include "insets/ExternalSupport.h"
-#include "insets/ExternalTemplate.h"
 #include "insets/RenderButton.h"
 #include "insets/RenderGraphic.h"
 #include "insets/RenderPreview.h"
 
 #include "Buffer.h"
+#include "BufferView.h"
 #include "Cursor.h"
 #include "DispatchResult.h"
 #include "Exporter.h"
@@ -29,31 +29,35 @@
 #include "LyXRC.h"
 #include "MetricsInfo.h"
 #include "OutputParams.h"
+#include "output_latex.h"
+#include "output_xhtml.h"
+#include "texstream.h"
+#include "TocBackend.h"
 
 #include "frontends/alert.h"
+#include "frontends/Application.h"
 
 #include "graphics/PreviewLoader.h"
 
+#include "support/bind.h"
+#include "support/convert.h"
 #include "support/debug.h"
 #include "support/ExceptionMessage.h"
 #include "support/filetools.h"
 #include "support/gettext.h"
+#include "support/lassert.h"
 #include "support/lstrings.h"
 #include "support/lyxlib.h"
-#include "support/convert.h"
-#include "support/Translator.h"
-
-#include <boost/bind.hpp>
+#include "support/TempFile.h"
 
 #include <sstream>
+#include <vector>
 
 using namespace std;
 using namespace lyx::support;
 
 namespace {
 
-lyx::external::DisplayType const defaultDisplayType = lyx::external::NoDisplay;
-
 unsigned int const defaultLyxScale = 100;
 
 string defaultTemplateName;
@@ -69,17 +73,20 @@ namespace external {
 
 TempName::TempName()
 {
-	FileName const tempname = FileName::tempName("lyxext");
-	// FIXME: This is unsafe
-	tempname.removeFile();
 	// must have an extension for the converter code to work correctly.
-	tempname_ = FileName(tempname.absFilename() + ".tmp");
+	support::TempFile f("lyxextXXXXXX.tmp");
+	// Let f go out of scope here and delete the file ourselves in
+	// ~TempName(), since otherwise external processes would not be able
+	// to use the file on windows (bug 9925). This is not as safe as
+	// keeping a support::TempFile member would be, but the best we can do.
+	f.setAutoRemove(false);
+	tempname_ = f.name();
 }
 
 
-TempName::TempName(TempName const &)
+TempName::TempName(TempName const & that)
 {
-	tempname_ = TempName()();
+	*this = that;
 }
 
 
@@ -91,51 +98,36 @@ TempName::~TempName()
 
 TempName & TempName::operator=(TempName const & other)
 {
-	if (this != &other)
-		tempname_ = TempName()();
+	if (this != &other) {
+		if (!tempname_.empty())
+			tempname_.removeFile();
+		support::TempFile f("lyxextXXXXXX.tmp");
+		f.setAutoRemove(false);
+		tempname_ = f.name(); 
+	}
 	return *this;
 }
 
 
-namespace {
-
-/// The translator between the Display enum and corresponding lyx string.
-Translator<DisplayType, string> const initTranslator()
-{
-	Translator<DisplayType, string> translator(DefaultDisplay, "default");
-
-	// Fill the display translator
-	translator.addPair(MonochromeDisplay, "monochrome");
-	translator.addPair(GrayscaleDisplay, "grayscale");
-	translator.addPair(ColorDisplay, "color");
-	translator.addPair(PreviewDisplay, "preview");
-	translator.addPair(NoDisplay, "none");
-
-	return translator;
-}
-
-} // namespace anon
-
-
-Translator<DisplayType, string> const & displayTranslator()
+support::FileName TempName::operator()() const
 {
-	static Translator<DisplayType, string> const translator =
-		initTranslator();
-	return translator;
+	return tempname_;
 }
 
 } // namespace external
 
 
 InsetExternalParams::InsetExternalParams()
-	: display(defaultDisplayType),
+	: display(true),
+	  preview_mode(PREVIEW_OFF),
 	  lyxscale(defaultLyxScale),
 	  draft(false)
 {
 	if (defaultTemplateName.empty()) {
 		external::TemplateManager const & etm =
 			external::TemplateManager::get();
-		templatename_ = etm.getTemplates().begin()->first;
+		if (!etm.getTemplates().empty())
+			templatename_ = etm.getTemplates().begin()->first;
 	} else
 		templatename_ = defaultTemplateName;
 }
@@ -178,22 +170,22 @@ void InsetExternalParams::settemplate(string const & name)
 	clearIfNotFound(extradata,    external::Extra,  ids);
 	clearIfNotFound(resizedata,   external::Resize, ids);
 	clearIfNotFound(rotationdata, external::Rotate, ids);
+
+	// 
+	preview_mode = et->preview_mode;
 }
 
 
-void InsetExternalParams::write(Buffer const & buffer, ostream & os) const
+void InsetExternalParams::write(Buffer const & buf, ostream & os) const
 {
 	os << "External\n"
 	   << "\ttemplate " << templatename() << '\n';
 
-	if (!filename.empty()) {
-		os << "\tfilename " << filename.outputFilename(buffer.filePath()) << '\n';
-		os << "\tembed " << (filename.embedded() ? filename.inzipName() : "\"\"") << '\n';
-	}
-	if (display != defaultDisplayType)
-		os << "\tdisplay "
-		   << external::displayTranslator().find(display)
-		   << '\n';
+	if (!filename.empty())
+		os << "\tfilename " << filename.outputFileName(buf.filePath()) << '\n';
+
+	if (!display)
+		os << "\tdisplay false\n";
 
 	if (lyxscale != defaultLyxScale)
 		os << "\tlyxscale " << convert<string>(lyxscale) << '\n';
@@ -243,10 +235,9 @@ void InsetExternalParams::write(Buffer const & buffer, ostream & os) const
 
 bool InsetExternalParams::read(Buffer const & buffer, Lexer & lex)
 {
-	enum ExternalTags {
+	enum {
 		EX_TEMPLATE = 1,
 		EX_FILENAME,
-		EX_EMBED,
 		EX_DISPLAY,
 		EX_LYXSCALE,
 		EX_DRAFT,
@@ -262,7 +253,7 @@ bool InsetExternalParams::read(Buffer const & buffer, Lexer & lex)
 		EX_END
 	};
 
-	keyword_item external_tags[] = {
+	LexerKeyword external_tags[] = {
 		{ "\\end_inset",     EX_END },
 		{ "boundingBox",     EX_BOUNDINGBOX },
 		{ "clip",            EX_CLIP },
@@ -270,7 +261,6 @@ bool InsetExternalParams::read(Buffer const & buffer, Lexer & lex)
 		{ "draft",           EX_DRAFT},
 		{ "extra",           EX_EXTRA },
 		{ "filename",        EX_FILENAME},
-		{ "embed",           EX_EMBED},
 		{ "height",          EX_HEIGHT },
 		{ "keepAspectRatio", EX_KEEPASPECTRATIO },
 		{ "lyxscale",        EX_LYXSCALE},
@@ -281,7 +271,7 @@ bool InsetExternalParams::read(Buffer const & buffer, Lexer & lex)
 		{ "width",           EX_WIDTH }
 	};
 
-	PushPopHelper pph(lex, external_tags, EX_END);
+	PushPopHelper pph(lex, external_tags);
 
 	bool found_end  = false;
 	bool read_error = false;
@@ -296,22 +286,13 @@ bool InsetExternalParams::read(Buffer const & buffer, Lexer & lex)
 		case EX_FILENAME: {
 			lex.eatLine();
 			string const name = lex.getString();
-			filename.set(name, buffer.filePath());
+			filename = buffer.getReferencedFileName(name);
 			break;
 		}
 		
-		case EX_EMBED: {
-			lex.next();
-			string const name = lex.getString();
-			filename.setInzipName(name);
-			filename.setEmbed(!name.empty());
-			break;
-		}
-
 		case EX_DISPLAY: {
 			lex.next();
-			string const name = lex.getString();
-			display = external::displayTranslator().find(name);
+			display = lex.getString() != "false";
 			break;
 		}
 
@@ -326,13 +307,13 @@ bool InsetExternalParams::read(Buffer const & buffer, Lexer & lex)
 
 		case EX_BOUNDINGBOX:
 			lex.next();
-			clipdata.bbox.xl = lex.getInteger();
+			clipdata.bbox.xl = Length(lex.getString());
 			lex.next();
-			clipdata.bbox.yb = lex.getInteger();
+			clipdata.bbox.yb = Length(lex.getString());
 			lex.next();
-			clipdata.bbox.xr = lex.getInteger();
+			clipdata.bbox.xr = Length(lex.getString());
 			lex.next();
-			clipdata.bbox.yt = lex.getInteger();
+			clipdata.bbox.yt = Length(lex.getString());
 			break;
 
 		case EX_CLIP:
@@ -398,6 +379,8 @@ bool InsetExternalParams::read(Buffer const & buffer, Lexer & lex)
 
 	if (lyxerr.debugging(Debug::EXTERNAL)) {
 		lyxerr	<< "InsetExternalParams::read:\n";
+		// false positive
+		// coverity[NEGATIVE_RETURNS]
 		write(buffer, lyxerr);
 	}
 
@@ -405,28 +388,64 @@ bool InsetExternalParams::read(Buffer const & buffer, Lexer & lex)
 }
 
 
-InsetExternal::InsetExternal()
-	: renderer_(new RenderButton)
-{}
+namespace {
+
+docstring screenLabel(InsetExternalParams const & params,
+			    Buffer const & buffer)
+{
+	external::Template const * const ptr =
+		external::getTemplatePtr(params);
+	if (!ptr)
+		// FIXME UNICODE
+		return bformat((_("External template %1$s is not installed")),
+					from_utf8(params.templatename()));
+	// FIXME UNICODE
+	docstring gui = _(ptr->guiName);
+	gui += ": ";
+
+	if (params.filename.empty())
+		gui += "???";
+	else
+		gui += from_utf8(params.filename.relFileName(buffer.filePath()));
+
+	return gui;
+}
+
+} // namespace anon
+
+
+
+InsetExternal::InsetExternal(Buffer * buf)
+	: Inset(buf), renderer_(new RenderButton)
+{
+}
 
 
+// Mouse hover is not copied and remains empty
 InsetExternal::InsetExternal(InsetExternal const & other)
 	: Inset(other),
-	  boost::signals::trackable(),
+	  boost::signals2::trackable(),
 	  params_(other.params_),
 	  renderer_(other.renderer_->clone(this))
 {}
 
 
-Inset * InsetExternal::clone() const
+InsetExternal::~InsetExternal()
 {
-	return new InsetExternal(*this);
+	hideDialogs("external", this);
+
+	map<BufferView const *, bool>::iterator it = mouse_hover_.begin();
+	map<BufferView const *, bool>::iterator end = mouse_hover_.end();
+	for (; it != end; ++it)
+		if (it->second)
+			it->first->clearLastInset(this);
 }
 
 
-InsetExternal::~InsetExternal()
+bool InsetExternal::setMouseHover(BufferView const * bv, bool mouse_hover) const
 {
-	InsetExternalMailer(*this).hideDialog();
+	mouse_hover_[bv] = mouse_hover;
+	return true;
 }
 
 
@@ -438,40 +457,27 @@ void InsetExternal::statusChanged() const
 
 void InsetExternal::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
-	switch (cmd.action) {
+	switch (cmd.action()) {
 
-	case LFUN_EXTERNAL_EDIT: {
-		Buffer const & buffer = cur.buffer();
-		InsetExternalParams p;
-		InsetExternalMailer::string2params(to_utf8(cmd.argument()), buffer, p);
-		external::editExternal(p, buffer);
+	case LFUN_INSET_EDIT: {
+		InsetExternalParams p =  params();
+		if (!cmd.argument().empty())
+			string2params(to_utf8(cmd.argument()), buffer(), p);
+		external::editExternal(p, buffer());
 		break;
 	}
 
 	case LFUN_INSET_MODIFY: {
-		Buffer const & buffer = cur.buffer();
 		InsetExternalParams p;
-		InsetExternalMailer::string2params(to_utf8(cmd.argument()), buffer, p);
-		if (!p.filename.empty()) {
-			try {
-				p.filename.enable(buffer.embedded(), &buffer);
-			} catch (ExceptionMessage const & message) {
-				Alert::error(message.title_, message.details_);
-				// do not set parameter if an error happens
-				break;
-			}
-		}
-		setParams(p, buffer);
+		string2params(to_utf8(cmd.argument()), buffer(), p);
+		cur.recordUndo();
+		setParams(p);
 		break;
 	}
 
 	case LFUN_INSET_DIALOG_UPDATE:
-		InsetExternalMailer(*this).updateDialog(&cur.bv());
-		break;
-
-	case LFUN_MOUSE_RELEASE:
-		if (!cur.selection())
-			InsetExternalMailer(*this).showDialog(&cur.bv());
+		cur.bv().updateDialog("external",
+			params2string(params(), cur.bv().buffer()));
 		break;
 
 	default:
@@ -483,12 +489,12 @@ void InsetExternal::doDispatch(Cursor & cur, FuncRequest & cmd)
 bool InsetExternal::getStatus(Cursor & cur, FuncRequest const & cmd,
 		FuncStatus & flag) const
 {
-	switch (cmd.action) {
+	switch (cmd.action()) {
 
-	case LFUN_EXTERNAL_EDIT:
+	case LFUN_INSET_EDIT:
 	case LFUN_INSET_MODIFY:
 	case LFUN_INSET_DIALOG_UPDATE:
-		flag.enabled(true);
+		flag.setEnabled(true);
 		return true;
 
 	default:
@@ -497,27 +503,21 @@ bool InsetExternal::getStatus(Cursor & cur, FuncRequest const & cmd,
 }
 
 
-void InsetExternal::registerEmbeddedFiles(Buffer const & buffer,
-	EmbeddedFileList & files) const
-{
-	files.registerFile(params_.filename, this, buffer);
-}
-
-
-void InsetExternal::updateEmbeddedFile(Buffer const & buf,
-	EmbeddedFile const & file)
+void InsetExternal::addToToc(DocIterator const & cpit, bool output_active,
+							 UpdateType) const
 {
-	// when embedding is enabled, change of embedding status leads to actions
-	EmbeddedFile temp = file;
-	temp.enable(buf.embedded(), &buf);
-	// this will not be set if an exception is thorwn in enable()
-	params_.filename = temp;
+	docstring str = screenLabel(params_, buffer());
+	TocBuilder & b = buffer().tocBackend().builder("external");
+	b.pushItem(cpit, str, output_active);
+	b.pop();
 }
 
 
-void InsetExternal::edit(Cursor & cur, bool, EntryDirection)
+bool InsetExternal::showInsetDialog(BufferView * bv) const
 {
-	InsetExternalMailer(*this).showDialog(&cur.bv());
+	bv->showDialog("external", params2string(params(), bv->buffer()),
+		const_cast<InsetExternal *>(this));
+	return true;
 }
 
 
@@ -529,99 +529,63 @@ void InsetExternal::metrics(MetricsInfo & mi, Dimension & dim) const
 
 void InsetExternal::draw(PainterInfo & pi, int x, int y) const
 {
+	if (renderer_->asButton())
+		renderer_->setRenderState(mouse_hover_[pi.base.bv]);
 	renderer_->draw(pi, x, y);
 }
 
 
 namespace {
 
-enum RenderType {
-	RENDERBUTTON,
-	RENDERGRAPHIC,
-	RENDERPREVIEW
-};
-
-
-RenderType getRenderType(InsetExternalParams const & p)
-{
-	if (!external::getTemplatePtr(p) ||
-	    p.filename.empty() ||
-	    p.display == external::NoDisplay)
-		return RENDERBUTTON;
-
-	if (p.display == external::PreviewDisplay) {
-		if (RenderPreview::status() != LyXRC::PREVIEW_OFF)
-			return RENDERPREVIEW;
-		return RENDERBUTTON;
-	}
-
-	if (p.display == external::DefaultDisplay &&
-	    lyxrc.display_graphics == graphics::NoDisplay)
-		return RENDERBUTTON;
-	return RENDERGRAPHIC;
-}
-
-
 graphics::Params get_grfx_params(InsetExternalParams const & eparams)
 {
 	graphics::Params gparams;
 
-	gparams.filename = eparams.filename.availableFile();
-	gparams.icon = eparams.filename.embedded() ? "pin.png" : "";
+	gparams.filename = eparams.filename;
 	gparams.scale = eparams.lyxscale;
 	if (eparams.clipdata.clip)
 		gparams.bb = eparams.clipdata.bbox;
 	gparams.angle = convert<double>(eparams.rotationdata.adjAngle());
-
-	switch (eparams.display) {
-	case external::DefaultDisplay:
-		gparams.display = graphics::DefaultDisplay;
-		break;
-	case external::MonochromeDisplay:
-		gparams.display = graphics::MonochromeDisplay;
-		break;
-	case external::GrayscaleDisplay:
-		gparams.display = graphics::GrayscaleDisplay;
-		break;
-	case external::ColorDisplay:
-		gparams.display = graphics::ColorDisplay;
-		break;
-	case external::NoDisplay:
-		gparams.display = graphics::NoDisplay;
-		break;
-	default:
-		BOOST_ASSERT(false);
-	}
-	if (gparams.display == graphics::DefaultDisplay)
-		gparams.display = graphics::DisplayType(lyxrc.display_graphics);
-	// Override the above if we're not using a gui
-	if (!use_gui)
-		gparams.display = graphics::NoDisplay;
+	gparams.display = eparams.display;
 
 	return gparams;
 }
 
+} // namespace anon
 
-docstring const getScreenLabel(InsetExternalParams const & params,
-			    Buffer const & buffer)
+
+static bool isPreviewWanted(InsetExternalParams const & params)
 {
-	external::Template const * const ptr =
-		external::getTemplatePtr(params);
-	if (!ptr)
-		// FIXME UNICODE
-		return bformat((_("External template %1$s is not installed")),
-					from_utf8(params.templatename()));
-	// FIXME UNICODE
-	docstring gui = _(ptr->guiName);
-	return from_utf8(external::doSubstitution(params, buffer,
-				to_utf8(gui), false));
+	return params.display && params.filename.isReadableFile();
 }
 
-void add_preview_and_start_loading(RenderMonitoredPreview &,
-				   InsetExternal const &,
-				   Buffer const &);
 
-} // namespace anon
+static docstring latexString(InsetExternal const & inset)
+{
+	odocstringstream ods;
+	otexstream os(ods);
+	// We don't need to set runparams.encoding since it is not used by
+	// latex().
+	OutputParams runparams(0);
+	runparams.flavor = OutputParams::LATEX;
+	inset.latex(os, runparams);
+	return ods.str();
+}
+
+
+static void add_preview_and_start_loading(RenderMonitoredPreview & renderer,
+				   InsetExternal const & inset,
+				   Buffer const & buffer)
+{
+	InsetExternalParams const & params = inset.params();
+
+	if (RenderPreview::previewText() && isPreviewWanted(params)) {
+		renderer.setAbsFile(params.filename);
+		docstring const snippet = latexString(inset);
+		renderer.addPreview(snippet, buffer);
+		renderer.startLoading(buffer);
+	}
+}
 
 
 InsetExternalParams const & InsetExternal::params() const
@@ -630,8 +594,13 @@ InsetExternalParams const & InsetExternal::params() const
 }
 
 
-void InsetExternal::setParams(InsetExternalParams const & p,
-			      Buffer const & buffer)
+void InsetExternal::updatePreview()
+{
+	setParams(params_);
+}
+
+
+void InsetExternal::setParams(InsetExternalParams const & p)
 {
 	params_ = p;
 
@@ -639,44 +608,42 @@ void InsetExternal::setParams(InsetExternalParams const & p,
 	// will use this.
 	defaultTemplateName = params_.templatename();
 
-	switch (getRenderType(params_)) {
-	case RENDERBUTTON: {
+	if (!external::getTemplatePtr(params_) || params_.filename.empty()
+		|| !params_.display
+		|| !lyxrc.display_graphics
+		|| params_.preview_mode == PREVIEW_OFF
+		|| (params_.preview_mode == PREVIEW_INSTANT
+		    && !RenderPreview::previewText())) {
 		RenderButton * button_ptr = renderer_->asButton();
 		if (!button_ptr) {
 			renderer_.reset(new RenderButton);
 			button_ptr = renderer_->asButton();
 		}
-
-		button_ptr->update(getScreenLabel(params_, buffer), true);
-		break;
+		button_ptr->update(screenLabel(params_, buffer()), true);
+		return;
 	}
 
-	case RENDERGRAPHIC: {
+	switch (params_.preview_mode) {
+	case PREVIEW_OFF:
+		// Already taken care of above.
+		LASSERT(false, return);
+		break;
+	case PREVIEW_INSTANT: {
+		renderer_.reset(new RenderMonitoredPreview(this));
+		RenderMonitoredPreview * preview_ptr = renderer_->asMonitoredPreview();
+		preview_ptr->fileChanged(bind(&InsetExternal::fileChanged, this));
+		if (preview_ptr->monitoring())
+			preview_ptr->stopMonitoring();
+		add_preview_and_start_loading(*preview_ptr, *this, buffer());
+		break;
+	} 
+	case PREVIEW_GRAPHICS: {
 		RenderGraphic * graphic_ptr = renderer_->asGraphic();
 		if (!graphic_ptr) {
 			renderer_.reset(new RenderGraphic(this));
 			graphic_ptr = renderer_->asGraphic();
 		}
-
 		graphic_ptr->update(get_grfx_params(params_));
-
-		break;
-	}
-
-	case RENDERPREVIEW: {
-		RenderMonitoredPreview * preview_ptr =
-			renderer_->asMonitoredPreview();
-		if (!preview_ptr) {
-			renderer_.reset(new RenderMonitoredPreview(this));
-			preview_ptr = renderer_->asMonitoredPreview();
-			preview_ptr->fileChanged(
-				boost::bind(&InsetExternal::fileChanged, this));
-		}
-
-		if (preview_ptr->monitoring())
-			preview_ptr->stopMonitoring();
-		add_preview_and_start_loading(*preview_ptr, *this, buffer);
-
 		break;
 	}
 	}
@@ -690,39 +657,35 @@ void InsetExternal::fileChanged() const
 		return;
 
 	RenderMonitoredPreview * const ptr = renderer_->asMonitoredPreview();
-	BOOST_ASSERT(ptr);
+	LASSERT(ptr, return);
 
 	ptr->removePreview(*buffer);
 	add_preview_and_start_loading(*ptr, *this, *buffer);
 }
 
 
-void InsetExternal::write(Buffer const & buffer, ostream & os) const
+void InsetExternal::write(ostream & os) const
 {
-	params_.write(buffer, os);
+	params_.write(buffer(), os);
 }
 
 
-void InsetExternal::read(Buffer const & buffer, Lexer & lex)
+void InsetExternal::read(Lexer & lex)
 {
 	InsetExternalParams params;
-	if (params.read(buffer, lex)) {
-		// exception handling is not needed as long as embedded files are in place.
-		params.filename.enable(buffer.embedded(), & buffer);
-		setParams(params, buffer);
-	}
+	if (params.read(buffer(), lex))
+		setParams(params);
 }
 
 
-int InsetExternal::latex(Buffer const & buf, odocstream & os,
-			 OutputParams const & runparams) const
+void InsetExternal::latex(otexstream & os, OutputParams const & runparams) const
 {
 	if (params_.draft) {
 		// FIXME UNICODE
 		os << "\\fbox{\\ttfamily{}"
-		   << from_utf8(params_.filename.outputFilename(buf.filePath()))
+		   << from_utf8(params_.filename.outputFileName(buffer().filePath()))
 		   << "}\n";
-		return 1;
+		return;
 	}
 
 	// "nice" means that the buffer is exported to LaTeX format but not
@@ -738,45 +701,71 @@ int InsetExternal::latex(Buffer const & buf, odocstream & os,
 		external::Template const * const et_ptr =
 			external::getTemplatePtr(params_);
 		if (!et_ptr)
-			return 0;
+			return;
 		external::Template const & et = *et_ptr;
 
 		external::Template::Formats::const_iterator cit =
 			et.formats.find("PDFLaTeX");
 
 		if (cit != et.formats.end()) {
-			return external::writeExternal(params_, "PDFLaTeX",
-						       buf, os,
-						       *(runparams.exportdata),
-						       external_in_tmpdir,
-						       dryrun);
+			external::writeExternal(params_, "PDFLaTeX",
+						buffer(), os,
+						*(runparams.exportdata),
+						external_in_tmpdir,
+						dryrun);
+			return;
 		}
 	}
 
-	return external::writeExternal(params_, "LaTeX", buf, os,
-				       *(runparams.exportdata),
-				       external_in_tmpdir,
-				       dryrun);
+	external::writeExternal(params_, "LaTeX", buffer(), os,
+				*(runparams.exportdata),
+				external_in_tmpdir,
+				dryrun);
 }
 
 
-int InsetExternal::plaintext(Buffer const & buf, odocstream & os,
-			     OutputParams const & runparams) const
+int InsetExternal::plaintext(odocstringstream & os,
+			     OutputParams const & runparams, size_t) const
 {
-	os << '\n'; // output external material on a new line
-	external::writeExternal(params_, "Ascii", buf, os,
-				*(runparams.exportdata), false,
-				runparams.dryrun || runparams.inComment);
+	// this is too slow for constant use
+	if (runparams.for_tooltip)
+		return 0;
+
+	bool const external_in_tmpdir = !runparams.nice;
+	bool const dryrun = runparams.dryrun || runparams.inComment;
+	otexstream ots(os);
+	ots << '\n'; // output external material on a new line
+	external::writeExternal(params_, "Ascii", buffer(), ots,
+				*(runparams.exportdata), external_in_tmpdir, dryrun);
 	return PLAINTEXT_NEWLINE;
 }
 
 
-int InsetExternal::docbook(Buffer const & buf, odocstream & os,
+int InsetExternal::docbook(odocstream & os,
 			   OutputParams const & runparams) const
 {
-	return external::writeExternal(params_, "DocBook", buf, os,
-				       *(runparams.exportdata), false,
-				       runparams.dryrun || runparams.inComment);
+	bool const external_in_tmpdir = !runparams.nice;
+	bool const dryrun = runparams.dryrun || runparams.inComment;
+	odocstringstream ods;
+	otexstream ots(ods);
+	external::writeExternal(params_, "DocBook", buffer(), ots,
+				*(runparams.exportdata), external_in_tmpdir, dryrun);
+	os << ods.str();
+	return int(count(ods.str().begin(), ods.str().end(), '\n'));
+}
+
+
+docstring InsetExternal::xhtml(XHTMLStream & xs,
+			OutputParams const & runparams) const
+{
+	bool const external_in_tmpdir = !runparams.nice;
+	bool const dryrun = runparams.dryrun || runparams.inComment;
+	odocstringstream ods;
+	otexstream ots(ods);
+	external::writeExternal(params_, "XHTML", buffer(), ots,
+				       *(runparams.exportdata), external_in_tmpdir, dryrun);
+	xs << XHTMLStream::ESCAPE_NONE << ods.str();
+	return docstring();
 }
 
 
@@ -794,21 +783,42 @@ void InsetExternal::validate(LaTeXFeatures & features) const
 	string format;
 	switch (features.runparams().flavor) {
 	case OutputParams::LATEX:
+	case OutputParams::DVILUATEX:
 		format = "LaTeX";
 		break;
+	case OutputParams::LUATEX:
 	case OutputParams::PDFLATEX:
+	case OutputParams::XETEX:
 		format = "PDFLaTeX";
 		break;
 	case OutputParams::XML:
 		format = "DocBook";
 		break;
+	case OutputParams::HTML:
+		format = "html";
+		break;
+	case OutputParams::TEXT:
+		format = "text";
+		break;
+	case OutputParams::LYX:
+		format = "lyx";
+		break;
 	}
 	external::Template::Formats::const_iterator cit =
 		et.formats.find(format);
-	if (cit == et.formats.end())
-		return;
 
-	// FIXME: We don't need that always
+	if (cit == et.formats.end()) {
+		// If the template has not specified a PDFLaTeX output,
+		// we try the LaTeX format.
+		if (format == "PDFLaTeX") {
+			cit = et.formats.find("LaTeX");
+			if (cit == et.formats.end())
+				return;
+		} else
+			return;
+	}
+
+	// FIXME: We don't need that always, see InsetGraphics
 	features.require("lyxdot");
 
 	vector<string>::const_iterator it  = cit->second.requirements.begin();
@@ -818,122 +828,73 @@ void InsetExternal::validate(LaTeXFeatures & features) const
 
 	external::TemplateManager & etm = external::TemplateManager::get();
 
-	it  = cit->second.preambleNames.begin();
-	end = cit->second.preambleNames.end();
-	for (; it != end; ++it) {
-		string const preamble = etm.getPreambleDefByName(*it);
+	for (string const & name : cit->second.preambleNames) {
+		docstring const preamble = etm.getPreambleDefByName(name);
 		if (!preamble.empty())
 			features.addPreambleSnippet(preamble);
 	}
 }
 
 
-//
-// preview stuff
-//
-
-namespace {
-
-bool preview_wanted(InsetExternalParams const & params)
-{
-	return params.display == external::PreviewDisplay &&
-		params.filename.isReadableFile();
-}
-
-
-docstring const latex_string(InsetExternal const & inset, Buffer const & buffer)
-{
-	odocstringstream os;
-	// We don't need to set runparams.encoding since it is not used by
-	// latex().
-	OutputParams runparams(0);
-	runparams.flavor = OutputParams::LATEX;
-	inset.latex(buffer, os, runparams);
-	return os.str();
-}
-
-
-void add_preview_and_start_loading(RenderMonitoredPreview & renderer,
-				   InsetExternal const & inset,
-				   Buffer const & buffer)
-{
-	InsetExternalParams const & params = inset.params();
-
-	if (RenderPreview::status() != LyXRC::PREVIEW_OFF &&
-	    preview_wanted(params)) {
-		renderer.setAbsFile(params.filename);
-		docstring const snippet = latex_string(inset, buffer);
-		renderer.addPreview(snippet, buffer);
-		renderer.startLoading(buffer);
-	}
-}
-
-} // namespace anon
-
-
-void InsetExternal::addPreview(graphics::PreviewLoader & ploader) const
+void InsetExternal::addPreview(DocIterator const & /*inset_pos*/,
+	graphics::PreviewLoader & ploader) const	
 {
 	RenderMonitoredPreview * const ptr = renderer_->asMonitoredPreview();
 	if (!ptr)
 		return;
 
-	if (preview_wanted(params())) {
+	if (isPreviewWanted(params())) {
 		ptr->setAbsFile(params_.filename);
-		docstring const snippet = latex_string(*this, ploader.buffer());
+		docstring const snippet = latexString(*this);
 		ptr->addPreview(snippet, ploader);
 	}
 }
 
 
-/// Mailer stuff
-
-string const InsetExternalMailer::name_("external");
-
-InsetExternalMailer::InsetExternalMailer(InsetExternal & inset)
-	: inset_(inset)
-{}
-
-
-string const InsetExternalMailer::inset2string(Buffer const & buffer) const
+string InsetExternal::contextMenuName() const
 {
-	return params2string(inset_.params(), buffer);
+	return "context-external";
 }
 
 
-void InsetExternalMailer::string2params(string const & in,
-					Buffer const & buffer,
-					InsetExternalParams & params)
+void InsetExternal::string2params(string const & in, Buffer const & buffer,
+	InsetExternalParams & params)
 {
 	params = InsetExternalParams();
 	if (in.empty())
 		return;
 
 	istringstream data(in);
-	Lexer lex(0,0);
+	Lexer lex;
 	lex.setStream(data);
 
 	string name;
 	lex >> name;
-	if (!lex || name != name_)
-		return print_mailer_error("InsetExternalMailer", in, 1, name_);
+	if (!lex || name != "external") {
+		LYXERR0("InsetExternal::string2params(" << in << ")\n"
+					  "Expected arg 1 to be \"external\"\n");
+		return;
+	}
 
 	// This is part of the inset proper that is usually swallowed
 	// by Text::readInset
 	string id;
 	lex >> id;
-	if (!lex || id != "External")
-		return print_mailer_error("InsetBoxMailer", in, 2, "External");
+	if (!lex || id != "External") {
+		LYXERR0("InsetExternal::string2params(" << in << ")\n"
+					  "Expected arg 2 to be \"External\"\n");
+		return;
+	}
 
 	params.read(buffer, lex);
 }
 
 
-string const
-InsetExternalMailer::params2string(InsetExternalParams const & params,
-				   Buffer const & buffer)
+string InsetExternal::params2string(InsetExternalParams const & params,
+	Buffer const & buffer)
 {
 	ostringstream data;
-	data << name_ << ' ';
+	data << "external" << ' ';
 	params.write(buffer, data);
 	data << "\\end_inset\n";
 	return data.str();