DEPM: reorganize a bit (no change intended)

Exit early if the cursor has not moved.

Place comments where they belong.

diff --git a/src/Text2.cpp b/src/Text2.cpp
index d70dfc15cae4bb2f59ac2e83f21204d5eabce28d..e4c0c2614edcbf79b3d4076becae0f5d0f80b81b 100644 (file)
--- a/src/Text2.cpp
+++ b/src/Text2.cpp
@@ -819,6 +819,10 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
        Paragraph & oldpar = old.paragraph();
        bool const trackChanges = cur.buffer()->params().track_changes;
 
+       // We do nothing if cursor did not move
+       if (cur.top() == old.top())
+               return false;
+
        // We do not do anything on read-only documents
        if (cur.buffer()->isReadonly())
                return false;
@@ -827,6 +831,22 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
        if (oldpar.isFreeSpacing())
                return false;
 
+       // Find a common inset and the corresponding depth.
+       size_t depth = 0;
+       for (; depth < cur.depth(); ++depth)
+               if (&old.inset() == &cur[depth].inset())
+                       break;
+
+       // Whether a common inset is found and whether the cursor is still in
+       // the same paragraph (possibly nested).
+       bool const same_par = depth < cur.depth() && old.idx() == cur[depth].idx()
+               && old.pit() == cur[depth].pit();
+
+       /*
+        * (1) If the chars around the old cursor were spaces, delete some of
+        * them, but only if the cursor has really moved.
+        */
+
        /* Ok I'll put some comments here about what is missing.
           There are still some small problems that can lead to
           double spaces stored in the document file or space at
@@ -844,61 +864,48 @@ bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
        // delete the LineSeparator.
        // MISSING
 
-       // Find a common inset and the corresponding depth.
-       size_t depth = 0;
-       for (; depth < cur.depth(); ++depth)
-               if (&old.inset() == &cur[depth].inset())
-                       break;
-
-       // Whether a common inset is found and whether the cursor is still in
-       // the same paragraph (possibly nested).
-       bool const same_par = depth < cur.depth() && old.idx() == cur[depth].idx()
-               && old.pit() == cur[depth].pit();
-       bool const same_par_pos = depth == cur.depth() - 1 && same_par
-               && old.pos() == cur[depth].pos();
-
-       // If the chars around the old cursor were spaces, delete some of
-       // them, but only if the cursor has really moved.
-       if (!same_par_pos) {
-               // find range of spaces around cursors
-               pos_type from = old.pos();
-               while (from > 0
-                      && oldpar.isLineSeparator(from - 1)
-                      && !oldpar.isDeleted(from - 1))
-                       --from;
-               pos_type to = old.pos();
-               while (to < old.lastpos()
-                      && oldpar.isLineSeparator(to)
-                      && !oldpar.isDeleted(to))
-                       ++to;
-
-               int num_spaces = to - from;
-               // If we are not at the start of the paragraph, keep one space
-               if (from != to && from > 0)
-                       --num_spaces;
-
-               // If cursor is inside range, keep one additional space
-               if (same_par && cur.pos() > from && cur.pos() < to)
-                       --num_spaces;
-
-               // Remove spaces and adapt cursor.
-               if (num_spaces > 0) {
-                       old.recordUndo();
-                       int const deleted =
-                               deleteSpaces(oldpar, from, to, num_spaces, trackChanges);
-                       // correct cur position
-                       // FIXME: there can be other cursors pointing there, we should update them
-                       if (same_par) {
-                               if (cur[depth].pos() >= to)
-                                       cur[depth].pos() -= deleted;
-                               else if (cur[depth].pos() > from)
-                                       cur[depth].pos() = min(from + 1, old.lastpos());
-                               need_anchor_change = true;
-                       }
-                       return true;
+       // find range of spaces around cursors
+       pos_type from = old.pos();
+       while (from > 0
+                  && oldpar.isLineSeparator(from - 1)
+                  && !oldpar.isDeleted(from - 1))
+               --from;
+       pos_type to = old.pos();
+       while (to < old.lastpos()
+                  && oldpar.isLineSeparator(to)
+                  && !oldpar.isDeleted(to))
+               ++to;
+
+       int num_spaces = to - from;
+       // If we are not at the start of the paragraph, keep one space
+       if (from != to && from > 0)
+               --num_spaces;
+
+       // If cursor is inside range, keep one additional space
+       if (same_par && cur.pos() > from && cur.pos() < to)
+               --num_spaces;
+
+       // Remove spaces and adapt cursor.
+       if (num_spaces > 0) {
+               old.recordUndo();
+               int const deleted =
+                       deleteSpaces(oldpar, from, to, num_spaces, trackChanges);
+               // correct cur position
+               // FIXME: there can be other cursors pointing there, we should update them
+               if (same_par) {
+                       if (cur[depth].pos() >= to)
+                               cur[depth].pos() -= deleted;
+                       else if (cur[depth].pos() > from)
+                               cur[depth].pos() = min(from + 1, old.lastpos());
+                       need_anchor_change = true;
                }
+               return true;
        }
 
+       /*
+        * (2) If the paragraph where the cursor was is empty, delete it
+        */
+
        // only do our other magic if we changed paragraph
        if (same_par)
                return false;