X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext3.C;h=5dfb32b086db03385cc4c4cb25b1e56f67cd33a7;hb=da65e2b7fbe29c5bca2812a56d5bbdb7efb702e5;hp=daf8a9ab7216eb6825835c9f4273700d5af815b1;hpb=342cdf432246110db37bee4e0aebb4b72c933ddb;p=lyx.git diff --git a/src/text3.C b/src/text3.C index daf8a9ab72..5dfb32b086 100644 --- a/src/text3.C +++ b/src/text3.C @@ -17,9 +17,11 @@ #include "lyxtext.h" +#include "BranchList.h" #include "FloatList.h" #include "FuncStatus.h" #include "buffer.h" +#include "buffer_funcs.h" #include "bufferparams.h" #include "BufferView.h" #include "cursor.h" @@ -32,6 +34,7 @@ #include "gettext.h" #include "intl.h" #include "language.h" +#include "LyXAction.h" #include "lyxfunc.h" #include "lyxlex.h" #include "lyxrc.h" @@ -41,6 +44,7 @@ #include "ParagraphParameters.h" #include "undo.h" #include "vspace.h" +#include "pariterator.h" #include "frontends/Dialogs.h" #include "frontends/LyXView.h" @@ -55,10 +59,13 @@ #include "support/lstrings.h" #include "support/lyxlib.h" #include "support/convert.h" +#include "support/lyxtime.h" #include "mathed/math_hullinset.h" #include "mathed/math_macrotemplate.h" +#include + #include #include @@ -73,10 +80,9 @@ using lyx::support::isStrUnsignedInt; using lyx::support::token; using std::endl; -using std::find; using std::string; using std::istringstream; -using std::vector; +using std::ostringstream; extern string current_layout; @@ -129,37 +135,46 @@ namespace { { recordUndo(cur); string sel = cur.selectionAsString(false); - lyxerr << "selection is: '" << sel << "'" << endl; + //lyxerr << "selection is: '" << sel << "'" << endl; + + // It may happen that sel is empty but there is a selection + replaceSelection(cur); 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_MATH_INSERT, + cmd.argument)); } else { // create a macro if we see "\\newcommand" // somewhere, and an ordinary formula // otherwise - cutSelection(cur, true, true); + istringstream is(sel); if (sel.find("\\newcommand") == string::npos && sel.find("\\def") == string::npos) { - cur.insert(new MathHullInset); - cur.dispatch(FuncRequest(LFUN_RIGHT)); - cur.dispatch(FuncRequest(LFUN_MATH_MUTATE, "simple")); - cur.dispatch(FuncRequest(LFUN_INSERT_MATH, sel)); - } else { - istringstream is(sel); + MathHullInset * formula = new MathHullInset; + LyXLex lex(0, 0); + lex.setStream(is); + formula->read(cur.buffer(), lex); + if (formula->getType() == "none") + // Don't create pseudo formulas if + // delimiters are left out + formula->mutate("simple"); + cur.insert(formula); + } else cur.insert(new MathMacroTemplate(is)); - } } cur.message(N_("Math editor mode")); } @@ -180,115 +195,50 @@ string const freefont2string() } -bool LyXText::gotoNextInset(LCursor & cur, - vector const & codes, string const & contents) -{ - BOOST_ASSERT(this == cur.text()); - pit_type end = paragraphs().size(); - pit_type pit = cur.pit(); - pos_type pos = cur.pos(); - - InsetBase * inset; - do { - if (pos + 1 < pars_[pit].size()) { - ++pos; - } else { - ++pit; - pos = 0; - } - - } while (pit != end && - !(pars_[pit].isInset(pos) && - (inset = pars_[pit].getInset(pos)) != 0 && - find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end() && - (contents.empty() || - static_cast(pars_[pit].getInset(pos))->getContents() - == contents))); - - if (pit == end) - return false; - - setCursor(cur, pit, pos, false); - return true; -} - - -void LyXText::gotoInset(LCursor & cur, - vector const & codes, bool same_content) -{ - cur.clearSelection(); - - string contents; - if (same_content - && cur.pos() < cur.lastpos() - && cur.paragraph().isInset(cur.pos())) { - InsetBase const * inset = cur.paragraph().getInset(cur.pos()); - if (find(codes.begin(), codes.end(), inset->lyxCode()) - != codes.end()) - contents = static_cast(inset)->getContents(); - } - - if (!gotoNextInset(cur, codes, contents)) { - if (cur.pos() || cur.pit() != 0) { - CursorSlice tmp = cur.top(); - cur.pit() = 0; - cur.pos() = 0; - if (!gotoNextInset(cur, codes, contents)) { - cur.top() = tmp; - cur.message(_("No more insets")); - } - } else { - cur.message(_("No more insets")); - } - } - cur.resetAnchor(); -} - - -void LyXText::gotoInset(LCursor & cur, InsetBase_code code, bool same_content) -{ - gotoInset(cur, vector(1, code), same_content); -} - - -void LyXText::cursorPrevious(LCursor & cur) +bool LyXText::cursorPrevious(LCursor & cur) { pos_type cpos = cur.pos(); lyx::pit_type cpar = cur.pit(); int x = cur.x_target(); - setCursorFromCoordinates(cur, x, 0); - 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 // simplest solution is to move to the previous row instead. - cursorUp(cur); + updated |= cursorUp(cur); } cur.bv().updateScrollbar(); finishUndo(); + return updated; } -void LyXText::cursorNext(LCursor & cur) +bool LyXText::cursorNext(LCursor & cur) { pos_type cpos = cur.pos(); lyx::pit_type cpar = cur.pit(); int x = cur.x_target(); - setCursorFromCoordinates(cur, x, cur.bv().workHeight() - 1); - 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 // simplest solution is to move to the next row instead. - cursorDown(cur); + updated |= cursorDown(cur); } cur.bv().updateScrollbar(); finishUndo(); + return updated; } @@ -302,12 +252,12 @@ void specialChar(LCursor & cur, InsetSpecialChar::Kind kind) } -void doInsertInset(LCursor & cur, LyXText * text, +bool doInsertInset(LCursor & cur, LyXText * text, FuncRequest const & cmd, bool edit, bool pastesel) { InsetBase * inset = createInset(&cur.bv(), cmd); if (!inset) - return; + return false; recordUndo(cur); bool gotsel = false; @@ -322,6 +272,7 @@ void doInsertInset(LCursor & cur, LyXText * text, if (gotsel && pastesel) cur.bv().owner()->dispatch(FuncRequest(LFUN_PASTE)); + return true; } @@ -329,7 +280,7 @@ void update(LCursor & cur) { //we don't call update(true, false) directly to save a metrics call if (cur.bv().fitCursor()) - cur.bv().update(false, true); + cur.bv().update(Update::Force); } @@ -353,20 +304,62 @@ bool LyXText::isRTL(Paragraph const & par) const 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 sl = cur.top(); + CursorSlice oldTopSlice = cur.top(); + bool oldBoundary = cur.boundary(); bool sel = cur.selection(); - bool moving = false; + // 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_PARAGRAPH_MOVE_DOWN: { + pit_type const pit = cur.pit(); + recUndo(pit, pit + 1); + finishUndo(); + std::swap(pars_[pit], pars_[pit + 1]); + + ParIterator begin(cur); + ++cur.pit(); + ParIterator end = boost::next(ParIterator(cur)); + updateLabels(cur.buffer(), begin, end); + + needsUpdate = true; + break; + } + + case LFUN_PARAGRAPH_MOVE_UP: { + pit_type const pit = cur.pit(); + recUndo(pit - 1, pit); + finishUndo(); + std::swap(pars_[pit], pars_[pit - 1]); + + ParIterator end = boost::next(ParIterator(cur)); + --cur.pit(); + ParIterator begin(cur); + updateLabels(cur.buffer(), begin, end); + + needsUpdate = true; + break; + } + case LFUN_APPENDIX: { Paragraph & par = cur.paragraph(); bool start = !par.params().startOfAppendix(); +#ifdef WITH_WARNINGS +#warning The code below only makes sense at top level. +// Should LFUN_APPENDIX be restricted to top-level paragraphs? +#endif // ensure that we have only one start_of_appendix in this document for (pit_type tmp = 0, end = pars_.size(); tmp != end; ++tmp) { if (pars_[tmp].params().startOfAppendix()) { @@ -380,197 +373,214 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) par.params().startOfAppendix(start); // we can set the refreshing parameters now - updateCounters(); + updateLabels(cur.buffer()); break; } - case LFUN_DELETE_WORD_FORWARD: + case LFUN_DELETE_FORWARD_WORD_FORWARD: cur.clearSelection(); deleteWordForward(cur); finishChange(cur, false); break; - case LFUN_DELETE_WORD_BACKWARD: + case LFUN_DELETE_FORWARD_WORD_BACKWARD: cur.clearSelection(); deleteWordBackward(cur); finishChange(cur, false); break; - case LFUN_DELETE_LINE_FORWARD: + case LFUN_DELETE_FORWARD_LINE_FORWARD: cur.clearSelection(); deleteLineForward(cur); finishChange(cur, false); break; - case LFUN_WORDRIGHT: - moving = true; + case LFUN_WORD_FORWARD: if (!cur.mark()) cur.clearSelection(); if (isRTL(cur.paragraph())) - cursorLeftOneWord(cur); + needsUpdate = cursorLeftOneWord(cur); else - cursorRightOneWord(cur); + needsUpdate = cursorRightOneWord(cur); finishChange(cur, false); break; - case LFUN_WORDLEFT: - moving = true; + case LFUN_WORD_BACKWARD: if (!cur.mark()) cur.clearSelection(); if (isRTL(cur.paragraph())) - cursorRightOneWord(cur); + needsUpdate = cursorRightOneWord(cur); else - cursorLeftOneWord(cur); + needsUpdate = cursorLeftOneWord(cur); finishChange(cur, false); break; - case LFUN_BEGINNINGBUF: - if (cur.size() == 1) { + case LFUN_BUFFER_BEGIN: + if (cur.depth() == 1) { if (!cur.mark()) cur.clearSelection(); - cursorTop(cur); + needsUpdate = cursorTop(cur); finishChange(cur, false); } else { cur.undispatched(); } break; - case LFUN_BEGINNINGBUFSEL: - if (cur.size() == 1) { + case LFUN_BUFFER_BEGINSEL: + if (cur.depth() == 1) { if (!cur.selection()) cur.resetAnchor(); - cursorTop(cur); + needsUpdate = cursorTop(cur); finishChange(cur, true); } else { cur.undispatched(); } break; - case LFUN_ENDBUF: - if (cur.size() == 1) { + case LFUN_BUFFER_END: + if (cur.depth() == 1) { if (!cur.mark()) cur.clearSelection(); - cursorBottom(cur); + needsUpdate = cursorBottom(cur); finishChange(cur, false); } else { cur.undispatched(); } break; - case LFUN_ENDBUFSEL: - if (cur.size() == 1) { + case LFUN_BUFFER_ENDSEL: + if (cur.depth() == 1) { if (!cur.selection()) cur.resetAnchor(); - cursorBottom(cur); + needsUpdate = cursorBottom(cur); finishChange(cur, true); } else { cur.undispatched(); } break; - case LFUN_RIGHT: - moving = true; - case LFUN_RIGHTSEL: - //lyxerr << "handle LFUN_RIGHT[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_RIGHTSEL); + case LFUN_CHAR_FORWARD: + case LFUN_CHAR_FORWARDSEL: + //lyxerr << BOOST_CURRENT_FUNCTION + // << " LFUN_CHAR_FORWARD[SEL]:\n" << cur << endl; + cur.selHandle(cmd.action == LFUN_CHAR_FORWARDSEL); if (isRTL(cur.paragraph())) - cursorLeft(cur); + needsUpdate = cursorLeft(cur); else - cursorRight(cur); - if (sl == cur.top()) { + needsUpdate = cursorRight(cur); + + if (!needsUpdate && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_RIGHT); } break; - case LFUN_LEFT: - moving = true; - case LFUN_LEFTSEL: - //lyxerr << "handle LFUN_LEFT[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_LEFTSEL); + case LFUN_CHAR_BACKWARD: + case LFUN_BACKWARD_SELECT: + //lyxerr << "handle LFUN_CHAR_BACKWARD[SEL]:\n" << cur << endl; + cur.selHandle(cmd.action == LFUN_BACKWARD_SELECT); if (isRTL(cur.paragraph())) - cursorRight(cur); + needsUpdate = cursorRight(cur); else - cursorLeft(cur); - if (sl == cur.top()) { + needsUpdate = cursorLeft(cur); + + if (!needsUpdate && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_LEFT); } break; case LFUN_UP: - moving = true; - case LFUN_UPSEL: + case LFUN_UP_SELECT: update(cur); //lyxerr << "handle LFUN_UP[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_UPSEL); - cursorUp(cur); - if (sl == cur.top()) { + cur.selHandle(cmd.action == LFUN_UP_SELECT); + + needsUpdate = cursorUp(cur); + if (!needsUpdate && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_UP); } break; case LFUN_DOWN: - moving = true; - case LFUN_DOWNSEL: + case LFUN_DOWN_SELECT: update(cur); //lyxerr << "handle LFUN_DOWN[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_DOWNSEL); - cursorDown(cur); - if (sl == cur.top()) { + cur.selHandle(cmd.action == LFUN_DOWN_SELECT); + needsUpdate = cursorDown(cur); + if (!needsUpdate && oldTopSlice == cur.top() && + cur.boundary() == oldBoundary) + { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_DOWN); } break; - case LFUN_UP_PARAGRAPHSEL: + case LFUN_PARAGRAPH_UP: + if (!cur.mark()) + cur.clearSelection(); + needsUpdate = cursorUpParagraph(cur); + finishChange(cur, false); + break; + + case LFUN_PARAGRAPH_UPSEL: if (!cur.selection()) cur.resetAnchor(); cursorUpParagraph(cur); finishChange(cur, true); break; - case LFUN_DOWN_PARAGRAPHSEL: + case LFUN_PARAGRAPH_DOWN: + if (!cur.mark()) + cur.clearSelection(); + needsUpdate = cursorDownParagraph(cur); + finishChange(cur, false); + break; + + case LFUN_PARAGRAPH_DOWNSEL: if (!cur.selection()) cur.resetAnchor(); cursorDownParagraph(cur); finishChange(cur, true); break; - case LFUN_PRIORSEL: + case LFUN_SCREEN_UPSEL: update(cur); if (!cur.selection()) cur.resetAnchor(); - cursorPrevious(cur); + needsUpdate = cursorPrevious(cur); finishChange(cur, true); break; - case LFUN_NEXTSEL: + case LFUN_SCREEN_DOWNSEL: update(cur); if (!cur.selection()) cur.resetAnchor(); - cursorNext(cur); + needsUpdate = cursorNext(cur); finishChange(cur, true); break; - case LFUN_HOMESEL: + case LFUN_LINE_BEGINSEL: update(cur); if (!cur.selection()) cur.resetAnchor(); - cursorHome(cur); + needsUpdate = cursorHome(cur); finishChange(cur, true); break; - case LFUN_ENDSEL: + case LFUN_LINE_ENDSEL: update(cur); if (!cur.selection()) cur.resetAnchor(); - cursorEnd(cur); + needsUpdate = cursorEnd(cur); finishChange(cur, true); break; - case LFUN_WORDRIGHTSEL: + case LFUN_WORD_FORWARDSEL: if (!cur.selection()) cur.resetAnchor(); if (isRTL(cur.paragraph())) @@ -580,7 +590,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) finishChange(cur, true); break; - case LFUN_WORDLEFTSEL: + case LFUN_WORD_BACKWARDSEL: if (!cur.selection()) cur.resetAnchor(); if (isRTL(cur.paragraph())) @@ -590,31 +600,14 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) finishChange(cur, true); break; - case LFUN_WORDSEL: { + case LFUN_WORD_SELECT: { selectWord(cur, lyx::WHOLE_WORD); finishChange(cur, true); break; } - case LFUN_UP_PARAGRAPH: - moving = true; - if (!cur.mark()) - cur.clearSelection(); - cursorUpParagraph(cur); - finishChange(cur, false); - break; - - case LFUN_DOWN_PARAGRAPH: - moving = true; - if (!cur.mark()) - cur.clearSelection(); - cursorDownParagraph(cur); - finishChange(cur, false); - break; - - case LFUN_PRIOR: + case LFUN_SCREEN_UP: update(cur); - moving = true; if (!cur.mark()) cur.clearSelection(); finishChange(cur, false); @@ -622,13 +615,12 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_UP); } else { - cursorPrevious(cur); + needsUpdate = cursorPrevious(cur); } break; - case LFUN_NEXT: + case LFUN_SCREEN_DOWN: update(cur); - moving = true; if (!cur.mark()) cur.clearSelection(); finishChange(cur, false); @@ -637,25 +629,25 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_DOWN); } else { - cursorNext(cur); + needsUpdate = cursorNext(cur); } break; - case LFUN_HOME: + case LFUN_LINE_BEGIN: if (!cur.mark()) cur.clearSelection(); - cursorHome(cur); + needsUpdate = cursorHome(cur); finishChange(cur, false); break; - case LFUN_END: + case LFUN_LINE_END: if (!cur.mark()) cur.clearSelection(); - cursorEnd(cur); + needsUpdate = cursorEnd(cur); finishChange(cur, false); break; - case LFUN_BREAKLINE: { + case LFUN_BREAK_LINE: { // Not allowed by LaTeX (labels or empty par) if (cur.pos() > cur.paragraph().beginOfBody()) { lyx::cap::replaceSelection(cur); @@ -666,26 +658,30 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_DELETE: + case LFUN_DELETE_FORWARD: if (!cur.selection()) { - Delete(cur); + if (cur.pos() == cur.paragraph().size()) + // Par boundary, force full-screen update + singleParUpdate = false; + needsUpdate = erase(cur); cur.resetAnchor(); // It is possible to make it a lot faster still // just comment out the line below... } else { cutSelection(cur, true, false); + singleParUpdate = false; } moveCursor(cur, false); break; - case LFUN_DELETE_SKIP: - // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP. + case LFUN_DELETE_FORWARD_SKIP: + // Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP. if (!cur.selection()) { if (cur.pos() == cur.lastpos()) { cursorRight(cur); cursorLeft(cur); } - Delete(cur); + erase(cur); cur.resetAnchor(); } else { cutSelection(cur, true, false); @@ -693,22 +689,26 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; - case LFUN_BACKSPACE: + case LFUN_DELETE_FORWARD_BACKWARD: if (!cur.selection()) { if (bv->owner()->getIntl().getTransManager().backspace()) { - backspace(cur); + // Par boundary, full-screen update + if (cur.pos() == 0) + singleParUpdate = false; + needsUpdate = backspace(cur); cur.resetAnchor(); // It is possible to make it a lot faster still // just comment out the line below... } } else { cutSelection(cur, true, false); + singleParUpdate = false; } bv->switchKeyMap(); break; - case LFUN_BACKSPACE_SKIP: - // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP. + case LFUN_DELETE_FORWARD_BACKWARD_SKIP: + // Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP. if (!cur.selection()) { #ifdef WITH_WARNINGS #warning look here @@ -721,23 +721,23 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } break; - case LFUN_BREAKPARAGRAPH: + case LFUN_BREAK_PARAGRAPH: lyx::cap::replaceSelection(cur); breakParagraph(cur, 0); cur.resetAnchor(); bv->switchKeyMap(); break; - case LFUN_BREAKPARAGRAPHKEEPLAYOUT: + case LFUN_BREAK_PARAGRAPHKEEPLAYOUT: lyx::cap::replaceSelection(cur); breakParagraph(cur, 1); cur.resetAnchor(); bv->switchKeyMap(); break; - case LFUN_BREAKPARAGRAPH_SKIP: { + case LFUN_BREAK_PARAGRAPH_SKIP: { // When at the beginning of a paragraph, remove - // indentation. Otherwise, do the same as LFUN_BREAKPARAGRAPH. + // indentation. Otherwise, do the same as LFUN_BREAK_PARAGRAPH. lyx::cap::replaceSelection(cur); if (cur.pos() == 0) cur.paragraph().params().labelWidthString(string()); @@ -787,19 +787,6 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_INSET_APPLY: { - string const name = cmd.getArg(0); - InsetBase * inset = bv->owner()->getDialogs().getOpenInset(name); - if (inset) { - FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument); - inset->dispatch(cur, fr); - } else { - FuncRequest fr(LFUN_INSET_INSERT, cmd.argument); - dispatch(cur, fr); - } - break; - } - case LFUN_INSET_INSERT: { recordUndo(cur); InsetBase * inset = createInset(bv, cmd); @@ -811,26 +798,31 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } case LFUN_INSET_SETTINGS: - if (cur.inset().asUpdatableInset()) - cur.inset().asUpdatableInset()->showInsetDialog(bv); + cur.inset().showInsetDialog(bv); break; - case LFUN_NEXT_INSET_TOGGLE: { + case LFUN_SCREEN_DOWN_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, ' '); @@ -841,48 +833,45 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) moveCursor(cur, false); break; - case LFUN_HYPHENATION: + case LFUN_HYPHENATION_POINT_INSERT: specialChar(cur, InsetSpecialChar::HYPHENATION); break; - case LFUN_LIGATURE_BREAK: + case LFUN_LIGATURE_BREAK_INSERT: specialChar(cur, InsetSpecialChar::LIGATURE_BREAK); break; - case LFUN_LDOTS: + case LFUN_DOTS_INSERT: specialChar(cur, InsetSpecialChar::LDOTS); break; - case LFUN_END_OF_SENTENCE: + case LFUN_LINE_END_OF_SENTENCE_PERIOD_INSERT: specialChar(cur, InsetSpecialChar::END_OF_SENTENCE); break; - case LFUN_MENU_SEPARATOR: + case LFUN_MENU_SEPARATOR_INSERT: specialChar(cur, InsetSpecialChar::MENU_SEPARATOR); break; - case LFUN_UPCASE_WORD: + case LFUN_WORD_UPCASE: changeCase(cur, LyXText::text_uppercase); break; - case LFUN_LOWCASE_WORD: + case LFUN_WORD_LOWCASE: changeCase(cur, LyXText::text_lowercase); break; - case LFUN_CAPITALIZE_WORD: + case LFUN_WORD_CAPITALIZE: changeCase(cur, LyXText::text_capitalization); break; - case LFUN_TRANSPOSE_CHARS: + case LFUN_CHARS_TRANSPOSE: recordUndo(cur); break; 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(cmd.argument)); else @@ -902,12 +891,12 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.message(_("Copy")); break; - case LFUN_GETXY: - cur.message(convert(cursorX(cur.top())) + ' ' - + convert(cursorY(cur.top()))); + case LFUN_SERVER_GET_XY: + cur.message(convert(cursorX(cur.top(), cur.boundary())) + ' ' + + convert(cursorY(cur.top(), cur.boundary()))); break; - case LFUN_SETXY: { + case LFUN_SERVER_SET_XY: { int x = 0; int y = 0; istringstream is(cmd.argument); @@ -920,7 +909,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_GETFONT: + case LFUN_SERVER_GET_FONT: if (current_font.shape() == LyXFont::ITALIC_SHAPE) cur.message("E"); else if (current_font.shape() == LyXFont::SMALLCAPS_SHAPE) @@ -929,7 +918,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.message("0"); break; - case LFUN_GETLAYOUT: + case LFUN_SERVER_GET_LAYOUT: cur.message(cur.paragraph().layout()->name()); break; @@ -991,10 +980,11 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_PASTESELECTION: { + case LFUN_PRIMARY_SELECTION_PASTE: { cur.clearSelection(); string const clip = bv->getClipboard(); if (!clip.empty()) { + recordUndo(cur); if (cmd.argument == "paragraph") insertStringAsParagraphs(cur, clip); else @@ -1003,27 +993,11 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_GOTOERROR: - gotoInset(cur, InsetBase::ERROR_CODE, false); - break; - - case LFUN_GOTONOTE: - gotoInset(cur, InsetBase::NOTE_CODE, false); - break; - - case LFUN_REFERENCE_GOTO: { - vector tmp; - tmp.push_back(InsetBase::LABEL_CODE); - tmp.push_back(InsetBase::REF_CODE); - gotoInset(cur, tmp, true); - break; - } - - case LFUN_QUOTE: { + case LFUN_QUOTE_INSERT: { lyx::cap::replaceSelection(cur); Paragraph & par = cur.paragraph(); lyx::pos_type pos = cur.pos(); - char c; + lyx::char_type c; if (pos == 0) c = ' '; else if (cur.prevInset() && cur.prevInset()->isSpace()) @@ -1041,40 +1015,25 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) 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 - bv->owner()->dispatch(FuncRequest(LFUN_SELFINSERT, "\"")); + bv->owner()->dispatch(FuncRequest(LFUN_SELF_INSERT, "\"")); break; } - case LFUN_DATE_INSERT: { - lyx::cap::replaceSelection(cur); - time_t now_time_t = time(NULL); - struct tm * now_tm = localtime(&now_time_t); - setlocale(LC_TIME, ""); - string arg; - if (!cmd.argument.empty()) - arg = cmd.argument; + case LFUN_DATE_INSERT: + if (cmd.argument.empty()) + bv->owner()->dispatch(FuncRequest(LFUN_SELF_INSERT, + lyx::formatted_time(lyx::current_time()))); else - arg = lyxrc.date_insert_format; - char datetmp[32]; - int const datetmp_len = - ::strftime(datetmp, 32, arg.c_str(), now_tm); - - for (int i = 0; i < datetmp_len; i++) - insertChar(cur, datetmp[i]); - - cur.resetAnchor(); - moveCursor(cur, false); + bv->owner()->dispatch(FuncRequest(LFUN_SELF_INSERT, + lyx::formatted_time(lyx::current_time(), cmd.argument))); break; - } case LFUN_MOUSE_TRIPLE: if (cmd.button() == mouse_button::button1) { @@ -1082,6 +1041,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.resetAnchor(); cursorEnd(cur); cur.setSelection(); + bv->cursor() = cur; bv->haveSelection(cur.selection()); } break; @@ -1089,6 +1049,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_MOUSE_DOUBLE: if (cmd.button() == mouse_button::button1) { selectWord(cur, lyx::WHOLE_WORD_STRICT); + bv->cursor() = cur; bv->haveSelection(cur.selection()); } break; @@ -1096,10 +1057,8 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // Single-click on work area case LFUN_MOUSE_PRESS: { // Right click on a footnote flag opens float menu - if (cmd.button() == mouse_button::button3) { + if (cmd.button() == mouse_button::button3) cur.clearSelection(); - break; - } // Middle button press pastes if we have a selection // We do this here as if the selection was inside an inset @@ -1111,20 +1070,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) 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, @@ -1133,7 +1079,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (paste_internally) bv->owner()->dispatch(FuncRequest(LFUN_PASTE)); else - bv->owner()->dispatch(FuncRequest(LFUN_PASTESELECTION, "paragraph")); + bv->owner()->dispatch(FuncRequest(LFUN_PRIMARY_SELECTION_PASTE, "paragraph")); } break; @@ -1172,7 +1118,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // don't set anchor_ bvcur.setCursor(cur); bvcur.selection() = true; - lyxerr << "MOTION: " << bv->cursor() << endl; + //lyxerr << "MOTION: " << bv->cursor() << endl; } } else @@ -1194,7 +1140,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_SELFINSERT: { + case LFUN_SELF_INSERT: { if (cmd.argument.empty()) break; @@ -1217,33 +1163,29 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) string::const_iterator end = cmd.argument.end(); for (; cit != end; ++cit) bv->owner()->getIntl().getTransManager(). - TranslateAndInsert(*cit, this); + translateAndInsert(*cit, this); cur.resetAnchor(); moveCursor(cur, false); - - // real_current_font.number can change so we need to - // update the minibuffer - if (old_font != real_current_font) bv->updateScrollbar(); break; } - case LFUN_URL: { + case LFUN_URL_INSERT: { InsetCommandParams p("url"); string const data = InsetCommandMailer::params2string("url", p); bv->owner()->getDialogs().show("url", data, 0); break; } - case LFUN_HTMLURL: { + case LFUN_HTML_INSERT: { InsetCommandParams p("htmlurl"); string const data = InsetCommandMailer::params2string("url", p); bv->owner()->getDialogs().show("url", data, 0); break; } - case LFUN_INSERT_LABEL: { + case LFUN_LABEL_INSERT: { // Try to generate a valid label string const contents = cmd.argument.empty() ? cur.getPossibleLabel() : cmd.argument; @@ -1262,23 +1204,19 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) #if 0 - case LFUN_INSET_LIST: - case LFUN_INSET_THEOREM: - case LFUN_INSET_CAPTION: + case LFUN_LIST_INSERT: + case LFUN_THEOREM_INSERT: + case LFUN_CAPTION_INSERT: #endif - case LFUN_INSERT_NOTE: - case LFUN_INSERT_CHARSTYLE: - case LFUN_INSERT_BOX: - case LFUN_INSERT_BRANCH: - case LFUN_INSERT_BIBITEM: - case LFUN_INSET_ERT: - case LFUN_INSET_FLOAT: - case LFUN_INSET_FOOTNOTE: - case LFUN_INSET_MARGINAL: - case LFUN_INSET_OPTARG: - case LFUN_INSET_WIDE_FLOAT: - case LFUN_INSET_WRAP: - case LFUN_TABULAR_INSERT: + case LFUN_NOTE_INSERT: + case LFUN_CHARSTYLE_INSERT: + case LFUN_BOX_INSERT: + case LFUN_BRANCH_INSERT: + case LFUN_BIBITEM_INSERT: + case LFUN_ERT_INSERT: + case LFUN_FOOTNOTE_INSERT: + case LFUN_MARGINALNOTE_INSERT: + case LFUN_OPTIONAL_INSERT: case LFUN_ENVIRONMENT_INSERT: // Open the inset, and move the current selection // inside it. @@ -1286,27 +1224,53 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.posRight(); break; - case LFUN_INDEX_INSERT: - // Just open the inset - doInsertInset(cur, this, cmd, true, false); + case LFUN_TABULAR_INSERT: + // if there were no arguments, just open the dialog + if (doInsertInset(cur, this, cmd, false, true)) + cur.posRight(); + else + bv->owner()->getDialogs().show("tabularcreate"); + + break; + + case LFUN_FLOAT_INSERT: + case LFUN_FLOAT_WIDE_INSERT: + case LFUN_WRAP_INSERT: + doInsertInset(cur, this, cmd, true, true); cur.posRight(); + // FIXME: the "Caption" name should not be hardcoded, + // but given by the float definition. + cur.dispatch(FuncRequest(LFUN_LAYOUT, "Caption")); break; + 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: - case LFUN_HFILL: - case LFUN_INSERT_LINE: - case LFUN_INSERT_PAGEBREAK: + case LFUN_HFILL_INSERT: + case LFUN_LINE_INSERT: + case LFUN_PAGEBREAK_INSERT: // do nothing fancy doInsertInset(cur, this, cmd, false, false); cur.posRight(); break; - case LFUN_DEPTH_MIN: + case LFUN_DEPTH_DECREMENT: changeDepth(cur, DEC_DEPTH); break; - case LFUN_DEPTH_PLUS: + case LFUN_DEPTH_INCREMENT: changeDepth(cur, INC_DEPTH); break; @@ -1332,78 +1296,77 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) int const nargs = s1.empty() ? 0 : convert(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; // passthrough hat and underscore outside mathed: - case LFUN_SUBSCRIPT: - mathDispatch(cur, FuncRequest(LFUN_SELFINSERT, "_"), false); + case LFUN_MATH_SUBSCRIPT: + mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "_"), false); break; - case LFUN_SUPERSCRIPT: - mathDispatch(cur, FuncRequest(LFUN_SELFINSERT, "^"), false); + case LFUN_MATH_SUPERSCRIPT: + mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "^"), false); break; - case LFUN_INSERT_MATH: - case LFUN_INSERT_MATRIX: + case LFUN_MATH_INSERT: + case LFUN_MATH_MATRIX: case LFUN_MATH_DELIM: { - cur.insert(new MathHullInset); - cur.dispatch(FuncRequest(LFUN_RIGHT)); - cur.dispatch(FuncRequest(LFUN_MATH_MUTATE, "simple")); + cur.insert(new MathHullInset("simple")); + cur.dispatch(FuncRequest(LFUN_CHAR_FORWARD)); cur.dispatch(cmd); break; } - case LFUN_EMPH: { + case LFUN_FONT_EMPH: { LyXFont font(LyXFont::ALL_IGNORE); font.setEmph(LyXFont::TOGGLE); toggleAndShow(cur, this, font); break; } - case LFUN_BOLD: { + case LFUN_FONT_BOLD: { LyXFont font(LyXFont::ALL_IGNORE); font.setSeries(LyXFont::BOLD_SERIES); toggleAndShow(cur, this, font); break; } - case LFUN_NOUN: { + case LFUN_FONT_NOUN: { LyXFont font(LyXFont::ALL_IGNORE); font.setNoun(LyXFont::TOGGLE); toggleAndShow(cur, this, font); break; } - case LFUN_CODE: { + case LFUN_FONT_CODE: { LyXFont font(LyXFont::ALL_IGNORE); font.setFamily(LyXFont::TYPEWRITER_FAMILY); // no good toggleAndShow(cur, this, font); break; } - case LFUN_SANS: { + case LFUN_FONT_SANS: { LyXFont font(LyXFont::ALL_IGNORE); font.setFamily(LyXFont::SANS_FAMILY); toggleAndShow(cur, this, font); break; } - case LFUN_ROMAN: { + case LFUN_FONT_ROMAN: { LyXFont font(LyXFont::ALL_IGNORE); font.setFamily(LyXFont::ROMAN_FAMILY); toggleAndShow(cur, this, font); break; } - case LFUN_DEFAULT: { + case LFUN_FONT_DEFAULT: { LyXFont font(LyXFont::ALL_INHERIT, ignore_language); toggleAndShow(cur, this, font); break; } - case LFUN_UNDERLINE: { + case LFUN_FONT_UNDERLINE: { LyXFont font(LyXFont::ALL_IGNORE); font.setUnderbar(LyXFont::TOGGLE); toggleAndShow(cur, this, font); @@ -1428,14 +1391,14 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_FREEFONT_APPLY: + case LFUN_FONT_FREE_APPLY: toggleAndShow(cur, this, freefont, toggleall); cur.message(_("Character set")); break; // Set the freefont using the contents of \param data dispatched from // the frontends and apply it at the current cursor location. - case LFUN_FREEFONT_UPDATE: { + case LFUN_FONT_FREE_UPDATE: { LyXFont font; bool toggle; if (bv_funcs::string2font(cmd.argument, font, toggle)) { @@ -1481,35 +1444,34 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) 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(accept) + '\n' + data; bv->owner()->getDialogs().update("paragraph", data); break; } - case LFUN_UMLAUT: - case LFUN_CIRCUMFLEX: - case LFUN_GRAVE: - case LFUN_ACUTE: - case LFUN_TILDE: - case LFUN_CEDILLA: - case LFUN_MACRON: - case LFUN_DOT: - case LFUN_UNDERDOT: - case LFUN_UNDERBAR: - case LFUN_CARON: - case LFUN_SPECIAL_CARON: - case LFUN_BREVE: - case LFUN_TIE: - case LFUN_HUNG_UMLAUT: - case LFUN_CIRCLE: - case LFUN_OGONEK: + case LFUN_ACCENT_UMLAUT: + case LFUN_ACCENT_CIRCUMFLEX: + case LFUN_ACCENT_GRAVE: + case LFUN_ACCENT_ACUTE: + case LFUN_ACCENT_TILDE: + case LFUN_ACCENT_CEDILLA: + case LFUN_ACCENT_MACRON: + case LFUN_ACCENT_DOT: + case LFUN_ACCENT_UNDERDOT: + case LFUN_ACCENT_UNDERBAR: + case LFUN_ACCENT_CARON: + case LFUN_ACCENT_SPECIAL_CARON: + case LFUN_ACCENT_BREVE: + case LFUN_ACCENT_TIE: + case LFUN_ACCENT_HUNGARIAN_UMLAUT: + case LFUN_ACCENT_CIRCLE: + case LFUN_ACCENT_OGONEK: bv->owner()->getLyXFunc().handleKeyFunc(cmd.action); if (!cmd.argument.empty()) bv->owner()->getIntl().getTransManager() - .TranslateAndInsert(cmd.argument[0], this); + .translateAndInsert(cmd.argument[0], this); break; case LFUN_FLOAT_LIST: { @@ -1561,7 +1523,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_PARAGRAPH_APPLY: { + case LFUN_PARAGRAPH_PARAMS_APPLY: { // Given data, an encoding of the ParagraphParameters // generated in the Paragraph dialog, this function sets // the current paragraph appropriately. @@ -1593,22 +1555,39 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.selection() = false; } else { cur.undispatched(); - cmd = FuncRequest(LFUN_FINISHED_LEFT); + cmd = FuncRequest(LFUN_FINISHED_RIGHT); } break; default: + lyxerr[Debug::ACTION] + << BOOST_CURRENT_FUNCTION + << ": Command " << cmd + << " not DISPATCHED by LyXText" << endl; cur.undispatched(); break; } - // avoid to update when navigating - if (moving - && &sl.inset() == &cur.inset() - && sl.idx() == cur.idx() - && sel == false - && cur.selection() == false) + 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::FitCursor | + Update::MultiParSel); + cur.noUpdate(); + return; + } else + needsUpdate = true; + if (!needsUpdate + && &oldTopSlice.inset() == &cur.inset() + && oldTopSlice.idx() == cur.idx() + && !sel + && !cur.selection()) cur.noUpdate(); + else + cur.needsUpdate(); } @@ -1616,32 +1595,29 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, 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) { - case LFUN_DEPTH_MIN: + case LFUN_DEPTH_DECREMENT: enable = changeDepthAllowed(cur, DEC_DEPTH); break; - case LFUN_DEPTH_PLUS: + case LFUN_DEPTH_INCREMENT: 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; + + case LFUN_BIBITEM_INSERT: + 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; @@ -1681,60 +1657,62 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, code = InsetBase::WRAP_CODE; break; - case LFUN_INSET_ERT: + case LFUN_ERT_INSERT: code = InsetBase::ERT_CODE; break; - case LFUN_INSET_FOOTNOTE: + case LFUN_FOOTNOTE_INSERT: code = InsetBase::FOOT_CODE; break; case LFUN_TABULAR_INSERT: code = InsetBase::TABULAR_CODE; break; - case LFUN_INSET_MARGINAL: + case LFUN_MARGINALNOTE_INSERT: code = InsetBase::MARGIN_CODE; break; - case LFUN_INSET_FLOAT: - case LFUN_INSET_WIDE_FLOAT: + case LFUN_FLOAT_INSERT: + case LFUN_FLOAT_WIDE_INSERT: code = InsetBase::FLOAT_CODE; break; - case LFUN_INSET_WRAP: + case LFUN_WRAP_INSERT: code = InsetBase::WRAP_CODE; break; case LFUN_FLOAT_LIST: code = InsetBase::FLOAT_LIST_CODE; break; #if 0 - case LFUN_INSET_LIST: + case LFUN_LIST_INSERT: code = InsetBase::LIST_CODE; break; - case LFUN_INSET_THEOREM: + case LFUN_THEOREM_INSERT: code = InsetBase::THEOREM_CODE; break; #endif - case LFUN_INSET_CAPTION: + case LFUN_CAPTION_INSERT: code = InsetBase::CAPTION_CODE; break; - case LFUN_INSERT_NOTE: + case LFUN_NOTE_INSERT: code = InsetBase::NOTE_CODE; break; - case LFUN_INSERT_CHARSTYLE: + case LFUN_CHARSTYLE_INSERT: code = InsetBase::CHARSTYLE_CODE; - if (buf->params().getLyXTextClass().charstyles().empty()) + if (cur.buffer().params().getLyXTextClass().charstyles().empty()) enable = false; break; - case LFUN_INSERT_BOX: + case LFUN_BOX_INSERT: code = InsetBase::BOX_CODE; break; - case LFUN_INSERT_BRANCH: + case LFUN_BRANCH_INSERT: code = InsetBase::BRANCH_CODE; - if (buf->params().branchlist().empty()) + if (cur.buffer().getMasterBuffer()->params().branchlist().empty()) enable = false; break; - case LFUN_INSERT_LABEL: + case LFUN_LABEL_INSERT: code = InsetBase::LABEL_CODE; break; - case LFUN_INSET_OPTARG: + case LFUN_OPTIONAL_INSERT: code = InsetBase::OPTARG_CODE; + enable = numberOfOptArgs(cur.paragraph()) + < cur.paragraph().layout()->optionalargs; break; case LFUN_ENVIRONMENT_INSERT: code = InsetBase::BOX_CODE; @@ -1748,20 +1726,20 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, case LFUN_TOC_INSERT: code = InsetBase::TOC_CODE; break; - case LFUN_HTMLURL: - case LFUN_URL: + case LFUN_HTML_INSERT: + case LFUN_URL_INSERT: code = InsetBase::URL_CODE; break; - case LFUN_QUOTE: + case LFUN_QUOTE_INSERT: // always allow this, since we will inset a raw quote // if an inset is not allowed. break; - case LFUN_HYPHENATION: - case LFUN_LIGATURE_BREAK: - case LFUN_HFILL: - case LFUN_MENU_SEPARATOR: - case LFUN_LDOTS: - case LFUN_END_OF_SENTENCE: + case LFUN_HYPHENATION_POINT_INSERT: + case LFUN_LIGATURE_BREAK_INSERT: + case LFUN_HFILL_INSERT: + case LFUN_MENU_SEPARATOR_INSERT: + case LFUN_DOTS_INSERT: + case LFUN_LINE_END_OF_SENTENCE_PERIOD_INSERT: code = InsetBase::SPECIALCHAR_CODE; break; case LFUN_SPACE_INSERT: @@ -1769,6 +1747,11 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, 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; @@ -1782,176 +1765,155 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, } 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: + case LFUN_INSET_MODIFY: + // We need to disable this, because we may get called for a + // tabular cell via + // InsetTabular::getStatus() -> InsetText::getStatus() + // and we don't handle LFUN_INSET_MODIFY. + enable = false; break; - case LFUN_EMPH: + case LFUN_FONT_EMPH: flag.setOnOff(font.emph() == LyXFont::ON); - break; + return true; - case LFUN_NOUN: + case LFUN_FONT_NOUN: flag.setOnOff(font.noun() == LyXFont::ON); - break; + return true; - case LFUN_BOLD: + case LFUN_FONT_BOLD: flag.setOnOff(font.series() == LyXFont::BOLD_SERIES); - break; + return true; - case LFUN_SANS: + case LFUN_FONT_SANS: flag.setOnOff(font.family() == LyXFont::SANS_FAMILY); - break; + return true; - case LFUN_ROMAN: + case LFUN_FONT_ROMAN: flag.setOnOff(font.family() == LyXFont::ROMAN_FAMILY); - break; + return true; - case LFUN_CODE: + case LFUN_FONT_CODE: flag.setOnOff(font.family() == LyXFont::TYPEWRITER_FAMILY); + return true; + + case LFUN_CUT: + case LFUN_COPY: + enable = cur.selection(); break; - case LFUN_DELETE_WORD_FORWARD: - case LFUN_DELETE_WORD_BACKWARD: - case LFUN_DELETE_LINE_FORWARD: - case LFUN_WORDRIGHT: - case LFUN_WORDLEFT: - case LFUN_RIGHT: - case LFUN_RIGHTSEL: - case LFUN_LEFT: - case LFUN_LEFTSEL: + case LFUN_PASTE: + enable = lyx::cap::numberOfSelections() > 0; + break; + + case LFUN_PARAGRAPH_MOVE_UP: { + enable = cur.pit() > 0 && !cur.selection(); + break; + } + + case LFUN_PARAGRAPH_MOVE_DOWN: { + enable = cur.pit() < cur.lastpit() && !cur.selection(); + break; + } + + case LFUN_DELETE_FORWARD_WORD_FORWARD: + case LFUN_DELETE_FORWARD_WORD_BACKWARD: + case LFUN_DELETE_FORWARD_LINE_FORWARD: + case LFUN_WORD_FORWARD: + case LFUN_WORD_BACKWARD: + case LFUN_CHAR_FORWARD: + case LFUN_CHAR_FORWARDSEL: + case LFUN_CHAR_BACKWARD: + case LFUN_BACKWARD_SELECT: case LFUN_UP: - case LFUN_UPSEL: + case LFUN_UP_SELECT: case LFUN_DOWN: - case LFUN_DOWNSEL: - case LFUN_UP_PARAGRAPHSEL: - case LFUN_DOWN_PARAGRAPHSEL: - case LFUN_PRIORSEL: - case LFUN_NEXTSEL: - case LFUN_HOMESEL: - case LFUN_ENDSEL: - case LFUN_WORDRIGHTSEL: - case LFUN_WORDLEFTSEL: - case LFUN_WORDSEL: - case LFUN_UP_PARAGRAPH: - case LFUN_DOWN_PARAGRAPH: - case LFUN_PRIOR: - case LFUN_NEXT: - case LFUN_HOME: - case LFUN_END: - case LFUN_BREAKLINE: - case LFUN_DELETE: - case LFUN_DELETE_SKIP: - case LFUN_BACKSPACE: - case LFUN_BACKSPACE_SKIP: - case LFUN_BREAKPARAGRAPH: - case LFUN_BREAKPARAGRAPHKEEPLAYOUT: - case LFUN_BREAKPARAGRAPH_SKIP: + case LFUN_DOWN_SELECT: + case LFUN_PARAGRAPH_UPSEL: + case LFUN_PARAGRAPH_DOWNSEL: + case LFUN_SCREEN_UPSEL: + case LFUN_SCREEN_DOWNSEL: + case LFUN_LINE_BEGINSEL: + case LFUN_LINE_ENDSEL: + case LFUN_WORD_FORWARDSEL: + case LFUN_WORD_BACKWARDSEL: + case LFUN_WORD_SELECT: + case LFUN_PARAGRAPH_UP: + case LFUN_PARAGRAPH_DOWN: + case LFUN_SCREEN_UP: + case LFUN_SCREEN_DOWN: + case LFUN_LINE_BEGIN: + case LFUN_LINE_END: + case LFUN_BREAK_LINE: + case LFUN_DELETE_FORWARD: + case LFUN_DELETE_FORWARD_SKIP: + case LFUN_DELETE_FORWARD_BACKWARD: + case LFUN_DELETE_FORWARD_BACKWARD_SKIP: + case LFUN_BREAK_PARAGRAPH: + case LFUN_BREAK_PARAGRAPHKEEPLAYOUT: + case LFUN_BREAK_PARAGRAPH_SKIP: case LFUN_PARAGRAPH_SPACING: - case LFUN_INSET_APPLY: case LFUN_INSET_INSERT: - case LFUN_NEXT_INSET_TOGGLE: - case LFUN_UPCASE_WORD: - 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_GETLAYOUT: + case LFUN_SCREEN_DOWN_INSET_TOGGLE: + case LFUN_WORD_UPCASE: + case LFUN_WORD_LOWCASE: + case LFUN_WORD_CAPITALIZE: + case LFUN_CHARS_TRANSPOSE: + case LFUN_SERVER_GET_XY: + case LFUN_SERVER_SET_XY: + case LFUN_SERVER_GET_FONT: + case LFUN_SERVER_GET_LAYOUT: case LFUN_LAYOUT: - case LFUN_PASTESELECTION: - case LFUN_GOTOERROR: - case LFUN_GOTONOTE: - case LFUN_REFERENCE_GOTO: + case LFUN_PRIMARY_SELECTION_PASTE: case LFUN_DATE_INSERT: - case LFUN_SELFINSERT: - case LFUN_INSERT_LABEL: - case LFUN_INSERT_NOTE: - case LFUN_INSERT_CHARSTYLE: - case LFUN_INSERT_BIBITEM: - 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_SELF_INSERT: + case LFUN_LINE_INSERT: + case LFUN_PAGEBREAK_INSERT: case LFUN_MATH_DISPLAY: case LFUN_MATH_IMPORT_SELECTION: case LFUN_MATH_MODE: case LFUN_MATH_MACRO: - case LFUN_INSERT_MATH: - case LFUN_INSERT_MATRIX: + case LFUN_MATH_INSERT: + case LFUN_MATH_MATRIX: case LFUN_MATH_DELIM: - case LFUN_SUBSCRIPT: - case LFUN_SUPERSCRIPT: - case LFUN_DEFAULT: - case LFUN_UNDERLINE: + case LFUN_MATH_SUBSCRIPT: + case LFUN_MATH_SUPERSCRIPT: + case LFUN_FONT_DEFAULT: + case LFUN_FONT_UNDERLINE: case LFUN_FONT_SIZE: case LFUN_LANGUAGE: - case LFUN_FREEFONT_APPLY: - case LFUN_FREEFONT_UPDATE: + case LFUN_FONT_FREE_APPLY: + case LFUN_FONT_FREE_UPDATE: case LFUN_LAYOUT_PARAGRAPH: case LFUN_PARAGRAPH_UPDATE: - case LFUN_UMLAUT: - case LFUN_CIRCUMFLEX: - case LFUN_GRAVE: - case LFUN_ACUTE: - case LFUN_TILDE: - case LFUN_CEDILLA: - case LFUN_MACRON: - case LFUN_DOT: - case LFUN_UNDERDOT: - case LFUN_UNDERBAR: - case LFUN_CARON: - case LFUN_SPECIAL_CARON: - case LFUN_BREVE: - case LFUN_TIE: - case LFUN_HUNG_UMLAUT: - case LFUN_CIRCLE: - case LFUN_OGONEK: - case LFUN_FLOAT_LIST: + case LFUN_ACCENT_UMLAUT: + case LFUN_ACCENT_CIRCUMFLEX: + case LFUN_ACCENT_GRAVE: + case LFUN_ACCENT_ACUTE: + case LFUN_ACCENT_TILDE: + case LFUN_ACCENT_CEDILLA: + case LFUN_ACCENT_MACRON: + case LFUN_ACCENT_DOT: + case LFUN_ACCENT_UNDERDOT: + case LFUN_ACCENT_UNDERBAR: + case LFUN_ACCENT_CARON: + case LFUN_ACCENT_SPECIAL_CARON: + case LFUN_ACCENT_BREVE: + case LFUN_ACCENT_TIE: + case LFUN_ACCENT_HUNGARIAN_UMLAUT: + case LFUN_ACCENT_CIRCLE: + case LFUN_ACCENT_OGONEK: case LFUN_ACCEPT_CHANGE: case LFUN_REJECT_CHANGE: case LFUN_THESAURUS_ENTRY: - case LFUN_PARAGRAPH_APPLY: + case LFUN_PARAGRAPH_PARAMS_APPLY: case LFUN_ESCAPE: - case LFUN_KEYMAP_TOGGLE: - case LFUN_ENDBUF: - case LFUN_BEGINNINGBUF: - case LFUN_BEGINNINGBUFSEL: - case LFUN_ENDBUFSEL: + case LFUN_BUFFER_END: + case LFUN_BUFFER_BEGIN: + case LFUN_BUFFER_BEGINSEL: + case LFUN_BUFFER_ENDSEL: // these are handled in our dispatch() enable = true; break; @@ -1959,6 +1921,11 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, default: return false; } + + if (code != InsetBase::NO_CODE + && (cur.empty() || !cur.inset().insetAllowed(code))) + enable = false; + flag.enabled(enable); return true; }