#include "math_macrotable.h"
#include "math_macro.h"
#include "math_macrotemplate.h"
+#include "math_parser.h"
#include "array.h"
-#include "math_accentinset.h"
+#include "math_decorationinset.h"
#include "math_deliminset.h"
#include "math_fracinset.h"
-#include "math_parinset.h"
+#include "math_inset.h"
#include "debug.h"
#include "support/LAssert.h"
using std::endl;
-using std::make_pair;
MathMacroTable::table_type MathMacroTable::macro_table;
-bool MathMacroTable::built = false;
-
void MathMacroTable::dump()
{
- using std::cerr;
-
- cerr << "\n------------------------------------------\n";
+ lyxerr << "\n------------------------------------------\n";
table_type::const_iterator it;
for (it = macro_table.begin(); it != macro_table.end(); ++it)
- cerr << it->first << ": " << it->second->GetData() << endl;
- cerr << "------------------------------------------\n";
+ lyxerr << it->first << " [" << it->second->nargs() << "] : "
+ << it->second << endl;
+ lyxerr << "------------------------------------------" << endl;;
}
-MathMacroTemplate &
-MathMacroTable::provideTemplate(string const & name, int na)
+void MathMacroTable::updateTemplate(MathMacroTemplate * par)
{
- if (!built)
- builtinMacros();
-
- if (macro_table.find(name) == macro_table.end())
- macro_table.insert(make_pair(name, new MathMacroTemplate(name, na)));
-
- return *(macro_table.find(name)->second);
+ table_type::iterator pos = macro_table.find(par->name());
+
+ if (pos == macro_table.end())
+ lyxerr << "MathMacroTable::updateTemplate: no template with name '"
+ << par->name() << "' available." << endl;
+ else
+ pos->second = par;
+}
+
+
+void MathMacroTable::insertTemplate(MathMacroTemplate * p)
+{
+ macro_table[p->name()] = p;
}
-MathMacroTemplate &
-MathMacroTable::provideTemplate(string const & name)
+MathMacroTemplate & MathMacroTable::provideTemplate(string const & name)
{
- if (!built)
- builtinMacros();
+ builtinMacros();
- return *macro_table[name];
+ table_type::iterator pos = macro_table.find(name);
+
+ if (pos == macro_table.end()) {
+ lyxerr << "MathMacroTable::provideTemplate: no template with name '"
+ << name << "' available." << endl;
+ }
+
+ return *pos->second;
}
bool MathMacroTable::hasTemplate(string const & name)
{
- if (!built)
- builtinMacros();
-
+ builtinMacros();
return macro_table.find(name) != macro_table.end();
}
void MathMacroTable::builtinMacros()
{
+ static bool built = false;
+
+ if (built)
+ return;
+
built = true;
lyxerr[Debug::MATHED] << "Building macros" << endl;
// This macro doesn't have arguments
{
- MathMacroTemplate & m = provideTemplate("notin", 0);
- m.push_back(new MathAccentInset(LM_in, LM_TC_BOPS, LM_not), LM_TC_INSET);
+ MathMacroTemplate * t = new MathMacroTemplate("notin", 0);
+ MathDecorationInset * p = new MathDecorationInset("not", LM_not);
+ p->cell(0).push_back(LM_in, LM_TC_BOPS);
+ t->push_back(p);
+ insertTemplate(t);
}
+/*
// This macro doesn't have arguments
{
- MathMacroTemplate & m = provideTemplate("silentmult", 0);
+ MathMacroTemplate & m = createTemplate("silentmult", 0);
istringstream is("\\cdot\0");
mathed_parser_file(is, 0);
- MathParInset * p = &m;
+ MathMatrixInset * p = &m;
mathed_parse(m.array, p, 0);
}
+*/
+
+ {
+ MathMacroTemplate * t = new MathMacroTemplate("emptyset", 0);
+ MathDecorationInset * p = new MathDecorationInset("not", LM_not);
+ p->cell(0).push_back('O', LM_TC_VAR);
+ t->push_back(p);
+ insertTemplate(t);
+ }
+
+ {
+ MathMacroTemplate * t = new MathMacroTemplate("land", 0);
+ t->push_back(LM_wedge, LM_TC_SYMB);
+ insertTemplate(t);
+ }
{
- MathMacroTemplate & m = provideTemplate("emptyset", 0);
- m.push_back(new MathAccentInset('0', LM_TC_RM, LM_not), LM_TC_INSET);
+ MathMacroTemplate * t = new MathMacroTemplate("lor", 0);
+ t->push_back(LM_vee, LM_TC_SYMB);
+ insertTemplate(t);
}
{
- MathMacroTemplate & m = provideTemplate("perp", 0);
- m.GetData().push_back(LM_bot, LM_TC_BOP);
+ MathMacroTemplate * t = new MathMacroTemplate("to", 0);
+ t->push_back(LM_rightarrow, LM_TC_SYMB);
+ insertTemplate(t);
}
{
- MathMacroTemplate & m = provideTemplate("lint", 4);
+ MathMacroTemplate * t = new MathMacroTemplate("perp", 0);
+ t->push_back(LM_bot, LM_TC_BOP);
+ insertTemplate(t);
+ }
+
+/*
+ {
+ MathMacroTemplate & m = createTemplate("lint", 4);
istringstream is("\\int_{#1}^{#2}#3 d#4\0");
mathed_parser_file(is, 0);
- MathParInset * p = &m;
+ MathMatrixInset * p = &m;
mathed_parse(m.array, p, 0);
}
+*/
+/*
+ {
+ MathMacroTemplate * t = new MathMacroTemplate("binomii", 2);
+ istringstream is("\\left(\\frac{#1}{#2}\\right)\0");
+ mathed_parser_file(is, 0);
+ mathed_parse(t->array, t, 0);
+ insertTemplate(t);
+ }
+*/
// binom has two arguments
+ {
+ MathFracInset * frac = new MathFracInset("atop");
+ frac->cell(0).push_back(new MathMacroArgument(1));
+ frac->cell(1).push_back(new MathMacroArgument(2));
+
+ MathInset * inset = new MathDelimInset('(', ')');
+ inset->push_back(frac);
+
+ MathMacroTemplate * t = new MathMacroTemplate("binom", 2);
+ t->push_back(inset);
+
+ insertTemplate(t);
+ }
+
+/*
{
MathFracInset * frac = new MathFracInset(LM_OT_ATOP);
- frac->push_back(new MathMacroArgument(1), LM_TC_INSET);
- frac->denom()->push_back(new MathMacroArgument(2), LM_TC_INSET);
+ frac->cell(0)->push_back(new MathMacroArgument(1));
+ frac->cell(1)->push_back(new MathMacroArgument(2));
- MathParInset * inset = new MathDelimInset('(', ')');
- inset->push_back(frac, LM_TC_ACTIVE_INSET);
+ MathMacroTemplate * t = new MathMacroTemplate("choose", 2);
+ t->push_back(frac);
- MathMacroTemplate & m = provideTemplate("binom", 2);
- m.push_back(inset, LM_TC_ACTIVE_INSET);
+ insertTemplate(t);
}
+*/
}