4 * Purpose: Implementation of macro class for mathed
5 * Author: Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
6 * Created: November 1996
7 * Description: WYSIWYG math macros
11 * Copyright: 1996, 1997 Alejandro Aguilar Sierra
13 * Version: 0.2, Mathed & Lyx project.
15 * This code is under the GNU General Public Licence version 2 or later.
19 #include FORMS_H_LOCATION
22 #pragma implementation "math_macro.h"
23 #pragma implementation "math_defs.h"
27 #include "math_macro.h"
28 #include "math_iter.h"
29 #include "math_inset.h"
30 #include "support/lstrings.h"
34 ostream & operator<<(ostream & o, MathedTextCodes mtc)
39 enum MathedMacroFlag {
45 ostream & operator<<(ostream & o, MathedMacroFlag mmf)
50 extern int mathed_string_width(short type, int style, byte const* s, int ls);
51 extern int mathed_string_height(short, int, byte const*, int, int&, int&);
54 MathMacro::MathMacro(MathMacroTemplate* t):
55 MathParInset(LM_ST_TEXT, "", LM_OT_MACRO), tmplate(t)
57 nargs = tmplate->getNoArgs();
58 tcode = tmplate->getTCode();
59 args = new MacroArgumentBase[nargs];
60 for (int i = 0; i < nargs; ++i) {
61 // if (tmplate->getMacroPar(i)->Permit(LMPF_ALLOW_CR))
62 // args[i].row = new MathedRowSt(tmplate->getMacroPar(i)->GetColumns());
65 /* int k = tmplate->getMacroPar(i)->GetColumns();
67 args[i].array = new LyxArrayBase;
68 for (int j= 0; j<k-1; ++j) args[i].array->Insert(j, LM_TC_TAB);
72 SetName(tmplate->GetName());
76 MathMacro::MathMacro(MathMacro * m):
77 MathParInset(LM_ST_TEXT, m->GetName(), LM_OT_MACRO)
80 nargs = tmplate->getNoArgs();
81 tcode = tmplate->getTCode();
82 args = new MacroArgumentBase[nargs];
84 SetName(tmplate->GetName());
85 for (int i = 0; i < tmplate->nargs; ++i) {
87 MathedIter it(m->GetData());
88 args[i].row = m->args[i].row;
89 args[i].array = it.Copy();
93 MathMacro::~MathMacro()
95 for (idx = 0; idx < nargs; ++idx) {
96 MathedIter it(args[idx].array);
104 MathedInset * MathMacro::Clone()
106 return new MathMacro(this);
110 void MathMacro::Metrics()
113 tmplate->update(this);
115 width = tmplate->Width();
116 ascent = tmplate->Ascent();
117 descent = tmplate->Descent();
121 void MathMacro::draw(Painter & pain, int x, int y)
125 tmplate->update(this);
126 tmplate->SetStyle(size);
127 tmplate->draw(pain, x, y);
128 for (int i = 0; i < nargs; ++i)
129 tmplate->GetMacroXY(i, args[i].x, args[i].y);
133 int MathMacro::GetColumns()
135 return tmplate->getMacroPar(idx)->GetColumns();
139 void MathMacro::GetXY(int & x, int & y) const
141 x = args[idx].x; y = args[idx].y;
145 bool MathMacro::Permit(short f)
148 tmplate->getMacroPar(idx)->Permit(f) : MathParInset::Permit(f);
152 void MathMacro::SetFocus(int x, int y)
154 tmplate->update(this);
155 tmplate->SetMacroFocus(idx, x, y);
159 void MathMacro::Write(ostream & os)
161 #ifdef USE_OSTREAM_ONLY
162 if (tmplate->flags & MMF_Exp) {
163 lyxerr[Debug::MATHED] << "Expand " << tmplate->flags
164 << ' ' << MMF_Exp << endl;
165 tmplate->update(this);
168 if (tmplate->flags & MMF_Env) {
181 if (!(tmplate->flags & MMF_Env) && nargs > 0)
184 for (int i = 0; i < nargs; ++i) {
185 array = args[i].array;
186 MathParInset::Write(os);
190 if (tmplate->flags & MMF_Env) {
203 MathMacro::Write(output);
209 #ifndef USE_OSTREAM_ONLY
210 void MathMacro::Write(string &file)
212 if (tmplate->flags & MMF_Exp) {
213 lyxerr[Debug::MATHED] << "Expand " << tmplate->flags
214 << ' ' << MMF_Exp << endl;
215 tmplate->update(this);
216 tmplate->Write(file);
218 if (tmplate->flags & MMF_Env) {
232 if (!(tmplate->flags & MMF_Env) && nargs > 0)
235 for (int i = 0; i < nargs; ++i) {
236 array = args[i].array;
237 MathParInset::Write(file);
241 if (tmplate->flags & MMF_Env) {
256 /*--------------- Macro argument -----------------------------------*/
258 MathMacroArgument::MathMacroArgument(int n)
262 SetType(LM_OT_MACRO_ARG);
266 void MathMacroArgument::draw(Painter & pain, int x, int baseline)
269 MathParInset::draw(pain, x, baseline);
273 ost << '#' << number;
274 drawStr(pain, LM_TC_TEX, size, x, baseline,
275 reinterpret_cast<byte const *>(ost.str().c_str()), 2);
278 ostrstream ost(s, 3);
279 ost << '#' << number << '\0';
280 drawStr(pain, LM_TC_TEX, size, x, baseline,
281 reinterpret_cast<byte *>(ost.str()), 2);
287 void MathMacroArgument::Metrics()
290 MathParInset::Metrics();
294 ost << '#' << number;
295 width = mathed_string_width(LM_TC_TEX, size,
296 reinterpret_cast<byte const *>(ost.str().c_str()), 2);
297 mathed_string_height(LM_TC_TEX, size,
298 reinterpret_cast<byte const *>(ost.str().c_str()),
302 ostrstream ost(s, 3);
303 ost << '#' << number << '\0';
304 width = mathed_string_width(LM_TC_TEX, size,
305 reinterpret_cast<byte *>
307 mathed_string_height(LM_TC_TEX, size,
308 reinterpret_cast<byte *>(ost.str()),
315 void MathMacroArgument::Write(ostream & os)
317 #ifdef USE_OSTREAM_ONLY
319 MathParInset::Write(os);
321 os << '#' << number << ' ';
325 MathMacroArgument::Write(output);
331 #ifndef USE_OSTREAM_ONLY
332 void MathMacroArgument::Write(string & file)
335 MathParInset::Write(file);
338 file += tostr(number);
345 /* --------------------- MathMacroTemplate ---------------------------*/
347 MathMacroTemplate::MathMacroTemplate(char const * nm, int na, int flg):
348 MathParInset(LM_ST_TEXT, nm, LM_OT_MACRO),
349 flags(flg), nargs(na)
352 tcode = LM_TC_ACTIVE_INSET;
353 args = new MathMacroArgument[nargs];
354 for (int i = 0; i < nargs; ++i) {
355 args[i].setNumber(i + 1);
362 MathMacroTemplate::~MathMacroTemplate()
364 // prevent to delete already deleted objects
365 for (int i = 0; i < nargs; ++i) {
372 void MathMacroTemplate::setEditMode(bool ed)
376 for (int i = 0; i < nargs; ++i) {
377 args[i].setExpand(false);
381 for (int i = 0; i < nargs; ++i) {
382 args[i].setExpand(true);
388 void MathMacroTemplate::draw(Painter & pain, int x, int y)
391 bool expnd = (nargs > 0) ? args[0].getExpand(): false;
392 if (flags & MMF_Edit) {
393 for (int i = 0; i < nargs; ++i) {
394 args[i].setExpand(false);
398 for (int i = 0; i < nargs; ++i) {
399 args[i].setExpand(true);
403 MathParInset::draw(pain, x, y);
406 for (int i = 0; i < nargs; ++i) {
407 args[i].setExpand(expnd);
412 void MathMacroTemplate::Metrics()
414 bool expnd = (nargs>0) ? args[0].getExpand(): false;
416 if (flags & MMF_Edit) {
417 for (int i = 0; i < nargs; ++i) {
418 args[i].setExpand(false);
421 for (int i = 0; i < nargs; ++i) {
422 args[i].setExpand(true);
425 MathParInset::Metrics();
427 for (int i = 0; i < nargs; ++i) {
428 args[i].setExpand(expnd);
433 void MathMacroTemplate::update(MathMacro * macro)
435 int idx = (macro) ? macro->getArgumentIdx(): 0;
436 for (int i = 0; i < nargs; ++i) {
438 macro->setArgumentIdx(i);
439 args[i].SetData(macro->GetData());
440 MathedRowSt *row = macro->getRowSt();
441 args[i].setRowSt(row);
445 macro->setArgumentIdx(idx);
449 void MathMacroTemplate::WriteDef(ostream & os)
451 os << "\n\\newcommand{\\" << name << "}";
454 os << "[" << nargs << "]";
458 for (int i = 0; i < nargs; ++i) {
459 args[i].setExpand(false);
466 #ifndef USE_OSTREAM_ONLY
467 void MathMacroTemplate::WriteDef(string & file)
469 file += "\n\\newcommand{\\";
475 file += tostr(nargs);
481 for (int i = 0; i < nargs; ++i) {
482 args[i].setExpand(false);
490 void MathMacroTemplate::setArgument(LyxArrayBase * a, int i)
496 void MathMacroTemplate::GetMacroXY(int i, int & x, int & y) const
502 MathParInset * MathMacroTemplate::getMacroPar(int i) const
504 return (i >= 0 && i < nargs) ? static_cast<MathParInset*>(&args[i]) : 0;
508 void MathMacroTemplate::SetMacroFocus(int &idx, int x, int y)
510 for (int i = 0; i < nargs; ++i) {
511 if (args[i].Inside(x, y)) {
519 /* -------------------------- MathMacroTable -----------------------*/
521 MathMacroTable::MathMacroTable(int n) : max_macros(n)
523 macro_table = new MathMacroTemplateP[max_macros];
528 MathMacroTable::~MathMacroTable()
530 delete[] macro_table;
534 // The search is currently linear but will be binary or hash, later.
535 MathMacroTemplate * MathMacroTable::getTemplate(char const * name) const
537 for (int i = 0; i < num_macros; ++i) {
538 if (strcmp(name, macro_table[i]->GetName()) == 0)
539 return macro_table[i];
545 void MathMacroTable::addTemplate(MathMacroTemplate * m)
547 if (num_macros < max_macros)
548 macro_table[num_macros++] = m;
550 lyxerr << "Error (MathMacroTable::addTemplate): "
551 "Macro table exhausted!" << endl;
555 // All this stuff aparently leaks because it's created here and is not
556 // deleted never, but it have to live all the LyX sesion. OK, would not
557 // so hard to do it in the MacroTable destructor, but this doesn't harm
558 // seriously, so don't bother me with purify results here. ;-)
560 void MathMacroTable::builtinMacros()
563 MathParInset * inset;// *arg;
564 LyxArrayBase * array2;
568 lyxerr[Debug::MATHED] << "Building macros" << endl;
570 // This macro doesn't have arguments
571 MathMacroTemplate * m = new MathMacroTemplate("notin"); // this leaks
573 LyxArrayBase * array = new LyxArrayBase; // this leaks
575 iter.Insert(new MathAccentInset(LM_in, LM_TC_BOPS, LM_not)); // this leaks
578 // These two are only while we are still with LyX 2.x
579 m = new MathMacroTemplate("emptyset"); // this leaks
581 array = new LyxArrayBase; // this leaks
583 iter.Insert(new MathAccentInset('O', LM_TC_RM, LM_not)); // this leaks
586 m = new MathMacroTemplate("perp"); // this leaks
588 array = new LyxArrayBase; // this leaks
590 iter.Insert(LM_bot, LM_TC_BOP);
593 // binom has two arguments
594 m = new MathMacroTemplate("binom", 2);
596 array = new LyxArrayBase;
599 inset = new MathDelimInset('(', ')');
600 iter.Insert(inset, LM_TC_ACTIVE_INSET);
601 array = new LyxArrayBase;
603 MathFracInset *frac = new MathFracInset(LM_OT_ATOP);
604 iter.Insert(frac, LM_TC_ACTIVE_INSET);
605 inset->SetData(array);
606 array = new LyxArrayBase;
607 array2 = new LyxArrayBase;
609 iter.Insert(m->getMacroPar(0));
610 iter.SetData(array2);
611 iter.Insert(m->getMacroPar(1));
612 frac->SetData(array, array2);
615 // Cases has 1 argument
616 m = new MathMacroTemplate("cases", 1, MMF_Env); // this leaks
618 array = new LyxArrayBase; // this leaks
620 arg = new MathMatrixInset(2, 1); // this leaks
623 arg->SetAlign('c', "ll");
624 iter.Insert(arg, LM_TC_ACTIVE_INSET);
625 inset = new MathDelimInset('{', '.'); // this leaks
626 inset->SetData(array);
627 array = new LyxArrayBase; // this leaks
629 iter.Insert(inset, LM_TC_ACTIVE_INSET);
633 // the environment substack has 1 argument
634 m = new MathMacroTemplate("substack", 1, MMF_Env); // this leaks
636 arg = new MathMatrixInset(1, 1); // this leaks
638 arg->SetType(LM_OT_MACRO);
639 array = new LyxArrayBase; // this leaks
641 iter.Insert(arg, LM_TC_ACTIVE_INSET);
646 MathMacroTable MathMacroTable::mathMTable(255);
647 bool MathMacroTable::built = false;