X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetexternal.C;h=910d3d071a55a3d2230672a217d987144652de64;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=3bc055888357e1a3b16bef2996a3f23b62bbc73c;hpb=44cd0fc9a1687cc63911c7f98d978594458e7813;p=lyx.git diff --git a/src/insets/insetexternal.C b/src/insets/insetexternal.C index 3bc0558883..910d3d071a 100644 --- a/src/insets/insetexternal.C +++ b/src/insets/insetexternal.C @@ -11,37 +11,38 @@ #include #include "insetexternal.h" -#include "insets/renderers.h" +#include "insets/ExternalSupport.h" +#include "insets/ExternalTemplate.h" +#include "insets/render_button.h" +#include "insets/render_graphic.h" +#include "insets/render_preview.h" #include "buffer.h" -#include "BufferView.h" -#include "converter.h" +#include "cursor.h" #include "debug.h" -#include "ExternalTemplate.h" +#include "dispatchresult.h" +#include "exporter.h" +#include "FuncStatus.h" #include "funcrequest.h" #include "gettext.h" #include "LaTeXFeatures.h" -#include "latexrunparams.h" +#include "lyx_main.h" #include "lyxlex.h" #include "lyxrc.h" -#include "support/std_sstream.h" +#include "metricsinfo.h" +#include "outputparams.h" -#include "frontends/lyx_gui.h" +#include "graphics/PreviewLoader.h" #include "support/filetools.h" -#include "support/forkedcall.h" #include "support/lstrings.h" -#include "support/lyxalgo.h" #include "support/lyxlib.h" -#include "support/path.h" -#include "support/path_defines.h" -#include "support/tostr.h" +#include "support/convert.h" #include "support/translator.h" #include -namespace support = lyx::support; -namespace external = lyx::external; +#include using std::endl; using std::string; @@ -52,88 +53,131 @@ using std::ostringstream; using std::vector; -namespace lyx { -namespace graphics { -/// The translator between the DisplayType and the corresponding lyx string. -extern Translator displayTranslator; -} -} - namespace { -lyx::graphics::DisplayType const defaultDisplayType = lyx::graphics::NoDisplay; +lyx::external::DisplayType const defaultDisplayType = lyx::external::NoDisplay; -unsigned int defaultLyxScale = 100; +unsigned int const defaultLyxScale = 100; + +string defaultTemplateName = "RasterImage"; + +} // namespace anon -/// Substitute meta-variables in string s, makeing use of params and buffer. -string const doSubstitution(InsetExternal::Params const & params, - Buffer const & buffer, string const & s); -/// Invoke the external editor. -void editExternal(InsetExternal::Params const & params, Buffer const & buffer); +namespace lyx { +namespace external { -external::Template const * getTemplatePtr(string const & name) +TempName::TempName() { - external::TemplateManager const & etm = - external::TemplateManager::get(); - return etm.getTemplateByName(name); + support::FileName const tempname(support::tempName(support::FileName(), "lyxext")); + // FIXME: This is unsafe + support::unlink(tempname); + // must have an extension for the converter code to work correctly. + tempname_ = support::FileName(tempname.absFilename() + ".tmp"); } -external::Template const * getTemplatePtr(InsetExternal::Params const & params) +TempName::TempName(TempName const &) { - external::TemplateManager const & etm = - external::TemplateManager::get(); - return etm.getTemplateByName(params.templatename()); + tempname_ = TempName()(); } -} // namespace anon - -InsetExternal::TempName::TempName() +TempName::~TempName() { - tempname_ = support::tempName(string(), "lyxext"); support::unlink(tempname_); - // must have an extension for the converter code to work correctly. - tempname_ += ".tmp"; } -InsetExternal::TempName::TempName(InsetExternal::TempName const &) +TempName & +TempName::operator=(TempName const & other) { - tempname_ = TempName()(); + if (this != &other) + tempname_ = TempName()(); + return *this; } -InsetExternal::TempName::~TempName() +namespace { + +/// The translator between the Display enum and corresponding lyx string. +Translator const initTranslator() { - support::unlink(tempname_); + Translator 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 + -InsetExternal::TempName & -InsetExternal::TempName::operator=(InsetExternal::TempName const & other) +Translator const & displayTranslator() { - if (this != &other) - tempname_ = TempName()(); - return *this; + static Translator const translator = + initTranslator(); + return translator; } +} // namespace external -InsetExternal::Params::Params() + +InsetExternalParams::InsetExternalParams() : display(defaultDisplayType), - lyxscale(defaultLyxScale) + lyxscale(defaultLyxScale), + draft(false), + templatename_(defaultTemplateName) {} -void InsetExternal::Params::settemplate(string const & name) +namespace { + +template +void clearIfNotFound(T & data, external::TransformID value, + vector const & ids) +{ + typedef vector::const_iterator + const_iterator; + + const_iterator it = ids.begin(); + const_iterator end = ids.end(); + it = std::find(it, end, value); + if (it == end) + data = T(); +} + +} // namespace anon + + +void InsetExternalParams::settemplate(string const & name) { templatename_ = name; + + external::TemplateManager const & etm = + external::TemplateManager::get(); + external::Template const * const et = etm.getTemplateByName(name); + if (!et) + // Be safe. Don't lose data. + return; + + // Ascertain which transforms the template supports. + // Empty all those that it doesn't. + vector const & ids = et->transformIds; + clearIfNotFound(clipdata, external::Clip, ids); + clearIfNotFound(extradata, external::Extra, ids); + clearIfNotFound(resizedata, external::Resize, ids); + clearIfNotFound(rotationdata, external::Rotate, ids); } -void InsetExternal::Params::write(Buffer const & buffer, ostream & os) const +void InsetExternalParams::write(Buffer const & buffer, ostream & os) const { os << "External\n" << "\ttemplate " << templatename() << '\n'; @@ -144,30 +188,93 @@ void InsetExternal::Params::write(Buffer const & buffer, ostream & os) const << '\n'; if (display != defaultDisplayType) - os << "\tdisplay " << lyx::graphics::displayTranslator.find(display) + os << "\tdisplay " + << external::displayTranslator().find(display) << '\n'; if (lyxscale != defaultLyxScale) - os << "\tlyxscale " << tostr(lyxscale) << '\n'; + os << "\tlyxscale " << convert(lyxscale) << '\n'; + + if (draft) + os << "\tdraft\n"; + + if (!clipdata.bbox.empty()) + os << "\tboundingBox " << clipdata.bbox << '\n'; + if (clipdata.clip) + os << "\tclip\n"; + + external::ExtraData::const_iterator it = extradata.begin(); + external::ExtraData::const_iterator end = extradata.end(); + for (; it != end; ++it) { + if (!it->second.empty()) + os << "\textra " << it->first << " \"" + << it->second << "\"\n"; + } + + if (!rotationdata.no_rotation()) { + os << "\trotateAngle " << rotationdata.adjAngle() << '\n'; + if (rotationdata.origin() != external::RotationData::DEFAULT) + os << "\trotateOrigin " + << rotationdata.originString() << '\n'; + } + + if (!resizedata.no_resize()) { + using support::float_equal; + double const scl = convert(resizedata.scale); + if (!float_equal(scl, 0.0, 0.05)) { + if (!float_equal(scl, 100.0, 0.05)) + os << "\tscale " + << resizedata.scale << '\n'; + } else { + if (!resizedata.width.zero()) + os << "\twidth " + << resizedata.width.asString() << '\n'; + if (!resizedata.height.zero()) + os << "\theight " + << resizedata.height.asString() << '\n'; + } + if (resizedata.keepAspectRatio) + os << "\tkeepAspectRatio\n"; + } } -bool InsetExternal::Params::read(Buffer const & buffer, LyXLex & lex) +bool InsetExternalParams::read(Buffer const & buffer, LyXLex & lex) { enum ExternalTags { EX_TEMPLATE = 1, EX_FILENAME, EX_DISPLAY, EX_LYXSCALE, + EX_DRAFT, + EX_BOUNDINGBOX, + EX_CLIP, + EX_EXTRA, + EX_HEIGHT, + EX_KEEPASPECTRATIO, + EX_ROTATEANGLE, + EX_ROTATEORIGIN, + EX_SCALE, + EX_WIDTH, EX_END }; keyword_item external_tags[] = { { "\\end_inset", EX_END }, + { "boundingBox", EX_BOUNDINGBOX }, + { "clip", EX_CLIP }, { "display", EX_DISPLAY}, + { "draft", EX_DRAFT}, + { "extra", EX_EXTRA }, { "filename", EX_FILENAME}, + { "height", EX_HEIGHT }, + { "keepAspectRatio", EX_KEEPASPECTRATIO }, { "lyxscale", EX_LYXSCALE}, - { "template", EX_TEMPLATE } + { "rotateAngle", EX_ROTATEANGLE }, + { "rotateOrigin", EX_ROTATEORIGIN }, + { "scale", EX_SCALE }, + { "template", EX_TEMPLATE }, + { "width", EX_WIDTH } }; pushpophelper pph(lex, external_tags, EX_END); @@ -183,7 +290,7 @@ bool InsetExternal::Params::read(Buffer const & buffer, LyXLex & lex) break; case EX_FILENAME: { - lex.next(); + lex.eatLine(); string const name = lex.getString(); filename.set(name, buffer.filePath()); break; @@ -192,7 +299,7 @@ bool InsetExternal::Params::read(Buffer const & buffer, LyXLex & lex) case EX_DISPLAY: { lex.next(); string const name = lex.getString(); - display = lyx::graphics::displayTranslator.find(name); + display = external::displayTranslator().find(name); break; } @@ -201,6 +308,62 @@ bool InsetExternal::Params::read(Buffer const & buffer, LyXLex & lex) lyxscale = lex.getInteger(); break; + case EX_DRAFT: + draft = true; + break; + + case EX_BOUNDINGBOX: + lex.next(); + clipdata.bbox.xl = lex.getInteger(); + lex.next(); + clipdata.bbox.yb = lex.getInteger(); + lex.next(); + clipdata.bbox.xr = lex.getInteger(); + lex.next(); + clipdata.bbox.yt = lex.getInteger(); + break; + + case EX_CLIP: + clipdata.clip = true; + break; + + case EX_EXTRA: { + lex.next(); + string const name = lex.getString(); + lex.next(); + extradata.set(name, lex.getString()); + break; + } + + case EX_HEIGHT: + lex.next(); + resizedata.height = LyXLength(lex.getString()); + break; + + case EX_KEEPASPECTRATIO: + resizedata.keepAspectRatio = true; + break; + + case EX_ROTATEANGLE: + lex.next(); + rotationdata.angle = lex.getString(); + break; + + case EX_ROTATEORIGIN: + lex.next(); + rotationdata.origin(lex.getString()); + break; + + case EX_SCALE: + lex.next(); + resizedata.scale = lex.getString(); + break; + + case EX_WIDTH: + lex.next(); + resizedata.width = LyXLength(lex.getString()); + break; + case EX_END: found_end = true; break; @@ -216,28 +379,23 @@ bool InsetExternal::Params::read(Buffer const & buffer, LyXLex & lex) break; } - if (!found_end) { - lex.printError("ExternalInset::read: " - "Missing \\end_inset."); - } + if (!found_end) + lex.printError("ExternalInsetParams::read: Missing \\end_inset."); // This is a trick to make sure that the data are self-consistent. settemplate(templatename_); - lyxerr[Debug::EXTERNAL] - << "InsetExternal::Params::read: " - << "template: '" << templatename() - << "' filename: '" << filename.absFilename() - << "' display: '" << display - << "' scale: '" << lyxscale - << '\'' << endl; + if (lyxerr.debugging(Debug::EXTERNAL)) { + lyxerr << "InsetExternalParams::read:\n"; + write(buffer, lyxerr); + } return !read_error; } InsetExternal::InsetExternal() - : renderer_(new ButtonRenderer) + : renderer_(new RenderButton) {} @@ -245,16 +403,11 @@ InsetExternal::InsetExternal(InsetExternal const & other) : InsetOld(other), boost::signals::trackable(), params_(other.params_), - renderer_(other.renderer_->clone()) -{ - GraphicRenderer * ptr = dynamic_cast(renderer_.get()); - if (ptr) { - ptr->connect(boost::bind(&InsetExternal::statusChanged, this)); - } -} + renderer_(other.renderer_->clone(this)) +{} -auto_ptr InsetExternal::clone() const +auto_ptr InsetExternal::doClone() const { return auto_ptr(new InsetExternal(*this)); } @@ -266,139 +419,243 @@ InsetExternal::~InsetExternal() } -void InsetExternal::statusChanged() +void InsetExternal::statusChanged() const { - BufferView * bv = renderer_->view(); - if (bv) - bv->updateInset(this); + LyX::cref().updateInset(this); } -dispatch_result InsetExternal::localDispatch(FuncRequest const & cmd) +void InsetExternal::doDispatch(LCursor & cur, FuncRequest & cmd) { switch (cmd.action) { case LFUN_EXTERNAL_EDIT: { - BOOST_ASSERT(cmd.view()); - - Buffer const & buffer = *cmd.view()->buffer(); - InsetExternal::Params p; - InsetExternalMailer::string2params(cmd.argument, buffer, p); - editExternal(p, buffer); - return DISPATCHED_NOUPDATE; + Buffer const & buffer = cur.buffer(); + InsetExternalParams p; + InsetExternalMailer::string2params(to_utf8(cmd.argument()), buffer, p); + external::editExternal(p, buffer); + break; } case LFUN_INSET_MODIFY: { - BOOST_ASSERT(cmd.view()); - - Buffer const & buffer = *cmd.view()->buffer(); - InsetExternal::Params p; - InsetExternalMailer::string2params(cmd.argument, buffer, p); + Buffer const & buffer = cur.buffer(); + InsetExternalParams p; + InsetExternalMailer::string2params(to_utf8(cmd.argument()), buffer, p); setParams(p, buffer); - cmd.view()->updateInset(this); - return DISPATCHED; + break; } case LFUN_INSET_DIALOG_UPDATE: - InsetExternalMailer(*this).updateDialog(cmd.view()); - return DISPATCHED; + InsetExternalMailer(*this).updateDialog(&cur.bv()); + break; case LFUN_MOUSE_RELEASE: - case LFUN_INSET_EDIT: - InsetExternalMailer(*this).showDialog(cmd.view()); - return DISPATCHED; + InsetExternalMailer(*this).showDialog(&cur.bv()); + break; + + default: + InsetBase::doDispatch(cur, cmd); + } +} + + +bool InsetExternal::getStatus(LCursor & cur, FuncRequest const & cmd, + FuncStatus & flag) const +{ + switch (cmd.action) { + + case LFUN_EXTERNAL_EDIT: + case LFUN_INSET_MODIFY: + case LFUN_INSET_DIALOG_UPDATE: + flag.enabled(true); + return true; default: - return UNDISPATCHED; + return InsetBase::getStatus(cur, cmd, flag); } } -void InsetExternal::metrics(MetricsInfo & mi, Dimension & dim) const +void InsetExternal::edit(LCursor & cur, bool) +{ + InsetExternalMailer(*this).showDialog(&cur.bv()); +} + + +bool InsetExternal::metrics(MetricsInfo & mi, Dimension & dim) const { renderer_->metrics(mi, dim); + bool const changed = dim_ != dim; dim_ = dim; + return changed; } void InsetExternal::draw(PainterInfo & pi, int x, int y) const { + setPosCache(pi, x, y); renderer_->draw(pi, x, y); } namespace { -lyx::graphics::Params get_grfx_params(InsetExternal::Params const & eparams) +enum RenderType { + RENDERBUTTON, + RENDERGRAPHIC, + RENDERPREVIEW +}; + + +RenderType getRenderType(InsetExternalParams const & p) { - lyx::graphics::Params gparams; + if (!external::getTemplatePtr(p) || + p.filename.empty() || + p.display == external::NoDisplay) + return RENDERBUTTON; - gparams.filename = eparams.filename.absFilename(); - gparams.scale = eparams.lyxscale; - gparams.display = eparams.display; + if (p.display == external::PreviewDisplay) { + if (RenderPreview::status() != LyXRC::PREVIEW_OFF) + return RENDERPREVIEW; + return RENDERBUTTON; + } - if (gparams.display == lyx::graphics::DefaultDisplay) - gparams.display = lyxrc.display_graphics; + 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; + gparams.scale = eparams.lyxscale; + if (eparams.clipdata.clip) + gparams.bb = eparams.clipdata.bbox; + gparams.angle = convert(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 = lyxrc.display_graphics; // Override the above if we're not using a gui - if (!lyx_gui::use_gui) - gparams.display = lyx::graphics::NoDisplay; + if (!use_gui) + gparams.display = graphics::NoDisplay; return gparams; } -string const getScreenLabel(InsetExternal::Params const & params, +docstring const getScreenLabel(InsetExternalParams const & params, Buffer const & buffer) { - external::Template const * const ptr = getTemplatePtr(params); + external::Template const * const ptr = + external::getTemplatePtr(params); if (!ptr) - return support::bformat(_("External template %1$s is not installed"), - params.templatename()); - return doSubstitution(params, buffer, ptr->guiName); + // FIXME UNICODE + return support::bformat((_("External template %1$s is not installed")), + from_utf8(params.templatename())); + // FIXME UNICODE + return from_utf8(external::doSubstitution(params, buffer, + ptr->guiName, false)); } +void add_preview_and_start_loading(RenderMonitoredPreview &, + InsetExternal const &, + Buffer const &); + } // namespace anon -InsetExternal::Params const & InsetExternal::params() const +InsetExternalParams const & InsetExternal::params() const { return params_; } -void InsetExternal::setParams(Params const & p, Buffer const & buffer) +void InsetExternal::setParams(InsetExternalParams const & p, + Buffer const & buffer) { - // The stored params; what we would like to happen in an ideal world. params_ = p; - // We display the inset as a button by default. - bool display_button = (!getTemplatePtr(params_) || - params_.filename.empty() || - params_.display == lyx::graphics::NoDisplay); + // Subsequent calls to the InsetExternal::Params default constructor + // will use this. + defaultTemplateName = params_.templatename(); - if (display_button) { - ButtonRenderer * button_ptr = - dynamic_cast(renderer_.get()); + switch (getRenderType(params_)) { + case RENDERBUTTON: { + RenderButton * button_ptr = renderer_->asButton(); if (!button_ptr) { - button_ptr = new ButtonRenderer; - renderer_.reset(button_ptr); + renderer_.reset(new RenderButton); + button_ptr = renderer_->asButton(); } button_ptr->update(getScreenLabel(params_, buffer), true); + break; - } else { - GraphicRenderer * graphic_ptr = - dynamic_cast(renderer_.get()); + } case RENDERGRAPHIC: { + RenderGraphic * graphic_ptr = renderer_->asGraphic(); if (!graphic_ptr) { - graphic_ptr = new GraphicRenderer; - graphic_ptr->connect( - boost::bind(&InsetExternal::statusChanged, this)); - renderer_.reset(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; } + } +} + + +void InsetExternal::fileChanged() const +{ + Buffer const * const buffer_ptr = LyX::cref().updateInset(this); + if (!buffer_ptr) + return; + + RenderMonitoredPreview * const ptr = renderer_->asMonitoredPreview(); + BOOST_ASSERT(ptr); + + Buffer const & buffer = *buffer_ptr; + ptr->removePreview(buffer); + add_preview_and_start_loading(*ptr, *this, buffer); } @@ -410,255 +667,180 @@ void InsetExternal::write(Buffer const & buffer, ostream & os) const void InsetExternal::read(Buffer const & buffer, LyXLex & lex) { - Params params; + InsetExternalParams params; if (params.read(buffer, lex)) setParams(params, buffer); } -int InsetExternal::write(string const & format, - Buffer const & buf, ostream & os, - bool external_in_tmpdir) const +int InsetExternal::latex(Buffer const & buf, odocstream & os, + OutputParams const & runparams) const { - external::Template const * const et_ptr = getTemplatePtr(params_); - if (!et_ptr) - return 0; - external::Template const & et = *et_ptr; - - external::Template::Formats::const_iterator cit = - et.formats.find(format); - if (cit == et.formats.end()) { - lyxerr[Debug::EXTERNAL] - << "External template format '" << format - << "' not specified in template " - << params_.templatename() << endl; - return 0; + if (params_.draft) { + // FIXME UNICODE + os << "\\fbox{\\ttfamily{}" + << from_utf8(params_.filename.outputFilename(buf.filePath())) + << "}\n"; + return 1; } - updateExternal(format, buf, external_in_tmpdir); - string const str = doSubstitution(params_, buf, cit->second.product); - os << str; - return int(lyx::count(str.begin(), str.end(),'\n') + 1); -} - - -int InsetExternal::latex(Buffer const & buf, ostream & os, - LatexRunParams const & runparams) const -{ // "nice" means that the buffer is exported to LaTeX format but not // run through the LaTeX compiler. // If we're running through the LaTeX compiler, we should write the // generated files in the bufer's temporary directory. - bool const external_in_tmpdir = - lyxrc.use_tempdir && !buf.temppath().empty() && !runparams.nice; + bool const external_in_tmpdir = !runparams.nice && !runparams.dryrun; // If the template has specified a PDFLaTeX output, then we try and // use that. - if (runparams.flavor == LatexRunParams::PDFLATEX) { - external::Template const * const et_ptr = getTemplatePtr(params_); + if (runparams.flavor == OutputParams::PDFLATEX) { + external::Template const * const et_ptr = + external::getTemplatePtr(params_); if (!et_ptr) return 0; external::Template const & et = *et_ptr; external::Template::Formats::const_iterator cit = et.formats.find("PDFLaTeX"); - if (cit != et.formats.end()) - return write("PDFLaTeX", buf, os, external_in_tmpdir); - } - - return write("LaTeX", buf, os, external_in_tmpdir); -} - -int InsetExternal::ascii(Buffer const & buf, ostream & os, int) const -{ - return write("Ascii", buf, os); + if (cit != et.formats.end()) { + return external::writeExternal(params_, "PDFLaTeX", + buf, os, + *(runparams.exportdata), + external_in_tmpdir, + runparams.inComment); + } + + } + + return external::writeExternal(params_, "LaTeX", buf, os, + *(runparams.exportdata), + external_in_tmpdir, + runparams.inComment); } -int InsetExternal::linuxdoc(Buffer const & buf, ostream & os) const +int InsetExternal::plaintext(Buffer const & buf, odocstream & os, + OutputParams const & runparams) const { - return write("LinuxDoc", buf, os); + return external::writeExternal(params_, "Ascii", buf, os, + *(runparams.exportdata), false, + runparams.inComment); } -int InsetExternal::docbook(Buffer const & buf, ostream & os, bool) const +int InsetExternal::docbook(Buffer const & buf, odocstream & os, + OutputParams const & runparams) const { - return write("DocBook", buf, os); + return external::writeExternal(params_, "DocBook", buf, os, + *(runparams.exportdata), false, + runparams.inComment); } void InsetExternal::validate(LaTeXFeatures & features) const { - external::Template const * const et_ptr = getTemplatePtr(params_); - if (!et_ptr) + if (params_.draft) return; - external::Template const & et = *et_ptr; - - external::Template::Formats::const_iterator cit = et.formats.find("LaTeX"); - if (cit == et.formats.end()) - return; - - if (!cit->second.requirement.empty()) - features.require(cit->second.requirement); - - external::TemplateManager & etm = external::TemplateManager::get(); - - vector::const_iterator it = cit->second.preambleNames.begin(); - vector::const_iterator end = cit->second.preambleNames.end(); - for (; it != end; ++it) { - string const preamble = etm.getPreambleDefByName(*it); - if (!preamble.empty()) - features.addExternalPreamble(preamble); - } -} - -void InsetExternal::updateExternal(string const & format, - Buffer const & buf, - bool external_in_tmpdir) const -{ - external::Template const * const et_ptr = getTemplatePtr(params_); + external::Template const * const et_ptr = + external::getTemplatePtr(params_); if (!et_ptr) return; external::Template const & et = *et_ptr; - if (!et.automaticProduction) - return; - + string format; + switch (features.runparams().flavor) { + case OutputParams::LATEX: + format = "LaTeX"; + break; + case OutputParams::PDFLATEX: + format = "PDFLaTeX"; + break; + case OutputParams::XML: + format = "DocBook"; + break; + } external::Template::Formats::const_iterator cit = et.formats.find(format); if (cit == et.formats.end()) return; - external::Template::Format const & outputFormat = cit->second; - if (outputFormat.updateResult.empty()) - return; + // FIXME: We don't need that always + features.require("lyxdot"); - string from_format = et.inputFormat; - if (from_format.empty()) - return; + vector::const_iterator it = cit->second.requirements.begin(); + vector::const_iterator end = cit->second.requirements.end(); + for (; it != end; ++it) + features.require(*it); - string from_file = params_.filename.absFilename(); - - if (from_format == "*") { - if (from_file.empty()) - return; - - // Try and ascertain the file format from its contents. - from_format = support::getExtFromContents(from_file); - if (from_format.empty()) - return; - } - - string const to_format = outputFormat.updateFormat; - if (to_format.empty()) - return; - - if (!converters.isReachable(from_format, to_format)) { - lyxerr[Debug::EXTERNAL] - << "InsetExternal::updateExternal. " - << "Unable to convert from " - << from_format << " to " << to_format << endl; - return; - } + external::TemplateManager & etm = external::TemplateManager::get(); - if (external_in_tmpdir && !from_file.empty()) { - // We are running stuff through LaTeX - string const temp_file = - support::MakeAbsPath(params_.filename.mangledFilename(), - buf.temppath()); - unsigned long const from_checksum = support::sum(from_file); - unsigned long const temp_checksum = support::sum(temp_file); - - // Nothing to do... - if (from_checksum == temp_checksum) - return; - - // Cannot proceed... - if (!support::copy(from_file, temp_file)) - return; - from_file = temp_file; + it = cit->second.preambleNames.begin(); + end = cit->second.preambleNames.end(); + for (; it != end; ++it) { + string const preamble = etm.getPreambleDefByName(*it); + if (!preamble.empty()) + features.addPreambleSnippet(preamble); } - - string const to_file = doSubstitution(params_, buf, - outputFormat.updateResult); - string const abs_to_file = support::MakeAbsPath(to_file, buf.filePath()); - - // Do we need to perform the conversion? - // Yes if to_file does not exist or if from_file is newer than to_file - if (support::compare_timestamps(from_file, abs_to_file) < 0) - return; - - string const to_filebase = support::ChangeExtension(to_file, string()); - converters.convert(&buf, from_file, to_filebase, from_format, to_format); } +// +// preview stuff +// + namespace { -/// Substitute meta-variables in this string -string const doSubstitution(InsetExternal::Params const & params, - Buffer const & buffer, string const & s) +bool preview_wanted(InsetExternalParams const & params) { - string result; - string const buffer_path = buffer.filePath(); - string const filename = params.filename.outputFilename(buffer_path); - string const basename = support::ChangeExtension(filename, string()); - string const filepath = support::OnlyPath(filename); - - result = support::subst(s, "$$FName", filename); - result = support::subst(result, "$$Basename", basename); - result = support::subst(result, "$$FPath", filepath); - result = support::subst(result, "$$Tempname", params.tempname()); - result = support::subst(result, "$$Sysdir", support::system_lyxdir()); + return params.display == external::PreviewDisplay && + support::isFileReadable(params.filename); +} - // Handle the $$Contents(filename) syntax - if (support::contains(result, "$$Contents(\"")) { - string::size_type const pos = result.find("$$Contents(\""); - string::size_type const end = result.find("\")", pos); - string const file = result.substr(pos + 12, end - (pos + 12)); - string contents; +docstring const latex_string(InsetExternal const & inset, Buffer const & buffer) +{ + odocstringstream os; + OutputParams runparams; + runparams.flavor = OutputParams::LATEX; + inset.latex(buffer, os, runparams); + return os.str(); +} - string const filepath = support::IsFileReadable(file) ? - buffer.filePath() : buffer.temppath(); - support::Path p(filepath); - if (support::IsFileReadable(file)) - contents = support::GetFileContents(file); +void add_preview_and_start_loading(RenderMonitoredPreview & renderer, + InsetExternal const & inset, + Buffer const & buffer) +{ + InsetExternalParams const & params = inset.params(); - result = support::subst(result, - ("$$Contents(\"" + file + "\")").c_str(), - contents); + 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); } - - return result; } +} // namespace anon -void editExternal(InsetExternal::Params const & params, Buffer const & buffer) -{ - external::Template const * const et_ptr = getTemplatePtr(params); - if (!et_ptr) - return; - external::Template const & et = *et_ptr; - if (et.editCommand.empty()) +void InsetExternal::addPreview(graphics::PreviewLoader & ploader) const +{ + RenderMonitoredPreview * const ptr = renderer_->asMonitoredPreview(); + if (!ptr) return; - string const command = doSubstitution(params, buffer, et.editCommand); - - support::Path p(buffer.filePath()); - support::Forkedcall call; - if (lyxerr.debugging(Debug::EXTERNAL)) { - lyxerr << "Executing '" << command << "' in '" - << buffer.filePath() << '\'' << endl; + if (preview_wanted(params())) { + ptr->setAbsFile(params_.filename); + docstring const snippet = latex_string(*this, ploader.buffer()); + ptr->addPreview(snippet, ploader); } - call.startscript(support::Forkedcall::DontWait, command); } -} // namespace anon + +/// Mailer stuff string const InsetExternalMailer::name_("external"); @@ -675,10 +857,9 @@ string const InsetExternalMailer::inset2string(Buffer const & buffer) const void InsetExternalMailer::string2params(string const & in, Buffer const & buffer, - InsetExternal::Params & params) + InsetExternalParams & params) { - params = InsetExternal::Params(); - + params = InsetExternalParams(); if (in.empty()) return; @@ -686,30 +867,24 @@ void InsetExternalMailer::string2params(string const & in, LyXLex lex(0,0); lex.setStream(data); - if (lex.isOK()) { - lex.next(); - string const token = lex.getString(); - if (token != name_) - return; - } + string name; + lex >> name; + if (!lex || name != name_) + return print_mailer_error("InsetExternalMailer", in, 1, name_); // This is part of the inset proper that is usually swallowed - // by Buffer::readInset - if (lex.isOK()) { - lex.next(); - string const token = lex.getString(); - if (token != "External") - return; - } + // by LyXText::readInset + string id; + lex >> id; + if (!lex || id != "External") + return print_mailer_error("InsetBoxMailer", in, 2, "External"); - if (lex.isOK()) { - params.read(buffer, lex); - } + params.read(buffer, lex); } string const -InsetExternalMailer::params2string(InsetExternal::Params const & params, +InsetExternalMailer::params2string(InsetExternalParams const & params, Buffer const & buffer) { ostringstream data; @@ -718,3 +893,5 @@ InsetExternalMailer::params2string(InsetExternal::Params const & params, data << "\\end_inset\n"; return data.str(); } + +} // namespace lyx