X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext3.C;h=9ddee5cf60f2574b5ce4fd8a2e52492ee0aa6687;hb=d1f2a9c0000f0ad038425900b001c16a56c72afa;hp=ba25ab6020abd888b57e0956ef6811087f30f937;hpb=ec4ab8ce18418999b547368d1d2bbf546bec1e7b;p=lyx.git diff --git a/src/text3.C b/src/text3.C index ba25ab6020..9ddee5cf60 100644 --- a/src/text3.C +++ b/src/text3.C @@ -17,18 +17,22 @@ #include "lyxtext.h" +#include "FloatList.h" +#include "FuncStatus.h" #include "buffer.h" #include "bufferparams.h" #include "BufferView.h" #include "cursor.h" +#include "coordcache.h" +#include "CutAndPaste.h" #include "debug.h" #include "dispatchresult.h" #include "factory.h" -#include "FloatList.h" #include "funcrequest.h" #include "gettext.h" #include "intl.h" #include "language.h" +#include "LyXAction.h" #include "lyxfunc.h" #include "lyxlex.h" #include "lyxrc.h" @@ -51,19 +55,22 @@ #include "support/lstrings.h" #include "support/lyxlib.h" -#include "support/tostr.h" -#include "support/std_sstream.h" +#include "support/convert.h" #include "mathed/math_hullinset.h" -#include "mathed/formulamacro.h" +#include "mathed/math_macrotemplate.h" #include +#include using lyx::pos_type; +using lyx::cap::copySelection; +using lyx::cap::cutSelection; +using lyx::cap::pasteSelection; +using lyx::cap::replaceSelection; + using lyx::support::isStrUnsignedInt; -using lyx::support::strToUnsignedInt; -using lyx::support::atoi; using lyx::support::token; using std::endl; @@ -75,10 +82,6 @@ using std::vector; extern string current_layout; -// the selection possible is needed, that only motion events are -// used, where the button press event was on the drawing area too -bool selection_possible = false; - namespace { @@ -95,12 +98,12 @@ namespace { if (font.language() != ignore_language || font.number() != LyXFont::IGNORE) { Paragraph & par = cur.paragraph(); - text->bidi.computeTables(par, *cur.bv().buffer(), cur.textRow()); + text->bidi.computeTables(par, cur.buffer(), cur.textRow()); if (cur.boundary() != - text->bidi.isBoundary(*cur.bv().buffer(), par, + text->bidi.isBoundary(cur.buffer(), par, cur.pos(), text->real_current_font)) - text->setCursor(cur, cur.par(), cur.pos(), + text->setCursor(cur, cur.pit(), cur.pos(), false, !cur.boundary()); } } @@ -123,34 +126,40 @@ namespace { } - void mathDispatch(LCursor & cur, LyXText * text, - FuncRequest const & cmd, bool display) + void mathDispatch(LCursor & cur, FuncRequest const & cmd, bool display) { recordUndo(cur); string sel = cur.selectionAsString(false); lyxerr << "selection is: '" << sel << "'" << endl; if (sel.empty()) { - cur.insert(new MathHullInset); // activates inset + const int old_pos = cur.pos(); + cur.insert(new MathHullInset); + 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"... + // 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)); } else { - // create a macro if we see "\\newcommand" somewhere, and an ordinary - // formula otherwise - text->cutSelection(cur, true, true); - if (sel.find("\\newcommand") == string::npos && - sel.find("\\def") == string::npos) + // 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) { cur.insert(new MathHullInset); + cur.dispatch(FuncRequest(LFUN_RIGHT)); cur.dispatch(FuncRequest(LFUN_MATH_MUTATE, "simple")); cur.dispatch(FuncRequest(LFUN_INSERT_MATH, sel)); } else { - cur.insert(new InsetFormulaMacro(sel)); + istringstream is(sel); + cur.insert(new MathMacroTemplate(is)); } } cur.message(N_("Math editor mode")); @@ -172,53 +181,17 @@ string const freefont2string() } - -//takes absolute x,y coordinates -InsetBase * LyXText::checkInsetHit(int x, int y) -{ - ParagraphList::iterator pit; - ParagraphList::iterator end; - - getParsInRange(paragraphs(), - bv()->top_y() - yo_, - bv()->top_y() - yo_ + bv()->workHeight(), - pit, end); - - lyxerr << "checkInsetHit: x: " << x << " y: " << y << endl; - for ( ; pit != end; ++pit) { - InsetList::iterator iit = pit->insetlist.begin(); - InsetList::iterator iend = pit->insetlist.end(); - for ( ; iit != iend; ++iit) { - InsetBase * inset = iit->inset; -#if 1 - lyxerr << "examining inset " << inset - //<< " xo/yo: " << inset->xo() << "/" << inset->yo() - << " xo: " << inset->xo() << "..." << inset->xo() + inset->width() - << " yo: " << inset->yo() - inset->ascent() << "..." - << inset->yo() + inset->descent() << endl; -#endif - if (inset->covers(x, y)) { - lyxerr << "Hit inset: " << inset << endl; - return inset; - } - } - } - lyxerr << "No inset hit. " << endl; - return 0; -} - - bool LyXText::gotoNextInset(LCursor & cur, - vector const & codes, string const & contents) + vector const & codes, string const & contents) { BOOST_ASSERT(this == cur.text()); - ParagraphList::iterator end = paragraphs().end(); - ParagraphList::iterator pit = getPar(cur.par()); + pit_type end = paragraphs().size(); + pit_type pit = cur.pit(); pos_type pos = cur.pos(); InsetBase * inset; do { - if (pos + 1 < pit->size()) { + if (pos + 1 < pars_[pit].size()) { ++pos; } else { ++pit; @@ -226,23 +199,23 @@ bool LyXText::gotoNextInset(LCursor & cur, } } while (pit != end && - !(pit->isInset(pos) && - (inset = pit->getInset(pos)) != 0 && + !(pars_[pit].isInset(pos) && + (inset = pars_[pit].getInset(pos)) != 0 && find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end() && (contents.empty() || - static_cast(pit->getInset(pos))->getContents() + static_cast(pars_[pit].getInset(pos))->getContents() == contents))); if (pit == end) return false; - setCursor(cur, parOffset(pit), pos, false); + setCursor(cur, pit, pos, false); return true; } void LyXText::gotoInset(LCursor & cur, - vector const & codes, bool same_content) + vector const & codes, bool same_content) { cur.clearSelection(); @@ -257,76 +230,78 @@ void LyXText::gotoInset(LCursor & cur, } if (!gotoNextInset(cur, codes, contents)) { - if (cur.pos() || cur.par() != 0) { + if (cur.pos() || cur.pit() != 0) { CursorSlice tmp = cur.top(); - cur.par() = 0; + cur.pit() = 0; cur.pos() = 0; if (!gotoNextInset(cur, codes, contents)) { - cursor() = tmp; + cur.top() = tmp; cur.message(_("No more insets")); } } else { cur.message(_("No more insets")); } } - cur.update(); cur.resetAnchor(); } -void LyXText::gotoInset(LCursor & cur, InsetOld_code code, bool same_content) +void LyXText::gotoInset(LCursor & cur, InsetBase_code code, bool same_content) { - gotoInset(cur, vector(1, code), 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::paroffset_type cpar = cur.par(); + lyx::pit_type cpar = cur.pit(); int x = cur.x_target(); - int y = bv()->top_y(); - setCursorFromCoordinates(cur, x, y); - if (cpar == cur.par() && cpos == cur.pos()) { + setCursorFromCoordinates(cur, x, 0); + bool 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); } - bv()->updateScrollbar(); + cur.bv().updateScrollbar(); finishUndo(); + return updated; } -void LyXText::cursorNext(LCursor & cur) +bool LyXText::cursorNext(LCursor & cur) { pos_type cpos = cur.pos(); - lyx::paroffset_type cpar = cur.par(); + lyx::pit_type cpar = cur.pit(); int x = cur.x_target(); - int y = bv()->top_y() + bv()->workHeight(); - setCursorFromCoordinates(cur, x, y); + setCursorFromCoordinates(cur, x, cur.bv().workHeight() - 1); + bool updated = cursorDown(cur); - if (cpar == cur.par() && cpos == cur.pos()) { + 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); } - bv()->updateScrollbar(); + cur.bv().updateScrollbar(); finishUndo(); + return updated; } namespace { -void specialChar(LCursor & cur, LyXText * text, InsetSpecialChar::Kind kind) +void specialChar(LCursor & cur, InsetSpecialChar::Kind kind) { - text->replaceSelection(cur); + lyx::cap::replaceSelection(cur); cur.insert(new InsetSpecialChar(kind)); - cur.update(); + cur.posRight(); } @@ -344,12 +319,23 @@ void doInsertInset(LCursor & cur, LyXText * text, gotsel = true; } text->insertInset(cur, inset); + if (edit) inset->edit(cur, true); + if (gotsel && pastesel) cur.bv().owner()->dispatch(FuncRequest(LFUN_PASTE)); } + +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); +} + + } // anon namespace @@ -367,13 +353,16 @@ bool LyXText::isRTL(Paragraph const & par) const } -void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) +void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) { lyxerr[Debug::ACTION] << "LyXText::dispatch: cmd: " << cmd << endl; - //lyxerr << "*** 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 sel = cur.selection(); + bool needsUpdate = !lyxaction.funcHasFlag(cmd.action, LyXAction::NoUpdate); switch (cmd.action) { @@ -382,14 +371,10 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) bool start = !par.params().startOfAppendix(); // ensure that we have only one start_of_appendix in this document - ParagraphList::iterator tmp = paragraphs().begin(); - ParagraphList::iterator end = paragraphs().end(); - - for (; tmp != end; ++tmp) { - if (tmp->params().startOfAppendix()) { - recUndo(parOffset(tmp)); - tmp->params().startOfAppendix(false); - redoParagraph(tmp); + for (pit_type tmp = 0, end = pars_.size(); tmp != end; ++tmp) { + if (pars_[tmp].params().startOfAppendix()) { + recUndo(tmp); + pars_[tmp].params().startOfAppendix(false); break; } } @@ -399,8 +384,6 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) // we can set the refreshing parameters now updateCounters(); - redoParagraph(cur); - cur.update(); break; } @@ -426,9 +409,9 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) if (!cur.mark()) cur.clearSelection(); if (isRTL(cur.paragraph())) - cursorLeftOneWord(cur); + needsUpdate = cursorLeftOneWord(cur); else - cursorRightOneWord(cur); + needsUpdate = cursorRightOneWord(cur); finishChange(cur, false); break; @@ -436,62 +419,114 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) 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.mark()) - cur.clearSelection(); - cursorTop(cur); - finishChange(cur, false); + if (cur.depth() == 1) { + if (!cur.mark()) + cur.clearSelection(); + cursorTop(cur); + finishChange(cur, false); + } else { + cur.undispatched(); + } + break; + + case LFUN_BEGINNINGBUFSEL: + if (cur.depth() == 1) { + if (!cur.selection()) + cur.resetAnchor(); + cursorTop(cur); + finishChange(cur, true); + } else { + cur.undispatched(); + } break; case LFUN_ENDBUF: - if (!cur.mark()) - cur.clearSelection(); - cursorBottom(cur); - finishChange(cur, false); + if (cur.depth() == 1) { + if (!cur.mark()) + cur.clearSelection(); + cursorBottom(cur); + finishChange(cur, false); + } 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: + lyxerr << BOOST_CURRENT_FUNCTION + << " LFUN_RIGHT[SEL]:\n" << cur << endl; cur.selHandle(cmd.action == LFUN_RIGHTSEL); if (isRTL(cur.paragraph())) - cursorLeft(cur); + needsUpdate = cursorLeft(cur); else - cursorRight(cur); - if (sl == cur.top()) - cur.dispatched(FINISHED_RIGHT); + needsUpdate = cursorRight(cur); + if (!needsUpdate && oldTopSlice == cur.top()) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_RIGHT); + } 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())) - cursorRight(cur); + needsUpdate = cursorRight(cur); else - cursorLeft(cur); - if (sl == cur.top()) - cur.dispatched(FINISHED_LEFT); + needsUpdate = cursorLeft(cur); + if (oldTopSlice == cur.top()) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_LEFT); + } break; case LFUN_UP: case LFUN_UPSEL: + update(cur); + //lyxerr << "handle LFUN_UP[SEL]:\n" << cur << endl; cur.selHandle(cmd.action == LFUN_UPSEL); - cursorUp(cur); - if (sl == cur.top()) - cur.dispatched(FINISHED_UP); + needsUpdate = cursorUp(cur); + if (oldTopSlice == cur.top()) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_UP); + } break; case LFUN_DOWN: case LFUN_DOWNSEL: + update(cur); + //lyxerr << "handle LFUN_DOWN[SEL]:\n" << cur << endl; cur.selHandle(cmd.action == LFUN_DOWNSEL); - cursorDown(cur); - if (sl == cur.top()) - cur.dispatched(FINISHED_DOWN); + needsUpdate = cursorDown(cur); + if (oldTopSlice == cur.top()) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_DOWN); + } + break; + + case LFUN_UP_PARAGRAPH: + if (!cur.mark()) + cur.clearSelection(); + needsUpdate = cursorUpParagraph(cur); + finishChange(cur, false); break; case LFUN_UP_PARAGRAPHSEL: @@ -501,6 +536,13 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) finishChange(cur, true); 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(); @@ -509,6 +551,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) break; case LFUN_PRIORSEL: + update(cur); if (!cur.selection()) cur.resetAnchor(); cursorPrevious(cur); @@ -516,6 +559,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) break; case LFUN_NEXTSEL: + update(cur); if (!cur.selection()) cur.resetAnchor(); cursorNext(cur); @@ -523,6 +567,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) break; case LFUN_HOMESEL: + update(cur); if (!cur.selection()) cur.resetAnchor(); cursorHome(cur); @@ -530,6 +575,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) break; case LFUN_ENDSEL: + update(cur); if (!cur.selection()) cur.resetAnchor(); cursorEnd(cur); @@ -562,39 +608,31 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) break; } - case LFUN_UP_PARAGRAPH: - if (!cur.mark()) - cur.clearSelection(); - cursorUpParagraph(cur); - finishChange(cur, false); - break; - - case LFUN_DOWN_PARAGRAPH: - if (!cur.mark()) - cur.clearSelection(); - cursorDownParagraph(cur); - finishChange(cur, false); - break; - case LFUN_PRIOR: + update(cur); if (!cur.mark()) cur.clearSelection(); finishChange(cur, false); - if (cur.par() == 0 && cur.textRow().pos() == 0) - cur.dispatched(FINISHED_UP); - else - cursorPrevious(cur); + if (cur.pit() == 0 && cur.textRow().pos() == 0) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_UP); + } else { + needsUpdate = cursorPrevious(cur); + } break; case LFUN_NEXT: + update(cur); if (!cur.mark()) cur.clearSelection(); finishChange(cur, false); - if (cur.par() == cur.lastpar() - && cur.textRow().endpos() == cur.lastpos()) - cur.dispatched(FINISHED_DOWN); - else - cursorNext(cur); + if (cur.pit() == cur.lastpit() + && cur.textRow().endpos() == cur.lastpos()) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_DOWN); + } else { + needsUpdate = cursorNext(cur); + } break; case LFUN_HOME: @@ -614,8 +652,9 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) case LFUN_BREAKLINE: { // Not allowed by LaTeX (labels or empty par) if (cur.pos() > cur.paragraph().beginOfBody()) { - replaceSelection(cur); + lyx::cap::replaceSelection(cur); cur.insert(new InsetNewline); + cur.posRight(); moveCursor(cur, false); } break; @@ -645,7 +684,6 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) } else { cutSelection(cur, true, false); } - cur.update(); break; @@ -661,54 +699,45 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) cutSelection(cur, true, false); } bv->switchKeyMap(); - cur.update(); break; case LFUN_BACKSPACE_SKIP: // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP. if (!cur.selection()) { +#ifdef WITH_WARNINGS #warning look here +#endif //CursorSlice cur = cursor(); backspace(cur); //anchor() = cur; } else { cutSelection(cur, true, false); } - cur.update(); break; case LFUN_BREAKPARAGRAPH: - replaceSelection(cur); + lyx::cap::replaceSelection(cur); breakParagraph(cur, 0); - cur.update(); cur.resetAnchor(); bv->switchKeyMap(); break; case LFUN_BREAKPARAGRAPHKEEPLAYOUT: - replaceSelection(cur); + lyx::cap::replaceSelection(cur); breakParagraph(cur, 1); - cur.update(); cur.resetAnchor(); bv->switchKeyMap(); break; case LFUN_BREAKPARAGRAPH_SKIP: { // When at the beginning of a paragraph, remove - // indentation and add a "defskip" at the top. - // Otherwise, do the same as LFUN_BREAKPARAGRAPH. - replaceSelection(cur); - if (cur.pos() == 0) { - ParagraphParameters & params = cur.paragraph().params(); - setParagraph(cur, - params.spacing(), - params.align(), - params.labelWidthString(), 1); - } else { + // indentation. Otherwise, do the same as LFUN_BREAKPARAGRAPH. + lyx::cap::replaceSelection(cur); + if (cur.pos() == 0) + cur.paragraph().params().labelWidthString(string()); + else breakParagraph(cur, 0); - } - cur.update(); -// anchor() = cur; + cur.resetAnchor(); bv->switchKeyMap(); break; } @@ -716,15 +745,15 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) case LFUN_PARAGRAPH_SPACING: { Paragraph & par = cur.paragraph(); Spacing::Space cur_spacing = par.params().spacing().getSpace(); - float cur_value = 1.0; + string cur_value = "1.0"; if (cur_spacing == Spacing::Other) - cur_value = par.params().spacing().getValue(); + cur_value = par.params().spacing().getValueAsString(); istringstream is(cmd.argument); string tmp; is >> tmp; Spacing::Space new_spacing = cur_spacing; - float new_value = cur_value; + string new_value = cur_value; if (tmp.empty()) { lyxerr << "Missing argument to `paragraph-spacing'" << endl; @@ -736,10 +765,10 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) new_spacing = Spacing::Double; } else if (tmp == "other") { new_spacing = Spacing::Other; - float tmpval = 0.0; + string tmpval = "0.0"; is >> tmpval; lyxerr << "new_value = " << tmpval << endl; - if (tmpval != 0.0) + if (tmpval != "0.0") new_value = tmpval; } else if (tmp == "default") { new_spacing = Spacing::Default; @@ -747,104 +776,112 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) lyxerr << _("Unknown spacing argument: ") << cmd.argument << endl; } - if (cur_spacing != new_spacing || cur_value != new_value) { + if (cur_spacing != new_spacing || cur_value != new_value) par.params().spacing(Spacing(new_spacing, new_value)); - redoParagraph(cur); - cur.update(); - } break; } case LFUN_INSET_APPLY: { string const name = cmd.getArg(0); InsetBase * inset = bv->owner()->getDialogs().getOpenInset(name); - if (inset) - inset->dispatch(cur, FuncRequest(LFUN_INSET_MODIFY, cmd.argument)); - else - dispatch(cur, FuncRequest(LFUN_INSET_INSERT, cmd.argument)); + 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); - if (inset) + if (inset) { insertInset(cur, inset); + cur.posRight(); + } break; } case LFUN_INSET_SETTINGS: - if (cur.inset() && cur.inset()->asUpdatableInset()) - cur.inset()->asUpdatableInset()->showInsetDialog(bv); + if (cur.inset().asUpdatableInset()) + cur.inset().asUpdatableInset()->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); + } break; + } - case LFUN_INSET_TOGGLE: + case LFUN_KEYMAP_TOGGLE: cur.clearSelection(); - if (!toggleInset(cur)) - cur.undispatched(); - else - bv->switchKeyMap(); + bv->switchKeyMap(); break; case LFUN_SPACE_INSERT: if (cur.paragraph().layout()->free_spacing) insertChar(cur, ' '); - else + else { doInsertInset(cur, this, cmd, false, false); + cur.posRight(); + } moveCursor(cur, false); break; case LFUN_HYPHENATION: - specialChar(cur, this, InsetSpecialChar::HYPHENATION); + specialChar(cur, InsetSpecialChar::HYPHENATION); break; case LFUN_LIGATURE_BREAK: - specialChar(cur, this, InsetSpecialChar::LIGATURE_BREAK); + specialChar(cur, InsetSpecialChar::LIGATURE_BREAK); break; case LFUN_LDOTS: - specialChar(cur, this, InsetSpecialChar::LDOTS); + specialChar(cur, InsetSpecialChar::LDOTS); break; case LFUN_END_OF_SENTENCE: - specialChar(cur, this, InsetSpecialChar::END_OF_SENTENCE); + specialChar(cur, InsetSpecialChar::END_OF_SENTENCE); break; case LFUN_MENU_SEPARATOR: - specialChar(cur, this, InsetSpecialChar::MENU_SEPARATOR); + specialChar(cur, InsetSpecialChar::MENU_SEPARATOR); break; case LFUN_UPCASE_WORD: changeCase(cur, LyXText::text_uppercase); - cur.update(); break; case LFUN_LOWCASE_WORD: changeCase(cur, LyXText::text_lowercase); - cur.update(); break; case LFUN_CAPITALIZE_WORD: changeCase(cur, LyXText::text_capitalization); - cur.update(); break; case LFUN_TRANSPOSE_CHARS: recordUndo(cur); - redoParagraph(cur); - cur.update(); break; case LFUN_PASTE: cur.message(_("Paste")); - replaceSelection(cur); + 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, strToUnsignedInt(cmd.argument)); + pasteSelection(cur, convert(cmd.argument)); else pasteSelection(cur, 0); cur.clearSelection(); // bug 393 - cur.update(); bv->switchKeyMap(); finishUndo(); break; @@ -852,7 +889,6 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) case LFUN_CUT: cutSelection(cur, true, true); cur.message(_("Cut")); - cur.update(); break; case LFUN_COPY: @@ -860,31 +896,9 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) cur.message(_("Copy")); break; - case LFUN_BEGINNINGBUFSEL: - if (in_inset_) { - cur.undispatched(); - } else { - if (!cur.selection()) - cur.resetAnchor(); - cursorTop(cur); - finishChange(cur, true); - } - break; - - case LFUN_ENDBUFSEL: - if (in_inset_) { - cur.undispatched(); - } else { - if (!cur.selection()) - cur.resetAnchor(); - cursorBottom(cur); - finishChange(cur, true); - } - break; - case LFUN_GETXY: - cur.message(tostr(cursorX(cur.top())) + ' ' - + tostr(cursorY(cur.top()))); + cur.message(convert(cursorX(cur.top())) + ' ' + + convert(cursorY(cur.top()))); break; case LFUN_SETXY: { @@ -949,12 +963,12 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) bool change_layout = (current_layout != layout); if (!change_layout && cur.selection() && - cur.selBegin().par() != cur.selEnd().par()) + cur.selBegin().pit() != cur.selEnd().pit()) { - ParagraphList::iterator spit = getPar(cur.selBegin()); - ParagraphList::iterator epit = boost::next(getPar(cur.selEnd())); + pit_type spit = cur.selBegin().pit(); + pit_type epit = cur.selEnd().pit() + 1; while (spit != epit) { - if (spit->layout()->name() != current_layout) { + if (pars_[spit].layout()->name() != current_layout) { change_layout = true; break; } @@ -966,7 +980,6 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) current_layout = layout; setLayout(cur, layout); bv->owner()->setLayout(layout); - cur.update(); bv->switchKeyMap(); } break; @@ -980,7 +993,6 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) insertStringAsParagraphs(cur, clip); else insertStringAsLines(cur, clip); - cur.update(); } break; } @@ -994,7 +1006,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) break; case LFUN_REFERENCE_GOTO: { - vector tmp; + vector tmp; tmp.push_back(InsetBase::LABEL_CODE); tmp.push_back(InsetBase::REF_CODE); gotoInset(cur, tmp, true); @@ -1002,7 +1014,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) } case LFUN_QUOTE: { - replaceSelection(cur); + lyx::cap::replaceSelection(cur); Paragraph & par = cur.paragraph(); lyx::pos_type pos = cur.pos(); char c; @@ -1014,29 +1026,30 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) c = par.getChar(pos - 1); LyXLayout_ptr const & style = par.layout(); - + BufferParams const & bufparams = bv->buffer()->params(); if (!style->pass_thru && par.getFontSettings(bufparams, pos).language()->lang() != "hebrew") { - string arg = cmd.argument; + string arg = cmd.argument; if (arg == "single") cur.insert(new InsetQuotes(c, - bufparams.quotes_language, + bufparams.quotes_language, InsetQuotes::SingleQ)); else if (arg == "double") cur.insert(new InsetQuotes(c, - bufparams.quotes_language, + bufparams.quotes_language, InsetQuotes::DoubleQ)); else - cur.insert(new InsetQuotes(c, bufparams)); - } + cur.insert(new InsetQuotes(c, bufparams)); + cur.posRight(); + } else bv->owner()->dispatch(FuncRequest(LFUN_SELFINSERT, "\"")); break; } case LFUN_DATE_INSERT: { - replaceSelection(cur); + lyx::cap::replaceSelection(cur); time_t now_time_t = time(NULL); struct tm * now_tm = localtime(&now_time_t); setlocale(LC_TIME, ""); @@ -1059,7 +1072,6 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) case LFUN_MOUSE_TRIPLE: if (cmd.button() == mouse_button::button1) { - selection_possible = true; cursorHome(cur); cur.resetAnchor(); cursorEnd(cur); @@ -1070,61 +1082,16 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) case LFUN_MOUSE_DOUBLE: if (cmd.button() == mouse_button::button1) { - selection_possible = true; selectWord(cur, lyx::WHOLE_WORD_STRICT); bv->haveSelection(cur.selection()); } break; - case LFUN_MOUSE_MOTION: { - // Only use motion with button 1 - //if (cmd.button() != mouse_button::button1) - // return false; - // The test for not selection possible is needed, that - // only motion events are used, where the bottom press - // event was on the drawing area too - if (!selection_possible) { - lyxerr[Debug::ACTION] << "BufferView::Pimpl::" - "Dispatch: no selection possible\n"; - break; - } - CursorSlice old = cur.top(); - setCursorFromCoordinates(cur, cmd.x, cmd.y); - - // This is to allow jumping over large insets - // FIXME: shouldn't be top-text-specific - if (!in_inset_ && cur.top() == old) { - if (cmd.y - bv->top_y() >= bv->workHeight()) - cursorDown(cur); - else if (cmd.y - bv->top_y() < 0) - cursorUp(cur); - } - - // don't set anchor_ - bv->cursor().setCursor(cur, false); - break; - } - // Single-click on work area case LFUN_MOUSE_PRESS: { - // ok ok, this is a hack (for xforms) - // We shouldn't go further down as we really should only do the - // scrolling and be done with this. Otherwise we may open some - // dialogs (Jug 20020424). - if (cmd.button() == mouse_button::button4) { - bv->scroll(-lyxrc.wheel_jump); - break; - } - - if (cmd.button() == mouse_button::button5) { - bv->scroll(lyxrc.wheel_jump); - break; - } - // Right click on a footnote flag opens float menu if (cmd.button() == mouse_button::button3) { cur.clearSelection(); - selection_possible = false; break; } @@ -1138,21 +1105,20 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) paste_internally = true; } - selection_possible = true; - // Clear the selection cur.clearSelection(); setCursorFromCoordinates(cur, cmd.x, cmd.y); cur.resetAnchor(); finishUndo(); - cur.x_target() = cursorX(cur.top()); + cur.setTargetX(); - // set cursor and anchor to this position - bv->cursor() = cur; + // Has the cursor just left the inset? + if (bv->cursor().inMathed() && !cur.inMathed()) + bv->cursor().inset().notifyCursorLeaves(bv->cursor()); - if (bv->fitCursor()) - selection_possible = false; + // Set cursor here. + bv->cursor() = cur; // Insert primary selection with middle mouse // if there is a local selection in the current buffer, @@ -1162,21 +1128,53 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) bv->owner()->dispatch(FuncRequest(LFUN_PASTE)); else bv->owner()->dispatch(FuncRequest(LFUN_PASTESELECTION, "paragraph")); - selection_possible = false; } + break; } - case LFUN_MOUSE_RELEASE: { - // do nothing if we used the mouse wheel - if (cmd.button() == mouse_button::button4 - || cmd.button() == mouse_button::button5) { - cur.undispatched(); - break; - } + case LFUN_MOUSE_MOTION: { + // Only use motion with button 1 + //if (cmd.button() != mouse_button::button1) + // return false; + + // ignore motions deeper nested than the real anchor + LCursor & bvcur = cur.bv().cursor(); + if (bvcur.anchor_.hasPart(cur)) { + CursorSlice old = bvcur.top(); - selection_possible = false; + int const wh = bv->workHeight(); + int const y = std::max(0, std::min(wh - 1, cmd.y)); + + setCursorFromCoordinates(cur, cmd.x, y); + cur.x_target() = cmd.x; + if (cmd.y >= wh) + cursorDown(cur); + else if (cmd.y < 0) + cursorUp(cur); + // This is to allow jumping over large insets + if (cur.top() == old) { + if (cmd.y >= wh) + cursorDown(cur); + else if (cmd.y < 0) + cursorUp(cur); + } + + if (cur.top() == old) + cur.noUpdate(); + else { + // don't set anchor_ + bvcur.setCursor(cur); + bvcur.selection() = true; + lyxerr << "MOTION: " << bv->cursor() << endl; + } + + } else + cur.undispatched(); + break; + } + case LFUN_MOUSE_RELEASE: { if (cmd.button() == mouse_button::button2) break; @@ -1186,7 +1184,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) bv->switchKeyMap(); bv->owner()->updateMenubar(); - bv->owner()->updateToolbar(); + bv->owner()->updateToolbars(); break; } @@ -1240,9 +1238,19 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) } case LFUN_INSERT_LABEL: { - InsetCommandParams p("label"); + // Try to generate a valid label + string const contents = cmd.argument.empty() ? + cur.getPossibleLabel() : cmd.argument; + + InsetCommandParams p("label", contents); string const data = InsetCommandMailer::params2string("label", p); - bv->owner()->getDialogs().show("label", data, 0); + + if (cmd.argument.empty()) { + bv->owner()->getDialogs().show("label", data, 0); + } else { + FuncRequest fr(LFUN_INSET_INSERT, data); + dispatch(cur, fr); + } break; } @@ -1269,11 +1277,13 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) // Open the inset, and move the current selection // inside it. doInsertInset(cur, this, cmd, true, true); + cur.posRight(); break; case LFUN_INDEX_INSERT: // Just open the inset doInsertInset(cur, this, cmd, true, false); + cur.posRight(); break; case LFUN_INDEX_PRINT: @@ -1283,25 +1293,28 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) case LFUN_INSERT_PAGEBREAK: // do nothing fancy doInsertInset(cur, this, cmd, false, false); + cur.posRight(); break; case LFUN_DEPTH_MIN: - changeDepth(cur, bv_funcs::DEC_DEPTH); - cur.update(); + changeDepth(cur, DEC_DEPTH); break; case LFUN_DEPTH_PLUS: - changeDepth(cur, bv_funcs::INC_DEPTH); - cur.update(); + changeDepth(cur, INC_DEPTH); break; case LFUN_MATH_DISPLAY: - mathDispatch(cur, this, cmd, true); + mathDispatch(cur, cmd, true); break; case LFUN_MATH_IMPORT_SELECTION: case LFUN_MATH_MODE: - mathDispatch(cur, this, cmd, false); + if (cmd.argument == "on") + // don't pass "on" as argument + mathDispatch(cur, FuncRequest(LFUN_MATH_MODE), false); + else + mathDispatch(cur, cmd, false); break; case LFUN_MATH_MACRO: @@ -1310,14 +1323,22 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) else { string s = cmd.argument; string const s1 = token(s, ' ', 1); - int const nargs = s1.empty() ? 0 : atoi(s1); + int const nargs = s1.empty() ? 0 : convert(s1); string const s2 = token(s, ' ', 2); string const type = s2.empty() ? "newcommand" : s2; - cur.insert(new InsetFormulaMacro(token(s, ' ', 0), nargs, s2)); - cur.nextInset()->edit(cur, true); + cur.insert(new MathMacroTemplate(token(s, ' ', 0), nargs, s2)); + //cur.nextInset()->edit(cur, true); } break; + // passthrough hat and underscore outside mathed: + case LFUN_SUBSCRIPT: + mathDispatch(cur, FuncRequest(LFUN_SELFINSERT, "_"), false); + break; + case LFUN_SUPERSCRIPT: + mathDispatch(cur, FuncRequest(LFUN_SELFINSERT, "^"), false); + break; + case LFUN_INSERT_MATH: case LFUN_INSERT_MATRIX: case LFUN_MATH_DELIM: { @@ -1421,29 +1442,22 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) } case LFUN_FINISHED_LEFT: - lyxerr << "handle LFUN_FINISHED_LEFT" << endl; - if (isRTL(cur.paragraph())) - cursorLeft(cur); - cur.bv().cursor() = cur; + lyxerr[Debug::DEBUG] << "handle LFUN_FINISHED_LEFT:\n" << cur << endl; break; case LFUN_FINISHED_RIGHT: - lyxerr << "handle LFUN_FINISHED_RIGHT" << endl; - if (!isRTL(cur.paragraph())) - cursorRight(cur); - cur.bv().cursor() = cur; + lyxerr[Debug::DEBUG] << "handle LFUN_FINISHED_RIGHT:\n" << cur << endl; + ++cur.pos(); break; case LFUN_FINISHED_UP: - lyxerr << "handle LFUN_FINISHED_UP" << endl; + lyxerr[Debug::DEBUG] << "handle LFUN_FINISHED_UP:\n" << cur << endl; cursorUp(cur); - cur.bv().cursor() = cur; break; case LFUN_FINISHED_DOWN: - lyxerr << "handle LFUN_FINISHED_DOWN" << endl; + lyxerr[Debug::DEBUG] << "handle LFUN_FINISHED_DOWN:\n" << cur << endl; cursorDown(cur); - cur.bv().cursor() = cur; break; case LFUN_LAYOUT_PARAGRAPH: { @@ -1461,11 +1475,10 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) params2string(cur.paragraph(), data); // Will the paragraph accept changes from the dialog? - InsetBase * const inset = cur.inset(); - bool const accept = - !(inset && inset->forceDefaultParagraphs(inset)); + InsetBase & inset = cur.inset(); + bool const accept = !inset.forceDefaultParagraphs(&inset); - data = "update " + tostr(accept) + '\n' + data; + data = "update " + convert(accept) + '\n' + data; bv->owner()->getDialogs().update("paragraph", data); break; } @@ -1509,6 +1522,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) setLayout(cur, tclass.defaultLayoutName()); setParagraph(cur, Spacing(), LYX_ALIGN_LAYOUT, string(), 0); insertInset(cur, new InsetFloatList(cmd.argument)); + cur.posRight(); } else { lyxerr << "Non-existent float type: " << cmd.argument << endl; @@ -1518,13 +1532,11 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) case LFUN_ACCEPT_CHANGE: { acceptChange(cur); - cur.update(); break; } case LFUN_REJECT_CHANGE: { rejectChange(cur); - cur.update(); break; } @@ -1557,26 +1569,393 @@ void LyXText::dispatch(LCursor & cur, FuncRequest const & cmd) params.align(), params.labelWidthString(), params.noindent()); - cur.update(); 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()) + if (cur.selection()) { cur.selection() = false; - else - cur.dispatched(FINISHED_LEFT); + } else { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_LEFT); + } break; default: + lyxerr << BOOST_CURRENT_FUNCTION + << " Not DISPATCHED by LyXText" << endl; cur.undispatched(); break; } + + if (!needsUpdate + && &oldTopSlice.inset() == &cur.inset() + && oldTopSlice.idx() == cur.idx() + && !sel + && !cur.selection()) + cur.noUpdate(); + else + cur.needsUpdate(); } -bool LyXText::getStatus(LCursor &, FuncRequest const &, FuncStatus &) +bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, + FuncStatus & flag) const { - return false; + BOOST_ASSERT(cur.text() == this); + LyXFont const & font = real_current_font; + bool enable = true; + + switch (cmd.action) { + + case LFUN_DEPTH_MIN: + enable = changeDepthAllowed(cur, DEC_DEPTH); + break; + + case LFUN_DEPTH_PLUS: + 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()); + 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; + else if (cmd.argument == "bibtex") + code = InsetBase::BIBTEX_CODE; + else if (cmd.argument == "box") + code = InsetBase::BOX_CODE; + else if (cmd.argument == "branch") + code = InsetBase::BRANCH_CODE; + else if (cmd.argument == "citation") + code = InsetBase::CITE_CODE; + else if (cmd.argument == "ert") + code = InsetBase::ERT_CODE; + else if (cmd.argument == "external") + code = InsetBase::EXTERNAL_CODE; + else if (cmd.argument == "float") + code = InsetBase::FLOAT_CODE; + else if (cmd.argument == "graphics") + code = InsetBase::GRAPHICS_CODE; + else if (cmd.argument == "include") + code = InsetBase::INCLUDE_CODE; + else if (cmd.argument == "index") + code = InsetBase::INDEX_CODE; + else if (cmd.argument == "label") + code = InsetBase::LABEL_CODE; + else if (cmd.argument == "note") + code = InsetBase::NOTE_CODE; + else if (cmd.argument == "ref") + code = InsetBase::REF_CODE; + else if (cmd.argument == "toc") + code = InsetBase::TOC_CODE; + else if (cmd.argument == "url") + code = InsetBase::URL_CODE; + else if (cmd.argument == "vspace") + code = InsetBase::VSPACE_CODE; + else if (cmd.argument == "wrap") + code = InsetBase::WRAP_CODE; + break; + + case LFUN_INSET_ERT: + code = InsetBase::ERT_CODE; + break; + case LFUN_INSET_FOOTNOTE: + code = InsetBase::FOOT_CODE; + break; + case LFUN_TABULAR_INSERT: + code = InsetBase::TABULAR_CODE; + break; + case LFUN_INSET_MARGINAL: + code = InsetBase::MARGIN_CODE; + break; + case LFUN_INSET_FLOAT: + case LFUN_INSET_WIDE_FLOAT: + code = InsetBase::FLOAT_CODE; + break; + case LFUN_INSET_WRAP: + code = InsetBase::WRAP_CODE; + break; + case LFUN_FLOAT_LIST: + code = InsetBase::FLOAT_LIST_CODE; + break; +#if 0 + case LFUN_INSET_LIST: + code = InsetBase::LIST_CODE; + break; + case LFUN_INSET_THEOREM: + code = InsetBase::THEOREM_CODE; + break; +#endif + case LFUN_INSET_CAPTION: + code = InsetBase::CAPTION_CODE; + break; + case LFUN_INSERT_NOTE: + code = InsetBase::NOTE_CODE; + break; + case LFUN_INSERT_CHARSTYLE: + code = InsetBase::CHARSTYLE_CODE; + if (buf->params().getLyXTextClass().charstyles().empty()) + enable = false; + break; + case LFUN_INSERT_BOX: + code = InsetBase::BOX_CODE; + break; + case LFUN_INSERT_BRANCH: + code = InsetBase::BRANCH_CODE; + if (buf->params().branchlist().empty()) + enable = false; + break; + case LFUN_INSERT_LABEL: + code = InsetBase::LABEL_CODE; + break; + case LFUN_INSET_OPTARG: + code = InsetBase::OPTARG_CODE; + break; + case LFUN_ENVIRONMENT_INSERT: + code = InsetBase::BOX_CODE; + break; + case LFUN_INDEX_INSERT: + code = InsetBase::INDEX_CODE; + break; + case LFUN_INDEX_PRINT: + code = InsetBase::INDEX_PRINT_CODE; + break; + case LFUN_TOC_INSERT: + code = InsetBase::TOC_CODE; + break; + case LFUN_HTMLURL: + case LFUN_URL: + code = InsetBase::URL_CODE; + break; + case LFUN_QUOTE: + // 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: + code = InsetBase::SPECIALCHAR_CODE; + break; + case LFUN_SPACE_INSERT: + // slight hack: we know this is allowed in math mode + 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_EMPH: + flag.setOnOff(font.emph() == LyXFont::ON); + break; + + case LFUN_NOUN: + flag.setOnOff(font.noun() == LyXFont::ON); + break; + + case LFUN_BOLD: + flag.setOnOff(font.series() == LyXFont::BOLD_SERIES); + break; + + case LFUN_SANS: + flag.setOnOff(font.family() == LyXFont::SANS_FAMILY); + break; + + case LFUN_ROMAN: + flag.setOnOff(font.family() == LyXFont::ROMAN_FAMILY); + break; + + case LFUN_CODE: + flag.setOnOff(font.family() == LyXFont::TYPEWRITER_FAMILY); + 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_UP: + case LFUN_UPSEL: + 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_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_LAYOUT: + case LFUN_PASTESELECTION: + case LFUN_GOTOERROR: + case LFUN_GOTONOTE: + case LFUN_REFERENCE_GOTO: + 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_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_DELIM: + case LFUN_SUBSCRIPT: + case LFUN_SUPERSCRIPT: + case LFUN_DEFAULT: + case LFUN_UNDERLINE: + case LFUN_FONT_SIZE: + case LFUN_LANGUAGE: + case LFUN_FREEFONT_APPLY: + case LFUN_FREEFONT_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_THESAURUS_ENTRY: + case LFUN_PARAGRAPH_APPLY: + case LFUN_ESCAPE: + case LFUN_KEYMAP_TOGGLE: + case LFUN_ENDBUF: + case LFUN_BEGINNINGBUF: + case LFUN_BEGINNINGBUFSEL: + case LFUN_ENDBUFSEL: + // these are handled in our dispatch() + enable = true; + break; + + default: + return false; + } + flag.enabled(enable); + return true; }