X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCutAndPaste.cpp;h=1f4633008774d4a66f043b933d9cc7fc8cb5b1c8;hb=02e59530b15d223c0978ecacfb7379f7bec986f4;hp=fb7ad88b5a5fe58eb54e9ceba391211f376cb414;hpb=9c9abe843fac080bf2c7d1172ba49b6233d07e39;p=lyx.git diff --git a/src/CutAndPaste.cpp b/src/CutAndPaste.cpp index fb7ad88b5a..1f46330087 100644 --- a/src/CutAndPaste.cpp +++ b/src/CutAndPaste.cpp @@ -23,6 +23,7 @@ #include "BufferView.h" #include "Changes.h" #include "Cursor.h" +#include "Encoding.h" #include "ErrorList.h" #include "FuncCode.h" #include "FuncRequest.h" @@ -56,6 +57,7 @@ #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" @@ -78,7 +80,7 @@ namespace { typedef pair PitPosPair; -typedef limited_stack > CutStack; +typedef limited_stack > CutStack; CutStack theCuts(10); // persistent selection, cleared until the next selection @@ -96,30 +98,41 @@ bool checkPastePossible(int index) } -pair -pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, - DocumentClass const * const oldDocClass, ErrorList & errorlist) +struct PasteReturnValue { + PasteReturnValue(pit_type r_par, pos_type r_pos, bool r_nu) : + par(r_par), pos(r_pos), needupdate(r_nu) + {} + + pit_type par; + pos_type pos; + bool needupdate; +}; + +PasteReturnValue +pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, + DocumentClassConstPtr oldDocClass, Buffer * tmpbuffer, + ErrorList & errorlist) { Buffer const & buffer = *cur.buffer(); pit_type pit = cur.pit(); pos_type pos = cur.pos(); + bool need_update = false; 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)); + LASSERT(target_inset, return PasteReturnValue(pit, pos, need_update)); ParagraphList & pars = target_inset->paragraphs(); if (parlist.empty()) - return make_pair(PitPosPair(pit, pos), pit); + return PasteReturnValue(pit, pos, need_update); BOOST_ASSERT (pos <= pars[pit].size()); // Make a copy of the CaP paragraphs. ParagraphList insertion = parlist; - DocumentClass const * const newDocClass = - buffer.params().documentClassPtr(); + DocumentClassConstPtr 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. @@ -227,7 +240,7 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, 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 + // since some inset might going to try to access // the buffer() member. it->setBuffer(const_cast(buffer)); switch (it->lyxCode()) { @@ -241,9 +254,9 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, continue; InsetLabel * lab = labels[i]; docstring const oldname = lab->getParam("name"); - lab->updateCommand(oldname, false); + lab->updateLabel(oldname); // We need to update the buffer reference cache. - cur.forceBufferUpdate(); + need_update = true; docstring const newname = lab->getParam("name"); if (oldname == newname) continue; @@ -255,13 +268,13 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, if (ref->getParam("reference") == oldname) ref->setParam("reference", newname); } else if (itt->lyxCode() == MATH_REF_CODE) { - InsetMathHull * mi = itt->asInsetMath()->asHullInset(); + 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->asRefInset()->getTarget() == oldname) - mi->asRefInset()->changeTarget(newname); + if (mi->getTarget() == oldname) + mi->changeTarget(newname); } } } @@ -272,9 +285,9 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, // check for duplicates InsetLabel & lab = static_cast(*it); docstring const oldname = lab.getParam("name"); - lab.updateCommand(oldname, false); + lab.updateLabel(oldname); // We need to update the buffer reference cache. - cur.forceBufferUpdate(); + need_update = true; docstring const newname = lab.getParam("name"); if (oldname == newname) break; @@ -285,14 +298,13 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, if (ref.getParam("reference") == oldname) ref.setParam("reference", newname); } else if (itt->lyxCode() == MATH_REF_CODE) { - InsetMathHull & mi = - static_cast(*itt); + 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.asRefInset()->getTarget() == oldname) - mi.asRefInset()->changeTarget(newname); + mi->setBuffer(const_cast(buffer)); + if (mi->getTarget() == oldname) + mi->changeTarget(newname); } } break; @@ -302,7 +314,7 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, InsetInclude & inc = static_cast(*it); inc.updateCommand(); // We need to update the list of included files. - cur.forceBufferUpdate(); + need_update = true; break; } @@ -312,7 +324,7 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, docstring const oldkey = bib.getParam("key"); bib.updateCommand(oldkey, false); // We need to update the buffer reference cache. - cur.forceBufferUpdate(); + need_update = true; docstring const newkey = bib.getParam("key"); if (oldkey == newkey) break; @@ -341,17 +353,23 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, || (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( + if (tmpbuffer) { + // This is for a temporary buffer, so simply create the branch. + // Must not use lyx::dispatch(), since tmpbuffer has no view. + DispatchResult dr; + tmpbuffer->dispatch(FuncRequest(LFUN_BRANCH_ADD, name), dr); + } else { + 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"), + if (frontend::Alert::prompt(_("Unknown branch"), text, 0, 1, _("&Add"), _("&Don't Add")) != 0) - break; - lyx::dispatch(FuncRequest(LFUN_BRANCH_ADD, name)); + break; + lyx::dispatch(FuncRequest(LFUN_BRANCH_ADD, name)); + } // We need to update the list of branches. - cur.forceBufferUpdate(); + need_update = true; break; } @@ -412,7 +430,7 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist, } } - return make_pair(PitPosPair(pit, pos), last_paste + 1); + return PasteReturnValue(pit, pos, need_update); } @@ -461,28 +479,66 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, void putClipboard(ParagraphList const & paragraphs, - DocumentClass const * const docclass, docstring const & plaintext) + DocumentClassConstPtr docclass, docstring const & plaintext) { - // For some strange reason gcc 3.2 and 3.3 do not accept - // Buffer buffer(string(), false); - // 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); + // 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 Buffer * staticbuffer = theBufferList().newInternalBuffer( + FileName::tempName("clipboard.internal").absFileName()); + + // These two things only really need doing the first time. + staticbuffer->setUnnamed(true); + staticbuffer->inset().setBuffer(*staticbuffer); + + // 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); + + // This needs doing every time. buffer->params().setDocumentClass(docclass); - ostringstream lyx; - if (buffer->write(lyx)) - theClipboard().put(lyx.str(), plaintext); - else - theClipboard().put(string(), plaintext); + + // 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, buffer, el); + + // 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; + buffer->writeLyXHTMLSource(oshtml, runparams, Buffer::FullSource); + + theClipboard().put(lyx, oshtml.str(), plaintext); + } + // Save that memory - buffer->paragraphs().clear(); + delete buffer; } @@ -503,13 +559,16 @@ static bool isFullyDeleted(ParagraphList const & pars) void copySelectionHelper(Buffer const & buf, Text const & text, pit_type startpit, pit_type endpit, - int start, int end, DocumentClass const * const dc, CutStack & cutstack) + int start, int end, DocumentClassConstPtr dc, CutStack & cutstack) { ParagraphList const & pars = text.paragraphs(); - LASSERT(0 <= start && start <= pars[startpit].size(), /**/); - LASSERT(0 <= end && end <= pars[endpit].size(), /**/); - LASSERT(startpit != endpit || start <= end, /**/); + // 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), @@ -528,7 +587,7 @@ void copySelectionHelper(Buffer const & buf, Text const & text, ParagraphList::iterator it = copy_pars.begin(); ParagraphList::iterator it_end = copy_pars.end(); - for (; it != it_end; it++) { + 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 @@ -553,13 +612,12 @@ void copySelectionHelper(Buffer const & buf, Text const & text, // 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++) { + for (; it != it_end; ++it) { it->setBuffer(*static_cast(0)); it->setInsetOwner(0); } - DocumentClass * d = const_cast(dc); - cutstack.push(make_pair(copy_pars, d)); + cutstack.push(make_pair(copy_pars, dc)); } } // namespace anon @@ -634,12 +692,12 @@ bool multipleCellsSelected(Cursor const & cur) } -void switchBetweenClasses(DocumentClass const * const oldone, - DocumentClass const * const newone, InsetText & in, ErrorList & errorlist) +void switchBetweenClasses(DocumentClassConstPtr oldone, + DocumentClassConstPtr newone, InsetText & in, ErrorList & errorlist) { errorlist.clear(); - LASSERT(!in.paragraphs().empty(), /**/); + LBUFERR(!in.paragraphs().empty()); if (oldone == newone) return; @@ -647,13 +705,25 @@ void switchBetweenClasses(DocumentClass const * const 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) { + // 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. - newtc.addLayoutIfNeeded(name); + 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->size())); + } if (in.usePlainLayout()) it->setLayout(newtc.plainLayout()); @@ -667,7 +737,9 @@ void switchBetweenClasses(DocumentClass const * const oldone, if (it->lyxCode() != FLEX_CODE) // FIXME: Should we verify all InsetCollapsable? continue; - docstring const & n = newone->insetLayout(it->name()).name(); + + docstring const layoutName = it->layoutName(); + docstring const & n = newone->insetLayout(layoutName).name(); bool const is_undefined = n.empty() || n == DocumentClass::plainInsetLayout().name(); if (!is_undefined) @@ -679,12 +751,11 @@ void switchBetweenClasses(DocumentClass const * const oldone, docstring s; if (oldname == newname) s = bformat(_("Flex inset %1$s is undefined after " - "reloading `%2$s' layout."), - it->name(), oldname); + "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'."), - it->name(), oldname, newname); + layoutName, oldname, newname); // To warn the user that something had to be done. errorlist.push_back(ErrorItem( _("Undefined flex inset"), @@ -744,7 +815,7 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) if (cur.inTexted()) { Text * text = cur.text(); - LASSERT(text, /**/); + LBUFERR(text); saveSelection(cur); @@ -838,6 +909,7 @@ void copyInset(Cursor const & cur, Inset * inset, docstring const & plaintext) putClipboard(theCuts[0].first, theCuts[0].second, plaintext); } + namespace { void copySelectionToStack(Cursor const & cur, CutStack & cutstack) @@ -852,7 +924,7 @@ void copySelectionToStack(Cursor const & cur, CutStack & cutstack) if (cur.inTexted()) { Text * text = cur.text(); - LASSERT(text, /**/); + LBUFERR(text); // ok we have a selection. This is always between cur.selBegin() // and sel_end cursor @@ -962,24 +1034,21 @@ docstring selection(size_t sel_index) void pasteParagraphList(Cursor & cur, ParagraphList const & parlist, - DocumentClass const * const docclass, ErrorList & errorList) + DocumentClassConstPtr docclass, ErrorList & errorList) { if (cur.inTexted()) { Text * text = cur.text(); - LASSERT(text, /**/); - - pit_type endpit; - PitPosPair ppp; + LBUFERR(text); - boost::tie(ppp, endpit) = - pasteSelectionHelper(cur, parlist, docclass, errorList); + PasteReturnValue prv = + pasteSelectionHelper(cur, parlist, docclass, 0, errorList); cur.forceBufferUpdate(); cur.clearSelection(); - text->setCursor(cur, ppp.first, ppp.second); + text->setCursor(cur, prv.par, prv.pos); } // mathed is handled in InsetMathNest/InsetMathGrid - LASSERT(!cur.inMathed(), /**/); + LATTEST(!cur.inMathed()); } @@ -992,20 +1061,24 @@ void pasteFromStack(Cursor & cur, ErrorList & errorList, size_t sel_index) cur.recordUndo(); pasteParagraphList(cur, theCuts[sel_index].first, theCuts[sel_index].second, errorList); - cur.setSelection(); } -void pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs) +void pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs, + Clipboard::TextType type) { // Use internal clipboard if it is the most recent one + // This overrides asParagraphs and type on purpose! if (theClipboard().isInternal()) { pasteFromStack(cur, errorList, 0); return; } // 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 @@ -1016,14 +1089,47 @@ void pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs) cur.recordUndo(); pasteParagraphList(cur, buffer.paragraphs(), buffer.params().documentClassPtr(), errorList); - cur.setSelection(); return; } } } + // Then try TeX and HTML + Clipboard::TextType types[2] = {Clipboard::HtmlTextType, Clipboard::LaTeXTextType}; + string names[2] = {"html", "latex"}; + 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); + if (buffer.importString(names[i], text, errorList)) { + cur.recordUndo(); + pasteParagraphList(cur, buffer.paragraphs(), + buffer.params().documentClassPtr(), errorList); + return; + } + } + } + } + // Then try plain text - docstring const text = theClipboard().getAsText(); + docstring const text = theClipboard().getAsText(Clipboard::PlainTextType); if (text.empty()) return; cur.recordUndo(); @@ -1034,10 +1140,43 @@ void pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs) } +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, true, false); + if (asParagraphs) + cur.text()->insertStringAsParagraphs(cur, text, cur.current_font); + else + cur.text()->insertStringAsLines(cur, text, cur.current_font); +} + + void pasteClipboardGraphics(Cursor & cur, ErrorList & /* errorList */, Clipboard::GraphicsType preferedType) { - LASSERT(theClipboard().hasGraphicsContents(preferedType), /**/); + LASSERT(theClipboard().hasGraphicsContents(preferedType), return); // get picture from clipboard FileName filename = theClipboard().getAsGraphics(cur, preferedType); @@ -1064,7 +1203,7 @@ 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(); @@ -1083,13 +1222,6 @@ void replaceSelectionWithString(Cursor & cur, docstring const & str, bool backwa // 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()); }