#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 "frontends/LyXKeySym.h"
#include "frontends/LyXView.h"
#include "frontends/Menubar.h"
-#include "frontends/Toolbar.h"
+#include "frontends/Toolbars.h"
+#include "support/filefilterlist.h"
#include "support/FileInfo.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/tostr.h"
-#include "support/std_sstream.h"
+#include "support/package.h"
+#include "support/systemcall.h"
+#include "support/convert.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::isStrInt;
using lyx::support::MakeAbsPath;
using lyx::support::MakeDisplayPath;
+using lyx::support::package;
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::system_lyxdir;
+using lyx::support::subst;
+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;
using std::endl;
using std::make_pair;
using std::string;
using std::istringstream;
+namespace biblio = lyx::biblio;
+
extern BufferList bufferlist;
extern LyXServer * lyxserver;
-extern bool selection_possible;
extern boost::scoped_ptr<kb_keymap> toplevel_keymap;
extern tex_accent_struct get_accent(kb_action action);
+namespace {
+
+bool getStatus(LCursor cursor,
+ FuncRequest const & cmd, FuncStatus & status)
+{
+ // This is, of course, a mess. Better create a new doc iterator and use
+ // this in Inset::getStatus. This might require an additional
+ // BufferView * arg, though (which should be avoided)
+ //LCursor safe = *this;
+ bool res = false;
+ for ( ; cursor.size(); cursor.pop()) {
+ //lyxerr << "\nLCursor::getStatus: cmd: " << cmd << endl << *this << endl;
+ DocIterator::idx_type & idx = cursor.idx();
+ DocIterator::idx_type const lastidx = cursor.lastidx();
+
+ if (idx > lastidx) {
+ lyxerr << "wrong idx " << idx << ", max is " << lastidx
+ << ". Trying to correct this." << endl;
+ idx = lastidx;
+ }
+
+ DocIterator::pit_type & pit = cursor.pit();
+ DocIterator::pit_type const lastpit = cursor.lastpit();
+
+ if (pit > lastpit) {
+ lyxerr << "wrong par " << pit << ", max is " << lastpit
+ << ". Trying to correct this." << endl;
+ pit = lastpit;
+ }
+
+ DocIterator::pos_type & pos = cursor.pos();
+ DocIterator::pos_type const lastpos = cursor.lastpos();
+
+ if (pos > lastpos) {
+ lyxerr << "wrong pos " << pos << ", max is " << lastpos
+ << ". Trying to correct this." << endl;
+ pos = lastpos;
+ }
+
+ // The inset's getStatus() will return 'true' if it made
+ // a definitive decision on whether it want to handle the
+ // request or not. The result of this decision is put into
+ // the 'status' parameter.
+ if (cursor.inset().getStatus(cursor, cmd, status)) {
+ res = true;
+ break;
+ }
+ }
+ return res;
+}
+
+}
+
LyXFunc::LyXFunc(LyXView * lv)
: owner(lv),
encoded_last_key(0),
{
//lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
FuncStatus flag;
- Buffer * buf = owner->buffer();
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) {
- setStatusMessage(N_("Nothing to do"));
+ flag.message(N_("Nothing to do"));
flag.enabled(false);
return flag;
}
}
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"));
+ if (!flag.enabled()) {
+ if (flag.message().empty())
+ flag.message(N_("Command disabled"));
+ return flag;
+ }
// 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.enabled(false);
- }
- } else {
- // no
- setStatusMessage(N_("Command not allowed with"
- "out any document open"));
- flag.enabled(false);
- return flag;
- }
+ 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;
}
// I would really like to avoid having this switch and rather try to
flag.setOnOff(true);
break;
- case LFUN_TRACK_CHANGES:
- flag.setOnOff(buf->params().tracking_changes);
- break;
-
case LFUN_EXPORT:
enable = cmd.argument == "custom"
|| Exporter::IsExportable(*buf, cmd.argument);
break;
- case LFUN_UNDO:
- enable = !buf->undostack().empty();
- break;
- case LFUN_REDO:
- enable = !buf->redostack().empty();
- break;
case LFUN_CUT:
case LFUN_COPY:
enable = cur.selection();
case LFUN_MENURELOAD:
enable = !buf->isUnnamed() && !buf->isClean();
break;
- case LFUN_BOOKMARK_GOTO:
- enable = view()->isSavedPosition(strToUnsignedInt(cmd.argument));
- break;
- case LFUN_MERGE_CHANGES:
- case LFUN_ACCEPT_CHANGE:
- case LFUN_REJECT_CHANGE:
- case LFUN_ACCEPT_ALL_CHANGES:
- case LFUN_REJECT_ALL_CHANGES:
- enable = buf && buf->params().tracking_changes;
- break;
case LFUN_INSET_SETTINGS: {
enable = false;
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();
- lyxerr << "inset 2: " << inset << endl;
- if (!inset)
- break;
-
- InsetOld::Code code = inset->lyxCode();
+ InsetBase::Code code = inset->lyxCode();
switch (code) {
- case InsetOld::TABULAR_CODE:
+ case InsetBase::TABULAR_CODE:
enable = cmd.argument == "tabular";
break;
- case InsetOld::ERT_CODE:
+ case InsetBase::ERT_CODE:
enable = cmd.argument == "ert";
break;
- case InsetOld::FLOAT_CODE:
+ case InsetBase::FLOAT_CODE:
enable = cmd.argument == "float";
break;
- case InsetOld::WRAP_CODE:
+ case InsetBase::WRAP_CODE:
enable = cmd.argument == "wrap";
break;
- case InsetOld::NOTE_CODE:
+ case InsetBase::NOTE_CODE:
enable = cmd.argument == "note";
break;
- case InsetOld::BRANCH_CODE:
+ case InsetBase::BRANCH_CODE:
enable = cmd.argument == "branch";
break;
- case InsetOld::BOX_CODE:
+ case InsetBase::BOX_CODE:
enable = cmd.argument == "box";
break;
default:
if (!buf)
enable = name == "aboutlyx"
|| name == "file"
- || name == "preferences"
+ || 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() != InsetOld::ERT_CODE;
+ enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
else if (name == "vclog")
enable = buf->lyxvc().inUse();
else if (name == "latexlog")
break;
}
+ case LFUN_DIALOG_UPDATE: {
+ string const name = cmd.getArg(0);
+ if (!buf)
+ enable = name == "prefs";
+ 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);
+ }
+
case LFUN_MENUNEW:
case LFUN_MENUNEWTMPLT:
case LFUN_WORDFINDFORWARD:
case LFUN_GOTO_PARAGRAPH:
case LFUN_DIALOG_SHOW_NEW_INSET:
case LFUN_DIALOG_SHOW_NEXT_INSET:
- case LFUN_DIALOG_UPDATE:
case LFUN_DIALOG_HIDE:
case LFUN_DIALOG_DISCONNECT_INSET:
case LFUN_CHILDOPEN:
case LFUN_KMAP_SEC:
case LFUN_KMAP_TOGGLE:
case LFUN_REPEAT:
- case LFUN_SEQUENCE:
+ 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;
default:
- cur.getStatus(cmd, flag);
- return flag;
+
+ if (!::getStatus(cur, cmd, flag))
+ flag = view()->getStatus(cmd);
}
- flag.enabled(enable);
+ 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);
+ }
+
+ // the default error message if we disable the command
+ if (!flag.enabled() && flag.message().empty())
+ flag.message(N_("Command disabled"));
+
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);
+ }
+}
+
+
+void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new);
+
} //namespace anon
-void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
+void LyXFunc::dispatch(FuncRequest const & cmd)
{
+ BOOST_ASSERT(view());
string const argument = cmd.argument;
kb_action const action = cmd.action;
// we have not done anything wrong yet.
errorstat = false;
dispatch_buffer.erase();
- selection_possible = false;
- // We cannot use this function here
- if (!getStatus(cmd).enabled()) {
+ bool update = true;
+
+ 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());
-
+ setErrorMessage(flag.message());
} else {
if (view()->available())
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->getToolbars().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;
case LFUN_QUIT:
-#if 0
- // test speed of DocumentIterator
- lyxerr << "start" << endl;
- for (DocumentIterator it(owner->buffer()->inset()), end;
- it != end; it.forwardPos())
- ;
- lyxerr << "end" << endl;
-#endif
QuitLyX();
break;
view()->setBuffer(bufferlist.getBuffer(argument));
break;
+ case LFUN_NEXTBUFFER:
+ view()->setBuffer(bufferlist.next(view()->buffer()));
+ break;
+
+ case LFUN_PREVIOUSBUFFER:
+ view()->setBuffer(bufferlist.previous(view()->buffer()));
+ break;
+
case LFUN_FILE_NEW:
NewFile(view(), argument);
break;
break;
case LFUN_DROP_LAYOUTS_CHOICE:
- owner->getToolbar().openLayoutList();
+ owner->getToolbars().openLayoutList();
break;
case LFUN_MENU_OPEN_BY_NAME:
int row;
istringstream is(argument);
is >> file_name >> row;
- if (prefixIs(file_name, getTmpDir())) {
+ if (prefixIs(file_name, package().temp_dir())) {
// Needed by inverse dvi search. If it is a file
// in tmpdir, call the apropriated function
view()->setBuffer(bufferlist.getBufferFromTmp(file_name));
if (!data.empty())
owner->getDialogs().show("character", data);
}
- else if (name == "document")
- owner->getDialogs().showDocument();
- 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 =
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_SEQUENCE:
+ case LFUN_SEQUENCE: {
// argument contains ';'-terminated commands
- while (!argument.empty()) {
+ string arg = argument;
+ while (!arg.empty()) {
string first;
- string rest = split(argument, first, ';');
- dispatch(lyxaction.lookupFunc(rest));
+ arg = split(arg, first, ';');
+ FuncRequest func(lyxaction.lookupFunc(first));
+ func.origin = cmd.origin;
+ dispatch(func);
}
break;
+ }
case LFUN_SAVEPREFERENCES: {
- Path p(user_lyxdir());
- lyxrc.write("preferences");
+ Path p(package().user_support());
+ 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 "
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;
+
+ if (oldL->RightToLeft() == newL->RightToLeft()
+ && !buffer.isMultiLingual())
+ buffer.changeLanguage(oldL, newL);
+ else
+ buffer.updateDocLang(newL);
+ break;
+ }
+
+ case LFUN_SAVE_AS_DEFAULT: {
+ string const fname =
+ AddName(AddPath(package().user_support(), "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;
+ }
+
+ if (defaults.writeFile(defaults.fileName()))
+ setMessage(_("Document defaults saved in ")
+ + MakeDisplayPath(fname));
+ else
+ setErrorMessage(_("Unable to save document defaults"));
+ break;
+ }
+
+ 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;
+
+ 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: {
+ LyXRC const lyxrc_orig = lyxrc;
+
+ 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;
+ }
+
+ actOnUpdatedPrefs(lyxrc_orig, lyxrc);
+ break;
+ }
+
default: {
- DispatchResult res = view()->cursor().dispatch(cmd);
- if (!res.dispatched());
- view()->dispatch(cmd);
+ 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()) {
- view()->fitCursor();
- view()->update();
- view()->cursor().updatePos();
- // 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()) {
+ // 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();
+ }
- if (view()->cursor().inTexted()) {
- view()->owner()->updateLayoutChoice();
- sendDispatchMessage(getMessage(), cmd, verbose);
+ if (view()->cursor().inTexted()) {
+ view()->owner()->updateLayoutChoice();
+ }
}
+ sendDispatchMessage(getMessage(), cmd);
}
-void LyXFunc::sendDispatchMessage(string const & msg,
- FuncRequest const & cmd, 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 (cmd.action == LFUN_SELFINSERT || !verbose) {
lyxerr[Debug::ACTION] << "dispatch msg is " << msg << endl;
}
}
- string const shortcuts = toplevel_keymap->findbinding(cmd);
+ string const shortcuts = toplevel_keymap->printbindings(cmd);
if (!shortcuts.empty()) {
comname += ": " + shortcuts;
if (filename.empty()) {
filename = AddName(lyxrc.document_path,
- "newfile" + tostr(++newfile_number) + ".lyx");
+ "newfile" + convert<string>(++newfile_number) + ".lyx");
FileInfo fi(filename);
while (bufferlist.exists(filename) || fi.readable()) {
++newfile_number;
filename = AddName(lyxrc.document_path,
- "newfile" + tostr(newfile_number) +
+ "newfile" + convert<string>(newfile_number) +
".lyx");
fi.newFile(filename);
}
make_pair(string(_("Documents|#o#O")),
string(lyxrc.document_path)),
make_pair(string(_("Examples|#E#e")),
- string(AddPath(system_lyxdir(), "examples"))));
+ string(AddPath(package().system_support(), "examples"))));
FileDialog::Result result =
fileDlg.open(initpath,
make_pair(string(_("Documents|#o#O")),
string(lyxrc.document_path)),
make_pair(string(_("Examples|#E#e")),
- string(AddPath(system_lyxdir(), "examples"))));
+ string(AddPath(package().system_support(), "examples"))));
string const filter = formats.prettyName(format)
+ " (*." + formats.extension(format) + ')';
}
-void LyXFunc::setStatusMessage(string const & m) const
-{
- status_buffer = m;
-}
-
-
string const LyXFunc::viewStatusMessage()
{
// When meta-fake key is pressed, show the key sequence so far + "M-".
{
return (meta_fake_bit != key_modifier::none);
}
+
+
+namespace {
+
+void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
+{
+ // Why the switch you might ask. It is a trick to ensure that all
+ // the elements in the LyXRCTags enum is handled. As you can see
+ // there are no breaks at all. So it is just a huge fall-through.
+ // The nice thing is that we will get a warning from the compiler
+ // if we forget an element.
+ LyXRC::LyXRCTags tag = LyXRC::RC_LAST;
+ switch (tag) {
+ case LyXRC::RC_ACCEPT_COMPOUND:
+ case LyXRC::RC_ALT_LANG:
+ case LyXRC::RC_ASCIIROFF_COMMAND:
+ case LyXRC::RC_ASCII_LINELEN:
+ case LyXRC::RC_AUTOREGIONDELETE:
+ case LyXRC::RC_AUTORESET_OPTIONS:
+ case LyXRC::RC_AUTOSAVE:
+ case LyXRC::RC_AUTO_NUMBER:
+ case LyXRC::RC_BACKUPDIR_PATH:
+ case LyXRC::RC_BIBTEX_COMMAND:
+ case LyXRC::RC_BINDFILE:
+ case LyXRC::RC_CHECKLASTFILES:
+ case LyXRC::RC_CHKTEX_COMMAND:
+ case LyXRC::RC_CONVERTER:
+ case LyXRC::RC_COPIER:
+ case LyXRC::RC_CURSOR_FOLLOWS_SCROLLBAR:
+ case LyXRC::RC_CUSTOM_EXPORT_COMMAND:
+ case LyXRC::RC_CUSTOM_EXPORT_FORMAT:
+ case LyXRC::RC_CYGWIN_PATH_FIX:
+ if (lyxrc_orig.cygwin_path_fix != lyxrc_new.cygwin_path_fix) {
+ namespace os = lyx::support::os;
+ os::cygwin_path_fix(lyxrc_new.cygwin_path_fix);
+ }
+ case LyXRC::RC_DATE_INSERT_FORMAT:
+ case LyXRC::RC_DEFAULT_LANGUAGE:
+ case LyXRC::RC_DEFAULT_PAPERSIZE:
+ case LyXRC::RC_DIALOGS_ICONIFY_WITH_MAIN:
+ case LyXRC::RC_DISPLAY_GRAPHICS:
+ case LyXRC::RC_DOCUMENTPATH:
+ if (lyxrc_orig.document_path != lyxrc_new.document_path) {
+ FileInfo fi(lyxrc_new.document_path);
+ if (fi.isOK() && fi.isDir()) {
+ using lyx::support::package;
+ package().document_dir() = lyxrc.document_path;
+ }
+ }
+ case LyXRC::RC_ESC_CHARS:
+ case LyXRC::RC_FONT_ENCODING:
+ case LyXRC::RC_FORMAT:
+ case LyXRC::RC_INDEX_COMMAND:
+ case LyXRC::RC_INPUT:
+ case LyXRC::RC_KBMAP:
+ case LyXRC::RC_KBMAP_PRIMARY:
+ case LyXRC::RC_KBMAP_SECONDARY:
+ case LyXRC::RC_LABEL_INIT_LENGTH:
+ case LyXRC::RC_LANGUAGE_AUTO_BEGIN:
+ case LyXRC::RC_LANGUAGE_AUTO_END:
+ case LyXRC::RC_LANGUAGE_COMMAND_BEGIN:
+ case LyXRC::RC_LANGUAGE_COMMAND_END:
+ case LyXRC::RC_LANGUAGE_COMMAND_LOCAL:
+ case LyXRC::RC_LANGUAGE_GLOBAL_OPTIONS:
+ case LyXRC::RC_LANGUAGE_PACKAGE:
+ case LyXRC::RC_LANGUAGE_USE_BABEL:
+ case LyXRC::RC_LASTFILES:
+ case LyXRC::RC_MAKE_BACKUP:
+ case LyXRC::RC_MARK_FOREIGN_LANGUAGE:
+ case LyXRC::RC_NUMLASTFILES:
+ case LyXRC::RC_PATH_PREFIX:
+ if (lyxrc_orig.path_prefix != lyxrc_new.path_prefix) {
+ using lyx::support::prependEnvPath;
+ prependEnvPath("PATH", lyxrc.path_prefix);
+ }
+ case LyXRC::RC_PERS_DICT:
+ case LyXRC::RC_POPUP_BOLD_FONT:
+ case LyXRC::RC_POPUP_FONT_ENCODING:
+ case LyXRC::RC_POPUP_NORMAL_FONT:
+ case LyXRC::RC_PREVIEW:
+ case LyXRC::RC_PREVIEW_HASHED_LABELS:
+ case LyXRC::RC_PREVIEW_SCALE_FACTOR:
+ case LyXRC::RC_PRINTCOLLCOPIESFLAG:
+ case LyXRC::RC_PRINTCOPIESFLAG:
+ case LyXRC::RC_PRINTER:
+ case LyXRC::RC_PRINTEVENPAGEFLAG:
+ case LyXRC::RC_PRINTEXSTRAOPTIONS:
+ case LyXRC::RC_PRINTFILEEXTENSION:
+ case LyXRC::RC_PRINTLANDSCAPEFLAG:
+ case LyXRC::RC_PRINTODDPAGEFLAG:
+ case LyXRC::RC_PRINTPAGERANGEFLAG:
+ case LyXRC::RC_PRINTPAPERDIMENSIONFLAG:
+ case LyXRC::RC_PRINTPAPERFLAG:
+ case LyXRC::RC_PRINTREVERSEFLAG:
+ case LyXRC::RC_PRINTSPOOL_COMMAND:
+ case LyXRC::RC_PRINTSPOOL_PRINTERPREFIX:
+ case LyXRC::RC_PRINTTOFILE:
+ case LyXRC::RC_PRINTTOPRINTER:
+ case LyXRC::RC_PRINT_ADAPTOUTPUT:
+ case LyXRC::RC_PRINT_COMMAND:
+ case LyXRC::RC_RTL_SUPPORT:
+ case LyXRC::RC_SCREEN_DPI:
+ case LyXRC::RC_SCREEN_FONT_ENCODING:
+ case LyXRC::RC_SCREEN_FONT_ROMAN:
+ case LyXRC::RC_SCREEN_FONT_ROMAN_FOUNDRY:
+ case LyXRC::RC_SCREEN_FONT_SANS:
+ case LyXRC::RC_SCREEN_FONT_SANS_FOUNDRY:
+ case LyXRC::RC_SCREEN_FONT_SCALABLE:
+ case LyXRC::RC_SCREEN_FONT_SIZES:
+ case LyXRC::RC_SCREEN_FONT_TYPEWRITER:
+ case LyXRC::RC_SCREEN_FONT_TYPEWRITER_FOUNDRY:
+ case LyXRC::RC_SCREEN_ZOOM:
+ case LyXRC::RC_SERVERPIPE:
+ case LyXRC::RC_SET_COLOR:
+ case LyXRC::RC_SHOW_BANNER:
+ case LyXRC::RC_SPELL_COMMAND:
+ case LyXRC::RC_TEMPDIRPATH:
+ case LyXRC::RC_TEMPLATEPATH:
+ case LyXRC::RC_UIFILE:
+ case LyXRC::RC_USER_EMAIL:
+ case LyXRC::RC_USER_NAME:
+ case LyXRC::RC_USETEMPDIR:
+ case LyXRC::RC_USE_ALT_LANG:
+ case LyXRC::RC_USE_ESC_CHARS:
+ case LyXRC::RC_USE_INP_ENC:
+ case LyXRC::RC_USE_PERS_DICT:
+ case LyXRC::RC_USE_SPELL_LIB:
+ case LyXRC::RC_VIEWDVI_PAPEROPTION:
+ case LyXRC::RC_VIEWER:
+ case LyXRC::RC_WHEEL_JUMP:
+ case LyXRC::RC_LAST:
+ break;
+ }
+}
+
+} // namespace anon
projects / lyx.git / blobdiff