#include "rowpainter.h"
#include "sgml.h"
#include "texrow.h"
-#include "undo_funcs.h"
+#include "undo.h"
#include "WordLangTuple.h"
#include "frontends/Alert.h"
top_y = 0;
locked = false;
- inset_par = paragraphs.end();
+ inset_par = -1;
inset_pos = 0;
inset_x = 0;
inset_y = 0;
no_selection = true;
the_locking_inset = 0;
- old_par = paragraphs.end();
+ old_par = -1;
in_insetAllowed = false;
mouse_x = 0;
mouse_y = 0;
top_baseline = y;
top_y = y - dim_.asc;
- if (the_locking_inset && cpar() == inset_par && cpos() == inset_pos) {
+ if (the_locking_inset
+ && text_.cursor.par() == inset_par && cpos() == inset_pos) {
inset_x = cx() - x;
inset_y = cy();
}
bv->owner()->view_state_changed();
bv->owner()->updateMenubar();
bv->owner()->updateToolbar();
- if (old_par != cpar()) {
+ if (old_par != text_.cursor.par()) {
bv->owner()->setLayout(cpar()->layout()->name());
- old_par = cpar();
+ old_par = text_.cursor.par();
}
}
no_selection = true;
locked = false;
- if (text_.selection.set()) {
+ if (text_.selection.set())
text_.clearSelection();
- } else if (owner()) {
+ else if (owner())
bv->owner()->setLayout(owner()->getLyXText(bv)
- ->cursor.par()->layout()->name());
- } else
- bv->owner()->setLayout(bv->text->cursor.par()->layout()->name());
+ ->cursorPar()->layout()->name());
+ else
+ bv->owner()->setLayout(bv->text->cursorPar()->layout()->name());
// hack for deleteEmptyParMech
- ParagraphList::iterator first_par = paragraphs.begin();
- if (!first_par->empty()) {
- text_.setCursor(first_par, 0);
- } else if (paragraphs.size() > 1) {
- text_.setCursor(boost::next(first_par), 0);
- }
+ if (!paragraphs.begin()->empty())
+ text_.setCursor(0, 0);
+ else if (paragraphs.size() > 1)
+ text_.setCursor(1, 0);
}
the_locking_inset = 0;
inset_pos = inset_x = inset_y = 0;
inset_boundary = false;
- inset_par = paragraphs.end();
- old_par = paragraphs.end();
- text_.setCursorIntern(paragraphs.begin(), 0);
+ inset_par = -1;
+ old_par = -1;
+ text_.setCursorIntern(0, 0);
text_.clearSelection();
finishUndo();
// If the inset is empty set the language of the current font to the
inset_x = cx() - top_x;
inset_y = cy();
inset_pos = cpos();
- inset_par = cpar();
+ inset_par = text_.cursor.par();
inset_boundary = cboundary();
}
for (; it != end; ++it) {
if (it->inset == inset) {
lyxerr << "InsetText::lockInsetInInset: 1 a" << endl;
- text_.setCursorIntern(pit, it->pos);
+ text_.setCursorIntern(
+ std::distance(paragraphs.begin(), pit), it->pos);
lyxerr << "InsetText::lockInsetInInset: 1 b" << endl;
lyxerr << "bv: " << bv << " inset: " << inset << endl;
lockInset(bv, inset);
}
if (the_locking_inset && the_locking_inset == inset) {
- if (cpar() == inset_par && cpos() == inset_pos) {
+ if (text_.cursor.par() == inset_par && cpos() == inset_pos) {
lyxerr[Debug::INSETS] << "OK" << endl;
inset_x = cx() - top_x;
inset_y = cy();
the_locking_inset = 0;
if (lr)
moveRightIntern(bv, true, false);
- old_par = paragraphs.end(); // force layout setting
+ old_par = -1; // force layout setting
if (scroll())
scroll(bv, 0.0F);
else
if (the_locking_inset) {
if (the_locking_inset == inset) {
- the_locking_inset->localDispatch(cmd1);
+ the_locking_inset->dispatch(cmd1);
return;
}
// otherwise only unlock the_locking_inset
if (!bv->lockInset(uinset)) {
lyxerr[Debug::INSETS] << "Cannot lock inset" << endl;
}
- inset->localDispatch(cmd1);
+ inset->dispatch(cmd1);
if (the_locking_inset)
updateLocal(bv, false);
return;
if (!inset) {
bool paste_internally = false;
if (cmd.button() == mouse_button::button2 && getLyXText(bv)->selection.set()) {
- localDispatch(FuncRequest(bv, LFUN_COPY));
+ dispatch(FuncRequest(bv, LFUN_COPY));
paste_internally = true;
}
int old_top_y = bv->top_y();
// we moved the view we cannot do mouse selection in this case!
if (bv->top_y() != old_top_y)
no_selection = true;
- old_par = cpar();
+ old_par = text_.cursor.par();
// Insert primary selection with middle mouse
// if there is a local selection in the current buffer,
// insert this
if (cmd.button() == mouse_button::button2) {
if (paste_internally)
- localDispatch(FuncRequest(bv, LFUN_PASTE));
+ dispatch(FuncRequest(bv, LFUN_PASTE));
else
- localDispatch(FuncRequest(bv, LFUN_PASTESELECTION, "paragraph"));
+ dispatch(FuncRequest(bv, LFUN_PASTESELECTION, "paragraph"));
}
} else {
getLyXText(bv)->clearSelection();
no_selection = true;
if (the_locking_inset)
- return the_locking_inset->localDispatch(cmd1);
+ return the_locking_inset->dispatch(cmd1);
int tmp_x = cmd.x;
int tmp_y = cmd.y + dim_.asc - bv->top_y();
InsetOld * inset = getLyXText(bv)->checkInsetHit(tmp_x, tmp_y);
- bool ret = false;
- if (inset) {
-// This code should probably be removed now. Simple insets
-// (!highlyEditable) can actually take the localDispatch,
-// and turn it into edit() if necessary. But we still
-// need to deal properly with the whole relative vs.
-// absolute mouse co-ords thing in a realiable, sensible way
-#if 0
- if (isHighlyEditableInset(inset))
- ret = inset->localDispatch(cmd1);
- else {
- inset_x = cx(bv) - top_x;
- inset_y = cy();
- cmd1.x = cmd.x - inset_x;
- cmd1.y = cmd.x - inset_y;
- inset->edit(bv, cmd1.x, cmd1.y, cmd.button());
- ret = true;
- }
-#endif
- ret = inset->localDispatch(cmd1);
- updateLocal(bv, false);
+ if (!inset)
+ return false;
- }
+ // We still need to deal properly with the whole relative vs.
+ // absolute mouse co-ords thing in a realiable, sensible way
+ bool ret = inset->dispatch(cmd1);
+ updateLocal(bv, false);
return ret;
}
cmd1.y -= inset_y;
if (the_locking_inset) {
- the_locking_inset->localDispatch(cmd1);
+ the_locking_inset->dispatch(cmd1);
return;
}
}
-InsetOld::RESULT InsetText::localDispatch(FuncRequest const & cmd)
+dispatch_result
+InsetText::priv_dispatch(FuncRequest const & cmd,
+ idx_type & idx, pos_type & pos)
{
BufferView * bv = cmd.view();
setViewCache(bv);
switch (cmd.action) {
case LFUN_INSET_EDIT: {
- UpdatableInset::localDispatch(cmd);
+ UpdatableInset::priv_dispatch(cmd, idx, pos);
if (!bv->lockInset(this)) {
lyxerr[Debug::INSETS] << "Cannot lock inset" << endl;
inset_x = 0;
inset_y = 0;
inset_boundary = false;
- inset_par = paragraphs.end();
- old_par = paragraphs.end();
+ inset_par = -1;
+ old_par = -1;
if (cmd.argument.size()) {
if (cmd.argument == "left")
- text_.setCursorIntern(paragraphs.begin(), 0);
- else {
- ParagraphList::iterator it = boost::prior(paragraphs.end());
- text_.setCursor(it, it->size());
- }
+ text_.setCursorIntern(0, 0);
+ else
+ text_.setCursor(paragraphs.size() - 1, paragraphs.back().size());
} else {
int tmp_y = (cmd.y < 0) ? 0 : cmd.y;
// we put here -1 and not button as now the button in the
bool was_empty = paragraphs.begin()->empty() && paragraphs.size() == 1;
no_selection = false;
- RESULT result = UpdatableInset::localDispatch(cmd);
+ dispatch_result result = UpdatableInset::priv_dispatch(cmd, idx, pos);
if (result != UNDISPATCHED)
return DISPATCHED;
return FINISHED;
if (the_locking_inset) {
- result = the_locking_inset->localDispatch(cmd);
+ result = the_locking_inset->dispatch(cmd);
if (result == DISPATCHED_NOUPDATE)
return result;
if (result == DISPATCHED) {
* true (on). */
#if 0
// This should not be needed here and is also WRONG!
- recordUndo(bv, Undo::INSERT, text_.cursor.par());
+ recordUndo(bv, Undo::INSERT, text_.cursorPar());
#endif
bv->switchKeyMap();
updflag = true;
break;
- case LFUN_PASTE: {
+ case LFUN_PASTE:
if (!autoBreakRows_) {
if (CutAndPaste::nrOfParagraphs() > 1) {
#ifdef WITH_WARNINGS
#warning FIXME horrendously bad UI
#endif
Alert::error(_("Paste failed"), _("Cannot include more than one paragraph."));
- break;
}
- }
-
- replaceSelection(bv->getLyXText());
- size_t sel_index = 0;
- string const & arg = cmd.argument;
- if (isStrUnsignedInt(arg)) {
- size_t const paste_arg = strToUnsignedInt(arg);
+ } else {
+ replaceSelection(bv->getLyXText());
+ size_t sel_index = 0;
+ string const & arg = cmd.argument;
+ if (isStrUnsignedInt(arg)) {
#warning FIXME Check if the arg is in the domain of available selections.
- sel_index = paste_arg;
+ sel_index = strToUnsignedInt(arg);
+ }
+ text_.pasteSelection(sel_index);
+ // bug 393
+ text_.clearSelection();
+ updflag = true;
}
- text_.pasteSelection(sel_index);
- // bug 393
- text_.clearSelection();
- updflag = true;
break;
- }
case LFUN_BREAKPARAGRAPH:
if (!autoBreakRows_) {
result = DISPATCHED;
- break;
+ } else {
+ replaceSelection(bv->getLyXText());
+ text_.breakParagraph(paragraphs, 0);
+ updflag = true;
}
- replaceSelection(bv->getLyXText());
- text_.breakParagraph(paragraphs, 0);
- updflag = true;
break;
case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
if (!autoBreakRows_) {
result = DISPATCHED;
- break;
+ } else {
+ replaceSelection(bv->getLyXText());
+ text_.breakParagraph(paragraphs, 1);
+ updflag = true;
}
- replaceSelection(bv->getLyXText());
- text_.breakParagraph(paragraphs, 1);
- updflag = true;
break;
case LFUN_BREAKLINE: {
if (!autoBreakRows_) {
result = DISPATCHED;
- break;
+ } else {
+ replaceSelection(bv->getLyXText());
+ text_.insertInset(new InsetNewline);
+ updflag = true;
}
-
- replaceSelection(bv->getLyXText());
- text_.insertInset(new InsetNewline);
- updflag = true;
break;
}
}
-InsetOld::RESULT InsetText::moveRight(BufferView * bv)
+dispatch_result InsetText::moveRight(BufferView * bv)
{
- if (text_.cursor.par()->isRightToLeftPar(bv->buffer()->params()))
+ if (text_.cursorPar()->isRightToLeftPar(bv->buffer()->params()))
return moveLeftIntern(bv, false, true, false);
else
return moveRightIntern(bv, true, true, false);
}
-InsetOld::RESULT InsetText::moveLeft(BufferView * bv)
+dispatch_result InsetText::moveLeft(BufferView * bv)
{
- if (text_.cursor.par()->isRightToLeftPar(bv->buffer()->params()))
+ if (text_.cursorPar()->isRightToLeftPar(bv->buffer()->params()))
return moveRightIntern(bv, true, true, false);
else
return moveLeftIntern(bv, false, true, false);
}
-InsetOld::RESULT
+dispatch_result
InsetText::moveRightIntern(BufferView * bv, bool front,
bool activate_inset, bool selecting)
{
}
-InsetOld::RESULT
+dispatch_result
InsetText::moveLeftIntern(BufferView * bv, bool front,
bool activate_inset, bool selecting)
{
}
-InsetOld::RESULT InsetText::moveUp(BufferView * bv)
+dispatch_result InsetText::moveUp(BufferView * bv)
{
if (crow() == text_.firstRow())
return FINISHED_UP;
}
-InsetOld::RESULT InsetText::moveDown(BufferView * bv)
+dispatch_result InsetText::moveDown(BufferView * bv)
{
if (crow() == text_.lastRow())
return FINISHED_DOWN;
if (text_.selection.set())
- recordUndo(bv, Undo::ATOMIC, text_.cursor.par());
+ text_.recUndo(text_.cursor.par());
if (selectall) {
text_.cursorTop();
if (!isHighlyEditableInset(inset))
return false;
FuncRequest cmd(bv, LFUN_INSET_EDIT, front ? "left" : "right");
- inset->localDispatch(cmd);
+ inset->dispatch(cmd);
if (!the_locking_inset)
return false;
updateLocal(bv, false);
inset_x = cx() - top_x;
inset_y = cy();
FuncRequest cmd(bv, LFUN_INSET_EDIT, x - inset_x, y - inset_y, button);
- inset->localDispatch(cmd);
+ inset->dispatch(cmd);
if (!the_locking_inset)
return false;
updateLocal(bv, false);
{
int x = text_.cursor.x() + top_x + TEXT_TO_INSET_OFFSET;
if (the_locking_inset) {
- LyXFont font = text_.getFont(text_.cursor.par(), text_.cursor.pos());
+ LyXFont font = text_.getFont(text_.cursorPar(), text_.cursor.pos());
if (font.isVisibleRightToLeft())
x -= the_locking_inset->width();
}
ParagraphList::iterator InsetText::cpar() const
{
- return text_.cursor.par();
+ return text_.cursorPar();
}
}
+LyXText * InsetText::getText(int i) const
+{
+ return (i == 0) ? const_cast<LyXText*>(&text_) : 0;
+}
+
+
LyXCursor const & InsetText::cursor(BufferView * bv) const
{
if (the_locking_inset)
return true;
}
if (!locked) {
- ParagraphList::iterator pit = boost::prior(paragraphs.end());
- text_.setCursor(pit, pit->size());
+ text_.setCursor(paragraphs.size() - 1, paragraphs.back().size());
}
lyx::find::SearchResult result =
lyx::find::find(bv, &text_, str, false, cs, mw);
void InsetText::collapseParagraphs(BufferView * bv)
{
while (paragraphs.size() > 1) {
- ParagraphList::iterator first_par = paragraphs.begin();
- ParagraphList::iterator next_par = boost::next(first_par);
- size_t const first_par_size = first_par->size();
-
- if (!first_par->empty() &&
- !next_par->empty() &&
- !first_par->isSeparator(first_par_size - 1)) {
- first_par->insertChar(first_par_size, ' ');
+ ParagraphList::iterator const first = paragraphs.begin();
+ ParagraphList::iterator second = first;
+ advance(second, 1);
+ size_t const first_par_size = first->size();
+
+ if (!first->empty() &&
+ !second->empty() &&
+ !first->isSeparator(first_par_size - 1)) {
+ first->insertChar(first_par_size, ' ');
}
+#warning probably broken
if (text_.selection.set()) {
- if (text_.selection.start.par() == next_par) {
- text_.selection.start.par(first_par);
- text_.selection.start.pos(
- text_.selection.start.pos() + first_par_size);
+ if (text_.selection.start.par() == 1) {
+ text_.selection.start.par(1);
+ text_.selection.start.pos(text_.selection.start.pos() + first_par_size);
}
- if (text_.selection.end.par() == next_par) {
- text_.selection.end.par(first_par);
- text_.selection.end.pos(
- text_.selection.end.pos() + first_par_size);
+ if (text_.selection.end.par() == 2) {
+ text_.selection.end.par(1);
+ text_.selection.end.pos(text_.selection.end.pos() + first_par_size);
}
}
- mergeParagraph(bv->buffer()->params(), paragraphs, first_par);
+ mergeParagraph(bv->buffer()->params(), paragraphs, first);
}
}
projects / lyx.git / blobdiff