src/insets/InsetQuotes.cpp

   1 /**
   2  * \file InsetQuotes.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Jean-Marc Lasgouttes
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "InsetQuotes.h"
  14
  15 #include "Buffer.h"
  16 #include "BufferParams.h"
  17 #include "BufferView.h"
  18 #include "Dimension.h"
  19 #include "Font.h"
  20 #include "Language.h"
  21 #include "LaTeXFeatures.h"
  22 #include "Lexer.h"
  23 #include "LyXRC.h"
  24 #include "MetricsInfo.h"
  25 #include "OutputParams.h"
  26 #include "output_xhtml.h"
  27 #include "texstream.h"
  28
  29 #include "frontends/FontMetrics.h"
  30 #include "frontends/Painter.h"
  31
  32 #include "support/debug.h"
  33 #include "support/docstring.h"
  34 #include "support/docstream.h"
  35 #include "support/lstrings.h"
  36
  37 using namespace std;
  38 using namespace lyx::support;
  39
  40 namespace lyx {
  41
  42 namespace {
  43
  44 /* codes used to read/write quotes to LyX files
  45  * e    ``english''
  46  * s    ''swedish''
  47  * g    ,,german``
  48  * p    ,,polish''
  49  * f    <<french>>
  50  * a    >>danish<<
  51  */
  52
  53 char const * const language_char = "esgpfa";
  54 char const * const side_char = "lr" ;
  55 char const * const times_char = "sd";
  56
  57 // List of known quote chars
  58 char const * const quote_char = ",'`<>";
  59
  60 // Unicode characters needed by each quote type
  61 char_type const display_quote_char[2][5] = {
  62         { 0x201a, 0x2019, 0x2018, 0x2039, 0x203a},
  63         { 0x201e, 0x201d, 0x201c, 0x00ab, 0x00bb}
  64 };
  65
  66 // Index of chars used for the quote. Index is [side, language]
  67 int quote_index[2][6] = {
  68         { 2, 1, 0, 0, 3, 4 },    // "'',,<>"
  69         { 1, 1, 2, 1, 4, 3 }     // "`'`'><"
  70 };
  71
  72 // Corresponding LaTeX code, for double and single quotes.
  73 char const * const latex_quote_t1[2][5] = {
  74         { "\\quotesinglbase ",  "'", "`",
  75     "\\guilsinglleft{}", "\\guilsinglright{}" },
  76   { ",,", "''", "``", "<<", ">>" }
  77 };
  78
  79 char const * const latex_quote_ot1[2][5] = {
  80         { "\\quotesinglbase ",  "'", "`",
  81     "\\guilsinglleft{}", "\\guilsinglright{}" },
  82   { "\\quotedblbase ", "''", "``",
  83     "\\guillemotleft{}", "\\guillemotright{}" }
  84 };
  85
  86 char const * const latex_quote_babel[2][5] = {
  87         { "\\glq ",  "'", "`", "\\flq{}", "\\frq{}" },
  88   { "\\glqq ", "''", "``", "\\flqq{}", "\\frqq{}" }
  89 };
  90
  91 } // namespace anon
  92
  93
  94 InsetQuotes::InsetQuotes(Buffer * buf, string const & str) : Inset(buf)
  95 {
  96         parseString(str);
  97 }
  98
  99 InsetQuotes::InsetQuotes(Buffer * buf, char_type c, QuoteTimes t)
 100         : Inset(buf), times_(t)
 101 {
 102         if (buf)
 103                 language_ = buf->params().quotes_language;
 104         else
 105                 language_ = EnglishQuotes;
 106
 107         setSide(c);
 108 }
 109
 110
 111 docstring InsetQuotes::layoutName() const
 112 {
 113         return from_ascii("Quotes");
 114 }
 115
 116
 117 void InsetQuotes::setSide(char_type c)
 118 {
 119         // Decide whether left or right
 120         switch (c) {
 121         case ' ':
 122         case '(':
 123         case '[':
 124                 side_ = LeftQuote;   // left quote
 125                 break;
 126         default:
 127                 side_ = RightQuote;  // right quote
 128         }
 129 }
 130
 131
 132 void InsetQuotes::parseString(string const & s)
 133 {
 134         string str = s;
 135         if (str.length() != 3) {
 136                 lyxerr << "ERROR (InsetQuotes::InsetQuotes):"
 137                         " bad string length." << endl;
 138                 str = "eld";
 139         }
 140
 141         int i;
 142
 143         for (i = 0; i < 6; ++i) {
 144                 if (str[0] == language_char[i]) {
 145                         language_ = QuoteLanguage(i);
 146                         break;
 147                 }
 148         }
 149         if (i >= 6) {
 150                 lyxerr << "ERROR (InsetQuotes::InsetQuotes):"
 151                         " bad language specification." << endl;
 152                 language_ = EnglishQuotes;
 153         }
 154
 155         for (i = 0; i < 2; ++i) {
 156                 if (str[1] == side_char[i]) {
 157                         side_ = QuoteSide(i);
 158                         break;
 159                 }
 160         }
 161         if (i >= 2) {
 162                 lyxerr << "ERROR (InsetQuotes::InsetQuotes):"
 163                         " bad side specification." << endl;
 164                 side_ = LeftQuote;
 165         }
 166
 167         for (i = 0; i < 2; ++i) {
 168                 if (str[2] == times_char[i]) {
 169                         times_ = QuoteTimes(i);
 170                         break;
 171                 }
 172         }
 173         if (i >= 2) {
 174                 lyxerr << "ERROR (InsetQuotes::InsetQuotes):"
 175                         " bad times specification." << endl;
 176                 times_ = DoubleQuotes;
 177         }
 178 }
 179
 180
 181 // FIXME: should we add a language or a font parameter member?
 182 docstring InsetQuotes::displayString() const
 183 {
 184         Language const * loclang =
 185                 isBufferValid() ? buffer().params().language : 0;
 186         int const index = quote_index[side_][language_];
 187         docstring retdisp = docstring(1, display_quote_char[times_][index]);
 188
 189         // in french, thin spaces are added inside double quotes
 190         // FIXME: this should be done by a separate quote type.
 191         if (times_ == DoubleQuotes && loclang && prefixIs(loclang->code(), "fr")) {
 192                 // THIN SPACE (U+2009)
 193                 char_type const thin_space = 0x2009;
 194                 if (side_ == LeftQuote)
 195                         retdisp += thin_space;
 196                 else
 197                         retdisp = thin_space + retdisp;
 198         }
 199
 200         return retdisp;
 201 }
 202
 203
 204 void InsetQuotes::metrics(MetricsInfo & mi, Dimension & dim) const
 205 {
 206         FontInfo & font = mi.base.font;
 207         frontend::FontMetrics const & fm = theFontMetrics(font);
 208         dim.asc = fm.maxAscent();
 209         dim.des = fm.maxDescent();
 210         dim.wid = fm.width(displayString());
 211 }
 212
 213
 214 void InsetQuotes::drawBackground(PainterInfo & pi, int x, int y) const
 215 {
 216         if (pi.full_repaint)
 217                 return;
 218         Dimension const dim = dimension(*pi.base.bv);
 219         pi.pain.fillRectangle(x, y - dim.asc, dim.wid, dim.asc + dim.des,
 220                               pi.backgroundColor(this));
 221 }
 222
 223
 224 void InsetQuotes::draw(PainterInfo & pi, int x, int y) const
 225 {
 226         FontInfo font = pi.base.font;
 227         font.setPaintColor(pi.textColor(font.realColor()));
 228         pi.pain.text(x, y, displayString(), font);
 229 }
 230
 231
 232 void InsetQuotes::write(ostream & os) const
 233 {
 234         string text;
 235         text += language_char[language_];
 236         text += side_char[side_];
 237         text += times_char[times_];
 238         os << "Quotes " << text;
 239 }
 240
 241
 242 void InsetQuotes::read(Lexer & lex)
 243 {
 244         lex.setContext("InsetQuotes::read");
 245         lex.next();
 246         parseString(lex.getString());
 247         lex >> "\\end_inset";
 248 }
 249
 250
 251 void InsetQuotes::latex(otexstream & os, OutputParams const & runparams) const
 252 {
 253         const int quoteind = quote_index[side_][language_];
 254         string qstr;
 255
 256         if (language_ == FrenchQuotes && times_ == DoubleQuotes
 257             && prefixIs(runparams.local_font->language()->code(), "fr")
 258             && !runparams.use_polyglossia) {
 259                 if (side_ == LeftQuote)
 260                         qstr = "\\og "; //the spaces are important here
 261                 else
 262                         qstr = " \\fg{}"; //and here
 263         } else if (lyxrc.fontenc == "T1" && !runparams.use_polyglossia) {
 264                 qstr = latex_quote_t1[times_][quoteind];
 265 #ifdef DO_USE_DEFAULT_LANGUAGE
 266         } else if (doclang == "default") {
 267 #else
 268         } else if (!runparams.use_babel) {
 269 #endif
 270                 // these are also used by polyglossia
 271                 qstr = latex_quote_ot1[times_][quoteind];
 272         } else {
 273                 qstr = latex_quote_babel[times_][quoteind];
 274         }
 275
 276         // Always guard against unfortunate ligatures (!` ?`)
 277         if (prefixIs(qstr, "`")) {
 278                 char_type const lastchar = os.lastChar();
 279                 if (lastchar == '!' || lastchar == '?')
 280                         qstr.insert(0, "{}");
 281         }
 282
 283         os << from_ascii(qstr);
 284 }
 285
 286
 287 int InsetQuotes::plaintext(odocstringstream & os,
 288         OutputParams const &, size_t) const
 289 {
 290         docstring const str = displayString();
 291         os << str;
 292         return str.size();
 293 }
 294
 295
 296 docstring InsetQuotes::getQuoteEntity() const {
 297         if (times_ == DoubleQuotes) {
 298                 if (side_ == LeftQuote)
 299                         return from_ascii("&ldquo;");
 300                 else
 301                         return from_ascii("&rdquo;");
 302         }
 303         if (side_ == LeftQuote)
 304                 return from_ascii("&lsquo;");
 305         else
 306                 return from_ascii("&rsquo;");
 307 }
 308
 309
 310 int InsetQuotes::docbook(odocstream & os, OutputParams const &) const
 311 {
 312         os << getQuoteEntity();
 313         return 0;
 314 }
 315
 316
 317 docstring InsetQuotes::xhtml(XHTMLStream & xs, OutputParams const &) const
 318 {
 319         xs << XHTMLStream::ESCAPE_NONE << getQuoteEntity();
 320         return docstring();
 321 }
 322
 323
 324 void InsetQuotes::toString(odocstream & os) const
 325 {
 326         os << displayString();
 327 }
 328
 329
 330 void InsetQuotes::forOutliner(docstring & os, size_t const, bool const) const
 331 {
 332         os += displayString();
 333 }
 334
 335
 336 void InsetQuotes::validate(LaTeXFeatures & features) const
 337 {
 338         char type = quote_char[quote_index[side_][language_]];
 339
 340 #ifdef DO_USE_DEFAULT_LANGUAGE
 341         if (features.bufferParams().language->lang() == "default"
 342 #else
 343         if (!features.useBabel()
 344 #endif
 345             && lyxrc.fontenc != "T1") {
 346                 if (times_ == SingleQuotes)
 347                         switch (type) {
 348                         case ',': features.require("quotesinglbase"); break;
 349                         case '<': features.require("guilsinglleft");  break;
 350                         case '>': features.require("guilsinglright"); break;
 351                         default: break;
 352                         }
 353                 else
 354                         switch (type) {
 355                         case ',': features.require("quotedblbase");   break;
 356                         case '<': features.require("guillemotleft");  break;
 357                         case '>': features.require("guillemotright"); break;
 358                         default: break;
 359                         }
 360         }
 361 }
 362
 363 } // namespace lyx