#include "Lexer.h"
#include "LyXRC.h"
#include "MetricsInfo.h"
-#include "OutputParams.h"
#include "Paragraph.h"
#include "ParIterator.h"
#include "texstream.h"
* r <<russian>> (,,inner quotation``)
* j [U+300C]cjk[U+300D] ([U+300E]inner quotation[U+300F]) [CORNER BRACKETS]
* k [U+300A]cjkangle[U+300B] ([U+3008]inner quotation[U+3009]) [ANGLE BRACKETS]
+ * h ,,hungarian'' (>>inner quotation<<)
* x dynamic style (inherits document settings)
*/
-char const * const style_char = "esgpcaqbwfirjkx";
+char const * const style_char = "esgpcaqbwfirjkhx";
char const * const side_char = "lr" ;
char const * const level_char = "sd";
char InsetQuotesParams::getStyleChar(QuoteStyle const & style) const
{
- return style_char[style];
+ return style_char[static_cast<int>(style)];
}
-InsetQuotesParams::QuoteStyle InsetQuotesParams::getQuoteStyle(string const & s,
+QuoteStyle InsetQuotesParams::getQuoteStyle(string const & s,
bool const allow_wildcards, QuoteStyle fb) const
{
QuoteStyle res = fb;
if (i >= stylescount()) {
LYXERR0("ERROR (InsetQuotes::InsetQuotes):"
" bad style specification.");
- res = EnglishQuotes;
+ res = QuoteStyle::English;
}
}
}
-InsetQuotesParams::QuoteSide InsetQuotesParams::getQuoteSide(string const & s,
+QuoteSide InsetQuotesParams::getQuoteSide(string const & s,
bool const allow_wildcards, QuoteSide fb) const
{
QuoteSide res = fb;
int i;
for (i = 0; i < 2; ++i) {
if (str[1] == side_char[i]) {
- res = InsetQuotesParams::QuoteSide(i);
+ res = QuoteSide(i);
break;
}
}
if (i >= 2) {
LYXERR0("ERROR (InsetQuotes::InsetQuotes):"
" bad side specification.");
- res = OpeningQuote;
+ res = QuoteSide::Opening;
}
}
}
-InsetQuotesParams::QuoteLevel InsetQuotesParams::getQuoteLevel(string const & s,
+QuoteLevel InsetQuotesParams::getQuoteLevel(string const & s,
bool const allow_wildcards, QuoteLevel fb) const
{
QuoteLevel res = fb;
int i;
for (i = 0; i < 2; ++i) {
if (str[2] == level_char[i]) {
- res = InsetQuotesParams::QuoteLevel(i);
+ res = QuoteLevel(i);
break;
}
}
if (i >= 2) {
LYXERR0("ERROR (InsetQuotes::InsetQuotes):"
" bad level specification.");
- res = InsetQuotesParams::PrimaryQuotes;
+ res = QuoteLevel::Primary;
}
}
char_type right_secondary;
switch (style) {
- case EnglishQuotes: {
+ case QuoteStyle::English: {
left_primary = 0x201c; // ``
right_primary = 0x201d; // ''
left_secondary = 0x2018; // `
right_secondary = 0x2019; // '
break;
}
- case SwedishQuotes: {
+ case QuoteStyle::Swedish: {
left_primary = 0x201d; // ''
right_primary = 0x201d; // ''
left_secondary = 0x2019; // '
right_secondary = 0x2019; // '
break;
}
- case GermanQuotes: {
+ case QuoteStyle::German: {
left_primary = 0x201e; // ,,
right_primary = 0x201c; // ``
left_secondary = 0x201a; // ,
right_secondary = 0x2018; // `
break;
}
- case PolishQuotes: {
+ case QuoteStyle::Polish: {
left_primary = 0x201e; // ,,
right_primary = 0x201d; // ''
left_secondary = 0x201a; // ,
right_secondary = 0x2019; // '
break;
}
- case SwissQuotes: {
+ case QuoteStyle::Swiss: {
left_primary = 0x00ab; // <<
right_primary = 0x00bb; // >>
left_secondary = 0x2039; // <
right_secondary = 0x203a; // >
break;
}
- case DanishQuotes: {
+ case QuoteStyle::Danish: {
left_primary = 0x00bb; // >>
right_primary = 0x00ab; // <<
left_secondary = 0x203a; // >
right_secondary = 0x2039; // <
break;
}
- case PlainQuotes: {
+ case QuoteStyle::Plain: {
left_primary = 0x0022; // "
right_primary = 0x0022; // "
left_secondary = 0x0027; // '
right_secondary = 0x0027; // '
break;
}
- case BritishQuotes: {
+ case QuoteStyle::British: {
left_primary = 0x2018; // `
right_primary = 0x2019; // '
left_secondary = 0x201c; // ``
right_secondary = 0x201d; // ''
break;
}
- case SwedishGQuotes: {
+ case QuoteStyle::SwedishG: {
left_primary = 0x00bb; // >>
right_primary = 0x00bb; // >>
left_secondary = 0x2019; // '
right_secondary = 0x2019; // '
break;
}
- case FrenchQuotes: {
+ case QuoteStyle::French: {
left_primary = 0x00ab; // <<
right_primary = 0x00bb; // >>
left_secondary = 0x201c; // ``
right_secondary = 0x201d; // ''
break;
}
- case FrenchINQuotes:{
+ case QuoteStyle::FrenchIN:{
left_primary = 0x00ab; // <<
right_primary = 0x00bb; // >>
left_secondary = 0x00ab; // <<
right_secondary = 0x00bb; // >>
break;
}
- case RussianQuotes:{
+ case QuoteStyle::Russian:{
left_primary = 0x00ab; // <<
right_primary = 0x00bb; // >>
left_secondary = 0x201e; // ,,
right_secondary = 0x201c; // ``
break;
}
- case CJKQuotes:{
+ case QuoteStyle::CJK:{
left_primary = 0x300c; // LEFT CORNER BRACKET
right_primary = 0x300d; // RIGHT CORNER BRACKET
left_secondary = 0x300e; // LEFT WHITE CORNER BRACKET
right_secondary = 0x300f; // RIGHT WHITE CORNER BRACKET
break;
}
- case CJKAngleQuotes:{
+ case QuoteStyle::CJKAngle:{
left_primary = 0x300a; // LEFT DOUBLE ANGLE BRACKET
right_primary = 0x300b; // RIGHT DOUBLE ANGLE BRACKET
left_secondary = 0x3008; // LEFT ANGLE BRACKET
right_secondary = 0x3009; // RIGHT ANGLE BRACKET
break;
}
- case DynamicQuotes:
+ case QuoteStyle::Hungarian: {
+ left_primary = 0x201e; // ,,
+ right_primary = 0x201d; // ''
+ left_secondary = 0x00bb; // >>
+ right_secondary = 0x00ab; // <<
+ break;
+ }
+ case QuoteStyle::Dynamic:
default:
// should not happen
left_primary = 0x003f; // ?
}
switch (level) {
- case SecondaryQuotes:
+ case QuoteLevel::Secondary:
if (rtl)
- return (side == ClosingQuote) ? left_secondary : right_secondary;
- return (side == OpeningQuote) ? left_secondary : right_secondary;
- case PrimaryQuotes:
+ return (side == QuoteSide::Closing) ? left_secondary : right_secondary;
+ return (side == QuoteSide::Opening) ? left_secondary : right_secondary;
+ case QuoteLevel::Primary:
if (rtl)
- return (side == ClosingQuote) ? left_primary : right_primary;
- return (side == OpeningQuote) ? left_primary : right_primary;
+ return (side == QuoteSide::Closing) ? left_primary : right_primary;
+ return (side == QuoteSide::Opening) ? left_primary : right_primary;
default:
break;
}
// get all quote types
for (sty = 0; sty < stylescount(); ++sty) {
style = QuoteStyle(sty);
- if (style == DynamicQuotes)
+ if (style == QuoteStyle::Dynamic)
continue;
for (sid = 0; sid < 2; ++sid) {
side = QuoteSide(sid);
for (lev = 0; lev < 2; ++lev) {
- type += style_char[style];
+ type += style_char[static_cast<int>(style)];
type += side_char[sid];
level = QuoteLevel(lev);
type += level_char[lev];
{
docstring const styledesc =
bformat(_("%1$souter%2$s and %3$sinner%4$s[[quotation marks]]"),
- docstring(1, getQuoteChar(qs, PrimaryQuotes, OpeningQuote)),
- docstring(1, getQuoteChar(qs, PrimaryQuotes, ClosingQuote)),
- docstring(1, getQuoteChar(qs, SecondaryQuotes, OpeningQuote)),
- docstring(1, getQuoteChar(qs, SecondaryQuotes, ClosingQuote))
+ docstring(1, getQuoteChar(qs, QuoteLevel::Primary, QuoteSide::Opening)),
+ docstring(1, getQuoteChar(qs, QuoteLevel::Primary, QuoteSide::Closing)),
+ docstring(1, getQuoteChar(qs, QuoteLevel::Secondary, QuoteSide::Opening)),
+ docstring(1, getQuoteChar(qs, QuoteLevel::Secondary, QuoteSide::Closing))
);
if (!langdef)
QuoteSide const side = getQuoteSide(s);
QuoteLevel const level = getQuoteLevel(s);
- return (side == OpeningQuote) ?
+ return (side == QuoteSide::Opening) ?
bformat(_("%1$stext"),
docstring(1, getQuoteChar(style, level, side))) :
bformat(_("text%1$s"),
}
-InsetQuotes::InsetQuotes(Buffer * buf, char_type c, InsetQuotesParams::QuoteLevel level,
+InsetQuotes::InsetQuotes(Buffer * buf, char_type c, QuoteLevel level,
string const & side, string const & style)
: Inset(buf), level_(level)
{
bool dynamic = false;
if (buf) {
global_style_ = buf->masterBuffer()->params().quotes_style;
- fontenc_ = buf->masterBuffer()->params().main_font_encoding();
dynamic = buf->masterBuffer()->params().dynamic_quotes;
fontspec_ = buf->masterBuffer()->params().useNonTeXFonts;
- } else {
- fontenc_ = "OT1";
}
if (style.empty())
- style_ = dynamic ? InsetQuotesParams::DynamicQuotes : global_style_;
+ style_ = dynamic ? QuoteStyle::Dynamic : global_style_;
else
style_ = getStyle(style);
if (side == "left" || side == "opening")
- side_ = InsetQuotesParams::OpeningQuote;
+ side_ = QuoteSide::Opening;
else if (side == "right" || side == "closing")
- side_ = InsetQuotesParams::ClosingQuote;
+ side_ = QuoteSide::Closing;
else
setSide(c);
}
{
// Decide whether opening or closing quote
if (lyx::isSpace(c) || isOpenPunctuation(c))
- side_ = InsetQuotesParams::OpeningQuote;// opening quote
+ side_ = QuoteSide::Opening;// opening quote
else
- side_ = InsetQuotesParams::ClosingQuote;// closing quote
+ side_ = QuoteSide::Closing;// closing quote
}
}
-InsetQuotesParams::QuoteStyle InsetQuotes::getStyle(string const & s)
+QuoteStyle InsetQuotes::getStyle(string const & s)
{
- InsetQuotesParams::QuoteStyle qs = InsetQuotesParams::EnglishQuotes;
+ QuoteStyle qs = QuoteStyle::English;
if (s == "english")
- qs = InsetQuotesParams::EnglishQuotes;
+ qs = QuoteStyle::English;
else if (s == "swedish")
- qs = InsetQuotesParams::SwedishQuotes;
+ qs = QuoteStyle::Swedish;
else if (s == "german")
- qs = InsetQuotesParams::GermanQuotes;
+ qs = QuoteStyle::German;
else if (s == "polish")
- qs = InsetQuotesParams::PolishQuotes;
+ qs = QuoteStyle::Polish;
else if (s == "swiss")
- qs = InsetQuotesParams::SwissQuotes;
+ qs = QuoteStyle::Swiss;
else if (s == "danish")
- qs = InsetQuotesParams::DanishQuotes;
+ qs = QuoteStyle::Danish;
else if (s == "plain")
- qs = InsetQuotesParams::PlainQuotes;
+ qs = QuoteStyle::Plain;
else if (s == "british")
- qs = InsetQuotesParams::BritishQuotes;
+ qs = QuoteStyle::British;
else if (s == "swedishg")
- qs = InsetQuotesParams::SwedishGQuotes;
+ qs = QuoteStyle::SwedishG;
else if (s == "french")
- qs = InsetQuotesParams::FrenchQuotes;
+ qs = QuoteStyle::French;
else if (s == "frenchin")
- qs = InsetQuotesParams::FrenchINQuotes;
+ qs = QuoteStyle::FrenchIN;
else if (s == "russian")
- qs = InsetQuotesParams::RussianQuotes;
+ qs = QuoteStyle::Russian;
else if (s == "cjk")
- qs = InsetQuotesParams::CJKQuotes;
+ qs = QuoteStyle::CJK;
else if (s == "cjkangle")
- qs = InsetQuotesParams::CJKAngleQuotes;
+ qs = QuoteStyle::CJKAngle;
+ else if (s == "hungarian")
+ qs = QuoteStyle::Hungarian;
else if (s == "dynamic")
- qs = InsetQuotesParams::DynamicQuotes;
+ qs = QuoteStyle::Dynamic;
return qs;
}
{
// In PassThru, we use straight quotes
if (pass_thru_)
- return (level_ == InsetQuotesParams::PrimaryQuotes) ?
+ return (level_ == QuoteLevel::Primary) ?
from_ascii("\"") : from_ascii("'");
- InsetQuotesParams::QuoteStyle style =
- (style_ == InsetQuotesParams::DynamicQuotes) ? global_style_ : style_;
+ QuoteStyle style =
+ (style_ == QuoteStyle::Dynamic) ? global_style_ : style_;
docstring retdisp = docstring(1, quoteparams.getQuoteChar(style, level_, side_, rtl_));
// in French, thin spaces are added inside double guillemets
if (prefixIs(context_lang_, "fr")
- && level_ == InsetQuotesParams::PrimaryQuotes
- && (style == InsetQuotesParams::SwissQuotes
- || style == InsetQuotesParams::FrenchQuotes
- || style == InsetQuotesParams::FrenchINQuotes)) {
+ && level_ == QuoteLevel::Primary
+ && (style == QuoteStyle::Swiss
+ || style == QuoteStyle::French
+ || style == QuoteStyle::FrenchIN)) {
// THIN SPACE (U+2009)
char_type const thin_space = 0x2009;
- if (side_ == InsetQuotesParams::OpeningQuote)
+ if (side_ == QuoteSide::Opening)
retdisp += thin_space;
else
retdisp = thin_space + retdisp;
void InsetQuotes::draw(PainterInfo & pi, int x, int y) const
{
FontInfo font = pi.base.font;
- if (style_ == InsetQuotesParams::DynamicQuotes)
+ if (style_ == QuoteStyle::Dynamic)
font.setPaintColor(Color_special);
else
font.setPaintColor(pi.textColor(font.realColor()));
string InsetQuotes::getType() const
{
string text;
- text += style_char[style_];
- text += side_char[side_];
- text += level_char[level_];
+ text += style_char[static_cast<int>(style_)];
+ text += side_char[static_cast<int>(side_)];
+ text += level_char[static_cast<int>(level_)];
return text;
}
void InsetQuotes::latex(otexstream & os, OutputParams const & runparams) const
{
- InsetQuotesParams::QuoteStyle style =
- (style_ == InsetQuotesParams::DynamicQuotes) ? global_style_ : style_;
+ QuoteStyle style =
+ (style_ == QuoteStyle::Dynamic) ? global_style_ : style_;
char_type quotechar = quoteparams.getQuoteChar(style, level_, side_, rtl_);
docstring qstr;
// In pass-thru context, we output plain quotes
- if (runparams.pass_thru)
- qstr = (level_ == InsetQuotesParams::PrimaryQuotes) ? from_ascii("\"") : from_ascii("'");
- else if (style == InsetQuotesParams::PlainQuotes && fontspec_) {
+ if (runparams.pass_thru || runparams.for_search != OutputParams::NoSearch)
+ qstr = (level_ == QuoteLevel::Primary) ? from_ascii("\"") : from_ascii("'");
+ else if (style == QuoteStyle::Plain && fontspec_) {
// For XeTeX and LuaTeX,we need to disable mapping to get straight
// quotes. We define our own commands that do this
- qstr = (level_ == InsetQuotesParams::PrimaryQuotes) ?
+ qstr = (level_ == QuoteLevel::Primary) ?
from_ascii("\\textquotedblplain") : from_ascii("\\textquotesingleplain");
}
else if (runparams.use_polyglossia) {
}
// The CJK marks are not yet covered by utf8 inputenc (we don't have the entry in
// unicodesymbols, since we don't want to add fake synbols there).
- else if (style == InsetQuotesParams::CJKQuotes || style == InsetQuotesParams::CJKAngleQuotes) {
+ else if (style == QuoteStyle::CJK || style == QuoteStyle::CJKAngle) {
if (runparams.encoding && runparams.encoding->name() != "utf8"
&& runparams.encoding->encodable(quotechar))
qstr = docstring(1, quotechar);
else
qstr = quoteparams.getLaTeXQuote(quotechar, "int");
}
- else if ((style == InsetQuotesParams::SwissQuotes
- || style == InsetQuotesParams::FrenchQuotes
- || style == InsetQuotesParams::FrenchINQuotes)
- && level_ == InsetQuotesParams::PrimaryQuotes
+ else if ((style == QuoteStyle::Swiss
+ || style == QuoteStyle::French
+ || style == QuoteStyle::FrenchIN)
+ && level_ == QuoteLevel::Primary
&& prefixIs(runparams.local_font->language()->code(), "fr")) {
// Specific guillemets of French babel
// including correct French spacing
- if (side_ == InsetQuotesParams::OpeningQuote)
+ if (side_ == QuoteSide::Opening)
qstr = from_ascii("\\og");
else
qstr = from_ascii("\\fg");
// Use internal commands in headings with hyperref
// (ligatures not featured in PDF strings)
qstr = quoteparams.getLaTeXQuote(quotechar, "int", rtl_);
- } else if (fontenc_ == "T1"
+ } else if (runparams.main_fontenc == "T1"
&& !runparams.local_font->language()->internalFontEncoding()) {
// Quotation marks for T1 font encoding
// (using ligatures)
#else
} else if ((!runparams.use_babel
#endif
- || (fontenc_ != "T1" && fontenc_ != "OT1"))
+ || (runparams.main_fontenc != "T1" && runparams.main_fontenc != "OT1"))
|| runparams.isFullUnicode()) {
// Standard quotation mark macros
// These are also used by babel
// LuaTeX does not respect {} as ligature breaker by design,
// see https://tex.stackexchange.com/q/349725/19291
docstring const nolig =
- (runparams.flavor == OutputParams::LUATEX
- || runparams.flavor == OutputParams::DVILUATEX) ?
+ (runparams.flavor == Flavor::LuaTeX
+ || runparams.flavor == Flavor::DviLuaTeX) ?
from_ascii("\\/") : from_ascii("{}");
// !` ?` => !{}` ?{}`
if (prefixIs(qstr, from_ascii("`"))
int InsetQuotes::plaintext(odocstringstream & os,
- OutputParams const &, size_t) const
+ OutputParams const & op, size_t) const
{
- docstring const str = displayString();
- os << str;
- return str.size();
+ if (op.for_search == OutputParams::NoSearch) {
+ docstring const str = displayString();
+ os << str;
+ return str.size();
+ }
+ else {
+ if (level_ == QuoteLevel::Primary)
+ os << from_ascii("\"");
+ else
+ os << from_ascii("'");
+ return 1;
+ }
}
docstring InsetQuotes::getQuoteEntity(bool isHTML) const {
- InsetQuotesParams::QuoteStyle style =
- (style_ == InsetQuotesParams::DynamicQuotes) ? global_style_ : style_;
+ QuoteStyle style =
+ (style_ == QuoteStyle::Dynamic) ? global_style_ : style_;
docstring res = isHTML ? quoteparams.getHTMLQuote(quoteparams.getQuoteChar(style, level_, side_)) :
quoteparams.getXMLQuote(quoteparams.getQuoteChar(style, level_, side_));
// in French, thin spaces are added inside double guillemets
if (prefixIs(context_lang_, "fr")
- && level_ == InsetQuotesParams::PrimaryQuotes
- && (style == InsetQuotesParams::FrenchQuotes
- || style == InsetQuotesParams::FrenchINQuotes
- || style == InsetQuotesParams::SwissQuotes)) {
+ && level_ == QuoteLevel::Primary
+ && (style == QuoteStyle::French
+ || style == QuoteStyle::FrenchIN
+ || style == QuoteStyle::Swiss)) {
// THIN SPACE (U+2009)
docstring const thin_space = from_ascii(" ");
- if (side_ == InsetQuotesParams::OpeningQuote) // Open quote: space after
+ if (side_ == QuoteSide::Opening) // Open quote: space after
res += thin_space;
else // Close quote: space before
res = thin_space + res;
pass_thru_ = it.paragraph().isPassThru();
context_lang_ = font.language()->code();
internal_fontenc_ = font.language()->internalFontEncoding();
- fontenc_ = bp.main_font_encoding();
global_style_ = bp.quotes_style;
fontspec_ = bp.useNonTeXFonts;
rtl_ = font.isRightToLeft();
void InsetQuotes::validate(LaTeXFeatures & features) const
{
- InsetQuotesParams::QuoteStyle style =
- (style_ == InsetQuotesParams::DynamicQuotes) ? global_style_ : style_;
+ QuoteStyle style =
+ (style_ == QuoteStyle::Dynamic) ? global_style_ : style_;
char_type type = quoteparams.getQuoteChar(style, level_, side_);
// Handle characters that are not natively supported by
#else
if (!features.useBabel()
#endif
- && !features.runparams().isFullUnicode() && fontenc_ != "T1") {
+ && !features.runparams().isFullUnicode()
+ && features.runparams().main_fontenc != "T1") {
switch (type) {
case 0x201a:
features.require("quotesinglbase");
case 0x0022: {
if (features.runparams().isFullUnicode() && fontspec_)
features.require("textquotedblp");
- else if (fontenc_ != "T1" || internal_fontenc_)
+ else if (features.runparams().main_fontenc != "T1" || internal_fontenc_)
features.require("textquotedbl");
break;
}
projects / lyx.git / blobdiff