X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=bfb392c63e2227ba34f276b3f44c9885c51b9aac;hb=2e72a0af48023956ae6ce3285b47168c2fed5099;hp=6b13972cc68f7870c1def6d5e8604664cdf89a60;hpb=8480d1dd9af6f3d403ea42e2b891d38dd3ce2509;p=lyx.git diff --git a/src/Text3.cpp b/src/Text3.cpp index 6b13972cc6..bfb392c63e 100644 --- a/src/Text3.cpp +++ b/src/Text3.cpp @@ -45,13 +45,13 @@ #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/Selection.h" +#include "insets/InsetArgument.h" #include "insets/InsetCollapsable.h" #include "insets/InsetCommand.h" #include "insets/InsetExternal.h" @@ -59,6 +59,7 @@ #include "insets/InsetFloatList.h" #include "insets/InsetGraphics.h" #include "insets/InsetGraphicsParams.h" +#include "insets/InsetIPAMacro.h" #include "insets/InsetNewline.h" #include "insets/InsetQuotes.h" #include "insets/InsetSpecialChar.h" @@ -68,6 +69,7 @@ #include "support/convert.h" #include "support/debug.h" #include "support/gettext.h" +#include "support/lassert.h" #include "support/lstrings.h" #include "support/lyxtime.h" #include "support/os.h" @@ -93,6 +95,7 @@ using cap::pasteClipboardGraphics; using cap::replaceSelection; using cap::grabAndEraseSelection; using cap::selClearOrDel; +using cap::pasteSimpleText; // globals... static Font freefont(ignore_font, ignore_language); @@ -226,6 +229,15 @@ static void specialChar(Cursor & cur, InsetSpecialChar::Kind kind) } +static void ipaChar(Cursor & cur, InsetIPAChar::Kind kind) +{ + cur.recordUndo(); + cap::replaceSelection(cur); + cur.insert(new InsetIPAChar(kind)); + cur.posForward(); +} + + static bool doInsertInset(Cursor & cur, Text * text, FuncRequest const & cmd, bool edit, bool pastesel) { @@ -245,8 +257,11 @@ static bool doInsertInset(Cursor & cur, Text * text, if (edit) inset->edit(cur, true); // Now put this into inset - cur.text()->insertStringAsLines(cur, ds, cur.current_font); - cur.leaveInset(*inset); + Font const f(inherit_font, cur.current_font.language()); + if (!ds.empty()) { + cur.text()->insertStringAsLines(cur, ds, f); + cur.leaveInset(*inset); + } return true; } @@ -268,10 +283,10 @@ static bool doInsertInset(Cursor & cur, Text * text, cur.buffer()->errors("Paste"); cur.clearSelection(); // bug 393 cur.finishUndo(); - InsetText * insetText = dynamic_cast(inset); - if (insetText) { - insetText->fixParagraphsFont(); - if (!insetText->allowMultiPar() || cur.lastpit() == 0) { + InsetText * inset_text = inset->asInsetText(); + if (inset_text) { + inset_text->fixParagraphsFont(); + if (!inset_text->allowMultiPar() || cur.lastpit() == 0) { // reset first par to default cur.text()->paragraphs().begin() ->setPlainOrDefaultLayout(bparams.documentClass()); @@ -280,7 +295,14 @@ static bool doInsertInset(Cursor & cur, Text * text, // Merge multiple paragraphs -- hack while (cur.lastpit() > 0) mergeParagraph(bparams, cur.text()->paragraphs(), 0); + if (cmd.action() == LFUN_FLEX_INSERT) + return true; + Cursor old = cur; cur.leaveInset(*inset); + if (cmd.action() == LFUN_PREVIEW_INSERT + || cmd.action() == LFUN_IPA_INSERT) + // trigger preview + notifyCursorLeavesOrEnters(old, cur); } } else { cur.leaveInset(*inset); @@ -324,7 +346,7 @@ static void outline(OutlineOp mode, Cursor & cur) DocumentClass const & tc = buf.params().documentClass(); - int const thistoclevel = start->layout().toclevel; + int const thistoclevel = buf.text().getTocLevel(distance(bgn, start)); int toclevel; // Move out (down) from this section header @@ -333,7 +355,7 @@ static void outline(OutlineOp mode, Cursor & cur) // Seek the one (on same level) below for (; finish != end; ++finish) { - toclevel = finish->layout().toclevel; + toclevel = buf.text().getTocLevel(distance(bgn, finish)); if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel) break; } @@ -350,7 +372,7 @@ static void outline(OutlineOp mode, Cursor & cur) // Search previous same-level header above do { --dest; - toclevel = dest->layout().toclevel; + toclevel = buf.text().getTocLevel(distance(bgn, dest)); } while(dest != bgn && (toclevel == Layout::NOT_IN_TOC || toclevel > thistoclevel)); @@ -373,7 +395,7 @@ static void outline(OutlineOp mode, Cursor & cur) ParagraphList::iterator dest = boost::next(finish, 1); // Go further down to find header to insert in front of: for (; dest != end; ++dest) { - toclevel = dest->layout().toclevel; + toclevel = buf.text().getTocLevel(distance(bgn, dest)); if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel) break; @@ -390,7 +412,7 @@ static void outline(OutlineOp mode, Cursor & cur) pit_type const len = distance(start, finish); buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, pit + len - 1); for (; start != finish; ++start) { - toclevel = start->layout().toclevel; + toclevel = buf.text().getTocLevel(distance(bgn, start)); if (toclevel == Layout::NOT_IN_TOC) continue; DocumentClass::const_iterator lit = tc.begin(); @@ -409,7 +431,7 @@ static void outline(OutlineOp mode, Cursor & cur) pit_type const len = distance(start, finish); buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, pit + len - 1); for (; start != finish; ++start) { - toclevel = start->layout().toclevel; + toclevel = buf.text().getTocLevel(distance(bgn, start)); if (toclevel == Layout::NOT_IN_TOC) continue; DocumentClass::const_iterator lit = tc.begin(); @@ -464,12 +486,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // 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(); + cur.noScreenUpdate(); LASSERT(cur.text() == this, /**/); - CursorSlice oldTopSlice = cur.top(); - bool oldBoundary = cur.boundary(); - bool sel = cur.selection(); + CursorSlice const oldTopSlice = cur.top(); + bool const oldBoundary = cur.boundary(); + bool const oldSelection = cur.selection(); // Signals that, even if needsUpdate == false, an update of the // cursor paragraph is required bool singleParUpdate = lyxaction.funcHasFlag(cmd.action(), @@ -477,7 +499,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Signals that a full-screen update is required bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action(), LyXAction::NoUpdate) || singleParUpdate); - + bool const last_misspelled = lyxrc.spellcheck_continuously + && cur.paragraph().isMisspelled(cur.pos(), true); + FuncCode const act = cmd.action(); switch (act) { @@ -486,8 +510,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) recUndo(cur, pit, pit + 1); cur.finishUndo(); pars_.swap(pit, pit + 1); - cur.buffer()->updateBuffer(); needsUpdate = true; + cur.forceBufferUpdate(); ++cur.pit(); break; } @@ -497,9 +521,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) recUndo(cur, pit - 1, pit); cur.finishUndo(); pars_.swap(pit, pit - 1); - cur.buffer()->updateBuffer(); --cur.pit(); needsUpdate = true; + cur.forceBufferUpdate(); break; } @@ -523,7 +547,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) par.params().startOfAppendix(start); // we can set the refreshing parameters now - cur.buffer()->updateBuffer(); + cur.forceBufferUpdate(); break; } @@ -558,7 +582,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= cursorTop(cur); else cur.undispatched(); - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_BUFFER_END: @@ -568,7 +592,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= cursorBottom(cur); else cur.undispatched(); - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_INSET_BEGIN: @@ -578,7 +602,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= cursorTop(cur); else cur.undispatched(); - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_INSET_END: @@ -588,7 +612,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= cursorBottom(cur); else cur.undispatched(); - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_INSET_SELECT_ALL: @@ -600,7 +624,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= cursorBottom(cur); } else cur.undispatched(); - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_CHAR_FORWARD: @@ -624,7 +648,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // provide it with two different cursors. Cursor dummy = cur; dummy.pos() = dummy.pit() = 0; - cur.bv().checkDepm(dummy, cur); + if (cur.bv().checkDepm(dummy, cur)) { + cur.forceBufferUpdate(); + // DEPM may have requested a screen update + cur.screenUpdateFlags( + cur.screenUpdate() | dummy.screenUpdate()); + } } } break; @@ -650,7 +679,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) Cursor dummy = cur; dummy.pos() = cur.lastpos(); dummy.pit() = cur.lastpit(); - cur.bv().checkDepm(dummy, cur); + if (cur.bv().checkDepm(dummy, cur)) { + cur.forceBufferUpdate(); + // DEPM may have requested a screen update + cur.screenUpdateFlags( + cur.screenUpdate() | dummy.screenUpdate()); + } } } break; @@ -766,7 +800,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) ParagraphList::iterator finish = start; ParagraphList::iterator end = pars.end(); - int const thistoclevel = start->layout().toclevel; + int const thistoclevel = buf.text().getTocLevel(distance(bgn, start)); if (thistoclevel == Layout::NOT_IN_TOC) break; @@ -780,7 +814,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Seek the one (on same level) below for (; finish != end; ++finish, ++cur.pit()) { - int const toclevel = finish->layout().toclevel; + int const toclevel = buf.text().getTocLevel(distance(bgn, finish)); if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel) break; } @@ -817,6 +851,30 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_FORWARD_SELECT: needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_FORWARD_SELECT); needsUpdate |= cursorForwardOneWord(cur); + + if (!needsUpdate && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_FORWARD); + + // we will probably be moving out the inset, so we should execute + // the depm-mechanism, but only when the cursor has a place to + // go outside this inset, i.e. in a slice above. + if (cur.depth() > 1 && cur.pos() == cur.lastpos() + && cur.pit() == cur.lastpit()) { + // The cursor hasn't changed yet. To give the + // DEPM the possibility of doing something we must + // provide it with two different cursors. + Cursor dummy = cur; + dummy.pos() = dummy.pit() = 0; + if (cur.bv().checkDepm(dummy, cur)) { + cur.forceBufferUpdate(); + // DEPM may have requested a screen update + cur.screenUpdateFlags( + cur.screenUpdate() | dummy.screenUpdate()); + } + } + } break; case LFUN_WORD_LEFT: @@ -846,6 +904,31 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_BACKWARD_SELECT: needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_BACKWARD_SELECT); needsUpdate |= cursorBackwardOneWord(cur); + + if (!needsUpdate && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_BACKWARD); + + // we will probably be moving out the inset, so we should execute + // the depm-mechanism, but only when the cursor has a place to + // go outside this inset, i.e. in a slice above. + if (cur.depth() > 1 && cur.pos() == 0 + && cur.pit() == 0) { + // The cursor hasn't changed yet. To give the + // DEPM the possibility of doing something we must + // provide it with two different cursors. + Cursor dummy = cur; + dummy.pos() = cur.lastpos(); + dummy.pit() = cur.lastpit(); + if (cur.bv().checkDepm(dummy, cur)) { + cur.forceBufferUpdate(); + // DEPM may have requested a screen update + cur.screenUpdateFlags( + cur.screenUpdate() | dummy.screenUpdate()); + } + } + } break; case LFUN_WORD_SELECT: { @@ -909,24 +992,22 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) pit_type const pit_end = cur.selEnd().pit(); for (pit_type pit = cur.selBegin().pit(); pit <= pit_end; pit++) { Paragraph & par = paragraphs()[pit]; - if (par.getChar(0) == '\t') { - if (cur.pit() == pit) - cur.posBackward(); - if (cur.realAnchor().pit() == pit && cur.realAnchor().pos() > 0 ) - cur.realAnchor().backwardPos(); - - par.eraseChar(0, tc); - } else - // If no tab was present, try to remove up to four spaces. - for (int n_spaces = 0; - par.getChar(0) == ' ' && n_spaces < 4; ++n_spaces) { + if (par.empty()) + continue; + char_type const c = par.getChar(0); + if (c == '\t' || c == ' ') { + // remove either 1 tab or 4 spaces. + int const n = (c == ' ' ? 4 : 1); + for (int i = 0; i < n + && !par.empty() && par.getChar(0) == c; ++i) { if (cur.pit() == pit) cur.posBackward(); - if (cur.realAnchor().pit() == pit && cur.realAnchor().pos() > 0 ) + if (cur.realAnchor().pit() == pit + && cur.realAnchor().pos() > 0 ) cur.realAnchor().backwardPos(); - par.eraseChar(0, tc); } + } } cur.finishUndo(); } else { @@ -990,7 +1071,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } break; - case LFUN_BREAK_PARAGRAPH: + case LFUN_PARAGRAPH_BREAK: cap::replaceSelection(cur); breakParagraph(cur, cmd.argument() == "inverse"); cur.resetAnchor(); @@ -1032,7 +1113,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (cur.selection()) cutSelection(cur, true, false); cur.insert(inset); - cur.posForward(); + if (inset->editable() && inset->asInsetText()) + inset->edit(cur, true); + else + cur.posForward(); // trigger InstantPreview now if (inset->lyxCode() == EXTERNAL_CODE) { @@ -1046,8 +1130,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_INSET_DISSOLVE: { - if (dissolveInset(cur)) + if (dissolveInset(cur)) { needsUpdate = true; + cur.forceBufferUpdate(); + } break; } @@ -1106,6 +1192,35 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } + case LFUN_IPAMACRO_INSERT: { + string const arg = cmd.getArg(0); + if (arg == "deco") { + // 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. + cur.forceBufferUpdate(); + break; + } + if (arg == "tone-falling") + ipaChar(cur, InsetIPAChar::TONE_FALLING); + else if (arg == "tone-rising") + ipaChar(cur, InsetIPAChar::TONE_RISING); + else if (arg == "tone-high-rising") + ipaChar(cur, InsetIPAChar::TONE_HIGH_RISING); + else if (arg == "tone-low-rising") + ipaChar(cur, InsetIPAChar::TONE_LOW_RISING); + else if (arg == "tone-high-rising-falling") + ipaChar(cur, InsetIPAChar::TONE_HIGH_RISING_FALLING); + else if (arg.empty()) + lyxerr << "LyX function 'ipamacro-insert' needs an argument." << endl; + else + lyxerr << "Wrong argument for LyX function 'ipamacro-insert'." << endl; + break; + } + case LFUN_WORD_UPCASE: changeCase(cur, text_uppercase); break; @@ -1259,17 +1374,49 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (change_layout) setLayout(cur, layout); + Layout::LaTeXArgMap args = tclass[layout].args(); + Layout::LaTeXArgMap::const_iterator lait = args.begin(); + Layout::LaTeXArgMap::const_iterator const laend = args.end(); + for (; lait != laend; ++lait) { + Layout::latexarg arg = (*lait).second; + if (arg.autoinsert) { + FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first); + lyx::dispatch(cmd); + } + } + + break; + } + + case LFUN_ENVIRONMENT_SPLIT: { + Paragraph const & para = cur.paragraph(); + docstring const layout = para.layout().name(); + if (cur.pos() > 0) + lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK)); + bool const morecont = cur.lastpos() > cur.pos(); + lyx::dispatch(FuncRequest(LFUN_LAYOUT, "Separator")); + lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse")); + if (morecont) + lyx::dispatch(FuncRequest(LFUN_DOWN)); + lyx::dispatch(FuncRequest(LFUN_LAYOUT, layout)); + break; } case LFUN_CLIPBOARD_PASTE: - cur.clearSelection(); + cap::replaceSelection(cur); pasteClipboardText(cur, bv->buffer().errorList("Paste"), cmd.argument() == "paragraph"); bv->buffer().errors("Paste"); break; + case LFUN_CLIPBOARD_PASTE_SIMPLE: + cap::replaceSelection(cur); + pasteSimpleText(cur, cmd.argument() == "paragraph"); + break; + case LFUN_PRIMARY_SELECTION_PASTE: + cap::replaceSelection(cur); pasteString(cur, theSelection().get(), cmd.argument() == "paragraph"); break; @@ -1278,6 +1425,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Copy the selection buffer to the clipboard stack, // because we want it to appear in the "Edit->Paste // recent" menu. + cap::replaceSelection(cur); cap::copySelectionToStack(); cap::pasteSelection(bv->cursor(), bv->buffer().errorList("Paste")); bv->buffer().errors("Paste"); @@ -1299,33 +1447,34 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_QUOTE_INSERT: { - Paragraph & par = cur.paragraph(); + // this avoids a double undo + // FIXME: should not be needed, ideally + if (!cur.selection()) + cur.recordUndo(); + cap::replaceSelection(cur); + + Paragraph const & par = cur.paragraph(); pos_type pos = cur.pos(); + BufferParams const & bufparams = bv->buffer().params(); - Layout const & style = par.layout(); - InsetLayout const & ilayout = cur.inset().getLayout(); - if (!style.pass_thru && !ilayout.isPassThru() - && par.getFontSettings(bufparams, pos).language()->lang() != "hebrew") { - // this avoids a double undo - // FIXME: should not be needed, ideally - if (!cur.selection()) - cur.recordUndo(); - cap::replaceSelection(cur); - pos = cur.pos(); - char_type c; - if (pos == 0) - c = ' '; - else if (cur.prevInset() && cur.prevInset()->isSpace()) - c = ' '; - else + bool const hebrew = + par.getFontSettings(bufparams, pos).language()->lang() == "hebrew"; + bool const allow_inset_quote = !(par.isPassThru() || hebrew); + + if (allow_inset_quote) { + char_type c = ' '; + if (pos > 0 && (!cur.prevInset() || !cur.prevInset()->isSpace())) c = par.getChar(pos - 1); - string arg = to_utf8(cmd.argument()); - cur.insert(new InsetQuotes(cur.buffer(), c, (arg == "single") - ? InsetQuotes::SingleQuotes : InsetQuotes::DoubleQuotes)); + string const arg = to_utf8(cmd.argument()); + InsetQuotes::QuoteTimes const quote_type = (arg == "single") + ? InsetQuotes::SingleQuotes : InsetQuotes::DoubleQuotes; + cur.insert(new InsetQuotes(cur.buffer(), c, quote_type)); cur.posForward(); - } - else + } else { + // The cursor might have been invalidated by the replaceSelection. + cur.buffer()->changed(true); lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, "\"")); + } break; } @@ -1363,7 +1512,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case mouse_button::button1: // Set the cursor if (!bv->mouseSetCursor(cur, cmd.argument() == "region-select")) - cur.updateFlags(Update::SinglePar | Update::FitCursor); + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); if (bvcur.wordSelection()) selectWord(bvcur, WHOLE_WORD); break; @@ -1374,7 +1523,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) lyx::dispatch( FuncRequest(LFUN_COMMAND_ALTERNATIVES, "selection-paste ; primary-selection-paste paragraph")); - cur.noUpdate(); + cur.noScreenUpdate(); break; case mouse_button::button3: { @@ -1382,11 +1531,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // selection, a context menu will popup. if (bvcur.selection() && cur >= bvcur.selectionBegin() && cur < bvcur.selectionEnd()) { - cur.noUpdate(); + cur.noScreenUpdate(); return; } if (!bv->mouseSetCursor(cur, false)) - cur.updateFlags(Update::SinglePar | Update::FitCursor); + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); break; } @@ -1398,7 +1547,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_MOUSE_MOTION: { // Mouse motion with right or middle mouse do nothing for now. if (cmd.button() != mouse_button::button1) { - cur.noUpdate(); + cur.noScreenUpdate(); return; } // ignore motions deeper nested than the real anchor @@ -1431,8 +1580,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bvcur.setSelection(true); if (cur.top() == old) { // We didn't move one iota, so no need to update the screen. - cur.updateFlags(Update::SinglePar | Update::FitCursor); - //cur.noUpdate(); + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); + //cur.noScreenUpdate(); return; } break; @@ -1453,23 +1602,23 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.bv().cursor().setSelection(); // We might have removed an empty but drawn selection // (probably a margin) - cur.updateFlags(Update::SinglePar | Update::FitCursor); + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); } else - cur.noUpdate(); + cur.noScreenUpdate(); // FIXME: We could try to handle drag and drop of selection here. return; case mouse_button::button2: // Middle mouse pasting is handled at mouse press time, // see LFUN_MOUSE_PRESS. - cur.noUpdate(); + cur.noScreenUpdate(); return; case mouse_button::button3: // Cursor was set at LFUN_MOUSE_PRESS time. // FIXME: If there is a selection we could try to handle a special // drag & drop context menu. - cur.noUpdate(); + cur.noScreenUpdate(); return; case mouse_button::none: @@ -1502,6 +1651,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.resetAnchor(); moveCursor(cur, false); + cur.markNewWordPosition(); bv->bookmarkEditPosition(); break; } @@ -1515,7 +1665,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } p["target"] = (cmd.argument().empty()) ? content : cmd.argument(); - string const data = InsetCommand::params2string("href", p); + string const data = InsetCommand::params2string(p); if (p["target"].empty()) { bv->showDialog("href", data); } else { @@ -1531,7 +1681,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) p["name"] = (cmd.argument().empty()) ? cur.getPossibleLabel() : cmd.argument(); - string const data = InsetCommand::params2string("label", p); + string const data = InsetCommand::params2string(p); if (cmd.argument().empty()) { bv->showDialog("label", data); @@ -1563,24 +1713,56 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CAPTION_INSERT: case LFUN_FOOTNOTE_INSERT: case LFUN_NOTE_INSERT: - case LFUN_FLEX_INSERT: case LFUN_BOX_INSERT: case LFUN_BRANCH_INSERT: case LFUN_PHANTOM_INSERT: case LFUN_ERT_INSERT: case LFUN_LISTING_INSERT: case LFUN_MARGINALNOTE_INSERT: - case LFUN_OPTIONAL_INSERT: + case LFUN_ARGUMENT_INSERT: case LFUN_INDEX_INSERT: case LFUN_PREVIEW_INSERT: + case LFUN_SCRIPT_INSERT: + case LFUN_IPA_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().updateBuffer(); + cur.forceBufferUpdate(); + break; + + case LFUN_FLEX_INSERT: { + // Open the inset, and move the current selection + // inside it. + bool const sel = cur.selection(); + doInsertInset(cur, this, cmd, true, true); + // Insert auto-insert arguments + bool autoargs = false; + Layout::LaTeXArgMap args = cur.inset().getLayout().latexargs(); + Layout::LaTeXArgMap::const_iterator lait = args.begin(); + Layout::LaTeXArgMap::const_iterator const laend = args.end(); + for (; lait != laend; ++lait) { + Layout::latexarg arg = (*lait).second; + if (arg.autoinsert) { + // The cursor might have been invalidated by the replaceSelection. + cur.buffer()->changed(true); + FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first); + lyx::dispatch(cmd); + autoargs = true; + } + } + if (!autoargs) { + if (sel) + cur.leaveInset(cur.inset()); + cur.posForward(); + } + // Some insets are numbered, others are shown in the outline pane so + // let's update the labels and the toc backend. + cur.forceBufferUpdate(); break; + } case LFUN_TABULAR_INSERT: // if there were no arguments, just open the dialog @@ -1594,16 +1776,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_FLOAT_INSERT: case LFUN_FLOAT_WIDE_INSERT: case LFUN_WRAP_INSERT: { - // will some text be moved into the inset? - bool content = cur.selection(); + // will some content be moved into the inset? + bool const content = cur.selection(); + // does the content consist of multiple paragraphs? + bool const singlepar = (cur.selBegin().pit() == cur.selEnd().pit()); doInsertInset(cur, this, cmd, true, true); cur.posForward(); - // If some text is moved into the inset, doInsertInset - // puts the cursor outside the inset. To insert the - // caption we put it back into the inset. - if (content) + // If some single-par content is moved into the inset, + // doInsertInset puts the cursor outside the inset. + // To insert the caption we put it back into the inset. + // FIXME cleanup doInsertInset to avoid such dances! + if (content && singlepar) cur.backwardPos(); ParagraphList & pars = cur.text()->paragraphs(); @@ -1633,8 +1818,8 @@ 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().updateBuffer(); - cur.updateFlags(Update::Force); + cur.forceBufferUpdate(); + cur.screenUpdateFlags(Update::Force); // FIXME: When leaving the Float (or Wrap) inset we should // delete any empty paragraph left above or below the // caption. @@ -1647,7 +1832,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) p["symbol"] = bv->cursor().innerText()->getStringToIndex(bv->cursor()); else p["symbol"] = cmd.argument(); - string const data = InsetCommand::params2string("nomenclature", p); + string const data = InsetCommand::params2string(p); bv->showDialog("nomenclature", data); break; } @@ -1658,15 +1843,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) p["type"] = from_ascii("idx"); else p["type"] = cmd.argument(); - string const data = InsetCommand::params2string("index_print", p); + string const data = InsetCommand::params2string(p); FuncRequest fr(LFUN_INSET_INSERT, data); dispatch(cur, fr); break; } case LFUN_NOMENCL_PRINT: - case LFUN_TOC_INSERT: - case LFUN_LINE_INSERT: case LFUN_NEWPAGE_INSERT: // do nothing fancy doInsertInset(cur, this, cmd, false, false); @@ -1692,6 +1875,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_MATH_MODE: if (cmd.argument() == "on") // don't pass "on" as argument + // (it would appear literally in the first cell) mathDispatch(cur, FuncRequest(LFUN_MATH_MODE), false); else mathDispatch(cur, cmd, false); @@ -1701,6 +1885,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (cmd.argument().empty()) cur.errorMessage(from_utf8(N_("Missing argument"))); else { + cur.recordUndo(); string s = to_utf8(cmd.argument()); string const s1 = token(s, ' ', 1); int const nargs = s1.empty() ? 0 : convert(s1); @@ -1836,11 +2021,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_LANGUAGE: { - Language const * lang = languages.getLanguage(to_utf8(cmd.argument())); - if (!lang) + string const lang_arg = cmd.getArg(0); + bool const reset = (lang_arg.empty() || lang_arg == "reset"); + Language const * lang = + reset ? reset_language + : languages.getLanguage(lang_arg); + // we allow reset_language, which is 0, but only if it + // was requested via empty or "reset" arg. + if (!lang && !reset) break; + bool const toggle = (cmd.getArg(1) != "set"); + selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT); Font font(ignore_font, lang); - toggleAndShow(cur, this, font); + toggleAndShow(cur, this, font, toggle); break; } @@ -1938,6 +2131,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (!cmd.argument().empty()) // FIXME: Are all these characters encoded in one byte in utf8? bv->translateAndInsert(cmd.argument()[0], this, cur); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_FLOAT_LIST_INSERT: { @@ -2038,6 +2232,25 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } + case LFUN_SPELLING_REMOVE: { + 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()->remove(wl); + break; + } + case LFUN_PARAGRAPH_PARAMS_APPLY: { // Given data, an encoding of the ParagraphParameters // generated in the Paragraph dialog, this function sets @@ -2074,26 +2287,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_OUTLINE_UP: outline(OutlineUp, cur); setCursor(cur, cur.pit(), 0); - cur.buffer()->updateBuffer(); + cur.forceBufferUpdate(); needsUpdate = true; break; case LFUN_OUTLINE_DOWN: outline(OutlineDown, cur); setCursor(cur, cur.pit(), 0); - cur.buffer()->updateBuffer(); + cur.forceBufferUpdate(); needsUpdate = true; break; case LFUN_OUTLINE_IN: outline(OutlineIn, cur); - cur.buffer()->updateBuffer(); + cur.forceBufferUpdate(); needsUpdate = true; break; case LFUN_OUTLINE_OUT: outline(OutlineOut, cur); - cur.buffer()->updateBuffer(); + cur.forceBufferUpdate(); needsUpdate = true; break; @@ -2105,12 +2318,27 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= (cur.pos() != cur.lastpos()) && cur.selection(); + if (lyxrc.spellcheck_continuously && !needsUpdate) { + // Check for misspelled text + // The redraw is useful because of the painting of + // misspelled markers depends on the cursor position. + // Trigger a redraw for cursor moves inside misspelled text. + if (!cur.inTexted()) { + // move from regular text to math + needsUpdate = last_misspelled; + } else if (oldTopSlice != cur.top() || oldBoundary != cur.boundary()) { + // move inside regular text + needsUpdate = last_misspelled + || cur.paragraph().isMisspelled(cur.pos(), true); + } + } + // 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 Text::erase() and Text::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) { + if (cur.result().screenUpdate() & Update::Force) { singleParUpdate = false; needsUpdate = true; } @@ -2121,27 +2349,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Inserting characters does not change par height in general. So, try // to update _only_ this paragraph. BufferView will detect if a full // metrics update is needed anyway. - cur.updateFlags(Update::SinglePar | Update::FitCursor); + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); return; } - if (!needsUpdate && &oldTopSlice.inset() == &cur.inset() && oldTopSlice.idx() == cur.idx() - && !sel // sel is a backup of cur.selection() at the beginning of the function. + && !oldSelection // oldSelection is a backup of cur.selection() at the beginning of the function. && !cur.selection()) // FIXME: it would be better if we could just do this // //if (cur.result().update() != Update::FitCursor) - // cur.noUpdate(); + // cur.noScreenUpdate(); // // But some LFUNs do not set Update::FitCursor when needed, so we // do it for all. This is not very harmfull as FitCursor will provoke // a full redraw only if needed but still, a proper review of all LFUN // should be done and this needsUpdate boolean can then be removed. - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); else - cur.updateFlags(Update::Force | Update::FitCursor); + cur.screenUpdateFlags(Update::Force | Update::FitCursor); } @@ -2152,6 +2379,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, FontInfo const & fontinfo = cur.real_current_font.fontInfo(); bool enable = true; + bool allow_in_passthru = false; InsetCode code = NO_CODE; switch (cmd.action()) { @@ -2165,6 +2393,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; case LFUN_APPENDIX: + // FIXME We really should not allow this to be put, e.g., + // in a footnote, or in ERT. But it would make sense in a + // branch, so I'm not sure what to do. flag.setOnOff(cur.paragraph().params().startOfAppendix()); break; @@ -2204,6 +2435,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, code = NOMENCL_PRINT_CODE; else if (cmd.argument() == "label") code = LABEL_CODE; + else if (cmd.argument() == "line") + code = LINE_CODE; else if (cmd.argument() == "note") code = NOTE_CODE; else if (cmd.argument() == "phantom") @@ -2287,7 +2520,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, // 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())) { + (!cit->second.usesFloatPkg() && cit->second.listCommand().empty())) { flag.setUnknown(true); // probably not necessary, but... enable = false; @@ -2295,11 +2528,21 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, } break; } - case LFUN_CAPTION_INSERT: + case LFUN_CAPTION_INSERT: { code = CAPTION_CODE; - // not allowed in description items - enable = !inDescriptionItem(cur); + bool varia = true; + if (cur.depth() > 0) { + if (&cur[cur.depth() - 1].inset() + && !cur[cur.depth() - 1].inset().allowsCaptionVariation()) + varia = false; + } + string arg = cmd.getArg(0); + // not allowed in description items, + // and in specific insets + enable = !inDescriptionItem(cur) + && (varia || arg.empty() || arg == "Standard"); break; + } case LFUN_NOTE_INSERT: code = NOTE_CODE; // in commands (sections etc.) and description items, @@ -2329,23 +2572,69 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, && cur.buffer()->params().branchlist().empty()) enable = false; break; + case LFUN_IPA_INSERT: + code = IPA_CODE; + break; case LFUN_PHANTOM_INSERT: code = PHANTOM_CODE; break; case LFUN_LABEL_INSERT: code = LABEL_CODE; break; - case LFUN_LINE_INSERT: - code = LINE_CODE; - break; case LFUN_INFO_INSERT: code = INFO_CODE; break; - case LFUN_OPTIONAL_INSERT: { + case LFUN_ARGUMENT_INSERT: { code = ARG_CODE; + allow_in_passthru = true; + string const arg = cmd.getArg(0); + if (arg.empty()) { + enable = false; + break; + } Layout const & lay = cur.paragraph().layout(); - int const numargs = lay.reqargs + lay.optargs; - enable = cur.paragraph().insetList().count(ARG_CODE) < numargs; + Layout::LaTeXArgMap args = lay.args(); + Layout::LaTeXArgMap::const_iterator const lait = + args.find(arg); + if (lait != args.end()) { + enable = true; + pit_type pit = cur.pit(); + pit_type lastpit = cur.pit(); + if (lay.isEnvironment() && !prefixIs(arg, "item:")) { + // In a sequence of "merged" environment layouts, we only allow + // non-item arguments once. + lastpit = cur.lastpit(); + // get the first paragraph in sequence with this layout + depth_type const current_depth = cur.paragraph().params().depth(); + while (true) { + if (pit == 0) + break; + Paragraph cpar = pars_[pit - 1]; + if (cpar.layout() == lay && cpar.params().depth() == current_depth) + --pit; + else + break; + } + } + for (; pit <= lastpit; ++pit) { + if (pars_[pit].layout() != lay) + break; + InsetList::const_iterator it = pars_[pit].insetList().begin(); + InsetList::const_iterator end = pars_[pit].insetList().end(); + for (; it != end; ++it) { + if (it->inset->lyxCode() == ARG_CODE) { + InsetArgument const * ins = + static_cast(it->inset); + if (ins->name() == arg) { + // we have this already + enable = false; + break; + } + } + } + } + } else + enable = false; break; } case LFUN_INDEX_INSERT: @@ -2368,11 +2657,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, // not allowed in description items enable = !inDescriptionItem(cur); break; - case LFUN_TOC_INSERT: - code = TOC_CODE; - // not allowed in description items - enable = !inDescriptionItem(cur); - break; case LFUN_HYPERLINK_INSERT: if (cur.selIsMultiCell() || cur.selIsMultiLine()) { enable = false; @@ -2380,6 +2664,14 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, } code = HYPERLINK_CODE; break; + case LFUN_IPAMACRO_INSERT: { + string const arg = cmd.getArg(0); + if (arg == "deco") + code = IPADECO_CODE; + else + code = IPACHAR_CODE; + break; + } case LFUN_QUOTE_INSERT: // always allow this, since we will inset a raw quote // if an inset is not allowed. @@ -2395,6 +2687,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_PREVIEW_INSERT: code = PREVIEW_CODE; break; + case LFUN_SCRIPT_INSERT: + code = SCRIPT_CODE; + break; case LFUN_MATH_INSERT: case LFUN_MATH_AMS_MATRIX: @@ -2424,38 +2719,38 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_FONT_EMPH: flag.setOnOff(fontinfo.emph() == FONT_ON); - enable = !cur.inset().getLayout().isPassThru(); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_ITAL: flag.setOnOff(fontinfo.shape() == ITALIC_SHAPE); - enable = !cur.inset().getLayout().isPassThru(); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_NOUN: flag.setOnOff(fontinfo.noun() == FONT_ON); - enable = !cur.inset().getLayout().isPassThru(); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_BOLD: case LFUN_FONT_BOLDSYMBOL: flag.setOnOff(fontinfo.series() == BOLD_SERIES); - enable = !cur.inset().getLayout().isPassThru(); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_SANS: flag.setOnOff(fontinfo.family() == SANS_FAMILY); - enable = !cur.inset().getLayout().isPassThru(); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_ROMAN: flag.setOnOff(fontinfo.family() == ROMAN_FAMILY); - enable = !cur.inset().getLayout().isPassThru(); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_TYPEWRITER: flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY); - enable = !cur.inset().getLayout().isPassThru(); + enable = !cur.paragraph().isPassThru(); break; case LFUN_CUT: @@ -2499,6 +2794,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, } case LFUN_CLIPBOARD_PASTE: + case LFUN_CLIPBOARD_PASTE_SIMPLE: enable = !theClipboard().empty(); break; @@ -2539,7 +2835,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_OUTLINE_OUT: // FIXME: LyX is not ready for outlining within inset. enable = isMainText() - && cur.paragraph().layout().toclevel != Layout::NOT_IN_TOC; + && cur.buffer()->text().getTocLevel(cur.pit()) != Layout::NOT_IN_TOC; break; case LFUN_NEWLINE_INSERT: @@ -2549,7 +2845,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_TAB_INSERT: case LFUN_TAB_DELETE: - enable = cur.inset().getLayout().isPassThru(); + enable = cur.paragraph().isPassThru(); break; case LFUN_SET_GRAPHICS_GROUP: { @@ -2575,23 +2871,34 @@ 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()); + enable = !cur.paragraph().isPassThru(); + flag.setOnOff(cmd.getArg(0) == cur.real_current_font.language()->lang()); break; - case LFUN_BREAK_PARAGRAPH: + case LFUN_PARAGRAPH_BREAK: enable = cur.inset().getLayout().isMultiPar(); break; case LFUN_SPELLING_ADD: case LFUN_SPELLING_IGNORE: + case LFUN_SPELLING_REMOVE: enable = theSpellChecker(); break; case LFUN_LAYOUT: enable = !cur.inset().forcePlainLayout(); break; - + + case LFUN_ENVIRONMENT_SPLIT: { + if (cur.paragraph().layout().isEnvironment() + && cur.buffer()->params().documentClass().hasLayout(from_ascii("Separator"))) { + enable = true; + break; + } + enable = false; + break; + } + case LFUN_LAYOUT_PARAGRAPH: case LFUN_PARAGRAPH_PARAMS: case LFUN_PARAGRAPH_PARAMS_APPLY: @@ -2626,7 +2933,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_FONT_UWAVE: case LFUN_TEXTSTYLE_APPLY: case LFUN_TEXTSTYLE_UPDATE: - enable = !cur.inset().getLayout().isPassThru(); + enable = !cur.paragraph().isPassThru(); break; case LFUN_WORD_DELETE_FORWARD: @@ -2673,7 +2980,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_LINE_END: case LFUN_CHAR_DELETE_FORWARD: case LFUN_CHAR_DELETE_BACKWARD: - case LFUN_INSET_INSERT: case LFUN_WORD_UPCASE: case LFUN_WORD_LOWCASE: case LFUN_WORD_CAPITALIZE: @@ -2689,6 +2995,19 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, enable = true; break; + case LFUN_INSET_INSERT: { + string const type = cmd.getArg(0); + if (type == "toc") { + code = TOC_CODE; + // not allowed in description items + //FIXME: couldn't this be merged in Inset::insetAllowed()? + enable = !inDescriptionItem(cur); + } else { + enable = true; + } + break; + } + default: return false; } @@ -2696,7 +3015,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, if (code != NO_CODE && (cur.empty() || !cur.inset().insetAllowed(code) - || cur.paragraph().layout().pass_thru)) + || (cur.paragraph().layout().pass_thru && !allow_in_passthru))) enable = false; flag.setEnabled(enable); @@ -2707,7 +3026,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, void Text::pasteString(Cursor & cur, docstring const & clip, bool asParagraphs) { - cur.clearSelection(); if (!clip.empty()) { cur.recordUndo(); if (asParagraphs)