Fix bug 5802 (http://bugzilla.lyx.org/show_bug.cgi?id=5802)

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

diff --git a/src/mathed/MathMacroTemplate.cpp b/src/mathed/MathMacroTemplate.cpp
index 3087919d2a80874dcb952d1e5d34fba06c822de3..6765f01a99783b8980d014da7c4de850785ee52d 100644 (file)
--- a/src/mathed/MathMacroTemplate.cpp
+++ b/src/mathed/MathMacroTemplate.cpp
@@ -3,7 +3,8 @@
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
- * \author André Pönitz
+ * \author André Pönitz
+ * \author Stefan Schimanski
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -36,6 +37,7 @@
 
 #include "frontends/Painter.h"
 
+#include "support/lassert.h"
 #include "support/convert.h"
 #include "support/debug.h"
 #include "support/gettext.h"
@@ -618,7 +620,7 @@ bool MathMacroTemplate::notifyCursorLeaves(Cursor const & old, Cursor & cur)
        // find this in cursor old
        Cursor insetCur = old;
        int scriptSlice = insetCur.find(this);
-       BOOST_ASSERT(scriptSlice != -1);
+       LASSERT(scriptSlice != -1, /**/);
        insetCur.cutOff(scriptSlice);
        
        commitEditChanges(insetCur);
@@ -628,8 +630,9 @@ bool MathMacroTemplate::notifyCursorLeaves(Cursor const & old, Cursor & cur)
 }
 
 
-void MathMacroTemplate::removeArguments(Cursor & cur, int from, int to) {
-       for (DocIterator it = doc_iterator_begin(*this); it; it.forwardChar()) {
+void MathMacroTemplate::removeArguments(Cursor & cur, int from, int to)
+{
+       for (DocIterator it = doc_iterator_begin(&buffer(), this); it; it.forwardChar()) {
                if (!it.nextInset())
                        continue;
                if (it.nextInset()->lyxCode() != MATHMACROARG_CODE)
@@ -649,8 +652,9 @@ void MathMacroTemplate::removeArguments(Cursor & cur, int from, int to) {
 }
 
 
-void MathMacroTemplate::shiftArguments(size_t from, int by) {
-       for (DocIterator it = doc_iterator_begin(*this); it; it.forwardChar()) {
+void MathMacroTemplate::shiftArguments(size_t from, int by)
+{
+       for (DocIterator it = doc_iterator_begin(&buffer(), this); it; it.forwardChar()) {
                if (!it.nextInset())
                        continue;
                if (it.nextInset()->lyxCode() != MATHMACROARG_CODE)
@@ -667,8 +671,7 @@ void MathMacroTemplate::shiftArguments(size_t from, int by) {
 int MathMacroTemplate::maxArgumentInDefinition() const
 {
        int maxArg = 0;
-       MathMacroTemplate * nonConst = const_cast<MathMacroTemplate *>(this);
-       DocIterator it = doc_iterator_begin(*nonConst);
+       DocIterator it = doc_iterator_begin(&buffer(), this);
        it.idx() = defIdx();
        for (; it; it.forwardChar()) {
                if (!it.nextInset())
@@ -688,7 +691,7 @@ void MathMacroTemplate::insertMissingArguments(int maxArg)
        idx_type idx = cell(displayIdx()).empty() ? defIdx() : displayIdx();
 
        // search for #n macros arguments
-       DocIterator it = doc_iterator_begin(*this);
+       DocIterator it = doc_iterator_begin(&buffer(), this);
        it.idx() = idx;
        for (; it && it[0].idx() == idx; it.forwardChar()) {
                if (!it.nextInset())
@@ -1046,48 +1049,48 @@ bool MathMacroTemplate::getStatus(Cursor & /*cur*/, FuncRequest const & cmd,
                                num = convert<int>(arg);
                        bool on = (num >= optionals_
                                   && numargs_ < 9 && num <= numargs_ + 1);
-                       flag.enabled(on);
+                       flag.setEnabled(on);
                        break;
                }
 
                case LFUN_MATH_MACRO_APPEND_GREEDY_PARAM:
-                       flag.enabled(numargs_ < 9);
+                       flag.setEnabled(numargs_ < 9);
                        break;
 
                case LFUN_MATH_MACRO_REMOVE_PARAM: {
                        int num = numargs_;
                        if (arg.size() != 0)
                                num = convert<int>(arg);
-                       flag.enabled(num >= 1 && num <= numargs_);
+                       flag.setEnabled(num >= 1 && num <= numargs_);
                        break;
                }
 
                case LFUN_MATH_MACRO_MAKE_OPTIONAL:
-                       flag.enabled(numargs_ > 0
+                       flag.setEnabled(numargs_ > 0
                                     && optionals_ < numargs_
                                     && type_ != MacroTypeDef);
                        break;
 
                case LFUN_MATH_MACRO_MAKE_NONOPTIONAL:
-                       flag.enabled(optionals_ > 0
+                       flag.setEnabled(optionals_ > 0
                                     && type_ != MacroTypeDef);
                        break;
 
                case LFUN_MATH_MACRO_ADD_OPTIONAL_PARAM:
-                       flag.enabled(numargs_ < 9);
+                       flag.setEnabled(numargs_ < 9);
                        break;
 
                case LFUN_MATH_MACRO_REMOVE_OPTIONAL_PARAM:
-                       flag.enabled(optionals_ > 0);
+                       flag.setEnabled(optionals_ > 0);
                        break;
 
                case LFUN_MATH_MACRO_ADD_GREEDY_OPTIONAL_PARAM:
-                       flag.enabled(numargs_ == 0
+                       flag.setEnabled(numargs_ == 0
                                     && type_ != MacroTypeDef);
                        break;
 
                case LFUN_IN_MATHMACROTEMPLATE:
-                       flag.enabled();
+                       flag.setEnabled(true);
                        break;
 
                default:
@@ -1116,7 +1119,7 @@ void MathMacroTemplate::read(Lexer & lex)
 void MathMacroTemplate::write(ostream & os) const
 {
        odocstringstream oss;
-       WriteStream wi(oss, false, false);
+       WriteStream wi(oss, false, false, false);
        oss << "FormulaMacro\n";
        write(wi);
        os << to_utf8(oss.str());
@@ -1135,12 +1138,13 @@ void MathMacroTemplate::write(WriteStream & os, bool overwriteRedefinition) cons
                if (optionals_ > 0) {
                        // macros with optionals use the xargs package, e.g.:
                        // \newcommandx{\foo}[2][usedefault, addprefix=\global,1=default]{#1,#2}
+                       // \long is implicit by xargs
                        if (redefinition_ && !overwriteRedefinition)
                                os << "\\renewcommandx";
                        else
                                os << "\\newcommandx";
 
-                       os << "\\" << name().c_str()
+                       os << "\\" << name()
                           << "[" << numargs_ << "]"
                           << "[usedefault, addprefix=\\global";
                        for (int i = 0; i < optionals_; ++i) {
@@ -1155,9 +1159,11 @@ void MathMacroTemplate::write(WriteStream & os, bool overwriteRedefinition) cons
                        }
                        os << "]";
                } else {
-                       // macros without optionals use standard _global_ \def macros:
-                       // \global\def\foo#1#2{#1,#2}
-                       os << "\\global\\def\\" << name().c_str();
+                       // Macros without optionals use standard _global_ \def macros:
+                       //   \global\def\long\foo#1#2{#1,#2}
+                       // We use the \long prefix as this is the equivalent to \newcommand.
+                       // We cannot use \newcommand directly because \global does not work with it.
+                       os << "\\global\\long\\def\\" << name();
                        docstring param = from_ascii("#0");
                        for (int i = 1; i <= numargs_; ++i) { 
                                param[1] = '0' + i;
@@ -1167,12 +1173,12 @@ void MathMacroTemplate::write(WriteStream & os, bool overwriteRedefinition) cons
        } else {
                // in LyX output we use some pseudo syntax which is implementation
                // independent, e.g.
-               // \newcommand{\foo}[2][default}{#1,#2}
+               // \newcommand{\foo}[2][default]{#1,#2}
                if (redefinition_ && !overwriteRedefinition)
                        os << "\\renewcommand";
                else
                        os << "\\newcommand";
-               os << "{\\" << name().c_str() << '}';
+               os << "{\\" << name() << '}';
                if (numargs_ > 0)
                        os << '[' << numargs_ << ']';