]> git.lyx.org Git - lyx.git/blobdiff - src/Text3.cpp
Merge branch 'master' of git.lyx.org:lyx
[lyx.git] / src / Text3.cpp
index 3d73e1ef66eccbbfbfdca83dce4ec233502ea728..0467aa8b69f4fa26dac881bbd683894140d23f2c 100644 (file)
@@ -17,7 +17,6 @@
 
 #include "Text.h"
 
-#include "Bidi.h"
 #include "BranchList.h"
 #include "FloatList.h"
 #include "FuncStatus.h"
@@ -45,6 +44,7 @@
 #include "SpellChecker.h"
 #include "TextClass.h"
 #include "TextMetrics.h"
+#include "Thesaurus.h"
 #include "WordLangTuple.h"
 
 #include "frontends/alert.h"
@@ -72,6 +72,7 @@
 #include "support/gettext.h"
 #include "support/lassert.h"
 #include "support/lstrings.h"
+#include "support/lyxalgo.h"
 #include "support/lyxtime.h"
 #include "support/os.h"
 #include "support/regex.h"
@@ -79,8 +80,6 @@
 #include "mathed/InsetMathHull.h"
 #include "mathed/MathMacroTemplate.h"
 
-#include <boost/next_prior.hpp>
-
 #include <clocale>
 #include <sstream>
 
@@ -133,7 +132,7 @@ static void finishChange(Cursor & cur, bool selecting)
 }
 
 
-static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
+static void mathDispatch(Cursor & cur, FuncRequest const & cmd)
 {
        cur.recordUndo();
        docstring sel = cur.selectionAsString(false);
@@ -153,45 +152,39 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
                LATTEST(old_pos == cur.pos());
 #endif
                cur.nextInset()->edit(cur, true);
-               // don't do that also for LFUN_MATH_MODE
-               // unless you want end up with always changing
-               // to mathrm when opening an inlined inset --
-               // I really hate "LyXfunc overloading"...
-               if (display)
-                       cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY));
-               // Avoid an unnecessary undo step if cmd.argument
-               // is empty
-               if (!cmd.argument().empty())
-                       cur.dispatch(FuncRequest(LFUN_MATH_INSERT,
-                                                cmd.argument()));
+               if (cmd.action() != LFUN_MATH_MODE)
+                       // LFUN_MATH_MODE has a different meaning in math mode
+                       cur.dispatch(cmd);
        } else {
-               // create a macro if we see "\\newcommand"
-               // somewhere, and an ordinary formula
-               // otherwise
-               if (sel.find(from_ascii("\\newcommand")) == string::npos
-                               && sel.find(from_ascii("\\newlyxcommand")) == string::npos
-                               && sel.find(from_ascii("\\def")) == string::npos)
-               {
-                       InsetMathHull * formula = new InsetMathHull(cur.buffer());
-                       string const selstr = to_utf8(sel);
-                       istringstream is(selstr);
-                       Lexer lex;
+               InsetMathHull * formula = new InsetMathHull(cur.buffer());
+               string const selstr = to_utf8(sel);
+               istringstream is(selstr);
+               Lexer lex;
+               lex.setStream(is);
+               if (!formula->readQuiet(lex)) {
+                       // No valid formula, let's try with delims
+                       is.str("$" + selstr + "$");
                        lex.setStream(is);
                        if (!formula->readQuiet(lex)) {
-                               // No valid formula, let's try with delims
-                               is.str("$" + selstr + "$");
-                               lex.setStream(is);
-                               if (!formula->readQuiet(lex)) {
-                                       // Still not valid, leave it as is
-                                       valid = false;
-                                       delete formula;
-                                       cur.insert(sel);
-                               } else
-                                       cur.insert(formula);
-                       } else
-                               cur.insert(formula);
-               } else {
-                       cur.insert(new MathMacroTemplate(cur.buffer(), sel));
+                               // Still not valid, leave it as is
+                               valid = false;
+                               delete formula;
+                               cur.insert(sel);
+                       }
+               }
+               if (valid) {
+                       cur.insert(formula);
+                       cur.nextInset()->edit(cur, true);
+                       LASSERT(cur.inMathed(), return);
+                       cur.pos() = 0;
+                       cur.resetAnchor();
+                       cur.selection(true);
+                       cur.pos() = cur.lastpos();
+                       if (cmd.action() != LFUN_MATH_MODE)
+                               // LFUN_MATH_MODE has a different meaning in math mode
+                               cur.dispatch(cmd);
+                       cur.clearSelection();
+                       cur.pos() = cur.lastpos();
                }
        }
        if (valid)
@@ -274,6 +267,13 @@ static bool doInsertInset(Cursor & cur, Text * text,
                Layout::LaTeXArgMap::const_iterator const lait = args.find(ia->name());
                if (lait != args.end())
                        cotextinsert = (*lait).second.insertcotext;
+               else {
+                       InsetLayout const & il = cur.inset().getLayout();
+                       args = il.args();
+                       Layout::LaTeXArgMap::const_iterator const ilait = args.find(ia->name());
+                       if (ilait != args.end())
+                               cotextinsert = (*ilait).second.insertcotext;
+               }
                // The argument requests to insert a copy of the co-text to the inset
                if (cotextinsert) {
                        docstring ds;
@@ -370,7 +370,7 @@ static void outline(OutlineOp mode, Cursor & cur)
        ParagraphList & pars = buf.text().paragraphs();
        ParagraphList::iterator const bgn = pars.begin();
        // The first paragraph of the area to be copied:
-       ParagraphList::iterator start = boost::next(bgn, pit);
+       ParagraphList::iterator start = lyx::next(bgn, pit);
        // The final paragraph of area to be copied:
        ParagraphList::iterator finish = start;
        ParagraphList::iterator const end = pars.end();
@@ -421,7 +421,7 @@ static void outline(OutlineOp mode, Cursor & cur)
                                // Nothing to move.
                                return;
                        // Go one down from *this* header:
-                       ParagraphList::iterator dest = boost::next(finish, 1);
+                       ParagraphList::iterator dest = next(finish, 1);
                        // Go further down to find header to insert in front of:
                        for (; dest != end; ++dest) {
                                toclevel = buf.text().getTocLevel(distance(bgn, dest));
@@ -481,6 +481,15 @@ bool Text::isRTL(Paragraph const & par) const
        return par.isRTL(buffer.params());
 }
 
+       
+namespace {
+               
+       Language const * getLanguage(Cursor const & cur, string const & lang) {
+               return lang.empty() ? cur.getFont().language() : languages.getLanguage(lang);
+       }
+
+}
+
 
 void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 {
@@ -704,7 +713,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                cmd = FuncRequest(LFUN_FINISHED_LEFT);
                        }
                } else {
-                       if (reverseDirectionNeeded(cur)) {
+                       if (cur.reverseDirectionNeeded()) {
                                cmd.setAction(cmd.action() == LFUN_CHAR_LEFT_SELECT ?
                                        LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD);
                        } else {
@@ -728,7 +737,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                cmd = FuncRequest(LFUN_FINISHED_RIGHT);
                        }
                } else {
-                       if (reverseDirectionNeeded(cur)) {
+                       if (cur.reverseDirectionNeeded()) {
                                cmd.setAction(cmd.action() == LFUN_CHAR_RIGHT_SELECT ?
                                        LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD);
                        } else {
@@ -799,7 +808,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                ParagraphList & pars = buf.text().paragraphs();
                ParagraphList::iterator bgn = pars.begin();
                // The first paragraph of the area to be selected:
-               ParagraphList::iterator start = boost::next(bgn, pit);
+               ParagraphList::iterator start = lyx::next(bgn, pit);
                // The final paragraph of area to be selected:
                ParagraphList::iterator finish = start;
                ParagraphList::iterator end = pars.end();
@@ -840,7 +849,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                cmd = FuncRequest(LFUN_FINISHED_RIGHT);
                        }
                } else {
-                       if (reverseDirectionNeeded(cur)) {
+                       if (cur.reverseDirectionNeeded()) {
                                cmd.setAction(cmd.action() == LFUN_WORD_RIGHT_SELECT ?
                                                LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD);
                        } else {
@@ -892,7 +901,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                cmd = FuncRequest(LFUN_FINISHED_LEFT);
                        }
                } else {
-                       if (reverseDirectionNeeded(cur)) {
+                       if (cur.reverseDirectionNeeded()) {
                                cmd.setAction(cmd.action() == LFUN_WORD_LEFT_SELECT ?
                                                LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD);
                        } else {
@@ -1039,22 +1048,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
        case LFUN_CHAR_DELETE_FORWARD:
                if (!cur.selection()) {
-                       bool was_separator = cur.paragraph().isEnvSeparator(cur.pos());
                        if (cur.pos() == cur.paragraph().size())
                                // Par boundary, force full-screen update
                                singleParUpdate = false;
                        needsUpdate |= erase(cur);
                        cur.resetAnchor();
-                       if (was_separator && cur.pos() == cur.paragraph().size()
-                           && (!cur.paragraph().layout().isEnvironment()
-                               || cur.paragraph().size() > 0)) {
-                               // Force full-screen update
-                               singleParUpdate = false;
-                               needsUpdate |= erase(cur);
-                               cur.resetAnchor();
-                       }
-                       // It is possible to make it a lot faster still
-                       // just comment out the line below...
                } else {
                        cutSelection(cur, true, false);
                        singleParUpdate = false;
@@ -1066,18 +1064,17 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                if (!cur.selection()) {
                        if (bv->getIntl().getTransManager().backspace()) {
                                bool par_boundary = cur.pos() == 0;
+                               bool first_par = cur.pit() == 0;
                                // Par boundary, full-screen update
                                if (par_boundary)
                                        singleParUpdate = false;
                                needsUpdate |= backspace(cur);
                                cur.resetAnchor();
-                               if (par_boundary && cur.pos() > 0
+                               if (par_boundary && !first_par && cur.pos() > 0
                                    && cur.paragraph().isEnvSeparator(cur.pos() - 1)) {
                                        needsUpdate |= backspace(cur);
                                        cur.resetAnchor();
                                }
-                               // It is possible to make it a lot faster still
-                               // just comment out the line below...
                        }
                } else {
                        cutSelection(cur, true, false);
@@ -1089,6 +1086,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                cap::replaceSelection(cur);
                pit_type pit = cur.pit();
                Paragraph const & par = pars_[pit];
+               bool lastpar = (pit == pit_type(pars_.size() - 1));
+               Paragraph const & nextpar = lastpar ? par : pars_[pit + 1];
                pit_type prev = pit;
                if (pit > 0) {
                        if (!pars_[pit - 1].layout().isEnvironment())
@@ -1097,28 +1096,43 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                prev = pit - 1;
                }
                if (prev < pit && cur.pos() == par.beginOfBody()
-                   && !par.isEnvSeparator(cur.pos())
+                   && !par.size() && !par.isEnvSeparator(cur.pos())
                    && !par.layout().isCommand()
                    && pars_[prev].layout() != par.layout()
-                   && pars_[prev].layout().isEnvironment()) {
+                   && pars_[prev].layout().isEnvironment()
+                   && !nextpar.isEnvSeparator(nextpar.beginOfBody())) {
                        if (par.layout().isEnvironment()
                            && pars_[prev].getDepth() == par.getDepth()) {
                                docstring const layout = par.layout().name();
                                DocumentClass const & tc = bv->buffer().params().documentClass();
                                lyx::dispatch(FuncRequest(LFUN_LAYOUT, tc.plainLayout().name()));
-                               lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "parbreak"));
+                               lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
                                lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse"));
                                lyx::dispatch(FuncRequest(LFUN_LAYOUT, layout));
                        } else {
-                               lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "parbreak"));
+                               lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
                                breakParagraph(cur);
                        }
                        Font const f(inherit_font, cur.current_font.language());
                        pars_[cur.pit() - 1].resetFonts(f);
                } else {
+                       if (par.isEnvSeparator(cur.pos()))
+                               cur.posForward();
                        breakParagraph(cur, cmd.argument() == "inverse");
                }
                cur.resetAnchor();
+               // If we have a list and autoinsert item insets,
+               // insert them now.
+               Layout::LaTeXArgMap args = par.layout().args();
+               Layout::LaTeXArgMap::const_iterator lait = args.begin();
+               Layout::LaTeXArgMap::const_iterator const laend = args.end();
+               for (; lait != laend; ++lait) {
+                       Layout::latexarg arg = (*lait).second;
+                       if (arg.autoinsert && prefixIs((*lait).first, "item:")) {
+                               FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first);
+                               lyx::dispatch(cmd);
+                       }
+               }
                break;
        }
 
@@ -1275,15 +1289,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
        }
 
        case LFUN_WORD_UPCASE:
-               changeCase(cur, text_uppercase);
+               changeCase(cur, text_uppercase, cmd.getArg(0) == "partial");
                break;
 
        case LFUN_WORD_LOWCASE:
-               changeCase(cur, text_lowercase);
+               changeCase(cur, text_lowercase, cmd.getArg(0) == "partial");
                break;
 
        case LFUN_WORD_CAPITALIZE:
-               changeCase(cur, text_capitalization);
+               changeCase(cur, text_capitalization, cmd.getArg(0) == "partial");
                break;
 
        case LFUN_CHARS_TRANSPOSE:
@@ -1340,7 +1354,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                bv->buffer().errors("Paste");
                cur.clearSelection(); // bug 393
                cur.finishUndo();
-               bv->buffer().updatePreviews();
                break;
        }
 
@@ -1595,7 +1608,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                case mouse_button::button1:
                        // Set the cursor
                        if (!bv->mouseSetCursor(cur, cmd.argument() == "region-select"))
-                               cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
+                               cur.screenUpdateFlags(Update::FitCursor);
                        if (bvcur.wordSelection())
                                selectWord(bvcur, WHOLE_WORD);
                        break;
@@ -1620,7 +1633,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                return;
                        }
                        if (!bv->mouseSetCursor(cur, false))
-                               cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
+                               cur.screenUpdateFlags(Update::FitCursor);
                        break;
                }
 
@@ -1648,6 +1661,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
                tm->setCursorFromCoordinates(cur, cmd.x(), y);
                cur.setTargetX(cmd.x());
+               // Don't allow selecting a separator inset
+               if (cur.pos() && cur.paragraph().isEnvSeparator(cur.pos() - 1))
+                       cur.posBackward();
                if (cmd.y() >= wh)
                        lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
                else if (cmd.y() < 0)
@@ -1662,7 +1678,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                // We continue with our existing selection or start a new one, so don't
                // reset the anchor.
                bvcur.setCursor(cur);
-               bvcur.setSelection(true);
+               bvcur.selection(true);
                if (cur.top() == old) {
                        // We didn't move one iota, so no need to update the screen.
                        cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
@@ -1990,22 +2006,38 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                changeDepth(cur, INC_DEPTH);
                break;
 
-       case LFUN_MATH_DISPLAY:
-               mathDispatch(cur, cmd, true);
-               break;
-
        case LFUN_REGEXP_MODE:
                regexpDispatch(cur, cmd);
                break;
 
-       case LFUN_MATH_MODE:
-               if (cmd.argument() == "on")
+       case LFUN_MATH_MODE: {
+               if (cmd.argument() == "on" || cmd.argument() == "") {
                        // don't pass "on" as argument
                        // (it would appear literally in the first cell)
-                       mathDispatch(cur, FuncRequest(LFUN_MATH_MODE), false);
-               else
-                       mathDispatch(cur, cmd, false);
+                       docstring sel = cur.selectionAsString(false);
+                       MathMacroTemplate * macro = new MathMacroTemplate(cur.buffer());
+                       // create a macro template if we see "\\newcommand" somewhere, and
+                       // an ordinary formula otherwise
+                       if (!sel.empty()
+                               && (sel.find(from_ascii("\\newcommand")) != string::npos
+                                       || sel.find(from_ascii("\\newlyxcommand")) != string::npos
+                                       || sel.find(from_ascii("\\def")) != string::npos)
+                               && macro->fromString(sel)) {
+                               cur.recordUndo();
+                               replaceSelection(cur);
+                               cur.insert(macro);
+                       } else {
+                               // no meaningful macro template was found
+                               delete macro;
+                               mathDispatch(cur,FuncRequest(LFUN_MATH_MODE));
+                       }
+               } else
+                       // The argument is meaningful
+                       // We replace cmd with LFUN_MATH_INSERT because LFUN_MATH_MODE
+                       // has a different meaning in math mode
+                       mathDispatch(cur, FuncRequest(LFUN_MATH_INSERT,cmd.argument()));
                break;
+       }
 
        case LFUN_MATH_MACRO:
                if (cmd.argument().empty())
@@ -2028,32 +2060,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                        cur.push(*inset);
                        cur.top().pos() = cur.top().lastpos();
                        cur.resetAnchor();
-                       cur.setSelection(true);
+                       cur.selection(true);
                        cur.top().pos() = 0;
                }
                break;
 
-       // passthrough hat and underscore outside mathed:
+       case LFUN_MATH_DISPLAY:
        case LFUN_MATH_SUBSCRIPT:
-               mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "_"), false);
-               break;
        case LFUN_MATH_SUPERSCRIPT:
-               mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "^"), false);
-               break;
-
        case LFUN_MATH_INSERT:
        case LFUN_MATH_AMS_MATRIX:
        case LFUN_MATH_MATRIX:
        case LFUN_MATH_DELIM:
-       case LFUN_MATH_BIGDELIM: {
-               cur.recordUndo();
-               cap::replaceSelection(cur);
-               cur.insert(new InsetMathHull(cur.buffer(), hullSimple));
-               checkAndActivateInset(cur, true);
-               LASSERT(cur.inMathed(), break);
-               cur.dispatch(cmd);
+       case LFUN_MATH_BIGDELIM:
+               mathDispatch(cur, cmd);
                break;
-       }
 
        case LFUN_FONT_EMPH: {
                Font font(ignore_font, ignore_language);
@@ -2208,6 +2229,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
        case LFUN_FINISHED_BACKWARD:
                LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_BACKWARD:\n" << cur);
+               cur.setCurrentFont();
                break;
 
        case LFUN_FINISHED_FORWARD:
@@ -2242,6 +2264,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
        case LFUN_ACCENT_GRAVE:
        case LFUN_ACCENT_ACUTE:
        case LFUN_ACCENT_TILDE:
+       case LFUN_ACCENT_PERISPOMENI:
        case LFUN_ACCENT_CEDILLA:
        case LFUN_ACCENT_MACRON:
        case LFUN_ACCENT_DOT:
@@ -2305,6 +2328,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
        }
 
        case LFUN_THESAURUS_ENTRY: {
+               Language const * language = cur.getFont().language();
                docstring arg = cmd.argument();
                if (arg.empty()) {
                        arg = cur.selectionAsString(false);
@@ -2313,10 +2337,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                // Get word or selection
                                selectWordWhenUnderCursor(cur, WHOLE_WORD);
                                arg = cur.selectionAsString(false);
-                               arg += " lang=" + from_ascii(cur.getFont().language()->lang());
+                               arg += " lang=" + from_ascii(language->lang());
+                       }
+               } else {
+                       string lang = cmd.getArg(1);
+                       // This duplicates the code in GuiThesaurus::initialiseParams
+                       if (prefixIs(lang, "lang=")) {
+                               language = languages.getLanguage(lang.substr(5));
+                               if (!language)
+                                       language = cur.getFont().language();
                        }
                }
-               if (lyxrc.thesaurusdir_path.empty()) {
+               string lang = language->code();
+               if (lyxrc.thesaurusdir_path.empty() && !thesaurus.thesaurusInstalled(from_ascii(lang))) {
+                       LYXERR(Debug::ACTION, "Command " << cmd << ". Thesaurus not found for language " << lang);
                        frontend::Alert::warning(_("Path to thesaurus directory not set!"),
                                        _("The path to the thesaurus directory has not been specified.\n"
                                          "The thesaurus is not functional.\n"
@@ -2328,8 +2362,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
        }
 
        case LFUN_SPELLING_ADD: {
+               Language const * language = getLanguage(cur, cmd.getArg(1));
                docstring word = from_utf8(cmd.getArg(0));
-               Language * lang;
                if (word.empty()) {
                        word = cur.selectionAsString(false);
                        // FIXME
@@ -2338,22 +2372,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                selectWordWhenUnderCursor(cur, WHOLE_WORD);
                                word = cur.selectionAsString(false);
                        }
-                       lang = const_cast<Language *>(cur.getFont().language());
-               } else if (cmd.getArg(1).empty()) {
-                       // optional language argument is missing
-                       // use the language at cursor position
-                       lang = const_cast<Language *>(cur.getFont().language());
-               } else {
-                       lang = const_cast<Language *>(languages.getLanguage(cmd.getArg(1)));
                }
-               WordLangTuple wl(word, lang);
+               WordLangTuple wl(word, language);
                theSpellChecker()->insert(wl);
                break;
        }
 
        case LFUN_SPELLING_IGNORE: {
+               Language const * language = getLanguage(cur, cmd.getArg(1));
                docstring word = from_utf8(cmd.getArg(0));
-               Language * lang;
                if (word.empty()) {
                        word = cur.selectionAsString(false);
                        // FIXME
@@ -2362,20 +2389,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                selectWordWhenUnderCursor(cur, WHOLE_WORD);
                                word = cur.selectionAsString(false);
                        }
-                       lang = const_cast<Language *>(cur.getFont().language());
-               } else if (cmd.getArg(1).empty()) {
-                       lang = const_cast<Language *>(cur.getFont().language());
-               } else {
-                       lang = const_cast<Language *>(languages.getLanguage(cmd.getArg(1)));
                }
-               WordLangTuple wl(word, lang);
+               WordLangTuple wl(word, language);
                theSpellChecker()->accept(wl);
                break;
        }
 
        case LFUN_SPELLING_REMOVE: {
+               Language const * language = getLanguage(cur, cmd.getArg(1));
                docstring word = from_utf8(cmd.getArg(0));
-               Language * lang;
                if (word.empty()) {
                        word = cur.selectionAsString(false);
                        // FIXME
@@ -2384,13 +2406,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
                                selectWordWhenUnderCursor(cur, WHOLE_WORD);
                                word = cur.selectionAsString(false);
                        }
-                       lang = const_cast<Language *>(cur.getFont().language());
-               } else if (cmd.getArg(1).empty()) {
-                       lang = const_cast<Language *>(cur.getFont().language());
-               } else {
-                       lang = const_cast<Language *>(languages.getLanguage(cmd.getArg(1)));
                }
-               WordLangTuple wl(word, lang);
+               WordLangTuple wl(word, language);
                theSpellChecker()->remove(wl);
                break;
        }
@@ -2419,7 +2436,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
        case LFUN_ESCAPE:
                if (cur.selection()) {
-                       cur.setSelection(false);
+                       cur.selection(false);
                } else {
                        cur.undispatched();
                        // This used to be LFUN_FINISHED_RIGHT, I think FORWARD is more
@@ -2704,7 +2721,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
        case LFUN_CAPTION_INSERT: {
                code = CAPTION_CODE;
                string arg = cmd.getArg(0);
-               bool varia = arg != "LongTableNoNumber"
+               bool varia = arg != "Unnumbered"
                        && cur.inset().allowsCaptionVariation(arg);
                // not allowed in description items,
                // and in specific insets
@@ -2959,25 +2976,30 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
                        break;
                }
 
-               // explicit graphics type?
                Clipboard::GraphicsType type = Clipboard::AnyGraphicsType;
-               if ((arg == "pdf" && (type = Clipboard::PdfGraphicsType))
-                         || (arg == "png" && (type = Clipboard::PngGraphicsType))
-                         || (arg == "jpeg" && (type = Clipboard::JpegGraphicsType))
-                         || (arg == "linkback" &&  (type = Clipboard::LinkBackGraphicsType))
-                         || (arg == "emf" &&  (type = Clipboard::EmfGraphicsType))
-                         || (arg == "wmf" &&  (type = Clipboard::WmfGraphicsType))) {
-                       enable = theClipboard().hasGraphicsContents(type);
+               if (arg == "pdf")
+                       type = Clipboard::PdfGraphicsType;
+               else if (arg == "png")
+                       type = Clipboard::PngGraphicsType;
+               else if (arg == "jpeg")
+                       type = Clipboard::JpegGraphicsType;
+               else if (arg == "linkback")
+                       type = Clipboard::LinkBackGraphicsType;
+               else if (arg == "emf")
+                       type = Clipboard::EmfGraphicsType;
+               else if (arg == "wmf")
+                       type = Clipboard::WmfGraphicsType;
+               else {
+                       // unknown argument
+                       LYXERR0("Unrecognized graphics type: " << arg);
+                       // we don't want to assert if the user just mistyped the LFUN
+                       LATTEST(cmd.origin() != FuncRequest::INTERNAL);
+                       enable = false;
                        break;
                }
-
-               // unknown argument
-               LYXERR0("Unrecognized graphics type: " << arg);
-               // we don't want to assert if the user just mistyped the LFUN
-               LATTEST(cmd.origin() != FuncRequest::INTERNAL);
-               enable = false;
+               enable = theClipboard().hasGraphicsContents(type);
                break;
-        }
+       }
 
        case LFUN_CLIPBOARD_PASTE:
        case LFUN_CLIPBOARD_PASTE_SIMPLE:
@@ -3083,13 +3105,12 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
                break;
 
        case LFUN_LAYOUT: {
-               enable = !cur.inset().forcePlainLayout();
-
+               DocumentClass const & tclass = cur.buffer()->params().documentClass();
                docstring layout = cmd.argument();
-               if (layout.empty()) {
-                       DocumentClass const & tclass = cur.buffer()->params().documentClass();
+               if (layout.empty())
                        layout = tclass.defaultLayoutName();
-               }
+               enable = !owner_->forcePlainLayout() && tclass.hasLayout(layout);
+
                flag.setOnOff(layout == cur.paragraph().layout().name());
                break;
        }
@@ -3124,10 +3145,13 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
        case LFUN_PARAGRAPH_PARAMS:
        case LFUN_PARAGRAPH_PARAMS_APPLY:
        case LFUN_PARAGRAPH_UPDATE:
-               enable = cur.inset().allowParagraphCustomization();
+               enable = owner_->allowParagraphCustomization();
                break;
 
        // FIXME: why are accent lfuns forbidden with pass_thru layouts?
+       //  Because they insert COMBINING DIACRITICAL Unicode characters,
+       //  that cannot be handled by LaTeX but must be converted according
+       //  to the definition in lib/unicodesymbols?
        case LFUN_ACCENT_ACUTE:
        case LFUN_ACCENT_BREVE:
        case LFUN_ACCENT_CARON:
@@ -3141,6 +3165,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
        case LFUN_ACCENT_OGONEK:
        case LFUN_ACCENT_TIE:
        case LFUN_ACCENT_TILDE:
+       case LFUN_ACCENT_PERISPOMENI:
        case LFUN_ACCENT_UMLAUT:
        case LFUN_ACCENT_UNDERBAR:
        case LFUN_ACCENT_UNDERDOT: