return updated;
}
-
namespace {
-// fix the cursor `cur' after characters has been deleted at `where'
-// position. Called by deleteEmptyParagraphMechanism
-void fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where,
- pos_type from, pos_type to)
-{
- // Do nothing if cursor is not in the paragraph where the
- // deletion occurred,
- if (cur.pit() != where.pit())
+
+void deleteSpaces(Paragraph & par, pos_type const from, pos_type to,
+ int num_spaces, bool const trackChanges)
+{
+ if (!num_spaces)
return;
- // If cursor position is after the deletion place update it
- if (cur.pos() > from)
- cur.pos() = max(from, cur.pos() - (to - from));
+ // First, delete spaces marked as inserted
+ int pos = from;
+ while (pos < to && num_spaces > 0) {
+ Change const & change = par.lookupChange(pos);
+ if (change.inserted() && change.currentAuthor()) {
+ par.eraseChar(pos, trackChanges);
+ --num_spaces;
+ --to;
+ } else
+ ++pos;
+ }
- // Check also if we don't want to set the cursor on a spot behind the
- // pagragraph because we erased the last character.
- if (cur.pos() > cur.lastpos())
- cur.pos() = cur.lastpos();
+ // Then remove remaining spaces
+ par.eraseChars(from, from + num_spaces, trackChanges);
}
}
There are still some small problems that can lead to
double spaces stored in the document file or space at
the beginning of paragraphs(). This happens if you have
- the cursor between to spaces and then save. Or if you
- cut and paste and the selection have a space at the
+ the cursor between two spaces and then save. Or if you
+ cut and paste and the selection has a space at the
beginning and then save right after the paste. (Lgb)
*/
// 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.pit() == cur[depth].pit();
+ 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.
+ // them, but only if the cursor has really moved.
if (!same_par_pos) {
// find range of spaces around cursors
- int from = old.pos();
+ pos_type from = old.pos();
while (from > 0
&& oldpar.isLineSeparator(from - 1)
&& !oldpar.isDeleted(from - 1))
--from;
- int to = old.pos();
+ pos_type to = old.pos();
while (to < oldpar.size() - 1
&& oldpar.isLineSeparator(to)
&& !oldpar.isDeleted(to))
++to;
+ int num_spaces = to - from;
+
// If we are not at the extremity of the paragraph, keep one space
if (from != to && from > 0 && to < oldpar.size())
- ++from;
+ --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 (from < to) {
- oldpar.eraseChars(from, to, cur.buffer()->params().track_changes);
-// FIXME: This will not work anymore when we have multiple views of the same buffer
-// In this case, we will have to correct also the cursors held by
-// other bufferviews. It will probably be easier to do that in a more
-// automated way in CursorSlice code. (JMarc 26/09/2001)
- // correct all cursor parts
+ if (num_spaces > 0) {
+ pos_type const oldsize = oldpar.size();
+ deleteSpaces(oldpar, from, to, num_spaces,
+ cur.buffer()->params().track_changes);
+ // correct cur position
+ // FIXME: there can be other cursors pointing there, we should update them
if (same_par) {
- fixCursorAfterDelete(cur[depth], old.top(), from, to);
+ if (cur[depth].pos() >= to)
+ cur[depth].pos() -= oldsize - oldpar.size();
+ else if (cur[depth].pos() > from)
+ cur[depth].pos() = min(from + 1, old.lastpos());
need_anchor_change = true;
}
return true;
}
}
- // only do our magic if we changed paragraph
+ // only do our other magic if we changed paragraph
if (same_par)
return false;
while (from < par.size()
&& (!par.isLineSeparator(from) || par.isDeleted(from)))
++from;
- LYXERR0("from=" << from);
// find string of spaces
pos_type to = from;
while (to < par.size()
&& par.isLineSeparator(to) && !par.isDeleted(to))
++to;
- LYXERR0("to=" << to);
// empty? We are done
if (from == to)
break;
- // if inside the line, keep one space
- if (from > 0 && to < par.size())
- ++from;
- // remove the extra spaces
- if (from < to)
- par.eraseChars(from, to, trackChanges);
+
+ int num_spaces = to - from;
+
+ // If we are not at the extremity of the paragraph, keep one space
+ if (from != to && from > 0 && to < par.size())
+ --num_spaces;
+
+ // Remove spaces if needed
+ deleteSpaces(par, from , to, num_spaces, trackChanges);
}
// don't delete anything if this is the only remaining paragraph
projects / lyx.git / blobdiff