X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText.cpp;h=d8436b2ddc7eed3cfa789a052477a5ef8401ac01;hb=ce2e071cdfde88864c1524818d66cbae52273502;hp=795fca6bf8765ed646fc9d9abfcd1df862880516;hpb=9d0ea8aeff32833a90b3fe64df0c5518a9e241be;p=lyx.git diff --git a/src/Text.cpp b/src/Text.cpp index 795fca6bf8..d8436b2ddc 100644 --- a/src/Text.cpp +++ b/src/Text.cpp @@ -1,17 +1,17 @@ /** - * \file src/text.cpp + * \file src/Text.cpp * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * * \author Asger Alstrup - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author Dov Feldstern * \author Jean-Marc Lasgouttes * \author John Levon - * \author André Pönitz + * \author André Pönitz * \author Stefan Schimanski * \author Dekel Tsur - * \author Jürgen Vigna + * \author Jürgen Vigna * * Full author contact details are available in file CREDITS. */ @@ -26,36 +26,33 @@ #include "BufferParams.h" #include "BufferView.h" #include "Changes.h" +#include "CompletionList.h" #include "Cursor.h" -#include "ParIterator.h" #include "CutAndPaste.h" -#include "support/debug.h" #include "DispatchResult.h" #include "Encoding.h" #include "ErrorList.h" #include "FuncRequest.h" #include "factory.h" -#include "FontIterator.h" -#include "support/gettext.h" +#include "InsetList.h" #include "Language.h" +#include "Layout.h" #include "Length.h" #include "Lexer.h" +#include "lyxfind.h" #include "LyXRC.h" #include "Paragraph.h" -#include "paragraph_funcs.h" #include "ParagraphParameters.h" +#include "ParIterator.h" #include "TextClass.h" #include "TextMetrics.h" #include "VSpace.h" #include "WordLangTuple.h" - -#include "frontends/FontMetrics.h" -#include "frontends/Painter.h" +#include "WordList.h" #include "insets/InsetText.h" #include "insets/InsetBibitem.h" #include "insets/InsetCaption.h" -#include "insets/InsetHFill.h" #include "insets/InsetLine.h" #include "insets/InsetNewline.h" #include "insets/InsetNewpage.h" @@ -64,42 +61,221 @@ #include "insets/InsetSpecialChar.h" #include "insets/InsetTabular.h" +#include "support/debug.h" #include "support/docstream.h" +#include "support/gettext.h" +#include "support/lassert.h" #include "support/lstrings.h" #include "support/textutils.h" -#include "support/convert.h" -#include #include #include -using std::auto_ptr; -using std::advance; -using std::distance; -using std::max; -using std::min; -using std::endl; -using std::string; +using namespace std; +using namespace lyx::support; namespace lyx { -using support::bformat; -using support::contains; -using support::split; -using support::subst; - using cap::cutSelection; using cap::pasteParagraphList; -using frontend::FontMetrics; +static bool moveItem(Paragraph & fromPar, pos_type fromPos, + Paragraph & toPar, pos_type toPos, BufferParams const & params) +{ + // Note: moveItem() does not honour change tracking! + // Therefore, it should only be used for breaking and merging paragraphs + + // We need a copy here because the character at fromPos is going to be erased. + Font const tmpFont = fromPar.getFontSettings(params, fromPos); + Change const tmpChange = fromPar.lookupChange(fromPos); + + if (Inset * tmpInset = fromPar.getInset(fromPos)) { + fromPar.releaseInset(fromPos); + // The inset is not in fromPar any more. + if (!toPar.insertInset(toPos, tmpInset, tmpFont, tmpChange)) { + delete tmpInset; + return false; + } + return true; + } + + char_type const tmpChar = fromPar.getChar(fromPos); + fromPar.eraseChar(fromPos, false); + toPar.insertChar(toPos, tmpChar, tmpFont, tmpChange); + return true; +} + + +void breakParagraphConservative(BufferParams const & bparams, + ParagraphList & pars, pit_type par_offset, pos_type pos) +{ + // create a new paragraph + Paragraph & tmp = *pars.insert(boost::next(pars.begin(), par_offset + 1), + Paragraph()); + Paragraph & par = pars[par_offset]; + + tmp.setInsetOwner(&par.inInset()); + tmp.makeSameLayout(par); + + LASSERT(pos <= par.size(), /**/); + + if (pos < par.size()) { + // move everything behind the break position to the new paragraph + pos_type pos_end = par.size() - 1; + + for (pos_type i = pos, j = 0; i <= pos_end; ++i) { + if (moveItem(par, pos, tmp, j, bparams)) { + ++j; + } + } + // Move over the end-of-par change information + tmp.setChange(tmp.size(), par.lookupChange(par.size())); + par.setChange(par.size(), Change(bparams.trackChanges ? + Change::INSERTED : Change::UNCHANGED)); + } +} + + +void mergeParagraph(BufferParams const & bparams, + ParagraphList & pars, pit_type par_offset) +{ + Paragraph & next = pars[par_offset + 1]; + Paragraph & par = pars[par_offset]; + + pos_type pos_end = next.size() - 1; + pos_type pos_insert = par.size(); + + // the imaginary end-of-paragraph character (at par.size()) has to be + // marked as unmodified. Otherwise, its change is adopted by the first + // character of the next paragraph. + if (par.isChanged(par.size())) { + LYXERR(Debug::CHANGES, + "merging par with inserted/deleted end-of-par character"); + par.setChange(par.size(), Change(Change::UNCHANGED)); + } + + Change change = next.lookupChange(next.size()); + + // move the content of the second paragraph to the end of the first one + for (pos_type i = 0, j = pos_insert; i <= pos_end; ++i) { + if (moveItem(next, 0, par, j, bparams)) { + ++j; + } + } + + // move the change of the end-of-paragraph character + par.setChange(par.size(), change); + + pars.erase(boost::next(pars.begin(), par_offset + 1)); +} -namespace { -void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex, +pit_type Text::depthHook(pit_type pit, depth_type depth) const +{ + pit_type newpit = pit; + + if (newpit != 0) + --newpit; + + while (newpit != 0 && pars_[newpit].getDepth() > depth) + --newpit; + + if (pars_[newpit].getDepth() > depth) + return pit; + + return newpit; +} + + +pit_type Text::outerHook(pit_type par_offset) const +{ + Paragraph const & par = pars_[par_offset]; + + if (par.getDepth() == 0) + return pars_.size(); + return depthHook(par_offset, depth_type(par.getDepth() - 1)); +} + + +bool Text::isFirstInSequence(pit_type par_offset) const +{ + Paragraph const & par = pars_[par_offset]; + + pit_type dhook_offset = depthHook(par_offset, par.getDepth()); + + if (dhook_offset == par_offset) + return true; + + Paragraph const & dhook = pars_[dhook_offset]; + + return dhook.layout() != par.layout() + || dhook.getDepth() != par.getDepth(); +} + + +Font const Text::outerFont(pit_type par_offset) const +{ + depth_type par_depth = pars_[par_offset].getDepth(); + FontInfo tmpfont = inherit_font; + + // Resolve against environment font information + while (par_offset != pit_type(pars_.size()) + && par_depth + && !tmpfont.resolved()) { + par_offset = outerHook(par_offset); + if (par_offset != pit_type(pars_.size())) { + tmpfont.realize(pars_[par_offset].layout().font); + par_depth = pars_[par_offset].getDepth(); + } + } + + return Font(tmpfont); +} + + +void acceptChanges(ParagraphList & pars, BufferParams const & bparams) +{ + pit_type pars_size = static_cast(pars.size()); + + // first, accept changes within each individual paragraph + // (do not consider end-of-par) + for (pit_type pit = 0; pit < pars_size; ++pit) { + if (!pars[pit].empty()) // prevent assertion failure + pars[pit].acceptChanges(0, pars[pit].size()); + } + + // next, accept imaginary end-of-par characters + for (pit_type pit = 0; pit < pars_size; ++pit) { + pos_type pos = pars[pit].size(); + + if (pars[pit].isInserted(pos)) { + pars[pit].setChange(pos, Change(Change::UNCHANGED)); + } else if (pars[pit].isDeleted(pos)) { + if (pit == pars_size - 1) { + // we cannot remove a par break at the end of the last + // paragraph; instead, we mark it unchanged + pars[pit].setChange(pos, Change(Change::UNCHANGED)); + } else { + mergeParagraph(bparams, pars, pit); + --pit; + --pars_size; + } + } + } +} + +InsetText const & Text::inset() const +{ + return *owner_; +} + + +void Text::readParToken(Paragraph & par, Lexer & lex, string const & token, Font & font, Change & change, ErrorList & errorList) { - BufferParams const & bp = buf.params(); + Buffer * buf = const_cast(&owner_->buffer()); + BufferParams const & bp = buf->params(); if (token[0] != '\\') { docstring dstr = lex.getDocString(); @@ -112,40 +288,45 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex, font = Font(inherit_font, bp.language); change = Change(Change::UNCHANGED); - TextClass const & tclass = bp.getTextClass(); + DocumentClass const & tclass = bp.documentClass(); - if (layoutname.empty()) { + if (layoutname.empty()) layoutname = tclass.defaultLayoutName(); - } - bool hasLayout = tclass.hasLayout(layoutname); - - if (!hasLayout) { - errorList.push_back(ErrorItem(_("Unknown layout"), - bformat(_("Layout '%1$s' does not exist in textclass '%2$s'\nTrying to use the default instead.\n"), - layoutname, from_utf8(tclass.name())), par.id(), 0, par.size())); - layoutname = tclass.defaultLayoutName(); + if (owner_->forcePlainLayout()) { + // in this case only the empty layout is allowed + layoutname = tclass.plainLayoutName(); + } else if (par.usePlainLayout()) { + // in this case, default layout maps to empty layout + if (layoutname == tclass.defaultLayoutName()) + layoutname = tclass.plainLayoutName(); + } else { + // otherwise, the empty layout maps to the default + if (layoutname == tclass.plainLayoutName()) + layoutname = tclass.defaultLayoutName(); } - par.layout(bp.getTextClass()[layoutname]); + // When we apply an unknown layout to a document, we add this layout to the textclass + // of this document. For example, when you apply class article to a beamer document, + // all unknown layouts such as frame will be added to document class article so that + // these layouts can keep their original names. + tclass.addLayoutIfNeeded(layoutname); + + par.setLayout(bp.documentClass()[layoutname]); // Test whether the layout is obsolete. - LayoutPtr const & layout = par.layout(); - if (!layout->obsoleted_by().empty()) - par.layout(bp.getTextClass()[layout->obsoleted_by()]); + Layout const & layout = par.layout(); + if (!layout.obsoleted_by().empty()) + par.setLayout(bp.documentClass()[layout.obsoleted_by()]); par.params().read(lex); } else if (token == "\\end_layout") { - lyxerr << BOOST_CURRENT_FUNCTION - << ": Solitary \\end_layout in line " - << lex.getLineNo() << "\n" - << "Missing \\begin_layout?.\n"; + LYXERR0("Solitary \\end_layout in line " << lex.lineNumber() << "\n" + << "Missing \\begin_layout ?"); } else if (token == "\\end_inset") { - lyxerr << BOOST_CURRENT_FUNCTION - << ": Solitary \\end_inset in line " - << lex.getLineNo() << "\n" - << "Missing \\begin_inset?.\n"; + LYXERR0("Solitary \\end_inset in line " << lex.lineNumber() << "\n" + << "Missing \\begin_inset ?"); } else if (token == "\\begin_inset") { Inset * inset = readInset(lex, buf); if (inset) @@ -180,10 +361,10 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex, } } else if (token == "\\numeric") { lex.next(); - font.fontInfo().setNumber(font.setLyXMisc(lex.getString())); + font.fontInfo().setNumber(setLyXMisc(lex.getString())); } else if (token == "\\emph") { lex.next(); - font.fontInfo().setEmph(font.setLyXMisc(lex.getString())); + font.fontInfo().setEmph(setLyXMisc(lex.getString())); } else if (token == "\\bar") { lex.next(); string const tok = lex.getString(); @@ -197,93 +378,58 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex, else lex.printError("Unknown bar font flag " "`$$Token'"); + } else if (token == "\\strikeout") { + lex.next(); + font.fontInfo().setStrikeout(setLyXMisc(lex.getString())); + } else if (token == "\\uuline") { + lex.next(); + font.fontInfo().setUuline(setLyXMisc(lex.getString())); + } else if (token == "\\uwave") { + lex.next(); + font.fontInfo().setUwave(setLyXMisc(lex.getString())); } else if (token == "\\noun") { lex.next(); - font.fontInfo().setNoun(font.setLyXMisc(lex.getString())); + font.fontInfo().setNoun(setLyXMisc(lex.getString())); } else if (token == "\\color") { lex.next(); setLyXColor(lex.getString(), font.fontInfo()); - } else if (token == "\\InsetSpace" || token == "\\SpecialChar") { - - // Insets don't make sense in a free-spacing context! ---Kayvan - if (par.isFreeSpacing()) { - if (token == "\\InsetSpace") - par.appendChar(' ', font, change); - else if (lex.isOK()) { - lex.next(); - string const next_token = lex.getString(); - if (next_token == "\\-") - par.appendChar('-', font, change); - else { - lex.printError("Token `$$Token' " - "is in free space " - "paragraph layout!"); - } - } - } else { - auto_ptr inset; - if (token == "\\SpecialChar" ) - inset.reset(new InsetSpecialChar); - else - inset.reset(new InsetSpace); - inset->read(buf, lex); - par.insertInset(par.size(), inset.release(), - font, change); - } + } else if (token == "\\SpecialChar") { + auto_ptr inset; + inset.reset(new InsetSpecialChar); + inset->read(lex); + inset->setBuffer(*buf); + par.insertInset(par.size(), inset.release(), font, change); } else if (token == "\\backslash") { par.appendChar('\\', font, change); - } else if (token == "\\linebreak") { - auto_ptr inset(new InsetLinebreak); - inset->read(buf, lex); - par.insertInset(par.size(), inset.release(), font, change); - } else if (token == "\\newline") { - auto_ptr inset(new InsetNewline); - inset->read(buf, lex); - par.insertInset(par.size(), inset.release(), font, change); } else if (token == "\\LyXTable") { auto_ptr inset(new InsetTabular(buf)); - inset->read(buf, lex); + inset->read(lex); par.insertInset(par.size(), inset.release(), font, change); - } else if (token == "\\hfill") { - par.insertInset(par.size(), new InsetHFill, font, change); } else if (token == "\\lyxline") { - par.insertInset(par.size(), new InsetLine, font, change); - } else if (token == "\\newpage") { - par.insertInset(par.size(), new InsetNewpage, font, change); - } else if (token == "\\pagebreak") { - par.insertInset(par.size(), new InsetPagebreak, font, change); - } else if (token == "\\clearpage") { - par.insertInset(par.size(), new InsetClearPage, font, change); - } else if (token == "\\cleardoublepage") { - par.insertInset(par.size(), new InsetClearDoublePage, font, change); + auto_ptr inset; + inset.reset(new InsetLine); + inset->setBuffer(*buf); + par.insertInset(par.size(), inset.release(), font, change); } else if (token == "\\change_unchanged") { change = Change(Change::UNCHANGED); - } else if (token == "\\change_inserted") { + } else if (token == "\\change_inserted" || token == "\\change_deleted") { lex.eatLine(); - std::istringstream is(lex.getString()); + istringstream is(lex.getString()); unsigned int aid; - time_type ct; + time_t ct; is >> aid >> ct; - if (aid >= bp.author_map.size()) { + map const & am = bp.author_map; + if (am.find(aid) == am.end()) { errorList.push_back(ErrorItem(_("Change tracking error"), - bformat(_("Unknown author index for insertion: %1$d\n"), aid), + bformat(_("Unknown author index for change: %1$d\n"), aid), par.id(), 0, par.size())); change = Change(Change::UNCHANGED); - } else - change = Change(Change::INSERTED, bp.author_map[aid], ct); - } else if (token == "\\change_deleted") { - lex.eatLine(); - std::istringstream is(lex.getString()); - unsigned int aid; - time_type ct; - is >> aid >> ct; - if (aid >= bp.author_map.size()) { - errorList.push_back(ErrorItem(_("Change tracking error"), - bformat(_("Unknown author index for deletion: %1$d\n"), aid), - par.id(), 0, par.size())); - change = Change(Change::UNCHANGED); - } else - change = Change(Change::DELETED, bp.author_map[aid], ct); + } else { + if (token == "\\change_inserted") + change = Change(Change::INSERTED, am.find(aid)->second, ct); + else + change = Change(Change::DELETED, am.find(aid)->second, ct); + } } else { lex.eatLine(); errorList.push_back(ErrorItem(_("Unknown token"), @@ -294,7 +440,7 @@ void readParToken(Buffer const & buf, Paragraph & par, Lexer & lex, } -void readParagraph(Buffer const & buf, Paragraph & par, Lexer & lex, +void Text::readParagraph(Paragraph & par, Lexer & lex, ErrorList & errorList) { lex.nextToken(); @@ -303,7 +449,7 @@ void readParagraph(Buffer const & buf, Paragraph & par, Lexer & lex, Change change(Change::UNCHANGED); while (lex.isOK()) { - readParToken(buf, par, lex, token, font, change, errorList); + readParToken(par, lex, token, font, change, errorList); lex.nextToken(); token = lex.getString(); @@ -322,7 +468,7 @@ void readParagraph(Buffer const & buf, Paragraph & par, Lexer & lex, || token == "\\end_deeper") { lex.pushToken(token); lyxerr << "Paragraph ended in line " - << lex.getLineNo() << "\n" + << lex.lineNumber() << "\n" << "Missing \\end_layout.\n"; break; } @@ -335,40 +481,167 @@ void readParagraph(Buffer const & buf, Paragraph & par, Lexer & lex, } -} // namespace anon +class TextCompletionList : public CompletionList +{ +public: + /// + TextCompletionList(Cursor const & cur) + : buffer_(cur.buffer()), pos_(0) + {} + /// + virtual ~TextCompletionList() {} + + /// + virtual bool sorted() const { return true; } + /// + virtual size_t size() const + { + return theWordList().size(); + } + /// + virtual docstring const & data(size_t idx) const + { + return theWordList().word(idx); + } + +private: + /// + Buffer const * buffer_; + /// + size_t pos_; +}; bool Text::empty() const { return pars_.empty() || (pars_.size() == 1 && pars_[0].empty() // FIXME: Should we consider the labeled type as empty too? - && pars_[0].layout()->labeltype == LABEL_NO_LABEL); + && pars_[0].layout().labeltype == LABEL_NO_LABEL); } -double Text::spacing(Buffer const & buffer, - Paragraph const & par) const +double Text::spacing(Paragraph const & par) const { if (par.params().spacing().isDefault()) - return buffer.params().spacing().getValue(); + return owner_->buffer().params().spacing().getValue(); return par.params().spacing().getValue(); } +/** + * This breaks a paragraph at the specified position. + * The new paragraph will: + * - Decrease depth by one (or change layout to default layout) when + * keep_layout == false + * - keep current depth and layout when keep_layout == true + */ +static void breakParagraph(Text & text, pit_type par_offset, pos_type pos, + bool keep_layout) +{ + BufferParams const & bparams = text.inset().buffer().params(); + ParagraphList & pars = text.paragraphs(); + // create a new paragraph, and insert into the list + ParagraphList::iterator tmp = + pars.insert(boost::next(pars.begin(), par_offset + 1), + Paragraph()); + + Paragraph & par = pars[par_offset]; + + // remember to set the inset_owner + tmp->setInsetOwner(&par.inInset()); + // without doing that we get a crash when typing at the + // end of a paragraph + tmp->setPlainOrDefaultLayout(bparams.documentClass()); + + // layout stays the same with latex-environments + if (keep_layout) { + tmp->setLayout(par.layout()); + tmp->setLabelWidthString(par.params().labelWidthString()); + tmp->params().depth(par.params().depth()); + } else if (par.params().depth() > 0) { + Paragraph const & hook = pars[text.outerHook(par_offset)]; + tmp->setLayout(hook.layout()); + // not sure the line below is useful + tmp->setLabelWidthString(par.params().labelWidthString()); + tmp->params().depth(hook.params().depth()); + } + + bool const isempty = (par.allowEmpty() && par.empty()); + + if (!isempty && (par.size() > pos || par.empty())) { + tmp->setLayout(par.layout()); + tmp->params().align(par.params().align()); + tmp->setLabelWidthString(par.params().labelWidthString()); + + tmp->params().depth(par.params().depth()); + tmp->params().noindent(par.params().noindent()); + + // move everything behind the break position + // to the new paragraph + + /* Note: if !keepempty, empty() == true, then we reach + * here with size() == 0. So pos_end becomes - 1. This + * doesn't cause problems because both loops below + * enforce pos <= pos_end and 0 <= pos + */ + pos_type pos_end = par.size() - 1; + + for (pos_type i = pos, j = 0; i <= pos_end; ++i) { + if (moveItem(par, pos, *tmp, j, bparams)) { + ++j; + } + } + } + + // Move over the end-of-par change information + tmp->setChange(tmp->size(), par.lookupChange(par.size())); + par.setChange(par.size(), Change(bparams.trackChanges ? + Change::INSERTED : Change::UNCHANGED)); + + if (pos) { + // Make sure that we keep the language when + // breaking paragraph. + if (tmp->empty()) { + Font changed = tmp->getFirstFontSettings(bparams); + Font const & old = par.getFontSettings(bparams, par.size()); + changed.setLanguage(old.language()); + tmp->setFont(0, changed); + } + + return; + } + + if (!isempty) { + bool const soa = par.params().startOfAppendix(); + par.params().clear(); + // do not lose start of appendix marker (bug 4212) + par.params().startOfAppendix(soa); + par.setPlainOrDefaultLayout(bparams.documentClass()); + } + + // layout stays the same with latex-environments + if (keep_layout) { + par.setLayout(tmp->layout()); + par.setLabelWidthString(tmp->params().labelWidthString()); + par.params().depth(tmp->params().depth()); + } +} + + void Text::breakParagraph(Cursor & cur, bool inverse_logic) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); Paragraph & cpar = cur.paragraph(); pit_type cpit = cur.pit(); - TextClass const & tclass = cur.buffer().params().getTextClass(); - LayoutPtr const & layout = cpar.layout(); + DocumentClass const & tclass = cur.buffer()->params().documentClass(); + Layout const & layout = cpar.layout(); // this is only allowed, if the current paragraph is not empty // or caption and if it has not the keepempty flag active if (cur.lastpos() == 0 && !cpar.allowEmpty() && - layout->labeltype != LABEL_SENSITIVE) + layout.labeltype != LABEL_SENSITIVE) return; // a layout change may affect also the following paragraph @@ -377,22 +650,21 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic) // Always break behind a space // It is better to erase the space (Dekel) if (cur.pos() != cur.lastpos() && cpar.isLineSeparator(cur.pos())) - cpar.eraseChar(cur.pos(), cur.buffer().params().trackChanges); + cpar.eraseChar(cur.pos(), cur.buffer()->params().trackChanges); // What should the layout for the new paragraph be? bool keep_layout = inverse_logic ? - !layout->isEnvironment() - : layout->isEnvironment(); + !layout.isEnvironment() + : layout.isEnvironment(); // We need to remember this before we break the paragraph, because // that invalidates the layout variable - bool sensitive = layout->labeltype == LABEL_SENSITIVE; + bool sensitive = layout.labeltype == LABEL_SENSITIVE; // we need to set this before we insert the paragraph. bool const isempty = cpar.allowEmpty() && cpar.empty(); - lyx::breakParagraph(cur.buffer().params(), paragraphs(), cpit, - cur.pos(), keep_layout); + lyx::breakParagraph(*this, cpit, cur.pos(), keep_layout); // After this, neither paragraph contains any rows! @@ -403,18 +675,20 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic) if (sensitive) { if (cur.pos() == 0) // set to standard-layout + //FIXME Check if this should be plainLayout() in some cases pars_[cpit].applyLayout(tclass.defaultLayout()); else // set to standard-layout + //FIXME Check if this should be plainLayout() in some cases pars_[next_par].applyLayout(tclass.defaultLayout()); } while (!pars_[next_par].empty() && pars_[next_par].isNewline(0)) { - if (!pars_[next_par].eraseChar(0, cur.buffer().params().trackChanges)) + if (!pars_[next_par].eraseChar(0, cur.buffer()->params().trackChanges)) break; // the character couldn't be deleted physically due to change tracking } - updateLabels(cur.buffer()); + cur.buffer()->updateLabels(); // A singlePar update is not enough in this case. cur.updateFlags(Update::Force); @@ -428,21 +702,100 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic) } +// needed to insert the selection +void Text::insertStringAsLines(DocIterator const & dit, docstring const & str, + Font const & font) +{ + BufferParams const & bparams = owner_->buffer().params(); + pit_type pit = dit.pit(); + pos_type pos = dit.pos(); + + // insert the string, don't insert doublespace + bool space_inserted = true; + for (docstring::const_iterator cit = str.begin(); + cit != str.end(); ++cit) { + Paragraph & par = pars_[pit]; + if (*cit == '\n') { + if (autoBreakRows_ && (!par.empty() || par.allowEmpty())) { + lyx::breakParagraph(*this, pit, pos, + par.layout().isEnvironment()); + ++pit; + pos = 0; + space_inserted = true; + } else { + continue; + } + // do not insert consecutive spaces if !free_spacing + } else if ((*cit == ' ' || *cit == '\t') && + space_inserted && !par.isFreeSpacing()) { + continue; + } else if (*cit == '\t') { + if (!par.isFreeSpacing()) { + // tabs are like spaces here + par.insertChar(pos, ' ', font, bparams.trackChanges); + ++pos; + space_inserted = true; + } else { + par.insertChar(pos, *cit, font, bparams.trackChanges); + ++pos; + space_inserted = true; + } + } else if (!isPrintable(*cit)) { + // Ignore unprintables + continue; + } else { + // just insert the character + par.insertChar(pos, *cit, font, bparams.trackChanges); + ++pos; + space_inserted = (*cit == ' '); + } + } +} + + +// turn double CR to single CR, others are converted into one +// blank. Then insertStringAsLines is called +void Text::insertStringAsParagraphs(DocIterator const & dit, docstring const & str, + Font const & font) +{ + docstring linestr = str; + bool newline_inserted = false; + + for (string::size_type i = 0, siz = linestr.size(); i < siz; ++i) { + if (linestr[i] == '\n') { + if (newline_inserted) { + // we know that \r will be ignored by + // insertStringAsLines. Of course, it is a dirty + // trick, but it works... + linestr[i - 1] = '\r'; + linestr[i] = '\n'; + } else { + linestr[i] = ' '; + newline_inserted = true; + } + } else if (isPrintable(linestr[i])) { + newline_inserted = false; + } + } + insertStringAsLines(dit, linestr, font); +} + + // insert a character, moves all the following breaks in the // same Paragraph one to the right and make a rebreak void Text::insertChar(Cursor & cur, char_type c) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); cur.recordUndo(INSERT_UNDO); TextMetrics const & tm = cur.bv().textMetrics(this); - Buffer const & buffer = cur.buffer(); + Buffer const & buffer = *cur.buffer(); Paragraph & par = cur.paragraph(); // try to remove this pit_type const pit = cur.pit(); - bool const freeSpacing = par.layout()->free_spacing || + bool const freeSpacing = par.layout().free_spacing || par.isFreeSpacing(); if (lyxrc.auto_number) { @@ -455,8 +808,8 @@ void Text::insertChar(Cursor & cur, char_type c) !(contains(number_seperators, c) && cur.pos() != 0 && cur.pos() != cur.lastpos() && - tm.getDisplayFont(pit, cur.pos()).fontInfo().number() == FONT_ON && - tm.getDisplayFont(pit, cur.pos() - 1).fontInfo().number() == FONT_ON) + tm.displayFont(pit, cur.pos()).fontInfo().number() == FONT_ON && + tm.displayFont(pit, cur.pos() - 1).fontInfo().number() == FONT_ON) ) number(cur); // Set current_font.number to OFF } else if (isDigit(c) && @@ -470,12 +823,12 @@ void Text::insertChar(Cursor & cur, char_type c) || par.isSeparator(cur.pos() - 2) || par.isNewline(cur.pos() - 2)) ) { - setCharFont(buffer, pit, cur.pos() - 1, cur.current_font, + setCharFont(pit, cur.pos() - 1, cur.current_font, tm.font_); } else if (contains(number_seperators, c) && cur.pos() >= 2 - && tm.getDisplayFont(pit, cur.pos() - 2).fontInfo().number() == FONT_ON) { - setCharFont(buffer, pit, cur.pos() - 1, cur.current_font, + && tm.displayFont(pit, cur.pos() - 2).fontInfo().number() == FONT_ON) { + setCharFont(pit, cur.pos() - 1, cur.current_font, tm.font_); } } @@ -507,7 +860,7 @@ void Text::insertChar(Cursor & cur, char_type c) if ((cur.pos() >= 2) && (par.isLineSeparator(cur.pos() - 1))) { // get font in front and behind the space in question. But do NOT // use getFont(cur.pos()) because the character c is not inserted yet - Font const pre_space_font = tm.getDisplayFont(cur.pit(), cur.pos() - 2); + Font const pre_space_font = tm.displayFont(cur.pit(), cur.pos() - 2); Font const & post_space_font = cur.real_current_font; bool pre_space_rtl = pre_space_font.isVisibleRightToLeft(); bool post_space_rtl = post_space_font.isVisibleRightToLeft(); @@ -520,7 +873,7 @@ void Text::insertChar(Cursor & cur, char_type c) (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); + Font space_font = tm.displayFont(cur.pit(), cur.pos() - 1); space_font.setLanguage(lang); par.setFont(cur.pos() - 1, space_font); } @@ -544,7 +897,7 @@ void Text::insertChar(Cursor & cur, char_type c) } return; } - BOOST_ASSERT(cur.pos() > 0); + LASSERT(cur.pos() > 0, /**/); if ((par.isLineSeparator(cur.pos() - 1) || par.isNewline(cur.pos() - 1)) && !par.isDeleted(cur.pos() - 1)) { static bool sent_space_message = false; @@ -557,25 +910,38 @@ void Text::insertChar(Cursor & cur, char_type c) } } - par.insertChar(cur.pos(), c, cur.current_font, cur.buffer().params().trackChanges); - checkBufferStructure(cur.buffer(), cur); + par.insertChar(cur.pos(), c, cur.current_font, + cur.buffer()->params().trackChanges); + cur.checkBufferStructure(); // cur.updateFlags(Update::Force); - setCursor(cur.top(), cur.pit(), cur.pos() + 1); + bool boundary = cur.boundary() + || tm.isRTLBoundary(cur.pit(), cur.pos() + 1); + setCursor(cur, cur.pit(), cur.pos() + 1, false, boundary); charInserted(cur); } void Text::charInserted(Cursor & cur) { + Paragraph & par = cur.paragraph(); + // Here we call finishUndo for every 20 characters inserted. // This is from my experience how emacs does it. (Lgb) - static unsigned int counter; - if (counter < 20) { - ++counter; + if (undo_counter_ < 20) { + ++undo_counter_; } else { cur.finishUndo(); - counter = 0; + undo_counter_ = 0; + } + + // register word if a non-letter was entered + if (cur.pos() > 1 + && !par.isWordSeparator(cur.pos() - 2) + && par.isWordSeparator(cur.pos() - 1)) { + // get the word in front of cursor + LASSERT(this == cur.text(), /**/); + cur.paragraph().updateWords(); } } @@ -585,49 +951,171 @@ void Text::charInserted(Cursor & cur) bool Text::cursorForwardOneWord(Cursor & cur) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); - Cursor old = cur; + pos_type const lastpos = cur.lastpos(); + pit_type pit = cur.pit(); + pos_type pos = cur.pos(); + Paragraph const & par = cur.paragraph(); - if (old.pos() == old.lastpos() && old.pit() != old.lastpit()) { - ++old.pit(); - old.pos() = 0; + // Paragraph boundary is a word boundary + if (pos == lastpos) { + if (pit != cur.lastpit()) + return setCursor(cur, pit + 1, 0); + else + return false; + } + + if (lyxrc.mac_like_word_movement) { + // Skip through trailing punctuation and spaces. + while (pos != lastpos && (par.isChar(pos) || par.isSpace(pos))) + ++pos; + + // Skip over either a non-char inset or a full word + if (pos != lastpos && par.isWordSeparator(pos)) + ++pos; + else while (pos != lastpos && !par.isWordSeparator(pos)) + ++pos; } else { - // Advance through word. - while (old.pos() != old.lastpos() && old.paragraph().isLetter(old.pos())) - ++old.pos(); - // Skip through trailing nonword stuff. - while (old.pos() != old.lastpos() && !old.paragraph().isLetter(old.pos())) - ++old.pos(); + LASSERT(pos < lastpos, /**/); // see above + if (!par.isWordSeparator(pos)) + while (pos != lastpos && !par.isWordSeparator(pos)) + ++pos; + else if (par.isChar(pos)) + while (pos != lastpos && par.isChar(pos)) + ++pos; + else if (!par.isSpace(pos)) // non-char inset + ++pos; + + // Skip over white space + while (pos != lastpos && par.isSpace(pos)) + ++pos; } - return setCursor(cur, old.pit(), old.pos()); + + return setCursor(cur, pit, pos); } bool Text::cursorBackwardOneWord(Cursor & cur) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); + + pit_type pit = cur.pit(); + pos_type pos = cur.pos(); + Paragraph & par = cur.paragraph(); - Cursor old = cur; + // Paragraph boundary is a word boundary + if (pos == 0 && pit != 0) + return setCursor(cur, pit - 1, getPar(pit - 1).size()); - if (old.pos() == 0 && old.pit() != 0) { - --old.pit(); - old.pos() = old.lastpos(); + if (lyxrc.mac_like_word_movement) { + // Skip through punctuation and spaces. + while (pos != 0 && (par.isChar(pos - 1) || par.isSpace(pos - 1))) + --pos; + + // Skip over either a non-char inset or a full word + if (pos != 0 && par.isWordSeparator(pos - 1) && !par.isChar(pos - 1)) + --pos; + else while (pos != 0 && !par.isWordSeparator(pos - 1)) + --pos; } else { - // Skip through initial nonword stuff. - while (old.pos() != 0 && !old.paragraph().isLetter(old.pos() - 1)) - --old.pos(); - // Advance through word. - while (old.pos() != 0 && old.paragraph().isLetter(old.pos() - 1)) - --old.pos(); + // Skip over white space + while (pos != 0 && par.isSpace(pos - 1)) + --pos; + + if (pos != 0 && !par.isWordSeparator(pos - 1)) + while (pos != 0 && !par.isWordSeparator(pos - 1)) + --pos; + else if (pos != 0 && par.isChar(pos - 1)) + while (pos != 0 && par.isChar(pos - 1)) + --pos; + else if (pos != 0 && !par.isSpace(pos - 1)) // non-char inset + --pos; } - return setCursor(cur, old.pit(), old.pos()); + + return setCursor(cur, pit, pos); +} + + +bool Text::cursorVisLeftOneWord(Cursor & cur) +{ + LASSERT(this == cur.text(), /**/); + + pos_type left_pos, right_pos; + bool left_is_letter, right_is_letter; + + Cursor temp_cur = cur; + + // always try to move at least once... + while (temp_cur.posVisLeft(true /* skip_inset */)) { + + // collect some information about current cursor position + temp_cur.getSurroundingPos(left_pos, right_pos); + left_is_letter = + (left_pos > -1 ? !temp_cur.paragraph().isWordSeparator(left_pos) : false); + right_is_letter = + (right_pos > -1 ? !temp_cur.paragraph().isWordSeparator(right_pos) : false); + + // if we're not at a letter/non-letter boundary, continue moving + if (left_is_letter == right_is_letter) + continue; + + // we should stop when we have an LTR word on our right or an RTL word + // on our left + if ((left_is_letter && temp_cur.paragraph().getFontSettings( + temp_cur.buffer()->params(), left_pos).isRightToLeft()) + || (right_is_letter && !temp_cur.paragraph().getFontSettings( + temp_cur.buffer()->params(), right_pos).isRightToLeft())) + break; + } + + return setCursor(cur, temp_cur.pit(), temp_cur.pos(), + true, temp_cur.boundary()); +} + + +bool Text::cursorVisRightOneWord(Cursor & cur) +{ + LASSERT(this == cur.text(), /**/); + + pos_type left_pos, right_pos; + bool left_is_letter, right_is_letter; + + Cursor temp_cur = cur; + + // always try to move at least once... + while (temp_cur.posVisRight(true /* skip_inset */)) { + + // collect some information about current cursor position + temp_cur.getSurroundingPos(left_pos, right_pos); + left_is_letter = + (left_pos > -1 ? !temp_cur.paragraph().isWordSeparator(left_pos) : false); + right_is_letter = + (right_pos > -1 ? !temp_cur.paragraph().isWordSeparator(right_pos) : false); + + // if we're not at a letter/non-letter boundary, continue moving + if (left_is_letter == right_is_letter) + continue; + + // we should stop when we have an LTR word on our right or an RTL word + // on our left + if ((left_is_letter && temp_cur.paragraph().getFontSettings( + temp_cur.buffer()->params(), + left_pos).isRightToLeft()) + || (right_is_letter && !temp_cur.paragraph().getFontSettings( + temp_cur.buffer()->params(), + right_pos).isRightToLeft())) + break; + } + + return setCursor(cur, temp_cur.pit(), temp_cur.pos(), + true, temp_cur.boundary()); } void Text::selectWord(Cursor & cur, word_location loc) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); CursorSlice from = cur.top(); CursorSlice to = cur.top(); getWord(from, to, loc); @@ -641,11 +1129,30 @@ void Text::selectWord(Cursor & cur, word_location loc) } +void Text::selectAll(Cursor & cur) +{ + LASSERT(this == cur.text(), /**/); + if (cur.lastpos() == 0 && cur.lastpit() == 0) + return; + // If the cursor is at the beginning, make sure the cursor ends there + if (cur.pit() == 0 && cur.pos() == 0) { + setCursor(cur, cur.lastpit(), getPar(cur.lastpit()).size()); + cur.resetAnchor(); + setCursor(cur, 0, 0); + } else { + setCursor(cur, 0, 0); + cur.resetAnchor(); + setCursor(cur, cur.lastpit(), getPar(cur.lastpit()).size()); + } + cur.setSelection(); +} + + // Select the word currently under the cursor when no // selection is currently set bool Text::selectWordWhenUnderCursor(Cursor & cur, word_location loc) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); if (cur.selection()) return false; selectWord(cur, loc); @@ -655,10 +1162,13 @@ bool Text::selectWordWhenUnderCursor(Cursor & cur, word_location loc) void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); - if (!cur.selection()) - return; + if (!cur.selection()) { + bool const changed = cur.paragraph().isChanged(cur.pos()); + if (!(changed && findNextChange(&cur.bv()))) + return; + } cur.recordUndoSelection(); @@ -693,9 +1203,9 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op) pos_type right = (pit == endPit ? endPos : parSize); if (op == ACCEPT) { - pars_[pit].acceptChanges(cur.buffer().params(), left, right); + pars_[pit].acceptChanges(left, right); } else { - pars_[pit].rejectChanges(cur.buffer().params(), left, right); + pars_[pit].rejectChanges(left, right); } } @@ -722,7 +1232,7 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op) // instead, we mark it unchanged pars_[pit].setChange(pos, Change(Change::UNCHANGED)); } else { - mergeParagraph(cur.buffer().params(), pars_, pit); + mergeParagraph(cur.buffer()->params(), pars_, pit); --endPit; --pit; } @@ -735,7 +1245,7 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op) // we mark the par break at the end of the last paragraph unchanged pars_[pit].setChange(pos, Change(Change::UNCHANGED)); } else { - mergeParagraph(cur.buffer().params(), pars_, pit); + mergeParagraph(cur.buffer()->params(), pars_, pit); --endPit; --pit; } @@ -745,7 +1255,7 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op) // finally, invoke the DEPM - deleteEmptyParagraphMechanism(begPit, endPit, cur.buffer().params().trackChanges); + deleteEmptyParagraphMechanism(begPit, endPit, cur.buffer()->params().trackChanges); // @@ -753,26 +1263,28 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op) cur.clearSelection(); setCursorIntern(cur, begPit, begPos); cur.updateFlags(Update::Force); - updateLabels(cur.buffer()); + cur.buffer()->updateLabels(); } -void Text::acceptChanges(BufferParams const & bparams) +void Text::acceptChanges() { + BufferParams const & bparams = owner_->buffer().params(); lyx::acceptChanges(pars_, bparams); deleteEmptyParagraphMechanism(0, pars_.size() - 1, bparams.trackChanges); } -void Text::rejectChanges(BufferParams const & bparams) +void Text::rejectChanges() { + BufferParams const & bparams = owner_->buffer().params(); pit_type pars_size = static_cast(pars_.size()); // first, reject changes within each individual paragraph // (do not consider end-of-par) for (pit_type pit = 0; pit < pars_size; ++pit) { if (!pars_[pit].empty()) // prevent assertion failure - pars_[pit].rejectChanges(bparams, 0, pars_[pit].size()); + pars_[pit].rejectChanges(0, pars_[pit].size()); } // next, reject imaginary end-of-par characters @@ -801,32 +1313,32 @@ void Text::rejectChanges(BufferParams const & bparams) void Text::deleteWordForward(Cursor & cur) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); if (cur.lastpos() == 0) cursorForward(cur); else { cur.resetAnchor(); - cur.selection() = true; + cur.setSelection(true); cursorForwardOneWord(cur); cur.setSelection(); cutSelection(cur, true, false); - checkBufferStructure(cur.buffer(), cur); + cur.checkBufferStructure(); } } void Text::deleteWordBackward(Cursor & cur) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); if (cur.lastpos() == 0) cursorBackward(cur); else { cur.resetAnchor(); - cur.selection() = true; + cur.setSelection(true); cursorBackwardOneWord(cur); cur.setSelection(); cutSelection(cur, true, false); - checkBufferStructure(cur.buffer(), cur); + cur.checkBufferStructure(); } } @@ -834,13 +1346,15 @@ void Text::deleteWordBackward(Cursor & cur) // Kill to end of line. void Text::changeCase(Cursor & cur, TextCase action) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); CursorSlice from; CursorSlice to; + bool gotsel = false; if (cur.selection()) { from = cur.selBegin(); to = cur.selEnd(); + gotsel = true; } else { from = cur.top(); getWord(from, to, PARTIAL_WORD); @@ -861,54 +1375,60 @@ void Text::changeCase(Cursor & cur, TextCase action) Paragraph & par = pars_[pit]; pos_type const pos = (pit == begPit ? begPos : 0); right = (pit == endPit ? endPos : par.size()); - par.changeCase(cur.buffer().params(), pos, right, action); + par.changeCase(cur.buffer()->params(), pos, right, action); } // the selection may have changed due to logically-only deleted chars - setCursor(cur, begPit, begPos); - cur.resetAnchor(); - setCursor(cur, endPit, right); - cur.setSelection(); + if (gotsel) { + setCursor(cur, begPit, begPos); + cur.resetAnchor(); + setCursor(cur, endPit, right); + cur.setSelection(); + } else + setCursor(cur, endPit, right); - checkBufferStructure(cur.buffer(), cur); + cur.checkBufferStructure(); } bool Text::handleBibitems(Cursor & cur) { - if (cur.paragraph().layout()->labeltype != LABEL_BIBLIO) + if (cur.paragraph().layout().labeltype != LABEL_BIBLIO) return false; + + if (cur.pos() != 0) + return false; + + BufferParams const & bufparams = cur.buffer()->params(); + Paragraph const & par = cur.paragraph(); + Cursor prevcur = cur; + if (cur.pit() > 0) { + --prevcur.pit(); + prevcur.pos() = prevcur.lastpos(); + } + Paragraph const & prevpar = prevcur.paragraph(); + // if a bibitem is deleted, merge with previous paragraph // if this is a bibliography item as well - if (cur.pos() == 0) { - BufferParams const & bufparams = cur.buffer().params(); - Paragraph const & par = cur.paragraph(); - Cursor prevcur = cur; - if (cur.pit() > 0) { - --prevcur.pit(); - prevcur.pos() = prevcur.lastpos(); - } - Paragraph const & prevpar = prevcur.paragraph(); - if (cur.pit() > 0 && par.layout() == prevpar.layout()) { - cur.recordUndo(ATOMIC_UNDO, prevcur.pit()); - mergeParagraph(bufparams, cur.text()->paragraphs(), - prevcur.pit()); - updateLabels(cur.buffer()); - setCursorIntern(cur, prevcur.pit(), prevcur.pos()); - cur.updateFlags(Update::Force); - // if not, reset the paragraph to default - } else - cur.paragraph().layout( - bufparams.getTextClass().defaultLayout()); + if (cur.pit() > 0 && par.layout() == prevpar.layout()) { + cur.recordUndo(ATOMIC_UNDO, prevcur.pit()); + mergeParagraph(bufparams, cur.text()->paragraphs(), + prevcur.pit()); + cur.buffer()->updateLabels(); + setCursorIntern(cur, prevcur.pit(), prevcur.pos()); + cur.updateFlags(Update::Force); return true; - } - return false; + } + + // otherwise reset to default + cur.paragraph().setPlainOrDefaultLayout(bufparams.documentClass()); + return true; } bool Text::erase(Cursor & cur) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), return false); bool needsUpdate = false; Paragraph & par = cur.paragraph(); @@ -916,17 +1436,21 @@ bool Text::erase(Cursor & cur) // this is the code for a normal delete, not pasting // any paragraphs cur.recordUndo(DELETE_UNDO); - if(!par.eraseChar(cur.pos(), cur.buffer().params().trackChanges)) { + bool const was_inset = cur.paragraph().isInset(cur.pos()); + if(!par.eraseChar(cur.pos(), cur.buffer()->params().trackChanges)) // the character has been logically deleted only => skip it cur.top().forwardPos(); - } - checkBufferStructure(cur.buffer(), cur); + + if (was_inset) + cur.buffer()->updateLabels(); + else + cur.checkBufferStructure(); needsUpdate = true; } else { if (cur.pit() == cur.lastpit()) return dissolveInset(cur); - if (!par.isMergedOnEndOfParDeletion(cur.buffer().params().trackChanges)) { + if (!par.isMergedOnEndOfParDeletion(cur.buffer()->params().trackChanges)) { par.setChange(cur.pos(), Change(Change::DELETED)); cur.forwardPos(); needsUpdate = true; @@ -942,7 +1466,7 @@ bool Text::erase(Cursor & cur) // Make sure the cursor is correct. Is this really needed? // No, not really... at least not here! cur.text()->setCursor(cur.top(), cur.pit(), cur.pos()); - checkBufferStructure(cur.buffer(), cur); + cur.checkBufferStructure(); } return needsUpdate; @@ -951,14 +1475,14 @@ bool Text::erase(Cursor & cur) bool Text::backspacePos0(Cursor & cur) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); if (cur.pit() == 0) return false; bool needsUpdate = false; - BufferParams const & bufparams = cur.buffer().params(); - TextClass const & tclass = bufparams.getTextClass(); + BufferParams const & bufparams = cur.buffer()->params(); + DocumentClass const & tclass = bufparams.documentClass(); ParagraphList & plist = cur.text()->paragraphs(); Paragraph const & par = cur.paragraph(); Cursor prevcur = cur; @@ -984,15 +1508,17 @@ bool Text::backspacePos0(Cursor & cur) // layouts. I think it is a real bug of all other // word processors to allow it. It confuses the user. // Correction: Pasting is always allowed with standard-layout + // or the empty layout. else if (par.layout() == prevpar.layout() - || par.layout() == tclass.defaultLayout()) { + || tclass.isDefaultLayout(par.layout()) + || tclass.isPlainLayout(par.layout())) { cur.recordUndo(ATOMIC_UNDO, prevcur.pit()); mergeParagraph(bufparams, plist, prevcur.pit()); needsUpdate = true; } if (needsUpdate) { - updateLabels(cur.buffer()); + cur.buffer()->updateLabels(); setCursorIntern(cur, prevcur.pit(), prevcur.pos()); } @@ -1002,7 +1528,7 @@ bool Text::backspacePos0(Cursor & cur) bool Text::backspace(Cursor & cur) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); bool needsUpdate = false; if (cur.pos() == 0) { if (cur.pit() == 0) @@ -1010,7 +1536,7 @@ bool Text::backspace(Cursor & cur) Paragraph & prev_par = pars_[cur.pit() - 1]; - if (!prev_par.isMergedOnEndOfParDeletion(cur.buffer().params().trackChanges)) { + if (!prev_par.isMergedOnEndOfParDeletion(cur.buffer()->params().trackChanges)) { prev_par.setChange(prev_par.size(), Change(Change::DELETED)); setCursorIntern(cur, cur.pit() - 1, prev_par.size()); return true; @@ -1029,8 +1555,12 @@ bool Text::backspace(Cursor & cur) // without the dreaded mechanism. (JMarc) setCursorIntern(cur, cur.pit(), cur.pos() - 1, false, cur.boundary()); - cur.paragraph().eraseChar(cur.pos(), cur.buffer().params().trackChanges); - checkBufferStructure(cur.buffer(), cur); + bool const was_inset = cur.paragraph().isInset(cur.pos()); + cur.paragraph().eraseChar(cur.pos(), cur.buffer()->params().trackChanges); + if (was_inset) + cur.buffer()->updateLabels(); + else + cur.checkBufferStructure(); } if (cur.pos() == cur.lastpos()) @@ -1046,13 +1576,15 @@ bool Text::backspace(Cursor & cur) } -bool Text::dissolveInset(Cursor & cur) { - BOOST_ASSERT(this == cur.text()); +bool Text::dissolveInset(Cursor & cur) +{ + LASSERT(this == cur.text(), return false); - if (isMainText(cur.bv().buffer()) || cur.inset().nargs() != 1) + if (isMainText() || cur.inset().nargs() != 1) return false; cur.recordUndoInset(); + cur.setMark(false); cur.selHandle(false); // save position pos_type spos = cur.pos(); @@ -1065,7 +1597,7 @@ bool Text::dissolveInset(Cursor & cur) { if (spit == 0) spos += cur.pos(); spit += cur.pit(); - Buffer & b = cur.buffer(); + Buffer & b = *cur.buffer(); cur.paragraph().eraseChar(cur.pos(), b.params().trackChanges); if (!plist.empty()) { // ERT paragraphs have the Language latex_language. @@ -1076,12 +1608,18 @@ bool Text::dissolveInset(Cursor & cur) { for (; it != it_end; it++) it->changeLanguage(b.params(), latex_language, b.language()); - pasteParagraphList(cur, plist, b.params().getTextClassPtr(), + pasteParagraphList(cur, plist, b.params().documentClassPtr(), b.errorList("Paste")); // restore position - cur.pit() = std::min(cur.lastpit(), spit); - cur.pos() = std::min(cur.lastpos(), spos); - } + cur.pit() = min(cur.lastpit(), spit); + cur.pos() = min(cur.lastpos(), spos); + } else + // this is the least that needs to be done (bug 6003) + // in the above case, pasteParagraphList handles this + cur.buffer()->updateLabels(); + + // Ensure the current language is set correctly (bug 6292) + cur.text()->setCursor(cur, cur.pit(), cur.pos()); cur.clearSelection(); cur.resetAnchor(); return true; @@ -1089,52 +1627,21 @@ bool Text::dissolveInset(Cursor & cur) { void Text::getWord(CursorSlice & from, CursorSlice & to, - word_location const loc) + word_location const loc) const { - Paragraph const & from_par = pars_[from.pit()]; - switch (loc) { - case WHOLE_WORD_STRICT: - if (from.pos() == 0 || from.pos() == from_par.size() - || !from_par.isLetter(from.pos()) - || !from_par.isLetter(from.pos() - 1)) { - to = from; - return; - } - // no break here, we go to the next - - case WHOLE_WORD: - // If we are already at the beginning of a word, do nothing - if (!from.pos() || !from_par.isLetter(from.pos() - 1)) - break; - // no break here, we go to the next - - case PREVIOUS_WORD: - // always move the cursor to the beginning of previous word - while (from.pos() && from_par.isLetter(from.pos() - 1)) - --from.pos(); - break; - case NEXT_WORD: - lyxerr << "Text::getWord: NEXT_WORD not implemented yet" - << endl; - break; - case PARTIAL_WORD: - // no need to move the 'from' cursor - break; - } to = from; - Paragraph & to_par = pars_[to.pit()]; - while (to.pos() < to_par.size() && to_par.isLetter(to.pos())) - ++to.pos(); + pars_[to.pit()].locateWord(from.pos(), to.pos(), loc); } -void Text::write(Buffer const & buf, std::ostream & os) const +void Text::write(ostream & os) const { + Buffer const & buf = owner_->buffer(); ParagraphList::const_iterator pit = paragraphs().begin(); ParagraphList::const_iterator end = paragraphs().end(); depth_type dth = 0; for (; pit != end; ++pit) - pit->write(buf, os, buf.params(), dth); + pit->write(os, buf.params(), dth); // Close begin_deeper for(; dth > 0; --dth) @@ -1142,9 +1649,12 @@ void Text::write(Buffer const & buf, std::ostream & os) const } -bool Text::read(Buffer const & buf, Lexer & lex, ErrorList & errorList) +bool Text::read(Lexer & lex, + ErrorList & errorList, InsetText * insetPtr) { + Buffer const & buf = owner_->buffer(); depth_type depth = 0; + bool res = true; while (lex.isOK()) { lex.nextToken(); @@ -1162,42 +1672,54 @@ bool Text::read(Buffer const & buf, Lexer & lex, ErrorList & errorList) if (token == "\\begin_body") continue; - if (token == "\\end_document") - return false; + if (token == "\\end_document") { + res = false; + break; + } if (token == "\\begin_layout") { lex.pushToken(token); Paragraph par; + par.setInsetOwner(insetPtr); par.params().depth(depth); par.setFont(0, Font(inherit_font, buf.params().language)); pars_.push_back(par); + readParagraph(pars_.back(), lex, errorList); - // FIXME: goddamn InsetTabular makes us pass a Buffer - // not BufferParams - lyx::readParagraph(buf, pars_.back(), lex, errorList); - + // register the words in the global word list + pars_.back().updateWords(); } else if (token == "\\begin_deeper") { ++depth; } else if (token == "\\end_deeper") { - if (!depth) { + if (!depth) lex.printError("\\end_deeper: " "depth is already null"); - } else { + else --depth; - } } else { - lyxerr << "Handling unknown body token: `" - << token << '\'' << endl; + LYXERR0("Handling unknown body token: `" << token << '\''); } } - return true; + + // avoid a crash on weird documents (bug 4859) + if (pars_.empty()) { + Paragraph par; + par.setInsetOwner(insetPtr); + par.params().depth(depth); + par.setFont(0, Font(inherit_font, + buf.params().language)); + par.setPlainOrDefaultLayout(buf.params().documentClass()); + pars_.push_back(par); + } + + return res; } // Returns the current font and depth as a message. -docstring Text::currentState(Cursor & cur) +docstring Text::currentState(Cursor const & cur) const { - BOOST_ASSERT(this == cur.text()); - Buffer & buf = cur.buffer(); + LASSERT(this == cur.text(), /**/); + Buffer & buf = *cur.buffer(); Paragraph const & par = cur.paragraph(); odocstringstream os; @@ -1206,7 +1728,7 @@ docstring Text::currentState(Cursor & cur) Change change = par.lookupChange(cur.pos()); - if (change.type != Change::UNCHANGED) { + if (change.changed()) { Author const & a = buf.params().authors().get(change.author); os << _("Change: ") << a.name(); if (!a.email().empty()) @@ -1263,7 +1785,7 @@ docstring Text::currentState(Cursor & cur) if (!par.empty() && cur.pos() < par.size()) { // Force output of code point, not character size_t const c = par.getChar(cur.pos()); - os << _(", Char: 0x") << std::hex << c; + os << _(", Char: 0x") << hex << c; } os << _(", Boundary: ") << cur.boundary(); // Row & row = cur.textRow(); @@ -1273,14 +1795,14 @@ docstring Text::currentState(Cursor & cur) } -docstring Text::getPossibleLabel(Cursor & cur) const +docstring Text::getPossibleLabel(Cursor const & cur) const { pit_type pit = cur.pit(); - LayoutPtr layout = pars_[pit].layout(); + Layout const * layout = &(pars_[pit].layout()); docstring text; - docstring par_text = pars_[pit].asString(cur.buffer(), false); + docstring par_text = pars_[pit].asString(); string piece; // the return string of math matrices might contain linebreaks par_text = subst(par_text, '\n', '-'); @@ -1304,7 +1826,7 @@ docstring Text::getPossibleLabel(Cursor & cur) const // For section, subsection, etc... if (layout->latextype == LATEX_PARAGRAPH && pit != 0) { - LayoutPtr const & layout2 = pars_[pit - 1].layout(); + Layout const * layout2 = &(pars_[pit - 1].layout()); if (layout2->latextype != LATEX_PARAGRAPH) { --pit; layout = layout2; @@ -1350,9 +1872,28 @@ docstring Text::getPossibleLabel(Cursor & cur) const } +docstring Text::asString(int options) const +{ + return asString(0, pars_.size(), options); +} + + +docstring Text::asString(pit_type beg, pit_type end, int options) const +{ + size_t i = size_t(beg); + docstring str = pars_[i].asString(options); + for (++i; i != size_t(end); ++i) { + str += '\n'; + str += pars_[i].asString(options); + } + return str; +} + + + void Text::charsTranspose(Cursor & cur) { - BOOST_ASSERT(this == cur.text()); + LASSERT(this == cur.text(), /**/); pos_type pos = cur.pos(); @@ -1382,17 +1923,17 @@ void Text::charsTranspose(Cursor & cur) return; // Store the characters to be transposed (including font information). - char_type char1 = par.getChar(pos1); + char_type const char1 = par.getChar(pos1); Font const font1 = - par.getFontSettings(cur.buffer().params(), pos1); + par.getFontSettings(cur.buffer()->params(), pos1); - char_type char2 = par.getChar(pos2); + char_type const char2 = par.getChar(pos2); Font const font2 = - par.getFontSettings(cur.buffer().params(), pos2); + par.getFontSettings(cur.buffer()->params(), pos2); // And finally, we are ready to perform the transposition. // Track the changes if Change Tracking is enabled. - bool const trackChanges = cur.buffer().params().trackChanges; + bool const trackChanges = cur.buffer()->params().trackChanges; cur.recordUndo(); @@ -1401,7 +1942,7 @@ void Text::charsTranspose(Cursor & cur) par.insertChar(pos1, char2, font2, trackChanges); par.insertChar(pos2, char1, font1, trackChanges); - checkBufferStructure(cur.buffer(), cur); + cur.checkBufferStructure(); // After the transposition, move cursor to after the transposition. setCursor(cur, cur.pit(), pos2); @@ -1409,4 +1950,60 @@ void Text::charsTranspose(Cursor & cur) } +DocIterator Text::macrocontextPosition() const +{ + return macrocontext_position_; +} + + +void Text::setMacrocontextPosition(DocIterator const & pos) +{ + macrocontext_position_ = pos; +} + + +docstring Text::previousWord(CursorSlice const & sl) const +{ + CursorSlice from = sl; + CursorSlice to = sl; + getWord(from, to, PREVIOUS_WORD); + if (sl == from || to == from) + return docstring(); + + Paragraph const & par = sl.paragraph(); + return par.asString(from.pos(), to.pos()); +} + + +bool Text::completionSupported(Cursor const & cur) const +{ + Paragraph const & par = cur.paragraph(); + return cur.pos() > 0 + && (cur.pos() >= par.size() || par.isWordSeparator(cur.pos())) + && !par.isWordSeparator(cur.pos() - 1); +} + + +CompletionList const * Text::createCompletionList(Cursor const & cur) const +{ + return new TextCompletionList(cur); +} + + +bool Text::insertCompletion(Cursor & cur, docstring const & s, bool /*finished*/) +{ + LASSERT(cur.bv().cursor() == cur, /**/); + cur.insert(s); + cur.bv().cursor() = cur; + if (!(cur.disp_.update() & Update::Force)) + cur.updateFlags(cur.disp_.update() | Update::SinglePar); + return true; +} + + +docstring Text::completionPrefix(Cursor const & cur) const +{ + return previousWord(cur.top()); +} + } // namespace lyx