#include "Text.h"
-#include "Bidi.h"
#include "Buffer.h"
#include "buffer_funcs.h"
#include "BufferList.h"
#include "TextClass.h"
#include "TextMetrics.h"
-#include "insets/InsetCollapsable.h"
+#include "insets/InsetCollapsible.h"
#include "mathed/InsetMathHull.h"
#include "support/lassert.h"
#include "support/debug.h"
#include "support/gettext.h"
+#include "support/lyxalgo.h"
#include "support/textutils.h"
-#include <boost/next_prior.hpp>
-
#include <sstream>
using namespace std;
pos_type pos, Font const & font)
{
Inset * const inset = pars_[pit].getInset(pos);
- LASSERT(inset && inset->resetFontEdit(), /**/);
+ LASSERT(inset && inset->resetFontEdit(), return);
CursorSlice::idx_type endidx = inset->nargs();
for (CursorSlice cs(*inset); cs.idx() != endidx; ++cs.idx()) {
void Text::setLayout(pit_type start, pit_type end,
docstring const & layout)
{
- LASSERT(start != end, /**/);
+ LASSERT(start != end, return);
Buffer const & buffer = owner_->buffer();
BufferParams const & bp = buffer.params();
// set layout over selection and make a total rebreak of those paragraphs
void Text::setLayout(Cursor & cur, docstring const & layout)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
pit_type start = cur.selBegin().pit();
pit_type end = cur.selEnd().pit() + 1;
cur.recordUndoSelection();
setLayout(start, end, layout);
+ cur.setCurrentFont();
cur.forceBufferUpdate();
}
bool Text::changeDepthAllowed(Cursor & cur, DEPTH_CHANGE type) const
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(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)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
pit_type const beg = cur.selBegin().pit();
pit_type const end = cur.selEnd().pit() + 1;
cur.recordUndoSelection();
void Text::setFont(Cursor & cur, Font const & font, bool toggleall)
{
LASSERT(this == cur.text(), return);
+
+ // If there is a selection, record undo before the cursor font is changed.
+ if (cur.selection())
+ cur.recordUndoSelection();
+
// Set the current_font
// Determine basis font
FontInfo layoutfont;
return;
// Ok, we have a selection.
- cur.recordUndoSelection();
Font newfont = font;
- if (toggleall) {
+ if (toggleall) {
// Toggling behaves as follows: We check the first character of the
// selection. If it's (say) got EMPH on, then we set to off; if off,
// then to on. With families and the like, we set it to INHERIT, if
CursorSlice const & sl = cur.selBegin();
Text const & text = *sl.text();
Paragraph const & par = text.getPar(sl.pit());
-
+
// get font at the position
Font oldfont = par.getFont(cur.bv().buffer().params(), sl.pos(),
text.outerFont(sl.pit()));
FontInfo const & oldfi = oldfont.fontInfo();
-
+
FontInfo & newfi = newfont.fontInfo();
-
+
FontFamily newfam = newfi.family();
if (newfam != INHERIT_FAMILY && newfam != IGNORE_FAMILY &&
newfam == oldfi.family())
newfi.setFamily(INHERIT_FAMILY);
-
+
FontSeries newser = newfi.series();
if (newser == BOLD_SERIES && oldfi.series() == BOLD_SERIES)
newfi.setSeries(INHERIT_SERIES);
-
+
FontShape newshp = newfi.shape();
- if (newshp != INHERIT_SHAPE && newshp != IGNORE_SHAPE &&
+ if (newshp != INHERIT_SHAPE && newshp != IGNORE_SHAPE &&
newshp == oldfi.shape())
newfi.setShape(INHERIT_SHAPE);
ColorCode newcol = newfi.color();
- if (newcol != Color_none && newcol != Color_inherit
+ if (newcol != Color_none && newcol != Color_inherit
&& newcol != Color_ignore && newcol == oldfi.color())
newfi.setColor(Color_none);
newfi.setUnderbar(oldfi.underbar() == FONT_OFF ? FONT_ON : FONT_OFF);
if (newfi.strikeout() == FONT_TOGGLE)
newfi.setStrikeout(oldfi.strikeout() == FONT_OFF ? FONT_ON : FONT_OFF);
+ if (newfi.xout() == FONT_TOGGLE)
+ newfi.setXout(oldfi.xout() == FONT_OFF ? FONT_ON : FONT_OFF);
if (newfi.uuline() == FONT_TOGGLE)
newfi.setUuline(oldfi.uuline() == FONT_OFF ? FONT_ON : FONT_OFF);
if (newfi.uwave() == FONT_TOGGLE)
newfi.setNoun(oldfi.noun() == FONT_OFF ? FONT_ON : FONT_OFF);
if (newfi.number() == FONT_TOGGLE)
newfi.setNumber(oldfi.number() == FONT_OFF ? FONT_ON : FONT_OFF);
+ if (newfi.nospellcheck() == FONT_TOGGLE)
+ newfi.setNoSpellcheck(oldfi.nospellcheck() == FONT_OFF ? FONT_ON : FONT_OFF);
}
- setFont(cur.bv(), cur.selectionBegin().top(),
+ setFont(cur.bv(), cur.selectionBegin().top(),
cur.selectionEnd().top(), newfont);
}
Font f = tm.displayFont(pit, pos);
f.update(font, language);
setCharFont(pit, pos, f, tm.font_);
- // font change may change language...
+ // font change may change language...
// spell checker has to know that
pars_[pit].requestSpellCheck(pos);
}
bool Text::cursorTop(Cursor & cur)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
return setCursor(cur, 0, 0);
}
bool Text::cursorBottom(Cursor & cur)
{
- LASSERT(this == cur.text(), /**/);
- return setCursor(cur, cur.lastpit(), boost::prior(paragraphs().end())->size());
+ LBUFERR(this == cur.text());
+ return setCursor(cur, cur.lastpit(), prev(paragraphs().end(), 1)->size());
}
void Text::toggleFree(Cursor & cur, Font const & font, bool toggleall)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
// If the mask is completely neutral, tell user
if (font.fontInfo() == ignore_font && font.language() == ignore_language) {
// Could only happen with user style
}
-docstring Text::getStringToIndex(Cursor const & cur)
+docstring Text::getStringForDialog(Cursor & cur)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
if (cur.selection())
return cur.selectionAsString(false);
// Try implicit word selection. If there is a change
// in the language the implicit word selection is
// disabled.
- Cursor tmpcur = cur;
- selectWord(tmpcur, 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
- return tmpcur.selectionAsString(false);
-
- return docstring();
+ selectWordWhenUnderCursor(cur, WHOLE_WORD);
+ docstring const & retval = cur.selectionAsString(false);
+ cur.clearSelection();
+ return retval;
}
}
-void Text::setParagraphs(Cursor & cur, docstring arg, bool merge)
+void Text::setParagraphs(Cursor & cur, docstring arg, bool merge)
{
- LASSERT(cur.text(), /**/);
+ LBUFERR(cur.text());
//FIXME UNICODE
string const argument = to_utf8(arg);
// with same layout in a sequence.
// Do this only once for a selected range of paragraphs
// of the same layout and depth.
- cur.recordUndo();
+ c.recordUndo();
par.params().apply(params, par.layout());
if (par.getDepth() != priordepth || par.layout() != priorlayout)
setLabelWidthStringToSequence(c, params.labelWidthString());
}
-//FIXME This is a little redundant now, but it's probably worth keeping,
-//especially if we're going to go away from using serialization internally
-//quite so much.
-void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p)
+void Text::setParagraphs(Cursor & cur, ParagraphParameters const & p)
{
- LASSERT(cur.text(), /**/);
+ LBUFERR(cur.text());
depth_type priordepth = -1;
Layout priorlayout;
// this really should just insert the inset and not move the cursor.
void Text::insertInset(Cursor & cur, Inset * inset)
{
- LASSERT(this == cur.text(), /**/);
- LASSERT(inset, /**/);
+ LBUFERR(this == cur.text());
+ LBUFERR(inset);
cur.paragraph().insertInset(cur.pos(), inset, cur.current_font,
- Change(cur.buffer()->params().trackChanges
+ Change(cur.buffer()->params().track_changes
? Change::INSERTED : Change::UNCHANGED));
}
-bool Text::setCursor(Cursor & cur, pit_type par, pos_type pos,
+bool Text::setCursor(Cursor & cur, pit_type pit, pos_type pos,
bool setfont, bool boundary)
{
TextMetrics const & tm = cur.bv().textMetrics(this);
- bool const update_needed = !tm.contains(par);
+ bool const update_needed = !tm.contains(pit);
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.
+ setCursorIntern(cur, pit, pos, setfont, boundary);
return cur.bv().checkDepm(cur, old) || update_needed;
}
-void Text::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
+void Text::setCursorIntern(Cursor & cur, pit_type pit, pos_type pos,
+ bool setfont, bool boundary)
{
- LASSERT(par != int(paragraphs().size()), /**/);
- cur.pit() = par;
- cur.pos() = pos;
-
- // now some strict checking
- Paragraph & para = getPar(par);
-
- // None of these should happen, but we're scaredy-cats
- if (pos < 0) {
- lyxerr << "don't like -1" << endl;
- LASSERT(false, /**/);
- }
-
- if (pos > para.size()) {
- lyxerr << "don't like 1, pos: " << pos
- << " size: " << para.size()
- << " par: " << par << endl;
- LASSERT(false, /**/);
- }
-}
-
-
-void Text::setCursorIntern(Cursor & cur,
- pit_type par, pos_type pos, bool setfont, bool boundary)
-{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
cur.boundary(boundary);
- setCursor(cur.top(), par, pos);
+ cur.top().setPitPos(pit, pos);
if (setfont)
cur.setCurrentFont();
}
bool Text::checkAndActivateInset(Cursor & cur, bool front)
{
- if (cur.selection())
- return false;
if (front && cur.pos() == cur.lastpos())
return false;
if (!front && cur.pos() == 0)
Inset * inset = front ? cur.nextInset() : cur.prevInset();
if (!inset || !inset->editable())
return false;
+ if (cur.selection() && cur.realAnchor().find(inset) == -1)
+ return false;
/*
* Apparently, when entering an inset we are expected to be positioned
* *before* it in the containing paragraph, regardless of the direction
if (!front)
--cur.pos();
inset->edit(cur, front);
+ cur.setCurrentFont();
+ cur.boundary(false);
return true;
}
bool Text::checkAndActivateInsetVisual(Cursor & cur, bool movingForward, bool movingLeft)
{
- if (cur.selection())
- return false;
if (cur.pos() == -1)
return false;
if (cur.pos() == cur.lastpos())
Inset * inset = par.isInset(cur.pos()) ? par.getInset(cur.pos()) : 0;
if (!inset || !inset->editable())
return false;
- inset->edit(cur, movingForward,
+ if (cur.selection() && cur.realAnchor().find(inset) == -1)
+ return false;
+ inset->edit(cur, movingForward,
movingLeft ? Inset::ENTRY_DIRECTION_RIGHT : Inset::ENTRY_DIRECTION_LEFT);
+ cur.setCurrentFont();
+ cur.boundary(false);
return true;
}
cur.textRow().pos() == cur.pos() &&
!cur.paragraph().isLineSeparator(cur.pos() - 1) &&
!cur.paragraph().isNewline(cur.pos() - 1) &&
+ !cur.paragraph().isEnvSeparator(cur.pos() - 1) &&
!cur.paragraph().isSeparator(cur.pos() - 1)) {
return setCursor(cur, cur.pit(), cur.pos(), true, true);
}
-
+
// go left and try to enter inset
if (checkAndActivateInset(cur, false))
return false;
-
+
// normal character left
return setCursor(cur, cur.pit(), cur.pos() - 1, true, false);
}
// move to the previous paragraph or do nothing
- if (cur.pit() > 0)
- return setCursor(cur, cur.pit() - 1, getPar(cur.pit() - 1).size(), true, false);
+ if (cur.pit() > 0) {
+ Paragraph & par = getPar(cur.pit() - 1);
+ pos_type lastpos = par.size();
+ if (lastpos > 0 && par.isEnvSeparator(lastpos - 1))
+ return setCursor(cur, cur.pit() - 1, lastpos - 1, true, false);
+ else
+ return setCursor(cur, cur.pit() - 1, lastpos, true, false);
+ }
return false;
}
cur = temp_cur;
return false;
}
- return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
+ return setCursor(cur, temp_cur.pit(), temp_cur.pos(),
true, temp_cur.boundary());
}
if (cur.boundary() && !tm.isRTLBoundary(cur.pit(), cur.pos()))
return setCursor(cur, cur.pit(), cur.pos(), true, false);
- // next position is left of boundary,
+ // next position is left of boundary,
// but go to next line for special cases like space, newline, linesep
#if 0
// some effectless debug code to see the values in the debugger
bool sep2 = cur.paragraph().isSeparator(cur.pos()+1);
}
#endif
- if (cur.textRow().endpos() == cur.pos() + 1 &&
- cur.textRow().endpos() != cur.lastpos() &&
- !cur.paragraph().isNewline(cur.pos()) &&
- !cur.paragraph().isLineSeparator(cur.pos()) &&
- !cur.paragraph().isSeparator(cur.pos())) {
- return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
+ if (cur.textRow().endpos() == cur.pos() + 1) {
+ if (cur.paragraph().isEnvSeparator(cur.pos()) &&
+ cur.pos() + 1 == cur.lastpos() &&
+ cur.pit() != cur.lastpit()) {
+ // move to next paragraph
+ return setCursor(cur, cur.pit() + 1, 0, true, false);
+ } else if (cur.textRow().endpos() != cur.lastpos() &&
+ !cur.paragraph().isNewline(cur.pos()) &&
+ !cur.paragraph().isEnvSeparator(cur.pos()) &&
+ !cur.paragraph().isLineSeparator(cur.pos()) &&
+ !cur.paragraph().isSeparator(cur.pos())) {
+ return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
+ }
}
-
+
// in front of RTL boundary? Stay on this side of the boundary because:
// ab|cDDEEFFghi -> abc|DDEEFFghi
if (tm.isRTLBoundary(cur.pit(), cur.pos() + 1))
return setCursor(cur, cur.pit(), cur.pos() + 1, true, true);
-
+
// move right
return setCursor(cur, cur.pit(), cur.pos() + 1, true, false);
}
{
bool updated = false;
if (cur.pit() != cur.lastpit())
- updated = setCursor(cur, cur.pit() + 1, 0);
+ if (lyxrc.mac_like_cursor_movement)
+ if (cur.pos() == cur.lastpos())
+ updated = setCursor(cur, cur.pit() + 1, getPar(cur.pit() + 1).size());
+ else
+ updated = setCursor(cur, cur.pit(), cur.lastpos());
+ else
+ updated = setCursor(cur, cur.pit() + 1, 0);
else
updated = setCursor(cur, cur.pit(), cur.lastpos());
return updated;
}
+namespace {
-// fix the cursor `cur' after a characters has been deleted at `where'
-// position. Called by deleteEmptyParagraphMechanism
-void Text::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
+/** delete num_spaces characters between from and to. Return the
+ * number of spaces that got physically deleted (not marked as
+ * deleted) */
+int deleteSpaces(Paragraph & par, pos_type const from, pos_type to,
+ int num_spaces, bool const trackChanges)
{
- // Do nothing if cursor is not in the paragraph where the
- // deletion occured,
- if (cur.pit() != where.pit())
- return;
+ if (num_spaces <= 0)
+ return 0;
- // If cursor position is after the deletion place update it
- if (cur.pos() > where.pos())
- --cur.pos();
+ // First, delete spaces marked as inserted
+ int pos = from;
+ while (pos < to && num_spaces > 0) {
+ Change const & change = par.lookupChange(pos);
+ if (change.inserted() && change.currentAuthor()) {
+ par.eraseChar(pos, trackChanges);
+ --num_spaces;
+ --to;
+ } else
+ ++pos;
+ }
+
+ // Then remove remaining spaces
+ int const psize = par.size();
+ par.eraseChars(from, from + num_spaces, trackChanges);
+ return psize - par.size();
+}
- // Check also if we don't want to set the cursor on a spot behind the
- // pagragraph because we erased the last character.
- if (cur.pos() > cur.lastpos())
- cur.pos() = cur.lastpos();
}
//LYXERR(Debug::DEBUG, "DEPM: cur:\n" << cur << "old:\n" << old);
Paragraph & oldpar = old.paragraph();
+ bool const trackChanges = cur.buffer()->params().track_changes;
// We allow all kinds of "mumbo-jumbo" when freespacing.
if (oldpar.isFreeSpacing())
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
+ the cursor between two spaces and then save. Or if you
+ cut and paste and the selection has a space at the
beginning and then save right after the paste. (Lgb)
*/
if (&old.inset() == &cur[depth].inset())
break;
- // Whether a common inset is found and whether the cursor is still in
+ // 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
+ bool const same_par = depth < cur.depth() && old.idx() == cur[depth].idx()
+ && 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 the chars around the old cursor were spaces, delete some of
+ // them, but only if the cursor has really moved.
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.isDeleted(old.pos() - 1)
- && !oldpar.isDeleted(old.pos())) {
- 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
+ // find range of spaces around cursors
+ pos_type from = old.pos();
+ while (from > 0
+ && oldpar.isLineSeparator(from - 1)
+ && !oldpar.isDeleted(from - 1))
+ --from;
+ pos_type to = old.pos();
+ while (to < old.lastpos()
+ && oldpar.isLineSeparator(to)
+ && !oldpar.isDeleted(to))
+ ++to;
+
+ int num_spaces = to - from;
+ // If we are not at the start of the paragraph, keep one space
+ if (from != to && from > 0)
+ --num_spaces;
+
+ // If cursor is inside range, keep one additional space
+ if (same_par && cur.pos() > from && cur.pos() < to)
+ --num_spaces;
+
+ // Remove spaces and adapt cursor.
+ if (num_spaces > 0) {
+ int const deleted =
+ deleteSpaces(oldpar, from, to, num_spaces, trackChanges);
+ // correct cur position
+ // FIXME: there can be other cursors pointing there, we should update them
if (same_par) {
- fixCursorAfterDelete(cur[depth], old.top());
+ if (cur[depth].pos() >= to)
+ cur[depth].pos() -= deleted;
+ else if (cur[depth].pos() > from)
+ cur[depth].pos() = min(from + 1, old.lastpos());
need_anchor_change = true;
}
return true;
}
}
- // only do our magic if we changed paragraph
+ // only do our other magic if we changed paragraph
if (same_par)
return false;
if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
// Delete old par.
- old.recordUndo(ATOMIC_UNDO,
- max(old.pit() - 1, pit_type(0)),
- min(old.pit() + 1, old.lastpit()));
+ old.recordUndo(max(old.pit() - 1, pit_type(0)),
+ min(old.pit() + 1, old.lastpit()));
ParagraphList & plist = old.text()->paragraphs();
bool const soa = oldpar.params().startOfAppendix();
- plist.erase(boost::next(plist.begin(), old.pit()));
+ plist.erase(lyx::next(plist.begin(), old.pit()));
// do not lose start of appendix marker (bug 4212)
if (soa && old.pit() < pit_type(plist.size()))
plist[old.pit()].params().startOfAppendix(true);
- // see #warning (FIXME?) above
+ // see #warning (FIXME?) above
if (cur.depth() >= old.depth()) {
CursorSlice & curslice = cur[old.depth() - 1];
if (&curslice.inset() == &old.inset()
return true;
}
- if (oldpar.stripLeadingSpaces(cur.buffer()->params().trackChanges)) {
+ if (oldpar.stripLeadingSpaces(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)
{
- LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), /**/);
+ LASSERT(first >= 0 && first <= last && last < (int) pars_.size(), return);
for (pit_type pit = first; pit <= last; ++pit) {
Paragraph & par = pars_[pit];
if (par.isFreeSpacing())
continue;
- for (pos_type pos = 1; pos < par.size(); ++pos) {
- if (par.isLineSeparator(pos) && par.isLineSeparator(pos - 1)
- && !par.isDeleted(pos - 1)) {
- if (par.eraseChar(pos - 1, trackChanges)) {
- --pos;
- }
- }
+ pos_type from = 0;
+ while (from < par.size()) {
+ // skip non-spaces
+ while (from < par.size()
+ && (!par.isLineSeparator(from) || par.isDeleted(from)))
+ ++from;
+ // find string of spaces
+ pos_type to = from;
+ while (to < par.size()
+ && par.isLineSeparator(to) && !par.isDeleted(to))
+ ++to;
+ // empty? We are done
+ if (from == to)
+ break;
+
+ int num_spaces = to - from;
+
+ // If we are not at the extremity of the paragraph, keep one space
+ if (from != to && from > 0 && to < par.size())
+ --num_spaces;
+
+ // Remove spaces if needed
+ int const deleted = deleteSpaces(par, from , to, num_spaces, trackChanges);
+ from = to - deleted;
}
// don't delete anything if this is the only remaining paragraph
continue;
if (par.empty() || (par.size() == 1 && par.isLineSeparator(0))) {
- pars_.erase(boost::next(pars_.begin(), pit));
+ pars_.erase(lyx::next(pars_.begin(), pit));
--pit;
--last;
continue;
}
-void Text::recUndo(Cursor & cur, pit_type first, pit_type last) const
-{
- cur.recordUndo(ATOMIC_UNDO, first, last);
-}
-
-
-void Text::recUndo(Cursor & cur, pit_type par) const
-{
- cur.recordUndo(ATOMIC_UNDO, par, par);
-}
-
} // namespace lyx