]> git.lyx.org Git - lyx.git/blobdiff - src/Text.cpp
* GuiToolbar.cpp:
[lyx.git] / src / Text.cpp
index 8b7457108de3a337874d9f052424b36594cabb8a..8e6361a6f09449a8b8cc0acff6ed780668787888 100644 (file)
@@ -59,6 +59,7 @@
 #include "insets/InsetSpecialChar.h"
 #include "insets/InsetTabular.h"
 
+#include "support/lassert.h"
 #include "support/convert.h"
 #include "support/debug.h"
 #include "support/docstream.h"
@@ -101,10 +102,10 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
                if (layoutname.empty())
                        layoutname = tclass.defaultLayoutName();
 
-               if (par.forceEmptyLayout()) {
+               if (par.forcePlainLayout()) {
                        // in this case only the empty layout is allowed
                        layoutname = tclass.emptyLayoutName();
-               } else if (par.useEmptyLayout()) {
+               } else if (par.usePlainLayout()) {
                        // in this case, default layout maps to empty layout 
                        if (layoutname == tclass.defaultLayoutName())
                                layoutname = tclass.emptyLayoutName();
@@ -114,16 +115,11 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
                                layoutname = tclass.defaultLayoutName();
                }
 
-               bool hasLayout = tclass.hasLayout(layoutname);
-
-               if (!hasLayout) {
-                       errorList.push_back(ErrorItem(_("Unknown layout"),
-                       bformat(_("Layout '%1$s' does not exist in textclass '%2$s'\nTrying to use the default instead.\n"),
-                       layoutname, from_utf8(tclass.name())), par.id(), 0, par.size()));
-                       layoutname = par.useEmptyLayout() ? 
-                                       tclass.emptyLayoutName() :
-                                       tclass.defaultLayoutName();
-               }
+               // When we apply an unknown layout to a document, we add this layout to the textclass
+               // of this document. For example, when you apply class article to a beamer document,
+               // all unknown layouts such as frame will be added to document class article so that
+               // these layouts can keep their original names.
+               tclass.addLayoutIfNeeded(layoutname);
 
                par.setLayout(bp.documentClass()[layoutname]);
 
@@ -135,10 +131,10 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
                par.params().read(lex);
 
        } else if (token == "\\end_layout") {
-               LYXERR0("Solitary \\end_layout in line " << lex.getLineNo() << "\n"
+               LYXERR0("Solitary \\end_layout in line " << lex.lineNumber() << "\n"
                       << "Missing \\begin_layout ?");
        } else if (token == "\\end_inset") {
-               LYXERR0("Solitary \\end_inset in line " << lex.getLineNo() << "\n"
+               LYXERR0("Solitary \\end_inset in line " << lex.lineNumber() << "\n"
                       << "Missing \\begin_inset ?");
        } else if (token == "\\begin_inset") {
                Inset * inset = readInset(lex, buf);
@@ -206,7 +202,7 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex,
        } else if (token == "\\backslash") {
                par.appendChar('\\', font, change);
        } else if (token == "\\LyXTable") {
-               auto_ptr<Inset> inset(new InsetTabular(buf));
+               auto_ptr<Inset> inset(new InsetTabular(const_cast<Buffer &>(buf)));
                inset->read(lex);
                par.insertInset(par.size(), inset.release(), font, change);
        } else if (token == "\\lyxline") {
@@ -277,7 +273,7 @@ void readParagraph(Buffer const & buf, Paragraph & par, Lexer & lex,
                    || token == "\\end_deeper") {
                        lex.pushToken(token);
                        lyxerr << "Paragraph ended in line "
-                              << lex.getLineNo() << "\n"
+                              << lex.lineNumber() << "\n"
                               << "Missing \\end_layout.\n";
                        break;
                }
@@ -340,7 +336,7 @@ double Text::spacing(Buffer const & buffer, Paragraph const & par) const
 
 void Text::breakParagraph(Cursor & cur, bool inverse_logic)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
 
        Paragraph & cpar = cur.paragraph();
        pit_type cpit = cur.pit();
@@ -417,7 +413,7 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic)
 // same Paragraph one to the right and make a rebreak
 void Text::insertChar(Cursor & cur, char_type c)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
 
        cur.recordUndo(INSERT_UNDO);
 
@@ -529,7 +525,7 @@ void Text::insertChar(Cursor & cur, char_type c)
                        }
                        return;
                }
-               BOOST_ASSERT(cur.pos() > 0);
+               LASSERT(cur.pos() > 0, /**/);
                if ((par.isLineSeparator(cur.pos() - 1) || par.isNewline(cur.pos() - 1))
                    && !par.isDeleted(cur.pos() - 1)) {
                        static bool sent_space_message = false;
@@ -570,7 +566,7 @@ void Text::charInserted(Cursor & cur)
            && par.isLetter(cur.pos() - 2)
            && !par.isLetter(cur.pos() - 1)) {
                // get the word in front of cursor
-               BOOST_ASSERT(this == cur.text());
+               LASSERT(this == cur.text(), /**/);
                cur.paragraph().updateWords(cur.top());
        }
 }
@@ -581,49 +577,173 @@ void Text::charInserted(Cursor & cur)
 
 bool Text::cursorForwardOneWord(Cursor & cur)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
+
+       pos_type const lastpos = cur.lastpos();
+       pit_type pit = cur.pit();
+       pos_type pos = cur.pos();
+       Paragraph const & par = cur.paragraph();
 
-       Cursor old = cur;
+       // Paragraph boundary is a word boundary
+       if (pos == lastpos) {
+               if (pit != cur.lastpit())
+                       return setCursor(cur, pit + 1, 0);
+               else
+                       return false;
+       }
 
-       if (old.pos() == old.lastpos() && old.pit() != old.lastpit()) {
-               ++old.pit();
-               old.pos() = 0;
+       if (lyxrc.mac_like_word_movement) {
+               // Skip through trailing punctuation and spaces.
+               while (pos != lastpos && (par.isChar(pos) || par.isSpace(pos)))
+                        ++pos;
+
+               // Skip over either a non-char inset or a full word
+               if (pos != lastpos && !par.isLetter(pos))
+                       ++pos;
+               else while (pos != lastpos && par.isLetter(pos))
+                            ++pos;
        } else {
-               // Advance through word.
-               while (old.pos() != old.lastpos() && old.paragraph().isLetter(old.pos()))
-                       ++old.pos();
-               // Skip through trailing nonword stuff.
-               while (old.pos() != old.lastpos() && !old.paragraph().isLetter(old.pos()))
-                       ++old.pos();
+               LASSERT(pos < lastpos, /**/); // see above
+               if (par.isLetter(pos))
+                       while (pos != lastpos && par.isLetter(pos))
+                               ++pos;
+               else if (par.isChar(pos))
+                       while (pos != lastpos && par.isChar(pos))
+                               ++pos;
+               else if (!par.isSpace(pos)) // non-char inset
+                       ++pos;
+
+               // Skip over white space
+               while (pos != lastpos && par.isSpace(pos))
+                            ++pos;             
        }
-       return setCursor(cur, old.pit(), old.pos());
+
+       return setCursor(cur, pit, pos);
 }
 
 
 bool Text::cursorBackwardOneWord(Cursor & cur)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
 
-       Cursor old = cur;
+       pit_type pit = cur.pit();
+       pos_type pos = cur.pos();
+       Paragraph & par = cur.paragraph();
+
+       // Paragraph boundary is a word boundary
+       if (pos == 0 && pit != 0)
+               return setCursor(cur, pit - 1, getPar(pit - 1).size());
 
-       if (old.pos() == 0 && old.pit() != 0) {
-               --old.pit();
-               old.pos() = old.lastpos();
+       if (lyxrc.mac_like_word_movement) {
+               // Skip through punctuation and spaces.
+               while (pos != 0 && (par.isChar(pos - 1) || par.isSpace(pos - 1)))
+                       --pos;
+
+               // Skip over either a non-char inset or a full word
+               if (pos != 0 && !par.isLetter(pos - 1) && !par.isChar(pos - 1))
+                       --pos;
+               else while (pos != 0 && par.isLetter(pos - 1))
+                            --pos;
        } else {
-               // Skip through initial nonword stuff.
-               while (old.pos() != 0 && !old.paragraph().isLetter(old.pos() - 1))
-                       --old.pos();
-               // Advance through word.
-               while (old.pos() != 0 && old.paragraph().isLetter(old.pos() - 1))
-                       --old.pos();
+               // Skip over white space
+               while (pos != 0 && par.isSpace(pos - 1))
+                            --pos;
+
+               if (pos != 0 && par.isLetter(pos - 1))
+                       while (pos != 0 && par.isLetter(pos - 1))
+                               --pos;
+               else if (pos != 0 && par.isChar(pos - 1))
+                       while (pos != 0 && par.isChar(pos - 1))
+                               --pos;
+               else if (pos != 0 && !par.isSpace(pos - 1)) // non-char inset
+                       --pos;
        }
-       return setCursor(cur, old.pit(), old.pos());
+
+       return setCursor(cur, pit, pos);
+}
+
+
+bool Text::cursorVisLeftOneWord(Cursor & cur)
+{
+       LASSERT(this == cur.text(), /**/);
+
+       pos_type left_pos, right_pos;
+       bool left_is_letter, right_is_letter;
+
+       Cursor temp_cur = cur;
+
+       // always try to move at least once...
+       while (temp_cur.posVisLeft(true /* skip_inset */)) {
+
+               // collect some information about current cursor position
+               temp_cur.getSurroundingPos(left_pos, right_pos);
+               left_is_letter = 
+                       (left_pos > -1 ? temp_cur.paragraph().isLetter(left_pos) : false);
+               right_is_letter = 
+                       (right_pos > -1 ? temp_cur.paragraph().isLetter(right_pos) : false);
+
+               // if we're not at a letter/non-letter boundary, continue moving
+               if (left_is_letter == right_is_letter)
+                       continue;
+
+               // we should stop when we have an LTR word on our right or an RTL word
+               // on our left
+               if ((left_is_letter && temp_cur.paragraph().getFontSettings(
+                               temp_cur.bv().buffer().params(), 
+                               left_pos).isRightToLeft())
+                       || (right_is_letter && !temp_cur.paragraph().getFontSettings(
+                               temp_cur.bv().buffer().params(), 
+                               right_pos).isRightToLeft()))
+                       break;
+       }
+
+       return setCursor(cur, temp_cur.pit(), temp_cur.pos(), 
+                                        true, temp_cur.boundary());
+}
+
+
+bool Text::cursorVisRightOneWord(Cursor & cur)
+{
+       LASSERT(this == cur.text(), /**/);
+
+       pos_type left_pos, right_pos;
+       bool left_is_letter, right_is_letter;
+
+       Cursor temp_cur = cur;
+
+       // always try to move at least once...
+       while (temp_cur.posVisRight(true /* skip_inset */)) {
+
+               // collect some information about current cursor position
+               temp_cur.getSurroundingPos(left_pos, right_pos);
+               left_is_letter = 
+                       (left_pos > -1 ? temp_cur.paragraph().isLetter(left_pos) : false);
+               right_is_letter = 
+                       (right_pos > -1 ? temp_cur.paragraph().isLetter(right_pos) : false);
+
+               // if we're not at a letter/non-letter boundary, continue moving
+               if (left_is_letter == right_is_letter)
+                       continue;
+
+               // we should stop when we have an LTR word on our right or an RTL word
+               // on our left
+               if ((left_is_letter && temp_cur.paragraph().getFontSettings(
+                               temp_cur.bv().buffer().params(), 
+                               left_pos).isRightToLeft())
+                       || (right_is_letter && !temp_cur.paragraph().getFontSettings(
+                               temp_cur.bv().buffer().params(), 
+                               right_pos).isRightToLeft()))
+                       break;
+       }
+
+       return setCursor(cur, temp_cur.pit(), temp_cur.pos(), 
+                                        true, temp_cur.boundary());
 }
 
 
 void Text::selectWord(Cursor & cur, word_location loc)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
        CursorSlice from = cur.top();
        CursorSlice to = cur.top();
        getWord(from, to, loc);
@@ -641,7 +761,7 @@ void Text::selectWord(Cursor & cur, word_location loc)
 // selection is currently set
 bool Text::selectWordWhenUnderCursor(Cursor & cur, word_location loc)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
        if (cur.selection())
                return false;
        selectWord(cur, loc);
@@ -651,7 +771,7 @@ bool Text::selectWordWhenUnderCursor(Cursor & cur, word_location loc)
 
 void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
 
        if (!cur.selection())
                return;
@@ -797,7 +917,7 @@ void Text::rejectChanges(BufferParams const & bparams)
 
 void Text::deleteWordForward(Cursor & cur)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
        if (cur.lastpos() == 0)
                cursorForward(cur);
        else {
@@ -813,7 +933,7 @@ void Text::deleteWordForward(Cursor & cur)
 
 void Text::deleteWordBackward(Cursor & cur)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
        if (cur.lastpos() == 0)
                cursorBackward(cur);
        else {
@@ -830,7 +950,7 @@ void Text::deleteWordBackward(Cursor & cur)
 // Kill to end of line.
 void Text::changeCase(Cursor & cur, TextCase action)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
        CursorSlice from;
        CursorSlice to;
 
@@ -905,14 +1025,14 @@ bool Text::handleBibitems(Cursor & cur)
        } 
 
        // otherwise reset to default
-       cur.paragraph().setEmptyOrDefaultLayout(bufparams.documentClass());
+       cur.paragraph().setPlainOrDefaultLayout(bufparams.documentClass());
        return true;
 }
 
 
 bool Text::erase(Cursor & cur)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
        bool needsUpdate = false;
        Paragraph & par = cur.paragraph();
 
@@ -959,7 +1079,7 @@ bool Text::erase(Cursor & cur)
 
 bool Text::backspacePos0(Cursor & cur)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
        if (cur.pit() == 0)
                return false;
 
@@ -995,7 +1115,7 @@ bool Text::backspacePos0(Cursor & cur)
        // or the empty layout.
        else if (par.layout() == prevpar.layout()
                 || tclass.isDefaultLayout(par.layout())
-                || tclass.isEmptyLayout(par.layout())) {
+                || tclass.isPlainLayout(par.layout())) {
                cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
                mergeParagraph(bufparams, plist, prevcur.pit());
                needsUpdate = true;
@@ -1012,7 +1132,7 @@ bool Text::backspacePos0(Cursor & cur)
 
 bool Text::backspace(Cursor & cur)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
        bool needsUpdate = false;
        if (cur.pos() == 0) {
                if (cur.pit() == 0)
@@ -1061,7 +1181,7 @@ bool Text::backspace(Cursor & cur)
 
 
 bool Text::dissolveInset(Cursor & cur) {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
 
        if (isMainText(cur.bv().buffer()) || cur.inset().nargs() != 1)
                return false;
@@ -1214,7 +1334,7 @@ bool Text::read(Buffer const & buf, Lexer & lex,
 // Returns the current font and depth as a message.
 docstring Text::currentState(Cursor & cur)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
        Buffer & buf = cur.buffer();
        Paragraph const & par = cur.paragraph();
        odocstringstream os;
@@ -1298,7 +1418,7 @@ docstring Text::getPossibleLabel(Cursor & cur) const
        Layout const * layout = &(pars_[pit].layout());
 
        docstring text;
-       docstring par_text = pars_[pit].asString(false);
+       docstring par_text = pars_[pit].asString();
        string piece;
        // the return string of math matrices might contain linebreaks
        par_text = subst(par_text, '\n', '-');
@@ -1370,7 +1490,7 @@ docstring Text::getPossibleLabel(Cursor & cur) const
 
 void Text::charsTranspose(Cursor & cur)
 {
-       BOOST_ASSERT(this == cur.text());
+       LASSERT(this == cur.text(), /**/);
 
        pos_type pos = cur.pos();
 
@@ -1448,7 +1568,7 @@ docstring Text::previousWord(CursorSlice const & sl) const
                return docstring();
        
        Paragraph const & par = sl.paragraph();
-       return par.asString(from.pos(), to.pos(), false);
+       return par.asString(from.pos(), to.pos());
 }
 
 
@@ -1469,7 +1589,7 @@ CompletionList const * Text::createCompletionList(Cursor const & cur) const
 
 bool Text::insertCompletion(Cursor & cur, docstring const & s, bool /*finished*/)
 {      
-       BOOST_ASSERT(cur.bv().cursor() == cur);
+       LASSERT(cur.bv().cursor() == cur, /**/);
        cur.insert(s);
        cur.bv().cursor() = cur;
        if (!(cur.disp_.update() & Update::Force))