#include "buffer_funcs.h"
#include "BufferParams.h"
#include "BufferView.h"
+#include "Changes.h"
#include "Cursor.h"
#include "ParIterator.h"
#include "CutAndPaste.h"
#include "Paragraph.h"
#include "paragraph_funcs.h"
#include "ParagraphParameters.h"
-#include "Undo.h"
+#include "TextMetrics.h"
#include "VSpace.h"
#include "WordLangTuple.h"
#include "support/convert.h"
#include <boost/current_function.hpp>
+#include <boost/next_prior.hpp>
#include <sstream>
BufferParams const & bp = buf.params();
if (token[0] != '\\') {
-#if 0
- string::const_iterator cit = token.begin();
- for (; cit != token.end(); ++cit)
- par.insertChar(par.size(), (*cit), font, change);
-#else
docstring dstr = lex.getDocString();
- docstring::const_iterator cit = dstr.begin();
- docstring::const_iterator cend = dstr.end();
- for (; cit != cend; ++cit)
- par.insertChar(par.size(), *cit, font, change);
-#endif
+ par.appendString(dstr, font, change);
+
} else if (token == "\\begin_layout") {
lex.eatLine();
docstring layoutname = lex.getDocString();
// Insets don't make sense in a free-spacing context! ---Kayvan
if (par.isFreeSpacing()) {
if (token == "\\InsetSpace")
- par.insertChar(par.size(), ' ', font, change);
+ par.appendChar(' ', font, change);
else if (lex.isOK()) {
lex.next();
string const next_token = lex.getString();
if (next_token == "\\-")
- par.insertChar(par.size(), '-', font, change);
+ par.appendChar('-', font, change);
else {
lex.printError("Token `$$Token' "
"is in free space "
font, change);
}
} else if (token == "\\backslash") {
- par.insertChar(par.size(), '\\', font, change);
+ par.appendChar('\\', font, change);
} else if (token == "\\newline") {
auto_ptr<Inset> inset(new InsetNewline);
inset->read(buf, lex);
}
-void Text::breakParagraph(Cursor & cur, bool keep_layout)
+void Text::breakParagraph(Cursor & cur, bool inverse_logic)
{
BOOST_ASSERT(this == cur.text());
cpar.eraseChar(cur.pos(), cur.buffer().params().trackChanges);
// What should the layout for the new paragraph be?
- int preserve_layout = 0;
- if (keep_layout)
- preserve_layout = 2;
- else
- preserve_layout = layout->isEnvironment();
+ bool keep_layout = inverse_logic ?
+ !layout->isEnvironment()
+ : layout->isEnvironment();
// We need to remember this before we break the paragraph, because
// that invalidates the layout variable
bool const isempty = cpar.allowEmpty() && cpar.empty();
lyx::breakParagraph(cur.buffer().params(), paragraphs(), cpit,
- cur.pos(), preserve_layout);
+ cur.pos(), keep_layout);
// After this, neither paragraph contains any rows!
BOOST_ASSERT(this == cur.text());
BOOST_ASSERT(c != Paragraph::META_INSET);
- recordUndo(cur, Undo::INSERT);
+ cur.recordUndo(INSERT_UNDO);
TextMetrics const & tm = cur.bv().textMetrics(this);
Buffer const & buffer = cur.buffer();
// adjacent character whose direction is the paragraph's
// direction; don't touch other properties of the font
Language const * lang =
- (pre_space_rtl == par.isRightToLeftPar(buffer.params())) ?
+ (pre_space_rtl == par.isRTL(buffer.params())) ?
pre_space_font.language() : post_space_font.language();
Font space_font = tm.getDisplayFont(cur.pit(), cur.pos() - 1);
// cur.updateFlags(Update::Force);
setCursor(cur.top(), cur.pit(), cur.pos() + 1);
- charInserted();
+ charInserted(cur);
}
-void Text::charInserted()
+void Text::charInserted(Cursor & cur)
{
// Here we call finishUndo for every 20 characters inserted.
// This is from my experience how emacs does it. (Lgb)
if (counter < 20) {
++counter;
} else {
- finishUndo();
+ cur.finishUndo();
counter = 0;
}
}
if (!cur.selection())
return;
- recordUndoSelection(cur, Undo::ATOMIC);
+ cur.recordUndoSelection();
pit_type begPit = cur.selectionBegin().pit();
pit_type endPit = cur.selectionEnd().pit();
//
- finishUndo();
+ cur.finishUndo();
cur.clearSelection();
setCursorIntern(cur, begPit, begPos);
cur.updateFlags(Update::Force);
{
BOOST_ASSERT(this == cur.text());
if (cur.lastpos() == 0)
- cursorRight(cur);
+ cursorForward(cur);
else {
cur.resetAnchor();
cur.selection() = true;
{
BOOST_ASSERT(this == cur.text());
if (cur.lastpos() == 0)
- cursorLeft(cur);
+ cursorBackward(cur);
else {
cur.resetAnchor();
cur.selection() = true;
cursorRightOneWord(cur);
}
- recordUndoSelection(cur, Undo::ATOMIC);
+ cur.recordUndoSelection();
pit_type begPit = from.pit();
pit_type endPit = to.pit();
}
Paragraph const & prevpar = prevcur.paragraph();
if (cur.pit() > 0 && par.layout() == prevpar.layout()) {
- recordUndo(cur, Undo::ATOMIC, prevcur.pit());
+ cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
mergeParagraph(bufparams, cur.text()->paragraphs(),
prevcur.pit());
updateLabels(cur.buffer());
if (cur.pos() != cur.lastpos()) {
// this is the code for a normal delete, not pasting
// any paragraphs
- recordUndo(cur, Undo::DELETE);
+ cur.recordUndo(DELETE_UNDO);
if(!par.eraseChar(cur.pos(), cur.buffer().params().trackChanges)) {
// the character has been logically deleted only => skip it
cur.top().forwardPos();
// is it an empty paragraph?
if (cur.lastpos() == 0
|| (cur.lastpos() == 1 && par.isSeparator(0))) {
- recordUndo(cur, Undo::ATOMIC, prevcur.pit(), cur.pit());
+ cur.recordUndo(ATOMIC_UNDO, prevcur.pit(), cur.pit());
plist.erase(boost::next(plist.begin(), cur.pit()));
needsUpdate = true;
}
// is previous par empty?
else if (prevcur.lastpos() == 0
|| (prevcur.lastpos() == 1 && prevpar.isSeparator(0))) {
- recordUndo(cur, Undo::ATOMIC, prevcur.pit(), cur.pit());
+ cur.recordUndo(ATOMIC_UNDO, prevcur.pit(), cur.pit());
plist.erase(boost::next(plist.begin(), prevcur.pit()));
needsUpdate = true;
}
// Correction: Pasting is always allowed with standard-layout
else if (par.layout() == prevpar.layout()
|| par.layout() == tclass.defaultLayout()) {
- recordUndo(cur, Undo::ATOMIC, prevcur.pit());
+ cur.recordUndo(ATOMIC_UNDO, prevcur.pit());
mergeParagraph(bufparams, plist, prevcur.pit());
needsUpdate = true;
}
} else {
// this is the code for a normal backspace, not pasting
// any paragraphs
- recordUndo(cur, Undo::DELETE);
- // We used to do cursorLeftIntern() here, but it is
+ cur.recordUndo(DELETE_UNDO);
+ // We used to do cursorBackwardIntern() here, but it is
// not a good idea since it triggers the auto-delete
- // mechanism. So we do a cursorLeftIntern()-lite,
+ // mechanism. So we do a cursorBackwardIntern()-lite,
// without the dreaded mechanism. (JMarc)
setCursorIntern(cur, cur.pit(), cur.pos() - 1,
false, cur.boundary());
if (isMainText(cur.bv().buffer()) || cur.inset().nargs() != 1)
return false;
- recordUndoInset(cur);
+ cur.recordUndoInset();
cur.selHandle(false);
// save position
pos_type spos = cur.pos();
// change it to the buffer language.
ParagraphList::iterator it = plist.begin();
ParagraphList::iterator it_end = plist.end();
- for (; it != it_end; it++) {
- it->changeLanguage(b.params(), latex_language,
- b.getLanguage());
- }
+ for (; it != it_end; it++)
+ it->changeLanguage(b.params(), latex_language, b.language());
- pasteParagraphList(cur, plist, b.params().getTextClass_ptr(),
+ pasteParagraphList(cur, plist, b.params().getTextClassPtr(),
b.errorList("Paste"));
// restore position
cur.pit() = std::min(cur.lastpit(), spit);
name = from_ascii(layout->latexname());
// for captions, we just take the caption type
- Inset * caption_inset = cur.innerInsetOfType(Inset::CAPTION_CODE);
+ Inset * caption_inset = cur.innerInsetOfType(CAPTION_CODE);
if (caption_inset)
name = from_ascii(static_cast<InsetCaption *>(caption_inset)->type());
// If none of the above worked, we'll see if we're inside various
// types of insets and take our abbreviation from them.
if (name.empty()) {
- Inset::Code const codes[] = {
- Inset::FLOAT_CODE,
- Inset::WRAP_CODE,
- Inset::FOOT_CODE
+ InsetCode const codes[] = {
+ FLOAT_CODE,
+ WRAP_CODE,
+ FOOT_CODE
};
for (unsigned int i = 0; i < (sizeof codes / sizeof codes[0]); ++i) {
Inset * float_inset = cur.innerInsetOfType(codes[i]);
// Track the changes if Change Tracking is enabled.
bool const trackChanges = cur.buffer().params().trackChanges;
- recordUndo(cur);
+ cur.recordUndo();
par.eraseChar(pos2, trackChanges);
par.eraseChar(pos1, trackChanges);