#include "lyxtext.h"
+#include "BranchList.h"
#include "FloatList.h"
#include "FuncStatus.h"
#include "buffer.h"
{
recordUndo(cur);
string sel = cur.selectionAsString(false);
- lyxerr << "selection is: '" << sel << "'" << endl;
+ //lyxerr << "selection is: '" << sel << "'" << endl;
if (sel.empty()) {
const int old_pos = cur.pos();
- cur.insert(new MathHullInset);
+ cur.insert(new MathHullInset("simple"));
BOOST_ASSERT(old_pos == cur.pos());
cur.nextInset()->edit(cur, true);
- cur.dispatch(FuncRequest(LFUN_MATH_MUTATE, "simple"));
// don't do that also for LFUN_MATH_MODE
// unless you want end up with always changing
// to mathrm when opening an inlined inset --
// I really hate "LyXfunc overloading"...
if (display)
cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY));
- cur.dispatch(FuncRequest(LFUN_INSERT_MATH, cmd.argument));
+ // Avoid an unnecessary undo step if cmd.argument
+ // is empty
+ if (!cmd.argument.empty())
+ cur.dispatch(FuncRequest(LFUN_INSERT_MATH,
+ cmd.argument));
} else {
// create a macro if we see "\\newcommand"
// somewhere, and an ordinary formula
if (sel.find("\\newcommand") == string::npos
&& sel.find("\\def") == string::npos)
{
- cur.insert(new MathHullInset);
+ cur.insert(new MathHullInset("simple"));
cur.dispatch(FuncRequest(LFUN_RIGHT));
- cur.dispatch(FuncRequest(LFUN_MATH_MUTATE, "simple"));
cur.dispatch(FuncRequest(LFUN_INSERT_MATH, sel));
} else {
istringstream is(sel);
int x = cur.x_target();
- setCursorFromCoordinates(cur, x, 0);
- bool updated = cursorUp(cur);
+ bool updated = setCursorFromCoordinates(cur, x, 0);
+ if (updated)
+ cur.bv().update();
+ updated |= cursorUp(cur);
if (cpar == cur.pit() && cpos == cur.pos()) {
// we have a row which is taller than the workarea. The
lyx::pit_type cpar = cur.pit();
int x = cur.x_target();
- setCursorFromCoordinates(cur, x, cur.bv().workHeight() - 1);
- bool updated = cursorDown(cur);
+ bool updated = setCursorFromCoordinates(cur, x, cur.bv().workHeight() - 1);
+ if (updated)
+ cur.bv().update();
+ updated |= cursorDown(cur);
if (cpar == cur.pit() && cpos == cur.pos()) {
// we have a row which is taller than the workarea. The
void LyXText::dispatch(LCursor & cur, FuncRequest & cmd)
{
lyxerr[Debug::ACTION] << "LyXText::dispatch: cmd: " << cmd << endl;
- lyxerr << "*** LyXText::dispatch: cmd: " << cmd << endl;
BOOST_ASSERT(cur.text() == this);
BufferView * bv = &cur.bv();
CursorSlice oldTopSlice = cur.top();
+ bool oldBoundary = cur.boundary();
bool sel = cur.selection();
- bool needsUpdate = !lyxaction.funcHasFlag(cmd.action, LyXAction::NoUpdate);
+ // Signals that, even if needsUpdate == false, an update of the
+ // cursor paragraph is required
+ bool singleParUpdate = lyxaction.funcHasFlag(cmd.action,
+ LyXAction::SingleParUpdate);
+ // Signals that a full-screen update is required
+ bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action,
+ LyXAction::NoUpdate) || singleParUpdate);
+ // Remember the old paragraph metric (_outer_ paragraph!)
+ Dimension olddim = cur.bottom().paragraph().dim();
switch (cmd.action) {
case LFUN_RIGHT:
case LFUN_RIGHTSEL:
- lyxerr << BOOST_CURRENT_FUNCTION
- << " LFUN_RIGHT[SEL]:\n" << cur << endl;
+ //lyxerr << BOOST_CURRENT_FUNCTION
+ // << " LFUN_RIGHT[SEL]:\n" << cur << endl;
cur.selHandle(cmd.action == LFUN_RIGHTSEL);
if (isRTL(cur.paragraph()))
needsUpdate = cursorLeft(cur);
else
needsUpdate = cursorRight(cur);
- if (!needsUpdate && oldTopSlice == cur.top()) {
+
+ if (!needsUpdate && oldTopSlice == cur.top()
+ && cur.boundary() == oldBoundary) {
cur.undispatched();
cmd = FuncRequest(LFUN_FINISHED_RIGHT);
}
needsUpdate = cursorRight(cur);
else
needsUpdate = cursorLeft(cur);
- if (oldTopSlice == cur.top()) {
+
+ if (!needsUpdate && oldTopSlice == cur.top()
+ && cur.boundary() == oldBoundary) {
cur.undispatched();
cmd = FuncRequest(LFUN_FINISHED_LEFT);
}
update(cur);
//lyxerr << "handle LFUN_UP[SEL]:\n" << cur << endl;
cur.selHandle(cmd.action == LFUN_UPSEL);
+
needsUpdate = cursorUp(cur);
- if (oldTopSlice == cur.top()) {
+ if (!needsUpdate && oldTopSlice == cur.top()
+ && cur.boundary() == oldBoundary) {
cur.undispatched();
cmd = FuncRequest(LFUN_FINISHED_UP);
}
//lyxerr << "handle LFUN_DOWN[SEL]:\n" << cur << endl;
cur.selHandle(cmd.action == LFUN_DOWNSEL);
needsUpdate = cursorDown(cur);
- if (oldTopSlice == cur.top()) {
+ if (!needsUpdate && oldTopSlice == cur.top() &&
+ cur.boundary() == oldBoundary)
+ {
cur.undispatched();
cmd = FuncRequest(LFUN_FINISHED_DOWN);
}
case LFUN_DELETE:
if (!cur.selection()) {
- Delete(cur);
+ needsUpdate = Delete(cur);
cur.resetAnchor();
// It is possible to make it a lot faster still
// just comment out the line below...
case LFUN_BACKSPACE:
if (!cur.selection()) {
if (bv->owner()->getIntl().getTransManager().backspace()) {
- backspace(cur);
+ needsUpdate = backspace(cur);
cur.resetAnchor();
// It is possible to make it a lot faster still
// just comment out the line below...
}
case LFUN_INSET_SETTINGS:
- if (cur.inset().asUpdatableInset())
- cur.inset().asUpdatableInset()->showInsetDialog(bv);
+ cur.inset().showInsetDialog(bv);
break;
case LFUN_NEXT_INSET_TOGGLE: {
InsetBase * inset = cur.nextInset();
+ // this is the real function we want to invoke
+ cmd = FuncRequest(LFUN_INSET_TOGGLE);
+ cur.undispatched();
+ // if there is an inset at cursor, see whether it
+ // wants to toggle.
if (inset) {
- cur.clearSelection();
- FuncRequest fr = cmd;
- fr.action = LFUN_INSET_TOGGLE;
- inset->dispatch(cur, fr);
+ LCursor tmpcur = cur;
+ tmpcur.pushLeft(*inset);
+ inset->dispatch(tmpcur, cmd);
+ if (tmpcur.result().dispatched()) {
+ cur.clearSelection();
+ cur.dispatched();
+ }
}
+ // if it did not work, try the underlying inset.
+ if (!cur.result().dispatched())
+ cur.inset().dispatch(cur, cmd);
break;
}
- case LFUN_KEYMAP_TOGGLE:
- cur.clearSelection();
- bv->switchKeyMap();
- break;
-
case LFUN_SPACE_INSERT:
if (cur.paragraph().layout()->free_spacing)
insertChar(cur, ' ');
case LFUN_PASTE:
cur.message(_("Paste"));
lyx::cap::replaceSelection(cur);
-#ifdef WITH_WARNINGS
-#warning FIXME Check if the arg is in the domain of available selections.
-#endif
if (isStrUnsignedInt(cmd.argument))
pasteSelection(cur, convert<unsigned int>(cmd.argument));
else
break;
case LFUN_GETXY:
- cur.message(convert<string>(cursorX(cur.top())) + ' '
- + convert<string>(cursorY(cur.top())));
+ cur.message(convert<string>(cursorX(cur.top(), cur.boundary())) + ' '
+ + convert<string>(cursorY(cur.top(), cur.boundary())));
break;
case LFUN_SETXY: {
cur.clearSelection();
string const clip = bv->getClipboard();
if (!clip.empty()) {
+ recordUndo(cur);
if (cmd.argument == "paragraph")
insertStringAsParagraphs(cur, clip);
else
cur.insert(new InsetQuotes(c,
bufparams.quotes_language,
InsetQuotes::SingleQ));
- else if (arg == "double")
+ else
cur.insert(new InsetQuotes(c,
bufparams.quotes_language,
InsetQuotes::DoubleQ));
- else
- cur.insert(new InsetQuotes(c, bufparams));
cur.posRight();
}
else
paste_internally = true;
}
- // Clear the selection
- cur.clearSelection();
-
- setCursorFromCoordinates(cur, cmd.x, cmd.y);
- cur.resetAnchor();
- finishUndo();
- cur.setTargetX();
-
- // Has the cursor just left the inset?
- if (bv->cursor().inMathed() && !cur.inMathed())
- bv->cursor().inset().notifyCursorLeaves(bv->cursor());
-
- // Set cursor here.
- bv->cursor() = cur;
+ bv->mouseSetCursor(cur);
// Insert primary selection with middle mouse
// if there is a local selection in the current buffer,
// don't set anchor_
bvcur.setCursor(cur);
bvcur.selection() = true;
- lyxerr << "MOTION: " << bv->cursor() << endl;
+ //lyxerr << "MOTION: " << bv->cursor() << endl;
}
} else
cur.clearSelection();
LyXFont const old_font = real_current_font;
- // Prevents language turds in new lyxtexts under non-english
- BufferParams const & bufparams = cur.buffer().params();
- Language const * lang = cur.paragraph().getParLanguage(bufparams);
- current_font.setLanguage(lang);
- real_current_font.setLanguage(lang);
-
string::const_iterator cit = cmd.argument.begin();
string::const_iterator end = cmd.argument.end();
for (; cit != end; ++cit)
cur.resetAnchor();
moveCursor(cur, false);
-
- needsUpdate = redoParagraph(cur.pit());
- if (!needsUpdate) {
- // update only this paragraph
- cur.bv().update(Update::SinglePar | Update::Force);
- }
-
bv->updateScrollbar();
break;
}
cur.dispatch(FuncRequest(LFUN_LAYOUT, "Caption"));
break;
- case LFUN_INDEX_INSERT:
- // Just open the inset
- doInsertInset(cur, this, cmd, true, false);
+ case LFUN_INDEX_INSERT: {
+ InsetBase * inset = createInset(&cur.bv(), cmd);
+ if (!inset)
+ break;
+
+ recordUndo(cur);
+ cur.clearSelection();
+ insertInset(cur, inset);
+ inset->edit(cur, true);
cur.posRight();
break;
+ }
case LFUN_INDEX_PRINT:
case LFUN_TOC_INSERT:
int const nargs = s1.empty() ? 0 : convert<int>(s1);
string const s2 = token(s, ' ', 2);
string const type = s2.empty() ? "newcommand" : s2;
- cur.insert(new MathMacroTemplate(token(s, ' ', 0), nargs, s2));
+ cur.insert(new MathMacroTemplate(token(s, ' ', 0), nargs, type));
//cur.nextInset()->edit(cur, true);
}
break;
case LFUN_INSERT_MATH:
case LFUN_INSERT_MATRIX:
case LFUN_MATH_DELIM: {
- cur.insert(new MathHullInset);
+ cur.insert(new MathHullInset("simple"));
cur.dispatch(FuncRequest(LFUN_RIGHT));
- cur.dispatch(FuncRequest(LFUN_MATH_MUTATE, "simple"));
cur.dispatch(cmd);
break;
}
params2string(cur.paragraph(), data);
// Will the paragraph accept changes from the dialog?
- InsetBase & inset = cur.inset();
- bool const accept = !inset.forceDefaultParagraphs(&inset);
+ bool const accept = !cur.inset().forceDefaultParagraphs(cur.idx());
data = "update " + convert<string>(accept) + '\n' + data;
bv->owner()->getDialogs().update("paragraph", data);
cur.selection() = false;
} else {
cur.undispatched();
- cmd = FuncRequest(LFUN_FINISHED_LEFT);
+ cmd = FuncRequest(LFUN_FINISHED_RIGHT);
}
break;
default:
- lyxerr << BOOST_CURRENT_FUNCTION
- << " Not DISPATCHED by LyXText" << endl;
+ lyxerr[Debug::ACTION]
+ << BOOST_CURRENT_FUNCTION
+ << ": Command " << cmd
+ << " not DISPATCHED by LyXText" << endl;
cur.undispatched();
break;
}
+ if (singleParUpdate)
+ // Inserting characters does not change par height
+ if (cur.bottom().paragraph().dim().height()
+ == olddim.height()) {
+ // if so, update _only_ this paragraph
+ cur.bv().update(Update::SinglePar | Update::Force);
+ } else
+ needsUpdate = true;
if (!needsUpdate
&& &oldTopSlice.inset() == &cur.inset()
&& oldTopSlice.idx() == cur.idx()
FuncStatus & flag) const
{
BOOST_ASSERT(cur.text() == this);
+
LyXFont const & font = real_current_font;
bool enable = true;
+ InsetBase::Code code = InsetBase::NO_CODE;
switch (cmd.action) {
enable = changeDepthAllowed(cur, INC_DEPTH);
break;
- case LFUN_INSET_OPTARG:
- enable = numberOfOptArgs(cur.paragraph())
- < cur.paragraph().layout()->optionalargs;
- break;
-
case LFUN_APPENDIX:
flag.setOnOff(cur.paragraph().params().startOfAppendix());
return true;
enable = (cur.paragraph().layout()->labeltype == LABEL_BIBLIO);
break;
-#if 0
- // the functions which insert insets
- InsetBase::Code code = InsetBase::NO_CODE;
- switch (cmd.action) {
case LFUN_DIALOG_SHOW_NEW_INSET:
if (cmd.argument == "bibitem")
code = InsetBase::BIBITEM_CODE;
break;
case LFUN_INSERT_CHARSTYLE:
code = InsetBase::CHARSTYLE_CODE;
- if (buf->params().getLyXTextClass().charstyles().empty())
+ if (cur.buffer().params().getLyXTextClass().charstyles().empty())
enable = false;
break;
case LFUN_INSERT_BOX:
break;
case LFUN_INSERT_BRANCH:
code = InsetBase::BRANCH_CODE;
- if (buf->params().branchlist().empty())
+ if (cur.buffer().getMasterBuffer()->params().branchlist().empty())
enable = false;
break;
case LFUN_INSERT_LABEL:
break;
case LFUN_INSET_OPTARG:
code = InsetBase::OPTARG_CODE;
+ enable = numberOfOptArgs(cur.paragraph())
+ < cur.paragraph().layout()->optionalargs;
break;
case LFUN_ENVIRONMENT_INSERT:
code = InsetBase::BOX_CODE;
if (cur.inTexted())
code = InsetBase::SPACE_CODE;
break;
+
+#ifdef WITH_WARNINGS
+#warning This LFUN is not used anymore and should be nuked (JMarc 29/10/2005)
+#endif
+#if 0
case LFUN_INSET_DIALOG_SHOW: {
InsetBase * inset = cur.nextInset();
enable = inset;
}
break;
}
- default:
- break;
- }
-
- if (code != InsetBase::NO_CODE
- && (cur.empty() || !cur.inset().insetAllowed(code)))
- enable = false;
-
#endif
- case LFUN_DIALOG_SHOW_NEW_INSET:
- case LFUN_INSET_ERT:
- case LFUN_INSERT_BOX:
- case LFUN_INSERT_BRANCH:
- case LFUN_ENVIRONMENT_INSERT:
- case LFUN_INDEX_INSERT:
- case LFUN_INDEX_PRINT:
- case LFUN_TOC_INSERT:
- case LFUN_HTMLURL:
- case LFUN_URL:
- case LFUN_QUOTE:
- case LFUN_HYPHENATION:
- case LFUN_LIGATURE_BREAK:
- case LFUN_HFILL:
- case LFUN_MENU_SEPARATOR:
- case LFUN_LDOTS:
- case LFUN_END_OF_SENTENCE:
- case LFUN_SPACE_INSERT:
- case LFUN_INSET_DIALOG_SHOW:
- break;
-
case LFUN_INSET_MODIFY:
// We need to disable this, because we may get called for a
// tabular cell via
flag.setOnOff(font.family() == LyXFont::TYPEWRITER_FAMILY);
return true;
+ case LFUN_CUT:
+ case LFUN_COPY:
+ enable = cur.selection();
+ break;
+
+ case LFUN_PASTE:
+ enable = lyx::cap::numberOfSelections() > 0;
+ break;
+
case LFUN_DELETE_WORD_FORWARD:
case LFUN_DELETE_WORD_BACKWARD:
case LFUN_DELETE_LINE_FORWARD:
case LFUN_LOWCASE_WORD:
case LFUN_CAPITALIZE_WORD:
case LFUN_TRANSPOSE_CHARS:
- case LFUN_PASTE:
- case LFUN_CUT:
- case LFUN_COPY:
case LFUN_GETXY:
case LFUN_SETXY:
case LFUN_GETFONT:
case LFUN_PASTESELECTION:
case LFUN_DATE_INSERT:
case LFUN_SELFINSERT:
- case LFUN_INSERT_LABEL:
- case LFUN_INSERT_NOTE:
- case LFUN_INSERT_CHARSTYLE:
- case LFUN_INSET_FLOAT:
- case LFUN_INSET_FOOTNOTE:
- case LFUN_INSET_MARGINAL:
- case LFUN_INSET_WIDE_FLOAT:
- case LFUN_INSET_WRAP:
- case LFUN_TABULAR_INSERT:
case LFUN_INSERT_LINE:
case LFUN_INSERT_PAGEBREAK:
case LFUN_MATH_DISPLAY:
case LFUN_HUNG_UMLAUT:
case LFUN_CIRCLE:
case LFUN_OGONEK:
- case LFUN_FLOAT_LIST:
case LFUN_ACCEPT_CHANGE:
case LFUN_REJECT_CHANGE:
case LFUN_THESAURUS_ENTRY:
case LFUN_PARAGRAPH_APPLY:
case LFUN_ESCAPE:
- case LFUN_KEYMAP_TOGGLE:
case LFUN_ENDBUF:
case LFUN_BEGINNINGBUF:
case LFUN_BEGINNINGBUFSEL:
default:
return false;
}
+
+ if (code != InsetBase::NO_CODE
+ && (cur.empty() || !cur.inset().insetAllowed(code)))
+ enable = false;
+
flag.enabled(enable);
return true;
}
projects / lyx.git / blobdiff