Fix copy&paste bug.

[lyx.git] / src / Text.cpp

diff --git a/src/Text.cpp b/src/Text.cpp
index 31bc420673d83b99a6374a993b0a2bc4a59f6c9c..456a127d41c54e915fcb25c3f09373e702a272b6 100644 (file)
--- a/src/Text.cpp
+++ b/src/Text.cpp
@@ -25,6 +25,7 @@
 #include "buffer_funcs.h"
 #include "BufferParams.h"
 #include "BufferView.h"
+#include "Changes.h"
 #include "Cursor.h"
 #include "ParIterator.h"
 #include "CutAndPaste.h"
@@ -44,7 +45,7 @@
 #include "Paragraph.h"
 #include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
-#include "Undo.h"
+#include "TextMetrics.h"
 #include "VSpace.h"
 #include "WordLangTuple.h"
 
@@ -68,6 +69,7 @@
 #include "support/convert.h"
 
 #include <boost/current_function.hpp>
+#include <boost/next_prior.hpp>
 
 #include <sstream>
 
@@ -356,7 +358,7 @@ double Text::spacing(Buffer const & buffer,
 }
 
 
-void Text::breakParagraph(Cursor & cur, bool keep_layout)
+void Text::breakParagraph(Cursor & cur, bool inverse_logic)
 {
        BOOST_ASSERT(this == cur.text());
 
@@ -381,11 +383,9 @@ void Text::breakParagraph(Cursor & cur, bool keep_layout)
                cpar.eraseChar(cur.pos(), cur.buffer().params().trackChanges);
 
        // What should the layout for the new paragraph be?
-       int preserve_layout = 0;
-       if (keep_layout)
-               preserve_layout = 2;
-       else
-               preserve_layout = layout->isEnvironment();
+       bool keep_layout = inverse_logic ? 
+               !layout->isEnvironment() 
+               : layout->isEnvironment();
 
        // We need to remember this before we break the paragraph, because
        // that invalidates the layout variable
@@ -395,7 +395,7 @@ void Text::breakParagraph(Cursor & cur, bool keep_layout)
        bool const isempty = cpar.allowEmpty() && cpar.empty();
 
        lyx::breakParagraph(cur.buffer().params(), paragraphs(), cpit,
-                        cur.pos(), preserve_layout);
+                        cur.pos(), keep_layout);
 
        // After this, neither paragraph contains any rows!
 
@@ -438,7 +438,7 @@ void Text::insertChar(Cursor & cur, char_type c)
        BOOST_ASSERT(this == cur.text());
        BOOST_ASSERT(c != Paragraph::META_INSET);
 
-       recordUndo(cur, Undo::INSERT);
+       cur.recordUndo(INSERT_UNDO);
 
        TextMetrics const & tm = cur.bv().textMetrics(this);
        Buffer const & buffer = cur.buffer();
@@ -566,11 +566,11 @@ void Text::insertChar(Cursor & cur, char_type c)
 
 //             cur.updateFlags(Update::Force);
        setCursor(cur.top(), cur.pit(), cur.pos() + 1);
-       charInserted();
+       charInserted(cur);
 }
 
 
-void Text::charInserted()
+void Text::charInserted(Cursor & cur)
 {
        // Here we call finishUndo for every 20 characters inserted.
        // This is from my experience how emacs does it. (Lgb)
@@ -578,7 +578,7 @@ void Text::charInserted()
        if (counter < 20) {
                ++counter;
        } else {
-               finishUndo();
+               cur.finishUndo();
                counter = 0;
        }
 }
@@ -664,7 +664,7 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op)
        if (!cur.selection())
                return;
 
-       recordUndoSelection(cur, Undo::ATOMIC);
+       cur.recordUndoSelection();
 
        pit_type begPit = cur.selectionBegin().pit();
        pit_type endPit = cur.selectionEnd().pit();
@@ -753,7 +753,7 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op)
 
        //
 
-       finishUndo();
+       cur.finishUndo();
        cur.clearSelection();
        setCursorIntern(cur, begPit, begPos);
        cur.updateFlags(Update::Force);
@@ -851,7 +851,7 @@ void Text::changeCase(Cursor & cur, Text::TextCase action)
                cursorRightOneWord(cur);
        }
 
-       recordUndoSelection(cur, Undo::ATOMIC);
+       cur.recordUndoSelection();
 
        pit_type begPit = from.pit();
        pit_type endPit = to.pit();
@@ -953,7 +953,7 @@ bool Text::handleBibitems(Cursor & cur)
                }
                Paragraph const & prevpar = prevcur.paragraph();
                if (cur.pit() > 0 && par.layout() == prevpar.layout()) {
-                       recordUndo(cur, Undo::ATOMIC, prevcur.pit());
+                       cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
                        mergeParagraph(bufparams, cur.text()->paragraphs(),
                                       prevcur.pit());
                        updateLabels(cur.buffer());
@@ -978,7 +978,7 @@ bool Text::erase(Cursor & cur)
        if (cur.pos() != cur.lastpos()) {
                // this is the code for a normal delete, not pasting
                // any paragraphs
-               recordUndo(cur, Undo::DELETE);
+               cur.recordUndo(DELETE_UNDO);
                if(!par.eraseChar(cur.pos(), cur.buffer().params().trackChanges)) {
                        // the character has been logically deleted only => skip it
                        cur.top().forwardPos();
@@ -1032,14 +1032,14 @@ bool Text::backspacePos0(Cursor & cur)
        // is it an empty paragraph?
        if (cur.lastpos() == 0
            || (cur.lastpos() == 1 && par.isSeparator(0))) {
-               recordUndo(cur, Undo::ATOMIC, prevcur.pit(), cur.pit());
+               cur.recordUndo(ATOMIC_UNDO, prevcur.pit(), cur.pit());
                plist.erase(boost::next(plist.begin(), cur.pit()));
                needsUpdate = true;
        }
        // is previous par empty?
        else if (prevcur.lastpos() == 0
                 || (prevcur.lastpos() == 1 && prevpar.isSeparator(0))) {
-               recordUndo(cur, Undo::ATOMIC, prevcur.pit(), cur.pit());
+               cur.recordUndo(ATOMIC_UNDO, prevcur.pit(), cur.pit());
                plist.erase(boost::next(plist.begin(), prevcur.pit()));
                needsUpdate = true;
        }
@@ -1049,7 +1049,7 @@ bool Text::backspacePos0(Cursor & cur)
        // Correction: Pasting is always allowed with standard-layout
        else if (par.layout() == prevpar.layout()
                 || par.layout() == tclass.defaultLayout()) {
-               recordUndo(cur, Undo::ATOMIC, prevcur.pit());
+               cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
                mergeParagraph(bufparams, plist, prevcur.pit());
                needsUpdate = true;
        }
@@ -1085,7 +1085,7 @@ bool Text::backspace(Cursor & cur)
        } else {
                // this is the code for a normal backspace, not pasting
                // any paragraphs
-               recordUndo(cur, Undo::DELETE);
+               cur.recordUndo(DELETE_UNDO);
                // We used to do cursorLeftIntern() here, but it is
                // not a good idea since it triggers the auto-delete
                // mechanism. So we do a cursorLeftIntern()-lite,
@@ -1115,7 +1115,7 @@ bool Text::dissolveInset(Cursor & cur) {
        if (isMainText(cur.bv().buffer()) || cur.inset().nargs() != 1)
                return false;
 
-       recordUndoInset(cur);
+       cur.recordUndoInset();
        cur.selHandle(false);
        // save position
        pos_type spos = cur.pos();
@@ -1376,17 +1376,17 @@ docstring Text::getPossibleLabel(Cursor & cur) const
                name = from_ascii(layout->latexname());
 
        // for captions, we just take the caption type
-       Inset * caption_inset = cur.innerInsetOfType(Inset::CAPTION_CODE);
+       Inset * caption_inset = cur.innerInsetOfType(CAPTION_CODE);
        if (caption_inset)
                name = from_ascii(static_cast<InsetCaption *>(caption_inset)->type());
 
        // If none of the above worked, we'll see if we're inside various
        // types of insets and take our abbreviation from them.
        if (name.empty()) {
-               Inset::Code const codes[] = {
-                       Inset::FLOAT_CODE,
-                       Inset::WRAP_CODE,
-                       Inset::FOOT_CODE
+               InsetCode const codes[] = {
+                       FLOAT_CODE,
+                       WRAP_CODE,
+                       FOOT_CODE
                };
                for (unsigned int i = 0; i < (sizeof codes / sizeof codes[0]); ++i) {
                        Inset * float_inset = cur.innerInsetOfType(codes[i]);
@@ -1456,7 +1456,7 @@ void Text::charsTranspose(Cursor & cur)
        // Track the changes if Change Tracking is enabled.
        bool const trackChanges = cur.buffer().params().trackChanges;
 
-       recordUndo(cur);
+       cur.recordUndo();
 
        par.eraseChar(pos2, trackChanges);
        par.eraseChar(pos1, trackChanges);