Quellcode-Bibliothek

^© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: math_inset.C Sprache: C

Original von: Lyx^©

/*
*  File:        math_inset.C
*  Purpose:     Implementation of insets for mathed
*  Author:      Alejandro Aguilar Sierra <[email protected]>
*  Created:     January 1996
*  Description:
*
*  Dependencies: Xlib, XForms
*
*  Copyright: (c) 1996, 1997 Alejandro Aguilar Sierra
*
*   Version: 0.8beta.
*
*   You are free to use and modify this code under the terms of
*   the GNU General Public Licence version 2 or later.
*/

#include <config.h>

#ifdef __GNUG__
#pragma implementation "math_inset.h"
#endif

#include "math_iter.h"
#include "math_inset.h"
#include "symbol_def.h"

inline
char *strnew(char const* s)
{
   char *s1 = new char[strlen(s)+1];
   return strcpy(s1, s);
}

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;
   }
}

MathFuncInset::MathFuncInset(char const *nm, short ot, short st):
    MathedInset("", ot, st)
{
   ln = 0;
   lims = (GetType()==LM_OT_FUNCLIM);
    if (GetType()==LM_OT_UNDEF) {
fname = strnew(nm);
SetName(fname);
    } else {
fname = 0;
SetName(nm);
    }
}

MathedInset *MathFuncInset::Clone()
{
   MathedInset *l = new MathFuncInset(name, GetType(), GetStyle());
   return l;
}

MathSpaceInset::MathSpaceInset(int sp, short ot, short st):
    MathedInset("", ot, st), space(sp)
{
}

MathedInset *MathSpaceInset::Clone()
{
   MathedInset *l = new MathSpaceInset(space, GetType(), GetStyle());
   return l;
}

MathParInset::MathParInset(short st, char const *nm, short ot):
   MathedInset(nm, ot, st)
{
    array = 0;
    ascent = 8;
    width = 4;
    descent = 0;
    flag = 1;
    if (objtype==LM_OT_SCRIPT)
      flag |= LMPF_SCRIPT;
}

MathParInset::MathParInset(MathParInset* p): MathedInset(p)
{
    flag = p->flag;
    p->setArgumentIdx(0);
    MathedIter it(p->GetData());
    SetData(it.Copy());
}

MathParInset::~MathParInset()
{
   if (array) {
      MathedIter it(array);
      it.Clear();
      delete array;
   }
}

MathedInset *MathParInset::Clone()
{
   MathParInset* p = new MathParInset(this);
   return p;
}

void MathParInset::SetData(LyxArrayBase *a)
{
    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();
}
   }
}

MathSqrtInset::MathSqrtInset(short st): MathParInset(st, "sqrt", LM_OT_SQRT)
{
}

MathedInset *MathSqrtInset::Clone()
{
   MathSqrtInset* p = new MathSqrtInset(GetStyle());
   MathedIter it(array);
   p->SetData(it.Copy());
   return p;
}

bool MathSqrtInset::Inside(int x, int y)
{
    return (x>=xo-hmax && x<=xo+width-hmax && y<=yo+descent && y>=yo-ascent);
}

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;
}

MathDecorationInset::MathDecorationInset(int d, short st):
  MathParInset(st, "", LM_OT_DECO), deco(d)
{
   upper = (deco!=LM_underline && deco!=LM_underbrace);
}

MathedInset *MathDecorationInset::Clone()
{
   MathDecorationInset* p = new MathDecorationInset(deco, GetStyle());
   MathedIter it(array);
   p->SetData(it.Copy());
   return p;
}

MathFracInset::MathFracInset(short ot): MathParInset(LM_ST_TEXT, "frac", ot)
{

    den = new MathParInset(LM_ST_TEXT); // this leaks
    dh = 0;
    idx = 0;
    if (objtype==LM_OT_STACKREL) {
flag |= LMPF_SCRIPT;
SetName("stackrel");
    }
}

MathFracInset::~MathFracInset()
{
    delete den;
}

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 MathFracInset::setArgumentIdx(int i)
{
   if (i==0 || i==1) {
       idx = i;
       return true;
   } else
      return false;
}

void MathFracInset::SetStyle(short st)
{
    MathParInset::SetStyle(st);
    dh = 0;
    den->SetStyle((size==LM_ST_DISPLAY) ? (short)LM_ST_TEXT: size);
}

void MathFracInset::SetData(LyxArrayBase *n, LyxArrayBase *d)
{
   den->SetData(d);
   MathParInset::SetData(n);
}

void MathFracInset::SetData(LyxArrayBase *d)
{
   if (idx==0)
     MathParInset::SetData(d);
   else {
      den->SetData(d);
   }
}

void MathFracInset::GetXY(int& x, int& y) const
{
   if (idx==0)
     MathParInset::GetXY(x, y);
   else
     den->GetXY(x, y);
}

LyxArrayBase *MathFracInset::GetData()
{
   if (idx==0)
     return array;
   else
     return den->GetData();
}

bool MathFracInset::Inside(int x, int y)
{
    int xx = xo - (width-w0)/2;

    return (x>=xx && x<=xx+width && y<=yo+descent && y>=yo-ascent);
}

void MathFracInset::SetFocus(int /*x*/, int y)
{
//    fprintf(stderr, "y %d %d %d ", y, yo, den->yo);
    idx = (y > yo) ? 1: 0;
}

MathMatrixInset::MathMatrixInset(int m, int n, short st):
   MathParInset(st, "array", LM_OT_MATRIX), nc(m)
{
    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 i=1; i<n; i++) it.addRow();
nr = n;
if (nr==1 && nc>1) {
     for (int i=0; i<nc-1; i++)
       it.Insert('T', LM_TC_TAB);
}
    } else if (n<0) {
     row = new MathedRowSt(nc+1);
nr = 1;
    }
}

MathMatrixInset::MathMatrixInset(MathMatrixInset *mt):
   MathParInset(mt->GetStyle(), mt->GetName(), mt->GetType())
{
    nc = mt->nc;
    nr = mt->nr;
    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) {
MathedRowSt *r, *ro=0, *mrow = mt->row;
for (int i=0; i<nr; i++) {
     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;
}
    } else
      row = 0;
    flag = mt->flag;
}

MathMatrixInset::~MathMatrixInset()
{
    delete[] ws;

    MathedRowSt *r = row;
    while (r) {
MathedRowSt *q = r->next;
delete r;
r = q;
    }
}

MathedInset *MathMatrixInset::Clone()
{
    MathMatrixInset* mt = new MathMatrixInset(this);
    return mt;
}

void MathMatrixInset::SetAlign(char vv, char const* hh)
{
   v_align = vv;
   strncpy(h_align, hh, nc);
}

// Check the number of tabs and crs
void MathMatrixInset::SetData(LyxArrayBase *a)
{
    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;
}

void MathMatrixInset::Draw(int x, int baseline)
{
    MathParInset::Draw(x, baseline);
}

void MathMatrixInset::Metrics()
{
    int i, /*cy,*/ hl, h=0;
    MathedRowSt *cprow=0, *cxrow;

    if (!row) {
// fprintf(stderr, " 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;
    }
}

MathAccentInset::MathAccentInset(byte cx, MathedTextCodes f, int cd, short st):
  MathedInset("", LM_OT_ACCENT, st), c(cx), fn(f), code(cd)
{
    inset = 0;
}

MathAccentInset::MathAccentInset(MathedInset *ins, int cd, short st):
  MathedInset("", LM_OT_ACCENT, st), c(0), fn(LM_TC_MIN), code(cd), inset(ins)
{
}

MathAccentInset::~MathAccentInset()
{
    if (inset)
      delete inset;
}

MathedInset *MathAccentInset::Clone()
{
    MathAccentInset* p;

    if (inset)
      p = new MathAccentInset(inset->Clone(), code, GetStyle());
    else
      p = new MathAccentInset(c, fn, code, GetStyle());

    return p;
}

MathBigopInset::MathBigopInset(char const* name, int id, short st):
  MathedInset(name, LM_OT_BIGOP, st), sym(id)
{
   lims = -1;
}

MathedInset *MathBigopInset::Clone()
{
   MathBigopInset* p = new MathBigopInset(name, sym, GetStyle());
   return p;
}

MathDotsInset::MathDotsInset(char const* name, int id, short st):
  MathedInset(name, LM_OT_DOTS, st), code(id)
{
}

MathedInset *MathDotsInset::Clone()
{
   MathDotsInset* p = new MathDotsInset(name, code, GetStyle());
   return p;
}

¤ Dauer der Verarbeitung: 0.4 Sekunden (vorverarbeitet) ¤

Download des Quellennavigators
Download des sprechenden Kalenders
in der Quellcodebibliothek suchen

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.