#include "insets/render_preview.h"
#include "buffer.h"
-#include "BufferView.h"
#include "cursor.h"
#include "debug.h"
#include "dispatchresult.h"
+#include "exporter.h"
+#include "FuncStatus.h"
#include "funcrequest.h"
#include "gettext.h"
#include "LaTeXFeatures.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 "support/convert.h"
#include "support/translator.h"
-#include "support/std_sstream.h"
#include <boost/bind.hpp>
-
-namespace support = lyx::support;
-namespace external = lyx::external;
-namespace graphics = lyx::graphics;
+#include <sstream>
using std::endl;
using std::string;
namespace {
-external::DisplayType const defaultDisplayType = external::NoDisplay;
+lyx::external::DisplayType const defaultDisplayType = lyx::external::NoDisplay;
unsigned int const defaultLyxScale = 100;
namespace lyx {
+
namespace external {
TempName::TempName()
{
- tempname_ = support::tempName(string(), "lyxext");
+ support::FileName const tempname(support::tempName(support::FileName(), "lyxext"));
// FIXME: This is unsafe
- support::unlink(tempname_);
+ support::unlink(tempname);
// must have an extension for the converter code to work correctly.
- tempname_ += ".tmp";
+ tempname_ = support::FileName(tempname.absFilename() + ".tmp");
}
}
} // namespace external
-} // namespace lyx
InsetExternalParams::InsetExternalParams()
<< '\n';
if (lyxscale != defaultLyxScale)
- os << "\tlyxscale " << tostr(lyxscale) << '\n';
+ os << "\tlyxscale " << convert<string>(lyxscale) << '\n';
if (draft)
os << "\tdraft\n";
}
if (!rotationdata.no_rotation()) {
- os << "\trotateAngle " << rotationdata.angle() << '\n';
+ os << "\trotateAngle " << rotationdata.adjAngle() << '\n';
if (rotationdata.origin() != external::RotationData::DEFAULT)
os << "\trotateOrigin "
<< rotationdata.originString() << '\n';
if (!resizedata.no_resize()) {
using support::float_equal;
-
- if (!float_equal(resizedata.scale, 0.0, 0.05)) {
- if (!float_equal(resizedata.scale, 100.0, 0.05))
+ double const scl = convert<double>(resizedata.scale);
+ if (!float_equal(scl, 0.0, 0.05)) {
+ if (!float_equal(scl, 100.0, 0.05))
os << "\tscale "
<< resizedata.scale << '\n';
} else {
break;
case EX_FILENAME: {
- lex.next();
+ lex.eatLine();
string const name = lex.getString();
filename.set(name, buffer.filePath());
break;
case EX_ROTATEANGLE:
lex.next();
- rotationdata.angle(lex.getFloat());
+ rotationdata.angle = lex.getString();
break;
case EX_ROTATEORIGIN:
case EX_SCALE:
lex.next();
- resizedata.scale = lex.getFloat();
+ resizedata.scale = lex.getString();
break;
case EX_WIDTH:
: InsetOld(other),
boost::signals::trackable(),
params_(other.params_),
- renderer_(other.renderer_->clone())
-{
- if (renderer_->asMonitoredPreview() != 0) {
- RenderMonitoredPreview * const ptr = renderer_->asMonitoredPreview();
- ptr->connect(boost::bind(&InsetExternal::statusChanged, this));
- ptr->fileChanged(boost::bind(&InsetExternal::fileChanged, this));
-
- } else if (renderer_->asGraphic() != 0 ) {
- RenderGraphic * const ptr = renderer_->asGraphic();
- ptr->connect(boost::bind(&InsetExternal::statusChanged, this));
- }
-}
+ renderer_(other.renderer_->clone(this))
+{}
-auto_ptr<InsetBase> InsetExternal::clone() const
+auto_ptr<InsetBase> InsetExternal::doClone() const
{
return auto_ptr<InsetBase>(new InsetExternal(*this));
}
}
-void InsetExternal::priv_dispatch(LCursor & cur, FuncRequest & cmd)
+void InsetExternal::doDispatch(LCursor & cur, FuncRequest & cmd)
{
switch (cmd.action) {
case LFUN_EXTERNAL_EDIT: {
Buffer const & buffer = cur.buffer();
InsetExternalParams p;
- InsetExternalMailer::string2params(cmd.argument, buffer, p);
+ InsetExternalMailer::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(cmd.argument, buffer, p);
+ InsetExternalMailer::string2params(to_utf8(cmd.argument()), buffer, p);
setParams(p, buffer);
-#warning is this needed?
- cur.bv().update();
break;
}
break;
default:
- InsetOld::priv_dispatch(cur, cmd);
+ 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 InsetBase::getStatus(cur, cmd, flag);
}
}
}
-void InsetExternal::metrics(MetricsInfo & mi, Dimension & dim) const
+bool InsetExternal::metrics(MetricsInfo & mi, Dimension & dim) const
{
renderer_->metrics(mi, dim);
+ bool const changed = dim_ != dim;
dim_ = dim;
+ return changed;
}
return RENDERBUTTON;
if (p.display == external::PreviewDisplay) {
- if (RenderPreview::activated())
+ if (RenderPreview::status() != LyXRC::PREVIEW_OFF)
return RENDERPREVIEW;
return RENDERBUTTON;
}
{
graphics::Params gparams;
- gparams.filename = eparams.filename.absFilename();
+ gparams.filename = eparams.filename;
gparams.scale = eparams.lyxscale;
if (eparams.clipdata.clip)
gparams.bb = eparams.clipdata.bbox;
- gparams.angle = eparams.rotationdata.angle();
+ gparams.angle = convert<double>(eparams.rotationdata.adjAngle());
switch (eparams.display) {
case external::DefaultDisplay:
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)
+ if (!use_gui)
gparams.display = graphics::NoDisplay;
return gparams;
}
-string const getScreenLabel(InsetExternalParams const & params,
+docstring const getScreenLabel(InsetExternalParams const & params,
Buffer const & buffer)
{
external::Template const * const ptr =
external::getTemplatePtr(params);
if (!ptr)
- return support::bformat(_("External template %1$s is not installed"),
- params.templatename());
- return external::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(RenderMonitoredPreview &, InsetExternal const &, Buffer const &);
+void add_preview_and_start_loading(RenderMonitoredPreview &,
+ InsetExternal const &,
+ Buffer const &);
} // namespace anon
} case RENDERGRAPHIC: {
RenderGraphic * graphic_ptr = renderer_->asGraphic();
if (!graphic_ptr) {
- renderer_.reset(new RenderGraphic);
+ renderer_.reset(new RenderGraphic(this));
graphic_ptr = renderer_->asGraphic();
- graphic_ptr->connect(
- boost::bind(&InsetExternal::statusChanged, this));
}
graphic_ptr->update(get_grfx_params(params_));
RenderMonitoredPreview * preview_ptr =
renderer_->asMonitoredPreview();
if (!preview_ptr) {
- renderer_.reset(new RenderMonitoredPreview);
+ renderer_.reset(new RenderMonitoredPreview(this));
preview_ptr = renderer_->asMonitoredPreview();
- preview_ptr->connect(
- boost::bind(&InsetExternal::statusChanged, this));
preview_ptr->fileChanged(
boost::bind(&InsetExternal::fileChanged, this));
}
if (preview_ptr->monitoring())
preview_ptr->stopMonitoring();
- add_preview(*preview_ptr, *this, buffer);
+ add_preview_and_start_loading(*preview_ptr, *this, buffer);
break;
}
Buffer const & buffer = *buffer_ptr;
ptr->removePreview(buffer);
- add_preview(*ptr, *this, buffer);
- ptr->startLoading(buffer);
+ add_preview_and_start_loading(*ptr, *this, buffer);
}
}
-int InsetExternal::latex(Buffer const & buf, ostream & os,
+int InsetExternal::latex(Buffer const & buf, odocstream & os,
OutputParams const & runparams) const
{
if (params_.draft) {
+ // FIXME UNICODE
os << "\\fbox{\\ttfamily{}"
- << params_.filename.outputFilename(buf.filePath())
+ << from_utf8(params_.filename.outputFilename(buf.filePath()))
<< "}\n";
return 1;
}
// 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 = !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.
external::Template::Formats::const_iterator cit =
et.formats.find("PDFLaTeX");
- if (cit != et.formats.end())
+
+ if (cit != et.formats.end()) {
return external::writeExternal(params_, "PDFLaTeX",
- buf, os, external_in_tmpdir);
+ buf, os,
+ *(runparams.exportdata),
+ external_in_tmpdir,
+ runparams.inComment);
+ }
+
}
-
- return external::writeExternal(params_, "LaTeX",
- buf, os, external_in_tmpdir);
-}
-
-
-int InsetExternal::plaintext(Buffer const & buf, ostream & os,
- OutputParams const &) const
-{
- return external::writeExternal(params_, "Ascii", buf, os);
+
+ return external::writeExternal(params_, "LaTeX", buf, os,
+ *(runparams.exportdata),
+ external_in_tmpdir,
+ runparams.inComment);
}
-int InsetExternal::linuxdoc(Buffer const & buf, ostream & os,
- OutputParams const &) const
+int InsetExternal::plaintext(Buffer const & buf, odocstream & os,
+ OutputParams const & runparams) const
{
- return external::writeExternal(params_, "LinuxDoc", buf, os);
+ return external::writeExternal(params_, "Ascii", buf, os,
+ *(runparams.exportdata), false,
+ runparams.inComment);
}
-int InsetExternal::docbook(Buffer const & buf, ostream & os,
- OutputParams const &) const
+int InsetExternal::docbook(Buffer const & buf, odocstream & os,
+ OutputParams const & runparams) const
{
- return external::writeExternal(params_, "DocBook", buf, os);
+ return external::writeExternal(params_, "DocBook", buf, os,
+ *(runparams.exportdata), false,
+ runparams.inComment);
}
return;
external::Template const & et = *et_ptr;
+ 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("LaTeX");
+ et.formats.find(format);
if (cit == et.formats.end())
return;
- if (!cit->second.requirement.empty())
- features.require(cit->second.requirement);
+ // FIXME: We don't need that always
+ features.require("lyxdot");
+
+ vector<string>::const_iterator it = cit->second.requirements.begin();
+ vector<string>::const_iterator end = cit->second.requirements.end();
+ for (; it != end; ++it)
+ features.require(*it);
external::TemplateManager & etm = external::TemplateManager::get();
- vector<string>::const_iterator it = cit->second.preambleNames.begin();
- vector<string>::const_iterator end = cit->second.preambleNames.end();
+ it = cit->second.preambleNames.begin();
+ end = cit->second.preambleNames.end();
for (; it != end; ++it) {
string const preamble = etm.getPreambleDefByName(*it);
if (!preamble.empty())
- features.addExternalPreamble(preamble);
+ features.addPreambleSnippet(preamble);
}
}
bool preview_wanted(InsetExternalParams const & params)
{
- string const included_file = params.filename.absFilename();
-
return params.display == external::PreviewDisplay &&
- support::IsFileReadable(included_file);
+ support::isFileReadable(params.filename);
}
-string const latex_string(InsetExternal const & inset, Buffer const & buffer)
+docstring const latex_string(InsetExternal const & inset, Buffer const & buffer)
{
- ostringstream os;
+ odocstringstream os;
OutputParams runparams;
runparams.flavor = OutputParams::LATEX;
inset.latex(buffer, os, runparams);
-
return os.str();
}
-void add_preview(RenderMonitoredPreview & renderer, InsetExternal const & inset,
- Buffer const & buffer)
+void add_preview_and_start_loading(RenderMonitoredPreview & renderer,
+ InsetExternal const & inset,
+ Buffer const & buffer)
{
InsetExternalParams const & params = inset.params();
- if (RenderPreview::activated() && preview_wanted(params)) {
- renderer.setAbsFile(params.filename.absFilename());
- string const snippet = latex_string(inset, buffer);
+
+ 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;
if (preview_wanted(params())) {
- ptr->setAbsFile(params_.filename.absFilename());
- string const snippet = latex_string(*this, ploader.buffer());
+ ptr->setAbsFile(params_.filename);
+ docstring const snippet = latex_string(*this, ploader.buffer());
ptr->addPreview(snippet, ploader);
}
}
data << "\\end_inset\n";
return data.str();
}
+
+} // namespace lyx
projects / lyx.git / blobdiff