X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=fa9fa8d69f0c9d22f09682e965a693aa38280c4c;hb=8c6ac457ecc69f57ab54cd8c9b8b7893607c65d6;hp=79f48c1bb58f5a44cf5b11409717779b92a214e9;hpb=12314897982e07afd8926c997f66d7bb08e7e1fd;p=lyx.git diff --git a/src/Text3.cpp b/src/Text3.cpp index 79f48c1bb5..fa9fa8d69f 100644 --- a/src/Text3.cpp +++ b/src/Text3.cpp @@ -27,12 +27,12 @@ #include "BufferView.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" @@ -44,9 +44,10 @@ #include "Paragraph.h" #include "paragraph_funcs.h" #include "ParagraphParameters.h" +#include "ParIterator.h" +#include "TextClass.h" #include "TextMetrics.h" #include "VSpace.h" -#include "ParIterator.h" #include "frontends/Clipboard.h" #include "frontends/Selection.h" @@ -68,7 +69,7 @@ #include "mathed/InsetMathHull.h" #include "mathed/MathMacroTemplate.h" -#include +#include #include #include @@ -90,7 +91,7 @@ using support::isStrUnsignedInt; using support::token; // globals... -static Font freefont(ignore_font); +static Font freefont(ignore_font, ignore_language); static bool toggleall = false; static void toggleAndShow(Cursor & cur, Text * text, @@ -99,12 +100,12 @@ static void toggleAndShow(Cursor & cur, Text * text, text->toggleFree(cur, font, toggleall); if (font.language() != ignore_language || - font.fontInfo().number() != FONT_IGNORE) { + 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)) + if (cur.boundary() != tm.isRTLBoundary(cur.pit(), cur.pos(), + cur.real_current_font)) text->setCursor(cur, cur.pit(), cur.pos(), - false, !cur.boundary()); + false, !cur.boundary()); } } @@ -179,17 +180,20 @@ static void specialChar(Cursor & cur, InsetSpecialChar::Kind kind) cur.recordUndo(); cap::replaceSelection(cur); cur.insert(new InsetSpecialChar(kind)); - cur.posRight(); + cur.posForward(); } 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; + 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', ' '); @@ -244,6 +248,129 @@ string const freefont2string() } +/// 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) { FontInfo font = ignore_font; @@ -260,7 +387,7 @@ bool Text::isRTL(Buffer const & buffer, Paragraph const & par) const 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 @@ -379,8 +506,7 @@ 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); needsUpdate |= cursorForward(cur); @@ -408,29 +534,27 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CHAR_LEFT_SELECT: //FIXME: for visual cursor, really move left if (reverseDirectionNeeded(cur)) { - lyx::dispatch(FuncRequest( - cmd.action == LFUN_CHAR_LEFT_SELECT ? - LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD)); + cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? + LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD; } else { - lyx::dispatch(FuncRequest( - cmd.action == LFUN_CHAR_LEFT_SELECT ? - LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD)); + cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? + LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD; } - break; + dispatch(cur, cmd); + return; case LFUN_CHAR_RIGHT: case LFUN_CHAR_RIGHT_SELECT: //FIXME: for visual cursor, really move right if (reverseDirectionNeeded(cur)) { - lyx::dispatch(FuncRequest( - cmd.action == LFUN_CHAR_RIGHT_SELECT ? - LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD)); + cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? + LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD; } else { - lyx::dispatch(FuncRequest( - cmd.action == LFUN_CHAR_RIGHT_SELECT ? - LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD)); + cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? + LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD; } - break; + dispatch(cur, cmd); + return; case LFUN_UP_SELECT: case LFUN_DOWN_SELECT: @@ -504,15 +628,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_RIGHT_SELECT: //FIXME: for visual cursor mode, really move right if (reverseDirectionNeeded(cur)) { - lyx::dispatch(FuncRequest( - cmd.action == LFUN_WORD_RIGHT_SELECT ? - LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD)); + cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ? + LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD; } else { - lyx::dispatch(FuncRequest( - cmd.action == LFUN_WORD_RIGHT_SELECT ? - LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD)); + cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ? + LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD; } - break; + dispatch(cur, cmd); + return; case LFUN_WORD_FORWARD: case LFUN_WORD_FORWARD_SELECT: @@ -524,15 +647,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_LEFT_SELECT: //FIXME: for visual cursor mode, really move left if (reverseDirectionNeeded(cur)) { - lyx::dispatch(FuncRequest( - cmd.action == LFUN_WORD_LEFT_SELECT ? - LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD)); + cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ? + LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD; } else { - lyx::dispatch(FuncRequest( - cmd.action == LFUN_WORD_LEFT_SELECT ? - LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD)); + cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ? + LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD; } - break; + dispatch(cur, cmd); + return; case LFUN_WORD_BACKWARD: case LFUN_WORD_BACKWARD_SELECT: @@ -546,7 +668,7 @@ 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 @@ -555,7 +677,22 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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; @@ -684,7 +821,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_INSET_INSERT: { cur.recordUndo(); - Inset * inset = createInset(bv, cmd); + Inset * inset = createInset(bv->buffer(), cmd); if (inset) { // FIXME (Abdel 01/02/2006): // What follows would be a partial fix for bug 2154: @@ -711,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; } @@ -729,30 +866,33 @@ 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_uppercase); @@ -831,7 +971,7 @@ 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(); @@ -933,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, "\"")); @@ -1013,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; } @@ -1079,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; @@ -1115,7 +1249,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) content : cmd.argument(); string const data = InsetCommandMailer::params2string("href", p); if (p["target"].empty()) { - bv->showInsetDialog("href", data, 0); + bv->showDialog("href", data); } else { FuncRequest fr(LFUN_INSET_INSERT, data); dispatch(cur, fr); @@ -1132,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); @@ -1141,7 +1275,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_INFO_INSERT: { - Inset * inset = createInset(&cur.bv(), cmd); + Inset * inset = createInset(cur.bv().buffer(), cmd); if (!inset) break; // if an empty inset is created (cmd.argument() is empty) @@ -1153,7 +1287,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) static_cast(inset)->setInfo(to_utf8(ds)); } insertInset(cur, inset); - cur.posRight(); + cur.posForward(); break; } #if 0 @@ -1161,10 +1295,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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: @@ -1174,20 +1310,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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"); @@ -1199,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(); @@ -1238,10 +1373,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_INDEX_INSERT: doInsertInset(cur, this, cmd, true, true); - cur.posRight(); + 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; cur.recordUndo(); @@ -1251,7 +1391,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // description entry still needs to be filled in. if (cmd.action == LFUN_NOMENCL_INSERT) inset->edit(cur, true); - cur.posRight(); + cur.posForward(); break; } @@ -1260,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: @@ -1329,42 +1470,42 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_FONT_EMPH: { - Font font(ignore_font); + Font font(ignore_font, ignore_language); font.fontInfo().setEmph(FONT_TOGGLE); toggleAndShow(cur, this, font); break; } case LFUN_FONT_BOLD: { - Font font(ignore_font); + Font font(ignore_font, ignore_language); font.fontInfo().setSeries(BOLD_SERIES); toggleAndShow(cur, this, font); break; } case LFUN_FONT_NOUN: { - Font font(ignore_font); + Font font(ignore_font, ignore_language); font.fontInfo().setNoun(FONT_TOGGLE); toggleAndShow(cur, this, font); break; } case LFUN_FONT_TYPEWRITER: { - Font font(ignore_font); + Font font(ignore_font, ignore_language); font.fontInfo().setFamily(TYPEWRITER_FAMILY); // no good toggleAndShow(cur, this, font); break; } case LFUN_FONT_SANS: { - Font font(ignore_font); + Font font(ignore_font, ignore_language); font.fontInfo().setFamily(SANS_FAMILY); toggleAndShow(cur, this, font); break; } case LFUN_FONT_ROMAN: { - Font font(ignore_font); + Font font(ignore_font, ignore_language); font.fontInfo().setFamily(ROMAN_FAMILY); toggleAndShow(cur, this, font); break; @@ -1377,14 +1518,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_FONT_UNDERLINE: { - Font font(ignore_font); + Font font(ignore_font, ignore_language); font.fontInfo().setUnderbar(FONT_TOGGLE); toggleAndShow(cur, this, font); break; } case LFUN_FONT_SIZE: { - Font font(ignore_font); + Font font(ignore_font, ignore_language); setLyXSize(to_utf8(cmd.argument()), font.fontInfo()); toggleAndShow(cur, this, font); break; @@ -1394,8 +1535,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) Language const * lang = languages.getLanguage(to_utf8(cmd.argument())); if (!lang) break; - Font font(ignore_font); - font.setLanguage(lang); + Font font(ignore_font, lang); toggleAndShow(cur, this, font); break; } @@ -1422,7 +1562,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_FINISHED_LEFT: - LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_LEFT:\n" << cur << endl; + LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_LEFT:\n" << cur); if (reverseDirectionNeeded(cur)) { ++cur.pos(); cur.setCurrentFont(); @@ -1430,7 +1570,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; case LFUN_FINISHED_RIGHT: - LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_RIGHT:\n" << cur << endl; + LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_RIGHT:\n" << cur); if (!reverseDirectionNeeded(cur)) { ++cur.pos(); cur.setCurrentFont(); @@ -1438,11 +1578,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; case LFUN_FINISHED_BACKWARD: - LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_BACKWARD:\n" << cur << endl; + LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_BACKWARD:\n" << cur); break; case LFUN_FINISHED_FORWARD: - LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_FORWARD:\n" << cur << endl; + LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_FORWARD:\n" << cur); ++cur.pos(); cur.setCurrentFont(); break; @@ -1451,7 +1591,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) string data; params2string(cur.paragraph(), data); data = "show\n" + data; - bv->showDialogWithData("paragraph", data); + bv->showDialog("paragraph", data); break; } @@ -1507,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; @@ -1536,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; } @@ -1573,11 +1713,34 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } 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; } @@ -1600,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 @@ -1748,7 +1909,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, InsetLayout il = cur.buffer().params().getTextClass().insetlayout(from_utf8(s)); if (il.lyxtype != "charstyle" && il.lyxtype != "custom" && - il.lyxtype != "element") + il.lyxtype != "element" && + il.lyxtype != "standard") enable = false; break; } @@ -1796,12 +1958,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, // 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: + case LFUN_SPECIALCHAR_INSERT: code = SPECIALCHAR_CODE; break; case LFUN_SPACE_INSERT: @@ -1902,6 +2060,13 @@ 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: @@ -1935,8 +2100,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_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: @@ -1957,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: