-/* This file is part of
- * ======================================================
+/**
+ * \file lyxfunc.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * LyX, The Document Processor
+ * \author Alfredo Braunstein
+ * \author Lars Gullik Bjønnes
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author André Pönitz
+ * \author Allan Rae
+ * \author Dekel Tsur
+ * \author Martin Vermeer
+ * \author Jürgen Vigna
*
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2001 The LyX Team.
- *
- * ====================================================== */
+ * Full author contact details are available in file CREDITS.
+ */
#include <config.h>
#include "lyxfunc.h"
-#include "version.h"
-#include "kbmap.h"
-#include "lyxrow.h"
-#include "bufferlist.h"
+
+#include "BranchList.h"
#include "buffer.h"
#include "buffer_funcs.h"
+#include "bufferlist.h"
+#include "bufferparams.h"
#include "BufferView.h"
-#include "lyxserver.h"
-#include "intl.h"
-#include "lyx_main.h"
-#include "lyx_cb.h"
-#include "LyXAction.h"
+#include "cursor.h"
+#include "CutAndPaste.h"
#include "debug.h"
-#include "lyxrc.h"
-#include "lyxtext.h"
-#include "gettext.h"
-#include "Lsstream.h"
-#include "trans_mgr.h"
+#include "dispatchresult.h"
#include "encoding.h"
-#include "layout.h"
-#include "bufferview_funcs.h"
-#include "frontends/LyXView.h"
-#include "frontends/lyx_gui.h"
-#include "vspace.h"
-#include "FloatList.h"
-#include "format.h"
+#include "errorlist.h"
#include "exporter.h"
+#include "format.h"
+#include "funcrequest.h"
+#include "gettext.h"
#include "importer.h"
-#include "TextCache.h"
+#include "insetiterator.h"
+#include "intl.h"
+#include "kbmap.h"
+#include "language.h"
+#include "LColor.h"
+#include "lyx_cb.h"
+#include "LyXAction.h"
#include "lyxfind.h"
-#include "undo_funcs.h"
+#include "lyxlex.h"
+#include "lyxrc.h"
+#include "lyxrow.h"
+#include "lyxserver.h"
+#include "lyxtextclasslist.h"
+#include "lyxvc.h"
+#include "paragraph.h"
+#include "pariterator.h"
#include "ParagraphParameters.h"
+#include "undo.h"
+#include "insets/insetbox.h"
+#include "insets/insetbranch.h"
#include "insets/insetcommand.h"
+#include "insets/insetert.h"
#include "insets/insetexternal.h"
+#include "insets/insetfloat.h"
+#include "insets/insetgraphics.h"
+#include "insets/insetnote.h"
#include "insets/insettabular.h"
+#include "insets/insetvspace.h"
+#include "insets/insetwrap.h"
-#include "mathed/formulamacro.h"
-#include "mathed/math_cursor.h"
-#include "mathed/math_inset.h"
-
-#include "frontends/FileDialog.h"
+#include "frontends/Alert.h"
#include "frontends/Dialogs.h"
-#include "frontends/Toolbar.h"
+#include "frontends/FileDialog.h"
+#include "frontends/lyx_gui.h"
+#include "frontends/LyXKeySym.h"
+#include "frontends/LyXView.h"
#include "frontends/Menubar.h"
-#include "frontends/Alert.h"
-
-#include "graphics/GraphicsCache.h"
+#include "frontends/Toolbars.h"
-#include "support/lyxalgo.h"
-#include "support/LAssert.h"
-#include "support/filetools.h"
+#include "support/filefilterlist.h"
#include "support/FileInfo.h"
+#include "support/filetools.h"
#include "support/forkedcontr.h"
#include "support/lstrings.h"
-#include "support/tostr.h"
#include "support/path.h"
-#include "support/lyxfunctional.h"
-
-#include <ctime>
-#include <clocale>
-#include <cstdlib>
-#include <cctype>
+#include "support/path_defines.h"
+#include "support/systemcall.h"
+#include "support/tostr.h"
+#include "support/os.h"
+
+#include <sstream>
+
+using bv_funcs::freefont2string;
+
+using lyx::support::AddName;
+using lyx::support::AddPath;
+using lyx::support::bformat;
+using lyx::support::ChangeExtension;
+using lyx::support::contains;
+using lyx::support::FileFilterList;
+using lyx::support::FileInfo;
+using lyx::support::FileSearch;
+using lyx::support::ForkedcallsController;
+using lyx::support::i18nLibFileSearch;
+using lyx::support::IsDirWriteable;
+using lyx::support::IsFileReadable;
+using lyx::support::isStrInt;
+using lyx::support::MakeAbsPath;
+using lyx::support::MakeDisplayPath;
+using lyx::support::Path;
+using lyx::support::QuoteName;
+using lyx::support::rtrim;
+using lyx::support::split;
+using lyx::support::strToInt;
+using lyx::support::strToUnsignedInt;
+using lyx::support::subst;
+using lyx::support::system_lyxdir;
+using lyx::support::Systemcall;
+using lyx::support::token;
+using lyx::support::trim;
+using lyx::support::user_lyxdir;
+using lyx::support::prefixIs;
+using lyx::support::os::getTmpDir;
-#include <utility>
-#include <algorithm>
+using std::endl;
+using std::make_pair;
+using std::pair;
+using std::string;
+using std::istringstream;
-using namespace lyx::support;
+namespace biblio = lyx::biblio;
-using std::pair;
-using std::make_pair;
-using std::endl;
-using std::find_if;
-using std::vector;
-using std::transform;
-using std::back_inserter;
-using namespace bv_funcs;
extern BufferList bufferlist;
extern LyXServer * lyxserver;
// (alkis)
extern tex_accent_struct get_accent(kb_action action);
-extern void ShowLatexLog();
-
-LyXFunc::LyXFunc(LyXView * o)
- : owner(o),
+LyXFunc::LyXFunc(LyXView * lv)
+ : owner(lv),
encoded_last_key(0),
keyseq(toplevel_keymap.get(), toplevel_keymap.get()),
cancel_meta_seq(toplevel_keymap.get(), toplevel_keymap.get()),
}
-inline
-LyXText * LyXFunc::TEXT(bool flag = true) const
-{
- if (flag)
- return view()->text;
- return view()->getLyXText();
-}
-
-
-inline
-void LyXFunc::moveCursorUpdate(bool flag, bool selecting)
-{
- if (selecting || TEXT(flag)->selection.mark()) {
- TEXT(flag)->setSelection();
- if (!TEXT(flag)->isInInset())
- view()->toggleToggle();
- }
- view()->update(TEXT(flag), BufferView::SELECT);
-
- view()->switchKeyMap();
-}
-
-
void LyXFunc::handleKeyFunc(kb_action action)
{
char c = encoded_last_key;
}
owner->getIntl().getTransManager()
- .deadkey(c, get_accent(action).accent, TEXT(false));
+ .deadkey(c, get_accent(action).accent, view()->getLyXText());
// Need to clear, in case the minibuffer calls these
// actions
keyseq.clear();
// copied verbatim from do_accent_char
- view()->update(TEXT(false), BufferView::SELECT);
- TEXT(false)->selection.cursor = TEXT(false)->cursor;
+ view()->cursor().resetAnchor();
+ view()->update();
}
-void LyXFunc::processKeySym(LyXKeySymPtr keysym,
- key_modifier::state state)
+void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
{
- string argument;
-
- if (lyxerr.debugging(Debug::KEY)) {
- lyxerr << "KeySym is "
- << keysym->getSymbolName()
- << endl;
- }
+ lyxerr[Debug::KEY] << "KeySym is " << keysym->getSymbolName() << endl;
// Do nothing if we have nothing (JMarc)
if (!keysym->isOK()) {
return;
}
- Encoding const * encoding = view()->getEncoding();
+ Encoding const * encoding = view()->cursor().getEncoding();
encoded_last_key = keysym->getISOEncoded(encoding ? encoding->Name() : "");
// cancel and meta-fake keys. RVDK_PATCH_5
cancel_meta_seq.reset();
- int action = cancel_meta_seq.addkey(keysym, state);
- lyxerr[Debug::KEY] << "action first set to [" << action << ']' << endl;
+ FuncRequest func = cancel_meta_seq.addkey(keysym, state);
+ lyxerr[Debug::KEY] << "action first set to [" << func.action << ']' << endl;
// When not cancel or meta-fake, do the normal lookup.
// Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards.
// Mostly, meta_fake_bit = key_modifier::none. RVDK_PATCH_5.
- if ((action != LFUN_CANCEL) && (action != LFUN_META_FAKE)) {
+ if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_FAKE)) {
// remove Caps Lock and Mod2 as a modifiers
- action = keyseq.addkey(keysym, (state | meta_fake_bit));
+ func = keyseq.addkey(keysym, (state | meta_fake_bit));
lyxerr[Debug::KEY] << "action now set to ["
- << action << ']' << endl;
+ << func.action << ']' << endl;
}
// Dont remove this unless you know what you are doing.
meta_fake_bit = key_modifier::none;
// can this happen now ?
- if (action == LFUN_NOACTION) {
- action = LFUN_PREFIX;
+ if (func.action == LFUN_NOACTION) {
+ func = FuncRequest(LFUN_PREFIX);
}
if (lyxerr.debugging(Debug::KEY)) {
lyxerr << "Key [action="
- << action << "]["
+ << func.action << "]["
<< keyseq.print() << ']'
<< endl;
}
// Maybe user can only reach the key via holding down shift.
// Let's see. But only if shift is the only modifier
- if (action == LFUN_UNKNOWN_ACTION && state == key_modifier::shift) {
+ if (func.action == LFUN_UNKNOWN_ACTION &&
+ state == key_modifier::shift) {
lyxerr[Debug::KEY] << "Trying without shift" << endl;
- action = keyseq.addkey(keysym, key_modifier::none);
- lyxerr[Debug::KEY] << "Action now " << action << endl;
+ func = keyseq.addkey(keysym, key_modifier::none);
+ lyxerr[Debug::KEY] << "Action now " << func.action << endl;
}
- if (action == LFUN_UNKNOWN_ACTION) {
+ if (func.action == LFUN_UNKNOWN_ACTION) {
// Hmm, we didn't match any of the keysequences. See
// if it's normal insertable text not already covered
// by a binding
if (keysym->isText() && keyseq.length() == 1) {
lyxerr[Debug::KEY] << "isText() is true, inserting." << endl;
- action = LFUN_SELFINSERT;
+ func = FuncRequest(LFUN_SELFINSERT);
} else {
lyxerr[Debug::KEY] << "Unknown, !isText() - giving up" << endl;
owner->message(_("Unknown function."));
}
}
- if (action == LFUN_SELFINSERT) {
+ if (func.action == LFUN_SELFINSERT) {
if (encoded_last_key != 0) {
- string arg;
- arg += encoded_last_key;
-
- dispatch(FuncRequest(view(), LFUN_SELFINSERT, arg));
-
- lyxerr[Debug::KEY] << "SelfInsert arg[`"
- << argument << "']" << endl;
+ string arg(1, encoded_last_key);
+ dispatch(FuncRequest(LFUN_SELFINSERT, arg));
+ lyxerr[Debug::KEY]
+ << "SelfInsert arg[`" << arg << "']" << endl;
}
} else {
- dispatch(action);
+ dispatch(func);
}
}
-FuncStatus LyXFunc::getStatus(int ac) const
-{
- return getStatus(lyxaction.retrieveActionArg(ac));
-}
-
-
-FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
+FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
{
+ //lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
FuncStatus flag;
- Buffer * buf = owner->buffer();
-
- if (ev.action == LFUN_NOACTION) {
- setStatusMessage(N_("Nothing to do"));
- return flag.disabled(true);
+ LCursor & cur = view()->cursor();
+
+ /* In LyX/Mac, when a dialog is open, the menus of the
+ application can still be accessed without giving focus to
+ the main window. In this case, we want to disable the menu
+ entries that are buffer-related.
+ */
+ Buffer * buf;
+ if (cmd.origin == FuncRequest::UI && !owner->hasFocus())
+ buf = 0;
+ else
+ buf = owner->buffer();
+
+ if (cmd.action == LFUN_NOACTION) {
+ flag.message(N_("Nothing to do"));
+ flag.enabled(false);
+ return flag;
}
- switch (ev.action) {
+ switch (cmd.action) {
case LFUN_UNKNOWN_ACTION:
#ifndef HAVE_LIBAIKSAURUS
case LFUN_THESAURUS_ENTRY:
#endif
flag.unknown(true);
+ flag.enabled(false);
break;
default:
- flag |= lyx_gui::getStatus(ev);
+ flag |= lyx_gui::getStatus(cmd);
}
if (flag.unknown()) {
- setStatusMessage(N_("Unknown action"));
+ flag.message(N_("Unknown action"));
return flag;
}
// the default error message if we disable the command
- setStatusMessage(N_("Command disabled"));
+ flag.message(N_("Command disabled"));
+ if (!flag.enabled())
+ return flag;
// Check whether we need a buffer
- if (!lyxaction.funcHasFlag(ev.action, LyXAction::NoBuffer)) {
- // Yes we need a buffer, do we have one?
- if (buf) {
- // yes
- // Can we use a readonly buffer?
- if (buf->isReadonly() &&
- !lyxaction.funcHasFlag(ev.action,
- LyXAction::ReadOnly)) {
- // no
- setStatusMessage(N_("Document is read-only"));
- flag.disabled(true);
- }
- } else {
- // no
- setStatusMessage(N_("Command not allowed with"
- "out any document open"));
- return flag.disabled(true);
- }
+ if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) && !buf) {
+ // no, exit directly
+ flag.message(N_("Command not allowed with"
+ "out any document open"));
+ flag.enabled(false);
+ return flag;
}
- UpdatableInset * tli = view()->theLockingInset();
-
// I would really like to avoid having this switch and rather try to
// encode this in the function itself.
- bool disable = false;
- switch (ev.action) {
- case LFUN_EXPORT:
- disable = ev.argument != "custom"
- && !Exporter::IsExportable(buf, ev.argument);
+ // -- And I'd rather let an inset decide which LFUNs it is willing
+ // to handle (Andre')
+ bool enable = true;
+ switch (cmd.action) {
+ case LFUN_TOOLTIPS_TOGGLE:
+ flag.setOnOff(owner->getDialogs().tooltipsEnabled());
break;
- case LFUN_UNDO:
- disable = buf->undostack.empty();
+
+ case LFUN_READ_ONLY_TOGGLE:
+ flag.setOnOff(buf->isReadonly());
break;
- case LFUN_REDO:
- disable = buf->redostack.empty();
+
+ case LFUN_SWITCHBUFFER:
+ // toggle on the current buffer, but do not toggle off
+ // the other ones (is that a good idea?)
+ if (cmd.argument == buf->fileName())
+ flag.setOnOff(true);
+ break;
+
+ case LFUN_EXPORT:
+ enable = cmd.argument == "custom"
+ || Exporter::IsExportable(*buf, cmd.argument);
break;
case LFUN_CUT:
case LFUN_COPY:
- if (tli) {
- UpdatableInset * in = tli;
- if (in->lyxCode() != Inset::TABULAR_CODE) {
- in = tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE);
- }
- if (in && static_cast<InsetTabular*>(in)->hasSelection()) {
- disable = false;
- break;
- }
- }
- disable = !mathcursor && !view()->getLyXText()->selection.set();
+ enable = cur.selection();
break;
+
case LFUN_RUNCHKTEX:
- disable = !buf->isLatex() || lyxrc.chktex_command == "none";
+ enable = buf->isLatex() && lyxrc.chktex_command != "none";
break;
+
case LFUN_BUILDPROG:
- disable = !Exporter::IsExportable(buf, "program");
+ enable = Exporter::IsExportable(*buf, "program");
break;
case LFUN_LAYOUT_TABULAR:
- disable = !tli
- || (tli->lyxCode() != Inset::TABULAR_CODE
- && !tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE));
- break;
-
- case LFUN_DEPTH_MIN:
- disable = !changeDepth(view(), TEXT(false), DEC_DEPTH, true);
- break;
-
- case LFUN_DEPTH_PLUS:
- disable = !changeDepth(view(), TEXT(false), INC_DEPTH, true);
+ enable = cur.innerInsetOfType(InsetBase::TABULAR_CODE);
break;
case LFUN_LAYOUT:
- case LFUN_LAYOUT_PARAGRAPH: {
- Inset * inset = TEXT(false)->cursor.par()->inInset();
- disable = inset && inset->forceDefaultParagraphs(inset);
- break;
- }
-
- case LFUN_INSET_OPTARG:
- disable = (TEXT(false)->cursor.par()->layout()->optionalargs == 0);
- break;
-
- case LFUN_TABULAR_FEATURE:
- if (mathcursor) {
-#if 0
- // FIXME: check temporarily disabled
- // valign code
- char align = mathcursor->valign();
- if (align == '\0') {
- disable = true;
- break;
- }
- if (ev.argument.empty()) {
- flag.clear();
- break;
- }
- if (!contains("tcb", ev.argument[0])) {
- disable = true;
- break;
- }
- flag.setOnOff(ev.argument[0] == align);
- } else
- disable = true;
-
- char align = mathcursor->halign();
- if (align == '\0') {
- disable = true;
- break;
- }
- if (ev.argument.empty()) {
- flag.clear();
- break;
- }
- if (!contains("lcr", ev.argument[0])) {
- disable = true;
- break;
- }
- flag.setOnOff(ev.argument[0] == align);
-#endif
-
- disable = !mathcursor->halign();
- break;
- }
-
- if (tli) {
- FuncStatus ret;
- //ret.disabled(true);
- if (tli->lyxCode() == Inset::TABULAR_CODE) {
- ret = static_cast<InsetTabular *>(tli)
- ->getStatus(ev.argument);
- flag |= ret;
- disable = false;
- } else if (tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE)) {
- ret = static_cast<InsetTabular *>
- (tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE))
- ->getStatus(ev.argument);
- flag |= ret;
- disable = false;
- } else {
- disable = true;
- }
- } else {
- static InsetTabular inset(*owner->buffer(), 1, 1);
- FuncStatus ret;
-
- disable = true;
- ret = inset.getStatus(ev.argument);
- if (ret.onoff(true) || ret.onoff(false))
- flag.setOnOff(false);
- }
+ case LFUN_LAYOUT_PARAGRAPH:
+ enable = !cur.inset().forceDefaultParagraphs(&cur.inset());
break;
case LFUN_VC_REGISTER:
- disable = buf->lyxvc.inUse();
+ enable = !buf->lyxvc().inUse();
break;
case LFUN_VC_CHECKIN:
- disable = !buf->lyxvc.inUse() || buf->isReadonly();
+ enable = buf->lyxvc().inUse() && !buf->isReadonly();
break;
case LFUN_VC_CHECKOUT:
- disable = !buf->lyxvc.inUse() || !buf->isReadonly();
+ enable = buf->lyxvc().inUse() && buf->isReadonly();
break;
case LFUN_VC_REVERT:
case LFUN_VC_UNDO:
- disable = !buf->lyxvc.inUse();
+ enable = buf->lyxvc().inUse();
break;
case LFUN_MENURELOAD:
- disable = buf->isUnnamed() || buf->isClean();
+ enable = !buf->isUnnamed() && !buf->isClean();
break;
- case LFUN_BOOKMARK_GOTO:
- disable = !view()->
- isSavedPosition(strToUnsignedInt(ev.argument));
- break;
- case LFUN_MERGE_CHANGES:
- case LFUN_ACCEPT_CHANGE:
- case LFUN_REJECT_CHANGE:
- case LFUN_ACCEPT_ALL_CHANGES:
- case LFUN_REJECT_ALL_CHANGES:
- disable = !buf->params.tracking_changes;
- break;
- case LFUN_INSET_TOGGLE: {
- LyXText * lt = view()->getLyXText();
- disable = !(isEditableInset(lt->getInset())
- || (lt->inset_owner
- && lt->inset_owner->owner()
- && lt->inset_owner->owner()->isOpen()));
- break;
- }
- case LFUN_INSET_SETTINGS: {
- disable = true;
- UpdatableInset * inset = view()->theLockingInset();
+ case LFUN_INSET_SETTINGS: {
+ enable = false;
+ if (!cur.size())
+ break;
+ UpdatableInset * inset = cur.inset().asUpdatableInset();
+ lyxerr << "inset: " << inset << endl;
if (!inset)
break;
- // get the innermost inset
- inset = inset->getLockingInset();
-
- // jump back to owner if an InsetText, so
- // we get back to the InsetTabular or whatever
- if (inset->lyxCode() == Inset::TEXT_CODE)
- inset = inset->owner();
-
- Inset::Code code = inset->lyxCode();
+ InsetBase::Code code = inset->lyxCode();
switch (code) {
- case Inset::TABULAR_CODE:
- disable = ev.argument != "tabular";
+ case InsetBase::TABULAR_CODE:
+ enable = cmd.argument == "tabular";
break;
- case Inset::ERT_CODE:
- disable = ev.argument != "ert";
+ case InsetBase::ERT_CODE:
+ enable = cmd.argument == "ert";
break;
- case Inset::FLOAT_CODE:
- disable = ev.argument != "float";
+ case InsetBase::FLOAT_CODE:
+ enable = cmd.argument == "float";
break;
- case Inset::MINIPAGE_CODE:
- disable = ev.argument != "minipage";
+ case InsetBase::WRAP_CODE:
+ enable = cmd.argument == "wrap";
break;
- case Inset::WRAP_CODE:
- disable = ev.argument != "wrap";
+ case InsetBase::NOTE_CODE:
+ enable = cmd.argument == "note";
+ break;
+ case InsetBase::BRANCH_CODE:
+ enable = cmd.argument == "branch";
+ break;
+ case InsetBase::BOX_CODE:
+ enable = cmd.argument == "box";
break;
default:
break;
break;
}
- case LFUN_MATH_MUTATE:
- if (mathcursor)
- //flag.setOnOff(mathcursor->formula()->hullType() == ev.argument);
- flag.setOnOff(false);
- else
- disable = true;
- break;
-
- // we just need to be in math mode to enable that
- case LFUN_MATH_SIZE:
- case LFUN_MATH_SPACE:
- case LFUN_MATH_LIMITS:
- case LFUN_MATH_NONUMBER:
- case LFUN_MATH_NUMBER:
- case LFUN_MATH_EXTERN:
- disable = !mathcursor;
- break;
-
case LFUN_DIALOG_SHOW: {
- string const name = ev.getArg(0);
- if (!buf) {
- disable = !(name == "aboutlyx" ||
- name == "file" ||
- name == "forks" ||
- name == "preferences" ||
- name == "texinfo");
- break;
- }
-
- if (name == "print") {
- disable = !Exporter::IsExportable(buf, "dvi") ||
- lyxrc.print_command == "none";
- } else if (name == "character") {
- UpdatableInset * tli = view()->theLockingInset();
- disable = tli && tli->lyxCode() == Inset::ERT_CODE;
- } else if (name == "vclog") {
- disable = !buf->lyxvc.inUse();
- } else if (name == "latexlog") {
- disable = !IsFileReadable(buf->getLogName().second);
- }
+ string const name = cmd.getArg(0);
+ if (!buf)
+ enable = name == "aboutlyx"
+ || name == "file"
+ || name == "forks"
+ || name == "prefs"
+ || name == "texinfo";
+ else if (name == "print")
+ enable = Exporter::IsExportable(*buf, "dvi")
+ && lyxrc.print_command != "none";
+ else if (name == "character")
+ enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
+ else if (name == "vclog")
+ enable = buf->lyxvc().inUse();
+ else if (name == "latexlog")
+ enable = IsFileReadable(buf->getLogName().second);
break;
}
- default:
+ case LFUN_DIALOG_UPDATE: {
+ string const name = cmd.getArg(0);
+ if (!buf)
+ enable = name == "prefs";
break;
}
- // the functions which insert insets
- Inset::Code code = Inset::NO_CODE;
- switch (ev.action) {
- case LFUN_DIALOG_SHOW_NEW_INSET:
- if (ev.argument == "bibitem")
- code = Inset::BIBITEM_CODE;
- else if (ev.argument == "bibtex")
- code = Inset::BIBTEX_CODE;
- else if (ev.argument == "citation")
- code = Inset::CITE_CODE;
- else if (ev.argument == "ert")
- code = Inset::ERT_CODE;
- else if (ev.argument == "external")
- code = Inset::EXTERNAL_CODE;
- else if (ev.argument == "float")
- code = Inset::FLOAT_CODE;
- else if (ev.argument == "graphics")
- code = Inset::GRAPHICS_CODE;
- else if (ev.argument == "include")
- code = Inset::INCLUDE_CODE;
- else if (ev.argument == "index")
- code = Inset::INDEX_CODE;
- else if (ev.argument == "label")
- code = Inset::LABEL_CODE;
- else if (ev.argument == "minipage")
- code = Inset::MINIPAGE_CODE;
- else if (ev.argument == "ref")
- code = Inset::REF_CODE;
- else if (ev.argument == "toc")
- code = Inset::TOC_CODE;
- else if (ev.argument == "url")
- code = Inset::URL_CODE;
- else if (ev.argument == "wrap")
- code = Inset::WRAP_CODE;
- break;
-
- case LFUN_INSET_ERT:
- code = Inset::ERT_CODE;
- break;
- case LFUN_INSET_FOOTNOTE:
- code = Inset::FOOT_CODE;
- break;
- case LFUN_TABULAR_INSERT:
- code = Inset::TABULAR_CODE;
- break;
- case LFUN_INSET_MARGINAL:
- code = Inset::MARGIN_CODE;
- break;
- case LFUN_INSET_MINIPAGE:
- code = Inset::MINIPAGE_CODE;
- break;
- case LFUN_INSET_FLOAT:
- case LFUN_INSET_WIDE_FLOAT:
- code = Inset::FLOAT_CODE;
- break;
- case LFUN_INSET_WRAP:
- code = Inset::WRAP_CODE;
- break;
- case LFUN_FLOAT_LIST:
- code = Inset::FLOAT_LIST_CODE;
- break;
-#if 0
- case LFUN_INSET_LIST:
- code = Inset::LIST_CODE;
- break;
- case LFUN_INSET_THEOREM:
- code = Inset::THEOREM_CODE;
- break;
-#endif
- case LFUN_INSET_CAPTION:
- code = Inset::CAPTION_CODE;
- break;
- case LFUN_INSERT_NOTE:
- code = Inset::NOTE_CODE;
- break;
- case LFUN_INSERT_LABEL:
- code = Inset::LABEL_CODE;
- break;
- case LFUN_INSET_OPTARG:
- code = Inset::OPTARG_CODE;
- break;
- case LFUN_ENVIRONMENT_INSERT:
- code = Inset::MINIPAGE_CODE;
- break;
- case LFUN_INDEX_INSERT:
- code = Inset::INDEX_CODE;
- break;
- case LFUN_INDEX_PRINT:
- code = Inset::INDEX_PRINT_CODE;
- break;
- case LFUN_TOC_INSERT:
- code = Inset::TOC_CODE;
- break;
- case LFUN_HTMLURL:
- case LFUN_URL:
- code = Inset::URL_CODE;
- break;
- case LFUN_QUOTE:
- // always allow this, since we will inset a raw quote
- // if an inset is not allowed.
- break;
- case LFUN_HYPHENATION:
- case LFUN_LIGATURE_BREAK:
- case LFUN_HFILL:
- case LFUN_MENU_SEPARATOR:
- case LFUN_LDOTS:
- case LFUN_END_OF_SENTENCE:
- code = Inset::SPECIALCHAR_CODE;
- break;
- case LFUN_SPACE_INSERT:
- // slight hack: we know this is allowed in math mode
- if (!mathcursor)
- code = Inset::SPACE_CODE;
- break;
- default:
- break;
+ // this one is difficult to get right. As a half-baked
+ // solution, we consider only the first action of the sequence
+ case LFUN_SEQUENCE: {
+ // argument contains ';'-terminated commands
+ string const firstcmd = token(cmd.argument, ';', 0);
+ FuncRequest func(lyxaction.lookupFunc(firstcmd));
+ func.origin = cmd.origin;
+ flag = getStatus(func);
}
- if (code != Inset::NO_CODE && tli && !tli->insetAllowed(code))
- disable = true;
-
- if (disable)
- flag.disabled(true);
- // A few general toggles
- switch (ev.action) {
- case LFUN_TOOLTIPS_TOGGLE:
- flag.setOnOff(owner->getDialogs().tooltipsEnabled());
+ case LFUN_MENUNEW:
+ case LFUN_MENUNEWTMPLT:
+ case LFUN_WORDFINDFORWARD:
+ case LFUN_WORDFINDBACKWARD:
+ case LFUN_PREFIX:
+ case LFUN_EXEC_COMMAND:
+ case LFUN_CANCEL:
+ case LFUN_META_FAKE:
+ case LFUN_CLOSEBUFFER:
+ case LFUN_MENUWRITE:
+ case LFUN_WRITEAS:
+ case LFUN_UPDATE:
+ case LFUN_PREVIEW:
+ case LFUN_IMPORT:
+ case LFUN_QUIT:
+ case LFUN_TOCVIEW:
+ case LFUN_AUTOSAVE:
+ case LFUN_RECONFIGURE:
+ case LFUN_HELP_OPEN:
+ case LFUN_FILE_NEW:
+ case LFUN_FILE_OPEN:
+ case LFUN_DROP_LAYOUTS_CHOICE:
+ case LFUN_MENU_OPEN_BY_NAME:
+ case LFUN_GETNAME:
+ case LFUN_NOTIFY:
+ case LFUN_GOTOFILEROW:
+ case LFUN_GOTO_PARAGRAPH:
+ case LFUN_DIALOG_SHOW_NEW_INSET:
+ case LFUN_DIALOG_SHOW_NEXT_INSET:
+ case LFUN_DIALOG_HIDE:
+ case LFUN_DIALOG_DISCONNECT_INSET:
+ case LFUN_CHILDOPEN:
+ case LFUN_TOGGLECURSORFOLLOW:
+ case LFUN_KMAP_OFF:
+ case LFUN_KMAP_PRIM:
+ case LFUN_KMAP_SEC:
+ case LFUN_KMAP_TOGGLE:
+ case LFUN_REPEAT:
+ case LFUN_EXPORT_CUSTOM:
+ case LFUN_PRINT:
+ case LFUN_SAVEPREFERENCES:
+ case LFUN_SCREEN_FONT_UPDATE:
+ case LFUN_SET_COLOR:
+ case LFUN_MESSAGE:
+ case LFUN_EXTERNAL_EDIT:
+ case LFUN_GRAPHICS_EDIT:
+ case LFUN_ALL_INSETS_TOGGLE:
+ case LFUN_LANGUAGE_BUFFER:
+ case LFUN_TEXTCLASS_APPLY:
+ case LFUN_TEXTCLASS_LOAD:
+ case LFUN_SAVE_AS_DEFAULT:
+ case LFUN_BUFFERPARAMS_APPLY:
+ case LFUN_LYXRC_APPLY:
+ case LFUN_NEXTBUFFER:
+ case LFUN_PREVIOUSBUFFER:
+ // these are handled in our dispatch()
break;
- case LFUN_READ_ONLY_TOGGLE:
- flag.setOnOff(buf->isReadonly());
- break;
- case LFUN_APPENDIX:
- flag.setOnOff(TEXT(false)->cursor.par()->params().startOfAppendix());
- break;
- case LFUN_SWITCHBUFFER:
- // toggle on the current buffer, but do not toggle off
- // the other ones (is that a good idea?)
- if (ev.argument == buf->fileName())
- flag.setOnOff(true);
- break;
- case LFUN_TRACK_CHANGES:
- flag.setOnOff(buf->params.tracking_changes);
- break;
default:
- break;
- }
- // the font related toggles
- if (!mathcursor) {
- LyXFont const & font = TEXT(false)->real_current_font;
- switch (ev.action) {
- case LFUN_EMPH:
- flag.setOnOff(font.emph() == LyXFont::ON);
- break;
- case LFUN_NOUN:
- flag.setOnOff(font.noun() == LyXFont::ON);
- break;
- case LFUN_BOLD:
- flag.setOnOff(font.series() == LyXFont::BOLD_SERIES);
- break;
- case LFUN_SANS:
- flag.setOnOff(font.family() == LyXFont::SANS_FAMILY);
- break;
- case LFUN_ROMAN:
- flag.setOnOff(font.family() == LyXFont::ROMAN_FAMILY);
- break;
- case LFUN_CODE:
- flag.setOnOff(font.family() == LyXFont::TYPEWRITER_FAMILY);
- break;
- default:
- break;
- }
- } else {
- string tc = mathcursor->getLastCode();
- switch (ev.action) {
- case LFUN_BOLD:
- flag.setOnOff(tc == "mathbf");
- break;
- case LFUN_SANS:
- flag.setOnOff(tc == "mathsf");
- break;
- case LFUN_EMPH:
- flag.setOnOff(tc == "mathcal");
- break;
- case LFUN_ROMAN:
- flag.setOnOff(tc == "mathrm");
- break;
- case LFUN_CODE:
- flag.setOnOff(tc == "mathtt");
- break;
- case LFUN_NOUN:
- flag.setOnOff(tc == "mathbb");
- break;
- case LFUN_DEFAULT:
- flag.setOnOff(tc == "mathnormal");
- break;
- default:
- break;
- }
+ if (!cur.getStatus(cmd, flag))
+ flag = view()->getStatus(cmd);
}
- // this one is difficult to get right. As a half-baked
- // solution, we consider only the first action of the sequence
- if (ev.action == LFUN_SEQUENCE) {
- // argument contains ';'-terminated commands
- flag = getStatus(lyxaction.LookupFunc(token(ev.argument, ';', 0)));
+ if (!enable)
+ flag.enabled(false);
+
+ // Can we use a readonly buffer?
+ if (buf && buf->isReadonly()
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
+ flag.message(N_("Document is read-only"));
+ flag.enabled(false);
}
+ //lyxerr << "LyXFunc::getStatus: got: " << flag.enabled() << endl;
return flag;
}
-void LyXFunc::dispatch(string const & s, bool verbose)
+namespace {
+
+bool ensureBufferClean(BufferView * bv)
{
- int const action = lyxaction.LookupFunc(s);
+ Buffer & buf = *bv->buffer();
+ if (buf.isClean())
+ return true;
+
+ string const file = MakeDisplayPath(buf.fileName(), 30);
+ string text = bformat(_("The document %1$s has unsaved "
+ "changes.\n\nDo you want to save "
+ "the document?"), file);
+ int const ret = Alert::prompt(_("Save changed document?"),
+ text, 0, 1, _("&Save"),
+ _("&Cancel"));
+
+ if (ret == 0)
+ bv->owner()->dispatch(FuncRequest(LFUN_MENUWRITE));
+
+ return buf.isClean();
+}
- if (action == LFUN_UNKNOWN_ACTION) {
- owner->message(bformat(_("Unknown function (%1$s)"), s));
- return;
- }
- dispatch(action, verbose);
+void showPrintError(string const & name)
+{
+ string str = bformat(_("Could not print the document %1$s.\n"
+ "Check that your printer is set up correctly."),
+ MakeDisplayPath(name, 50));
+ Alert::error(_("Print document failed"), str);
}
-void LyXFunc::dispatch(int ac, bool verbose)
+void loadTextclass(string const & name)
{
- dispatch(lyxaction.retrieveActionArg(ac), verbose);
-}
+ std::pair<bool, lyx::textclass_type> const tc_pair =
+ textclasslist.NumberOfClass(name);
-namespace {
- bool ensureBufferClean(BufferView * bv) {
-
- Buffer & buf = *bv->buffer();
- if (buf.isClean())
- return true;
-
- string const file = MakeDisplayPath(buf.fileName(), 30);
- string text = bformat(_("The document %1$s has unsaved "
- "changes.\n\nDo you want to save "
- "the document?"), file);
- int const ret = Alert::prompt(_("Save changed document?"),
- text, 0, 1, _("&Save"),
- _("&Cancel"));
-
- if (ret == 0)
- bv->owner()->dispatch(FuncRequest(LFUN_MENUWRITE));
-
- return buf.isClean();
+ if (!tc_pair.first) {
+ lyxerr << "Document class \"" << name
+ << "\" does not exist."
+ << std::endl;
+ return;
}
+
+ lyx::textclass_type const tc = tc_pair.second;
+
+ if (!textclasslist[tc].load()) {
+ string s = bformat(_("The document could not be converted\n"
+ "into the document class %1$s."),
+ textclasslist[tc].name());
+ Alert::error(_("Could not change class"), s);
+ }
+}
+
} //namespace anon
-void LyXFunc::dispatch(FuncRequest const & ev, bool verbose)
+
+void LyXFunc::dispatch(FuncRequest const & cmd)
{
- lyxerr[Debug::ACTION] << "LyXFunc::dispatch: action[" << ev.action
- <<"] arg[" << ev.argument << ']' << endl;
+ BOOST_ASSERT(view());
+ string const argument = cmd.argument;
+ kb_action const action = cmd.action;
+
+ lyxerr[Debug::ACTION] << "LyXFunc::dispatch: cmd: " << cmd << endl;
+ //lyxerr << "LyXFunc::dispatch: cmd: " << cmd << endl;
// we have not done anything wrong yet.
errorstat = false;
dispatch_buffer.erase();
-
-#ifdef NEW_DISPATCHER
- // We try do call the most specific dispatcher first:
- // 1. the lockinginset's dispatch
- // 2. the bufferview's dispatch
- // 3. the lyxview's dispatch
-#endif
-
selection_possible = false;
- string argument = ev.argument;
- kb_action action = ev.action;
+ bool update = true;
- // We cannot use this function here
- if (getStatus(ev).disabled()) {
+ FuncStatus const flag = getStatus(cmd);
+ if (!flag.enabled()) {
+ // We cannot use this function here
lyxerr[Debug::ACTION] << "LyXFunc::dispatch: "
<< lyxaction.getActionName(action)
<< " [" << action << "] is disabled at this location"
<< endl;
- setErrorMessage(getStatusMessage());
- goto exit_with_message;
- }
+ setErrorMessage(flag.message());
+ } else {
- if (view()->available())
- view()->hideCursor();
-
- if (view()->available() && view()->theLockingInset()) {
- Inset::RESULT result;
- if ((action > 1) || ((action == LFUN_UNKNOWN_ACTION) &&
- (!keyseq.deleted())))
- {
- UpdatableInset * inset = view()->theLockingInset();
-#if 1
- int inset_x;
- int dummy_y;
- inset->getCursorPos(view(), inset_x, dummy_y);
-#endif
- if ((action == LFUN_UNKNOWN_ACTION)
- && argument.empty()) {
- argument = encoded_last_key;
- }
+ if (view()->available())
+ view()->hideCursor();
- // the insets can't try to handle this,
- // a table cell in the dummy position will
- // lock its insettext, the insettext will
- // pass it the bufferview, and succeed,
- // so it will stay not locked. Not good
- // if we've just done LFUN_ESCAPE (which
- // injects an LFUN_PARAGRAPH_UPDATE)
- if (action == LFUN_PARAGRAPH_UPDATE) {
- view()->dispatch(ev);
- goto exit_with_message;
- }
+ switch (action) {
- // Undo/Redo is a bit tricky for insets.
- if (action == LFUN_UNDO) {
- view()->undo();
- goto exit_with_message;
- } else if (action == LFUN_REDO) {
- view()->redo();
- goto exit_with_message;
- } else if (((result=inset->
- // Hand-over to inset's own dispatch:
- localDispatch(FuncRequest(view(), action, argument))) ==
- DISPATCHED) ||
- (result == DISPATCHED_NOUPDATE))
- goto exit_with_message;
- // If UNDISPATCHED, just soldier on
- else if (result == FINISHED) {
- owner->clearMessage();
- goto exit_with_message;
- // We do not need special RTL handling here:
- // FINISHED means that the cursor should be
- // one position after the inset.
- } else if (result == FINISHED_RIGHT) {
- TEXT()->cursorRight(view());
- moveCursorUpdate(true, false);
- owner->clearMessage();
- goto exit_with_message;
- } else if (result == FINISHED_UP) {
- if (TEXT()->cursor.irow() != TEXT()->rows().begin()) {
-#if 1
- TEXT()->setCursorFromCoordinates(
- TEXT()->cursor.ix() + inset_x,
- TEXT()->cursor.iy() -
- TEXT()->cursor.irow()->baseline() - 1);
- TEXT()->cursor.x_fix(TEXT()->cursor.x());
-#else
- TEXT()->cursorUp(view());
-#endif
- moveCursorUpdate(true, false);
- } else {
- view()->update(TEXT(), BufferView::SELECT);
- }
- owner->clearMessage();
- goto exit_with_message;
- } else if (result == FINISHED_DOWN) {
- if (boost::next(TEXT()->cursor.irow()) != TEXT()->rows().end()) {
-#if 1
- TEXT()->setCursorFromCoordinates(
- TEXT()->cursor.ix() + inset_x,
- TEXT()->cursor.iy() -
- TEXT()->cursor.irow()->baseline() +
- TEXT()->cursor.irow()->height() + 1);
- TEXT()->cursor.x_fix(TEXT()->cursor.x());
-#else
- TEXT()->cursorDown(view());
-#endif
- } else {
- TEXT()->cursorRight(view());
- }
- moveCursorUpdate(true, false);
- owner->clearMessage();
- goto exit_with_message;
- }
-#warning I am not sure this is still right, please have a look! (Jug 20020417)
- else { // result == UNDISPATCHED
- //setMessage(N_("Text mode"));
- switch (action) {
- case LFUN_UNKNOWN_ACTION:
- case LFUN_BREAKPARAGRAPH:
- case LFUN_BREAKLINE:
- TEXT()->cursorRight(view());
- view()->switchKeyMap();
- owner->view_state_changed();
- break;
- case LFUN_RIGHT:
- if (!TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params)) {
- TEXT()->cursorRight(view());
- moveCursorUpdate(true, false);
- owner->view_state_changed();
- }
- goto exit_with_message;
- case LFUN_LEFT:
- if (TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params)) {
- TEXT()->cursorRight(view());
- moveCursorUpdate(true, false);
- owner->view_state_changed();
- }
- goto exit_with_message;
- case LFUN_DOWN:
- if (boost::next(TEXT()->cursorRow()) != TEXT()->rows().end())
- TEXT()->cursorDown(view());
- else
- TEXT()->cursorRight(view());
- moveCursorUpdate(true, false);
- owner->view_state_changed();
- goto exit_with_message;
- default:
- break;
- }
- }
- }
- }
+ case LFUN_WORDFINDFORWARD:
+ case LFUN_WORDFINDBACKWARD: {
+ static string last_search;
+ string searched_string;
- switch (action) {
-
- case LFUN_ESCAPE:
- {
- if (!view()->available()) break;
- // this function should be used always [asierra060396]
- UpdatableInset * tli =
- view()->theLockingInset();
- if (tli) {
- UpdatableInset * lock = tli->getLockingInset();
-
- if (tli == lock) {
- view()->unlockInset(tli);
- TEXT()->cursorRight(view());
- moveCursorUpdate(true, false);
- owner->view_state_changed();
+ if (!argument.empty()) {
+ last_search = argument;
+ searched_string = argument;
} else {
- tli->unlockInsetInInset(view(),
- lock,
- true);
+ searched_string = last_search;
}
- finishUndo();
- // Tell the paragraph dialog that we changed paragraph
- dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
- }
- }
- break;
- // --- Misc -------------------------------------------
- case LFUN_WORDFINDFORWARD :
- case LFUN_WORDFINDBACKWARD : {
- static string last_search;
- string searched_string;
+ if (searched_string.empty())
+ break;
- if (!argument.empty()) {
- last_search = argument;
- searched_string = argument;
- } else {
- searched_string = last_search;
- }
- bool fw = (action == LFUN_WORDFINDFORWARD);
- if (!searched_string.empty()) {
- lyxfind::LyXFind(view(), searched_string, fw);
+ bool const fw = action == LFUN_WORDFINDFORWARD;
+ string const data =
+ lyx::find::find2string(searched_string, true, false, fw);
+ lyx::find::find(view(), FuncRequest(LFUN_WORD_FIND, data));
+ break;
}
- }
- break;
- case LFUN_PREFIX:
- {
- if (view()->available() && !view()->theLockingInset()) {
- view()->update(TEXT(), BufferView::SELECT);
- }
- owner->message(keyseq.printOptions());
- }
- break;
+ case LFUN_PREFIX:
+ owner->message(keyseq.printOptions());
+ break;
- // --- Misc -------------------------------------------
- case LFUN_EXEC_COMMAND:
- owner->focus_command_buffer();
- break;
+ case LFUN_EXEC_COMMAND:
+ owner->getToolbars().display("minibuffer", true);
+ owner->focus_command_buffer();
+ break;
- case LFUN_CANCEL: // RVDK_PATCH_5
- keyseq.reset();
- meta_fake_bit = key_modifier::none;
- if (view()->available())
- // cancel any selection
- dispatch(LFUN_MARK_OFF);
- setMessage(N_("Cancel"));
- break;
+ case LFUN_CANCEL:
+ keyseq.reset();
+ meta_fake_bit = key_modifier::none;
+ if (view()->available())
+ // cancel any selection
+ dispatch(FuncRequest(LFUN_MARK_OFF));
+ setMessage(N_("Cancel"));
+ break;
- case LFUN_META_FAKE: // RVDK_PATCH_5
- {
- meta_fake_bit = key_modifier::alt;
- setMessage(keyseq.print());
- }
- break;
+ case LFUN_META_FAKE:
+ meta_fake_bit = key_modifier::alt;
+ setMessage(keyseq.print());
+ break;
- case LFUN_READ_ONLY_TOGGLE:
- if (owner->buffer()->lyxvc.inUse()) {
- owner->buffer()->lyxvc.toggleReadOnly();
- } else {
- owner->buffer()->setReadonly(
- !owner->buffer()->isReadonly());
+ case LFUN_READ_ONLY_TOGGLE:
+ if (owner->buffer()->lyxvc().inUse())
+ owner->buffer()->lyxvc().toggleReadOnly();
+ else
+ owner->buffer()->setReadonly(
+ !owner->buffer()->isReadonly());
+ break;
+
+ // --- Menus -----------------------------------------------
+ case LFUN_MENUNEW:
+ menuNew(argument, false);
+ break;
+
+ case LFUN_MENUNEWTMPLT:
+ menuNew(argument, true);
+ break;
+
+ case LFUN_CLOSEBUFFER:
+ closeBuffer();
+ break;
+
+ case LFUN_MENUWRITE:
+ if (!owner->buffer()->isUnnamed()) {
+ string const str = bformat(_("Saving document %1$s..."),
+ MakeDisplayPath(owner->buffer()->fileName()));
+ owner->message(str);
+ MenuWrite(owner->buffer());
+ owner->message(str + _(" done."));
+ } else
+ WriteAs(owner->buffer());
+ break;
+
+ case LFUN_WRITEAS:
+ WriteAs(owner->buffer(), argument);
+ break;
+
+ case LFUN_MENURELOAD: {
+ string const file = MakeDisplayPath(view()->buffer()->fileName(), 20);
+ string text = bformat(_("Any changes will be lost. Are you sure "
+ "you want to revert to the saved version of the document %1$s?"), file);
+ int const ret = Alert::prompt(_("Revert to saved document?"),
+ text, 0, 1, _("&Revert"), _("&Cancel"));
+
+ if (ret == 0)
+ view()->reload();
+ break;
}
- break;
- case LFUN_CENTER: // this is center and redraw.
- view()->center();
- break;
+ case LFUN_UPDATE:
+ Exporter::Export(owner->buffer(), argument, true);
+ view()->showErrorList(BufferFormat(*owner->buffer()));
+ break;
- // --- Menus -----------------------------------------------
- case LFUN_MENUNEW:
- menuNew(argument, false);
- break;
+ case LFUN_PREVIEW:
+ Exporter::Preview(owner->buffer(), argument);
+ view()->showErrorList(BufferFormat(*owner->buffer()));
+ break;
- case LFUN_MENUNEWTMPLT:
- menuNew(argument, true);
- break;
+ case LFUN_BUILDPROG:
+ Exporter::Export(owner->buffer(), "program", true);
+ view()->showErrorList(_("Build"));
+ break;
- case LFUN_CLOSEBUFFER:
- closeBuffer();
- break;
+ case LFUN_RUNCHKTEX:
+ owner->buffer()->runChktex();
+ view()->showErrorList(_("ChkTeX"));
+ break;
- case LFUN_MENUWRITE:
- if (!owner->buffer()->isUnnamed()) {
- string const str = bformat(_("Saving document %1$s..."),
- MakeDisplayPath(owner->buffer()->fileName()));
- owner->message(str);
- MenuWrite(owner->buffer());
- owner->message(str + _(" done."));
- } else
- WriteAs(owner->buffer());
- break;
+ case LFUN_EXPORT:
+ if (argument == "custom")
+ owner->getDialogs().show("sendto");
+ else {
+ Exporter::Export(owner->buffer(), argument, false);
+ view()->showErrorList(BufferFormat(*owner->buffer()));
+ }
+ break;
- case LFUN_WRITEAS:
- WriteAs(owner->buffer(), argument);
- break;
+ case LFUN_EXPORT_CUSTOM: {
+ string format_name;
+ string command = split(argument, format_name, ' ');
+ Format const * format = formats.getFormat(format_name);
+ if (!format) {
+ lyxerr << "Format \"" << format_name
+ << "\" not recognized!"
+ << std::endl;
+ break;
+ }
- case LFUN_MENURELOAD: {
- string const file = MakeDisplayPath(view()->buffer()->fileName(), 20);
- string text = bformat(_("Any changes will be lost. Are you sure "
- "you want to revert to the saved version of the document %1$s?"), file);
- int const ret = Alert::prompt(_("Revert to saved document?"),
- text, 0, 1, _("&Revert"), _("&Cancel"));
+ Buffer * buffer = owner->buffer();
- if (ret == 0)
- view()->reload();
- break;
- }
+ // The name of the file created by the conversion process
+ string filename;
- case LFUN_UPDATE:
- Exporter::Export(owner->buffer(), argument, true);
- view()->showErrorList(BufferFormat(*owner->buffer()));
- break;
+ // Output to filename
+ if (format->name() == "lyx") {
+ string const latexname =
+ buffer->getLatexName(false);
+ filename = ChangeExtension(latexname,
+ format->extension());
+ filename = AddName(buffer->temppath(), filename);
- case LFUN_PREVIEW:
- Exporter::Preview(owner->buffer(), argument);
- view()->showErrorList(BufferFormat(*owner->buffer()));
- break;
+ if (!buffer->writeFile(filename))
+ break;
- case LFUN_BUILDPROG:
- Exporter::Export(owner->buffer(), "program", true);
- view()->showErrorList(_("Build"));
- break;
+ } else {
+ Exporter::Export(buffer, format_name, true,
+ filename);
+ }
- case LFUN_RUNCHKTEX:
- owner->buffer()->runChktex();
- view()->showErrorList(_("ChkTeX"));
- break;
+ // Substitute $$FName for filename
+ if (!contains(command, "$$FName"))
+ command = "( " + command + " ) < $$FName";
+ command = subst(command, "$$FName", filename);
- case LFUN_EXPORT:
- if (argument == "custom")
- owner->getDialogs().showSendto();
- else {
- Exporter::Export(owner->buffer(), argument, false);
- view()->showErrorList(BufferFormat(*owner->buffer()));
+ // Execute the command in the background
+ Systemcall call;
+ call.startscript(Systemcall::DontWait, command);
+ break;
}
- break;
-
- case LFUN_IMPORT:
- doImport(argument);
- break;
- case LFUN_QUIT:
- QuitLyX();
- break;
+ case LFUN_PRINT: {
+ string target;
+ string target_name;
+ string command = split(split(argument, target, ' '),
+ target_name, ' ');
+
+ if (target.empty()
+ || target_name.empty()
+ || command.empty()) {
+ lyxerr << "Unable to parse \""
+ << argument << '"' << std::endl;
+ break;
+ }
+ if (target != "printer" && target != "file") {
+ lyxerr << "Unrecognized target \""
+ << target << '"' << std::endl;
+ break;
+ }
- case LFUN_TOCVIEW:
- {
- InsetCommandParams p("tableofcontents");
- string const data = InsetCommandMailer::params2string("toc", p);
- owner->getDialogs().show("toc", data, 0);
- break;
- }
+ Buffer * buffer = owner->buffer();
- case LFUN_AUTOSAVE:
- AutoSave(view());
- break;
+ if (!Exporter::Export(buffer, "dvi", true)) {
+ showPrintError(buffer->fileName());
+ break;
+ }
- case LFUN_UNDO:
- view()->undo();
- break;
+ // Push directory path.
+ string const path = buffer->temppath();
+ Path p(path);
+
+ // there are three cases here:
+ // 1. we print to a file
+ // 2. we print directly to a printer
+ // 3. we print using a spool command (print to file first)
+ Systemcall one;
+ int res = 0;
+ string const dviname =
+ ChangeExtension(buffer->getLatexName(true),
+ "dvi");
+
+ if (target == "printer") {
+ if (!lyxrc.print_spool_command.empty()) {
+ // case 3: print using a spool
+ string const psname =
+ ChangeExtension(dviname,".ps");
+ command += lyxrc.print_to_file
+ + QuoteName(psname)
+ + ' '
+ + QuoteName(dviname);
+
+ string command2 =
+ lyxrc.print_spool_command +' ';
+ if (target_name != "default") {
+ command2 += lyxrc.print_spool_printerprefix
+ + target_name
+ + ' ';
+ }
+ command2 += QuoteName(psname);
+ // First run dvips.
+ // If successful, then spool command
+ res = one.startscript(
+ Systemcall::Wait,
+ command);
+
+ if (res == 0)
+ res = one.startscript(
+ Systemcall::DontWait,
+ command2);
+ } else {
+ // case 2: print directly to a printer
+ res = one.startscript(
+ Systemcall::DontWait,
+ command + QuoteName(dviname));
+ }
- case LFUN_REDO:
- view()->redo();
- break;
+ } else {
+ // case 1: print to a file
+ command += lyxrc.print_to_file
+ + QuoteName(MakeAbsPath(target_name,
+ path))
+ + ' '
+ + QuoteName(dviname);
+ res = one.startscript(Systemcall::DontWait,
+ command);
+ }
- case LFUN_DEPTH_MIN:
- changeDepth(view(), TEXT(false), DEC_DEPTH, false);
- owner->view_state_changed();
- break;
+ if (res != 0)
+ showPrintError(buffer->fileName());
+ break;
+ }
- case LFUN_DEPTH_PLUS:
- changeDepth(view(), TEXT(false), INC_DEPTH, false);
- owner->view_state_changed();
- break;
+ case LFUN_IMPORT:
+ doImport(argument);
+ break;
- case LFUN_FREEFONT_APPLY:
- apply_freefont(view());
- break;
+ case LFUN_QUIT:
+ QuitLyX();
+ break;
- case LFUN_FREEFONT_UPDATE:
- update_and_apply_freefont(view(), argument);
- break;
+ case LFUN_TOCVIEW: {
+ InsetCommandParams p("tableofcontents");
+ string const data = InsetCommandMailer::params2string("toc", p);
+ owner->getDialogs().show("toc", data, 0);
+ break;
+ }
- case LFUN_RECONFIGURE:
- Reconfigure(view());
- break;
+ case LFUN_AUTOSAVE:
+ AutoSave(view());
+ break;
-#if 0
- case LFUN_FLOATSOPERATE:
- if (argument == "openfoot")
- view()->allFloats(1,0);
- else if (argument == "closefoot")
- view()->allFloats(0,0);
- else if (argument == "openfig")
- view()->allFloats(1,1);
- else if (argument == "closefig")
- view()->allFloats(0,1);
- break;
-#else
-#ifdef WITH_WARNINGS
-//#warning Find another implementation here (or another lyxfunc)!
-#endif
-#endif
- case LFUN_HELP_OPEN:
- {
- string const arg = argument;
- if (arg.empty()) {
- setErrorMessage(N_("Missing argument"));
+ case LFUN_RECONFIGURE:
+ Reconfigure(view());
break;
- }
- string const fname = i18nLibFileSearch("doc", arg, "lyx");
- if (fname.empty()) {
- lyxerr << "LyX: unable to find documentation file `"
- << arg << "'. Bad installation?" << endl;
+
+ case LFUN_HELP_OPEN: {
+ string const arg = argument;
+ if (arg.empty()) {
+ setErrorMessage(N_("Missing argument"));
+ break;
+ }
+ string const fname = i18nLibFileSearch("doc", arg, "lyx");
+ if (fname.empty()) {
+ lyxerr << "LyX: unable to find documentation file `"
+ << arg << "'. Bad installation?" << endl;
+ break;
+ }
+ owner->message(bformat(_("Opening help file %1$s..."),
+ MakeDisplayPath(fname)));
+ view()->loadLyXFile(fname, false);
break;
}
- owner->message(bformat(_("Opening help file %1$s..."),
- MakeDisplayPath(fname)));
- view()->loadLyXFile(fname, false);
- break;
- }
// --- version control -------------------------------
- case LFUN_VC_REGISTER:
- {
- if (!ensureBufferClean(view()))
+ case LFUN_VC_REGISTER:
+ if (!ensureBufferClean(view()))
+ break;
+ if (!owner->buffer()->lyxvc().inUse()) {
+ owner->buffer()->lyxvc().registrer();
+ view()->reload();
+ }
break;
- if (!owner->buffer()->lyxvc.inUse()) {
- owner->buffer()->lyxvc.registrer();
- view()->reload();
- }
- }
- break;
- case LFUN_VC_CHECKIN:
- {
- if (!ensureBufferClean(view()))
+ case LFUN_VC_CHECKIN:
+ if (!ensureBufferClean(view()))
+ break;
+ if (owner->buffer()->lyxvc().inUse()
+ && !owner->buffer()->isReadonly()) {
+ owner->buffer()->lyxvc().checkIn();
+ view()->reload();
+ }
break;
- if (owner->buffer()->lyxvc.inUse()
- && !owner->buffer()->isReadonly()) {
- owner->buffer()->lyxvc.checkIn();
- view()->reload();
- }
- }
- break;
- case LFUN_VC_CHECKOUT:
- {
- if (!ensureBufferClean(view()))
+ case LFUN_VC_CHECKOUT:
+ if (!ensureBufferClean(view()))
+ break;
+ if (owner->buffer()->lyxvc().inUse()
+ && owner->buffer()->isReadonly()) {
+ owner->buffer()->lyxvc().checkOut();
+ view()->reload();
+ }
break;
- if (owner->buffer()->lyxvc.inUse()
- && owner->buffer()->isReadonly()) {
- owner->buffer()->lyxvc.checkOut();
- view()->reload();
- }
- }
- break;
- case LFUN_VC_REVERT:
- {
- owner->buffer()->lyxvc.revert();
- view()->reload();
- }
- break;
+ case LFUN_VC_REVERT:
+ owner->buffer()->lyxvc().revert();
+ view()->reload();
+ break;
- case LFUN_VC_UNDO:
- {
- owner->buffer()->lyxvc.undoLast();
- view()->reload();
- }
- break;
+ case LFUN_VC_UNDO:
+ owner->buffer()->lyxvc().undoLast();
+ view()->reload();
+ break;
- // --- buffers ----------------------------------------
+ // --- buffers ----------------------------------------
+ case LFUN_SWITCHBUFFER:
+ view()->setBuffer(bufferlist.getBuffer(argument));
+ break;
- case LFUN_SWITCHBUFFER:
- view()->buffer(bufferlist.getBuffer(argument));
- break;
+ case LFUN_NEXTBUFFER:
+ view()->setBuffer(bufferlist.next(view()->buffer()));
+ break;
- case LFUN_FILE_NEW:
- NewFile(view(), argument);
- break;
+ case LFUN_PREVIOUSBUFFER:
+ view()->setBuffer(bufferlist.previous(view()->buffer()));
+ break;
- case LFUN_FILE_OPEN:
- open(argument);
- break;
+ case LFUN_FILE_NEW:
+ NewFile(view(), argument);
+ break;
- case LFUN_LAYOUT_TABULAR:
- if (view()->theLockingInset()) {
- if (view()->theLockingInset()->lyxCode()==Inset::TABULAR_CODE) {
- InsetTabular * inset = static_cast<InsetTabular *>
- (view()->theLockingInset());
- inset->openLayoutDialog(view());
- } else if (view()->theLockingInset()->
- getFirstLockingInsetOfType(Inset::TABULAR_CODE)!=0) {
- InsetTabular * inset = static_cast<InsetTabular *>(
- view()->theLockingInset()->getFirstLockingInsetOfType(Inset::TABULAR_CODE));
- inset->openLayoutDialog(view());
- }
- }
- break;
+ case LFUN_FILE_OPEN:
+ open(argument);
+ break;
- case LFUN_DROP_LAYOUTS_CHOICE:
- owner->getToolbar().openLayoutList();
- break;
+ case LFUN_DROP_LAYOUTS_CHOICE:
+ owner->getToolbars().openLayoutList();
+ break;
- case LFUN_MENU_OPEN_BY_NAME:
- owner->getMenubar().openByName(argument);
- break; // RVDK_PATCH_5
+ case LFUN_MENU_OPEN_BY_NAME:
+ owner->getMenubar().openByName(argument);
+ break;
- // --- lyxserver commands ----------------------------
+ // --- lyxserver commands ----------------------------
+ case LFUN_GETNAME:
+ setMessage(owner->buffer()->fileName());
+ lyxerr[Debug::INFO] << "FNAME["
+ << owner->buffer()->fileName()
+ << "] " << endl;
+ break;
+ case LFUN_NOTIFY:
+ dispatch_buffer = keyseq.print();
+ lyxserver->notifyClient(dispatch_buffer);
+ break;
- case LFUN_GETNAME:
- setMessage(owner->buffer()->fileName());
- lyxerr[Debug::INFO] << "FNAME["
- << owner->buffer()->fileName()
- << "] " << endl;
- break;
+ case LFUN_GOTOFILEROW: {
+ string file_name;
+ int row;
+ istringstream is(argument);
+ is >> file_name >> row;
+ if (prefixIs(file_name, getTmpDir())) {
+ // Needed by inverse dvi search. If it is a file
+ // in tmpdir, call the apropriated function
+ view()->setBuffer(bufferlist.getBufferFromTmp(file_name));
+ } else {
+ // Must replace extension of the file to be .lyx
+ // and get full path
+ string const s = ChangeExtension(file_name, ".lyx");
+ // Either change buffer or load the file
+ if (bufferlist.exists(s)) {
+ view()->setBuffer(bufferlist.getBuffer(s));
+ } else {
+ view()->loadLyXFile(s);
+ }
+ }
- case LFUN_NOTIFY:
- {
- dispatch_buffer = keyseq.print();
- lyxserver->notifyClient(dispatch_buffer);
- }
- break;
+ view()->setCursorFromRow(row);
- case LFUN_GOTOFILEROW:
- {
- string file_name;
- int row;
- istringstream istr(argument.c_str());
- istr >> file_name >> row;
- // Must replace extension of the file to be .lyx and get full path
- string const s(ChangeExtension(file_name, ".lyx"));
-
- // Either change buffer or load the file
- if (bufferlist.exists(s)) {
- view()->buffer(bufferlist.getBuffer(s));
- } else {
- view()->loadLyXFile(s);
+ view()->center();
+ // see BufferView_pimpl::center()
+ view()->updateScrollbar();
+ break;
}
- view()->setCursorFromRow(row);
+ case LFUN_GOTO_PARAGRAPH: {
+ istringstream is(argument);
+ int id;
+ is >> id;
+ ParIterator par = owner->buffer()->getParFromID(id);
+ if (par == owner->buffer()->par_iterator_end()) {
+ lyxerr[Debug::INFO] << "No matching paragraph found! ["
+ << id << ']' << endl;
+ break;
+ } else {
+ lyxerr[Debug::INFO] << "Paragraph " << par->id()
+ << " found." << endl;
+ }
- view()->center();
- // see BufferView_pimpl::center()
- view()->updateScrollbar();
- }
- break;
+ // Set the cursor
+ view()->setCursor(par, 0);
- case LFUN_GOTO_PARAGRAPH:
- {
- istringstream istr(argument.c_str());
+ view()->switchKeyMap();
+ owner->view_state_changed();
- int id;
- istr >> id;
- ParIterator par = owner->buffer()->getParFromID(id);
- if (par == owner->buffer()->par_iterator_end()) {
- lyxerr[Debug::INFO] << "No matching paragraph found! ["
- << id << ']' << endl;
+ view()->center();
+ // see BufferView_pimpl::center()
+ view()->updateScrollbar();
break;
- } else {
- lyxerr[Debug::INFO] << "Paragraph " << par->id()
- << " found." << endl;
}
- if (view()->theLockingInset())
- view()->unlockInset(view()->theLockingInset());
- if (par->inInset()) {
- FuncRequest cmd(view(), LFUN_INSET_EDIT, "left");
- par->inInset()->localDispatch(cmd);
- }
- // Set the cursor
- view()->getLyXText()->setCursor(par.pit(), 0);
- view()->switchKeyMap();
- owner->view_state_changed();
-
- view()->center();
- // see BufferView_pimpl::center()
- view()->updateScrollbar();
- }
- break;
-
- // --- insert characters ----------------------------------------
-
- // --- Mathed stuff. If we are here, there is no locked inset yet.
- case LFUN_MATH_EXTERN:
- case LFUN_MATH_NUMBER:
- case LFUN_MATH_NONUMBER:
- case LFUN_MATH_LIMITS:
- {
- setErrorMessage(N_("This is only allowed in math mode!"));
- }
- break;
+ case LFUN_DIALOG_SHOW: {
+ string const name = cmd.getArg(0);
+ string data = trim(cmd.argument.substr(name.size()));
- // passthrough hat and underscore outside mathed:
- case LFUN_SUBSCRIPT:
- dispatch(FuncRequest(view(), LFUN_SELFINSERT, "_"));
- break;
- case LFUN_SUPERSCRIPT:
- dispatch(FuncRequest(view(), LFUN_SELFINSERT, "^"));
- break;
+ if (name == "character") {
+ data = freefont2string();
+ if (!data.empty())
+ owner->getDialogs().show("character", data);
+ }
- case LFUN_DIALOG_SHOW: {
- string const name = ev.getArg(0);
- string data = trim(ev.argument.substr(name.size()));
-
- if (name == "character") {
- data = freefont2string();
- if (!data.empty())
- owner->getDialogs().show("character", data);
- } else if (name == "document")
- owner->getDialogs().showDocument();
- else if (name == "findreplace")
- owner->getDialogs().showSearch();
- else if (name == "forks")
- owner->getDialogs().showForks();
- else if (name == "preamble")
- owner->getDialogs().showPreamble();
- else if (name == "preferences")
- owner->getDialogs().showPreferences();
- else if (name == "print")
- owner->getDialogs().showPrint();
- else if (name == "spellchecker")
- owner->getDialogs().showSpellchecker();
- else
- owner->getDialogs().show(name, data);
- break;
- }
+ else if (name == "latexlog") {
+ pair<Buffer::LogType, string> const logfile =
+ owner->buffer()->getLogName();
+ switch (logfile.first) {
+ case Buffer::latexlog:
+ data = "latex ";
+ break;
+ case Buffer::buildlog:
+ data = "literate ";
+ break;
+ }
+ data += logfile.second;
+ owner->getDialogs().show("log", data);
+ }
+ else if (name == "vclog") {
+ string const data = "vc " +
+ owner->buffer()->lyxvc().getLogFile();
+ owner->getDialogs().show("log", data);
+ }
+ else
+ owner->getDialogs().show(name, data);
+ break;
+ }
- case LFUN_DIALOG_SHOW_NEW_INSET: {
- string const & name = argument;
- string data;
- if (name == "bibitem" ||
- name == "bibtex" ||
- name == "include" ||
- name == "index" ||
- name == "ref" ||
- name == "toc" ||
- name == "url") {
- InsetCommandParams p(name);
- data = InsetCommandMailer::params2string(name, p);
- } else if (name == "citation") {
- InsetCommandParams p("cite");
- data = InsetCommandMailer::params2string(name, p);
+ case LFUN_DIALOG_SHOW_NEW_INSET: {
+ string const name = cmd.getArg(0);
+ string data = trim(cmd.argument.substr(name.size()));
+ if (name == "bibitem" ||
+ name == "bibtex" ||
+ name == "include" ||
+ name == "index" ||
+ name == "label" ||
+ name == "ref" ||
+ name == "toc" ||
+ name == "url") {
+ InsetCommandParams p(name);
+ data = InsetCommandMailer::params2string(name, p);
+ } else if (name == "box") {
+ // \c data == "Boxed" || "Frameless" etc
+ InsetBoxParams p(data);
+ data = InsetBoxMailer::params2string(p);
+ } else if (name == "branch") {
+ InsetBranchParams p;
+ data = InsetBranchMailer::params2string(p);
+ } else if (name == "citation") {
+ InsetCommandParams p("cite");
+ data = InsetCommandMailer::params2string(name, p);
+ } else if (name == "ert") {
+ data = InsetERTMailer::params2string(InsetCollapsable::Open);
+ } else if (name == "external") {
+ InsetExternalParams p;
+ Buffer const & buffer = *owner->buffer();
+ data = InsetExternalMailer::params2string(p, buffer);
+ } else if (name == "float") {
+ InsetFloatParams p;
+ data = InsetFloatMailer::params2string(p);
+ } else if (name == "graphics") {
+ InsetGraphicsParams p;
+ Buffer const & buffer = *owner->buffer();
+ data = InsetGraphicsMailer::params2string(p, buffer);
+ } else if (name == "note") {
+ InsetNoteParams p;
+ data = InsetNoteMailer::params2string(p);
+ } else if (name == "vspace") {
+ VSpace space;
+ data = InsetVSpaceMailer::params2string(space);
+ } else if (name == "wrap") {
+ InsetWrapParams p;
+ data = InsetWrapMailer::params2string(p);
+ }
+ owner->getDialogs().show(name, data, 0);
+ break;
}
- owner->getDialogs().show(name, data, 0);
- }
- break;
- case LFUN_DIALOG_SHOW_NEXT_INSET: {
- }
- break;
+ case LFUN_DIALOG_SHOW_NEXT_INSET:
+ break;
- case LFUN_DIALOG_UPDATE: {
- string const & name = argument;
- // Can only update a dialog connected to an existing inset
- InsetBase * inset = owner->getDialogs().getOpenInset(name);
- if (inset) {
- FuncRequest fr(view(), LFUN_INSET_DIALOG_UPDATE,
- ev.argument);
- inset->localDispatch(fr);
- } else if (name == "paragraph") {
- dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
+ case LFUN_DIALOG_UPDATE: {
+ string const & name = argument;
+ // Can only update a dialog connected to an existing inset
+ InsetBase * inset = owner->getDialogs().getOpenInset(name);
+ if (inset) {
+ FuncRequest fr(LFUN_INSET_DIALOG_UPDATE, cmd.argument);
+ inset->dispatch(view()->cursor(), fr);
+ } else if (name == "paragraph") {
+ dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
+ } else if (name == "prefs") {
+ owner->getDialogs().update(name, string());
+ }
+ break;
}
- }
- break;
- case LFUN_DIALOG_HIDE:
- Dialogs::hide(argument, 0);
- break;
+ case LFUN_DIALOG_HIDE:
+ Dialogs::hide(argument, 0);
+ break;
- case LFUN_DIALOG_DISCONNECT_INSET:
- owner->getDialogs().disconnect(argument);
- break;
+ case LFUN_DIALOG_DISCONNECT_INSET:
+ owner->getDialogs().disconnect(argument);
+ break;
- case LFUN_CHILDOPEN:
- {
- string const filename =
- MakeAbsPath(argument,
- owner->buffer()->filePath());
- setMessage(N_("Opening child document ") +
- MakeDisplayPath(filename) + "...");
- view()->savePosition(0);
- if (bufferlist.exists(filename))
- view()->buffer(bufferlist.getBuffer(filename));
- else
- view()->loadLyXFile(filename);
- }
- break;
+ case LFUN_CHILDOPEN: {
+ string const filename =
+ MakeAbsPath(argument, owner->buffer()->filePath());
+ setMessage(N_("Opening child document ") +
+ MakeDisplayPath(filename) + "...");
+ view()->savePosition(0);
+ string const parentfilename = owner->buffer()->fileName();
+ if (bufferlist.exists(filename))
+ view()->setBuffer(bufferlist.getBuffer(filename));
+ else
+ view()->loadLyXFile(filename);
+ // Set the parent name of the child document.
+ // This makes insertion of citations and references in the child work,
+ // when the target is in the parent or another child document.
+ owner->buffer()->setParentName(parentfilename);
+ break;
+ }
- case LFUN_TOGGLECURSORFOLLOW:
- lyxrc.cursor_follows_scrollbar = !lyxrc.cursor_follows_scrollbar;
- break;
+ case LFUN_TOGGLECURSORFOLLOW:
+ lyxrc.cursor_follows_scrollbar = !lyxrc.cursor_follows_scrollbar;
+ break;
- case LFUN_KMAP_OFF:
- owner->getIntl().KeyMapOn(false);
- break;
+ case LFUN_KMAP_OFF:
+ owner->getIntl().KeyMapOn(false);
+ break;
- case LFUN_KMAP_PRIM:
- owner->getIntl().KeyMapPrim();
- break;
+ case LFUN_KMAP_PRIM:
+ owner->getIntl().KeyMapPrim();
+ break;
- case LFUN_KMAP_SEC:
- owner->getIntl().KeyMapSec();
- break;
+ case LFUN_KMAP_SEC:
+ owner->getIntl().KeyMapSec();
+ break;
- case LFUN_KMAP_TOGGLE:
- owner->getIntl().ToggleKeyMap();
- break;
+ case LFUN_KMAP_TOGGLE:
+ owner->getIntl().ToggleKeyMap();
+ break;
- case LFUN_SEQUENCE:
- {
- // argument contains ';'-terminated commands
- while (!argument.empty()) {
- string first;
- argument = split(argument, first, ';');
- dispatch(first);
+ case LFUN_REPEAT: {
+ // repeat command
+ string countstr;
+ string rest = split(argument, countstr, ' ');
+ istringstream is(countstr);
+ int count = 0;
+ is >> count;
+ lyxerr << "repeat: count: " << count << " cmd: " << rest << endl;
+ for (int i = 0; i < count; ++i)
+ dispatch(lyxaction.lookupFunc(rest));
+ break;
}
- }
- break;
- case LFUN_SAVEPREFERENCES:
- {
- Path p(user_lyxdir);
- lyxrc.write("preferences");
- }
- break;
+ case LFUN_SEQUENCE: {
+ // argument contains ';'-terminated commands
+ string arg = argument;
+ while (!arg.empty()) {
+ string first;
+ arg = split(arg, first, ';');
+ FuncRequest func(lyxaction.lookupFunc(first));
+ func.origin = cmd.origin;
+ dispatch(func);
+ }
+ break;
+ }
- case LFUN_SCREEN_FONT_UPDATE:
- {
- // handle the screen font changes.
- lyxrc.set_font_norm_type();
- lyx_gui::update_fonts();
- // We also need to empty the textcache so that
- // the buffer will be formatted correctly after
- // a zoom change.
- textcache.clear();
- // Of course we should only do the resize and the textcache.clear
- // if values really changed...but not very important right now. (Lgb)
- // All visible buffers will need resize
- view()->resize();
- view()->repaint();
- }
- break;
+ case LFUN_SAVEPREFERENCES: {
+ Path p(user_lyxdir());
+ lyxrc.write("preferences", false);
+ break;
+ }
- case LFUN_SET_COLOR:
- {
- string lyx_name;
- string const x11_name = split(argument, lyx_name, ' ');
- if (lyx_name.empty() || x11_name.empty()) {
- setErrorMessage(N_("Syntax: set-color <lyx_name>"
- " <x11_name>"));
+ case LFUN_SCREEN_FONT_UPDATE:
+ // handle the screen font changes.
+ lyxrc.set_font_norm_type();
+ lyx_gui::update_fonts();
+ // All visible buffers will need resize
+ view()->resize();
break;
+
+ case LFUN_SET_COLOR: {
+ string lyx_name;
+ string const x11_name = split(argument, lyx_name, ' ');
+ if (lyx_name.empty() || x11_name.empty()) {
+ setErrorMessage(N_("Syntax: set-color <lyx_name>"
+ " <x11_name>"));
+ break;
}
- bool const graphicsbg_changed =
- (lyx_name == lcolor.getLyXName(LColor::graphicsbg) &&
- x11_name != lcolor.getX11Name(LColor::graphicsbg));
+ bool const graphicsbg_changed =
+ (lyx_name == lcolor.getLyXName(LColor::graphicsbg) &&
+ x11_name != lcolor.getX11Name(LColor::graphicsbg));
- if (!lcolor.setColor(lyx_name, x11_name)) {
- setErrorMessage(
- bformat(_("Set-color \"%1$s\" failed "
- "- color is undefined or "
- "may not be redefined"), lyx_name));
- break;
- }
+ if (!lcolor.setColor(lyx_name, x11_name)) {
+ setErrorMessage(
+ bformat(_("Set-color \"%1$s\" failed "
+ "- color is undefined or "
+ "may not be redefined"), lyx_name));
+ break;
+ }
- lyx_gui::update_color(lcolor.getFromLyXName(lyx_name));
+ lyx_gui::update_color(lcolor.getFromLyXName(lyx_name));
- if (graphicsbg_changed) {
+ if (graphicsbg_changed) {
#ifdef WITH_WARNINGS
#warning FIXME!! The graphics cache no longer has a changeDisplay method.
#endif
#if 0
- grfx::GCache & gc = grfx::GCache::get();
- gc.changeDisplay(true);
+ lyx::graphics::GCache::get().changeDisplay(true);
#endif
+ }
+ break;
}
- view()->repaint();
- break;
- }
+ case LFUN_MESSAGE:
+ owner->message(argument);
+ break;
- case LFUN_MESSAGE:
- owner->message(argument);
- break;
+ case LFUN_TOOLTIPS_TOGGLE:
+ owner->getDialogs().toggleTooltips();
+ break;
- case LFUN_FORKS_KILL:
- {
- if (!isStrInt(argument))
+ case LFUN_EXTERNAL_EDIT: {
+ FuncRequest fr(action, argument);
+ InsetExternal().dispatch(view()->cursor(), fr);
break;
+ }
- pid_t const pid = strToInt(argument);
- ForkedcallsController & fcc = ForkedcallsController::get();
- fcc.kill(pid);
- break;
- }
+ case LFUN_GRAPHICS_EDIT: {
+ FuncRequest fr(action, argument);
+ InsetGraphics().dispatch(view()->cursor(), fr);
+ break;
+ }
- case LFUN_TOOLTIPS_TOGGLE:
- owner->getDialogs().toggleTooltips();
- break;
+ case LFUN_ALL_INSETS_TOGGLE: {
+ string action;
+ string const name = split(argument, action, ' ');
+ InsetBase::Code const inset_code =
+ InsetBase::translate(name);
+
+ LCursor & cur = view()->cursor();
+ FuncRequest fr(LFUN_INSET_TOGGLE, action);
+
+ InsetBase & inset = owner->buffer()->inset();
+ InsetIterator it = inset_iterator_begin(inset);
+ InsetIterator const end = inset_iterator_end(inset);
+ for (; it != end; ++it) {
+ if (inset_code == InsetBase::NO_CODE
+ || inset_code == it->lyxCode())
+ it->dispatch(cur, fr);
+ }
+ break;
+ }
- case LFUN_EXTERNAL_EDIT: {
- InsetExternal()
- .localDispatch(FuncRequest(view(), action, argument));
- break;
- }
+ case LFUN_LANGUAGE_BUFFER: {
+ Buffer & buffer = *owner->buffer();
+ Language const * oldL = buffer.params().language;
+ Language const * newL = languages.getLanguage(argument);
+ if (!newL || oldL == newL)
+ break;
- default:
- // Then if it was none of the above
- // Trying the BufferView::pimpl dispatch:
- if (!view()->dispatch(ev))
- lyxerr << "A truly unknown func ["
- << lyxaction.getActionName(ev.action) << "]!"
- << endl;
- break;
- } // end of switch
+ if (oldL->RightToLeft() == newL->RightToLeft()
+ && !buffer.isMultiLingual())
+ buffer.changeLanguage(oldL, newL);
+ else
+ buffer.updateDocLang(newL);
+ break;
+ }
-exit_with_message:
+ case LFUN_SAVE_AS_DEFAULT: {
+ string const fname =
+ AddName(AddPath(user_lyxdir(), "templates/"),
+ "defaults.lyx");
+ Buffer defaults(fname);
+
+ istringstream ss(argument);
+ LyXLex lex(0,0);
+ lex.setStream(ss);
+ int const unknown_tokens = defaults.readHeader(lex);
+
+ if (unknown_tokens != 0) {
+ lyxerr << "Warning in LFUN_SAVE_AS_DEFAULT!\n"
+ << unknown_tokens << " unknown token"
+ << (unknown_tokens == 1 ? "" : "s")
+ << endl;
+ }
- view()->owner()->updateLayoutChoice();
+ if (defaults.writeFile(defaults.fileName()))
+ setMessage(_("Document defaults saved in ")
+ + MakeDisplayPath(fname));
+ else
+ setErrorMessage(_("Unable to save document defaults"));
+ break;
+ }
- if (view()->available()) {
- view()->fitCursor();
+ case LFUN_BUFFERPARAMS_APPLY: {
+ biblio::CiteEngine const engine =
+ owner->buffer()->params().cite_engine;
+
+ istringstream ss(argument);
+ LyXLex lex(0,0);
+ lex.setStream(ss);
+ int const unknown_tokens =
+ owner->buffer()->readHeader(lex);
+
+ if (unknown_tokens != 0) {
+ lyxerr << "Warning in LFUN_BUFFERPARAMS_APPLY!\n"
+ << unknown_tokens << " unknown token"
+ << (unknown_tokens == 1 ? "" : "s")
+ << endl;
+ }
+ if (engine == owner->buffer()->params().cite_engine)
+ break;
- // If we executed a mutating lfun, mark the buffer as dirty
- if (!lyxaction.funcHasFlag(ev.action, LyXAction::NoBuffer)
- && !lyxaction.funcHasFlag(ev.action, LyXAction::ReadOnly))
- view()->buffer()->markDirty();
- }
+ LCursor & cur = view()->cursor();
+ FuncRequest fr(LFUN_INSET_REFRESH);
+
+ InsetBase & inset = owner->buffer()->inset();
+ InsetIterator it = inset_iterator_begin(inset);
+ InsetIterator const end = inset_iterator_end(inset);
+ for (; it != end; ++it)
+ if (it->lyxCode() == InsetBase::CITE_CODE)
+ it->dispatch(cur, fr);
+ break;
+ }
+
+ case LFUN_TEXTCLASS_APPLY: {
+ Buffer * buffer = owner->buffer();
+
+ lyx::textclass_type const old_class =
+ buffer->params().textclass;
+
+ loadTextclass(argument);
+
+ std::pair<bool, lyx::textclass_type> const tc_pair =
+ textclasslist.NumberOfClass(argument);
+
+ if (!tc_pair.first)
+ break;
+
+ lyx::textclass_type const new_class = tc_pair.second;
+ if (old_class == new_class)
+ // nothing to do
+ break;
+
+ owner->message(_("Converting document to new document class..."));
+ ErrorList el;
+ lyx::cap::SwitchLayoutsBetweenClasses(
+ old_class, new_class,
+ buffer->paragraphs(), el);
+
+ bufferErrors(*buffer, el);
+ view()->showErrorList(_("Class switch"));
+ break;
+ }
+
+ case LFUN_TEXTCLASS_LOAD:
+ loadTextclass(argument);
+ break;
+
+ case LFUN_LYXRC_APPLY: {
+ istringstream ss(argument);
+ bool const success = lyxrc.read(ss) == 0;
+
+ if (!success) {
+ lyxerr << "Warning in LFUN_LYXRC_APPLY!\n"
+ << "Unable to read lyxrc data"
+ << endl;
+ }
+ break;
+ }
+
+ default: {
+ update = false;
+ view()->cursor().dispatch(cmd);
+ if (view()->cursor().result().dispatched())
+ update |= view()->cursor().result().update();
+ else
+ update |= view()->dispatch(cmd);
+ break;
+ }
+ }
+
+ if (view()->available()) {
+ // Redraw screen unless explicitly told otherwise.
+ // This also initializes the position cache for all insets
+ // in (at least partially) visible top-level paragraphs.
+ view()->update(true, update);
+
+ // if we executed a mutating lfun, mark the buffer as dirty
+ if (getStatus(cmd).enabled()
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly))
+ view()->buffer()->markDirty();
+ }
- sendDispatchMessage(getMessage(), ev, verbose);
+ if (view()->cursor().inTexted()) {
+ view()->owner()->updateLayoutChoice();
+ }
+ }
+ sendDispatchMessage(getMessage(), cmd);
}
-void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & ev, bool verbose)
+void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & cmd)
{
owner->updateMenubar();
- owner->updateToolbar();
+ owner->updateToolbars();
+
+ const bool verbose = (cmd.origin == FuncRequest::UI
+ || cmd.origin == FuncRequest::COMMANDBUFFER);
- if (ev.action == LFUN_SELFINSERT || !verbose) {
+ if (cmd.action == LFUN_SELFINSERT || !verbose) {
lyxerr[Debug::ACTION] << "dispatch msg is " << msg << endl;
if (!msg.empty())
owner->message(msg);
if (!dispatch_msg.empty())
dispatch_msg += ' ';
- string comname = lyxaction.getActionName(ev.action);
+ string comname = lyxaction.getActionName(cmd.action);
- int pseudoaction = ev.action;
bool argsadded = false;
- if (!ev.argument.empty()) {
- // the pseudoaction is useful for the bindings
- pseudoaction = lyxaction.searchActionArg(ev.action, ev.argument);
-
- if (pseudoaction == LFUN_UNKNOWN_ACTION) {
- pseudoaction = ev.action;
- } else {
- comname += ' ' + ev.argument;
+ if (!cmd.argument.empty()) {
+ if (cmd.action != LFUN_UNKNOWN_ACTION) {
+ comname += ' ' + cmd.argument;
argsadded = true;
}
}
- string const shortcuts = toplevel_keymap->findbinding(pseudoaction);
+ string const shortcuts = toplevel_keymap->printbindings(cmd);
if (!shortcuts.empty()) {
comname += ": " + shortcuts;
- } else if (!argsadded && !ev.argument.empty()) {
- comname += ' ' + ev.argument;
+ } else if (!argsadded && !cmd.argument.empty()) {
+ comname += ' ' + cmd.argument;
}
if (!comname.empty()) {
void LyXFunc::setupLocalKeymap()
{
- keyseq.stdmap = keyseq.curmap = toplevel_keymap.get();
- cancel_meta_seq.stdmap = cancel_meta_seq.curmap = toplevel_keymap.get();
+ keyseq.stdmap = toplevel_keymap.get();
+ keyseq.curmap = toplevel_keymap.get();
+ cancel_meta_seq.stdmap = toplevel_keymap.get();
+ cancel_meta_seq.curmap = toplevel_keymap.get();
}
FileDialog::Result result =
fileDlg.open(lyxrc.template_path,
- _("*.lyx| LyX Documents (*.lyx)"));
+ FileFilterList(_("LyX Documents (*.lyx)")),
+ string());
if (result.first == FileDialog::Later)
return;
-
- string const fname = result.second;
-
- if (fname.empty())
+ if (result.second.empty())
return;
- templname = fname;
+ templname = result.second;
}
view()->newFile(filename, templname, !name.empty());
make_pair(string(_("Documents|#o#O")),
string(lyxrc.document_path)),
make_pair(string(_("Examples|#E#e")),
- string(AddPath(system_lyxdir, "examples"))));
+ string(AddPath(system_lyxdir(), "examples"))));
FileDialog::Result result =
fileDlg.open(initpath,
- _("*.lyx| LyX Documents (*.lyx)"));
+ FileFilterList(_("LyX Documents (*.lyx)")),
+ string());
if (result.first == FileDialog::Later)
return;
make_pair(string(_("Documents|#o#O")),
string(lyxrc.document_path)),
make_pair(string(_("Examples|#E#e")),
- string(AddPath(system_lyxdir, "examples"))));
+ string(AddPath(system_lyxdir(), "examples"))));
- string const extension = "*." + formats.extension(format)
- + "| " + formats.prettyName(format)
+ string const filter = formats.prettyName(format)
+ " (*." + formats.extension(format) + ')';
- FileDialog::Result result = fileDlg.open(initpath,
- extension);
+ FileDialog::Result result =
+ fileDlg.open(initpath,
+ FileFilterList(filter),
+ string());
if (result.first == FileDialog::Later)
return;
{
if (bufferlist.close(owner->buffer(), true) && !quitting) {
if (bufferlist.empty()) {
- view()->buffer(0);
- // need this otherwise SEGV may occur while trying to
- // set variables that don't exist
+ // need this otherwise SEGV may occur while
+ // trying to set variables that don't exist
// since there's no current buffer
owner->getDialogs().hideBufferDependent();
} else {
- view()->buffer(bufferlist.first());
+ view()->setBuffer(bufferlist.first());
}
}
}
// 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
-// This func is bit problematic when it comes to NLS, to make the
+// This function is bit problematic when it comes to NLS, to make the
// lyx servers client be language indepenent we must not translate
// strings sent to this func.
void LyXFunc::setErrorMessage(string const & m) const
}
-void LyXFunc::setStatusMessage(string const & m) const
-{
- status_buffer = m;
-}
-
-
-string const LyXFunc::view_status_message()
+string const LyXFunc::viewStatusMessage()
{
// When meta-fake key is pressed, show the key sequence so far + "M-".
- if (wasMetaKey()) {
+ if (wasMetaKey())
return keyseq.print() + "M-";
- }
// Else, when a non-complete key sequence is pressed,
// show the available options.
- if (keyseq.length() > 0 && !keyseq.deleted()) {
+ if (keyseq.length() > 0 && !keyseq.deleted())
return keyseq.printOptions();
- }
if (!view()->available())
return _("Welcome to LyX!");
- return currentState(view());
+ return view()->cursor().currentState();
}
BufferView * LyXFunc::view() const
{
- Assert(owner);
+ BOOST_ASSERT(owner);
return owner->view().get();
}
+
+
+bool LyXFunc::wasMetaKey() const
+{
+ return (meta_fake_bit != key_modifier::none);
+}