]> git.lyx.org Git - lyx.git/blob - src/LyXFunc.cpp
Cleanups:
[lyx.git] / src / LyXFunc.cpp
1 /**
2  * \file LyXFunc.cpp
3  * This file is part of LyX, the document processor.
4  * Licence details can be found in the file COPYING.
5  *
6  * \author Alfredo Braunstein
7  * \author Lars Gullik Bjønnes
8  * \author Jean-Marc Lasgouttes
9  * \author Angus Leeming
10  * \author John Levon
11  * \author André Pönitz
12  * \author Allan Rae
13  * \author Dekel Tsur
14  * \author Martin Vermeer
15  * \author Jürgen Vigna
16  *
17  * Full author contact details are available in file CREDITS.
18  */
19
20 #include <config.h>
21
22 #include "LyXFunc.h"
23
24 #include "LayoutFile.h"
25 #include "BranchList.h"
26 #include "buffer_funcs.h"
27 #include "Buffer.h"
28 #include "BufferList.h"
29 #include "BufferParams.h"
30 #include "BufferView.h"
31 #include "CmdDef.h"
32 #include "Color.h"
33 #include "Converter.h"
34 #include "Cursor.h"
35 #include "CutAndPaste.h"
36 #include "DispatchResult.h"
37 #include "Encoding.h"
38 #include "ErrorList.h"
39 #include "Format.h"
40 #include "FuncRequest.h"
41 #include "FuncStatus.h"
42 #include "InsetIterator.h"
43 #include "Intl.h"
44 #include "KeyMap.h"
45 #include "Language.h"
46 #include "LaTeXFeatures.h"
47 #include "Lexer.h"
48 #include "LyXAction.h"
49 #include "lyxfind.h"
50 #include "LyX.h"
51 #include "LyXRC.h"
52 #include "LyXVC.h"
53 #include "Paragraph.h"
54 #include "ParagraphParameters.h"
55 #include "ParIterator.h"
56 #include "Row.h"
57 #include "Server.h"
58 #include "Session.h"
59 #include "SpellChecker.h"
60
61 #include "frontends/alert.h"
62 #include "frontends/Application.h"
63 #include "frontends/KeySymbol.h"
64 #include "frontends/LyXView.h"
65 #include "frontends/Selection.h"
66
67 #include "support/debug.h"
68 #include "support/environment.h"
69 #include "support/FileName.h"
70 #include "support/filetools.h"
71 #include "support/gettext.h"
72 #include "support/lassert.h"
73 #include "support/lstrings.h"
74 #include "support/Path.h"
75 #include "support/Package.h"
76 #include "support/Systemcall.h"
77 #include "support/convert.h"
78 #include "support/os.h"
79
80 #include <sstream>
81 #include <vector>
82
83 using namespace std;
84 using namespace lyx::support;
85
86 namespace lyx {
87
88 using frontend::LyXView;
89
90 namespace Alert = frontend::Alert;
91
92 namespace {
93
94
95 // This function runs "configure" and then rereads lyx.defaults to
96 // reconfigure the automatic settings.
97 void reconfigure(LyXView * lv, string const & option)
98 {
99         // emit message signal.
100         if (lv)
101                 lv->message(_("Running configure..."));
102
103         // Run configure in user lyx directory
104         PathChanger p(package().user_support());
105         string configure_command = package().configure_command();
106         configure_command += option;
107         Systemcall one;
108         int ret = one.startscript(Systemcall::Wait, configure_command);
109         p.pop();
110         // emit message signal.
111         if (lv)
112                 lv->message(_("Reloading configuration..."));
113         lyxrc.read(libFileSearch(string(), "lyxrc.defaults"));
114         // Re-read packages.lst
115         LaTeXFeatures::getAvailable();
116
117         if (ret)
118                 Alert::information(_("System reconfiguration failed"),
119                            _("The system reconfiguration has failed.\n"
120                                   "Default textclass is used but LyX may "
121                                   "not be able to work properly.\n"
122                                   "Please reconfigure again if needed."));
123         else
124
125                 Alert::information(_("System reconfigured"),
126                            _("The system has been reconfigured.\n"
127                              "You need to restart LyX to make use of any\n"
128                              "updated document class specifications."));
129 }
130
131 }
132
133
134 LyXFunc::LyXFunc()
135         : encoded_last_key(0), meta_fake_bit(NoModifier)
136 {
137 }
138
139
140 void LyXFunc::initKeySequences(KeyMap * kb)
141 {
142         keyseq = KeySequence(kb, kb);
143         cancel_meta_seq = KeySequence(kb, kb);
144 }
145
146
147 void LyXFunc::handleKeyFunc(FuncCode action)
148 {
149         char_type c = encoded_last_key;
150
151         if (keyseq.length())
152                 c = 0;
153         LyXView * lv = theApp()->currentWindow();
154         LASSERT(lv && lv->currentBufferView(), /**/);
155         BufferView * bv = lv->currentBufferView();
156         bv->getIntl().getTransManager().deadkey(
157                 c, get_accent(action).accent, bv->cursor().innerText(),
158                 bv->cursor());
159         // Need to clear, in case the minibuffer calls these
160         // actions
161         keyseq.clear();
162         // copied verbatim from do_accent_char
163         bv->cursor().resetAnchor();
164         bv->processUpdateFlags(Update::FitCursor);
165 }
166
167 //FIXME: bookmark handling is a frontend issue. This code should be transferred
168 // to GuiView and be GuiView and be window dependent.
169 void LyXFunc::gotoBookmark(unsigned int idx, bool openFile, bool switchToBuffer)
170 {
171         LyXView * lv = theApp()->currentWindow();
172         LASSERT(lv, /**/);
173         if (!theSession().bookmarks().isValid(idx))
174                 return;
175         BookmarksSection::Bookmark const & bm = theSession().bookmarks().bookmark(idx);
176         LASSERT(!bm.filename.empty(), /**/);
177         string const file = bm.filename.absFilename();
178         // if the file is not opened, open it.
179         if (!theBufferList().exists(bm.filename)) {
180                 if (openFile)
181                         dispatch(FuncRequest(LFUN_FILE_OPEN, file));
182                 else
183                         return;
184         }
185         // open may fail, so we need to test it again
186         if (!theBufferList().exists(bm.filename))
187                 return;
188
189         // bm can be changed when saving
190         BookmarksSection::Bookmark tmp = bm;
191
192         // Special case idx == 0 used for back-from-back jump navigation
193         if (idx == 0)
194                 dispatch(FuncRequest(LFUN_BOOKMARK_SAVE, "0"));
195
196         // if the current buffer is not that one, switch to it.
197         if (!lv->documentBufferView()
198                 || lv->documentBufferView()->buffer().fileName() != tmp.filename) {
199                 if (!switchToBuffer)
200                         return;
201                 dispatch(FuncRequest(LFUN_BUFFER_SWITCH, file));
202         }
203
204         // moveToPosition try paragraph id first and then paragraph (pit, pos).
205         if (!lv->documentBufferView()->moveToPosition(
206                 tmp.bottom_pit, tmp.bottom_pos, tmp.top_id, tmp.top_pos))
207                 return;
208
209         // bm changed
210         if (idx == 0)
211                 return;
212
213         // Cursor jump succeeded!
214         Cursor const & cur = lv->documentBufferView()->cursor();
215         pit_type new_pit = cur.pit();
216         pos_type new_pos = cur.pos();
217         int new_id = cur.paragraph().id();
218
219         // if bottom_pit, bottom_pos or top_id has been changed, update bookmark
220         // see http://bugzilla.lyx.org/show_bug.cgi?id=3092
221         if (bm.bottom_pit != new_pit || bm.bottom_pos != new_pos 
222                 || bm.top_id != new_id) {
223                 const_cast<BookmarksSection::Bookmark &>(bm).updatePos(
224                         new_pit, new_pos, new_id);
225         }
226 }
227
228
229 void LyXFunc::processKeySym(KeySymbol const & keysym, KeyModifier state)
230 {
231         LYXERR(Debug::KEY, "KeySym is " << keysym.getSymbolName());
232
233         LyXView * lv = theApp()->currentWindow();
234
235         // Do nothing if we have nothing (JMarc)
236         if (!keysym.isOK()) {
237                 LYXERR(Debug::KEY, "Empty kbd action (probably composing)");
238                 lv->restartCursor();
239                 return;
240         }
241
242         if (keysym.isModifier()) {
243                 LYXERR(Debug::KEY, "isModifier true");
244                 if (lv)
245                         lv->restartCursor();
246                 return;
247         }
248
249         //Encoding const * encoding = lv->documentBufferView()->cursor().getEncoding();
250         //encoded_last_key = keysym.getISOEncoded(encoding ? encoding->name() : "");
251         // FIXME: encoded_last_key shadows the member variable of the same
252         // name. Is that intended?
253         char_type encoded_last_key = keysym.getUCSEncoded();
254
255         // Do a one-deep top-level lookup for
256         // cancel and meta-fake keys. RVDK_PATCH_5
257         cancel_meta_seq.reset();
258
259         FuncRequest func = cancel_meta_seq.addkey(keysym, state);
260         LYXERR(Debug::KEY, "action first set to [" << func.action << ']');
261
262         // When not cancel or meta-fake, do the normal lookup.
263         // Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards.
264         // Mostly, meta_fake_bit = NoModifier. RVDK_PATCH_5.
265         if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_PREFIX)) {
266                 // remove Caps Lock and Mod2 as a modifiers
267                 func = keyseq.addkey(keysym, (state | meta_fake_bit));
268                 LYXERR(Debug::KEY, "action now set to [" << func.action << ']');
269         }
270
271         // Dont remove this unless you know what you are doing.
272         meta_fake_bit = NoModifier;
273
274         // Can this happen now ?
275         if (func.action == LFUN_NOACTION)
276                 func = FuncRequest(LFUN_COMMAND_PREFIX);
277
278         LYXERR(Debug::KEY, " Key [action=" << func.action << "]["
279                 << keyseq.print(KeySequence::Portable) << ']');
280
281         // already here we know if it any point in going further
282         // why not return already here if action == -1 and
283         // num_bytes == 0? (Lgb)
284
285         if (keyseq.length() > 1)
286                 lv->message(keyseq.print(KeySequence::ForGui));
287
288
289         // Maybe user can only reach the key via holding down shift.
290         // Let's see. But only if shift is the only modifier
291         if (func.action == LFUN_UNKNOWN_ACTION && state == ShiftModifier) {
292                 LYXERR(Debug::KEY, "Trying without shift");
293                 func = keyseq.addkey(keysym, NoModifier);
294                 LYXERR(Debug::KEY, "Action now " << func.action);
295         }
296
297         if (func.action == LFUN_UNKNOWN_ACTION) {
298                 // Hmm, we didn't match any of the keysequences. See
299                 // if it's normal insertable text not already covered
300                 // by a binding
301                 if (keysym.isText() && keyseq.length() == 1) {
302                         LYXERR(Debug::KEY, "isText() is true, inserting.");
303                         func = FuncRequest(LFUN_SELF_INSERT,
304                                            FuncRequest::KEYBOARD);
305                 } else {
306                         LYXERR(Debug::KEY, "Unknown, !isText() - giving up");
307                         lv->message(_("Unknown function."));
308                         lv->restartCursor();
309                         return;
310                 }
311         }
312
313         if (func.action == LFUN_SELF_INSERT) {
314                 if (encoded_last_key != 0) {
315                         docstring const arg(1, encoded_last_key);
316                         dispatch(FuncRequest(LFUN_SELF_INSERT, arg,
317                                              FuncRequest::KEYBOARD));
318                         LYXERR(Debug::KEY, "SelfInsert arg[`" << to_utf8(arg) << "']");
319                 }
320         } else {
321                 dispatch(func);
322                 if (!lv)
323                         return;
324         }
325 }
326
327
328 FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
329 {
330         //lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
331         FuncStatus flag;
332
333         if (cmd.action == LFUN_NOACTION) {
334                 flag.message(from_utf8(N_("Nothing to do")));
335                 flag.setEnabled(false);
336                 return flag;
337         }
338
339         switch (cmd.action) {
340         case LFUN_UNKNOWN_ACTION:
341                 flag.unknown(true);
342                 flag.setEnabled(false);
343                 break;
344
345         default:
346                 break;
347         }
348
349         if (flag.unknown()) {
350                 flag.message(from_utf8(N_("Unknown action")));
351                 return flag;
352         }
353
354         if (!flag.enabled()) {
355                 if (flag.message().empty())
356                         flag.message(from_utf8(N_("Command disabled")));
357                 return flag;
358         }
359
360         // I would really like to avoid having this switch and rather try to
361         // encode this in the function itself.
362         // -- And I'd rather let an inset decide which LFUNs it is willing
363         // to handle (Andre')
364         bool enable = true;
365         switch (cmd.action) {
366
367         // This could be used for the no-GUI version. The GUI version is handled in
368         // LyXView::getStatus(). See above.
369         /*
370         case LFUN_BUFFER_WRITE:
371         case LFUN_BUFFER_WRITE_AS: {
372                 Buffer * b = theBufferList().getBuffer(FileName(cmd.getArg(0)));
373                 enable = b && (b->isUnnamed() || !b->isClean());
374                 break;
375         }
376         */
377
378         case LFUN_BOOKMARK_GOTO: {
379                 const unsigned int num = convert<unsigned int>(to_utf8(cmd.argument()));
380                 enable = theSession().bookmarks().isValid(num);
381                 break;
382         }
383
384         case LFUN_BOOKMARK_CLEAR:
385                 enable = theSession().bookmarks().hasValid();
386                 break;
387
388         // this one is difficult to get right. As a half-baked
389         // solution, we consider only the first action of the sequence
390         case LFUN_COMMAND_SEQUENCE: {
391                 // argument contains ';'-terminated commands
392                 string const firstcmd = token(to_utf8(cmd.argument()), ';', 0);
393                 FuncRequest func(lyxaction.lookupFunc(firstcmd));
394                 func.origin = cmd.origin;
395                 flag = getStatus(func);
396                 break;
397         }
398
399         // we want to check if at least one of these is enabled
400         case LFUN_COMMAND_ALTERNATIVES: {
401                 // argument contains ';'-terminated commands
402                 string arg = to_utf8(cmd.argument());
403                 while (!arg.empty()) {
404                         string first;
405                         arg = split(arg, first, ';');
406                         FuncRequest func(lyxaction.lookupFunc(first));
407                         func.origin = cmd.origin;
408                         flag = getStatus(func);
409                         // if this one is enabled, the whole thing is
410                         if (flag.enabled())
411                                 break;
412                 }
413                 break;
414         }
415
416         case LFUN_CALL: {
417                 FuncRequest func;
418                 string name = to_utf8(cmd.argument());
419                 if (theTopLevelCmdDef().lock(name, func)) {
420                         func.origin = cmd.origin;
421                         flag = getStatus(func);
422                         theTopLevelCmdDef().release(name);
423                 } else {
424                         // catch recursion or unknown command
425                         // definition. all operations until the
426                         // recursion or unknown command definition
427                         // occurs are performed, so set the state to
428                         // enabled
429                         enable = true;
430                 }
431                 break;
432         }
433
434         case LFUN_COMMAND_PREFIX:
435         case LFUN_CANCEL:
436         case LFUN_META_PREFIX:
437         case LFUN_RECONFIGURE:
438         case LFUN_DROP_LAYOUTS_CHOICE:
439         case LFUN_SERVER_GET_FILENAME:
440         case LFUN_SERVER_NOTIFY:
441         case LFUN_CURSOR_FOLLOWS_SCROLLBAR_TOGGLE:
442         case LFUN_REPEAT:
443         case LFUN_PREFERENCES_SAVE:
444         case LFUN_INSET_EDIT:
445         case LFUN_BUFFER_SAVE_AS_DEFAULT:
446         case LFUN_LYXRC_APPLY:
447                 // these are handled in our dispatch()
448                 break;
449
450         default:
451                 if (!theApp()) {
452                         enable = false;
453                         break;
454                 }
455                 if (theApp()->getStatus(cmd, flag))
456                         break;
457
458                 // Does the view know something?
459                 LyXView * lv = theApp()->currentWindow();
460                 if (!lv) {
461                         enable = false;
462                         break;
463                 }
464                 if (lv->getStatus(cmd, flag))
465                         break;
466
467                 BufferView * bv = lv->currentBufferView();
468                 BufferView * doc_bv = lv->documentBufferView();
469                 // If we do not have a BufferView, then other functions are disabled
470                 if (!bv) {
471                         enable = false;
472                         break;
473                 }
474                 // try the BufferView
475                 bool decided = bv->getStatus(cmd, flag);
476                 if (!decided)
477                         // try the Buffer
478                         decided = bv->buffer().getStatus(cmd, flag);
479                 if (!decided && doc_bv)
480                         // try the Document Buffer
481                         decided = doc_bv->buffer().getStatus(cmd, flag);
482         }
483
484         if (!enable)
485                 flag.setEnabled(false);
486
487         // the default error message if we disable the command
488         if (!flag.enabled() && flag.message().empty())
489                 flag.message(from_utf8(N_("Command disabled")));
490
491         return flag;
492 }
493
494
495 namespace {
496
497 void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new);
498
499 /// send a post-dispatch status message
500 docstring sendDispatchMessage(docstring const & msg, FuncRequest const & cmd)
501 {
502         const bool verbose = (cmd.origin == FuncRequest::MENU
503                               || cmd.origin == FuncRequest::TOOLBAR
504                               || cmd.origin == FuncRequest::COMMANDBUFFER);
505
506         if (cmd.action == LFUN_SELF_INSERT || !verbose) {
507                 LYXERR(Debug::ACTION, "dispatch msg is " << msg);
508                 return msg;
509         }
510
511         docstring dispatch_msg = msg;
512         if (!dispatch_msg.empty())
513                 dispatch_msg += ' ';
514
515         docstring comname = from_utf8(lyxaction.getActionName(cmd.action));
516
517         bool argsadded = false;
518
519         if (!cmd.argument().empty()) {
520                 if (cmd.action != LFUN_UNKNOWN_ACTION) {
521                         comname += ' ' + cmd.argument();
522                         argsadded = true;
523                 }
524         }
525         docstring const shortcuts = theTopLevelKeymap().
526                 printBindings(cmd, KeySequence::ForGui);
527
528         if (!shortcuts.empty())
529                 comname += ": " + shortcuts;
530         else if (!argsadded && !cmd.argument().empty())
531                 comname += ' ' + cmd.argument();
532
533         if (!comname.empty()) {
534                 comname = rtrim(comname);
535                 dispatch_msg += '(' + rtrim(comname) + ')';
536         }
537         LYXERR(Debug::ACTION, "verbose dispatch msg " << to_utf8(dispatch_msg));
538         return dispatch_msg;
539 }
540
541
542 } //namespace anon
543
544
545 void LyXFunc::dispatch(FuncRequest const & cmd)
546 {
547         string const argument = to_utf8(cmd.argument());
548         FuncCode const action = cmd.action;
549
550         LYXERR(Debug::ACTION, "\nLyXFunc::dispatch: cmd: " << cmd);
551         //lyxerr << "LyXFunc::dispatch: cmd: " << cmd << endl;
552
553         // we have not done anything wrong yet.
554         errorstat = false;
555         dispatch_buffer.erase();
556
557         // redraw the screen at the end (first of the two drawing steps).
558         //This is done unless explicitely requested otherwise
559         Update::flags updateFlags = Update::FitCursor;
560
561         LyXView * lv = theApp()->currentWindow();
562
563         FuncStatus const flag = getStatus(cmd);
564         if (!flag.enabled()) {
565                 // We cannot use this function here
566                 LYXERR(Debug::ACTION, "LyXFunc::dispatch: "
567                        << lyxaction.getActionName(action)
568                        << " [" << action << "] is disabled at this location");
569                 setErrorMessage(flag.message());
570                 if (lv)
571                         lv->restartCursor();
572         } else {
573                 switch (action) {
574
575                 case LFUN_COMMAND_PREFIX:
576                         dispatch(FuncRequest(LFUN_MESSAGE, keyseq.printOptions(true)));
577                         break;
578
579                 case LFUN_CANCEL:
580                         keyseq.reset();
581                         meta_fake_bit = NoModifier;
582                         if (lv && lv->currentBufferView())
583                                 // cancel any selection
584                                 dispatch(FuncRequest(LFUN_MARK_OFF));
585                         setMessage(from_ascii(N_("Cancel")));
586                         break;
587
588                 case LFUN_META_PREFIX:
589                         meta_fake_bit = AltModifier;
590                         setMessage(keyseq.print(KeySequence::ForGui));
591                         break;
592
593                 // --- Menus -----------------------------------------------
594                 case LFUN_RECONFIGURE:
595                         // argument is any additional parameter to the configure.py command
596                         reconfigure(lv, argument);
597                         break;
598
599                 // --- lyxserver commands ----------------------------
600                 case LFUN_SERVER_GET_FILENAME: {
601                         LASSERT(lv && lv->documentBufferView(), return);
602                         docstring const fname = from_utf8(
603                                 lv->documentBufferView()->buffer().absFileName());
604                         setMessage(fname);
605                         LYXERR(Debug::INFO, "FNAME[" << fname << ']');
606                         break;
607                 }
608                 case LFUN_SERVER_NOTIFY:
609                         dispatch_buffer = keyseq.print(KeySequence::Portable);
610                         theServer().notifyClient(to_utf8(dispatch_buffer));
611                         break;
612
613                 case LFUN_CURSOR_FOLLOWS_SCROLLBAR_TOGGLE:
614                         lyxrc.cursor_follows_scrollbar = !lyxrc.cursor_follows_scrollbar;
615                         break;
616
617                 case LFUN_REPEAT: {
618                         // repeat command
619                         string countstr;
620                         string rest = split(argument, countstr, ' ');
621                         istringstream is(countstr);
622                         int count = 0;
623                         is >> count;
624                         //lyxerr << "repeat: count: " << count << " cmd: " << rest << endl;
625                         for (int i = 0; i < count; ++i)
626                                 dispatch(lyxaction.lookupFunc(rest));
627                         break;
628                 }
629
630                 case LFUN_COMMAND_SEQUENCE: {
631                         // argument contains ';'-terminated commands
632                         string arg = argument;
633                         // FIXME: this LFUN should also work without any view.
634                         Buffer * buffer = (lv && lv->documentBufferView())
635                                 ? &(lv->documentBufferView()->buffer()) : 0;
636                         buffer = &lv->currentBufferView()->buffer();
637                         if (buffer && !theBufferList().isLoaded(buffer))
638                                 buffer = 0;
639                         if (buffer)
640                                 buffer->undo().beginUndoGroup();
641                         while (!arg.empty()) {
642                                 string first;
643                                 arg = split(arg, first, ';');
644                                 FuncRequest func(lyxaction.lookupFunc(first));
645                                 func.origin = cmd.origin;
646                                 dispatch(func);
647                         }
648                         if (buffer)
649                                 buffer->undo().endUndoGroup();
650                         break;
651                 }
652
653                 case LFUN_COMMAND_ALTERNATIVES: {
654                         // argument contains ';'-terminated commands
655                         string arg = argument;
656                         while (!arg.empty()) {
657                                 string first;
658                                 arg = split(arg, first, ';');
659                                 FuncRequest func(lyxaction.lookupFunc(first));
660                                 func.origin = cmd.origin;
661                                 FuncStatus stat = getStatus(func);
662                                 if (stat.enabled()) {
663                                         dispatch(func);
664                                         break;
665                                 }
666                         }
667                         break;
668                 }
669
670                 case LFUN_CALL: {
671                         FuncRequest func;
672                         if (theTopLevelCmdDef().lock(argument, func)) {
673                                 func.origin = cmd.origin;
674                                 dispatch(func);
675                                 theTopLevelCmdDef().release(argument);
676                         } else {
677                                 if (func.action == LFUN_UNKNOWN_ACTION) {
678                                         // unknown command definition
679                                         lyxerr << "Warning: unknown command definition `"
680                                                    << argument << "'"
681                                                    << endl;
682                                 } else {
683                                         // recursion detected
684                                         lyxerr << "Warning: Recursion in the command definition `"
685                                                    << argument << "' detected"
686                                                    << endl;
687                                 }
688                         }
689                         break;
690                 }
691
692                 case LFUN_PREFERENCES_SAVE: {
693                         lyxrc.write(makeAbsPath("preferences",
694                                                 package().user_support().absFilename()),
695                                     false);
696                         break;
697                 }
698
699                 case LFUN_BUFFER_SAVE_AS_DEFAULT: {
700                         string const fname =
701                                 addName(addPath(package().user_support().absFilename(), "templates/"),
702                                         "defaults.lyx");
703                         Buffer defaults(fname);
704
705                         istringstream ss(argument);
706                         Lexer lex;
707                         lex.setStream(ss);
708                         int const unknown_tokens = defaults.readHeader(lex);
709
710                         if (unknown_tokens != 0) {
711                                 lyxerr << "Warning in LFUN_BUFFER_SAVE_AS_DEFAULT!\n"
712                                        << unknown_tokens << " unknown token"
713                                        << (unknown_tokens == 1 ? "" : "s")
714                                        << endl;
715                         }
716
717                         if (defaults.writeFile(FileName(defaults.absFileName())))
718                                 setMessage(bformat(_("Document defaults saved in %1$s"),
719                                                    makeDisplayPath(fname)));
720                         else
721                                 setErrorMessage(from_ascii(N_("Unable to save document defaults")));
722                         break;
723                 }
724
725                 case LFUN_LYXRC_APPLY: {
726                         // reset active key sequences, since the bindings
727                         // are updated (bug 6064)
728                         keyseq.reset();
729                         LyXRC const lyxrc_orig = lyxrc;
730
731                         istringstream ss(argument);
732                         bool const success = lyxrc.read(ss) == 0;
733
734                         if (!success) {
735                                 lyxerr << "Warning in LFUN_LYXRC_APPLY!\n"
736                                        << "Unable to read lyxrc data"
737                                        << endl;
738                                 break;
739                         }
740
741                         actOnUpdatedPrefs(lyxrc_orig, lyxrc);
742
743                         setSpellChecker();
744
745                         theApp()->resetGui();
746
747                         /// We force the redraw in any case because there might be
748                         /// some screen font changes.
749                         /// FIXME: only the current view will be updated. the Gui
750                         /// class is able to furnish the list of views.
751                         updateFlags = Update::Force;
752                         break;
753                 }
754
755                 case LFUN_BOOKMARK_GOTO:
756                         // go to bookmark, open unopened file and switch to buffer if necessary
757                         gotoBookmark(convert<unsigned int>(to_utf8(cmd.argument())), true, true);
758                         updateFlags = Update::FitCursor;
759                         break;
760
761                 case LFUN_BOOKMARK_CLEAR:
762                         theSession().bookmarks().clear();
763                         break;
764
765                 default:
766                         LASSERT(theApp(), /**/);
767                         // Let the frontend dispatch its own actions.
768                         if (theApp()->dispatch(cmd))
769                                 // Nothing more to do.
770                                 return;
771
772                         // Everything below is only for active window
773                         if (lv == 0)
774                                 break;
775
776                         // Let the current LyXView dispatch its own actions.
777                         if (lv->dispatch(cmd)) {
778                                 BufferView * bv = lv->currentBufferView();
779                                 if (bv)
780                                         updateFlags = bv->cursor().result().update();
781                                 break;
782                         }
783
784                         BufferView * bv = lv->currentBufferView();
785                         LASSERT(bv, /**/);
786
787                         // Let the current BufferView dispatch its own actions.
788                         if (bv->dispatch(cmd)) {
789                                 // The BufferView took care of its own updates if needed.
790                                 updateFlags = Update::None;
791                                 break;
792                         }
793
794                         BufferView * doc_bv = lv->documentBufferView();
795                         // Try with the document BufferView dispatch if any.
796                         if (doc_bv && doc_bv->dispatch(cmd)) {
797                                 updateFlags = Update::None;
798                                 break;
799                         }
800
801                         // OK, so try the current Buffer itself...
802                         DispatchResult dr;
803                         bv->buffer().dispatch(cmd, dr);
804                         if (dr.dispatched()) {
805                                 updateFlags = dr.update();
806                                 break;
807                         }
808                         // and with the document Buffer.
809                         if (doc_bv) {
810                                 doc_bv->buffer().dispatch(cmd, dr);
811                                 if (dr.dispatched()) {
812                                         updateFlags = dr.update();
813                                         break;
814                                 }
815                         }
816
817                         // Is this a function that acts on inset at point?
818                         Inset * inset = bv->cursor().nextInset();
819                         if (lyxaction.funcHasFlag(action, LyXAction::AtPoint)
820                             && inset) {
821                                 bv->cursor().result().dispatched(true);
822                                 bv->cursor().result().update(Update::FitCursor | Update::Force);
823                                 FuncRequest tmpcmd = cmd;
824                                 inset->dispatch(bv->cursor(), tmpcmd);
825                                 if (bv->cursor().result().dispatched()) {
826                                         updateFlags = bv->cursor().result().update();
827                                         break;
828                                 }
829                         }
830
831                         // Let the current Cursor dispatch its own actions.
832                         Cursor old = bv->cursor();
833                         bv->cursor().getPos(cursorPosBeforeDispatchX_,
834                                                 cursorPosBeforeDispatchY_);
835                         bv->cursor().dispatch(cmd);
836
837                         // notify insets we just left
838                         if (bv->cursor() != old) {
839                                 old.fixIfBroken();
840                                 bool badcursor = notifyCursorLeavesOrEnters(old, bv->cursor());
841                                 if (badcursor)
842                                         bv->cursor().fixIfBroken();
843                         }
844
845                         // update completion. We do it here and not in
846                         // processKeySym to avoid another redraw just for a
847                         // changed inline completion
848                         if (cmd.origin == FuncRequest::KEYBOARD) {
849                                 if (cmd.action == LFUN_SELF_INSERT
850                                     || (cmd.action == LFUN_ERT_INSERT && bv->cursor().inMathed()))
851                                         lv->updateCompletion(bv->cursor(), true, true);
852                                 else if (cmd.action == LFUN_CHAR_DELETE_BACKWARD)
853                                         lv->updateCompletion(bv->cursor(), false, true);
854                                 else
855                                         lv->updateCompletion(bv->cursor(), false, false);
856                         }
857
858                         updateFlags = bv->cursor().result().update();
859                 }
860
861                 // if we executed a mutating lfun, mark the buffer as dirty
862                 Buffer * doc_buffer = (lv && lv->documentBufferView())
863                         ? &(lv->documentBufferView()->buffer()) : 0;
864                 if (doc_buffer && theBufferList().isLoaded(doc_buffer)
865                         && flag.enabled()
866                     && !lyxaction.funcHasFlag(action, LyXAction::NoBuffer)
867                     && !lyxaction.funcHasFlag(action, LyXAction::ReadOnly))
868                         doc_buffer->markDirty();                        
869
870                 if (lv && lv->currentBufferView()) {
871                         // BufferView::update() updates the ViewMetricsInfo and
872                         // also initializes the position cache for all insets in
873                         // (at least partially) visible top-level paragraphs.
874                         // We will redraw the screen only if needed.
875                         lv->currentBufferView()->processUpdateFlags(updateFlags);
876
877                         // Do we have a selection?
878                         theSelection().haveSelection(
879                                 lv->currentBufferView()->cursor().selection());
880                         
881                         // update gui
882                         lv->restartCursor();
883                 }
884         }
885         if (lv) {
886                 // Some messages may already be translated, so we cannot use _()
887                 lv->message(sendDispatchMessage(
888                         translateIfPossible(getMessage()), cmd));
889         }
890 }
891
892
893 // Each LyXView should have it's own message method. lyxview and
894 // the minibuffer would use the minibuffer, but lyxserver would
895 // send an ERROR signal to its client.  Alejandro 970603
896 // This function is bit problematic when it comes to NLS, to make the
897 // lyx servers client be language indepenent we must not translate
898 // strings sent to this func.
899 void LyXFunc::setErrorMessage(docstring const & m) const
900 {
901         dispatch_buffer = m;
902         errorstat = true;
903 }
904
905
906 void LyXFunc::setMessage(docstring const & m) const
907 {
908         dispatch_buffer = m;
909 }
910
911
912 docstring LyXFunc::viewStatusMessage()
913 {
914         // When meta-fake key is pressed, show the key sequence so far + "M-".
915         if (wasMetaKey())
916                 return keyseq.print(KeySequence::ForGui) + "M-";
917
918         // Else, when a non-complete key sequence is pressed,
919         // show the available options.
920         if (keyseq.length() > 0 && !keyseq.deleted())
921                 return keyseq.printOptions(true);
922
923         return docstring();
924 }
925
926
927 bool LyXFunc::wasMetaKey() const
928 {
929         return (meta_fake_bit != NoModifier);
930 }
931
932
933 namespace {
934
935 void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
936 {
937         // Why the switch you might ask. It is a trick to ensure that all
938         // the elements in the LyXRCTags enum is handled. As you can see
939         // there are no breaks at all. So it is just a huge fall-through.
940         // The nice thing is that we will get a warning from the compiler
941         // if we forget an element.
942         LyXRC::LyXRCTags tag = LyXRC::RC_LAST;
943         switch (tag) {
944         case LyXRC::RC_ACCEPT_COMPOUND:
945         case LyXRC::RC_ALT_LANG:
946         case LyXRC::RC_PLAINTEXT_LINELEN:
947         case LyXRC::RC_PLAINTEXT_ROFF_COMMAND:
948         case LyXRC::RC_AUTOCORRECTION_MATH:
949         case LyXRC::RC_AUTOREGIONDELETE:
950         case LyXRC::RC_AUTORESET_OPTIONS:
951         case LyXRC::RC_AUTOSAVE:
952         case LyXRC::RC_AUTO_NUMBER:
953         case LyXRC::RC_BACKUPDIR_PATH:
954         case LyXRC::RC_BIBTEX_ALTERNATIVES:
955         case LyXRC::RC_BIBTEX_COMMAND:
956         case LyXRC::RC_BINDFILE:
957         case LyXRC::RC_CHECKLASTFILES:
958         case LyXRC::RC_COMPLETION_CURSOR_TEXT:
959         case LyXRC::RC_COMPLETION_INLINE_DELAY:
960         case LyXRC::RC_COMPLETION_INLINE_DOTS:
961         case LyXRC::RC_COMPLETION_INLINE_MATH:
962         case LyXRC::RC_COMPLETION_INLINE_TEXT:
963         case LyXRC::RC_COMPLETION_POPUP_AFTER_COMPLETE:
964         case LyXRC::RC_COMPLETION_POPUP_DELAY:
965         case LyXRC::RC_COMPLETION_POPUP_MATH:
966         case LyXRC::RC_COMPLETION_POPUP_TEXT:
967         case LyXRC::RC_USELASTFILEPOS:
968         case LyXRC::RC_LOADSESSION:
969         case LyXRC::RC_CHKTEX_COMMAND:
970         case LyXRC::RC_CONVERTER:
971         case LyXRC::RC_CONVERTER_CACHE_MAXAGE:
972         case LyXRC::RC_COPIER:
973         case LyXRC::RC_CURSOR_FOLLOWS_SCROLLBAR:
974         case LyXRC::RC_SCROLL_BELOW_DOCUMENT:
975         case LyXRC::RC_DATE_INSERT_FORMAT:
976         case LyXRC::RC_DEFAULT_LANGUAGE:
977         case LyXRC::RC_GUI_LANGUAGE:
978         case LyXRC::RC_DEFAULT_PAPERSIZE:
979         case LyXRC::RC_DEFAULT_VIEW_FORMAT:
980         case LyXRC::RC_DEFFILE:
981         case LyXRC::RC_DIALOGS_ICONIFY_WITH_MAIN:
982         case LyXRC::RC_DISPLAY_GRAPHICS:
983         case LyXRC::RC_DOCUMENTPATH:
984                 if (lyxrc_orig.document_path != lyxrc_new.document_path) {
985                         FileName path(lyxrc_new.document_path);
986                         if (path.exists() && path.isDirectory())
987                                 package().document_dir() = FileName(lyxrc.document_path);
988                 }
989         case LyXRC::RC_EDITOR_ALTERNATIVES:
990         case LyXRC::RC_ESC_CHARS:
991         case LyXRC::RC_EXAMPLEPATH:
992         case LyXRC::RC_FONT_ENCODING:
993         case LyXRC::RC_FORMAT:
994         case LyXRC::RC_GROUP_LAYOUTS:
995         case LyXRC::RC_HUNSPELLDIR_PATH:
996         case LyXRC::RC_INDEX_ALTERNATIVES:
997         case LyXRC::RC_INDEX_COMMAND:
998         case LyXRC::RC_JBIBTEX_COMMAND:
999         case LyXRC::RC_JINDEX_COMMAND:
1000         case LyXRC::RC_NOMENCL_COMMAND:
1001         case LyXRC::RC_INPUT:
1002         case LyXRC::RC_KBMAP:
1003         case LyXRC::RC_KBMAP_PRIMARY:
1004         case LyXRC::RC_KBMAP_SECONDARY:
1005         case LyXRC::RC_LABEL_INIT_LENGTH:
1006         case LyXRC::RC_LANGUAGE_AUTO_BEGIN:
1007         case LyXRC::RC_LANGUAGE_AUTO_END:
1008         case LyXRC::RC_LANGUAGE_COMMAND_BEGIN:
1009         case LyXRC::RC_LANGUAGE_COMMAND_END:
1010         case LyXRC::RC_LANGUAGE_COMMAND_LOCAL:
1011         case LyXRC::RC_LANGUAGE_GLOBAL_OPTIONS:
1012         case LyXRC::RC_LANGUAGE_PACKAGE:
1013         case LyXRC::RC_LANGUAGE_USE_BABEL:
1014         case LyXRC::RC_MAC_LIKE_WORD_MOVEMENT:
1015         case LyXRC::RC_MACRO_EDIT_STYLE:
1016         case LyXRC::RC_MAKE_BACKUP:
1017         case LyXRC::RC_MARK_FOREIGN_LANGUAGE:
1018         case LyXRC::RC_MOUSE_WHEEL_SPEED:
1019         case LyXRC::RC_NUMLASTFILES:
1020         case LyXRC::RC_PARAGRAPH_MARKERS:
1021         case LyXRC::RC_PATH_PREFIX:
1022                 if (lyxrc_orig.path_prefix != lyxrc_new.path_prefix) {
1023                         prependEnvPath("PATH", lyxrc.path_prefix);
1024                 }
1025         case LyXRC::RC_PERS_DICT:
1026         case LyXRC::RC_PREVIEW:
1027         case LyXRC::RC_PREVIEW_HASHED_LABELS:
1028         case LyXRC::RC_PREVIEW_SCALE_FACTOR:
1029         case LyXRC::RC_PRINTCOLLCOPIESFLAG:
1030         case LyXRC::RC_PRINTCOPIESFLAG:
1031         case LyXRC::RC_PRINTER:
1032         case LyXRC::RC_PRINTEVENPAGEFLAG:
1033         case LyXRC::RC_PRINTEXSTRAOPTIONS:
1034         case LyXRC::RC_PRINTFILEEXTENSION:
1035         case LyXRC::RC_PRINTLANDSCAPEFLAG:
1036         case LyXRC::RC_PRINTODDPAGEFLAG:
1037         case LyXRC::RC_PRINTPAGERANGEFLAG:
1038         case LyXRC::RC_PRINTPAPERDIMENSIONFLAG:
1039         case LyXRC::RC_PRINTPAPERFLAG:
1040         case LyXRC::RC_PRINTREVERSEFLAG:
1041         case LyXRC::RC_PRINTSPOOL_COMMAND:
1042         case LyXRC::RC_PRINTSPOOL_PRINTERPREFIX:
1043         case LyXRC::RC_PRINTTOFILE:
1044         case LyXRC::RC_PRINTTOPRINTER:
1045         case LyXRC::RC_PRINT_ADAPTOUTPUT:
1046         case LyXRC::RC_PRINT_COMMAND:
1047         case LyXRC::RC_RTL_SUPPORT:
1048         case LyXRC::RC_SCREEN_DPI:
1049         case LyXRC::RC_SCREEN_FONT_ROMAN:
1050         case LyXRC::RC_SCREEN_FONT_ROMAN_FOUNDRY:
1051         case LyXRC::RC_SCREEN_FONT_SANS:
1052         case LyXRC::RC_SCREEN_FONT_SANS_FOUNDRY:
1053         case LyXRC::RC_SCREEN_FONT_SCALABLE:
1054         case LyXRC::RC_SCREEN_FONT_SIZES:
1055         case LyXRC::RC_SCREEN_FONT_TYPEWRITER:
1056         case LyXRC::RC_SCREEN_FONT_TYPEWRITER_FOUNDRY:
1057         case LyXRC::RC_GEOMETRY_SESSION:
1058         case LyXRC::RC_SCREEN_ZOOM:
1059         case LyXRC::RC_SERVERPIPE:
1060         case LyXRC::RC_SET_COLOR:
1061         case LyXRC::RC_SHOW_BANNER:
1062         case LyXRC::RC_OPEN_BUFFERS_IN_TABS:
1063         case LyXRC::RC_SPELL_COMMAND:
1064         case LyXRC::RC_SPELLCHECKER:
1065         case LyXRC::RC_SPELLCHECK_CONTINUOUSLY:
1066         case LyXRC::RC_SPLITINDEX_COMMAND:
1067         case LyXRC::RC_TEMPDIRPATH:
1068         case LyXRC::RC_TEMPLATEPATH:
1069         case LyXRC::RC_TEX_ALLOWS_SPACES:
1070         case LyXRC::RC_TEX_EXPECTS_WINDOWS_PATHS:
1071                 if (lyxrc_orig.windows_style_tex_paths != lyxrc_new.windows_style_tex_paths) {
1072                         os::windows_style_tex_paths(lyxrc_new.windows_style_tex_paths);
1073                 }
1074         case LyXRC::RC_THESAURUSDIRPATH:
1075         case LyXRC::RC_UIFILE:
1076         case LyXRC::RC_USER_EMAIL:
1077         case LyXRC::RC_USER_NAME:
1078         case LyXRC::RC_USETEMPDIR:
1079         case LyXRC::RC_USE_ALT_LANG:
1080         case LyXRC::RC_USE_CONVERTER_CACHE:
1081         case LyXRC::RC_USE_ESC_CHARS:
1082         case LyXRC::RC_USE_INP_ENC:
1083         case LyXRC::RC_USE_PERS_DICT:
1084         case LyXRC::RC_USE_TOOLTIP:
1085         case LyXRC::RC_USE_PIXMAP_CACHE:
1086         case LyXRC::RC_USE_SPELL_LIB:
1087         case LyXRC::RC_VIEWDVI_PAPEROPTION:
1088         case LyXRC::RC_SORT_LAYOUTS:
1089         case LyXRC::RC_FULL_SCREEN_LIMIT:
1090         case LyXRC::RC_FULL_SCREEN_SCROLLBAR:
1091         case LyXRC::RC_FULL_SCREEN_MENUBAR:
1092         case LyXRC::RC_FULL_SCREEN_TABBAR:
1093         case LyXRC::RC_FULL_SCREEN_TOOLBARS:
1094         case LyXRC::RC_FULL_SCREEN_WIDTH:
1095         case LyXRC::RC_VISUAL_CURSOR:
1096         case LyXRC::RC_VIEWER:
1097         case LyXRC::RC_VIEWER_ALTERNATIVES:
1098         case LyXRC::RC_LAST:
1099                 break;
1100         }
1101 }
1102
1103 } // namespace anon
1104 } // namespace lyx