src/insets/render_preview.C

   1 /**
   2  * \file render_preview.C
   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 "render_preview.h"
  14
  15 #include "dimension.h"
  16 #include "LColor.h"
  17 #include "metricsinfo.h"
  18
  19 #include "frontends/Painter.h"
  20
  21 #include "graphics/PreviewImage.h"
  22 #include "graphics/PreviewLoader.h"
  23 #include "graphics/Previews.h"
  24
  25 #include "support/lstrings.h"
  26
  27 #include <boost/bind.hpp>
  28
  29 using std::string;
  30
  31 namespace graphics = lyx::graphics;
  32 namespace support  = lyx::support;
  33
  34
  35 bool RenderPreview::activated()
  36 {
  37         return graphics::Previews::activated();
  38 }
  39
  40
  41 RenderPreview::RenderPreview()
  42         : pimage_(0)
  43 {}
  44
  45
  46 RenderPreview::RenderPreview(RenderPreview const & other)
  47         : RenderBase(other),
  48           boost::signals::trackable(),
  49           snippet_(other.snippet_),
  50           pimage_(0)
  51 {}
  52
  53
  54 RenderBase * RenderPreview::clone() const
  55 {
  56         return new RenderPreview(*this);
  57 }
  58
  59
  60 void RenderPreview::metrics(MetricsInfo &, Dimension & dim) const
  61 {
  62         if (previewReady()) {
  63                 dim.asc = pimage_->ascent();
  64                 dim.des = pimage_->descent();
  65                 dim.wid = pimage_->width();
  66         } else {
  67                 dim.asc = 20;
  68                 dim.des = 20;
  69                 dim.wid = 20;
  70         }
  71
  72         dim_ = dim;
  73 }
  74
  75
  76 void RenderPreview::draw(PainterInfo & pi, int x, int y) const
  77 {
  78         if (!previewReady())
  79                 pi.pain.rectangle(x, y - dim_.asc, dim_.wid, dim_.height(),
  80                                   LColor::foreground);
  81         else
  82                 pi.pain.image(x, y - dim_.asc, dim_.wid, dim_.height(),
  83                               *(pimage_->image()));
  84 }
  85
  86
  87 boost::signals::connection RenderPreview::connect(slot_type const & slot)
  88 {
  89         return preview_ready_signal_.connect(slot);
  90 }
  91
  92
  93 void RenderPreview::generatePreview(string const & latex_snippet,
  94                                      Buffer const & buffer)
  95 {
  96         if (!activated())
  97                 return;
  98
  99         graphics::Previews & previews = graphics::Previews::get();
 100         graphics::PreviewLoader & loader = previews.loader(buffer);
 101         addPreview(latex_snippet, loader);
 102         if (!snippet_.empty())
 103                 loader.startLoading();
 104 }
 105
 106
 107 void RenderPreview::addPreview(string const & latex_snippet,
 108                                 graphics::PreviewLoader & ploader)
 109 {
 110         if (!activated())
 111                 return;
 112
 113         snippet_ = support::trim(latex_snippet);
 114         pimage_ = 0;
 115         if (snippet_.empty())
 116                 return;
 117
 118         pimage_ = ploader.preview(snippet_);
 119         if (pimage_)
 120                 return;
 121
 122         // If this is the first time of calling, connect to the
 123         // PreviewLoader signal that'll inform us when the preview image
 124         // is ready for loading.
 125         if (!ploader_connection_.connected()) {
 126                 ploader_connection_ = ploader.connect(
 127                         boost::bind(&RenderPreview::imageReady, this, _1));
 128         }
 129
 130         ploader.add(snippet_);
 131 }
 132
 133
 134 void RenderPreview::removePreview(Buffer const & buffer)
 135 {
 136         if (snippet_.empty())
 137                 return;
 138
 139         graphics::Previews & previews = graphics::Previews::get();
 140         graphics::PreviewLoader & loader = previews.loader(buffer);
 141         loader.remove(snippet_);
 142         snippet_.erase();
 143         pimage_ = 0;
 144 }
 145
 146
 147 bool RenderPreview::previewReady() const
 148 {
 149         return pimage_ ? pimage_->image() : false;
 150 }
 151
 152
 153 void RenderPreview::imageReady(graphics::PreviewImage const & pimage)
 154 {
 155         // Check the current snippet is the same as that previewed.
 156         if (snippet_ != pimage.snippet())
 157                 return;
 158
 159         pimage_ = &pimage;
 160         preview_ready_signal_();
 161 }
 162
 163
 164 void RenderMonitoredPreview::startMonitoring(string const & file)
 165 {
 166         monitor_.reset(file);
 167         monitor_.start();
 168 }
 169
 170
 171 boost::signals::connection
 172 RenderMonitoredPreview::fileChanged(slot_type const & slot)
 173 {
 174         return monitor_.connect(slot);
 175 }