X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext3.C;h=85cf5515d6225daac73e3a421b871ca8878b84d6;hb=52eb91c94fb70d58dceef430659c8781de2eccda;hp=015a83f03fe2e8b394c6ac0988907a5493768b19;hpb=3674a8c003a5d4f6e890b47062b164395e17e0f8;p=lyx.git diff --git a/src/text3.C b/src/text3.C index 015a83f03f..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" @@ -75,8 +76,10 @@ namespace lyx { using cap::copySelection; using cap::cutSelection; -using cap::pasteSelection; +using cap::pasteFromStack; +using cap::pasteClipboard; using cap::replaceSelection; +using cap::saveSelection; using support::isStrUnsignedInt; using support::token; @@ -120,8 +123,7 @@ namespace { { if (selecting || cur.mark()) cur.setSelection(); - if (!cur.selection()) - theSelection().haveSelection(false); + saveSelection(cur); cur.bv().switchKeyMap(); } @@ -137,13 +139,14 @@ namespace { { recordUndo(cur); docstring sel = cur.selectionAsString(false); - //lyxerr << "selection is: '" << sel << "'" << endl; // 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); @@ -198,48 +201,42 @@ string const freefont2string() } -bool LyXText::cursorPrevious(LCursor & cur) +void LyXText::cursorPrevious(LCursor & cur) { pos_type cpos = cur.pos(); 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(); 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); } @@ -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 = @@ -295,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()); } @@ -305,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(); @@ -318,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]); @@ -339,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]); @@ -363,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; } @@ -420,7 +424,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) //lyxerr << BOOST_CURRENT_FUNCTION // << " LFUN_CHAR_FORWARD[SEL]:\n" << cur << endl; needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT); - if (isRTL(cur.paragraph())) + if (isRTL(*cur.bv().buffer(), cur.paragraph())) needsUpdate |= cursorLeft(cur); else needsUpdate |= cursorRight(cur); @@ -430,13 +434,15 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) 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; needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT); - if (isRTL(cur.paragraph())) + if (isRTL(*cur.bv().buffer(), cur.paragraph())) needsUpdate |= cursorRight(cur); else needsUpdate |= cursorLeft(cur); @@ -446,6 +452,8 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_LEFT); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_UP: @@ -460,6 +468,8 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_UP); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_DOWN: @@ -474,18 +484,24 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_DOWN); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_UP_SELECT: 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: needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_DOWN_SELECT); needsUpdate |= cursorDownParagraph(cur); + if (cur.selection()) + saveSelection(cur); break; case LFUN_SCREEN_UP: @@ -495,8 +511,10 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_UP); } else { - needsUpdate |= cursorPrevious(cur); + cursorPrevious(cur); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_SCREEN_DOWN: @@ -507,8 +525,10 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_DOWN); } else { - needsUpdate |= cursorNext(cur); + cursorNext(cur); } + if (cur.selection()) + saveSelection(cur); break; case LFUN_LINE_BEGIN: @@ -521,24 +541,30 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_LINE_END_SELECT: 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: needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT); - if (isRTL(cur.paragraph())) + if (isRTL(*cur.bv().buffer(), cur.paragraph())) needsUpdate |= cursorLeftOneWord(cur); else needsUpdate |= cursorRightOneWord(cur); + if (cur.selection()) + saveSelection(cur); break; case LFUN_WORD_BACKWARD: case LFUN_WORD_BACKWARD_SELECT: needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT); - if (isRTL(cur.paragraph())) + if (isRTL(*cur.bv().buffer(), cur.paragraph())) needsUpdate |= cursorRightOneWord(cur); else needsUpdate |= cursorLeftOneWord(cur); + if (cur.selection()) + saveSelection(cur); break; case LFUN_WORD_SELECT: { @@ -550,6 +576,8 @@ 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()) { + if (!cur.selection()) + recordUndo(cur); cap::replaceSelection(cur); cur.insert(new InsetNewline); cur.posRight(); @@ -691,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(); } @@ -748,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")); cap::replaceSelection(cur); - if (isStrUnsignedInt(to_utf8(cmd.argument()))) - pasteSelection(cur, bv->buffer()->errorList("Paste"), - convert(to_utf8(cmd.argument()))); - else - pasteSelection(cur, bv->buffer()->errorList("Paste"), - 0); + 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(); @@ -778,8 +831,8 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) case LFUN_SERVER_GET_XY: cur.message(from_utf8( - convert(cursorX(cur.top(), cur.boundary())) + ' ' - + convert(cursorY(cur.top(), cur.boundary())))); + convert(cursorX(cur.bv(), cur.top(), cur.boundary())) + + ' ' + convert(cursorY(cur.bv(), cur.top(), cur.boundary())))); break; case LFUN_SERVER_SET_XY: { @@ -809,24 +862,15 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) break; case LFUN_LAYOUT: { - lyxerr[Debug::INFO] << "LFUN_LAYOUT: (arg) " - << 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(to_utf8(cmd.argument())); - string layout = 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) { @@ -867,31 +911,17 @@ 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()) @@ -957,7 +987,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) cursorEnd(cur); cur.setSelection(); bv->cursor() = cur; - theSelection().haveSelection(cur.selection()); + saveSelection(cur); } break; @@ -965,7 +995,6 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) if (cmd.button() == mouse_button::button1) { selectWord(cur, WHOLE_WORD_STRICT); bv->cursor() = cur; - theSelection().haveSelection(cur.selection()); } break; @@ -980,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; } @@ -1016,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) @@ -1045,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; @@ -1063,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; @@ -1105,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 - from_utf8(cur.getPossibleLabel()) : + cur.getPossibleLabel() : cmd.argument(); string const data = InsetCommandMailer::params2string("label", p); @@ -1123,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: @@ -1152,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; @@ -1169,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(); @@ -1388,7 +1482,7 @@ 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: { @@ -1405,7 +1499,7 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } setLayout(cur, tclass.defaultLayoutName()); - setParagraph(cur, Spacing(), LYX_ALIGN_LAYOUT, string(), 0); + setParagraph(cur, Spacing(), LYX_ALIGN_LAYOUT, docstring(), 0); insertInset(cur, new InsetFloatList(to_utf8(cmd.argument()))); cur.posRight(); } else { @@ -1416,12 +1510,12 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } case LFUN_CHANGE_ACCEPT: { - acceptChange(cur); + acceptOrRejectChanges(cur, ACCEPT); break; } case LFUN_CHANGE_REJECT: { - rejectChange(cur); + acceptOrRejectChanges(cur, REJECT); break; } @@ -1449,11 +1543,10 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) lex.setStream(is); ParagraphParameters params; params.read(lex); - // FIXME UNICODE setParagraph(cur, params.spacing(), params.align(), - to_ascii(params.labelWidthString()), + params.labelWidthString(), params.noindent()); cur.message(_("Paragraph layout set")); break; @@ -1462,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); @@ -1478,9 +1572,24 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) } needsUpdate |= (cur.pos() != cur.lastpos()) && cur.selection(); - if (singleParUpdate) + + // 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.updateFlags(Update::SinglePar | @@ -1489,12 +1598,23 @@ void LyXText::dispatch(LCursor & cur, FuncRequest & cmd) 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.updateFlags(Update::Force | Update::FitCursor); } @@ -1550,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") @@ -1632,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; @@ -1695,7 +1823,28 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, break; case LFUN_PASTE: - enable = 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: @@ -1707,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: @@ -1762,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: @@ -1827,4 +1982,17 @@ bool LyXText::getStatus(LCursor & cur, FuncRequest const & cmd, } +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