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 "FuncRequest.h"
  19 #include "FuncStatus.h"
  20 #include "LaTeXFeatures.h"
  21 #include "Lexer.h"
  22 #include "LyXRC.h"
  23 #include "MetricsInfo.h"
  24 #include "OutputParams.h"
  25 #include "RenderPreview.h"
  26
  27 #include "frontends/Painter.h"
  28
  29 #include "graphics/PreviewImage.h"
  30
  31 #include <sstream>
  32
  33 using namespace std;
  34
  35 namespace lyx {
  36
  37
  38 InsetIPA::InsetIPA(Buffer * buf)
  39         : InsetText(buf),
  40           preview_(new RenderPreview(this)), use_preview_(true)
  41 {
  42         setAutoBreakRows(true);
  43         setDrawFrame(true);
  44         setFrameColor(Color_insetframe);
  45 }
  46
  47
  48 InsetIPA::~InsetIPA()
  49 {}
  50
  51
  52 InsetIPA::InsetIPA(InsetIPA const & other)
  53         : InsetText(other)
  54 {
  55         preview_.reset(new RenderPreview(*other.preview_, this));
  56 }
  57
  58
  59 void InsetIPA::write(ostream & os) const
  60 {
  61         os << "IPA" << "\n";
  62         text().write(os);
  63 }
  64
  65
  66 void InsetIPA::doDispatch(Cursor & cur, FuncRequest & cmd)
  67 {
  68         switch (cmd.action()) {
  69         case LFUN_QUOTE_INSERT: {
  70                 FuncRequest fr(LFUN_SELF_INSERT, "\"");
  71                 InsetText::doDispatch(cur, fr);
  72                 break;
  73         }
  74         default:
  75                 InsetText::doDispatch(cur, cmd);
  76                 break;
  77         }
  78
  79 }
  80
  81
  82 bool InsetIPA::getStatus(Cursor & cur, FuncRequest const & cmd,
  83                 FuncStatus & flag) const
  84 {
  85         switch (cmd.action()) {
  86         case LFUN_SCRIPT_INSERT: {
  87                 if (cmd.argument() == "subscript") {
  88                         flag.setEnabled(false);
  89                         return true;
  90                 }
  91                 break;
  92         }
  93         default:
  94                 break;
  95         }
  96         return InsetText::getStatus(cur, cmd, flag);
  97 }
  98
  99
 100 void InsetIPA::addPreview(DocIterator const & inset_pos,
 101         graphics::PreviewLoader &) const
 102 {
 103         preparePreview(inset_pos);
 104 }
 105
 106
 107 void InsetIPA::preparePreview(DocIterator const & pos) const
 108 {
 109         TexRow texrow;
 110         odocstringstream str;
 111         otexstream os(str, texrow);
 112         OutputParams runparams(&pos.buffer()->params().encoding());
 113         latex(os, runparams);
 114         docstring const snippet = str.str();
 115         preview_->addPreview(snippet, *pos.buffer());
 116 }
 117
 118
 119 bool InsetIPA::previewState(BufferView * bv) const
 120 {
 121         if (!editing(bv) && (RenderPreview::status() == LyXRC::PREVIEW_ON ||
 122                              RenderPreview::status() == LyXRC::PREVIEW_NO_MATH)) {
 123                 graphics::PreviewImage const * pimage =
 124                         preview_->getPreviewImage(bv->buffer());
 125                 return pimage && pimage->image();
 126         }
 127         return false;
 128 }
 129
 130
 131 void InsetIPA::reloadPreview(DocIterator const & pos) const
 132 {
 133         preparePreview(pos);
 134         preview_->startLoading(*pos.buffer());
 135 }
 136
 137
 138 void InsetIPA::draw(PainterInfo & pi, int x, int y) const
 139 {
 140         use_preview_ = previewState(pi.base.bv);
 141
 142         if (use_preview_) {
 143                 preview_->draw(pi, x + TEXT_TO_INSET_OFFSET, y);
 144                 setPosCache(pi, x, y);
 145                 return;
 146         }
 147         InsetText::draw(pi, x, y);
 148 }
 149
 150
 151 void InsetIPA::edit(Cursor & cur, bool front, EntryDirection entry_from)
 152 {
 153         cur.push(*this);
 154         InsetText::edit(cur, front, entry_from);
 155 }
 156
 157
 158 Inset * InsetIPA::editXY(Cursor & cur, int x, int y)
 159 {
 160         if (use_preview_) {
 161                 edit(cur, true, ENTRY_DIRECTION_IGNORE);
 162                 return this;
 163         }
 164         cur.push(*this);
 165         return InsetText::editXY(cur, x, y);
 166 }
 167
 168
 169 void InsetIPA::metrics(MetricsInfo & mi, Dimension & dim) const
 170 {
 171         if (previewState(mi.base.bv)) {
 172                 preview_->metrics(mi, dim);
 173                 mi.base.textwidth += 2 * TEXT_TO_INSET_OFFSET;
 174
 175                 dim.wid = max(dim.wid, 4);
 176                 dim.asc = max(dim.asc, 4);
 177
 178                 dim.asc += TEXT_TO_INSET_OFFSET;
 179                 dim.des += TEXT_TO_INSET_OFFSET;
 180                 dim.wid += TEXT_TO_INSET_OFFSET;
 181                 dim_ = dim;
 182                 dim.wid += TEXT_TO_INSET_OFFSET;
 183                 // insert a one pixel gap
 184                 dim.wid += 1;
 185                 // Cache the inset dimension.
 186                 setDimCache(mi, dim);
 187                 Dimension dim_dummy;
 188                 MetricsInfo mi_dummy = mi;
 189                 InsetText::metrics(mi_dummy, dim_dummy);
 190                 return;
 191         }
 192         InsetText::metrics(mi, dim);
 193 }
 194
 195
 196 bool InsetIPA::notifyCursorLeaves(Cursor const & old, Cursor & cur)
 197 {
 198         reloadPreview(old);
 199         cur.screenUpdateFlags(Update::Force);
 200         return InsetText::notifyCursorLeaves(old, cur);
 201 }
 202
 203
 204 void InsetIPA::validate(LaTeXFeatures & features) const
 205 {
 206         if (buffer_->params().useNonTeXFonts)
 207                 return;
 208         features.require("tipa");
 209         features.require("tipx");
 210 }
 211
 212
 213 void InsetIPA::latex(otexstream & os, OutputParams const & runparams_in) const
 214 {
 215         OutputParams runparams(runparams_in);
 216         runparams.inIPA = true;
 217         bool const multipar = (text().paragraphs().size() > 1);
 218         // fontspec knows \textipa, but not the IPA environment
 219         bool const nontexfonts = buffer_->params().useNonTeXFonts;
 220         if (multipar && !nontexfonts)
 221                 os << "\\begin{IPA}\n";
 222         else
 223                 os << "\\textipa{";
 224         InsetText::latex(os, runparams);
 225         if (multipar && !nontexfonts)
 226                 os << "\n\\end{IPA}";
 227         else
 228                 os << "}";
 229 }
 230
 231
 232 bool InsetIPA::insetAllowed(InsetCode code) const
 233 {
 234         switch (code) {
 235         // code that is allowed
 236         case ERT_CODE:
 237         case SCRIPT_CODE:
 238                 return true;
 239         default:
 240                 return false;
 241         }
 242 }
 243
 244
 245 } // namespace lyx