+
+
+void BufferView::Pimpl::pasteClipboard(bool asPara)
+{
+ if (!buffer_) return;
+
+ screen_->HideCursor();
+ beforeChange(bv_->text);
+
+ string const clip(workarea_.getClipboard());
+
+ if (clip.empty()) return;
+
+ if (asPara) {
+ bv_->text->insertStringAsParagraphs(bv_, clip);
+ } else {
+ bv_->text->insertStringAsLines(bv_, clip);
+ }
+ update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+}
+
+
+void BufferView::Pimpl::stuffClipboard(string const & stuff) const
+{
+ workarea_.putClipboard(stuff);
+}
+
+
+/*
+ * Dispatch functions for actions which can be valid for BufferView->text
+ * and/or InsetText->text!!!
+ */
+
+
+inline
+void BufferView::Pimpl::moveCursorUpdate(bool selecting)
+{
+ LyXText * lt = bv_->getLyXText();
+
+ if (selecting || lt->selection.mark()) {
+ lt->setSelection(bv_);
+ if (lt->bv_owner)
+ toggleToggle();
+ }
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ showCursor();
+
+ /* ---> Everytime the cursor is moved, show the current font state. */
+ // should this too me moved out of this func?
+ //owner->showState();
+ setState();
+}
+
+
+Inset * BufferView::Pimpl::getInsetByCode(Inset::Code code)
+{
+ LyXCursor cursor = bv_->getLyXText()->cursor;
+ Buffer::inset_iterator it =
+ find_if(Buffer::inset_iterator(
+ cursor.par(), cursor.pos()),
+ buffer_->inset_iterator_end(),
+ lyx::compare_memfun(&Inset::lyxCode, code));
+ return it != buffer_->inset_iterator_end() ? (*it) : 0;
+}
+
+
+void BufferView::Pimpl::MenuInsertLyXFile(string const & filen)
+{
+ string filename = filen;
+
+ if (filename.empty()) {
+ // Launch a file browser
+ string initpath = lyxrc.document_path;
+
+ if (available()) {
+ string const trypath = owner_->buffer()->filepath;
+ // If directory is writeable, use this as default.
+ if (IsDirWriteable(trypath) == 1)
+ initpath = trypath;
+ }
+
+ FileDialog fileDlg(bv_->owner(),
+ _("Select LyX document to insert"),
+ LFUN_FILE_INSERT,
+ make_pair(string(_("Documents")),
+ string(lyxrc.document_path)),
+ make_pair(string(_("Examples")),
+ string(AddPath(system_lyxdir, "examples"))));
+
+ FileDialog::Result result =
+ fileDlg.Select(initpath,
+ _("*.lyx| LyX Documents (*.lyx)"));
+
+ if (result.first == FileDialog::Later)
+ return;
+
+ filename = result.second;
+
+ // check selected filename
+ if (filename.empty()) {
+ owner_->message(_("Canceled."));
+ return;
+ }
+ }
+
+ // get absolute path of file and add ".lyx" to the filename if
+ // necessary
+ filename = FileSearch(string(), filename, "lyx");
+
+ string const disp_fn(MakeDisplayPath(filename));
+
+ ostringstream s1;
+ s1 << _("Inserting document") << ' '
+ << disp_fn << " ...";
+ owner_->message(s1.str().c_str());
+ bool const res = bv_->insertLyXFile(filename);
+ if (res) {
+ ostringstream str;
+ str << _("Document") << ' ' << disp_fn
+ << ' ' << _("inserted.");
+ owner_->message(str.str().c_str());
+ } else {
+ ostringstream str;
+ str << _("Could not insert document") << ' '
+ << disp_fn;
+ owner_->message(str.str().c_str());
+ }
+}
+
+
+bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
+{
+ lyxerr[Debug::ACTION] << "BufferView::Pimpl::Dispatch: action["
+ << action <<"] arg[" << argument << "]" << endl;
+
+ switch (action) {
+ // --- Misc -------------------------------------------
+ case LFUN_APPENDIX:
+ {
+ if (available()) {
+ LyXText * lt = bv_->getLyXText();
+ lt->toggleAppendix(bv_);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ }
+ break;
+
+ case LFUN_TOC_INSERT:
+ {
+ InsetCommandParams p;
+ p.setCmdName("tableofcontents");
+ Inset * inset = new InsetTOC(p);
+ if (!insertInset(inset, "Standard"))
+ delete inset;
+ break;
+ }
+
+ case LFUN_TABULAR_FEATURE:
+ case LFUN_SCROLL_INSET:
+ // this is not handled here as this funktion is only aktive
+ // if we have a locking_inset and that one is (or contains)
+ // a tabular-inset
+ break;
+
+ case LFUN_INSET_GRAPHICS:
+ {
+ Inset * new_inset = new InsetGraphics;
+ if (!insertInset(new_inset)) {
+ delete new_inset;
+ } else {
+ // this is need because you don't use a inset->Edit()
+ updateInset(new_inset, true);
+ new_inset->edit(bv_, 0, 0, 0);
+ }
+ break;
+ }
+
+ case LFUN_PASTE:
+ bv_->paste();
+ setState();
+ break;
+
+ case LFUN_PASTESELECTION:
+ {
+ bool asPara = false;
+ if (argument == "paragraph") asPara = true;
+ pasteClipboard(asPara);
+ }
+ break;
+
+ case LFUN_CUT:
+ bv_->cut();
+ break;
+
+ case LFUN_COPY:
+ bv_->copy();
+ break;
+
+ case LFUN_LAYOUT_COPY:
+ bv_->copyEnvironment();
+ break;
+
+ case LFUN_LAYOUT_PASTE:
+ bv_->pasteEnvironment();
+ setState();
+ break;
+
+ case LFUN_GOTOERROR:
+ gotoInset(Inset::ERROR_CODE, false);
+ break;
+
+ case LFUN_GOTONOTE:
+ gotoInset(Inset::IGNORE_CODE, false);
+ break;
+
+ case LFUN_REFERENCE_GOTO:
+ {
+ vector<Inset::Code> tmp;
+ tmp.push_back(Inset::LABEL_CODE);
+ tmp.push_back(Inset::REF_CODE);
+ gotoInset(tmp, true);
+ break;
+ }
+
+ case LFUN_HYPHENATION:
+ hyphenationPoint();
+ break;
+
+ case LFUN_LDOTS:
+ ldots();
+ break;
+
+ case LFUN_END_OF_SENTENCE:
+ endOfSentenceDot();
+ break;
+
+ case LFUN_MENU_SEPARATOR:
+ menuSeparator();
+ break;
+
+ case LFUN_HFILL:
+ hfill();
+ break;
+
+ case LFUN_DEPTH:
+ changeDepth(bv_, bv_->getLyXText(), 0);
+ break;
+
+ case LFUN_DEPTH_MIN:
+ changeDepth(bv_, bv_->getLyXText(), -1);
+ break;
+
+ case LFUN_DEPTH_PLUS:
+ changeDepth(bv_, bv_->getLyXText(), 1);
+ break;
+
+ case LFUN_FREE:
+ owner_->getDialogs()->setUserFreeFont();
+ break;
+
+#ifndef NO_LATEX
+ case LFUN_TEX:
+ Tex(bv_);
+ setState();
+ owner_->showState();
+ break;
+#endif
+
+ case LFUN_FILE_INSERT:
+ {
+ MenuInsertLyXFile(argument);
+ }
+ break;
+
+ case LFUN_FILE_INSERT_ASCII_PARA:
+ InsertAsciiFile(bv_, argument, true);
+ break;
+
+ case LFUN_FILE_INSERT_ASCII:
+ InsertAsciiFile(bv_, argument, false);
+ break;
+
+ case LFUN_LAYOUT:
+ {
+ lyxerr[Debug::INFO] << "LFUN_LAYOUT: (arg) "
+ << argument << endl;
+
+ // Derive layout number from given argument (string)
+ // and current buffer's textclass (number). */
+ LyXTextClassList::ClassList::size_type tclass =
+ buffer_->params.textclass;
+ pair <bool, LyXTextClass::size_type> layout =
+ textclasslist.NumberOfLayout(tclass, argument);
+
+ // If the entry is obsolete, use the new one instead.
+ if (layout.first) {
+ string obs = textclasslist.Style(tclass,layout.second)
+ .obsoleted_by();
+ if (!obs.empty())
+ layout =
+ textclasslist.NumberOfLayout(tclass, obs);
+ }
+
+ // see if we found the layout number:
+ if (!layout.first) {
+ owner_->getLyXFunc()->setErrorMessage(
+ string(N_("Layout ")) + argument +
+ N_(" not known"));
+ break;
+ }
+
+ if (current_layout != layout.second) {
+ LyXText * lt = bv_->getLyXText();
+ hideCursor();
+ current_layout = layout.second;
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR);
+ lt->setLayout(bv_, layout.second);
+ owner_->setLayout(layout.second);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ setState();
+ }
+ }
+ break;
+
+ case LFUN_LANGUAGE:
+ Lang(bv_, argument);
+ setState();
+ owner_->showState();
+ break;
+
+ case LFUN_EMPH:
+ Emph(bv_);
+ owner_->showState();
+ break;
+
+ case LFUN_BOLD:
+ Bold(bv_);
+ owner_->showState();
+ break;
+
+ case LFUN_NOUN:
+ Noun(bv_);
+ owner_->showState();
+ break;
+
+ case LFUN_CODE:
+ Code(bv_);
+ owner_->showState();
+ break;
+
+ case LFUN_SANS:
+ Sans(bv_);
+ owner_->showState();
+ break;
+
+ case LFUN_ROMAN:
+ Roman(bv_);
+ owner_->showState();
+ break;
+
+ case LFUN_DEFAULT:
+ StyleReset(bv_);
+ owner_->showState();
+ break;
+
+ case LFUN_UNDERLINE:
+ Underline(bv_);
+ owner_->showState();
+ break;
+
+ case LFUN_FONT_SIZE:
+ FontSize(bv_, argument);
+ owner_->showState();
+ break;
+
+ case LFUN_FONT_STATE:
+ owner_->getLyXFunc()->setMessage(CurrentState(bv_));
+ break;
+
+ case LFUN_UPCASE_WORD:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR);
+ lt->changeCase(bv_, LyXText::text_uppercase);
+ if (lt->inset_owner)
+ updateInset(lt->inset_owner, true);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ break;
+
+ case LFUN_LOWCASE_WORD:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->changeCase(bv_, LyXText::text_lowercase);
+ if (lt->inset_owner)
+ updateInset(lt->inset_owner, true);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ break;
+
+ case LFUN_CAPITALIZE_WORD:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->changeCase(bv_, LyXText::text_capitalization);
+ if (lt->inset_owner)
+ updateInset(lt->inset_owner, true);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ break;
+
+ case LFUN_TRANSPOSE_CHARS:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->transposeChars(*bv_);
+ if (lt->inset_owner)
+ updateInset(lt->inset_owner, true);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ break;
+
+
+ case LFUN_INSERT_LABEL:
+ MenuInsertLabel(bv_, argument);
+ break;
+
+ case LFUN_REF_INSERT:
+ if (argument.empty()) {
+ InsetCommandParams p("ref");
+ owner_->getDialogs()->createRef(p.getAsString());
+ } else {
+ InsetCommandParams p;
+ p.setFromString(argument);
+
+ InsetRef * inset = new InsetRef(p, *buffer_);
+ if (!insertInset(inset))
+ delete inset;
+ else
+ updateInset(inset, true);
+ }
+ break;
+
+ case LFUN_BOOKMARK_SAVE:
+ savePosition(strToUnsignedInt(argument));
+ break;
+
+ case LFUN_BOOKMARK_GOTO:
+ restorePosition(strToUnsignedInt(argument));
+ break;
+
+ case LFUN_REF_GOTO:
+ {
+ string label(argument);
+ if (label.empty()) {
+ InsetRef * inset =
+ static_cast<InsetRef*>(getInsetByCode(Inset::REF_CODE));
+ if (inset) {
+ label = inset->getContents();
+ savePosition(0);
+ }
+ }
+
+ if (!label.empty()) {
+ //bv_->savePosition(0);
+ if (!bv_->gotoLabel(label))
+ WriteAlert(_("Error"),
+ _("Couldn't find this label"),
+ _("in current document."));
+ }
+ }
+ break;
+
+ // --- Cursor Movements -----------------------------
+ case LFUN_RIGHT:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ bool is_rtl = lt->cursor.par()->isRightToLeftPar(buffer_->params);
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ if (is_rtl)
+ lt->cursorLeft(bv_, false);
+ if (lt->cursor.pos() < lt->cursor.par()->size()
+ && lt->cursor.par()->getChar(lt->cursor.pos())
+ == Paragraph::META_INSET
+ && lt->cursor.par()->getInset(lt->cursor.pos())
+ && lt->cursor.par()->getInset(lt->cursor.pos())->editable() == Inset::HIGHLY_EDITABLE){
+ Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos());
+ owner_->getLyXFunc()->setMessage(tmpinset->editMessage());
+ int y = 0;
+ if (is_rtl) {
+ LyXFont const font =
+ lt->getFont(buffer_,
+ lt->cursor.par(),
+ lt->cursor.pos());
+ y = tmpinset->descent(bv_,font);
+ }
+ tmpinset->edit(bv_, 0, y, 0);
+ break;
+ }
+ if (!is_rtl)
+ lt->cursorRight(bv_, false);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_LEFT:
+ {
+ // This is soooo ugly. Isn`t it possible to make
+ // it simpler? (Lgb)
+ LyXText * lt = bv_->getLyXText();
+ bool is_rtl = lt->cursor.par()->isRightToLeftPar(buffer_->params);
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ LyXCursor const cur = lt->cursor;
+ if (!is_rtl)
+ lt->cursorLeft(bv_, false);
+ if ((is_rtl || cur != lt->cursor) && // only if really moved!
+ lt->cursor.pos() < lt->cursor.par()->size() &&
+ (lt->cursor.par()->getChar(lt->cursor.pos()) ==
+ Paragraph::META_INSET) &&
+ lt->cursor.par()->getInset(lt->cursor.pos()) &&
+ (lt->cursor.par()->getInset(lt->cursor.pos())->editable()
+ == Inset::HIGHLY_EDITABLE))
+ {
+ Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos());
+ owner_->getLyXFunc()->setMessage(tmpinset->editMessage());
+ LyXFont const font = lt->getFont(buffer_,
+ lt->cursor.par(),
+ lt->cursor.pos());
+ int y = is_rtl ? 0
+ : tmpinset->descent(bv_,font);
+ tmpinset->edit(bv_,
+ tmpinset->x() +
+ tmpinset->width(bv_,font),
+ y, 0);
+ break;
+ }
+ if (is_rtl)
+ lt->cursorRight(bv_, false);
+
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_UP:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::UPDATE);
+ lt->cursorUp(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_DOWN:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::UPDATE);
+ lt->cursorDown(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_UP_PARAGRAPH:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::UPDATE);
+ lt->cursorUpParagraph(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_DOWN_PARAGRAPH:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::UPDATE);
+ lt->cursorDownParagraph(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_PRIOR:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::UPDATE);
+ cursorPrevious(lt);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_NEXT:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::UPDATE);
+ cursorNext(lt);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_HOME:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorHome(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_END:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorEnd(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_SHIFT_TAB:
+ case LFUN_TAB:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorTab(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_WORDRIGHT:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
+ lt->cursorLeftOneWord(bv_);
+ else
+ lt->cursorRightOneWord(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_WORDLEFT:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
+ lt->cursorRightOneWord(bv_);
+ else
+ lt->cursorLeftOneWord(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_BEGINNINGBUF:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorTop(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_ENDBUF:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.mark())
+ beforeChange(lt);
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorBottom(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ /* cursor selection ---------------------------- */
+ case LFUN_RIGHTSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
+ lt->cursorLeft(bv_);
+ else
+ lt->cursorRight(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_LEFTSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
+ lt->cursorRight(bv_);
+ else
+ lt->cursorLeft(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_UPSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorUp(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_DOWNSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorDown(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_UP_PARAGRAPHSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorUpParagraph(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_DOWN_PARAGRAPHSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorDownParagraph(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_PRIORSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ cursorPrevious(lt);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_NEXTSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ cursorNext(lt);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_HOMESEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorHome(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_ENDSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorEnd(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_WORDRIGHTSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
+ lt->cursorLeftOneWord(bv_);
+ else
+ lt->cursorRightOneWord(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_WORDLEFTSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
+ lt->cursorRightOneWord(bv_);
+ else
+ lt->cursorLeftOneWord(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_BEGINNINGBUFSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (lt->inset_owner)
+ break;
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorTop(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_ENDBUFSEL:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (lt->inset_owner)
+ break;
+ update(lt,
+ BufferView::SELECT|BufferView::FITCUR);
+ lt->cursorBottom(bv_);
+ lt->finishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ }
+ break;
+
+ // --- text changing commands ------------------------
+ case LFUN_BREAKLINE:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ beforeChange(lt);
+ lt->insertChar(bv_, Paragraph::META_NEWLINE);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ moveCursorUpdate(false);
+ }
+ break;
+
+ case LFUN_PROTECTEDSPACE:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ LyXLayout const & style = textclasslist
+ .Style(buffer_->params.textclass,
+ lt->cursor.par()->getLayout());
+
+ if (style.free_spacing) {
+ lt->insertChar(bv_, ' ');
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ } else {
+ protectedBlank(lt);
+ }
+ moveCursorUpdate(false);
+ }
+ break;
+
+ case LFUN_SETMARK:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (lt->selection.mark()) {
+ beforeChange(lt);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR);
+ owner_->getLyXFunc()->setMessage(N_("Mark removed"));
+ } else {
+ beforeChange(lt);
+ lt->selection.mark(true);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR);
+ owner_->getLyXFunc()->setMessage(N_("Mark set"));
+ }
+ lt->selection.cursor = lt->cursor;
+ }
+ break;
+
+ case LFUN_DELETE:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.set()) {
+ lt->Delete(bv_);
+ lt->selection.cursor = lt->cursor;
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ // It is possible to make it a lot faster still
+ // just comment out the line below...
+ showCursor();
+ } else {
+ bv_->cut();
+ }
+ moveCursorUpdate(false);
+ owner_->showState();
+ setState();
+ }
+ break;
+
+ case LFUN_DELETE_SKIP:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP.
+
+ LyXCursor cursor = lt->cursor;
+
+ if (!lt->selection.set()) {
+ if (cursor.pos() == cursor.par()->size()) {
+ lt->cursorRight(bv_);
+ cursor = lt->cursor;
+ if (cursor.pos() == 0
+ && !(cursor.par()->params().spaceTop()
+ == VSpace (VSpace::NONE))) {
+ lt->setParagraph
+ (bv_,
+ cursor.par()->params().lineTop(),
+ cursor.par()->params().lineBottom(),
+ cursor.par()->params().pagebreakTop(),
+ cursor.par()->params().pagebreakBottom(),
+ VSpace(VSpace::NONE),
+ cursor.par()->params().spaceBottom(),
+ cursor.par()->params().align(),
+ cursor.par()->params().labelWidthString(), 0);
+ lt->cursorLeft(bv_);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ } else {
+ lt->cursorLeft(bv_);
+ lt->Delete(bv_);
+ lt->selection.cursor = lt->cursor;
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ } else {
+ lt->Delete(bv_);
+ lt->selection.cursor = lt->cursor;
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ } else {
+ bv_->cut();
+ }
+ }
+ break;
+
+ /* -------> Delete word forward. */
+ case LFUN_DELETE_WORD_FORWARD:
+ update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR);
+ bv_->getLyXText()->deleteWordForward(bv_);
+ update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ /* -------> Delete word backward. */
+ case LFUN_DELETE_WORD_BACKWARD:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->deleteWordBackward(bv_);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ /* -------> Kill to end of line. */
+ case LFUN_DELETE_LINE_FORWARD:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->deleteLineForward(bv_);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ moveCursorUpdate(false);
+ }
+ break;
+
+ /* -------> Set mark off. */
+ case LFUN_MARK_OFF:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ beforeChange(lt);
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->selection.cursor = lt->cursor;
+ owner_->getLyXFunc()->setMessage(N_("Mark off"));
+ }
+ break;
+
+ /* -------> Set mark on. */
+ case LFUN_MARK_ON:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ beforeChange(lt);
+ lt->selection.mark(true);
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ lt->selection.cursor = lt->cursor;
+ owner_->getLyXFunc()->setMessage(N_("Mark on"));
+ }
+ break;
+
+ case LFUN_BACKSPACE:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ if (!lt->selection.set()) {
+ if (owner_->getIntl()->getTrans().backspace()) {
+ lt->backspace(bv_);
+ lt->selection.cursor = lt->cursor;
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ // It is possible to make it a lot faster still
+ // just comment out the line below...
+ showCursor();
+ }
+ } else {
+ bv_->cut();
+ }
+ owner_->showState();
+ setState();
+ }
+ break;
+
+ case LFUN_BACKSPACE_SKIP:
+ {
+ // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP.
+ LyXText * lt = bv_->getLyXText();
+
+ LyXCursor cursor = lt->cursor;
+
+ if (!lt->selection.set()) {
+ if (cursor.pos() == 0
+ && !(cursor.par()->params().spaceTop()
+ == VSpace (VSpace::NONE))) {
+ lt->setParagraph
+ (bv_,
+ cursor.par()->params().lineTop(),
+ cursor.par()->params().lineBottom(),
+ cursor.par()->params().pagebreakTop(),
+ cursor.par()->params().pagebreakBottom(),
+ VSpace(VSpace::NONE), cursor.par()->params().spaceBottom(),
+ cursor.par()->params().align(),
+ cursor.par()->params().labelWidthString(), 0);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ } else {
+ lt->backspace(bv_);
+ lt->selection.cursor = cursor;
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ } else
+ bv_->cut();
+ }
+ break;
+
+ case LFUN_BREAKPARAGRAPH:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ beforeChange(lt);
+ lt->breakParagraph(bv_, 0);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ lt->selection.cursor = lt->cursor;
+ setState();
+ owner_->showState();
+ break;
+ }
+
+ case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ beforeChange(lt);
+ lt->breakParagraph(bv_, 1);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ lt->selection.cursor = lt->cursor;
+ setState();
+ owner_->showState();
+ break;
+ }
+
+ case LFUN_BREAKPARAGRAPH_SKIP:
+ {
+ // When at the beginning of a paragraph, remove
+ // indentation and add a "defskip" at the top.
+ // Otherwise, do the same as LFUN_BREAKPARAGRAPH.
+ LyXText * lt = bv_->getLyXText();
+
+ LyXCursor cursor = lt->cursor;
+
+ beforeChange(lt);
+ if (cursor.pos() == 0) {
+ if (cursor.par()->params().spaceTop() == VSpace(VSpace::NONE)) {
+ lt->setParagraph
+ (bv_,
+ cursor.par()->params().lineTop(),
+ cursor.par()->params().lineBottom(),
+ cursor.par()->params().pagebreakTop(),
+ cursor.par()->params().pagebreakBottom(),
+ VSpace(VSpace::DEFSKIP), cursor.par()->params().spaceBottom(),
+ cursor.par()->params().align(),
+ cursor.par()->params().labelWidthString(), 1);
+ //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+ }
+ else {
+ lt->breakParagraph(bv_, 0);
+ //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ lt->selection.cursor = cursor;
+ setState();
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_PARAGRAPH_SPACING:
+ {
+ LyXText * lt = bv_->getLyXText();
+
+ Paragraph * par = lt->cursor.par();
+ Spacing::Space cur_spacing = par->params().spacing().getSpace();
+ float cur_value = 1.0;
+ if (cur_spacing == Spacing::Other) {
+ cur_value = par->params().spacing().getValue();
+ }
+
+ istringstream istr(argument.c_str());
+
+ string tmp;
+ istr >> tmp;
+ Spacing::Space new_spacing = cur_spacing;
+ float new_value = cur_value;
+ if (tmp.empty()) {
+ lyxerr << "Missing argument to `paragraph-spacing'"
+ << endl;
+ } else if (tmp == "single") {
+ new_spacing = Spacing::Single;
+ } else if (tmp == "onehalf") {
+ new_spacing = Spacing::Onehalf;
+ } else if (tmp == "double") {
+ new_spacing = Spacing::Double;
+ } else if (tmp == "other") {
+ new_spacing = Spacing::Other;
+ float tmpval = 0.0;
+ istr >> tmpval;
+ lyxerr << "new_value = " << tmpval << endl;
+ if (tmpval != 0.0)
+ new_value = tmpval;
+ } else if (tmp == "default") {
+ new_spacing = Spacing::Default;
+ } else {
+ lyxerr << _("Unknown spacing argument: ")
+ << argument << endl;
+ }
+ if (cur_spacing != new_spacing || cur_value != new_value) {
+ par->params().spacing(Spacing(new_spacing, new_value));
+ lt->redoParagraph(bv_);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ }
+ break;
+
+ case LFUN_QUOTE:
+ bv_->insertCorrectQuote();
+ break;
+
+ case LFUN_HTMLURL:
+ case LFUN_URL:
+ {
+ InsetCommandParams p;
+ if (action == LFUN_HTMLURL)
+ p.setCmdName("htmlurl");
+ else
+ p.setCmdName("url");
+ owner_->getDialogs()->createUrl( p.getAsString() );
+ }
+ break;
+
+ case LFUN_INSERT_URL:
+ {
+ InsetCommandParams p;
+ p.setFromString( argument );
+
+ InsetUrl * inset = new InsetUrl( p );
+ if (!insertInset(inset))
+ delete inset;
+ else
+ updateInset( inset, true );
+ }
+ break;
+
+ case LFUN_INSET_TEXT:
+ {
+ InsetText * new_inset = new InsetText;
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ break;
+
+ case LFUN_INSET_ERT:
+ {
+ InsetERT * new_inset = new InsetERT;
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ break;
+
+ case LFUN_INSET_EXTERNAL:
+ {
+ InsetExternal * new_inset = new InsetExternal;
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ break;
+
+ case LFUN_INSET_FOOTNOTE:
+ {
+ InsetFoot * new_inset = new InsetFoot;
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ break;
+
+ case LFUN_INSET_MARGINAL:
+ {
+ InsetMarginal * new_inset = new InsetMarginal;
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ break;
+
+ case LFUN_INSET_MINIPAGE:
+ {
+ InsetMinipage * new_inset = new InsetMinipage;
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ break;
+
+ case LFUN_INSET_FLOAT:
+ {
+ // check if the float type exist
+ if (floatList.typeExist(argument)) {
+ InsetFloat * new_inset = new InsetFloat(argument);
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ } else {
+ lyxerr << "Non-existant float type: "
+ << argument << endl;
+ }
+
+ }
+ break;
+
+ case LFUN_INSET_WIDE_FLOAT:
+ {
+ // check if the float type exist
+ if (floatList.typeExist(argument)) {
+ InsetFloat * new_inset = new InsetFloat(argument);
+ new_inset->wide(true);
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ } else {
+ lyxerr << "Non-existant float type: "
+ << argument << endl;
+ }
+
+ }
+ break;
+
+ case LFUN_INSET_LIST:
+ {
+ InsetList * new_inset = new InsetList;
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ break;
+
+ case LFUN_INSET_THEOREM:
+ {
+ InsetTheorem * new_inset = new InsetTheorem;
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ break;
+
+ case LFUN_INSET_CAPTION:
+ {
+ // Do we have a locking inset...
+ if (bv_->theLockingInset()) {
+ lyxerr << "Locking inset code: "
+ << static_cast<int>(bv_->theLockingInset()->lyxCode());
+ InsetCaption * new_inset = new InsetCaption;
+ new_inset->setOwner(bv_->theLockingInset());
+ new_inset->setAutoBreakRows(true);
+ new_inset->setDrawFrame(0, InsetText::LOCKED);
+ new_inset->setFrameColor(0, LColor::captionframe);
+ if (insertInset(new_inset))
+ new_inset->edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ }
+ break;
+
+ case LFUN_INSET_TABULAR:
+ {
+ int r = 2;
+ int c = 2;
+ if (!argument.empty())
+ ::sscanf(argument.c_str(),"%d%d", &r, &c);
+ InsetTabular * new_inset =
+ new InsetTabular(*buffer_, r, c);
+ bool const rtl =
+ bv_->getLyXText()->real_current_font.isRightToLeft();
+ if (!open_new_inset(new_inset, rtl))
+ delete new_inset;
+ }
+ break;
+
+ // --- lyxserver commands ----------------------------
+
+ case LFUN_CHARATCURSOR:
+ {
+ Paragraph::size_type pos = bv_->getLyXText()->cursor.pos();
+ if (pos < bv_->getLyXText()->cursor.par()->size())
+ owner_->getLyXFunc()->setMessage(
+ tostr(bv_->getLyXText()->cursor.par()->getChar(pos)));
+ else
+ owner_->getLyXFunc()->setMessage("EOF");
+ }
+ break;
+
+ case LFUN_GETXY:
+ owner_->getLyXFunc()->setMessage(tostr(bv_->getLyXText()->cursor.x())
+ + ' '
+ + tostr(bv_->getLyXText()->cursor.y()));
+ break;
+
+ case LFUN_SETXY:
+ {
+ int x = 0;
+ int y = 0;
+ if (::sscanf(argument.c_str(), " %d %d", &x, &y) != 2) {
+ lyxerr << "SETXY: Could not parse coordinates in '"
+ << argument << std::endl;
+ }
+ bv_->getLyXText()->setCursorFromCoordinates(bv_, x, y);
+ }
+ break;
+
+ case LFUN_GETLAYOUT:
+ owner_->getLyXFunc()->setMessage(tostr(bv_->getLyXText()->cursor.par()->layout));
+ break;
+
+ case LFUN_GETFONT:
+ {
+ LyXFont & font = bv_->getLyXText()->current_font;
+ if (font.shape() == LyXFont::ITALIC_SHAPE)
+ owner_->getLyXFunc()->setMessage("E");
+ else if (font.shape() == LyXFont::SMALLCAPS_SHAPE)
+ owner_->getLyXFunc()->setMessage("N");
+ else
+ owner_->getLyXFunc()->setMessage("0");
+
+ }
+ break;
+
+ case LFUN_GETLATEX:
+ {
+#ifndef NO_LATEX
+ LyXFont & font = bv_->getLyXText()->current_font;
+ if (font.latex() == LyXFont::ON)
+ owner_->getLyXFunc()->setMessage("L");
+ else
+#endif
+ owner_->getLyXFunc()->setMessage("0");
+ }
+ break;
+
+ // --- accented characters ---------------------------
+
+ case LFUN_UMLAUT:
+ case LFUN_CIRCUMFLEX:
+ case LFUN_GRAVE:
+ case LFUN_ACUTE:
+ case LFUN_TILDE:
+ case LFUN_CEDILLA:
+ case LFUN_MACRON:
+ case LFUN_DOT:
+ case LFUN_UNDERDOT:
+ case LFUN_UNDERBAR:
+ case LFUN_CARON:
+ case LFUN_SPECIAL_CARON:
+ case LFUN_BREVE:
+ case LFUN_TIE:
+ case LFUN_HUNG_UMLAUT:
+ case LFUN_CIRCLE:
+ case LFUN_OGONEK:
+ if (argument.empty()) {
+ // As always...
+ owner_->getLyXFunc()->handleKeyFunc(action);
+ } else {
+ owner_->getLyXFunc()->handleKeyFunc(action);
+ owner_->getIntl()->getTrans()
+ .TranslateAndInsert(argument[0], bv_->getLyXText());
+ update(bv_->getLyXText(),
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ break;
+
+ // --- insert characters ----------------------------------------
+
+ case LFUN_MATH_DELIM:
+ case LFUN_INSERT_MATRIX:
+ {
+ if (available()) {
+ if (open_new_inset(new InsetFormula, false)) {
+ bv_->theLockingInset()
+ ->localDispatch(bv_, action, argument);
+ }
+ }
+ }
+ break;
+
+ case LFUN_INSERT_MATH:
+ {
+ if (!available())
+ break;
+
+ InsetFormula * f = new InsetFormula(LM_OT_EQUATION);
+ open_new_inset(f);
+ f->localDispatch(bv_, LFUN_INSERT_MATH, argument);
+ }
+ break;
+
+ case LFUN_MATH_DISPLAY:
+ {
+ if (available())
+ open_new_inset(new InsetFormula(LM_OT_EQUATION), false);
+ break;
+ }
+
+ case LFUN_MATH_MACRO:
+ {
+ if (available()) {
+ string s(argument);
+ if (s.empty())
+ owner_->getLyXFunc()->setErrorMessage(N_("Missing argument"));
+ else {
+ string const s1 = token(s, ' ', 1);
+ int const na = s1.empty() ? 0 : lyx::atoi(s1);
+ open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na), false);
+ }
+ }
+ }
+ break;
+
+ case LFUN_MATH_MODE: // Open or create a math inset
+ {
+ if (available())
+ open_new_inset(new InsetFormula, false);
+ owner_->getLyXFunc()->setMessage(N_("Math editor mode"));
+ }
+ break;
+
+ case LFUN_CITATION_INSERT:
+ {
+ InsetCommandParams p;
+ p.setFromString( argument );
+
+ InsetCitation * inset = new InsetCitation( p );
+ if (!insertInset(inset))
+ delete inset;
+ else
+ updateInset( inset, true );
+ }
+ break;
+
+ case LFUN_INSERT_BIBTEX:
+ {
+ // ale970405+lasgoutt970425
+ // The argument can be up to two tokens separated
+ // by a space. The first one is the bibstyle.
+ string const db = token(argument, ' ', 0);
+ string bibstyle = token(argument, ' ', 1);
+ if (bibstyle.empty())
+ bibstyle = "plain";
+
+ InsetCommandParams p( "BibTeX", db, bibstyle );
+ InsetBibtex * inset = new InsetBibtex(p);
+
+ if (insertInset(inset)) {
+ if (argument.empty())
+ inset->edit(bv_, 0, 0, 0);
+ } else
+ delete inset;
+ }
+ break;
+
+ // BibTeX data bases
+ case LFUN_BIBDB_ADD:
+ {
+ InsetBibtex * inset =
+ static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
+ if (inset) {
+ inset->addDatabase(argument);
+ }
+ }
+ break;
+
+ case LFUN_BIBDB_DEL:
+ {
+ InsetBibtex * inset =
+ static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
+ if (inset) {
+ inset->delDatabase(argument);
+ }
+ }
+ break;
+
+ case LFUN_BIBTEX_STYLE:
+ {
+ InsetBibtex * inset =
+ static_cast<InsetBibtex*>(getInsetByCode(Inset::BIBTEX_CODE));
+ if (inset) {
+ inset->setOptions(argument);
+ }
+ }
+ break;
+
+ case LFUN_INDEX_CREATE:
+ {
+ InsetCommandParams p( "index" );
+
+ if (argument.empty()) {
+ // Get the word immediately preceding the cursor
+ Paragraph::size_type curpos =
+ bv_->getLyXText()->cursor.pos() - 1;
+
+ string curstring;
+ if (curpos >= 0 )
+ curstring = bv_->getLyXText()
+ ->cursor.par()->getWord(curpos);
+
+ p.setContents( curstring );
+ } else {
+ p.setContents( argument );
+ }
+
+ owner_->getDialogs()->createIndex( p.getAsString() );
+ }
+ break;
+
+ case LFUN_INDEX_INSERT:
+ {
+ InsetCommandParams p;
+ p.setFromString(argument);
+ InsetIndex * inset = new InsetIndex(p);
+
+ if (!insertInset(inset))
+ delete inset;
+ else
+ updateInset(inset, true);
+ }
+ break;
+
+ case LFUN_INDEX_INSERT_LAST:
+ {
+ // Get word immediately preceding the cursor
+ Paragraph::size_type curpos =
+ bv_->getLyXText()->cursor.pos() - 1;
+ // Can't do that at the beginning of a paragraph
+ if (curpos < 0) break;
+
+ string const curstring(bv_->getLyXText()
+ ->cursor.par()->getWord(curpos));
+
+ InsetCommandParams p("index", curstring);
+ InsetIndex * inset = new InsetIndex(p);
+
+ if (!insertInset(inset))
+ delete inset;
+ else
+ updateInset(inset, true);
+ }
+ break;
+
+ case LFUN_INDEX_PRINT:
+ {
+ InsetCommandParams p("printindex");
+ Inset * inset = new InsetPrintIndex(p);
+ if (!insertInset(inset, "Standard"))
+ delete inset;
+ }
+ break;
+
+ case LFUN_PARENTINSERT:
+ {
+ lyxerr << "arg " << argument << endl;
+ InsetCommandParams p( "lyxparent", argument );
+ Inset * inset = new InsetParent(p, *buffer_);
+ if (!insertInset(inset, "Standard"))
+ delete inset;
+ }
+
+ break;
+
+ case LFUN_CHILD_INSERT:
+ {
+ InsetInclude::Params p;
+ p.cparams.setFromString(argument);
+ p.masterFilename_ = buffer_->fileName();
+
+ InsetInclude * inset = new InsetInclude(p);
+ if (!insertInset(inset))
+ delete inset;
+ else {
+ updateInset(inset, true);
+ bv_->owner()->getDialogs()->showInclude(inset);
+ }
+ }
+ break;
+
+ case LFUN_FLOAT_LIST:
+ {
+ // We should check the argument for validity. (Lgb)
+ Inset * inset = new InsetFloatList(argument);
+ if (!insertInset(inset, "Standard"))
+ delete inset;
+ }
+ break;
+
+ case LFUN_INSERT_NOTE:
+ insertNote();
+ break;
+
+ case LFUN_SELFINSERT:
+ {
+ if (argument.empty()) break;
+
+ /* Automatically delete the currently selected
+ * text and replace it with what is being
+ * typed in now. Depends on lyxrc settings
+ * "auto_region_delete", which defaults to
+ * true (on). */
+
+ LyXText * lt = bv_->getLyXText();
+
+ if (lyxrc.auto_region_delete) {
+ if (lt->selection.set()) {
+ lt->cutSelection(bv_, false);
+ bv_->update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+ }
+
+ bv_->beforeChange(lt);
+ LyXFont const old_font(lt->real_current_font);
+
+ string::const_iterator cit = argument.begin();
+ string::const_iterator end = argument.end();
+ for (; cit != end; ++cit) {
+ if (greek_kb_flag) {
+ if (!math_insert_greek(bv_, *cit))
+ owner_->getIntl()->getTrans().TranslateAndInsert(*cit, lt);
+ } else
+ owner_->getIntl()->getTrans().TranslateAndInsert(*cit, lt);
+ }
+
+ bv_->update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+
+ lt->selection.cursor = lt->cursor;
+ moveCursorUpdate(false);
+
+ // real_current_font.number can change so we need to
+ // update the minibuffer
+ if (old_font != lt->real_current_font)
+ owner_->showState();
+ //return string();
+ }
+ break;
+
+ case LFUN_DATE_INSERT: // jdblair: date-insert cmd
+ {
+ time_t now_time_t = time(NULL);
+ struct tm * now_tm = localtime(&now_time_t);
+ setlocale(LC_TIME, "");
+ string arg;
+ if (!argument.empty())
+ arg = argument;
+ else
+ arg = lyxrc.date_insert_format;
+ char datetmp[32];
+ int const datetmp_len =
+ ::strftime(datetmp, 32, arg.c_str(), now_tm);
+
+ LyXText * lt = bv_->getLyXText();
+
+ for (int i = 0; i < datetmp_len; i++) {
+ lt->insertChar(bv_, datetmp[i]);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+
+ lt->selection.cursor = lt->cursor;
+ moveCursorUpdate(false);
+ }
+ break;
+
+ case LFUN_UNKNOWN_ACTION:
+ owner_->getLyXFunc()->setErrorMessage(N_("Unknown function!"));
+ break;
+
+ default:
+ return false;
+ } // end of switch
+
+ return true;
+}
+
+
+void BufferView::Pimpl::newline()
+{
+ if (available()) {
+ LyXText * lt = bv_->getLyXText();
+ hideCursor();
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR);
+ lt->insertChar(bv_, Paragraph::META_NEWLINE);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+}
+
+
+void BufferView::Pimpl::hfill()
+{
+ if (available()) {
+ LyXText * lt = bv_->getLyXText();
+ hideCursor();
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR);
+ lt->insertChar(bv_, Paragraph::META_HFILL);
+ update(lt,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ }
+}
+
+
+void BufferView::Pimpl::protectedBlank(LyXText * lt)
+{
+ if (available()) {
+ hideCursor();
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ InsetSpecialChar * new_inset =
+ new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR);
+ if (!insertInset(new_inset))
+ delete new_inset;
+ else
+ updateInset(new_inset, true);
+ }
+}
+
+
+void BufferView::Pimpl::menuSeparator()
+{
+ if (available()) {
+ LyXText * lt = bv_->getLyXText();
+
+ hideCursor();
+ update(lt, BufferView::SELECT|BufferView::FITCUR);
+ InsetSpecialChar * new_inset =
+ new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR);
+ insertInset(new_inset);
+ }
+}
+
+
+void BufferView::Pimpl::endOfSentenceDot()
+{
+ if (available()) {
+ hideCursor();
+ update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR);
+ InsetSpecialChar * new_inset =
+ new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE);
+ insertInset(new_inset);
+ }
+}
+
+
+void BufferView::Pimpl::ldots()
+{
+ if (available()) {
+ hideCursor();
+ update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR);
+ InsetSpecialChar * new_inset =
+ new InsetSpecialChar(InsetSpecialChar::LDOTS);
+ insertInset(new_inset);
+ }
+}
+
+
+void BufferView::Pimpl::hyphenationPoint()
+{
+ if (available()) {
+ hideCursor();
+ update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR);
+ InsetSpecialChar * new_inset =
+ new InsetSpecialChar(InsetSpecialChar::HYPHENATION);
+ insertInset(new_inset);
+ }
+}
+
+
+void BufferView::Pimpl::insertNote()
+{
+ InsetInfo * new_inset = new InsetInfo();
+ insertInset(new_inset);
+ new_inset->edit(bv_, 0, 0, 0);
+}
+
+
+// Open and lock an updatable inset
+bool BufferView::Pimpl::open_new_inset(UpdatableInset * new_inset, bool behind)
+{
+ LyXText * lt = bv_->getLyXText();
+
+ beforeChange(lt);
+ lt->finishUndo();
+ if (!insertInset(new_inset)) {
+ delete new_inset;
+ return false;
+ }
+ if (behind) {
+ LyXFont & font = lt->real_current_font;
+ new_inset->edit(bv_, new_inset->width(bv_, font), 0, 0);
+ } else
+ new_inset->edit(bv_, 0, 0, 0);
+ return true;
+}
+
+
+bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout)
+{
+ // if we are in a locking inset we should try to insert the
+ // inset there otherwise this is a illegal function now
+ if (bv_->theLockingInset()) {
+ if (bv_->theLockingInset()->insertInsetAllowed(inset))
+ return bv_->theLockingInset()->insertInset(bv_, inset);
+ return false;
+ }
+
+ // not quite sure if we want this...
+ bv_->text->setCursorParUndo(buffer_);
+ bv_->text->freezeUndo();
+
+ beforeChange(bv_->text);
+ if (!lout.empty()) {
+ update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
+ bv_->text->breakParagraph(bv_);
+ update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+
+ if (bv_->text->cursor.par()->size()) {
+ bv_->text->cursorLeft(bv_);
+
+ bv_->text->breakParagraph(bv_);
+ update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+
+ pair<bool, LyXTextClass::size_type> lres =
+ textclasslist.NumberOfLayout(buffer_->params
+ .textclass, lout);
+ LyXTextClass::size_type lay;
+ if (lres.first != false) {
+ // layout found
+ lay = lres.second;
+ } else {
+ // layout not fount using default "Standard" (0)
+ lay = 0;
+ }
+
+ bv_->text->setLayout(bv_, lay);
+
+ bv_->text->setParagraph(bv_, 0, 0,
+ 0, 0,
+ VSpace(VSpace::NONE), VSpace(VSpace::NONE),
+ LYX_ALIGN_LAYOUT,
+ string(),
+ 0);
+ update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+#ifndef NO_LATEX
+ bv_->text->current_font.setLatex(LyXFont::OFF);
+#endif
+ }
+
+ bv_->text->insertInset(bv_, inset);
+ update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+
+ bv_->text->unFreezeUndo();
+ return true;
+}
+
+
+void BufferView::Pimpl::updateInset(Inset * inset, bool mark_dirty)
+{
+ if (!inset)
+ return;
+
+ // first check for locking insets
+ if (bv_->theLockingInset()) {
+ if (bv_->theLockingInset() == inset) {
+ if (bv_->text->updateInset(bv_, inset)) {
+ update();
+ if (mark_dirty) {
+ buffer_->markDirty();
+ }
+ updateScrollbar();
+ return;
+ }
+ } else if (bv_->theLockingInset()->updateInsetInInset(bv_, inset)) {
+ if (bv_->text->updateInset(bv_,
+ bv_->theLockingInset())) {
+ update();
+ if (mark_dirty){
+ buffer_->markDirty();
+ }
+ updateScrollbar();
+ return;
+ }
+ }
+ }
+
+ // then check the current buffer
+ if (available()) {
+ hideCursor();
+ update(bv_->text, BufferView::UPDATE);
+ if (bv_->text->updateInset(bv_, inset)) {
+ if (mark_dirty) {
+ update(bv_->text,
+ BufferView::SELECT
+ | BufferView::FITCUR
+ | BufferView::CHANGE);
+ } else {
+ update(bv_->text, SELECT);
+ }
+ return;
+ }
+ }
+}
+
+
+void BufferView::Pimpl::gotoInset(vector<Inset::Code> const & codes,
+ bool same_content)
+{
+ if (!available()) return;
+
+ hideCursor();
+ beforeChange(bv_->text);
+ update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
+
+ string contents;
+ if (same_content &&
+ bv_->text->cursor.par()->getChar(bv_->text->cursor.pos()) == Paragraph::META_INSET) {
+ Inset const * inset = bv_->text->cursor.par()->getInset(bv_->text->cursor.pos());
+ if (find(codes.begin(), codes.end(), inset->lyxCode())
+ != codes.end())
+ contents =
+ static_cast<InsetCommand const *>(inset)->getContents();
+ }
+
+ if (!bv_->text->gotoNextInset(bv_, codes, contents)) {
+ if (bv_->text->cursor.pos()
+ || bv_->text->cursor.par() != bv_->text->firstParagraph()) {
+ LyXCursor tmp = bv_->text->cursor;
+ bv_->text->cursor.par(bv_->text->firstParagraph());
+ bv_->text->cursor.pos(0);
+ if (!bv_->text->gotoNextInset(bv_, codes, contents)) {
+ bv_->text->cursor = tmp;
+ bv_->owner()->message(_("No more insets"));
+ }
+ } else {
+ bv_->owner()->message(_("No more insets"));
+ }
+ }
+ update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
+ bv_->text->selection.cursor = bv_->text->cursor;
+}
+
+
+void BufferView::Pimpl::gotoInset(Inset::Code code, bool same_content)
+{
+ gotoInset(vector<Inset::Code>(1, code), same_content);
+}