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_iter.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  19KB  |  956 lines
  1. /*
  2.  *  File:        math_inset.C
  3.  *  Purpose:     Implementation of insets for mathed
  4.  *  Author:      Alejandro Aguilar Sierra <asierra@servidor.unam.mx> 
  5.  *  Created:     January 1996
  6.  *  Description: 
  7.  *
  8.  *  Dependencies: Xlib, XForms
  9.  *
  10.  *  Copyright: (c) 1996, Alejandro Aguilar Sierra
  11.  *
  12.  *   Version: 0.8beta.
  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. #include <config.h>
  19.  
  20. #ifdef __GNUG__
  21. #pragma implementation "math_iter.h"
  22. #endif
  23.  
  24. #include "math_iter.h"
  25. #include "math_inset.h"
  26. #include "symbol_def.h"
  27. #include "error.h"
  28.  
  29. const int SizeInset = sizeof(char*) + 2;
  30. const int SizeFont = 2;
  31.  
  32. extern int mathed_char_width(short type, int style, byte c);
  33. extern int mathed_string_width(short type, int style, byte const* s, int ls);
  34. extern int mathed_char_height(short, int, byte, int&, int&);
  35.  
  36.  
  37. void MathedIter::Reset()
  38. {
  39.     if (array->last>0 && MathIsFont(array->bf[0])) {
  40.     fcode = array->bf[0];
  41.     pos = 1;
  42.     } else {
  43.     fcode = -1;
  44.     pos = 0;
  45.     }
  46.     col = row = 0;
  47. }
  48.  
  49.  
  50. byte MathedIter::GetChar()
  51. {
  52.     if (IsFont()) { 
  53.     fcode = array->bf[pos];
  54.     pos++;
  55.     }
  56.     return array->bf[pos];
  57. }
  58.  
  59.  
  60. byte* MathedIter::GetString(int& len)
  61. {
  62.     if (IsFont()) { 
  63.     fcode = array->bf[++pos];
  64.     pos++;
  65.     }
  66.     byte *s = &array->bf[pos];
  67.     len = pos;
  68.     while (array->bf[pos]>=' ' && pos<array->last) pos++;
  69.     len = pos-len;   
  70.    
  71.    return s;
  72. }
  73.  
  74. MathedInset* MathedIter::GetInset()
  75. {
  76.    if (IsInset()) {
  77.       MathedInset* p;
  78.       memcpy(&p, &array->bf[pos+1], sizeof(p));
  79.       return p;
  80.    } else {
  81.       fprintf(stderr,"Math Error: This is not an inset[%d]\n", array->bf[pos]);
  82.      return 0;
  83.    }
  84. }
  85.  
  86. // An active math inset MUST be derived from MathParInset because it 
  87. // must have at least one paragraph to edit
  88. MathParInset* MathedIter::GetActiveInset()
  89. {
  90.     if (IsActive()) {
  91.     return (MathParInset*)GetInset();
  92.     } 
  93.     
  94.     fprintf(stderr,"Math Error: This is not an active inset\n");
  95.     return 0;
  96. }
  97.  
  98. bool MathedIter::Next()
  99. {  
  100.     if (!OK()) return false;
  101.    
  102.     if (array->bf[pos]<' ') {
  103.     fcode = -1;     
  104.     if (IsTab()) col++;
  105.     if (IsCR())  {
  106.         col = 0;
  107.         row++;
  108.     }
  109.     }
  110.     
  111.     if (IsInset())
  112.       pos += sizeof(char*) + 2;
  113.     else 
  114.       pos++;
  115.     
  116.     if (IsFont()) {
  117.     fcode = array->bf[pos++];
  118.     }
  119.  
  120.     return true;   
  121. }
  122.  
  123.  
  124. bool MathedIter::goNextCode(MathedTextCodes code)
  125. {  
  126.     while (Next()) {
  127.     if (array->bf[pos]==code) 
  128.       return true;
  129.     }
  130.     
  131.     return false;
  132. }
  133.  
  134.  
  135. void MathedIter::goPosAbs(int p)
  136. {  
  137.     Reset();
  138.     while (pos<p && Next());
  139. }
  140.  
  141.  
  142. void MathedIter::goPosRel(int dp)
  143. {  
  144.     int posx = pos+dp;
  145.  
  146.     // is posx a valid position?
  147.     if (dp<0)
  148.       Reset();
  149.     while (pos<posx && Next());
  150. }
  151.  
  152.  
  153. void MathedIter::Insert(byte c, MathedTextCodes t)
  154. {
  155.     if (c<' ') return;
  156.     
  157.     if (t==LM_TC_TAB && col>=ncols-1) 
  158.       return;
  159.     
  160.     // Never more than one space // array->bf[pos-1] gives error from purify:
  161.     //       Reading 1 byte from 0x47b857 in the heap.
  162.     //  Address 0x47b857 is 1 byte before start of malloc'd block at 0x47b858 of 16 bytes.
  163.     if (c==' ' && (array->bf[pos]==' ' || array->bf[pos-1]==' ')) 
  164.       return;
  165.     
  166.     if (IsFont() && array->bf[pos]==t) {
  167.     fcode = t;
  168.     pos++;
  169.     } else
  170.       if (t!=fcode && pos>0 && MathIsFont(array->bf[pos-1])) {
  171.       pos--;
  172.       int k;
  173.       for (k=pos-1; k>=0 && array->bf[k]>=' '; k--);
  174.       fcode = (k >= 0 && MathIsFont(array->bf[k])) ? array->bf[k]: -1;
  175.       }
  176.     short f = (array->bf[pos]<' ') ? 0: fcode;
  177.     int shift = (t==fcode) ? 1: ((f) ? 3: 2);
  178.     
  179.     if (t==LM_TC_TAB || t==LM_TC_CR) {
  180.     shift--;
  181.     c = t;
  182.     if (t==LM_TC_CR) {
  183.         row++;
  184.         col = 0;
  185.     } else
  186.       col++;
  187.     }
  188.  
  189.     if (pos < array->last)
  190.         array->Move(pos, shift);
  191.     else {
  192.     if (array->last+shift>=array->maxsize) {
  193.         array->Resize(array->last+shift);
  194.     }
  195.     array->last += shift;
  196.     array->bf[array->last] = '\0';
  197.     }
  198.     if (t != fcode) {
  199.     if (f)  
  200.       array->bf[pos+shift-1] = fcode;
  201.      if (c>=' ') {
  202.         array->bf[pos++] = t;
  203.         fcode = t;
  204.     } else {
  205.         fcode = 0;
  206.     }
  207.     }      
  208.     array->bf[pos++] = c;
  209. }
  210.  
  211.  
  212. // Prepare to insert a non-char object
  213. void MathedIter::split(int shift)
  214. {
  215.    if (pos < array->last) {
  216.       bool fg = false;
  217.       if (array->bf[pos]>=' ') {
  218.      if (pos> 0 && MathIsFont(array->bf[pos-1]))
  219.        pos--;
  220.      else { 
  221.         fg = true; 
  222.         shift++;
  223.      }
  224.       }      
  225.       array->Move(pos, shift);
  226.       if (fg) array->bf[pos+shift-1] = fcode;
  227.    } else {
  228.       if (array->last+shift>=array->maxsize) {
  229.       array->Resize(array->last+shift);
  230.       }
  231.       array->last += shift;
  232.    }
  233.    array->bf[array->last] = '\0';
  234. }
  235.  
  236.  
  237. // I assume that both pos and pos2 are legal positions
  238. void MathedIter::join(int pos2)
  239. {   
  240.     if (!OK() || pos2<=pos)
  241.       return;    
  242.  
  243.     short f=fcode;        
  244.     if (pos>0 && array->bf[pos]>=' ' && MathIsFont(array->bf[pos-1])) 
  245.       pos--;    
  246.             
  247.     if (MathIsFont(array->bf[pos2-1]))
  248.       pos2--;
  249.     
  250.     if (array->bf[pos2]>=' ') {
  251.     for (int p=pos2; p>0; p--) 
  252.       if (MathIsFont(array->bf[p])) {
  253.           f = array->bf[p];
  254.           break;
  255.       }
  256.     array->bf[pos++] = f;
  257.     }    
  258.  
  259.     array->Move(pos2, pos-pos2);
  260. }
  261.  
  262. void MathedIter::Insert(MathedInset* p, int type)
  263. {
  264.     int shift = SizeInset;
  265.     if (!MathIsInset(type))
  266.       type = LM_TC_INSET;
  267.     split(shift);
  268.     array->bf[pos] = type;
  269.     memcpy(&array->bf[pos+1], &p, sizeof(p));
  270.     pos += SizeInset;
  271.     array->bf[pos-1] = type;
  272.     array->bf[array->last] = '\0';
  273.     fcode = -1;
  274. }
  275.  
  276.  
  277. bool MathedIter::Delete()
  278. {   
  279.    if (!OK())
  280.      return false;
  281.    
  282.    int shift = 0;
  283.    byte c = GetChar();
  284.    if (c>=' ') { 
  285.       if (MathIsFont(array->bf[pos-1]) && array->bf[pos+1]<' ') {
  286.      int i;
  287.      shift = 2;
  288.      pos--;
  289.      for (i=pos-1; i>0 && !MathIsFont(array->bf[i]); i--);
  290.      if (i>0 && MathIsFont(array->bf[i]))
  291.        fcode = array->bf[i];
  292.       } else
  293.     shift = 1;      
  294.    } else {
  295.       if (MathIsInset(array->bf[pos]))
  296.     shift = sizeof(char*) + 2;
  297.      else 
  298.       if (c==LM_TC_TAB || c==LM_TC_CR) {
  299.      shift++;
  300. //     fprintf(stderr, "Es un tab.");
  301.       }
  302.      else {
  303.     fprintf(stderr, "Math Warning: expected inset.");
  304.     fflush(stderr);
  305.      }
  306.    } 
  307.     
  308.    if (shift!=0) {
  309.       array->Move(pos+shift, -shift);
  310.       if (pos>=array->last) 
  311.      pos = (array->last>0) ? array->last: 0;
  312.        return true;
  313.    } else
  314.      return false;
  315. }
  316.  
  317.  
  318. LyxArrayBase *MathedIter::Copy(int pos1, int pos2)
  319. {
  320.    if (!array) {
  321. //      fprintf(stderr, "Math error: Attempting to copy a void array.\n");
  322.       return 0;
  323.    }
  324.       
  325. //   int posx = pos;
  326.    ipush(); 
  327.    LyxArrayBase *t=array, *a;
  328.     
  329.    if (pos1>0 || pos2<=array->last) {       
  330.        short fc=0;
  331.        if (pos1>0 && array->bf[pos1]>' ') {
  332.        for (int p=pos1; p>=0; p--) 
  333.          if (MathIsFont(array->bf[p])) {
  334.          if (p!=pos1-1)
  335.            fc = array->bf[p];
  336.          else
  337.            pos1--;
  338.          break;
  339.          }
  340.        }
  341.  
  342.        if (pos2>0 && array->bf[pos2]>=' ' && MathIsFont(array->bf[pos2-1])) 
  343.      pos2--;
  344.  
  345.        int dx = pos2 - pos1;
  346.        a = new LyxArrayBase(dx+LyxArrayBase::ARRAY_MIN_SIZE);
  347. //       fprintf(stderr, "VA %d %d %d ", pos1, pos2, dx); fflush(stderr);
  348.        memcpy(&a->bf[(fc) ? 1: 0], &array->bf[pos1], dx);
  349.        if (fc) {
  350.        a->bf[0] = fc;
  351.        dx++;
  352.        }
  353.        a->last = dx;
  354.        a->bf[dx] = '\0';
  355.    }  else   
  356.       a = new LyxArrayBase(*array);
  357.    SetData(a);
  358.    while (OK()) {
  359.       if (IsInset()) {
  360.      MathedInset* inset = GetInset();
  361.      inset = inset->Clone();
  362.      memcpy(&array->bf[pos+1], &inset, sizeof(inset));
  363.       }
  364.       Next();
  365.    }
  366. //   pos = posx;
  367.    array = t;
  368.    ipop(); 
  369.    return a;
  370. }
  371.  
  372.  
  373. void MathedIter::Clear()
  374. {
  375.    if (!array) {
  376.       fprintf(stderr, "Math error: Attempting to clean a void array.\n");
  377.       return;
  378.    }   
  379.    Reset();  
  380.    while (OK()) {
  381.       if (IsInset()) {
  382.      MathedInset* inset = GetInset();
  383.       Delete();
  384.       if (inset->GetType()!=LM_OT_MACRO_ARG)
  385.         delete inset;
  386.       } else
  387.       Next();
  388.    }
  389. }
  390.  
  391.  
  392. // Check consistency of tabs and crs
  393. void MathedIter::checkTabs()
  394. {
  395.     ipush();
  396.     
  397. //    MathedIter:Reset();
  398.     while (OK()) {
  399.         if ((IsTab() && col>=ncols-1) || (IsCR() && !(MthIF_CR&flags))) {
  400.             Delete();
  401.             continue;
  402.         }
  403.         if (IsCR() && col<ncols-2) {
  404.             Insert(' ', LM_TC_TAB);
  405.     }
  406.         MathedIter::Next();
  407.     }
  408.     if (col<ncols-2) {
  409.     Insert(' ', LM_TC_TAB);
  410.     }
  411.     ipop();
  412. }         
  413.  
  414.  
  415. //  Try to adjust tabs in the expected place, as used in eqnarrays
  416. //  Rules:
  417. //   - If there are a relation operator, put tabs around it
  418. //   - If tehre are not a relation operator, put everything in the
  419. //     3rd column.
  420. void MathedIter::adjustTabs()
  421. {
  422.  
  423. }         
  424.  
  425.  
  426. void MathedXIter::Clean(int pos2)
  427. {
  428.     if (!array) {
  429.     fprintf(stderr, "Math error: Attempting to clean a void array.\n");
  430.     return;
  431.     } 
  432.     
  433.     int pos1 = pos;
  434.     
  435.     if (pos2<pos1) {  
  436.     GoBegin();
  437.     while (pos<pos2 && OK()) { Next();
  438.     }
  439.     pos2 = pos1;
  440.     pos1 = pos;
  441.     }
  442.  
  443.     ipush();
  444.     while (OK() && pos<pos2) {
  445.     if (IsInset()) {
  446.         MathedInset* inset = GetInset();
  447.         if (inset->GetType()!=LM_OT_MACRO_ARG)
  448.           delete inset;
  449.     } 
  450.     if (IsCR()) {
  451.         if (crow) {
  452.         MathedRowSt *r = crow->next;
  453.         if (r) {
  454.             crow->next = r->next;
  455.             delete r;
  456.         }       
  457.         }
  458.     }
  459.     Next();
  460.     }    
  461.     ipop();
  462.     
  463.     if (pos2<=array->Last()) {
  464.     pos = pos1;
  465.     join(pos2);
  466.     checkTabs();
  467.     } 
  468. }
  469.  
  470.  
  471. void MathedXIter::Merge(LyxArrayBase *a0)
  472. {
  473.     if (!a0) {
  474.     lyxerr.debug("Math error: Attempting to merge a void array.",
  475.              Error::MATHED);
  476.     return;
  477.     }
  478.     // All insets must be clonned
  479.     MathedIter it(a0);
  480.     LyxArrayBase *a = it.Copy();
  481.     
  482.     // make rom for the data 
  483.     split(a->Last());
  484.     array->MergeF(a, pos, a->Last());
  485.  
  486.     int pos1=pos, pos2 = pos + a->Last(); // pos3=0;
  487.  
  488.     goPosAbs(pos1);
  489.     
  490.     // Complete rows
  491.     while (pos<pos2 && OK()) {
  492.     if (IsCR()) {
  493.         if (p && p->Permit(LMPF_ALLOW_CR)) {
  494.         MathedRowSt *r = new MathedRowSt(ncols+1);
  495.         if (crow) {
  496.             r->next = crow->next;
  497.             crow->next = r;
  498.           } else {
  499.               r->next = 0;
  500.           }
  501.         crow = r;
  502.         } else {
  503.         Delete();
  504.         pos2--;
  505.         }
  506.     }
  507.         Next();    
  508.     }
  509.     pos2 = getPos();
  510.     goPosAbs(pos1);
  511.     checkTabs();
  512.     goPosAbs(pos2);
  513.     
  514.     delete a;
  515. }
  516.  
  517.  
  518. //-----------  XIter
  519.  
  520.  
  521. MathedXIter::MathedXIter(MathParInset* pp): p(pp) 
  522. { 
  523.     x = y = 0;
  524.     sx = sw = 0;   
  525.     limits = false;
  526.     s_type = 0;  
  527.     if (p) 
  528.       SetData(p);
  529.     else {
  530.     crow = 0;
  531.     size = 0;
  532.     }
  533. }
  534.  
  535. void MathedXIter::SetData(MathParInset *pp)
  536. {
  537.     p = pp;
  538.     x = y = 0;
  539.     array = p->GetData();
  540.     ncols = p->GetColumns();
  541.     crow = p->getRowSt();
  542.     if (p->Permit(LMPF_ALLOW_CR))
  543.       flags |= MthIF_CR;
  544.     if (p->Permit(LMPF_ALLOW_TAB))
  545.       flags |= MthIF_Tabs;
  546.     
  547.     if (crow) {
  548.     x = crow->getTab(0);
  549.     y = crow->getBaseline();
  550.     } 
  551.     if (!array) {
  552.         array = new LyxArrayBase; // this leaks
  553.     p->SetData(array);
  554.     }
  555.     size = p->GetStyle();
  556.     Reset();
  557. }
  558.  
  559. byte* MathedXIter::GetString(int& ls)
  560. {  
  561.    static byte s[255];
  562.    byte const *sx =  MathedIter::GetString(ls);
  563.    if (ls>0) {
  564.        strncpy((char *)s, (char const*)sx, ls);
  565.        x += mathed_string_width(fcode, size, s, ls);
  566.        return &s[0];
  567.    }         
  568.     return 0;
  569. }
  570.  
  571.  
  572. bool MathedXIter::Next()
  573. {  
  574. //    fprintf(stderr, "Ne[%d]", pos);
  575.    if (!OK()) return false;
  576.    int w=0;
  577. //   fprintf(stderr, "xt ");
  578.    if (IsInset()) {
  579.       MathedInset* px = GetInset();
  580.       w = px->Width();
  581.       if (px->GetType()==LM_OT_SCRIPT) {
  582.      if (w>sw) sw = w;
  583.      w = 0;
  584.       } else
  585.     sx = (px->GetLimits()) ? w: 0;
  586.    } else {  
  587.       byte c = GetChar();
  588.       if (c>=' ') {
  589. //      fprintf(stderr, "WD[%d %d %c] ", fcode, size, c); fflush(stderr);
  590.       w = mathed_char_width(fcode, size, c);
  591.       } else
  592.       if (c==LM_TC_TAB && p) {
  593. //     w = p->GetTab(col+1);
  594.       w = (crow) ? crow->getTab(col+1): 0;
  595.      //fprintf(stderr, "WW[%d]", w);
  596.       } else
  597.       if (c==LM_TC_CR && p) {
  598.       x = 0;
  599.       if (crow && crow->next) {
  600.           crow = crow->next;
  601.           y = crow->getBaseline();
  602.           w = crow->getTab(0);
  603.       }
  604. //      fprintf(stderr, "WW[%d %d|%d]", col, row, w);
  605.       } else 
  606.     fprintf(stderr, "No hubo w[%d]!", (int)c);   
  607.    }
  608.    if (MathedIter::Next()) {
  609. //       fprintf(stderr, "LNX %d ", pos); fflush(stderr);
  610. //       if (sw>0 && GetChar()!=LM_TC_UP && GetChar()!=LM_TC_DOWN) {
  611. //       w = (sx>sw) ? 0: sw-sx;
  612.       if ((sw>0 || sx>0) && GetChar()!=LM_TC_UP && GetChar()!=LM_TC_DOWN) {
  613.       if (sw>0)
  614.         w = (sx>sw) ? 0: sw-sx;
  615.       sx = sw = 0;
  616.       }
  617.       x += w;
  618.       return true;
  619.    } else
  620.      return false;
  621. }
  622.  
  623.  
  624. void MathedXIter::GoBegin()
  625. {
  626.    Reset();
  627.    x = y = 0;   
  628.    sw = sx = 0;
  629.    if (p) {
  630.        crow = p->getRowSt();
  631.        if (crow) {
  632.        x = crow->getTab(0);
  633.        y = crow->getBaseline();
  634.        }
  635.    }
  636. }
  637.  
  638. void MathedXIter::GoLast()
  639. {
  640.    while (Next());
  641. }
  642.  
  643.  
  644. void MathedXIter::Adjust()
  645. {
  646.    int posx = pos;
  647.    GoBegin();
  648.    while (posx>pos && OK()) Next();  
  649. }
  650.  
  651.  
  652. bool MathedXIter::Prev()
  653. {  
  654.     if (pos==0 || (pos==1 && GetChar()>=' '))
  655.       return false;
  656.     
  657.     int pos2 = pos; // pos1
  658.     GoBegin();
  659.     do {
  660.     ipush();
  661.     Next();
  662.     } while (pos<pos2);
  663.     ipop();
  664.     
  665.     return (!IsCR());
  666. }
  667.  
  668.  
  669. bool MathedXIter::goNextColumn()
  670. {  
  671.     int rowp = row, colp=col;
  672.     while (Next() && col==colp);
  673.     
  674.     return (col!=colp+1 || rowp!=row);
  675. }
  676.  
  677.  
  678. bool MathedXIter::Up()
  679. {
  680.     if (row==0) return false;
  681.     int xp = x, rowp = row, colp=col;
  682.     GoBegin();
  683.     while (row<rowp-1) Next();
  684.     while (x<xp && OK() && !IsCR()) {
  685.     ipush();
  686.     Next();
  687.     }
  688.     if (col>colp) // || (stck.col==colp && stck.x<=xp && x>xp))
  689.       ipop();
  690.     
  691.     return true;
  692. }
  693.  
  694.  
  695. bool MathedXIter::Down()
  696. {
  697.     int xp = x, colp=col; // ,rowp = row
  698.     
  699.     bool res = (IsCR()) ? true: goNextCode(LM_TC_CR);
  700.     if (res) {
  701.         Next();
  702.     ipush();
  703.     while (x<xp && OK()) {
  704.         ipush();
  705.         Next();
  706.     }
  707.     if (col>colp || (stck.col==colp && stck.x<=xp && x>xp)) 
  708.       ipop();       
  709.         return true;
  710.     }
  711.     return false;
  712. }
  713.  
  714.  
  715. void MathedXIter::addRow()
  716. {
  717.     if (!crow) {
  718.     lyxerr.debug(LString("MathErr: Attempt to insert new"
  719.                  " line in a subparagraph. ")
  720.              + long(this), Error::MATHED);
  721.     return;
  722.     }    
  723.     // Create new item for the structure    
  724.     MathedRowSt *r = new MathedRowSt(ncols+1);
  725.     if (crow) {
  726.     r->next = crow->next;
  727.     crow->next = r;
  728.     } else {
  729.     crow = r;
  730.     r->next = 0;
  731.     }    
  732.     // Fill missed tabs in current row
  733.     while (col<ncols-1) 
  734.       Insert('T', LM_TC_TAB); 
  735.     //newline
  736.     Insert('K', LM_TC_CR);
  737.     
  738.     ipush();
  739.     if (!IsCR())
  740.       goNextCode(LM_TC_CR);
  741.     
  742.     // Fill missed tabs in new row
  743.     while (col<ncols-1) 
  744.       Insert('T', LM_TC_TAB);
  745.     ipop();
  746. }
  747.  
  748.  
  749. void MathedXIter::delRow()
  750. {
  751.     if (!crow) {
  752.     lyxerr.debug("MathErr: Attempt to delete a line in a subparagraph.",
  753.              Error::MATHED);
  754.     return;
  755.     }
  756.     bool line_empty = true;
  757.     ipush();
  758. //    while (Next()) {
  759.     do {
  760.     if (IsCR()){
  761.         break;
  762.     } else if (!IsTab()) {
  763.         line_empty = false;
  764.     }
  765.     } while (Next());
  766.     int p1 = getPos();
  767.     ipop();
  768.     
  769.     if (line_empty) {
  770.     
  771.     MathedRowSt *r = crow->next;
  772.     if (r) {
  773.         crow->next = r->next;
  774.         delete r;
  775.     }
  776.     join(p1);
  777.     Delete();
  778.     } else
  779.       Clean(p1);
  780.     
  781.     checkTabs();    
  782. }
  783.  
  784. void MathedXIter::ipush()
  785. { 
  786.     MathedIter::ipush();
  787.     stck.x = x;
  788.     stck.y = y;
  789. }
  790.  
  791.  
  792. void MathedXIter::ipop()
  793. { 
  794.     MathedIter::ipop();
  795.     x = stck.x;
  796.     y = stck.y;
  797.     if (p) {
  798.     crow = p->getRowSt();
  799.     if (crow)
  800.       for (int i=0; i<row; i++) 
  801.         crow = crow->next;
  802.     }
  803. }
  804.  
  805.  
  806. void MathedXIter::fitCoord(int /*xx*/, int yy)
  807. {
  808.     int xo = 0, yo = 0;
  809.     
  810.     GoBegin();
  811.     if (p) 
  812.       p->GetXY(xo, yo);
  813.     // first fit vertically
  814.     while (crow && OK()) {
  815.     if (yy>=yo+y-crow->asc && yy<= yo+y+crow->desc) 
  816.       break;
  817.     goNextCode(LM_TC_CR);
  818.     Next();
  819.     }
  820.     // now horizontally
  821. //    while (x<xx && Next());
  822. }
  823.  
  824. void MathedXIter::setTab(int tx, int tab)
  825. {
  826.     if (crow && tab<=ncols) {
  827.     crow->w[tab] = tx;
  828.     }
  829.     else 
  830.       fprintf(stderr, "MathErr: No tabs allowed here");
  831. }
  832.  
  833.  
  834. void MathedXIter::subMetrics(int a, int d)
  835. {
  836.     if (!crow) {
  837. //    fprintf(stderr, "MathErr: Attempt to submetric a subparagraph.");
  838.     return;
  839.     }    
  840.     crow->asc = a;
  841.     crow->desc = d;
  842. }
  843.  
  844.  
  845. // This function is not recursive, as MathPar::Metrics is
  846. void MathedXIter::IMetrics(int pos2, int& width, int& ascent, int& descent)
  847. {  
  848.     byte cx, cxp=0;// *s;
  849.     int x1;// ls;
  850.     int asc=0, des=0;
  851.     bool limits = false;
  852.   
  853.     descent = ascent = width = 0;
  854.     if (!array) return;
  855.     if (array->Empty()) return;
  856. //    if  (pos2 > array->last) return;
  857.     x1 = x; 
  858.     while (pos<pos2) {
  859.     cx = GetChar();
  860.     if (cx >= ' ') {
  861.         mathed_char_height(FCode(), size, cx, asc, des);
  862.         if (asc > ascent) ascent = asc;
  863.         if (des > descent) descent = des;
  864.         limits = false;
  865.     } else
  866.     if (MathIsInset(cx)) {
  867.         MathedInset *pp = GetInset();
  868.         if (cx==LM_TC_UP) {
  869.         if (!asc && p) {
  870.             int xx, yy;
  871.             p->GetXY(xx, yy);
  872.             ((MathParInset*)pp)->GetXY(xx, asc);
  873.             asc = yy - asc;
  874.         }
  875.         asc += ((limits) ? pp->Height()+4: pp->Ascent());
  876.         } else
  877.           if (cx==LM_TC_DOWN) {
  878.           if (!des && p) {
  879.               int xx, yy;
  880.               p->GetXY(xx, yy);
  881.               ((MathParInset*)pp)->GetXY(xx, des);
  882.               if (des-pp->Height()<yy && !asc)
  883.             asc = yy - (des-pp->Height());
  884.               des -= yy;
  885.           }
  886.           des += ((limits) ? pp->Height()+4: pp->Height()-pp->Ascent()/2);
  887.           } else {
  888.           asc = pp->Ascent();
  889.           des = pp->Descent();
  890.           }
  891.         if (asc > ascent) ascent = asc;
  892.         if (des > descent) descent = des;
  893.         if (cx!=LM_TC_UP && cx!=LM_TC_DOWN)
  894.           limits = pp->GetLimits();
  895.     } else 
  896.     if (cx==LM_TC_TAB) {
  897.         limits = false;                   
  898.     }      
  899.     else {
  900.         lyxerr.debug(LString("Mathed Sel-Error: Unrecognized code[")
  901.              + int(cx) + ']', Error::MATHED);
  902.         break;
  903.     }       
  904.     if (pos<pos2)  Next();
  905.     cxp = cx;
  906.    }
  907.     width = x - x1;
  908. }
  909.  
  910.  
  911. bool MathedXIter::setNumbered(bool numb)
  912. {  
  913.     if (crow) {
  914.     crow->setNumbered(numb);
  915.     return true;
  916.     }
  917.     
  918.     return false;
  919. }
  920.  
  921.  
  922. bool MathedXIter::setLabel(char* label)
  923. {  
  924.     if (label && crow) {
  925.     crow->setLabel(label);
  926.     return true;
  927.     }
  928.     
  929.     return false;
  930. }
  931.  
  932.  
  933. MathedRowSt *MathedXIter::adjustVerticalSt()
  934. {
  935.     GoBegin();
  936.     if (!crow) {
  937. //    fprintf(stderr, " CRW%d ", ncols);
  938.         crow = new MathedRowSt(ncols+1); // this leaks
  939.     }
  940. //    fprintf(stderr, " CRW[%p] ", crow);
  941.     MathedRowSt *row = crow;
  942.     while (OK()) {
  943.     if (IsCR()) {
  944.         if (col>=ncols) ncols = col+1; 
  945.         MathedRowSt *r = new MathedRowSt(ncols+1); // this leaks
  946. //        r->next = crow->next;
  947.         crow->next = r;
  948.         crow = r;
  949. //        fprintf(stderr, " CX[%p]", crow);
  950.     }   
  951.     Next();    
  952.     }
  953.     return row;
  954. }
  955.  
  956.