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 / math_cursor.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  21KB  |  942 lines
  1. /*
  2.  *  File:        math_cursor.C
  3.  *  Purpose:     Interaction for mathed
  4.  *  Author:      Alejandro Aguilar Sierra <asierra@servidor.unam.mx> 
  5.  *  Created:     January 1996
  6.  *  Description: Math interaction for a WYSIWYG math editor.
  7.  *
  8.  *  Dependencies: Xlib, XForms
  9.  *
  10.  *  Copyright: (c) 1996, Alejandro Aguilar Sierra
  11.  *
  12.  *   Version: 0.8beta, Mathed & Lyx project.
  13.  *
  14.  *   You are free to use and modify this code under the terms of
  15.  *   the GNU General Public Licence version 2 or later.
  16.  */
  17.  
  18. #ifdef __GNUG__
  19. #pragma implementation
  20. #endif
  21.  
  22. #include <config.h>
  23. #include FORMS_H_LOCATION
  24. #include "math_inset.h"
  25. #include "math_parser.h"
  26. #include "math_cursor.h"
  27. #include "math_macro.h"
  28. #include "error.h"
  29.  
  30. extern void mathed_set_font(short type, int style);
  31.  
  32. extern GC canvasGC, mathGC, latexGC, cursorGC, mathFrameGC;
  33.  
  34. static LyxArrayBase *selarray=0;
  35.  
  36. inline bool IsAlpha(char c)
  37. {
  38.    return ('A' <= c  && c<='Z' || 'a' <= c  && c<='z');
  39. }
  40.  
  41. // This was very smaller, I'll change it later 
  42. inline bool IsMacro(short token, int id)
  43. {
  44.    return (token!=LM_TK_STACK && token!=LM_TK_FRAC && token!=LM_TK_SQRT && token!=LM_TK_WIDE &&
  45.        token!=LM_TK_SPACE && token!=LM_TK_DOTS &&  token!=LM_TK_FUNCLIM &&
  46.        token!=LM_TK_BIGSYM && token!=LM_TK_ACCENT && 
  47.        !(token==LM_TK_SYM && id<255));
  48. }
  49.  
  50. // Yes, mathed isn't using LString yet.
  51. inline char *strnew(char const* s)
  52. {
  53.     char *s1 = new char[strlen(s)+1];
  54.     strcpy(s1, s);
  55.     return s1;
  56. }
  57.  
  58.  
  59.  
  60. #define MAX_STACK_ITEMS 32
  61.  
  62. struct MathStackXIter {
  63.     
  64.     int i, imax;
  65.     MathedXIter *item;
  66.     
  67.     MathStackXIter(int n=MAX_STACK_ITEMS): imax(n) {
  68.     item = new MathedXIter[imax];
  69.     i = 0;
  70.     }
  71.     
  72.     MathStackXIter(MathStackXIter &stk);
  73.     
  74.     ~MathStackXIter() {
  75.     delete[] item;
  76.     }
  77.    
  78.     void push(MathedXIter** a) {
  79.     *a = &item[i++];
  80.     }
  81.       
  82.     MathedXIter* pop() {
  83.     i--;
  84.     return &item[i-1];
  85.     }
  86.       
  87.     MathedXIter* Item(int idx) {
  88.        return (idx+1 <= i) ? &item[i-idx-1]: (MathedXIter*)NULL;
  89.     }
  90.  
  91.     void Reset() {
  92.     i = 0;
  93.     }
  94.    
  95.     int Full() {
  96.     return (i>=MAX_STACK_ITEMS);
  97.     }
  98.    
  99.     int Empty() {
  100.     return (i<=1);
  101.     }
  102.  
  103.     int Level() { return i; } 
  104.     
  105. } mathstk, *selstk=0;
  106.  
  107.  
  108. MathStackXIter::MathStackXIter(MathStackXIter &stk) {
  109.     imax = stk.imax;
  110.     item = new MathedXIter[imax];
  111.     i = stk.i;
  112.     for (int k=0; k<i; k++) {
  113.         item[k].SetData(stk.item[k].getPar());
  114.         item[k].GoBegin();
  115.         item[k].goPosAbs(stk.item[k].getPos());
  116.     }
  117. }
  118.  
  119.  
  120. /***----------------  Mathed Cursor  ---------------------------***/
  121.   
  122. MathedCursor::MathedCursor(MathParInset *p) // : par(p)
  123. {
  124.     accent = 0;
  125.     anchor = 0;
  126.     lastcode = LM_TC_MIN;
  127.     SetPar(p);
  128. //    selarray = NULL;     
  129.     if (!MathMacroTable::built)
  130.     MathMacroTable::mathMTable.builtinMacros();
  131. }
  132.  
  133.  
  134. void MathedCursor::SetPar(MathParInset *p)
  135. {
  136.    win = 0;
  137.    is_visible = False;
  138.    macro_mode = false;
  139.    selection = false; // not SelClear() ?
  140.    mathstk.Reset();
  141.    mathstk.push(&cursor);
  142.    par = p;
  143.    cursor->SetData(par);
  144. }
  145.  
  146. void MathedCursor::Draw(long unsigned pm, int x, int y)
  147. {
  148. //    fprintf(stderr, "Cursor[%d %d] ", x, y);
  149.     win = pm;    // win = (mathedCanvas) ? mathedCanvas: pm;
  150.     par->Metrics();
  151.     int w = par->Width()+2, a = par->Ascent()+1, h = par->Height()+1;
  152.     if (par->GetType()>LM_OT_PAR) { a += 4;  h += 8; }
  153.     
  154.    if (!canvasGC) mathed_set_font(LM_TC_VAR, 1);
  155.     //   XFillRectangle(fl_display,pm, canvasGC, x, y-a, w, h);
  156.     XDrawRectangle(fl_display,pm, mathFrameGC, x-1, y-a, w, h);
  157.     XFlush(fl_display);
  158.     MathParInset::pm = pm;
  159.     par->Draw(x, y);
  160.     cursor->Adjust();
  161. }
  162.  
  163.  
  164. void MathedCursor::Redraw()
  165. {  
  166.    lyxerr.debug("Mathed: Redrawing!", Error::MATHED);
  167.    par->Metrics();
  168.    int w = par->Width(), h = par->Height();
  169.    int x, y;
  170.    par->GetXY(x, y);
  171.    mathed_set_font(LM_TC_VAR, 1);
  172.    XFillRectangle(fl_display, win,canvasGC,x, y-par->Ascent(), w, h);
  173.    XFlush(fl_display);
  174.     MathParInset::pm = win;
  175.    par->Draw(x, y);
  176. }
  177.  
  178. bool MathedCursor::Left(bool sel)
  179. {
  180.    if (macro_mode) {
  181.       MacroModeBack();
  182.       return true;
  183.    }
  184.     clearLastCode();
  185.    if (sel && !selection) SelStart();
  186.    if (!sel && selection) SelClear();
  187.    bool result = cursor->Prev();
  188.    if (!result && !mathstk.Empty()) {
  189.       cursor = mathstk.pop();
  190.       cursor->Adjust();
  191.       result = true;
  192.       if (selection) SelClear();
  193.    } else  
  194.      if (result && cursor->IsActive()) {
  195.     if (cursor->IsScript()) {
  196.        cursor->Prev();
  197.        if (!cursor->IsScript())
  198.          cursor->Next();
  199.        cursor->Adjust(); 
  200.        return true;
  201.     }
  202.     if (!selection) {
  203.         MathParInset *p = cursor->GetActiveInset();
  204.         if (!p)
  205.           return result;
  206.         
  207.         p->setArgumentIdx(p->getMaxArgumentIdx());
  208.         mathstk.push(&cursor);
  209.         cursor->SetData(p);
  210.         cursor->GoLast();
  211.     }
  212.      } 
  213.    return result;  
  214. }
  215.  
  216. // Leave the inset
  217. bool MathedCursor::Pop()
  218. {
  219.    if (!mathstk.Empty()) {
  220.       cursor = mathstk.pop();
  221.       cursor->Next(); 
  222.       return true;
  223.    }
  224.    return false;
  225. }
  226.  
  227. // Go to the inset 
  228. bool MathedCursor::Push()
  229. { 
  230.    if (cursor->IsActive()) {
  231.       MathParInset *p = cursor->GetActiveInset();
  232.        if (!p) return false;
  233.       mathstk.push(&cursor);
  234.       cursor->SetData(p);
  235.       return true;
  236.    }
  237.    return false;
  238. }  
  239.  
  240. bool MathedCursor::Right(bool sel)
  241. {  
  242.    if (macro_mode) {
  243.       MacroModeClose();
  244.       return true;
  245.    } 
  246.     clearLastCode();
  247.    if (sel && !selection) SelStart();
  248.    if (!sel && selection) SelClear();
  249.    bool result = false;
  250.  
  251.    if (cursor->IsActive()) {
  252.       if (cursor->IsScript()) {
  253.      cursor->Next();
  254.      // A script may be followed by another script
  255.      if (cursor->IsScript()) 
  256.        cursor->Next();
  257.      return true;
  258.       }
  259.       if (!selection) { 
  260.       MathParInset *p = cursor->GetActiveInset();
  261.       if (!p) {
  262.           fprintf(stderr, "Math error: Inset expected.\n");
  263.           return cursor->Next();
  264.       }
  265.       p->setArgumentIdx(0);
  266.       mathstk.push(&cursor);
  267.       cursor->SetData(p);
  268.       result = true;
  269.       } else
  270.      result = cursor->Next();
  271.    } else {
  272.        if (cursor->GetChar()!=LM_TC_CR)
  273.      result = cursor->Next();
  274.      if (!result && !mathstk.Empty()) {
  275.     cursor = mathstk.pop();
  276.     cursor->Next();
  277.      cursor->Adjust();
  278.     result = true;
  279.     if (selection) SelClear();
  280.      }
  281.    }
  282.    return result;
  283. }
  284.  
  285.  
  286. void MathedCursor::SetPos(int x, int y)
  287. {
  288.     int xp = 0;
  289.     
  290.     if (macro_mode) MacroModeClose();
  291.     lastcode = LM_TC_MIN;
  292.     mathstk.Reset();
  293.     mathstk.push(&cursor);
  294.     cursor->SetData(par);
  295.     cursor->fitCoord(x, y);
  296.     while (cursor->GetX()<x && cursor->OK()) {
  297.     if (cursor->IsActive()) {
  298.         MathParInset *p = cursor->GetActiveInset();
  299.         if (p->Inside(x, y)) {
  300.         p->SetFocus(x, y);
  301.         mathstk.push(&cursor);
  302.         cursor->SetData(p);
  303.         cursor->fitCoord(x, y);
  304.         continue;
  305.         }
  306.     }
  307.     xp = cursor->GetX();
  308.     cursor->ipush();
  309.     if (!cursor->Next() && !Pop()) 
  310.       break;
  311.     }
  312.     if (x-xp < cursor->GetX()-x) cursor->ipop();
  313.     cursor->Adjust();
  314. }
  315.    
  316.  
  317. void MathedCursor::Home()
  318. {
  319.    if (macro_mode) MacroModeClose();
  320.     clearLastCode();
  321.    mathstk.Reset();
  322.    mathstk.push(&cursor);
  323.    cursor->GoBegin();
  324. }
  325.  
  326. void MathedCursor::End()
  327. {
  328.    if (macro_mode) MacroModeClose();
  329.     clearLastCode();
  330.    mathstk.Reset();
  331.    mathstk.push(&cursor);
  332.    cursor->GoLast();
  333. }
  334.  
  335. void MathedCursor::Insert(byte c, MathedTextCodes t)
  336. {  
  337.    if (selection) SelDel();
  338.    
  339.    if (t==LM_TC_MIN)
  340.       t = lastcode;
  341.     
  342.    if (t==LM_TC_CR) {
  343.       MathParInset *p= cursor->p;
  344.       if (p==par && p->GetType()<LM_OT_MPAR && p->GetType()>LM_OT_MIN) {
  345.      MathMatrixInset* mt = new MathMatrixInset(3, 0);
  346.      mt->SetAlign(' ', "rcl");
  347.      mt->SetStyle(LM_ST_DISPLAY);
  348.      mt->SetType((p->GetType()==LM_OT_PARN) ? LM_OT_MPARN: LM_OT_MPAR);
  349.      mt->SetData(p->GetData());
  350.      p->SetData(0);//BUG duda
  351.      delete p;
  352.      par = mt;
  353.      p = mt;
  354.      p->Metrics();
  355.      int pos = cursor->getPos();
  356.      cursor->SetData(par);
  357.      cursor->goPosAbs(pos);
  358.       }      
  359.       if (p &&  p->Permit(LMPF_ALLOW_CR)) {
  360.       cursor->addRow();
  361.       }
  362.    } else
  363.    if (t==LM_TC_TAB) {
  364.       MathParInset *p = cursor->p;
  365.       if (p &&  p->Permit(LMPF_ALLOW_TAB)) {
  366.       if (c) {
  367.           cursor->Insert(c, t);
  368.           cursor->checkTabs();
  369.       } else
  370.         cursor->goNextColumn();
  371.       } else // Navigate between arguments
  372.      if (p && p->GetType()==LM_OT_MACRO) {
  373.          if (p->getArgumentIdx() < p->getMaxArgumentIdx()) {
  374.          p->setArgumentIdx(p->getArgumentIdx()+1);
  375.          cursor->SetData(p);
  376.          return;
  377.          }
  378.  
  379.      }
  380.        
  381.    } else {
  382.        if (macro_mode) {
  383.        if (MathIsAlphaFont(t) || t==LM_TC_MIN) {
  384.            MacroModeInsert(c);
  385.            return;
  386.        } else {
  387.            MacroModeClose();
  388.        }
  389.        } 
  390.        if (accent) {
  391.        cursor->Insert(new MathAccentInset(c, t, accent));
  392.        accent = 0;  // accent consumed
  393.        } else 
  394.      cursor->Insert(c, t);
  395.        lastcode = t;
  396.        
  397.        return;
  398.    }
  399.     clearLastCode();
  400. }
  401.  
  402. void MathedCursor::Insert(MathedInset* p, int t)
  403. {
  404.    if (macro_mode) MacroModeClose();
  405.    if (selection) {
  406.       if (MathIsActive(t)) {
  407.      SelCut();
  408.      ((MathParInset*)p)->SetData(selarray);
  409.       } else
  410.     SelDel();
  411.    }
  412.          
  413.    if (mathstk.i<MAX_STACK_ITEMS-1) {
  414.        
  415.        if (accent && !MathIsActive(t)) {
  416.        cursor->Insert(new MathAccentInset(p, accent));
  417.        accent = 0;  // accent consumed
  418.        } else {
  419.        cursor->Insert(p, t);
  420.        
  421.        if (MathIsActive(t)) {
  422.            cursor->Prev();
  423.            Push();
  424.        }
  425.        }
  426.      
  427.    } else
  428.      fprintf(stderr, "Math error: Full stack.\n");
  429. }
  430.  
  431. void MathedCursor::Delete() 
  432. {   
  433.    if (macro_mode) return;
  434.    if (selection) {
  435.       SelDel();
  436.       return;
  437.    }
  438.    if (cursor->Empty() && !mathstk.Empty()) {
  439.       cursor = mathstk.pop();
  440.    } 
  441. //   if (cursor->GetChar()!=LM_TC_TAB)
  442.     cursor->Delete();
  443.     cursor->checkTabs();
  444. }
  445.  
  446. void MathedCursor::DelLine()
  447. {  
  448.     if (macro_mode) MacroModeClose();
  449.     if (selection) {
  450.     SelDel();
  451.     return;
  452.     }
  453.     MathParInset *p= cursor->p;
  454.     if (p &&  (p->GetType()<=LM_OT_MATRIX && p->GetType()>=LM_OT_MPAR)) {
  455.     cursor->delRow();
  456.     }
  457. }
  458.  
  459.  
  460. bool MathedCursor::Up(bool sel)
  461. {
  462.     bool result = false;
  463.    
  464.     if (macro_mode) MacroModeClose();
  465.     
  466.     if (sel && !selection) SelStart();
  467.     if (!sel && selection) SelClear();
  468.     
  469.     MathParInset *p;
  470.  
  471.     if (cursor->IsScript()) {
  472.     char cd = cursor->GetChar();
  473.     if (MathIsUp(cd)) {
  474.         Push();
  475.         return true;
  476.     } else {
  477.         // A subscript may be followed by a superscript
  478.         cursor->ipush();
  479.         cursor->Next();
  480.         if (MathIsUp(cursor->GetChar())) {
  481.         Push();
  482.         return true;
  483.         } else  // return to the previous state
  484.           cursor->ipop();
  485.       }
  486.    }    
  487.      
  488.     result = cursor->Up();
  489.     if (!result && cursor->p) {
  490.     p = cursor->p;   
  491.    
  492.     if (p->GetType()==LM_OT_SCRIPT) {
  493.         MathedXIter *cx = mathstk.Item(1);
  494.         bool is_down = (cx->GetChar()==LM_TC_DOWN);
  495.         cursor = mathstk.pop();
  496.         cursor->Next();
  497.         result =  (is_down) ? true: Up();
  498.     } else {
  499.         result = (p->getArgumentIdx() > 0);
  500.         if (result) {
  501.         p->setArgumentIdx(p->getArgumentIdx()-1);
  502.         cursor->SetData(p);
  503.         }
  504.     }
  505.     if (!result && !mathstk.Empty()) {
  506.         cursor = mathstk.pop();
  507.         return Up();
  508.     }     
  509.     }
  510.     return result;
  511. }
  512.  
  513.  
  514. bool MathedCursor::Down(bool sel)
  515. {
  516.     bool result = false;
  517.    
  518.     if (macro_mode) MacroModeClose();
  519.     
  520.     if (sel && !selection) SelStart();
  521.     if (!sel && selection) SelClear();
  522. //    if (selection) SelClear();
  523.  
  524.     MathParInset *p;
  525.  
  526.     if (cursor->IsScript()) {
  527.     char cd = cursor->GetChar(); 
  528.     if (MathIsDown(cd)) {
  529.         Push();
  530.         return true;
  531.     } else {
  532.         // A superscript may be followed by a subscript
  533.         cursor->ipush();
  534.         cursor->Next();
  535.         if (MathIsDown(cursor->GetChar())) {
  536.         Push();
  537.         return true;
  538.         } else
  539.           cursor->ipop();
  540.       }
  541.    }
  542.      
  543.     result = cursor->Down();
  544.     if (!result && cursor->p) {
  545.        p= cursor->p;   
  546.     if (p->GetType()==LM_OT_SCRIPT) {
  547.         MathedXIter *cx = mathstk.Item(1);
  548.         bool is_up = (cx->GetChar()==LM_TC_UP);
  549.         cursor = mathstk.pop();
  550.         cursor->Next();
  551.         result = (is_up) ? true: Down();
  552.     } else {
  553.         result = (p->getArgumentIdx() < p->getMaxArgumentIdx());
  554.         if (result) {
  555.         p->setArgumentIdx(p->getArgumentIdx()+1);
  556.         cursor->SetData(p);
  557.         }
  558.     }
  559.     if (!result && !mathstk.Empty()) {
  560.         cursor = mathstk.pop();
  561.         return Down(sel);
  562.     }    
  563.     }
  564.     return result;
  565. }
  566.  
  567. bool MathedCursor::Limits()
  568. {
  569.    if (cursor->IsInset()) {
  570.       MathedInset *p = cursor->GetInset();
  571.       bool ol = p->GetLimits();
  572.       p->SetLimits(!ol);
  573.       return (ol!=p->GetLimits());
  574.    }
  575.    return false;
  576. }
  577.  
  578. void MathedCursor::SetSize(short size)
  579. {
  580.     MathParInset *p = cursor->p;
  581.     p->UserSetSize(size);
  582.     cursor->SetData(p);
  583. }
  584.  
  585.  
  586. void MathedCursor::setLabel(char const* label)
  587. {  // ugly hack and possible bug
  588.     if (!cursor->setLabel(strnew(label)))
  589.       fprintf(stderr, "MathErr: Bad place to set labels.");
  590. }
  591.  
  592.  
  593. void MathedCursor::setNumbered()
  594. {  // another ugly hack
  595.     MathedRowSt *crow = cursor->crow;
  596.     if (!crow) return;    
  597.     crow->setNumbered(!crow->isNumbered());
  598. }
  599.  
  600.  
  601. void MathedCursor::Interpret(char const *s)
  602. {
  603.     MathedInset *p = 0;
  604.     latexkeys *l = 0;   
  605.     MathedTextCodes tcode = LM_TC_INSET;
  606.     
  607.     if (s[0]=='^' || s[0]=='_') {
  608.     char c = cursor->GetChar();
  609.     if (MathIsUp(c) && s[0]=='^' || MathIsDown(c) && s[0]=='_') {
  610.         Push();
  611.         return;
  612.     } else // A script may be followed by a script
  613.       if (MathIsUp(c)  || MathIsDown(c)) { 
  614.         cursor->ipush();
  615.         cursor->Next();
  616.         c = cursor->GetChar();
  617.         if (MathIsUp(c) && s[0]=='^' || MathIsDown(c) && s[0]=='_') {
  618.         Push();
  619.         return;
  620.         } else
  621.           cursor->ipop();
  622.     }
  623.     p = new MathParInset(LM_ST_SCRIPT, "", LM_OT_SCRIPT);
  624.     Insert (p, (s[0]=='_') ? LM_TC_DOWN: LM_TC_UP); 
  625.     return;
  626.     } else   
  627.       if (s[0]=='!' || s[0]==','  || s[0]==':' || s[0]==';') {
  628.       int sp = ((s[0]==',') ? 1:((s[0]==':') ? 2:((s[0]==';') ? 3: 0))); 
  629.       p = new MathSpaceInset(sp);
  630.       Insert(p);
  631.       return;
  632.       } else  
  633.       l = in_word_set (s, strlen(s));
  634.     
  635.     if (!l) {       
  636.     p = MathMacroTable::mathMTable.getMacro(s);
  637.     if (!p) {
  638.         lyxerr.debug(LString("Macro2 ") + s + ' ' + tcode, Error::MATHED);
  639.         p = new MathFuncInset(s, LM_OT_UNDEF);
  640.     } else {
  641.         tcode = ((MathMacro*)p)->getTCode();
  642.         fprintf(stderr, "Macro2 %s %d  ", s, tcode);
  643.     }
  644.     } else {
  645.     MathedInsetTypes fractype = LM_OT_FRAC;
  646.     switch (l->token) {
  647.      case LM_TK_BIGSYM:
  648.      {
  649.          p = new MathBigopInset(l->name, l->id);
  650.          break;
  651.      }
  652.      case LM_TK_SYM:
  653.      {              
  654.          if (l->id<255) {
  655.          Insert((byte)l->id, MathIsBOPS(l->id) ? 
  656.             LM_TC_BOPS: LM_TC_SYMB);         
  657.          } else {
  658.          p = new MathFuncInset(l->name);
  659.          }
  660.          break;
  661.      }  
  662.      case LM_TK_STACK:
  663.         fractype = LM_OT_STACKREL;
  664.         lyxerr.debug(" i:stackrel ", Error::MATHED);
  665.      case LM_TK_FRAC: 
  666.      {     
  667.          p = new MathFracInset(fractype);
  668.          tcode = LM_TC_ACTIVE_INSET;
  669.          break;
  670.      }
  671.      case LM_TK_SQRT: 
  672.      {     
  673.          p = new MathSqrtInset; 
  674.          tcode = LM_TC_ACTIVE_INSET;
  675.          break;
  676.      }
  677.      case LM_TK_WIDE: 
  678.      {     
  679.          p = new MathDecorationInset(l->id); 
  680.          tcode = LM_TC_ACTIVE_INSET;
  681.          break;
  682.      } 
  683.      case  LM_TK_FUNCLIM:
  684.      {
  685.          p = new MathFuncInset(l->name, LM_OT_FUNCLIM);
  686.          break;
  687.      }
  688.      case LM_TK_SPACE:
  689.      {
  690.          p = new MathSpaceInset(l->id);
  691.          break;
  692.      }       
  693.      case LM_TK_DOTS: 
  694.      {
  695.          p = new MathDotsInset(l->name, l->id);
  696.          break;
  697.      }       
  698.      case LM_TK_ACCENT:
  699.         setAccent(l->id);
  700.         break;
  701.      case LM_TK_MACRO:
  702.         p = MathMacroTable::mathMTable.getMacro(s);
  703.         tcode = ((MathMacro*)p)->getTCode();
  704.         lyxerr.debug(LString("Macro ") + s + ' ' + tcode, Error::MATHED);
  705.         break;
  706.      default:
  707.      {
  708.          p = new MathFuncInset(l->name);
  709.          break;
  710.      }
  711.     }
  712.     }
  713.     if (p) {
  714.     Insert(p, tcode);
  715.     par->Metrics();
  716.     }
  717. }
  718.  
  719.  
  720. void MathedCursor::MacroModeOpen()
  721. {
  722.    if (!macro_mode)  {
  723.       macroln = 0;
  724.       macrobf[0] = '\0';
  725.       imacro = new MathFuncInset(¯obf[0]);
  726.       Insert (imacro);
  727.       macro_mode = true;
  728.    } else
  729.      fprintf(stderr, "Mathed Warning: Already in macro mode\n");
  730. }
  731.  
  732. void MathedCursor::MacroModeClose()
  733. {
  734.    if (macro_mode)  {
  735. //       fprintf(stderr, "Pos[%d] ", cursor->getPos());
  736.       macro_mode = false;
  737.       latexkeys *l = in_word_set(macrobf, macroln);
  738.       if (macroln>0 && (!l || (l && IsMacro(l->token, l->id))) && 
  739.       !MathMacroTable::mathMTable.getMacro(macrobf)) {
  740.       if (!l) {
  741.         imacro->SetName(strnew(macrobf));
  742.           // This guarantees that the string will be removed by destructor
  743.         imacro->SetType(LM_OT_UNDEF);
  744.       } else 
  745.         imacro->SetName(l->name);
  746.       } else {
  747.          Left();
  748.      imacro->SetName(NULL);
  749.      if (cursor->GetInset()->GetType()==LM_OT_ACCENT) {
  750.          accent = ((MathAccentInset*)cursor->GetInset())->getAccentCode();
  751.      }
  752.      cursor->Delete();
  753.      if (l || MathMacroTable::mathMTable.getMacro(macrobf)) {
  754.         Interpret(macrobf);
  755.      }
  756.       }
  757.       imacro = NULL;
  758.    } else
  759.      fprintf(stderr, "Mathed Warning: we are not in macro mode\n");
  760. }
  761.  
  762. void MathedCursor::MacroModeBack()
  763. {
  764.    if (macro_mode) {
  765.      if (macroln>0) {
  766.     macrobf[--macroln] = '\0';
  767.     imacro->Metrics();
  768.      } else 
  769.     MacroModeClose();
  770.    } else
  771.      fprintf(stderr, "Mathed Warning: we are not in macro mode\n");
  772. }
  773.  
  774. void MathedCursor::MacroModeInsert(char c)
  775. {
  776.    if (macro_mode) {
  777.       macrobf[macroln+1] = macrobf[macroln];
  778.       macrobf[macroln++] = c;
  779.       imacro->Metrics();
  780.    } else
  781.      fprintf(stderr, "Mathed Warning: we are not in macro mode\n");
  782. }
  783.  
  784. void MathedCursor::SelCopy()
  785. {
  786.     if (selection) {
  787.     int p1, p2;
  788.     p1 = (cursor->pos < selpos) ? cursor->pos: selpos;
  789.     p2 = (cursor->pos > selpos) ? cursor->pos: selpos;
  790.     selarray = cursor->Copy(p1, p2);
  791.     cursor->Adjust();
  792.     SelClear();
  793.     }
  794. }
  795.  
  796. void MathedCursor::SelCut()
  797. {   
  798.     if (selection) {
  799.     if (cursor->pos==selpos) return;
  800.     
  801.     int p1, p2;
  802.     p1 = (cursor->pos < selpos) ? cursor->pos: selpos;
  803.     p2 = (cursor->pos > selpos) ? cursor->pos: selpos;
  804.     selarray = cursor->Copy(p1, p2);
  805.     cursor->Clean(selpos);
  806.     cursor->Adjust();
  807.     SelClear();
  808.     }
  809. }
  810.  
  811. void MathedCursor::SelDel()
  812. {
  813. //    fprintf(stderr, "Deleting sel ");
  814.     if (selection) {    
  815.     if (cursor->pos==selpos) return;
  816.          cursor->Clean(selpos);
  817.     cursor->Adjust();
  818.     SelClear();
  819.     }
  820. }
  821.  
  822. void MathedCursor::SelPaste()
  823. {
  824. //    fprintf(stderr, "paste %p %d ", selarray, cursor->pos);
  825.     if (selection) SelDel();
  826.     if (selarray) {
  827.     cursor->Merge(selarray);
  828.     cursor->Adjust();
  829.     }
  830. }
  831.  
  832. void MathedCursor::SelStart()
  833. {
  834.    lyxerr.debug("Starting sel ",Error::MATHED);
  835.     if (!anchor) {
  836.     selpos = cursor->pos;   
  837.     selstk = new MathStackXIter(mathstk); 
  838.     anchor = selstk->Item(-1); 
  839.     anchor->SetData(cursor->p);
  840.     anchor->GoBegin();
  841.     anchor->goPosAbs(selpos);
  842.     selection = true;
  843.     
  844.     }
  845. }
  846.  
  847. void MathedCursor::SelClear()
  848. {   
  849.    lyxerr.debug("Clearing sel ", Error::MATHED);
  850.     selection = false;
  851.     delete selstk;
  852.     selstk = 0;
  853.     anchor = 0;
  854. }
  855.  
  856.  
  857.  
  858. // Anchor position must be at the same level that stack.
  859. void MathedCursor::SelBalance()
  860. {
  861.     int d = mathstk.Level() - selstk->Level();
  862.  
  863.     // If unbalanced, balance them
  864.     while (d != 0) {
  865.         if (d<0) {
  866. //            fprintf(stderr, "b[%d %d %d %d]", mathstk.Level(), selstk->Level(), anchor->GetX(), cursor->GetX());
  867.             anchor = selstk->pop();
  868.             if (anchor->GetX() >= cursor->GetX()) 
  869.           anchor->Next();
  870.         } else {
  871. //            fprintf(stderr, "a[%d %d]", mathstk.Level(), selstk->Level());
  872.             Pop();
  873.         }
  874.         d = mathstk.Level() - selstk->Level();
  875.     }
  876.  
  877.     // Once balanced the levels, check that they are at the same paragraph
  878.     selpos = anchor->pos;
  879. } 
  880.  
  881.  
  882. XPoint *MathedCursor::SelGetArea(int& np)
  883. {   
  884.     if (!selection) {
  885.     np = 0;
  886.     return 0;
  887.     }
  888.     
  889.     static XPoint point[10];
  890.     
  891.     // single row selection
  892.     int i = 0, x, y, a, d, w, xo, yo, x1, y1, a1, d1; //, p1, p2;
  893.  
  894.     // Balance anchor and cursor
  895.     SelBalance();
  896.  
  897.     cursor->p->GetXY(xo, yo);
  898.     w = cursor->p->Width();
  899.     cursor->GetPos(x1, y1);
  900.     cursor->getAD(a1, d1);
  901.     anchor->GetPos(x, y);
  902.     anchor->getAD(a, d);
  903.  
  904.     point[i].x = x;
  905.     point[i++].y = y+d;
  906.     point[i].x = x;
  907.     point[i++].y = y-a;
  908.     
  909.     if (y!=y1) {
  910.     point[i].x = xo + w;
  911.     point[i++].y = y-a;
  912.     if (x1<xo+w) {
  913.         point[i].x = xo + w;
  914.         point[i++].y = y1-a;
  915.     }
  916.     }
  917.     
  918.     point[i].x = x1;
  919.     point[i++].y = y1-a;
  920.     point[i].x = x1;
  921.     point[i++].y = y1+d;
  922.     
  923.     if (y!=y1) {
  924.     point[i].x = xo;
  925.     point[i++].y = y1+d;
  926.     if (x>xo) {
  927.         point[i].x = xo;
  928.         point[i++].y = y+d;
  929.     }
  930.     }
  931.     point[i].x = point[0].x;
  932.     point[i++].y = point[0].y;
  933.     np = i;
  934. //    fprintf(stderr, "AN[%d %d %d %d] ", x, y, x1, y1); 
  935. //    fprintf(stderr, "MT[%d %d %d %d] ", a, d, a1, d1);
  936. //    for (i=0; i<np; i++)
  937. //      fprintf(stderr, "XY[%d %d] ", point[i].x, point[i].y);
  938.     
  939.     return &point[0];
  940. }
  941.  
  942.