Revert "XHTML: remove DOCTYPE, as the document is then understood as HTML4/XHTML1...

[lyx.git] / src / mathed / InsetMathNest.cpp

diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp
index 66e900ad52441be1be5c857890172c72268d4cbe..be6fecc52654cf7a62c17f76bcc479dcada16a50 100644 (file)
--- a/src/mathed/InsetMathNest.cpp
+++ b/src/mathed/InsetMathNest.cpp
@@ -185,10 +185,10 @@ void InsetMathNest::cellsMetrics(MetricsInfo const & mi) const
 }
 
 
-void InsetMathNest::updateBuffer(ParIterator const & it, UpdateType utype)
+void InsetMathNest::updateBuffer(ParIterator const & it, UpdateType utype, bool const deleted)
 {
        for (idx_type i = 0, n = nargs(); i != n; ++i)
-               cell(i).updateBuffer(it, utype);
+               cell(i).updateBuffer(it, utype, deleted);
 }
 
 
@@ -330,6 +330,7 @@ void InsetMathNest::write(WriteStream & os) const
        ModeSpecifier specifier(os, currentMode(), lockedMode());
        docstring const latex_name = name();
        os << '\\' << latex_name;
+       os.inMathClass(asClassInset());
        for (size_t i = 0; i < nargs(); ++i) {
                Changer dummy = os.changeRowEntry(TexRow::mathEntry(id(),i));
                os << '{' << cell(i) << '}';
@@ -340,6 +341,7 @@ void InsetMathNest::write(WriteStream & os) const
                os << "\\lyxlock";
                os.pendingSpace(true);
        }
+       os.inMathClass(false);
 }
 
 
@@ -357,10 +359,7 @@ void InsetMathNest::latex(otexstream & os, OutputParams const & runparams) const
        WriteStream wi(os, runparams.moving_arg, true,
                        runparams.dryrun ? WriteStream::wsDryrun : WriteStream::wsDefault,
                        runparams.encoding);
-       wi.strikeoutMath(runparams.inDeletedInset
-                        && (!LaTeXFeatures::isAvailable("dvipost")
-                               || (runparams.flavor != OutputParams::LATEX
-                                   && runparams.flavor != OutputParams::DVILUATEX)));
+       wi.strikeoutMath(runparams.inDeletedInset);
        if (runparams.inulemcmd) {
                wi.ulemCmd(WriteStream::UNDERLINE);
                if (runparams.local_font) {
@@ -521,7 +520,6 @@ void InsetMathNest::handleFont2(Cursor & cur, docstring const & arg)
        // FIXME: support other font changes here as well?
 }
 
-
 void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
        //LYXERR0("InsetMathNest: request: " << cmd);
@@ -1235,10 +1233,12 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
                cur.recordUndoSelection();
                if (cmd.argument() == "^" || cmd.argument() == "_")
                        interpretChar(cur, cmd.argument()[0]);
+               else if (!cur.selection())
+                       cur.niceInsert(cmd.argument());
                else {
-                       MathData ar;
+                       MathData ar(cur.buffer());
                        asArray(cmd.argument(), ar);
-                       if (cur.selection() && ar.size() == 1
+                       if (ar.size() == 1
                            && ar[0]->asNestInset()
                            && ar[0]->asNestInset()->nargs() > 1)
                                handleNest(cur, ar[0]);
@@ -1278,6 +1278,32 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
                }
                break;
 
+       case LFUN_MATH_LIMITS: {
+               InsetMath * in = 0;
+               if (cur.pos() < cur.lastpos() && cur.nextMath().allowsLimitsChange())
+                       in = &cur.nextMath();
+               else if (cur.pos() > 0 && cur.prevMath().allowsLimitsChange())
+                       in = &cur.prevMath();
+               else if (cur.lastpos() > 0 && cur.cell().back()->allowsLimitsChange())
+                       in = cur.cell().back().nucleus();
+               // only when nucleus allows this
+               if (!in)
+                       return;
+               cur.recordUndoInset();
+               if (!cmd.argument().empty()) {
+                       if (cmd.argument() == "limits")
+                               in->limits(LIMITS);
+                       else if (cmd.argument() == "nolimits")
+                               in->limits(NO_LIMITS);
+                       else
+                               in->limits(AUTO_LIMITS);
+               } else if (in->limits() == AUTO_LIMITS)
+                       in->limits(in->defaultLimits() == LIMITS ? NO_LIMITS : LIMITS);
+               else
+                       in->limits(AUTO_LIMITS);
+               return;
+       }
+
        default:
                InsetMath::doDispatch(cur, cmd);
                break;
@@ -1327,9 +1353,6 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
        bool ret = true;
        string const arg = to_utf8(cmd.argument());
        switch (cmd.action()) {
-       case LFUN_INSET_MODIFY:
-               flag.setEnabled(false);
-               break;
 #if 0
        case LFUN_INSET_MODIFY:
                // FIXME: check temporarily disabled
@@ -1405,7 +1428,7 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
        case LFUN_INSET_INSERT: {
                // Don't test createMathInset_fromDialogStr(), since
                // getStatus is not called with a valid reference and the
-               // dialog would not be applyable.
+               // dialog would not be applicable.
                string const name = cmd.getArg(0);
                flag.setEnabled(name == "ref" || name == "mathspace");
                break;
@@ -1461,6 +1484,29 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
                break;
        }
 
+       case LFUN_MATH_LIMITS: {
+               InsetMath * in = 0;
+               if (cur.pos() < cur.lastpos() && cur.nextMath().allowsLimitsChange())
+                       in = &cur.nextMath();
+               else if (cur.pos() > 0 && cur.prevMath().allowsLimitsChange())
+                       in = &cur.prevMath();
+               else if (cur.lastpos() > 0 && cur.cell().back()->allowsLimitsChange())
+                       in = cur.cell().back().nucleus();
+               if (in) {
+                       if (!cmd.argument().empty()) {
+                               if (cmd.argument() == "limits")
+                                       flag.setOnOff(in->limits() == LIMITS);
+                               else if (cmd.argument() == "nolimits")
+                                       flag.setOnOff(in->limits() == NO_LIMITS);
+                               else
+                                       flag.setOnOff(in->limits() == AUTO_LIMITS);
+                       }
+                       flag.setEnabled(true);
+               } else
+                       flag.setEnabled(false);
+               return true;
+       }
+
        default:
                ret = false;
                break;
@@ -1862,6 +1908,15 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 
 bool InsetMathNest::interpretString(Cursor & cur, docstring const & str)
 {
+       if (str == "\\limits" || str == "\\nolimits") {
+               if (cur.pos() > 0 && cur.prevMath().allowsLimitsChange()) {
+                       cur.prevMath().limits(str == "\\limits" ? LIMITS : NO_LIMITS);
+                       return true;
+               } else {
+                       cur.message(bformat(_("Cannot apply %1$s here."), str));
+                       return false;
+               }
+       }
        // Create a InsetMathBig from cur.cell()[cur.pos() - 1] and t if
        // possible
        if (!cur.empty() && cur.pos() > 0 &&
@@ -2181,11 +2236,11 @@ std::string MathCompletionList::icon(size_t idx) const
        else
                cmd = locals[idx];
 
-       // get the icon resource name by stripping the backslash
+       // get the icon name by stripping the backslash
        docstring icon_name = frontend::Application::mathIcon(cmd.substr(1));
        if (icon_name.empty())
                return std::string();
-       return "images/math/" + to_utf8(icon_name);
+       return "math/" + to_utf8(icon_name);
 }
 
 std::vector<docstring> MathCompletionList::globals;