src/mathed/math_macro.C

   1 // -*- C++ -*-
   2 /*
   3  *  File:        math_macro.C
   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
   8  *
   9  *  Dependencies: Mathed
  10  *
  11  *  Copyright: 1996, 1997 Alejandro Aguilar Sierra
  12  *
  13  *  Version: 0.2, Mathed & Lyx project.
  14  *
  15  *  This code is under the GNU General Public Licence version 2 or later.
  16  */
  17
  18 #include <config.h>
  19 #include FORMS_H_LOCATION
  20
  21 #ifdef __GNUG__
  22 #pragma implementation "math_macro.h"
  23 #pragma implementation "math_defs.h"
  24 #endif
  25
  26 #include "LString.h"
  27 #include "math_macro.h"
  28 #include "math_iter.h"
  29 #include "math_inset.h"
  30 #include "support/lstrings.h"
  31 #include "debug.h"
  32
  33 using std::ostream;
  34 using std::endl;
  35
  36 ostream & operator<<(ostream & o, MathedTextCodes mtc)
  37 {
  38         return o << int(mtc);
  39 }
  40
  41 enum MathedMacroFlag {
  42     MMF_Env= 1,
  43     MMF_Exp= 2,
  44     MMF_Edit= 4
  45 };
  46
  47 ostream & operator<<(ostream & o, MathedMacroFlag mmf)
  48 {
  49         return o << int(mmf);
  50 }
  51
  52 extern int mathed_string_width(short type, int style, string const & s);
  53 extern int mathed_string_height(short, int, string const &, int &, int &);
  54
  55
  56 MathMacro::MathMacro(MathMacroTemplate* t):
  57     MathParInset(LM_ST_TEXT, "", LM_OT_MACRO), tmplate(t)
  58 {
  59     nargs = tmplate->getNoArgs();
  60     tcode = tmplate->getTCode();
  61     args = new MacroArgumentBase[nargs];
  62     for (int i = 0; i < nargs; ++i) {
  63 //      if (tmplate->getMacroPar(i)->Permit(LMPF_ALLOW_CR))
  64 //        args[i].row = new MathedRowSt(tmplate->getMacroPar(i)->GetColumns());
  65 //      else
  66           args[i].row = 0;
  67 /*      int k = tmplate->getMacroPar(i)->GetColumns();
  68         if (k>0) {
  69             args[i].array = new LyxArrayBase;
  70             for (int j= 0; j<k-1; ++j) args[i].array->Insert(j, LM_TC_TAB);
  71         }*/
  72     }
  73     idx = 0;
  74     SetName(tmplate->GetName());
  75 }
  76
  77
  78 MathMacro::MathMacro(MathMacro * m):
  79     MathParInset(LM_ST_TEXT, m->GetName(), LM_OT_MACRO)
  80 {
  81     tmplate = m->tmplate;
  82     nargs = tmplate->getNoArgs();
  83     tcode = tmplate->getTCode();
  84     args = new MacroArgumentBase[nargs];
  85     idx = 0;
  86     SetName(tmplate->GetName());
  87     for (int i = 0; i < tmplate->nargs; ++i) {
  88         m->setArgumentIdx(i);
  89         MathedIter it(m->GetData());
  90         args[i].row = m->args[i].row;
  91         args[i].array = it.Copy();
  92     }
  93 }
  94
  95 MathMacro::~MathMacro()
  96 {
  97     for (idx = 0; idx < nargs; ++idx) {
  98         MathedIter it(args[idx].array);
  99         it. Clear();
 100         delete args[idx].row;
 101     }
 102     delete[] args;
 103 }
 104
 105
 106 MathedInset * MathMacro::Clone()
 107 {
 108     return new MathMacro(this);
 109 }
 110
 111
 112 void MathMacro::Metrics()
 113 {
 114     if (nargs > 0)
 115       tmplate->update(this);
 116     tmplate->SetStyle(size);
 117     tmplate->Metrics();
 118     width = tmplate->Width();
 119     ascent = tmplate->Ascent();
 120     descent = tmplate->Descent();
 121 }
 122
 123
 124 void MathMacro::draw(Painter & pain, int x, int y)
 125 {
 126     xo = x;  yo = y;
 127     Metrics();
 128     tmplate->update(this);
 129     tmplate->SetStyle(size);
 130     tmplate->draw(pain, x, y);
 131     for (int i = 0; i < nargs; ++i) {
 132             tmplate->GetMacroXY(i, args[i].x, args[i].y);
 133     }
 134 }
 135
 136
 137 int MathMacro::GetColumns() const
 138 {
 139     return tmplate->getMacroPar(idx)->GetColumns();
 140 }
 141
 142
 143 void MathMacro::GetXY(int & x, int & y) const
 144 {
 145     x = args[idx].x;  y = args[idx].y;
 146 }
 147
 148
 149 bool MathMacro::Permit(short f)
 150 {
 151     return (nargs > 0) ?
 152             tmplate->getMacroPar(idx)->Permit(f) : MathParInset::Permit(f);
 153 }
 154
 155
 156 void MathMacro::SetFocus(int x, int y)
 157 {
 158     tmplate->update(this);
 159     tmplate->SetMacroFocus(idx, x, y);
 160 }
 161
 162
 163 void MathMacro::Write(ostream & os, bool fragile)
 164 {
 165     if (tmplate->flags & MMF_Exp) {
 166             lyxerr[Debug::MATHED] << "Expand " << tmplate->flags
 167                                   << ' ' << MMF_Exp << endl;
 168         tmplate->update(this);
 169         tmplate->Write(os, fragile);
 170     } else {
 171         if (tmplate->flags & MMF_Env) {
 172                 os << "\\begin{"
 173                    << name
 174                    << "} ";
 175         } else {
 176                 os << '\\' << name;
 177         }
 178 //      if (options) {
 179 //        file += '[';
 180 //        file += options;
 181 //        file += ']';
 182 //      }
 183
 184         if (!(tmplate->flags & MMF_Env) && nargs > 0)
 185                 os << '{';
 186
 187         for (int i = 0; i < nargs; ++i) {
 188             array = args[i].array;
 189             MathParInset::Write(os, fragile);
 190             if (i < nargs - 1)
 191                     os << "}{";
 192         }
 193         if (tmplate->flags & MMF_Env) {
 194                 os << "\\end{"
 195                    << name
 196                    << '}';
 197         } else {
 198             if (nargs > 0)
 199                     os << '}';
 200             else
 201                     os << ' ';
 202         }
 203     }
 204 }
 205
 206
 207 /*---------------  Macro argument -----------------------------------*/
 208
 209 MathMacroArgument::MathMacroArgument(int n)
 210 {
 211     number = n;
 212     expnd_mode = false;
 213     SetType(LM_OT_MACRO_ARG);
 214 }
 215
 216
 217 void MathMacroArgument::draw(Painter & pain, int x, int baseline)
 218 {
 219         if (expnd_mode) {
 220                 MathParInset::draw(pain, x, baseline);
 221         }
 222         else {
 223                 std::ostringstream ost;
 224                 ost << '#' << number;
 225                 drawStr(pain, LM_TC_TEX, size, x, baseline, ost.str().c_str());
 226         }
 227 }
 228
 229
 230 void MathMacroArgument::Metrics()
 231 {
 232         if (expnd_mode) {
 233                 MathParInset::Metrics();
 234         }
 235         else {
 236                 std::ostringstream ost;
 237                 ost << '#' << number;
 238                 width = mathed_string_width(LM_TC_TEX, size, ost.str().c_str());
 239                 mathed_string_height(LM_TC_TEX, size, ost.str().c_str(),
 240                                      ascent, descent);
 241         }
 242 }
 243
 244
 245 void MathMacroArgument::Write(ostream & os, bool fragile)
 246 {
 247     if (expnd_mode) {
 248         MathParInset::Write(os, fragile);
 249     } else {
 250             os << '#' << number << ' ';
 251     }
 252 }
 253
 254
 255 /* --------------------- MathMacroTemplate ---------------------------*/
 256
 257 MathMacroTemplate::MathMacroTemplate(string const & nm, int na, int flg):
 258     MathParInset(LM_ST_TEXT, nm, LM_OT_MACRO),
 259     flags(flg), nargs(na)
 260 {
 261     if (nargs > 0) {
 262         tcode = LM_TC_ACTIVE_INSET;
 263         args = new MathMacroArgument[nargs];
 264         for (int i = 0; i < nargs; ++i) {
 265             args[i].setNumber(i + 1);
 266         }
 267     } else {
 268         tcode = LM_TC_INSET;
 269         args = 0;
 270     }
 271 }
 272
 273
 274 MathMacroTemplate::~MathMacroTemplate()
 275 {
 276     // prevent to delete already deleted objects
 277     for (int i = 0; i < nargs; ++i) {
 278         args[i].SetData(0);
 279     }
 280     delete[] args;
 281 }
 282
 283
 284 void MathMacroTemplate::setEditMode(bool ed)
 285 {
 286     if (ed) {
 287         flags |= MMF_Edit;
 288         for (int i = 0; i < nargs; ++i) {
 289             args[i].setExpand(false);
 290         }
 291     } else {
 292         flags &= ~MMF_Edit;
 293         for (int i = 0; i < nargs; ++i) {
 294             args[i].setExpand(true);
 295         }
 296     }
 297 }
 298
 299
 300 void MathMacroTemplate::draw(Painter & pain, int x, int y)
 301 {
 302     int x2, y2;
 303     bool expnd = (nargs > 0) ? args[0].getExpand(): false;
 304     if (flags & MMF_Edit) {
 305         for (int i = 0; i < nargs; ++i) {
 306             args[i].setExpand(false);
 307         }
 308       x2 = x; y2 = y;
 309     } else {
 310         for (int i = 0; i < nargs; ++i) {
 311             args[i].setExpand(true);
 312         }
 313       x2 = xo; y2 = yo;
 314     }
 315     MathParInset::draw(pain, x, y);
 316     xo = x2; yo = y2;
 317
 318     for (int i = 0; i < nargs; ++i) {
 319         args[i].setExpand(expnd);
 320     }
 321 }
 322
 323
 324 void MathMacroTemplate::Metrics()
 325 {
 326     bool expnd = (nargs > 0) ? args[0].getExpand(): false;
 327
 328     if (flags & MMF_Edit) {
 329         for (int i = 0; i < nargs; ++i) {
 330             args[i].setExpand(false);
 331         }
 332     } else {
 333         for (int i = 0; i < nargs; ++i) {
 334             args[i].setExpand(true);
 335         }
 336     }
 337     MathParInset::Metrics();
 338
 339     for (int i = 0; i < nargs; ++i) {
 340         args[i].setExpand(expnd);
 341     }
 342 }
 343
 344
 345 void MathMacroTemplate::update(MathMacro * macro)
 346 {
 347     int idx = (macro) ? macro->getArgumentIdx() : 0;
 348     for (int i = 0; i < nargs; ++i) {
 349         if (macro) {
 350             macro->setArgumentIdx(i);
 351             args[i].SetData(macro->GetData());
 352             MathedRowSt * row = macro->getRowSt();
 353             args[i].setRowSt(row);
 354         }
 355     }
 356     if (macro)
 357       macro->setArgumentIdx(idx);
 358 }
 359
 360
 361 void MathMacroTemplate::WriteDef(ostream & os, bool fragile)
 362 {
 363         os << "\n\\newcommand{\\" << name << "}";
 364
 365     if (nargs > 0 )
 366             os << "[" << nargs << "]";
 367
 368     os << "{";
 369
 370     for (int i = 0; i < nargs; ++i) {
 371         args[i].setExpand(false);
 372     }
 373     Write(os, fragile);
 374     os << "}\n";
 375 }
 376
 377
 378 void MathMacroTemplate::setArgument(LyxArrayBase * a, int i)
 379 {
 380     args[i].SetData(a);
 381 }
 382
 383
 384 void MathMacroTemplate::GetMacroXY(int i, int & x, int & y) const
 385 {
 386     args[i].GetXY(x, y);
 387 }
 388
 389
 390 MathParInset * MathMacroTemplate::getMacroPar(int i) const
 391 {
 392     return (i >= 0 && i < nargs) ? static_cast<MathParInset*>(&args[i]) : 0;
 393 }
 394
 395
 396 void MathMacroTemplate::SetMacroFocus(int &idx, int x, int y)
 397 {
 398     for (int i = 0; i < nargs; ++i) {
 399         if (args[i].Inside(x, y)) {
 400             idx = i;
 401             break;
 402         }
 403     }
 404 }
 405
 406
 407 /* -------------------------- MathMacroTable -----------------------*/
 408
 409 MathMacroTable::MathMacroTable(int n) : max_macros(n)
 410 {
 411     macro_table = new MathMacroTemplateP[max_macros];
 412     num_macros = 0;
 413 }
 414
 415
 416 MathMacroTable::~MathMacroTable()
 417 {
 418     delete[] macro_table;
 419 }
 420
 421
 422 // The search is currently linear but will be binary or hash, later.
 423 MathMacroTemplate * MathMacroTable::getTemplate(string const & name) const
 424 {
 425     for (int i = 0; i < num_macros; ++i) {
 426       if (name == macro_table[i]->GetName())
 427         return macro_table[i];
 428     }
 429
 430     return 0;
 431 }
 432
 433 void MathMacroTable::addTemplate(MathMacroTemplate * m)
 434 {
 435     if (num_macros < max_macros)
 436       macro_table[num_macros++] = m;
 437     else
 438             lyxerr << "Error (MathMacroTable::addTemplate): "
 439                     "Macro table exhausted!" << endl;
 440 }
 441
 442
 443 // All this stuff aparently leaks because it's created here and is not
 444 // deleted never, but it have to live all the LyX sesion. OK, would not
 445 // so hard to do it in the MacroTable destructor, but this doesn't harm
 446 // seriously, so don't bother me with purify results here.   ;-)
 447
 448 void MathMacroTable::builtinMacros()
 449 {
 450     MathedIter iter;
 451     MathParInset * inset;// *arg;
 452     LyxArrayBase * array2;
 453
 454     built = true;
 455
 456     lyxerr[Debug::MATHED] << "Building macros" << endl;
 457
 458     // This macro doesn't have arguments
 459     MathMacroTemplate * m = new MathMacroTemplate("notin");  // this leaks
 460     addTemplate(m);
 461     LyxArrayBase * array = new LyxArrayBase; // this leaks
 462     iter.SetData(array);
 463     iter.Insert(new MathAccentInset(LM_in, LM_TC_BOPS, LM_not)); // this leaks
 464     m->SetData(array);
 465
 466     // These two are only while we are still with LyX 2.x
 467     m = new MathMacroTemplate("emptyset"); // this leaks
 468     addTemplate(m);
 469     array = new LyxArrayBase; // this leaks
 470     iter.SetData(array);
 471     iter.Insert(new MathAccentInset('O', LM_TC_RM, LM_not)); // this leaks
 472     m->SetData(array);
 473
 474     m = new MathMacroTemplate("perp"); // this leaks
 475     addTemplate(m);
 476     array = new LyxArrayBase; // this leaks
 477     iter.SetData(array);
 478     iter.Insert(LM_bot, LM_TC_BOP);
 479     m->SetData(array);
 480
 481     // binom has two arguments
 482     m = new MathMacroTemplate("binom", 2);
 483     addTemplate(m);
 484     array = new LyxArrayBase;
 485     m->SetData(array);
 486     iter.SetData(array);
 487     inset = new MathDelimInset('(', ')');
 488     iter.Insert(inset, LM_TC_ACTIVE_INSET);
 489     array = new LyxArrayBase;
 490     iter.SetData(array);
 491     MathFracInset *frac = new MathFracInset(LM_OT_ATOP);
 492     iter.Insert(frac, LM_TC_ACTIVE_INSET);
 493     inset->SetData(array);
 494     array = new LyxArrayBase;
 495     array2 = new LyxArrayBase;
 496     iter.SetData(array);
 497     iter.Insert(m->getMacroPar(0));
 498     iter.SetData(array2);
 499     iter.Insert(m->getMacroPar(1));
 500     frac->SetData(array, array2);
 501
 502 /*
 503     // Cases has 1 argument
 504     m = new MathMacroTemplate("cases", 1, MMF_Env); // this leaks
 505     addTemplate(m);
 506     array = new LyxArrayBase; // this leaks
 507     iter.SetData(array);
 508     arg = new MathMatrixInset(2, 1); // this leaks
 509
 510     m->setArgument(arg);
 511     arg->SetAlign('c', "ll");
 512     iter.Insert(arg, LM_TC_ACTIVE_INSET);
 513     inset = new MathDelimInset('{', '.'); // this leaks
 514     inset->SetData(array);
 515     array = new LyxArrayBase; // this leaks
 516     iter.SetData(array);
 517     iter.Insert(inset, LM_TC_ACTIVE_INSET);
 518     m->SetData(array);
 519
 520
 521     // the environment substack has 1 argument
 522     m = new MathMacroTemplate("substack", 1, MMF_Env); // this leaks
 523     addTemplate(m);
 524     arg = new MathMatrixInset(1, 1); // this leaks
 525     m->setArgument(arg);
 526     arg->SetType(LM_OT_MACRO);
 527     array = new LyxArrayBase; // this leaks
 528     iter.SetData(array);
 529     iter.Insert(arg, LM_TC_ACTIVE_INSET);
 530     m->SetData(array);*/
 531 }
 532
 533
 534 MathMacroTable MathMacroTable::mathMTable(255);
 535 bool MathMacroTable::built = false;