using std::endl;
using std::ostringstream;
using std::string;
+using std::min;
LyXText::LyXText(BufferView * bv)
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
{
// Don't use forwardChar here as ditend might have
// pos() == lastpos() and forwardChar would miss it.
// Can't use forwardPos either as this descends into
- // nested insets.
+ // nested insets.
for (; dit != ditend; dit.forwardPosNoDescend()) {
if (dit.pos() != dit.lastpos()) {
LyXFont f = getFont(dit.paragraph(), dit.pos());
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);
}
}
-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;
}
// 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_);
}
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)
{
+ cur.boundary(boundary);
setCursor(cur.top(), par, pos, boundary);
cur.setTargetX();
if (setfont)
}
}
+// 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);
bool LyXText::cursorRight(LCursor & cur)
{
- if (false && cur.boundary()) {
+ if (cur.boundary()) {
return setCursor(cur, cur.pit(), cur.pos(), true, false);
}
if (cur.pos() != cur.lastpos()) {
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()))
updateNeeded |= setCursor(cur, cur.pit(), cur.pos(), true, true);
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);
} else if (cur.pit() > 0) {
--cur.pit();
//cannot use 'par' now
- updateNeeded |= setCursor(cur, cur.pit(), x2pos(cur.pit(), cur.paragraph().rows().size() - 1, x));
+ updateNeeded |= setCursor(cur, cur.pit(),
+ 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,
}
}
- 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);