X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=fa9fa8d69f0c9d22f09682e965a693aa38280c4c;hb=8c6ac457ecc69f57ab54cd8c9b8b7893607c65d6;hp=e89f81e77a75ab8203bf618f9e61c0b3bd542e7c;hpb=d35d25460b57c14e67a26c593881dfff31b35da5;p=lyx.git diff --git a/src/Text3.cpp b/src/Text3.cpp index e89f81e77a..fa9fa8d69f 100644 --- a/src/Text3.cpp +++ b/src/Text3.cpp @@ -17,6 +17,7 @@ #include "Text.h" +#include "Bidi.h" #include "BranchList.h" #include "FloatList.h" #include "FuncStatus.h" @@ -24,17 +25,18 @@ #include "buffer_funcs.h" #include "BufferParams.h" #include "BufferView.h" -#include "bufferview_funcs.h" #include "Cursor.h" #include "CutAndPaste.h" -#include "debug.h" +#include "support/debug.h" #include "DispatchResult.h" #include "ErrorList.h" #include "factory.h" #include "FuncRequest.h" -#include "gettext.h" +#include "support/gettext.h" +#include "InsetList.h" #include "Intl.h" #include "Language.h" +#include "Layout.h" #include "LyXAction.h" #include "LyXFunc.h" #include "Lexer.h" @@ -42,19 +44,22 @@ #include "Paragraph.h" #include "paragraph_funcs.h" #include "ParagraphParameters.h" -#include "Undo.h" -#include "VSpace.h" #include "ParIterator.h" +#include "TextClass.h" +#include "TextMetrics.h" +#include "VSpace.h" #include "frontends/Clipboard.h" #include "frontends/Selection.h" +#include "insets/InsetCollapsable.h" #include "insets/InsetCommand.h" #include "insets/InsetFloatList.h" #include "insets/InsetNewline.h" #include "insets/InsetQuotes.h" #include "insets/InsetSpecialChar.h" #include "insets/InsetText.h" +#include "insets/InsetInfo.h" #include "support/lstrings.h" #include "support/lyxlib.h" @@ -64,7 +69,7 @@ #include "mathed/InsetMathHull.h" #include "mathed/MathMacroTemplate.h" -#include +#include #include #include @@ -85,176 +90,304 @@ using cap::replaceSelection; using support::isStrUnsignedInt; using support::token; -namespace frontend { -extern docstring current_layout; -} +// globals... +static Font freefont(ignore_font, ignore_language); +static bool toggleall = false; -namespace { - - // globals... - Font freefont(Font::ALL_IGNORE); - bool toggleall = false; - - void toggleAndShow(Cursor & cur, Text * text, - Font const & font, bool toggleall = true) - { - text->toggleFree(cur, font, toggleall); - - if (font.language() != ignore_language || - font.number() != Font::IGNORE) { - Paragraph & par = cur.paragraph(); - TextMetrics const & tm = cur.bv().textMetrics(text); - if (cur.boundary() != tm.isRTLBoundary(par, - cur.pos(), cur.real_current_font)) - text->setCursor(cur, cur.pit(), cur.pos(), - false, !cur.boundary()); - } +static void toggleAndShow(Cursor & cur, Text * text, + Font const & font, bool toggleall = true) +{ + text->toggleFree(cur, font, toggleall); + + if (font.language() != ignore_language || + font.fontInfo().number() != FONT_IGNORE) { + TextMetrics const & tm = cur.bv().textMetrics(text); + if (cur.boundary() != tm.isRTLBoundary(cur.pit(), cur.pos(), + cur.real_current_font)) + text->setCursor(cur, cur.pit(), cur.pos(), + false, !cur.boundary()); } +} - void moveCursor(Cursor & cur, bool selecting) - { - if (selecting || cur.mark()) - cur.setSelection(); - } +static void moveCursor(Cursor & cur, bool selecting) +{ + if (selecting || cur.mark()) + cur.setSelection(); +} - void finishChange(Cursor & cur, bool selecting) - { - finishUndo(); - moveCursor(cur, selecting); - } +static void finishChange(Cursor & cur, bool selecting) +{ + cur.finishUndo(); + moveCursor(cur, selecting); +} - void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display) - { - recordUndo(cur); - docstring sel = cur.selectionAsString(false); +static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display) +{ + cur.recordUndo(); + docstring sel = cur.selectionAsString(false); - // It may happen that sel is empty but there is a selection - replaceSelection(cur); + // It may happen that sel is empty but there is a selection + replaceSelection(cur); - if (sel.empty()) { + if (sel.empty()) { #ifdef ENABLE_ASSERTIONS - const int old_pos = cur.pos(); + const int old_pos = cur.pos(); #endif - cur.insert(new InsetMathHull(hullSimple)); - BOOST_ASSERT(old_pos == cur.pos()); - cur.nextInset()->edit(cur, true); - // don't do that also for LFUN_MATH_MODE - // 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)); - // Avoid an unnecessary undo step if cmd.argument - // is empty - if (!cmd.argument().empty()) - cur.dispatch(FuncRequest(LFUN_MATH_INSERT, - cmd.argument())); + cur.insert(new InsetMathHull(hullSimple)); + BOOST_ASSERT(old_pos == cur.pos()); + cur.nextInset()->edit(cur, true); + // don't do that also for LFUN_MATH_MODE + // 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)); + // Avoid an unnecessary undo step if cmd.argument + // is empty + if (!cmd.argument().empty()) + cur.dispatch(FuncRequest(LFUN_MATH_INSERT, + cmd.argument())); + } else { + // create a macro if we see "\\newcommand" + // somewhere, and an ordinary formula + // otherwise + if (sel.find(from_ascii("\\newcommand")) == string::npos + && sel.find(from_ascii("\\def")) == string::npos) + { + InsetMathHull * formula = new InsetMathHull; + istringstream is(to_utf8(sel)); + Lexer lex(0, 0); + lex.setStream(is); + formula->read(cur.buffer(), lex); + if (formula->getType() == hullNone) + // Don't create pseudo formulas if + // delimiters are left out + formula->mutate(hullSimple); + cur.insert(formula); } else { - // create a macro if we see "\\newcommand" - // somewhere, and an ordinary formula - // otherwise - if (sel.find(from_ascii("\\newcommand")) == string::npos - && sel.find(from_ascii("\\def")) == string::npos) - { - InsetMathHull * formula = new InsetMathHull; - istringstream is(to_utf8(sel)); - Lexer lex(0, 0); - lex.setStream(is); - formula->read(cur.buffer(), lex); - if (formula->getType() == hullNone) - // Don't create pseudo formulas if - // delimiters are left out - formula->mutate(hullSimple); - cur.insert(formula); - } else { - cur.insert(new MathMacroTemplate(sel)); - } + cur.insert(new MathMacroTemplate(sel)); } - cur.message(from_utf8(N_("Math editor mode"))); } - -} // namespace anon - - - -namespace bv_funcs { - -string const freefont2string() -{ - string data; - if (font2string(freefont, toggleall, data)) - return data; - return string(); -} - + cur.message(from_utf8(N_("Math editor mode"))); } -namespace { - -void specialChar(Cursor & cur, InsetSpecialChar::Kind kind) +static void specialChar(Cursor & cur, InsetSpecialChar::Kind kind) { - recordUndo(cur); + cur.recordUndo(); cap::replaceSelection(cur); cur.insert(new InsetSpecialChar(kind)); - cur.posRight(); + cur.posForward(); } -bool doInsertInset(Cursor & cur, Text * text, +static bool doInsertInset(Cursor & cur, Text * text, FuncRequest const & cmd, bool edit, bool pastesel) { - Inset * inset = createInset(&cur.bv(), cmd); + Inset * inset = createInset(cur.bv().buffer(), cmd); if (!inset) return false; - recordUndo(cur); - bool gotsel = false; - if (cur.selection()) { - lyx::dispatch(FuncRequest(LFUN_CUT)); - gotsel = true; - } - text->insertInset(cur, inset); - - if (edit) - inset->edit(cur, true); - - if (gotsel && pastesel) { - lyx::dispatch(FuncRequest(LFUN_PASTE, "0")); - // reset first par to default - if (cur.lastpit() != 0 || cur.lastpos() != 0) { - LayoutPtr const layout = - cur.buffer().params().getTextClass().defaultLayout(); - cur.text()->paragraphs().begin()->layout(layout); + if (InsetCollapsable * ci = inset->asInsetCollapsable()) + ci->setLayout(cur.bv().buffer().params()); + + cur.recordUndo(); + if (cmd.action == LFUN_INDEX_INSERT) { + docstring ds = support::subst(text->getStringToIndex(cur), '\n', ' '); + text->insertInset(cur, inset); + if (edit) + inset->edit(cur, true); + // Now put this into inset + static_cast(inset)->text_.insertStringAsParagraphs(cur, ds); + } else { + bool gotsel = false; + if (cur.selection()) { + lyx::dispatch(FuncRequest(LFUN_CUT)); + gotsel = true; + } + text->insertInset(cur, inset); + + if (edit) + inset->edit(cur, true); + + if (gotsel && pastesel) { + lyx::dispatch(FuncRequest(LFUN_PASTE, "0")); + InsetText * insetText = dynamic_cast(inset); + if (insetText && !insetText->allowMultiPar() + || cur.lastpit() == 0) { + // reset first par to default + LayoutPtr const layout = + cur.buffer().params().getTextClass().defaultLayout(); + cur.text()->paragraphs().begin()->layout(layout); + cur.pos() = 0; + cur.pit() = 0; + // Merge multiple paragraphs -- hack + while (cur.lastpit() > 0) { + mergeParagraph(cur.buffer().params(), + cur.text()->paragraphs(), 0); + } + } else { + // reset surrounding par to default + docstring const layoutname = + cur.buffer().params().getTextClass().defaultLayoutName(); + cur.leaveInset(*inset); + text->setLayout(cur, layoutname); + } } } return true; } -} // anon namespace +string const freefont2string() +{ + return freefont.toString(toggleall); +} + + +/// the type of outline operation +enum OutlineOp { + OutlineUp, // Move this header with text down + OutlineDown, // Move this header with text up + OutlineIn, // Make this header deeper + OutlineOut // Make this header shallower +}; + + +static void outline(OutlineOp mode, Cursor & cur) +{ + Buffer & buf = cur.buffer(); + pit_type & pit = cur.pit(); + ParagraphList & pars = buf.text().paragraphs(); + ParagraphList::iterator bgn = pars.begin(); + // The first paragraph of the area to be copied: + ParagraphList::iterator start = boost::next(bgn, pit); + // The final paragraph of area to be copied: + ParagraphList::iterator finish = start; + ParagraphList::iterator end = pars.end(); + + TextClass::const_iterator lit = + buf.params().getTextClass().begin(); + TextClass::const_iterator const lend = + buf.params().getTextClass().end(); + + int const thistoclevel = start->layout()->toclevel; + int toclevel; + switch (mode) { + case OutlineUp: { + // Move out (down) from this section header + if (finish != end) + ++finish; + // Seek the one (on same level) below + for (; finish != end; ++finish) { + toclevel = finish->layout()->toclevel; + if (toclevel != Layout::NOT_IN_TOC + && toclevel <= thistoclevel) { + break; + } + } + ParagraphList::iterator dest = start; + // Move out (up) from this header + if (dest == bgn) + break; + // Search previous same-level header above + do { + --dest; + toclevel = dest->layout()->toclevel; + } while(dest != bgn + && (toclevel == Layout::NOT_IN_TOC + || toclevel > thistoclevel)); + // Not found; do nothing + if (toclevel == Layout::NOT_IN_TOC || toclevel > thistoclevel) + break; + pit_type const newpit = std::distance(bgn, dest); + pit_type const len = std::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); + break; + } + case OutlineDown: { + // Go down out of current header: + if (finish != end) + ++finish; + // Find next same-level header: + for (; finish != end; ++finish) { + toclevel = finish->layout()->toclevel; + if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel) + break; + } + ParagraphList::iterator dest = finish; + // Go one down from *this* header: + if (dest != end) + ++dest; + else + break; + // Go further down to find header to insert in front of: + for (; dest != end; ++dest) { + toclevel = dest->layout()->toclevel; + if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel) + break; + } + // One such was found: + pit_type newpit = std::distance(bgn, dest); + pit_type const len = std::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); + break; + } + case OutlineIn: + buf.undo().recordUndo(cur); + for (; lit != lend; ++lit) { + if ((*lit)->toclevel == thistoclevel + 1 && + start->layout()->labeltype == (*lit)->labeltype) { + start->layout((*lit)); + break; + } + } + break; + case OutlineOut: + buf.undo().recordUndo(cur); + for (; lit != lend; ++lit) { + if ((*lit)->toclevel == thistoclevel - 1 && + start->layout()->labeltype == (*lit)->labeltype) { + start->layout((*lit)); + break; + } + } + break; + default: + break; + } +} void Text::number(Cursor & cur) { - Font font(Font::ALL_IGNORE); - font.setNumber(Font::TOGGLE); - toggleAndShow(cur, this, font); + FontInfo font = ignore_font; + font.setNumber(FONT_TOGGLE); + toggleAndShow(cur, this, Font(font)); } bool Text::isRTL(Buffer const & buffer, Paragraph const & par) const { - return par.isRightToLeftPar(buffer.params()); + return par.isRTL(buffer.params()); } void Text::dispatch(Cursor & cur, FuncRequest & cmd) { - LYXERR(Debug::ACTION) << "Text::dispatch: cmd: " << cmd << endl; + LYXERR(Debug::ACTION, "Text::dispatch: cmd: " << 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 @@ -284,7 +417,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_PARAGRAPH_MOVE_DOWN: { pit_type const pit = cur.pit(); recUndo(cur, pit, pit + 1); - finishUndo(); + cur.finishUndo(); std::swap(pars_[pit], pars_[pit + 1]); updateLabels(cur.buffer()); needsUpdate = true; @@ -295,7 +428,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_PARAGRAPH_MOVE_UP: { pit_type const pit = cur.pit(); recUndo(cur, pit - 1, pit); - finishUndo(); + cur.finishUndo(); std::swap(pars_[pit], pars_[pit - 1]); updateLabels(cur.buffer()); --cur.pit(); @@ -319,7 +452,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } - recordUndo(cur); + cur.recordUndo(); par.params().startOfAppendix(start); // we can set the refreshing parameters now @@ -373,18 +506,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CHAR_FORWARD: case LFUN_CHAR_FORWARD_SELECT: - //lyxerr << BOOST_CURRENT_FUNCTION - // << " LFUN_CHAR_FORWARD[SEL]:\n" << cur << endl; + //LYXERR0(" LFUN_CHAR_FORWARD[SEL]:\n" << cur); needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT); - if (reverseDirectionNeeded(cur)) - needsUpdate |= cursorLeft(cur); - else - needsUpdate |= cursorRight(cur); + needsUpdate |= cursorForward(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); - cmd = FuncRequest(LFUN_FINISHED_RIGHT); + cmd = FuncRequest(LFUN_FINISHED_FORWARD); } break; @@ -392,18 +521,41 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CHAR_BACKWARD_SELECT: //lyxerr << "handle LFUN_CHAR_BACKWARD[_SELECT]:\n" << cur << endl; needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT); - if (reverseDirectionNeeded(cur)) - needsUpdate |= cursorRight(cur); - else - needsUpdate |= cursorLeft(cur); + needsUpdate |= cursorBackward(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); - cmd = FuncRequest(LFUN_FINISHED_LEFT); + cmd = FuncRequest(LFUN_FINISHED_BACKWARD); } break; + case LFUN_CHAR_LEFT: + case LFUN_CHAR_LEFT_SELECT: + //FIXME: for visual cursor, really move left + if (reverseDirectionNeeded(cur)) { + cmd.action = 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; + } + dispatch(cur, cmd); + return; + + case LFUN_CHAR_RIGHT: + case LFUN_CHAR_RIGHT_SELECT: + //FIXME: for visual cursor, really move right + if (reverseDirectionNeeded(cur)) { + cmd.action = 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; + } + dispatch(cur, cmd); + return; + case LFUN_UP_SELECT: case LFUN_DOWN_SELECT: case LFUN_UP: @@ -441,9 +593,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= cursorDownParagraph(cur); break; - case LFUN_SCREEN_UP: case LFUN_SCREEN_UP_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_UP_SELECT); + needsUpdate |= cur.selHandle(true); if (cur.pit() == 0 && cur.textRow().pos() == 0) cur.undispatched(); else { @@ -451,9 +602,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } break; - case LFUN_SCREEN_DOWN: case LFUN_SCREEN_DOWN_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_DOWN_SELECT); + needsUpdate |= cur.selHandle(true); if (cur.pit() == cur.lastpit() && cur.textRow().endpos() == cur.lastpos()) cur.undispatched(); @@ -474,22 +624,42 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= tm.cursorEnd(cur); break; + case LFUN_WORD_RIGHT: + case LFUN_WORD_RIGHT_SELECT: + //FIXME: for visual cursor mode, really move right + if (reverseDirectionNeeded(cur)) { + cmd.action = 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; + } + dispatch(cur, cmd); + return; + case LFUN_WORD_FORWARD: case LFUN_WORD_FORWARD_SELECT: needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT); - if (reverseDirectionNeeded(cur)) - needsUpdate |= cursorLeftOneWord(cur); - else - needsUpdate |= cursorRightOneWord(cur); + needsUpdate |= cursorForwardOneWord(cur); break; + case LFUN_WORD_LEFT: + case LFUN_WORD_LEFT_SELECT: + //FIXME: for visual cursor mode, really move left + if (reverseDirectionNeeded(cur)) { + cmd.action = 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; + } + dispatch(cur, cmd); + return; + case LFUN_WORD_BACKWARD: case LFUN_WORD_BACKWARD_SELECT: needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT); - if (reverseDirectionNeeded(cur)) - needsUpdate |= cursorRightOneWord(cur); - else - needsUpdate |= cursorLeftOneWord(cur); + needsUpdate |= cursorBackwardOneWord(cur); break; case LFUN_WORD_SELECT: { @@ -498,16 +668,31 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } - case LFUN_BREAK_LINE: { + case LFUN_NEW_LINE: { // Not allowed by LaTeX (labels or empty par) if (cur.pos() > cur.paragraph().beginOfBody()) { // this avoids a double undo // FIXME: should not be needed, ideally if (!cur.selection()) - recordUndo(cur); + cur.recordUndo(); cap::replaceSelection(cur); cur.insert(new InsetNewline); - cur.posRight(); + cur.posForward(); + moveCursor(cur, false); + } + break; + } + + case LFUN_LINE_BREAK: { + // Not allowed by LaTeX (labels or empty par) + if (cur.pos() > cur.paragraph().beginOfBody()) { + // this avoids a double undo + // FIXME: should not be needed, ideally + if (!cur.selection()) + cur.recordUndo(); + cap::replaceSelection(cur); + cur.insert(new InsetLinebreak); + cur.posForward(); moveCursor(cur, false); } break; @@ -533,8 +718,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP. if (!cur.selection()) { if (cur.pos() == cur.lastpos()) { - cursorRight(cur); - cursorLeft(cur); + cursorForward(cur); + cursorBackward(cur); } erase(cur); cur.resetAnchor(); @@ -575,13 +760,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_BREAK_PARAGRAPH: cap::replaceSelection(cur); - breakParagraph(cur, 0); - cur.resetAnchor(); - break; - - case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT: - cap::replaceSelection(cur); - breakParagraph(cur, 1); + breakParagraph(cur, cmd.argument() == "inverse"); cur.resetAnchor(); break; @@ -592,7 +771,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (cur.pos() == 0) cur.paragraph().params().labelWidthString(docstring()); else - breakParagraph(cur, 0); + breakParagraph(cur, false); cur.resetAnchor(); break; } @@ -641,8 +820,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_INSET_INSERT: { - recordUndo(cur); - Inset * inset = createInset(bv, cmd); + cur.recordUndo(); + Inset * inset = createInset(bv->buffer(), cmd); if (inset) { // FIXME (Abdel 01/02/2006): // What follows would be a partial fix for bug 2154: @@ -655,7 +834,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // other feature like "automatic labelling". /* Paragraph & par = pars_[cur.pit()]; - if (inset->lyxCode() == Inset::LABEL_CODE + if (inset->lyxCode() == LABEL_CODE && par.layout()->labeltype == LABEL_COUNTER) { // Go to the end of the paragraph // Warning: Because of Change-Tracking, the last @@ -669,7 +848,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (cur.selection()) cutSelection(cur, true, false); insertInset(cur, inset); - cur.posRight(); + cur.posForward(); } break; } @@ -687,41 +866,44 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) insertChar(cur, ' '); else { doInsertInset(cur, this, cmd, false, false); - cur.posRight(); + cur.posForward(); } moveCursor(cur, false); break; - case LFUN_HYPHENATION_POINT_INSERT: - specialChar(cur, InsetSpecialChar::HYPHENATION); - break; - - case LFUN_LIGATURE_BREAK_INSERT: - specialChar(cur, InsetSpecialChar::LIGATURE_BREAK); - break; - - case LFUN_DOTS_INSERT: - specialChar(cur, InsetSpecialChar::LDOTS); - break; - - case LFUN_END_OF_SENTENCE_PERIOD_INSERT: - specialChar(cur, InsetSpecialChar::END_OF_SENTENCE); - break; - - case LFUN_MENU_SEPARATOR_INSERT: - specialChar(cur, InsetSpecialChar::MENU_SEPARATOR); + case LFUN_SPECIALCHAR_INSERT: { + string const name = to_utf8(cmd.argument()); + if (name == "hyphenation") + specialChar(cur, InsetSpecialChar::HYPHENATION); + else if (name == "ligature-break") + specialChar(cur, InsetSpecialChar::LIGATURE_BREAK); + else if (name == "slash") + specialChar(cur, InsetSpecialChar::SLASH); + else if (name == "nobreakdash") + specialChar(cur, InsetSpecialChar::NOBREAKDASH); + else if (name == "dots") + specialChar(cur, InsetSpecialChar::LDOTS); + else if (name == "end-of-sentence") + specialChar(cur, InsetSpecialChar::END_OF_SENTENCE); + else if (name == "menu-separator") + specialChar(cur, InsetSpecialChar::MENU_SEPARATOR); + else if (name.empty()) + lyxerr << "LyX function 'specialchar-insert' needs an argument." << endl; + else + lyxerr << "Wrong argument for LyX function 'specialchar-insert'." << endl; break; + } case LFUN_WORD_UPCASE: - changeCase(cur, Text::text_uppercase); + changeCase(cur, text_uppercase); break; case LFUN_WORD_LOWCASE: - changeCase(cur, Text::text_lowercase); + changeCase(cur, text_lowercase); break; case LFUN_WORD_CAPITALIZE: - changeCase(cur, Text::text_capitalization); + changeCase(cur, text_capitalization); break; case LFUN_CHARS_TRANSPOSE: @@ -742,7 +924,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } bv->buffer().errors("Paste"); cur.clearSelection(); // bug 393 - finishUndo(); + cur.finishUndo(); break; case LFUN_CUT: @@ -775,9 +957,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_SERVER_GET_FONT: - if (cur.current_font.shape() == Font::ITALIC_SHAPE) + if (cur.current_font.fontInfo().shape() == ITALIC_SHAPE) cur.message(from_ascii("E")); - else if (cur.current_font.shape() == Font::SMALLCAPS_SHAPE) + else if (cur.current_font.fontInfo().shape() == SMALLCAPS_SHAPE) cur.message(from_ascii("N")); else cur.message(from_ascii("0")); @@ -789,7 +971,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_LAYOUT: { docstring layout = cmd.argument(); - LYXERR(Debug::INFO) << "LFUN_LAYOUT: (arg) " << to_utf8(layout) << endl; + LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(layout)); + + docstring const old_layout = cur.paragraph().layout()->name(); // Derive layout number from given argument (string) // and current buffer's textclass (number) @@ -811,7 +995,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } - bool change_layout = (frontend::current_layout != layout); + bool change_layout = (old_layout != layout); if (!change_layout && cur.selection() && cur.selBegin().pit() != cur.selEnd().pit()) @@ -819,7 +1003,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) pit_type spit = cur.selBegin().pit(); pit_type epit = cur.selEnd().pit() + 1; while (spit != epit) { - if (pars_[spit].layout()->name() != frontend::current_layout) { + if (pars_[spit].layout()->name() != old_layout) { change_layout = true; break; } @@ -827,11 +1011,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } - if (change_layout) { + if (change_layout) setLayout(cur, layout); - // inform the GUI that the layout has changed. - bv->layoutChanged(layout); - } + break; } @@ -872,7 +1054,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // this avoids a double undo // FIXME: should not be needed, ideally if (!cur.selection()) - recordUndo(cur); + cur.recordUndo(); cap::replaceSelection(cur); pos = cur.pos(); char_type c; @@ -891,7 +1073,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.insert(new InsetQuotes(c, bufparams.quotes_language, InsetQuotes::DoubleQ)); - cur.posRight(); + cur.posForward(); } else lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, "\"")); @@ -926,11 +1108,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Single-click on work area case LFUN_MOUSE_PRESS: { // Right click on a footnote flag opens float menu + // FIXME: Why should we clear the selection in this case? if (cmd.button() == mouse_button::button3) cur.clearSelection(); + bool do_selection = cmd.button() == mouse_button::button1 + && cmd.argument() == "region-select"; // Set the cursor - bool update = bv->mouseSetCursor(cur); + bool update = bv->mouseSetCursor(cur, do_selection); // Insert primary selection with middle mouse // if there is a local selection in the current buffer, @@ -946,7 +1131,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bv->buffer().errorList("Paste")); bv->buffer().errors("Paste"); bv->buffer().markDirty(); - finishUndo(); + bv->cursor().finishUndo(); } else { lyx::dispatch(FuncRequest(LFUN_PRIMARY_SELECTION_PASTE, "paragraph")); } @@ -968,37 +1153,40 @@ 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)) { - CursorSlice old = bvcur.top(); - - int const wh = bv->workHeight(); - int const y = std::max(0, std::min(wh - 1, cmd.y)); - - tm.setCursorFromCoordinates(cur, cmd.x, y); - cur.setTargetX(cmd.x); + if (!bvcur.anchor_.hasPart(cur)) { + cur.undispatched(); + break; + } + CursorSlice old = bvcur.top(); + + int const wh = bv->workHeight(); + int const y = std::max(0, std::min(wh - 1, cmd.y)); + + 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) + lyx::dispatch(FuncRequest(LFUN_UP_SELECT)); + // This is to allow jumping over large insets + if (cur.top() == old) { if (cmd.y >= wh) lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT)); 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) - lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT)); - else if (cmd.y < 0) - lyx::dispatch(FuncRequest(LFUN_UP_SELECT)); - } - - 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(); + if (cur.top() == old) + cur.noUpdate(); + else { + // FIXME: This is brute force! But without it the selected + // area is not corrected updated while moving the mouse. + cur.updateFlags(Update::Force | Update::FitCursor); + // don't set anchor_ + bvcur.setCursor(cur); + bvcur.selection() = true; + //lyxerr << "MOTION: " << bv->cursor() << endl; + } break; } @@ -1034,17 +1222,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // "auto_region_delete", which defaults to // true (on). - if (lyxrc.auto_region_delete && cur.selection()) { + if (lyxrc.auto_region_delete && cur.selection()) cutSelection(cur, false, false); - // When change tracking is set to off, the metrics update - // mechanism correctly detects if a full update is needed or not. - // This detection fails when a selection spans multiple rows and - // change tracking is enabled because the paragraph metrics stays - // the same. In this case, we force the full update: - // (see http://bugzilla.lyx.org/show_bug.cgi?id=3992) - if (cur.buffer().params().trackChanges) - cur.updateFlags(Update::Force); - } cur.clearSelection(); Font const old_font = cur.real_current_font; @@ -1059,27 +1238,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } - case LFUN_URL_INSERT: { - InsetCommandParams p("url"); - docstring content; - if (cur.selection()) { - content = cur.selectionAsString(false); - cutSelection(cur, true, false); - } - p["target"] = (cmd.argument().empty()) ? - content : cmd.argument(); - string const data = InsetCommandMailer::params2string("url", p); - if (p["target"].empty()) { - bv->showInsetDialog("url", data, 0); - } else { - FuncRequest fr(LFUN_INSET_INSERT, data); - dispatch(cur, fr); - } - break; - } - - case LFUN_HTML_INSERT: { - InsetCommandParams p("htmlurl"); + case LFUN_HYPERLINK_INSERT: { + InsetCommandParams p(HYPERLINK_CODE); docstring content; if (cur.selection()) { content = cur.selectionAsString(false); @@ -1087,9 +1247,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } p["target"] = (cmd.argument().empty()) ? content : cmd.argument(); - string const data = InsetCommandMailer::params2string("url", p); + string const data = InsetCommandMailer::params2string("href", p); if (p["target"].empty()) { - bv->showInsetDialog("url", data, 0); + bv->showDialog("href", data); } else { FuncRequest fr(LFUN_INSET_INSERT, data); dispatch(cur, fr); @@ -1098,7 +1258,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_LABEL_INSERT: { - InsetCommandParams p("label"); + InsetCommandParams p(LABEL_CODE); // Try to generate a valid label p["name"] = (cmd.argument().empty()) ? cur.getPossibleLabel() : @@ -1106,7 +1266,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) string const data = InsetCommandMailer::params2string("label", p); if (cmd.argument().empty()) { - bv->showInsetDialog("label", data, 0); + bv->showDialog("label", data); } else { FuncRequest fr(LFUN_INSET_INSERT, data); dispatch(cur, fr); @@ -1114,39 +1274,55 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } - + case LFUN_INFO_INSERT: { + Inset * inset = createInset(cur.bv().buffer(), cmd); + if (!inset) + break; + // if an empty inset is created (cmd.argument() is empty) + // use current selection as parameter. + if (cmd.argument().empty() && cur.selection()) { + // use selected text as info to avoid a separate UI + docstring ds = cur.selectionAsString(false); + cutSelection(cur, true, false); + static_cast(inset)->setInfo(to_utf8(ds)); + } + insertInset(cur, inset); + cur.posForward(); + break; + } #if 0 case LFUN_LIST_INSERT: case LFUN_THEOREM_INSERT: #endif case LFUN_CAPTION_INSERT: + case LFUN_FOOTNOTE_INSERT: // Open the inset, and move the current selection // inside it. doInsertInset(cur, this, cmd, true, true); - cur.posRight(); + cur.posForward(); + // These insets are numbered. updateLabels(bv->buffer()); break; case LFUN_NOTE_INSERT: - case LFUN_CHARSTYLE_INSERT: + case LFUN_FLEX_INSERT: case LFUN_BOX_INSERT: case LFUN_BRANCH_INSERT: case LFUN_BIBITEM_INSERT: case LFUN_ERT_INSERT: case LFUN_LISTING_INSERT: - case LFUN_FOOTNOTE_INSERT: case LFUN_MARGINALNOTE_INSERT: case LFUN_OPTIONAL_INSERT: case LFUN_ENVIRONMENT_INSERT: // Open the inset, and move the current selection // inside it. doInsertInset(cur, this, cmd, true, true); - cur.posRight(); + cur.posForward(); break; case LFUN_TABULAR_INSERT: // if there were no arguments, just open the dialog if (doInsertInset(cur, this, cmd, false, true)) - cur.posRight(); + cur.posForward(); else bv->showDialog("tabularcreate"); @@ -1158,7 +1334,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bool content = cur.selection(); // will some text be moved into the inset? doInsertInset(cur, this, cmd, true, true); - cur.posRight(); + cur.posForward(); ParagraphList & pars = cur.text()->paragraphs(); TextClass const & tclass = bv->buffer().params().getTextClass(); @@ -1196,20 +1372,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_INDEX_INSERT: + doInsertInset(cur, this, cmd, true, true); + cur.posForward(); + break; + case LFUN_NOMENCL_INSERT: { - Inset * inset = createInset(&cur.bv(), cmd); + FuncRequest cmd1 = cmd; + if (cmd.argument().empty()) + cmd1 = FuncRequest(cmd, + bv->cursor().innerText()->getStringToIndex(bv->cursor())); + Inset * inset = createInset(cur.bv().buffer(), cmd1); if (!inset) break; - recordUndo(cur); + cur.recordUndo(); cur.clearSelection(); insertInset(cur, inset); - inset->edit(cur, true); // Show the dialog for the nomenclature entry, since the // description entry still needs to be filled in. if (cmd.action == LFUN_NOMENCL_INSERT) - InsetCommandMailer("nomenclature", - *reinterpret_cast(inset)).showDialog(&cur.bv()); - cur.posRight(); + inset->edit(cur, true); + cur.posForward(); break; } @@ -1218,12 +1400,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_TOC_INSERT: case LFUN_HFILL_INSERT: case LFUN_LINE_INSERT: + case LFUN_NEWPAGE_INSERT: case LFUN_PAGEBREAK_INSERT: case LFUN_CLEARPAGE_INSERT: case LFUN_CLEARDOUBLEPAGE_INSERT: // do nothing fancy doInsertInset(cur, this, cmd, false, false); - cur.posRight(); + cur.posForward(); break; case LFUN_DEPTH_DECREMENT: @@ -1256,7 +1439,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) int const nargs = s1.empty() ? 0 : convert(s1); string const s2 = token(s, ' ', 2); string const type = s2.empty() ? "newcommand" : s2; - cur.insert(new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, from_utf8(type))); + cur.insert(new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, false, from_utf8(type))); //cur.nextInset()->edit(cur, true); } break; @@ -1287,63 +1470,63 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_FONT_EMPH: { - Font font(Font::ALL_IGNORE); - font.setEmph(Font::TOGGLE); + Font font(ignore_font, ignore_language); + font.fontInfo().setEmph(FONT_TOGGLE); toggleAndShow(cur, this, font); break; } case LFUN_FONT_BOLD: { - Font font(Font::ALL_IGNORE); - font.setSeries(Font::BOLD_SERIES); + Font font(ignore_font, ignore_language); + font.fontInfo().setSeries(BOLD_SERIES); toggleAndShow(cur, this, font); break; } case LFUN_FONT_NOUN: { - Font font(Font::ALL_IGNORE); - font.setNoun(Font::TOGGLE); + Font font(ignore_font, ignore_language); + font.fontInfo().setNoun(FONT_TOGGLE); toggleAndShow(cur, this, font); break; } - case LFUN_FONT_CODE: { - Font font(Font::ALL_IGNORE); - font.setFamily(Font::TYPEWRITER_FAMILY); // no good + case LFUN_FONT_TYPEWRITER: { + Font font(ignore_font, ignore_language); + font.fontInfo().setFamily(TYPEWRITER_FAMILY); // no good toggleAndShow(cur, this, font); break; } case LFUN_FONT_SANS: { - Font font(Font::ALL_IGNORE); - font.setFamily(Font::SANS_FAMILY); + Font font(ignore_font, ignore_language); + font.fontInfo().setFamily(SANS_FAMILY); toggleAndShow(cur, this, font); break; } case LFUN_FONT_ROMAN: { - Font font(Font::ALL_IGNORE); - font.setFamily(Font::ROMAN_FAMILY); + Font font(ignore_font, ignore_language); + font.fontInfo().setFamily(ROMAN_FAMILY); toggleAndShow(cur, this, font); break; } case LFUN_FONT_DEFAULT: { - Font font(Font::ALL_INHERIT, ignore_language); + Font font(inherit_font, ignore_language); toggleAndShow(cur, this, font); break; } case LFUN_FONT_UNDERLINE: { - Font font(Font::ALL_IGNORE); - font.setUnderbar(Font::TOGGLE); + Font font(ignore_font, ignore_language); + font.fontInfo().setUnderbar(FONT_TOGGLE); toggleAndShow(cur, this, font); break; } case LFUN_FONT_SIZE: { - Font font(Font::ALL_IGNORE); - font.setLyXSize(to_utf8(cmd.argument())); + Font font(ignore_font, ignore_language); + setLyXSize(to_utf8(cmd.argument()), font.fontInfo()); toggleAndShow(cur, this, font); break; } @@ -1352,8 +1535,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) Language const * lang = languages.getLanguage(to_utf8(cmd.argument())); if (!lang) break; - Font font(Font::ALL_IGNORE); - font.setLanguage(lang); + Font font(ignore_font, lang); toggleAndShow(cur, this, font); break; } @@ -1368,32 +1550,48 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_FONT_FREE_UPDATE: { Font font; bool toggle; - if (bv_funcs::string2font(to_utf8(cmd.argument()), font, toggle)) { + if (font.fromString(to_utf8(cmd.argument()), toggle)) { freefont = font; toggleall = toggle; toggleAndShow(cur, this, freefont, toggleall); cur.message(_("Character set")); + } else { + lyxerr << "Argument not ok"; } break; } case LFUN_FINISHED_LEFT: - LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_LEFT:\n" << cur << endl; - if (reverseDirectionNeeded(cur)) + LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_LEFT:\n" << cur); + if (reverseDirectionNeeded(cur)) { ++cur.pos(); + cur.setCurrentFont(); + } break; case LFUN_FINISHED_RIGHT: - LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_RIGHT:\n" << cur << endl; - if (!reverseDirectionNeeded(cur)) + LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_RIGHT:\n" << cur); + if (!reverseDirectionNeeded(cur)) { ++cur.pos(); + cur.setCurrentFont(); + } + break; + + case LFUN_FINISHED_BACKWARD: + LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_BACKWARD:\n" << cur); + break; + + case LFUN_FINISHED_FORWARD: + LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_FORWARD:\n" << cur); + ++cur.pos(); + cur.setCurrentFont(); break; case LFUN_LAYOUT_PARAGRAPH: { string data; params2string(cur.paragraph(), data); data = "show\n" + data; - bv->showDialogWithData("paragraph", data); + bv->showDialog("paragraph", data); break; } @@ -1435,13 +1633,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_FLOAT_LIST: { TextClass const & tclass = bv->buffer().params().getTextClass(); if (tclass.floats().typeExist(to_utf8(cmd.argument()))) { - recordUndo(cur); + cur.recordUndo(); if (cur.selection()) cutSelection(cur, true, false); breakParagraph(cur); if (cur.lastpos() != 0) { - cursorLeft(cur); + cursorBackward(cur); breakParagraph(cur); } @@ -1449,7 +1647,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) ParagraphParameters p; setParagraphs(cur, p); insertInset(cur, new InsetFloatList(to_utf8(cmd.argument()))); - cur.posRight(); + cur.posForward(); } else { lyxerr << "Non-existent float type: " << to_utf8(cmd.argument()) << endl; @@ -1478,7 +1676,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) arg = cur.selectionAsString(false); } } - bv->showDialogWithData("thesaurus", to_utf8(arg)); + bv->showDialog("thesaurus", to_utf8(arg)); break; } @@ -1509,15 +1707,40 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.selection() = false; } else { cur.undispatched(); - cmd = FuncRequest(LFUN_FINISHED_RIGHT); + // This used to be LFUN_FINISHED_RIGHT, I think FORWARD is more + // correct, but I'm not 100% sure -- dov, 071019 + cmd = FuncRequest(LFUN_FINISHED_FORWARD); } break; + case LFUN_OUTLINE_UP: + outline(OutlineUp, cur); + setCursor(cur, cur.pit(), 0); + updateLabels(cur.buffer()); + needsUpdate = true; + break; + + case LFUN_OUTLINE_DOWN: + outline(OutlineDown, cur); + setCursor(cur, cur.pit(), 0); + updateLabels(cur.buffer()); + needsUpdate = true; + break; + + case LFUN_OUTLINE_IN: + outline(OutlineIn, cur); + updateLabels(cur.buffer()); + needsUpdate = true; + break; + + case LFUN_OUTLINE_OUT: + outline(OutlineOut, cur); + updateLabels(cur.buffer()); + needsUpdate = true; + break; + default: - LYXERR(Debug::ACTION) - << BOOST_CURRENT_FUNCTION - << ": Command " << cmd - << " not DISPATCHED by Text" << endl; + LYXERR(Debug::ACTION, "Command " << cmd << " not DISPATCHED by Text"); cur.undispatched(); break; } @@ -1540,15 +1763,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Inserting characters does not change par height ParagraphMetrics const & pms = cur.bv().parMetrics(cur.bottom().text(), cur.bottom().pit()); - if (pms.dim().height() - == olddim.height()) { + if (pms.dim().height() == olddim.height()) { // if so, update _only_ this paragraph cur.updateFlags(Update::SinglePar | - Update::FitCursor | - Update::MultiParSel); + Update::FitCursor); return; - } else - needsUpdate = true; + } + needsUpdate = true; } if (!needsUpdate @@ -1577,8 +1798,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, BOOST_ASSERT(cur.text() == this); Font const & font = cur.real_current_font; + FontInfo const & fontinfo = font.fontInfo(); bool enable = true; - Inset::Code code = Inset::NO_CODE; + InsetCode code = NO_CODE; switch (cmd.action) { @@ -1601,145 +1823,149 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_DIALOG_SHOW_NEW_INSET: if (cmd.argument() == "bibitem") - code = Inset::BIBITEM_CODE; + code = BIBITEM_CODE; else if (cmd.argument() == "bibtex") - code = Inset::BIBTEX_CODE; + code = BIBTEX_CODE; else if (cmd.argument() == "box") - code = Inset::BOX_CODE; + code = BOX_CODE; else if (cmd.argument() == "branch") - code = Inset::BRANCH_CODE; + code = BRANCH_CODE; else if (cmd.argument() == "citation") - code = Inset::CITE_CODE; + code = CITE_CODE; else if (cmd.argument() == "ert") - code = Inset::ERT_CODE; + code = ERT_CODE; else if (cmd.argument() == "external") - code = Inset::EXTERNAL_CODE; + code = EXTERNAL_CODE; else if (cmd.argument() == "float") - code = Inset::FLOAT_CODE; + code = FLOAT_CODE; else if (cmd.argument() == "graphics") - code = Inset::GRAPHICS_CODE; + code = GRAPHICS_CODE; + else if (cmd.argument() == "href") + code = HYPERLINK_CODE; else if (cmd.argument() == "include") - code = Inset::INCLUDE_CODE; + code = INCLUDE_CODE; else if (cmd.argument() == "index") - code = Inset::INDEX_CODE; + code = INDEX_CODE; else if (cmd.argument() == "nomenclature") - code = Inset::NOMENCL_CODE; + code = NOMENCL_CODE; else if (cmd.argument() == "label") - code = Inset::LABEL_CODE; + code = LABEL_CODE; else if (cmd.argument() == "note") - code = Inset::NOTE_CODE; + code = NOTE_CODE; else if (cmd.argument() == "ref") - code = Inset::REF_CODE; + code = REF_CODE; else if (cmd.argument() == "toc") - code = Inset::TOC_CODE; - else if (cmd.argument() == "url") - code = Inset::URL_CODE; + code = TOC_CODE; else if (cmd.argument() == "vspace") - code = Inset::VSPACE_CODE; + code = VSPACE_CODE; else if (cmd.argument() == "wrap") - code = Inset::WRAP_CODE; + code = WRAP_CODE; else if (cmd.argument() == "listings") - code = Inset::LISTINGS_CODE; + code = LISTINGS_CODE; break; case LFUN_ERT_INSERT: - code = Inset::ERT_CODE; + code = ERT_CODE; break; case LFUN_LISTING_INSERT: - code = Inset::LISTINGS_CODE; + code = LISTINGS_CODE; break; case LFUN_FOOTNOTE_INSERT: - code = Inset::FOOT_CODE; + code = FOOT_CODE; break; case LFUN_TABULAR_INSERT: - code = Inset::TABULAR_CODE; + code = TABULAR_CODE; break; case LFUN_MARGINALNOTE_INSERT: - code = Inset::MARGIN_CODE; + code = MARGIN_CODE; break; case LFUN_FLOAT_INSERT: case LFUN_FLOAT_WIDE_INSERT: - code = Inset::FLOAT_CODE; + code = FLOAT_CODE; break; case LFUN_WRAP_INSERT: - code = Inset::WRAP_CODE; + code = WRAP_CODE; break; case LFUN_FLOAT_LIST: - code = Inset::FLOAT_LIST_CODE; + code = FLOAT_LIST_CODE; break; #if 0 case LFUN_LIST_INSERT: - code = Inset::LIST_CODE; + code = LIST_CODE; break; case LFUN_THEOREM_INSERT: - code = Inset::THEOREM_CODE; + code = THEOREM_CODE; break; #endif case LFUN_CAPTION_INSERT: - code = Inset::CAPTION_CODE; + code = CAPTION_CODE; break; case LFUN_NOTE_INSERT: - code = Inset::NOTE_CODE; - break; - case LFUN_CHARSTYLE_INSERT: - code = Inset::CHARSTYLE_CODE; - if (cur.buffer().params().getTextClass().insetlayouts().empty()) + code = NOTE_CODE; + break; + case LFUN_FLEX_INSERT: { + code = FLEX_CODE; + string s = cmd.getArg(0); + InsetLayout il = cur.buffer().params().getTextClass().insetlayout(from_utf8(s)); + if (il.lyxtype != "charstyle" && + il.lyxtype != "custom" && + il.lyxtype != "element" && + il.lyxtype != "standard") enable = false; break; + } case LFUN_BOX_INSERT: - code = Inset::BOX_CODE; + code = BOX_CODE; break; case LFUN_BRANCH_INSERT: - code = Inset::BRANCH_CODE; - if (cur.buffer().getMasterBuffer()->params().branchlist().empty()) + code = BRANCH_CODE; + if (cur.buffer().masterBuffer()->params().branchlist().empty()) enable = false; break; case LFUN_LABEL_INSERT: - code = Inset::LABEL_CODE; + code = LABEL_CODE; + break; + case LFUN_INFO_INSERT: + code = INFO_CODE; break; case LFUN_OPTIONAL_INSERT: - code = Inset::OPTARG_CODE; - enable = numberOfOptArgs(cur.paragraph()) + code = OPTARG_CODE; + enable = cur.paragraph().insetList().count(OPTARG_CODE) < cur.paragraph().layout()->optionalargs; break; case LFUN_ENVIRONMENT_INSERT: - code = Inset::BOX_CODE; + code = BOX_CODE; break; case LFUN_INDEX_INSERT: - code = Inset::INDEX_CODE; + code = INDEX_CODE; break; case LFUN_INDEX_PRINT: - code = Inset::INDEX_PRINT_CODE; + code = INDEX_PRINT_CODE; break; case LFUN_NOMENCL_INSERT: - code = Inset::NOMENCL_CODE; + code = NOMENCL_CODE; break; case LFUN_NOMENCL_PRINT: - code = Inset::NOMENCL_PRINT_CODE; + code = NOMENCL_PRINT_CODE; break; case LFUN_TOC_INSERT: - code = Inset::TOC_CODE; + code = TOC_CODE; break; - case LFUN_HTML_INSERT: - case LFUN_URL_INSERT: - code = Inset::URL_CODE; + case LFUN_HYPERLINK_INSERT: + code = HYPERLINK_CODE; break; case LFUN_QUOTE_INSERT: // always allow this, since we will inset a raw quote // if an inset is not allowed. break; - case LFUN_HYPHENATION_POINT_INSERT: - case LFUN_LIGATURE_BREAK_INSERT: case LFUN_HFILL_INSERT: - case LFUN_MENU_SEPARATOR_INSERT: - case LFUN_DOTS_INSERT: - case LFUN_END_OF_SENTENCE_PERIOD_INSERT: - code = Inset::SPECIALCHAR_CODE; + case LFUN_SPECIALCHAR_INSERT: + code = SPECIALCHAR_CODE; break; case LFUN_SPACE_INSERT: // slight hack: we know this is allowed in math mode if (cur.inTexted()) - code = Inset::SPACE_CODE; + code = SPACE_CODE; break; case LFUN_INSET_MODIFY: @@ -1751,27 +1977,27 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; case LFUN_FONT_EMPH: - flag.setOnOff(font.emph() == Font::ON); + flag.setOnOff(fontinfo.emph() == FONT_ON); return true; case LFUN_FONT_NOUN: - flag.setOnOff(font.noun() == Font::ON); + flag.setOnOff(fontinfo.noun() == FONT_ON); return true; case LFUN_FONT_BOLD: - flag.setOnOff(font.series() == Font::BOLD_SERIES); + flag.setOnOff(fontinfo.series() == BOLD_SERIES); return true; case LFUN_FONT_SANS: - flag.setOnOff(font.family() == Font::SANS_FAMILY); + flag.setOnOff(fontinfo.family() == SANS_FAMILY); return true; case LFUN_FONT_ROMAN: - flag.setOnOff(font.family() == Font::ROMAN_FAMILY); + flag.setOnOff(fontinfo.family() == ROMAN_FAMILY); return true; - case LFUN_FONT_CODE: - flag.setOnOff(font.family() == Font::TYPEWRITER_FAMILY); + case LFUN_FONT_TYPEWRITER: + flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY); return true; case LFUN_CUT: @@ -1813,7 +2039,14 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; case LFUN_INSET_DISSOLVE: - enable = !isMainText(cur.bv().buffer()) && cur.inset().nargs() == 1; + if (!cmd.argument().empty()) { + InsetLayout il = cur.inset().getLayout(cur.buffer().params()); + enable = cur.inset().lyxCode() == FLEX_CODE + && il.lyxtype == to_utf8(cmd.argument()); + } else { + enable = !isMainText(cur.bv().buffer()) + && cur.inset().nargs() == 1; + } break; case LFUN_CHANGE_ACCEPT: @@ -1827,15 +2060,28 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, enable = true; break; + case LFUN_OUTLINE_UP: + case LFUN_OUTLINE_DOWN: + case LFUN_OUTLINE_IN: + case LFUN_OUTLINE_OUT: + enable = (cur.paragraph().layout()->toclevel != Layout::NOT_IN_TOC); + break; + case LFUN_WORD_DELETE_FORWARD: case LFUN_WORD_DELETE_BACKWARD: case LFUN_LINE_DELETE: case LFUN_WORD_FORWARD: case LFUN_WORD_BACKWARD: + case LFUN_WORD_RIGHT: + case LFUN_WORD_LEFT: case LFUN_CHAR_FORWARD: case LFUN_CHAR_FORWARD_SELECT: case LFUN_CHAR_BACKWARD: case LFUN_CHAR_BACKWARD_SELECT: + case LFUN_CHAR_LEFT: + case LFUN_CHAR_LEFT_SELECT: + case LFUN_CHAR_RIGHT: + case LFUN_CHAR_RIGHT_SELECT: case LFUN_UP: case LFUN_UP_SELECT: case LFUN_DOWN: @@ -1848,20 +2094,20 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_LINE_END_SELECT: case LFUN_WORD_FORWARD_SELECT: case LFUN_WORD_BACKWARD_SELECT: + case LFUN_WORD_RIGHT_SELECT: + case LFUN_WORD_LEFT_SELECT: case LFUN_WORD_SELECT: case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_DOWN: - case LFUN_SCREEN_UP: - case LFUN_SCREEN_DOWN: case LFUN_LINE_BEGIN: + case LFUN_LINE_BREAK: case LFUN_LINE_END: - case LFUN_BREAK_LINE: + case LFUN_NEW_LINE: case LFUN_CHAR_DELETE_FORWARD: case LFUN_DELETE_FORWARD_SKIP: case LFUN_CHAR_DELETE_BACKWARD: case LFUN_DELETE_BACKWARD_SKIP: case LFUN_BREAK_PARAGRAPH: - case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT: case LFUN_BREAK_PARAGRAPH_SKIP: case LFUN_PARAGRAPH_SPACING: case LFUN_INSET_INSERT: @@ -1877,6 +2123,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_DATE_INSERT: case LFUN_SELF_INSERT: case LFUN_LINE_INSERT: + case LFUN_NEWPAGE_INSERT: case LFUN_PAGEBREAK_INSERT: case LFUN_CLEARPAGE_INSERT: case LFUN_CLEARDOUBLEPAGE_INSERT: @@ -1932,7 +2179,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, return false; } - if (code != Inset::NO_CODE + if (code != NO_CODE && (cur.empty() || !cur.inset().insetAllowed(code))) enable = false; @@ -1946,7 +2193,7 @@ void Text::pasteString(Cursor & cur, docstring const & clip, { cur.clearSelection(); if (!clip.empty()) { - recordUndo(cur); + cur.recordUndo(); if (asParagraphs) insertStringAsParagraphs(cur, clip); else