InsetMathFrac: reimplement \cfrac with its optional argument the way Enrico proposed...

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

diff --git a/src/mathed/MathParser.cpp b/src/mathed/MathParser.cpp
index 3cb58f42b7ccb33e07febe32f3366f45ed3e5380..757458cc88329a83cafe70db7ba35576578675b9 100644 (file)
--- a/src/mathed/MathParser.cpp
+++ b/src/mathed/MathParser.cpp
@@ -54,6 +54,7 @@ following hack as starting point to write some macros:
 #include "InsetMathRef.h"
 #include "InsetMathRoot.h"
 #include "InsetMathScript.h"
+#include "InsetMathSpace.h"
 #include "InsetMathSplit.h"
 #include "InsetMathSqrt.h"
 #include "InsetMathTabular.h"
@@ -671,7 +672,7 @@ docstring Parser::parse_verbatim_option()
                                putback();
                                res += '{' + parse_verbatim_item() + '}';
                        } else
-                               res += t.asString();
+                               res += t.asInput();
                }
        }
        return res;
@@ -690,7 +691,7 @@ docstring Parser::parse_verbatim_item()
                                res += '{' + parse_verbatim_item() + '}';
                        }
                        else
-                               res += t.asString();
+                               res += t.asInput();
                }
        }
        return res;
@@ -906,8 +907,24 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        return success_;
                }
 
-               else if (t.cat() == catOther)
-                       cell->push_back(MathAtom(new InsetMathChar(t.character())));
+               else if (t.cat() == catOther) {
+                       char_type c = t.character();
+                       if (isAsciiOrMathAlpha(c)
+                           || mode_ & Parse::VERBATIM
+                           || !(mode_ & Parse::USETEXT)
+                           || mode == InsetMath::TEXT_MODE) {
+                               cell->push_back(MathAtom(new InsetMathChar(c)));
+                       } else {
+                               MathAtom at = createInsetMath("text");
+                               at.nucleus()->cell(0).push_back(MathAtom(new InsetMathChar(c)));
+                               while (nextToken().cat() == catOther
+                                      && !isAsciiOrMathAlpha(nextToken().character())) {
+                                       c = getToken().character();
+                                       at.nucleus()->cell(0).push_back(MathAtom(new InsetMathChar(c)));
+                               }
+                               cell->push_back(at);
+                       }
+               }
 
                else if (t.cat() == catComment) {
                        docstring s;
@@ -1287,6 +1304,7 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
                        }
                }
+
                else if (t.cs() == "unitfrac") {
                        // Here allowed formats are \unitfrac[val]{num}{denom}
                        MathData ar;
@@ -1301,6 +1319,24 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode);
                }
 
+               else if (t.cs() == "cfrac") {
+                       // allowed formats are \cfrac[pos]{num}{denom}
+                       docstring const arg = getArg('[', ']');
+                       //lyxerr << "got so far: '" << arg << "'" << endl;                              
+                               if (arg == "l")
+                                       cell->push_back(MathAtom(new InsetMathFrac(InsetMathFrac::CFRACLEFT)));
+                               else if (arg == "r")
+                                       cell->push_back(MathAtom(new InsetMathFrac(InsetMathFrac::CFRACRIGHT)));
+                               else if (arg.empty() || arg == "c")
+                                       cell->push_back(MathAtom(new InsetMathFrac(InsetMathFrac::CFRAC)));
+                               else {
+                                       error("found invalid optional argument");
+                                       break;
+                               }
+                       parse(cell->back().nucleus()->cell(0), FLAG_ITEM, mode);
+                       parse(cell->back().nucleus()->cell(1), FLAG_ITEM, mode);
+               }
+
                else if (t.cs() == "xrightarrow" || t.cs() == "xleftarrow") {
                        cell->push_back(createInsetMath(t.cs()));
                        parse(cell->back().nucleus()->cell(1), FLAG_OPTION, mode);
@@ -1594,6 +1630,22 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                        parse(cell->back().nucleus()->cell(0), FLAG_ITEM, InsetMath::TEXT_MODE);
                }
 
+               else if (t.cs() == "hspace" && nextToken().character() != '*') {
+                       docstring const name = t.cs();
+                       docstring const arg = parse_verbatim_item();
+                       Length length;
+                       if (isValidLength(to_utf8(arg), &length))
+                               cell->push_back(MathAtom(new InsetMathSpace(length)));
+                       else {
+                               // Since the Length class cannot use length variables
+                               // we must not create an InsetMathSpace.
+                               cell->push_back(MathAtom(new MathMacro(name)));
+                               MathData ar;
+                               mathed_parse_cell(ar, '{' + arg + '}');
+                               cell->append(ar);
+                       }
+               }
+
 #if 0
                else if (t.cs() == "infer") {
                        MathData ar;
@@ -1642,17 +1694,18 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                return success_;
                        }
                        docstring rem;
-                       cmd = Encodings::fromLaTeXCommand(cmd, rem);
-                       for (size_t i = 0; i < cmd.size(); ++i)
-                               cell->push_back(MathAtom(new InsetMathChar(cmd[i])));
-                       if (rem.size()) {
-                               MathAtom at = createInsetMath(t.cs());
-                               cell->push_back(at);
-                               MathData ar;
-                               if (!mathed_parse_cell(ar, '{' + rem + '}', mode_))
-                                       success_ = false;;
-                               cell->append(ar);
-                       }
+                       do {
+                               cmd = Encodings::fromLaTeXCommand(cmd, rem);
+                               for (size_t i = 0; i < cmd.size(); ++i)
+                                       cell->push_back(MathAtom(new InsetMathChar(cmd[i])));
+                               if (rem.size()) {
+                                       char_type c = rem[0];
+                                       cell->push_back(MathAtom(new InsetMathChar(c)));
+                                       cmd = rem.substr(1);
+                                       rem.clear();
+                               } else
+                                       cmd.clear();
+                       } while (cmd.size());
                }
 
                else if (t.cs().size()) {