X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext3.C;h=9fb01eda4f153259b3307df1a09148b06d5424b3;hb=35204f8f33d7400a5fefeffea533fb4cb4097211;hp=5f3323a0cd1bde047fb0003de8e1d11b9596b99c;hpb=20af9e85559789af33e6d0504005677a9e715e5c;p=lyx.git diff --git a/src/text3.C b/src/text3.C index 5f3323a0cd..9fb01eda4f 100644 --- a/src/text3.C +++ b/src/text3.C @@ -17,6 +17,7 @@ #include "lyxtext.h" +#include "BranchList.h" #include "FloatList.h" #include "FuncStatus.h" #include "buffer.h" @@ -28,6 +29,7 @@ #include "CutAndPaste.h" #include "debug.h" #include "dispatchresult.h" +#include "errorlist.h" #include "factory.h" #include "funcrequest.h" #include "gettext.h" @@ -43,9 +45,10 @@ #include "ParagraphParameters.h" #include "undo.h" #include "vspace.h" +#include "pariterator.h" -#include "frontends/Dialogs.h" -#include "frontends/LyXView.h" +#include "frontends/Clipboard.h" +#include "frontends/Selection.h" #include "insets/insetcommand.h" #include "insets/insetfloatlist.h" @@ -59,27 +62,29 @@ #include "support/convert.h" #include "support/lyxtime.h" -#include "mathed/math_hullinset.h" -#include "mathed/math_macrotemplate.h" +#include "mathed/InsetMathHull.h" +#include "mathed/MathMacroTemplate.h" #include #include #include -using lyx::pos_type; -using lyx::cap::copySelection; -using lyx::cap::cutSelection; -using lyx::cap::pasteSelection; -using lyx::cap::replaceSelection; +namespace lyx { -using lyx::support::isStrUnsignedInt; -using lyx::support::token; +using cap::copySelection; +using cap::cutSelection; +using cap::pasteSelection; +using cap::replaceSelection; + +using support::isStrUnsignedInt; +using support::token; using std::endl; using std::string; using std::istringstream; +using std::ostringstream; extern string current_layout; @@ -116,7 +121,7 @@ namespace { if (selecting || cur.mark()) cur.setSelection(); if (!cur.selection()) - cur.bv().haveSelection(false); + theSelection().haveSelection(false); cur.bv().switchKeyMap(); } @@ -131,12 +136,15 @@ namespace { void mathDispatch(LCursor & cur, FuncRequest const & cmd, bool display) { recordUndo(cur); - string sel = cur.selectionAsString(false); + docstring sel = cur.selectionAsString(false); //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("simple")); + cur.insert(new InsetMathHull(hullSimple)); BOOST_ASSERT(old_pos == cur.pos()); cur.nextInset()->edit(cur, true); // don't do that also for LFUN_MATH_MODE @@ -147,26 +155,31 @@ namespace { cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY)); // Avoid an unnecessary undo step if cmd.argument // is empty - if (!cmd.argument.empty()) - cur.dispatch(FuncRequest(LFUN_INSERT_MATH, - cmd.argument)); + 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); - if (sel.find("\\newcommand") == string::npos - && sel.find("\\def") == string::npos) + if (sel.find(from_ascii("\\newcommand")) == string::npos + && sel.find(from_ascii("\\def")) == string::npos) { - cur.insert(new MathHullInset("simple")); - cur.dispatch(FuncRequest(LFUN_RIGHT)); - cur.dispatch(FuncRequest(LFUN_INSERT_MATH, sel)); + InsetMathHull * formula = new InsetMathHull; + istringstream is(to_utf8(sel)); + LyXLex lex(0, 0); + lex.setStream(is); + formula->read(cur.buffer(), lex); + if (formula->getType() == hullNone) + // Don't create pseudo formulas if + // delimiters are left out + formula->mutate(hullSimple); + cur.insert(formula); } else { - istringstream is(sel); - cur.insert(new MathMacroTemplate(is)); + cur.insert(new MathMacroTemplate(sel)); } } - cur.message(N_("Math editor mode")); + cur.message(from_utf8(N_("Math editor mode"))); } } // namespace anon @@ -188,7 +201,7 @@ string const freefont2string() bool LyXText::cursorPrevious(LCursor & cur) { pos_type cpos = cur.pos(); - lyx::pit_type cpar = cur.pit(); + pit_type cpar = cur.pit(); int x = cur.x_target(); @@ -203,7 +216,6 @@ bool LyXText::cursorPrevious(LCursor & cur) updated |= cursorUp(cur); } - cur.bv().updateScrollbar(); finishUndo(); return updated; } @@ -212,7 +224,7 @@ bool LyXText::cursorPrevious(LCursor & cur) bool LyXText::cursorNext(LCursor & cur) { pos_type cpos = cur.pos(); - lyx::pit_type cpar = cur.pit(); + pit_type cpar = cur.pit(); int x = cur.x_target(); bool updated = setCursorFromCoordinates(cur, x, cur.bv().workHeight() - 1); @@ -226,7 +238,6 @@ bool LyXText::cursorNext(LCursor & cur) updated |= cursorDown(cur); } - cur.bv().updateScrollbar(); finishUndo(); return updated; } @@ -236,7 +247,7 @@ namespace { void specialChar(LCursor & cur, InsetSpecialChar::Kind kind) { - lyx::cap::replaceSelection(cur); + cap::replaceSelection(cur); cur.insert(new InsetSpecialChar(kind)); cur.posRight(); } @@ -252,7 +263,7 @@ bool doInsertInset(LCursor & cur, LyXText * text, recordUndo(cur); bool gotsel = false; if (cur.selection()) { - cur.bv().owner()->dispatch(FuncRequest(LFUN_CUT)); + lyx::dispatch(FuncRequest(LFUN_CUT)); gotsel = true; } text->insertInset(cur, inset); @@ -260,20 +271,19 @@ bool doInsertInset(LCursor & cur, LyXText * text, if (edit) inset->edit(cur, true); - if (gotsel && pastesel) - cur.bv().owner()->dispatch(FuncRequest(LFUN_PASTE)); + if (gotsel && pastesel) { + lyx::dispatch(FuncRequest(LFUN_PASTE)); + // reset first par to default + if (cur.lastpit() != 0 || cur.lastpos() != 0) { + LyXLayout_ptr const layout = + cur.buffer().params().getLyXTextClass().defaultLayout(); + cur.text()->paragraphs().begin()->layout(layout); + } + } return true; } -void update(LCursor & cur) -{ - //we don't call update(true, false) directly to save a metrics call - if (cur.bv().fitCursor()) - cur.bv().update(Update::Force); -} - - } // anon namespace @@ -285,9 +295,9 @@ void LyXText::number(LCursor & cur) } -bool LyXText::isRTL(Paragraph const & par) const +bool LyXText::isRTL(Buffer const & buffer, Paragraph const & par) const { - return par.isRightToLeftPar(bv()->buffer()->params()); + return par.isRightToLeftPar(buffer.params()); } @@ -295,6 +305,11 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) { lyxerr[Debug::ACTION] << "LyXText::dispatch: cmd: " << cmd << endl; + // FIXME: We use the update flag to indicates wether a singlePar or a + // full screen update is needed. We reset it here but shall we restore it + // at the end? + cur.noUpdate(); + BOOST_ASSERT(cur.text() == this); BufferView * bv = &cur.bv(); CursorSlice oldTopSlice = cur.top(); @@ -305,13 +320,43 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) bool singleParUpdate = lyxaction.funcHasFlag(cmd.action, LyXAction::SingleParUpdate); // Signals that a full-screen update is required - bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action, + bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action, LyXAction::NoUpdate) || singleParUpdate); - // Remember the old paragraph metric - Dimension olddim = cur.paragraph().dim(); + // 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(cur, 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(cur, 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(); @@ -323,7 +368,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // 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()) { - recUndo(tmp); + recUndo(cur, tmp); pars_[tmp].params().startOfAppendix(false); break; } @@ -333,101 +378,57 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) par.params().startOfAppendix(start); // we can set the refreshing parameters now - updateCounters(cur.buffer()); + updateLabels(cur.buffer()); break; } - case LFUN_DELETE_WORD_FORWARD: + case LFUN_WORD_DELETE_FORWARD: cur.clearSelection(); deleteWordForward(cur); finishChange(cur, false); break; - case LFUN_DELETE_WORD_BACKWARD: + case LFUN_WORD_DELETE_BACKWARD: cur.clearSelection(); deleteWordBackward(cur); finishChange(cur, false); break; - case LFUN_DELETE_LINE_FORWARD: + case LFUN_LINE_DELETE: cur.clearSelection(); deleteLineForward(cur); finishChange(cur, false); break; - case LFUN_WORDRIGHT: - if (!cur.mark()) - cur.clearSelection(); - if (isRTL(cur.paragraph())) - needsUpdate = cursorLeftOneWord(cur); - else - needsUpdate = cursorRightOneWord(cur); - finishChange(cur, false); - break; - - case LFUN_WORDLEFT: - if (!cur.mark()) - cur.clearSelection(); - if (isRTL(cur.paragraph())) - needsUpdate = cursorRightOneWord(cur); - else - needsUpdate = cursorLeftOneWord(cur); - finishChange(cur, false); - break; - - case LFUN_BEGINNINGBUF: + case LFUN_BUFFER_BEGIN: + case LFUN_BUFFER_BEGIN_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_BEGIN_SELECT); if (cur.depth() == 1) { - if (!cur.mark()) - cur.clearSelection(); - cursorTop(cur); - finishChange(cur, false); + needsUpdate |= cursorTop(cur); } else { cur.undispatched(); } break; - case LFUN_BEGINNINGBUFSEL: + case LFUN_BUFFER_END: + case LFUN_BUFFER_END_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_END_SELECT); if (cur.depth() == 1) { - if (!cur.selection()) - cur.resetAnchor(); - cursorTop(cur); - finishChange(cur, true); - } else { - cur.undispatched(); - } - break; - - case LFUN_ENDBUF: - if (cur.depth() == 1) { - if (!cur.mark()) - cur.clearSelection(); - cursorBottom(cur); - finishChange(cur, false); + needsUpdate |= cursorBottom(cur); } else { cur.undispatched(); } break; - case LFUN_ENDBUFSEL: - if (cur.depth() == 1) { - if (!cur.selection()) - cur.resetAnchor(); - cursorBottom(cur); - finishChange(cur, true); - } else { - cur.undispatched(); - } - break; - - case LFUN_RIGHT: - case LFUN_RIGHTSEL: + case LFUN_CHAR_FORWARD: + case LFUN_CHAR_FORWARD_SELECT: //lyxerr << BOOST_CURRENT_FUNCTION - // << " LFUN_RIGHT[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_RIGHTSEL); - if (isRTL(cur.paragraph())) - needsUpdate = cursorLeft(cur); + // << " LFUN_CHAR_FORWARD[SEL]:\n" << cur << endl; + needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT); + if (isRTL(*cur.bv().buffer(), cur.paragraph())) + needsUpdate |= cursorLeft(cur); else - needsUpdate = cursorRight(cur); + needsUpdate |= cursorRight(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { @@ -436,14 +437,14 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } break; - case LFUN_LEFT: - case LFUN_LEFTSEL: - //lyxerr << "handle LFUN_LEFT[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_LEFTSEL); - if (isRTL(cur.paragraph())) - needsUpdate = cursorRight(cur); + case LFUN_CHAR_BACKWARD: + case LFUN_CHAR_BACKWARD_SELECT: + //lyxerr << "handle LFUN_CHAR_BACKWARD[_SELECT]:\n" << cur << endl; + needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT); + if (isRTL(*cur.bv().buffer(), cur.paragraph())) + needsUpdate |= cursorRight(cur); else - needsUpdate = cursorLeft(cur); + needsUpdate |= cursorLeft(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { @@ -453,12 +454,12 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; case LFUN_UP: - case LFUN_UPSEL: - update(cur); + case LFUN_UP_SELECT: //lyxerr << "handle LFUN_UP[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_UPSEL); + needsUpdate |= cur.selHandle(cmd.action == LFUN_UP_SELECT); + + needsUpdate |= cursorUp(cur); - needsUpdate = cursorUp(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); @@ -467,11 +468,11 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; case LFUN_DOWN: - case LFUN_DOWNSEL: - update(cur); + case LFUN_DOWN_SELECT: //lyxerr << "handle LFUN_DOWN[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_DOWNSEL); - needsUpdate = cursorDown(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_DOWN_SELECT); + needsUpdate |= cursorDown(cur); + if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { @@ -480,137 +481,81 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } break; - case LFUN_UP_PARAGRAPH: - if (!cur.mark()) - cur.clearSelection(); - needsUpdate = cursorUpParagraph(cur); - finishChange(cur, false); - break; - - case LFUN_UP_PARAGRAPHSEL: - if (!cur.selection()) - cur.resetAnchor(); - cursorUpParagraph(cur); - finishChange(cur, true); + case LFUN_PARAGRAPH_UP: + case LFUN_PARAGRAPH_UP_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_UP_SELECT); + needsUpdate |= cursorUpParagraph(cur); break; - case LFUN_DOWN_PARAGRAPH: - if (!cur.mark()) - cur.clearSelection(); - needsUpdate = cursorDownParagraph(cur); - finishChange(cur, false); - break; - - case LFUN_DOWN_PARAGRAPHSEL: - if (!cur.selection()) - cur.resetAnchor(); - cursorDownParagraph(cur); - finishChange(cur, true); + case LFUN_PARAGRAPH_DOWN: + case LFUN_PARAGRAPH_DOWN_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_DOWN_SELECT); + needsUpdate |= cursorDownParagraph(cur); break; - case LFUN_PRIORSEL: - update(cur); - if (!cur.selection()) - cur.resetAnchor(); - cursorPrevious(cur); - finishChange(cur, true); - break; - - case LFUN_NEXTSEL: - update(cur); - if (!cur.selection()) - cur.resetAnchor(); - cursorNext(cur); - finishChange(cur, true); - break; - - case LFUN_HOMESEL: - update(cur); - if (!cur.selection()) - cur.resetAnchor(); - cursorHome(cur); - finishChange(cur, true); - break; - - case LFUN_ENDSEL: - update(cur); - if (!cur.selection()) - cur.resetAnchor(); - cursorEnd(cur); - finishChange(cur, true); - break; - - case LFUN_WORDRIGHTSEL: - if (!cur.selection()) - cur.resetAnchor(); - if (isRTL(cur.paragraph())) - cursorLeftOneWord(cur); - else - cursorRightOneWord(cur); - finishChange(cur, true); - break; - - case LFUN_WORDLEFTSEL: - if (!cur.selection()) - cur.resetAnchor(); - if (isRTL(cur.paragraph())) - cursorRightOneWord(cur); - else - cursorLeftOneWord(cur); - finishChange(cur, true); - break; - - case LFUN_WORDSEL: { - selectWord(cur, lyx::WHOLE_WORD); - finishChange(cur, true); - break; - } - - case LFUN_PRIOR: - update(cur); - if (!cur.mark()) - cur.clearSelection(); - finishChange(cur, false); + case LFUN_SCREEN_UP: + case LFUN_SCREEN_UP_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_UP_SELECT); if (cur.pit() == 0 && cur.textRow().pos() == 0) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_UP); } else { - needsUpdate = cursorPrevious(cur); + needsUpdate |= cursorPrevious(cur); } break; - case LFUN_NEXT: - update(cur); - if (!cur.mark()) - cur.clearSelection(); - finishChange(cur, false); + case LFUN_SCREEN_DOWN: + case LFUN_SCREEN_DOWN_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_DOWN_SELECT); if (cur.pit() == cur.lastpit() && cur.textRow().endpos() == cur.lastpos()) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_DOWN); } else { - needsUpdate = cursorNext(cur); + needsUpdate |= cursorNext(cur); } break; - case LFUN_HOME: - if (!cur.mark()) - cur.clearSelection(); - cursorHome(cur); - finishChange(cur, false); + case LFUN_LINE_BEGIN: + case LFUN_LINE_BEGIN_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT); + needsUpdate |= cursorHome(cur); break; - case LFUN_END: - if (!cur.mark()) - cur.clearSelection(); - cursorEnd(cur); - finishChange(cur, false); + case LFUN_LINE_END: + case LFUN_LINE_END_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_END_SELECT); + needsUpdate |= cursorEnd(cur); + break; + + case LFUN_WORD_FORWARD: + case LFUN_WORD_FORWARD_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT); + if (isRTL(*cur.bv().buffer(), cur.paragraph())) + needsUpdate |= cursorLeftOneWord(cur); + else + needsUpdate |= cursorRightOneWord(cur); + break; + + case LFUN_WORD_BACKWARD: + case LFUN_WORD_BACKWARD_SELECT: + needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT); + if (isRTL(*cur.bv().buffer(), cur.paragraph())) + needsUpdate |= cursorRightOneWord(cur); + else + needsUpdate |= cursorLeftOneWord(cur); break; - case LFUN_BREAKLINE: { + case LFUN_WORD_SELECT: { + selectWord(cur, WHOLE_WORD); + finishChange(cur, true); + break; + } + + case LFUN_BREAK_LINE: { // Not allowed by LaTeX (labels or empty par) if (cur.pos() > cur.paragraph().beginOfBody()) { - lyx::cap::replaceSelection(cur); + cap::replaceSelection(cur); cur.insert(new InsetNewline); cur.posRight(); moveCursor(cur, false); @@ -618,26 +563,30 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_DELETE: + case LFUN_CHAR_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); @@ -645,22 +594,26 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; - case LFUN_BACKSPACE: + case LFUN_CHAR_DELETE_BACKWARD: if (!cur.selection()) { - if (bv->owner()->getIntl().getTransManager().backspace()) { - backspace(cur); + if (bv->getIntl().getTransManager().backspace()) { + // 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_BACKWARD_SKIP: + // Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP. if (!cur.selection()) { #ifdef WITH_WARNINGS #warning look here @@ -673,26 +626,26 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } break; - case LFUN_BREAKPARAGRAPH: - lyx::cap::replaceSelection(cur); + case LFUN_BREAK_PARAGRAPH: + cap::replaceSelection(cur); breakParagraph(cur, 0); cur.resetAnchor(); bv->switchKeyMap(); break; - case LFUN_BREAKPARAGRAPHKEEPLAYOUT: - lyx::cap::replaceSelection(cur); + case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT: + 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. - lyx::cap::replaceSelection(cur); + // indentation. Otherwise, do the same as LFUN_BREAK_PARAGRAPH. + cap::replaceSelection(cur); if (cur.pos() == 0) - cur.paragraph().params().labelWidthString(string()); + cur.paragraph().params().labelWidthString(docstring()); else breakParagraph(cur, 0); cur.resetAnchor(); @@ -707,7 +660,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (cur_spacing == Spacing::Other) cur_value = par.params().spacing().getValueAsString(); - istringstream is(cmd.argument); + istringstream is(to_utf8(cmd.argument())); string tmp; is >> tmp; Spacing::Space new_spacing = cur_spacing; @@ -731,8 +684,8 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } else if (tmp == "default") { new_spacing = Spacing::Default; } else { - lyxerr << _("Unknown spacing argument: ") - << cmd.argument << endl; + lyxerr << to_utf8(_("Unknown spacing argument: ")) + << to_utf8(cmd.argument()) << endl; } if (cur_spacing != new_spacing || cur_value != new_value) par.params().spacing(Spacing(new_spacing, new_value)); @@ -749,24 +702,12 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_INSET_SETTINGS: - cur.inset().showInsetDialog(bv); - break; - - case LFUN_NEXT_INSET_TOGGLE: { - InsetBase * inset = cur.nextInset(); - if (inset) { - cur.clearSelection(); - FuncRequest fr = cmd; - fr.action = LFUN_INSET_TOGGLE; - inset->dispatch(cur, fr); - } + case LFUN_INSET_DISSOLVE: + needsUpdate |= dissolveInset(cur); break; - } - case LFUN_KEYMAP_TOGGLE: - cur.clearSelection(); - bv->switchKeyMap(); + case LFUN_INSET_SETTINGS: + cur.inset().showInsetDialog(bv); break; case LFUN_SPACE_INSERT: @@ -779,52 +720,52 @@ 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_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: - recordUndo(cur); + case LFUN_CHARS_TRANSPOSE: + charsTranspose(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)); + cap::replaceSelection(cur); + if (isStrUnsignedInt(to_utf8(cmd.argument()))) + pasteSelection(cur, bv->buffer()->errorList("Paste"), + convert(to_utf8(cmd.argument()))); else - pasteSelection(cur, 0); + pasteSelection(cur, bv->buffer()->errorList("Paste"), + 0); + bv->buffer()->errors("Paste"); cur.clearSelection(); // bug 393 bv->switchKeyMap(); finishUndo(); @@ -840,56 +781,48 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.message(_("Copy")); break; - case LFUN_GETXY: - cur.message(convert(cursorX(cur.top(), cur.boundary())) + ' ' - + convert(cursorY(cur.top(), cur.boundary()))); + case LFUN_SERVER_GET_XY: + cur.message(from_utf8( + convert(cursorX(cur.buffer(), 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); + istringstream is(to_utf8(cmd.argument())); is >> x >> y; if (!is) lyxerr << "SETXY: Could not parse coordinates in '" - << cmd.argument << std::endl; + << to_utf8(cmd.argument()) << std::endl; else setCursorFromCoordinates(cur, x, y); break; } - case LFUN_GETFONT: + case LFUN_SERVER_GET_FONT: if (current_font.shape() == LyXFont::ITALIC_SHAPE) - cur.message("E"); + cur.message(from_ascii("E")); else if (current_font.shape() == LyXFont::SMALLCAPS_SHAPE) - cur.message("N"); + cur.message(from_ascii("N")); else - cur.message("0"); + cur.message(from_ascii("0")); break; - case LFUN_GETLAYOUT: - cur.message(cur.paragraph().layout()->name()); + case LFUN_SERVER_GET_LAYOUT: + cur.message(from_utf8(cur.paragraph().layout()->name())); break; case LFUN_LAYOUT: { - lyxerr[Debug::INFO] << "LFUN_LAYOUT: (arg) " - << cmd.argument << endl; - - // This is not the good solution to the empty argument - // problem, but it will hopefully suffice for 1.2.0. - // The correct solution would be to augument the - // function list/array with information about what - // functions needs arguments and their type. - if (cmd.argument.empty()) { - cur.errorMessage(_("LyX function 'layout' needs an argument.")); - break; - } + string layout = to_ascii(cmd.argument()); + lyxerr[Debug::INFO] << "LFUN_LAYOUT: (arg) " << layout << endl; // Derive layout number from given argument (string) // and current buffer's textclass (number) LyXTextClass const & tclass = bv->buffer()->params().getLyXTextClass(); - bool hasLayout = tclass.hasLayout(cmd.argument); - string layout = cmd.argument; + if (layout.empty()) + layout = tclass.defaultLayoutName(); + bool hasLayout = tclass.hasLayout(layout); // If the entry is obsolete, use the new one instead. if (hasLayout) { @@ -899,8 +832,8 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } if (!hasLayout) { - cur.errorMessage(string(N_("Layout ")) + cmd.argument + - N_(" not known")); + cur.errorMessage(from_utf8(N_("Layout ")) + cmd.argument() + + from_utf8(N_(" not known"))); break; } @@ -923,18 +856,19 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (change_layout) { current_layout = layout; setLayout(cur, layout); - bv->owner()->setLayout(layout); + // inform the GUI that the layout has changed. + bv->layoutChanged(layout); bv->switchKeyMap(); } break; } - case LFUN_PASTESELECTION: { + case LFUN_CLIPBOARD_PASTE: { cur.clearSelection(); - string const clip = bv->getClipboard(); + docstring const clip = theClipboard().get(); if (!clip.empty()) { recordUndo(cur); - if (cmd.argument == "paragraph") + if (cmd.argument() == "paragraph") insertStringAsParagraphs(cur, clip); else insertStringAsLines(cur, clip); @@ -942,11 +876,39 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_QUOTE: { - lyx::cap::replaceSelection(cur); + case LFUN_PRIMARY_SELECTION_PASTE: { + cur.clearSelection(); + docstring const clip = theSelection().get(); + if (!clip.empty()) { + recordUndo(cur); + if (cmd.argument() == "paragraph") + insertStringAsParagraphs(cur, clip); + else + insertStringAsLines(cur, clip); + } + break; + } + + case LFUN_UNICODE_INSERT: { + if (cmd.argument().empty()) + break; + docstring hexstring = cmd.argument(); + if (lyx::support::isHex(hexstring)) { + char_type c = lyx::support::hexToInt(hexstring); + if (c > 32 && c < 0x10ffff) { + lyxerr << "Inserting c: " << c << endl; + docstring s = docstring(1, c); + lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, s)); + } + } + break; + } + + case LFUN_QUOTE_INSERT: { + cap::replaceSelection(cur); Paragraph & par = cur.paragraph(); - lyx::pos_type pos = cur.pos(); - char c; + pos_type pos = cur.pos(); + char_type c; if (pos == 0) c = ' '; else if (cur.prevInset() && cur.prevInset()->isSpace()) @@ -959,7 +921,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) BufferParams const & bufparams = bv->buffer()->params(); if (!style->pass_thru && par.getFontSettings(bufparams, pos).language()->lang() != "hebrew") { - string arg = cmd.argument; + string arg = to_utf8(cmd.argument()); if (arg == "single") cur.insert(new InsetQuotes(c, bufparams.quotes_language, @@ -971,17 +933,17 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.posRight(); } else - bv->owner()->dispatch(FuncRequest(LFUN_SELFINSERT, "\"")); + lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, "\"")); break; } - case LFUN_DATE_INSERT: - if (cmd.argument.empty()) - bv->owner()->dispatch(FuncRequest(LFUN_SELFINSERT, - lyx::formatted_time(lyx::current_time()))); + case LFUN_DATE_INSERT: + if (cmd.argument().empty()) + lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, + formatted_time(current_time()))); else - bv->owner()->dispatch(FuncRequest(LFUN_SELFINSERT, - lyx::formatted_time(lyx::current_time(), cmd.argument))); + lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, + formatted_time(current_time(), to_utf8(cmd.argument())))); break; case LFUN_MOUSE_TRIPLE: @@ -991,25 +953,23 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cursorEnd(cur); cur.setSelection(); bv->cursor() = cur; - bv->haveSelection(cur.selection()); + theSelection().haveSelection(cur.selection()); } break; case LFUN_MOUSE_DOUBLE: if (cmd.button() == mouse_button::button1) { - selectWord(cur, lyx::WHOLE_WORD_STRICT); + selectWord(cur, WHOLE_WORD_STRICT); bv->cursor() = cur; - bv->haveSelection(cur.selection()); + theSelection().haveSelection(cur.selection()); } break; // 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 @@ -1017,33 +977,25 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // we have to check this first bool paste_internally = false; if (cmd.button() == mouse_button::button2 && cur.selection()) { - bv->owner()->dispatch(FuncRequest(LFUN_COPY)); + lyx::dispatch(FuncRequest(LFUN_COPY)); 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, // insert this if (cmd.button() == mouse_button::button2) { if (paste_internally) - bv->owner()->dispatch(FuncRequest(LFUN_PASTE)); + lyx::dispatch(FuncRequest(LFUN_PASTE)); else - bv->owner()->dispatch(FuncRequest(LFUN_PASTESELECTION, "paragraph")); + lyx::dispatch(FuncRequest(LFUN_PRIMARY_SELECTION_PASTE, "paragraph")); + } + + if (cmd.button() == mouse_button::button1) { + needsUpdate = false; + cur.noUpdate(); } break; @@ -1095,17 +1047,19 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; // finish selection - if (cmd.button() == mouse_button::button1) - bv->haveSelection(cur.selection()); + if (cmd.button() == mouse_button::button1) { + if (cur.selection()) + theSelection().haveSelection(cur.selection()); + needsUpdate = false; + cur.noUpdate(); + } bv->switchKeyMap(); - bv->owner()->updateMenubar(); - bv->owner()->updateToolbars(); break; } - case LFUN_SELFINSERT: { - if (cmd.argument.empty()) + case LFUN_SELF_INSERT: { + if (cmd.argument().empty()) break; // Automatically delete the currently selected @@ -1117,54 +1071,51 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (lyxrc.auto_region_delete) { if (cur.selection()) cutSelection(cur, false, false); - bv->haveSelection(false); + theSelection().haveSelection(false); } 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(); + docstring::const_iterator cit = cmd.argument().begin(); + docstring::const_iterator end = cmd.argument().end(); for (; cit != end; ++cit) - bv->owner()->getIntl().getTransManager(). - TranslateAndInsert(*cit, this); +#if 0 + bv->getIntl().getTransManager(). + translateAndInsert(*cit, this); +#else + insertChar(bv->cursor(), *cit); +#endif cur.resetAnchor(); moveCursor(cur, false); - 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); + bv->showInsetDialog("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); + bv->showInsetDialog("url", data, 0); break; } - case LFUN_INSERT_LABEL: { + case LFUN_LABEL_INSERT: { + InsetCommandParams p("label"); // Try to generate a valid label - string const contents = cmd.argument.empty() ? - cur.getPossibleLabel() : cmd.argument; - - InsetCommandParams p("label", contents); + p["name"] = (cmd.argument().empty()) ? + cur.getPossibleLabel() : + cmd.argument(); string const data = InsetCommandMailer::params2string("label", p); - if (cmd.argument.empty()) { - bv->owner()->getDialogs().show("label", data, 0); + if (cmd.argument().empty()) { + bv->showInsetDialog("label", data, 0); } else { FuncRequest fr(LFUN_INSET_INSERT, data); dispatch(cur, fr); @@ -1174,19 +1125,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_FOOTNOTE: - case LFUN_INSET_MARGINAL: - case LFUN_INSET_OPTARG: + 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. @@ -1199,13 +1150,13 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (doInsertInset(cur, this, cmd, false, true)) cur.posRight(); else - bv->owner()->getDialogs().show("tabularcreate"); + bv->showDialog("tabularcreate"); break; - case LFUN_INSET_FLOAT: - case LFUN_INSET_WIDE_FLOAT: - case LFUN_INSET_WRAP: + 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, @@ -1214,26 +1165,40 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; case LFUN_INDEX_INSERT: - // Just open the inset - doInsertInset(cur, this, cmd, true, false); + case LFUN_NOMENCL_INSERT: { + InsetBase * inset = createInset(&cur.bv(), cmd); + if (!inset) + break; + + recordUndo(cur); + cur.clearSelection(); + insertInset(cur, inset); + inset->edit(cur, true); + // Show the dialog for the nomenclature entry, since the + // description entry still needs to be filled in. + if (cmd.action == LFUN_NOMENCL_INSERT) + InsetCommandMailer("nomenclature", + *reinterpret_cast(inset)).showDialog(&cur.bv()); cur.posRight(); break; + } case LFUN_INDEX_PRINT: + case LFUN_NOMENCL_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; @@ -1243,7 +1208,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_MATH_IMPORT_SELECTION: case LFUN_MATH_MODE: - if (cmd.argument == "on") + if (cmd.argument() == "on") // don't pass "on" as argument mathDispatch(cur, FuncRequest(LFUN_MATH_MODE), false); else @@ -1251,85 +1216,86 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; case LFUN_MATH_MACRO: - if (cmd.argument.empty()) - cur.errorMessage(N_("Missing argument")); + if (cmd.argument().empty()) + cur.errorMessage(from_utf8(N_("Missing argument"))); else { - string s = cmd.argument; + string s = to_utf8(cmd.argument()); string const s1 = token(s, ' ', 1); 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, type)); + cur.insert(new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, from_utf8(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_DELIM: { - cur.insert(new MathHullInset("simple")); - cur.dispatch(FuncRequest(LFUN_RIGHT)); + case LFUN_MATH_INSERT: + case LFUN_MATH_MATRIX: + case LFUN_MATH_DELIM: + case LFUN_MATH_BIGDELIM: { + cur.insert(new InsetMathHull(hullSimple)); + 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); @@ -1338,13 +1304,13 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_FONT_SIZE: { LyXFont font(LyXFont::ALL_IGNORE); - font.setLyXSize(cmd.argument); + font.setLyXSize(to_utf8(cmd.argument())); toggleAndShow(cur, this, font); break; } case LFUN_LANGUAGE: { - Language const * lang = languages.getLanguage(cmd.argument); + Language const * lang = languages.getLanguage(to_utf8(cmd.argument())); if (!lang) break; LyXFont font(LyXFont::ALL_IGNORE); @@ -1354,17 +1320,17 @@ 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)) { + if (bv_funcs::string2font(to_utf8(cmd.argument()), font, toggle)) { freefont = font; toggleall = toggle; toggleAndShow(cur, this, freefont, toggleall); @@ -1396,51 +1362,49 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) string data; params2string(cur.paragraph(), data); data = "show\n" + data; - bv->owner()->getDialogs().show("paragraph", data); + bv->showDialogWithData("paragraph", data); break; } case LFUN_PARAGRAPH_UPDATE: { - if (!bv->owner()->getDialogs().visible("paragraph")) - break; string data; 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); + bv->updateDialog("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: - bv->owner()->getLyXFunc().handleKeyFunc(cmd.action); - if (!cmd.argument.empty()) - bv->owner()->getIntl().getTransManager() - .TranslateAndInsert(cmd.argument[0], this); + 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: + theLyXFunc().handleKeyFunc(cmd.action); + if (!cmd.argument().empty()) + // FIXME: Are all these characters encoded in one byte in utf8? + bv->getIntl().getTransManager() + .translateAndInsert(cmd.argument()[0], this, cur); break; case LFUN_FLOAT_LIST: { LyXTextClass const & tclass = bv->buffer()->params().getLyXTextClass(); - if (tclass.floats().typeExist(cmd.argument)) { + if (tclass.floats().typeExist(to_utf8(cmd.argument()))) { // not quite sure if we want this... recordUndo(cur); cur.clearSelection(); @@ -1452,68 +1416,59 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } setLayout(cur, tclass.defaultLayoutName()); - setParagraph(cur, Spacing(), LYX_ALIGN_LAYOUT, string(), 0); - insertInset(cur, new InsetFloatList(cmd.argument)); + setParagraph(cur, Spacing(), LYX_ALIGN_LAYOUT, docstring(), 0); + insertInset(cur, new InsetFloatList(to_utf8(cmd.argument()))); cur.posRight(); } else { lyxerr << "Non-existent float type: " - << cmd.argument << endl; + << to_utf8(cmd.argument()) << endl; } break; } - case LFUN_ACCEPT_CHANGE: { + case LFUN_CHANGE_ACCEPT: { acceptChange(cur); break; } - case LFUN_REJECT_CHANGE: { + case LFUN_CHANGE_REJECT: { rejectChange(cur); break; } case LFUN_THESAURUS_ENTRY: { - string arg = cmd.argument; + docstring arg = cmd.argument(); if (arg.empty()) { arg = cur.selectionAsString(false); // FIXME if (arg.size() > 100 || arg.empty()) { // Get word or selection - selectWordWhenUnderCursor(cur, lyx::WHOLE_WORD); + selectWordWhenUnderCursor(cur, WHOLE_WORD); arg = cur.selectionAsString(false); } } - bv->owner()->getDialogs().show("thesaurus", arg); + bv->showDialogWithData("thesaurus", to_utf8(arg)); 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. - istringstream is(cmd.argument); + istringstream is(to_utf8(cmd.argument())); LyXLex lex(0, 0); lex.setStream(is); ParagraphParameters params; params.read(lex); setParagraph(cur, - params.spacing(), - params.align(), - params.labelWidthString(), - params.noindent()); + params.spacing(), + params.align(), + params.labelWidthString(), + params.noindent()); cur.message(_("Paragraph layout set")); break; } - case LFUN_INSET_DIALOG_SHOW: { - InsetBase * inset = cur.nextInset(); - if (inset) { - FuncRequest fr(LFUN_INSET_DIALOG_SHOW); - inset->dispatch(cur, fr); - } - break; - } - case LFUN_ESCAPE: if (cur.selection()) { cur.selection() = false; @@ -1524,30 +1479,48 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; default: - lyxerr[Debug::ACTION] + lyxerr[Debug::ACTION] << BOOST_CURRENT_FUNCTION - << ": Command " << cmd + << ": Command " << cmd << " not DISPATCHED by LyXText" << endl; cur.undispatched(); break; } + needsUpdate |= (cur.pos() != cur.lastpos()) && cur.selection(); + + // FIXME: The cursor flag is reset two lines below + // so we need to check here if some of the LFUN did touch that. + // for now only LyXText::erase() and LyXText::backspace() do that. + // The plan is to verify all the LFUNs and then to remove this + // singleParUpdate boolean altogether. + if (cur.result().update() & Update::Force) { + singleParUpdate = false; + needsUpdate = true; + } + + // FIXME: the following code should go in favor of fine grained + // update flag treatment. if (singleParUpdate) // Inserting characters does not change par height - if (cur.paragraph().dim().asc == olddim.asc - && cur.paragraph().dim().des == olddim.des) { + if (cur.bottom().paragraph().dim().height() + == olddim.height()) { // if so, update _only_ this paragraph - cur.bv().update(Update::SinglePar | Update::Force); + cur.updateFlags(Update::SinglePar | + Update::FitCursor | + Update::MultiParSel); + return; } else needsUpdate = true; + if (!needsUpdate && &oldTopSlice.inset() == &cur.inset() && oldTopSlice.idx() == cur.idx() - && !sel + && !sel // sel is a backup of cur.selection() at the biginning of the function. && !cur.selection()) cur.noUpdate(); else - cur.needsUpdate(); + cur.updateFlags(Update::Force | Update::FitCursor); } @@ -1555,129 +1528,126 @@ 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_INSERT_BIBITEM: + 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") + if (cmd.argument() == "bibitem") code = InsetBase::BIBITEM_CODE; - else if (cmd.argument == "bibtex") + else if (cmd.argument() == "bibtex") code = InsetBase::BIBTEX_CODE; - else if (cmd.argument == "box") + else if (cmd.argument() == "box") code = InsetBase::BOX_CODE; - else if (cmd.argument == "branch") + else if (cmd.argument() == "branch") code = InsetBase::BRANCH_CODE; - else if (cmd.argument == "citation") + else if (cmd.argument() == "citation") code = InsetBase::CITE_CODE; - else if (cmd.argument == "ert") + else if (cmd.argument() == "ert") code = InsetBase::ERT_CODE; - else if (cmd.argument == "external") + else if (cmd.argument() == "external") code = InsetBase::EXTERNAL_CODE; - else if (cmd.argument == "float") + else if (cmd.argument() == "float") code = InsetBase::FLOAT_CODE; - else if (cmd.argument == "graphics") + else if (cmd.argument() == "graphics") code = InsetBase::GRAPHICS_CODE; - else if (cmd.argument == "include") + else if (cmd.argument() == "include") code = InsetBase::INCLUDE_CODE; - else if (cmd.argument == "index") + else if (cmd.argument() == "index") code = InsetBase::INDEX_CODE; - else if (cmd.argument == "label") + else if (cmd.argument() == "nomenclature") + code = InsetBase::NOMENCL_CODE; + else if (cmd.argument() == "label") code = InsetBase::LABEL_CODE; - else if (cmd.argument == "note") + else if (cmd.argument() == "note") code = InsetBase::NOTE_CODE; - else if (cmd.argument == "ref") + else if (cmd.argument() == "ref") code = InsetBase::REF_CODE; - else if (cmd.argument == "toc") + else if (cmd.argument() == "toc") code = InsetBase::TOC_CODE; - else if (cmd.argument == "url") + else if (cmd.argument() == "url") code = InsetBase::URL_CODE; - else if (cmd.argument == "vspace") + else if (cmd.argument() == "vspace") code = InsetBase::VSPACE_CODE; - else if (cmd.argument == "wrap") + else if (cmd.argument() == "wrap") 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; @@ -1688,23 +1658,29 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, case LFUN_INDEX_PRINT: code = InsetBase::INDEX_PRINT_CODE; break; + case LFUN_NOMENCL_INSERT: + code = InsetBase::NOMENCL_CODE; + break; + case LFUN_NOMENCL_PRINT: + code = InsetBase::NOMENCL_PRINT_CODE; + break; 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_END_OF_SENTENCE_PERIOD_INSERT: code = InsetBase::SPECIALCHAR_CODE; break; case LFUN_SPACE_INSERT: @@ -1712,49 +1688,6 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, if (cur.inTexted()) code = InsetBase::SPACE_CODE; break; - case LFUN_INSET_DIALOG_SHOW: { - InsetBase * inset = cur.nextInset(); - enable = inset; - if (inset) { - code = inset->lyxCode(); - if (!(code == InsetBase::INCLUDE_CODE - || code == InsetBase::BIBTEX_CODE - || code == InsetBase::FLOAT_LIST_CODE - || code == InsetBase::TOC_CODE)) - enable = false; - } - 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 @@ -1764,140 +1697,151 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, enable = false; break; - case LFUN_EMPH: + case LFUN_FONT_EMPH: flag.setOnOff(font.emph() == LyXFont::ON); return true; - case LFUN_NOUN: + case LFUN_FONT_NOUN: flag.setOnOff(font.noun() == LyXFont::ON); return true; - case LFUN_BOLD: + case LFUN_FONT_BOLD: flag.setOnOff(font.series() == LyXFont::BOLD_SERIES); return true; - case LFUN_SANS: + case LFUN_FONT_SANS: flag.setOnOff(font.family() == LyXFont::SANS_FAMILY); return true; - case LFUN_ROMAN: + case LFUN_FONT_ROMAN: flag.setOnOff(font.family() == LyXFont::ROMAN_FAMILY); return true; - case LFUN_CODE: + case LFUN_FONT_CODE: flag.setOnOff(font.family() == LyXFont::TYPEWRITER_FAMILY); return true; - 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_CUT: + case LFUN_COPY: + enable = cur.selection(); + break; + + case LFUN_PASTE: + enable = 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_INSET_DISSOLVE: + enable = !isMainText(*cur.bv().buffer()) && cur.inset().nargs() == 1; + break; + + case LFUN_CHANGE_ACCEPT: + case LFUN_CHANGE_REJECT: + enable = true; // FIXME: Change tracking (MG) + break; + + case LFUN_WORD_DELETE_FORWARD: + case LFUN_WORD_DELETE_BACKWARD: + case LFUN_LINE_DELETE: + case LFUN_WORD_FORWARD: + case LFUN_WORD_BACKWARD: + case LFUN_CHAR_FORWARD: + case LFUN_CHAR_FORWARD_SELECT: + case LFUN_CHAR_BACKWARD: + case LFUN_CHAR_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_UP_SELECT: + case LFUN_PARAGRAPH_DOWN_SELECT: + case LFUN_SCREEN_UP_SELECT: + case LFUN_SCREEN_DOWN_SELECT: + case LFUN_LINE_BEGIN_SELECT: + case LFUN_LINE_END_SELECT: + case LFUN_WORD_FORWARD_SELECT: + case LFUN_WORD_BACKWARD_SELECT: + 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_CHAR_DELETE_FORWARD: + case LFUN_DELETE_FORWARD_SKIP: + case LFUN_CHAR_DELETE_BACKWARD: + case LFUN_DELETE_BACKWARD_SKIP: + case LFUN_BREAK_PARAGRAPH: + case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT: + case LFUN_BREAK_PARAGRAPH_SKIP: case LFUN_PARAGRAPH_SPACING: 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_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_CLIPBOARD_PASTE: + 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_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_MATRIX: case LFUN_MATH_DELIM: - case LFUN_SUBSCRIPT: - case LFUN_SUPERSCRIPT: - case LFUN_DEFAULT: - case LFUN_UNDERLINE: + case LFUN_MATH_BIGDELIM: + 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_ACCEPT_CHANGE: - case LFUN_REJECT_CHANGE: + 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_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_BEGIN_SELECT: + case LFUN_BUFFER_END_SELECT: + case LFUN_UNICODE_INSERT: // these are handled in our dispatch() enable = true; break; @@ -1905,6 +1849,14 @@ 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; } + + +} // namespace lyx