#include "Converter.h"
#include "Encoding.h"
#include "Format.h"
-#include "InsetIterator.h"
#include "LaTeXFeatures.h"
#include "LyXRC.h"
#include "output.h"
#include "frontends/Application.h" // hexName
-#include "insets/Inset.h"
-
#include "support/convert.h"
#include "support/debug.h"
#include "support/FileName.h"
#include "support/ForkedCalls.h"
#include "support/lstrings.h"
-#include "support/bind.h"
#include "support/TempFile.h"
#include <atomic>
}
-class FindFirst
+std::function <bool (SnippetPair const &)> FindFirst(string const & comp)
{
-public:
- FindFirst(string const & comp) : comp_(comp) {}
- bool operator()(SnippetPair const & sp) const { return sp.first == comp_; }
-private:
- string const comp_;
-};
+ return [&comp](SnippetPair const & sp) { return sp.first == comp; };
+}
/// Store info on a currently executing, forked process.
/// Remove any files left lying around and kill the forked process.
void stop() const;
- ///
- pid_t pid;
///
string command;
///
FileName metrics_file;
///
BitmapFile snippets;
+ ///
+ pid_t pid;
};
typedef map<pid_t, InProgress> InProgressProcesses;
typedef InProgressProcesses::value_type InProgressProcess;
-} // namespace anon
-
+} // namespace
namespace lyx {
namespace graphics {
-class PreviewLoader::Impl : public boost::signals2::trackable {
+class PreviewLoader::Impl {
public:
///
Impl(PreviewLoader & p, Buffer const & b);
void refreshPreviews();
/// Emit this signal when an image is ready for display.
- boost::signals2::signal<void(PreviewImage const &)> imageReady;
+ signals2::signal<void(PreviewImage const &)> imageReady;
Buffer const & buffer() const { return buffer_; }
/// Called by the ForkedCall process that generated the bitmap files.
void finishedGenerating(pid_t, int);
///
- void dumpPreamble(otexstream &, OutputParams::FLAVOR) const;
+ void dumpPreamble(otexstream &, FLAVOR) const;
///
void dumpData(odocstream &, BitmapFile const &) const;
/** in_progress_ stores all forked processes so that we can proceed
* thereafter.
- The map uses the conversion commands as its identifiers.
*/
InProgressProcesses in_progress_;
///
QTimer * delay_refresh_;
///
+ Trackable trackable_;
+ ///
bool finished_generating_;
/// We don't own this
static lyx::Converter const * pconverter_;
+
};
}
-boost::signals2::connection PreviewLoader::connect(slot_type const & slot) const
+signals2::connection PreviewLoader::connect(slot const & slot) const
{
return pimpl_->imageReady.connect(slot);
}
{
ostringstream os;
os << base_ << counter_++ << '.' << to_format_;
- string const file = os.str();
-
- return make_pair(snippet, FileName(file));
+ string const file_name = os.str();
+ return make_pair(snippet, FileName(file_name));
}
-
+
private:
string const & to_format_;
string const & base_;
InProgress::InProgress(string const & filename_base,
PendingSnippets const & pending,
string const & to_format)
- : pid(0),
- metrics_file(filename_base + ".metrics"),
- snippets(pending.size())
+ : metrics_file(filename_base + ".metrics"),
+ snippets(pending.size()), pid(0)
{
PendingSnippets::const_iterator pit = pending.begin();
PendingSnippets::const_iterator pend = pending.end();
}
}
-} // namespace anon
+} // namespace
namespace lyx {
{
font_scaling_factor_ = int(buffer_.fontScalingFactor());
if (theApp()) {
- fg_color_ = strtol(theApp()->hexName(foregroundColor()).c_str(), 0, 16);
- bg_color_ = strtol(theApp()->hexName(backgroundColor()).c_str(), 0, 16);
+ fg_color_ = convert(theApp()->hexName(foregroundColor()).c_str(), 16);
+ bg_color_ = convert(theApp()->hexName(backgroundColor()).c_str(), 16);
} else {
fg_color_ = 0x0;
bg_color_ = 0xffffff;
int fg = 0x0;
int bg = 0xffffff;
if (theApp()) {
- fg = strtol(theApp()->hexName(foregroundColor()).c_str(), 0, 16);
- bg = strtol(theApp()->hexName(backgroundColor()).c_str(), 0, 16);
+ fg = convert(theApp()->hexName(foregroundColor()).c_str(), 16);
+ bg = convert(theApp()->hexName(backgroundColor()).c_str(), 16);
}
if (font_scaling_factor_ != fs || fg_color_ != fg || bg_color_ != bg) {
// Schedule refresh of all previews on zoom or color changes.
}
// Don't try to access the cache until we are done.
if (delay_refresh_->isActive() || !finished_generating_)
- return 0;
+ return nullptr;
+
Cache::const_iterator it = cache_.find(latex_snippet);
- return (it == cache_.end()) ? 0 : it->second.get();
+ return (it == cache_.end()) ? nullptr : it->second.get();
}
namespace {
-class FindSnippet {
-public:
- FindSnippet(string const & s) : snippet_(s) {}
- bool operator()(InProgressProcess const & process) const
- {
+std::function<bool (InProgressProcess const &)> FindSnippet(string const & s)
+{
+ return [&s](InProgressProcess const & process) {
BitmapFile const & snippets = process.second.snippets;
BitmapFile::const_iterator beg = snippets.begin();
BitmapFile::const_iterator end = snippets.end();
- return find_if(beg, end, FindFirst(snippet_)) != end;
- }
-
-private:
- string const snippet_;
-};
+ return find_if(beg, end, FindFirst(s)) != end;
+ };
+}
-} // namespace anon
+} // namespace
PreviewLoader::Status
PreviewLoader::Impl::status(string const & latex_snippet) const
namespace {
-class EraseSnippet {
-public:
- EraseSnippet(string const & s) : snippet_(s) {}
- void operator()(InProgressProcess & process)
- {
+std::function<void (InProgressProcess &)> EraseSnippet(string const & s)
+{
+ return [&s](InProgressProcess & process) {
BitmapFile & snippets = process.second.snippets;
BitmapFile::iterator it = snippets.begin();
BitmapFile::iterator end = snippets.end();
- it = find_if(it, end, FindFirst(snippet_));
+ it = find_if(it, end, FindFirst(s));
if (it != end)
snippets.erase(it, it+1);
- }
-
-private:
- string const & snippet_;
-};
+ };
+}
-} // namespace anon
+} // namespace
void PreviewLoader::Impl::remove(string const & latex_snippet)
// Set \jobname of previews to the document name (see bug 9627)
of << "\\def\\jobname{"
- << from_utf8(changeExtension(buffer_.latexName(true), ""))
+ << from_utf8(changeExtension(buffer_.latexName(), ""))
<< "}\n";
LYXERR(Debug::LATEX, "Format = " << buffer_.params().getDefaultOutputFormat());
&& buffer_.params().default_output_format != "default";
// Use LATEX flavor if the document does not specify a specific
// output format (see bug 9371).
- OutputParams::FLAVOR flavor = docformat
+ FLAVOR flavor = docformat
? buffer_.params().getOutputFlavor()
- : OutputParams::LATEX;
+ : FLAVOR::LATEX;
if (buffer_.params().encoding().package() == Encoding::japanese) {
latexparam = " --latex=platex";
- flavor = OutputParams::LATEX;
+ flavor = FLAVOR::LATEX;
}
else if (buffer_.params().useNonTeXFonts) {
- if (flavor == OutputParams::LUATEX)
+ if (flavor == FLAVOR::LUATEX)
latexparam = " --latex=lualatex";
else {
- flavor = OutputParams::XETEX;
+ flavor = FLAVOR::XETEX;
latexparam = " --latex=xelatex";
}
}
else {
switch (flavor) {
- case OutputParams::PDFLATEX:
+ case FLAVOR::PDFLATEX:
latexparam = " --latex=pdflatex";
break;
- case OutputParams::XETEX:
+ case FLAVOR::XETEX:
latexparam = " --latex=xelatex";
break;
- case OutputParams::LUATEX:
+ case FLAVOR::LUATEX:
latexparam = " --latex=lualatex";
break;
- case OutputParams::DVILUATEX:
+ case FLAVOR::DVILUATEX:
latexparam = " --latex=dvilualatex";
break;
default:
- flavor = OutputParams::LATEX;
+ flavor = FLAVOR::LATEX;
}
}
dumpPreamble(os, flavor);
// handle inputenc etc.
- // I think, this is already hadled by dumpPreamble(): Kornel
+ // I think this is already handled by dumpPreamble(): Kornel
// buffer_.params().writeEncodingPreamble(os, features);
of << "\n\\begin{document}\n";
dumpData(of, inprogress.snippets);
<< " " << quoteName(latexfile.toFilesystemEncoding())
<< " --dpi " << font_scaling_factor_;
- // FIXME XHTML
+ // FIXME XHTML
// The colors should be customizable.
if (!buffer_.isExporting()) {
ColorCode const fg = PreviewLoader::foregroundColor();
ColorCode const bg = PreviewLoader::backgroundColor();
- cs << " --fg " << theApp()->hexName(fg)
+ cs << " --fg " << theApp()->hexName(fg)
<< " --bg " << theApp()->hexName(bg);
}
if (wait) {
ForkedCall call(buffer_.filePath(), buffer_.layoutPos());
int ret = call.startScript(ForkedProcess::Wait, command);
- static atomic_int fake((2^20) + 1);
+ // PID_MAX_LIMIT is 2^22 so we start one after that
+ static atomic_int fake((1 << 22) + 1);
int pid = fake++;
inprogress.pid = pid;
inprogress.command = command;
}
// Initiate the conversion from LaTeX to bitmap images files.
- ForkedCall::SignalTypePtr
- convert_ptr(new ForkedCall::SignalType);
- convert_ptr->connect(bind(&Impl::finishedGenerating, this, _1, _2));
+ ForkedCall::sigPtr convert_ptr = make_shared<ForkedCall::sig>();
+ convert_ptr->connect(ForkedProcess::slot([this](pid_t pid, int retval){
+ finishedGenerating(pid, retval);
+ }).track_foreign(trackable_.p()));
ForkedCall call(buffer_.filePath());
int ret = call.startScript(command, convert_ptr);
list<PreviewImagePtr> newimages;
- int metrics_counter = 0;
+ size_t metrics_counter = 0;
for (; it != end; ++it, ++metrics_counter) {
string const & snip = it->first;
FileName const & file = it->second;
}
-void PreviewLoader::Impl::dumpPreamble(otexstream & os, OutputParams::FLAVOR flavor) const
+void PreviewLoader::Impl::dumpPreamble(otexstream & os, FLAVOR flavor) const
{
// Dump the preamble only.
- LYXERR(Debug::LATEX, "dumpPreamble, flavor == " << flavor);
+ LYXERR(Debug::LATEX, "dumpPreamble, flavor == " << static_cast<int>(flavor));
OutputParams runparams(&buffer_.params().encoding());
runparams.flavor = flavor;
runparams.nice = true;
projects / lyx.git / blobdiff