src/insets/InsetPreview.cpp

   1 /**
   2  * \file InsetPreview.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Vincent van Ravesteijn
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10 #include "config.h"
  11
  12 #include "InsetPreview.h"
  13
  14 #include "Buffer.h"
  15 #include "BufferParams.h"
  16 #include "BufferView.h"
  17 #include "Cursor.h"
  18 #include "Lexer.h"
  19 #include "LyXRC.h"
  20 #include "MetricsInfo.h"
  21 #include "OutputParams.h"
  22 #include "RenderPreview.h"
  23
  24 #include "frontends/Painter.h"
  25
  26 #include "graphics/PreviewImage.h"
  27
  28 #include <sstream>
  29
  30 using namespace std;
  31
  32 namespace lyx {
  33
  34
  35 InsetPreview::InsetPreview(Buffer * buf)
  36         : InsetText(buf),
  37           preview_(new RenderPreview(this)), use_preview_(true)
  38 {
  39         setAutoBreakRows(true);
  40         setDrawFrame(true);
  41         setFrameColor(Color_previewframe);
  42 }
  43
  44
  45 InsetPreview::~InsetPreview()
  46 {}
  47
  48
  49 InsetPreview::InsetPreview(InsetPreview const & other)
  50         : InsetText(other)
  51 {
  52         preview_.reset(new RenderPreview(*other.preview_, this));
  53 }
  54
  55
  56 void InsetPreview::write(ostream & os) const
  57 {
  58         os << "Preview" << "\n";
  59         text().write(os);
  60 }
  61
  62
  63 void InsetPreview::addPreview(DocIterator const & inset_pos,
  64         graphics::PreviewLoader &) const
  65 {
  66         preparePreview(inset_pos);
  67 }
  68
  69
  70 void InsetPreview::preparePreview(DocIterator const & pos) const
  71 {
  72         odocstringstream str;
  73         otexstream os(str);
  74         OutputParams runparams(&pos.buffer()->params().encoding());
  75         latex(os, runparams);
  76         docstring const snippet = str.str();
  77         preview_->addPreview(snippet, *pos.buffer());
  78 }
  79
  80
  81 bool InsetPreview::previewState(BufferView * bv) const
  82 {
  83         if (!editing(bv) && (RenderPreview::status() == LyXRC::PREVIEW_ON ||
  84                              RenderPreview::status() == LyXRC::PREVIEW_NO_MATH)) {
  85                 graphics::PreviewImage const * pimage =
  86                         preview_->getPreviewImage(bv->buffer());
  87                 return pimage && pimage->image();
  88         }
  89         return false;
  90 }
  91
  92
  93 void InsetPreview::reloadPreview(DocIterator const & pos) const
  94 {
  95         preparePreview(pos);
  96         preview_->startLoading(*pos.buffer());
  97 }
  98
  99
 100 void InsetPreview::draw(PainterInfo & pi, int x, int y) const
 101 {
 102         use_preview_ = previewState(pi.base.bv);
 103
 104         if (use_preview_) {
 105                 // one pixel gap in front
 106                 preview_->draw(pi, x + 1 + TEXT_TO_INSET_OFFSET, y);
 107                 setPosCache(pi, x, y);
 108                 return;
 109         }
 110         InsetText::draw(pi, x, y);
 111 }
 112
 113
 114 void InsetPreview::edit(Cursor & cur, bool front, EntryDirection entry_from)
 115 {
 116         cur.push(*this);
 117         InsetText::edit(cur, front, entry_from);
 118 }
 119
 120
 121 Inset * InsetPreview::editXY(Cursor & cur, int x, int y)
 122 {
 123         if (use_preview_) {
 124                 edit(cur, true, ENTRY_DIRECTION_IGNORE);
 125                 return this;
 126         }
 127         cur.push(*this);
 128         return InsetText::editXY(cur, x, y);
 129 }
 130
 131
 132 void InsetPreview::metrics(MetricsInfo & mi, Dimension & dim) const
 133 {
 134         if (previewState(mi.base.bv)) {
 135                 preview_->metrics(mi, dim);
 136                 mi.base.textwidth += 2 * TEXT_TO_INSET_OFFSET;
 137
 138                 dim.wid = max(dim.wid, 4);
 139                 dim.asc = max(dim.asc, 4);
 140
 141                 dim.asc += TEXT_TO_INSET_OFFSET;
 142                 dim.des += TEXT_TO_INSET_OFFSET;
 143                 dim.wid += TEXT_TO_INSET_OFFSET;
 144                 dim_ = dim;
 145                 dim.wid += TEXT_TO_INSET_OFFSET;
 146                 // insert a one pixel gap
 147                 dim.wid += 1;
 148                 // Cache the inset dimension.
 149                 setDimCache(mi, dim);
 150                 Dimension dim_dummy;
 151                 MetricsInfo mi_dummy = mi;
 152                 InsetText::metrics(mi_dummy, dim_dummy);
 153                 return;
 154         }
 155         InsetText::metrics(mi, dim);
 156 }
 157
 158
 159 bool InsetPreview::notifyCursorLeaves(Cursor const & old, Cursor & cur)
 160 {
 161         reloadPreview(old);
 162         cur.screenUpdateFlags(Update::Force);
 163         return InsetText::notifyCursorLeaves(old, cur);
 164 }
 165
 166
 167 } // namespace lyx