Fix bug 2029 (RtL space width)

[lyx.git] / src / CutAndPaste.C

diff --git a/src/CutAndPaste.C b/src/CutAndPaste.C
index e5d2cdb8b624794092c61b114e16c8d88174f08a..25193a4a07cf335c0d43d47c853b38d2bc3c957a 100644 (file)
--- a/src/CutAndPaste.C
+++ b/src/CutAndPaste.C
@@ -68,6 +68,11 @@ typedef limited_stack<pair<ParagraphList, textclass_type> > CutStack;
 
 CutStack theCuts(10);
 
+// store whether the tabular stack is newer than the normal copy stack
+// FIXME: this is a workaround for bug 1919. Should be removed for 1.5, 
+// when we (hopefully) have a one-for-all paste mechanism.
+bool dirty_tabular_stack_;
+
 class resetOwnerAndChanges : public std::unary_function<Paragraph, void> {
 public:
        void operator()(Paragraph & p) const {
@@ -253,41 +258,50 @@ PitPosPair eraseSelectionHelper(BufferParams const & params,
        pit_type startpit, pit_type endpit,
        int startpos, int endpos, bool doclear)
 {
+        // Start of selection is really invalid.
        if (startpit == pit_type(pars.size()) ||
            (startpos > pars[startpit].size()))
                return PitPosPair(endpit, endpos);
 
+        // Start and end is inside same paragraph
        if (endpit == pit_type(pars.size()) ||
            startpit == endpit) {
                endpos -= pars[startpit].erase(startpos, endpos);
                return PitPosPair(endpit, endpos);
        }
 
-       // clear end/begin fragments of the first/last par in selection
        bool all_erased = true;
 
+        // Clear fragments of the first par in selection
        pars[startpit].erase(startpos, pars[startpit].size());
        if (pars[startpit].size() != startpos)
                all_erased = false;
 
+        // Clear fragments of the last par in selection
        endpos -= pars[endpit].erase(0, endpos);
        if (endpos != 0)
                all_erased = false;
 
-       // Loop through the deleted pars if any, erasing as needed
-       for (pit_type pit = startpit + 1; pit != endpit;) {
-               // "erase" the contents of the par
-               pars[pit].erase(0, pars[pit].size());
-               if (!pars[pit].size()) {
-                       // remove the par if it's now empty
-                       pars.erase(pars.begin() + pit);
-                       --endpit;
-               } else {
-                       ++pit;
-                       all_erased = false;
+        // Erase all the "middle" paragraphs.
+       if (params.tracking_changes) {
+               // Look through the deleted pars if any, erasing as needed
+               for (pit_type pit = startpit + 1; pit != endpit;) {
+                       // "erase" the contents of the par
+                       pars[pit].erase(0, pars[pit].size());
+                       if (pars[pit].empty()) {
+                               // remove the par if it's now empty
+                               pars.erase(pars.begin() + pit);
+                               --endpit;
+                       } else {
+                               ++pit;
+                               all_erased = false;
+                       }
                }
+       } else {
+               pars.erase(pars.begin() + startpit + 1, pars.begin() + endpit);
+               endpit = startpit + 1;
        }
-
+       
 #if 0 // FIXME: why for cut but not copy ?
        // the cut selection should begin with standard layout
        if (realcut) {
@@ -304,18 +318,17 @@ PitPosPair eraseSelectionHelper(BufferParams const & params,
                pars[startpit + 1].stripLeadingSpaces();
        }
 
-       // paste the paragraphs again, if possible
+       // Merge first and last paragraph, if possible
        if (all_erased &&
            (pars[startpit].hasSameLayout(pars[startpit + 1]) ||
             pars[startpit + 1].empty())) {
                mergeParagraph(params, pars, startpit);
-               // this because endpar gets deleted here!
+               // This because endpar gets deleted here!
                endpit = startpit;
                endpos = startpos;
        }
 
        return PitPosPair(endpit, endpos);
-
 }
 
 
@@ -329,6 +342,7 @@ void copySelectionHelper(ParagraphList & pars,
 
        // Clone the paragraphs within the selection.
        ParagraphList paragraphs(pars.begin() + startpit, pars.begin() + endpit + 1);
+
        for_each(paragraphs.begin(), paragraphs.end(), resetOwnerAndChanges());
 
        // Cut out the end of the last paragraph.
@@ -342,18 +356,6 @@ void copySelectionHelper(ParagraphList & pars,
        theCuts.push(make_pair(paragraphs, tc));
 }
 
-
-
-PitPosPair cutSelectionHelper(BufferParams const & params,
-       ParagraphList & pars, pit_type startpit, pit_type endpit,
-       int startpos, int endpos, textclass_type tc, bool doclear)
-{
-       copySelectionHelper(pars, startpit, endpit, startpos, endpos, tc);
-       return eraseSelectionHelper(params, pars, startpit, endpit,
-               startpos, endpos, doclear);
-}
-
-
 } // namespace anon
 
 
@@ -490,7 +492,7 @@ void cutSelection(LCursor & cur, bool doclear, bool realcut)
                // finished. The solution used currently just works, to make it
                // faster we need to be more clever and probably also have more
                // calls to stuffClipboard. (Lgb)
-               cur.bv().stuffClipboard(cur.selectionAsString(true));
+//             cur.bv().stuffClipboard(cur.selectionAsString(true));
 
                // This doesn't make sense, if there is no selection
                if (!cur.selection())
@@ -534,6 +536,9 @@ void cutSelection(LCursor & cur, bool doclear, bool realcut)
                // need a valid cursor. (Lgb)
                cur.clearSelection();
                updateCounters(cur.buffer());
+
+               // tell tabular that a recent copy happened
+               dirtyTabularStack(false);
        }
 
        if (cur.inMathed()) {
@@ -584,6 +589,8 @@ void copySelection(LCursor & cur)
                pars.back().insert(0, grabSelection(cur), LyXFont());
                theCuts.push(make_pair(pars, bp.textclass));
        }
+       // tell tabular that a recent copy happened
+       dirtyTabularStack(false);
 }
 
 
@@ -615,10 +622,10 @@ void pasteSelection(LCursor & cur, size_t sel_index)
 
                boost::tie(ppp, endpit) =
                        pasteSelectionHelper(cur.buffer(),
-                                                               text->paragraphs(),
-                                                               cur.pit(), cur.pos(),
-                                                               cur.buffer().params().textclass,
-                                                               sel_index, el);
+                                             text->paragraphs(),
+                                             cur.pit(), cur.pos(),
+                                             cur.buffer().params().textclass,
+                                             sel_index, el);
                bufferErrors(cur.buffer(), el);
                cur.bv().showErrorList(_("Paste"));
 
@@ -782,5 +789,17 @@ string grabSelection(LCursor & cur)
 }
 
 
+void dirtyTabularStack(bool b)
+{
+       dirty_tabular_stack_ = b;
+}
+
+
+bool tabularStackDirty()
+{
+       return dirty_tabular_stack_;
+}
+
+
 } // namespace cap
 } // namespace lyx