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_inset.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  11KB  |  540 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, 1997 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_inset.h"
  22. #endif
  23.  
  24. #include "math_iter.h"
  25. #include "math_inset.h"
  26. #include "symbol_def.h"
  27.  
  28.  
  29. inline
  30. char *strnew(char const* s)
  31. {
  32.    char *s1 = new char[strlen(s)+1];
  33.    return strcpy(s1, s);
  34. }
  35.  
  36.  
  37. MathedInset::MathedInset(MathedInset* inset) 
  38. {
  39.    if (inset) {
  40.       name = inset->GetName();
  41.       objtype = inset->GetType();
  42.       size = inset->GetStyle();
  43.       width = inset->Width();
  44.       ascent = inset->Ascent();
  45.       descent = inset->Descent();
  46.    } else {
  47.       objtype = LM_OT_UNDEF;
  48.       size = LM_ST_TEXT;
  49.       width = ascent = descent = 0;
  50.       name = 0;
  51.    }
  52. }
  53.  
  54.  
  55. MathFuncInset::MathFuncInset(char const *nm, short ot, short st):
  56.     MathedInset("", ot, st)
  57. {
  58.    ln = 0;
  59.    lims = (GetType()==LM_OT_FUNCLIM);
  60.     if (GetType()==LM_OT_UNDEF) {
  61.     fname = strnew(nm);
  62.     SetName(fname);
  63.     } else {
  64.     fname = 0;
  65.     SetName(nm);
  66.     }
  67. }
  68.  
  69. MathedInset *MathFuncInset::Clone()
  70. { 
  71.    MathedInset *l = new MathFuncInset(name, GetType(), GetStyle());
  72.    return l;
  73. }
  74.  
  75. MathSpaceInset::MathSpaceInset(int sp, short ot, short st):
  76.     MathedInset("", ot, st), space(sp)
  77. {
  78. }
  79.  
  80. MathedInset *MathSpaceInset::Clone()
  81. { 
  82.    MathedInset *l = new MathSpaceInset(space, GetType(), GetStyle());
  83.    return l;
  84. }
  85.  
  86. MathParInset::MathParInset(short st, char const *nm, short ot):
  87.    MathedInset(nm, ot, st)
  88. {
  89.     array = 0;
  90.     ascent = 8;
  91.     width = 4;
  92.     descent = 0;
  93.     flag = 1;
  94.     if (objtype==LM_OT_SCRIPT)
  95.       flag |= LMPF_SCRIPT;
  96. }
  97.  
  98. MathParInset::MathParInset(MathParInset* p): MathedInset(p)
  99. {
  100.     flag = p->flag;
  101.     p->setArgumentIdx(0);
  102.     MathedIter it(p->GetData());
  103.     SetData(it.Copy());
  104. }
  105.  
  106.  
  107. MathParInset::~MathParInset()
  108. {
  109.    if (array) {
  110.       MathedIter it(array);
  111.       it.Clear();
  112.       delete array;
  113.    }
  114. }
  115.  
  116.  
  117. MathedInset *MathParInset::Clone()
  118. {   
  119.    MathParInset* p = new MathParInset(this);
  120.    return p;
  121. }
  122.  
  123.  
  124. void MathParInset::SetData(LyxArrayBase *a)
  125. {
  126.     array = a;
  127.    
  128.     // A standard paragraph shouldn't have any tabs nor CRs.
  129.     if (array) {
  130.     MathedIter it(array);
  131.     while (it.OK()) {
  132.         char c = it.GetChar();
  133.         if (c==LM_TC_TAB || c==LM_TC_CR) 
  134.           it.Delete();
  135.         else
  136.           it.Next();
  137.     }
  138.    }
  139. }
  140.  
  141.  
  142. MathSqrtInset::MathSqrtInset(short st): MathParInset(st, "sqrt", LM_OT_SQRT)
  143. {    
  144. }
  145.  
  146.  
  147. MathedInset *MathSqrtInset::Clone()
  148. {   
  149.    MathSqrtInset* p = new MathSqrtInset(GetStyle());
  150.    MathedIter it(array);
  151.    p->SetData(it.Copy());
  152.    return p;
  153. }
  154.  
  155.  
  156. bool MathSqrtInset::Inside(int x, int y) 
  157. {
  158.     return (x>=xo-hmax && x<=xo+width-hmax && y<=yo+descent && y>=yo-ascent);
  159. }
  160.  
  161.  
  162. MathDelimInset::MathDelimInset(int l, int r, short st): 
  163.   MathParInset(st, "", LM_OT_DELIM), left(l), right(r)
  164. {
  165. }
  166.  
  167. MathedInset *MathDelimInset::Clone()
  168. {   
  169.    MathDelimInset* p = new MathDelimInset(left, right, GetStyle());
  170.    MathedIter it(array);
  171.    p->SetData(it.Copy());
  172.    return p;
  173. }
  174.  
  175.  
  176. MathDecorationInset::MathDecorationInset(int d, short st): 
  177.   MathParInset(st, "", LM_OT_DECO), deco(d)
  178. {
  179.    upper = (deco!=LM_underline && deco!=LM_underbrace);
  180. }
  181.  
  182. MathedInset *MathDecorationInset::Clone()
  183. {   
  184.    MathDecorationInset* p = new MathDecorationInset(deco, GetStyle());
  185.    MathedIter it(array);
  186.    p->SetData(it.Copy());
  187.    return p;
  188. }
  189.  
  190. MathFracInset::MathFracInset(short ot): MathParInset(LM_ST_TEXT, "frac", ot)
  191. {
  192.     
  193.     den = new MathParInset(LM_ST_TEXT); // this leaks
  194.     dh = 0;
  195.     idx = 0;
  196.     if (objtype==LM_OT_STACKREL) {
  197.     flag |= LMPF_SCRIPT;
  198.     SetName("stackrel");
  199.     }
  200. }
  201.  
  202. MathFracInset::~MathFracInset()
  203. {
  204.     delete den;
  205. }
  206.  
  207. MathedInset *MathFracInset::Clone()
  208. {   
  209.     MathFracInset* p = new MathFracInset(GetType());
  210.     MathedIter itn(array);
  211.     MathedIter itd(den->GetData());
  212.     p->SetData(itn.Copy(), itd.Copy());
  213.     p->idx = idx;
  214.     p->dh = dh;
  215.    return p;
  216. }
  217.  
  218. bool MathFracInset::setArgumentIdx(int i)
  219. {
  220.    if (i==0 || i==1) {
  221.        idx = i;
  222.        return true;
  223.    } else 
  224.       return false;
  225. }
  226.  
  227.  
  228. void MathFracInset::SetStyle(short st)
  229. {
  230.     MathParInset::SetStyle(st);
  231.     dh = 0;
  232.     den->SetStyle((size==LM_ST_DISPLAY) ? LM_ST_TEXT: size);
  233. }
  234.  
  235. void MathFracInset::SetData(LyxArrayBase *n, LyxArrayBase *d)
  236. {
  237.    den->SetData(d);
  238.    MathParInset::SetData(n);
  239. }
  240.  
  241. void MathFracInset::SetData(LyxArrayBase *d)
  242. {
  243.    if (idx==0)
  244.      MathParInset::SetData(d);
  245.    else {
  246.       den->SetData(d);
  247.    }
  248. }
  249.  
  250. void MathFracInset::GetXY(int& x, int& y) const
  251. {  
  252.    if (idx==0)
  253.      MathParInset::GetXY(x, y);
  254.    else
  255.      den->GetXY(x, y);
  256. }
  257.    
  258. LyxArrayBase *MathFracInset::GetData()
  259. {
  260.    if (idx==0)
  261.      return array;
  262.    else
  263.      return den->GetData();
  264. }
  265.  
  266.  
  267. bool MathFracInset::Inside(int x, int y) 
  268. {
  269.     int xx = xo - (width-w0)/2;
  270.     
  271.     return (x>=xx && x<=xx+width && y<=yo+descent && y>=yo-ascent);
  272. }
  273.  
  274. void MathFracInset::SetFocus(int /*x*/, int y)
  275. {  
  276. //    fprintf(stderr, "y %d %d %d ", y, yo, den->yo);
  277.     idx = (y > yo) ? 1: 0;
  278. }
  279.  
  280.  
  281. MathMatrixInset::MathMatrixInset(int m, int n, short st): 
  282.    MathParInset(st, "array", LM_OT_MATRIX), nc(m)
  283. {
  284.     ws = new int[nc]; 
  285.     v_align = 0;
  286.     h_align = new char[nc+1];
  287.     for (int i =0; i<nc; i++) h_align[i] = 'c'; 
  288.     h_align[nc] = '\0';
  289.     nr = 0;
  290.     row = 0;
  291.     flag = 15;
  292.     if (n>0) {
  293.         row = new MathedRowSt(nc+1);
  294.     MathedXIter it(this);
  295.     for (int i=1; i<n; i++) it.addRow();
  296.     nr = n;
  297.     if (nr==1 && nc>1) {
  298.         for (int i=0; i<nc-1; i++) 
  299.           it.Insert('T', LM_TC_TAB);
  300.     }
  301.     } else if (n<0) {
  302.         row = new MathedRowSt(nc+1);
  303.     nr = 1;
  304.     }
  305. }
  306.  
  307.  
  308. MathMatrixInset::MathMatrixInset(MathMatrixInset *mt): 
  309.    MathParInset(mt->GetStyle(), mt->GetName(), mt->GetType())
  310. {
  311.     nc = mt->nc;
  312.     nr = mt->nr;
  313.     ws = new int[nc];
  314.     h_align = new char[nc+1];
  315.     strcpy(h_align, mt->GetAlign(&v_align));
  316.     MathedIter it;   
  317.     it.SetData(mt->GetData());
  318.     array = it.Copy();
  319.     if (mt->row && (objtype==LM_OT_MPARN)) {
  320.     MathedRowSt *r, *ro=0, *mrow = mt->row;
  321.     for (int i=0; i<nr; i++) {
  322.         r = new MathedRowSt(nc+1);
  323.         r->numbered = mrow->numbered;
  324.         if (mrow->label) 
  325.           r->label = strnew(mrow->label);
  326.         if (!ro) 
  327.         row = r;
  328.         else
  329.           ro->next = r;
  330.         mrow = mrow->next;
  331.         ro = r;
  332.     } 
  333.     } else
  334.       row = 0;
  335.     
  336.     flag = mt->flag;
  337. }
  338.  
  339.  
  340. MathMatrixInset::~MathMatrixInset()
  341. {
  342.     delete[] ws;
  343.     
  344.     MathedRowSt *r = row;    
  345.     while (r) {
  346.     MathedRowSt *q = r->next;
  347.     delete r;
  348.     r = q;
  349.     }
  350. }
  351.  
  352. MathedInset *MathMatrixInset::Clone()
  353. {   
  354.    MathMatrixInset* mt = new MathMatrixInset(this);
  355.    return mt;
  356. }
  357.  
  358. void MathMatrixInset::SetAlign(char vv, char const* hh)
  359. {
  360.    v_align = vv;
  361.    strncpy(h_align, hh, nc);
  362. }
  363.  
  364.  
  365. // Check the number of tabs and crs
  366. void MathMatrixInset::SetData(LyxArrayBase *a)
  367. {
  368.     if (!a) return;
  369.     MathedIter it(a);
  370.     int nn = nc-1;
  371.     nr = 1;
  372.     // count tabs per row
  373.     while (it.OK()) {
  374.     if (it.IsTab()) {
  375.         if (nn<0) { 
  376.         it.Delete();
  377.         continue;
  378.         } else {
  379. //          it.Next();
  380.         nn--;
  381.         }
  382.     }
  383.     if (it.IsCR()) {
  384.         while (nn>0) {
  385.         it.Insert(' ', LM_TC_TAB);
  386.         nn--;
  387.         }
  388.         nn = nc-1;
  389.         nr++;
  390.     }
  391.     it.Next();
  392.     }  
  393.     it.Reset();
  394.  
  395.     // Automatically inserts tabs around bops
  396.     // DISABLED because it's very easy to insert tabs 
  397.     array = a;
  398. }
  399.  
  400.  
  401. void MathMatrixInset::Draw(int x, int baseline)
  402. {
  403.     MathParInset::Draw(x, baseline);
  404. }                
  405.  
  406. void MathMatrixInset::Metrics()
  407. {
  408.     int i, /*cy,*/ hl, h=0;
  409.     MathedRowSt *cprow=0, *cxrow;
  410.  
  411.     if (!row) {
  412. //    fprintf(stderr, " MIDA ");
  413.     MathedXIter it(this);
  414.     row = it.adjustVerticalSt();
  415.     } 
  416.     
  417.     // Clean the arrays      
  418.     cxrow = row;
  419.     while (cxrow) {   
  420.     for (i=0; i<=nc; i++) cxrow->w[i] = 0;
  421.     cxrow = cxrow->next;
  422.     }
  423.     
  424.     // Basic metrics
  425.     MathParInset::Metrics();
  426.         
  427.     if (nc<=1 && !row->next) {
  428.     row->asc = ascent;
  429.     row->desc = descent;
  430.     }
  431.     
  432.     // Vertical positions of each row
  433.     cxrow = row;     
  434.     while (cxrow) {
  435.     for (i=0; i<nc; i++) {
  436.         if (cxrow==row || ws[i]<cxrow->w[i]) ws[i]=cxrow->w[i];
  437.         if (cxrow->next==0 && ws[i]==0) ws[i] = df_width;
  438.     }
  439.     
  440.     cxrow->y = (cxrow==row) ? cxrow->asc:
  441.                cxrow->asc + cprow->desc + MATH_ROWSEP + cprow->y;
  442.     h += cxrow->asc + cxrow->desc + MATH_ROWSEP;     
  443.     cprow = cxrow;
  444.     cxrow = cxrow->next;
  445.     }
  446.     
  447.     hl = Descent();
  448.     h -= MATH_ROWSEP;
  449.  
  450.     //  Compute vertical align
  451.     switch (v_align) {
  452.      case 't': ascent = row->y; break;
  453.      case 'b': ascent = h - hl; break;
  454.      default:  ascent = (row->next) ? h/2: h - hl; break;
  455.     }
  456.     descent = h - ascent + 2;
  457.     
  458.    
  459.    // Adjust local tabs
  460.     cxrow = row;
  461.     width = MATH_COLSEP;
  462.     while (cxrow) {   
  463.     int rg=MATH_COLSEP, ww, lf=0, *w = cxrow->w;
  464.     for (i=0; i<nc; i++) {
  465.         bool isvoid = false;
  466.         if (w[i]<=0) {
  467.         w[i] = df_width;
  468.         isvoid = true;
  469.         }
  470.         switch (h_align[i]) {
  471.          case 'l': lf = 0; break;
  472.          case 'c': lf = (ws[i] - w[i])/2; 
  473.                break;
  474.          case 'r': lf = ws[i] - w[i]; break;
  475.         }
  476.         ww = (isvoid) ? lf: lf + w[i];
  477.         w[i] = lf + rg;
  478.         rg = ws[i] - ww + MATH_COLSEP;
  479.         if (cxrow==row) width += ws[i] + MATH_COLSEP;
  480.     }
  481.     cxrow->y -= ascent;
  482.     cxrow = cxrow->next;
  483.     }
  484. }
  485.  
  486. MathAccentInset::MathAccentInset(byte cx, MathedTextCodes f, int cd, short st): 
  487.   MathedInset("", LM_OT_ACCENT, st), c(cx), fn(f), code(cd)
  488. {
  489.     inset = 0;
  490. }
  491.  
  492. MathAccentInset::MathAccentInset(MathedInset *ins, int cd, short st):
  493.   MathedInset("", LM_OT_ACCENT, st), c(0), fn(LM_TC_MIN), code(cd), inset(ins)
  494. {
  495. }
  496.  
  497.  
  498. MathAccentInset::~MathAccentInset()
  499. {
  500.     if (inset)
  501.       delete inset;
  502. }
  503.  
  504. MathedInset *MathAccentInset::Clone()
  505. {   
  506.     MathAccentInset* p;
  507.     
  508.     if (inset) 
  509.       p = new MathAccentInset(inset->Clone(), code, GetStyle());
  510.     else
  511.       p = new MathAccentInset(c, fn, code, GetStyle());
  512.     
  513.     return p;
  514. }
  515.  
  516.  
  517. MathBigopInset::MathBigopInset(char const* name, int id, short st): 
  518.   MathedInset(name, LM_OT_BIGOP, st), sym(id)
  519. {
  520.    lims = -1;
  521. }
  522.  
  523. MathedInset *MathBigopInset::Clone()
  524. {   
  525.    MathBigopInset* p = new MathBigopInset(name, sym, GetStyle());
  526.    return p;
  527. }
  528.  
  529. MathDotsInset::MathDotsInset(char const* name, int id, short st):
  530.   MathedInset(name, LM_OT_DOTS, st), code(id)
  531. {
  532. }
  533.  
  534. MathedInset *MathDotsInset::Clone()
  535. {
  536.    MathDotsInset* p = new MathDotsInset(name, code, GetStyle());
  537.    return p;
  538. }     
  539.  
  540.