X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCutAndPaste.h;h=d7fec67c176a930b5133531eac25721b75f4134f;hb=4ed0312c51704780af1c452d3a82a84171b3725a;hp=dbb7a297bbfa9229389da534f4c34069271e60be;hpb=e48e2aa2cf03f662f927155a6c70794f08d54122;p=lyx.git diff --git a/src/CutAndPaste.h b/src/CutAndPaste.h index dbb7a297bb..d7fec67c17 100644 --- a/src/CutAndPaste.h +++ b/src/CutAndPaste.h @@ -1,60 +1,188 @@ // -*- C++ -*- -/* This file is part of - * ====================================================== +/** + * \file CutAndPaste.h + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Jürgen Vigna + * \author Lars Gullik Bjønnes + * \author Alfredo Braunstein * - * Copyright 1995-2001 the LyX Team. - * - * ====================================================== */ + * Full author contact details are available in file CREDITS. + */ #ifndef CUTANDPASTE_H #define CUTANDPASTE_H +#include "Author.h" +#include "DocumentClassPtr.h" + +#include "support/strfwd.h" #include "support/types.h" -#include "ParagraphList.h" -class Paragraph; -class BufferParams; -class LyXTextClass; +#include "frontends/Clipboard.h" +#include + + +namespace lyx { + +class Buffer; +class ErrorList; +class Inset; +class InsetText; +class Cursor; +class CursorData; +class CursorSlice; +class ParagraphList; + +namespace cap { + +/// Get all elements of the cut buffer in plain text format. +std::vector availableSelections(Buffer const *); +/// Get the number of available elements in the cut buffer. +size_type numberOfSelections(); /// -namespace CutAndPaste { -/// -PitPosPair cutSelection(ParagraphList & pars, - ParagraphList::iterator startpit, - ParagraphList::iterator endpit, - int start, int end, lyx::textclass_type tc, - bool doclear = false); -/// -PitPosPair eraseSelection(ParagraphList & pars, - ParagraphList::iterator startpit, - ParagraphList::iterator endpit, - int start, int end, bool doclear = false); -/// -bool copySelection(ParagraphList::iterator startpit, - ParagraphList::iterator endpit, - int start, int end, lyx::textclass_type tc); -/// -std::pair -pasteSelection(ParagraphList & pars, - ParagraphList::iterator pit, int pos, - lyx::textclass_type tc); +typedef std::pair DocInfoPair; +/** + * Get the sel_index-th element of the cut buffer in plain text format + * or, if \param for_math is true, in a format suitable for mathed. + */ +docstring selection(size_t sel_index, DocInfoPair docinfo, bool for_math = false); + +/** + * Replace using the font of the first selected character and select + * the new string. Does handle undo. + */ +void replaceSelectionWithString(Cursor & cur, docstring const & str); +/// If a selection exists, delete it without pushing it to the cut buffer. +/// Does handle undo. +void replaceSelection(Cursor & cur); +/** + * Cut the current selection and possibly push it to the cut buffer and + * system clipboard. + * Does handle undo. Calls saveSelection. + * \param doclear If this is true: Delete leading spaces in paragraphs before + * they get merged. + * \param realcut If this is true: Push the selection to the cut buffer and + * system clipboard. Set this to false to only delete the + * selection. + */ +void cutSelection(Cursor & cur, bool realcut = true); +/// Like cutSelection, but only put to temporary cut buffer +void cutSelectionToTemp(Cursor & cur, bool realcut = true); + +/// Push the current selection to the cut buffer and the system clipboard. +void copySelection(Cursor const & cur); +/// Like copySelection, but only put to temporary cut buffer +void copySelectionToTemp(Cursor const & cur); /// -int nrOfParagraphs(); - -/** needed to switch between different classes this works - for a list of paragraphs beginning with the specified par - return value is the number of wrong conversions -*/ -int SwitchLayoutsBetweenClasses(lyx::textclass_type c1, - lyx::textclass_type c2, - Paragraph * par, - BufferParams const & bparams); +void copyInset(Cursor const & cur, Inset * inset, docstring const & plaintext); /// -bool checkPastePossible(); +void copyInsetToTemp(Cursor const & cur, Inset * inset); +/** + * Push the current selection to the cut buffer and the system clipboard. + * \param plaintext plain text version of the selection for the system + * clipboard + */ +void copySelection(Cursor const & cur, docstring const & plaintext); +/// Push the selection buffer to the cut buffer. +void copySelectionToStack(); +/// Store the current selection in the internal selection buffer +void saveSelection(Cursor const & cur); +/// Is a selection available in our selection buffer? +bool selection(); +/// Clear our selection buffer +void clearSelection(); +/// Clear our cut stack. +void clearCutStack(); +/// Paste the current selection at \p cur +/// Does handle undo. Does only work in text, not mathed. +void pasteSelection(Cursor & cur, ErrorList &); +/// Replace the current selection with the clipboard contents as text +/// (internal or external: which is newer). +/// Does handle undo. Does only work in text, not mathed. +/// \p asParagraphs is only considered if plain text is pasted. +bool pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs, + frontend::Clipboard::TextType preferedType = frontend::Clipboard::LyXOrPlainTextType); +/// Replace the current selection with the clipboard contents as graphic. +/// Does handle undo. Does only work in text, not mathed. +void pasteClipboardGraphics(Cursor & cur, ErrorList & errorList, + frontend::Clipboard::GraphicsType preferedType = frontend::Clipboard::AnyGraphicsType); +/// Replace the current selection with cut buffer \c sel_index +/// Does handle undo. Does only work in text, not mathed. +bool pasteFromStack(Cursor & cur, ErrorList & errorList, size_t sel_index); +/// Replace the current selection with temporary cut buffer +/// Does handle undo. Does only work in text, not mathed. +bool pasteFromTemp(Cursor & cur, ErrorList & errorList); +/// Paste the clipboard as simple text, removing any formatting +void pasteSimpleText(Cursor & cur, bool asParagraphs); + +// What to do with unknown branches? +enum BranchAction { + BRANCH_ADD, // add the branch unconditionally + BRANCH_IGNORE, // leave the branch undefined + BRANCH_ASK // ask the user whether the branch should be added +}; +/// Paste the paragraph list \p parlist at the position given by \p cur. +/// Does not handle undo. Does only work in text, not mathed. +void pasteParagraphList(Cursor & cur, ParagraphList const & parlist, + DocumentClassConstPtr textclass, AuthorList const & authors, + ErrorList & errorList, + BranchAction branchAction = BRANCH_ASK); + + +/** Needed to switch between different classes. This works + * for a list of paragraphs beginning with the specified par. + * It changes layouts and character styles. Errors are reported + * in the passed ErrorList. + */ +void switchBetweenClasses(DocumentClassConstPtr oldone, + DocumentClassConstPtr newone, InsetText & in, ErrorList & el); +/// Same but without error reporting. +void switchBetweenClasses(DocumentClassConstPtr oldone, + DocumentClassConstPtr newone, InsetText & in); -} // end of CutAndPaste +/// Get the current selection as a string. Does not change the selection. +/// Does only work if the whole selection is in mathed. +docstring grabSelection(CursorData const & cur); +/// Erase the current selection. +/// Does not handle undo. Does only work if the whole selection is in mathed. +/// Calls saveSelection. +void eraseSelection(Cursor & cur); +/// Reduce the selected text in mathed to only one cell. If it spans multiple +/// cells, the cursor is moved the end of the current cell and the anchor to the +/// start. If the selection is inside only one cell, nothing is done. Return +/// true if the selection now does not span multiple cells anymore. +bool reduceSelectionToOneCell(CursorData & cur); +/// Returns true if multiple cells are selected in mathed. +bool multipleCellsSelected(CursorData const & cur); +/// Erase the selection and return it as a string. +/// Does not handle undo. Does only work if the whole selection is in mathed. +docstring grabAndEraseSelection(Cursor & cur); +// other selection methods +/// Erase the selection if one exists. +/// Does not handle undo. Does only work if the whole selection is in mathed. +void selDel(Cursor & cur); +/// Clear or delete the selection if one exists, depending on lyxrc setting. +/// Does not handle undo. Does only work if the whole selection is in mathed. +void selClearOrDel(Cursor & cur); +/// Calculate rectangular region of cell between \c i1 and \c i2. +void region(CursorSlice const & i1, CursorSlice const & i2, + row_type & r1, row_type & r2, + col_type & c1, col_type & c2); +/** Tabular has its own paste stack for multiple cells + * but it needs to know whether there is a more recent + * ordinary paste. Therefore which one is newer. + */ +//FIXME: this is a workaround for bug 1919. Replace this by +//an all-for-one-paste mechanism in 1.7 +/// store whether tabular or ordinary paste stack is newer +void dirtyTabularStack(bool b); +/// is the tabular paste stack newer than the ordinary one? +bool tabularStackDirty(); +} // namespace cap +} // namespace lyx #endif