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