#include "Text.h"
-#include "Bidi.h"
#include "Buffer.h"
#include "buffer_funcs.h"
#include "BufferList.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(), /**/);
+ 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) {
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);
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)
{
- LASSERT(this == cur.text(), /**/);
+ LBUFERR(this == cur.text());
if (cur.selection())
return cur.selectionAsString(false);
}
-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 const update_needed = !tm.contains(par);
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.
return cur.bv().checkDepm(cur, old) || update_needed;
}
void Text::setCursor(CursorSlice & cur, pit_type par, pos_type pos)
{
- LASSERT(par != int(paragraphs().size()), /**/);
+ LASSERT(par != int(paragraphs().size()), return);
cur.pit() = par;
cur.pos() = pos;
// None of these should happen, but we're scaredy-cats
if (pos < 0) {
- lyxerr << "don't like -1" << endl;
- LASSERT(false, /**/);
+ LYXERR0("Don't like -1!");
+ LATTEST(false);
}
if (pos > para.size()) {
- lyxerr << "don't like 1, pos: " << pos
+ LYXERR0("Don't like 1, pos: " << pos
<< " size: " << para.size()
- << " par: " << par << endl;
- LASSERT(false, /**/);
+ << " par: " << par);
+ LATTEST(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);
if (setfont)
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();
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;
+ 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();
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);
}
}
// 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;
}
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:
{
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;
void Text::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
{
// Do nothing if cursor is not in the paragraph where the
- // deletion occured,
+ // deletion occurred,
if (cur.pit() != where.pit())
return;
&& oldpar.isLineSeparator(old.pos() - 1)
&& !oldpar.isDeleted(old.pos() - 1)
&& !oldpar.isDeleted(old.pos())) {
- oldpar.eraseChar(old.pos() - 1, cur.buffer()->params().trackChanges);
+ oldpar.eraseChar(old.pos() - 1, cur.buffer()->params().track_changes);
// 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
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(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);
return true;
}
- if (oldpar.stripLeadingSpaces(cur.buffer()->params().trackChanges)) {
+ if (oldpar.stripLeadingSpaces(cur.buffer()->params().track_changes)) {
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];
continue;
if (par.empty() || (par.size() == 1 && par.isLineSeparator(0))) {
- pars_.erase(boost::next(pars_.begin(), pit));
+ pars_.erase(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