Correctly set language after intitle paragraphs

[lyx.git] / src / Paragraph.cpp

diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp
index caaa0288f26f8ec9051e4371a61e5f36314a38cf..eb2bb9548cc6f3fe1c152fb4cd0a6da86e75c923 100644 (file)
--- a/src/Paragraph.cpp
+++ b/src/Paragraph.cpp
@@ -1005,7 +1005,7 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
        bool close = false;
        odocstream::pos_type const len = os.os().tellp();
 
-       if (inset->forceLTR()
+       if (inset->forceLTR(runparams)
            && running_font.isRightToLeft()
            // ERT is an exception, it should be output with no
            // decorations at all
@@ -1860,8 +1860,9 @@ char_type Paragraph::getUChar(BufferParams const & bparams,
        char_type c = d->text_[pos];
 
        // Return unchanged character in LTR languages
-       // or if we use poylglossia/bidi.
-       if (rp.use_polyglossia || !getFontSettings(bparams, pos).isRightToLeft())
+       // or if we use poylglossia/bidi (XeTeX).
+       if (rp.useBidiPackage()
+           || !getFontSettings(bparams, pos).isRightToLeft())
                return c;
 
        // Without polyglossia/bidi, we need to account for some special cases.
@@ -1880,7 +1881,8 @@ char_type Paragraph::getUChar(BufferParams const & bparams,
        char_type uc = c;
 
        // 1. In the following languages, parentheses need to be reversed.
-       bool const reverseparens = lang == "hebrew";
+       //    Also with polyglodia/luabidi
+       bool const reverseparens = (lang == "hebrew" || rp.use_polyglossia);
 
        // 2. In the following languages, brackets don't need to be reversed.
        bool const reversebrackets = lang != "arabic_arabtex"
@@ -1983,15 +1985,29 @@ depth_type Paragraph::getMaxDepthAfter() const
 }
 
 
-LyXAlignment Paragraph::getAlign() const
+LyXAlignment Paragraph::getAlign(BufferParams const & bparams) const
 {
        if (d->params_.align() == LYX_ALIGN_LAYOUT)
-               return d->layout_->align;
+               return getDefaultAlign(bparams);
        else
                return d->params_.align();
 }
 
 
+LyXAlignment Paragraph::getDefaultAlign(BufferParams const & bparams) const
+{
+       LyXAlignment res = layout().align;
+       if (isRTL(bparams)) {
+               // Swap sides
+               if (res == LYX_ALIGN_LEFT)
+                       res = LYX_ALIGN_RIGHT;
+               else if  (res == LYX_ALIGN_RIGHT)
+                       res = LYX_ALIGN_LEFT;
+       }
+       return res;
+}
+
+
 docstring const & Paragraph::labelString() const
 {
        return d->params_.labelString();
@@ -2231,8 +2247,9 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams,
        InsetCode code = ownerCode();
        bool const lastpar = runparams.isLastPar;
        // RTL in classic (PDF)LaTeX (without the Bidi package)
+       // Luabibdi (used by LuaTeX) behaves like classic
        bool const rtl_classic = owner_->getParLanguage(bparams)->rightToLeft()
-               && !runparams.use_polyglossia;
+               && !runparams.useBidiPackage();
 
        switch (curAlign) {
        case LYX_ALIGN_NONE:
@@ -2294,8 +2311,9 @@ bool Paragraph::Private::endTeXParParams(BufferParams const & bparams,
        InsetCode code = ownerCode();
        bool const lastpar = runparams.isLastPar;
        // RTL in classic (PDF)LaTeX (without the Bidi package)
+       // Luabibdi (used by LuaTeX) behaves like classic
        bool const rtl_classic = owner_->getParLanguage(bparams)->rightToLeft()
-               && !runparams.use_polyglossia;
+               && !runparams.useBidiPackage();
 
        switch (curAlign) {
        case LYX_ALIGN_NONE:
@@ -2730,7 +2748,7 @@ void Paragraph::latex(BufferParams const & bparams,
                runparams.post_macro = rp.post_macro;
        }
 
-    // Close wrapper for alien script
+       // Close wrapper for alien script
        if (!alien_script.empty()) {
                os << "}";
                alien_script.clear();
@@ -3020,7 +3038,7 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
 
        FontShape  curr_fs   = INHERIT_SHAPE;
        FontFamily curr_fam  = INHERIT_FAMILY;
-       FontSize   curr_size = FONT_SIZE_INHERIT;
+       FontSize   curr_size = INHERIT_SIZE;
 
        string const default_family =
                buf.masterBuffer()->params().fonts_default_family;
@@ -3185,41 +3203,41 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                if (old_size != curr_size) {
                        if (size_flag) {
                                switch (old_size) {
-                               case FONT_SIZE_TINY:
+                               case TINY_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_TINY));
                                        break;
-                               case FONT_SIZE_SCRIPT:
+                               case SCRIPT_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_SCRIPT));
                                        break;
-                               case FONT_SIZE_FOOTNOTE:
+                               case FOOTNOTE_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_FOOTNOTE));
                                        break;
-                               case FONT_SIZE_SMALL:
+                               case SMALL_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_SMALL));
                                        break;
-                               case FONT_SIZE_LARGE:
+                               case LARGE_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGE));
                                        break;
-                               case FONT_SIZE_LARGER:
+                               case LARGER_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGER));
                                        break;
-                               case FONT_SIZE_LARGEST:
+                               case LARGEST_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_LARGEST));
                                        break;
-                               case FONT_SIZE_HUGE:
+                               case HUGE_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_HUGE));
                                        break;
-                               case FONT_SIZE_HUGER:
+                               case HUGER_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_HUGER));
                                        break;
-                               case FONT_SIZE_INCREASE:
+                               case INCREASE_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_INCREASE));
                                        break;
-                               case FONT_SIZE_DECREASE:
+                               case DECREASE_SIZE:
                                        tagsToClose.push_back(html::EndFontTag(html::FT_SIZE_DECREASE));
                                        break;
-                               case FONT_SIZE_INHERIT:
-                               case FONT_SIZE_NORMAL:
+                               case INHERIT_SIZE:
+                               case NORMAL_SIZE:
                                        break;
                                default:
                                        // the other tags are for internal use
@@ -3229,52 +3247,52 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                                size_flag = false;
                        }
                        switch (curr_size) {
-                       case FONT_SIZE_TINY:
+                       case TINY_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_TINY));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_SCRIPT:
+                       case SCRIPT_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_SCRIPT));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_FOOTNOTE:
+                       case FOOTNOTE_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_FOOTNOTE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_SMALL:
+                       case SMALL_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_SMALL));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_LARGE:
+                       case LARGE_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_LARGER:
+                       case LARGER_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGER));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_LARGEST:
+                       case LARGEST_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_LARGEST));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_HUGE:
+                       case HUGE_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_HUGE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_HUGER:
+                       case HUGER_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_HUGER));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_INCREASE:
+                       case INCREASE_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_INCREASE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_DECREASE:
+                       case DECREASE_SIZE:
                                tagsToOpen.push_back(html::FontTag(html::FT_SIZE_DECREASE));
                                size_flag = true;
                                break;
-                       case FONT_SIZE_NORMAL:
-                       case FONT_SIZE_INHERIT:
+                       case NORMAL_SIZE:
+                       case INHERIT_SIZE:
                                break;
                        default:
                                // the other tags are for internal use