#include "bufferparams.h"
#include "BufferView.h"
#include "cursor.h"
+#include "CutAndPaste.h"
#include "debug.h"
#include "dispatchresult.h"
#include "encoding.h"
+#include "errorlist.h"
#include "exporter.h"
#include "format.h"
#include "funcrequest.h"
#include "gettext.h"
#include "importer.h"
+#include "insetiterator.h"
#include "intl.h"
-#include "iterators.h"
#include "kbmap.h"
+#include "language.h"
#include "LColor.h"
#include "lyx_cb.h"
#include "LyXAction.h"
#include "lyxfind.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 "support/filetools.h"
#include "support/forkedcontr.h"
#include "support/globbing.h"
+#include "support/lstrings.h"
#include "support/path.h"
#include "support/path_defines.h"
+#include "support/systemcall.h"
#include "support/tostr.h"
#include "support/std_sstream.h"
#include "support/os.h"
-using bv_funcs::DEC_DEPTH;
using bv_funcs::freefont2string;
-using bv_funcs::INC_DEPTH;
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::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;
FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
{
+ //lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
FuncStatus flag;
Buffer * buf = owner->buffer();
LCursor & cur = view()->cursor();
if (cmd.action == LFUN_NOACTION) {
setStatusMessage(N_("Nothing to do"));
- flag.disabled(true);
+ flag.enabled(false);
return flag;
}
case LFUN_THESAURUS_ENTRY:
#endif
flag.unknown(true);
- flag.disabled(true);
+ flag.enabled(false);
break;
default:
flag |= lyx_gui::getStatus(cmd);
setStatusMessage(N_("Command disabled"));
// Check whether we need a buffer
- if (!lyxaction.funcHasFlag(cmd.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(cmd.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"));
- flag.disabled(true);
- return flag;
- }
+ if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) && !buf) {
+ // no, exit directly
+ setStatusMessage(N_("Command not allowed with"
+ "out any document open"));
+ flag.enabled(false);
+ return flag;
}
// I would really like to avoid having this switch and rather try to
// encode this in the function itself.
- bool disable = false;
+ // -- And I'd rather let an inset decide which LFUNs it is willing
+ // to handle (Andre')
+ bool enable = true;
switch (cmd.action) {
- case LFUN_EXPORT:
- disable = cmd.argument != "custom"
- && !Exporter::IsExportable(*buf, cmd.argument);
+ 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_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_REDO:
- disable = buf->redostack().empty();
+
+ case LFUN_EXPORT:
+ enable = cmd.argument == "custom"
+ || Exporter::IsExportable(*buf, cmd.argument);
break;
case LFUN_CUT:
case LFUN_COPY:
- disable = !cur.selection();
+ 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 = !cur.innerInsetOfType(InsetBase::TABULAR_CODE);
- break;
-
- case LFUN_DEPTH_MIN:
- disable = !changeDepthAllowed(cur, view()->getLyXText(), DEC_DEPTH);
- break;
-
- case LFUN_DEPTH_PLUS:
- disable = !changeDepthAllowed(cur, view()->getLyXText(), INC_DEPTH);
+ enable = cur.innerInsetOfType(InsetBase::TABULAR_CODE);
break;
case LFUN_LAYOUT:
case LFUN_LAYOUT_PARAGRAPH:
- disable = cur.inset().forceDefaultParagraphs(&cur.inset());
- break;
-
- case LFUN_INSET_OPTARG:
- disable = cur.inMathed()
- || cur.paragraph().layout()->optionalargs == 0;
- break;
-
- case LFUN_TABULAR_FEATURE:
-#if 0
- if (cur.inMathed()) {
- // FIXME: check temporarily disabled
- // valign code
- char align = mathcursor::valign();
- if (align == '\0') {
- disable = true;
- break;
- }
- if (cmd.argument.empty()) {
- flag.clear();
- break;
- }
- if (!contains("tcb", cmd.argument[0])) {
- disable = true;
- break;
- }
- flag.setOnOff(cmd.argument[0] == align);
- } else {
- disable = true;
-
- char const align = mathcursor::halign();
- if (align == '\0') {
- disable = true;
- break;
- }
- if (cmd.argument.empty()) {
- flag.clear();
- break;
- }
- if (!contains("lcr", cmd.argument[0])) {
- disable = true;
- break;
- }
- flag.setOnOff(cmd.argument[0] == align);
-
- disable = !mathcursor::halign();
- break;
- }
-
- if (!cur.empty() && cur.inset().asUpdatableInset()) {
- FuncStatus ret;
- //ret.disabled(true);
- InsetTabular * tab = static_cast<InsetTabular *>
- (cur.innerInsetOfType(InsetBase::TABULAR_CODE));
- if (tab) {
- ret = tab->getStatus(cmd.argument);
- flag |= ret;
- disable = false;
- } else {
- disable = true;
- }
- } else {
- static InsetTabular inset(*buf, 1, 1);
- disable = true;
- FuncStatus ret = inset.getStatus(cmd.argument);
- if (ret.onoff(true) || ret.onoff(false))
- flag.setOnOff(false);
- }
-#endif
+ 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();
- break;
- case LFUN_BOOKMARK_GOTO:
- disable = !view()->
- isSavedPosition(strToUnsignedInt(cmd.argument));
+ enable = !buf->isUnnamed() && !buf->isClean();
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_SETTINGS: {
- disable = true;
+ enable = false;
+ if (!cur.size())
+ break;
UpdatableInset * inset = cur.inset().asUpdatableInset();
+ lyxerr << "inset: " << inset << endl;
if (!inset)
break;
- // jump back to owner if an InsetText, so
- // we get back to the InsetTabular or whatever
- if (inset->lyxCode() == InsetOld::TEXT_CODE)
- inset = inset->owner();
-
InsetOld::Code code = inset->lyxCode();
switch (code) {
case InsetOld::TABULAR_CODE:
- disable = cmd.argument != "tabular";
+ enable = cmd.argument == "tabular";
break;
case InsetOld::ERT_CODE:
- disable = cmd.argument != "ert";
+ enable = cmd.argument == "ert";
break;
case InsetOld::FLOAT_CODE:
- disable = cmd.argument != "float";
+ enable = cmd.argument == "float";
break;
case InsetOld::WRAP_CODE:
- disable = cmd.argument != "wrap";
+ enable = cmd.argument == "wrap";
break;
case InsetOld::NOTE_CODE:
- disable = cmd.argument != "note";
+ enable = cmd.argument == "note";
break;
case InsetOld::BRANCH_CODE:
- disable = cmd.argument != "branch";
+ enable = cmd.argument == "branch";
break;
case InsetOld::BOX_CODE:
- disable = cmd.argument != "box";
+ enable = cmd.argument == "box";
break;
default:
break;
break;
}
- case LFUN_MATH_MUTATE:
- if (cur.inMathed())
- //flag.setOnOff(mathcursor::formula()->hullType() == cmd.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 = cur.inTexted();
- break;
-
case LFUN_DIALOG_SHOW: {
string const name = cmd.getArg(0);
if (!buf)
- disable = !(name == "aboutlyx" ||
- name == "file" ||
- name == "forks" ||
- name == "preferences" ||
- name == "texinfo");
+ enable = name == "aboutlyx"
+ || name == "file"
+ || name == "forks"
+ || name == "prefs"
+ || name == "texinfo";
else if (name == "print")
- disable = !Exporter::IsExportable(*buf, "dvi") ||
- lyxrc.print_command == "none";
+ enable = Exporter::IsExportable(*buf, "dvi")
+ && lyxrc.print_command != "none";
else if (name == "character")
- disable = cur.inset().lyxCode() == InsetOld::ERT_CODE;
+ enable = cur.inset().lyxCode() != InsetOld::ERT_CODE;
else if (name == "vclog")
- disable = !buf->lyxvc().inUse();
+ enable = buf->lyxvc().inUse();
else if (name == "latexlog")
- disable = !IsFileReadable(buf->getLogName().second);
+ 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
- InsetOld::Code code = InsetOld::NO_CODE;
- switch (cmd.action) {
+ 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:
- if (cmd.argument == "bibitem")
- code = InsetOld::BIBITEM_CODE;
- else if (cmd.argument == "bibtex")
- code = InsetOld::BIBTEX_CODE;
- else if (cmd.argument == "box")
- code = InsetOld::BOX_CODE;
- else if (cmd.argument == "branch")
- code = InsetOld::BRANCH_CODE;
- else if (cmd.argument == "citation")
- code = InsetOld::CITE_CODE;
- else if (cmd.argument == "ert")
- code = InsetOld::ERT_CODE;
- else if (cmd.argument == "external")
- code = InsetOld::EXTERNAL_CODE;
- else if (cmd.argument == "float")
- code = InsetOld::FLOAT_CODE;
- else if (cmd.argument == "graphics")
- code = InsetOld::GRAPHICS_CODE;
- else if (cmd.argument == "include")
- code = InsetOld::INCLUDE_CODE;
- else if (cmd.argument == "index")
- code = InsetOld::INDEX_CODE;
- else if (cmd.argument == "label")
- code = InsetOld::LABEL_CODE;
- else if (cmd.argument == "note")
- code = InsetOld::NOTE_CODE;
- else if (cmd.argument == "ref")
- code = InsetOld::REF_CODE;
- else if (cmd.argument == "toc")
- code = InsetOld::TOC_CODE;
- else if (cmd.argument == "url")
- code = InsetOld::URL_CODE;
- else if (cmd.argument == "vspace")
- code = InsetOld::VSPACE_CODE;
- else if (cmd.argument == "wrap")
- code = InsetOld::WRAP_CODE;
+ 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_SEQUENCE:
+ 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:
+ // these are handled in our dispatch()
break;
- case LFUN_INSET_ERT:
- code = InsetOld::ERT_CODE;
- break;
- case LFUN_INSET_FOOTNOTE:
- code = InsetOld::FOOT_CODE;
- break;
- case LFUN_TABULAR_INSERT:
- code = InsetOld::TABULAR_CODE;
- break;
- case LFUN_INSET_MARGINAL:
- code = InsetOld::MARGIN_CODE;
- break;
- case LFUN_INSET_FLOAT:
- case LFUN_INSET_WIDE_FLOAT:
- code = InsetOld::FLOAT_CODE;
- break;
- case LFUN_INSET_WRAP:
- code = InsetOld::WRAP_CODE;
- break;
- case LFUN_FLOAT_LIST:
- code = InsetOld::FLOAT_LIST_CODE;
- break;
-#if 0
- case LFUN_INSET_LIST:
- code = InsetOld::LIST_CODE;
- break;
- case LFUN_INSET_THEOREM:
- code = InsetOld::THEOREM_CODE;
- break;
-#endif
- case LFUN_INSET_CAPTION:
- code = InsetOld::CAPTION_CODE;
- break;
- case LFUN_INSERT_NOTE:
- code = InsetOld::NOTE_CODE;
- break;
- case LFUN_INSERT_CHARSTYLE:
- code = InsetOld::CHARSTYLE_CODE;
- if (buf->params().getLyXTextClass().charstyles().empty())
- disable = true;
- break;
- case LFUN_INSERT_BOX:
- code = InsetOld::BOX_CODE;
- break;
- case LFUN_INSERT_BRANCH:
- code = InsetOld::BRANCH_CODE;
- if (buf->params().branchlist().empty())
- disable = true;
- break;
- case LFUN_INSERT_LABEL:
- code = InsetOld::LABEL_CODE;
- break;
- case LFUN_INSET_OPTARG:
- code = InsetOld::OPTARG_CODE;
- break;
- case LFUN_ENVIRONMENT_INSERT:
- code = InsetOld::BOX_CODE;
- break;
- case LFUN_INDEX_INSERT:
- code = InsetOld::INDEX_CODE;
- break;
- case LFUN_INDEX_PRINT:
- code = InsetOld::INDEX_PRINT_CODE;
- break;
- case LFUN_TOC_INSERT:
- code = InsetOld::TOC_CODE;
- break;
- case LFUN_HTMLURL:
- case LFUN_URL:
- code = InsetOld::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 = InsetOld::SPECIALCHAR_CODE;
- break;
- case LFUN_SPACE_INSERT:
- // slight hack: we know this is allowed in math mode
- if (cur.inTexted())
- code = InsetOld::SPACE_CODE;
- break;
- case LFUN_INSET_DIALOG_SHOW: {
- InsetBase * inset = cur.nextInset();
- disable = !inset;
- if (inset) {
- code = inset->lyxCode();
- if (!(code == InsetOld::INCLUDE_CODE
- || code == InsetOld::BIBTEX_CODE
- || code == InsetOld::FLOAT_LIST_CODE
- || code == InsetOld::TOC_CODE))
- disable = true;
- }
- break;
- }
default:
- break;
- }
-
- if (code != InsetOld::NO_CODE
- && (cur.empty() || !cur.inset().insetAllowed(code)))
- disable = true;
- if (disable)
- flag.disabled(true);
-
- // A few general toggles
- switch (cmd.action) {
- case LFUN_TOOLTIPS_TOGGLE:
- flag.setOnOff(owner->getDialogs().tooltipsEnabled());
- break;
-
- case LFUN_READ_ONLY_TOGGLE:
- flag.setOnOff(buf->isReadonly());
- break;
- case LFUN_APPENDIX:
- flag.setOnOff(cur.inTexted()
- && cur.paragraph().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 (cmd.argument == buf->fileName())
- flag.setOnOff(true);
- break;
- case LFUN_TRACK_CHANGES:
- flag.setOnOff(buf->params().tracking_changes);
- break;
- default:
- break;
+ cur.getStatus(cmd, flag);
+ if (!flag.enabled())
+ flag = view()->getStatus(cmd);
}
-#ifdef LOCK
- // the font related toggles
- if (cur.inTexted()) {
- LyXFont const & font = cur.text()->real_current_font;
- switch (cmd.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 (cmd.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;
- }
- }
-#endif
+ if (!enable)
+ flag.enabled(false);
- // this one is difficult to get right. As a half-baked
- // solution, we consider only the first action of the sequence
- if (cmd.action == LFUN_SEQUENCE) {
- // argument contains ';'-terminated commands
-#warning LyXAction arguments not handled here.
- flag = getStatus(FuncRequest(
- lyxaction.lookupFunc(token(cmd.argument, ';', 0))));
+ // Can we use a readonly buffer?
+ if (buf && buf->isReadonly()
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
+ setStatusMessage(N_("Document is read-only"));
+ flag.enabled(false);
}
+ //lyxerr << "LyXFunc::getStatus: got: " << flag.enabled() << endl;
return flag;
}
return buf.isClean();
}
+
+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 loadTextclass(string const & name)
+{
+ std::pair<bool, lyx::textclass_type> const tc_pair =
+ textclasslist.NumberOfClass(name);
+
+ 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 & cmd, bool verbose)
{
- string argument = cmd.argument;
- kb_action action = cmd.action;
+ 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;
dispatch_buffer.erase();
selection_possible = false;
+ bool update = true;
+
// We cannot use this function here
- if (getStatus(cmd).disabled()) {
+ if (!getStatus(cmd).enabled()) {
lyxerr[Debug::ACTION] << "LyXFunc::dispatch: "
<< lyxaction.getActionName(action)
<< " [" << action << "] is disabled at this location"
if (!argument.empty()) {
last_search = argument;
searched_string = argument;
- } else
+ } else {
searched_string = last_search;
+ }
if (searched_string.empty())
break;
bool const fw = action == LFUN_WORDFINDFORWARD;
string const data =
lyx::find::find2string(searched_string, true, false, fw);
- view()->dispatch(FuncRequest(LFUN_WORD_FIND, data));
+ lyx::find::find(view(), FuncRequest(LFUN_WORD_FIND, data));
break;
}
break;
case LFUN_EXEC_COMMAND:
+ owner->getToolbar().display("minibuffer", true);
owner->focus_command_buffer();
break;
case LFUN_EXPORT:
if (argument == "custom")
- owner->getDialogs().showSendto();
+ owner->getDialogs().show("sendto");
else {
Exporter::Export(owner->buffer(), argument, false);
view()->showErrorList(BufferFormat(*owner->buffer()));
}
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;
+ }
+
+ Buffer * buffer = owner->buffer();
+
+ // The name of the file created by the conversion process
+ string filename;
+
+ // Output to filename
+ if (format->name() == "lyx") {
+ string const latexname =
+ buffer->getLatexName(false);
+ filename = ChangeExtension(latexname,
+ format->extension());
+ filename = AddName(buffer->temppath(), filename);
+
+ if (!buffer->writeFile(filename))
+ break;
+
+ } else {
+ Exporter::Export(buffer, format_name, true,
+ filename);
+ }
+
+ // Substitute $$FName for filename
+ if (!contains(command, "$$FName"))
+ command = "( " + command + " ) < $$FName";
+ command = subst(command, "$$FName", filename);
+
+ // Execute the command in the background
+ Systemcall call;
+ call.startscript(Systemcall::DontWait, command);
+ 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;
+ }
+
+ Buffer * buffer = owner->buffer();
+
+ if (!Exporter::Export(buffer, "dvi", true)) {
+ showPrintError(buffer->fileName());
+ 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));
+ }
+
+ } 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);
+ }
+
+ if (res != 0)
+ showPrintError(buffer->fileName());
+ break;
+ }
+
case LFUN_IMPORT:
doImport(argument);
break;
if (!data.empty())
owner->getDialogs().show("character", data);
}
- else if (name == "document")
- owner->getDialogs().showDocument();
- 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 if (name == "latexlog") {
pair<Buffer::LogType, string> const logfile =
case LFUN_DIALOG_SHOW_NEXT_INSET:
break;
- case LFUN_INSET_DIALOG_SHOW: {
- InsetBase * inset = view()->cursor().nextInset();
- if (inset)
- inset->dispatch(view()->cursor(), FuncRequest(LFUN_INSET_DIALOG_SHOW));
- break;
- }
-
case LFUN_DIALOG_UPDATE: {
string const & name = argument;
// Can only update a dialog connected to an existing inset
inset->dispatch(view()->cursor(), fr);
} else if (name == "paragraph") {
dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
+ } else if (name == "prefs") {
+ owner->getDialogs().update(name, string());
}
break;
}
case LFUN_REPEAT: {
// repeat command
string countstr;
- argument = split(argument, countstr, ' ');
+ string rest = split(argument, countstr, ' ');
istringstream is(countstr);
int count = 0;
is >> count;
- lyxerr << "repeat: count: " << count << " cmd: " << argument << endl;
+ lyxerr << "repeat: count: " << count << " cmd: " << rest << endl;
for (int i = 0; i < count; ++i)
- dispatch(lyxaction.lookupFunc(argument));
+ dispatch(lyxaction.lookupFunc(rest));
break;
}
// argument contains ';'-terminated commands
while (!argument.empty()) {
string first;
- argument = split(argument, first, ';');
- dispatch(lyxaction.lookupFunc(first));
+ string rest = split(argument, first, ';');
+ dispatch(lyxaction.lookupFunc(rest));
}
break;
case LFUN_SAVEPREFERENCES: {
Path p(user_lyxdir());
- lyxrc.write("preferences");
+ lyxrc.write("preferences", false);
break;
}
(lyx_name == lcolor.getLyXName(LColor::graphicsbg) &&
x11_name != lcolor.getX11Name(LColor::graphicsbg));
- LColor::color col = lcolor.getFromLyXName(lyx_name);
- if (!lcolor.setColor(col, x11_name)) {
+ if (!lcolor.setColor(lyx_name, x11_name)) {
setErrorMessage(
bformat(_("Set-color \"%1$s\" failed "
"- color is undefined or "
owner->message(argument);
break;
- case LFUN_FORKS_KILL:
- if (isStrInt(argument))
- ForkedcallsController::get().kill(strToInt(argument));
- break;
-
case LFUN_TOOLTIPS_TOGGLE:
owner->getDialogs().toggleTooltips();
break;
- case LFUN_EXTERNAL_EDIT:
- InsetExternal().dispatch(view()->cursor(), FuncRequest(action, argument));
+ case LFUN_EXTERNAL_EDIT: {
+ FuncRequest fr(action, argument);
+ InsetExternal().dispatch(view()->cursor(), fr);
+ break;
+ }
+
+ case LFUN_GRAPHICS_EDIT: {
+ FuncRequest fr(action, argument);
+ InsetGraphics().dispatch(view()->cursor(), fr);
+ 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_LANGUAGE_BUFFER: {
+ Buffer & buffer = *owner->buffer();
+ Language const * oldL = buffer.params().language;
+ Language const * newL = languages.getLanguage(argument);
+ if (!newL || oldL == newL)
+ break;
- default:
+ if (oldL->RightToLeft() == newL->RightToLeft()
+ && !buffer.isMultiLingual())
+ buffer.changeLanguage(oldL, newL);
+ else
+ buffer.updateDocLang(newL);
+ break;
+ }
+
+ case LFUN_BUFFERPARAMS_APPLY: {
+ 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;
+ }
+ 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;
DispatchResult res = view()->cursor().dispatch(cmd);
- if (!res.dispatched());
- view()->dispatch(cmd);
+ if (res.dispatched())
+ update |= res.update();
+ else
+ update |= view()->dispatch(cmd);
+
break;
}
- }
+ }
- if (view()->cursor().inTexted())
- view()->owner()->updateLayoutChoice();
+ if (view()->available()) {
+ if (view()->fitCursor() || update)
+ view()->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();
+ }
- if (view()->available()) {
- view()->fitCursor();
- view()->update();
- view()->cursor().updatePos();
- // if we executed a mutating lfun, mark the buffer as dirty
- if (!getStatus(cmd).disabled()
- && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)
- && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly))
- view()->buffer()->markDirty();
+ if (view()->cursor().inTexted()) {
+ view()->owner()->updateLayoutChoice();
+ sendDispatchMessage(getMessage(), cmd, verbose);
+ }
}
-
- if (view()->cursor().inTexted())
- sendDispatchMessage(getMessage(), cmd, verbose);
}
projects / lyx.git / blobdiff