#include "output.h"
#include "OutputParams.h"
#include "TexRow.h"
+#include "texstream.h"
#include "frontends/Application.h" // hexName
#include "support/ForkedCalls.h"
#include "support/lstrings.h"
-#include "support/bind.h"
#include "support/TempFile.h"
-#include <sstream>
+#include <atomic>
#include <fstream>
#include <iomanip>
+#include <memory>
+#include <mutex>
+#include <sstream>
+
+#include <QTimer>
using namespace std;
using namespace lyx::support;
}
-lyx::Converter const * setConverter(string const & from)
-{
- 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;
- if (from == to)
- continue;
-
- lyx::Converter const * ptr = lyx::theConverters().getConverter(from, to);
- if (ptr)
- return ptr;
- }
-
- // FIXME THREAD
- static bool first = true;
- if (first) {
- first = false;
- LYXERR0("PreviewLoader::startLoading()\n"
- << "No converter from \"" << from << "\" format has been defined.");
- }
- return 0;
-}
-
-
void setAscentFractions(vector<double> & ascent_fractions,
FileName const & metrics_file)
{
typedef InProgressProcesses::value_type InProgressProcess;
-} // namespace anon
-
+} // namespace
namespace lyx {
namespace graphics {
-class PreviewLoader::Impl : public boost::signals::trackable {
+class PreviewLoader::Impl {
public:
///
Impl(PreviewLoader & p, Buffer const & b);
/// \p wait whether to wait for the process to complete or, instead,
/// to do it in the background.
void startLoading(bool wait = false);
+ ///
+ void refreshPreviews();
/// Emit this signal when an image is ready for display.
- boost::signal<void(PreviewImage const &)> imageReady;
+ signals2::signal<void(PreviewImage const &)> imageReady;
Buffer const & buffer() const { return buffer_; }
+ lyx::Converter const * setConverter(string const & from);
+
private:
/// Called by the ForkedCall process that generated the bitmap files.
void finishedGenerating(pid_t, int);
/** cache_ allows easy retrieval of already-generated images
* using the LaTeX snippet as the identifier.
*/
- typedef shared_ptr<PreviewImage> PreviewImagePtr;
+ typedef s
td::shared_ptr<PreviewImage> PreviewImagePtr;
///
typedef map<string, PreviewImagePtr> Cache;
///
Buffer const & buffer_;
///
mutable int font_scaling_factor_;
+ ///
+ mutable int fg_color_;
+ ///
+ mutable int bg_color_;
+ ///
+ QTimer * delay_refresh_;
+ ///
+ bool finished_generating_;
/// We don't own this
static lyx::Converter const * pconverter_;
+
+ Trackable trackable_;
};
}
-boost::signals::connection PreviewLoader::connect(slot_type const & slot) const
+void PreviewLoader::refreshPreviews()
+{
+ pimpl_->refreshPreviews();
+}
+
+
+signals2::connection PreviewLoader::connect(slot const & slot) const
{
return pimpl_->imageReady.connect(slot);
}
}
}
-} // namespace anon
+} // namespace
namespace lyx {
namespace graphics {
PreviewLoader::Impl::Impl(PreviewLoader & p, Buffer const & b)
- : parent_(p), buffer_(b)
+ : parent_(p), buffer_(b), finished_generating_(true)
{
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);
+ } else {
+ fg_color_ = 0x0;
+ bg_color_ = 0xffffff;
+ }
if (!pconverter_)
pconverter_ = setConverter("lyxpreview");
+
+ delay_refresh_ = new QTimer(&parent_);
+ delay_refresh_->setSingleShot(true);
+ QObject::connect(delay_refresh_, SIGNAL(timeout()),
+ &parent_, SLOT(refreshPreviews()));
+}
+
+
+lyx::Converter const * PreviewLoader::Impl::setConverter(string const & from)
+{
+ typedef vector<string> FmtList;
+ FmtList const & loadableFormats = graphics::Cache::get().loadableFormats();
+ FmtList::const_iterator it = loadableFormats.begin();
+ FmtList::const_iterator const end = loadableFormats.end();
+
+ for (; it != end; ++it) {
+ string const to = *it;
+ if (from == to)
+ continue;
+
+ lyx::Converter const * ptr = lyx::theConverters().getConverter(from, to);
+ if (ptr)
+ return ptr;
+ }
+
+ // Show the error only once. This is thread-safe.
+ static nullptr_t no_conv = [&]{
+ LYXERR0("PreviewLoader::startLoading()\n"
+ << "No converter from \"" << from
+ << "\" format has been defined.");
+ return nullptr;
+ } ();
+
+ return no_conv;
}
PreviewLoader::Impl::~Impl()
{
+ delete delay_refresh_;
+
InProgressProcesses::iterator ipit = in_progress_.begin();
InProgressProcesses::iterator ipend = in_progress_.end();
PreviewLoader::Impl::preview(string const & latex_snippet) const
{
int fs = int(buffer_.fontScalingFactor());
- if (font_scaling_factor_ != fs) {
- // Refresh all previews on zoom changes
- font_scaling_factor_ = fs;
- Cache::const_iterator cit = cache_.begin();
- Cache::const_iterator cend = cache_.end();
- while (cit != cend) {
- string const snippet = (cit++)->first;
- parent_.remove(snippet);
- parent_.add(snippet);
- }
- parent_.startLoading(false);
+ 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);
+ }
+ if (font_scaling_factor_ != fs || fg_color_ != fg || bg_color_ != bg) {
+ // Schedule refresh of all previews on zoom or color changes.
+ // The previews are regenerated only after the zoom factor
+ // has not been changed for about 1 second.
+ fg_color_ = fg;
+ bg_color_ = bg;
+ delay_refresh_->start(1000);
}
+ // Don't try to access the cache until we are done.
+ if (delay_refresh_->isActive() || !finished_generating_)
+ return 0;
Cache::const_iterator it = cache_.find(latex_snippet);
return (it == cache_.end()) ? 0 : it->second.get();
}
+void PreviewLoader::Impl::refreshPreviews()
+{
+ font_scaling_factor_ = int(buffer_.fontScalingFactor());
+ // Reschedule refresh until the previous process completed.
+ if (!finished_generating_) {
+ delay_refresh_->start(1000);
+ return;
+ }
+ Cache::const_iterator cit = cache_.begin();
+ Cache::const_iterator cend = cache_.end();
+ while (cit != cend)
+ parent_.remove((cit++)->first);
+ finished_generating_ = false;
+ buffer_.updatePreviews();
+}
+
+
namespace {
class FindSnippet {
string const snippet_;
};
-} // namespace anon
+} // namespace
PreviewLoader::Status
PreviewLoader::Impl::status(string const & latex_snippet) const
string const & snippet_;
};
-} // namespace anon
+} // namespace
void PreviewLoader::Impl::remove(string const & latex_snippet)
return;
}
- TexRow texrow;
- otexstream os(of, texrow);
+ otexstream os(of);
OutputParams runparams(&enc);
LaTeXFeatures features(buffer_, buffer_.params(), runparams);
}
of << "\\batchmode\n";
+ // Set \jobname of previews to the document name (see bug 9627)
+ of << "\\def\\jobname{"
+ << from_utf8(changeExtension(buffer_.latexName(true), ""))
+ << "}\n";
+
LYXERR(Debug::LATEX, "Format = " << buffer_.params().getDefaultOutputFormat());
string latexparam = "";
- OutputParams::FLAVOR flavor = buffer_.params().getOutputFlavor();
+ bool docformat = !buffer_.params().default_output_format.empty()
+ && 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
+ ? buffer_.params().getOutputFlavor()
+ : OutputParams::LATEX;
if (buffer_.params().encoding().package() == Encoding::japanese) {
latexparam = " --latex=platex";
flavor = OutputParams::LATEX;
<< " " << 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);
}
cs << latexparam;
- if (buffer_.params().bibtex_command != "default")
- cs << " --bibtex=" << quoteName(buffer_.params().bibtex_command);
- else if (buffer_.params().encoding().package() == Encoding::japanese)
- cs << " --bibtex=" << quoteName(lyxrc.jbibtex_command);
- else
- cs << " --bibtex=" << quoteName(lyxrc.bibtex_command);
+ cs << " --bibtex=" << quoteName(buffer_.params().bibtexCommand());
if (buffer_.params().bufferFormat() == "lilypond-book")
cs << " --lilypond";
string const command = cs.str();
if (wait) {
- ForkedCall call(buffer_.filePath());
+ ForkedCall call(buffer_.filePath(), buffer_.layoutPos());
int ret = call.startScript(ForkedProcess::Wait, command);
- // FIXME THREAD
- static int fake = (2^20) + 1;
+ static atomic_int fake((2^20) + 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);
if (git == in_progress_.end()) {
lyxerr << "PreviewLoader::finishedGenerating(): unable to find "
"data for PID " << pid << endl;
+ finished_generating_ = true;
return;
}
LYXERR(Debug::GRAPHICS, "PreviewLoader::finishedInProgress("
<< retval << "): processing " << status
<< " for " << command);
- if (retval > 0)
+ if (retval > 0) {
+ in_progress_.erase(git);
+ finished_generating_ = true;
return;
+ }
// Read the metrics file, if it exists
vector<double> ascent_fractions(git->second.snippets.size());
double af = ascent_fractions[metrics_counter];
// Add the image to the cache only if it's actually present
- if (file.isReadableFile()) {
+ // and not empty (an empty image is signaled by af < 0)
+ if (af >= 0 && file.isReadableFile()) {
PreviewImagePtr ptr(new PreviewImage(parent_, snip, file, af));
cache_[snip] = ptr;
for (; nit != nend; ++nit) {
imageReady(*nit->get());
}
+ finished_generating_ = true;
}
} // namespace graphics
} // namespace lyx
+
+#include "moc_PreviewLoader.cpp"
projects / lyx.git / blobdiff