3 * This file is part of LyX, the document processor.
4 * Licence details can be found in the file COPYING.
6 * \author Asger Alstrup
7 * \author Lars Gullik Bjønnes
8 * \author Alfredo Braunstein
9 * \author Jean-Marc Lasgouttes
10 * \author Angus Leeming
12 * \author André Pönitz
14 * \author Stefan Schimanski
16 * \author Jürgen Vigna
18 * Full author contact details are available in file CREDITS.
27 #include "buffer_funcs.h"
28 #include "BufferList.h"
29 #include "BufferParams.h"
30 #include "BufferView.h"
33 #include "CutAndPaste.h"
34 #include "DispatchResult.h"
35 #include "ErrorList.h"
41 #include "Paragraph.h"
42 #include "ParagraphParameters.h"
43 #include "TextClass.h"
44 #include "TextMetrics.h"
47 #include "insets/InsetCollapsable.h"
49 #include "mathed/InsetMathHull.h"
51 #include "support/lassert.h"
52 #include "support/debug.h"
53 #include "support/gettext.h"
54 #include "support/textutils.h"
56 #include <boost/next_prior.hpp>
64 bool Text::isMainText() const
66 return &owner_->buffer().text() == this;
70 // Note that this is supposed to return a fully realized font.
71 FontInfo Text::layoutFont(pit_type const pit) const
73 Layout const & layout = pars_[pit].layout();
75 if (!pars_[pit].getDepth()) {
76 FontInfo lf = layout.resfont;
77 // In case the default family has been customized
78 if (layout.font.family() == INHERIT_FAMILY)
79 lf.setFamily(owner_->buffer().params().getFont().fontInfo().family());
81 // It ought to be possible here just to use Inset::getLayout() and skip
82 // the asInsetCollapsable() bit. Unfortunatley, that doesn't work right
83 // now, because Inset::getLayout() will return a default-constructed
84 // InsetLayout, and that e.g. sets the foreground color to red. So we
85 // need to do some work to make that possible.
86 InsetCollapsable const * icp = owner_->asInsetCollapsable();
89 FontInfo icf = icp->getLayout().font();
94 FontInfo font = layout.font;
95 // Realize with the fonts of lesser depth.
96 //font.realize(outerFont(pit));
97 font.realize(owner_->buffer().params().getFont().fontInfo());
103 // Note that this is supposed to return a fully realized font.
104 FontInfo Text::labelFont(Paragraph const & par) const
106 Buffer const & buffer = owner_->buffer();
107 Layout const & layout = par.layout();
109 if (!par.getDepth()) {
110 FontInfo lf = layout.reslabelfont;
111 // In case the default family has been customized
112 if (layout.labelfont.family() == INHERIT_FAMILY)
113 lf.setFamily(buffer.params().getFont().fontInfo().family());
117 FontInfo font = layout.labelfont;
118 // Realize with the fonts of lesser depth.
119 font.realize(buffer.params().getFont().fontInfo());
125 void Text::setCharFont(pit_type pit,
126 pos_type pos, Font const & fnt, Font const & display_font)
128 Buffer const & buffer = owner_->buffer();
130 Layout const & layout = pars_[pit].layout();
132 // Get concrete layout font to reduce against
135 if (pos < pars_[pit].beginOfBody())
136 layoutfont = layout.labelfont;
138 layoutfont = layout.font;
140 // Realize against environment font information
141 if (pars_[pit].getDepth()) {
143 while (!layoutfont.resolved() &&
144 tp != pit_type(paragraphs().size()) &&
145 pars_[tp].getDepth()) {
147 if (tp != pit_type(paragraphs().size()))
148 layoutfont.realize(pars_[tp].layout().font);
152 // Inside inset, apply the inset's font attributes if any
155 layoutfont.realize(display_font.fontInfo());
157 layoutfont.realize(buffer.params().getFont().fontInfo());
159 // Now, reduce font against full layout font
160 font.fontInfo().reduce(layoutfont);
162 pars_[pit].setFont(pos, font);
166 void Text::setInsetFont(BufferView const & bv, pit_type pit,
167 pos_type pos, Font const & font, bool toggleall)
169 Inset * const inset = pars_[pit].getInset(pos);
170 LASSERT(inset && inset->resetFontEdit(), /**/);
172 CursorSlice::idx_type endidx = inset->nargs();
173 for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
174 Text * text = cs.text();
176 // last position of the cell
177 CursorSlice cellend = cs;
178 cellend.pit() = cellend.lastpit();
179 cellend.pos() = cellend.lastpos();
180 text->setFont(bv, cs, cellend, font, toggleall);
186 // return past-the-last paragraph influenced by a layout change on pit
187 pit_type Text::undoSpan(pit_type pit)
189 pit_type const end = paragraphs().size();
190 pit_type nextpit = pit + 1;
193 //because of parindents
194 if (!pars_[pit].getDepth())
195 return boost::next(nextpit);
196 //because of depth constrains
197 for (; nextpit != end; ++pit, ++nextpit) {
198 if (!pars_[pit].getDepth())
205 void Text::setLayout(pit_type start, pit_type end,
206 docstring const & layout)
208 LASSERT(start != end, /**/);
210 Buffer const & buffer = owner_->buffer();
211 BufferParams const & bp = buffer.params();
212 Layout const & lyxlayout = bp.documentClass()[layout];
214 for (pit_type pit = start; pit != end; ++pit) {
215 Paragraph & par = pars_[pit];
216 par.applyLayout(lyxlayout);
217 if (lyxlayout.margintype == MARGIN_MANUAL)
218 par.setLabelWidthString(par.expandLabel(lyxlayout, bp));
223 // set layout over selection and make a total rebreak of those paragraphs
224 void Text::setLayout(Cursor & cur, docstring const & layout)
226 LASSERT(this == cur.text(), /**/);
228 pit_type start = cur.selBegin().pit();
229 pit_type end = cur.selEnd().pit() + 1;
230 pit_type undopit = undoSpan(end - 1);
231 recUndo(cur, start, undopit - 1);
232 setLayout(start, end, layout);
233 cur.forceBufferUpdate();
237 static bool changeDepthAllowed(Text::DEPTH_CHANGE type,
238 Paragraph const & par, int max_depth)
240 if (par.layout().labeltype == LABEL_BIBLIO)
242 int const depth = par.params().depth();
243 if (type == Text::INC_DEPTH && depth < max_depth)
245 if (type == Text::DEC_DEPTH && depth > 0)
251 bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
253 LASSERT(this == cur.text(), /**/);
254 // this happens when selecting several cells in tabular (bug 2630)
255 if (cur.selBegin().idx() != cur.selEnd().idx())
258 pit_type const beg = cur.selBegin().pit();
259 pit_type const end = cur.selEnd().pit() + 1;
260 int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
262 for (pit_type pit = beg; pit != end; ++pit) {
263 if (lyx::changeDepthAllowed(type, pars_[pit], max_depth))
265 max_depth = pars_[pit].getMaxDepthAfter();
271 void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
273 LASSERT(this == cur.text(), /**/);
274 pit_type const beg = cur.selBegin().pit();
275 pit_type const end = cur.selEnd().pit() + 1;
276 cur.recordUndoSelection();
277 int max_depth = (beg != 0 ? pars_[beg - 1].getMaxDepthAfter() : 0);
279 for (pit_type pit = beg; pit != end; ++pit) {
280 Paragraph & par = pars_[pit];
281 if (lyx::changeDepthAllowed(type, par, max_depth)) {
282 int const depth = par.params().depth();
283 if (type == INC_DEPTH)
284 par.params().depth(depth + 1);
286 par.params().depth(depth - 1);
288 max_depth = par.getMaxDepthAfter();
290 // this handles the counter labels, and also fixes up
291 // depth values for follow-on (child) paragraphs
292 cur.forceBufferUpdate();
296 void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
298 LASSERT(this == cur.text(), /**/);
299 // Set the current_font
300 // Determine basis font
302 pit_type pit = cur.pit();
303 if (cur.pos() < pars_[pit].beginOfBody())
304 layoutfont = labelFont(pars_[pit]);
306 layoutfont = layoutFont(pit);
308 // Update current font
309 cur.real_current_font.update(font,
310 cur.buffer()->params().language,
313 // Reduce to implicit settings
314 cur.current_font = cur.real_current_font;
315 cur.current_font.fontInfo().reduce(layoutfont);
316 // And resolve it completely
317 cur.real_current_font.fontInfo().realize(layoutfont);
319 // if there is no selection that's all we need to do
320 if (!cur.selection())
323 // Ok, we have a selection.
324 cur.recordUndoSelection();
326 setFont(cur.bv(), cur.selectionBegin().top(),
327 cur.selectionEnd().top(), font, toggleall);
331 void Text::setFont(BufferView const & bv, CursorSlice const & begin,
332 CursorSlice const & end, Font const & font,
335 Buffer const & buffer = bv.buffer();
337 // Don't use forwardChar here as ditend might have
338 // pos() == lastpos() and forwardChar would miss it.
339 // Can't use forwardPos either as this descends into
341 Language const * language = buffer.params().language;
342 for (CursorSlice dit = begin; dit != end; dit.forwardPos()) {
343 if (dit.pos() == dit.lastpos())
345 pit_type const pit = dit.pit();
346 pos_type const pos = dit.pos();
347 Inset * inset = pars_[pit].getInset(pos);
348 if (inset && inset->resetFontEdit()) {
349 // We need to propagate the font change to all
350 // text cells of the inset (bugs 1973, 6919).
351 setInsetFont(bv, pit, pos, font, toggleall);
353 TextMetrics const & tm = bv.textMetrics(this);
354 Font f = tm.displayFont(pit, pos);
355 f.update(font, language, toggleall);
356 setCharFont(pit, pos, f, tm.font_);
357 // font change may change language...
358 // spell checker has to know that
359 pars_[pit].requestSpellCheck(pos);
364 bool Text::cursorTop(Cursor & cur)
366 LASSERT(this == cur.text(), /**/);
367 return setCursor(cur, 0, 0);
371 bool Text::cursorBottom(Cursor & cur)
373 LASSERT(this == cur.text(), /**/);
374 return setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
378 void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
380 LASSERT(this == cur.text(), /**/);
381 // If the mask is completely neutral, tell user
382 if (font.fontInfo() == ignore_font && font.language() == ignore_language) {
383 // Could only happen with user style
384 cur.message(_("No font change defined."));
388 // Try implicit word selection
389 // If there is a change in the language the implicit word selection
391 CursorSlice const resetCursor = cur.top();
392 bool const implicitSelection =
393 font.language() == ignore_language
394 && font.fontInfo().number() == FONT_IGNORE
395 && selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT);
398 setFont(cur, font, toggleall);
400 // Implicit selections are cleared afterwards
401 // and cursor is set to the original position.
402 if (implicitSelection) {
403 cur.clearSelection();
404 cur.top() = resetCursor;
410 docstring Text::getStringToIndex(Cursor const & cur)
412 LASSERT(this == cur.text(), /**/);
415 return cur.selectionAsString(false);
417 // Try implicit word selection. If there is a change
418 // in the language the implicit word selection is
421 selectWord(tmpcur, PREVIOUS_WORD);
423 if (!tmpcur.selection())
424 cur.message(_("Nothing to index!"));
425 else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
426 cur.message(_("Cannot index more than one paragraph!"));
428 return tmpcur.selectionAsString(false);
434 void Text::setLabelWidthStringToSequence(pit_type const par_offset,
437 pit_type offset = par_offset;
438 // Find first of same layout in sequence
439 while (!isFirstInSequence(offset)) {
440 offset = depthHook(offset, pars_[offset].getDepth());
443 // now apply label width string to every par
445 pit_type const end = pars_.size();
446 depth_type const depth = pars_[offset].getDepth();
447 Layout const & layout = pars_[offset].layout();
448 for (pit_type pit = offset; pit != end; ++pit) {
449 while (pars_[pit].getDepth() > depth)
451 if (pars_[pit].getDepth() < depth)
453 if (pars_[pit].layout() != layout)
455 pars_[pit].setLabelWidthString(s);
460 void Text::setParagraphs(Cursor & cur, docstring arg, bool merge)
462 LASSERT(cur.text(), /**/);
463 // make sure that the depth behind the selection are restored, too
464 pit_type undopit = undoSpan(cur.selEnd().pit());
465 recUndo(cur, cur.selBegin().pit(), undopit - 1);
468 string const argument = to_utf8(arg);
469 depth_type priordepth = -1;
471 for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
473 Paragraph & par = pars_[pit];
474 ParagraphParameters params = par.params();
475 params.read(argument, merge);
476 // Changes to label width string apply to all paragraphs
477 // with same layout in a sequence.
478 // Do this only once for a selected range of paragraphs
479 // of the same layout and depth.
480 if (par.getDepth() != priordepth || par.layout() != priorlayout)
481 setLabelWidthStringToSequence(pit, params.labelWidthString());
482 par.params().apply(params, par.layout());
483 priordepth = par.getDepth();
484 priorlayout = par.layout();
489 //FIXME This is a little redundant now, but it's probably worth keeping,
490 //especially if we're going to go away from using serialization internally
492 void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p)
494 LASSERT(cur.text(), /**/);
495 // make sure that the depth behind the selection are restored, too
496 pit_type undopit = undoSpan(cur.selEnd().pit());
497 recUndo(cur, cur.selBegin().pit(), undopit - 1);
499 depth_type priordepth = -1;
501 for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
503 Paragraph & par = pars_[pit];
504 // Changes to label width string apply to all paragraphs
505 // with same layout in a sequence.
506 // Do this only once for a selected range of paragraphs
507 // of the same layout and depth.
508 if (par.getDepth() != priordepth || par.layout() != priorlayout)
509 setLabelWidthStringToSequence(pit,
510 par.params().labelWidthString());
511 par.params().apply(p, par.layout());
512 priordepth = par.getDepth();
513 priorlayout = par.layout();
518 // this really should just insert the inset and not move the cursor.
519 void Text::insertInset(Cursor & cur, Inset * inset)
521 LASSERT(this == cur.text(), /**/);
522 LASSERT(inset, /**/);
523 cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
524 Change(cur.buffer()->params().trackChanges
525 ? Change::INSERTED : Change::UNCHANGED));
529 bool Text::setCursor(Cursor & cur, pit_type par, pos_type pos,
530 bool setfont, bool boundary)
532 TextMetrics const & tm = cur.bv().textMetrics(this);
533 bool const update_needed = !tm.contains(par);
535 setCursorIntern(cur, par, pos, setfont, boundary);
536 return cur.bv().checkDepm(cur, old) || update_needed;
540 void Text::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
542 LASSERT(par != int(paragraphs().size()), /**/);
546 // now some strict checking
547 Paragraph & para = getPar(par);
549 // None of these should happen, but we're scaredy-cats
551 lyxerr << "don't like -1" << endl;
552 LASSERT(false, /**/);
555 if (pos > para.size()) {
556 lyxerr << "don't like 1, pos: " << pos
557 << " size: " << para.size()
558 << " par: " << par << endl;
559 LASSERT(false, /**/);
564 void Text::setCursorIntern(Cursor & cur,
565 pit_type par, pos_type pos, bool setfont, bool boundary)
567 LASSERT(this == cur.text(), /**/);
568 cur.boundary(boundary);
569 setCursor(cur.top(), par, pos);
571 cur.setCurrentFont();
575 bool Text::checkAndActivateInset(Cursor & cur, bool front)
579 if (front && cur.pos() == cur.lastpos())
581 if (!front && cur.pos() == 0)
583 Inset * inset = front ? cur.nextInset() : cur.prevInset();
584 if (!inset || !inset->editable())
587 * Apparently, when entering an inset we are expected to be positioned
588 * *before* it in the containing paragraph, regardless of the direction
589 * from which we are entering. Otherwise, cursor placement goes awry,
590 * and when we exit from the beginning, we'll be placed *after* the
595 inset->edit(cur, front);
600 bool Text::checkAndActivateInsetVisual(Cursor & cur, bool movingForward, bool movingLeft)
606 if (cur.pos() == cur.lastpos())
608 Paragraph & par = cur.paragraph();
609 Inset * inset = par.isInset(cur.pos()) ? par.getInset(cur.pos()) : 0;
610 if (!inset || !inset->editable())
612 inset->edit(cur, movingForward,
613 movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
618 bool Text::cursorBackward(Cursor & cur)
620 // Tell BufferView to test for FitCursor in any case!
621 cur.screenUpdateFlags(Update::FitCursor);
623 // not at paragraph start?
625 // if on right side of boundary (i.e. not at paragraph end, but line end)
626 // -> skip it, i.e. set boundary to true, i.e. go only logically left
627 // there are some exceptions to ignore this: lineseps, newlines, spaces
629 // some effectless debug code to see the values in the debugger
630 bool bound = cur.boundary();
631 int rowpos = cur.textRow().pos();
633 bool sep = cur.paragraph().isSeparator(cur.pos() - 1);
634 bool newline = cur.paragraph().isNewline(cur.pos() - 1);
635 bool linesep = cur.paragraph().isLineSeparator(cur.pos() - 1);
637 if (!cur.boundary() &&
638 cur.textRow().pos() == cur.pos() &&
639 !cur.paragraph().isLineSeparator(cur.pos() - 1) &&
640 !cur.paragraph().isNewline(cur.pos() - 1) &&
641 !cur.paragraph().isSeparator(cur.pos() - 1)) {
642 return setCursor(cur, cur.pit(), cur.pos(), true, true);
645 // go left and try to enter inset
646 if (checkAndActivateInset(cur, false))
649 // normal character left
650 return setCursor(cur, cur.pit(), cur.pos() - 1, true, false);
653 // move to the previous paragraph or do nothing
655 return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size(), true, false);
660 bool Text::cursorVisLeft(Cursor & cur, bool skip_inset)
662 Cursor temp_cur = cur;
663 temp_cur.posVisLeft(skip_inset);
664 if (temp_cur.depth() > cur.depth()) {
668 return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
669 true, temp_cur.boundary());
673 bool Text::cursorVisRight(Cursor & cur, bool skip_inset)
675 Cursor temp_cur = cur;
676 temp_cur.posVisRight(skip_inset);
677 if (temp_cur.depth() > cur.depth()) {
681 return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
682 true, temp_cur.boundary());
686 bool Text::cursorForward(Cursor & cur)
688 // Tell BufferView to test for FitCursor in any case!
689 cur.screenUpdateFlags(Update::FitCursor);
691 // not at paragraph end?
692 if (cur.pos() != cur.lastpos()) {
693 // in front of editable inset, i.e. jump into it?
694 if (checkAndActivateInset(cur, true))
697 TextMetrics const & tm = cur.bv().textMetrics(this);
698 // if left of boundary -> just jump to right side
699 // but for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi
700 if (cur.boundary() && !tm.isRTLBoundary(cur.pit(), cur.pos()))
701 return setCursor(cur, cur.pit(), cur.pos(), true, false);
703 // next position is left of boundary,
704 // but go to next line for special cases like space, newline, linesep
706 // some effectless debug code to see the values in the debugger
707 int endpos = cur.textRow().endpos();
708 int lastpos = cur.lastpos();
710 bool linesep = cur.paragraph().isLineSeparator(cur.pos());
711 bool newline = cur.paragraph().isNewline(cur.pos());
712 bool sep = cur.paragraph().isSeparator(cur.pos());
713 if (cur.pos() != cur.lastpos()) {
714 bool linesep2 = cur.paragraph().isLineSeparator(cur.pos()+1);
715 bool newline2 = cur.paragraph().isNewline(cur.pos()+1);
716 bool sep2 = cur.paragraph().isSeparator(cur.pos()+1);
719 if (cur.textRow().endpos() == cur.pos() + 1 &&
720 cur.textRow().endpos() != cur.lastpos() &&
721 !cur.paragraph().isNewline(cur.pos()) &&
722 !cur.paragraph().isLineSeparator(cur.pos()) &&
723 !cur.paragraph().isSeparator(cur.pos())) {
724 return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
727 // in front of RTL boundary? Stay on this side of the boundary because:
728 // ab|cDDEEFFghi -> abc|DDEEFFghi
729 if (tm.isRTLBoundary(cur.pit(), cur.pos() + 1))
730 return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
733 return setCursor(cur, cur.pit(), cur.pos() + 1, true, false);
736 // move to next paragraph
737 if (cur.pit() != cur.lastpit())
738 return setCursor(cur, cur.pit() + 1, 0, true, false);
743 bool Text::cursorUpParagraph(Cursor & cur)
745 bool updated = false;
747 updated = setCursor(cur, cur.pit(), 0);
748 else if (cur.pit() != 0)
749 updated = setCursor(cur, cur.pit() - 1, 0);
754 bool Text::cursorDownParagraph(Cursor & cur)
756 bool updated = false;
757 if (cur.pit() != cur.lastpit())
758 updated = setCursor(cur, cur.pit() + 1, 0);
760 updated = setCursor(cur, cur.pit(), cur.lastpos());
765 // fix the cursor `cur' after a characters has been deleted at `where'
766 // position. Called by deleteEmptyParagraphMechanism
767 void Text::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
769 // Do nothing if cursor is not in the paragraph where the
771 if (cur.pit() != where.pit())
774 // If cursor position is after the deletion place update it
775 if (cur.pos() > where.pos())
778 // Check also if we don't want to set the cursor on a spot behind the
779 // pagragraph because we erased the last character.
780 if (cur.pos() > cur.lastpos())
781 cur.pos() = cur.lastpos();
785 bool Text::deleteEmptyParagraphMechanism(Cursor & cur,
786 Cursor & old, bool & need_anchor_change)
788 //LYXERR(Debug::DEBUG, "DEPM: cur:\n" << cur << "old:\n" << old);
790 Paragraph & oldpar = old.paragraph();
792 // We allow all kinds of "mumbo-jumbo" when freespacing.
793 if (oldpar.isFreeSpacing())
796 /* Ok I'll put some comments here about what is missing.
797 There are still some small problems that can lead to
798 double spaces stored in the document file or space at
799 the beginning of paragraphs(). This happens if you have
800 the cursor between to spaces and then save. Or if you
801 cut and paste and the selection have a space at the
802 beginning and then save right after the paste. (Lgb)
805 // If old.pos() == 0 and old.pos()(1) == LineSeparator
806 // delete the LineSeparator.
809 // If old.pos() == 1 and old.pos()(0) == LineSeparator
810 // delete the LineSeparator.
813 // Find a common inset and the corresponding depth.
815 for (; depth < cur.depth(); ++depth)
816 if (&old.inset() == &cur[depth].inset())
819 // Whether a common inset is found and whether the cursor is still in
820 // the same paragraph (possibly nested).
821 bool const same_par = depth < cur.depth() && old.pit() == cur[depth].pit();
822 bool const same_par_pos = depth == cur.depth() - 1 && same_par
823 && old.pos() == cur[depth].pos();
825 // If the chars around the old cursor were spaces, delete one of them.
827 // Only if the cursor has really moved.
829 && old.pos() < oldpar.size()
830 && oldpar.isLineSeparator(old.pos())
831 && oldpar.isLineSeparator(old.pos() - 1)
832 && !oldpar.isDeleted(old.pos() - 1)
833 && !oldpar.isDeleted(old.pos())) {
834 oldpar.eraseChar(old.pos() - 1, cur.buffer()->params().trackChanges);
835 // FIXME: This will not work anymore when we have multiple views of the same buffer
836 // In this case, we will have to correct also the cursors held by
837 // other bufferviews. It will probably be easier to do that in a more
838 // automated way in CursorSlice code. (JMarc 26/09/2001)
839 // correct all cursor parts
841 fixCursorAfterDelete(cur[depth], old.top());
842 need_anchor_change = true;
848 // only do our magic if we changed paragraph
852 // don't delete anything if this is the ONLY paragraph!
853 if (old.lastpit() == 0)
856 // Do not delete empty paragraphs with keepempty set.
857 if (oldpar.allowEmpty())
860 if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
862 old.recordUndo(ATOMIC_UNDO,
863 max(old.pit() - 1, pit_type(0)),
864 min(old.pit() + 1, old.lastpit()));
865 ParagraphList & plist = old.text()->paragraphs();
866 bool const soa = oldpar.params().startOfAppendix();
867 plist.erase(boost::next(plist.begin(), old.pit()));
868 // do not lose start of appendix marker (bug 4212)
869 if (soa && old.pit() < pit_type(plist.size()))
870 plist[old.pit()].params().startOfAppendix(true);
872 // see #warning (FIXME?) above
873 if (cur.depth() >= old.depth()) {
874 CursorSlice & curslice = cur[old.depth() - 1];
875 if (&curslice.inset() == &old.inset()
876 && curslice.pit() > old.pit()) {
878 // since a paragraph has been deleted, all the
879 // insets after `old' have been copied and
880 // their address has changed. Therefore we
881 // need to `regenerate' cur. (JMarc)
882 cur.updateInsets(&(cur.bottom().inset()));
883 need_anchor_change = true;
889 if (oldpar.stripLeadingSpaces(cur.buffer()->params().trackChanges)) {
890 need_anchor_change = true;
891 // We return true here because the Paragraph contents changed and
892 // we need a redraw before further action is processed.
900 void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool trackChanges)
902 LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), /**/);
904 for (pit_type pit = first; pit <= last; ++pit) {
905 Paragraph & par = pars_[pit];
907 // We allow all kinds of "mumbo-jumbo" when freespacing.
908 if (par.isFreeSpacing())
911 for (pos_type pos = 1; pos < par.size(); ++pos) {
912 if (par.isLineSeparator(pos) && par.isLineSeparator(pos - 1)
913 && !par.isDeleted(pos - 1)) {
914 if (par.eraseChar(pos - 1, trackChanges)) {
920 // don't delete anything if this is the only remaining paragraph
921 // within the given range. Note: Text::acceptOrRejectChanges()
922 // sets the cursor to 'first' after calling DEPM
926 // don't delete empty paragraphs with keepempty set
927 if (par.allowEmpty())
930 if (par.empty() || (par.size() == 1 && par.isLineSeparator(0))) {
931 pars_.erase(boost::next(pars_.begin(), pit));
937 par.stripLeadingSpaces(trackChanges);
942 void Text::recUndo(Cursor & cur, pit_type first, pit_type last) const
944 cur.recordUndo(ATOMIC_UNDO, first, last);
948 void Text::recUndo(Cursor & cur, pit_type par) const
950 cur.recordUndo(ATOMIC_UNDO, par, par);