anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-09-20 06:49:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

partial fix for cut and paste

Browse Source 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@8658 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
André Pönitz 2004-04-18 07:32:34 +00:00
parent 7b54b9ca42
commit ba0a69bcd9
6 changed files with 457 additions and 454 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

699
src/CutAndPaste.C
View File

@ -19,8 +19,12 @@
#include "bufferparams.h"
#include "BufferView.h"
#include "cursor.h"
#include "debug.h"
#include "errorlist.h"
#include "funcrequest.h"
#include "gettext.h"
#include "lfuns.h"
#include "lyxrc.h"
#include "lyxtext.h"
#include "lyxtextclasslist.h"
#include "paragraph.h"
@ -32,6 +36,10 @@
#include "insets/insettabular.h"
#include "mathed/math_data.h"
#include "mathed/math_inset.h"
#include "mathed/math_support.h"
#include "support/lstrings.h"
#include <boost/tuple/tuple.hpp>
@ -42,6 +50,7 @@ using lyx::textclass_type;
using lyx::support::bformat;
using std::endl;
using std::for_each;
using std::make_pair;
using std::pair;
@ -55,7 +64,7 @@ typedef std::pair<lyx::par_type, int> PitPosPair;
typedef limited_stack<pair<ParagraphList, textclass_type> > CutStack;
CutStack cuts(10);
CutStack theCuts(10);
struct resetOwnerAndChanges : public std::unary_function<Paragraph, void> {
void operator()(Paragraph & p) const {
@ -64,207 +73,48 @@ struct resetOwnerAndChanges : public std::unary_function<Paragraph, void> {
}
};
} // namespace anon
namespace lyx {
namespace cap {
int SwitchLayoutsBetweenClasses(textclass_type c1, textclass_type c2,
ParagraphList & pars, ErrorList & errorlist)
void region(CursorSlice const & i1, CursorSlice const & i2,
InsetBase::row_type & r1, InsetBase::row_type & r2,
InsetBase::col_type & c1, InsetBase::col_type & c2)
{
BOOST_ASSERT(!pars.empty());
int ret = 0;
if (c1 == c2)
return ret;
LyXTextClass const & tclass1 = textclasslist[c1];
LyXTextClass const & tclass2 = textclasslist[c2];
InsetText in;
std::swap(in.paragraphs(), pars);
ParIterator end = par_iterator_end(in);
for (ParIterator it = par_iterator_begin(in); it != end; ++it) {
string const name = it->layout()->name();
bool hasLayout = tclass2.hasLayout(name);
if (hasLayout)
it->layout(tclass2[name]);
else
it->layout(tclass2.defaultLayout());
if (!hasLayout && name != tclass1.defaultLayoutName()) {
++ret;
string 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(), tclass1.name(), tclass2.name());
// To warn the user that something had to be done.
errorlist.push_back(ErrorItem("Changed Layout", s,
it->id(), 0,
it->size()));
}
}
std::swap(in.paragraphs(), pars);
return ret;
InsetBase & 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);
}
std::vector<string> const availableSelections(Buffer const & buffer)
bool checkPastePossible(int index)
{
vector<string> selList;
CutStack::const_iterator cit = cuts.begin();
CutStack::const_iterator end = cuts.end();
for (; cit != end; ++cit) {
// we do not use cit-> here because gcc 2.9x does not
// like it (JMarc)
ParagraphList const & pars = (*cit).first;
string asciiSel;
ParagraphList::const_iterator pit = pars.begin();
ParagraphList::const_iterator pend = pars.end();
for (; pit != pend; ++pit) {
asciiSel += pit->asString(buffer, false);
if (asciiSel.size() > 25) {
asciiSel.replace(22, string::npos, "...");
break;
}
}
selList.push_back(asciiSel);
}
return selList;
}
PitPosPair eraseSelection(BufferParams const & params, ParagraphList & pars,
par_type startpit, par_type endpit,
int startpos, int endpos, bool doclear)
{
if (startpit == par_type(pars.size()) ||
(startpos > pars[startpit].size()))
return PitPosPair(endpit, endpos);
if (endpit == par_type(pars.size()) ||
startpit == endpit) {
endpos -= pars[startpit].erase(startpos, endpos);
return PitPosPair(endpit, endpos);
}
// clear end/begin fragments of the first/last par in selection
bool all_erased = true;
pars[startpit].erase(startpos, pars[startpit].size());
if (pars[startpit].size() != startpos)
all_erased = false;
endpos -= pars[endpit].erase(0, endpos);
if (endpos != 0)
all_erased = false;
// Loop through the deleted pars if any, erasing as needed
for (par_type pit = startpit + 1; pit != endpit;) {
// "erase" the contents of the par
pars[pit].erase(0, pars[pit].size());
if (!pars[pit].size()) {
// remove the par if it's now empty
pars.erase(pars.begin() + pit);
--endpit;
} else {
++pit;
all_erased = false;
}
}
#if 0 // FIXME: why for cut but not copy ?
// the cut selection should begin with standard layout
if (realcut) {
buf->params().clear();
buf->bibkey = 0;
buf->layout(textclasslist[buffer->params.textclass].defaultLayoutName());
}
#endif
if (startpit + 1 == par_type(pars.size()))
return PitPosPair(endpit, endpos);
if (doclear) {
pars[startpit + 1].stripLeadingSpaces();
}
// paste the paragraphs again, if possible
if (all_erased &&
(pars[startpit].hasSameLayout(pars[startpit + 1]) ||
pars[startpit + 1].empty())) {
mergeParagraph(params, pars, startpit);
// this because endpar gets deleted here!
endpit = startpit;
endpos = startpos;
}
return PitPosPair(endpit, endpos);
}
bool copySelection(ParagraphList & pars,
par_type startpit, par_type endpit,
int start, int end, textclass_type tc)
{
BOOST_ASSERT(0 <= start && start <= pars[startpit].size());
BOOST_ASSERT(0 <= end && end <= pars[endpit].size());
BOOST_ASSERT(startpit != endpit || start <= end);
// Clone the paragraphs within the selection.
ParagraphList paragraphs(pars.begin() + startpit, pars.begin() + endpit + 1);
for_each(paragraphs.begin(), paragraphs.end(), resetOwnerAndChanges());
// Cut out the end of the last paragraph.
Paragraph & back = paragraphs.back();
back.erase(end, back.size());
// Cut out the begin of the first paragraph
Paragraph & front = paragraphs.front();
front.erase(0, start);
cuts.push(make_pair(paragraphs, tc));
return true;
}
PitPosPair cutSelection(BufferParams const & params, ParagraphList & pars,
par_type startpit, par_type endpit,
int startpos, int endpos, textclass_type tc, bool doclear)
{
copySelection(pars, startpit, endpit, startpos, endpos, tc);
return eraseSelection(params, pars, startpit, endpit, startpos,
endpos, doclear);
return size_t(index) < theCuts.size() && !theCuts[index].first.empty();
}
pair<PitPosPair, par_type>
pasteSelection(Buffer const & buffer, ParagraphList & pars,
pasteSelectionHelper(Buffer const & buffer, ParagraphList & pars,
par_type pit, int pos,
textclass_type tc, size_t cut_index, ErrorList & errorlist)
{
if (!checkPastePossible())
if (!checkPastePossible(cut_index))
return make_pair(PitPosPair(pit, pos), pit);
BOOST_ASSERT (pos <= pars[pit].size());
// Make a copy of the CaP paragraphs.
ParagraphList insertion = cuts[cut_index].first;
textclass_type const textclass = cuts[cut_index].second;
ParagraphList insertion = theCuts[cut_index].first;
textclass_type const textclass = theCuts[cut_index].second;
// Now remove all out of the pars which is NOT allowed in the
// new environment and set also another font if that is required.
// Make sure there is no class difference.
SwitchLayoutsBetweenClasses(textclass, tc, insertion,
lyx::cap::SwitchLayoutsBetweenClasses(textclass, tc, insertion,
errorlist);
ParagraphList::iterator tmpbuf = insertion.begin();
@ -368,88 +218,278 @@ pasteSelection(Buffer const & buffer, ParagraphList & pars,
}
pair<PitPosPair, par_type>
pasteSelection(Buffer const & buffer, ParagraphList & pars,
par_type pit, int pos, textclass_type tc, ErrorList & errorlist)
PitPosPair eraseSelectionHelper(BufferParams const & params,
ParagraphList & pars,
par_type startpit, par_type endpit,
int startpos, int endpos, bool doclear)
{
return pasteSelection(buffer, pars, pit, pos, tc, 0, errorlist);
if (startpit == par_type(pars.size()) ||
(startpos > pars[startpit].size()))
return PitPosPair(endpit, endpos);
if (endpit == par_type(pars.size()) ||
startpit == endpit) {
endpos -= pars[startpit].erase(startpos, endpos);
return PitPosPair(endpit, endpos);
}
// clear end/begin fragments of the first/last par in selection
bool all_erased = true;
pars[startpit].erase(startpos, pars[startpit].size());
if (pars[startpit].size() != startpos)
all_erased = false;
endpos -= pars[endpit].erase(0, endpos);
if (endpos != 0)
all_erased = false;
// Loop through the deleted pars if any, erasing as needed
for (par_type pit = startpit + 1; pit != endpit;) {
// "erase" the contents of the par
pars[pit].erase(0, pars[pit].size());
if (!pars[pit].size()) {
// remove the par if it's now empty
pars.erase(pars.begin() + pit);
--endpit;
} else {
++pit;
all_erased = false;
}
}
#if 0 // FIXME: why for cut but not copy ?
// the cut selection should begin with standard layout
if (realcut) {
buf->params().clear();
buf->bibkey = 0;
buf->layout(textclasslist[buffer->params.textclass].defaultLayoutName());
}
#endif
if (startpit + 1 == par_type(pars.size()))
return PitPosPair(endpit, endpos);
if (doclear) {
pars[startpit + 1].stripLeadingSpaces();
}
// paste the paragraphs again, if possible
if (all_erased &&
(pars[startpit].hasSameLayout(pars[startpit + 1]) ||
pars[startpit + 1].empty())) {
mergeParagraph(params, pars, startpit);
// this because endpar gets deleted here!
endpit = startpit;
endpos = startpos;
}
return PitPosPair(endpit, endpos);
}
void copySelectionHelper(ParagraphList & pars,
par_type startpit, par_type endpit,
int start, int end, textclass_type tc)
{
BOOST_ASSERT(0 <= start && start <= pars[startpit].size());
BOOST_ASSERT(0 <= end && end <= pars[endpit].size());
BOOST_ASSERT(startpit != endpit || start <= end);
// Clone the paragraphs within the selection.
ParagraphList paragraphs(pars.begin() + startpit, pars.begin() + endpit + 1);
for_each(paragraphs.begin(), paragraphs.end(), resetOwnerAndChanges());
// Cut out the end of the last paragraph.
Paragraph & back = paragraphs.back();
back.erase(end, back.size());
// Cut out the begin of the first paragraph
Paragraph & front = paragraphs.front();
front.erase(0, start);
theCuts.push(make_pair(paragraphs, tc));
}
PitPosPair cutSelectionHelper(BufferParams const & params,
ParagraphList & pars, par_type startpit, par_type endpit,
int startpos, int endpos, textclass_type tc, bool doclear)
{
copySelectionHelper(pars, startpit, endpit, startpos, endpos, tc);
return eraseSelectionHelper(params, pars, startpit, endpit,
startpos, endpos, doclear);
}
} // namespace anon
namespace lyx {
namespace cap {
string grabAndEraseSelection(LCursor & cur)
{
if (!cur.selection())
return string();
string res = grabSelection(cur);
eraseSelection(cur);
cur.selection() = false;
return res;
}
int SwitchLayoutsBetweenClasses(textclass_type c1, textclass_type c2,
ParagraphList & pars, ErrorList & errorlist)
{
BOOST_ASSERT(!pars.empty());
int ret = 0;
if (c1 == c2)
return ret;
LyXTextClass const & tclass1 = textclasslist[c1];
LyXTextClass const & tclass2 = textclasslist[c2];
InsetText in;
std::swap(in.paragraphs(), pars);
ParIterator end = par_iterator_end(in);
for (ParIterator it = par_iterator_begin(in); it != end; ++it) {
string const name = it->layout()->name();
bool hasLayout = tclass2.hasLayout(name);
if (hasLayout)
it->layout(tclass2[name]);
else
it->layout(tclass2.defaultLayout());
if (!hasLayout && name != tclass1.defaultLayoutName()) {
++ret;
string 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(), tclass1.name(), tclass2.name());
// To warn the user that something had to be done.
errorlist.push_back(ErrorItem("Changed Layout", s,
it->id(), 0,
it->size()));
}
}
std::swap(in.paragraphs(), pars);
return ret;
}
std::vector<string> const availableSelections(Buffer const & buffer)
{
vector<string> selList;
CutStack::const_iterator cit = theCuts.begin();
CutStack::const_iterator end = theCuts.end();
for (; cit != end; ++cit) {
// we do not use cit-> here because gcc 2.9x does not
// like it (JMarc)
ParagraphList const & pars = (*cit).first;
string asciiSel;
ParagraphList::const_iterator pit = pars.begin();
ParagraphList::const_iterator pend = pars.end();
for (; pit != pend; ++pit) {
asciiSel += pit->asString(buffer, false);
if (asciiSel.size() > 25) {
asciiSel.replace(22, string::npos, "...");
break;
}
}
selList.push_back(asciiSel);
}
return selList;
}
int nrOfParagraphs()
{
return cuts.empty() ? 0 : cuts[0].first.size();
}
bool checkPastePossible()
{
return !cuts.empty() && !cuts[0].first.empty();
return theCuts.empty() ? 0 : theCuts[0].first.size();
}
void cutSelection(LCursor & cur, bool doclear, bool realcut)
{
LyXText * text = cur.text();
BOOST_ASSERT(text);
// Stuff what we got on the clipboard. Even if there is no selection.
if (cur.inTexted()) {
LyXText * text = cur.text();
BOOST_ASSERT(text);
// Stuff what we got on the clipboard. Even if there is no selection.
// There is a problem with having the stuffing here in that the
// larger the selection the slower LyX will get. This can be
// solved by running the line below only when the selection has
// finished. The solution used currently just works, to make it
// faster we need to be more clever and probably also have more
// calls to stuffClipboard. (Lgb)
cur.bv().stuffClipboard(cur.selectionAsString(true));
// There is a problem with having the stuffing here in that the
// larger the selection the slower LyX will get. This can be
// solved by running the line below only when the selection has
// finished. The solution used currently just works, to make it
// faster we need to be more clever and probably also have more
// calls to stuffClipboard. (Lgb)
cur.bv().stuffClipboard(cur.selectionAsString(true));
// This doesn't make sense, if there is no selection
if (!cur.selection())
return;
// This doesn't make sense, if there is no selection
if (!cur.selection())
return;
// OK, we have a selection. This is always between cur.selBegin()
// and cur.selEnd()
// OK, we have a selection. This is always between cur.selBegin()
// and cur.selEnd()
// make sure that the depth behind the selection are restored, too
recordUndoSelection(cur);
par_type begpit = cur.selBegin().par();
par_type endpit = cur.selEnd().par();
// make sure that the depth behind the selection are restored, too
recordUndoSelection(cur);
par_type begpit = cur.selBegin().par();
par_type endpit = cur.selEnd().par();
int endpos = cur.selEnd().pos();
int endpos = cur.selEnd().pos();
BufferParams const & bufparams = cur.buffer().params();
boost::tie(endpit, endpos) = realcut ?
cutSelection(bufparams,
text->paragraphs(),
begpit, endpit,
cur.selBegin().pos(), endpos,
bufparams.textclass,
doclear)
: eraseSelection(bufparams,
text->paragraphs(),
begpit, endpit,
cur.selBegin().pos(), endpos,
doclear);
// sometimes necessary
if (doclear)
text->paragraphs()[begpit].stripLeadingSpaces();
BufferParams const & bp = cur.buffer().params();
if (realcut) {
copySelectionHelper(text->paragraphs(),
begpit, endpit,
cur.selBegin().pos(), endpos,
bp.textclass);
}
text->redoParagraphs(begpit, begpit + 1);
// cutSelection can invalidate the cursor so we need to set
// it anew. (Lgb)
// we prefer the end for when tracking changes
cur.pos() = endpos;
cur.par() = endpit;
boost::tie(endpit, endpos) =
eraseSelectionHelper(bp,
text->paragraphs(),
begpit, endpit,
cur.selBegin().pos(), endpos,
doclear);
// need a valid cursor. (Lgb)
cur.clearSelection();
text->updateCounters();
// sometimes necessary
if (doclear)
text->paragraphs()[begpit].stripLeadingSpaces();
text->redoParagraphs(begpit, begpit + 1);
// cutSelection can invalidate the cursor so we need to set
// it anew. (Lgb)
// we prefer the end for when tracking changes
cur.pos() = endpos;
cur.par() = endpit;
// need a valid cursor. (Lgb)
cur.clearSelection();
text->updateCounters();
}
if (cur.inMathed()) {
lyxerr << "cutSelection in mathed" << endl;
LCursor tmp = cur;
copySelection(cur);
cur.selection() = false;
eraseSelection(tmp);
}
}
void copySelection(LCursor & cur)
{
LyXText * text = cur.text();
BOOST_ASSERT(text);
// stuff the selection onto the X clipboard, from an explicit copy request
cur.bv().stuffClipboard(cur.selectionAsString(true));
@ -457,54 +497,85 @@ void copySelection(LCursor & cur)
if (!cur.selection())
return;
// ok we have a selection. This is always between cur.selBegin()
// and sel_end cursor
if (cur.inTexted()) {
LyXText * text = cur.text();
BOOST_ASSERT(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();
par_type par = cur.selBegin().par();
while (pos < pars[par].size()
&& pars[par].isLineSeparator(pos)
&& (par != cur.selEnd().par() || pos < cur.selEnd().pos()))
++pos;
// copy behind a space if there is one
ParagraphList & pars = text->paragraphs();
pos_type pos = cur.selBegin().pos();
par_type par = cur.selBegin().par();
while (pos < pars[par].size()
&& pars[par].isLineSeparator(pos)
&& (par != cur.selEnd().par() || pos < cur.selEnd().pos()))
++pos;
copySelection(pars, par, cur.selEnd().par(),
pos, cur.selEnd().pos(), cur.buffer().params().textclass);
copySelectionHelper(pars, par, cur.selEnd().par(),
pos, cur.selEnd().pos(), cur.buffer().params().textclass);
}
if (cur.inMathed()) {
lyxerr << "copySelection in mathed" << endl;
ParagraphList pars;
pars.push_back(Paragraph());
BufferParams const & bp = cur.buffer().params();
pars.back().layout(bp.getLyXTextClass().defaultLayout());
for_each(pars.begin(), pars.end(), resetOwnerAndChanges());
pars.back().insert(0, grabSelection(cur), LyXFont());
theCuts.push(make_pair(pars, bp.textclass));
}
}
std::string getSelection(Buffer const & buf, size_t sel_index)
{
return sel_index < theCuts.size()
? theCuts[sel_index].first.back().asString(buf, false)
: string();
}
void pasteSelection(LCursor & cur, size_t sel_index)
{
LyXText * text = cur.text();
BOOST_ASSERT(text);
// this does not make sense, if there is nothing to paste
if (!checkPastePossible())
lyxerr << "#### pasteSelection " << sel_index << endl;
if (!checkPastePossible(sel_index))
return;
recordUndo(cur);
if (cur.inTexted()) {
LyXText * text = cur.text();
BOOST_ASSERT(text);
par_type endpit;
PitPosPair ppp;
recordUndo(cur);
ErrorList el;
par_type endpit;
PitPosPair ppp;
boost::tie(ppp, endpit) =
pasteSelection(cur.buffer(),
text->paragraphs(),
cur.par(), cur.pos(),
cur.buffer().params().textclass,
sel_index, el);
bufferErrors(cur.buffer(), el);
cur.bv().showErrorList(_("Paste"));
ErrorList el;
text->redoParagraphs(cur.par(), endpit);
boost::tie(ppp, endpit) =
pasteSelectionHelper(cur.buffer(),
text->paragraphs(),
cur.par(), cur.pos(),
cur.buffer().params().textclass,
sel_index, el);
bufferErrors(cur.buffer(), el);
cur.bv().showErrorList(_("Paste"));
cur.clearSelection();
cur.resetAnchor();
text->setCursor(cur, ppp.first, ppp.second);
cur.setSelection();
text->updateCounters();
text->redoParagraphs(cur.par(), endpit);
cur.clearSelection();
cur.resetAnchor();
text->setCursor(cur, ppp.first, ppp.second);
cur.setSelection();
text->updateCounters();
}
if (cur.inMathed()) {
lyxerr << "### should be handled in MathNest/GridInset" << endl;
}
}
@ -566,5 +637,93 @@ void replaceWord(LCursor & cur, string const & replacestring)
}
void eraseSelection(LCursor & cur)
{
//lyxerr << "LCursor::eraseSelection" << endl;
CursorSlice const & i1 = cur.selBegin();
CursorSlice const & i2 = cur.selEnd();
#ifdef WITH_WARNINGS
#warning FIXME
#endif
if (i1.inset().asMathInset()) {
if (i1.idx() == i2.idx()) {
i1.cell().erase(i1.pos(), i2.pos());
} else {
MathInset * p = i1.asMathInset();
InsetBase::row_type r1, r2;
InsetBase::col_type c1, c2;
region(i1, i2, r1, r2, c1, c2);
for (InsetBase::row_type row = r1; row <= r2; ++row)
for (InsetBase::col_type col = c1; col <= c2; ++col)
p->cell(p->index(row, col)).clear();
}
cur.back() = i1;
} else {
lyxerr << "can't erase this selection 1" << endl;
}
//lyxerr << "LCursor::eraseSelection end" << endl;
}
void selDel(LCursor & cur)
{
//lyxerr << "LCursor::selDel" << endl;
if (cur.selection()) {
eraseSelection(cur);
cur.selection() = false;
}
}
void selClearOrDel(LCursor & cur)
{
//lyxerr << "LCursor::selClearOrDel" << endl;
if (lyxrc.auto_region_delete)
selDel(cur);
else
cur.selection() = false;
}
string grabSelection(LCursor & cur)
{
if (!cur.selection())
return string();
CursorSlice i1 = cur.selBegin();
CursorSlice i2 = cur.selEnd();
if (i1.idx() == i2.idx()) {
if (i1.inset().asMathInset()) {
MathArray::const_iterator it = i1.cell().begin();
return asString(MathArray(it + i1.pos(), it + i2.pos()));
} else {
return "unknown selection 1";
}
}
InsetBase::row_type r1, r2;
InsetBase::col_type c1, c2;
region(i1, i2, r1, r2, c1, c2);
string data;
if (i1.inset().asMathInset()) {
for (InsetBase::row_type row = r1; row <= r2; ++row) {
if (row > r1)
data += "\\\\";
for (InsetBase::col_type col = c1; col <= c2; ++col) {
if (col > c1)
data += '&';
data += asString(i1.asMathInset()->
cell(i1.asMathInset()->index(row, col)));
}
}
} else {
data = "unknown selection 2";
}
return data;
}
} // namespace cap
} // namespace lyx

19
src/CutAndPaste.h
View File

@ -31,6 +31,8 @@ namespace cap {
///
std::vector<std::string> const availableSelections(Buffer const & buffer);
///
std::string getSelection(Buffer const & buffer, size_t sel_index);
///
void cutSelection(LCursor & cur, bool doclear, bool realcut);
@ -60,12 +62,25 @@ int SwitchLayoutsBetweenClasses(lyx::textclass_type c1,
lyx::textclass_type c2,
ParagraphList & par,
ErrorList &);
///
bool checkPastePossible();
// only used by the spellchecker
void replaceWord(LCursor & cur, std::string const & replacestring);
///
std::string grabSelection(LCursor & cur);
///
void eraseSelection(LCursor & cur);
///
std::string grabAndEraseSelection(LCursor & cur);
// other selection methods
///
void selCut(LCursor & cur);
///
void selDel(LCursor & cur);
/// clears or deletes selection depending on lyxrc setting
void selClearOrDel(LCursor & cur);
/// pastes n-th element of cut buffer
void selPaste(LCursor & cur, size_t n);
} // namespace cap
} // namespce lyx

168
src/cursor.C
View File

@ -36,9 +36,7 @@
#include "insets/insettext.h"
#include "mathed/math_data.h"
#include "mathed/math_support.h"
#include "mathed/math_inset.h"
#include "mathed/math_braceinset.h"
#include "mathed/math_macrotable.h"
#include "support/limited_stack.h"
@ -60,31 +58,6 @@ using std::min;
using std::swap;
// our own cut buffer
limited_stack<string> theCutBuffer;
namespace {
void region(CursorSlice const & i1, CursorSlice const & i2,
LCursor::row_type & r1, LCursor::row_type & r2,
LCursor::col_type & c1, LCursor::col_type & c2)
{
InsetBase & 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);
}
}
LCursor::LCursor(BufferView & bv)
: DocIterator(), bv_(&bv), anchor_(), x_target_(-1),
selection_(false), mark_(false)
@ -408,121 +381,6 @@ void LCursor::info(std::ostream & os) const
}
string LCursor::grabSelection()
{
if (!selection())
return string();
CursorSlice i1 = selBegin();
CursorSlice i2 = selEnd();
if (i1.idx() == i2.idx()) {
if (i1.inset().asMathInset()) {
MathArray::const_iterator it = i1.cell().begin();
return asString(MathArray(it + i1.pos(), it + i2.pos()));
} else {
return "unknown selection 1";
}
}
row_type r1, r2;
col_type c1, c2;
region(i1, i2, r1, r2, c1, c2);
string data;
if (i1.inset().asMathInset()) {
for (row_type row = r1; row <= r2; ++row) {
if (row > r1)
data += "\\\\";
for (col_type col = c1; col <= c2; ++col) {
if (col > c1)
data += '&';
data += asString(i1.asMathInset()->cell(i1.asMathInset()->index(row, col)));
}
}
} else {
data = "unknown selection 2";
}
return data;
}
void LCursor::eraseSelection()
{
//lyxerr << "LCursor::eraseSelection" << endl;
CursorSlice const & i1 = selBegin();
CursorSlice const & i2 = selEnd();
#ifdef WITH_WARNINGS
#warning FIXME
#endif
if (i1.inset().asMathInset()) {
if (i1.idx() == i2.idx()) {
i1.cell().erase(i1.pos(), i2.pos());
} else {
MathInset * p = i1.asMathInset();
row_type r1, r2;
col_type c1, c2;
region(i1, i2, r1, r2, c1, c2);
for (row_type row = r1; row <= r2; ++row)
for (col_type col = c1; col <= c2; ++col)
p->cell(p->index(row, col)).clear();
}
back() = i1;
} else {
lyxerr << "can't erase this selection 1" << endl;
}
//lyxerr << "LCursor::eraseSelection end" << endl;
}
string LCursor::grabAndEraseSelection()
{
if (!selection())
return string();
string res = grabSelection();
eraseSelection();
selection() = false;
return res;
}
void LCursor::selCopy()
{
if (selection()) {
theCutBuffer.push(grabSelection());
selection() = false;
} else {
//theCutBuffer.erase();
}
}
void LCursor::selCut()
{
theCutBuffer.push(grabAndEraseSelection());
}
void LCursor::selDel()
{
//lyxerr << "LCursor::selDel" << endl;
if (selection()) {
eraseSelection();
selection() = false;
}
}
void LCursor::selPaste(size_t n)
{
selClearOrDel();
if (n < theCutBuffer.size())
paste(theCutBuffer[n]);
//grabSelection();
selection() = false;
}
void LCursor::selHandle(bool sel)
{
//lyxerr << "LCursor::selHandle" << endl;
@ -538,16 +396,6 @@ void LCursor::selHandle(bool sel)
}
void LCursor::selClearOrDel()
{
//lyxerr << "LCursor::selClearOrDel" << endl;
if (lyxrc.auto_region_delete)
selDel();
else
selection() = false;
}
std::ostream & operator<<(std::ostream & os, LCursor const & cur)
{
for (size_t i = 0, n = cur.size(); i != n; ++i) {
@ -682,7 +530,7 @@ void LCursor::insert(char c)
//lyxerr << "LCursor::insert char '" << c << "'" << endl;
BOOST_ASSERT(!empty());
if (inMathed()) {
selClearOrDel();
lyx::cap::selClearOrDel(*this);
insert(new MathCharInset(c));
} else {
text()->insertChar(*this, c);
@ -694,7 +542,7 @@ void LCursor::insert(MathAtom const & t)
{
//lyxerr << "LCursor::insert MathAtom: " << endl;
macroModeClose();
selClearOrDel();
lyx::cap::selClearOrDel(*this);
plainInsert(t);
lyxerr << "LCursor::insert MathAtom: cur:\n" << *this << endl;
}
@ -723,7 +571,7 @@ void LCursor::niceInsert(string const & t)
void LCursor::niceInsert(MathAtom const & t)
{
macroModeClose();
string safe = grabAndEraseSelection();
string safe = lyx::cap::grabAndEraseSelection(*this);
plainInsert(t);
// enter the new inset and move the contents of the selection if possible
if (t->isActive()) {
@ -740,7 +588,7 @@ void LCursor::insert(MathArray const & ar)
{
macroModeClose();
if (selection())
eraseSelection();
lyx::cap::eraseSelection(*this);
cell().insert(pos(), ar);
pos() += ar.size();
}
@ -751,7 +599,7 @@ bool LCursor::backspace()
autocorrect() = false;
if (selection()) {
selDel();
lyx::cap::selDel(*this);
return true;
}
@ -791,7 +639,7 @@ bool LCursor::erase()
return true;
if (selection()) {
selDel();
lyx::cap::selDel(*this);
return true;
}
@ -884,7 +732,7 @@ void LCursor::handleNest(MathAtom const & a, int c)
{
//lyxerr << "LCursor::handleNest: " << c << endl;
MathAtom t = a;
asArray(grabAndEraseSelection(), t.nucleus()->cell(c));
asArray(lyx::cap::grabAndEraseSelection(*this), t.nucleus()->cell(c));
insert(t);
posLeft();
pushLeft(*nextInset());
@ -1138,7 +986,7 @@ void LCursor::handleFont(string const & font)
string safe;
if (selection()) {
macroModeClose();
safe = grabAndEraseSelection();
safe = lyx::cap::grabAndEraseSelection(*this);
}
if (lastpos() != 0) {

17
src/cursor.h
View File

@ -81,24 +81,7 @@ public:
/// access start of selection
DocIterator selectionEnd() const;
///
std::string grabSelection();
///
void eraseSelection();
///
std::string grabAndEraseSelection();
// other selection methods
///
void selCopy();
///
void selCut();
///
void selDel();
/// pastes n-th element of cut buffer
void selPaste(size_t n);
///
void selHandle(bool selecting);
/// clears or deletes selection depending on lyxrc setting
void selClearOrDel();
//
std::string selectionAsString(bool label) const;
///

3
src/paragraph.C
View File

@ -1570,8 +1570,7 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams) const
// Convert the paragraph to a string.
// Used for building the table of contents
string const Paragraph::asString(Buffer const & buffer,
bool label) const
string const Paragraph::asString(Buffer const & buffer, bool label) const
{
OutputParams runparams;
return asString(buffer, runparams, label);

5
src/text3.C
View File

@ -158,9 +158,8 @@ namespace {
cur.dispatch(FuncRequest(LFUN_MATH_MUTATE, "simple"));
cur.dispatch(FuncRequest(LFUN_INSERT_MATH, sel));
} else {
cur.insert(new MathMacroTemplate);
//cur.dispatch(FuncRequest(LFUN_RIGHT));
//cur.dispatch(FuncRequest(LFUN_INSERT_MATH, sel));
istringstream is(sel);
cur.insert(new MathMacroTemplate(is));
}
}
cur.message(N_("Math editor mode"));