3 * This file is part of LyX, the document processor.
4 * Licence details can be found in the file COPYING.
6 * \author Alfredo Braunstein
7 * \author Lars Gullik Bjønnes
8 * \author Jean-Marc Lasgouttes
9 * \author Angus Leeming
11 * \author André Pönitz
14 * \author Martin Vermeer
15 * \author Jürgen Vigna
17 * Full author contact details are available in file CREDITS.
24 #include "LayoutFile.h"
25 #include "BranchList.h"
26 #include "buffer_funcs.h"
28 #include "BufferList.h"
29 #include "BufferParams.h"
30 #include "BufferView.h"
33 #include "Converter.h"
35 #include "CutAndPaste.h"
36 #include "DispatchResult.h"
38 #include "ErrorList.h"
40 #include "FuncRequest.h"
41 #include "FuncStatus.h"
42 #include "InsetIterator.h"
46 #include "LyXAction.h"
51 #include "Paragraph.h"
52 #include "ParagraphParameters.h"
53 #include "ParIterator.h"
56 #include "SpellChecker.h"
58 #include "frontends/alert.h"
59 #include "frontends/Application.h"
60 #include "frontends/KeySymbol.h"
61 #include "frontends/LyXView.h"
62 #include "frontends/Selection.h"
64 #include "support/debug.h"
65 #include "support/environment.h"
66 #include "support/FileName.h"
67 #include "support/filetools.h"
68 #include "support/gettext.h"
69 #include "support/lassert.h"
70 #include "support/lstrings.h"
71 #include "support/Package.h"
72 #include "support/convert.h"
73 #include "support/os.h"
79 using namespace lyx::support;
83 using frontend::LyXView;
85 namespace Alert = frontend::Alert;
92 //FIXME: bookmark handling is a frontend issue. This code should be transferred
93 // to GuiView and be GuiView and be window dependent.
94 void LyXFunc::gotoBookmark(unsigned int idx, bool openFile, bool switchToBuffer)
96 LyXView * lv = theApp()->currentWindow();
98 if (!theSession().bookmarks().isValid(idx))
100 BookmarksSection::Bookmark const & bm = theSession().bookmarks().bookmark(idx);
101 LASSERT(!bm.filename.empty(), /**/);
102 string const file = bm.filename.absFilename();
103 // if the file is not opened, open it.
104 if (!theBufferList().exists(bm.filename)) {
106 dispatch(FuncRequest(LFUN_FILE_OPEN, file));
110 // open may fail, so we need to test it again
111 if (!theBufferList().exists(bm.filename))
114 // bm can be changed when saving
115 BookmarksSection::Bookmark tmp = bm;
117 // Special case idx == 0 used for back-from-back jump navigation
119 dispatch(FuncRequest(LFUN_BOOKMARK_SAVE, "0"));
121 // if the current buffer is not that one, switch to it.
122 if (!lv->documentBufferView()
123 || lv->documentBufferView()->buffer().fileName() != tmp.filename) {
126 dispatch(FuncRequest(LFUN_BUFFER_SWITCH, file));
129 // moveToPosition try paragraph id first and then paragraph (pit, pos).
130 if (!lv->documentBufferView()->moveToPosition(
131 tmp.bottom_pit, tmp.bottom_pos, tmp.top_id, tmp.top_pos))
138 // Cursor jump succeeded!
139 Cursor const & cur = lv->documentBufferView()->cursor();
140 pit_type new_pit = cur.pit();
141 pos_type new_pos = cur.pos();
142 int new_id = cur.paragraph().id();
144 // if bottom_pit, bottom_pos or top_id has been changed, update bookmark
145 // see http://www.lyx.org/trac/ticket/3092
146 if (bm.bottom_pit != new_pit || bm.bottom_pos != new_pos
147 || bm.top_id != new_id) {
148 const_cast<BookmarksSection::Bookmark &>(bm).updatePos(
149 new_pit, new_pos, new_id);
154 FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
156 //lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
159 if (cmd.action == LFUN_NOACTION) {
160 flag.message(from_utf8(N_("Nothing to do")));
161 flag.setEnabled(false);
165 if (cmd.action == LFUN_UNKNOWN_ACTION) {
167 flag.setEnabled(false);
168 flag.message(from_utf8(N_("Unknown action")));
172 // I would really like to avoid having this switch and rather try to
173 // encode this in the function itself.
174 // -- And I'd rather let an inset decide which LFUNs it is willing
175 // to handle (Andre')
177 switch (cmd.action) {
179 // This could be used for the no-GUI version. The GUI version is handled in
180 // LyXView::getStatus(). See above.
182 case LFUN_BUFFER_WRITE:
183 case LFUN_BUFFER_WRITE_AS: {
184 Buffer * b = theBufferList().getBuffer(FileName(cmd.getArg(0)));
185 enable = b && (b->isUnnamed() || !b->isClean());
190 case LFUN_BOOKMARK_GOTO: {
191 const unsigned int num = convert<unsigned int>(to_utf8(cmd.argument()));
192 enable = theSession().bookmarks().isValid(num);
196 case LFUN_BOOKMARK_CLEAR:
197 enable = theSession().bookmarks().hasValid();
200 // this one is difficult to get right. As a half-baked
201 // solution, we consider only the first action of the sequence
202 case LFUN_COMMAND_SEQUENCE: {
203 // argument contains ';'-terminated commands
204 string const firstcmd = token(to_utf8(cmd.argument()), ';', 0);
205 FuncRequest func(lyxaction.lookupFunc(firstcmd));
206 func.origin = cmd.origin;
207 flag = getStatus(func);
211 // we want to check if at least one of these is enabled
212 case LFUN_COMMAND_ALTERNATIVES: {
213 // argument contains ';'-terminated commands
214 string arg = to_utf8(cmd.argument());
215 while (!arg.empty()) {
217 arg = split(arg, first, ';');
218 FuncRequest func(lyxaction.lookupFunc(first));
219 func.origin = cmd.origin;
220 flag = getStatus(func);
221 // if this one is enabled, the whole thing is
230 string name = to_utf8(cmd.argument());
231 if (theTopLevelCmdDef().lock(name, func)) {
232 func.origin = cmd.origin;
233 flag = getStatus(func);
234 theTopLevelCmdDef().release(name);
236 // catch recursion or unknown command
237 // definition. all operations until the
238 // recursion or unknown command definition
239 // occurs are performed, so set the state to
246 case LFUN_CURSOR_FOLLOWS_SCROLLBAR_TOGGLE:
248 case LFUN_PREFERENCES_SAVE:
249 case LFUN_BUFFER_SAVE_AS_DEFAULT:
250 case LFUN_DEBUG_LEVEL_SET:
251 // these are handled in our dispatch()
259 if (theApp()->getStatus(cmd, flag))
262 // Does the view know something?
263 LyXView * lv = theApp()->currentWindow();
268 if (lv->getStatus(cmd, flag))
271 BufferView * bv = lv->currentBufferView();
272 BufferView * doc_bv = lv->documentBufferView();
273 // If we do not have a BufferView, then other functions are disabled
278 // try the BufferView
279 bool decided = bv->getStatus(cmd, flag);
282 decided = bv->buffer().getStatus(cmd, flag);
283 if (!decided && doc_bv)
284 // try the Document Buffer
285 decided = doc_bv->buffer().getStatus(cmd, flag);
289 flag.setEnabled(false);
291 // the default error message if we disable the command
292 if (!flag.enabled() && flag.message().empty())
293 flag.message(from_utf8(N_("Command disabled")));
298 /// make a post-dispatch status message
299 static docstring makeDispatchMessage(docstring const & msg,
300 FuncRequest const & cmd)
302 const bool verbose = (cmd.origin == FuncRequest::MENU
303 || cmd.origin == FuncRequest::TOOLBAR
304 || cmd.origin == FuncRequest::COMMANDBUFFER);
306 if (cmd.action == LFUN_SELF_INSERT || !verbose) {
307 LYXERR(Debug::ACTION, "dispatch msg is " << msg);
311 docstring dispatch_msg = msg;
312 if (!dispatch_msg.empty())
315 docstring comname = from_utf8(lyxaction.getActionName(cmd.action));
317 bool argsadded = false;
319 if (!cmd.argument().empty()) {
320 if (cmd.action != LFUN_UNKNOWN_ACTION) {
321 comname += ' ' + cmd.argument();
325 docstring const shortcuts = theTopLevelKeymap().
326 printBindings(cmd, KeySequence::ForGui);
328 if (!shortcuts.empty())
329 comname += ": " + shortcuts;
330 else if (!argsadded && !cmd.argument().empty())
331 comname += ' ' + cmd.argument();
333 if (!comname.empty()) {
334 comname = rtrim(comname);
335 dispatch_msg += '(' + rtrim(comname) + ')';
337 LYXERR(Debug::ACTION, "verbose dispatch msg " << to_utf8(dispatch_msg));
342 void LyXFunc::dispatch(FuncRequest const & cmd)
345 // redraw the screen at the end (first of the two drawing steps).
346 //This is done unless explicitly requested otherwise
347 dr.update(Update::FitCursor);
350 LyXView * lv = theApp()->currentWindow();
351 if (lv && lv->currentBufferView()) {
352 // BufferView::update() updates the ViewMetricsInfo and
353 // also initializes the position cache for all insets in
354 // (at least partially) visible top-level paragraphs.
355 // We will redraw the screen only if needed.
356 lv->currentBufferView()->processUpdateFlags(dr.update());
358 // Do we have a selection?
359 theSelection().haveSelection(
360 lv->currentBufferView()->cursor().selection());
368 void LyXFunc::dispatch(FuncRequest const & cmd, DispatchResult & dr)
370 string const argument = to_utf8(cmd.argument());
371 FuncCode const action = cmd.action;
373 LYXERR(Debug::ACTION, "\nLyXFunc::dispatch: cmd: " << cmd);
375 // we have not done anything wrong yet.
378 LyXView * lv = theApp()->currentWindow();
380 FuncStatus const flag = getStatus(cmd);
381 if (!flag.enabled()) {
382 // We cannot use this function here
383 LYXERR(Debug::ACTION, "LyXFunc::dispatch: "
384 << lyxaction.getActionName(action)
385 << " [" << action << "] is disabled at this location");
388 dr.setMessage(flag.message());
390 dr.dispatched(false);
391 dr.update(Update::None);
395 case LFUN_CURSOR_FOLLOWS_SCROLLBAR_TOGGLE:
396 lyxrc.cursor_follows_scrollbar = !lyxrc.cursor_follows_scrollbar;
402 string rest = split(argument, countstr, ' ');
403 istringstream is(countstr);
406 //lyxerr << "repeat: count: " << count << " cmd: " << rest << endl;
407 for (int i = 0; i < count; ++i)
408 dispatch(lyxaction.lookupFunc(rest));
412 case LFUN_COMMAND_SEQUENCE: {
413 // argument contains ';'-terminated commands
414 string arg = argument;
415 // FIXME: this LFUN should also work without any view.
416 Buffer * buffer = (lv && lv->documentBufferView())
417 ? &(lv->documentBufferView()->buffer()) : 0;
419 buffer->undo().beginUndoGroup();
420 while (!arg.empty()) {
422 arg = split(arg, first, ';');
423 FuncRequest func(lyxaction.lookupFunc(first));
424 func.origin = cmd.origin;
427 // the buffer may have been closed by one action
428 if (theBufferList().isLoaded(buffer))
429 buffer->undo().endUndoGroup();
433 case LFUN_COMMAND_ALTERNATIVES: {
434 // argument contains ';'-terminated commands
435 string arg = argument;
436 while (!arg.empty()) {
438 arg = split(arg, first, ';');
439 FuncRequest func(lyxaction.lookupFunc(first));
440 func.origin = cmd.origin;
441 FuncStatus stat = getStatus(func);
442 if (stat.enabled()) {
452 if (theTopLevelCmdDef().lock(argument, func)) {
453 func.origin = cmd.origin;
455 theTopLevelCmdDef().release(argument);
457 if (func.action == LFUN_UNKNOWN_ACTION) {
458 // unknown command definition
459 lyxerr << "Warning: unknown command definition `"
463 // recursion detected
464 lyxerr << "Warning: Recursion in the command definition `"
465 << argument << "' detected"
472 case LFUN_PREFERENCES_SAVE: {
473 lyxrc.write(makeAbsPath("preferences",
474 package().user_support().absFilename()),
479 case LFUN_BUFFER_SAVE_AS_DEFAULT: {
481 addName(addPath(package().user_support().absFilename(), "templates/"),
483 Buffer defaults(fname);
485 istringstream ss(argument);
488 int const unknown_tokens = defaults.readHeader(lex);
490 if (unknown_tokens != 0) {
491 lyxerr << "Warning in LFUN_BUFFER_SAVE_AS_DEFAULT!\n"
492 << unknown_tokens << " unknown token"
493 << (unknown_tokens == 1 ? "" : "s")
497 if (defaults.writeFile(FileName(defaults.absFileName())))
498 dr.setMessage(bformat(_("Document defaults saved in %1$s"),
499 makeDisplayPath(fname)));
502 dr.setMessage(from_ascii(N_("Unable to save document defaults")));
507 case LFUN_BOOKMARK_GOTO:
508 // go to bookmark, open unopened file and switch to buffer if necessary
509 gotoBookmark(convert<unsigned int>(to_utf8(cmd.argument())), true, true);
510 dr.update(Update::FitCursor);
513 case LFUN_BOOKMARK_CLEAR:
514 theSession().bookmarks().clear();
517 case LFUN_DEBUG_LEVEL_SET:
518 lyxerr.setLevel(Debug::value(to_utf8(cmd.argument())));
522 LASSERT(theApp(), /**/);
523 // Let the frontend dispatch its own actions.
524 theApp()->dispatch(cmd, dr);
526 // Nothing more to do.
529 // Everything below is only for active window
533 // Let the current LyXView dispatch its own actions.
534 lv->dispatch(cmd, dr);
536 BufferView * bv = lv->currentBufferView();
539 // Let the current BufferView dispatch its own actions.
540 bv->dispatch(cmd, dr);
544 BufferView * doc_bv = lv->documentBufferView();
545 // Try with the document BufferView dispatch if any.
547 doc_bv->dispatch(cmd, dr);
552 // OK, so try the current Buffer itself...
553 bv->buffer().dispatch(cmd, dr);
557 // and with the document Buffer.
559 doc_bv->buffer().dispatch(cmd, dr);
564 // Let the current Cursor dispatch its own actions.
565 Cursor old = bv->cursor();
566 bv->cursor().getPos(cursorPosBeforeDispatchX_,
567 cursorPosBeforeDispatchY_);
568 bv->cursor().dispatch(cmd);
570 // notify insets we just left
571 if (bv->cursor() != old) {
573 bool badcursor = notifyCursorLeavesOrEnters(old, bv->cursor());
575 bv->cursor().fixIfBroken();
578 // update completion. We do it here and not in
579 // processKeySym to avoid another redraw just for a
580 // changed inline completion
581 if (cmd.origin == FuncRequest::KEYBOARD) {
582 if (cmd.action == LFUN_SELF_INSERT
583 || (cmd.action == LFUN_ERT_INSERT && bv->cursor().inMathed()))
584 lv->updateCompletion(bv->cursor(), true, true);
585 else if (cmd.action == LFUN_CHAR_DELETE_BACKWARD)
586 lv->updateCompletion(bv->cursor(), false, true);
588 lv->updateCompletion(bv->cursor(), false, false);
591 dr = bv->cursor().result();
594 // if we executed a mutating lfun, mark the buffer as dirty
595 Buffer * doc_buffer = (lv && lv->documentBufferView())
596 ? &(lv->documentBufferView()->buffer()) : 0;
597 if (doc_buffer && theBufferList().isLoaded(doc_buffer)
599 && !lyxaction.funcHasFlag(action, LyXAction::NoBuffer)
600 && !lyxaction.funcHasFlag(action, LyXAction::ReadOnly))
601 lv->currentBufferView()->buffer().markDirty();
604 // Some messages may already be translated, so we cannot use _()
605 lv->message(makeDispatchMessage(translateIfPossible(dr.message()), cmd));