]> git.lyx.org Git - lyx.git/blobdiff - src/Paragraph.cpp
FindAdv: Comments
[lyx.git] / src / Paragraph.cpp
index dc41fb9e965a48d7784f21333296595a54279ae5..5bad896dfdf4e13f0a09bc9d1597e52290332e16 100644 (file)
@@ -913,7 +913,7 @@ int Paragraph::Private::latexSurrogatePair(BufferParams const & bparams,
        if (runparams.local_font)
                fontenc = runparams.local_font->language()->fontenc(bparams);
        else
-               fontenc = runparams.main_fontenc;
+               fontenc = bparams.language->fontenc(bparams);
        docstring scriptmacro;
        docstring cb;
        if (script == "textgreek" || script == "textcyrillic") {
@@ -1143,13 +1143,15 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
        odocstream::pos_type const len = os.os().tellp();
 
        if (inset->forceLTR()
-           && !runparams.use_polyglossia
            && running_font.isRightToLeft()
            // ERT is an exception, it should be output with no
            // decorations at all
            && inset->lyxCode() != ERT_CODE) {
-               if (running_font.language()->lang() == "farsi")
-                       os << "\\beginL" << termcmd;
+               if (runparams.use_polyglossia) {
+                       os << "\\LRE{";
+               } else if (running_font.language()->lang() == "farsi"
+                          || running_font.language()->lang() == "arabic_arabi")
+                       os << "\\textLR{" << termcmd;
                else
                        os << "\\L{";
                close = true;
@@ -1205,12 +1207,8 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
                throw(e);
        }
 
-       if (close) {
-               if (running_font.language()->lang() == "farsi")
-                               os << "\\endL" << termcmd;
-                       else
-                               os << '}';
-       }
+       if (close)
+               os << '}';
 
        if (os.texrow().rows() > previous_row_count) {
                os.texrow().start(owner_->id(), i + 1);
@@ -1234,10 +1232,7 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
                                          pos_type end_pos,
                                          unsigned int & column)
 {
-       // With polyglossia, brackets and stuff need not be reversed
-       // in RTL scripts (see bug #8251)
-       char_type const c = (runparams.use_polyglossia) ?
-               owner_->getUChar(bparams, i) : text_[i];
+       char_type const c = owner_->getUChar(bparams, runparams, i);
 
        if (style.pass_thru || runparams.pass_thru
            || contains(style.pass_thru_chars, c)
@@ -1395,10 +1390,7 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
                        }
                }
                string fontenc;
-               if (running_font.language()->lang() == bparams.language->lang())
-                       fontenc = runparams.main_fontenc;
-               else
-                       fontenc = running_font.language()->fontenc(bparams);
+               fontenc = running_font.language()->fontenc(bparams);
                // "Script chars" need to embraced in \textcyrillic and \textgreek notwithstanding
                // whether they are encodable or not (it only depends on the font encoding)
                if (!runparams.isFullUnicode() && Encodings::isKnownScriptChar(c, script)) {
@@ -1553,21 +1545,52 @@ void Paragraph::Private::validate(LaTeXFeatures & features) const
        // then the contents
        BufferParams const bp = features.runparams().is_child
                ? features.buffer().masterParams() : features.buffer().params();
-       string bscript = "textbaltic";
        for (pos_type i = 0; i < int(text_.size()) ; ++i) {
                char_type c = text_[i];
+               CharInfo const & ci = Encodings::unicodeCharInfo(c);
                if (c == 0x0022) {
                        if (features.runparams().isFullUnicode() && bp.useNonTeXFonts)
                                features.require("textquotedblp");
                        else if (bp.main_font_encoding() != "T1"
                                 || ((&owner_->getFontSettings(bp, i))->language()->internalFontEncoding()))
                                features.require("textquotedbl");
-               } else if (Encodings::isKnownScriptChar(c, bscript)){
+               } else if (ci.textfeature() && contains(ci.textpreamble(), '=')) {
+                       // features that depend on the font or input encoding
+                       string feats = ci.textpreamble();
                        string fontenc = (&owner_->getFontSettings(bp, i))->language()->fontenc(bp);
                        if (fontenc.empty())
                                fontenc = features.runparams().main_fontenc;
-                       if (Encodings::needsScriptWrapper("textbaltic", fontenc))
-                               features.require("textbalticdefs");
+                       while (!feats.empty()) {
+                               string feat;
+                               feats = split(feats, feat, ',');
+                               if (contains(feat, "!=")) {
+                                       // a feature that is required except for the spcified
+                                       // font or input encodings
+                                       string realfeature;
+                                       string const contexts = ltrim(split(feat, realfeature, '!'), "=");
+                                       // multiple encodings are separated by semicolon
+                                       vector<string> context = getVectorFromString(contexts, ";");
+                                       // require feature if the context matches neither current font
+                                       // nor input encoding
+                                       if (std::find(context.begin(), context.end(), fontenc) == context.end()
+                                           && std::find(context.begin(), context.end(),
+                                                        features.runparams().encoding->name()) == context.end())
+                                               features.require(realfeature);
+                               } else if (contains(feat, '=')) {
+                                       // a feature that is required only for the spcified
+                                       // font or input encodings
+                                       string realfeature;
+                                       string const contexts = split(feat, realfeature, '=');
+                                       // multiple encodings are separated by semicolon
+                                       vector<string> context = getVectorFromString(contexts, ";");
+                                       // require feature if the context matches either current font
+                                       // or input encoding
+                                       if (std::find(context.begin(), context.end(), fontenc) != context.end()
+                                           || std::find(context.begin(), context.end(),
+                                                        features.runparams().encoding->name()) != context.end())
+                                               features.require(realfeature);
+                               }
+                       }
                } else if (!bp.use_dash_ligatures
                           && (c == 0x2013 || c == 0x2014)
                           && bp.useNonTeXFonts
@@ -1763,7 +1786,9 @@ void Paragraph::write(ostream & os, BufferParams const & bparams,
 void Paragraph::validate(LaTeXFeatures & features) const
 {
        d->validate(features);
-       if (needsCProtection())
+       bool fragile = features.runparams().moving_arg;
+       fragile |= layout().needprotect;
+       if (needsCProtection(fragile))
                features.require("cprotect");
 }
 
@@ -1967,32 +1992,57 @@ Font const Paragraph::getLayoutFont
 }
 
 
-char_type Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
+char_type Paragraph::getUChar(BufferParams const & bparams,
+                             OutputParams const & rp,
+                             pos_type pos) const
 {
        char_type c = d->text_[pos];
-       if (!getFontSettings(bparams, pos).isRightToLeft())
+
+       // Return unchanged character in LTR languages
+       // or if we use poylglossia/bidi.
+       if (rp.use_polyglossia || !getFontSettings(bparams, pos).isRightToLeft())
                return c;
 
-       // FIXME: The arabic special casing is due to the difference of arabic
-       // round brackets input introduced in r18599. Check if this should be
-       // unified with Hebrew or at least if all bracket types should be
-       // handled the same (file format change in either case).
+       // Without polyglossia/bidi, we need to account for some special cases.
+       // FIXME This needs to be audited!
+       // Check if:
+       // * The input is as expected for all delimiters
+       //   => checked for Hebrew!
+       // * The output matches the display in the LyX workarea
+       //   => checked for Hebrew!
+       // * The special cases below are really necessary
+       //   => checked for Hebrew!
+       // * In arabic_arabi, brackets are transformed to Arabic
+       //   Ornate Parentheses. Is this is really wanted?
+
        string const & lang = getFontSettings(bparams, pos).language()->lang();
-       bool const arabic = lang == "arabic_arabtex" || lang == "arabic_arabi"
-               || lang == "farsi";
        char_type uc = c;
+
+       // 1. In the following languages, parentheses need to be reversed.
+       bool const reverseparens = lang == "hebrew";
+
+       // 2. In the following languages, brackets don't need to be reversed.
+       bool const reversebrackets = lang != "arabic_arabtex"
+                       && lang != "arabic_arabi"
+                       && lang != "farsi";
+
+       // Now swap delimiters if needed.
        switch (c) {
        case '(':
-               uc = arabic ? c : ')';
+               if (reverseparens)
+                       uc = ')';
                break;
        case ')':
-               uc = arabic ? c : '(';
+               if (reverseparens)
+                       uc = '(';
                break;
        case '[':
-               uc = ']';
+               if (reversebrackets)
+                       uc = ']';
                break;
        case ']':
-               uc = '[';
+               if (reversebrackets)
+                       uc = '[';
                break;
        case '{':
                uc = '}';
@@ -2328,13 +2378,13 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
        case LYX_ALIGN_DECIMAL:
                break;
        case LYX_ALIGN_LEFT: {
-               if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+               if (!owner_->getParLanguage(bparams)->rightToLeft())
                        corrected_env(os, begin_tag, "flushleft", code, lastpar, column);
                else
                        corrected_env(os, begin_tag, "flushright", code, lastpar, column);
                break;
        } case LYX_ALIGN_RIGHT: {
-               if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+               if (!owner_->getParLanguage(bparams)->rightToLeft())
                        corrected_env(os, begin_tag, "flushright", code, lastpar, column);
                else
                        corrected_env(os, begin_tag, "flushleft", code, lastpar, column);
@@ -2386,13 +2436,13 @@ bool Paragraph::Private::endTeXParParams(BufferParams const & bparams,
        case LYX_ALIGN_DECIMAL:
                break;
        case LYX_ALIGN_LEFT: {
-               if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+               if (!owner_->getParLanguage(bparams)->rightToLeft())
                        output = corrected_env(os, end_tag, "flushleft", code, lastpar, col);
                else
                        output = corrected_env(os, end_tag, "flushright", code, lastpar, col);
                break;
        } case LYX_ALIGN_RIGHT: {
-               if (owner_->getParLanguage(bparams)->babel() != "hebrew")
+               if (!owner_->getParLanguage(bparams)->rightToLeft())
                        output = corrected_env(os, end_tag, "flushright", code, lastpar, col);
                else
                        output = corrected_env(os, end_tag, "flushleft", code, lastpar, col);
@@ -3357,7 +3407,8 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                                retval += inset->xhtml(xs, np);
                        }
                } else {
-                       char_type c = getUChar(buf.masterBuffer()->params(), i);
+                       char_type c = getUChar(buf.masterBuffer()->params(),
+                                              runparams, i);
                        xs << c;
                }
                font_old = font.fontInfo();
@@ -3447,7 +3498,7 @@ bool Paragraph::isHardHyphenOrApostrophe(pos_type pos) const
 }
 
 
-bool Paragraph::needsCProtection() const
+bool Paragraph::needsCProtection(bool const fragile) const
 {
        // first check the layout of the paragraph, but only in insets
        InsetText const * textinset = inInset().asInsetText();
@@ -3475,7 +3526,7 @@ bool Paragraph::needsCProtection() const
        // now check whether we have insets that need cprotection
        pos_type size = d->text_.size();
        for (pos_type i = 0; i < size; ++i)
-               if (isInset(i) && getInset(i)->needsCProtection(maintext))
+               if (isInset(i) && getInset(i)->needsCProtection(maintext, fragile))
                        return true;
 
        return false;
@@ -4201,6 +4252,9 @@ SpellChecker::Result Paragraph::spellCheck(pos_type & from, pos_type & to,
        docstring word = asString(from, to, AS_STR_INSETS | AS_STR_SKIPDELETE);
        Language * lang = d->getSpellLanguage(from);
 
+       if (getFontSettings(d->inset_owner_->buffer().params(), from).fontInfo().nospellcheck() == FONT_ON)
+               return result;
+
        wl = WordLangTuple(word, lang);
 
        if (word.empty())