X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2Fmath_inset.C;h=9bc23390677907a362a73df3f06b728794f56084;hb=2da8fcabdc695b8bb139d7252b923ef6b9aa29dd;hp=da543e7a25ec8b87bf41b2246fd400451f200f56;hpb=cfdd73ea94c3cc0058459d67b1c62fabd31fbeb1;p=lyx.git

diff --git a/src/mathed/math_inset.C b/src/mathed/math_inset.C
index da543e7a25..9bc2339067 100644
--- a/src/mathed/math_inset.C
+++ b/src/mathed/math_inset.C
@@ -7,7 +7,7 @@
  *
  *  Dependencies: Xlib, XForms
  *
- *  Copyright: (c) 1996, 1997 Alejandro Aguilar Sierra
+ *  Copyright: 1996, 1997 Alejandro Aguilar Sierra
  *
  *   Version: 0.8beta.
  *
@@ -15,550 +15,288 @@
  *   the GNU General Public Licence version 2 or later.
  */
 
-#include <config.h>
-
 #ifdef __GNUG__
-#pragma implementation "math_inset.h"
+#pragma implementation
 #endif
 
-#include "math_iter.h"
 #include "math_inset.h"
-#include "symbol_def.h"
+#include "debug.h"
 
 
-inline
-char * strnew(char const * s)
-{
-   char * s1 = new char[strlen(s)+1];
-   return strcpy(s1, s);
-}
+int MathInset::workwidth;
 
 
-MathedInset::MathedInset(MathedInset * inset) 
-{
-   if (inset) {
-      name = inset->GetName();
-      objtype = inset->GetType();
-      size = inset->GetStyle();
-      width = inset->Width();
-      ascent = inset->Ascent();
-      descent = inset->Descent();
-   } else {
-      objtype = LM_OT_UNDEF;
-      size = LM_ST_TEXT;
-      width = ascent = descent = 0;
-      name = 0;
-   }
-}
+MathInset::MathInset()
+	: size_(LM_ST_DISPLAY), xo_(0), yo_(0)
+{}
 
 
-MathFuncInset::MathFuncInset(char const * nm, short ot, short st)
-	: MathedInset("", ot, st)
+int MathInset::height() const
 {
-   ln = 0;
-   lims = (GetType() == LM_OT_FUNCLIM);
-    if (GetType() == LM_OT_UNDEF) {
-	fname = strnew(nm);
-	SetName(fname);
-    } else {
-	fname = 0;
-	SetName(nm);
-    }
+	return ascent() + descent();
 }
 
 
-MathedInset * MathFuncInset::Clone()
+MathStyles MathInset::size() const
 {
-   return new MathFuncInset(name, GetType(), GetStyle());
+	return size_;
 }
 
 
-MathSpaceInset::MathSpaceInset(int sp, short ot, short st)
-	: MathedInset("", ot, st), space(sp)
-{}
+void MathInset::size(MathStyles s) const
+{
+	size_ = s;
+}
 
 
-MathedInset * MathSpaceInset::Clone()
+std::ostream & operator<<(std::ostream & os, MathInset const & inset)
 {
-   return new MathSpaceInset(space, GetType(), GetStyle());
+	inset.write(os, false);
+	return os;
 }
 
 
-MathParInset::MathParInset(short st, char const * nm, short ot)
-	: MathedInset(nm, ot, st)
+int MathInset::xo() const
 {
-    array = 0;
-    ascent = 8;
-    width = 4;
-    descent = 0;
-    flag = 1;
-    if (objtype == LM_OT_SCRIPT)
-      flag |= LMPF_SCRIPT;
+	return xo_;
 }
 
 
-MathParInset::MathParInset(MathParInset * p)
-	: MathedInset(p)
+int MathInset::yo() const
 {
-    flag = p->flag;
-    p->setArgumentIdx(0);
-    MathedIter it(p->GetData());
-    SetData(it.Copy());
+	return yo_;
 }
 
 
-MathParInset::~MathParInset()
+void MathInset::xo(int x) const
 {
-   if (array) {
-      MathedIter it(array);
-      it.Clear();
-      delete array;
-   }
+	xo_ = x;
 }
 
 
-MathedInset * MathParInset::Clone()
+void MathInset::yo(int y) const
 {
-   return new MathParInset(this);
+	yo_ = y;
 }
 
 
-void MathParInset::SetData(LyxArrayBase * a)
+int MathInset::nargs() const
 {
-    array = a;
-   
-    // A standard paragraph shouldn't have any tabs nor CRs.
-    if (array) {
-	MathedIter it(array);
-	while (it.OK()) {
-	    char c = it.GetChar();
-	    if (c == LM_TC_TAB || c == LM_TC_CR) 
-	      it.Delete();
-	    else
-	      it.Next();
-	}
-   }
+	return 0;
 }
 
 
-MathSqrtInset::MathSqrtInset(short st)
-	: MathParInset(st, "sqrt", LM_OT_SQRT) {}
+MathXArray dummyCell;
 
-
-MathedInset * MathSqrtInset::Clone()
-{   
-   MathSqrtInset * p = new MathSqrtInset(GetStyle());
-   MathedIter it(array);
-   p->SetData(it.Copy());
-   return p;
+MathXArray & MathInset::xcell(int)
+{
+	lyxerr << "I don't have a cell\n";
+	return dummyCell;
 }
 
 
-bool MathSqrtInset::Inside(int x, int y) 
+MathXArray const & MathInset::xcell(int) const
 {
-	return x >= xo - hmax
-		&& x <= xo + width - hmax
-		&& y <= yo + descent
-		&& y >= yo - ascent;
+	lyxerr << "I don't have a cell\n";
+	return dummyCell;
 }
 
 
-MathDelimInset::MathDelimInset(int l, int r, short st)
-	: MathParInset(st, "", LM_OT_DELIM), left(l), right(r) {}
-
-
-MathedInset * MathDelimInset::Clone()
-{   
-   MathDelimInset * p = new MathDelimInset(left, right, GetStyle());
-   MathedIter it(array);
-   p->SetData(it.Copy());
-   return p;
+MathArray & MathInset::cell(int)
+{
+	lyxerr << "I don't have a cell\n";
+	return dummyCell.data_;
 }
 
 
-MathDecorationInset::MathDecorationInset(int d, short st)
-	: MathParInset(st, "", LM_OT_DECO), deco(d)
+MathArray const & MathInset::cell(int) const
 {
-   upper = (deco!= LM_underline && deco!= LM_underbrace);
+	lyxerr << "I don't have a cell\n";
+	return dummyCell.data_;
 }
 
 
-MathedInset * MathDecorationInset::Clone()
-{   
-   MathDecorationInset * p = new MathDecorationInset(deco, GetStyle());
-   MathedIter it(array);
-   p->SetData(it.Copy());
-   return p;
+void MathInset::substitute(MathArray & array, MathMacro const &) const
+{
+	array.push_back(clone());
 }
 
 
-MathFracInset::MathFracInset(short ot)
-	: MathParInset(LM_ST_TEXT, "frac", ot)
+bool MathInset::idxNext(int &, int &) const
 {
-	
-    den = new MathParInset(LM_ST_TEXT); // this leaks
-    dh = 0;
-    idx = 0;
-    if (objtype == LM_OT_STACKREL) {
-	flag |= LMPF_SCRIPT;
-	SetName("stackrel");
-    }
+	return false;
 }
 
 
-MathFracInset::~MathFracInset()
+bool MathInset::idxRight(int &, int &) const
 {
-    delete den;
+	return false;
 }
 
 
-MathedInset * MathFracInset::Clone()
-{   
-    MathFracInset * p = new MathFracInset(GetType());
-    MathedIter itn(array);
-    MathedIter itd(den->GetData());
-    p->SetData(itn.Copy(), itd.Copy());
-    p->idx = idx;
-    p->dh = dh;
-   return p;
+bool MathInset::idxPrev(int &, int &) const
+{
+	return false;
 }
 
 
-bool MathFracInset::setArgumentIdx(int i)
+bool MathInset::idxLeft(int &, int &) const
 {
-   if (i == 0 || i == 1) {
-       idx = i;
-       return true;
-   } else 
-      return false;
+	return false;
 }
 
 
-void MathFracInset::SetStyle(short st)
+bool MathInset::idxUp(int &, int &) const
 {
-    MathParInset::SetStyle(st);
-    dh = 0;
-    den->SetStyle((size == LM_ST_DISPLAY) ?
-		  static_cast<short>(LM_ST_TEXT)
-		  : size);
+	return false;
 }
 
 
-void MathFracInset::SetData(LyxArrayBase * n, LyxArrayBase * d)
+bool MathInset::idxDown(int &, int &) const
 {
-   den->SetData(d);
-   MathParInset::SetData(n);
+	return false;
 }
 
 
-void MathFracInset::SetData(LyxArrayBase * d)
+bool MathInset::idxFirst(int &, int &) const
 {
-   if (idx == 0)
-     MathParInset::SetData(d);
-   else {
-      den->SetData(d);
-   }
+	return false;
 }
 
 
-void MathFracInset::GetXY(int & x, int & y) const
-{  
-   if (idx == 0)
-     MathParInset::GetXY(x, y);
-   else
-     den->GetXY(x, y);
+bool MathInset::idxLast(int &, int &) const
+{
+	return false;
 }
 
 
-LyxArrayBase * MathFracInset::GetData()
+bool MathInset::idxHome(int &, int &) const
 {
-   if (idx == 0)
-     return array;
-   else
-     return den->GetData();
+	return false;
 }
 
 
-bool MathFracInset::Inside(int x, int y) 
+bool MathInset::idxEnd(int &, int &) const
 {
-    int xx = xo - (width - w0) / 2;
-    
-    return x >= xx && x <= xx + width && y <= yo + descent && y >= yo - ascent;
+	return false;
 }
 
 
-void MathFracInset::SetFocus(int /*x*/, int y)
-{  
-//    lyxerr << "y " << y << " " << yo << " " << den->yo << " ";
-    idx = (y > yo) ? 1: 0;
+bool MathInset::idxFirstUp(int &, int &) const
+{
+	return false;
 }
 
 
-MathMatrixInset::MathMatrixInset(int m, int n, short st)
-	: MathParInset(st, "array", LM_OT_MATRIX), nc(m)
+bool MathInset::idxFirstDown(int &, int &) const
 {
-    ws = new int[nc]; 
-    v_align = 0;
-    h_align = new char[nc + 1];
-    for (int i = 0; i < nc; ++i) h_align[i] = 'c'; 
-    h_align[nc] = '\0';
-    nr = 0;
-    row = 0;
-    flag = 15;
-    if (n > 0) {
-	    row = new MathedRowSt(nc+1);
-	MathedXIter it(this);
-	for (int j = 1; j < n; ++j) it.addRow();
-	nr = n;
-	if (nr == 1 && nc > 1) {
-	    for (int j = 0; j < nc - 1; ++j) 
-	      it.Insert('T', LM_TC_TAB);
-	}
-    } else if (n < 0) {
-	    row = new MathedRowSt(nc + 1);
-	nr = 1;
-    }
+	return false;
 }
 
 
-MathMatrixInset::MathMatrixInset(MathMatrixInset * mt)
-	: MathParInset(mt->GetStyle(), mt->GetName(), mt->GetType())
+void MathInset::idxDelete(int &, bool & popit, bool & deleteit)
 {
-	nr = 0;
-    nc = mt->nc;
-    ws = new int[nc];
-    h_align = new char[nc + 1];
-    strcpy(h_align, mt->GetAlign(&v_align));
-    MathedIter it;
-    it.SetData(mt->GetData());
-    array = it.Copy();
-    if (mt->row != 0) {
-	MathedRowSt * r, * ro= 0, * mrow = mt->row;
-	//mrow = mt->row; // This must be redundant...
-	while (mrow) {
-	    r = new MathedRowSt(nc + 1);
-	    r->numbered = mrow->numbered;
-	    if (mrow->label) 
-	      r->label = strnew(mrow->label);
-	    if (!ro) 
-	      row = r;
-	    else
-	      ro->next = r;
-	    mrow = mrow->next;
-	    ro = r;
-	    ++nr;
-	} 
-    } else         
-      row = 0;
-    flag = mt->flag;
+	popit    = false;
+	deleteit = false;
 }
 
 
-MathMatrixInset::~MathMatrixInset()
-{
-    delete[] ws;
-    
-    MathedRowSt * r = row;
-    while (r) {
-	MathedRowSt * q = r->next;
-	delete r;
-	r = q;
-    }
-}
+void MathInset::idxDeleteRange(int, int)
+{}
 
 
-MathedInset * MathMatrixInset::Clone()
+bool MathInset::idxLastUp(int &, int &) const
 {
-    return new MathMatrixInset(this);
+	return false;
 }
 
 
-void MathMatrixInset::SetAlign(char vv, char const * hh)
+bool MathInset::idxLastDown(int &, int &) const
 {
-   v_align = vv;
-   strncpy(h_align, hh, nc);
+	return false;
 }
 
 
-// Check the number of tabs and crs
-void MathMatrixInset::SetData(LyxArrayBase * a)
+void MathInset::getXY(int & x, int & y) const
 {
-    if (!a) return;
-    MathedIter it(a);
-    int nn = nc - 1;
-    nr = 1;
-    // count tabs per row
-    while (it.OK()) {
-	if (it.IsTab()) {
-	    if (nn < 0) { 
-		it.Delete();
-		continue;
-	    } else {
-//	      it.Next();
-		--nn;
-	    }
-	}
-	if (it.IsCR()) {
-	    while (nn > 0) {
-		it.Insert(' ', LM_TC_TAB);
-		--nn;
-	    }
-	    nn = nc - 1;
-	    ++nr;
-	}
-	it.Next();
-    }
-    it.Reset();
-
-    // Automatically inserts tabs around bops
-    // DISABLED because it's very easy to insert tabs 
-    array = a;
+   x = xo();
+   y = yo();
 }
 
 
-#ifdef USE_PAINTER
-void MathMatrixInset::draw(Painter & pain, int x, int baseline)
+/*
+void MathInset::userSetSize(MathStyles sz)
 {
-    MathParInset::draw(pain, x, baseline);
+	if (sz >= 0) {
+		size_ = sz;      
+		flag = flag & ~LMPF_FIXED_SIZE;
+	}
 }
-#else
-void MathMatrixInset::Draw(int x, int baseline)
+*/
+
+void MathInset::writeNormal(std::ostream & os) const
 {
-    MathParInset::Draw(x, baseline);
+	os << "[unknown] ";
 }
-#endif
 
 
-void MathMatrixInset::Metrics()
-{
-    int i, hl, h= 0;
-    MathedRowSt * cprow= 0, * cxrow;
-
-    if (!row) {
-//	lyxerr << " MIDA ";
-	MathedXIter it(this);
-	row = it.adjustVerticalSt();
-    } 
-    
-    // Clean the arrays      
-    cxrow = row;
-    while (cxrow) {   
-	for (i = 0; i <= nc; ++i) cxrow->w[i] = 0;
-	cxrow = cxrow->next;
-    }
-    
-    // Basic metrics
-    MathParInset::Metrics();
-	    
-    if (nc <= 1 && !row->next) {
-	row->asc = ascent;
-	row->desc = descent;
-    }
-    
-    // Vertical positions of each row
-    cxrow = row;     
-    while (cxrow) {
-	for (i = 0; i < nc; ++i) {
-	    if (cxrow == row || ws[i]<cxrow->w[i]) ws[i]= cxrow->w[i];
-	    if (cxrow->next == 0 && ws[i] == 0) ws[i] = df_width;
-	}
-	
-	cxrow->y = (cxrow == row) ? cxrow->asc:
-	           cxrow->asc + cprow->desc + MATH_ROWSEP + cprow->y;
-	h += cxrow->asc + cxrow->desc + MATH_ROWSEP; 	
-	cprow = cxrow;
-	cxrow = cxrow->next;
-    }
-    
-    hl = Descent();
-    h -= MATH_ROWSEP;
-
-    //  Compute vertical align
-    switch (v_align) {
-     case 't': ascent = row->y; break;
-     case 'b': ascent = h - hl; break;
-     default:  ascent = (row->next) ? h / 2: h - hl; break;
-    }
-    descent = h - ascent + 2;
-    
-   
-   // Adjust local tabs
-    cxrow = row;
-    width = MATH_COLSEP;
-    while (cxrow) {   
-	int rg = MATH_COLSEP, ww, lf = 0, * w = cxrow->w;
-	for (i = 0; i < nc; ++i) {
-	    bool isvoid = false;
-	    if (w[i] <= 0) {
-		w[i] = df_width;
-		isvoid = true;
-	    }
-	    switch (h_align[i]) {
-	     case 'l': lf = 0; break;
-	     case 'c': lf = (ws[i] - w[i])/2; 
-		       break;
-	     case 'r': lf = ws[i] - w[i]; break;
-	    }
-	    ww = (isvoid) ? lf: lf + w[i];
-	    w[i] = lf + rg;
-	    rg = ws[i] - ww + MATH_COLSEP;
-	    if (cxrow == row) width += ws[i] + MATH_COLSEP;
-	}
-	cxrow->y -= ascent;
-	cxrow = cxrow->next;
-    }
+void MathInset::dump() const
+{
+	lyxerr << "---------------------------------------------\n";
+	write(lyxerr, false);
+	lyxerr << "\n---------------------------------------------\n";
 }
 
 
-MathAccentInset::MathAccentInset(byte cx, MathedTextCodes f, int cd, short st)
-	: MathedInset("", LM_OT_ACCENT, st), c(cx), fn(f), code(cd)
+void MathInset::push_back(unsigned char, MathTextCodes)
 {
-    inset = 0;
+	lyxerr << "can't push without a cell\n";
 }
 
 
-MathAccentInset::MathAccentInset(MathedInset *ins, int cd, short st)
-	: MathedInset("", LM_OT_ACCENT, st),
-	  c(0), fn(LM_TC_MIN), code(cd), inset(ins) {}
+void MathInset::push_back(MathInset *)
+{
+	lyxerr << "can't push without a cell\n";
+}
 
 
-MathAccentInset::~MathAccentInset()
+bool MathInset::covers(int x, int y) const
 {
-	delete inset;
+	return
+		x >= xo_ &&
+		x <= xo_ + width() &&
+		y >= yo_ - ascent() &&
+		y <= yo_ + descent();
 }
 
 
-MathedInset * MathAccentInset::Clone()
-{   
-    MathAccentInset * p;
-    
-    if (inset) 
-      p = new MathAccentInset(inset->Clone(), code, GetStyle());
-    else
-      p = new MathAccentInset(c, fn, code, GetStyle());
-    
-    return p;
-}
+void MathInset::validate(LaTeXFeatures &) const
+{}
 
 
-MathBigopInset::MathBigopInset(char const* nam, int id, short st)
-	: MathedInset(nam, LM_OT_BIGOP, st), sym(id)
+std::vector<int> MathInset::idxBetween(int from, int to) const
 {
-   lims = -1;
+	std::vector<int> res;
+	for (int i = from; i <= to; ++i)
+		res.push_back(i);
+	return res;
 }
 
 
-MathedInset * MathBigopInset::Clone()
+void MathInset::metrics(MathStyles st) const
 {
-   return new MathBigopInset(name, sym, GetStyle());
+	lyxerr << "MathInset::metrics() called directly!\n";
+	size_ = st;
 }
 
 
-MathDotsInset::MathDotsInset(char const * nam, int id, short st)
-	: MathedInset(nam, LM_OT_DOTS, st), code(id) {}
+void MathInset::draw(Painter &, int, int) const
+{
+	lyxerr << "MathInset::draw() called directly!\n";
+}
 
 
-MathedInset * MathDotsInset::Clone()
+void MathInset::write(std::ostream &, bool) const
 {
-   return new MathDotsInset(name, code, GetStyle());
-}     
+	lyxerr << "MathInset::write() called directly!\n";
+}