#include <boost/tuple/tuple.hpp>
using lyx::pos_type;
+using lyx::paroffset_type;
using lyx::support::bformat;
using std::endl;
using std::ostringstream;
+using std::string;
LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
ParagraphList & paragraphs)
: height(0), width(0), anchor_y_(0),
inset_owner(inset), the_locking_inset(0), bv_owner(bv),
- in_inset_(ininset), paragraphs_(paragraphs)
+ in_inset_(ininset), paragraphs_(¶graphs)
{
}
current_font = getFont(beg, 0);
redoParagraphs(beg, end);
- setCursorIntern(beg, 0);
+ setCursorIntern(0, 0);
selection.cursor = cursor;
updateCounters();
InsetOld * LyXText::getInset() const
{
- ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator pit = cursorPar();
pos_type const pos = cursor.pos();
if (pos < pit->size() && pit->isInset(pos)) {
LyXCursor & send_cur,
string const & layout)
{
- ParagraphList::iterator endpit = boost::next(send_cur.par());
+ ParagraphList::iterator endpit = boost::next(getPar(send_cur));
ParagraphList::iterator undoendpit = endpit;
ParagraphList::iterator pars_end = ownerParagraphs().end();
++endpit;
}
- recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
+ recordUndo(bv(), Undo::ATOMIC, getPar(sstart_cur), boost::prior(undoendpit));
// ok we have a selection. This is always between sstart_cur
// and sel_end cursor
cur = sstart_cur;
- ParagraphList::iterator pit = sstart_cur.par();
- ParagraphList::iterator epit = boost::next(send_cur.par());
+ ParagraphList::iterator pit = getPar(sstart_cur);
+ ParagraphList::iterator epit = boost::next(getPar(send_cur));
BufferParams const & bufparams = bv()->buffer()->params();
LyXLayout_ptr const & lyxlayout =
: VSpace(VSpace::NONE));
if (lyxlayout->margintype == MARGIN_MANUAL)
pit->setLabelWidthString(lyxlayout->labelstring());
- cur.par(pit);
+ cur.par(std::distance(ownerParagraphs().begin(), pit));
++pit;
} while (pit != epit);
ParagraphList::iterator endpit = setLayout(cursor, selection.start,
selection.end, layout);
- redoParagraphs(selection.start.par(), endpit);
+ redoParagraphs(getPar(selection.start), endpit);
// we have to reset the selection, because the
// geometry could have changed
bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
{
- ParagraphList::iterator pit = cursor.par();
- ParagraphList::iterator end = cursor.par();
+ ParagraphList::iterator pit = cursorPar();
+ ParagraphList::iterator end = cursorPar();
ParagraphList::iterator start = pit;
if (selection.set()) {
- pit = selection.start.par();
- end = selection.end.par();
+ pit = getPar(selection.start);
+ end = getPar(selection.end);
start = pit;
}
if (!selection.set()) {
// Determine basis font
LyXFont layoutfont;
- if (cursor.pos() < cursor.par()->beginningOfBody()) {
- layoutfont = getLabelFont(cursor.par());
+ if (cursor.pos() < cursorPar()->beginningOfBody()) {
+ layoutfont = getLabelFont(cursorPar());
} else {
- layoutfont = getLayoutFont(cursor.par());
+ layoutfont = getLayoutFont(cursorPar());
}
// Update current font
real_current_font.update(font,
// ok we have a selection. This is always between sel_start_cursor
// and sel_end cursor
- recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
+ recordUndo(bv(), Undo::ATOMIC, getPar(selection.start), getPar(selection.end));
freezeUndo();
cursor = selection.start;
while (cursor.par() != selection.end.par() ||
cursor.pos() < selection.end.pos())
{
- if (cursor.pos() < cursor.par()->size()) {
+ if (cursor.pos() < cursorPar()->size()) {
// an open footnote should behave like a closed one
- setCharFont(cursor.par(), cursor.pos(),
- font, toggleall);
+ setCharFont(cursorPar(), cursor.pos(), font, toggleall);
cursor.pos(cursor.pos() + 1);
} else {
cursor.pos(0);
- cursor.par(boost::next(cursor.par()));
+ cursor.par(cursor.par() + 1);
}
}
unFreezeUndo();
- redoParagraph(selection.start.par());
+ redoParagraph(getPar(selection.start));
// we have to reset the selection, because the
// geometry could have changed, but we keep
void LyXText::cursorHome()
{
- setCursor(cursor.par(), cursorRow()->pos());
+ setCursor(cursorPar(), cursorRow()->pos());
}
void LyXText::cursorEnd()
{
- setCursor(cursor.par(), cursorRow()->end() - 1);
+ setCursor(cursorPar(), cursorRow()->end() - 1);
}
if (implicitSelection) {
clearSelection();
cursor = resetCursor;
- setCursor(cursor.par(), cursor.pos());
+ setCursor(cursorPar(), cursor.pos());
selection.cursor = cursor;
}
}
// Reset cursors to their original position.
cursor = reset_cursor;
- setCursor(cursor.par(), cursor.pos());
+ setCursor(cursorPar(), cursor.pos());
selection.cursor = cursor;
// Clear the implicit selection.
}
// make sure that the depth behind the selection are restored, too
- ParagraphList::iterator endpit = boost::next(selection.end.par());
+ ParagraphList::iterator endpit = boost::next(getPar(selection.end));
ParagraphList::iterator undoendpit = endpit;
ParagraphList::iterator pars_end = ownerParagraphs().end();
++endpit;
}
- recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
+ recordUndo(bv(), Undo::ATOMIC, getPar(selection.start),
boost::prior(undoendpit));
- ParagraphList::iterator tmppit = selection.end.par();
+ int tmppit = selection.end.par();
- while (tmppit != boost::prior(selection.start.par())) {
+ while (tmppit != selection.start.par() - 1) {
setCursor(tmppit, 0);
- ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator const pit = cursorPar();
ParagraphParameters & params = pit->params();
params.lineTop(line_top);
}
pit->setLabelWidthString(labelwidthstring);
params.noindent(noindent);
- tmppit = boost::prior(pit);
+ --tmppit;
}
- redoParagraphs(selection.start.par(), endpit);
+ redoParagraphs(getPar(selection.start), endpit);
clearSelection();
setCursor(selection.start.par(), selection.start.pos());
return textclass.counters().counterLabel(fmt);
}
+
+void incrementItemDepth(ParagraphList::iterator pit,
+ ParagraphList::iterator first_pit)
+{
+ int const cur_labeltype = pit->layout()->labeltype;
+
+ if (cur_labeltype != LABEL_ENUMERATE &&
+ cur_labeltype != LABEL_ITEMIZE)
+ return;
+
+ int const cur_depth = pit->getDepth();
+
+ ParagraphList::iterator prev_pit = boost::prior(pit);
+ while (true) {
+ int const prev_depth = prev_pit->getDepth();
+ int const prev_labeltype = prev_pit->layout()->labeltype;
+ if (prev_depth == 0 && cur_depth > 0) {
+ if (prev_labeltype == cur_labeltype) {
+ pit->itemdepth = prev_pit->itemdepth + 1;
+ }
+ break;
+ } else if (prev_depth < cur_depth) {
+ if (prev_labeltype == cur_labeltype) {
+ pit->itemdepth = prev_pit->itemdepth + 1;
+ break;
+ }
+ } else if (prev_depth == cur_depth) {
+ if (prev_labeltype == cur_labeltype) {
+ pit->itemdepth = prev_pit->itemdepth;
+ break;
+ }
+ }
+ if (prev_pit == first_pit)
+ break;
+
+ --prev_pit;
+ }
+}
+
+
+void resetEnumCounterIfNeeded(ParagraphList::iterator pit,
+ ParagraphList::iterator firstpit,
+ Counters & counters)
+{
+ if (pit == firstpit)
+ return;
+
+ int const cur_depth = pit->getDepth();
+ ParagraphList::iterator prev_pit = boost::prior(pit);
+ while (true) {
+ int const prev_depth = prev_pit->getDepth();
+ int const prev_labeltype = prev_pit->layout()->labeltype;
+ if (prev_depth <= cur_depth) {
+ if (prev_labeltype != LABEL_ENUMERATE) {
+ switch (pit->itemdepth) {
+ case 0:
+ counters.reset("enumi");
+ case 1:
+ counters.reset("enumii");
+ case 2:
+ counters.reset("enumiii");
+ case 3:
+ counters.reset("enumiv");
+ }
+ }
+ break;
+ }
+
+ if (prev_pit == firstpit)
+ break;
+
+ --prev_pit;
+ }
}
+} // anon namespace
+
// set the counter of a paragraph. This includes the labels
void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
BufferParams const & bufparams = buf.params();
LyXTextClass const & textclass = bufparams.getLyXTextClass();
LyXLayout_ptr const & layout = pit->layout();
+ ParagraphList::iterator first_pit = ownerParagraphs().begin();
+ Counters & counters = textclass.counters();
- if (pit != ownerParagraphs().begin()) {
+ // Always reset
+ pit->itemdepth = 0;
+
+ if (pit == first_pit) {
+ pit->params().appendix(pit->params().startOfAppendix());
+ } else {
pit->params().appendix(boost::prior(pit)->params().appendix());
if (!pit->params().appendix() &&
pit->params().startOfAppendix()) {
pit->params().appendix(true);
textclass.counters().reset();
}
- pit->enumdepth = boost::prior(pit)->enumdepth;
- pit->itemdepth = boost::prior(pit)->itemdepth;
- } else {
- pit->params().appendix(pit->params().startOfAppendix());
- pit->enumdepth = 0;
- pit->itemdepth = 0;
- }
- // Maybe we have to increment the enumeration depth.
- // Bibliographies can't have their depth changed ie. they
- // are always of depth 0
- if (pit != ownerParagraphs().begin()
- && boost::prior(pit)->getDepth() < pit->getDepth()
- && boost::prior(pit)->layout()->labeltype == LABEL_ENUMERATE
- && pit->enumdepth < 3
- && layout->labeltype != LABEL_BIBLIO) {
- pit->enumdepth++;
- }
-
- // Maybe we have to increment the enumeration depth.
- // Bibliographies can't have their depth changed ie. they
- // are always of depth 0
- if (pit != ownerParagraphs().begin()
- && boost::prior(pit)->getDepth() < pit->getDepth()
- && boost::prior(pit)->layout()->labeltype == LABEL_ITEMIZE
- && pit->itemdepth < 3
- && layout->labeltype != LABEL_BIBLIO) {
- pit->itemdepth++;
- }
-
- // Maybe we have to decrement the enumeration depth, see note above
- if (pit != ownerParagraphs().begin()
- && boost::prior(pit)->getDepth() > pit->getDepth()
- && layout->labeltype != LABEL_BIBLIO) {
- pit->enumdepth = depthHook(pit, ownerParagraphs(),
- pit->getDepth())->enumdepth;
+ // Maybe we have to increment the item depth.
+ incrementItemDepth(pit, first_pit);
}
// erase what was there before
if (layout->labeltype == LABEL_COUNTER) {
BufferParams const & bufparams = buf.params();
LyXTextClass const & textclass = bufparams.getLyXTextClass();
- textclass.counters().step(layout->counter);
+ counters.step(layout->counter);
string label = expandLabel(textclass, layout, pit->params().appendix());
pit->params().labelString(label);
- textclass.counters().reset("enum");
} else if (layout->labeltype == LABEL_ITEMIZE) {
- // At some point of time we should do something more clever here,
- // like:
+ // At some point of time we should do something more
+ // clever here, like:
// pit->params().labelString(
- // bufparams.user_defined_bullet(pit->itemdepth).getText());
- // for now, use a static label
- pit->params().labelString("*");
- textclass.counters().reset("enum");
+ // bufparams.user_defined_bullet(pit->itemdepth).getText());
+ // for now, use a simple hardcoded label
+ string itemlabel;
+ switch (pit->itemdepth) {
+ case 0:
+ itemlabel = "*";
+ break;
+ case 1:
+ itemlabel = "-";
+ break;
+ case 2:
+ itemlabel = "@";
+ break;
+ case 3:
+ itemlabel = "·";
+ break;
+ }
+
+ pit->params().labelString(itemlabel);
} else if (layout->labeltype == LABEL_ENUMERATE) {
+ // Maybe we have to reset the enumeration counter.
+ resetEnumCounterIfNeeded(pit, first_pit, counters);
+
// FIXME
// Yes I know this is a really, really! bad solution
// (Lgb)
string enumcounter = "enum";
- switch (pit->enumdepth) {
+ switch (pit->itemdepth) {
case 2:
enumcounter += 'i';
case 1:
break;
}
- textclass.counters().step(enumcounter);
+ counters.step(enumcounter);
- pit->params().labelString(textclass.counters().enumLabel(enumcounter));
+ pit->params().labelString(counters.enumLabel(enumcounter));
} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
- textclass.counters().step("bibitem");
- int number = textclass.counters().value("bibitem");
+ counters.step("bibitem");
+ int number = counters.value("bibitem");
if (pit->bibitem()) {
pit->bibitem()->setCounter(number);
pit->params().labelString(layout->labelstring());
break;
} else {
Paragraph const * owner = &ownerPar(buf, in);
- tmppit = ownerParagraphs().begin();
+ tmppit = first_pit;
for ( ; tmppit != end; ++tmppit)
if (&*tmppit == owner)
break;
Floating const & fl = textclass.floats().getType(type);
- textclass.counters().step(fl.type());
+ counters.step(fl.type());
// Doesn't work... yet.
s = bformat(_("%1$s #:"), buf.B_(fl.name()));
}
pit->params().labelString(s);
- // reset the enumeration counter. They are always reset
- // when there is any other layout between
- // Just fall-through between the cases so that all
- // enum counters deeper than enumdepth is also reset.
- switch (pit->enumdepth) {
- case 0:
- textclass.counters().reset("enumi");
- case 1:
- textclass.counters().reset("enumii");
- case 2:
- textclass.counters().reset("enumiii");
- case 3:
- textclass.counters().reset("enumiv");
- }
}
}
void LyXText::insertInset(InsetOld * inset)
{
- if (!cursor.par()->insetAllowed(inset->lyxCode()))
+ if (!cursorPar()->insetAllowed(inset->lyxCode()))
return;
- recordUndo(bv(), Undo::ATOMIC, cursor.par());
+ recordUndo(bv(), Undo::ATOMIC, cursorPar());
freezeUndo();
- cursor.par()->insertInset(cursor.pos(), inset);
+ cursorPar()->insertInset(cursor.pos(), inset);
// Just to rebreak and refresh correctly.
// The character will not be inserted a second time
insertChar(Paragraph::META_INSET);
// and selection.end
// make sure that the depth behind the selection are restored, too
- ParagraphList::iterator endpit = boost::next(selection.end.par());
+ ParagraphList::iterator endpit = boost::next(getPar(selection.end.par()));
ParagraphList::iterator undoendpit = endpit;
ParagraphList::iterator pars_end = ownerParagraphs().end();
++endpit;
}
- recordUndo(bv(), Undo::DELETE, selection.start.par(),
+ recordUndo(bv(), Undo::DELETE, getPar(selection.start),
boost::prior(undoendpit));
- endpit = selection.end.par();
+ endpit = getPar(selection.end.par());
int endpos = selection.end.pos();
BufferParams const & bufparams = bv()->buffer()->params();
boost::tie(endpit, endpos) = realcut ?
CutAndPaste::cutSelection(bufparams,
ownerParagraphs(),
- selection.start.par(), endpit,
+ getPar(selection.start.par()), endpit,
selection.start.pos(), endpos,
bufparams.textclass,
doclear)
: CutAndPaste::eraseSelection(bufparams,
ownerParagraphs(),
- selection.start.par(), endpit,
+ getPar(selection.start.par()), endpit,
selection.start.pos(), endpos,
doclear);
// sometimes necessary
if (doclear)
- selection.start.par()->stripLeadingSpaces();
+ getPar(selection.start.par())->stripLeadingSpaces();
- redoParagraphs(selection.start.par(), boost::next(endpit));
+ redoParagraphs(getPar(selection.start.par()), boost::next(endpit));
// cutSelection can invalidate the cursor so we need to set
// it anew. (Lgb)
// we prefer the end for when tracking changes
cursor.pos(endpos);
- cursor.par(endpit);
+ cursor.par(parOffset(endpit));
// need a valid cursor. (Lgb)
clearSelection();
- setCursor(cursor.par(), cursor.pos());
+ setCursor(cursorPar(), cursor.pos());
selection.cursor = cursor;
updateCounters();
}
// and sel_end cursor
// copy behind a space if there is one
- while (selection.start.par()->size() > selection.start.pos()
- && selection.start.par()->isLineSeparator(selection.start.pos())
+ while (getPar(selection.start)->size() > selection.start.pos()
+ && getPar(selection.start)->isLineSeparator(selection.start.pos())
&& (selection.start.par() != selection.end.par()
|| selection.start.pos() < selection.end.pos()))
selection.start.pos(selection.start.pos() + 1);
- CutAndPaste::copySelection(selection.start.par(),
- selection.end.par(),
+ CutAndPaste::copySelection(getPar(selection.start.par()),
+ getPar(selection.end.par()),
selection.start.pos(), selection.end.pos(),
bv()->buffer()->params().textclass);
}
if (!CutAndPaste::checkPastePossible())
return;
- recordUndo(bv(), Undo::INSERT, cursor.par());
+ recordUndo(bv(), Undo::INSERT, cursorPar());
ParagraphList::iterator endpit;
PitPosPair ppp;
boost::tie(ppp, endpit) =
CutAndPaste::pasteSelection(*bv()->buffer(),
ownerParagraphs(),
- cursor.par(), cursor.pos(),
+ cursorPar(), cursor.pos(),
bv()->buffer()->params().textclass,
sel_index, el);
bufferErrors(*bv()->buffer(), el);
bv()->showErrorList(_("Paste"));
- redoParagraphs(cursor.par(), endpit);
+ redoParagraphs(cursorPar(), endpit);
setCursor(cursor.par(), cursor.pos());
clearSelection();
// Get font setting before we cut
pos_type pos = selection.end.pos();
- LyXFont const font = selection.start.par()
+ LyXFont const font = getPar(selection.start)
->getFontSettings(bv()->buffer()->params(),
selection.start.pos());
string::const_iterator cit = str.begin();
string::const_iterator end = str.end();
for (; cit != end; ++cit) {
- selection.end.par()->insertChar(pos, (*cit), font);
+ getPar(selection.end)->insertChar(pos, (*cit), font);
++pos;
}
// needed to insert the selection
void LyXText::insertStringAsLines(string const & str)
{
- ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator pit = cursorPar();
pos_type pos = cursor.pos();
- ParagraphList::iterator endpit = boost::next(cursor.par());
+ ParagraphList::iterator endpit = boost::next(cursorPar());
recordUndo(bv(), Undo::ATOMIC);
bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
- redoParagraphs(cursor.par(), endpit);
- setCursor(cursor.par(), cursor.pos());
+ redoParagraphs(cursorPar(), endpit);
+ setCursor(cursorPar(), cursor.pos());
selection.cursor = cursor;
setCursor(pit, pos);
setSelection();
}
-bool LyXText::setCursor(ParagraphList::iterator pit,
- pos_type pos,
- bool setfont, bool boundary)
+void LyXText::setCursor(ParagraphList::iterator pit, pos_type pos)
+{
+ setCursor(parOffset(pit), pos);
+}
+
+
+bool LyXText::setCursor(paroffset_type par, pos_type pos, bool setfont, bool boundary)
{
LyXCursor old_cursor = cursor;
- setCursorIntern(pit, pos, setfont, boundary);
+ setCursorIntern(par, pos, setfont, boundary);
return deleteEmptyParagraphMechanism(old_cursor);
}
}
-void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
- pos_type pos, bool boundary)
+void LyXText::setCursor(LyXCursor & cur, paroffset_type par,
+ pos_type pos, bool boundary)
{
- BOOST_ASSERT(pit != ownerParagraphs().end());
+ BOOST_ASSERT(par != int(ownerParagraphs().size()));
- cur.par(pit);
+ cur.par(par);
cur.pos(pos);
cur.boundary(boundary);
- if (noRows())
+
+ // no rows, no fun...
+ if (ownerParagraphs().begin()->rows.empty())
return;
// get the cursor y position in text
+ ParagraphList::iterator pit = getPar(par);
RowList::iterator row = getRow(pit, pos);
int y = row->y();
}
-void LyXText::setCursorIntern(ParagraphList::iterator pit,
+void LyXText::setCursorIntern(paroffset_type par,
pos_type pos, bool setfont, bool boundary)
{
- setCursor(cursor, pit, pos, boundary);
+ setCursor(cursor, par, pos, boundary);
if (setfont)
setCurrentFont();
}
void LyXText::setCurrentFont()
{
pos_type pos = cursor.pos();
- ParagraphList::iterator pit = cursor.par();
+ ParagraphList::iterator pit = cursorPar();
if (cursor.boundary() && pos > 0)
--pos;
bool bound = false;
pos_type const column = getColumnNearX(pit, rit, x, bound);
- cur.par(pit);
+ cur.par(parOffset(pit));
cur.pos(rit->pos() + column);
cur.x(x);
cur.y(y + rit->baseline());
bool boundary = cursor.boundary();
setCursor(cursor.par(), cursor.pos() - 1, true, false);
if (!internal && !boundary &&
- isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos() + 1))
+ isBoundary(*bv()->buffer(), *cursorPar(), cursor.pos() + 1))
setCursor(cursor.par(), cursor.pos() + 1, true, true);
- } else if (cursor.par() != ownerParagraphs().begin()) {
+ } else if (cursor.par() != 0) {
// steps into the paragraph above
- ParagraphList::iterator pit = boost::prior(cursor.par());
- setCursor(pit, pit->size());
+ setCursor(cursor.par() - 1, boost::prior(cursorPar())->size());
}
}
void LyXText::cursorRight(bool internal)
{
- bool const at_end = (cursor.pos() == cursor.par()->size());
+ bool const at_end = (cursor.pos() == cursorPar()->size());
bool const at_newline = !at_end &&
- cursor.par()->isNewline(cursor.pos());
+ cursorPar()->isNewline(cursor.pos());
if (!internal && cursor.boundary() && !at_newline)
setCursor(cursor.par(), cursor.pos(), true, false);
else if (!at_end) {
setCursor(cursor.par(), cursor.pos() + 1, true, false);
if (!internal &&
- isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos()))
+ isBoundary(*bv()->buffer(), *cursorPar(), cursor.pos()))
setCursor(cursor.par(), cursor.pos(), true, true);
- } else if (boost::next(cursor.par()) != ownerParagraphs().end())
- setCursor(boost::next(cursor.par()), 0);
+ } else if (cursor.par() + 1 != int(ownerParagraphs().size()))
+ setCursor(cursor.par() + 1, 0);
}
void LyXText::cursorUpParagraph()
{
if (cursor.pos() > 0)
- setCursor(cursor.par(), 0);
- else if (cursor.par() != ownerParagraphs().begin())
- setCursor(boost::prior(cursor.par()), 0);
+ setCursor(cursorPar(), 0);
+ else if (cursorPar() != ownerParagraphs().begin())
+ setCursor(boost::prior(cursorPar()), 0);
}
void LyXText::cursorDownParagraph()
{
- ParagraphList::iterator par = cursor.par();
+ ParagraphList::iterator par = cursorPar();
ParagraphList::iterator next_par = boost::next(par);
if (next_par != ownerParagraphs().end())
// 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.par()->size())
- cur.pos(cur.par()->size());
+ if (cur.pos() > getPar(cur)->size())
+ cur.pos(getPar(cur)->size());
// recompute row et al. for this cursor
setCursor(cur, cur.par(), cur.pos(), cur.boundary());
if (selection.set())
return false;
+ // Don't do anything if the cursor is invalid
+ if (old_cursor.par() == -1)
+ return false;
+
// We allow all kinds of "mumbo-jumbo" when freespacing.
- if (old_cursor.par()->isFreeSpacing())
+ ParagraphList::iterator const old_pit = getPar(old_cursor);
+ if (old_pit->isFreeSpacing())
return false;
/* Ok I'll put some comments here about what is missing.
// Only if the cursor has really moved
if (old_cursor.pos() > 0
- && old_cursor.pos() < old_cursor.par()->size()
- && old_cursor.par()->isLineSeparator(old_cursor.pos())
- && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
- bool erased = old_cursor.par()->erase(old_cursor.pos() - 1);
- redoParagraph(old_cursor.par());
+ && old_cursor.pos() < old_pit->size()
+ && old_pit->isLineSeparator(old_cursor.pos())
+ && old_pit->isLineSeparator(old_cursor.pos() - 1)) {
+ bool erased = old_pit->erase(old_cursor.pos() - 1);
+ redoParagraph(old_pit);
if (!erased)
return false;
return false;
// Do not delete empty paragraphs with keepempty set.
- if (old_cursor.par()->allowEmpty())
+ if (old_pit->allowEmpty())
return false;
// only do our magic if we changed paragraph
// we can't possibly have deleted a paragraph before this point
bool deleted = false;
- if (old_cursor.par()->empty() ||
- (old_cursor.par()->size() == 1 &&
- old_cursor.par()->isLineSeparator(0))) {
+ if (old_pit->empty() ||
+ (old_pit->size() == 1 && old_pit->isLineSeparator(0))) {
// ok, we will delete something
LyXCursor tmpcursor;
deleted = true;
- bool selection_position_was_oldcursor_position = (
- selection.cursor.par() == old_cursor.par()
- && selection.cursor.pos() == old_cursor.pos());
+ bool selection_position_was_oldcursor_position =
+ selection.cursor.par() == old_cursor.par()
+ && selection.cursor.pos() == old_cursor.pos();
tmpcursor = cursor;
cursor = old_cursor; // that undo can restore the right cursor position
- ParagraphList::iterator endpit = boost::next(old_cursor.par());
+ ParagraphList::iterator endpit = boost::next(old_pit);
while (endpit != ownerParagraphs().end() && endpit->getDepth())
++endpit;
- recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
+ recordUndo(bv(), Undo::DELETE, old_pit, boost::prior(endpit));
cursor = tmpcursor;
// delete old par
- ownerParagraphs().erase(old_cursor.par());
+ ownerParagraphs().erase(old_pit);
redoParagraph();
// correct cursor y
}
}
if (!deleted) {
- if (old_cursor.par()->stripLeadingSpaces()) {
- redoParagraph(old_cursor.par());
+ if (old_pit->stripLeadingSpaces()) {
+ redoParagraph(old_pit);
// correct cursor y
setCursorIntern(cursor.par(), cursor.pos());
selection.cursor = cursor;
ParagraphList & LyXText::ownerParagraphs() const
{
- return paragraphs_;
+ return *paragraphs_;
}
projects / lyx.git / blobdiff