X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCutAndPaste.cpp;h=364e1e9d034e5eaf06cc5515a5a7695719d9ccf3;hb=190439eccfb04b3a27b4e85b548245d3b1f4076a;hp=51fd1bbf1bde66962a6b75142ee15200b3ff446a;hpb=9383f4c3c6f9cfab2d658701ba66e2b54cd68bea;p=lyx.git diff --git a/src/CutAndPaste.cpp b/src/CutAndPaste.cpp index 51fd1bbf1b..364e1e9d03 100644 --- a/src/CutAndPaste.cpp +++ b/src/CutAndPaste.cpp @@ -1,10 +1,10 @@ -/* +/** * \file CutAndPaste.cpp * 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,33 +15,41 @@ #include "CutAndPaste.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 "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 "TextClassList.h" #include "Paragraph.h" -#include "paragraph_funcs.h" #include "ParagraphParameters.h" #include "ParIterator.h" -#include "Undo.h" +#include "insets/InsetBibitem.h" +#include "insets/InsetBranch.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" @@ -50,6 +58,7 @@ #include "support/limited_stack.h" #include "support/lstrings.h" +#include "frontends/alert.h" #include "frontends/Clipboard.h" #include "frontends/Selection.h" @@ -59,17 +68,16 @@ #include using namespace std; +using namespace lyx::support; +using lyx::frontend::Clipboard; namespace lyx { -using support::bformat; -using frontend::Clipboard; - namespace { -typedef std::pair PitPosPair; +typedef pair PitPosPair; -typedef limited_stack > CutStack; +typedef limited_stack > CutStack; CutStack theCuts(10); // persistent selection, cleared until the next selection @@ -81,22 +89,6 @@ 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) - std::swap(c1, c2); - r1 = p.row(i1.idx()); - r2 = p.row(i2.idx()); - if (r1 > r2) - std::swap(r1, r2); -} - - bool checkPastePossible(int index) { return size_t(index) < theCuts.size() && !theCuts[index].first.empty(); @@ -105,12 +97,18 @@ bool checkPastePossible(int index) pair pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, - TextClassPtr textclass, ErrorList & errorlist) + DocumentClass const * const oldDocClass, 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(); + 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 make_pair(PitPosPair(pit, pos), pit)); + ParagraphList & pars = target_inset->paragraphs(); if (parlist.empty()) return make_pair(PitPosPair(pit, pos), pit); @@ -119,48 +117,64 @@ pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, // Make a copy of the CaP paragraphs. ParagraphList insertion = parlist; - TextClassPtr const tc = buffer.params().getTextClassPtr(); + DocumentClass const * const newDocClass = + buffer.params().documentClassPtr(); // 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! - if (pars[pit].inInset() && - (pars[pit].inInset()->lyxCode() == ERT_CODE || - pars[pit].inInset()->lyxCode() == LISTINGS_CODE)) { - for (ParagraphList::size_type i = 0; i < insertion.size(); ++i) { - for (pos_type j = 0; j < insertion[i].size(); ++j) { + InsetCode const code = target_inset->lyxCode(); + if (code == ERT_CODE || code == LISTINGS_CODE) { + 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; } } } } - // If we are in an inset which returns forceDefaultParagraphs, - // set the paragraphs to default - if (cur.inset().forceDefaultParagraphs(cur.idx())) { - LayoutPtr const layout = - buffer.params().getTextClass().defaultLayout(); + // set the paragraphs to plain layout if necessary + if (cur.inset().usePlainLayout()) { + bool forcePlainLayout = cur.inset().forcePlainLayout(); + Layout const & plainLayout = newDocClass->plainLayout(); + Layout const & defaultLayout = newDocClass->defaultLayout(); ParagraphList::iterator const end = insertion.end(); - for (ParagraphList::iterator par = insertion.begin(); - par != end; ++par) - par->layout(layout); + 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(); + 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); insertion.swap(in.paragraphs()); ParagraphList::iterator tmpbuf = insertion.begin(); @@ -188,12 +202,12 @@ pasteSelectionHelper(Cursor & cur, ParagraphList const & parlist, 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) { - if (tmpbuf->isInset(i) && - !pars[pit].insetAllowed(tmpbuf->getInset(i)->lyxCode())) - // do not track deletion of invalid insets - tmpbuf->eraseChar(i--, false); + // do not track deletion of invalid insets + if (Inset * inset = tmpbuf->getInset(i)) + if (!target_inset->insetAllowed(inset->lyxCode())) + tmpbuf->eraseChar(i--, false); } tmpbuf->setChange(Change(buffer.params().trackChanges ? @@ -208,27 +222,141 @@ 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); - - for (; fpit != fend; ++fpit) { - InsetList::const_iterator lit = fpit->insetList().begin(); - InsetList::const_iterator eit = fpit->insetList().end(); + 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, e.g., InsetLabel::updateCommand() is 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->updateCommand(oldname, false); + // We need to update the buffer reference cache. + cur.forceBufferUpdate(); + 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) { + InsetMathHull * mi = itt->asInsetMath()->asHullInset(); + // 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->asRefInset()->getTarget() == oldname) + mi->asRefInset()->changeTarget(newname); + } + } + } + break; + } - for (; lit != eit; ++lit) { - switch (lit->inset->lyxCode()) { - case TABULAR_CODE: { - InsetTabular * it = static_cast(lit->inset); - it->buffer(&buffer); + case LABEL_CODE: { + // check for duplicates + InsetLabel & lab = static_cast(*it); + docstring const oldname = lab.getParam("name"); + lab.updateCommand(oldname, false); + // We need to update the buffer reference cache. + cur.forceBufferUpdate(); + 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) { + InsetMathHull & mi = + static_cast(*itt); + // 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.asRefInset()->getTarget() == oldname) + mi.asRefInset()->changeTarget(newname); + } } + break; + } + + case INCLUDE_CODE: { + InsetInclude & inc = static_cast(*it); + inc.updateCommand(); + // We need to update the list of included files. + cur.forceBufferUpdate(); + break; + } - default: - break; // nothing + 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. + cur.forceBufferUpdate(); + 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; + // FIXME: add an option to add the branch to the master's BranchList. + 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)); + // We need to update the list of branches. + cur.forceBufferUpdate(); + break; + } + + default: + break; // nothing } } insertion.swap(in.paragraphs()); @@ -255,12 +383,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())) { @@ -308,7 +442,9 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, // Separate handling of paragraph break: if (merge && pit != endpit && - (pit + 1 != endpit || pars[pit].hasSameLayout(pars[endpit]))) { + (pit + 1 != endpit + || pars[pit].hasSameLayout(pars[endpit]) + || pars[endpit].size() == endpos)) { if (pit + 1 == endpit) endpos += pars[pit].size(); mergeParagraph(params, pars, pit); @@ -324,30 +460,56 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, } -void putClipboard(ParagraphList const & paragraphs, TextClassPtr textclass, - docstring const & plaintext) +void putClipboard(ParagraphList const & paragraphs, + DocumentClass const * const docclass, docstring const & plaintext) { // 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); - std::ostringstream lyx; - if (buffer.write(lyx)) + // This needs to be static to avoid a memory leak. When a Buffer is + // constructed, it constructs a BufferParams, which in turn constructs + // a DocumentClass, via new, that is never deleted. If we were to go to + // some kind of garbage collection there, or a shared_ptr, then this + // would not be needed. + static Buffer * buffer = theBufferList().newBuffer( + FileName::tempName().absFileName() + "_clipboard.internal"); + buffer->setUnnamed(true); + buffer->paragraphs() = paragraphs; + buffer->inset().setBuffer(*buffer); + buffer->params().setDocumentClass(docclass); + ostringstream lyx; + if (buffer->write(lyx)) theClipboard().put(lyx.str(), plaintext); else theClipboard().put(string(), plaintext); + // Save that memory + buffer->paragraphs().clear(); } -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, DocumentClass const * const 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(); + + LASSERT(0 <= start && start <= pars[startpit].size(), /**/); + LASSERT(0 <= end && end <= pars[endpit].size(), /**/); + LASSERT(startpit != endpit || start <= end, /**/); // Clone the paragraphs within the selection. ParagraphList copy_pars(boost::next(pars.begin(), startpit), @@ -367,19 +529,37 @@ void copySelectionHelper(Buffer const & buf, ParagraphList & pars, 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); + // 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 (text.inset().getLayout().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()); + + + // 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->setBuffer(*static_cast(0)); + it->setInsetOwner(0); + } - cutstack.push(make_pair(copy_pars, tc)); + DocumentClass * d = const_cast(dc); + cutstack.push(make_pair(copy_pars, d)); } } // namespace anon @@ -389,6 +569,22 @@ void copySelectionHelper(Buffer const & buf, ParagraphList & pars, 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()) @@ -399,63 +595,90 @@ docstring grabAndEraseSelection(Cursor & cur) } -void switchBetweenClasses(TextClassPtr const & c1, - TextClassPtr const & c2, 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(DocumentClass const * const oldone, + DocumentClass const * const newone, InsetText & in, ErrorList & errorlist) { errorlist.clear(); - BOOST_ASSERT(!in.paragraphs().empty()); - if (c1 == c2) + LASSERT(!in.paragraphs().empty(), /**/); + if (oldone == newone) return; - TextClass const & tclass1 = *c1; - TextClass const & tclass2 = *c2; + DocumentClass const & oldtc = *oldone; + DocumentClass const & newtc = *newone; // layouts ParIterator end = par_iterator_end(in); for (ParIterator it = par_iterator_begin(in); it != end; ++it) { - docstring const name = it->layout()->name(); - bool hasLayout = tclass2.hasLayout(name); + 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. + newtc.addLayoutIfNeeded(name); - if (hasLayout) - it->layout(tclass2[name]); + if (in.usePlainLayout()) + it->setLayout(newtc.plainLayout()); else - it->layout(tclass2.defaultLayout()); - - if (!hasLayout && name != tclass1.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(tclass1.name()), from_utf8(tclass2.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 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) + if (it->lyxCode() != FLEX_CODE) // FIXME: Should we verify all InsetCollapsable? continue; - docstring const name = inset->name(); - InsetLayout const & il = tclass2.insetlayout(name); - inset->setLayout(il); - if (il.labelstring != from_utf8("UNDEFINED")) + docstring const & n = newone->insetLayout(it->name()).name(); + bool const is_undefined = n.empty() || + n == DocumentClass::plainInsetLayout().name(); + if (!is_undefined) continue; - // The flex inset is undefined in tclass2 + // 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"), - name, from_utf8(tclass1.name()), - from_utf8(tclass2.name())); + it->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"), @@ -464,9 +687,11 @@ void switchBetweenClasses(TextClassPtr const & c1, } -std::vector const availableSelections(Buffer const & buffer) +vector availableSelections(Buffer const * buf) { vector selList; + if (!buf) + return selList; CutStack::const_iterator cit = theCuts.begin(); CutStack::const_iterator end = theCuts.end(); @@ -478,7 +703,10 @@ std::vector const availableSelections(Buffer const & buffer) ParagraphList::const_iterator pit = pars.begin(); ParagraphList::const_iterator pend = pars.end(); for (; pit != pend; ++pit) { - asciiSel += pit->asString(buffer, false); + Paragraph par(*pit, 0, 26); + // adapt paragraph to current buffer. + par.setBuffer(const_cast(*buf)); + asciiSel += par.asString(AS_STR_INSETS); if (asciiSel.size() > 25) { asciiSel.replace(22, docstring::npos, from_ascii("...")); @@ -510,7 +738,7 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) if (cur.inTexted()) { Text * text = cur.text(); - BOOST_ASSERT(text); + LASSERT(text, /**/); saveSelection(cur); @@ -521,19 +749,22 @@ 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.getTextClassPtr(), theCuts); + bp.documentClassPtr(), theCuts); // Stuff what we got on the clipboard. // Even if there is no selection. putClipboard(theCuts[0].first, theCuts[0].second, cur.selectionAsString(true)); } + if (begpit != endpit) + cur.screenUpdateFlags(Update::Force | Update::FitCursor); + boost::tie(endpit, endpos) = eraseSelectionHelper(bp, text->paragraphs(), @@ -553,7 +784,7 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) // need a valid cursor. (Lgb) cur.clearSelection(); - updateLabels(cur.buffer()); + cur.forceBufferUpdate(); // tell tabular that a recent copy happened dirtyTabularStack(false); @@ -576,15 +807,29 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) } -void copySelection(Cursor & cur) +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()); + par.insertInset(0, inset, 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()) @@ -596,7 +841,7 @@ void copySelectionToStack(Cursor & cur, CutStack & cutstack) if (cur.inTexted()) { Text * text = cur.text(); - BOOST_ASSERT(text); + LASSERT(text, /**/); // ok we have a selection. This is always between cur.selBegin() // and sel_end cursor @@ -609,21 +854,26 @@ void copySelectionToStack(Cursor & cur, CutStack & cutstack) (par != cur.selEnd().pit() || pos < cur.selEnd().pos())) ++pos; - copySelectionHelper(cur.buffer(), pars, par, cur.selEnd().pit(), + copySelectionHelper(*cur.buffer(), *text, par, cur.selEnd().pit(), pos, cur.selEnd().pos(), - cur.buffer().params().getTextClassPtr(), cutstack); - dirtyTabularStack(false); + 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.layout(bp.getTextClass().defaultLayout()); + BufferParams const & bp = cur.buffer()->params(); + // FIXME This should be the plain layout...right? + par.setLayout(bp.documentClass().plainLayout()); par.insert(0, grabSelection(cur), Font(), Change(Change::UNCHANGED)); pars.push_back(par); - cutstack.push(make_pair(pars, bp.getTextClassPtr())); + cutstack.push(make_pair(pars, bp.documentClassPtr())); } } @@ -637,7 +887,7 @@ void copySelectionToStack() } -void copySelection(Cursor & cur, docstring const & plaintext) +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 @@ -646,11 +896,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.layout(bp.getTextClass().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.getTextClassPtr())); + theCuts.push(make_pair(pars, bp.documentClassPtr())); } else { copySelectionToStack(cur, theCuts); } @@ -660,7 +910,7 @@ 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 @@ -668,7 +918,7 @@ void saveSelection(Cursor & cur) 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); } } @@ -692,34 +942,33 @@ void clearCutStack() } -docstring getSelection(Buffer const & buf, size_t sel_index) +docstring selection(size_t sel_index) { return sel_index < theCuts.size() - ? theCuts[sel_index].first.back().asString(buf, false) + ? theCuts[sel_index].first.back().asString(AS_STR_INSETS | AS_STR_NEWLINES) : docstring(); } void pasteParagraphList(Cursor & cur, ParagraphList const & parlist, - TextClassPtr textclass, ErrorList & errorList) + DocumentClass const * const docclass, ErrorList & errorList) { if (cur.inTexted()) { Text * text = cur.text(); - BOOST_ASSERT(text); + LASSERT(text, /**/); pit_type endpit; PitPosPair ppp; boost::tie(ppp, endpit) = - pasteSelectionHelper(cur, parlist, - textclass, errorList); - updateLabels(cur.buffer()); + pasteSelectionHelper(cur, parlist, docclass, errorList); + cur.forceBufferUpdate(); cur.clearSelection(); text->setCursor(cur, ppp.first, ppp.second); } // mathed is handled in InsetMathNest/InsetMathGrid - BOOST_ASSERT(!cur.inMathed()); + LASSERT(!cur.inMathed(), /**/); } @@ -736,7 +985,7 @@ void pasteFromStack(Cursor & cur, ErrorList & errorList, size_t sel_index) } -void pasteClipboard(Cursor & cur, ErrorList & errorList, bool asParagraphs) +void pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs) { // Use internal clipboard if it is the most recent one if (theClipboard().isInternal()) { @@ -755,7 +1004,7 @@ void pasteClipboard(Cursor & cur, ErrorList & errorList, bool asParagraphs) if (buffer.readString(lyx)) { cur.recordUndo(); pasteParagraphList(cur, buffer.paragraphs(), - buffer.params().getTextClassPtr(), errorList); + buffer.params().documentClassPtr(), errorList); cur.setSelection(); return; } @@ -768,9 +1017,29 @@ void pasteClipboard(Cursor & cur, ErrorList & errorList, bool asParagraphs) return; cur.recordUndo(); 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) +{ + LASSERT(theClipboard().hasGraphicsContents(preferedType), /**/); + + // get picture from clipboard + FileName filename = theClipboard().getAsGraphics(cur, preferedType); + if (filename.empty()) + return; + + // create inset for graphic + InsetGraphics * inset = new InsetGraphics(cur.buffer()); + InsetGraphicsParams params; + params.filename = support::DocFileName(filename.absFileName()); + inset->setParams(params); + cur.recordUndo(); + cur.insert(inset); } @@ -789,9 +1058,9 @@ void replaceSelectionWithString(Cursor & cur, docstring const & str, bool backwa 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(); @@ -799,7 +1068,7 @@ 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().trackChanges); // Cut the selection cutSelection(cur, true, false); @@ -868,7 +1137,7 @@ void selClearOrDel(Cursor & cur) if (lyxrc.auto_region_delete) selDel(cur); else - cur.selection() = false; + cur.setSelection(false); } @@ -877,9 +1146,11 @@ docstring grabSelection(Cursor const & cur) if (!cur.selection()) return docstring(); - // FIXME: What is wrong with the following? #if 0 - std::ostringstream os; + // 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()) os << asString(dit.cell()); @@ -892,7 +1163,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"); } @@ -934,5 +1206,4 @@ bool tabularStackDirty() } // namespace cap - } // namespace lyx