src/insets/InsetIPA.cpp

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