#include "support/textutils.h"
+#include <boost/current_function.hpp>
+
#include <sstream>
using lyx::pit_type;
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
{
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;
// 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);
}
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);
// 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
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)
+ 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);
+ cur.clearSelection();
// This happens when you move out of an inset.
// And to give the DEPM the possibility of doing
} 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);
+ cur.clearSelection();
// This happens when you move out of an inset.
// And to give the DEPM the possibility of doing
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);
+ 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);
projects / lyx.git / blobdiff