X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText.cpp;h=48f8c82491fc40db4c3f867a5a52fb6e7a67848f;hb=90f7007a2e6c78ffd031e4636ff909ab1bc2ddec;hp=54ee1dac9b5f1e80a2af2d8cb7d3fa6ae2985409;hpb=b3d7fce1b248db0ea50d7924d33f65e27bd481db;p=lyx.git diff --git a/src/Text.cpp b/src/Text.cpp index 54ee1dac9b..48f8c82491 100644 --- a/src/Text.cpp +++ b/src/Text.cpp @@ -46,21 +46,21 @@ #include "ParIterator.h" #include "TextClass.h" #include "TextMetrics.h" -#include "VSpace.h" #include "WordLangTuple.h" #include "WordList.h" #include "insets/InsetText.h" #include "insets/InsetBibitem.h" #include "insets/InsetCaption.h" -#include "insets/InsetLine.h" #include "insets/InsetNewline.h" #include "insets/InsetNewpage.h" -#include "insets/InsetOptArg.h" +#include "insets/InsetArgument.h" +#include "insets/InsetIPAMacro.h" #include "insets/InsetSpace.h" #include "insets/InsetSpecialChar.h" #include "insets/InsetTabular.h" +#include "support/convert.h" #include "support/debug.h" #include "support/docstream.h" #include "support/gettext.h" @@ -70,8 +70,34 @@ #include +#include #include + +// TODO: replace if in Text::readParToken() with compile time switch +#if 0 + +#include "support/metahash.h" + +typedef boost::mpl::string<'\\end','_lay','out'> end_layout; +typedef boost::mpl::string<'\\end','in','set'> end_inset; + +void foo() +{ + std::string token = "\\end_layout"; + + switch (boost::hash_value(token)) { + case lyx::support::hash_string::value: + return; + case lyx::support::hash_string::value: + return; + default: ; + }; + +} +#endif + + using namespace std; using namespace lyx::support; @@ -171,6 +197,31 @@ void mergeParagraph(BufferParams const & bparams, } +Text::Text(InsetText * owner, bool use_default_layout) + : owner_(owner), autoBreakRows_(false), undo_counter_(0) +{ + pars_.push_back(Paragraph()); + Paragraph & par = pars_.back(); + par.setInsetOwner(owner); + DocumentClass const & dc = owner->buffer().params().documentClass(); + if (use_default_layout) + par.setDefaultLayout(dc); + else + par.setPlainLayout(dc); +} + + +Text::Text(InsetText * owner, Text const & text) + : owner_(owner), autoBreakRows_(text.autoBreakRows_), undo_counter_(0) +{ + pars_ = text.pars_; + ParagraphList::iterator const end = pars_.end(); + ParagraphList::iterator it = pars_.begin(); + for (; it != end; ++it) + it->setInsetOwner(owner); +} + + pit_type Text::depthHook(pit_type pit, depth_type depth) const { pit_type newpit = pit; @@ -214,15 +265,28 @@ bool Text::isFirstInSequence(pit_type par_offset) const } +int Text::getTocLevel(pit_type par_offset) const +{ + Paragraph const & par = pars_[par_offset]; + + if (par.layout().isEnvironment() && !isFirstInSequence(par_offset)) + return Layout::NOT_IN_TOC; + + return par.layout().toclevel; +} + + Font const Text::outerFont(pit_type par_offset) const { depth_type par_depth = pars_[par_offset].getDepth(); FontInfo tmpfont = inherit_font; - + depth_type prev_par_depth = 0; // Resolve against environment font information while (par_offset != pit_type(pars_.size()) + && par_depth != prev_par_depth && par_depth && !tmpfont.resolved()) { + prev_par_depth = par_depth; par_offset = outerHook(par_offset); if (par_offset != pit_type(pars_.size())) { tmpfont.realize(pars_[par_offset].layout().font); @@ -234,48 +298,71 @@ Font const Text::outerFont(pit_type par_offset) const } -void acceptChanges(ParagraphList & pars, BufferParams const & bparams) +static void acceptOrRejectChanges(ParagraphList & pars, + BufferParams const & bparams, Text::ChangeOp op) { pit_type pars_size = static_cast(pars.size()); - // first, accept changes within each individual paragraph - // (do not consider end-of-par) + // first, accept or 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].acceptChanges(0, pars[pit].size()); + // prevent assertion failure + if (!pars[pit].empty()) { + if (op == Text::ACCEPT) + pars[pit].acceptChanges(0, pars[pit].size()); + else + pars[pit].rejectChanges(0, pars[pit].size()); + } } - // next, accept imaginary end-of-par characters + // next, accept or reject 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 + if (pars[pit].isChanged(pos)) { + // keep the end-of-par char if it is inserted and accepted + // or when it is deleted and rejected. + if (pars[pit].isInserted(pos) == (op == Text::ACCEPT)) { pars[pit].setChange(pos, Change(Change::UNCHANGED)); } else { - mergeParagraph(bparams, pars, pit); - --pit; - --pars_size; + 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; + } } } } } + +void acceptChanges(ParagraphList & pars, BufferParams const & bparams) +{ + acceptOrRejectChanges(pars, bparams, Text::ACCEPT); +} + + +void rejectChanges(ParagraphList & pars, BufferParams const & bparams) +{ + acceptOrRejectChanges(pars, bparams, Text::REJECT); +} + + InsetText const & Text::inset() const { return *owner_; } + void Text::readParToken(Paragraph & par, Lexer & lex, string const & token, Font & font, Change & change, ErrorList & errorList) { - Buffer const & buf = owner_->buffer(); - BufferParams const & bp = buf.params(); + Buffer * buf = const_cast(&owner_->buffer()); + BufferParams const & bp = buf->params(); if (token[0] != '\\') { docstring dstr = lex.getDocString(); @@ -310,7 +397,13 @@ void Text::readParToken(Paragraph & par, Lexer & lex, // 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); + bool const added_one = tclass.addLayoutIfNeeded(layoutname); + if (added_one) { + // Warn the user. + docstring const s = bformat(_("Layout `%1$s' was not found."), layoutname); + errorList.push_back( + ErrorItem(_("Layout Not Found"), s, par.id(), 0, par.size())); + } par.setLayout(bp.documentClass()[layoutname]); @@ -361,10 +454,10 @@ void Text::readParToken(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(); @@ -380,42 +473,46 @@ void Text::readParToken(Paragraph & par, Lexer & lex, "`$$Token'"); } else if (token == "\\strikeout") { lex.next(); - font.fontInfo().setStrikeout(font.setLyXMisc(lex.getString())); + font.fontInfo().setStrikeout(setLyXMisc(lex.getString())); } else if (token == "\\uuline") { lex.next(); - font.fontInfo().setUuline(font.setLyXMisc(lex.getString())); + font.fontInfo().setUuline(setLyXMisc(lex.getString())); } else if (token == "\\uwave") { lex.next(); - font.fontInfo().setUwave(font.setLyXMisc(lex.getString())); + 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 == "\\SpecialChar") { - auto_ptr inset; - inset.reset(new InsetSpecialChar); - inset->read(lex); - par.insertInset(par.size(), inset.release(), - font, change); + auto_ptr inset; + inset.reset(new InsetSpecialChar); + inset->read(lex); + inset->setBuffer(*buf); + par.insertInset(par.size(), inset.release(), font, change); + } else if (token == "\\IPAChar") { + auto_ptr inset; + inset.reset(new InsetIPAChar); + 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 == "\\LyXTable") { - auto_ptr inset(new InsetTabular(const_cast(buf))); + auto_ptr inset(new InsetTabular(buf)); inset->read(lex); par.insertInset(par.size(), inset.release(), font, change); - } else if (token == "\\lyxline") { - par.insertInset(par.size(), new InsetLine, font, change); } else if (token == "\\change_unchanged") { change = Change(Change::UNCHANGED); } else if (token == "\\change_inserted" || token == "\\change_deleted") { lex.eatLine(); istringstream is(lex.getString()); - unsigned int aid; + int aid; time_t ct; is >> aid >> ct; - map const & am = bp.author_map; + BufferParams::AuthorMap const & am = bp.author_map; if (am.find(aid) == am.end()) { errorList.push_back(ErrorItem(_("Change tracking error"), bformat(_("Unknown author index for change: %1$d\n"), aid), @@ -475,6 +572,9 @@ void Text::readParagraph(Paragraph & par, Lexer & lex, // Initialize begin_of_body_ on load; redoParagraph maintains par.setBeginOfBody(); + + // mark paragraph for spell checking on load + // par.requestSpellCheck(); } @@ -482,8 +582,8 @@ class TextCompletionList : public CompletionList { public: /// - TextCompletionList(Cursor const & cur) - : buffer_(cur.buffer()), pos_(0) + TextCompletionList(Cursor const & cur, WordList const * list) + : buffer_(cur.buffer()), pos_(0), list_(list) {} /// virtual ~TextCompletionList() {} @@ -493,12 +593,12 @@ public: /// virtual size_t size() const { - return theWordList().size(); + return list_->size(); } /// virtual docstring const & data(size_t idx) const { - return theWordList().word(idx); + return list_->word(idx); } private: @@ -506,6 +606,8 @@ private: Buffer const * buffer_; /// size_t pos_; + /// + WordList const * list_; }; @@ -550,7 +652,6 @@ static void breakParagraph(Text & text, pit_type par_offset, pos_type pos, // 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()); @@ -616,7 +717,6 @@ static void breakParagraph(Text & text, pit_type par_offset, pos_type pos, par.setPlainOrDefaultLayout(bparams.documentClass()); } - // layout stays the same with latex-environments if (keep_layout) { par.setLayout(tmp->layout()); par.setLabelWidthString(tmp->params().labelWidthString()); @@ -635,14 +735,15 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic) 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) + if (cur.lastpos() == 0 && !cpar.allowEmpty()) { + if (changeDepthAllowed(cur, DEC_DEPTH)) + changeDepth(cur, DEC_DEPTH); + else + setLayout(cur, tclass.defaultLayoutName()); return; + } - // a layout change may affect also the following paragraph - recUndo(cur, cur.pit(), undoSpan(cur.pit()) - 1); + cur.recordUndo(); // Always break behind a space // It is better to erase the space (Dekel) @@ -650,9 +751,10 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic) 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(); + bool keep_layout = layout.isEnvironment() + || (layout.isParagraph() && layout.parbreak_is_newline); + if (inverse_logic) + keep_layout = !keep_layout; // We need to remember this before we break the paragraph, because // that invalidates the layout variable @@ -685,10 +787,9 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic) break; // the character couldn't be deleted physically due to change tracking } - cur.buffer()->updateLabels(); - // A singlePar update is not enough in this case. - cur.updateFlags(Update::Force); + cur.screenUpdateFlags(Update::Force); + cur.forceBufferUpdate(); // This check is necessary. Otherwise the new empty paragraph will // be deleted automatically. And it is more friendly for the user! @@ -700,12 +801,12 @@ void Text::breakParagraph(Cursor & cur, bool inverse_logic) // needed to insert the selection -void Text::insertStringAsLines(DocIterator const & dit, docstring const & str, +void Text::insertStringAsLines(Cursor & cur, docstring const & str, Font const & font) { BufferParams const & bparams = owner_->buffer().params(); - pit_type pit = dit.pit(); - pos_type pos = dit.pos(); + pit_type pit = cur.pit(); + pos_type pos = cur.pos(); // insert the string, don't insert doublespace bool space_inserted = true; @@ -747,12 +848,13 @@ void Text::insertStringAsLines(DocIterator const & dit, docstring const & str, space_inserted = (*cit == ' '); } } + setCursor(cur, pit, pos); } // 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, +void Text::insertStringAsParagraphs(Cursor & cur, docstring const & str, Font const & font) { docstring linestr = str; @@ -774,7 +876,7 @@ void Text::insertStringAsParagraphs(DocIterator const & dit, docstring const & s newline_inserted = false; } } - insertStringAsLines(dit, linestr, font); + insertStringAsLines(cur, linestr, font); } @@ -801,7 +903,7 @@ void Text::insertChar(Cursor & cur, char_type c) static docstring const number_seperators = from_ascii(".,:"); if (cur.current_font.fontInfo().number() == FONT_ON) { - if (!isDigit(c) && !contains(number_operators, c) && + if (!isDigitASCII(c) && !contains(number_operators, c) && !(contains(number_seperators, c) && cur.pos() != 0 && cur.pos() != cur.lastpos() && @@ -809,7 +911,7 @@ void Text::insertChar(Cursor & cur, char_type c) tm.displayFont(pit, cur.pos() - 1).fontInfo().number() == FONT_ON) ) number(cur); // Set current_font.number to OFF - } else if (isDigit(c) && + } else if (isDigitASCII(c) && cur.real_current_font.isVisibleRightToLeft()) { number(cur); // Set current_font.number to ON @@ -886,23 +988,17 @@ void Text::insertChar(Cursor & cur, char_type c) // disable the double-space checking if (!freeSpacing && isLineSeparatorChar(c)) { if (cur.pos() == 0) { - static bool sent_space_message = false; - if (!sent_space_message) { - cur.message(_("You cannot insert a space at the " - "beginning of a paragraph. Please read the Tutorial.")); - sent_space_message = true; - } + cur.message(_( + "You cannot insert a space at the " + "beginning of a paragraph. Please read the Tutorial.")); return; } 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; - if (!sent_space_message) { - cur.message(_("You cannot type two spaces this way. " - "Please read the Tutorial.")); - sent_space_message = true; - } + && !par.isDeleted(cur.pos() - 1)) { + cur.message(_( + "You cannot type two spaces this way. " + "Please read the Tutorial.")); return; } } @@ -911,8 +1007,9 @@ void Text::insertChar(Cursor & cur, char_type c) cur.buffer()->params().trackChanges); cur.checkBufferStructure(); -// cur.updateFlags(Update::Force); - bool boundary = tm.isRTLBoundary(cur.pit(), cur.pos() + 1); +// cur.screenUpdateFlags(Update::Force); + bool boundary = cur.boundary() + || tm.isRTLBoundary(cur.pit(), cur.pos() + 1); setCursor(cur, cur.pit(), cur.pos() + 1, false, boundary); charInserted(cur); } @@ -924,12 +1021,11 @@ void Text::charInserted(Cursor & cur) // 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 @@ -1120,9 +1216,11 @@ void Text::selectWord(Cursor & cur, word_location loc) setCursor(cur, from.pit(), from.pos()); if (to == from) return; - cur.resetAnchor(); + if (!cur.selection()) + cur.resetAnchor(); setCursor(cur, to.pit(), to.pos()); cur.setSelection(); + cur.setWordSelection(true); } @@ -1198,7 +1296,11 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op) pos_type left = (pit == begPit ? begPos : 0); pos_type right = (pit == endPit ? endPos : parSize); - + + if (left == right) + // there is no change here + continue; + if (op == ACCEPT) { pars_[pit].acceptChanges(left, right); } else { @@ -1259,8 +1361,8 @@ void Text::acceptOrRejectChanges(Cursor & cur, ChangeOp op) cur.finishUndo(); cur.clearSelection(); setCursorIntern(cur, begPit, begPos); - cur.updateFlags(Update::Force); - cur.buffer()->updateLabels(); + cur.screenUpdateFlags(Update::Force); + cur.forceBufferUpdate(); } @@ -1411,9 +1513,9 @@ bool Text::handleBibitems(Cursor & cur) cur.recordUndo(ATOMIC_UNDO, prevcur.pit()); mergeParagraph(bufparams, cur.text()->paragraphs(), prevcur.pit()); - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); setCursorIntern(cur, prevcur.pit(), prevcur.pos()); - cur.updateFlags(Update::Force); + cur.screenUpdateFlags(Update::Force); return true; } @@ -1439,7 +1541,7 @@ bool Text::erase(Cursor & cur) cur.top().forwardPos(); if (was_inset) - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); else cur.checkBufferStructure(); needsUpdate = true; @@ -1515,7 +1617,7 @@ bool Text::backspacePos0(Cursor & cur) } if (needsUpdate) { - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); setCursorIntern(cur, prevcur.pit(), prevcur.pos()); } @@ -1555,7 +1657,7 @@ bool Text::backspace(Cursor & 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(); + cur.forceBufferUpdate(); else cur.checkBufferStructure(); } @@ -1566,7 +1668,7 @@ bool Text::backspace(Cursor & cur) needsUpdate |= handleBibitems(cur); // A singlePar update is not enough in this case. -// cur.updateFlags(Update::Force); +// cur.screenUpdateFlags(Update::Force); setCursor(cur.top(), cur.pit(), cur.pos()); return needsUpdate; @@ -1596,13 +1698,23 @@ bool Text::dissolveInset(Cursor & cur) spit += cur.pit(); Buffer & b = *cur.buffer(); cur.paragraph().eraseChar(cur.pos(), b.params().trackChanges); + if (!plist.empty()) { + // see bug 7319 + // we clear the cache so that we won't get conflicts with labels + // that get pasted into the buffer. we should update this before + // its being empty matters. if not (i.e., if we encounter bugs), + // then this should instead be: + // cur.buffer().updateBuffer(); + // but we'll try the cheaper solution here. + cur.buffer()->clearReferenceCache(); + // ERT paragraphs have the Language latex_language. // This is invalid outside of ERT, so we need to // change it to the buffer language. ParagraphList::iterator it = plist.begin(); ParagraphList::iterator it_end = plist.end(); - for (; it != it_end; it++) + for (; it != it_end; ++it) it->changeLanguage(b.params(), latex_language, b.language()); pasteParagraphList(cur, plist, b.params().documentClassPtr(), @@ -1610,10 +1722,12 @@ bool Text::dissolveInset(Cursor & cur) // restore position 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(); + } + + cur.forceBufferUpdate(); + + // Ensure the current language is set correctly (bug 6292) + cur.text()->setCursor(cur, cur.pit(), cur.pos()); cur.clearSelection(); cur.resetAnchor(); return true; @@ -1709,6 +1823,7 @@ bool Text::read(Lexer & lex, return res; } + // Returns the current font and depth as a message. docstring Text::currentState(Cursor const & cur) const { @@ -1797,10 +1912,11 @@ docstring Text::getPossibleLabel(Cursor const & cur) const docstring text; docstring par_text = pars_[pit].asString(); - string piece; - // the return string of math matrices might contain linebreaks + + // The return string of math matrices might contain linebreaks par_text = subst(par_text, '\n', '-'); - for (int i = 0; i < lyxrc.label_init_length; ++i) { + int const numwords = 3; + for (int i = 0; i < numwords; ++i) { if (par_text.empty()) break; docstring head; @@ -1810,12 +1926,13 @@ docstring Text::getPossibleLabel(Cursor const & cur) const text += '-'; text += head; } + + // Make sure it isn't too long + unsigned int const max_label_length = 32; + if (text.size() > max_label_length) + text.resize(max_label_length); - // No need for a prefix if the user said so. - if (lyxrc.label_init_length <= 0) - return text; - - // Will contain the label type. + // Will contain the label prefix. docstring name; // For section, subsection, etc... @@ -1827,42 +1944,39 @@ docstring Text::getPossibleLabel(Cursor const & cur) const } } if (layout->latextype != LATEX_PARAGRAPH) - name = from_ascii(layout->latexname()); + name = layout->refprefix; - // for captions, we just take the caption type + // For captions, we just take the caption type Inset * caption_inset = cur.innerInsetOfType(CAPTION_CODE); - if (caption_inset) - name = from_ascii(static_cast(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()) { - 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]); - if (float_inset) { - name = float_inset->name(); - break; - } + if (caption_inset) { + string const & ftype = static_cast(caption_inset)->type(); + FloatList const & fl = cur.buffer()->params().documentClass().floats(); + if (fl.typeExist(ftype)) { + Floating const & flt = fl.getType(ftype); + name = from_utf8(flt.refPrefix()); } + if (name.empty()) + name = from_utf8(ftype.substr(0,3)); } - // Create a correct prefix for prettyref - if (name == "theorem") - name = from_ascii("thm"); - else if (name == "Foot") - name = from_ascii("fn"); - else if (name == "listing") - name = from_ascii("lst"); + // If none of the above worked, see if the inset knows. + if (name.empty()) { + InsetLayout const & il = cur.inset().getLayout(); + name = il.refprefix(); + } if (!name.empty()) - text = name.substr(0, 3) + ':' + text; + text = name + ':' + text; + + // We need a unique label + docstring label = text; + int i = 1; + while (cur.buffer()->insetLabel(label)) { + label = text + '-' + convert(i); + ++i; + } - return text; + return label; } @@ -1884,6 +1998,18 @@ docstring Text::asString(pit_type beg, pit_type end, int options) const } +void Text::forToc(docstring & os, size_t maxlen, bool shorten) const +{ + if (maxlen == 0) + maxlen = std::numeric_limits::max(); + else + LASSERT(maxlen >= 8, maxlen = TOC_ENTRY_LENGTH); + for (size_t i = 0; i != pars_.size() && os.length() < maxlen; ++i) + pars_[i].forToc(os, maxlen); + if (shorten && os.length() >= maxlen) + os = os.substr(0, maxlen - 3) + from_ascii("..."); +} + void Text::charsTranspose(Cursor & cur) { @@ -1980,7 +2106,8 @@ bool Text::completionSupported(Cursor const & cur) const CompletionList const * Text::createCompletionList(Cursor const & cur) const { - return new TextCompletionList(cur); + WordList const * list = theWordList(*cur.getFont().language()); + return new TextCompletionList(cur, list); } @@ -1989,8 +2116,8 @@ 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); + if (!(cur.result().screenUpdate() & Update::Force)) + cur.screenUpdateFlags(cur.result().screenUpdate() | Update::SinglePar); return true; }