X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=0dd3b6492c96ee94fb1906e658d4fa0ae9533c95;hb=5b75a45bc1c590cca5ac2a3e539a741a4aede26a;hp=1874607f53ffa4dee0fe8044dd3e662b8abc1734;hpb=f35561d0557a9d8eb13072532aa130a46b0a0fe1;p=lyx.git diff --git a/src/Text3.cpp b/src/Text3.cpp index 1874607f53..0dd3b6492c 100644 --- a/src/Text3.cpp +++ b/src/Text3.cpp @@ -37,21 +37,20 @@ #include "Language.h" #include "Layout.h" #include "LyXAction.h" -#include "LyXFunc.h" +#include "LyX.h" #include "Lexer.h" #include "LyXRC.h" #include "Paragraph.h" -#include "paragraph_funcs.h" #include "ParagraphParameters.h" +#include "SpellChecker.h" #include "TextClass.h" #include "TextMetrics.h" #include "VSpace.h" +#include "WordLangTuple.h" #include "frontends/Application.h" #include "frontends/Clipboard.h" -#include "frontends/LyXView.h" #include "frontends/Selection.h" -#include "frontends/WorkArea.h" #include "insets/InsetCollapsable.h" #include "insets/InsetCommand.h" @@ -144,7 +143,7 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display) #ifdef ENABLE_ASSERTIONS const int old_pos = cur.pos(); #endif - cur.insert(new InsetMathHull(hullSimple)); + cur.insert(new InsetMathHull(cur.buffer(), hullSimple)); #ifdef ENABLE_ASSERTIONS LASSERT(old_pos == cur.pos(), /**/); #endif @@ -168,7 +167,7 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display) && sel.find(from_ascii("\\newlyxcommand")) == string::npos && sel.find(from_ascii("\\def")) == string::npos) { - InsetMathHull * formula = new InsetMathHull; + InsetMathHull * formula = new InsetMathHull(cur.buffer()); string const selstr = to_utf8(sel); istringstream is(selstr); Lexer lex; @@ -187,7 +186,7 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display) } else cur.insert(formula); } else { - cur.insert(new MathMacroTemplate(sel)); + cur.insert(new MathMacroTemplate(cur.buffer(), sel)); } } if (valid) @@ -199,19 +198,20 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display) void regexpDispatch(Cursor & cur, FuncRequest const & cmd) { - BOOST_ASSERT(cmd.action == LFUN_REGEXP_MODE); + LASSERT(cmd.action() == LFUN_REGEXP_MODE, return); if (cur.inRegexped()) { - cur.message(_("Already in regexp mode")); + cur.message(_("Already in regular expression mode")); return; } cur.recordUndo(); - docstring const save_selection = grabAndEraseSelection(cur); - selClearOrDel(cur); - // replaceSelection(cur); + docstring sel = cur.selectionAsString(false); + + // It may happen that sel is empty but there is a selection + replaceSelection(cur); - cur.insert(new InsetMathHull(hullRegexp)); + cur.insert(new InsetMathHull(cur.buffer(), hullRegexp)); cur.nextInset()->edit(cur, true); - cur.niceInsert(save_selection); + cur.niceInsert(sel); cur.message(_("Regexp editor mode")); } @@ -231,7 +231,7 @@ static bool doInsertInset(Cursor & cur, Text * text, { Buffer & buffer = cur.bv().buffer(); BufferParams const & bparams = buffer.params(); - Inset * inset = createInset(buffer, cmd); + Inset * inset = createInset(&buffer, cmd); if (!inset) return false; @@ -239,7 +239,7 @@ static bool doInsertInset(Cursor & cur, Text * text, ci->setButtonLabel(); cur.recordUndo(); - if (cmd.action == LFUN_INDEX_INSERT) { + if (cmd.action() == LFUN_INDEX_INSERT) { docstring ds = subst(text->getStringToIndex(cur), '\n', ' '); text->insertInset(cur, inset); if (edit) @@ -269,16 +269,19 @@ static bool doInsertInset(Cursor & cur, Text * text, cur.clearSelection(); // bug 393 cur.finishUndo(); InsetText * insetText = dynamic_cast(inset); - if (insetText && (!insetText->allowMultiPar() || cur.lastpit() == 0)) { - // reset first par to default - cur.text()->paragraphs().begin() - ->setPlainOrDefaultLayout(bparams.documentClass()); - cur.pos() = 0; - cur.pit() = 0; - // Merge multiple paragraphs -- hack - while (cur.lastpit() > 0) - mergeParagraph(bparams, cur.text()->paragraphs(), 0); - cur.leaveInset(*inset); + if (insetText) { + insetText->fixParagraphsFont(); + if (!insetText->allowMultiPar() || cur.lastpit() == 0) { + // reset first par to default + cur.text()->paragraphs().begin() + ->setPlainOrDefaultLayout(bparams.documentClass()); + cur.pos() = 0; + cur.pit() = 0; + // Merge multiple paragraphs -- hack + while (cur.lastpit() > 0) + mergeParagraph(bparams, cur.text()->paragraphs(), 0); + cur.leaveInset(*inset); + } } else { cur.leaveInset(*inset); // reset surrounding par to default @@ -288,7 +291,6 @@ static bool doInsertInset(Cursor & cur, Text * text, : dc.defaultLayoutName(); text->setLayout(cur, layoutname); } - return true; } @@ -299,59 +301,6 @@ string const freefont2string() } -static void dragMove(Cursor & cur, int moveid, int movetoid) -{ - // Create pointers to buffers - Buffer & buf_move = *cur.buffer(); - DocIterator dit_move = buf_move.getParFromID(moveid); - DocIterator dit_dest = buf_move.getParFromID(movetoid); - - pit_type & pit_move = dit_move.pit(); - pit_type & pit_dest = dit_dest.pit(); - ParagraphList & pars = dit_move.text()->paragraphs(); - - // Create references to the paragraphs to be moved - ParagraphList::iterator const bgn = pars.begin(); - ParagraphList::iterator dest_start = boost::next(bgn, pit_dest); - - // The first paragraph of the area to be copied: - ParagraphList::iterator start = boost::next(bgn, pit_move); - // The final paragraph of area to be copied: - ParagraphList::iterator finish = start; - ParagraphList::iterator const end = pars.end(); - - // Move out (down) from this section header - if (finish != end) - ++finish; - - // Seek the one (on same level) below - int const thistoclevel = start->layout().toclevel; - for (; finish != end; ++finish) { - int const toclevel = finish->layout().toclevel; - if (toclevel != Layout::NOT_IN_TOC - && toclevel <= thistoclevel) - break; - } - - if (start == pars.begin() || start == dest_start) - // Nothing to move - return; - - pars.insert(dest_start, start, finish); - pars.erase(start, finish); - - // FIXME: This only really needs doing for the newly - // introduced paragraphs. Something like: - // pit_type const numpars = distance(start, finish); - // start = boost::next(bgn, pit); - // finish = boost::next(start, numpars); - // for (; start != finish; ++start) - // start->setBuffer(buf); - // But while this seems to work, it is kind of fragile. - buf_move.inset().setBuffer(buf_move); -} - - /// the type of outline operation enum OutlineOp { OutlineUp, // Move this header with text down @@ -389,10 +338,6 @@ static void outline(OutlineOp mode, Cursor & cur) break; } - // Do we need to set insets' buffer_ members, because we copied - // some stuff? We'll assume we do and reset it otherwise. - bool set_buffers = true; - switch (mode) { case OutlineUp: { if (start == pars.begin()) @@ -416,10 +361,8 @@ static void outline(OutlineOp mode, Cursor & cur) pit_type const len = distance(start, finish); pit_type const deletepit = pit + len; buf.undo().recordUndo(cur, ATOMIC_UNDO, newpit, deletepit - 1); - pars.insert(dest, start, finish); - start = boost::next(pars.begin(), deletepit); - pit = newpit; - pars.erase(start, finish); + pars.splice(dest, start, finish); + cur.pit() = newpit; break; } case OutlineDown: { @@ -437,12 +380,10 @@ static void outline(OutlineOp mode, Cursor & cur) } // One such was found: pit_type newpit = distance(bgn, dest); - pit_type const len = distance(start, finish); buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, newpit - 1); - pars.insert(dest, start, finish); - start = boost::next(bgn, pit); - pit = newpit - len; - pars.erase(start, finish); + pit_type const len = distance(start, finish); + pars.splice(dest, start, finish); + cur.pit() = newpit - len; break; } case OutlineIn: { @@ -462,7 +403,6 @@ static void outline(OutlineOp mode, Cursor & cur) } } } - set_buffers = false; break; } case OutlineOut: { @@ -482,20 +422,9 @@ static void outline(OutlineOp mode, Cursor & cur) } } } - set_buffers = false; break; } } - if (set_buffers) - // FIXME This only really needs doing for the newly introduced - // paragraphs. Something like: - // pit_type const numpars = distance(start, finish); - // start = boost::next(bgn, pit); - // finish = boost::next(start, numpars); - // for (; start != finish; ++start) - // start->setBuffer(buf); - // But while this seems to work, it is kind of fragile. - buf.inset().setBuffer(buf); } @@ -543,20 +472,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bool sel = cur.selection(); // Signals that, even if needsUpdate == false, an update of the // cursor paragraph is required - bool singleParUpdate = lyxaction.funcHasFlag(cmd.action, + 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); - switch (cmd.action) { + FuncCode const act = cmd.action(); + switch (act) { case LFUN_PARAGRAPH_MOVE_DOWN: { pit_type const pit = cur.pit(); recUndo(cur, pit, pit + 1); cur.finishUndo(); - swap(pars_[pit], pars_[pit + 1]); - cur.buffer()->updateLabels(); + pars_.swap(pit, pit + 1); + cur.buffer()->updateBuffer(); needsUpdate = true; ++cur.pit(); break; @@ -566,8 +496,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) pit_type const pit = cur.pit(); recUndo(cur, pit - 1, pit); cur.finishUndo(); - swap(pars_[pit], pars_[pit - 1]); - cur.buffer()->updateLabels(); + pars_.swap(pit, pit - 1); + cur.buffer()->updateBuffer(); --cur.pit(); needsUpdate = true; break; @@ -593,7 +523,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) par.params().startOfAppendix(start); // we can set the refreshing parameters now - cur.buffer()->updateLabels(); + cur.buffer()->updateBuffer(); break; } @@ -623,7 +553,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_BUFFER_BEGIN: case LFUN_BUFFER_BEGIN_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_BEGIN_SELECT); + needsUpdate |= cur.selHandle(act == LFUN_BUFFER_BEGIN_SELECT); if (cur.depth() == 1) needsUpdate |= cursorTop(cur); else @@ -633,7 +563,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_BUFFER_END: case LFUN_BUFFER_END_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_END_SELECT); + needsUpdate |= cur.selHandle(act == LFUN_BUFFER_END_SELECT); if (cur.depth() == 1) needsUpdate |= cursorBottom(cur); else @@ -643,8 +573,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_INSET_BEGIN: case LFUN_INSET_BEGIN_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_BEGIN_SELECT); - if (cur.depth() == 1 || cur.pos() > 0) + needsUpdate |= cur.selHandle(act == LFUN_INSET_BEGIN_SELECT); + if (cur.depth() == 1 || !cur.top().at_begin()) needsUpdate |= cursorTop(cur); else cur.undispatched(); @@ -653,18 +583,30 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_INSET_END: case LFUN_INSET_END_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_END_SELECT); - if (cur.depth() == 1 || cur.pos() < cur.lastpos()) + needsUpdate |= cur.selHandle(act == LFUN_INSET_END_SELECT); + if (cur.depth() == 1 || !cur.top().at_end()) needsUpdate |= cursorBottom(cur); else cur.undispatched(); cur.updateFlags(Update::FitCursor); break; + case LFUN_INSET_SELECT_ALL: + if (cur.depth() == 1 || !cur.selection() || !cur.selBegin().at_begin() + || !cur.selEnd().at_end()) { + needsUpdate |= cur.selHandle(false); + needsUpdate |= cursorTop(cur); + needsUpdate |= cur.selHandle(true); + needsUpdate |= cursorBottom(cur); + } else + cur.undispatched(); + cur.updateFlags(Update::FitCursor); + break; + case LFUN_CHAR_FORWARD: case LFUN_CHAR_FORWARD_SELECT: //LYXERR0(" LFUN_CHAR_FORWARD[SEL]:\n" << cur); - needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT); + needsUpdate |= cur.selHandle(act == LFUN_CHAR_FORWARD_SELECT); needsUpdate |= cursorForward(cur); if (!needsUpdate && oldTopSlice == cur.top() @@ -690,7 +632,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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); + needsUpdate |= cur.selHandle(act == LFUN_CHAR_BACKWARD_SELECT); needsUpdate |= cursorBackward(cur); if (!needsUpdate && oldTopSlice == cur.top() @@ -716,7 +658,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CHAR_LEFT: case LFUN_CHAR_LEFT_SELECT: if (lyxrc.visual_cursor) { - needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_LEFT_SELECT); + needsUpdate |= cur.selHandle(act == LFUN_CHAR_LEFT_SELECT); needsUpdate |= cursorVisLeft(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { @@ -725,11 +667,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } else { if (reverseDirectionNeeded(cur)) { - cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? - LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD; + cmd.setAction(cmd.action() == LFUN_CHAR_LEFT_SELECT ? + LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD); } else { - cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? - LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD; + cmd.setAction(cmd.action() == LFUN_CHAR_LEFT_SELECT ? + LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD); } dispatch(cur, cmd); return; @@ -739,7 +681,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CHAR_RIGHT: case LFUN_CHAR_RIGHT_SELECT: if (lyxrc.visual_cursor) { - needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_RIGHT_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_CHAR_RIGHT_SELECT); needsUpdate |= cursorVisRight(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { @@ -748,11 +690,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } else { if (reverseDirectionNeeded(cur)) { - cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? - LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD; + cmd.setAction(cmd.action() == LFUN_CHAR_RIGHT_SELECT ? + LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD); } else { - cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? - LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD; + cmd.setAction(cmd.action() == LFUN_CHAR_RIGHT_SELECT ? + LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD); } dispatch(cur, cmd); return; @@ -765,11 +707,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_UP: case LFUN_DOWN: { // stop/start the selection - bool select = cmd.action == LFUN_DOWN_SELECT || - cmd.action == LFUN_UP_SELECT; + bool select = cmd.action() == LFUN_DOWN_SELECT || + cmd.action() == LFUN_UP_SELECT; // move cursor up/down - bool up = cmd.action == LFUN_UP_SELECT || cmd.action == LFUN_UP; + bool up = cmd.action() == LFUN_UP_SELECT || cmd.action() == LFUN_UP; bool const atFirstOrLastRow = cur.atFirstOrLastRow(up); if (!atFirstOrLastRow) { @@ -791,25 +733,25 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_UP_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_UP_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_PARAGRAPH_UP_SELECT); needsUpdate |= cursorUpParagraph(cur); break; case LFUN_PARAGRAPH_DOWN: case LFUN_PARAGRAPH_DOWN_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_DOWN_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_PARAGRAPH_DOWN_SELECT); needsUpdate |= cursorDownParagraph(cur); break; case LFUN_LINE_BEGIN: case LFUN_LINE_BEGIN_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_LINE_BEGIN_SELECT); needsUpdate |= tm->cursorHome(cur); break; case LFUN_LINE_END: case LFUN_LINE_END_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_END_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_LINE_END_SELECT); needsUpdate |= tm->cursorEnd(cur); break; @@ -851,7 +793,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_RIGHT: case LFUN_WORD_RIGHT_SELECT: if (lyxrc.visual_cursor) { - needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_RIGHT_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_RIGHT_SELECT); needsUpdate |= cursorVisRightOneWord(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { @@ -860,11 +802,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } else { if (reverseDirectionNeeded(cur)) { - cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ? - LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD; + cmd.setAction(cmd.action() == LFUN_WORD_RIGHT_SELECT ? + LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD); } else { - cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ? - LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD; + cmd.setAction(cmd.action() == LFUN_WORD_RIGHT_SELECT ? + LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD); } dispatch(cur, cmd); return; @@ -873,14 +815,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_FORWARD: case LFUN_WORD_FORWARD_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_FORWARD_SELECT); needsUpdate |= cursorForwardOneWord(cur); break; case LFUN_WORD_LEFT: case LFUN_WORD_LEFT_SELECT: if (lyxrc.visual_cursor) { - needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_LEFT_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_LEFT_SELECT); needsUpdate |= cursorVisLeftOneWord(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { @@ -889,11 +831,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } else { if (reverseDirectionNeeded(cur)) { - cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ? - LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD; + cmd.setAction(cmd.action() == LFUN_WORD_LEFT_SELECT ? + LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD); } else { - cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ? - LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD; + cmd.setAction(cmd.action() == LFUN_WORD_LEFT_SELECT ? + LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD); } dispatch(cur, cmd); return; @@ -902,7 +844,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_BACKWARD: case LFUN_WORD_BACKWARD_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_BACKWARD_SELECT); needsUpdate |= cursorBackwardOneWord(cur); break; @@ -943,8 +885,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bv->buffer().params().trackChanges); // Update the selection pos to make sure the selection does not // change as the inserted tab will increase the logical pos. - if (cur.anchor_.pit() == pit) - cur.anchor_.forwardPos(); + if (cur.realAnchor().pit() == pit) + cur.realAnchor().forwardPos(); if (cur.pit() == pit) cur.forwardPos(); } @@ -970,8 +912,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (par.getChar(0) == '\t') { if (cur.pit() == pit) cur.posBackward(); - if (cur.anchor_.pit() == pit && cur.anchor_.pos() > 0 ) - cur.anchor_.backwardPos(); + if (cur.realAnchor().pit() == pit && cur.realAnchor().pos() > 0 ) + cur.realAnchor().backwardPos(); par.eraseChar(0, tc); } else @@ -980,8 +922,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) par.getChar(0) == ' ' && n_spaces < 4; ++n_spaces) { if (cur.pit() == pit) cur.posBackward(); - if (cur.anchor_.pit() == pit && cur.anchor_.pos() > 0 ) - cur.anchor_.backwardPos(); + if (cur.realAnchor().pit() == pit && cur.realAnchor().pos() > 0 ) + cur.realAnchor().backwardPos(); par.eraseChar(0, tc); } @@ -1061,13 +1003,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // before inserting into the document. See bug #5626. bool loaded = bv->buffer().isFullyLoaded(); bv->buffer().setFullyLoaded(false); - Inset * inset = createInset(bv->buffer(), cmd); + Inset * inset = createInset(&bv->buffer(), cmd); bv->buffer().setFullyLoaded(loaded); if (inset) { // FIXME (Abdel 01/02/2006): // What follows would be a partial fix for bug 2154: - // http://bugzilla.lyx.org/show_bug.cgi?id=2154 + // http://www.lyx.org/trac/ticket/2154 // This automatically put the label inset _after_ a // numbered section. It should be possible to extend the mechanism // to any kind of LateX environement. @@ -1104,26 +1046,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_INSET_DISSOLVE: { - // first, try if there's an inset at cursor - // FIXME: this first part should be moved to - // a LFUN_NEXT_INSET_DISSOLVE, or be called via - // some generic "next-inset inset-dissolve" - Inset * inset = cur.nextInset(); - if (inset && inset->isActive()) { - Cursor tmpcur = cur; - tmpcur.pushBackward(*inset); - inset->dispatch(tmpcur, cmd); - if (tmpcur.result().dispatched()) { - cur.dispatched(); - break; - } - } - // if it did not work, try the underlying inset - if (dissolveInset(cur)) { + if (dissolveInset(cur)) needsUpdate = true; - break; - } - // if it did not work, do nothing. break; } @@ -1396,7 +1320,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) else c = par.getChar(pos - 1); string arg = to_utf8(cmd.argument()); - cur.insert(new InsetQuotes(bv->buffer(), c, (arg == "single") + cur.insert(new InsetQuotes(cur.buffer(), c, (arg == "single") ? InsetQuotes::SingleQuotes : InsetQuotes::DoubleQuotes)); cur.posForward(); } @@ -1431,14 +1355,17 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; // Single-click on work area - case LFUN_MOUSE_PRESS: + case LFUN_MOUSE_PRESS: { // We are not marking a selection with the keyboard in any case. - cur.bv().cursor().setMark(false); + Cursor & bvcur = cur.bv().cursor(); + bvcur.setMark(false); switch (cmd.button()) { case mouse_button::button1: // Set the cursor if (!bv->mouseSetCursor(cur, cmd.argument() == "region-select")) cur.updateFlags(Update::SinglePar | Update::FitCursor); + if (bvcur.wordSelection()) + selectWord(bvcur, WHOLE_WORD); break; case mouse_button::button2: @@ -1451,7 +1378,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; case mouse_button::button3: { - Cursor const & bvcur = cur.bv().cursor(); // Don't do anything if we right-click a // selection, a context menu will popup. if (bvcur.selection() && cur >= bvcur.selectionBegin() @@ -1468,7 +1394,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } // switch (cmd.button()) break; - + } case LFUN_MOUSE_MOTION: { // Mouse motion with right or middle mouse do nothing for now. if (cmd.button() != mouse_button::button1) { @@ -1477,26 +1403,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } // ignore motions deeper nested than the real anchor Cursor & bvcur = cur.bv().cursor(); - if (!bvcur.anchor_.hasPart(cur)) { + if (!bvcur.realAnchor().hasPart(cur)) { cur.undispatched(); break; } CursorSlice old = bvcur.top(); int const wh = bv->workHeight(); - int const y = max(0, min(wh - 1, cmd.y)); + int const y = max(0, min(wh - 1, cmd.y())); - tm->setCursorFromCoordinates(cur, cmd.x, y); - cur.setTargetX(cmd.x); - if (cmd.y >= wh) + tm->setCursorFromCoordinates(cur, cmd.x(), y); + cur.setTargetX(cmd.x()); + if (cmd.y() >= wh) lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT)); - else if (cmd.y < 0) + else if (cmd.y() < 0) lyx::dispatch(FuncRequest(LFUN_UP_SELECT)); // This is to allow jumping over large insets if (cur.top() == old) { - if (cmd.y >= wh) + if (cmd.y() >= wh) lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT)); - else if (cmd.y < 0) + else if (cmd.y() < 0) lyx::dispatch(FuncRequest(LFUN_UP_SELECT)); } // We continue with our existing selection or start a new one, so don't @@ -1623,9 +1549,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) docstring ds = cur.selectionAsString(false); cutSelection(cur, true, false); FuncRequest cmd0(cmd, ds); - inset = createInset(cur.bv().buffer(), cmd0); + inset = createInset(cur.buffer(), cmd0); } else { - inset = createInset(cur.bv().buffer(), cmd); + inset = createInset(cur.buffer(), cmd); } if (!inset) break; @@ -1646,13 +1572,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_MARGINALNOTE_INSERT: case LFUN_OPTIONAL_INSERT: case LFUN_INDEX_INSERT: + case LFUN_PREVIEW_INSERT: // Open the inset, and move the current selection // inside it. doInsertInset(cur, this, cmd, true, true); cur.posForward(); // Some insets are numbered, others are shown in the outline pane so // let's update the labels and the toc backend. - bv->buffer().updateLabels(); + bv->buffer().updateBuffer(); break; case LFUN_TABULAR_INSERT: @@ -1685,7 +1612,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // add a separate paragraph for the caption inset pars.push_back(Paragraph()); - pars.back().setInsetOwner(&pars[0].inInset()); + pars.back().setInsetOwner(&cur.text()->inset()); pars.back().setPlainOrDefaultLayout(tclass); int cap_pit = pars.size() - 1; @@ -1694,7 +1621,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // the graphics (or table). if (!content) { pars.push_back(Paragraph()); - pars.back().setInsetOwner(&pars[0].inInset()); + pars.back().setInsetOwner(&cur.text()->inset()); pars.back().setPlainOrDefaultLayout(tclass); } @@ -1706,7 +1633,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // date metrics. FuncRequest cmd_caption(LFUN_CAPTION_INSERT); doInsertInset(cur, cur.text(), cmd_caption, true, false); - bv->buffer().updateLabels(); + bv->buffer().updateBuffer(); cur.updateFlags(Update::Force); // FIXME: When leaving the Float (or Wrap) inset we should // delete any empty paragraph left above or below the @@ -1781,7 +1708,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) MacroType type = MacroTypeNewcommand; if (s2 == "def") type = MacroTypeDef; - MathMacroTemplate * inset = new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, false, type); + MathMacroTemplate * inset = new MathMacroTemplate(cur.buffer(), + from_utf8(token(s, ' ', 0)), nargs, false, type); inset->setBuffer(bv->buffer()); insertInset(cur, inset); @@ -1809,7 +1737,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_MATH_BIGDELIM: { cur.recordUndo(); cap::replaceSelection(cur); - cur.insert(new InsetMathHull(hullSimple)); + cur.insert(new InsetMathHull(cur.buffer(), hullSimple)); checkAndActivateInset(cur, true); LASSERT(cur.inMathed(), /**/); cur.dispatch(cmd); @@ -2006,7 +1934,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_ACCENT_HUNGARIAN_UMLAUT: case LFUN_ACCENT_CIRCLE: case LFUN_ACCENT_OGONEK: - theLyXFunc().handleKeyFunc(cmd.action); + theApp()->handleKeyFunc(cmd.action()); if (!cmd.argument().empty()) // FIXME: Are all these characters encoded in one byte in utf8? bv->translateAndInsert(cmd.argument()[0], this, cur); @@ -2035,7 +1963,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) setParagraphs(cur, p); // FIXME This should be simplified when InsetFloatList takes a // Buffer in its constructor. - InsetFloatList * ifl = new InsetFloatList(to_utf8(cmd.argument())); + InsetFloatList * ifl = new InsetFloatList(cur.buffer(), to_utf8(cmd.argument())); ifl->setBuffer(bv->buffer()); insertInset(cur, ifl); cur.posForward(); @@ -2072,6 +2000,44 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } + case LFUN_SPELLING_ADD: { + docstring word = from_utf8(cmd.getArg(0)); + Language * lang; + if (word.empty()) { + word = cur.selectionAsString(false); + // FIXME + if (word.size() > 100 || word.empty()) { + // Get word or selection + selectWordWhenUnderCursor(cur, WHOLE_WORD); + word = cur.selectionAsString(false); + } + lang = const_cast(cur.getFont().language()); + } else + lang = const_cast(languages.getLanguage(cmd.getArg(1))); + WordLangTuple wl(word, lang); + theSpellChecker()->insert(wl); + break; + } + + case LFUN_SPELLING_IGNORE: { + docstring word = from_utf8(cmd.getArg(0)); + Language * lang; + if (word.empty()) { + word = cur.selectionAsString(false); + // FIXME + if (word.size() > 100 || word.empty()) { + // Get word or selection + selectWordWhenUnderCursor(cur, WHOLE_WORD); + word = cur.selectionAsString(false); + } + lang = const_cast(cur.getFont().language()); + } else + lang = const_cast(languages.getLanguage(cmd.getArg(1))); + WordLangTuple wl(word, lang); + theSpellChecker()->accept(wl); + break; + } + case LFUN_PARAGRAPH_PARAMS_APPLY: { // Given data, an encoding of the ParagraphParameters // generated in the Paragraph dialog, this function sets @@ -2108,38 +2074,28 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_OUTLINE_UP: outline(OutlineUp, cur); setCursor(cur, cur.pit(), 0); - cur.buffer()->updateLabels(); + cur.buffer()->updateBuffer(); needsUpdate = true; break; case LFUN_OUTLINE_DOWN: outline(OutlineDown, cur); setCursor(cur, cur.pit(), 0); - cur.buffer()->updateLabels(); + cur.buffer()->updateBuffer(); needsUpdate = true; break; case LFUN_OUTLINE_IN: outline(OutlineIn, cur); - cur.buffer()->updateLabels(); + cur.buffer()->updateBuffer(); needsUpdate = true; break; case LFUN_OUTLINE_OUT: outline(OutlineOut, cur); - cur.buffer()->updateLabels(); + cur.buffer()->updateBuffer(); needsUpdate = true; break; - - case LFUN_OUTLINE_DRAGMOVE: { - int const move_id = convert(cmd.getArg(0)); - int const move_to_id = convert(cmd.getArg(1)); - dragMove(cur, move_id, move_to_id); - setCursor(cur, cur.pit(), 0); - cur.buffer()->updateLabels(); - needsUpdate = true; - break; - } default: LYXERR(Debug::ACTION, "Command " << cmd << " not DISPATCHED by Text"); @@ -2147,10 +2103,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } - if (lyxrc.spellcheck_continuously && cur.inTexted()) - // Take this opportunity to spellcheck current word. - cur.paragraph().isMisspelled(cur.pos()); - needsUpdate |= (cur.pos() != cur.lastpos()) && cur.selection(); // FIXME: The cursor flag is reset two lines below @@ -2202,7 +2154,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, bool enable = true; InsetCode code = NO_CODE; - switch (cmd.action) { + switch (cmd.action()) { case LFUN_DEPTH_DECREMENT: enable = changeDepthAllowed(cur, DEC_DEPTH); @@ -2325,11 +2277,24 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, // not allowed in description items enable = !inDescriptionItem(cur); break; - case LFUN_FLOAT_LIST_INSERT: + case LFUN_FLOAT_LIST_INSERT: { code = FLOAT_LIST_CODE; // not allowed in description items enable = !inDescriptionItem(cur); + if (enable) { + FloatList const & floats = cur.buffer()->params().documentClass().floats(); + FloatList::const_iterator cit = floats[to_ascii(cmd.argument())]; + // make sure we know about such floats + if (cit == floats.end() || + // and that we know how to generate a list of them + (!cit->second.needsFloatPkg() && cit->second.listCommand().empty())) { + flag.setUnknown(true); + // probably not necessary, but... + enable = false; + } + } break; + } case LFUN_CAPTION_INSERT: code = CAPTION_CODE; // not allowed in description items @@ -2425,6 +2390,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, if (cur.inTexted()) code = SPACE_CODE; break; + case LFUN_PREVIEW_INSERT: + code = PREVIEW_CODE; + break; case LFUN_MATH_INSERT: case LFUN_MATH_AMS_MATRIX: @@ -2439,6 +2407,11 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, code = MATH_HULL_CODE; break; + case LFUN_REGEXP_MODE: + code = MATH_HULL_CODE; + enable = cur.buffer()->isInternal() && !cur.inRegexped(); + break; + case LFUN_INSET_MODIFY: // We need to disable this, because we may get called for a // tabular cell via @@ -2449,31 +2422,38 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_FONT_EMPH: flag.setOnOff(fontinfo.emph() == FONT_ON); + enable = !cur.inset().getLayout().isPassThru(); break; case LFUN_FONT_ITAL: flag.setOnOff(fontinfo.shape() == ITALIC_SHAPE); + enable = !cur.inset().getLayout().isPassThru(); break; case LFUN_FONT_NOUN: flag.setOnOff(fontinfo.noun() == FONT_ON); + enable = !cur.inset().getLayout().isPassThru(); break; case LFUN_FONT_BOLD: case LFUN_FONT_BOLDSYMBOL: flag.setOnOff(fontinfo.series() == BOLD_SERIES); + enable = !cur.inset().getLayout().isPassThru(); break; case LFUN_FONT_SANS: flag.setOnOff(fontinfo.family() == SANS_FAMILY); + enable = !cur.inset().getLayout().isPassThru(); break; case LFUN_FONT_ROMAN: flag.setOnOff(fontinfo.family() == ROMAN_FAMILY); + enable = !cur.inset().getLayout().isPassThru(); break; case LFUN_FONT_TYPEWRITER: flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY); + enable = !cur.inset().getLayout().isPassThru(); break; case LFUN_CUT: @@ -2536,21 +2516,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, enable = cur.pit() < cur.lastpit() && !cur.selection(); break; - case LFUN_INSET_DISSOLVE: - if (!cmd.argument().empty()) { - InsetLayout const & il = cur.inset().getLayout(); - InsetLayout::InsetLyXType const type = - translateLyXType(to_utf8(cmd.argument())); - enable = cur.inset().lyxCode() == FLEX_CODE - && il.lyxtype() == type; - } else { - enable = ((!isMainText() - && cur.inset().nargs() == 1) - || (cur.nextInset() - && cur.nextInset()->nargs() == 1)); - } - break; - case LFUN_CHANGE_ACCEPT: case LFUN_CHANGE_REJECT: // In principle, these LFUNs should only be enabled if there @@ -2570,7 +2535,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_OUTLINE_DOWN: case LFUN_OUTLINE_IN: case LFUN_OUTLINE_OUT: - case LFUN_OUTLINE_DRAGMOVE: // FIXME: LyX is not ready for outlining within inset. enable = isMainText() && cur.paragraph().layout().toclevel != Layout::NOT_IN_TOC; @@ -2610,9 +2574,58 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_LANGUAGE: enable = !cur.inset().getLayout().isPassThru(); + flag.setOnOff(to_utf8(cmd.argument()) == cur.real_current_font.language()->lang()); + break; case LFUN_BREAK_PARAGRAPH: enable = cur.inset().getLayout().isMultiPar(); + break; + + case LFUN_SPELLING_ADD: + case LFUN_SPELLING_IGNORE: + enable = theSpellChecker(); + break; + + case LFUN_LAYOUT: + enable = !cur.inset().forcePlainLayout(); + break; + + case LFUN_LAYOUT_PARAGRAPH: + case LFUN_PARAGRAPH_PARAMS: + case LFUN_PARAGRAPH_PARAMS_APPLY: + case LFUN_PARAGRAPH_UPDATE: + enable = cur.inset().allowParagraphCustomization(); + break; + + // FIXME: why are accent lfuns forbidden with pass_thru layouts? + case LFUN_ACCENT_ACUTE: + case LFUN_ACCENT_BREVE: + case LFUN_ACCENT_CARON: + case LFUN_ACCENT_CEDILLA: + case LFUN_ACCENT_CIRCLE: + case LFUN_ACCENT_CIRCUMFLEX: + case LFUN_ACCENT_DOT: + case LFUN_ACCENT_GRAVE: + case LFUN_ACCENT_HUNGARIAN_UMLAUT: + case LFUN_ACCENT_MACRON: + case LFUN_ACCENT_OGONEK: + case LFUN_ACCENT_TIE: + case LFUN_ACCENT_TILDE: + case LFUN_ACCENT_UMLAUT: + case LFUN_ACCENT_UNDERBAR: + case LFUN_ACCENT_UNDERDOT: + case LFUN_FONT_DEFAULT: + case LFUN_FONT_FRAK: + case LFUN_FONT_SIZE: + case LFUN_FONT_STATE: + case LFUN_FONT_UNDERLINE: + case LFUN_FONT_STRIKEOUT: + case LFUN_FONT_UULINE: + case LFUN_FONT_UWAVE: + case LFUN_TEXTSTYLE_APPLY: + case LFUN_TEXTSTYLE_UPDATE: + enable = !cur.inset().getLayout().isPassThru(); + break; case LFUN_WORD_DELETE_FORWARD: case LFUN_WORD_DELETE_BACKWARD: @@ -2643,6 +2656,15 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_WORD_LEFT_SELECT: case LFUN_WORD_SELECT: case LFUN_SECTION_SELECT: + case LFUN_BUFFER_BEGIN: + case LFUN_BUFFER_END: + case LFUN_BUFFER_BEGIN_SELECT: + case LFUN_BUFFER_END_SELECT: + case LFUN_INSET_BEGIN: + case LFUN_INSET_END: + case LFUN_INSET_BEGIN_SELECT: + case LFUN_INSET_END_SELECT: + case LFUN_INSET_SELECT_ALL: case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_DOWN: case LFUN_LINE_BEGIN: @@ -2657,47 +2679,10 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_SERVER_GET_XY: case LFUN_SERVER_SET_XY: case LFUN_SERVER_GET_LAYOUT: - case LFUN_LAYOUT: case LFUN_SELF_INSERT: - case LFUN_FONT_DEFAULT: - case LFUN_FONT_UNDERLINE: - case LFUN_FONT_STRIKEOUT: - case LFUN_FONT_UULINE: - case LFUN_FONT_UWAVE: - case LFUN_FONT_SIZE: - case LFUN_TEXTSTYLE_APPLY: - case LFUN_TEXTSTYLE_UPDATE: - case LFUN_LAYOUT_PARAGRAPH: - case LFUN_PARAGRAPH_UPDATE: - 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_BREVE: - case LFUN_ACCENT_TIE: - case LFUN_ACCENT_HUNGARIAN_UMLAUT: - case LFUN_ACCENT_CIRCLE: - case LFUN_ACCENT_OGONEK: + case LFUN_UNICODE_INSERT: case LFUN_THESAURUS_ENTRY: - case LFUN_PARAGRAPH_PARAMS_APPLY: - case LFUN_PARAGRAPH_PARAMS: case LFUN_ESCAPE: - case LFUN_BUFFER_BEGIN: - case LFUN_BUFFER_END: - case LFUN_BUFFER_BEGIN_SELECT: - case LFUN_BUFFER_END_SELECT: - case LFUN_INSET_BEGIN: - case LFUN_INSET_END: - case LFUN_INSET_BEGIN_SELECT: - case LFUN_INSET_END_SELECT: - case LFUN_UNICODE_INSERT: // these are handled in our dispatch() enable = true; break; @@ -2712,61 +2697,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, || cur.paragraph().layout().pass_thru)) enable = false; - switch (cmd.action) { - case LFUN_ACCENT_ACUTE: - case LFUN_ACCENT_BREVE: - case LFUN_ACCENT_CARON: - case LFUN_ACCENT_CEDILLA: - case LFUN_ACCENT_CIRCLE: - case LFUN_ACCENT_CIRCUMFLEX: - case LFUN_ACCENT_DOT: - case LFUN_ACCENT_GRAVE: - case LFUN_ACCENT_HUNGARIAN_UMLAUT: - case LFUN_ACCENT_MACRON: - case LFUN_ACCENT_OGONEK: - case LFUN_ACCENT_TIE: - case LFUN_ACCENT_TILDE: - case LFUN_ACCENT_UMLAUT: - case LFUN_ACCENT_UNDERBAR: - case LFUN_ACCENT_UNDERDOT: - case LFUN_APPENDIX: - case LFUN_DEPTH_DECREMENT: - case LFUN_DEPTH_INCREMENT: - case LFUN_FILE_INSERT: - case LFUN_FONT_BOLD: - case LFUN_FONT_BOLDSYMBOL: - case LFUN_FONT_TYPEWRITER: - case LFUN_FONT_DEFAULT: - case LFUN_FONT_EMPH: - case LFUN_FONT_NOUN: - case LFUN_FONT_ROMAN: - case LFUN_FONT_SANS: - case LFUN_FONT_FRAK: - case LFUN_FONT_ITAL: - case LFUN_FONT_SIZE: - case LFUN_FONT_STATE: - case LFUN_FONT_UNDERLINE: - case LFUN_FONT_STRIKEOUT: - case LFUN_FONT_UULINE: - case LFUN_FONT_UWAVE: - case LFUN_LABEL_GOTO: - case LFUN_LAYOUT_TABULAR: - case LFUN_MENU_OPEN: - case LFUN_NOACTION: - case LFUN_NOTE_NEXT: - case LFUN_REFERENCE_NEXT: - case LFUN_SERVER_GOTO_FILE_ROW: - case LFUN_SERVER_NOTIFY: - case LFUN_SERVER_SET_XY: - case LFUN_TEXTSTYLE_APPLY: - case LFUN_TEXTSTYLE_UPDATE: - if (cur.inset().getLayout().isPassThru()) - enable = false; - break; - default: - break; - } - flag.setEnabled(enable); return true; }