#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 "cursor.h"
#include "debug.h"
+#include "dispatchresult.h"
+#include "exporter.h"
#include "funcrequest.h"
#include "gettext.h"
#include "LaTeXFeatures.h"
-#include "latexrunparams.h"
#include "lyx_main.h"
#include "lyxlex.h"
#include "lyxrc.h"
#include "metricsinfo.h"
+#include "outputparams.h"
#include "frontends/lyx_gui.h"
#include "frontends/LyXView.h"
+#include "graphics/PreviewLoader.h"
+
+#include "support/FileInfo.h"
+#include "support/filetools.h"
#include "support/lstrings.h"
#include "support/lyxlib.h"
#include "support/tostr.h"
#include <boost/bind.hpp>
-#include "support/std_sstream.h"
+#include <sstream>
namespace support = lyx::support;
namespace external = lyx::external;
+namespace graphics = lyx::graphics;
using std::endl;
using std::string;
namespace {
-lyx::graphics::DisplayType const defaultDisplayType = lyx::graphics::NoDisplay;
+external::DisplayType const defaultDisplayType = external::NoDisplay;
+
+unsigned int const defaultLyxScale = 100;
-unsigned int defaultLyxScale = 100;
+string defaultTemplateName = "RasterImage";
} // namespace anon
TempName::TempName()
{
tempname_ = support::tempName(string(), "lyxext");
+ // FIXME: This is unsafe
support::unlink(tempname_);
// must have an extension for the converter code to work correctly.
tempname_ += ".tmp";
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()
+{
+ static Translator<DisplayType, string> const translator =
+ initTranslator();
+ return translator;
+}
+
} // namespace external
} // namespace lyx
InsetExternalParams::InsetExternalParams()
: display(defaultDisplayType),
- lyxscale(defaultLyxScale)
+ lyxscale(defaultLyxScale),
+ draft(false),
+ templatename_(defaultTemplateName)
{}
if (display != defaultDisplayType)
os << "\tdisplay "
- << lyx::graphics::displayTranslator().find(display)
+ << external::displayTranslator().find(display)
<< '\n';
if (lyxscale != defaultLyxScale)
os << "\tlyxscale " << tostr(lyxscale) << '\n';
+ if (draft)
+ os << "\tdraft\n";
+
if (!clipdata.bbox.empty())
os << "\tboundingBox " << clipdata.bbox << '\n';
if (clipdata.clip)
EX_FILENAME,
EX_DISPLAY,
EX_LYXSCALE,
+ EX_DRAFT,
EX_BOUNDINGBOX,
EX_CLIP,
EX_EXTRA,
{ "boundingBox", EX_BOUNDINGBOX },
{ "clip", EX_CLIP },
{ "display", EX_DISPLAY},
+ { "draft", EX_DRAFT},
{ "extra", EX_EXTRA },
{ "filename", EX_FILENAME},
{ "height", EX_HEIGHT },
case EX_DISPLAY: {
lex.next();
string const name = lex.getString();
- display = lyx::graphics::displayTranslator().find(name);
+ display = external::displayTranslator().find(name);
break;
}
lyxscale = lex.getInteger();
break;
+ case EX_DRAFT:
+ draft = true;
+ break;
+
case EX_BOUNDINGBOX:
lex.next();
clipdata.bbox.xl = lex.getInteger();
}
if (!found_end)
- lex.printError("ExternalInset::read: Missing \\end_inset.");
+ lex.printError("ExternalInsetParams::read: Missing \\end_inset.");
// This is a trick to make sure that the data are self-consistent.
settemplate(templatename_);
: InsetOld(other),
boost::signals::trackable(),
params_(other.params_),
- renderer_(other.renderer_->clone())
-{
- RenderGraphic * ptr =
- dynamic_cast<RenderGraphic *>(renderer_.get());
- if (ptr)
- ptr->connect(boost::bind(&InsetExternal::statusChanged, this));
-}
+ renderer_(other.renderer_->clone(this))
+{}
auto_ptr<InsetBase> InsetExternal::clone() const
}
-dispatch_result
-InsetExternal::priv_dispatch(FuncRequest const & cmd, idx_type &, pos_type &)
+void InsetExternal::priv_dispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
case LFUN_EXTERNAL_EDIT: {
- BOOST_ASSERT(cmd.view());
-
- Buffer const & buffer = *cmd.view()->buffer();
+ Buffer const & buffer = cur.buffer();
InsetExternalParams p;
InsetExternalMailer::string2params(cmd.argument, buffer, p);
external::editExternal(p, buffer);
- return DISPATCHED_NOUPDATE;
+ break;
}
case LFUN_INSET_MODIFY: {
- BOOST_ASSERT(cmd.view());
-
- Buffer const & buffer = *cmd.view()->buffer();
+ Buffer const & buffer = cur.buffer();
InsetExternalParams p;
InsetExternalMailer::string2params(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:
- return UNDISPATCHED;
+ InsetOld::priv_dispatch(cur, cmd);
}
}
+void InsetExternal::edit(LCursor & cur, bool)
+{
+ InsetExternalMailer(*this).showDialog(&cur.bv());
+}
+
+
void InsetExternal::metrics(MetricsInfo & mi, Dimension & dim) const
{
renderer_->metrics(mi, dim);
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(InsetExternalParams 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;
+
+ 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.absFilename();
gparams.scale = eparams.lyxscale;
gparams.bb = eparams.clipdata.bbox;
gparams.angle = eparams.rotationdata.angle();
- gparams.display = eparams.display;
- if (gparams.display == lyx::graphics::DefaultDisplay)
+ 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;
+ gparams.display = graphics::NoDisplay;
return gparams;
}
return external::doSubstitution(params, buffer, ptr->guiName);
}
+void add_preview_and_start_loading(RenderMonitoredPreview &,
+ InsetExternal const &,
+ Buffer const &);
+
} // namespace anon
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 = (!external::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) {
- RenderButton * button_ptr =
- dynamic_cast<RenderButton *>(renderer_.get());
+ switch (getRenderType(params_)) {
+ case RENDERBUTTON: {
+ RenderButton * button_ptr = renderer_->asButton();
if (!button_ptr) {
- button_ptr = new RenderButton;
- renderer_.reset(button_ptr);
+ renderer_.reset(new RenderButton);
+ button_ptr = renderer_->asButton();
}
button_ptr->update(getScreenLabel(params_, buffer), true);
+ break;
- } else {
- RenderGraphic * graphic_ptr =
- dynamic_cast<RenderGraphic *>(renderer_.get());
+ } case RENDERGRAPHIC: {
+ RenderGraphic * graphic_ptr = renderer_->asGraphic();
if (!graphic_ptr) {
- graphic_ptr = new RenderGraphic;
- 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);
+}
+
+
void InsetExternal::write(Buffer const & buffer, ostream & os) const
{
params_.write(buffer, os);
int InsetExternal::latex(Buffer const & buf, ostream & os,
- LatexRunParams const & runparams) const
+ OutputParams const & runparams) const
{
+ if (params_.draft) {
+ os << "\\fbox{\\ttfamily{}"
+ << params_.filename.outputFilename(buf.filePath())
+ << "}\n";
+ return 1;
+ }
+
// "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;
// If the template has specified a PDFLaTeX output, then we try and
// use that.
- if (runparams.flavor == LatexRunParams::PDFLATEX) {
+ if (runparams.flavor == OutputParams::PDFLATEX) {
external::Template const * const et_ptr =
external::getTemplatePtr(params_);
if (!et_ptr)
et.formats.find("PDFLaTeX");
if (cit != et.formats.end())
return external::writeExternal(params_, "PDFLaTeX",
- buf, os, external_in_tmpdir);
+ buf, os,
+ *(runparams.exportdata),
+ external_in_tmpdir);
}
-
- return external::writeExternal(params_, "LaTeX",
- buf, os, external_in_tmpdir);
+ return external::writeExternal(params_, "LaTeX", buf, os,
+ *(runparams.exportdata),
+ external_in_tmpdir);
}
-int InsetExternal::ascii(Buffer const & buf, ostream & os, int) const
+int InsetExternal::plaintext(Buffer const & buf, ostream & os,
+ OutputParams const & runparams) const
{
- return external::writeExternal(params_, "Ascii", buf, os);
+ return external::writeExternal(params_, "Ascii", buf, os,
+ *(runparams.exportdata));
}
-int InsetExternal::linuxdoc(Buffer const & buf, ostream & os) const
+int InsetExternal::linuxdoc(Buffer const & buf, ostream & os,
+ OutputParams const & runparams) const
{
- return external::writeExternal(params_, "LinuxDoc", buf, os);
+ return external::writeExternal(params_, "LinuxDoc", buf, os,
+ *(runparams.exportdata));
}
-int InsetExternal::docbook(Buffer const & buf, ostream & os, bool) const
+int InsetExternal::docbook(Buffer const & buf, ostream & os,
+ OutputParams const & runparams) const
{
- return external::writeExternal(params_, "DocBook", buf, os);
+ return external::writeExternal(params_, "DocBook", buf, os,
+ *(runparams.exportdata));
}
void InsetExternal::validate(LaTeXFeatures & features) const
{
+ if (params_.draft)
+ return;
+
external::Template const * const et_ptr =
external::getTemplatePtr(params_);
if (!et_ptr)
}
+//
+// preview stuff
+//
+
+namespace {
+
+bool preview_wanted(InsetExternalParams const & params)
+{
+ string const included_file = params.filename.absFilename();
+
+ return params.display == external::PreviewDisplay &&
+ support::IsFileReadable(included_file);
+}
+
+
+string const latex_string(InsetExternal const & inset, Buffer const & buffer)
+{
+ ostringstream os;
+ OutputParams runparams;
+ 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.absFilename());
+ string const snippet = latex_string(inset, buffer);
+ renderer.addPreview(snippet, buffer);
+ renderer.startLoading(buffer);
+ }
+}
+
+} // namespace anon
+
+
+void InsetExternal::addPreview(graphics::PreviewLoader & ploader) const
+{
+ RenderMonitoredPreview * const ptr = renderer_->asMonitoredPreview();
+ if (!ptr)
+ return;
+
+ if (preview_wanted(params())) {
+ ptr->setAbsFile(params_.filename.absFilename());
+ string const snippet = latex_string(*this, ploader.buffer());
+ ptr->addPreview(snippet, ploader);
+ }
+}
+
+
+/// Mailer stuff
+
string const InsetExternalMailer::name_("external");
InsetExternalMailer::InsetExternalMailer(InsetExternal & inset)
InsetExternalParams & params)
{
params = InsetExternalParams();
-
if (in.empty())
return;
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);
}