#include "PreviewLoader.h"
#include "PreviewImage.h"
+#include "GraphicsCache.h"
#include "buffer.h"
#include "converter.h"
#include "debug.h"
#include "format.h"
-#include "latexrunparams.h"
+#include "insetiterator.h"
+#include "LColor.h"
#include "lyxrc.h"
+#include "outputparams.h"
+#include "paragraph.h"
#include "frontends/lyx_gui.h" // hexname
+#include "insets/inset.h"
+
#include "support/filetools.h"
#include "support/forkedcall.h"
#include "support/forkedcontr.h"
#include "support/lstrings.h"
#include "support/lyxlib.h"
-#include "support/tostr.h"
+#include "support/convert.h"
#include <boost/bind.hpp>
-#include "support/std_sstream.h"
+#include <sstream>
#include <fstream>
#include <iomanip>
using std::find_if;
using std::make_pair;
+using boost::bind;
+
using std::ifstream;
using std::list;
using std::map;
using std::ostringstream;
using std::pair;
using std::vector;
+using std::string;
namespace {
void setAscentFractions(vector<double> & ascent_fractions,
string const & metrics_file);
-struct FindFirst {
+class FindFirst : public std::unary_function<StrPair, bool> {
+public:
FindFirst(string const & comp) : comp_(comp) {}
- bool operator()(StrPair const & sp)
+ bool operator()(StrPair const & sp) const
{
return sp.first == comp_;
}
/// Store info on a currently executing, forked process.
-struct InProgress {
+class InProgress {
+public:
///
InProgress() : pid(0) {}
///
namespace lyx {
namespace graphics {
-struct PreviewLoader::Impl : public boost::signals::trackable {
+class PreviewLoader::Impl : public boost::signals::trackable {
+public:
///
Impl(PreviewLoader & p, Buffer const & b);
/// Stop any InProgress items still executing.
void startLoading();
/// Emit this signal when an image is ready for display.
- boost::signal1<void, PreviewImage const &> imageReady;
+ boost::signal<void(PreviewImage const &)> imageReady;
Buffer const & buffer() const { return buffer_; }
namespace {
-struct IncrementedFileName {
+class IncrementedFileName {
+public:
IncrementedFileName(string const & to_format,
string const & filename_base)
: to_format_(to_format), base_(filename_base), counter_(1)
{
ostringstream os;
os << base_ << counter_++ << '.' << to_format_;
- string const file = STRCONV(os.str());
+ string const file = os.str();
return make_pair(snippet, file);
}
: parent_(p), buffer_(b), font_scaling_factor_(0.0)
{
font_scaling_factor_ = 0.01 * lyxrc.dpi * lyxrc.zoom *
- lyxrc.preview_scale_factor;
+ convert<double>(lyxrc.preview_scale_factor);
lyxerr[Debug::GRAPHICS] << "The font scaling factor is "
<< font_scaling_factor_ << endl;
namespace {
-struct FindSnippet {
+class FindSnippet : public std::unary_function<InProgressProcess, bool> {
+public:
FindSnippet(string const & s) : snippet_(s) {}
- bool operator()(InProgressProcess const & process)
+ bool operator()(InProgressProcess const & process) const
{
BitmapFile const & snippets = process.second.snippets;
- BitmapFile::const_iterator it = snippets.begin();
+ BitmapFile::const_iterator beg = snippets.begin();
BitmapFile::const_iterator end = snippets.end();
- it = find_if(it, end, FindFirst(snippet_));
- return it != end;
+ return find_if(beg, end, FindFirst(snippet_)) != end;
}
private:
- string const & snippet_;
+ string const snippet_;
};
} // namespace anon
namespace {
-struct EraseSnippet {
+class EraseSnippet {
+public:
EraseSnippet(string const & s) : snippet_(s) {}
void operator()(InProgressProcess & process)
{
std::for_each(ipit, ipend, EraseSnippet(latex_snippet));
- for (; ipit != ipend; ++ipit) {
+ while (ipit != ipend) {
InProgressProcesses::iterator curr = ipit++;
if (curr->second.snippets.empty())
in_progress_.erase(curr);
if (pending_.empty() || !pconverter_)
return;
+ // Only start the process off after the buffer is loaded from file.
+ if (!buffer_.fully_loaded())
+ return;
+
lyxerr[Debug::GRAPHICS] << "PreviewLoader::startLoading()" << endl;
// As used by the LaTeX file and by the resulting image files
- string directory = buffer_.tmppath;
- if (directory.empty())
- directory = buffer_.filePath();
+ string const directory = buffer_.temppath();
string const filename_base(unique_filename(directory));
string const latexfile = filename_base + ".tex";
ofstream of(latexfile.c_str());
+ if (!of) {
+ lyxerr[Debug::GRAPHICS] << "PreviewLoader::startLoading()\n"
+ << "Unable to create LaTeX file\n"
+ << latexfile << endl;
+ return;
+ }
of << "\\batchmode\n";
dumpPreamble(of);
of << "\n\\begin{document}\n";
// The conversion command.
ostringstream cs;
- cs << pconverter_->command << ' ' << latexfile << ' '
- << int(font_scaling_factor_) << ' ' << pconverter_->to;
+ cs << pconverter_->command << ' ' << pconverter_->to << ' '
+ << latexfile << ' ' << int(font_scaling_factor_) << ' '
+ << lyx_gui::hexname(LColor::preview) << ' '
+ << lyx_gui::hexname(LColor::background);
- string const command = "sh " + support::LibScriptSearch(STRCONV(cs.str()));
+ string const command = support::LibScriptSearch(cs.str());
// Initiate the conversion from LaTeX to bitmap images files.
support::Forkedcall::SignalTypePtr
convert_ptr(new support::Forkedcall::SignalType);
- convert_ptr->connect(
- boost::bind(&Impl::finishedGenerating, this, _1, _2));
+ convert_ptr->connect(bind(&Impl::finishedGenerating, this, _1, _2));
support::Forkedcall call;
int ret = call.startscript(command, convert_ptr);
if (ret != 0) {
lyxerr[Debug::GRAPHICS] << "PreviewLoader::startLoading()\n"
- << "Unable to start process \n"
+ << "Unable to start process\n"
<< command << endl;
return;
}
// Why on earth is Buffer::makeLaTeXFile a non-const method?
Buffer & tmp = const_cast<Buffer &>(buffer_);
// Dump the preamble only.
- LatexRunParams runparams;
- runparams.flavor = LatexRunParams::LATEX;
+ OutputParams runparams;
+ runparams.flavor = OutputParams::LATEX;
runparams.nice = true;
runparams.moving_arg = true;
runparams.free_spacing = true;
// FIXME! This is a HACK! The proper fix is to control the 'true'
// passed to WriteStream below:
// int InsetFormula::latex(Buffer const &, ostream & os,
- // LatexRunParams const & runparams) const
+ // OutputParams const & runparams) const
// {
// WriteStream wi(os, runparams.moving_arg, true);
// par_->write(wi);
<< "\n";
// Loop over the insets in the buffer and dump all the math-macros.
- Buffer::inset_iterator it = buffer_.inset_const_iterator_begin();
- Buffer::inset_iterator end = buffer_.inset_const_iterator_end();
+ InsetBase & inset = buffer_.inset();
+ InsetIterator it = inset_iterator_begin(inset);
+ InsetIterator const end = inset_iterator_end(inset);
for (; it != end; ++it)
- if (it->lyxCode() == InsetOld::MATHMACRO_CODE)
+ if (it->lyxCode() == InsetBase::MATHMACRO_CODE)
it->latex(buffer_, os, runparams);
// All equation lables appear as "(#)" + preview.sty's rendering of
// Use the preview style file to ensure that each snippet appears on a
// fresh page.
os << "\n"
- << "\\usepackage[active,delayed,dvips,tightpage,showlabels,lyx]{preview}\n"
+ << "\\usepackage[active,delayed,dvips,showlabels,lyx]{preview}\n"
<< "\n";
-
- // This piece of PostScript magic ensures that the foreground and
- // background colors are the same as the LyX screen.
- string fg = lyx_gui::hexname(LColor::preview);
- if (fg.empty()) fg = "000000";
-
- string bg = lyx_gui::hexname(LColor::background);
- if (bg.empty()) bg = "ffffff";
-
- os << "\\AtBeginDocument{\\AtBeginDvi{%\n"
- << "\\special{!userdict begin/bop-hook{//bop-hook exec\n"
- << '<' << fg << bg << ">{255 div}forall setrgbcolor\n"
- << "clippath fill setrgbcolor}bind def end}}}\n";
}
string const unique_filename(string const bufferpath)
{
static int theCounter = 0;
- string const filename = tostr(theCounter++) + "lyxpreview";
+ string const filename = convert<string>(theCounter++) + "lyxpreview";
return support::AddName(bufferpath, filename);
}
{
string const from = "lyxpreview";
- Formats::FormatList::const_iterator it = formats.begin();
- Formats::FormatList::const_iterator end = formats.end();
+ typedef vector<string> FmtList;
+ typedef lyx::graphics::Cache GCache;
+ FmtList const loadableFormats = GCache::get().loadableFormats();
+ FmtList::const_iterator it = loadableFormats.begin();
+ FmtList::const_iterator const end = loadableFormats.end();
for (; it != end; ++it) {
- string const to = it->name();
+ string const to = *it;
if (from == to)
continue;
bool error = false;
- // Tightpage dimensions affect all subsequent dimensions
- int tp_ascent;
- int tp_descent;
+ int snippet_counter = 1;
+ while (!in.eof() && it != end) {
+ string snippet;
+ int id;
+ double ascent_fraction;
- int snippet_counter = 0;
- while (!in.eof()) {
- // Expecting lines of the form
- // Preview: Tightpage tp_bl_x tp_bl_y tp_tr_x tp_tr_y
- // Preview: Snippet id ascent descent width
- string preview;
- string type;
- in >> preview >> type;
+ in >> snippet >> id >> ascent_fraction;
if (!in.good())
// eof after all
break;
- error = preview != "Preview:"
- || (type != "Tightpage" && type != "Snippet");
+ error = snippet != "Snippet";
if (error)
break;
- if (type == "Tightpage") {
- int dummy;
- in >> dummy >> tp_descent >> dummy >> tp_ascent;
-
- error = !in.good();
- if (error)
- break;
-
- } else {
- int dummy;
- int snippet_id;
- int ascent;
- int descent;
- in >> snippet_id >> ascent >> descent >> dummy;
-
- error = !in.good() || ++snippet_counter != snippet_id;
- if (error)
- break;
-
- double const a = ascent + tp_ascent;
- double const d = descent - tp_descent;
+ error = id != snippet_counter;
+ if (error)
+ break;
- if (!support::float_equal(a + d, 0, 0.1))
- *it = a / (a + d);
+ *it = ascent_fraction;
- if (++it == end)
- break;
- }
+ ++snippet_counter;
+ ++it;
}
if (error) {
projects / lyx.git / blobdiff