#include "support/textutils.h"
+#include <boost/current_function.hpp>
+
#include <sstream>
using lyx::pit_type;
Paragraph const & par = pars_[pit];
lyxerr[Debug::DEBUG]
- << BOOST_CURRENT_FUNCTION
- << ": x: " << x
- << " y: " << y
- << " pit: " << pit
- << endl;
+ << 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[Debug::DEBUG]
- << BOOST_CURRENT_FUNCTION
- << ": examining inset " << inset << endl;
-
+ << BOOST_CURRENT_FUNCTION
+ << ": examining inset " << inset << endl;
+
if (theCoords.getInsets().has(inset))
lyxerr[Debug::DEBUG]
- << BOOST_CURRENT_FUNCTION
+ << BOOST_CURRENT_FUNCTION
<< ": xo: " << inset->xo() << "..."
<< inset->xo() + inset->width()
<< " yo: " << inset->yo() - inset->ascent()
<< "..."
<< inset->yo() + inset->descent()
- << endl;
+ << endl;
else
lyxerr[Debug::DEBUG]
- << BOOST_CURRENT_FUNCTION
- << ": inset has no cached position" << endl;
+ << BOOST_CURRENT_FUNCTION
+ << ": inset has no cached position" << endl;
#endif
if (inset->covers(x, y)) {
lyxerr[Debug::DEBUG]
- << BOOST_CURRENT_FUNCTION
- << ": Hit inset: " << inset << endl;
+ << BOOST_CURRENT_FUNCTION
+ << ": Hit inset: " << inset << endl;
return inset;
}
}
lyxerr[Debug::DEBUG]
- << BOOST_CURRENT_FUNCTION
- << ": No inset hit. " << endl;
+ << BOOST_CURRENT_FUNCTION
+ << ": No inset hit. " << endl;
return 0;
}
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;
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;
}
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);
- cur.boundary(boundary);
return deleteEmptyParagraphMechanism(cur, old);
}
-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;
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
&& par.getInset(end - 1)->display()) {
c = end - 1;
}
+#endif
x = int(tmpx) + xo;
+ pos_type const col = c - row.pos();
- if (end == par.size())
- return c - row.pos();
+ if (!c || end == par.size())
+ return col;
- if (c && !par.isSeparator(c-1)) {
+ if (c==end && !par.isLineSeparator(c-1) && !par.isNewline(c-1)) {
boundary = true;
- return c - row.pos();
+ return col;
}
- return min(c - row.pos(), end - 1 - row.pos());
+ return min(col, end - 1 - row.pos());
}
BOOST_ASSERT(theCoords.getParPos().find(this) != theCoords.getParPos().end());
CoordCache::InnerParPosCache const & cc = theCoords.getParPos().find(this)->second;
lyxerr[Debug::DEBUG]
- << BOOST_CURRENT_FUNCTION
- << ": y: " << y << " cache size: " << cc.size()
- << endl;
+ << 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 et = cc.end();
for (; it != et; ++it) {
lyxerr[Debug::DEBUG]
- << BOOST_CURRENT_FUNCTION
- << " examining: pit: " << it->first
- << " y: " << it->second.y_
- << endl;
-
+ << 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[Debug::DEBUG]
- << BOOST_CURRENT_FUNCTION
- << ": found best y: " << yy << " for pit: " << pit
- << endl;
-
+ << BOOST_CURRENT_FUNCTION
+ << ": found best y: " << yy << " for pit: " << pit
+ << endl;
+
return pit;
}
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, 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, 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
cur = dummy;
return changed;
-
}
bool updateNeeded = false;
}
-bool LyXText::deleteEmptyParagraphMechanism(LCursor & cur, LCursor const & old)
+bool LyXText::deleteEmptyParagraphMechanism(LCursor & cur, LCursor & old)
{
// Would be wrong to delete anything if we have a selection.
if (cur.selection())
return false;
//lyxerr[Debug::DEBUG] << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
- Paragraph const & oldpar = pars_[old.pit()];
+ // old should point to us
+ BOOST_ASSERT(old.text() == this);
+
+ Paragraph & oldpar = old.paragraph();
// We allow all kinds of "mumbo-jumbo" when freespacing.
if (oldpar.isFreeSpacing())
return false;
/* Ok I'll put some comments here about what is missing.
- I have fixed BackSpace (and thus Delete) to not delete
- double-spaces automagically. I have also changed Cut,
- Copy and Paste to hopefully do some sensible things.
There are still some small problems that can lead to
double spaces stored in the document file or space at
the beginning of paragraphs(). This happens if you have
the cursor between to spaces and then save. Or if you
cut and paste and the selection have a space at the
- beginning and then save right after the paste. I am
- sure none of these are very hard to fix, but I will
- put out 1.1.4pre2 with FIX_DOUBLE_SPACE defined so
- that I can get some feedback. (Lgb)
+ beginning and then save right after the paste. (Lgb)
*/
// If old.pos() == 0 and old.pos()(1) == LineSeparator
// delete the LineSeparator.
// MISSING
- // If the chars around the old cursor were spaces, delete one of them.
- if (old.pit() != cur.pit() || old.pos() != cur.pos()) {
+ 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();
+ // If the chars around the old cursor were spaces, delete one of them.
+ if (!same_par_pos) {
// Only if the cursor has really moved.
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);
+ oldpar.setChange(old.pos() -1, Change::INSERTED);
+ oldpar.erase(old.pos() - 1);
#ifdef WITH_WARNINGS
#warning 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
// automated way in CursorSlice code. (JMarc 26/09/2001)
#endif
// correct all cursor parts
- fixCursorAfterDelete(cur.top(), old.top());
-#ifdef WITH_WARNINGS
-#warning DEPM, look here
-#endif
- //fixCursorAfterDelete(cur.anchor(), old.top());
+ if (same_par) {
+ fixCursorAfterDelete(cur.top(), old.top());
+ cur.resetAnchor();
+ }
return true;
}
}
// only do our magic if we changed paragraph
- if (old.pit() == cur.pit())
+ if (same_par)
return false;
// don't delete anything if this is the ONLY paragraph!
- if (pars_.size() == 1)
+ if (old.lastpit() == 0)
return false;
// Do not delete empty paragraphs with keepempty set.
if (oldpar.allowEmpty())
return false;
- // record if we have deleted a paragraph
- // we can't possibly have deleted a paragraph before this point
- bool deleted = false;
-
if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
- // ok, we will delete something
- deleted = true;
-
- bool selection_position_was_oldcursor_position =
- cur.anchor().pit() == old.pit() && cur.anchor().pos() == old.pos();
-
- // This is a bit of a overkill. We change the old and the cur par
- // at max, certainly not everything in between...
- recUndo(old.pit(), cur.pit());
-
// Delete old par.
- pars_.erase(pars_.begin() + old.pit());
-
- // Update cursor par offset if necessary.
- // Some 'iterator registration' would be nice that takes care of
- // such events. Maybe even signal/slot?
- if (cur.pit() > old.pit())
- --cur.pit();
-#ifdef WITH_WARNINGS
-#warning DEPM, look here
-#endif
-// if (cur.anchor().pit() > old.pit())
-// --cur.anchor().pit();
-
- if (selection_position_was_oldcursor_position) {
- // correct selection
- cur.resetAnchor();
+ recordUndo(old, Undo::ATOMIC, old.pit());
+ ParagraphList & plist = old.text()->paragraphs();
+ plist.erase(plist.begin() + old.pit());
+
+ // see #warning above
+ if (cur.depth() >= old.depth()) {
+ CursorSlice & curslice = cur[old.depth() - 1];
+ if (&curslice.inset() == &old.inset()
+ && curslice.pit() > old.pit()) {
+ --curslice.pit();
+ // since a paragraph has been deleted, all the
+ // insets after `old' have been copied and
+ // their address has changed. Therefore we
+ // need to `regenerate' cur. (JMarc)
+ cur.updateInsets(&(cur.bottom().inset()));
+ cur.resetAnchor();
+ }
}
- }
-
- if (deleted)
+ updateCounters(old.buffer());
return true;
+ }
- if (pars_[old.pit()].stripLeadingSpaces())
+ if (oldpar.stripLeadingSpaces())
cur.resetAnchor();
return false;
}
-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