#include "bufferparams.h"
#include "BufferView.h"
#include "Bullet.h"
-#include "counters.h"
#include "coordcache.h"
#include "cursor.h"
#include "CutAndPaste.h"
#include "debug.h"
#include "dispatchresult.h"
#include "errorlist.h"
-#include "Floating.h"
-#include "FloatList.h"
#include "funcrequest.h"
#include "gettext.h"
#include "language.h"
#include "paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
+#include "pariterator.h"
#include "undo.h"
#include "vspace.h"
#include "frontends/font_metrics.h"
#include "frontends/LyXView.h"
-#include "insets/insetbibitem.h"
#include "insets/insetenv.h"
-#include "insets/insetfloat.h"
-#include "insets/insetwrap.h"
-#include "support/lstrings.h"
#include "support/textutils.h"
-#include "support/convert.h"
+
+#include <boost/current_function.hpp>
#include <sstream>
using lyx::pit_type;
using lyx::pos_type;
-using lyx::support::bformat;
using std::endl;
using std::ostringstream;
using std::string;
+using std::min;
LyXText::LyXText(BufferView * bv)
pars_[pit].rows().clear();
current_font = getFont(pars_[0], 0);
- updateCounters();
+ updateCounters(*bv->buffer());
}
Paragraph const & par = pars_[pit];
- lyxerr << "checkInsetHit: x: " << x << " y: " << y << endl;
- lyxerr << " pit: " << pit << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": x: " << x
+ << " y: " << y
+ << " pit: " << pit
+ << endl;
InsetList::const_iterator iit = par.insetlist.begin();
InsetList::const_iterator iend = par.insetlist.end();
for (; iit != iend; ++iit) {
InsetBase * inset = iit->inset;
#if 1
- lyxerr << "examining inset " << inset << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": examining inset " << inset << endl;
+
if (theCoords.getInsets().has(inset))
- lyxerr
- << " xo: " << inset->xo() << "..."
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": xo: " << inset->xo() << "..."
<< inset->xo() + inset->width()
<< " yo: " << inset->yo() - inset->ascent()
<< "..."
- << inset->yo() + inset->descent() << endl;
+ << inset->yo() + inset->descent()
+ << endl;
else
- lyxerr << " inset has no cached position" << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": inset has no cached position" << endl;
#endif
if (inset->covers(x, y)) {
- lyxerr << "Hit inset: " << inset << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": Hit inset: " << inset << endl;
return inset;
}
}
- lyxerr << "No inset hit. " << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": No inset hit. " << endl;
return 0;
}
if (!par.getDepth()) {
LyXFont f = par.getFontSettings(params, pos);
if (!isMainText())
- f.realize(font_);
+ applyOuterFont(f);
if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
return f.realize(layout->reslabelfont);
else
font.realize(layoutfont);
if (!isMainText())
- font.realize(font_);
+ applyOuterFont(font);
// Realize with the fonts of lesser depth.
font.realize(defaultfont_);
return font;
}
+// There are currently two font mechanisms in LyX:
+// 1. The font attributes in a lyxtext, and
+// 2. The inset-specific font properties, defined in an inset's
+// metrics() and draw() methods and handed down the inset chain through
+// the pi/mi parameters, and stored locally in a lyxtext in font_.
+// This is where the two are integrated in the final fully realized
+// font.
+void LyXText::applyOuterFont(LyXFont & font) const {
+ LyXFont lf(font_);
+ lf.reduce(defaultfont_);
+ lf.realize(font);
+ lf.setLanguage(font.language());
+ font = lf;
+}
+
LyXFont LyXText::getLayoutFont(pit_type const pit) const
{
pit_type start = cur.selBegin().pit();
pit_type end = cur.selEnd().pit() + 1;
setLayout(start, end, layout);
- updateCounters();
+ updateCounters(cur.buffer());
}
bool changeDepthAllowed(LyXText::DEPTH_CHANGE type,
- Paragraph const & par, int max_depth)
+ Paragraph const & par, int max_depth)
{
if (par.layout()->labeltype == LABEL_BIBLIO)
return false;
}
// this handles the counter labels, and also fixes up
// depth values for follow-on (child) paragraphs
- updateCounters();
+ updateCounters(cur.buffer());
}
// Don't use forwardChar here as ditend might have
// pos() == lastpos() and forwardChar would miss it.
- for (; dit != ditend; dit.forwardPos()) {
+ // Can't use forwardPos either as this descends into
+ // nested insets.
+ for (; dit != ditend; dit.forwardPosNoDescend()) {
if (dit.pos() != dit.lastpos()) {
LyXFont f = getFont(dit.paragraph(), dit.pos());
f.update(font, params.language, toggleall);
void LyXText::cursorHome(LCursor & cur)
{
BOOST_ASSERT(this == cur.text());
- setCursor(cur, cur.pit(), cur.textRow().pos());
+ Row const & row = cur.paragraph().getRow(cur.pos(),cur.boundary());
+
+ setCursor(cur, cur.pit(), row.pos());
}
{
BOOST_ASSERT(this == cur.text());
// if not on the last row of the par, put the cursor before
- // the final space
-// FIXME: does this final space exist?
- pos_type const end = cur.textRow().endpos();
- setCursor(cur, cur.pit(), end == cur.lastpos() ? end : end - 1);
+ // the final space exept if I have a spanning inset or one string
+ // is so long that we force a break.
+ pos_type end = cur.textRow().endpos();
+ if (end == 0)
+ // empty text, end-1 is no valid position
+ return;
+ bool boundary = false;
+ if (end != cur.lastpos()) {
+ if (!cur.paragraph().isLineSeparator(end-1)
+ && !cur.paragraph().isNewline(end-1))
+ boundary = true;
+ else
+ --end;
+ }
+ setCursor(cur, cur.pit(), end, true, boundary);
}
if (font == LyXFont(LyXFont::ALL_IGNORE)) {
// Could only happen with user style
cur.message(_("No font change defined. "
- "Use Character under the Layout menu to define font change."));
+ "Use Character under the Layout menu to define font change."));
return;
}
}
-string LyXText::getStringToIndex(LCursor & cur)
+string LyXText::getStringToIndex(LCursor const & cur)
{
BOOST_ASSERT(this == cur.text());
- // Try implicit word selection
- // If there is a change in the language the implicit word selection
- // is disabled.
- CursorSlice const reset_cursor = cur.top();
- bool const implicitSelection =
- selectWordWhenUnderCursor(cur, lyx::PREVIOUS_WORD);
string idxstring;
- if (!cur.selection())
- cur.message(_("Nothing to index!"));
- else if (cur.selBegin().pit() != cur.selEnd().pit())
- cur.message(_("Cannot index more than one paragraph!"));
- else
+ if (cur.selection()) {
idxstring = cur.selectionAsString(false);
-
- // Reset cursors to their original position.
- cur.top() = reset_cursor;
- cur.resetAnchor();
-
- // Clear the implicit selection.
- if (implicitSelection)
- cur.clearSelection();
+ } else {
+ // Try implicit word selection. If there is a change
+ // in the language the implicit word selection is
+ // disabled.
+ LCursor tmpcur = cur;
+ selectWord(tmpcur, lyx::PREVIOUS_WORD);
+
+ if (!tmpcur.selection())
+ cur.message(_("Nothing to index!"));
+ else if (tmpcur.selBegin().pit() != tmpcur.selEnd().pit())
+ cur.message(_("Cannot index more than one paragraph!"));
+ else
+ idxstring = tmpcur.selectionAsString(false);
+ }
return idxstring;
}
void LyXText::setParagraph(LCursor & cur,
- Spacing const & spacing, LyXAlignment align,
- string const & labelwidthstring, bool noindent)
+ Spacing const & spacing, LyXAlignment align,
+ string const & labelwidthstring, bool noindent)
{
BOOST_ASSERT(cur.text());
// make sure that the depth behind the selection are restored, too
recUndo(cur.selBegin().pit(), undopit - 1);
for (pit_type pit = cur.selBegin().pit(), end = cur.selEnd().pit();
- pit <= end; ++pit) {
+ pit <= end; ++pit) {
Paragraph & par = pars_[pit];
ParagraphParameters & params = par.params();
params.spacing(spacing);
}
-string expandLabel(LyXTextClass const & textclass,
- LyXLayout_ptr const & layout, bool appendix)
-{
- string fmt = appendix ?
- layout->labelstring_appendix() : layout->labelstring();
-
- // handle 'inherited level parts' in 'fmt',
- // i.e. the stuff between '@' in '@Section@.\arabic{subsection}'
- size_t const i = fmt.find('@', 0);
- if (i != string::npos) {
- size_t const j = fmt.find('@', i + 1);
- if (j != string::npos) {
- string parent(fmt, i + 1, j - i - 1);
- string label = expandLabel(textclass, textclass[parent], appendix);
- fmt = string(fmt, 0, i) + label + string(fmt, j + 1, string::npos);
- }
- }
-
- return textclass.counters().counterLabel(fmt);
-}
-
-
-namespace {
-
-void incrementItemDepth(ParagraphList & pars, pit_type pit, pit_type first_pit)
-{
- int const cur_labeltype = pars[pit].layout()->labeltype;
-
- if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE)
- return;
-
- int const cur_depth = pars[pit].getDepth();
-
- pit_type prev_pit = pit - 1;
- while (true) {
- int const prev_depth = pars[prev_pit].getDepth();
- int const prev_labeltype = pars[prev_pit].layout()->labeltype;
- if (prev_depth == 0 && cur_depth > 0) {
- if (prev_labeltype == cur_labeltype) {
- pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
- }
- break;
- } else if (prev_depth < cur_depth) {
- if (prev_labeltype == cur_labeltype) {
- pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
- break;
- }
- } else if (prev_depth == cur_depth) {
- if (prev_labeltype == cur_labeltype) {
- pars[pit].itemdepth = pars[prev_pit].itemdepth;
- break;
- }
- }
- if (prev_pit == first_pit)
- break;
-
- --prev_pit;
- }
-}
-
-
-void resetEnumCounterIfNeeded(ParagraphList & pars, pit_type pit,
- pit_type firstpit, Counters & counters)
-{
- if (pit == firstpit)
- return;
-
- int const cur_depth = pars[pit].getDepth();
- pit_type prev_pit = pit - 1;
- while (true) {
- int const prev_depth = pars[prev_pit].getDepth();
- int const prev_labeltype = pars[prev_pit].layout()->labeltype;
- if (prev_depth <= cur_depth) {
- if (prev_labeltype != LABEL_ENUMERATE) {
- switch (pars[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, pit_type pit)
-{
- Paragraph & par = pars_[pit];
- BufferParams const & bufparams = buf.params();
- LyXTextClass const & textclass = bufparams.getLyXTextClass();
- LyXLayout_ptr const & layout = par.layout();
- Counters & counters = textclass.counters();
-
- // Always reset
- par.itemdepth = 0;
-
- if (pit == 0) {
- par.params().appendix(par.params().startOfAppendix());
- } else {
- par.params().appendix(pars_[pit - 1].params().appendix());
- if (!par.params().appendix() &&
- par.params().startOfAppendix()) {
- par.params().appendix(true);
- textclass.counters().reset();
- }
-
- // Maybe we have to increment the item depth.
- incrementItemDepth(pars_, pit, 0);
- }
-
- // erase what was there before
- par.params().labelString(string());
-
- if (layout->margintype == MARGIN_MANUAL) {
- if (par.params().labelWidthString().empty())
- par.setLabelWidthString(layout->labelstring());
- } else {
- par.setLabelWidthString(string());
- }
-
- // is it a layout that has an automatic label?
- if (layout->labeltype == LABEL_COUNTER) {
- BufferParams const & bufparams = buf.params();
- LyXTextClass const & textclass = bufparams.getLyXTextClass();
- counters.step(layout->counter);
- string label = expandLabel(textclass, layout, par.params().appendix());
- par.params().labelString(label);
- } else if (layout->labeltype == LABEL_ITEMIZE) {
- // At some point of time we should do something more
- // clever here, like:
- // par.params().labelString(
- // bufparams.user_defined_bullet(par.itemdepth).getText());
- // for now, use a simple hardcoded label
- string itemlabel;
- switch (par.itemdepth) {
- case 0:
- itemlabel = "*";
- break;
- case 1:
- itemlabel = "-";
- break;
- case 2:
- itemlabel = "@";
- break;
- case 3:
- itemlabel = "·";
- break;
- }
-
- par.params().labelString(itemlabel);
- } else if (layout->labeltype == LABEL_ENUMERATE) {
- // Maybe we have to reset the enumeration counter.
- resetEnumCounterIfNeeded(pars_, pit, 0, counters);
-
- // FIXME
- // Yes I know this is a really, really! bad solution
- // (Lgb)
- string enumcounter = "enum";
-
- switch (par.itemdepth) {
- case 2:
- enumcounter += 'i';
- case 1:
- enumcounter += 'i';
- case 0:
- enumcounter += 'i';
- break;
- case 3:
- enumcounter += "iv";
- break;
- default:
- // not a valid enumdepth...
- break;
- }
-
- counters.step(enumcounter);
-
- par.params().labelString(counters.enumLabel(enumcounter));
- } else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
- counters.step("bibitem");
- int number = counters.value("bibitem");
- if (par.bibitem()) {
- par.bibitem()->setCounter(number);
- par.params().labelString(layout->labelstring());
- }
- // In biblio should't be following counters but...
- } else {
- string s = buf.B_(layout->labelstring());
-
- // the caption hack:
- if (layout->labeltype == LABEL_SENSITIVE) {
- pit_type end = paragraphs().size();
- pit_type tmppit = pit;
- InsetBase * in = 0;
- bool isOK = false;
- while (tmppit != end) {
- in = pars_[tmppit].inInset();
- // FIXME: in should be always valid.
- if (in &&
- (in->lyxCode() == InsetBase::FLOAT_CODE ||
- in->lyxCode() == InsetBase::WRAP_CODE)) {
- isOK = true;
- break;
- }
-#ifdef WITH_WARNINGS
-#warning replace this code by something that works
-// This code does not work because we have currently no way to move up
-// in the hierarchy of insets (JMarc 16/08/2004)
-#endif
-#if 0
-/* I think this code is supposed to be useful when one has a caption
- * in a minipage in a figure inset. We need to go up to be able to see
- * that the caption should use "Figure" as label
- */
- else {
- Paragraph const * owner = &ownerPar(buf, in);
- tmppit = 0;
- for ( ; tmppit != end; ++tmppit)
- if (&pars_[tmppit] == owner)
- break;
- }
-#else
- ++tmppit;
-#endif
- }
-
- if (isOK) {
- string type;
-
- if (in->lyxCode() == InsetBase::FLOAT_CODE)
- type = static_cast<InsetFloat*>(in)->params().type;
- else if (in->lyxCode() == InsetBase::WRAP_CODE)
- type = static_cast<InsetWrap*>(in)->params().type;
- else
- BOOST_ASSERT(false);
-
- Floating const & fl = textclass.floats().getType(type);
-
- counters.step(fl.type());
-
- // Doesn't work... yet.
- s = bformat(_("%1$s #:"), buf.B_(fl.name()));
- } else {
- // par->SetLayout(0);
- // s = layout->labelstring;
- s = _("Senseless: ");
- }
- }
- par.params().labelString(s);
-
- }
-}
-
-
-// Updates all counters.
-void LyXText::updateCounters()
-{
- // start over
- bv()->buffer()->params().getLyXTextClass().counters().reset();
-
- bool update_pos = false;
-
- pit_type end = paragraphs().size();
- for (pit_type pit = 0; pit != end; ++pit) {
- string const oldLabel = pars_[pit].params().labelString();
- size_t maxdepth = 0;
- if (pit != 0)
- maxdepth = pars_[pit - 1].getMaxDepthAfter();
-
- if (pars_[pit].params().depth() > maxdepth)
- pars_[pit].params().depth(maxdepth);
-
- // setCounter can potentially change the labelString.
- setCounter(*bv()->buffer(), pit);
- string const & newLabel = pars_[pit].params().labelString();
- if (oldLabel != newLabel) {
- //lyxerr[Debug::DEBUG] << "changing labels: old: " << oldLabel << " new: "
- // << newLabel << endl;
- update_pos = true;
- }
- }
-}
-
-
// this really should just insert the inset and not move the cursor.
void LyXText::insertInset(LCursor & cur, InsetBase * inset)
{
// needed to insert the selection
void LyXText::insertStringAsLines(LCursor & cur, string const & str)
{
- pit_type pit = cur.pit();
- pos_type pos = cur.pos();
- recordUndo(cur);
-
- // only to be sure, should not be neccessary
- cur.clearSelection();
- cur.buffer().insertStringAsLines(pars_, pit, pos, current_font, str,
- autoBreakRows_);
-
- cur.resetAnchor();
- setCursor(cur, cur.pit(), pos);
- cur.setSelection();
+ cur.buffer().insertStringAsLines(pars_, cur.pit(), cur.pos(),
+ current_font, str, autoBreakRows_);
}
bool LyXText::setCursor(LCursor & cur, pit_type par, pos_type pos,
- bool setfont, bool boundary)
+ bool setfont, bool boundary)
{
LCursor old = cur;
setCursorIntern(cur, par, pos, setfont, boundary);
}
-void LyXText::setCursor(CursorSlice & cur, pit_type par,
- pos_type pos, bool boundary)
+void LyXText::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
{
BOOST_ASSERT(par != int(paragraphs().size()));
cur.pit() = par;
cur.pos() = pos;
- cur.boundary() = boundary;
// now some strict checking
Paragraph & para = getPar(par);
void LyXText::setCursorIntern(LCursor & cur,
- pit_type par, pos_type pos, bool setfont, bool boundary)
+ pit_type par, pos_type pos, bool setfont, bool boundary)
{
- setCursor(cur.top(), par, pos, boundary);
+ cur.boundary(boundary);
+ setCursor(cur.top(), par, pos);
cur.setTargetX();
if (setfont)
setCurrentFont(cur);
// returns the column near the specified x-coordinate of the row
// x is set to the real beginning of this column
pos_type LyXText::getColumnNearX(pit_type const pit,
- Row const & row, int & x, bool & boundary) const
+ Row const & row, int & x, bool & boundary) const
{
int const xo = theCoords.get(this, pit).x_;
x -= xo;
// the value of rtl.
bool const rtl = lastrow ? isRTL(par) : false;
if (lastrow &&
- ((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
- (!rtl && !left_side && vc == end && x > tmpx + 5)))
+ ((rtl && left_side && vc == row.pos() && x < tmpx - 5) ||
+ (!rtl && !left_side && vc == end && x > tmpx + 5)))
c = end;
else if (vc == row.pos()) {
c = bidi.vis2log(vc);
}
}
+// I believe this code is not needed anymore (Jug 20050717)
+#if 0
+ // The following code is necessary because the cursor position past
+ // the last char in a row is logically equivalent to that before
+ // the first char in the next row. That's why insets causing row
+ // divisions -- Newline and display-style insets -- must be treated
+ // specially, so cursor up/down doesn't get stuck in an air gap -- MV
+ // Newline inset, air gap below:
if (row.pos() < end && c >= end && par.isNewline(end - 1)) {
if (bidi.level(end -1) % 2 == 0)
tmpx -= singleWidth(par, end - 1);
c = end - 1;
}
+ // Air gap above display inset:
+ if (row.pos() < end && c >= end && end < par.size()
+ && par.isInset(end) && par.getInset(end)->display()) {
+ c = end - 1;
+ }
+ // Air gap below display inset:
+ if (row.pos() < end && c >= end && par.isInset(end - 1)
+ && par.getInset(end - 1)->display()) {
+ c = end - 1;
+ }
+#endif
+
x = int(tmpx) + xo;
- return c - row.pos();
+ pos_type const col = c - row.pos();
+
+ if (!c || end == par.size())
+ return col;
+
+ if (c==end && !par.isLineSeparator(c-1) && !par.isNewline(c-1)) {
+ boundary = true;
+ return col;
+ }
+
+ return min(col, end - 1 - row.pos());
}
BOOST_ASSERT(!paragraphs().empty());
BOOST_ASSERT(theCoords.getParPos().find(this) != theCoords.getParPos().end());
CoordCache::InnerParPosCache const & cc = theCoords.getParPos().find(this)->second;
- lyxerr << "LyXText::getPitNearY: y: " << y << " cache size: "
- << cc.size() << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": y: " << y << " cache size: " << cc.size()
+ << endl;
// look for highest numbered paragraph with y coordinate less than given y
pit_type pit = 0;
CoordCache::InnerParPosCache::const_iterator it = cc.begin();
CoordCache::InnerParPosCache::const_iterator et = cc.end();
for (; it != et; ++it) {
- lyxerr << " examining: pit: " << it->first << " y: "
- << it->second.y_ << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << " examining: pit: " << it->first
+ << " y: " << it->second.y_
+ << endl;
+
if (it->first >= pit && int(it->second.y_) - int(pars_[it->first].ascent()) <= y) {
pit = it->first;
yy = it->second.y_;
}
}
- lyxerr << " found best y: " << yy << " for pit: " << pit << endl;
+ lyxerr[Debug::DEBUG]
+ << BOOST_CURRENT_FUNCTION
+ << ": found best y: " << yy << " for pit: " << pit
+ << endl;
+
return pit;
}
// x,y are absolute screen coordinates
// sets cursor recursively descending into nested editable insets
-InsetBase * LyXText::editXY(LCursor & cur, int x, int y) const
+InsetBase * LyXText::editXY(LCursor & cur, int x, int y)
{
pit_type pit = getPitNearY(y);
BOOST_ASSERT(pit != -1);
pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
cur.pit() = pit;
cur.pos() = pos;
- cur.boundary() = bound;
+ cur.boundary(bound);
cur.x_target() = x;
// try to descend into nested insets
InsetBase * inset = checkInsetHit(x, y);
- lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
+ //lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
if (!inset) {
// Either we deconst editXY or better we move current_font
// and real_current_font to LCursor
- const_cast<LyXText *>(this)->setCurrentFont(cur);
+ setCurrentFont(cur);
return 0;
}
--cur.pos();
inset = inset->editXY(cur, x, y);
if (cur.top().text() == this)
- const_cast<LyXText *>(this)->setCurrentFont(cur);
+ setCurrentFont(cur);
return inset;
}
bool LyXText::cursorLeft(LCursor & cur)
{
+ if (!cur.boundary() && cur.pos() > 0 &&
+ cur.textRow().pos() == cur.pos() &&
+ !cur.paragraph().isLineSeparator(cur.pos()-1) &&
+ !cur.paragraph().isNewline(cur.pos()-1)) {
+ return setCursor(cur, cur.pit(), cur.pos(), true, true);
+ }
if (cur.pos() != 0) {
bool boundary = cur.boundary();
bool updateNeeded = setCursor(cur, cur.pit(), cur.pos() - 1, true, false);
if (!checkAndActivateInset(cur, false)) {
if (false && !boundary &&
- bidi.isBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
+ bidi.isBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
updateNeeded |=
setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
}
bool LyXText::cursorRight(LCursor & cur)
{
- if (false && cur.boundary()) {
- return setCursor(cur, cur.pit(), cur.pos(), true, false);
- }
-
if (cur.pos() != cur.lastpos()) {
+ if (cur.boundary())
+ return setCursor(cur, cur.pit(), cur.pos(),
+ true, false);
+
bool updateNeeded = false;
if (!checkAndActivateInset(cur, true)) {
- updateNeeded |= setCursor(cur, cur.pit(), cur.pos() + 1, true, false);
+ if (cur.textRow().endpos() == cur.pos() + 1 &&
+ cur.textRow().endpos() != cur.lastpos() &&
+ !cur.paragraph().isLineSeparator(cur.pos()) &&
+ !cur.paragraph().isNewline(cur.pos())) {
+ cur.boundary(true);
+ }
+ updateNeeded |= setCursor(cur, cur.pit(), cur.pos() + 1, true, cur.boundary());
if (false && bidi.isBoundary(cur.buffer(), cur.paragraph(),
- cur.pos()))
+ cur.pos()))
updateNeeded |= setCursor(cur, cur.pit(), cur.pos(), true, true);
}
return updateNeeded;
bool LyXText::cursorUp(LCursor & cur)
{
Paragraph const & par = cur.paragraph();
- int const row = par.pos2row(cur.pos());
+ int row;
int const x = cur.targetX();
+ if (cur.pos() && cur.boundary())
+ row = par.pos2row(cur.pos()-1);
+ else
+ row = par.pos2row(cur.pos());
+
if (!cur.selection()) {
- int const y = bv_funcs::getPos(cur).y_;
+ int const y = bv_funcs::getPos(cur, cur.boundary()).y_;
LCursor old = cur;
editXY(cur, x, y - par.rows()[row].ascent() - 1);
x2pos(cur.pit(), row - 1, x));
} else if (cur.pit() > 0) {
--cur.pit();
+ //cannot use 'par' now
updateNeeded |= setCursor(cur, cur.pit(),
- x2pos(cur.pit(), par.rows().size() - 1, x));
+ x2pos(cur.pit(), cur.paragraph().rows().size() - 1, x));
}
cur.x_target() = x;
bool LyXText::cursorDown(LCursor & cur)
{
Paragraph const & par = cur.paragraph();
- int const row = par.pos2row(cur.pos());
+ int row;
int const x = cur.targetX();
+ if (cur.pos() && cur.boundary())
+ row = par.pos2row(cur.pos()-1);
+ else
+ row = par.pos2row(cur.pos());
+
if (!cur.selection()) {
- int const y = bv_funcs::getPos(cur).y_;
+ int const y = bv_funcs::getPos(cur, cur.boundary()).y_;
LCursor old = cur;
editXY(cur, x, y + par.rows()[row].descent() + 1);
if (old.pos() > 0
&& old.pos() < oldpar.size()
&& oldpar.isLineSeparator(old.pos())
- && oldpar.isLineSeparator(old.pos() - 1)) {
+ && oldpar.isLineSeparator(old.pos() - 1)
+ && oldpar.lookupChange(old.pos() - 1) != Change::DELETED) {
+ // We need to set the text to Change::INSERTED to
+ // get it erased properly
+ pars_[old.pit()].setChange(old.pos() -1,
+ Change::INSERTED);
pars_[old.pit()].erase(old.pos() - 1);
#ifdef WITH_WARNINGS
#warning This will not work anymore when we have multiple views of the same buffer
}
}
- if (deleted)
+ if (deleted) {
+ updateCounters(cur.buffer());
return true;
+ }
if (pars_[old.pit()].stripLeadingSpaces())
cur.resetAnchor();
}
-ParagraphList & LyXText::paragraphs() const
-{
- return const_cast<ParagraphList &>(pars_);
-}
-
-
void LyXText::recUndo(pit_type first, pit_type last) const
{
recordUndo(bv()->cursor(), Undo::ATOMIC, first, last);