Fix bug #7059: Display the vertical alignment of tables.

[lyx.git] / src / Paragraph.cpp

diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp
index 359606a96641211be5f7a1c2e3458246a04b0884..d44d0473e11f7ad8384429d5e82ace4b794040db 100644 (file)
--- a/src/Paragraph.cpp
+++ b/src/Paragraph.cpp
@@ -51,6 +51,7 @@
 
 #include "insets/InsetBibitem.h"
 #include "insets/InsetLabel.h"
+#include "insets/InsetSpecialChar.h"
 
 #include "support/debug.h"
 #include "support/docstring_list.h"
@@ -153,6 +154,12 @@ public:
                needsRefresh(pos);
        }
 
+       void refreshLast(pos_type pos)
+       {
+               if (pos < refresh_.last)
+                       refresh_.last = pos;
+       }
+
        SpellChecker::Result getState(pos_type pos) const
        {
                SpellChecker::Result result = SpellChecker::WORD_OK;
@@ -784,6 +791,7 @@ bool Paragraph::eraseChar(pos_type pos, bool trackChanges)
 
        // Update list of misspelled positions
        d->speller_state_.decreasePosAfterPos(pos);
+       d->speller_state_.refreshLast(size());
 
        return true;
 }
@@ -1104,7 +1112,7 @@ void Paragraph::Private::latexInset(BufferParams const & bparams,
                texrow.start(owner_->id(), i + 1);
                column = 0;
        } else {
-               column += os.tellp() - len;
+               column += (unsigned int)(os.tellp() - len);
        }
 
        if (owner_->isDeleted(i))
@@ -2361,12 +2369,16 @@ void Paragraph::latex(BufferParams const & bparams,
                        open_font = false;
                }
 
+               string const running_lang = runparams.use_polyglossia ?
+                       running_font.language()->polyglossia() : running_font.language()->babel();
                // close babel's font environment before opening CJK.
-               if (!running_font.language()->babel().empty() &&
+               string const lang_end_command = runparams.use_polyglossia ?
+                       "\\end{$$lang}" : lyxrc.language_command_end;
+               if (!running_lang.empty() &&
                    font.language()->encoding()->package() == Encoding::CJK) {
-                               string end_tag = subst(lyxrc.language_command_end,
+                               string end_tag = subst(lang_end_command,
                                                        "$$lang",
-                                                       running_font.language()->babel());
+                                                       running_lang);
                                os << from_ascii(end_tag);
                                column += end_tag.length();
                }
@@ -2504,7 +2516,7 @@ void Paragraph::latex(BufferParams const & bparams,
        if (allowcust && d->endTeXParParams(bparams, os, texrow, runparams)
            && runparams.encoding != prev_encoding) {
                runparams.encoding = prev_encoding;
-               if (!bparams.useXetex)
+               if (!runparams.isFullUnicode())
                        os << setEncoding(prev_encoding->iconvName());
        }
 
@@ -2718,13 +2730,9 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
 
                Inset const * inset = getInset(i);
                if (inset) {
-                       InsetCommand const * ic = inset->asInsetCommand();
-                       InsetLayout const & il = inset->getLayout();
-                       InsetMath const * im = inset->asInsetMath();
-                       if (!runparams.for_toc
-                           || im || il.isInToc() || (ic && ic->isInToc())) {
+                       if (!runparams.for_toc || inset->isInToc()) {
                                OutputParams np = runparams;
-                               if (!il.htmlisblock())
+                               if (!inset->getLayout().htmlisblock())
                                        np.html_in_par = true;
                                retval += inset->xhtml(xs, np);
                        }
@@ -2751,7 +2759,7 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                                // We don't want to escape the entities. Note that
                                // it is safe to do this, since str can otherwise
                                // only be "-". E.g., it can't be "<".
-                               xs << XHTMLStream::NextRaw() << str;
+                               xs << XHTMLStream::ESCAPE_NONE << str;
                        } else
                                xs << c;
                }
@@ -3093,8 +3101,8 @@ int Paragraph::checkBiblio(Buffer const & buffer)
        InsetList::iterator end = d->insetlist_.end();
        for (; it != end; ++it)
                if (it->inset->lyxCode() == BIBITEM_CODE
-                   && it->pos > 0) {
-                       InsetBibitem * olditem = static_cast<InsetBibitem *>(it->inset);
+                     && it->pos > 0) {
+                       InsetCommand * olditem = it->inset->asInsetCommand();
                        oldkey = olditem->getParam("key");
                        oldlabel = olditem->getParam("label");
                        erasedInsetPosition = it->pos;
@@ -3110,8 +3118,7 @@ int Paragraph::checkBiblio(Buffer const & buffer)
        // There was an InsetBibitem at the beginning and we did have to
        // erase one. So we give its properties to the beginning inset.
        if (hasbibitem) {
-               InsetBibitem * inset =
-                       static_cast<InsetBibitem *>(d->insetlist_.begin()->inset);
+               InsetCommand * inset = d->insetlist_.begin()->inset->asInsetCommand();
                if (!oldkey.empty())
                        inset->setParam("key", oldkey);
                inset->setParam("label", oldlabel);
@@ -3126,7 +3133,7 @@ int Paragraph::checkBiblio(Buffer const & buffer)
        if (!oldkey.empty())
                inset->setParam("key", oldkey);
        inset->setParam("label", oldlabel);
-       insertInset(0, static_cast<Inset *>(inset),
+       insertInset(0, inset,
                    Change(track_changes ? Change::INSERTED : Change::UNCHANGED));
 
        return 1;
@@ -3256,36 +3263,44 @@ void Paragraph::changeCase(BufferParams const & bparams, pos_type pos,
 }
 
 
-bool Paragraph::find(docstring const & str, bool cs, bool mw,
-               pos_type pos, bool del) const
+int Paragraph::find(docstring const & str, bool cs, bool mw,
+               pos_type start_pos, bool del) const
 {
+       pos_type pos = start_pos;
        int const strsize = str.length();
        int i = 0;
        pos_type const parsize = d->text_.size();
-       for (i = 0; pos + i < parsize; ++i) {
-               if (i >= strsize)
-                       break;
-               if (cs && str[i] != d->text_[pos + i])
+       for (i = 0; i < strsize && pos < parsize; ++i, ++pos) {
+               // Ignore ligature break and hyphenation chars while searching
+               while (pos < parsize - 1 && isInset(pos)) {
+                       const InsetSpecialChar *isc = dynamic_cast<const InsetSpecialChar*>(getInset(pos));
+                       if (isc == 0
+                           || (isc->kind() != InsetSpecialChar::HYPHENATION
+                               && isc->kind() != InsetSpecialChar::LIGATURE_BREAK))
+                               break;
+                       pos++;
+               }
+               if (cs && str[i] != d->text_[pos])
                        break;
-               if (!cs && uppercase(str[i]) != uppercase(d->text_[pos + i]))
+               if (!cs && uppercase(str[i]) != uppercase(d->text_[pos]))
                        break;
-               if (!del && isDeleted(pos + i))
+               if (!del && isDeleted(pos))
                        break;
        }
 
        if (i != strsize)
-               return false;
+               return 0;
 
        // if necessary, check whether string matches word
        if (mw) {
-               if (pos > 0 && !isWordSeparator(pos - 1))
-                       return false;
-               if (pos + strsize < parsize
-                       && !isWordSeparator(pos + strsize))
-                       return false;
+               if (start_pos > 0 && !isWordSeparator(start_pos - 1))
+                       return 0;
+               if (pos < parsize
+                       && !isWordSeparator(pos))
+                       return 0;
        }
 
-       return true;
+       return pos - start_pos;
 }