return static_cast<BufferView::UpdateCodes>
(static_cast<int>(uc1) | static_cast<int>(uc2));
}
+
+bool BufferView::Dispatch(kb_action action, string const & argument)
+{
+ return pimpl_->Dispatch(action, argument);
+}
#include FORMS_H_LOCATION
#include "undo.h"
+#include "commandtags.h"
#include <boost/utility.hpp>
class LyXView;
void pasteClipboard(bool asPara);
///
void stuffClipboard(string const &) const;
+ ///
+ bool Dispatch(kb_action action, string const & argument);
private:
struct Pimpl;
///
#include "bufferview_funcs.h"
#include "TextCache.h"
#include "bufferlist.h"
-#include "insets/insetbib.h"
-#include "insets/insettext.h"
#include "lyx_gui_misc.h"
#include "lyxrc.h"
#include "intl.h"
#include "support/LAssert.h"
#include "frontends/Dialogs.h"
+#include "insets/insetbib.h"
+#include "insets/insettext.h"
+/// added for Dispatch functions
+#include "lyx_cb.h"
+#include "filedlg.h"
+#include "lyx_main.h"
+#include "FloatList.h"
+#include "support/filetools.h"
+#include "support/lyxfunctional.h"
+#include "insets/inseturl.h"
+#include "insets/insetlatexaccent.h"
+#include "insets/insettoc.h"
+#include "insets/insetref.h"
+#include "insets/insetparent.h"
+#include "insets/insetindex.h"
+#include "insets/insetinclude.h"
+#include "insets/insetcite.h"
+#include "insets/insetert.h"
+#include "insets/insetexternal.h"
+#include "insets/insetgraphics.h"
+#include "insets/insetfoot.h"
+#include "insets/insetmarginal.h"
+#include "insets/insetminipage.h"
+#include "insets/insetfloat.h"
+#include "insets/insetlist.h"
+#include "insets/insettabular.h"
+#include "insets/insettheorem.h"
+#include "insets/insetcaption.h"
+#include "mathed/formulamacro.h"
+extern LyXTextClass::size_type current_layout;
+extern void math_insert_symbol(BufferView *, string const &);
+extern bool math_insert_greek(BufferView *, char);
+extern int greek_kb_flag;
#ifdef SIGC_CXX_NAMESPACES
using SigC::slot;
LyXParagraph * par = 0;
LyXParagraph * selstartpar = 0;
LyXParagraph * selendpar = 0;
- UpdatableInset * the_locking_inset;
+ UpdatableInset * the_locking_inset = 0;
int pos = 0;
int selstartpos = 0;
{
workarea_->putClipboard(stuff);
}
+
+
+/*
+ * Dispatch functions for actions which can be valid for BufferView->text
+ * and/or InsetText->text!!!
+ */
+static LyXText * TEXT(BufferView * bv) { return bv->getLyXText(); }
+
+inline
+void BufferView::Pimpl::moveCursorUpdate(bool selecting)
+{
+ if (selecting || TEXT(bv_)->mark_set) {
+ TEXT(bv_)->SetSelection(bv_);
+ if (TEXT(bv_)->bv_owner)
+ bv_->toggleToggle();
+ }
+ update(TEXT(bv_), 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();
+ bv_->setState();
+}
+
+
+Inset * BufferView::Pimpl::getInsetByCode(Inset::Code code)
+{
+ LyXCursor cursor = TEXT(bv_)->cursor;
+ Buffer::inset_iterator it =
+ find_if(Buffer::inset_iterator(
+ cursor.par(), cursor.pos()),
+ buffer_->inset_iterator_end(),
+ 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;
+ LyXFileDlg fileDlg;
+
+ if (available()) {
+ string const trypath = owner_->buffer()->filepath;
+ // If directory is writeable, use this as default.
+ if (IsDirWriteable(trypath) == 1)
+ initpath = trypath;
+ }
+
+ // launches dialog
+ ProhibitInput(bv_);
+ fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
+ fileDlg.SetButton(1, _("Examples"),
+ AddPath(system_lyxdir, "examples"));
+ filename = fileDlg.Select(_("Select Document to Insert"),
+ initpath, "*.lyx");
+ AllowInput(bv_);
+
+ // check selected filename
+ if (filename.empty()) {
+ owner_->getMiniBuffer()->Set(_("Canceled."));
+ return;
+ }
+ }
+
+ // get absolute path of file and make sure the filename ends
+ // with .lyx
+ filename = MakeAbsPath(filename);
+ if (!IsLyXFilename(filename))
+ filename += ".lyx";
+
+ // Inserts document
+ owner_->getMiniBuffer()->Set(_("Inserting document"),
+ MakeDisplayPath(filename), "...");
+ bool const res = bv_->insertLyXFile(filename);
+ if (res) {
+ owner_->getMiniBuffer()->Set(_("Document"),
+ MakeDisplayPath(filename),
+ _("inserted."));
+ } else {
+ owner_->getMiniBuffer()->Set(_("Could not insert document"),
+ MakeDisplayPath(filename));
+ }
+}
+
+
+bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
+{
+ switch (action) {
+ // --- Misc -------------------------------------------
+ case LFUN_APPENDIX:
+ if (available()) {
+ TEXT(bv_)->toggleAppendix(bv_);
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+ break;
+
+ case LFUN_TOC_INSERT:
+ case LFUN_LOA_INSERT:
+ case LFUN_LOF_INSERT:
+ case LFUN_LOT_INSERT:
+ {
+ InsetCommandParams p;
+
+ if (action == LFUN_TOC_INSERT )
+ p.setCmdName( "tableofcontents" );
+ else if (action == LFUN_LOA_INSERT )
+ p.setCmdName( "listofalgorithms" );
+ else if (action == LFUN_LOF_INSERT )
+ p.setCmdName( "listoffigures" );
+ else
+ p.setCmdName( "listoftables" );
+
+ Inset * inset = new InsetTOC( p );
+ if (!bv_->insertInset( inset, "Standard", true ) )
+ 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 (!bv_->insertInset(new_inset)) {
+ delete new_inset;
+ } else {
+ // this is need because you don't use a inset->Edit()
+ bv_->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:
+ bv_->gotoInset(Inset::ERROR_CODE, false);
+ break;
+
+ case LFUN_GOTONOTE:
+ bv_->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);
+ bv_->gotoInset(tmp, true);
+ break;
+ }
+
+ case LFUN_HYPHENATION:
+ bv_->hyphenationPoint();
+ break;
+
+ case LFUN_LDOTS:
+ bv_->ldots();
+ break;
+
+ case LFUN_END_OF_SENTENCE:
+ bv_->endOfSentenceDot();
+ break;
+
+ case LFUN_MENU_SEPARATOR:
+ bv_->menuSeparator();
+ break;
+
+ case LFUN_HFILL:
+ bv_->hfill();
+ break;
+
+ case LFUN_DEPTH:
+ changeDepth(bv_, TEXT(bv_), 0);
+ break;
+
+ case LFUN_DEPTH_MIN:
+ changeDepth(bv_, TEXT(bv_), -1);
+ break;
+
+ case LFUN_DEPTH_PLUS:
+ changeDepth(bv_, TEXT(bv_), 1);
+ break;
+
+ case LFUN_FREE:
+ Free(bv_);
+ setState();
+ owner_->showState();
+ break;
+
+ case LFUN_TEX:
+ Tex(bv_);
+ setState();
+ owner_->showState();
+ break;
+
+ case LFUN_FILE_INSERT:
+ {
+ MenuInsertLyXFile(argument);
+ }
+ break;
+
+ case LFUN_FILE_INSERT_ASCII:
+ {
+ bool asPara = (argument == "paragraph");
+ InsertAsciiFile(bv_, string(), asPara);
+ }
+ break;
+
+ case LFUN_LAYOUT:
+ {
+ lyxerr.debug() << "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) {
+ hideCursor();
+ current_layout = layout.second;
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->SetLayout(bv_, layout.second);
+ owner_->setLayout(layout.second);
+ update(TEXT(bv_),
+ 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:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->ChangeWordCase(bv_, LyXText::text_uppercase);
+ if (TEXT(bv_)->inset_owner)
+ bv_->updateInset(TEXT(bv_)->inset_owner, true);
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ break;
+
+ case LFUN_LOWCASE_WORD:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->ChangeWordCase(bv_, LyXText::text_lowercase);
+ if (TEXT(bv_)->inset_owner)
+ bv_->updateInset(TEXT(bv_)->inset_owner, true);
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ break;
+
+ case LFUN_CAPITALIZE_WORD:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->ChangeWordCase(bv_,
+ LyXText::text_capitalization);
+ if (TEXT(bv_)->inset_owner)
+ bv_->updateInset(TEXT(bv_)->inset_owner, true);
+ update(TEXT(bv_), 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 (!bv_->insertInset(inset))
+ delete inset;
+ else
+ bv_->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:
+ {
+ bool is_rtl = TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params);
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ if (is_rtl)
+ TEXT(bv_)->CursorLeft(bv_, false);
+ if (TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->Last()
+ && TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos())
+ == LyXParagraph::META_INSET
+ && TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())
+ && TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE){
+ Inset * tmpinset = TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos());
+ owner_->getLyXFunc()->setMessage(tmpinset->EditMessage());
+ int y = 0;
+ if (is_rtl) {
+ LyXFont font =
+ TEXT(bv_)->GetFont(buffer_,
+ TEXT(bv_)->cursor.par(),
+ TEXT(bv_)->cursor.pos());
+ y = tmpinset->descent(bv_,font);
+ }
+ tmpinset->Edit(bv_, 0, y, 0);
+ break;
+ }
+ if (!is_rtl)
+ TEXT(bv_)->CursorRight(bv_, false);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_LEFT:
+ {
+ // This is soooo ugly. Isn`t it possible to make
+ // it simpler? (Lgb)
+ bool is_rtl = TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params);
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ LyXCursor cur = TEXT(bv_)->cursor;
+ if (!is_rtl)
+ TEXT(bv_)->CursorLeft(bv_, false);
+ if ((is_rtl || cur != TEXT(bv_)->cursor) && // only if really moved!
+ TEXT(bv_)->cursor.pos() < TEXT(bv_)->cursor.par()->Last() &&
+ (TEXT(bv_)->cursor.par()->GetChar(TEXT(bv_)->cursor.pos()) ==
+ LyXParagraph::META_INSET) &&
+ TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos()) &&
+ (TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos())->Editable()
+ == Inset::HIGHLY_EDITABLE))
+ {
+ Inset * tmpinset = TEXT(bv_)->cursor.par()->GetInset(TEXT(bv_)->cursor.pos());
+ owner_->getLyXFunc()->setMessage(tmpinset->EditMessage());
+ LyXFont font = TEXT(bv_)->GetFont(buffer_,
+ TEXT(bv_)->cursor.par(),
+ TEXT(bv_)->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)
+ TEXT(bv_)->CursorRight(bv_, false);
+
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_UP:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::UPDATE);
+ TEXT(bv_)->CursorUp(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_DOWN:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::UPDATE);
+ TEXT(bv_)->CursorDown(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_UP_PARAGRAPH:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::UPDATE);
+ TEXT(bv_)->CursorUpParagraph(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_DOWN_PARAGRAPH:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::UPDATE);
+ TEXT(bv_)->CursorDownParagraph(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_PRIOR:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::UPDATE);
+ cursorPrevious(TEXT(bv_));
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_NEXT:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::UPDATE);
+ cursorNext(TEXT(bv_));
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_HOME:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorHome(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_END:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorEnd(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_SHIFT_TAB:
+ case LFUN_TAB:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorTab(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_WORDRIGHT:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
+ TEXT(bv_)->CursorLeftOneWord(bv_);
+ else
+ TEXT(bv_)->CursorRightOneWord(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_WORDLEFT:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
+ TEXT(bv_)->CursorRightOneWord(bv_);
+ else
+ TEXT(bv_)->CursorLeftOneWord(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_BEGINNINGBUF:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorTop(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ case LFUN_ENDBUF:
+ if (!TEXT(bv_)->mark_set)
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorBottom(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+
+ /* cursor selection ---------------------------- */
+ case LFUN_RIGHTSEL:
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
+ TEXT(bv_)->CursorLeft(bv_);
+ else
+ TEXT(bv_)->CursorRight(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_LEFTSEL:
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
+ TEXT(bv_)->CursorRight(bv_);
+ else
+ TEXT(bv_)->CursorLeft(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_UPSEL:
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorUp(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_DOWNSEL:
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorDown(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_UP_PARAGRAPHSEL:
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorUpParagraph(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_DOWN_PARAGRAPHSEL:
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorDownParagraph(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_PRIORSEL:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ cursorPrevious(TEXT(bv_));
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_NEXTSEL:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ cursorNext(TEXT(bv_));
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_HOMESEL:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorHome(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_ENDSEL:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorEnd(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_WORDRIGHTSEL:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
+ TEXT(bv_)->CursorLeftOneWord(bv_);
+ else
+ TEXT(bv_)->CursorRightOneWord(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_WORDLEFTSEL:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ if (TEXT(bv_)->cursor.par()->isRightToLeftPar(buffer_->params))
+ TEXT(bv_)->CursorRightOneWord(bv_);
+ else
+ TEXT(bv_)->CursorLeftOneWord(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_BEGINNINGBUFSEL:
+ if (TEXT(bv_)->inset_owner)
+ break;
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorTop(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ case LFUN_ENDBUFSEL:
+ if (TEXT(bv_)->inset_owner)
+ break;
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->CursorBottom(bv_);
+ TEXT(bv_)->FinishUndo();
+ moveCursorUpdate(true);
+ owner_->showState();
+ break;
+
+ // --- text changing commands ------------------------
+ case LFUN_BREAKLINE:
+ beforeChange(TEXT(bv_));
+ TEXT(bv_)->InsertChar(bv_, LyXParagraph::META_NEWLINE);
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ moveCursorUpdate(false);
+ break;
+
+ case LFUN_PROTECTEDSPACE:
+ {
+ LyXLayout const & style =
+ textclasslist.Style(buffer_->params.textclass,
+ TEXT(bv_)->cursor.par()->GetLayout());
+
+ if (style.free_spacing) {
+ TEXT(bv_)->InsertChar(bv_, ' ');
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ } else {
+ bv_->protectedBlank(TEXT(bv_));
+ }
+ moveCursorUpdate(false);
+ }
+ break;
+
+ case LFUN_SETMARK:
+ if (TEXT(bv_)->mark_set) {
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ owner_->getLyXFunc()->setMessage(N_("Mark removed"));
+ } else {
+ beforeChange(TEXT(bv_));
+ TEXT(bv_)->mark_set = 1;
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ owner_->getLyXFunc()->setMessage(N_("Mark set"));
+ }
+ TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
+ break;
+
+ case LFUN_DELETE:
+ if (!TEXT(bv_)->selection) {
+ TEXT(bv_)->Delete(bv_);
+ TEXT(bv_)->sel_cursor =
+ TEXT(bv_)->cursor;
+ update(TEXT(bv_),
+ 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:
+ {
+ // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP.
+
+ LyXCursor cursor = TEXT(bv_)->cursor;
+
+ if (!TEXT(bv_)->selection) {
+ if (cursor.pos() == cursor.par()->Last()) {
+ TEXT(bv_)->CursorRight(bv_);
+ cursor = TEXT(bv_)->cursor;
+ if (cursor.pos() == 0
+ && !(cursor.par()->added_space_top
+ == VSpace (VSpace::NONE))) {
+ TEXT(bv_)->SetParagraph
+ (bv_,
+ cursor.par()->line_top,
+ cursor.par()->line_bottom,
+ cursor.par()->pagebreak_top,
+ cursor.par()->pagebreak_bottom,
+ VSpace(VSpace::NONE),
+ cursor.par()->added_space_bottom,
+ cursor.par()->align,
+ cursor.par()->labelwidthstring, 0);
+ TEXT(bv_)->CursorLeft(bv_);
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ } else {
+ TEXT(bv_)->CursorLeft(bv_);
+ TEXT(bv_)->Delete(bv_);
+ TEXT(bv_)->sel_cursor =
+ TEXT(bv_)->cursor;
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+ } else {
+ TEXT(bv_)->Delete(bv_);
+ TEXT(bv_)->sel_cursor =
+ TEXT(bv_)->cursor;
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+ } else {
+ bv_->cut();
+ }
+ }
+ break;
+
+ /* -------> Delete word forward. */
+ case LFUN_DELETE_WORD_FORWARD:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->DeleteWordForward(bv_);
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ /* -------> Delete word backward. */
+ case LFUN_DELETE_WORD_BACKWARD:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->DeleteWordBackward(bv_);
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ moveCursorUpdate(false);
+ owner_->showState();
+ break;
+
+ /* -------> Kill to end of line. */
+ case LFUN_DELETE_LINE_FORWARD:
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->DeleteLineForward(bv_);
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ moveCursorUpdate(false);
+ break;
+
+ /* -------> Set mark off. */
+ case LFUN_MARK_OFF:
+ beforeChange(TEXT(bv_));
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
+ owner_->getLyXFunc()->setMessage(N_("Mark off"));
+ break;
+
+ /* -------> Set mark on. */
+ case LFUN_MARK_ON:
+ beforeChange(TEXT(bv_));
+ TEXT(bv_)->mark_set = 1;
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR);
+ TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
+ owner_->getLyXFunc()->setMessage(N_("Mark on"));
+ break;
+
+ case LFUN_BACKSPACE:
+ {
+ if (!TEXT(bv_)->selection) {
+ if (owner_->getIntl()->getTrans().backspace()) {
+ TEXT(bv_)->Backspace(bv_);
+ TEXT(bv_)->sel_cursor =
+ TEXT(bv_)->cursor;
+ update(TEXT(bv_),
+ 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.
+
+ LyXCursor cursor = TEXT(bv_)->cursor;
+
+ if (!TEXT(bv_)->selection) {
+ if (cursor.pos() == 0
+ && !(cursor.par()->added_space_top
+ == VSpace (VSpace::NONE))) {
+ TEXT(bv_)->SetParagraph
+ (bv_,
+ cursor.par()->line_top,
+ cursor.par()->line_bottom,
+ cursor.par()->pagebreak_top,
+ cursor.par()->pagebreak_bottom,
+ VSpace(VSpace::NONE), cursor.par()->added_space_bottom,
+ cursor.par()->align,
+ cursor.par()->labelwidthstring, 0);
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ } else {
+ TEXT(bv_)->Backspace(bv_);
+ TEXT(bv_)->sel_cursor
+ = cursor;
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+ } else
+ bv_->cut();
+ }
+ break;
+
+ case LFUN_BREAKPARAGRAPH:
+ {
+ beforeChange(TEXT(bv_));
+ TEXT(bv_)->BreakParagraph(bv_, 0);
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
+ setState();
+ owner_->showState();
+ break;
+ }
+
+ case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
+ {
+ beforeChange(TEXT(bv_));
+ TEXT(bv_)->BreakParagraph(bv_, 1);
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ TEXT(bv_)->sel_cursor = TEXT(bv_)->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.
+
+ LyXCursor cursor = TEXT(bv_)->cursor;
+
+ beforeChange(TEXT(bv_));
+ if (cursor.pos() == 0) {
+ if (cursor.par()->added_space_top == VSpace(VSpace::NONE)) {
+ TEXT(bv_)->SetParagraph
+ (bv_,
+ cursor.par()->line_top,
+ cursor.par()->line_bottom,
+ cursor.par()->pagebreak_top,
+ cursor.par()->pagebreak_bottom,
+ VSpace(VSpace::DEFSKIP), cursor.par()->added_space_bottom,
+ cursor.par()->align,
+ cursor.par()->labelwidthstring, 1);
+ //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+ }
+ else {
+ TEXT(bv_)->BreakParagraph(bv_, 0);
+ //update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ TEXT(bv_)->sel_cursor = cursor;
+ setState();
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_PARAGRAPH_SPACING:
+ {
+ LyXParagraph * par = TEXT(bv_)->cursor.par();
+ Spacing::Space cur_spacing = par->spacing.getSpace();
+ float cur_value = 1.0;
+ if (cur_spacing == Spacing::Other) {
+ cur_value = par->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->spacing.set(new_spacing, new_value);
+ TEXT(bv_)->RedoParagraph(bv_);
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+ }
+ break;
+
+ case LFUN_QUOTE:
+ beforeChange(TEXT(bv_));
+ TEXT(bv_)->InsertChar(bv_, '\"'); // This " matches the single quote in the code
+ update(TEXT(bv_), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ moveCursorUpdate(false);
+ 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 (!bv_->insertInset(inset))
+ delete inset;
+ else
+ bv_->updateInset( inset, true );
+ }
+ break;
+
+ case LFUN_INSET_TEXT:
+ {
+ InsetText * new_inset = new InsetText;
+ if (bv_->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 (bv_->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 (bv_->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 (bv_->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 (bv_->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 (bv_->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 (bv_->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 (bv_->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 (bv_->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::footnoteframe);
+ if (bv_->insertInset(new_inset))
+ new_inset->Edit(bv_, 0, 0, 0);
+ else
+ delete new_inset;
+ }
+ }
+ break;
+
+ case LFUN_INSET_TABULAR:
+ {
+ int r = 2, c = 2;
+ if (!argument.empty())
+ ::sscanf(argument.c_str(),"%d%d", &r, &c);
+ InsetTabular * new_inset =
+ new InsetTabular(*buffer_, r, c);
+ bool rtl =
+ TEXT(bv_)->real_current_font.isRightToLeft();
+ if (!bv_->open_new_inset(new_inset, rtl))
+ delete new_inset;
+ }
+ break;
+
+ // --- lyxserver commands ----------------------------
+
+ case LFUN_CHARATCURSOR:
+ {
+ LyXParagraph::size_type pos = TEXT(bv_)->cursor.pos();
+ if (pos < TEXT(bv_)->cursor.par()->size())
+ owner_->getLyXFunc()->setMessage(
+ tostr(TEXT(bv_)->cursor.par()->GetChar(pos)));
+ else
+ owner_->getLyXFunc()->setMessage("EOF");
+ }
+ break;
+
+ case LFUN_GETXY:
+ owner_->getLyXFunc()->setMessage(tostr(TEXT(bv_)->cursor.x())
+ + ' '
+ + tostr(TEXT(bv_)->cursor.y()));
+ break;
+
+ case LFUN_SETXY:
+ {
+ int x;
+ int y;
+ ::sscanf(argument.c_str(), " %d %d", &x, &y);
+ TEXT(bv_)->SetCursorFromCoordinates(bv_, x, y);
+ }
+ break;
+
+ case LFUN_GETLAYOUT:
+ owner_->getLyXFunc()->setMessage(tostr(TEXT(bv_)->cursor.par()->layout));
+ break;
+
+ case LFUN_GETFONT:
+ {
+ LyXFont & font = TEXT(bv_)->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:
+ {
+ LyXFont & font = TEXT(bv_)->current_font;
+ if (font.latex() == LyXFont::ON)
+ owner_->getLyXFunc()->setMessage("L");
+ else
+ 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:
+ owner_->getLyXFunc()->handleKeyFunc(action);
+ break;
+
+ // --- insert characters ----------------------------------------
+
+ case LFUN_MATH_DELIM:
+ case LFUN_INSERT_MATRIX:
+ {
+ if (available()) {
+ if (bv_->open_new_inset(new InsetFormula(false)))
+ {
+ bv_->theLockingInset()
+ ->LocalDispatch(bv_, action, argument);
+ }
+ }
+ }
+ break;
+
+ case LFUN_INSERT_MATH:
+ {
+ math_insert_symbol(bv_, argument);
+ }
+ break;
+
+ case LFUN_MATH_DISPLAY:
+ {
+ if (available())
+ bv_->open_new_inset(new InsetFormula(true));
+ 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);
+ bv_->open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na));
+ }
+ }
+ }
+ break;
+
+ case LFUN_MATH_MODE: // Open or create a math inset
+ {
+ if (available())
+ bv_->open_new_inset(new InsetFormula);
+ owner_->getLyXFunc()->setMessage(N_("Math editor mode"));
+ }
+ break;
+
+ case LFUN_CITATION_INSERT:
+ {
+ InsetCommandParams p;
+ p.setFromString( argument );
+
+ InsetCitation * inset = new InsetCitation( p );
+ if (!bv_->insertInset(inset))
+ delete inset;
+ else
+ bv_->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 (bv_->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
+ LyXParagraph::size_type curpos =
+ TEXT(bv_)->cursor.pos() - 1;
+
+ string curstring;
+ if (curpos >= 0 )
+ curstring = TEXT(bv_)
+ ->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 (!bv_->insertInset(inset))
+ delete inset;
+ else
+ bv_->updateInset(inset, true);
+ }
+ break;
+
+ case LFUN_INDEX_INSERT_LAST:
+ {
+ // Get word immediately preceding the cursor
+ LyXParagraph::size_type curpos =
+ TEXT(bv_)->cursor.pos() - 1;
+ // Can't do that at the beginning of a paragraph
+ if (curpos < 0) break;
+
+ string const curstring(TEXT(bv_)
+ ->cursor.par()->GetWord(curpos));
+
+ InsetCommandParams p("index", curstring);
+ InsetIndex * inset = new InsetIndex(p);
+
+ if (!bv_->insertInset(inset))
+ delete inset;
+ else
+ bv_->updateInset(inset, true);
+ }
+ break;
+
+ case LFUN_INDEX_PRINT:
+ {
+ InsetCommandParams p("printindex");
+ Inset * inset = new InsetPrintIndex(p);
+ if (!bv_->insertInset(inset, "Standard", true))
+ delete inset;
+ }
+ break;
+
+ case LFUN_PARENTINSERT:
+ {
+ lyxerr << "arg " << argument << endl;
+ InsetCommandParams p( "lyxparent", argument );
+ Inset * inset = new InsetParent(p, *buffer_);
+ if (!bv_->insertInset(inset, "Standard", true))
+ delete inset;
+ }
+ break;
+
+ case LFUN_CHILD_INSERT:
+ {
+ InsetCommandParams p;
+ p.setFromString(argument);
+
+ InsetInclude * inset = new InsetInclude(p, *buffer_);
+ if (!bv_->insertInset(inset))
+ delete inset;
+ else
+ bv_->updateInset(inset, true);
+ }
+ break;
+
+ case LFUN_INSERT_NOTE:
+ bv_->insertNote();
+ break;
+
+ case LFUN_SELFINSERT:
+ {
+ LyXFont const old_font(TEXT(bv_)->real_current_font);
+ for (string::size_type i = 0; i < argument.length(); ++i) {
+ TEXT(bv_)->InsertChar(bv_, argument[i]);
+ // This needs to be in the loop, or else we
+ // won't break lines correctly. (Asger)
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+ TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
+ moveCursorUpdate(false);
+
+ // real_current_font.number can change so we need to
+ // update the minibuffer
+ if (old_font != TEXT(bv_)->real_current_font)
+ owner_->showState();
+ }
+ break;
+
+ case LFUN_DATE_INSERT: // jdblair: date-insert cmd
+ {
+ struct tm * now_tm;
+
+ time_t now_time_t = time(NULL);
+ 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);
+ for (int i = 0; i < datetmp_len; i++) {
+ TEXT(bv_)->InsertChar(bv_, datetmp[i]);
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+
+ TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
+ moveCursorUpdate(false);
+ }
+ break;
+
+ case LFUN_UNKNOWN_ACTION:
+ {
+ if (!buffer_) {
+ owner_->getLyXFunc()->setErrorMessage(N_("No document open"));
+ break;
+ }
+
+ if (buffer_->isReadonly()) {
+ owner_->getLyXFunc()->setErrorMessage(N_("Document is read only"));
+ break;
+ }
+ if (!argument.empty()) {
+ /* 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). */
+
+ if (lyxrc.auto_region_delete) {
+ if (TEXT(bv_)->selection){
+ TEXT(bv_)->CutSelection(bv_, false);
+ update(TEXT(bv_),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ }
+ }
+
+ beforeChange(TEXT(bv_));
+ LyXFont const old_font(TEXT(bv_)->real_current_font);
+ for (string::size_type i = 0;
+ i < argument.length(); ++i) {
+ if (greek_kb_flag) {
+ if (!math_insert_greek(bv_,
+ argument[i]))
+ owner_->getIntl()->getTrans().TranslateAndInsert(argument[i], TEXT(bv_));
+ } else
+ owner_->getIntl()->getTrans().TranslateAndInsert(argument[i], TEXT(bv_));
+ }
+
+ update(TEXT(bv_),BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+
+ TEXT(bv_)->sel_cursor = TEXT(bv_)->cursor;
+ moveCursorUpdate(false);
+
+ // real_current_font.number can change so we need to
+ // update the minibuffer
+ if (old_font != TEXT(bv_)->real_current_font)
+ owner_->showState();
+ } else {
+ // if we don't have an argument there was something
+ // strange going on so we just tell this to someone!
+ owner_->getLyXFunc()->setErrorMessage(N_("No argument givven"));
+ }
+ break;
+ }
+ default:
+ return false;
+ } // end of switch
+
+ return true;
+}
#include "BufferView.h"
#include "UpdateInset.h"
+#include "commandtags.h"
#include "frontends/Timeout.h"
#ifdef __GNUG__
///
void center();
///
+ bool Dispatch(kb_action action, string const & argument);
+ ///
BufferView * bv_;
///
LyXView * owner_;
: filename(f), par_id(id), par_pos(pos) {}
};
std::vector<Position> saved_positions;
+
+ void moveCursorUpdate(bool selecting);
+ /// Get next inset of this class from current cursor position
+ Inset * getInsetByCode(Inset::Code code);
+ void MenuInsertLyXFile(string const & filen);
};
#endif
+2001-02-23 Juergen Vigna <jug@sad.it>
+
+ * lyxfunc.C (Dispatch): removed the whole part of the switch statement
+ which works with LyXText and putted it inside BufferView. Here now we
+ only call for that part the BufferView::Dispatch() function.
+
+ * BufferView.C (Dispatch): added.
+
+ * BufferView_pimpl.C (Dispatch): added! Here are now all dispatch
+ functions which needs to use a LyXText over from LyXFunc.
+ (MenuInsertLyXFile): added
+ (getInsetByCode): added
+ (moveCursorUpdate): added
+ (static TEXT): added
+
2001-02-22 Juergen Vigna <jug@sad.it>
* BufferView_pimpl.C (update): call a status update to see if LyXText
+2001-02-23 Juergen Vigna <jug@sad.it>
+
+ * insettext.C (draw): some small repainting fixes.
+ (LocalDispatch): put the sel_cursor stuff after the insert of chars.
+
+ * inset.C (LocalDispatch): changed action to be a kb_action (as it
+ should be) and not an int.
+
+ * insettabular.C (LocalDispatch): ditto
+
+ * insettext.C (LocalDispatch): ditto
+
+ * insetcollapsable.C (LocalDispatch): ditto
+
+2001-02-22 Juergen Vigna <jug@sad.it>
+
+ * insettabular.C (LocalDispatch): return DISPATCHED if we cannot
+ DISPATCH it and we don't have a locking_inset.
+
2001-02-21 Baruch Even <baruch@ev-en.org>
* insetgraphics.[Ch]: Changed to use boost::shared_ptr<GraphicsCacheItem>
/// An updatable inset could handle lyx editing commands
UpdatableInset::RESULT
UpdatableInset::LocalDispatch(BufferView * bv,
- int action, string const & arg)
+ kb_action action, string const & arg)
{
if (!arg.empty() && (action==LFUN_SCROLL_INSET)) {
if (arg.find('.') != arg.npos) {
UpdatableInset::RESULT
-InsetCollapsable::LocalDispatch(BufferView * bv, int action,
+InsetCollapsable::LocalDispatch(BufferView * bv, kb_action action,
string const & arg)
{
UpdatableInset::RESULT result = inset->LocalDispatch(bv, action, arg);
///
void InsetKeyPress(XKeyEvent *);
///
- UpdatableInset::RESULT LocalDispatch(BufferView *, int, string const &);
+ UpdatableInset::RESULT LocalDispatch(BufferView *, kb_action,
+ string const &);
///
int Latex(Buffer const *, std::ostream &,
bool fragile, bool free_spc) const;
}
-UpdatableInset::RESULT InsetTabular::LocalDispatch(BufferView * bv, int action,
+UpdatableInset::RESULT InsetTabular::LocalDispatch(BufferView * bv,
+ kb_action action,
string const & arg)
{
// We need to save the value of the_locking_inset as the call to
///
void InsetKeyPress(XKeyEvent *);
///
- UpdatableInset::RESULT LocalDispatch(BufferView *, int, string const &);
+ UpdatableInset::RESULT LocalDispatch(BufferView *, kb_action,
+ string const &);
///
int Latex(Buffer const *, std::ostream &, bool, bool) const;
///
// no draw is necessary !!!
if ((drawFrame == LOCKED) && !locked && !par->size()) {
- if (!cleared && (need_update == CLEAR_FRAME)) {
+ if (!cleared && (need_update & CLEAR_FRAME)) {
pain.rectangle(top_x + 1, baseline - insetAscent + 1,
width(bv, f) - 1,
insetAscent + insetDescent - 1,
if (y_offset < 0)
y_offset = y;
TEXT(bv)->first = first;
- if (cleared || !locked || (need_update&FULL) || (need_update&INIT)) {
+ if (cleared) { // (need_update&FULL) || (need_update&INIT)
int yf = y_offset;
y = 0;
while ((row != 0) && (yf < ph)) {
yf += row->height();
row = row->next();
}
+ } else if (!locked) {
+ if (need_update & CURSOR) {
+ bv->screen()->ToggleSelection(TEXT(bv), bv, true, y_offset,int(x));
+ TEXT(bv)->ClearSelection(bv);
+ TEXT(bv)->sel_cursor = TEXT(bv)->cursor;
+ }
+ bv->screen()->Update(TEXT(bv), bv, y_offset, int(x));
} else {
locked = false;
if (need_update & SELECTION)
UpdatableInset::RESULT
InsetText::LocalDispatch(BufferView * bv,
- int action, string const & arg)
+ kb_action action, string const & arg)
{
no_selection = false;
UpdatableInset::RESULT
moveRightIntern(bv, false, false);
dispatched = true;
break;
+ default:
+ break;
}
the_locking_inset = 0;
if (dispatched)
}
}
TEXT(bv)->ClearSelection(bv);
- TEXT(bv)->sel_cursor = TEXT(bv)->cursor;
for (string::size_type i = 0; i < arg.length(); ++i) {
if (greek_kb_flag) {
if (!math_insert_greek(bv, arg[i])) {
}
}
}
+ TEXT(bv)->sel_cursor = TEXT(bv)->cursor;
UpdateLocal(bv, CURSOR_PAR, true);
result=DISPATCHED_NOUPDATE;
break;
break;
default:
- result = UNDISPATCHED;
+ if (!bv->Dispatch(action, arg))
+ result = UNDISPATCHED;
break;
}
///
void InsetKeyPress(XKeyEvent *);
///
- UpdatableInset::RESULT LocalDispatch(BufferView *, int, string const &);
+ UpdatableInset::RESULT LocalDispatch(BufferView *, kb_action, string const &);
///
int Latex(Buffer const *, std::ostream &,
bool fragile, bool free_spc) const;
#include "gettext.h"
#include "lyxfont.h"
#include "lyxlex.h"
+#include "commandtags.h"
class BufferView;
class Buffer;
bool /*lr*/ = false)
{ return false; }
/// An updatable inset could handle lyx editing commands
- virtual RESULT LocalDispatch(BufferView *, int, string const &);
+ virtual RESULT LocalDispatch(BufferView *, kb_action, string const &);
///
virtual bool isCursorVisible() const { return cursor_visible; }
///
}
+void LyXFunc::handleKeyFunc(kb_action action)
+{
+ char c = 0;
+
+ if (keyseq.length == -1 && keyseq.getiso() != 0)
+ c = keyseq.getiso();
+ owner->getIntl()->getTrans()
+ .deadkey(c, get_accent(action).accent, TEXT(false));
+ // Need to reset, in case the minibuffer calls these
+ // actions
+ keyseq.reset();
+ keyseq.length = 0;
+ // copied verbatim from do_accent_char
+ owner->view()->update(TEXT(false),
+ BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
+ TEXT(false)->sel_cursor = TEXT(false)->cursor;
+}
+
+
int LyXFunc::processKeySym(KeySym keysym, unsigned int state)
{
string argument;
owner->view()->showCursor();
}
break;
-
+
case LFUN_PREFIX:
{
if (owner->view()->available()) {
owner->view()->center();
break;
- case LFUN_APPENDIX:
- if (owner->view()->available()) {
- TEXT(false)->toggleAppendix(owner->view());
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
- break;
-
// --- Menus -----------------------------------------------
case LFUN_MENUNEW:
MenuNew(false);
break;
}
- case LFUN_TOC_INSERT:
- case LFUN_LOA_INSERT:
- case LFUN_LOF_INSERT:
- case LFUN_LOT_INSERT:
- {
- InsetCommandParams p;
-
- if (action == LFUN_TOC_INSERT )
- p.setCmdName( "tableofcontents" );
- else if (action == LFUN_LOA_INSERT )
- p.setCmdName( "listofalgorithms" );
- else if (action == LFUN_LOF_INSERT )
- p.setCmdName( "listoffigures" );
- else
- p.setCmdName( "listoftables" );
-
- Inset * inset = new InsetTOC( p );
- if (!owner->view()->insertInset( inset, "Standard", true ) )
- delete inset;
- break;
- }
-
case LFUN_DIALOG_TABULAR_INSERT:
owner->getDialogs()->showTabularCreate();
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_FIGURE:
Figure();
break;
- case LFUN_INSET_GRAPHICS:
- {
- Inset * new_inset = new InsetGraphics;
- if (!owner->view()->insertInset(new_inset)) {
- delete new_inset;
- } else {
- // this is need because you don't use a inset->Edit()
- owner->view()->updateInset(new_inset, true);
- new_inset->Edit(owner->view(), 0, 0, 0);
- }
- break;
- }
-
case LFUN_AUTOSAVE:
AutoSave(owner->view());
break;
}
break;
- case LFUN_PASTE:
- owner->view()->paste();
- owner->view()->setState();
- break;
-
- case LFUN_PASTESELECTION:
- {
- bool asPara = false;
- if (argument == "paragraph") asPara = true;
- owner->view()->pasteClipboard(asPara);
- }
- break;
-
- case LFUN_CUT:
- owner->view()->cut();
- break;
-
- case LFUN_COPY:
- owner->view()->copy();
- break;
-
- case LFUN_LAYOUT_COPY:
- owner->view()->copyEnvironment();
- break;
-
- case LFUN_LAYOUT_PASTE:
- owner->view()->pasteEnvironment();
- owner->view()->setState();
- break;
-
- case LFUN_GOTOERROR:
- owner->view()->gotoInset(Inset::ERROR_CODE, false);
- break;
-
case LFUN_REMOVEERRORS:
if (owner->view()->removeAutoInsets()) {
owner->view()->redraw();
}
break;
- case LFUN_GOTONOTE:
- owner->view()->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);
- owner->view()->gotoInset(tmp, true);
- break;
- }
-
#ifndef NEW_INSETS
case LFUN_OPENSTUFF:
owner->view()->openStuff();
owner->view()->buffer(bufferlist.getBuffer(argument));
break;
-
- case LFUN_FILE_INSERT:
- {
- MenuInsertLyXFile(argument);
- }
- break;
-
- case LFUN_FILE_INSERT_ASCII:
- {
- bool asPara = (argument == "paragraph");
- InsertAsciiFile(owner->view(), string(), asPara);
- }
- break;
-
case LFUN_FILE_NEW:
{
// servercmd: argument must be <file>:<template>
return string();
}
- case LFUN_LAYOUT:
- {
- lyxerr.debug() << "LFUN_LAYOUT: (arg) "
- << argument << endl;
-
- // Derive layout number from given argument (string)
- // and current buffer's textclass (number). */
- LyXTextClassList::ClassList::size_type tclass =
- owner->view()->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) {
- setErrorMessage(string(N_("Layout ")) + argument +
- N_(" not known"));
- break;
- }
-
- if (current_layout != layout.second) {
- owner->view()->hideCursor();
- current_layout = layout.second;
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->
- SetLayout(owner->view(), layout.second);
- owner->setLayout(layout.second);
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- owner->view()->setState();
- }
- }
- break;
-
case LFUN_LAYOUT_DOCUMENT:
owner->getDialogs()->showLayoutDocument();
break;
owner->getToolbar()->openLayoutList();
break;
- case LFUN_LANGUAGE:
- Lang(owner->view(), argument);
- owner->view()->setState();
- owner->showState();
- break;
-
- case LFUN_EMPH:
- Emph(owner->view());
- owner->showState();
- break;
-
- case LFUN_BOLD:
- Bold(owner->view());
- owner->showState();
- break;
-
- case LFUN_NOUN:
- Noun(owner->view());
- owner->showState();
- break;
-
- case LFUN_CODE:
- Code(owner->view());
- owner->showState();
- break;
-
- case LFUN_SANS:
- Sans(owner->view());
- owner->showState();
- break;
-
- case LFUN_ROMAN:
- Roman(owner->view());
- owner->showState();
- break;
-
- case LFUN_DEFAULT:
- StyleReset(owner->view());
- owner->showState();
- break;
-
- case LFUN_UNDERLINE:
- Underline(owner->view());
- owner->showState();
- break;
-
- case LFUN_FONT_SIZE:
- FontSize(owner->view(), argument);
- owner->showState();
- break;
-
- case LFUN_FONT_STATE:
- setMessage(CurrentState(owner->view()));
- break;
-
- case LFUN_UPCASE_WORD:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->ChangeWordCase(owner->view(), LyXText::text_uppercase);
- if (TEXT(false)->inset_owner)
- owner->view()->updateInset(TEXT(false)->inset_owner, true);
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- break;
-
- case LFUN_LOWCASE_WORD:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->ChangeWordCase(owner->view(), LyXText::text_lowercase);
- if (TEXT(false)->inset_owner)
- owner->view()->updateInset(TEXT(false)->inset_owner, true);
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- break;
-
- case LFUN_CAPITALIZE_WORD:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->ChangeWordCase(owner->view(),
- LyXText::text_capitalization);
- if (TEXT(false)->inset_owner)
- owner->view()->updateInset(TEXT(false)->inset_owner, true);
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- break;
-
- case LFUN_INSERT_LABEL:
- MenuInsertLabel(owner->view(), 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, *owner->buffer());
- if (!owner->view()->insertInset(inset))
- delete inset;
- else
- owner->view()->updateInset(inset, true);
- }
- break;
-
- case LFUN_BOOKMARK_SAVE:
- owner->view()->savePosition(strToUnsignedInt(argument));
- break;
-
- case LFUN_BOOKMARK_GOTO:
- owner->view()->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();
- owner->view()->savePosition(0);
- }
- }
-
- if (!label.empty()) {
- //owner->view()->savePosition(0);
- if (!owner->view()->gotoLabel(label))
- WriteAlert(_("Error"),
- _("Couldn't find this label"),
- _("in current document."));
- }
- }
- break;
-
case LFUN_MENU_OPEN_BY_NAME:
owner->getMenubar()->openByName(argument);
break; // RVDK_PATCH_5
ShowSpellChecker(owner->view());
break; // RVDK_PATCH_5
- // --- Cursor Movements -----------------------------
- case LFUN_RIGHT:
+ // --- lyxserver commands ----------------------------
+
+
+ case LFUN_GETNAME:
+ setMessage(owner->buffer()->fileName());
+ lyxerr.debug() << "FNAME["
+ << owner->buffer()->fileName()
+ << "] " << endl;
+ break;
+
+ case LFUN_NOTIFY:
{
- bool is_rtl = TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params);
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(), BufferView::SELECT|BufferView::FITCUR);
- if (is_rtl)
- TEXT()->CursorLeft(owner->view(), false);
- if (TEXT()->cursor.pos() < TEXT()->cursor.par()->Last()
- && TEXT()->cursor.par()->GetChar(TEXT()->cursor.pos())
- == LyXParagraph::META_INSET
- && TEXT()->cursor.par()->GetInset(TEXT()->cursor.pos())
- && TEXT()->cursor.par()->GetInset(TEXT()->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE){
- Inset * tmpinset = TEXT()->cursor.par()->GetInset(TEXT()->cursor.pos());
- setMessage(tmpinset->EditMessage());
- int y = 0;
- if (is_rtl) {
- LyXFont font =
- TEXT()->GetFont(owner->view()->buffer(),
- TEXT()->cursor.par(),
- TEXT()->cursor.pos());
- y = tmpinset->descent(owner->view(),font);
- }
- tmpinset->Edit(owner->view(), 0, y, 0);
- break;
- }
- if (!is_rtl)
- TEXT()->CursorRight(owner->view(), false);
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
+ string buf;
+ keyseq.print(buf);
+ dispatch_buffer = buf;
+ lyxserver->notifyClient(dispatch_buffer);
}
break;
-
- case LFUN_LEFT:
+
+ case LFUN_GOTOFILEROW:
{
- // This is soooo ugly. Isn`t it possible to make
- // it simpler? (Lgb)
- bool is_rtl = TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params);
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(), BufferView::SELECT|BufferView::FITCUR);
- LyXCursor cur = TEXT()->cursor;
- if (!is_rtl)
- TEXT()->CursorLeft(owner->view(), false);
- if ((is_rtl || cur != TEXT()->cursor) && // only if really moved!
- TEXT()->cursor.pos() < TEXT()->cursor.par()->Last() &&
- (TEXT()->cursor.par()->GetChar(TEXT()->cursor.pos()) ==
- LyXParagraph::META_INSET) &&
- TEXT()->cursor.par()->GetInset(TEXT()->cursor.pos()) &&
- (TEXT()->cursor.par()->GetInset(TEXT()->cursor.pos())->Editable()
- == Inset::HIGHLY_EDITABLE))
- {
- Inset * tmpinset = TEXT()->cursor.par()->GetInset(TEXT()->cursor.pos());
- setMessage(tmpinset->EditMessage());
- LyXFont font = TEXT()->GetFont(owner->view()->buffer(),
- TEXT()->cursor.par(),
- TEXT()->cursor.pos());
- int y = is_rtl ? 0
- : tmpinset->descent(owner->view(),font);
- tmpinset->Edit(owner->view(),
- tmpinset->x() +
- tmpinset->width(owner->view(),font),
- y, 0);
- break;
- }
- if (is_rtl)
- TEXT()->CursorRight(owner->view(), false);
+ char file_name[100];
+ int row;
+ ::sscanf(argument.c_str(), " %s %d", file_name, &row);
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
+ // Must replace extension of the file to be .lyx and get full path
+ string s = ChangeExtension(string(file_name), ".lyx");
+
+ // Either change buffer or load the file
+ if (bufferlist.exists(s))
+ owner->view()->buffer(bufferlist.getBuffer(s));
+ else
+ owner->view()->buffer(bufferlist.loadLyXFile(s));
+
+ // Set the cursor
+ owner->view()->setCursorFromRow(row);
+
+ // Recenter screen
+ owner->view()->center();
}
break;
-
- case LFUN_UP:
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(), BufferView::UPDATE);
- TEXT()->CursorUp(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
- break;
-
- case LFUN_DOWN:
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(), BufferView::UPDATE);
- TEXT()->CursorDown(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
- break;
- case LFUN_UP_PARAGRAPH:
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(), BufferView::UPDATE);
- TEXT()->CursorUpParagraph(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
- break;
-
- case LFUN_DOWN_PARAGRAPH:
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(), BufferView::UPDATE);
- TEXT()->CursorDownParagraph(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
- break;
-
- case LFUN_PRIOR:
- if (!TEXT(false)->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(), BufferView::UPDATE);
- owner->view()->cursorPrevious(TEXT(false));
- TEXT()->FinishUndo();
- moveCursorUpdate(false, false);
- owner->showState();
- break;
-
- case LFUN_NEXT:
- if (!TEXT(false)->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(), BufferView::UPDATE);
- owner->view()->cursorNext(TEXT(false));
- TEXT()->FinishUndo();
- moveCursorUpdate(false, false);
- owner->showState();
- break;
-
- case LFUN_HOME:
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(), BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorHome(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
- break;
-
- case LFUN_END:
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorEnd(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
- break;
-
- case LFUN_SHIFT_TAB:
- case LFUN_TAB:
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorTab(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
- break;
-
- case LFUN_WORDRIGHT:
- if (!TEXT(false)->mark_set)
- owner->view()->beforeChange(TEXT(false));
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- if (TEXT(false)->cursor.par()->isRightToLeftPar(owner->buffer()->params))
- TEXT(false)->CursorLeftOneWord(owner->view());
- else
- TEXT(false)->CursorRightOneWord(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(false, false);
- owner->showState();
- break;
-
- case LFUN_WORDLEFT:
- if (!TEXT(false)->mark_set)
- owner->view()->beforeChange(TEXT(false));
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- if (TEXT(false)->cursor.par()->isRightToLeftPar(owner->buffer()->params))
- TEXT(false)->CursorRightOneWord(owner->view());
- else
- TEXT(false)->CursorLeftOneWord(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(false, false);
- owner->showState();
- break;
-
- case LFUN_BEGINNINGBUF:
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorTop(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
- break;
-
- case LFUN_ENDBUF:
- if (!TEXT()->mark_set)
- owner->view()->beforeChange(TEXT());
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorBottom(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, false);
- owner->showState();
- break;
+ case LFUN_GOTO_PARAGRAPH:
+ {
+ istringstream istr(argument.c_str());
-
- /* cursor selection ---------------------------- */
- case LFUN_RIGHTSEL:
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- if (TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params))
- TEXT()->CursorLeft(owner->view());
- else
- TEXT()->CursorRight(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, true);
- owner->showState();
- break;
-
- case LFUN_LEFTSEL:
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- if (TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params))
- TEXT()->CursorRight(owner->view());
- else
- TEXT()->CursorLeft(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, true);
- owner->showState();
- break;
-
- case LFUN_UPSEL:
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorUp(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, true);
- owner->showState();
- break;
-
- case LFUN_DOWNSEL:
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorDown(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, true);
- owner->showState();
- break;
+ int id;
+ istr >> id;
+ LyXParagraph * par = TEXT()->GetParFromID(id);
- case LFUN_UP_PARAGRAPHSEL:
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorUpParagraph(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, true);
- owner->showState();
- break;
-
- case LFUN_DOWN_PARAGRAPHSEL:
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorDownParagraph(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, true);
- owner->showState();
- break;
-
- case LFUN_PRIORSEL:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- owner->view()->cursorPrevious(TEXT(false));
- TEXT()->FinishUndo();
- moveCursorUpdate(false, true);
- owner->showState();
- break;
-
- case LFUN_NEXTSEL:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- owner->view()->cursorNext(TEXT(false));
- TEXT()->FinishUndo();
- moveCursorUpdate(false, true);
- owner->showState();
- break;
-
- case LFUN_HOMESEL:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->CursorHome(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(false, true);
- owner->showState();
- break;
-
- case LFUN_ENDSEL:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->CursorEnd(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(false, true);
- owner->showState();
- break;
-
- case LFUN_WORDRIGHTSEL:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- if (TEXT(false)->cursor.par()->isRightToLeftPar(owner->buffer()->params))
- TEXT(false)->CursorLeftOneWord(owner->view());
- else
- TEXT(false)->CursorRightOneWord(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(false, true);
- owner->showState();
- break;
-
- case LFUN_WORDLEFTSEL:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- if (TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params))
- TEXT(false)->CursorRightOneWord(owner->view());
- else
- TEXT(false)->CursorLeftOneWord(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(false, true);
- owner->showState();
- break;
-
- case LFUN_BEGINNINGBUFSEL:
- if (TEXT(false)->inset_owner)
- break;
- owner->view()->update(TEXT(), BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorTop(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, true);
- owner->showState();
- break;
-
- case LFUN_ENDBUFSEL:
- if (TEXT(false)->inset_owner)
- break;
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR);
- TEXT()->CursorBottom(owner->view());
- TEXT()->FinishUndo();
- moveCursorUpdate(true, true);
- owner->showState();
- break;
-
- // --- text changing commands ------------------------
- case LFUN_BREAKLINE:
- owner->view()->beforeChange(TEXT());
- TEXT()->InsertChar(owner->view(), LyXParagraph::META_NEWLINE);
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- moveCursorUpdate(true, false);
- break;
-
- case LFUN_PROTECTEDSPACE:
- {
- LyXLayout const & style =
- textclasslist.Style(owner->view()->buffer()->params.textclass,
- TEXT(false)->cursor.par()->GetLayout());
-
- if (style.free_spacing) {
- TEXT(false)->InsertChar(owner->view(), ' ');
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- } else {
- owner->view()->protectedBlank(TEXT(false));
- }
- moveCursorUpdate(false, false);
- }
- break;
-
- case LFUN_SETMARK:
- if (TEXT(false)->mark_set) {
- owner->view()->beforeChange(TEXT(false));
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- setMessage(N_("Mark removed"));
- } else {
- owner->view()->beforeChange(TEXT(false));
- TEXT(false)->mark_set = 1;
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- setMessage(N_("Mark set"));
- }
- TEXT(false)->sel_cursor = TEXT(false)->cursor;
- break;
-
- case LFUN_DELETE:
- if (!TEXT()->selection) {
- TEXT()->Delete(owner->view());
- TEXT()->sel_cursor =
- TEXT()->cursor;
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- // It is possible to make it a lot faster still
- // just comment out the line below...
- owner->view()->showCursor();
- } else {
- owner->view()->cut();
- }
- moveCursorUpdate(true, false);
- owner->showState();
- owner->view()->setState();
- break;
-
- case LFUN_DELETE_SKIP:
- {
- // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP.
-
- LyXCursor cursor = TEXT()->cursor;
-
- if (!TEXT()->selection) {
- if (cursor.pos() == cursor.par()->Last()) {
- TEXT()->CursorRight(owner->view());
- cursor = TEXT()->cursor;
- if (cursor.pos() == 0
- && !(cursor.par()->added_space_top
- == VSpace (VSpace::NONE))) {
- TEXT()->SetParagraph
- (owner->view(),
- cursor.par()->line_top,
- cursor.par()->line_bottom,
- cursor.par()->pagebreak_top,
- cursor.par()->pagebreak_bottom,
- VSpace(VSpace::NONE),
- cursor.par()->added_space_bottom,
- cursor.par()->align,
- cursor.par()->labelwidthstring, 0);
- TEXT()->CursorLeft(owner->view());
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- } else {
- TEXT()->CursorLeft(owner->view());
- TEXT()->Delete(owner->view());
- TEXT()->sel_cursor =
- TEXT()->cursor;
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
- } else {
- TEXT()->Delete(owner->view());
- TEXT()->sel_cursor =
- TEXT()->cursor;
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
- } else {
- owner->view()->cut();
- }
- }
- break;
-
- /* -------> Delete word forward. */
- case LFUN_DELETE_WORD_FORWARD:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->DeleteWordForward(owner->view());
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- moveCursorUpdate(false, false);
- owner->showState();
- break;
-
- /* -------> Delete word backward. */
- case LFUN_DELETE_WORD_BACKWARD:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->DeleteWordBackward(owner->view());
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- moveCursorUpdate(false, false);
- owner->showState();
- break;
-
- /* -------> Kill to end of line. */
- case LFUN_DELETE_LINE_FORWARD:
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->DeleteLineForward(owner->view());
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- moveCursorUpdate(false, false);
- break;
-
- /* -------> Set mark off. */
- case LFUN_MARK_OFF:
- owner->view()->beforeChange(TEXT(false));
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->sel_cursor = TEXT(false)->cursor;
- setMessage(N_("Mark off"));
- break;
-
- /* -------> Set mark on. */
- case LFUN_MARK_ON:
- owner->view()->beforeChange(TEXT(false));
- TEXT(false)->mark_set = 1;
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR);
- TEXT(false)->sel_cursor = TEXT(false)->cursor;
- setMessage(N_("Mark on"));
- break;
-
- case LFUN_BACKSPACE:
- {
- if (!TEXT()->selection) {
- if (owner->getIntl()->getTrans().backspace()) {
- TEXT()->Backspace(owner->view());
- TEXT()->sel_cursor =
- TEXT()->cursor;
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- // It is possible to make it a lot faster still
- // just comment out the line below...
- owner->view()->showCursor();
- }
- } else {
- owner->view()->cut();
- }
- owner->showState();
- owner->view()->setState();
- }
- break;
-
- case LFUN_BACKSPACE_SKIP:
- {
- // Reverse the effect of LFUN_BREAKPARAGRAPH_SKIP.
-
- LyXCursor cursor = TEXT()->cursor;
-
- if (!TEXT()->selection) {
- if (cursor.pos() == 0
- && !(cursor.par()->added_space_top
- == VSpace (VSpace::NONE))) {
- TEXT()->SetParagraph
- (owner->view(),
- cursor.par()->line_top,
- cursor.par()->line_bottom,
- cursor.par()->pagebreak_top,
- cursor.par()->pagebreak_bottom,
- VSpace(VSpace::NONE), cursor.par()->added_space_bottom,
- cursor.par()->align,
- cursor.par()->labelwidthstring, 0);
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- } else {
- TEXT()->Backspace(owner->view());
- TEXT()->sel_cursor
- = cursor;
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
- } else
- owner->view()->cut();
- }
- break;
-
- case LFUN_BREAKPARAGRAPH:
- {
- owner->view()->beforeChange(TEXT());
- TEXT()->BreakParagraph(owner->view(), 0);
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- TEXT()->sel_cursor =
- TEXT()->cursor;
- owner->view()->setState();
- owner->showState();
- break;
- }
-
- case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
- {
- owner->view()->beforeChange(TEXT());
- TEXT()->BreakParagraph(owner->view(), 1);
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- TEXT()->sel_cursor =
- TEXT()->cursor;
- owner->view()->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.
-
- LyXCursor cursor = TEXT()->cursor;
-
- owner->view()->beforeChange(TEXT());
- if (cursor.pos() == 0) {
- if (cursor.par()->added_space_top == VSpace(VSpace::NONE)) {
- TEXT()->SetParagraph
- (owner->view(),
- cursor.par()->line_top,
- cursor.par()->line_bottom,
- cursor.par()->pagebreak_top,
- cursor.par()->pagebreak_bottom,
- VSpace(VSpace::DEFSKIP), cursor.par()->added_space_bottom,
- cursor.par()->align,
- cursor.par()->labelwidthstring, 1);
- //owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
- }
- else {
- TEXT()->BreakParagraph(owner->view(), 0);
- //owner->view()->update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
-
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- TEXT()->sel_cursor = cursor;
- owner->view()->setState();
- owner->showState();
- }
- break;
-
- case LFUN_PARAGRAPH_SPACING:
- {
- LyXParagraph * par = TEXT()->cursor.par();
- Spacing::Space cur_spacing = par->spacing.getSpace();
- float cur_value = 1.0;
- if (cur_spacing == Spacing::Other) {
- cur_value = par->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->spacing.set(new_spacing, new_value);
- TEXT()->RedoParagraph(owner->view());
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
- }
- break;
-
- case LFUN_QUOTE:
- owner->view()->beforeChange(TEXT(false));
- TEXT(false)->InsertChar(owner->view(), '\"'); // This " matches the single quote in the code
- owner->view()->update(TEXT(false), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- moveCursorUpdate(false, false);
- 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 (!owner->view()->insertInset(inset))
- delete inset;
- else
- owner->view()->updateInset( inset, true );
- }
- break;
-
- case LFUN_INSET_TEXT:
- {
- InsetText * new_inset = new InsetText;
- if (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 0, 0, 0);
- else
- delete new_inset;
- }
- break;
-
- case LFUN_INSET_ERT:
- {
- InsetERT * new_inset = new InsetERT;
- if (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 0, 0, 0);
- else
- delete new_inset;
- }
- break;
-
- case LFUN_INSET_EXTERNAL:
- {
- InsetExternal * new_inset = new InsetExternal;
- if (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 0, 0, 0);
- else
- delete new_inset;
- }
- break;
-
- case LFUN_INSET_FOOTNOTE:
- {
- InsetFoot * new_inset = new InsetFoot;
- if (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 0, 0, 0);
- else
- delete new_inset;
- }
- break;
-
- case LFUN_INSET_MARGINAL:
- {
- InsetMarginal * new_inset = new InsetMarginal;
- if (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 0, 0, 0);
- else
- delete new_inset;
- }
- break;
-
- case LFUN_INSET_MINIPAGE:
- {
- InsetMinipage * new_inset = new InsetMinipage;
- if (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 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 (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 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 (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 0, 0, 0);
- else
- delete new_inset;
- }
- break;
-
- case LFUN_INSET_THEOREM:
- {
- InsetTheorem * new_inset = new InsetTheorem;
- if (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 0, 0, 0);
- else
- delete new_inset;
- }
- break;
-
- case LFUN_INSET_CAPTION:
- {
- // Do we have a locking inset...
- if (owner->view()->theLockingInset()) {
- lyxerr << "Locking inset code: "
- << static_cast<int>(owner->view()->theLockingInset()->LyxCode());
- InsetCaption * new_inset = new InsetCaption;
- new_inset->setOwner(owner->view()->theLockingInset());
- new_inset->SetAutoBreakRows(true);
- new_inset->SetDrawFrame(0, InsetText::LOCKED);
- new_inset->SetFrameColor(0, LColor::footnoteframe);
- if (owner->view()->insertInset(new_inset))
- new_inset->Edit(owner->view(), 0, 0, 0);
- else
- delete new_inset;
- }
- }
- break;
-
- case LFUN_INSET_TABULAR:
- {
- int r = 2, c = 2;
- if (!argument.empty())
- ::sscanf(argument.c_str(),"%d%d", &r, &c);
- InsetTabular * new_inset =
- new InsetTabular(*owner->buffer(), r, c);
- bool rtl =
- TEXT(false)->real_current_font.isRightToLeft();
- if (!owner->view()->open_new_inset(new_inset, rtl))
- delete new_inset;
- }
- break;
-
- // --- lyxserver commands ----------------------------
-
- case LFUN_CHARATCURSOR:
- {
- LyXParagraph::size_type pos =
- TEXT()->cursor.pos();
- if (pos < TEXT()->cursor.par()->size())
- //dispatch_buffer = TEXT()->
- // cursor.par()->text[pos];
- dispatch_buffer =
- TEXT()->
- cursor.par()->GetChar(pos);
- else
- dispatch_buffer = "EOF";
- }
- break;
-
- case LFUN_GETXY:
- dispatch_buffer =
- tostr(TEXT()->cursor.x()) + ' '
- + tostr(TEXT()->cursor.y());
- break;
-
- case LFUN_SETXY:
- {
- int x;
- int y;
- ::sscanf(argument.c_str(), " %d %d", &x, &y);
- TEXT()->SetCursorFromCoordinates(owner->view(), x, y);
- }
- break;
-
- case LFUN_GETLAYOUT:
- dispatch_buffer =
- tostr(TEXT()->cursor.par()->layout);
- break;
-
- case LFUN_GETFONT:
- {
- LyXFont & font = TEXT()->current_font;
- if (font.shape() == LyXFont::ITALIC_SHAPE)
- dispatch_buffer = 'E';
- else if (font.shape() == LyXFont::SMALLCAPS_SHAPE)
- dispatch_buffer = 'N';
- else
- dispatch_buffer = '0';
-
- }
- break;
-
- case LFUN_GETLATEX:
- {
- LyXFont & font = TEXT()->current_font;
- if (font.latex() == LyXFont::ON)
- dispatch_buffer = 'L';
- else
- dispatch_buffer = '0';
- }
- break;
-
- case LFUN_GETNAME:
- setMessage(owner->buffer()->fileName());
- lyxerr.debug() << "FNAME["
- << owner->buffer()->fileName()
- << "] " << endl;
- break;
-
- case LFUN_NOTIFY:
- {
- string buf;
- keyseq.print(buf);
- dispatch_buffer = buf;
- lyxserver->notifyClient(dispatch_buffer);
- }
- break;
-
- case LFUN_GOTOFILEROW:
- {
- char file_name[100];
- int row;
- ::sscanf(argument.c_str(), " %s %d", file_name, &row);
-
- // Must replace extension of the file to be .lyx and get full path
- string s = ChangeExtension(string(file_name), ".lyx");
-
- // Either change buffer or load the file
- if (bufferlist.exists(s))
- owner->view()->buffer(bufferlist.getBuffer(s));
- else
- owner->view()->buffer(bufferlist.loadLyXFile(s));
-
- // Set the cursor
- owner->view()->setCursorFromRow(row);
-
- // Recenter screen
- owner->view()->center();
- }
- break;
-
- case LFUN_GOTO_PARAGRAPH:
- {
- istringstream istr(argument.c_str());
-
- int id;
- istr >> id;
- LyXParagraph * par = TEXT()->GetParFromID(id);
-
- // Set the cursor
- TEXT()->SetCursor(owner->view(), par, 0);
- owner->view()->setState();
+ // Set the cursor
+ TEXT()->SetCursor(owner->view(), par, 0);
+ owner->view()->setState();
owner->showState();
// Recenter screen
}
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:
- {
- char c = 0;
-
- if (keyseq.length == -1 && keyseq.getiso() != 0)
- c = keyseq.getiso();
-
- owner->getIntl()->getTrans()
- .deadkey(c, get_accent(action).accent,
- TEXT());
-
- // Need to reset, in case the minibuffer calls these
- // actions
- keyseq.reset();
- keyseq.length = 0;
-
- // copied verbatim from do_accent_char
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
-
- TEXT()->sel_cursor =
- TEXT()->cursor;
- }
- break;
-
// --- toolbar ----------------------------------
case LFUN_PUSH_TOOLBAR:
{
}
break;
- case LFUN_MATH_DELIM:
- case LFUN_INSERT_MATRIX:
- {
- if (owner->view()->available()) {
- if (owner->view()->
- open_new_inset(new InsetFormula(false)))
- {
- owner->view()->theLockingInset()
- ->LocalDispatch(owner->view(),
- action,
- argument);
- }
- }
- }
- break;
-
- case LFUN_INSERT_MATH:
- {
- math_insert_symbol(owner->view(), argument);
- }
- break;
-
- case LFUN_MATH_DISPLAY:
- {
- if (owner->view()->available())
- owner->view()->open_new_inset(new InsetFormula(true));
- break;
- }
-
- case LFUN_MATH_MACRO:
- {
- if (owner->view()->available()) {
- string s(argument);
- if (s.empty())
- setErrorMessage(N_("Missing argument"));
- else {
- string const s1 = token(s, ' ', 1);
- int const na = s1.empty() ? 0 : lyx::atoi(s1);
- owner->view()->
- open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na));
- }
- }
- }
- break;
-
- case LFUN_MATH_MODE: // Open or create a math inset
- {
- if (owner->view()->available())
- owner->view()->open_new_inset(new InsetFormula);
- setMessage(N_("Math editor mode"));
- }
- break;
-
case LFUN_MATH_NUMBER:
case LFUN_MATH_LIMITS:
{
}
break;
- case LFUN_CITATION_INSERT:
- {
- InsetCommandParams p;
- p.setFromString( argument );
-
- InsetCitation * inset = new InsetCitation( p );
- if (!owner->view()->insertInset(inset))
- delete inset;
- else
- owner->view()->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 (owner->view()->insertInset(inset)) {
- if (argument.empty())
- inset->Edit(owner->view(), 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
- LyXParagraph::size_type curpos =
- TEXT()->cursor.pos() - 1;
-
- string curstring;
- if (curpos >= 0 )
- curstring = TEXT()
- ->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 (!owner->view()->insertInset(inset))
- delete inset;
- else
- owner->view()->updateInset(inset, true);
- }
- break;
-
- case LFUN_INDEX_INSERT_LAST:
- {
- // Get word immediately preceding the cursor
- LyXParagraph::size_type curpos =
- TEXT()->cursor.pos() - 1;
- // Can't do that at the beginning of a paragraph
- if (curpos < 0) break;
-
- string const curstring(TEXT()
- ->cursor.par()->GetWord(curpos));
-
- InsetCommandParams p("index", curstring);
- InsetIndex * inset = new InsetIndex(p);
-
- if (!owner->view()->insertInset(inset))
- delete inset;
- else
- owner->view()->updateInset(inset, true);
- }
- break;
-
- case LFUN_INDEX_PRINT:
- {
- InsetCommandParams p("printindex");
- Inset * inset = new InsetPrintIndex(p);
- if (!owner->view()->insertInset(inset, "Standard", true))
- delete inset;
- }
- break;
-
- case LFUN_PARENTINSERT:
- {
- lyxerr << "arg " << argument << endl;
- InsetCommandParams p( "lyxparent", argument );
- Inset * inset = new InsetParent(p, *owner->buffer());
- if (!owner->view()->insertInset(inset, "Standard", true))
- delete inset;
- }
- break;
-
case LFUN_CHILD_CREATE:
{
InsetCommandParams p("include");
}
break;
- case LFUN_CHILD_INSERT:
- {
- InsetCommandParams p;
- p.setFromString(argument);
-
- InsetInclude * inset = new InsetInclude(p, *owner->buffer());
- if (!owner->view()->insertInset(inset))
- delete inset;
- else
- owner->view()->updateInset(inset, true);
- }
- break;
-
case LFUN_CHILDOPEN:
{
string const filename =
}
break;
- case LFUN_INSERT_NOTE:
- owner->view()->insertNote();
- break;
#ifndef NEW_INSETS
case LFUN_INSERTFOOTNOTE:
{
owner->getIntl()->ToggleKeyMap();
break;
- case LFUN_SELFINSERT:
- {
- LyXFont const old_font(TEXT(false)->real_current_font);
- for (string::size_type i = 0; i < argument.length(); ++i) {
- TEXT(false)->InsertChar(owner->view(), argument[i]);
- // This needs to be in the loop, or else we
- // won't break lines correctly. (Asger)
- owner->view()->update(TEXT(false),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
- TEXT(false)->sel_cursor = TEXT(false)->cursor;
- moveCursorUpdate(false, false);
-
- // real_current_font.number can change so we need to
- // update the minibuffer
- if (old_font != TEXT(false)->real_current_font)
- owner->showState();
- }
- break;
-
case LFUN_SEQUENCE:
{
// argument contains ';'-terminated commands
}
break;
- case LFUN_DATE_INSERT: // jdblair: date-insert cmd
- {
- struct tm * now_tm;
-
- time_t now_time_t = time(NULL);
- 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);
- for (int i = 0; i < datetmp_len; i++) {
- TEXT()->InsertChar(owner->view(), datetmp[i]);
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
-
- TEXT()->sel_cursor = TEXT()->cursor;
- moveCursorUpdate(true, false);
- }
- break;
-
case LFUN_DIALOG_PREFERENCES:
owner->getDialogs()->showPreferences();
break;
break;
}
- case LFUN_UNKNOWN_ACTION:
- {
- if (!owner->buffer()) {
- setErrorMessage(N_("No document open"));
- break;
- }
-
- if (owner->buffer()->isReadonly()) {
- setErrorMessage(N_("Document is read only"));
- break;
- }
-
- if (!argument.empty()) {
-
- /* 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). */
-
- if (lyxrc.auto_region_delete) {
- if (TEXT()->selection){
- TEXT()->CutSelection(owner->view(), false);
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- }
- }
-
- owner->view()->beforeChange(TEXT());
- LyXFont const old_font(TEXT()->real_current_font);
- for (string::size_type i = 0;
- i < argument.length(); ++i) {
- if (greek_kb_flag) {
- if (!math_insert_greek(owner->view(),
- argument[i]))
- owner->getIntl()->getTrans().TranslateAndInsert(argument[i], TEXT());
- } else
- owner->getIntl()->getTrans().TranslateAndInsert(argument[i], TEXT());
- }
-
- owner->view()->update(TEXT(),
- BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
-
- TEXT()->sel_cursor =
- TEXT()->cursor;
- moveCursorUpdate(true, false);
-
- // real_current_font.number can change so we need to
- // update the minibuffer
- if (old_font != TEXT()->real_current_font)
- owner->showState();
- return string();
- } else {
- // why is an "Unknown action" with empty
- // argument even dispatched in the first
- // place? I`ll probably change that. (Lgb)
- setErrorMessage(N_("Unknown action"));
- }
- break;
- }
-
default:
- lyxerr << "A truly unknown func!" << endl;
+ // Then if it was none of the above
+ if (!owner->view()->Dispatch(action, argument))
+ lyxerr << "A truly unknown func!" << endl;
break;
} // end of switch
- exit_with_message:
+
+exit_with_message:
string const res = getMessage();
}
-void LyXFunc::MenuInsertLyXFile(string const & filen)
-{
- string filename = filen;
-
- if (filename.empty()) {
- // Launch a file browser
- string initpath = lyxrc.document_path;
- LyXFileDlg fileDlg;
-
- if (owner->view()->available()) {
- string const trypath = owner->buffer()->filepath;
- // If directory is writeable, use this as default.
- if (IsDirWriteable(trypath) == 1)
- initpath = trypath;
- }
-
- // launches dialog
- ProhibitInput(owner->view());
- fileDlg.SetButton(0, _("Documents"), lyxrc.document_path);
- fileDlg.SetButton(1, _("Examples"),
- AddPath(system_lyxdir, "examples"));
- filename = fileDlg.Select(_("Select Document to Insert"),
- initpath, "*.lyx");
- AllowInput(owner->view());
-
- // check selected filename
- if (filename.empty()) {
- owner->getMiniBuffer()->Set(_("Canceled."));
- return;
- }
- }
-
- // get absolute path of file and make sure the filename ends
- // with .lyx
- filename = MakeAbsPath(filename);
- if (!IsLyXFilename(filename))
- filename += ".lyx";
-
- // Inserts document
- owner->getMiniBuffer()->Set(_("Inserting document"),
- MakeDisplayPath(filename), "...");
- bool const res = owner->view()->insertLyXFile(filename);
- if (res) {
- owner->getMiniBuffer()->Set(_("Document"),
- MakeDisplayPath(filename),
- _("inserted."));
- } else {
- owner->getMiniBuffer()->Set(_("Could not insert document"),
- MakeDisplayPath(filename));
- }
-}
-
-
void LyXFunc::reloadBuffer()
{
string const fn = owner->buffer()->fileName();
}
-Inset * LyXFunc::getInsetByCode(Inset::Code code)
-{
- LyXCursor cursor = TEXT()->cursor;
- Buffer * buffer = owner->view()->buffer();
- Buffer::inset_iterator it =
- find_if(Buffer::inset_iterator(cursor.par(),
- cursor.pos()),
- buffer->inset_iterator_end(),
- compare_memfun(&Inset::LyxCode, code));
- return it != buffer->inset_iterator_end() ? (*it) : 0;
-}
-
-
// Each "owner" should have it's own message method. lyxview and
// the minibuffer would use the minibuffer, but lyxserver would
// send an ERROR signal to its client. Alejandro 970603
void setErrorMessage(string const &) const;
/// Buffer to store result messages
string const getMessage() const { return dispatch_buffer; }
- /// Get next inset of this class from current cursor position
- Inset * getInsetByCode(Inset::Code);
-
+ /// Handle a accented char keysequenze
+ void handleKeyFunc(kb_action action);
/// Should a hint message be displayed?
void setHintMessage(bool);
private:
///
void doImport(string const &);
- ///
- void MenuInsertLyXFile(string const &);
///
void CloseBuffer();
+2001-02-23 Juergen Vigna <jug@sad.it>
+
+ * formula.C (LocalDispatch): changed action to be a kb_action (as it
+ should be) and not an int.
+
+ * formulamacro.C (LocalDispatch): ditto.
+
2001-02-14 André Pönitz <poenitz@htwm.de>
* math_parinset.[Ch]: make array a real MathArray, not just a
UpdatableInset::RESULT
-InsetFormula::LocalDispatch(BufferView * bv, int action, string const & arg)
+InsetFormula::LocalDispatch(BufferView * bv, kb_action action,
+ string const & arg)
{
// extern char *dispatch_result;
MathedTextCodes varcode = LM_TC_MIN;
void InsetUnlock(BufferView *);
/// To allow transparent use of math editing functions
- virtual RESULT LocalDispatch(BufferView *, int, string const &);
+ virtual RESULT LocalDispatch(BufferView *, kb_action, string const &);
///
void InsertSymbol(BufferView *, string const &);
UpdatableInset::RESULT
InsetFormulaMacro::LocalDispatch(BufferView * bv,
- int action, string const & arg)
+ kb_action action, string const & arg)
{
if (action == LFUN_MATH_MACROARG) {
int i = lyx::atoi(arg) - 1;
///
void InsetUnlock(BufferView *);
///
- RESULT LocalDispatch(BufferView *, int, string const &);
+ RESULT LocalDispatch(BufferView *, kb_action, string const &);
private:
///
projects / lyx.git / commitdiff