X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext3.C;h=85cf5515d6225daac73e3a421b871ca8878b84d6;hb=52eb91c94fb70d58dceef430659c8781de2eccda;hp=847bdf5a3ad99757241673235713d1c5bb104093;hpb=b27bb5cb53edeee088cf408eb37dd7d72586b90d;p=lyx.git diff --git a/src/text3.C b/src/text3.C index 847bdf5a3a..85cf5515d6 100644 --- a/src/text3.C +++ b/src/text3.C @@ -24,6 +24,7 @@ #include "buffer_funcs.h" #include "bufferparams.h" #include "BufferView.h" +#include "bufferview_funcs.h" #include "cursor.h" #include "coordcache.h" #include "CutAndPaste.h" @@ -70,17 +71,18 @@ #include #include -using lyx::char_type; -using lyx::docstring; -using lyx::pos_type; -using lyx::cap::copySelection; -using lyx::cap::cutSelection; -using lyx::cap::pasteSelection; -using lyx::cap::replaceSelection; +namespace lyx { -using lyx::support::isStrUnsignedInt; -using lyx::support::token; +using cap::copySelection; +using cap::cutSelection; +using cap::pasteFromStack; +using cap::pasteClipboard; +using cap::replaceSelection; +using cap::saveSelection; + +using support::isStrUnsignedInt; +using support::token; using std::endl; using std::string; @@ -121,8 +123,7 @@ namespace { { if (selecting || cur.mark()) cur.setSelection(); - if (!cur.selection()) - theSelection().haveSelection(false); + saveSelection(cur); cur.bv().switchKeyMap(); } @@ -137,14 +138,15 @@ namespace { void mathDispatch(LCursor & cur, FuncRequest const & cmd, bool display) { recordUndo(cur); - string sel = lyx::to_utf8(cur.selectionAsString(false)); - //lyxerr << "selection is: '" << sel << "'" << endl; + docstring sel = cur.selectionAsString(false); // It may happen that sel is empty but there is a selection replaceSelection(cur); if (sel.empty()) { +#ifdef ENABLE_ASSERTIONS const int old_pos = cur.pos(); +#endif cur.insert(new InsetMathHull(hullSimple)); BOOST_ASSERT(old_pos == cur.pos()); cur.nextInset()->edit(cur, true); @@ -163,11 +165,11 @@ namespace { // create a macro if we see "\\newcommand" // somewhere, and an ordinary formula // otherwise - istringstream is(sel); - if (sel.find("\\newcommand") == string::npos - && sel.find("\\def") == string::npos) + if (sel.find(from_ascii("\\newcommand")) == string::npos + && sel.find(from_ascii("\\def")) == string::npos) { InsetMathHull * formula = new InsetMathHull; + istringstream is(to_utf8(sel)); LyXLex lex(0, 0); lex.setStream(is); formula->read(cur.buffer(), lex); @@ -176,10 +178,11 @@ namespace { // delimiters are left out formula->mutate(hullSimple); cur.insert(formula); - } else - cur.insert(new MathMacroTemplate(is)); + } else { + cur.insert(new MathMacroTemplate(sel)); + } } - cur.message(lyx::from_utf8(N_("Math editor mode"))); + cur.message(from_utf8(N_("Math editor mode"))); } } // namespace anon @@ -198,48 +201,42 @@ string const freefont2string() } -bool LyXText::cursorPrevious(LCursor & cur) +void LyXText::cursorPrevious(LCursor & cur) { pos_type cpos = cur.pos(); - lyx::pit_type cpar = cur.pit(); + pit_type cpar = cur.pit(); int x = cur.x_target(); + setCursorFromCoordinates(cur, x, 0); + cur.dispatch(FuncRequest(cur.selection()? LFUN_UP_SELECT: LFUN_UP)); - bool updated = setCursorFromCoordinates(cur, x, 0); - if (updated) - cur.bv().update(); - updated |= cursorUp(cur); - - if (cpar == cur.pit() && cpos == cur.pos()) { + if (cpar == cur.pit() && cpos == cur.pos()) // we have a row which is taller than the workarea. The // simplest solution is to move to the previous row instead. - updated |= cursorUp(cur); - } + cur.dispatch(FuncRequest(cur.selection()? LFUN_UP_SELECT: LFUN_UP)); finishUndo(); - return updated; + cur.updateFlags(Update::Force | Update::FitCursor); } -bool LyXText::cursorNext(LCursor & cur) +void LyXText::cursorNext(LCursor & cur) { pos_type cpos = cur.pos(); - lyx::pit_type cpar = cur.pit(); + pit_type cpar = cur.pit(); int x = cur.x_target(); - bool updated = setCursorFromCoordinates(cur, x, cur.bv().workHeight() - 1); - if (updated) - cur.bv().update(); - updated |= cursorDown(cur); + setCursorFromCoordinates(cur, x, cur.bv().workHeight() - 1); + cur.dispatch(FuncRequest(cur.selection()? LFUN_DOWN_SELECT: LFUN_DOWN)); - if (cpar == cur.pit() && cpos == cur.pos()) { + if (cpar == cur.pit() && cpos == cur.pos()) // we have a row which is taller than the workarea. The // simplest solution is to move to the next row instead. - updated |= cursorDown(cur); - } + cur.dispatch( + FuncRequest(cur.selection()? LFUN_DOWN_SELECT: LFUN_DOWN)); finishUndo(); - return updated; + cur.updateFlags(Update::Force | Update::FitCursor); } @@ -247,7 +244,7 @@ namespace { void specialChar(LCursor & cur, InsetSpecialChar::Kind kind) { - lyx::cap::replaceSelection(cur); + cap::replaceSelection(cur); cur.insert(new InsetSpecialChar(kind)); cur.posRight(); } @@ -272,7 +269,7 @@ bool doInsertInset(LCursor & cur, LyXText * text, inset->edit(cur, true); if (gotsel && pastesel) { - lyx::dispatch(FuncRequest(LFUN_PASTE)); + lyx::dispatch(FuncRequest(LFUN_PASTE, "0")); // reset first par to default if (cur.lastpit() != 0 || cur.lastpos() != 0) { LyXLayout_ptr const layout = @@ -284,14 +281,6 @@ bool doInsertInset(LCursor & cur, LyXText * text, } -void update(LCursor & cur) -{ - //we don't call update(true, false) directly to save a metrics call - if (cur.bv().fitCursor()) - cur.bv().update(Update::Force); -} - - } // anon namespace @@ -303,9 +292,9 @@ void LyXText::number(LCursor & cur) } -bool LyXText::isRTL(Paragraph const & par) const +bool LyXText::isRTL(Buffer const & buffer, Paragraph const & par) const { - return par.isRightToLeftPar(bv()->buffer()->params()); + return par.isRightToLeftPar(buffer.params()); } @@ -313,6 +302,11 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) { lyxerr[Debug::ACTION] << "LyXText::dispatch: cmd: " << cmd << endl; + // 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(); + BOOST_ASSERT(cur.text() == this); BufferView * bv = &cur.bv(); CursorSlice oldTopSlice = cur.top(); @@ -326,13 +320,15 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action, LyXAction::NoUpdate) || singleParUpdate); // Remember the old paragraph metric (_outer_ paragraph!) - Dimension olddim = cur.bottom().paragraph().dim(); + ParagraphMetrics const & pm = cur.bv().parMetrics( + cur.bottom().text(), cur.bottom().pit()); + Dimension olddim = pm.dim(); switch (cmd.action) { case LFUN_PARAGRAPH_MOVE_DOWN: { pit_type const pit = cur.pit(); - recUndo(pit, pit + 1); + recUndo(cur, pit, pit + 1); finishUndo(); std::swap(pars_[pit], pars_[pit + 1]); @@ -347,7 +343,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_PARAGRAPH_MOVE_UP: { pit_type const pit = cur.pit(); - recUndo(pit - 1, pit); + recUndo(cur, pit - 1, pit); finishUndo(); std::swap(pars_[pit], pars_[pit - 1]); @@ -371,7 +367,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // ensure that we have only one start_of_appendix in this document for (pit_type tmp = 0, end = pars_.size(); tmp != end; ++tmp) { if (pars_[tmp].params().startOfAppendix()) { - recUndo(tmp); + recUndo(cur, tmp); pars_[tmp].params().startOfAppendix(false); break; } @@ -405,9 +401,9 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_BUFFER_BEGIN: case LFUN_BUFFER_BEGIN_SELECT: - cur.selHandle(cmd.action == LFUN_BUFFER_BEGIN_SELECT); + needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_BEGIN_SELECT); if (cur.depth() == 1) { - needsUpdate = cursorTop(cur); + needsUpdate |= cursorTop(cur); } else { cur.undispatched(); } @@ -415,9 +411,9 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_BUFFER_END: case LFUN_BUFFER_END_SELECT: - cur.selHandle(cmd.action == LFUN_BUFFER_END_SELECT); + needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_END_SELECT); if (cur.depth() == 1) { - needsUpdate = cursorBottom(cur); + needsUpdate |= cursorBottom(cur); } else { cur.undispatched(); } @@ -427,134 +423,152 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_CHAR_FORWARD_SELECT: //lyxerr << BOOST_CURRENT_FUNCTION // << " LFUN_CHAR_FORWARD[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT); - if (isRTL(cur.paragraph())) - needsUpdate = cursorLeft(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT); + if (isRTL(*cur.bv().buffer(), cur.paragraph())) + needsUpdate |= cursorLeft(cur); else - needsUpdate = cursorRight(cur); + needsUpdate |= cursorRight(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_RIGHT); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_CHAR_BACKWARD: case LFUN_CHAR_BACKWARD_SELECT: //lyxerr << "handle LFUN_CHAR_BACKWARD[_SELECT]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT); - if (isRTL(cur.paragraph())) - needsUpdate = cursorRight(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT); + if (isRTL(*cur.bv().buffer(), cur.paragraph())) + needsUpdate |= cursorRight(cur); else - needsUpdate = cursorLeft(cur); + needsUpdate |= cursorLeft(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_LEFT); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_UP: case LFUN_UP_SELECT: - update(cur); //lyxerr << "handle LFUN_UP[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_UP_SELECT); + needsUpdate |= cur.selHandle(cmd.action == LFUN_UP_SELECT); + + needsUpdate |= cursorUp(cur); - needsUpdate = cursorUp(cur); if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_UP); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_DOWN: case LFUN_DOWN_SELECT: - update(cur); //lyxerr << "handle LFUN_DOWN[SEL]:\n" << cur << endl; - cur.selHandle(cmd.action == LFUN_DOWN_SELECT); - needsUpdate = cursorDown(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_DOWN_SELECT); + needsUpdate |= cursorDown(cur); + if (!needsUpdate && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_DOWN); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_UP_SELECT: - cur.selHandle(cmd.action == LFUN_PARAGRAPH_UP_SELECT); - needsUpdate = cursorUpParagraph(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_UP_SELECT); + needsUpdate |= cursorUpParagraph(cur); + if (cur.selection()) + saveSelection(cur); break; case LFUN_PARAGRAPH_DOWN: case LFUN_PARAGRAPH_DOWN_SELECT: - cur.selHandle(cmd.action == LFUN_PARAGRAPH_DOWN_SELECT); - needsUpdate = cursorDownParagraph(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_DOWN_SELECT); + needsUpdate |= cursorDownParagraph(cur); + if (cur.selection()) + saveSelection(cur); break; case LFUN_SCREEN_UP: case LFUN_SCREEN_UP_SELECT: - update(cur); - cur.selHandle(cmd.action == LFUN_SCREEN_UP_SELECT); + needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_UP_SELECT); if (cur.pit() == 0 && cur.textRow().pos() == 0) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_UP); } else { - needsUpdate = cursorPrevious(cur); + cursorPrevious(cur); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_SCREEN_DOWN: case LFUN_SCREEN_DOWN_SELECT: - update(cur); - cur.selHandle(cmd.action == LFUN_SCREEN_DOWN_SELECT); + needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_DOWN_SELECT); if (cur.pit() == cur.lastpit() && cur.textRow().endpos() == cur.lastpos()) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_DOWN); } else { - needsUpdate = cursorNext(cur); + cursorNext(cur); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_LINE_BEGIN: case LFUN_LINE_BEGIN_SELECT: - update(cur); - cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT); - needsUpdate = cursorHome(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT); + needsUpdate |= cursorHome(cur); break; case LFUN_LINE_END: case LFUN_LINE_END_SELECT: - update(cur); - cur.selHandle(cmd.action == LFUN_LINE_END_SELECT); - needsUpdate = cursorEnd(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_END_SELECT); + needsUpdate |= cursorEnd(cur); + if (cur.selection()) + saveSelection(cur); break; case LFUN_WORD_FORWARD: case LFUN_WORD_FORWARD_SELECT: - cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT); - if (isRTL(cur.paragraph())) - needsUpdate = cursorLeftOneWord(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT); + if (isRTL(*cur.bv().buffer(), cur.paragraph())) + needsUpdate |= cursorLeftOneWord(cur); else - needsUpdate = cursorRightOneWord(cur); + needsUpdate |= cursorRightOneWord(cur); + if (cur.selection()) + saveSelection(cur); break; case LFUN_WORD_BACKWARD: case LFUN_WORD_BACKWARD_SELECT: - cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT); - if (isRTL(cur.paragraph())) - needsUpdate = cursorRightOneWord(cur); + needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT); + if (isRTL(*cur.bv().buffer(), cur.paragraph())) + needsUpdate |= cursorRightOneWord(cur); else - needsUpdate = cursorLeftOneWord(cur); + needsUpdate |= cursorLeftOneWord(cur); + if (cur.selection()) + saveSelection(cur); break; case LFUN_WORD_SELECT: { - selectWord(cur, lyx::WHOLE_WORD); + selectWord(cur, WHOLE_WORD); finishChange(cur, true); break; } @@ -562,7 +576,9 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_BREAK_LINE: { // Not allowed by LaTeX (labels or empty par) if (cur.pos() > cur.paragraph().beginOfBody()) { - lyx::cap::replaceSelection(cur); + if (!cur.selection()) + recordUndo(cur); + cap::replaceSelection(cur); cur.insert(new InsetNewline); cur.posRight(); moveCursor(cur, false); @@ -575,7 +591,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (cur.pos() == cur.paragraph().size()) // Par boundary, force full-screen update singleParUpdate = false; - needsUpdate = erase(cur); + needsUpdate |= erase(cur); cur.resetAnchor(); // It is possible to make it a lot faster still // just comment out the line below... @@ -607,7 +623,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // Par boundary, full-screen update if (cur.pos() == 0) singleParUpdate = false; - needsUpdate = backspace(cur); + needsUpdate |= backspace(cur); cur.resetAnchor(); // It is possible to make it a lot faster still // just comment out the line below... @@ -634,14 +650,14 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; case LFUN_BREAK_PARAGRAPH: - lyx::cap::replaceSelection(cur); + cap::replaceSelection(cur); breakParagraph(cur, 0); cur.resetAnchor(); bv->switchKeyMap(); break; case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT: - lyx::cap::replaceSelection(cur); + cap::replaceSelection(cur); breakParagraph(cur, 1); cur.resetAnchor(); bv->switchKeyMap(); @@ -650,7 +666,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_BREAK_PARAGRAPH_SKIP: { // When at the beginning of a paragraph, remove // indentation. Otherwise, do the same as LFUN_BREAK_PARAGRAPH. - lyx::cap::replaceSelection(cur); + cap::replaceSelection(cur); if (cur.pos() == 0) cur.paragraph().params().labelWidthString(docstring()); else @@ -667,7 +683,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (cur_spacing == Spacing::Other) cur_value = par.params().spacing().getValueAsString(); - istringstream is(lyx::to_utf8(cmd.argument())); + istringstream is(to_utf8(cmd.argument())); string tmp; is >> tmp; Spacing::Space new_spacing = cur_spacing; @@ -691,8 +707,8 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } else if (tmp == "default") { new_spacing = Spacing::Default; } else { - lyxerr << lyx::to_utf8(_("Unknown spacing argument: ")) - << lyx::to_utf8(cmd.argument()) << endl; + lyxerr << to_utf8(_("Unknown spacing argument: ")) + << to_utf8(cmd.argument()) << endl; } if (cur_spacing != new_spacing || cur_value != new_value) par.params().spacing(Spacing(new_spacing, new_value)); @@ -703,6 +719,28 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) recordUndo(cur); InsetBase * inset = createInset(bv, cmd); if (inset) { + // FIXME (Abdel 01/02/2006): + // What follows would be a partial fix for bug 2154: + // http://bugzilla.lyx.org/show_bug.cgi?id=2154 + // This automatically put the label inset _after_ a + // numbered section. It should be possible to extend the mechanism + // to any kind of LateX environement. + // The correct way to fix that bug would be at LateX generation. + // I'll let the code here for reference as it could be used for some + // other feature like "automatic labelling". + /* + Paragraph & par = pars_[cur.pit()]; + if (inset->lyxCode() == InsetBase::LABEL_CODE + && par.layout()->labeltype == LABEL_COUNTER) { + // Go to the end of the paragraph + // Warning: Because of Change-Tracking, the last + // position is 'size()' and not 'size()-1': + cur.pos() = par.size(); + // Insert a new paragraph + FuncRequest fr(LFUN_BREAK_PARAGRAPH); + dispatch(cur, fr); + } + */ insertInset(cur, inset); cur.posRight(); } @@ -710,7 +748,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } case LFUN_INSET_DISSOLVE: - needsUpdate = dissolveInset(cur); + needsUpdate |= dissolveInset(cur); break; case LFUN_INSET_SETTINGS: @@ -760,18 +798,21 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; case LFUN_CHARS_TRANSPOSE: - recordUndo(cur); + charsTranspose(cur); break; case LFUN_PASTE: cur.message(_("Paste")); - lyx::cap::replaceSelection(cur); - if (isStrUnsignedInt(lyx::to_utf8(cmd.argument()))) - pasteSelection(cur, bv->buffer()->errorList("Paste"), - convert(lyx::to_utf8(cmd.argument()))); - else - pasteSelection(cur, bv->buffer()->errorList("Paste"), - 0); + cap::replaceSelection(cur); + if (cmd.argument().empty() && !theClipboard().isInternal()) + pasteClipboard(cur, bv->buffer()->errorList("Paste")); + else { + string const arg(to_utf8(cmd.argument())); + pasteFromStack(cur, bv->buffer()->errorList("Paste"), + isStrUnsignedInt(arg) ? + convert(arg) : + 0); + } bv->buffer()->errors("Paste"); cur.clearSelection(); // bug 393 bv->switchKeyMap(); @@ -789,19 +830,19 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; case LFUN_SERVER_GET_XY: - cur.message(lyx::from_utf8( - convert(cursorX(cur.top(), cur.boundary())) + ' ' - + convert(cursorY(cur.top(), cur.boundary())))); + cur.message(from_utf8( + convert(cursorX(cur.bv(), cur.top(), cur.boundary())) + + ' ' + convert(cursorY(cur.bv(), cur.top(), cur.boundary())))); break; case LFUN_SERVER_SET_XY: { int x = 0; int y = 0; - istringstream is(lyx::to_utf8(cmd.argument())); + istringstream is(to_utf8(cmd.argument())); is >> x >> y; if (!is) lyxerr << "SETXY: Could not parse coordinates in '" - << lyx::to_utf8(cmd.argument()) << std::endl; + << to_utf8(cmd.argument()) << std::endl; else setCursorFromCoordinates(cur, x, y); break; @@ -809,36 +850,27 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_SERVER_GET_FONT: if (current_font.shape() == LyXFont::ITALIC_SHAPE) - cur.message(lyx::from_ascii("E")); + cur.message(from_ascii("E")); else if (current_font.shape() == LyXFont::SMALLCAPS_SHAPE) - cur.message(lyx::from_ascii("N")); + cur.message(from_ascii("N")); else - cur.message(lyx::from_ascii("0")); + cur.message(from_ascii("0")); break; case LFUN_SERVER_GET_LAYOUT: - cur.message(lyx::from_utf8(cur.paragraph().layout()->name())); + cur.message(from_utf8(cur.paragraph().layout()->name())); break; case LFUN_LAYOUT: { - lyxerr[Debug::INFO] << "LFUN_LAYOUT: (arg) " - << lyx::to_utf8(cmd.argument()) << endl; - - // This is not the good solution to the empty argument - // problem, but it will hopefully suffice for 1.2.0. - // The correct solution would be to augument the - // function list/array with information about what - // functions needs arguments and their type. - if (cmd.argument().empty()) { - cur.errorMessage(_("LyX function 'layout' needs an argument.")); - break; - } + string layout = to_ascii(cmd.argument()); + lyxerr[Debug::INFO] << "LFUN_LAYOUT: (arg) " << layout << endl; // Derive layout number from given argument (string) // and current buffer's textclass (number) LyXTextClass const & tclass = bv->buffer()->params().getLyXTextClass(); - bool hasLayout = tclass.hasLayout(lyx::to_utf8(cmd.argument())); - string layout = lyx::to_utf8(cmd.argument()); + if (layout.empty()) + layout = tclass.defaultLayoutName(); + bool hasLayout = tclass.hasLayout(layout); // If the entry is obsolete, use the new one instead. if (hasLayout) { @@ -848,8 +880,8 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } if (!hasLayout) { - cur.errorMessage(lyx::from_utf8(N_("Layout ")) + cmd.argument() + - lyx::from_utf8(N_(" not known"))); + cur.errorMessage(from_utf8(N_("Layout ")) + cmd.argument() + + from_utf8(N_(" not known"))); break; } @@ -879,37 +911,38 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - case LFUN_CLIPBOARD_PASTE: { + case LFUN_CLIPBOARD_PASTE: cur.clearSelection(); - docstring const clip = theClipboard().get(); - if (!clip.empty()) { - recordUndo(cur); - if (cmd.argument() == "paragraph") - insertStringAsParagraphs(cur, clip); - else - insertStringAsLines(cur, clip); - } + pasteClipboard(cur, bv->buffer()->errorList("Paste"), + cmd.argument() == "paragraph"); + bv->buffer()->errors("Paste"); break; - } - case LFUN_PRIMARY_SELECTION_PASTE: { - cur.clearSelection(); - docstring const clip = theSelection().get(); - if (!clip.empty()) { - recordUndo(cur); - if (cmd.argument() == "paragraph") - insertStringAsParagraphs(cur, clip); - else - insertStringAsLines(cur, clip); + case LFUN_PRIMARY_SELECTION_PASTE: + pasteString(cur, theSelection().get(), + cmd.argument() == "paragraph"); + break; + + case LFUN_UNICODE_INSERT: { + if (cmd.argument().empty()) + break; + docstring hexstring = cmd.argument(); + if (lyx::support::isHex(hexstring)) { + char_type c = lyx::support::hexToInt(hexstring); + if (c > 32 && c < 0x10ffff) { + lyxerr << "Inserting c: " << c << endl; + docstring s = docstring(1, c); + lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, s)); + } } break; } - + case LFUN_QUOTE_INSERT: { - lyx::cap::replaceSelection(cur); + cap::replaceSelection(cur); Paragraph & par = cur.paragraph(); - lyx::pos_type pos = cur.pos(); - lyx::char_type c; + pos_type pos = cur.pos(); + char_type c; if (pos == 0) c = ' '; else if (cur.prevInset() && cur.prevInset()->isSpace()) @@ -922,7 +955,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) BufferParams const & bufparams = bv->buffer()->params(); if (!style->pass_thru && par.getFontSettings(bufparams, pos).language()->lang() != "hebrew") { - string arg = lyx::to_utf8(cmd.argument()); + string arg = to_utf8(cmd.argument()); if (arg == "single") cur.insert(new InsetQuotes(c, bufparams.quotes_language, @@ -941,10 +974,10 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_DATE_INSERT: if (cmd.argument().empty()) lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, - lyx::formatted_time(lyx::current_time()))); + formatted_time(current_time()))); else lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, - lyx::formatted_time(lyx::current_time(), lyx::to_utf8(cmd.argument())))); + formatted_time(current_time(), to_utf8(cmd.argument())))); break; case LFUN_MOUSE_TRIPLE: @@ -954,15 +987,14 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cursorEnd(cur); cur.setSelection(); bv->cursor() = cur; - theSelection().haveSelection(cur.selection()); + saveSelection(cur); } break; case LFUN_MOUSE_DOUBLE: if (cmd.button() == mouse_button::button1) { - selectWord(cur, lyx::WHOLE_WORD_STRICT); + selectWord(cur, WHOLE_WORD_STRICT); bv->cursor() = cur; - theSelection().haveSelection(cur.selection()); } break; @@ -977,23 +1009,36 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // it could get cleared on the unlocking of the inset so // we have to check this first bool paste_internally = false; - if (cmd.button() == mouse_button::button2 && cur.selection()) { - lyx::dispatch(FuncRequest(LFUN_COPY)); + if (cmd.button() == mouse_button::button2 && cap::selection()) { + // Copy the selection buffer to the clipboard + // stack, because we want it to appear in the + // "Edit->Paste recent" menu. + cap::copySelectionToStack(); paste_internally = true; } - bv->mouseSetCursor(cur); + // we have to update after dePM triggered + bool update = bv->mouseSetCursor(cur); // Insert primary selection with middle mouse // if there is a local selection in the current buffer, // insert this if (cmd.button() == mouse_button::button2) { - if (paste_internally) - lyx::dispatch(FuncRequest(LFUN_PASTE)); - else + if (paste_internally) { + cap::pasteSelection(cur, bv->buffer()->errorList("Paste")); + bv->buffer()->errors("Paste"); + cur.clearSelection(); // bug 393 + bv->switchKeyMap(); + finishUndo(); + } else lyx::dispatch(FuncRequest(LFUN_PRIMARY_SELECTION_PASTE, "paragraph")); } + if (!update && cmd.button() == mouse_button::button1) { + needsUpdate = false; + cur.noUpdate(); + } + break; } @@ -1013,15 +1058,15 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) setCursorFromCoordinates(cur, cmd.x, y); cur.x_target() = cmd.x; if (cmd.y >= wh) - cursorDown(cur); + lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT)); else if (cmd.y < 0) - cursorUp(cur); + lyx::dispatch(FuncRequest(LFUN_UP_SELECT)); // This is to allow jumping over large insets if (cur.top() == old) { if (cmd.y >= wh) - cursorDown(cur); + lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT)); else if (cmd.y < 0) - cursorUp(cur); + lyx::dispatch(FuncRequest(LFUN_UP_SELECT)); } if (cur.top() == old) @@ -1042,9 +1087,21 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (cmd.button() == mouse_button::button2) break; - // finish selection - if (cmd.button() == mouse_button::button1) - theSelection().haveSelection(cur.selection()); + if (cmd.button() == mouse_button::button1) { + // if there is new selection, update persistent + // selection, otherwise, single click does not + // clear persistent selection buffer + if (cur.selection()) { + // finish selection + // if double click, cur is moved to the end of word by selectWord + // but bvcur is current mouse position + LCursor & bvcur = cur.bv().cursor(); + bvcur.selection() = true; + saveSelection(bvcur); + } + needsUpdate = false; + cur.noUpdate(); + } bv->switchKeyMap(); break; @@ -1060,11 +1117,9 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // "auto_region_delete", which defaults to // true (on). - if (lyxrc.auto_region_delete) { + if (lyxrc.auto_region_delete) if (cur.selection()) cutSelection(cur, false, false); - theSelection().haveSelection(false); - } cur.clearSelection(); LyXFont const old_font = real_current_font; @@ -1102,8 +1157,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) InsetCommandParams p("label"); // Try to generate a valid label p["name"] = (cmd.argument().empty()) ? - // FIXME UNICODE - lyx::from_utf8(cur.getPossibleLabel()) : + cur.getPossibleLabel() : cmd.argument(); string const data = InsetCommandMailer::params2string("label", p); @@ -1120,8 +1174,14 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) #if 0 case LFUN_LIST_INSERT: case LFUN_THEOREM_INSERT: - case LFUN_CAPTION_INSERT: #endif + case LFUN_CAPTION_INSERT: + // Open the inset, and move the current selection + // inside it. + doInsertInset(cur, this, cmd, true, true); + cur.posRight(); + updateLabels(*bv->buffer()); + break; case LFUN_NOTE_INSERT: case LFUN_CHARSTYLE_INSERT: case LFUN_BOX_INSERT: @@ -1149,15 +1209,44 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_FLOAT_INSERT: case LFUN_FLOAT_WIDE_INSERT: - case LFUN_WRAP_INSERT: + case LFUN_WRAP_INSERT: { + bool content = cur.selection(); // will some text be moved into the inset? + doInsertInset(cur, this, cmd, true, true); cur.posRight(); - // FIXME: the "Caption" name should not be hardcoded, - // but given by the float definition. - cur.dispatch(FuncRequest(LFUN_LAYOUT, "Caption")); + ParagraphList & pars = cur.text()->paragraphs(); + + LyXTextClass const & tclass = bv->buffer()->params().getLyXTextClass(); + + // add a separate paragraph for the caption inset + pars.push_back(Paragraph()); + pars.back().setInsetOwner(pars[0].inInset()); + pars.back().layout(tclass.defaultLayout()); + + int cap_pit = pars.size() - 1; + + // if an empty inset was created, we create an additional empty + // paragraph at the bottom so that the user can choose where to put + // the graphics (or table). + if (!content) { + pars.push_back(Paragraph()); + pars.back().setInsetOwner(pars[0].inInset()); + pars.back().layout(tclass.defaultLayout()); + + } + + // reposition the cursor to the caption + cur.pit() = cap_pit; + cur.pos() = 0; + cur.dispatch(FuncRequest(LFUN_CAPTION_INSERT)); + // FIXME: When leaving the Float (or Wrap) inset we should + // delete any empty paragraph left above or below the + // caption. break; + } - case LFUN_INDEX_INSERT: { + case LFUN_INDEX_INSERT: + case LFUN_NOMENCL_INSERT: { InsetBase * inset = createInset(&cur.bv(), cmd); if (!inset) break; @@ -1166,15 +1255,23 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) 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(); break; } case LFUN_INDEX_PRINT: + case LFUN_NOMENCL_PRINT: case LFUN_TOC_INSERT: case LFUN_HFILL_INSERT: case LFUN_LINE_INSERT: case LFUN_PAGEBREAK_INSERT: + case LFUN_CLEARPAGE_INSERT: + case LFUN_CLEARDOUBLEPAGE_INSERT: // do nothing fancy doInsertInset(cur, this, cmd, false, false); cur.posRight(); @@ -1203,14 +1300,14 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_MATH_MACRO: if (cmd.argument().empty()) - cur.errorMessage(lyx::from_utf8(N_("Missing argument"))); + cur.errorMessage(from_utf8(N_("Missing argument"))); else { - string s = lyx::to_utf8(cmd.argument()); + string s = to_utf8(cmd.argument()); string const s1 = token(s, ' ', 1); 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(token(s, ' ', 0), nargs, type)); + cur.insert(new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, from_utf8(type))); //cur.nextInset()->edit(cur, true); } break; @@ -1290,13 +1387,13 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_FONT_SIZE: { LyXFont font(LyXFont::ALL_IGNORE); - font.setLyXSize(lyx::to_utf8(cmd.argument())); + font.setLyXSize(to_utf8(cmd.argument())); toggleAndShow(cur, this, font); break; } case LFUN_LANGUAGE: { - Language const * lang = languages.getLanguage(lyx::to_utf8(cmd.argument())); + Language const * lang = languages.getLanguage(to_utf8(cmd.argument())); if (!lang) break; LyXFont font(LyXFont::ALL_IGNORE); @@ -1316,7 +1413,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_FONT_FREE_UPDATE: { LyXFont font; bool toggle; - if (bv_funcs::string2font(lyx::to_utf8(cmd.argument()), font, toggle)) { + if (bv_funcs::string2font(to_utf8(cmd.argument()), font, toggle)) { freefont = font; toggleall = toggle; toggleAndShow(cur, this, freefont, toggleall); @@ -1385,12 +1482,12 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (!cmd.argument().empty()) // FIXME: Are all these characters encoded in one byte in utf8? bv->getIntl().getTransManager() - .translateAndInsert(cmd.argument()[0], this); + .translateAndInsert(cmd.argument()[0], this, cur); break; case LFUN_FLOAT_LIST: { LyXTextClass const & tclass = bv->buffer()->params().getLyXTextClass(); - if (tclass.floats().typeExist(lyx::to_utf8(cmd.argument()))) { + if (tclass.floats().typeExist(to_utf8(cmd.argument()))) { // not quite sure if we want this... recordUndo(cur); cur.clearSelection(); @@ -1402,23 +1499,23 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } setLayout(cur, tclass.defaultLayoutName()); - setParagraph(cur, Spacing(), LYX_ALIGN_LAYOUT, string(), 0); - insertInset(cur, new InsetFloatList(lyx::to_utf8(cmd.argument()))); + setParagraph(cur, Spacing(), LYX_ALIGN_LAYOUT, docstring(), 0); + insertInset(cur, new InsetFloatList(to_utf8(cmd.argument()))); cur.posRight(); } else { lyxerr << "Non-existent float type: " - << lyx::to_utf8(cmd.argument()) << endl; + << to_utf8(cmd.argument()) << endl; } break; } case LFUN_CHANGE_ACCEPT: { - acceptChange(cur); + acceptOrRejectChanges(cur, ACCEPT); break; } case LFUN_CHANGE_REJECT: { - rejectChange(cur); + acceptOrRejectChanges(cur, REJECT); break; } @@ -1429,11 +1526,11 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // FIXME if (arg.size() > 100 || arg.empty()) { // Get word or selection - selectWordWhenUnderCursor(cur, lyx::WHOLE_WORD); + selectWordWhenUnderCursor(cur, WHOLE_WORD); arg = cur.selectionAsString(false); } } - bv->showDialogWithData("thesaurus", lyx::to_utf8(arg)); + bv->showDialogWithData("thesaurus", to_utf8(arg)); break; } @@ -1441,16 +1538,15 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) // Given data, an encoding of the ParagraphParameters // generated in the Paragraph dialog, this function sets // the current paragraph appropriately. - istringstream is(lyx::to_utf8(cmd.argument())); + istringstream is(to_utf8(cmd.argument())); LyXLex lex(0, 0); lex.setStream(is); ParagraphParameters params; params.read(lex); - // FIXME UNICODE setParagraph(cur, params.spacing(), params.align(), - lyx::to_ascii(params.labelWidthString()), + params.labelWidthString(), params.noindent()); cur.message(_("Paragraph layout set")); break; @@ -1459,6 +1555,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_ESCAPE: if (cur.selection()) { cur.selection() = false; + saveSelection(cur); } else { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_RIGHT); @@ -1474,26 +1571,52 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; } - if (singleParUpdate) + needsUpdate |= (cur.pos() != cur.lastpos()) && cur.selection(); + + // 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 LyXText::erase() and LyXText::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) { + singleParUpdate = false; + needsUpdate = true; + } + + // FIXME: the following code should go in favor of fine grained + // update flag treatment. + if (singleParUpdate) { // Inserting characters does not change par height - if (cur.bottom().paragraph().dim().height() + ParagraphMetrics const & pms + = cur.bv().parMetrics(cur.bottom().text(), cur.bottom().pit()); + if (pms.dim().height() == olddim.height()) { // if so, update _only_ this paragraph - cur.bv().update(Update::SinglePar | - Update::FitCursor | - Update::MultiParSel); - cur.noUpdate(); + cur.updateFlags(Update::SinglePar | + Update::FitCursor | + Update::MultiParSel); return; } else needsUpdate = true; + } + if (!needsUpdate && &oldTopSlice.inset() == &cur.inset() && oldTopSlice.idx() == cur.idx() - && !sel + && !sel // sel is a backup of cur.selection() at the biginning of the function. && !cur.selection()) - cur.noUpdate(); + // FIXME: it would be better if we could just do this + // + //if (cur.result().update() != Update::FitCursor) + // cur.noUpdate(); + // + // 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); else - cur.needsUpdate(); + cur.updateFlags(Update::Force | Update::FitCursor); } @@ -1547,6 +1670,8 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, code = InsetBase::INCLUDE_CODE; else if (cmd.argument() == "index") code = InsetBase::INDEX_CODE; + else if (cmd.argument() == "nomenclature") + code = InsetBase::NOMENCL_CODE; else if (cmd.argument() == "label") code = InsetBase::LABEL_CODE; else if (cmd.argument() == "note") @@ -1629,6 +1754,12 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, case LFUN_INDEX_PRINT: code = InsetBase::INDEX_PRINT_CODE; break; + case LFUN_NOMENCL_INSERT: + code = InsetBase::NOMENCL_CODE; + break; + case LFUN_NOMENCL_PRINT: + code = InsetBase::NOMENCL_PRINT_CODE; + break; case LFUN_TOC_INSERT: code = InsetBase::TOC_CODE; break; @@ -1692,7 +1823,28 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, break; case LFUN_PASTE: - enable = lyx::cap::numberOfSelections() > 0; + if (cmd.argument().empty()) { + if (theClipboard().isInternal()) + enable = cap::numberOfSelections() > 0; + else + enable = !theClipboard().empty(); + } else { + string const arg = to_utf8(cmd.argument()); + if (isStrUnsignedInt(arg)) { + unsigned int n = convert(arg); + enable = cap::numberOfSelections() > n; + } else + // unknown argument + enable = false; + } + break; + + case LFUN_CLIPBOARD_PASTE: + enable = !theClipboard().empty(); + break; + + case LFUN_PRIMARY_SELECTION_PASTE: + enable = cur.selection() || !theSelection().empty(); break; case LFUN_PARAGRAPH_MOVE_UP: @@ -1704,12 +1856,18 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, break; case LFUN_INSET_DISSOLVE: - enable = !isMainText() && cur.inset().nargs() == 1; + enable = !isMainText(*cur.bv().buffer()) && cur.inset().nargs() == 1; break; case LFUN_CHANGE_ACCEPT: case LFUN_CHANGE_REJECT: - enable = true; // FIXME: Change tracking (MG) + // TODO: context-sensitive enabling of LFUN_CHANGE_ACCEPT/REJECT + // In principle, these LFUNs should only be enabled if there + // is a change at the current position/in the current selection. + // However, without proper optimizations, this will inevitably + // result in unacceptable performance - just imagine a user who + // wants to select the complete content of a long document. + enable = true; break; case LFUN_WORD_DELETE_FORWARD: @@ -1759,12 +1917,12 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, case LFUN_SERVER_GET_FONT: case LFUN_SERVER_GET_LAYOUT: case LFUN_LAYOUT: - case LFUN_CLIPBOARD_PASTE: - case LFUN_PRIMARY_SELECTION_PASTE: case LFUN_DATE_INSERT: case LFUN_SELF_INSERT: case LFUN_LINE_INSERT: case LFUN_PAGEBREAK_INSERT: + case LFUN_CLEARPAGE_INSERT: + case LFUN_CLEARDOUBLEPAGE_INSERT: case LFUN_MATH_DISPLAY: case LFUN_MATH_IMPORT_SELECTION: case LFUN_MATH_MODE: @@ -1806,6 +1964,7 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, case LFUN_BUFFER_BEGIN: case LFUN_BUFFER_BEGIN_SELECT: case LFUN_BUFFER_END_SELECT: + case LFUN_UNICODE_INSERT: // these are handled in our dispatch() enable = true; break; @@ -1821,3 +1980,19 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, flag.enabled(enable); return true; } + + +void LyXText::pasteString(LCursor & cur, docstring const & clip, + bool asParagraphs) +{ + cur.clearSelection(); + if (!clip.empty()) { + recordUndo(cur); + if (asParagraphs) + insertStringAsParagraphs(cur, clip); + else + insertStringAsLines(cur, clip); + } +} + +} // namespace lyx