src/graphics/PreviewLoader.cpp

   1 /**
   2  * \file PreviewLoader.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Angus Leeming
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "PreviewLoader.h"
  14 #include "PreviewImage.h"
  15 #include "GraphicsCache.h"
  16
  17 #include "Buffer.h"
  18 #include "BufferParams.h"
  19 #include "Converter.h"
  20 #include "Encoding.h"
  21 #include "Format.h"
  22 #include "InsetIterator.h"
  23 #include "LaTeXFeatures.h"
  24 #include "LyXRC.h"
  25 #include "output.h"
  26 #include "OutputParams.h"
  27 #include "TexRow.h"
  28
  29 #include "frontends/Application.h" // hexName
  30
  31 #include "insets/Inset.h"
  32
  33 #include "support/convert.h"
  34 #include "support/debug.h"
  35 #include "support/FileName.h"
  36 #include "support/filetools.h"
  37 #include "support/ForkedCalls.h"
  38 #include "support/lstrings.h"
  39
  40 #include "support/bind.h"
  41 #include "support/TempFile.h"
  42
  43 #include <sstream>
  44 #include <fstream>
  45 #include <iomanip>
  46
  47 using namespace std;
  48 using namespace lyx::support;
  49
  50
  51
  52 namespace {
  53
  54 typedef pair<string, FileName> SnippetPair;
  55
  56 // A list of all snippets to be converted to previews
  57 typedef list<string> PendingSnippets;
  58
  59 // Each item in the vector is a pair<snippet, image file name>.
  60 typedef vector<SnippetPair> BitmapFile;
  61
  62
  63 FileName const unique_tex_filename(FileName const & bufferpath)
  64 {
  65         TempFile tempfile(bufferpath, "lyxpreviewXXXXXX.tex");
  66         tempfile.setAutoRemove(false);
  67         return tempfile.name();
  68 }
  69
  70
  71 lyx::Converter const * setConverter(string const & from)
  72 {
  73         typedef vector<string> FmtList;
  74         typedef lyx::graphics::Cache GCache;
  75         FmtList const & loadableFormats = GCache::get().loadableFormats();
  76         FmtList::const_iterator it = loadableFormats.begin();
  77         FmtList::const_iterator const end = loadableFormats.end();
  78
  79         for (; it != end; ++it) {
  80                 string const to = *it;
  81                 if (from == to)
  82                         continue;
  83
  84                 lyx::Converter const * ptr = lyx::theConverters().getConverter(from, to);
  85                 if (ptr)
  86                         return ptr;
  87         }
  88
  89         // FIXME THREAD
  90         static bool first = true;
  91         if (first) {
  92                 first = false;
  93                 LYXERR0("PreviewLoader::startLoading()\n"
  94                         << "No converter from \"" << from << "\" format has been defined.");
  95         }
  96         return 0;
  97 }
  98
  99
 100 void setAscentFractions(vector<double> & ascent_fractions,
 101                         FileName const & metrics_file)
 102 {
 103         // If all else fails, then the images will have equal ascents and
 104         // descents.
 105         vector<double>::iterator it  = ascent_fractions.begin();
 106         vector<double>::iterator end = ascent_fractions.end();
 107         fill(it, end, 0.5);
 108
 109         ifstream in(metrics_file.toFilesystemEncoding().c_str());
 110         if (!in.good()) {
 111                 LYXERR(lyx::Debug::GRAPHICS, "setAscentFractions(" << metrics_file << ")\n"
 112                         << "Unable to open file!");
 113                 return;
 114         }
 115
 116         bool error = false;
 117
 118         int snippet_counter = 1;
 119         while (!in.eof() && it != end) {
 120                 string snippet;
 121                 int id;
 122                 double ascent_fraction;
 123
 124                 in >> snippet >> id >> ascent_fraction;
 125
 126                 if (!in.good())
 127                         // eof after all
 128                         break;
 129
 130                 error = snippet != "Snippet";
 131                 if (error)
 132                         break;
 133
 134                 error = id != snippet_counter;
 135                 if (error)
 136                         break;
 137
 138                 *it = ascent_fraction;
 139
 140                 ++snippet_counter;
 141                 ++it;
 142         }
 143
 144         if (error) {
 145                 LYXERR(lyx::Debug::GRAPHICS, "setAscentFractions(" << metrics_file << ")\n"
 146                         << "Error reading file!\n");
 147         }
 148 }
 149
 150
 151 class FindFirst
 152 {
 153 public:
 154         FindFirst(string const & comp) : comp_(comp) {}
 155         bool operator()(SnippetPair const & sp) const { return sp.first == comp_; }
 156 private:
 157         string const comp_;
 158 };
 159
 160
 161 /// Store info on a currently executing, forked process.
 162 class InProgress {
 163 public:
 164         ///
 165         InProgress() : pid(0) {}
 166         ///
 167         InProgress(string const & filename_base,
 168                    PendingSnippets const & pending,
 169                    string const & to_format);
 170         /// Remove any files left lying around and kill the forked process.
 171         void stop() const;
 172
 173         ///
 174         pid_t pid;
 175         ///
 176         string command;
 177         ///
 178         FileName metrics_file;
 179         ///
 180         BitmapFile snippets;
 181 };
 182
 183 typedef map<pid_t, InProgress>  InProgressProcesses;
 184
 185 typedef InProgressProcesses::value_type InProgressProcess;
 186
 187 } // namespace anon
 188
 189
 190
 191 namespace lyx {
 192 namespace graphics {
 193
 194 class PreviewLoader::Impl : public boost::signals::trackable {
 195 public:
 196         ///
 197         Impl(PreviewLoader & p, Buffer const & b);
 198         /// Stop any InProgress items still executing.
 199         ~Impl();
 200         ///
 201         PreviewImage const * preview(string const & latex_snippet) const;
 202         ///
 203         PreviewLoader::Status status(string const & latex_snippet) const;
 204         ///
 205         void add(string const & latex_snippet);
 206         ///
 207         void remove(string const & latex_snippet);
 208         /// \p wait whether to wait for the process to complete or, instead,
 209         /// to do it in the background.
 210         void startLoading(bool wait = false);
 211
 212         /// Emit this signal when an image is ready for display.
 213         boost::signal<void(PreviewImage const &)> imageReady;
 214
 215         Buffer const & buffer() const { return buffer_; }
 216
 217 private:
 218         /// Called by the ForkedCall process that generated the bitmap files.
 219         void finishedGenerating(pid_t, int);
 220         ///
 221         void dumpPreamble(otexstream &) const;
 222         ///
 223         void dumpData(odocstream &, BitmapFile const &) const;
 224
 225         /** cache_ allows easy retrieval of already-generated images
 226          *  using the LaTeX snippet as the identifier.
 227          */
 228         typedef shared_ptr<PreviewImage> PreviewImagePtr;
 229         ///
 230         typedef map<string, PreviewImagePtr> Cache;
 231         ///
 232         Cache cache_;
 233
 234         /** pending_ stores the LaTeX snippets in anticipation of them being
 235          *  sent to the converter.
 236          */
 237         PendingSnippets pending_;
 238
 239         /** in_progress_ stores all forked processes so that we can proceed
 240          *  thereafter.
 241             The map uses the conversion commands as its identifiers.
 242          */
 243         InProgressProcesses in_progress_;
 244
 245         ///
 246         PreviewLoader & parent_;
 247         ///
 248         Buffer const & buffer_;
 249
 250         /// We don't own this
 251         static lyx::Converter const * pconverter_;
 252 };
 253
 254
 255 lyx::Converter const * PreviewLoader::Impl::pconverter_;
 256
 257
 258 //
 259 // The public interface, defined in PreviewLoader.h
 260 //
 261
 262 PreviewLoader::PreviewLoader(Buffer const & b)
 263         : pimpl_(new Impl(*this, b))
 264 {}
 265
 266
 267 PreviewLoader::~PreviewLoader()
 268 {
 269         delete pimpl_;
 270 }
 271
 272
 273 PreviewImage const * PreviewLoader::preview(string const & latex_snippet) const
 274 {
 275         return pimpl_->preview(latex_snippet);
 276 }
 277
 278
 279 PreviewLoader::Status PreviewLoader::status(string const & latex_snippet) const
 280 {
 281         return pimpl_->status(latex_snippet);
 282 }
 283
 284
 285 void PreviewLoader::add(string const & latex_snippet) const
 286 {
 287         pimpl_->add(latex_snippet);
 288 }
 289
 290
 291 void PreviewLoader::remove(string const & latex_snippet) const
 292 {
 293         pimpl_->remove(latex_snippet);
 294 }
 295
 296
 297 void PreviewLoader::startLoading(bool wait) const
 298 {
 299         pimpl_->startLoading(wait);
 300 }
 301
 302
 303 boost::signals::connection PreviewLoader::connect(slot_type const & slot) const
 304 {
 305         return pimpl_->imageReady.connect(slot);
 306 }
 307
 308
 309 void PreviewLoader::emitSignal(PreviewImage const & pimage) const
 310 {
 311         pimpl_->imageReady(pimage);
 312 }
 313
 314
 315 Buffer const & PreviewLoader::buffer() const
 316 {
 317         return pimpl_->buffer();
 318 }
 319
 320 } // namespace graphics
 321 } // namespace lyx
 322
 323
 324 // The details of the Impl
 325 // =======================
 326
 327 namespace {
 328
 329 class IncrementedFileName {
 330 public:
 331         IncrementedFileName(string const & to_format,
 332                             string const & filename_base)
 333                 : to_format_(to_format), base_(filename_base), counter_(1)
 334         {}
 335
 336         SnippetPair const operator()(string const & snippet)
 337         {
 338                 ostringstream os;
 339                 os << base_ << counter_++ << '.' << to_format_;
 340                 string const file = os.str();
 341
 342                 return make_pair(snippet, FileName(file));
 343         }
 344
 345 private:
 346         string const & to_format_;
 347         string const & base_;
 348         int counter_;
 349 };
 350
 351
 352 InProgress::InProgress(string const & filename_base,
 353                        PendingSnippets const & pending,
 354                        string const & to_format)
 355         : pid(0),
 356           metrics_file(filename_base + ".metrics"),
 357           snippets(pending.size())
 358 {
 359         PendingSnippets::const_iterator pit  = pending.begin();
 360         PendingSnippets::const_iterator pend = pending.end();
 361         BitmapFile::iterator sit = snippets.begin();
 362
 363         transform(pit, pend, sit,
 364                        IncrementedFileName(to_format, filename_base));
 365 }
 366
 367
 368 void InProgress::stop() const
 369 {
 370         if (pid)
 371                 ForkedCallsController::kill(pid, 0);
 372
 373         if (!metrics_file.empty())
 374                 metrics_file.removeFile();
 375
 376         BitmapFile::const_iterator vit  = snippets.begin();
 377         BitmapFile::const_iterator vend = snippets.end();
 378         for (; vit != vend; ++vit) {
 379                 if (!vit->second.empty())
 380                         vit->second.removeFile();
 381         }
 382 }
 383
 384 } // namespace anon
 385
 386
 387 namespace lyx {
 388 namespace graphics {
 389
 390 PreviewLoader::Impl::Impl(PreviewLoader & p, Buffer const & b)
 391         : parent_(p), buffer_(b)
 392 {
 393         if (!pconverter_)
 394                 pconverter_ = setConverter("lyxpreview");
 395 }
 396
 397
 398 PreviewLoader::Impl::~Impl()
 399 {
 400         InProgressProcesses::iterator ipit  = in_progress_.begin();
 401         InProgressProcesses::iterator ipend = in_progress_.end();
 402
 403         for (; ipit != ipend; ++ipit)
 404                 ipit->second.stop();
 405 }
 406
 407
 408 PreviewImage const *
 409 PreviewLoader::Impl::preview(string const & latex_snippet) const
 410 {
 411         Cache::const_iterator it = cache_.find(latex_snippet);
 412         return (it == cache_.end()) ? 0 : it->second.get();
 413 }
 414
 415
 416 namespace {
 417
 418 class FindSnippet {
 419 public:
 420         FindSnippet(string const & s) : snippet_(s) {}
 421         bool operator()(InProgressProcess const & process) const
 422         {
 423                 BitmapFile const & snippets = process.second.snippets;
 424                 BitmapFile::const_iterator beg  = snippets.begin();
 425                 BitmapFile::const_iterator end = snippets.end();
 426                 return find_if(beg, end, FindFirst(snippet_)) != end;
 427         }
 428
 429 private:
 430         string const snippet_;
 431 };
 432
 433 } // namespace anon
 434
 435 PreviewLoader::Status
 436 PreviewLoader::Impl::status(string const & latex_snippet) const
 437 {
 438         Cache::const_iterator cit = cache_.find(latex_snippet);
 439         if (cit != cache_.end())
 440                 return Ready;
 441
 442         PendingSnippets::const_iterator pit  = pending_.begin();
 443         PendingSnippets::const_iterator pend = pending_.end();
 444
 445         pit = find(pit, pend, latex_snippet);
 446         if (pit != pend)
 447                 return InQueue;
 448
 449         InProgressProcesses::const_iterator ipit  = in_progress_.begin();
 450         InProgressProcesses::const_iterator ipend = in_progress_.end();
 451
 452         ipit = find_if(ipit, ipend, FindSnippet(latex_snippet));
 453         if (ipit != ipend)
 454                 return Processing;
 455
 456         return NotFound;
 457 }
 458
 459
 460 void PreviewLoader::Impl::add(string const & latex_snippet)
 461 {
 462         if (!pconverter_ || status(latex_snippet) != NotFound)
 463                 return;
 464
 465         string const snippet = trim(latex_snippet);
 466         if (snippet.empty())
 467                 return;
 468
 469         LYXERR(Debug::GRAPHICS, "adding snippet:\n" << snippet);
 470
 471         pending_.push_back(snippet);
 472 }
 473
 474
 475 namespace {
 476
 477 class EraseSnippet {
 478 public:
 479         EraseSnippet(string const & s) : snippet_(s) {}
 480         void operator()(InProgressProcess & process)
 481         {
 482                 BitmapFile & snippets = process.second.snippets;
 483                 BitmapFile::iterator it  = snippets.begin();
 484                 BitmapFile::iterator end = snippets.end();
 485
 486                 it = find_if(it, end, FindFirst(snippet_));
 487                 if (it != end)
 488                         snippets.erase(it, it+1);
 489         }
 490
 491 private:
 492         string const & snippet_;
 493 };
 494
 495 } // namespace anon
 496
 497
 498 void PreviewLoader::Impl::remove(string const & latex_snippet)
 499 {
 500         Cache::iterator cit = cache_.find(latex_snippet);
 501         if (cit != cache_.end())
 502                 cache_.erase(cit);
 503
 504         PendingSnippets::iterator pit  = pending_.begin();
 505         PendingSnippets::iterator pend = pending_.end();
 506
 507         pending_.erase(std::remove(pit, pend, latex_snippet), pend);
 508
 509         InProgressProcesses::iterator ipit  = in_progress_.begin();
 510         InProgressProcesses::iterator ipend = in_progress_.end();
 511
 512         for_each(ipit, ipend, EraseSnippet(latex_snippet));
 513
 514         while (ipit != ipend) {
 515                 InProgressProcesses::iterator curr = ipit++;
 516                 if (curr->second.snippets.empty())
 517                         in_progress_.erase(curr);
 518         }
 519 }
 520
 521
 522 void PreviewLoader::Impl::startLoading(bool wait)
 523 {
 524         if (pending_.empty() || !pconverter_)
 525                 return;
 526
 527         // Only start the process off after the buffer is loaded from file.
 528         if (!buffer_.isFullyLoaded())
 529                 return;
 530
 531         LYXERR(Debug::GRAPHICS, "PreviewLoader::startLoading()");
 532
 533         // As used by the LaTeX file and by the resulting image files
 534         FileName const directory(buffer_.temppath());
 535
 536         FileName const latexfile = unique_tex_filename(directory);
 537         string const filename_base = removeExtension(latexfile.absFileName());
 538
 539         // Create an InProgress instance to place in the map of all
 540         // such processes if it starts correctly.
 541         InProgress inprogress(filename_base, pending_, pconverter_->to());
 542
 543         // clear pending_, so we're ready to start afresh.
 544         pending_.clear();
 545
 546         // Output the LaTeX file.
 547         // we use the encoding of the buffer
 548         Encoding const & enc = buffer_.params().encoding();
 549         ofdocstream of;
 550         try { of.reset(enc.iconvName()); }
 551         catch (iconv_codecvt_facet_exception const & e) {
 552                 LYXERR0("Caught iconv exception: " << e.what()
 553                         << "\nUnable to create LaTeX file: " << latexfile);
 554                 return;
 555         }
 556
 557         TexRow texrow;
 558         otexstream os(of, texrow);
 559         OutputParams runparams(&enc);
 560         LaTeXFeatures features(buffer_, buffer_.params(), runparams);
 561
 562         if (!openFileWrite(of, latexfile))
 563                 return;
 564
 565         if (!of) {
 566                 LYXERR(Debug::GRAPHICS, "PreviewLoader::startLoading()\n"
 567                                         << "Unable to create LaTeX file\n" << latexfile);
 568                 return;
 569         }
 570         of << "\\batchmode\n";
 571         dumpPreamble(os);
 572         // handle inputenc etc.
 573         buffer_.params().writeEncodingPreamble(os, features);
 574         of << "\n\\begin{document}\n";
 575         dumpData(of, inprogress.snippets);
 576         of << "\n\\end{document}\n";
 577         of.close();
 578         if (of.fail()) {
 579                 LYXERR(Debug::GRAPHICS, "PreviewLoader::startLoading()\n"
 580                                          << "File was not closed properly.");
 581                 return;
 582         }
 583
 584         double const font_scaling_factor = buffer_.fontScalingFactor();
 585
 586         // The conversion command.
 587         ostringstream cs;
 588         cs << pconverter_->command()
 589            << " " << quoteName(latexfile.toFilesystemEncoding())
 590            << " --dpi " << int(font_scaling_factor);
 591
 592         // FIXME XHTML
 593         // The colors should be customizable.
 594         if (!buffer_.isExporting()) {
 595                 ColorCode const fg = PreviewLoader::foregroundColor();
 596                 ColorCode const bg = PreviewLoader::backgroundColor();
 597                 cs << " --fg " << theApp()->hexName(fg)
 598                    << " --bg " << theApp()->hexName(bg);
 599         }
 600
 601         // FIXME what about LuaTeX?
 602         if (buffer_.params().useNonTeXFonts)
 603                 cs << " --latex=xelatex";
 604         if (buffer_.params().encoding().package() == Encoding::japanese)
 605                 cs << " --latex=platex";
 606         if (buffer_.params().bibtex_command != "default")
 607                 cs << " --bibtex=" << quoteName(buffer_.params().bibtex_command);
 608         else if (buffer_.params().encoding().package() == Encoding::japanese)
 609                 cs << " --bibtex=" << quoteName(lyxrc.jbibtex_command);
 610         else
 611                 cs << " --bibtex=" << quoteName(lyxrc.bibtex_command);
 612         if (buffer_.params().bufferFormat() == "lilypond-book")
 613                 cs << " --lilypond";
 614
 615         string const command = cs.str();
 616
 617         if (wait) {
 618                 ForkedCall call(buffer_.filePath());
 619                 int ret = call.startScript(ForkedProcess::Wait, command);
 620                 // FIXME THREAD
 621                 static int fake = (2^20) + 1;
 622                 int pid = fake++;
 623                 inprogress.pid = pid;
 624                 inprogress.command = command;
 625                 in_progress_[pid] = inprogress;
 626                 finishedGenerating(pid, ret);
 627                 return;
 628         }
 629
 630         // Initiate the conversion from LaTeX to bitmap images files.
 631         ForkedCall::SignalTypePtr
 632                 convert_ptr(new ForkedCall::SignalType);
 633         convert_ptr->connect(bind(&Impl::finishedGenerating, this, _1, _2));
 634
 635         ForkedCall call(buffer_.filePath());
 636         int ret = call.startScript(command, convert_ptr);
 637
 638         if (ret != 0) {
 639                 LYXERR(Debug::GRAPHICS, "PreviewLoader::startLoading()\n"
 640                                         << "Unable to start process\n" << command);
 641                 return;
 642         }
 643
 644         // Store the generation process in a list of all such processes
 645         inprogress.pid = call.pid();
 646         inprogress.command = command;
 647         in_progress_[inprogress.pid] = inprogress;
 648 }
 649
 650
 651 double PreviewLoader::displayPixelRatio() const
 652 {
 653         return buffer().params().display_pixel_ratio;
 654 }
 655
 656 void PreviewLoader::Impl::finishedGenerating(pid_t pid, int retval)
 657 {
 658         // Paranoia check!
 659         InProgressProcesses::iterator git = in_progress_.find(pid);
 660         if (git == in_progress_.end()) {
 661                 lyxerr << "PreviewLoader::finishedGenerating(): unable to find "
 662                         "data for PID " << pid << endl;
 663                 return;
 664         }
 665
 666         string const command = git->second.command;
 667         string const status = retval > 0 ? "failed" : "succeeded";
 668         LYXERR(Debug::GRAPHICS, "PreviewLoader::finishedInProgress("
 669                                 << retval << "): processing " << status
 670                                 << " for " << command);
 671         if (retval > 0)
 672                 return;
 673
 674         // Read the metrics file, if it exists
 675         vector<double> ascent_fractions(git->second.snippets.size());
 676         setAscentFractions(ascent_fractions, git->second.metrics_file);
 677
 678         // Add these newly generated bitmap files to the cache and
 679         // start loading them into LyX.
 680         BitmapFile::const_iterator it  = git->second.snippets.begin();
 681         BitmapFile::const_iterator end = git->second.snippets.end();
 682
 683         list<PreviewImagePtr> newimages;
 684
 685         int metrics_counter = 0;
 686         for (; it != end; ++it, ++metrics_counter) {
 687                 string const & snip = it->first;
 688                 FileName const & file = it->second;
 689                 double af = ascent_fractions[metrics_counter];
 690
 691                 // Add the image to the cache only if it's actually present
 692                 if (file.isReadableFile()) {
 693                         PreviewImagePtr ptr(new PreviewImage(parent_, snip, file, af));
 694                         cache_[snip] = ptr;
 695
 696                         newimages.push_back(ptr);
 697                 }
 698
 699         }
 700
 701         // Remove the item from the list of still-executing processes.
 702         in_progress_.erase(git);
 703
 704         // Tell the outside world
 705         list<PreviewImagePtr>::const_reverse_iterator
 706                 nit  = newimages.rbegin();
 707         list<PreviewImagePtr>::const_reverse_iterator
 708                 nend = newimages.rend();
 709         for (; nit != nend; ++nit) {
 710                 imageReady(*nit->get());
 711         }
 712 }
 713
 714
 715 void PreviewLoader::Impl::dumpPreamble(otexstream & os) const
 716 {
 717         // Dump the preamble only.
 718         OutputParams runparams(&buffer_.params().encoding());
 719         if (buffer_.params().useNonTeXFonts)
 720                 runparams.flavor = OutputParams::XETEX;
 721         else
 722                 runparams.flavor = OutputParams::LATEX;
 723         runparams.nice = true;
 724         runparams.moving_arg = true;
 725         runparams.free_spacing = true;
 726         runparams.is_child = buffer_.parent();
 727         buffer_.writeLaTeXSource(os, buffer_.filePath(), runparams, Buffer::OnlyPreamble);
 728
 729         // FIXME! This is a HACK! The proper fix is to control the 'true'
 730         // passed to WriteStream below:
 731         // int InsetMathNest::latex(Buffer const &, odocstream & os,
 732         //                          OutputParams const & runparams) const
 733         // {
 734         //      WriteStream wi(os, runparams.moving_arg, true);
 735         //      par_->write(wi);
 736         //      return wi.line();
 737         // }
 738         os << "\n"
 739            << "\\def\\lyxlock{}\n"
 740            << "\n";
 741
 742         // All equation labels appear as "(#)" + preview.sty's rendering of
 743         // the label name
 744         if (lyxrc.preview_hashed_labels)
 745                 os << "\\renewcommand{\\theequation}{\\#}\n";
 746
 747         // Use the preview style file to ensure that each snippet appears on a
 748         // fresh page.
 749         // Also support PDF output (automatically generated e.g. when
 750         // \usepackage[pdftex]{hyperref} is used and XeTeX.
 751         os << "\n"
 752            << "\\usepackage[active,delayed,showlabels,lyx]{preview}\n"
 753            << "\n";
 754 }
 755
 756
 757 void PreviewLoader::Impl::dumpData(odocstream & os,
 758                                    BitmapFile const & vec) const
 759 {
 760         if (vec.empty())
 761                 return;
 762
 763         BitmapFile::const_iterator it  = vec.begin();
 764         BitmapFile::const_iterator end = vec.end();
 765
 766         for (; it != end; ++it) {
 767                 // FIXME UNICODE
 768                 os << "\\begin{preview}\n"
 769                    << from_utf8(it->first)
 770                    << "\n\\end{preview}\n\n";
 771         }
 772 }
 773
 774 } // namespace graphics
 775 } // namespace lyx