* Licence details can be found in the file COPYING.
*
* \author Asger Alstrup
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
* \author Alfredo Braunstein
* \author Jean-Marc Lasgouttes
* \author Angus Leeming
* \author John Levon
- * \author André Pönitz
+ * \author André Pönitz
* \author Allan Rae
* \author Stefan Schimanski
* \author Dekel Tsur
- * \author Jürgen Vigna
+ * \author Jürgen Vigna
*
* Full author contact details are available in file CREDITS.
*/
#include "CutAndPaste.h"
#include "DispatchResult.h"
#include "ErrorList.h"
-#include "FuncRequest.h"
#include "Language.h"
#include "Layout.h"
#include "Lexer.h"
-#include "LyXFunc.h"
+#include "LyX.h"
#include "LyXRC.h"
#include "Paragraph.h"
-#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
#include "TextClass.h"
#include "TextMetrics.h"
-#include "VSpace.h"
-#include "insets/InsetEnvironment.h"
+#include "insets/InsetCollapsable.h"
#include "mathed/InsetMathHull.h"
+#include "support/lassert.h"
#include "support/debug.h"
#include "support/gettext.h"
#include "support/textutils.h"
namespace lyx {
-Text::Text()
- : autoBreakRows_(false)
-{}
-
-
-bool Text::isMainText(Buffer const & buffer) const
+bool Text::isMainText() const
{
- return &buffer.text() == this;
+ return &owner_->buffer().text() == this;
}
-FontInfo Text::layoutFont(Buffer const & buffer, pit_type const pit) const
+// Note that this is supposed to return a fully realized font.
+FontInfo Text::layoutFont(pit_type const pit) const
{
Layout const & layout = pars_[pit].layout();
FontInfo lf = layout.resfont;
// In case the default family has been customized
if (layout.font.family() == INHERIT_FAMILY)
- lf.setFamily(buffer.params().getFont().fontInfo().family());
- return lf;
+ lf.setFamily(owner_->buffer().params().getFont().fontInfo().family());
+ // FIXME
+ // It ought to be possible here just to use Inset::getLayout() and skip
+ // the asInsetCollapsable() bit. Unfortunatley, that doesn't work right
+ // now, because Inset::getLayout() will return a default-constructed
+ // InsetLayout, and that e.g. sets the foreground color to red. So we
+ // need to do some work to make that possible.
+ InsetCollapsable const * icp = owner_->asInsetCollapsable();
+ if (!icp)
+ return lf;
+ FontInfo icf = icp->getLayout().font();
+ icf.realize(lf);
+ return icf;
}
FontInfo font = layout.font;
// Realize with the fonts of lesser depth.
- //font.realize(outerFont(pit, paragraphs()));
- font.realize(buffer.params().getFont().fontInfo());
+ //font.realize(outerFont(pit));
+ font.realize(owner_->buffer().params().getFont().fontInfo());
return font;
}
-FontInfo Text::labelFont(Buffer const & buffer, Paragraph const & par) const
+// Note that this is supposed to return a fully realized font.
+FontInfo Text::labelFont(Paragraph const & par) const
{
+ Buffer const & buffer = owner_->buffer();
Layout const & layout = par.layout();
if (!par.getDepth()) {
}
-void Text::setCharFont(Buffer const & buffer, pit_type pit,
+void Text::setCharFont(pit_type pit,
pos_type pos, Font const & fnt, Font const & display_font)
{
+ Buffer const & buffer = owner_->buffer();
Font font = fnt;
Layout const & layout = pars_[pit].layout();
while (!layoutfont.resolved() &&
tp != pit_type(paragraphs().size()) &&
pars_[tp].getDepth()) {
- tp = outerHook(tp, paragraphs());
+ tp = outerHook(tp);
if (tp != pit_type(paragraphs().size()))
layoutfont.realize(pars_[tp].layout().font);
}
// Inside inset, apply the inset's font attributes if any
// (charstyle!)
- if (!isMainText(buffer))
+ if (!isMainText())
layoutfont.realize(display_font.fontInfo());
layoutfont.realize(buffer.params().getFont().fontInfo());
pos_type pos, Font const & font, bool toggleall)
{
Inset * const inset = pars_[pit].getInset(pos);
- BOOST_ASSERT(inset && inset->noFontChange());
+ LASSERT(inset && inset->resetFontEdit(), /**/);
CursorSlice::idx_type endidx = inset->nargs();
for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
// return past-the-last paragraph influenced by a layout change on pit
pit_type Text::undoSpan(pit_type pit)
{
- pit_type end = paragraphs().size();
+ pit_type const end = paragraphs().size();
pit_type nextpit = pit + 1;
if (nextpit == end)
return nextpit;
}
-void Text::setLayout(Buffer const & buffer, pit_type start, pit_type end,
- docstring const & layout)
+void Text::setLayout(pit_type start, pit_type end,
+ docstring const & layout)
{
- BOOST_ASSERT(start != end);
+ LASSERT(start != end, /**/);
- BufferParams const & bufparams = buffer.params();
- Layout const & lyxlayout = bufparams.documentClass()[layout];
+ Buffer const & buffer = owner_->buffer();
+ BufferParams const & bp = buffer.params();
+ Layout const & lyxlayout = bp.documentClass()[layout];
for (pit_type pit = start; pit != end; ++pit) {
Paragraph & par = pars_[pit];
par.applyLayout(lyxlayout);
if (lyxlayout.margintype == MARGIN_MANUAL)
- par.setLabelWidthString(par.translateIfPossible(
- lyxlayout.labelstring(), buffer.params()));
+ par.setLabelWidthString(par.expandLabel(lyxlayout, bp));
}
}
// set layout over selection and make a total rebreak of those paragraphs
void Text::setLayout(Cursor & cur, docstring const & layout)
{
- BOOST_ASSERT(this == cur.text());
- // special handling of new environment insets
- BufferView & bv = cur.bv();
- BufferParams const & params = bv.buffer().params();
- Layout const & lyxlayout = params.documentClass()[layout];
- if (lyxlayout.is_environment) {
- // move everything in a new environment inset
- LYXERR(Debug::DEBUG, "setting layout " << to_utf8(layout));
- lyx::dispatch(FuncRequest(LFUN_LINE_BEGIN));
- lyx::dispatch(FuncRequest(LFUN_LINE_END_SELECT));
- lyx::dispatch(FuncRequest(LFUN_CUT));
- Inset * inset = new InsetEnvironment(bv.buffer(), layout);
- insertInset(cur, inset);
- //inset->edit(cur, true);
- //lyx::dispatch(FuncRequest(LFUN_PASTE));
- return;
- }
+ LASSERT(this == cur.text(), /**/);
pit_type start = cur.selBegin().pit();
pit_type end = cur.selEnd().pit() + 1;
pit_type undopit = undoSpan(end - 1);
recUndo(cur, start, undopit - 1);
- setLayout(cur.buffer(), start, end, layout);
- updateLabels(cur.buffer());
+ setLayout(start, end, layout);
+ cur.forceBufferUpdate();
}
bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
// this happens when selecting several cells in tabular (bug 2630)
if (cur.selBegin().idx() != cur.selEnd().idx())
return false;
void Text::changeDepth(Cursor & cur, DEPTH_CHANGE type)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
pit_type const beg = cur.selBegin().pit();
pit_type const end = cur.selEnd().pit() + 1;
cur.recordUndoSelection();
}
// this handles the counter labels, and also fixes up
// depth values for follow-on (child) paragraphs
- updateLabels(cur.buffer());
+ cur.forceBufferUpdate();
}
void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
// Set the current_font
// Determine basis font
FontInfo layoutfont;
pit_type pit = cur.pit();
if (cur.pos() < pars_[pit].beginOfBody())
- layoutfont = labelFont(cur.buffer(), pars_[pit]);
+ layoutfont = labelFont(pars_[pit]);
else
- layoutfont = layoutFont(cur.buffer(), pit);
+ layoutfont = layoutFont(pit);
// Update current font
cur.real_current_font.update(font,
- cur.buffer().params().language,
+ cur.buffer()->params().language,
toggleall);
// Reduce to implicit settings
pit_type const pit = dit.pit();
pos_type const pos = dit.pos();
Inset * inset = pars_[pit].getInset(pos);
- if (inset && inset->noFontChange()) {
+ if (inset && inset->resetFontEdit()) {
// We need to propagate the font change to all
- // text cells of the inset (bug 1973).
- // FIXME: This should change, see documentation
- // of noFontChange in Inset.h
+ // text cells of the inset (bugs 1973, 6919).
setInsetFont(bv, pit, pos, font, toggleall);
}
TextMetrics const & tm = bv.textMetrics(this);
Font f = tm.displayFont(pit, pos);
f.update(font, language, toggleall);
- setCharFont(buffer, pit, pos, f, tm.font_);
+ setCharFont(pit, pos, f, tm.font_);
+ // font change may change language...
+ // spell checker has to know that
+ pars_[pit].requestSpellCheck(pos);
}
}
bool Text::cursorTop(Cursor & cur)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
return setCursor(cur, 0, 0);
}
bool Text::cursorBottom(Cursor & cur)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
return setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
}
void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
// If the mask is completely neutral, tell user
- if (font.fontInfo() == ignore_font &&
- (font.language() == 0 || font.language() == ignore_language)) {
+ if (font.fontInfo() == ignore_font && font.language() == ignore_language) {
// Could only happen with user style
cur.message(_("No font change defined."));
return;
// Try implicit word selection
// If there is a change in the language the implicit word selection
// is disabled.
- CursorSlice resetCursor = cur.top();
- bool implicitSelection =
+ CursorSlice const resetCursor = cur.top();
+ bool const implicitSelection =
font.language() == ignore_language
&& font.fontInfo().number() == FONT_IGNORE
&& selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT);
docstring Text::getStringToIndex(Cursor const & cur)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
if (cur.selection())
return cur.selectionAsString(false);
}
+void Text::setLabelWidthStringToSequence(pit_type const par_offset,
+ docstring const & s)
+{
+ pit_type offset = par_offset;
+ // Find first of same layout in sequence
+ while (!isFirstInSequence(offset)) {
+ offset = depthHook(offset, pars_[offset].getDepth());
+ }
+
+ // now apply label width string to every par
+ // in sequence
+ pit_type const end = pars_.size();
+ depth_type const depth = pars_[offset].getDepth();
+ Layout const & layout = pars_[offset].layout();
+ for (pit_type pit = offset; pit != end; ++pit) {
+ while (pars_[pit].getDepth() > depth) {
+ ++pit;
+ if (pit == end)
+ return;
+ }
+ if (pars_[pit].getDepth() < depth)
+ return;
+ if (pars_[pit].layout() != layout)
+ return;
+ pars_[pit].setLabelWidthString(s);
+ }
+}
+
+
void Text::setParagraphs(Cursor & cur, docstring arg, bool merge)
{
- BOOST_ASSERT(cur.text());
+ LASSERT(cur.text(), /**/);
// make sure that the depth behind the selection are restored, too
pit_type undopit = undoSpan(cur.selEnd().pit());
recUndo(cur, cur.selBegin().pit(), undopit - 1);
//FIXME UNICODE
string const argument = to_utf8(arg);
+ depth_type priordepth = -1;
+ Layout priorlayout;
for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
pit <= end; ++pit) {
Paragraph & par = pars_[pit];
ParagraphParameters params = par.params();
params.read(argument, merge);
+ // Changes to label width string apply to all paragraphs
+ // with same layout in a sequence.
+ // Do this only once for a selected range of paragraphs
+ // of the same layout and depth.
+ if (par.getDepth() != priordepth || par.layout() != priorlayout)
+ setLabelWidthStringToSequence(pit, params.labelWidthString());
par.params().apply(params, par.layout());
+ priordepth = par.getDepth();
+ priorlayout = par.layout();
}
}
//quite so much.
void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p)
{
- BOOST_ASSERT(cur.text());
+ LASSERT(cur.text(), /**/);
// make sure that the depth behind the selection are restored, too
pit_type undopit = undoSpan(cur.selEnd().pit());
recUndo(cur, cur.selBegin().pit(), undopit - 1);
+ depth_type priordepth = -1;
+ Layout priorlayout;
for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
pit <= end; ++pit) {
Paragraph & par = pars_[pit];
+ // Changes to label width string apply to all paragraphs
+ // with same layout in a sequence.
+ // Do this only once for a selected range of paragraphs
+ // of the same layout and depth.
+ if (par.getDepth() != priordepth || par.layout() != priorlayout)
+ setLabelWidthStringToSequence(pit,
+ par.params().labelWidthString());
par.params().apply(p, par.layout());
- }
+ priordepth = par.getDepth();
+ priorlayout = par.layout();
+ }
}
// this really should just insert the inset and not move the cursor.
void Text::insertInset(Cursor & cur, Inset * inset)
{
- BOOST_ASSERT(this == cur.text());
- BOOST_ASSERT(inset);
+ LASSERT(this == cur.text(), /**/);
+ LASSERT(inset, /**/);
cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
- Change(cur.buffer().params().trackChanges
+ Change(cur.buffer()->params().trackChanges
? Change::INSERTED : Change::UNCHANGED));
}
-// needed to insert the selection
-void Text::insertStringAsLines(Cursor & cur, docstring const & str)
-{
- cur.buffer().insertStringAsLines(pars_, cur.pit(), cur.pos(),
- cur.current_font, str, autoBreakRows_);
-}
-
-
-// turn double CR to single CR, others are converted into one
-// blank. Then insertStringAsLines is called
-void Text::insertStringAsParagraphs(Cursor & cur, docstring const & str)
-{
- docstring linestr = str;
- bool newline_inserted = false;
-
- for (string::size_type i = 0, siz = linestr.size(); i < siz; ++i) {
- if (linestr[i] == '\n') {
- if (newline_inserted) {
- // we know that \r will be ignored by
- // insertStringAsLines. Of course, it is a dirty
- // trick, but it works...
- linestr[i - 1] = '\r';
- linestr[i] = '\n';
- } else {
- linestr[i] = ' ';
- newline_inserted = true;
- }
- } else if (isPrintable(linestr[i])) {
- newline_inserted = false;
- }
- }
- insertStringAsLines(cur, linestr);
-}
-
-
bool Text::setCursor(Cursor & cur, pit_type par, pos_type pos,
bool setfont, bool boundary)
{
bool const update_needed = !tm.contains(par);
Cursor old = cur;
setCursorIntern(cur, par, pos, setfont, boundary);
+ // FIXME There is a chance that we'll miss a screen update here.
+ // If so, then do DEPM and then check if cur wants an update and
+ // go ahead and do it, if so.
return cur.bv().checkDepm(cur, old) || update_needed;
}
void Text::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
{
- BOOST_ASSERT(par != int(paragraphs().size()));
+ LASSERT(par != int(paragraphs().size()), /**/);
cur.pit() = par;
cur.pos() = pos;
// None of these should happen, but we're scaredy-cats
if (pos < 0) {
- lyxerr << "dont like -1" << endl;
- BOOST_ASSERT(false);
+ lyxerr << "don't like -1" << endl;
+ LASSERT(false, /**/);
}
if (pos > para.size()) {
- lyxerr << "dont like 1, pos: " << pos
+ lyxerr << "don't like 1, pos: " << pos
<< " size: " << para.size()
<< " par: " << par << endl;
- BOOST_ASSERT(false);
+ LASSERT(false, /**/);
}
}
void Text::setCursorIntern(Cursor & cur,
pit_type par, pos_type pos, bool setfont, bool boundary)
{
- BOOST_ASSERT(this == cur.text());
+ LASSERT(this == cur.text(), /**/);
cur.boundary(boundary);
setCursor(cur.top(), par, pos);
if (setfont)
if (!front && cur.pos() == 0)
return false;
Inset * inset = front ? cur.nextInset() : cur.prevInset();
- if (!inset || inset->editable() != Inset::HIGHLY_EDITABLE)
+ if (!inset || !inset->editable())
return false;
/*
* Apparently, when entering an inset we are expected to be positioned
return false;
Paragraph & par = cur.paragraph();
Inset * inset = par.isInset(cur.pos()) ? par.getInset(cur.pos()) : 0;
- if (!inset || inset->editable() != Inset::HIGHLY_EDITABLE)
+ if (!inset || !inset->editable())
return false;
inset->edit(cur, movingForward,
movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
bool Text::cursorBackward(Cursor & cur)
{
// Tell BufferView to test for FitCursor in any case!
- cur.updateFlags(Update::FitCursor);
+ cur.screenUpdateFlags(Update::FitCursor);
// not at paragraph start?
if (cur.pos() > 0) {
bool Text::cursorVisLeft(Cursor & cur, bool skip_inset)
{
- pit_type new_pit = cur.pit(); // the paragraph to which we will move
- pos_type new_pos; // the position we will move to
- bool new_boundary; // will we move to a boundary position?
- pos_type left_pos; // position visually left of current cursor
- pos_type right_pos; // position visually right of current cursor
- bool new_pos_is_RTL; // is new position we're moving to RTL?
-
- cur.getSurroundingPos(left_pos, right_pos);
-
- LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<<cur.pos()<<")");
-
- // Are we at an inset?
Cursor temp_cur = cur;
- temp_cur.pos() = left_pos;
- temp_cur.boundary(false);
- if (!skip_inset &&
- checkAndActivateInsetVisual(temp_cur, left_pos >= cur.pos(), true)) {
- LYXERR(Debug::RTL, "entering inset at: " << temp_cur.pos());
- cur = temp_cur; // set the real cursor to new position inside inset!
+ temp_cur.posVisLeft(skip_inset);
+ if (temp_cur.depth() > cur.depth()) {
+ cur = temp_cur;
return false;
}
-
- // Are we already at leftmost pos in row?
- if (left_pos == -1) {
-
- Cursor new_cur = cur;
- if (!new_cur.posVisToNewRow(true)) {
- LYXERR(Debug::RTL, "not moving!");
- return false;
- }
-
- // we actually move the cursor at the end of this function, for now
- // just keep track of the new position...
- new_pit = new_cur.pit();
- new_pos = new_cur.pos();
- new_boundary = new_cur.boundary();
-
- LYXERR(Debug::RTL, "left edge, moving: " << int(new_pit) << ","
- << int(new_pos) << "," << (new_boundary ? 1 : 0));
-
- }
- // normal movement to the left
- else {
- // Recall, if the cursor is at position 'x', that means *before*
- // the character at position 'x'. In RTL, "before" means "to the
- // right of", in LTR, "to the left of". So currently our situation
- // is this: the position to our left is 'left_pos' (i.e., we're
- // currently to the right of 'left_pos'). In order to move to the
- // left, it depends whether or not the character at 'left_pos' is RTL.
- new_pos_is_RTL = cur.paragraph().getFontSettings(
- cur.bv().buffer().params(), left_pos).isVisibleRightToLeft();
- // If the character at 'left_pos' *is* RTL, then in order to move to
- // the left of it, we need to be *after* 'left_pos', i.e., move to
- // position 'left_pos' + 1.
- if (new_pos_is_RTL) {
- new_pos = left_pos + 1;
- // set the boundary to true in two situations:
- if (
- // 1. if new_pos is now lastpos (which means that we're moving left
- // to the end of an RTL chunk which is at the end of an LTR
- // paragraph);
- new_pos == cur.lastpos()
- // 2. if the position *after* left_pos is not RTL (we want to be
- // *after* left_pos, not before left_pos + 1!)
- || !cur.paragraph().getFontSettings(cur.bv().buffer().params(),
- new_pos).isVisibleRightToLeft()
- )
- new_boundary = true;
- else // set the boundary to false
- new_boundary = false;
- }
- // Otherwise (if the character at position 'left_pos' is LTR), then
- // moving to the left of it is as easy as setting the new position
- // to 'left_pos'.
- else {
- new_pos = left_pos;
- new_boundary = false;
- }
-
- }
-
- LYXERR(Debug::RTL, "moving to: " << new_pos
- << (new_boundary ? " (boundary)" : ""));
-
- return setCursor(cur, new_pit, new_pos, true, new_boundary);
+ return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
+ true, temp_cur.boundary());
}
bool Text::cursorVisRight(Cursor & cur, bool skip_inset)
{
- pit_type new_pit = cur.pit(); // the paragraph to which we will move
- pos_type new_pos; // the position we will move to
- bool new_boundary; // will we move to a boundary position?
- pos_type left_pos; // position visually left of current cursor
- pos_type right_pos; // position visually right of current cursor
- bool new_pos_is_RTL; // is new position we're moving to RTL?
-
- cur.getSurroundingPos(left_pos, right_pos);
-
- LYXERR(Debug::RTL, left_pos <<"|"<< right_pos << " (pos: "<<cur.pos()<<")");
-
- // Are we at an inset?
Cursor temp_cur = cur;
- temp_cur.pos() = right_pos;
- temp_cur.boundary(false);
- if (!skip_inset &&
- checkAndActivateInsetVisual(temp_cur, right_pos >= cur.pos(), false)) {
- LYXERR(Debug::RTL, "entering inset at: " << temp_cur.pos());
- cur = temp_cur; // set the real cursor to new position inside inset!
+ temp_cur.posVisRight(skip_inset);
+ if (temp_cur.depth() > cur.depth()) {
+ cur = temp_cur;
return false;
}
-
- // Are we already at rightmost pos in row?
- if (right_pos == -1) {
-
- Cursor new_cur = cur;
- if (!new_cur.posVisToNewRow(false)) {
- LYXERR(Debug::RTL, "not moving!");
- return false;
- }
-
- // we actually move the cursor at the end of this function, for now
- // just keep track of the new position...
- new_pit = new_cur.pit();
- new_pos = new_cur.pos();
- new_boundary = new_cur.boundary();
-
- LYXERR(Debug::RTL, "right edge, moving: " << int(new_pit) << ","
- << int(new_pos) << "," << (new_boundary ? 1 : 0));
-
- }
- // normal movement to the right
- else {
- // Recall, if the cursor is at position 'x', that means *before*
- // the character at position 'x'. In RTL, "before" means "to the
- // right of", in LTR, "to the left of". So currently our situation
- // is this: the position to our right is 'right_pos' (i.e., we're
- // currently to the left of 'right_pos'). In order to move to the
- // right, it depends whether or not the character at 'right_pos' is RTL.
- new_pos_is_RTL = cur.paragraph().getFontSettings(
- cur.bv().buffer().params(), right_pos).isVisibleRightToLeft();
- // If the character at 'right_pos' *is* LTR, then in order to move to
- // the right of it, we need to be *after* 'right_pos', i.e., move to
- // position 'right_pos' + 1.
- if (!new_pos_is_RTL) {
- new_pos = right_pos + 1;
- // set the boundary to true in two situations:
- if (
- // 1. if new_pos is now lastpos (which means that we're moving
- // right to the end of an LTR chunk which is at the end of an
- // RTL paragraph);
- new_pos == cur.lastpos()
- // 2. if the position *after* right_pos is RTL (we want to be
- // *after* right_pos, not before right_pos + 1!)
- || cur.paragraph().getFontSettings(cur.bv().buffer().params(),
- new_pos).isVisibleRightToLeft()
- )
- new_boundary = true;
- else // set the boundary to false
- new_boundary = false;
- }
- // Otherwise (if the character at position 'right_pos' is RTL), then
- // moving to the right of it is as easy as setting the new position
- // to 'right_pos'.
- else {
- new_pos = right_pos;
- new_boundary = false;
- }
-
- }
-
- LYXERR(Debug::RTL, "moving to: " << new_pos
- << (new_boundary ? " (boundary)" : ""));
-
- return setCursor(cur, new_pit, new_pos, true, new_boundary);
+ return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
+ true, temp_cur.boundary());
}
bool Text::cursorForward(Cursor & cur)
{
// Tell BufferView to test for FitCursor in any case!
- cur.updateFlags(Update::FitCursor);
+ cur.screenUpdateFlags(Update::FitCursor);
// not at paragraph end?
if (cur.pos() != cur.lastpos()) {
// delete the LineSeparator.
// MISSING
- bool const same_inset = &old.inset() == &cur.inset();
- bool const same_par = same_inset && old.pit() == cur.pit();
- bool const same_par_pos = same_par && old.pos() == cur.pos();
+ // 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.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 one of them.
if (!same_par_pos) {
// Only if the cursor has really moved.
&& oldpar.isLineSeparator(old.pos() - 1)
&& !oldpar.isDeleted(old.pos() - 1)
&& !oldpar.isDeleted(old.pos())) {
- oldpar.eraseChar(old.pos() - 1, cur.buffer().params().trackChanges);
+ oldpar.eraseChar(old.pos() - 1, cur.buffer()->params().trackChanges);
// 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 (same_par) {
- fixCursorAfterDelete(cur.top(), old.top());
+ fixCursorAfterDelete(cur[depth], old.top());
need_anchor_change = true;
}
return true;
return true;
}
- if (oldpar.stripLeadingSpaces(cur.buffer().params().trackChanges)) {
+ if (oldpar.stripLeadingSpaces(cur.buffer()->params().trackChanges)) {
need_anchor_change = true;
// We return true here because the Paragraph contents changed and
// we need a redraw before further action is processed.
void Text::deleteEmptyParagraphMechanism(pit_type first, pit_type last, bool trackChanges)
{
- BOOST_ASSERT(first >= 0 && first <= last && last < (int) pars_.size());
+ LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), /**/);
for (pit_type pit = first; pit <= last; ++pit) {
Paragraph & par = pars_[pit];
}
}
- // don't delete anything if this is the only remaining paragraph within the given range
- // note: Text::acceptOrRejectChanges() sets the cursor to 'first' after calling DEPM
+ // don't delete anything if this is the only remaining paragraph
+ // within the given range. Note: Text::acceptOrRejectChanges()
+ // sets the cursor to 'first' after calling DEPM
if (first == last)
continue;