home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / formula.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  29KB  |  1,205 lines
  1. /*
  2.  *  File:        formula.h
  3.  *  Purpose:     Implementation of formula inset
  4.  *  Author:      Alejandro Aguilar Sierra <asierra@servidor.unam.mx> 
  5.  *  Created:     January 1996
  6.  *  Description: Allows the edition of math paragraphs inside Lyx. 
  7.  *
  8.  *  Copyright: (c) 1996-1998 Alejandro Aguilar Sierra
  9.  *
  10.  *  Version: 0.4, Lyx project.
  11.  *
  12.  *   You are free to use and modify this code under the terms of
  13.  *   the GNU General Public Licence version 2 or later.
  14.  */
  15.  
  16. #include <config.h>
  17.  
  18. #include <stdlib.h>
  19.  
  20. #ifdef __GNUG__
  21. #pragma implementation "formula.h"
  22. #endif
  23.  
  24. #include "formula.h"
  25. #include "commandtags.h"
  26. #include "math_cursor.h"
  27. #include "math_parser.h"
  28. #include "lyx_main.h"
  29. #include "bufferlist.h"
  30. #include "lyx_cb.h"
  31. #include "minibuffer.h"
  32. #include "BufferView.h"
  33. #include "lyxscreen.h"
  34. #include "lyxdraw.h"
  35. #include "lyxtext.h"
  36. #include "gettext.h"
  37. #include "LaTeXFeatures.h"
  38. #include "error.h"
  39.  
  40. //     $Id: formula.C,v 1.1.1.1 1998/04/23 16:02:50 larsbj Exp $    
  41.  
  42. #if !defined(lint) && !defined(WITH_WARNINGS)
  43. static char vcid[] = "$Id: formula.C,v 1.1.1.1 1998/04/23 16:02:50 larsbj Exp $";
  44. #endif /* lint */
  45.  
  46. extern void UpdateInset(Inset* inset, bool mark_dirty = true);
  47. extern void LockedInsetStoreUndo(Undo::undo_kind);
  48. extern MiniBuffer *minibuffer;
  49. extern void ShowLockedInsetCursor(long, long, int, int);
  50. extern void HideLockedInsetCursor(long, long, int, int);
  51. extern void FitLockedInsetCursor(long, long, int, int);
  52. extern int LockInset(UpdatableInset*);
  53. extern int UnlockInset(UpdatableInset*);
  54.  
  55.  
  56. extern GC canvasGC, mathGC, mathLineGC, latexGC, cursorGC, mathFrameGC;
  57. extern char *mathed_label;
  58.  
  59. extern BufferView *current_view;
  60. extern BufferList bufferlist;
  61. extern char const *latex_special_chars;
  62.  
  63. short greek_kb_flag = 0;
  64.  
  65. LyXFont *Math_Fonts = NULL; // this is only used by Whichfont and mathed_init_fonts (Lgb)
  66.  
  67. static LyXFont::FONT_SIZE lfont_size = LyXFont::SIZE_NORMAL;
  68.  
  69. // local global 
  70. static int sel_x, sel_y;
  71. static bool sel_flag;
  72. MathedCursor* InsetFormula::mathcursor = NULL; 
  73.  
  74.  
  75. int MathedInset::df_asc;
  76. int MathedInset::df_des;
  77. int MathedInset::df_width;
  78.  
  79. // wrong name on this one should be called "IsAscii"
  80. inline bool IsAlpha(char c)
  81. {
  82.    return ('A' <= c  && c<='Z' || 'a' <= c  && c<='z');
  83. }
  84.  
  85. inline bool IsDigit(char c)
  86. {
  87.    return ('0' <= c && c <='9');
  88. }
  89.  
  90. inline bool IsMacro(short token, int id)
  91. {
  92.    return (token!=LM_TK_FRAC && token!=LM_TK_SQRT &&
  93.       !((token==LM_TK_SYM || token==LM_TC_BSYM) && id<255));
  94. }
  95.  
  96. void mathedValidate(LaTeXFeatures &features, MathParInset *par);
  97.  
  98. LyXFont WhichFont(short type, int size)
  99. {
  100.     LyXFont f;
  101.     
  102.       if (!Math_Fonts)
  103.     mathed_init_fonts();
  104.    
  105.    switch (type) {
  106.     case LM_TC_SYMB:         
  107.       f = Math_Fonts[2];
  108.       break;
  109.     case LM_TC_BSYM:         
  110.       f = Math_Fonts[2];
  111.       break;
  112.     case LM_TC_VAR:
  113.       f = Math_Fonts[0];
  114.       break;
  115.     case LM_TC_BF:
  116.       f = Math_Fonts[3];
  117.       break;
  118.     case LM_TC_CAL:
  119.       f = Math_Fonts[4];
  120.       break;
  121.     case LM_TC_TT:
  122.       f = Math_Fonts[5];
  123.       break;
  124.     case LM_TC_SPECIAL: //f = Math_Fonts[0]; break;
  125.     case LM_TC_TEXTRM:
  126.     case LM_TC_RM:    
  127.       f = Math_Fonts[6];
  128.       break;
  129.     default:
  130.       f = Math_Fonts[1];
  131.       break;   
  132.    }
  133.     
  134.     f.setSize(lfont_size);
  135.     
  136.     switch (size) {
  137.      case LM_ST_DISPLAY:     
  138.     if (type==LM_TC_BSYM) {
  139.         f.incSize();
  140.         f.incSize();
  141.     }
  142.     break;
  143.      case LM_ST_TEXT:
  144.     break;
  145.      case LM_ST_SCRIPT:
  146.     f.decSize();
  147.     break;
  148.      case LM_ST_SCRIPTSCRIPT:
  149.     f.decSize();
  150.     f.decSize();
  151.     break;
  152.      default:
  153.     fprintf(stderr, "Mathed Error: wrong font size: %d\n", size);
  154.     break;
  155.     }
  156.     
  157.     if (type!=LM_TC_TEXTRM) 
  158.       f.setColor(LyXFont::MATH);
  159.     return f;
  160. }
  161.  
  162.  
  163. void mathed_init_fonts() //removed 'static' because DEC cxx does not
  164.              //like it (JMarc) 
  165. {
  166.  
  167.     Math_Fonts = new LyXFont[8]; //DEC cxx cannot initialize all fonts
  168.                  //at once (JMarc) rc
  169.     for (int i=0 ; i<8 ; i++){ 
  170.         Math_Fonts[i] = LyXFont::ALL_SANE;
  171.     }
  172.     Math_Fonts[0].setShape(LyXFont::ITALIC_SHAPE);
  173.     
  174.     Math_Fonts[1].setFamily(LyXFont::SYMBOL_FAMILY);
  175.     
  176.     Math_Fonts[2].setFamily(LyXFont::SYMBOL_FAMILY);
  177.     Math_Fonts[2].setShape(LyXFont::ITALIC_SHAPE);
  178.  
  179.     Math_Fonts[3].setSeries(LyXFont::BOLD_SERIES);
  180.       
  181.     Math_Fonts[4].setFamily(LyXFont::SANS_FAMILY);
  182.     Math_Fonts[4].setShape(LyXFont::ITALIC_SHAPE);
  183.       
  184.     Math_Fonts[5].setFamily(LyXFont::TYPEWRITER_FAMILY);
  185.  
  186.     Math_Fonts[6].setFamily(LyXFont::ROMAN_FAMILY);
  187.     
  188.     LyXFont f = WhichFont(LM_TC_VAR, LM_ST_TEXT);
  189.     MathedInset::df_asc = f.maxAscent(); 
  190.     MathedInset::df_des = f.maxDescent();
  191.     MathedInset::df_width = f.width('I');    
  192. }
  193.  
  194.  
  195. void mathed_set_font(short type, int size)
  196. {
  197.     if (!canvasGC) {
  198.         cursorGC = getGC(gc_thin_on_off_line);
  199.         canvasGC = getGC(gc_lighted);
  200.         latexGC =  getGC(gc_latex);
  201.         mathLineGC = getGC(gc_math);
  202.         mathFrameGC = getGC(gc_math_frame);
  203.     }
  204.     LyXFont f = WhichFont(type, size); 
  205.     if (type==LM_TC_TEX) {
  206.     f.setLatex(LyXFont::ON);
  207.     latexGC = f.getGC();
  208.     } else
  209.       mathGC = f.getGC();
  210. }
  211.  
  212.  
  213. int mathed_string_width(short type, int size, byte const* s, int ls)
  214. {
  215.     LyXFont f = WhichFont(type, size);
  216.       
  217.     byte sx[80];
  218.     if (MathIsBinary(type)) {
  219.     byte *ps = &sx[0];
  220.     for (int i=0; i<ls; i++) {
  221.         *(ps++) = ' ';
  222.         *(ps++) = s[i];
  223.         *(ps++) = ' ';
  224.     }
  225.     *(ps++) = '\0';
  226.     ls = 3*ls;
  227.     s = &sx[0];
  228.     
  229.     }       
  230.     return f.textWidth((const char*)s, ls);;
  231. }
  232.  
  233. int mathed_char_width(short type, int size, byte c)
  234. {
  235.     int t= (MathIsBinary(type)) ? mathed_string_width(type, size, &c, 1):
  236.            WhichFont(type, size).width(c);
  237.     return t;
  238. }
  239.  
  240. int mathed_string_height(short type, int size, byte const * s, int ls, int& asc, int& des)
  241. {
  242.    LyXFont font = WhichFont(type, size);
  243.    asc = des = 0;
  244.    for (int i=0; i<ls; i++) {
  245.       if (font.descent(s[i]) > des)
  246.     des = font.descent(s[i]);
  247.       if (font.ascent(s[i]) > asc)
  248.     asc = font.ascent(s[i]);
  249.    }
  250.    return asc+des;
  251. }
  252.  
  253. int mathed_char_height(short type, int size, byte c, int& asc, int& des)
  254. {
  255.    LyXFont font = WhichFont(type, size);
  256.    asc = des = 0;
  257.    des = font.descent(c);
  258.    asc = font.ascent(c);
  259.    return asc+des;
  260. }
  261.  
  262.  
  263. // In a near future maybe we use a better fonts renderer
  264. void MathedInset::drawStr(short type, int size, int x, int y, byte* s, int ls)
  265. {
  266.     mathed_set_font(type, size);
  267.     byte sx[80];
  268.     if (MathIsBinary(type)) {
  269.     byte *ps = &sx[0];
  270.     for (int i=0; i<ls; i++) {
  271.         *(ps++) = ' ';
  272.         *(ps++) = s[i];
  273.         *(ps++) = ' ';
  274.     }
  275.     //    *ps = ' ';
  276.     ls = 3*ls;
  277.     s = &sx[0];
  278.     
  279.     }       
  280.     GC gc = (type==LM_TC_TEX) ? latexGC: mathGC;
  281.     XDrawString(fl_display, pm, gc, x, y, (char*)s, ls);
  282.     XFlush(fl_display);
  283. }
  284.  
  285.  
  286. InsetFormula::InsetFormula(bool display)
  287. {
  288.     par = new MathParInset; // this leaks
  289. //   mathcursor = NULL;
  290.    disp_flag = display;
  291.    //label = NULL;
  292.    if (disp_flag) {
  293.       par->SetType(LM_OT_PAR);
  294.       par->SetStyle(LM_ST_DISPLAY);
  295.    }
  296. }
  297.  
  298. InsetFormula::InsetFormula(MathParInset *p)
  299. {
  300.    par = (p->GetType()>=LM_OT_MPAR) ? 
  301.          new MathMatrixInset((MathMatrixInset*)p): 
  302.          new MathParInset(p);
  303. //   mathcursor = NULL;
  304.    
  305.    disp_flag = (par->GetType()>0);
  306.    //label = NULL;
  307. }
  308.  
  309. InsetFormula::~InsetFormula()
  310. {
  311.    delete par;
  312.    //if (label) delete label;
  313. }
  314.  
  315. Inset* InsetFormula::Clone()
  316. {
  317.     InsetFormula* f = new InsetFormula(par);
  318.     f->label = (!label.empty()) ? label.c_str(): 0;
  319.     return (Inset*)f;
  320. }
  321.  
  322. void InsetFormula::Write(FILE *file)
  323. {
  324.    fprintf(file, "Formula ");
  325.    Latex(file, 0);
  326. }
  327.  
  328. int InsetFormula::Latex(FILE *file, signed char fragile)
  329. {
  330.     int ret = 0;      
  331. //#warning Alejandro, the number of lines is not returned in this case
  332. // This problem will disapear at 0.13.
  333.     LString output;
  334.     InsetFormula::Latex(output, fragile);
  335.     fprintf(file, "%s", output.c_str());
  336.     return ret;
  337. }
  338.  
  339. int InsetFormula::Latex(LString &file, signed char fragile)
  340. {
  341.     int ret = 0;        
  342. //#warning Alejandro, the number of lines is not returned in this case
  343. // This problem will disapear at 0.13.
  344.     if (fragile < 0)
  345.         par->Write(file);
  346.     else
  347.         mathed_write(par, file, &ret, fragile, label.c_str());
  348.     return ret;
  349. }
  350.  
  351.  
  352. // Check if uses AMS macros 
  353. void InsetFormula::Validate(LaTeXFeatures &features) const
  354. {
  355.     // Validation only necesary if not using an AMS Style
  356.     if (!features.amsstyle)
  357.       mathedValidate(features, par);
  358. }
  359.  
  360.  
  361. void InsetFormula::Read(LyXLex &lex)
  362. {
  363.     FILE *file = lex.getFile();
  364.     
  365.     mathed_parser_file(file, lex.GetLineNo());   
  366.    
  367.    // Silly hack to read labels. 
  368.    mathed_label = NULL;
  369.    mathed_parse(0, NULL, &par);
  370.    par->Metrics();
  371.    disp_flag = (par->GetType()>0);
  372.    
  373.     // Update line number
  374.     lex.setLineNo(mathed_parser_lineno());
  375.     
  376.    if (mathed_label) {
  377.       label = mathed_label;
  378.       mathed_label = NULL;
  379.    }
  380.    
  381. #ifdef DEBUG
  382.    Write(stdout);
  383.    fflush(stdout);
  384. #endif
  385. }
  386.  
  387. int InsetFormula::Ascent(LyXFont const &) const
  388. {
  389.    return par->Ascent() + ((disp_flag) ? 8: 1);
  390. }
  391.  
  392. int InsetFormula::Descent(LyXFont const &) const
  393. {
  394.    return par->Descent() + ((disp_flag) ? 8: 1);
  395. }
  396.  
  397. int InsetFormula::Width(LyXFont const &f) const
  398. {
  399.     lfont_size = f.size();
  400.     par->Metrics();
  401.     return par->Width()+2;
  402. }
  403.  
  404. void InsetFormula::Draw(LyXFont f, LyXScreen &scr, int baseline, float &x)
  405. {
  406.     // This is Alejandros domain so I'll use this
  407.     unsigned long pm = scr.getForeground();
  408.     
  409.    lfont_size = f.size();
  410.    mathed_set_font(LM_TC_TEXTRM, LM_ST_TEXT); // otherwise a segfault could occur
  411.                                 // in some XDrawRectangles (i.e. matrix) (Matthias)   
  412.    if (mathcursor && mathcursor->GetPar()==par) { 
  413.        if (mathcursor->Selection()) {
  414.        int n;
  415.        XPoint * p = mathcursor->SelGetArea(n);
  416.        XFillPolygon(fl_display, pm, getGC(gc_selection), //LyXGetSelectionGC(),
  417.             p, n, Nonconvex, CoordModeOrigin);
  418.        }
  419.        mathcursor->Draw(pm, (int)x, baseline);
  420.    } else {
  421. //       par->Metrics();
  422.        par->setDrawable(pm);
  423.        par->Draw((int)x, baseline);
  424.    }
  425.    x += (float)Width(f);
  426.  
  427.    if (par->GetType()==LM_OT_PARN || par->GetType()==LM_OT_MPARN) {
  428.        char s[80];
  429.        LyXFont  font = WhichFont(LM_TC_BF, par->size);
  430.        font.setLatex(LyXFont::OFF);
  431.       
  432.        if (par->GetType()==LM_OT_PARN) {
  433.        if (!label.empty())
  434.          sprintf(s, "(%s)", label.c_str());
  435.        else
  436.          sprintf(s, "(#)");
  437.        font.drawString(s, pm, baseline, int(x+20));
  438.        } else 
  439.        if (par->GetType()==LM_OT_MPARN) {
  440.        MathMatrixInset *mt = (MathMatrixInset*)par;
  441.        //int i=0;
  442.        int y;
  443.        MathedRowSt const* crow = mt->getRowSt();
  444.        while (crow) {
  445.            y = baseline + crow->getBaseline();
  446.            if (crow->isNumbered()) {
  447.            if (crow->getLabel())
  448.              sprintf(s, "(%s)", crow->getLabel());
  449.            else
  450.              sprintf(s, "(#)");
  451.            font.drawString(s, pm, y, int(x+20));
  452.            }
  453.            crow = crow->getNext();
  454.        }
  455.        }
  456.    }
  457.    cursor_visible = false;
  458. }
  459.  
  460.  
  461. void InsetFormula::Edit(int x, int y)
  462. {
  463.    mathcursor = new MathedCursor(par);
  464.    LockInset(this);
  465.    par->Metrics();
  466.    UpdateInset(this, false);
  467.    x += par->xo; 
  468.    y += par->yo; 
  469.    mathcursor->SetPos(x, y);
  470.     sel_x = sel_y = 0;
  471.     sel_flag = false;
  472. }
  473.                        
  474. void InsetFormula::InsetUnlock()
  475. {
  476.    if (mathcursor) {
  477.        if (mathcursor->InMacroMode()) {
  478.        mathcursor->MacroModeClose();
  479.        UpdateLocal();
  480.        }                                         
  481.      delete mathcursor;
  482.    }
  483.    mathcursor = NULL;
  484.    UpdateInset(this, false);
  485. }
  486.  
  487. // Now a symbol can be inserted only if the inset is locked
  488. void InsetFormula::InsertSymbol(char const* s)
  489. { 
  490.    if (!s || !mathcursor) return;   
  491.    mathcursor->Interpret(s);
  492.    UpdateLocal();
  493. }
  494.    
  495. void InsetFormula::GetCursorPos(int& x, int& y)
  496. {
  497.     mathcursor->GetPos(x, y);
  498.     x -= par->xo; 
  499.     y -= par->yo;
  500. }
  501.  
  502. void InsetFormula::ToggleInsetCursor()
  503. {
  504.   if (!mathcursor)
  505.     return;
  506.  
  507.   int x, y, asc, desc;
  508.   mathcursor->GetPos(x, y);
  509. //  x -= par->xo; 
  510.   y -= par->yo; 
  511.     LyXFont font = WhichFont(LM_TC_TEXTRM, LM_ST_TEXT);
  512.   asc = font.maxAscent();
  513.   desc = font.maxDescent();
  514.   
  515.   if (cursor_visible)
  516.     HideLockedInsetCursor(x, y, asc, desc);
  517.   else
  518.     ShowLockedInsetCursor(x, y, asc, desc);
  519.   cursor_visible = !cursor_visible;
  520. }
  521.  
  522. void InsetFormula::ShowInsetCursor(){
  523.   if (!cursor_visible){
  524.     int x, y, asc, desc;
  525.     if (mathcursor){
  526.       mathcursor->GetPos(x, y);
  527.       //  x -= par->xo; 
  528.       y -= par->yo;
  529.     LyXFont font = WhichFont(LM_TC_TEXTRM, LM_ST_TEXT);
  530.     asc = font.maxAscent();
  531.     desc = font.maxDescent();
  532.       FitLockedInsetCursor(x, y, asc, desc);
  533.     }
  534.     ToggleInsetCursor();
  535.   }
  536. }
  537.  
  538. void InsetFormula::HideInsetCursor(){
  539.   if (cursor_visible)
  540.     ToggleInsetCursor();
  541. }
  542.  
  543. void InsetFormula::ToggleInsetSelection()
  544. {
  545.     if (!mathcursor)
  546.       return;
  547.     
  548. //    int x, y, w, h;
  549.     //int n;
  550.     //XPoint * p = 
  551.     //mathcursor->SelGetArea(n);
  552. //    XFillPolygon(fl_display, pm, LyXGetSelectionGC(), p, n, Nonconvex, CoordModeOrigin);
  553. //    x -= par->xo; 
  554. //    y -= par->yo;
  555.  
  556.     UpdateInset(this, false);
  557.       
  558. }
  559.  
  560. void InsetFormula::SetDisplay(bool dspf)
  561. {
  562.    if (dspf!=disp_flag) {
  563.       if (dspf) {
  564.      par->SetType(LM_OT_PAR);
  565.      par->SetStyle(LM_ST_DISPLAY);
  566.       } else {
  567.      if (par->GetType()>=LM_OT_MPAR) { 
  568.         MathParInset *p = new MathParInset(par);
  569.         delete par;
  570.         par = p;
  571.         if (mathcursor) 
  572.            mathcursor->SetPar(par); 
  573.      }
  574.      par->SetType(LM_OT_MIN);
  575.      par->SetStyle(LM_ST_TEXT);
  576.      if (!label.empty() && par->GetType()!=LM_OT_MPARN) {
  577.          label.erase();
  578.      }
  579.       }
  580.       disp_flag = dspf;
  581.    }   
  582. }
  583.    
  584.  
  585.  
  586. int InsetFormula::GetNumberOfLabels() const
  587. {
  588.    // This is dirty, I know. I'll clean it at 0.13
  589.    if (par->GetType()==LM_OT_MPARN) {
  590.        MathMatrixInset *mt = (MathMatrixInset*)par;
  591.        int nl=0;
  592.        MathedRowSt const* crow = mt->getRowSt();
  593.        while (crow) {
  594.        if (crow->getLabel()) nl++;
  595.        crow = crow->getNext();
  596.        }
  597.        return nl;
  598.    } else
  599.    if (!label.empty())
  600.        return 1;
  601.    else
  602.        return 0;
  603. }
  604.  
  605.  
  606. LString InsetFormula::getLabel(int il) const
  607. {
  608. //#warning This is dirty, I know. Ill clean it at 0.11
  609.     // Correction, the only way to clean this is with a new kernel: 0.13.
  610.     if (par->GetType()==LM_OT_MPARN) {
  611.        LString label;
  612.        MathMatrixInset *mt = (MathMatrixInset*)par;
  613.        int nl=0;
  614.        MathedRowSt const* crow = mt->getRowSt();
  615.        while (crow) {
  616.        if (crow->getLabel()) {
  617.            if (nl==il) {
  618.            label = crow->getLabel();
  619.            break;
  620.            }
  621.            nl++;
  622.        }
  623.        crow = crow->getNext();
  624.        }
  625.        return label;
  626.    }
  627.    return label;
  628. }
  629.  
  630. void InsetFormula::UpdateLocal()
  631. {
  632.    par->Metrics();  // To inform lyx kernel the exact size 
  633.                   // (there were problems with arrays).
  634.    UpdateInset(this);
  635. }
  636.    
  637.  
  638.  
  639. void InsetFormula::InsetButtonRelease(int x, int y, int /*button*/)
  640. {
  641.     HideInsetCursor();
  642.     x += par->xo;
  643.     y += par->yo;
  644.     mathcursor->SetPos(x, y);
  645.     ShowInsetCursor();
  646.     if (sel_flag) {
  647.     sel_flag = false; 
  648.     sel_x = sel_y = 0;
  649.     UpdateInset(this,false); 
  650.     }
  651. }
  652.  
  653. void InsetFormula::InsetButtonPress(int x, int y, int /*button*/)
  654. {
  655.     sel_flag = false;
  656.     sel_x = x;  sel_y = y; 
  657.     if (mathcursor->Selection()) {
  658.     mathcursor->SelClear();
  659.     UpdateInset(this, false); 
  660.     }
  661. }
  662.  
  663. void InsetFormula::InsetMotionNotify(int x, int y, int /*button*/)
  664. {
  665.     if (sel_x && sel_y && abs(x-sel_x)>4 && !sel_flag) {
  666.     sel_flag = true;
  667.     HideInsetCursor();
  668.     mathcursor->SetPos(sel_x + par->xo, sel_y + par->yo);
  669.     mathcursor->SelStart();
  670.     ShowInsetCursor(); 
  671.     mathcursor->GetPos(sel_x, sel_y);
  672.     } else
  673.       if (sel_flag) {
  674.       HideInsetCursor();
  675.       x += par->xo;
  676.       y += par->yo;
  677.       mathcursor->SetPos(x, y);
  678.       ShowInsetCursor();
  679.       mathcursor->GetPos(x, y);
  680.       if (sel_x!=x || sel_y!=y)
  681.         UpdateInset(this, false); 
  682.       sel_x = x;  sel_y = y;
  683.       }
  684. }
  685.  
  686. void InsetFormula::InsetKeyPress(XKeyEvent *)
  687. {
  688.    lyxerr.debug("Used InsetFormula::InsetKeyPress.", Error::MATHED);
  689. }
  690.  
  691. // Special Mathed functions
  692. bool InsetFormula::SetNumber(bool numbf)
  693. {
  694.    if (disp_flag) {
  695.       short type = par->GetType();
  696.       bool oldf = (type==LM_OT_PARN || type==LM_OT_MPARN);
  697.       if (numbf && !oldf) type++;
  698.       if (!numbf && oldf) type--;
  699.       par->SetType(type);
  700.       return oldf;
  701.    } else
  702.      return false;
  703. }
  704.  
  705. bool InsetFormula::LocalDispatch(int action, char const *arg)
  706. {
  707. //   extern char *dispatch_result;
  708.     MathedTextCodes varcode = LM_TC_MIN;       
  709.    bool was_macro = mathcursor->InMacroMode();
  710.    bool sel=false;
  711.    bool space_on = false;
  712.    bool was_selection = mathcursor->Selection();
  713.    bool result = true;
  714.    static MathSpaceInset* sp=NULL;
  715.  
  716.    HideInsetCursor();
  717.  
  718.     if (mathcursor->getLastCode()==LM_TC_TEX) { 
  719.     varcode = LM_TC_TEX;
  720.     }
  721.    switch (action) {
  722.        
  723.     // --- Cursor Movements ---------------------------------------------
  724.     case LFUN_RIGHTSEL: sel = true;
  725.     case LFUN_RIGHT:
  726.       {
  727.      result = mathcursor->Right(sel);
  728.      break;
  729.       }
  730.     case LFUN_LEFTSEL: sel = true;     
  731.     case LFUN_LEFT:
  732.       {
  733.      result = mathcursor->Left(sel);
  734.      break;
  735.       }
  736.     case LFUN_UPSEL: sel = true;  
  737.     case LFUN_UP:
  738.       result = mathcursor->Up(sel);
  739.       break;
  740.        
  741.     case LFUN_DOWNSEL: sel = true;  
  742.     case LFUN_DOWN:
  743.       result = mathcursor->Down(sel);
  744.       break;
  745.     case LFUN_HOME:
  746.       mathcursor->Home();
  747.       break;
  748.     case LFUN_END:
  749.       mathcursor->End();
  750.       break;
  751.     case LFUN_DELETE_LINE_FORWARD:
  752.         //LockedInsetStoreUndo(Undo::INSERT);
  753.         LockedInsetStoreUndo(Undo::DELETE);
  754.       mathcursor->DelLine();
  755.       UpdateLocal();
  756.       break;
  757.     case LFUN_BREAKLINE:
  758.       LockedInsetStoreUndo(Undo::INSERT);
  759.       mathcursor->Insert(' ', LM_TC_CR);
  760.       par = mathcursor->GetPar();
  761.       UpdateLocal();     
  762.       break;
  763.     case LFUN_TAB:
  764.       LockedInsetStoreUndo(Undo::INSERT);
  765.       mathcursor->Insert(0, LM_TC_TAB);
  766.       //UpdateInset(this);
  767.       break;     
  768.     case LFUN_TABINSERT:
  769.       LockedInsetStoreUndo(Undo::INSERT);
  770.       mathcursor->Insert('T', LM_TC_TAB);
  771.       UpdateLocal();
  772.       break;     
  773.     case LFUN_BACKSPACE:
  774.       if (!mathcursor->Left()) break;
  775.       
  776.     case LFUN_DELETE:
  777.         //LockedInsetStoreUndo(Undo::INSERT);
  778.         LockedInsetStoreUndo(Undo::DELETE);
  779.       mathcursor->Delete();       
  780.       UpdateInset(this);
  781.       break;    
  782. //    case LFUN_GETXY:
  783. //      sprintf(dispatch_buffer, "%d %d",);
  784. //      dispatch_result = dispatch_buffer;
  785. //      break;
  786.     case LFUN_SETXY:
  787.       {
  788.      int x, y, x1, y1;
  789.          sscanf(arg, "%d %d", &x, &y);
  790.      par->GetXY(x1, y1);
  791.      mathcursor->SetPos(x1+x, y1+y);
  792.       }
  793.       break;
  794.  
  795.       /* cursor selection ---------------------------- */
  796.  
  797.     case LFUN_PASTE:
  798.         LockedInsetStoreUndo(Undo::INSERT);
  799.         mathcursor->SelPaste(); UpdateLocal(); break;
  800.     case LFUN_CUT:
  801.         LockedInsetStoreUndo(Undo::DELETE);
  802.         mathcursor->SelCut(); UpdateLocal(); break;
  803.     case LFUN_COPY: mathcursor->SelCopy(); break;      
  804.     case LFUN_HOMESEL:
  805.     case LFUN_ENDSEL:
  806.     case LFUN_WORDRIGHTSEL:
  807.     case LFUN_WORDLEFTSEL:
  808.       break;
  809.       
  810.     // --- accented characters ------------------------------
  811.  
  812.     case LFUN_UMLAUT: mathcursor->setAccent(LM_ddot); break;
  813.     case LFUN_CIRCUMFLEX: mathcursor->setAccent(LM_hat); break;
  814.     case LFUN_GRAVE: mathcursor->setAccent(LM_grave); break;
  815.     case LFUN_ACUTE: mathcursor->setAccent(LM_acute); break;
  816.     case LFUN_TILDE: mathcursor->setAccent(LM_tilde); break;
  817.     case LFUN_MACRON: mathcursor->setAccent(LM_bar); break;
  818.     case LFUN_DOT: mathcursor->setAccent(LM_dot); break;
  819.     case LFUN_CARON: mathcursor->setAccent(LM_check); break;
  820.     case LFUN_BREVE: mathcursor->setAccent(LM_breve); break;
  821.     case LFUN_VECTOR: mathcursor->setAccent(LM_vec); break; 
  822.       
  823.     // Greek mode     
  824.     case LFUN_GREEK:
  825.     {
  826.        if (!greek_kb_flag) {
  827.       greek_kb_flag = 1;
  828.       minibuffer->Set(_("Math greek mode on"));
  829.        } else
  830.      greek_kb_flag = 0;
  831.        break;
  832.     }  
  833.       
  834.     // Greek keyboard      
  835.     case LFUN_GREEK_TOGGLE:
  836.     {
  837.        greek_kb_flag = (greek_kb_flag) ? 0: 2;
  838.        if (greek_kb_flag)
  839.      minibuffer->Set(_("Math greek keyboard on"));
  840.        else
  841.      minibuffer->Set(_("Math greek keyboard off"));
  842.        break;
  843.     }  
  844.    
  845.       //  Math fonts 
  846.     case LFUN_BOLD:      mathcursor->setLastCode(LM_TC_BF); break;
  847.     case LFUN_SANS:  mathcursor->setLastCode( LM_TC_SF); break;
  848.     case LFUN_EMPH:  mathcursor->setLastCode(LM_TC_CAL); break;
  849.     case LFUN_ROMAN: mathcursor->setLastCode(LM_TC_RM); break;
  850.     case LFUN_CODE: mathcursor->setLastCode(LM_TC_TT); break;   
  851.     case LFUN_DEFAULT:  varcode = LM_TC_VAR; break;
  852.     case LFUN_TEX: 
  853.     {
  854. //       varcode = LM_TC_TEX;
  855.     mathcursor->setLastCode(LM_TC_TEX);
  856.        minibuffer->Set(_("TeX mode")); 
  857.        break;
  858.     }
  859.  
  860.     case LFUN_MATH_NUMBER:
  861.     {
  862.       LockedInsetStoreUndo(Undo::INSERT);
  863.        if (disp_flag) {
  864.       short type = par->GetType();
  865.       bool oldf = (type==LM_OT_PARN || type==LM_OT_MPARN);
  866.       if (oldf) {
  867.          type--;
  868.          if (!label.empty()) {
  869.              label.erase();
  870.          }
  871.          minibuffer->Set(_("No number"));  
  872.       } else {
  873.          type++;
  874.              minibuffer->Set(_("Number"));
  875.       }
  876.       par->SetType(type);
  877.       UpdateLocal();
  878.        }
  879.        break;
  880.     }
  881.     
  882.     case LFUN_MATH_NONUMBER:
  883.     { 
  884.     if (par->GetType()==LM_OT_MPARN) {
  885. //       MathMatrixInset *mt = (MathMatrixInset*)par;
  886.        //BUG 
  887. //       mt->SetNumbered(!mt->IsNumbered());
  888.         
  889.         mathcursor->setNumbered();
  890.        UpdateLocal();
  891.     }
  892.     break;
  893.     }
  894.        
  895.     case LFUN_MATH_LIMITS:
  896.     {
  897.       LockedInsetStoreUndo(Undo::INSERT);
  898.        if (mathcursor->Limits())
  899.      UpdateLocal();
  900.     }
  901.  
  902.     case LFUN_MATH_SIZE:
  903.        if (arg) {
  904.        latexkeys *l = in_word_set (arg, strlen(arg));
  905.        int sz = (l) ? l->id: -1;
  906.        mathcursor->SetSize(sz);
  907.        UpdateLocal();
  908.        break;
  909.        }
  910.        
  911.     case LFUN_INSERT_MATH:
  912.     {
  913.     LockedInsetStoreUndo(Undo::INSERT);
  914.     InsertSymbol(arg);
  915.     break;
  916.     }
  917.     
  918.     case LFUN_INSERT_MATRIX:
  919.     { 
  920.       LockedInsetStoreUndo(Undo::INSERT);
  921.        int k, m, n;
  922.        char s[80];
  923.        k = sscanf(arg, "%d %d %s", &m, &n, s);
  924.     
  925.        if (k<1) {
  926.        m = n = 1;
  927.        } else if (k==1) {
  928.        n = 1;
  929.        }
  930.     
  931.        MathMatrixInset *p = new MathMatrixInset(m, n);      
  932.        if (mathcursor && p) {
  933.       if (k>2 && (int)strlen(s)>m)
  934.         p->SetAlign(s[0], &s[1]);
  935.       mathcursor->Insert(p, LM_TC_ACTIVE_INSET);
  936.       UpdateLocal();     
  937.        }
  938.        break;
  939.     }
  940.       
  941.     case LFUN_MATH_DELIM:
  942.     {  
  943.       LockedInsetStoreUndo(Undo::INSERT);
  944.        char lf[40], rg[40];
  945.        int ilf = '(', irg = '.';
  946.        latexkeys *l;
  947.        LString vdelim("(){}[]./|");
  948.     
  949.        if (!arg) break;
  950.        int n = sscanf(arg, "%s %s", lf, rg);
  951.        if (n>0) {
  952.        if (IsDigit(lf[0])) 
  953.          ilf = atoi(lf);
  954.        else 
  955.          if (lf[1]) {
  956.          l = in_word_set(lf, strlen(lf));
  957.          ilf = l->id;
  958.          } else
  959.          if (vdelim.charPos(lf[0])>=0)
  960.            ilf = lf[0];
  961.        
  962.        if (n>1) {
  963.            if (IsDigit(rg[0]))
  964.          irg = atoi(rg);
  965.            else 
  966.          if (rg[1]) {
  967.              l = in_word_set(rg, strlen(rg));
  968.              irg = l->id;
  969.          } else
  970.          if (vdelim.charPos(rg[0])>=0)
  971.            irg = rg[0];
  972.        }
  973.        }
  974.        
  975.        MathDelimInset* p = new MathDelimInset(ilf, irg);
  976.        mathcursor->Insert(p, LM_TC_ACTIVE_INSET);
  977.        UpdateLocal();                             
  978.        break;
  979.     }
  980.  
  981.     case LFUN_PROTECTEDSPACE:
  982.     {
  983.       LockedInsetStoreUndo(Undo::INSERT);
  984.        sp = new MathSpaceInset(1); 
  985.        mathcursor->Insert(sp);
  986.        space_on = true;
  987.        UpdateLocal();
  988.        break;
  989.     }
  990.       
  991.     case LFUN_INSERT_LABEL:
  992.     {
  993.       LockedInsetStoreUndo(Undo::INSERT);
  994.        if (par->GetType()<LM_OT_PAR) break;
  995.        LString lb = (arg) ? LString(arg):
  996.           LString(fl_show_input(_("Enter new label to insert:"),""));
  997.        if (!lb.empty() && lb[0]> ' ') {
  998.       SetNumber(true);
  999.       if (par->GetType()==LM_OT_MPARN) {
  1000.           mathcursor->setLabel(lb.c_str());
  1001. //          MathMatrixInset *mt = (MathMatrixInset*)par;
  1002. //          mt->SetLabel(lb);
  1003.       } else {
  1004.           //if (label.notEmpty()) delete label;
  1005.           label = lb;
  1006.       }
  1007.       UpdateLocal();
  1008.        } else
  1009.            label.erase();
  1010.            //label = NULL;
  1011.        break;
  1012.     }
  1013.     
  1014.     case LFUN_MATH_DISPLAY:
  1015.         //LockedInsetStoreUndo(Undo::INSERT);
  1016.         LockedInsetStoreUndo(Undo::EDIT);
  1017.       SetDisplay(!disp_flag);
  1018.       UpdateLocal();
  1019.       break;
  1020.       
  1021.     // Invalid actions under math mode
  1022.     case LFUN_MATH_MODE:  
  1023.     {
  1024.     if (mathcursor->getLastCode()!=LM_TC_TEXTRM) {
  1025.         minibuffer->Set(_("math text mode"));
  1026.         varcode = LM_TC_TEXTRM;
  1027.     } else {
  1028.         varcode = LM_TC_VAR;
  1029.     }
  1030.     mathcursor->setLastCode(varcode);
  1031.     break; 
  1032.     }
  1033.     case LFUN_UNDO:
  1034.       minibuffer->Set(_("Invalid action in math mode!"));
  1035.       break;
  1036.  
  1037.     //------- dummy actions
  1038.     case LFUN_EXEC_COMMAND:
  1039.        minibuffer->ExecCommand(); 
  1040.        break;
  1041.        
  1042.     default:
  1043.       if ((action==-1  || action==LFUN_SELFINSERT) && arg)  {
  1044.      char c = arg[0];
  1045.      LockedInsetStoreUndo(Undo::INSERT);
  1046.      
  1047.      if (c==' ' && mathcursor->getAccent()==LM_hat) {
  1048.          c = '^';
  1049.          mathcursor->setAccent(0);
  1050.      }
  1051.      if (c==0) {      // Dead key, do nothing 
  1052.          //fprintf(stderr, "deadkey");
  1053.          break;
  1054.      } 
  1055.      if ('A' <= c  && c<='Z' || 'a' <= c  && c<='z') {
  1056.         if (mathcursor->getLastCode()==LM_TC_TEX) {          
  1057.            mathcursor->MacroModeOpen();
  1058.            mathcursor->clearLastCode();
  1059.            varcode = LM_TC_MIN;
  1060.         } else        
  1061.         if (!varcode) {        
  1062.         short f = (mathcursor->getLastCode()) ? 
  1063.                   mathcursor->getLastCode():
  1064.                   (MathedTextCodes)mathcursor->GetFCode();
  1065.            varcode =  MathIsAlphaFont(f) ?  (MathedTextCodes)f:LM_TC_VAR;
  1066.         }
  1067.  
  1068. //         fprintf(stderr, "Varcode %d ", varcode);
  1069.         mathcursor->Insert(c, (greek_kb_flag) ? LM_TC_SYMB: varcode);
  1070.         varcode = LM_TC_MIN;
  1071.         if (greek_kb_flag<2) greek_kb_flag = 0;
  1072.      } else 
  1073.        if (strchr("!,:;{}", c) && (varcode==LM_TC_TEX||was_macro)) {
  1074.            mathcursor->Insert(c, LM_TC_TEX);
  1075.            if (c=='{') {
  1076.            mathcursor->Insert('}', LM_TC_TEX);
  1077.            mathcursor->Left();
  1078.            }
  1079.            mathcursor->clearLastCode();
  1080. //           varcode = LM_TC_MIN;
  1081.        } else
  1082.        if (c=='_' && varcode==LM_TC_TEX) {
  1083.            mathcursor->Insert(c, LM_TC_SPECIAL);
  1084.            mathcursor->clearLastCode();
  1085. //           varcode = LM_TC_MIN;
  1086.        } else
  1087.        if (('0'<=c && c<='9') || strchr(";:!|[]().,?", c)) 
  1088.           mathcursor->Insert(c, LM_TC_CONST);
  1089.      else
  1090.        if (strchr("+/-*<>=", c))
  1091.           mathcursor->Insert(c, LM_TC_BOP);
  1092.      else
  1093.        if (strchr(latex_special_chars, c) && c!='_')
  1094.           mathcursor->Insert(c, LM_TC_SPECIAL);
  1095.      else
  1096.        if (c=='_' || c=='^') {
  1097.            char s[2];
  1098.            s[0] = c;
  1099.            s[1] = 0;
  1100.           mathcursor->Interpret (s);
  1101.        } else
  1102.        if (c==' ') {        
  1103.            if (!varcode) {    
  1104.            short f = (mathcursor->getLastCode()) ? 
  1105.                       mathcursor->getLastCode():
  1106.                       (MathedTextCodes)mathcursor->GetFCode();
  1107.            varcode = MathIsAlphaFont(f) ? (MathedTextCodes)f:LM_TC_VAR;
  1108.            }
  1109.           if (varcode==LM_TC_TEXTRM) {
  1110.           mathcursor->Insert(c, LM_TC_TEXTRM);
  1111.           } else
  1112.           if (was_macro)
  1113.         mathcursor->MacroModeClose();
  1114.           else 
  1115.           if (sp) {
  1116.          int isp = (sp->GetSpace()<5) ? sp->GetSpace()+1: 0;
  1117.          sp->SetSpace(isp);
  1118.          space_on = true;
  1119.           } else {
  1120.           if (!mathcursor->Pop() && mathcursor->IsEnd()) 
  1121.             result = false;
  1122.           }
  1123.        } else
  1124.        if (c=='\'') {
  1125.           mathcursor->Insert (c, LM_TC_VAR);
  1126.        } else
  1127.        if (c=='\\') {
  1128.           if (was_macro)
  1129.         mathcursor->MacroModeClose();
  1130.           minibuffer->Set(_("TeX mode")); 
  1131.            mathcursor->setLastCode(LM_TC_TEX);
  1132.        } 
  1133.      UpdateLocal();
  1134.       } else {
  1135.     // fprintf(stderr, "Closed by action %d\n", action);
  1136.     result =  false;
  1137.       }
  1138.    }
  1139.    if (was_macro!=mathcursor->InMacroMode()&&action>=0&&action!=LFUN_BACKSPACE)
  1140.      UpdateLocal();
  1141.    if (sp && !space_on) sp = NULL;
  1142.    if (mathcursor->Selection() || was_selection)
  1143.        ToggleInsetSelection();
  1144.     
  1145.    if (result)
  1146.       ShowInsetCursor();
  1147.    else
  1148.       UnlockInset(this);
  1149.     
  1150.    return result;
  1151. }
  1152.  
  1153.  
  1154. void
  1155. MathFuncInset::Draw(int x, int y)
  1156. { 
  1157.     if (name && name[0]>' ') {
  1158.         LyXFont  font = WhichFont(LM_TC_TEXTRM, size);
  1159.         font.setLatex(LyXFont::ON);
  1160.             x += (font.textWidth("I", 1)+3)/4;
  1161.         font.drawString(name, pm, y, x);
  1162.     }
  1163. }
  1164.  
  1165.  
  1166. void MathFuncInset::Metrics() 
  1167. {
  1168.     ln = (name) ? strlen(name): 0;
  1169.     LyXFont  font = WhichFont(LM_TC_TEXTRM, size);
  1170.     font.setLatex(LyXFont::ON);
  1171.     width = font.textWidth(name, ln) + font.textWidth("I", 1)/2;
  1172.     mathed_string_height(LM_TC_TEXTRM, size, (byte const *) name,
  1173.                  strlen(name), ascent, descent);
  1174. }
  1175.  
  1176.  
  1177. void mathedValidate(LaTeXFeatures &features, MathParInset *par)
  1178. {
  1179.     MathedIter it(par->GetData());
  1180.     
  1181.     while (it.OK() && !(features.binom && features.boldsymbol)) {
  1182.     if (it.IsInset()) {
  1183.         if(it.IsActive()) {
  1184.         MathParInset *p = it.GetActiveInset();
  1185.         if (!features.binom && p->GetType()==LM_OT_MACRO && 
  1186.             strcmp(p->GetName(), "binom")==0) {
  1187.             features.binom = true;
  1188.         } else {
  1189.             for (int i=0; i<=p->getMaxArgumentIdx(); i++) {
  1190.             p->setArgumentIdx(i);
  1191.             mathedValidate(features, p);
  1192.             }
  1193.         }
  1194.         } else {
  1195.         MathedInset* p = it.GetInset();
  1196.         if (!features.boldsymbol && p->GetName() &&
  1197.             strcmp(p->GetName(), "boldsymbol")==0) {
  1198.             features.boldsymbol = true;
  1199.         }
  1200.         }        
  1201.     }
  1202.     it.Next();
  1203.     }
  1204. }
  1205.