X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCutAndPaste.cpp;h=9507b2b57f1fb70b7160da88b25ad212b3366d6d;hb=7950ace3d96543e3099aa3bde823f970a1ce6a86;hp=48453cdd632a53a1523c2f3f41c3b07dc4860bbc;hpb=db8c16d554ebb1dcb319e44d318572de6eff024b;p=lyx.git diff --git a/src/CutAndPaste.cpp b/src/CutAndPaste.cpp index 48453cdd63..9507b2b57f 100644 --- a/src/CutAndPaste.cpp +++ b/src/CutAndPaste.cpp @@ -3,8 +3,8 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author Jürgen Vigna - * \author Lars Gullik Bjønnes + * \author Jürgen Vigna + * \author Lars Gullik Bjønnes * \author Alfredo Braunstein * \author Michael Gerz * @@ -15,50 +15,62 @@ #include "CutAndPaste.h" -#include "BaseClassList.h" +#include "BranchList.h" #include "Buffer.h" #include "buffer_funcs.h" +#include "BufferList.h" #include "BufferParams.h" #include "BufferView.h" #include "Changes.h" #include "Cursor.h" +#include "Encoding.h" #include "ErrorList.h" +#include "FuncCode.h" #include "FuncRequest.h" #include "InsetIterator.h" #include "InsetList.h" #include "Language.h" -#include "lfuns.h" -#include "LyXFunc.h" +#include "LyX.h" #include "LyXRC.h" #include "Text.h" #include "Paragraph.h" -#include "paragraph_funcs.h" #include "ParagraphParameters.h" #include "ParIterator.h" -#include "Undo.h" +#include "TextClass.h" +#include "insets/InsetBibitem.h" +#include "insets/InsetBranch.h" +#include "insets/InsetCitation.h" +#include "insets/InsetCommand.h" #include "insets/InsetFlex.h" #include "insets/InsetGraphics.h" #include "insets/InsetGraphicsParams.h" +#include "insets/InsetInclude.h" +#include "insets/InsetLabel.h" #include "insets/InsetTabular.h" #include "mathed/MathData.h" #include "mathed/InsetMath.h" +#include "mathed/InsetMathHull.h" +#include "mathed/InsetMathRef.h" #include "mathed/MathSupport.h" #include "support/debug.h" #include "support/docstream.h" #include "support/gettext.h" +#include "support/lassert.h" #include "support/limited_stack.h" #include "support/lstrings.h" +#include "support/lyxalgo.h" +#include "support/TempFile.h" +#include "support/unique_ptr.h" +#include "frontends/alert.h" #include "frontends/Clipboard.h" #include "frontends/Selection.h" -#include -#include - #include +#include using namespace std; using namespace lyx::support; @@ -70,11 +82,13 @@ namespace { typedef pair PitPosPair; -typedef limited_stack > CutStack; +typedef limited_stack > CutStack; CutStack theCuts(10); // persistent selection, cleared until the next selection CutStack selectionBuffer(1); +// temporary scratch area +CutStack tempCut(1); // store whether the tabular stack is newer than the normal copy stack // FIXME: this is a workaround for bug 1919. Should be removed for 1.5, @@ -82,87 +96,151 @@ CutStack selectionBuffer(1); bool dirty_tabular_stack_ = false; -void region(CursorSlice const & i1, CursorSlice const & i2, - Inset::row_type & r1, Inset::row_type & r2, - Inset::col_type & c1, Inset::col_type & c2) -{ - Inset & p = i1.inset(); - c1 = p.col(i1.idx()); - c2 = p.col(i2.idx()); - if (c1 > c2) - swap(c1, c2); - r1 = p.row(i1.idx()); - r2 = p.row(i2.idx()); - if (r1 > r2) - swap(r1, r2); -} - - bool checkPastePossible(int index) { return size_t(index) < theCuts.size() && !theCuts[index].first.empty(); } -pair -pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, - TextClassPtr textclass, ErrorList & errorlist) +struct PasteReturnValue { + PasteReturnValue(pit_type r_pit, pos_type r_pos, bool r_nu) : + pit(r_pit), pos(r_pos), needupdate(r_nu) + {} + + pit_type pit; + pos_type pos; + bool needupdate; +}; + +PasteReturnValue +pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, + DocumentClassConstPtr oldDocClass, cap::BranchAction branchAction, + ErrorList & errorlist) { - Buffer const & buffer = cur.buffer(); + Buffer const & buffer = *cur.buffer(); pit_type pit = cur.pit(); pos_type pos = cur.pos(); - ParagraphList & pars = cur.text()->paragraphs(); + bool need_update = false; if (parlist.empty()) - return make_pair(PitPosPair(pit, pos), pit); + return PasteReturnValue(pit, pos, need_update); - BOOST_ASSERT (pos <= pars[pit].size()); + InsetText * target_inset = cur.inset().asInsetText(); + if (!target_inset) { + InsetTabular * it = cur.inset().asInsetTabular(); + target_inset = it ? it->cell(cur.idx())->asInsetText() : 0; + } + LASSERT(target_inset, return PasteReturnValue(pit, pos, need_update)); + + ParagraphList & pars = target_inset->paragraphs(); + LASSERT(pos <= pars[pit].size(), + return PasteReturnValue(pit, pos, need_update)); // Make a copy of the CaP paragraphs. ParagraphList insertion = parlist; - TextClassPtr const tc = buffer.params().textClassPtr(); // Now remove all out of the pars which is NOT allowed in the // new environment and set also another font if that is required. - // Convert newline to paragraph break in ERT inset. - // This should not be here! - Inset * inset = pars[pit].inInset(); - if (inset && (inset->lyxCode() == ERT_CODE || - inset->lyxCode() == LISTINGS_CODE)) { + // Merge paragraphs that are to be pasted into a text inset + // that does not allow multiple pars. + InsetText * inset_text = target_inset->asInsetText(); + if (inset_text && !inset_text->allowMultiPar()) { + while (insertion.size() > 1) + mergeParagraph(buffer.params(), insertion, 0); + } + + // Convert newline to paragraph break in ParbreakIsNewline + if (target_inset->getLayout().parbreakIsNewline() + || pars[pit].layout().parbreak_is_newline) { for (size_t i = 0; i != insertion.size(); ++i) { for (pos_type j = 0; j != insertion[i].size(); ++j) { if (insertion[i].isNewline(j)) { // do not track deletion of newline insertion[i].eraseChar(j, false); + insertion[i].setInsetOwner(target_inset); breakParagraphConservative( buffer.params(), insertion, i, j); + break; } } } } - // set the paragraphs to empty layout if necessary - // note that we are doing this if the empty layout is - // supposed to be the default, not just if it is forced - if (cur.inset().useEmptyLayout()) { - LayoutPtr const layout = - buffer.params().textClass().emptyLayout(); + // Prevent to paste uncodable characters in verbatim and ERT. + // The encoding is inherited from the context here. + docstring uncodable_content; + if (target_inset->getLayout().isPassThru() && cur.getEncoding()) { + odocstringstream res; + Encoding const * e = cur.getEncoding(); + for (size_t i = 0; i != insertion.size(); ++i) { + pos_type end = insertion[i].size(); + for (pos_type j = 0; j != end; ++j) { + // skip insets + if (insertion[i].isInset(j)) + continue; + char_type const c = insertion[i].getChar(j); + if (!e->encodable(c)) { + // do not track deletion + res.put(c); + insertion[i].eraseChar(j, false); + --end; + --j; + } + } + } + docstring const uncodable = res.str(); + if (!uncodable.empty()) { + if (uncodable.size() == 1) + uncodable_content = bformat(_("The character \"%1$s\" is uncodable in this verbatim context " + "and thus has not been pasted."), + uncodable); + else + uncodable_content = bformat(_("The characters \"%1$s\" are uncodable in this verbatim context " + "and thus have not been pasted."), + uncodable); + } + } + + // set the paragraphs to plain layout if necessary + DocumentClassConstPtr newDocClass = buffer.params().documentClassPtr(); + if (cur.inset().usePlainLayout()) { + bool forcePlainLayout = target_inset->forcePlainLayout(); + Layout const & plainLayout = newDocClass->plainLayout(); + Layout const & defaultLayout = newDocClass->defaultLayout(); + ParagraphList::iterator const end = insertion.end(); + ParagraphList::iterator par = insertion.begin(); + for (; par != end; ++par) { + Layout const & parLayout = par->layout(); + if (forcePlainLayout || parLayout == defaultLayout) + par->setLayout(plainLayout); + } + } else { + // check if we need to reset from plain layout + Layout const & defaultLayout = newDocClass->defaultLayout(); + Layout const & plainLayout = newDocClass->plainLayout(); ParagraphList::iterator const end = insertion.end(); - for (ParagraphList::iterator par = insertion.begin(); - par != end; ++par) - par->setLayout(layout); + ParagraphList::iterator par = insertion.begin(); + for (; par != end; ++par) { + Layout const & parLayout = par->layout(); + if (parLayout == plainLayout) + par->setLayout(defaultLayout); + } } + InsetText in(cur.buffer()); // Make sure there is no class difference. - InsetText in; + in.paragraphs().clear(); // This works without copying any paragraph data because we have // a specialized swap method for ParagraphList. This is important // since we store pointers to insets at some places and we don't // want to invalidate them. insertion.swap(in.paragraphs()); - cap::switchBetweenClasses(textclass, tc, in, errorlist); + cap::switchBetweenClasses(oldDocClass, newDocClass, in, errorlist); + // Do this here since switchBetweenClasses clears the errorlist + if (!uncodable_content.empty()) + errorlist.push_back(ErrorItem(_("Uncodable content"), uncodable_content)); insertion.swap(in.paragraphs()); ParagraphList::iterator tmpbuf = insertion.begin(); @@ -184,21 +262,19 @@ pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, if (tmpbuf->params().depth() > max_depth) tmpbuf->params().depth(max_depth); - // Only set this from the 2nd on as the 2nd depends - // for maxDepth still on pit. - if (tmpbuf != insertion.begin()) - max_depth = tmpbuf->getMaxDepthAfter(); + // Set max_depth for the next paragraph + max_depth = tmpbuf->getMaxDepthAfter(); // Set the inset owner of this paragraph. - tmpbuf->setInsetOwner(pars[pit].inInset()); + tmpbuf->setInsetOwner(target_inset); for (pos_type i = 0; i < tmpbuf->size(); ++i) { // do not track deletion of invalid insets if (Inset * inset = tmpbuf->getInset(i)) - if (!pars[pit].insetAllowed(inset->lyxCode())) + if (!target_inset->insetAllowed(inset->lyxCode())) tmpbuf->eraseChar(i--, false); } - tmpbuf->setChange(Change(buffer.params().trackChanges ? + tmpbuf->setChange(Change(buffer.params().track_changes ? Change::INSERTED : Change::UNCHANGED)); } @@ -210,17 +286,164 @@ pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, } // Prepare the paragraphs and insets for insertion. - // A couple of insets store buffer references so need updating. insertion.swap(in.paragraphs()); - ParIterator fpit = par_iterator_begin(in); - ParIterator fend = par_iterator_end(in); + InsetIterator const i_end = inset_iterator_end(in); + for (InsetIterator it = inset_iterator_begin(in); it != i_end; ++it) { + // Even though this will also be done later, it has to be done here + // since some inset might going to try to access + // the buffer() member. + it->setBuffer(const_cast(buffer)); + switch (it->lyxCode()) { + + case MATH_HULL_CODE: { + // check for equation labels and resolve duplicates + InsetMathHull * ins = it->asInsetMath()->asHullInset(); + std::vector labels = ins->getLabels(); + for (size_t i = 0; i != labels.size(); ++i) { + if (!labels[i]) + continue; + InsetLabel * lab = labels[i]; + docstring const oldname = lab->getParam("name"); + lab->updateLabel(oldname); + // We need to update the buffer reference cache. + need_update = true; + docstring const newname = lab->getParam("name"); + if (oldname == newname) + continue; + // adapt the references + for (InsetIterator itt = inset_iterator_begin(in); + itt != i_end; ++itt) { + if (itt->lyxCode() == REF_CODE) { + InsetCommand * ref = itt->asInsetCommand(); + if (ref->getParam("reference") == oldname) + ref->setParam("reference", newname); + } else if (itt->lyxCode() == MATH_REF_CODE) { + InsetMathRef * mi = itt->asInsetMath()->asRefInset(); + // this is necessary to prevent an uninitialized + // buffer when the RefInset is in a MathBox. + // FIXME audit setBuffer calls + mi->setBuffer(const_cast(buffer)); + if (mi->getTarget() == oldname) + mi->changeTarget(newname); + } + } + } + break; + } + + case LABEL_CODE: { + // check for duplicates + InsetLabel & lab = static_cast(*it); + docstring const oldname = lab.getParam("name"); + lab.updateLabel(oldname); + // We need to update the buffer reference cache. + need_update = true; + docstring const newname = lab.getParam("name"); + if (oldname == newname) + break; + // adapt the references + for (InsetIterator itt = inset_iterator_begin(in); itt != i_end; ++itt) { + if (itt->lyxCode() == REF_CODE) { + InsetCommand & ref = static_cast(*itt); + if (ref.getParam("reference") == oldname) + ref.setParam("reference", newname); + } else if (itt->lyxCode() == MATH_REF_CODE) { + InsetMathRef * mi = itt->asInsetMath()->asRefInset(); + // this is necessary to prevent an uninitialized + // buffer when the RefInset is in a MathBox. + // FIXME audit setBuffer calls + mi->setBuffer(const_cast(buffer)); + if (mi->getTarget() == oldname) + mi->changeTarget(newname); + } + } + break; + } + + case INCLUDE_CODE: { + InsetInclude & inc = static_cast(*it); + inc.updateCommand(); + // We need to update the list of included files. + need_update = true; + break; + } + + case CITE_CODE: { + InsetCitation & cit = static_cast(*it); + // This actually only needs to be done if the cite engine + // differs, but we do it in general. + cit.redoLabel(); + // We need to update the list of citations. + need_update = true; + break; + } + + case BIBITEM_CODE: { + // check for duplicates + InsetBibitem & bib = static_cast(*it); + docstring const oldkey = bib.getParam("key"); + bib.updateCommand(oldkey, false); + // We need to update the buffer reference cache. + need_update = true; + docstring const newkey = bib.getParam("key"); + if (oldkey == newkey) + break; + // adapt the references + for (InsetIterator itt = inset_iterator_begin(in); + itt != i_end; ++itt) { + if (itt->lyxCode() == CITE_CODE) { + InsetCommand * ref = itt->asInsetCommand(); + if (ref->getParam("key") == oldkey) + ref->setParam("key", newkey); + } + } + break; + } + + case BRANCH_CODE: { + // check if branch is known to target buffer + // or its master + InsetBranch & br = static_cast(*it); + docstring const name = br.branch(); + if (name.empty()) + break; + bool const is_child = (&buffer != buffer.masterBuffer()); + BranchList branchlist = buffer.params().branchlist(); + if ((!is_child && branchlist.find(name)) + || (is_child && (branchlist.find(name) + || buffer.masterBuffer()->params().branchlist().find(name)))) + break; + switch(branchAction) { + case cap::BRANCH_ADD: { + // This is for a temporary buffer, so simply create the branch. + // Must not use lyx::dispatch(), since tmpbuffer has no view. + DispatchResult dr; + const_cast(buffer).dispatch(FuncRequest(LFUN_BRANCH_ADD, name), dr); + break; + } + case cap::BRANCH_ASK: { + docstring text = bformat( + _("The pasted branch \"%1$s\" is undefined.\n" + "Do you want to add it to the document's branch list?"), + name); + if (frontend::Alert::prompt(_("Unknown branch"), + text, 0, 1, _("&Add"), _("&Don't Add")) != 0) + break; + lyx::dispatch(FuncRequest(LFUN_BRANCH_ADD, name)); + break; + } + case cap::BRANCH_IGNORE: + break; + } + // We need to update the list of branches. + need_update = true; + break; + } - for (; fpit != fend; ++fpit) { - InsetList::const_iterator it = fpit->insetList().begin(); - InsetList::const_iterator et = fpit->insetList().end(); - for (; it != et; ++it) - it->inset->setBuffer(const_cast(buffer)); + default: + break; // nothing + } } insertion.swap(in.paragraphs()); @@ -230,7 +453,7 @@ pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, // Paste it! if (empty) { - pars.insert(boost::next(pars.begin(), pit), + pars.insert(lyx::next(pars.begin(), pit), insertion.begin(), insertion.end()); @@ -238,7 +461,7 @@ pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, mergeParagraph(buffer.params(), pars, pit + insertion.size() - 1); } else { - pars.insert(boost::next(pars.begin(), pit + 1), + pars.insert(lyx::next(pars.begin(), pit + 1), insertion.begin(), insertion.end()); @@ -246,12 +469,18 @@ pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, mergeParagraph(buffer.params(), pars, pit); } - pit_type last_paste = pit + insertion.size() - 1; - // Store the new cursor position. + pit_type last_paste = pit + insertion.size() - 1; + pit_type startpit = pit; pit = last_paste; pos = pars[last_paste].size(); + // FIXME Should we do it here, or should we let updateBuffer() do it? + // Set paragraph buffers. It's important to do this right away + // before something calls Inset::buffer() and causes a crash. + for (pit_type p = startpit; p <= pit; ++p) + pars[p].setBuffer(const_cast(buffer)); + // Join (conditionally) last pasted paragraph with next one, i.e., // the tail of the spliced document paragraph if (!empty && last_paste + 1 != pit_type(pars.size())) { @@ -264,12 +493,12 @@ pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, pars[last_paste].makeSameLayout(pars[last_paste + 1]); mergeParagraph(buffer.params(), pars, last_paste); } else { - pars[last_paste + 1].stripLeadingSpaces(buffer.params().trackChanges); + pars[last_paste + 1].stripLeadingSpaces(buffer.params().track_changes); ++last_paste; } } - return make_pair(PitPosPair(pit, pos), last_paste + 1); + return PasteReturnValue(pit, pos, need_update); } @@ -285,21 +514,21 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, // Start and end is inside same paragraph if (endpit == pit_type(pars.size()) || startpit == endpit) { - endpos -= pars[startpit].eraseChars(startpos, endpos, params.trackChanges); + endpos -= pars[startpit].eraseChars(startpos, endpos, params.track_changes); return PitPosPair(endpit, endpos); } for (pit_type pit = startpit; pit != endpit + 1;) { pos_type const left = (pit == startpit ? startpos : 0); pos_type right = (pit == endpit ? endpos : pars[pit].size() + 1); - bool const merge = pars[pit].isMergedOnEndOfParDeletion(params.trackChanges); + bool const merge = pars[pit].isMergedOnEndOfParDeletion(params.track_changes); // Logically erase only, including the end-of-paragraph character - pars[pit].eraseChars(left, right, params.trackChanges); + pars[pit].eraseChars(left, right, params.track_changes); // Separate handling of paragraph break: if (merge && pit != endpit && - (pit + 1 != endpit + (pit + 1 != endpit || pars[pit].hasSameLayout(pars[endpit]) || pars[endpit].size() == endpos)) { if (pit + 1 == endpit) @@ -317,34 +546,129 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, } -void putClipboard(ParagraphList const & paragraphs, TextClassPtr textclass, - docstring const & plaintext) +Buffer * copyToTempBuffer(ParagraphList const & paragraphs, DocumentClassConstPtr docclass) { - // For some strange reason gcc 3.2 and 3.3 do not accept - // Buffer buffer(string(), false); - Buffer buffer("", false); - buffer.setUnnamed(true); - buffer.paragraphs() = paragraphs; - buffer.params().setTextClass(textclass); - ostringstream lyx; - if (buffer.write(lyx)) - theClipboard().put(lyx.str(), plaintext); - else - theClipboard().put(string(), plaintext); + // This used to need to be static to avoid a memory leak. It no longer needs + // to be so, but the alternative is to construct a new one of these (with a + // new temporary directory, etc) every time, and then to destroy it. So maybe + // it's worth just keeping this one around. + static TempFile tempfile("clipboard.internal"); + tempfile.setAutoRemove(false); + // The initialization of staticbuffer is thread-safe. Using a lambda + // guarantees that the properties are set only once. + static Buffer * staticbuffer = [&](){ + Buffer * b = + theBufferList().newInternalBuffer(tempfile.name().absFileName()); + b->setUnnamed(true); + b->inset().setBuffer(*b); + //initialize staticbuffer with b + return b; + }(); + // Use a clone for the complicated stuff so that we do not need to clean + // up in order to avoid a crash. + Buffer * buffer = staticbuffer->cloneBufferOnly(); + LASSERT(buffer, return 0); + + // This needs doing every time. + // Since setDocumentClass() causes deletion of the old document class + // we need to reset all layout pointers in paragraphs (otherwise they + // would be dangling). + ParIterator const end = buffer->par_iterator_end(); + for (ParIterator it = buffer->par_iterator_begin(); it != end; ++it) { + docstring const name = it->layout().name(); + if (docclass->hasLayout(name)) + it->setLayout((*docclass)[name]); + else + it->setPlainOrDefaultLayout(*docclass); + } + buffer->params().setDocumentClass(docclass); + + // we will use pasteSelectionHelper to copy the paragraphs into the + // temporary Buffer, since it does a lot of things to fix them up. + DocIterator dit = doc_iterator_begin(buffer, &buffer->inset()); + ErrorList el; + pasteSelectionHelper(dit, paragraphs, docclass, cap::BRANCH_ADD, el); + + return buffer; +} + + +void putClipboard(ParagraphList const & paragraphs, + DocumentClassConstPtr docclass, docstring const & plaintext) +{ + Buffer * buffer = copyToTempBuffer(paragraphs, docclass); + if (!buffer) // already asserted in copyToTempBuffer() + return; + + // We don't want to produce images that are not used. Therefore, + // output formulas as MathML. Even if this is not understood by all + // applications, the number that can parse it should go up in the future. + buffer->params().html_math_output = BufferParams::MathML; + + // Make sure MarkAsExporting is deleted before buffer is + { + // The Buffer is being used to export. This is necessary so that the + // updateMacros call will record the needed information. + MarkAsExporting mex(buffer); + + buffer->updateBuffer(Buffer::UpdateMaster, OutputUpdate); + buffer->updateMacros(); + buffer->updateMacroInstances(OutputUpdate); + + // LyX's own format + string lyx; + ostringstream oslyx; + if (buffer->write(oslyx)) + lyx = oslyx.str(); + + // XHTML format + odocstringstream oshtml; + OutputParams runparams(encodings.fromLyXName("utf8")); + // We do not need to produce images, etc. + runparams.dryrun = true; + // We are not interested in errors (bug 8866) + runparams.silent = true; + buffer->writeLyXHTMLSource(oshtml, runparams, Buffer::FullSource); + + theClipboard().put(lyx, oshtml.str(), plaintext); + } + + // Save that memory + delete buffer; } -void copySelectionHelper(Buffer const & buf, ParagraphList & pars, +/// return true if the whole ParagraphList is deleted +static bool isFullyDeleted(ParagraphList const & pars) +{ + pit_type const pars_size = static_cast(pars.size()); + + // check all paragraphs + for (pit_type pit = 0; pit < pars_size; ++pit) { + if (!pars[pit].empty()) // prevent assertion failure + if (!pars[pit].isDeleted(0, pars[pit].size())) + return false; + } + return true; +} + + +void copySelectionHelper(Buffer const & buf, Text const & text, pit_type startpit, pit_type endpit, - int start, int end, TextClassPtr tc, CutStack & cutstack) + int start, int end, DocumentClassConstPtr dc, CutStack & cutstack) { - BOOST_ASSERT(0 <= start && start <= pars[startpit].size()); - BOOST_ASSERT(0 <= end && end <= pars[endpit].size()); - BOOST_ASSERT(startpit != endpit || start <= end); + ParagraphList const & pars = text.paragraphs(); + + // In most of these cases, we can try to recover. + LASSERT(0 <= start, start = 0); + LASSERT(start <= pars[startpit].size(), start = pars[startpit].size()); + LASSERT(0 <= end, end = 0); + LASSERT(end <= pars[endpit].size(), end = pars[endpit].size()); + LASSERT(startpit != endpit || start <= end, return); // Clone the paragraphs within the selection. - ParagraphList copy_pars(boost::next(pars.begin(), startpit), - boost::next(pars.begin(), endpit + 1)); + ParagraphList copy_pars(lyx::next(pars.begin(), startpit), + lyx::next(pars.begin(), endpit + 1)); // Remove the end of the last paragraph; afterwards, remove the // beginning of the first paragraph. Keep this order - there may only @@ -359,29 +683,60 @@ void copySelectionHelper(Buffer const & buf, ParagraphList & pars, ParagraphList::iterator it = copy_pars.begin(); ParagraphList::iterator it_end = copy_pars.end(); - for (; it != it_end; it++) { - // ERT paragraphs have the Language latex_language. - // This is invalid outside of ERT, so we need to change it - // to the buffer language. - if (it->ownerCode() == ERT_CODE || it->ownerCode() == LISTINGS_CODE) { - it->changeLanguage(buf.params(), latex_language, buf.language()); - } - it->setInsetOwner(0); + for (; it != it_end; ++it) { + // Since we have a copy of the paragraphs, the insets + // do not have a proper buffer reference. It makes + // sense to add them temporarily, because the + // operations below depend on that (acceptChanges included). + it->setBuffer(const_cast(buf)); + // PassThru paragraphs have the Language + // latex_language. This is invalid for others, so we + // need to change it to the buffer language. + if (it->isPassThru()) + it->changeLanguage(buf.params(), + latex_language, buf.language()); } - // do not copy text (also nested in insets) which is marked as deleted - acceptChanges(copy_pars, buf.params()); + // do not copy text (also nested in insets) which is marked as + // deleted, unless the whole selection was deleted + if (!isFullyDeleted(copy_pars)) + acceptChanges(copy_pars, buf.params()); + else + rejectChanges(copy_pars, buf.params()); - cutstack.push(make_pair(copy_pars, tc)); -} -} // namespace anon + // do some final cleanup now, to make sure that the paragraphs + // are not linked to something else. + it = copy_pars.begin(); + for (; it != it_end; ++it) { + it->resetBuffer(); + it->setInsetOwner(0); + } + cutstack.push(make_pair(copy_pars, dc)); +} +} // namespace namespace cap { +void region(CursorSlice const & i1, CursorSlice const & i2, + Inset::row_type & r1, Inset::row_type & r2, + Inset::col_type & c1, Inset::col_type & c2) +{ + Inset & p = i1.inset(); + c1 = p.col(i1.idx()); + c2 = p.col(i2.idx()); + if (c1 > c2) + swap(c1, c2); + r1 = p.row(i1.idx()); + r2 = p.row(i2.idx()); + if (r1 > r2) + swap(r1, r2); +} + + docstring grabAndEraseSelection(Cursor & cur) { if (!cur.selection()) @@ -392,72 +747,130 @@ docstring grabAndEraseSelection(Cursor & cur) } -void switchBetweenClasses(TextClassPtr const & oldone, - TextClassPtr const & newone, InsetText & in, ErrorList & errorlist) +bool reduceSelectionToOneCell(Cursor & cur) +{ + if (!cur.selection() || !cur.inMathed()) + return false; + + CursorSlice i1 = cur.selBegin(); + CursorSlice i2 = cur.selEnd(); + if (!i1.inset().asInsetMath()) + return false; + + // the easy case: do nothing if only one cell is selected + if (i1.idx() == i2.idx()) + return true; + + cur.top().pos() = 0; + cur.resetAnchor(); + cur.top().pos() = cur.top().lastpos(); + + return true; +} + + +bool multipleCellsSelected(Cursor const & cur) +{ + if (!cur.selection() || !cur.inMathed()) + return false; + + CursorSlice i1 = cur.selBegin(); + CursorSlice i2 = cur.selEnd(); + if (!i1.inset().asInsetMath()) + return false; + + if (i1.idx() == i2.idx()) + return false; + + return true; +} + + +void switchBetweenClasses(DocumentClassConstPtr oldone, + DocumentClassConstPtr newone, InsetText & in, ErrorList & errorlist) { errorlist.clear(); - BOOST_ASSERT(!in.paragraphs().empty()); + LBUFERR(!in.paragraphs().empty()); if (oldone == newone) return; - - TextClass const & oldtc = *oldone; - TextClass const & newtc = *newone; + + DocumentClass const & oldtc = *oldone; + DocumentClass const & newtc = *newone; // layouts + ParIterator it = par_iterator_begin(in); ParIterator end = par_iterator_end(in); - for (ParIterator it = par_iterator_begin(in); it != end; ++it) { - docstring const name = it->layout()->name(); - bool hasLayout = newtc.hasLayout(name); + // for remembering which layouts we've had to add + set newlayouts; + for (; it != end; ++it) { + docstring const name = it->layout().name(); + + // the pasted text will keep their own layout name. If this layout does + // not exist in the new document, it will behave like a standard layout. + bool const added_one = newtc.addLayoutIfNeeded(name); + if (added_one) + newlayouts.insert(name); + + if (added_one || newlayouts.find(name) != newlayouts.end()) { + // Warn the user. + docstring const s = bformat(_("Layout `%1$s' was not found."), name); + errorlist.push_back(ErrorItem(_("Layout Not Found"), s, + {it->id(), 0}, {it->id(), -1})); + } - if (hasLayout) - it->setLayout(newtc[name]); + if (in.usePlainLayout()) + it->setLayout(newtc.plainLayout()); else - it->setLayout(newtc.defaultLayout()); - - if (!hasLayout && name != oldtc.defaultLayoutName()) { - docstring const s = bformat( - _("Layout had to be changed from\n%1$s to %2$s\n" - "because of class conversion from\n%3$s to %4$s"), - name, it->layout()->name(), - from_utf8(oldtc.name()), from_utf8(newtc.name())); - // To warn the user that something had to be done. - errorlist.push_back(ErrorItem(_("Changed Layout"), s, - it->id(), 0, - it->size())); - } + it->setLayout(newtc[name]); } - // character styles + // character styles and hidden table cells InsetIterator const i_end = inset_iterator_end(in); - for (InsetIterator it = inset_iterator_begin(in); it != i_end; ++it) { - InsetCollapsable * inset = it->asInsetCollapsable(); - if (!inset) - continue; - if (inset->lyxCode() != FLEX_CODE) - // FIXME: Should we verify all InsetCollapsable? - continue; - inset->setLayout(newone); - if (!inset->undefined()) - continue; - // The flex inset is undefined in newtc - docstring const s = bformat(_( - "Flex inset %1$s is " - "undefined because of class " - "conversion from\n%2$s to %3$s"), - inset->name(), from_utf8(oldtc.name()), - from_utf8(newtc.name())); - // To warn the user that something had to be done. - errorlist.push_back(ErrorItem( - _("Undefined flex inset"), - s, it.paragraph().id(), it.pos(), it.pos() + 1)); + for (InsetIterator iit = inset_iterator_begin(in); iit != i_end; ++iit) { + InsetCode const code = iit->lyxCode(); + if (code == FLEX_CODE) { + // FIXME: Should we verify all InsetCollapsible? + docstring const layoutName = iit->layoutName(); + docstring const & n = newone->insetLayout(layoutName).name(); + bool const is_undefined = n.empty() || + n == DocumentClass::plainInsetLayout().name(); + if (!is_undefined) + continue; + + // The flex inset is undefined in newtc + docstring const oldname = from_utf8(oldtc.name()); + docstring const newname = from_utf8(newtc.name()); + docstring s; + if (oldname == newname) + s = bformat(_("Flex inset %1$s is undefined after " + "reloading `%2$s' layout."), layoutName, oldname); + else + s = bformat(_("Flex inset %1$s is undefined because of " + "conversion from `%2$s' layout to `%3$s'."), + layoutName, oldname, newname); + // To warn the user that something had to be done. + errorlist.push_back(ErrorItem( + _("Undefined flex inset"), s, + {iit.paragraph().id(), iit.pos()}, + {iit.paragraph().id(), iit.pos() + 1})); + } else if (code == TABULAR_CODE) { + // The recursion above does not catch paragraphs in "hidden" cells, + // i.e., ones that are part of a multirow or multicolum. So we need + // to handle those separately. + // This is the cause of bug #9049. + InsetTabular * table = iit->asInsetTabular(); + table->setLayoutForHiddenCells(newtc); + } } } -vector availableSelections() +vector availableSelections(Buffer const * buf) { vector selList; + if (!buf) + return selList; CutStack::const_iterator cit = theCuts.begin(); CutStack::const_iterator end = theCuts.end(); @@ -465,19 +878,20 @@ vector availableSelections() // we do not use cit-> here because gcc 2.9x does not // like it (JMarc) ParagraphList const & pars = (*cit).first; - docstring asciiSel; + docstring textSel; ParagraphList::const_iterator pit = pars.begin(); ParagraphList::const_iterator pend = pars.end(); for (; pit != pend; ++pit) { - asciiSel += pit->asString(false); - if (asciiSel.size() > 25) { - asciiSel.replace(22, docstring::npos, - from_ascii("...")); + Paragraph par(*pit, 0, 46); + // adapt paragraph to current buffer. + par.setBuffer(const_cast(*buf)); + textSel += par.asString(AS_STR_INSETS); + if (textSel.size() > 45) { + support::truncateWithEllipsis(textSel,45); break; } } - - selList.push_back(asciiSel); + selList.push_back(textSel); } return selList; @@ -489,8 +903,9 @@ size_type numberOfSelections() return theCuts.size(); } +namespace { -void cutSelection(Cursor & cur, bool doclear, bool realcut) +void cutSelectionHelper(Cursor & cur, CutStack & cuts, bool realcut, bool putclip) { // This doesn't make sense, if there is no selection if (!cur.selection()) @@ -501,7 +916,7 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) if (cur.inTexted()) { Text * text = cur.text(); - BOOST_ASSERT(text); + LBUFERR(text); saveSelection(cur); @@ -512,24 +927,26 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) int endpos = cur.selEnd().pos(); - BufferParams const & bp = cur.buffer().params(); + BufferParams const & bp = cur.buffer()->params(); if (realcut) { - copySelectionHelper(cur.buffer(), - text->paragraphs(), + copySelectionHelper(*cur.buffer(), + *text, begpit, endpit, cur.selBegin().pos(), endpos, - bp.textClassPtr(), theCuts); + bp.documentClassPtr(), cuts); // Stuff what we got on the clipboard. // Even if there is no selection. - putClipboard(theCuts[0].first, theCuts[0].second, - cur.selectionAsString(true)); + if (putclip) + putClipboard(cuts[0].first, cuts[0].second, + cur.selectionAsString(true)); } - boost::tie(endpit, endpos) = - eraseSelectionHelper(bp, - text->paragraphs(), - begpit, endpit, - cur.selBegin().pos(), endpos); + if (begpit != endpit) + cur.screenUpdateFlags(Update::Force | Update::FitCursor); + + tie(endpit, endpos) = + eraseSelectionHelper(bp, text->paragraphs(), begpit, endpit, + cur.selBegin().pos(), endpos); // cutSelection can invalidate the cursor so we need to set // it anew. (Lgb) @@ -537,14 +954,14 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) cur.pos() = endpos; cur.pit() = endpit; - // sometimes necessary - if (doclear - && text->paragraphs()[begpit].stripLeadingSpaces(bp.trackChanges)) - cur.fixIfBroken(); - // need a valid cursor. (Lgb) cur.clearSelection(); - updateLabels(cur.buffer()); + + // After a cut operation, we must make sure that the Buffer is updated + // because some further operation might need updated label information for + // example. So we cannot just use "cur.forceBufferUpdate()" here. + // This fixes #7071. + cur.buffer()->updateBuffer(); // tell tabular that a recent copy happened dirtyTabularStack(false); @@ -566,16 +983,45 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) } } +} // namespace -void copySelection(Cursor & cur) +void cutSelection(Cursor & cur, bool realcut) +{ + cutSelectionHelper(cur, theCuts, realcut, true); +} + + +void cutSelectionToTemp(Cursor & cur, bool realcut) +{ + cutSelectionHelper(cur, tempCut, realcut, false); +} + + +void copySelection(Cursor const & cur) { copySelection(cur, cur.selectionAsString(true)); } +void copyInset(Cursor const & cur, Inset * inset, docstring const & plaintext) +{ + ParagraphList pars; + Paragraph par; + BufferParams const & bp = cur.buffer()->params(); + par.setLayout(bp.documentClass().plainLayout()); + Font font(inherit_font, bp.language); + par.insertInset(0, inset, font, Change(Change::UNCHANGED)); + pars.push_back(par); + theCuts.push(make_pair(pars, bp.documentClassPtr())); + + // stuff the selection onto the X clipboard, from an explicit copy request + putClipboard(theCuts[0].first, theCuts[0].second, plaintext); +} + + namespace { -void copySelectionToStack(Cursor & cur, CutStack & cutstack) +void copySelectionToStack(Cursor const & cur, CutStack & cutstack) { // this doesn't make sense, if there is no selection if (!cur.selection()) @@ -587,38 +1033,37 @@ void copySelectionToStack(Cursor & cur, CutStack & cutstack) if (cur.inTexted()) { Text * text = cur.text(); - BOOST_ASSERT(text); + LBUFERR(text); // ok we have a selection. This is always between cur.selBegin() // and sel_end cursor - - // copy behind a space if there is one - ParagraphList & pars = text->paragraphs(); - pos_type pos = cur.selBegin().pos(); - pit_type par = cur.selBegin().pit(); - while (pos < pars[par].size() && - pars[par].isLineSeparator(pos) && - (par != cur.selEnd().pit() || pos < cur.selEnd().pos())) - ++pos; - - copySelectionHelper(cur.buffer(), pars, par, cur.selEnd().pit(), - pos, cur.selEnd().pos(), - cur.buffer().params().textClassPtr(), cutstack); - dirtyTabularStack(false); + copySelectionHelper(*cur.buffer(), *text, + cur.selBegin().pit(), cur.selEnd().pit(), + cur.selBegin().pos(), cur.selEnd().pos(), + cur.buffer()->params().documentClassPtr(), + cutstack); + // Reset the dirty_tabular_stack_ flag only when something + // is copied to the clipboard (not to the selectionBuffer). + if (&cutstack == &theCuts) + dirtyTabularStack(false); } if (cur.inMathed()) { //lyxerr << "copySelection in mathed" << endl; ParagraphList pars; Paragraph par; - BufferParams const & bp = cur.buffer().params(); - par.setLayout(bp.textClass().defaultLayout()); - par.insert(0, grabSelection(cur), Font(), Change(Change::UNCHANGED)); + BufferParams const & bp = cur.buffer()->params(); + // FIXME This should be the plain layout...right? + par.setLayout(bp.documentClass().plainLayout()); + // For pasting into text, we set the language to the paragraph language + // (rather than the default_language which is always English; see #2596) + par.insert(0, grabSelection(cur), Font(sane_font, par.getParLanguage(bp)), + Change(Change::UNCHANGED)); pars.push_back(par); - cutstack.push(make_pair(pars, bp.textClassPtr())); + cutstack.push(make_pair(pars, bp.documentClassPtr())); } } -} +} // namespace void copySelectionToStack() @@ -628,7 +1073,13 @@ void copySelectionToStack() } -void copySelection(Cursor & cur, docstring const & plaintext) +void copySelectionToTemp(Cursor & cur) +{ + copySelectionToStack(cur, tempCut); +} + + +void copySelection(Cursor const & cur, docstring const & plaintext) { // In tablemode, because copy and paste actually use special table stack // we do not attempt to get selected paragraphs under cursor. Instead, a @@ -637,11 +1088,11 @@ void copySelection(Cursor & cur, docstring const & plaintext) if (cur.selBegin().idx() != cur.selEnd().idx()) { ParagraphList pars; Paragraph par; - BufferParams const & bp = cur.buffer().params(); - par.setLayout(bp.textClass().defaultLayout()); + BufferParams const & bp = cur.buffer()->params(); + par.setLayout(bp.documentClass().plainLayout()); par.insert(0, plaintext, Font(), Change(Change::UNCHANGED)); pars.push_back(par); - theCuts.push(make_pair(pars, bp.textClassPtr())); + theCuts.push(make_pair(pars, bp.documentClassPtr())); } else { copySelectionToStack(cur, theCuts); } @@ -651,15 +1102,15 @@ void copySelection(Cursor & cur, docstring const & plaintext) } -void saveSelection(Cursor & cur) +void saveSelection(Cursor const & cur) { // This function is called, not when a selection is formed, but when // a selection is cleared. Therefore, multiple keyboard selection // will not repeatively trigger this function (bug 3877). - if (cur.selection() + if (cur.selection() && cur.selBegin() == cur.bv().cursor().selBegin() && cur.selEnd() == cur.bv().cursor().selEnd()) { - LYXERR(Debug::ACTION, "'" << cur.selectionAsString(true) << "'"); + LYXERR(Debug::SELECTION, "saveSelection: '" << cur.selectionAsString(true) << "'"); copySelectionToStack(cur, selectionBuffer); } } @@ -680,62 +1131,83 @@ void clearSelection() void clearCutStack() { theCuts.clear(); + tempCut.clear(); } -docstring selection(size_t sel_index) +docstring selection(size_t sel_index, DocumentClassConstPtr docclass) { - return sel_index < theCuts.size() - ? theCuts[sel_index].first.back().asString(false) - : docstring(); + if (sel_index >= theCuts.size()) + return docstring(); + + unique_ptr buffer(copyToTempBuffer(theCuts[sel_index].first, + docclass)); + if (!buffer) + return docstring(); + + return buffer->paragraphs().back().asString(AS_STR_INSETS | AS_STR_NEWLINES); } void pasteParagraphList(Cursor & cur, ParagraphList const & parlist, - TextClassPtr textclass, ErrorList & errorList) + DocumentClassConstPtr docclass, ErrorList & errorList, + cap::BranchAction branchAction) { if (cur.inTexted()) { Text * text = cur.text(); - BOOST_ASSERT(text); - - pit_type endpit; - PitPosPair ppp; + LBUFERR(text); - boost::tie(ppp, endpit) = - pasteSelectionHelper(cur, parlist, textclass, errorList); - updateLabels(cur.buffer()); + PasteReturnValue prv = + pasteSelectionHelper(cur, parlist, docclass, branchAction, errorList); + cur.forceBufferUpdate(); cur.clearSelection(); - text->setCursor(cur, ppp.first, ppp.second); + text->setCursor(cur, prv.pit, prv.pos); } // mathed is handled in InsetMathNest/InsetMathGrid - BOOST_ASSERT(!cur.inMathed()); + LATTEST(!cur.inMathed()); } -void pasteFromStack(Cursor & cur, ErrorList & errorList, size_t sel_index) +bool pasteFromStack(Cursor & cur, ErrorList & errorList, size_t sel_index) { // this does not make sense, if there is nothing to paste if (!checkPastePossible(sel_index)) - return; + return false; cur.recordUndo(); pasteParagraphList(cur, theCuts[sel_index].first, - theCuts[sel_index].second, errorList); - cur.setSelection(); + theCuts[sel_index].second, errorList, BRANCH_ASK); + return true; } -void pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs) +bool pasteFromTemp(Cursor & cur, ErrorList & errorList) +{ + // this does not make sense, if there is nothing to paste + if (tempCut.empty() || tempCut[0].first.empty()) + return false; + + cur.recordUndo(); + pasteParagraphList(cur, tempCut[0].first, + tempCut[0].second, errorList, BRANCH_IGNORE); + return true; +} + + +bool pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs, + Clipboard::TextType type) { // Use internal clipboard if it is the most recent one - if (theClipboard().isInternal()) { - pasteFromStack(cur, errorList, 0); - return; - } + // This overrides asParagraphs and type on purpose! + if (theClipboard().isInternal()) + return pasteFromStack(cur, errorList, 0); // First try LyX format - if (theClipboard().hasLyXContents()) { + if ((type == Clipboard::LyXTextType || + type == Clipboard::LyXOrPlainTextType || + type == Clipboard::AnyTextType) && + theClipboard().hasTextContents(Clipboard::LyXTextType)) { string lyx = theClipboard().getAsLyX(); if (!lyx.empty()) { // For some strange reason gcc 3.2 and 3.3 do not accept @@ -745,29 +1217,104 @@ void pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs) if (buffer.readString(lyx)) { cur.recordUndo(); pasteParagraphList(cur, buffer.paragraphs(), - buffer.params().textClassPtr(), errorList); - cur.setSelection(); - return; + buffer.params().documentClassPtr(), errorList); + return true; + } + } + } + + // Then try TeX and HTML + Clipboard::TextType types[2] = {Clipboard::HtmlTextType, Clipboard::LaTeXTextType}; + string names[2] = {"html", "latexclipboard"}; + for (int i = 0; i < 2; ++i) { + if (type != types[i] && type != Clipboard::AnyTextType) + continue; + bool available = theClipboard().hasTextContents(types[i]); + + // If a specific type was explicitly requested, try to + // interpret plain text: The user told us that the clipboard + // contents is in the desired format + if (!available && type == types[i]) { + types[i] = Clipboard::PlainTextType; + available = theClipboard().hasTextContents(types[i]); + } + + if (available) { + docstring text = theClipboard().getAsText(types[i]); + available = !text.empty(); + if (available) { + // For some strange reason gcc 3.2 and 3.3 do not accept + // Buffer buffer(string(), false); + Buffer buffer("", false); + buffer.setUnnamed(true); + available = buffer.importString(names[i], text, errorList); + if (available) + available = !buffer.paragraphs().empty(); + if (available && !buffer.paragraphs()[0].empty()) { + // TeX2lyx (also used in the HTML chain) assumes English as document language + // if no language is explicitly set (as is the case here). + // We thus reset the temp buffer's language to the context language + buffer.changeLanguage(buffer.language(), cur.getFont().language()); + cur.recordUndo(); + pasteParagraphList(cur, buffer.paragraphs(), + buffer.params().documentClassPtr(), errorList); + return true; + } } } } // Then try plain text - docstring const text = theClipboard().getAsText(); + docstring const text = theClipboard().getAsText(Clipboard::PlainTextType); + if (text.empty()) + return false; + cur.recordUndo(); + if (asParagraphs) + cur.text()->insertStringAsParagraphs(cur, text, cur.current_font); + else + cur.text()->insertStringAsLines(cur, text, cur.current_font); + cur.forceBufferUpdate(); + return true; +} + + +void pasteSimpleText(Cursor & cur, bool asParagraphs) +{ + docstring text; + // Use internal clipboard if it is the most recent one + if (theClipboard().isInternal()) { + if (!checkPastePossible(0)) + return; + + ParagraphList const & pars = theCuts[0].first; + ParagraphList::const_iterator it = pars.begin(); + for (; it != pars.end(); ++it) { + if (it != pars.begin()) + text += "\n"; + text += (*it).asString(); + } + asParagraphs = false; + } else { + // Then try plain text + text = theClipboard().getAsText(Clipboard::PlainTextType); + } + if (text.empty()) return; + cur.recordUndo(); + cutSelection(cur, false); if (asParagraphs) - cur.text()->insertStringAsParagraphs(cur, text); + cur.text()->insertStringAsParagraphs(cur, text, cur.current_font); else - cur.text()->insertStringAsLines(cur, text); + cur.text()->insertStringAsLines(cur, text, cur.current_font); } void pasteClipboardGraphics(Cursor & cur, ErrorList & /* errorList */, Clipboard::GraphicsType preferedType) { - BOOST_ASSERT(theClipboard().hasGraphicsContents(preferedType)); + LASSERT(theClipboard().hasGraphicsContents(preferedType), return); // get picture from clipboard FileName filename = theClipboard().getAsGraphics(cur, preferedType); @@ -775,9 +1322,9 @@ void pasteClipboardGraphics(Cursor & cur, ErrorList & /* errorList */, return; // create inset for graphic - InsetGraphics * inset = new InsetGraphics; + InsetGraphics * inset = new InsetGraphics(cur.buffer()); InsetGraphicsParams params; - params.filename = EmbeddedFile(filename.absFilename(), cur.buffer().filePath()); + params.filename = support::DocFileName(filename.absFileName(), false); inset->setParams(params); cur.recordUndo(); cur.insert(inset); @@ -794,14 +1341,14 @@ void pasteSelection(Cursor & cur, ErrorList & errorList) } -void replaceSelectionWithString(Cursor & cur, docstring const & str, bool backwards) +void replaceSelectionWithString(Cursor & cur, docstring const & str) { cur.recordUndo(); DocIterator selbeg = cur.selectionBegin(); - // Get font setting before we cut + // Get font setting before we cut, we need a copy here, not a bare reference. Font const font = - selbeg.paragraph().getFontSettings(cur.buffer().params(), selbeg.pos()); + selbeg.paragraph().getFontSettings(cur.buffer()->params(), selbeg.pos()); // Insert the new string pos_type pos = cur.selEnd().pos(); @@ -809,24 +1356,17 @@ void replaceSelectionWithString(Cursor & cur, docstring const & str, bool backwa docstring::const_iterator cit = str.begin(); docstring::const_iterator end = str.end(); for (; cit != end; ++cit, ++pos) - par.insertChar(pos, *cit, font, cur.buffer().params().trackChanges); + par.insertChar(pos, *cit, font, cur.buffer()->params().track_changes); // Cut the selection - cutSelection(cur, true, false); - - // select the replacement - if (backwards) { - selbeg.pos() += str.length(); - cur.setSelection(selbeg, -int(str.length())); - } else - cur.setSelection(selbeg, str.length()); + cutSelection(cur, false); } void replaceSelection(Cursor & cur) { if (cur.selection()) - cutSelection(cur, true, false); + cutSelection(cur, false); } @@ -835,31 +1375,43 @@ void eraseSelection(Cursor & cur) //lyxerr << "cap::eraseSelection begin: " << cur << endl; CursorSlice const & i1 = cur.selBegin(); CursorSlice const & i2 = cur.selEnd(); - if (i1.inset().asInsetMath()) { - saveSelection(cur); - cur.top() = i1; - if (i1.idx() == i2.idx()) { - i1.cell().erase(i1.pos(), i2.pos()); - // We may have deleted i1.cell(cur.pos()). - // Make sure that pos is valid. - if (cur.pos() > cur.lastpos()) - cur.pos() = cur.lastpos(); - } else { - InsetMath * p = i1.asInsetMath(); - Inset::row_type r1, r2; - Inset::col_type c1, c2; - region(i1, i2, r1, r2, c1, c2); - for (Inset::row_type row = r1; row <= r2; ++row) - for (Inset::col_type col = c1; col <= c2; ++col) - p->cell(p->index(row, col)).clear(); - // We've deleted the whole cell. Only pos 0 is valid. - cur.pos() = 0; - } - // need a valid cursor. (Lgb) - cur.clearSelection(); + if (!i1.asInsetMath()) { + LYXERR0("Can't erase this selection"); + return; + } + + saveSelection(cur); + cur.top() = i1; + InsetMath * p = i1.asInsetMath(); + if (i1.idx() == i2.idx()) { + i1.cell().erase(i1.pos(), i2.pos()); + // We may have deleted i1.cell(cur.pos()). + // Make sure that pos is valid. + if (cur.pos() > cur.lastpos()) + cur.pos() = cur.lastpos(); + } else if (p->nrows() > 0 && p->ncols() > 0) { + // This is a grid, delete a nice square region + Inset::row_type r1, r2; + Inset::col_type c1, c2; + region(i1, i2, r1, r2, c1, c2); + for (Inset::row_type row = r1; row <= r2; ++row) + for (Inset::col_type col = c1; col <= c2; ++col) + p->cell(p->index(row, col)).clear(); + // We've deleted the whole cell. Only pos 0 is valid. + cur.pos() = 0; } else { - lyxerr << "can't erase this selection 1" << endl; + Inset::idx_type idx1 = i1.idx(); + Inset::idx_type idx2 = i2.idx(); + if (idx1 > idx2) + swap(idx1, idx2); + for (Inset::idx_type idx = idx1 ; idx <= idx2; ++idx) + p->cell(idx).clear(); + // We've deleted the whole cell. Only pos 0 is valid. + cur.pos() = 0; } + + // need a valid cursor. (Lgb) + cur.clearSelection(); //lyxerr << "cap::eraseSelection end: " << cur << endl; } @@ -878,7 +1430,7 @@ void selClearOrDel(Cursor & cur) if (lyxrc.auto_region_delete) selDel(cur); else - cur.selection() = false; + cur.selection(false); } @@ -887,8 +1439,10 @@ docstring grabSelection(Cursor const & cur) if (!cur.selection()) return docstring(); - // FIXME: What is wrong with the following? #if 0 + // grab selection by glueing multiple cells together. This is not what + // we want because selections spanning multiple cells will get "&" and "\\" + // seperators. ostringstream os; for (DocIterator dit = cur.selectionBegin(); dit != cur.selectionEnd(); dit.forwardPos()) @@ -902,7 +1456,8 @@ docstring grabSelection(Cursor const & cur) if (i1.idx() == i2.idx()) { if (i1.inset().asInsetMath()) { MathData::const_iterator it = i1.cell().begin(); - return asString(MathData(it + i1.pos(), it + i2.pos())); + Buffer * buf = cur.buffer(); + return asString(MathData(buf, it + i1.pos(), it + i2.pos())); } else { return from_ascii("unknown selection 1"); } @@ -944,5 +1499,4 @@ bool tabularStackDirty() } // namespace cap - } // namespace lyx