Quellcode-Bibliothek

^© Kompilation durch diese Firma

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

Datei: Sprache: C

Original von: Lyx^©

// -*- C++ -*-
/*
*  File:        math_macro.C
*  Purpose:     Implementation of macro class for mathed
*  Author:      Alejandro Aguilar Sierra <[email protected]>
*  Created:     November 1996
*  Description: WYSIWYG math macros
*
*  Dependencies: Mathed
*
*  Copyright: (c) 1996, 1997 Alejandro Aguilar Sierra
*
*  Version: 0.2, Mathed & Lyx project.
*
*  This code is under the GNU General Public Licence version 2 or later.
*/

#include <config.h>
#include FORMS_H_LOCATION

#ifdef __GNUG__
#pragma implementation "math_macro.h"
#pragma implementation "math_defs.h"
#endif

#include "LString.h"
#include "math_macro.h"
#include "math_iter.h"
#include "math_inset.h"
#include "error.h"

enum MathedMacroFlag {
    MMF_Env=1,
    MMF_Exp=2,
    MMF_Edit=4
};

extern GC mathGC, mathFrameGC, latexGC;
extern int mathed_string_width(short type, int style, byte const* s, int ls);
extern int mathed_string_height(short, int, byte const*, int, int&, int&);

MathMacro::MathMacro(MathMacroTemplate* t):
    MathParInset(LM_ST_TEXT, "", LM_OT_MACRO), tmplate(t)
{
    nargs = tmplate->getNoArgs();
    tcode = tmplate->getTCode();
    args = new MacroArgumentBase[nargs];
    for (int i=0; i<nargs; i++) {
// if (tmplate->getMacroPar(i)->Permit(LMPF_ALLOW_CR))
//   args[i].row = new MathedRowSt(tmplate->getMacroPar(i)->GetColumns());
// else
   args[i].row = 0;
/* int k = tmplate->getMacroPar(i)->GetColumns();
if (k>0) {
    args[i].array = new LyxArrayBase;
    for (int j=0; j<k-1; j++) args[i].array->Insert(j, LM_TC_TAB);
}*/
    }
    idx = 0;
    SetName(tmplate->GetName());
}

MathMacro::MathMacro(MathMacro* m):
    MathParInset(LM_ST_TEXT, m->GetName(), LM_OT_MACRO)
{
    tmplate = m->tmplate;
    nargs = tmplate->getNoArgs();
    tcode = tmplate->getTCode();
    args = new MacroArgumentBase[nargs];
    idx = 0;
    SetName(tmplate->GetName());
    for (int i=0; i<tmplate->nargs; i++) {
m->setArgumentIdx(i);
MathedIter it(m->GetData());
args[i].row = m->args[i].row;
args[i].array = it.Copy();
    }
}

MathMacro::~MathMacro()
{
    for (idx=0; idx<nargs; idx++) {
MathedIter it(args[idx].array);
it. Clear();
delete args[idx].row;
    }
    delete[] args;
}

MathedInset *MathMacro::Clone()
{
    MathMacro *m = new MathMacro(this);
    return m;
}

void MathMacro::Metrics()
{
    if (nargs>0)
      tmplate->update(this);
    tmplate->Metrics();
    width = tmplate->Width();
    ascent = tmplate->Ascent();
    descent = tmplate->Descent();
}

void MathMacro::Draw(int x, int y)
{
    xo = x;  yo = y;
    Metrics();
    tmplate->update(this);
    tmplate->SetStyle(size);
    mathGC = latexGC;
    tmplate->Draw(x, y);
    for (int i=0; i<nargs; i++)
      tmplate->GetMacroXY(i, args[i].x, args[i].y);
}

int MathMacro::GetColumns()
{
    return tmplate->getMacroPar(idx)->GetColumns();
}

void MathMacro::GetXY(int& x, int& y) const
{
    x = args[idx].x;  y = args[idx].y;
}

bool MathMacro::Permit(short f)
{
    return ((nargs>0) ? tmplate->getMacroPar(idx)->Permit(f): MathParInset::Permit(f));
}

void MathMacro::SetFocus(int x, int y)
{
    tmplate->update(this);
    tmplate->SetMacroFocus(idx, x, y);
}

void MathMacro::Write(FILE *file)
{
   LString output;
   MathMacro::Write(output);
   fprintf(file, "%s", output.c_str());
}

void MathMacro::Write(LString &file)
{
    if (tmplate->flags & MMF_Exp) {
lyxerr.debug(LString("Expand ")+ int(tmplate->flags)
       + ' ' + int(MMF_Exp),
       Error::MATHED);
tmplate->update(this);
tmplate->Write(file);
    } else {
if (tmplate->flags & MMF_Env) {
   file += "\\begin{";
   file += name;
   file += "} ";
} else {
   file += '\\';
   file += name;
}
// if (options) {
//   file += '[';
//   file += options;
//   file += ']';
//      }

if (!(tmplate->flags & MMF_Env) && nargs>0)
   file += '{';

for (int i=0; i<nargs; i++) {
     array = args[i].array;
     MathParInset::Write(file);
     if (i<nargs-1)
       file += "}{";
}
if (tmplate->flags & MMF_Env) {
     file += "\\end{";
     file += name;
     file += '}';
} else {
     if (nargs>0)
         file += '}';
     else
         file += ' ';
}
    }
}

/*---------------  Macro argument -----------------------------------*/

MathMacroArgument::MathMacroArgument(int n)
{
    number = n;
    expnd_mode = false;
    SetType(LM_OT_MACRO_ARG);
}

void MathMacroArgument::Draw(int x, int baseline)
{
    if (expnd_mode) {
MathParInset::Draw(x, baseline);
    } else {
unsigned char s[3];
sprintf((char*)s, "#%d", number);
drawStr(LM_TC_TEX, size, x, baseline, &s[0], 2);
    }
}

void MathMacroArgument::Metrics()
{
    if (expnd_mode) {
MathParInset::Metrics();
    } else {
unsigned char s[3];
sprintf((char*)s, "#%d", number);
width = mathed_string_width(LM_TC_TEX, size, &s[0], 2);
mathed_string_height(LM_TC_TEX, size, &s[0], 2, ascent, descent);
    }
}

void MathMacroArgument::Write(FILE *file)
{
   LString output;
   MathMacroArgument::Write(output);
   fprintf(file, "%s", output.c_str());
}

void MathMacroArgument::Write(LString &file)
{
    if (expnd_mode) {
MathParInset::Write(file);
    } else {
file += '#';
file += number;
file += ' ';
    }
}

/* --------------------- MathMacroTemplate ---------------------------*/

MathMacroTemplate::MathMacroTemplate(char const *nm, int na, int flg):
    MathParInset(LM_ST_TEXT, nm, LM_OT_MACRO),
    flags(flg), nargs(na)
{
    if (nargs>0) {
tcode = LM_TC_ACTIVE_INSET;
args = new MathMacroArgument[nargs];
for (int i=0; i<nargs; i++) {
     args[i].setNumber(i+1);
}
    } else
      tcode = LM_TC_INSET;
}

MathMacroTemplate::~MathMacroTemplate()
{
    // prevent to delete already deleted objects
    for (int i=0; i<nargs; i++) {
args[i].SetData(0);
    }
    delete[] args;
}

void MathMacroTemplate::setEditMode(bool ed)
{
    if (ed) {
flags |= MMF_Edit;
for (int i=0; i<nargs; i++) {
     args[i].setExpand(false);
}
    } else {
flags &= ~MMF_Edit;
for (int i=0; i<nargs; i++) {
     args[i].setExpand(true);
}
    }
}

void MathMacroTemplate::Draw(int x, int y)
{
    int x2, y2;
    bool expnd = (nargs>0) ? args[0].getExpand(): false;
    if (flags & MMF_Edit) {
for (int i=0; i<nargs; i++) {
     args[i].setExpand(false);
}
      x2 = x; y2 = y;
    } else {
for (int i=0; i<nargs; i++) {
     args[i].setExpand(true);
}
      x2 = xo; y2 = yo;
    }
    MathParInset::Draw(x, y);
    xo = x2; yo = y2;

    for (int i=0; i<nargs; i++) {
args[i].setExpand(expnd);
    }
}

void MathMacroTemplate::Metrics()
{
    bool expnd = (nargs>0) ? args[0].getExpand(): false;

    if (flags & MMF_Edit) {
for (int i=0; i<nargs; i++) {
     args[i].setExpand(false);
}
    } else {
for (int i=0; i<nargs; i++) {
     args[i].setExpand(true);
}
    }
    MathParInset::Metrics();

    for (int i=0; i<nargs; i++) {
args[i].setExpand(expnd);
    }
}

void MathMacroTemplate::update(MathMacro* macro)
{
    int idx = (macro) ? macro->getArgumentIdx(): 0;
    for (int i=0; i<nargs; i++) {
if (macro) {
     macro->setArgumentIdx(i);
     args[i].SetData(macro->GetData());
     MathedRowSt *row = macro->getRowSt();
     args[i].setRowSt(row);
}
    }
    if (macro)
      macro->setArgumentIdx(idx);
}


void MathMacroTemplate::WriteDef(FILE *file)
{
    fprintf(file, "\n\\newcommand{\\%s}", name);

    if (nargs > 0 )
      fprintf(file, "[%d]", nargs);

    fprintf(file, "{");

    for (int i=0; i<nargs; i++) {
args[i].setExpand(false);
    }
    Write(file);
    fprintf(file, "}\n");
}

void MathMacroTemplate::WriteDef(LString &file)
{
    file += "\n\\newcommand{\\";
    file += name;
    file += '}';

    if (nargs > 0 ) {
      file += '[';
      file += nargs;
      file += ']';
    }

    file += '{';

    for (int i=0; i<nargs; i++) {
args[i].setExpand(false);
    }
    Write(file);
    file += "}\n";
}

void MathMacroTemplate::setArgument(LyxArrayBase *a, int i)
{
    args[i].SetData(a);
}

void MathMacroTemplate::GetMacroXY(int i, int& x, int& y) const
{
    args[i].GetXY(x, y);
}

MathParInset *MathMacroTemplate::getMacroPar(int i) const
{
    return ((i>=0 && i<nargs) ? (MathParInset*)&args[i]: 0);
}

void MathMacroTemplate::SetMacroFocus(int &idx, int x, int y)
{
    for (int i=0; i<nargs; i++) {
if (args[i].Inside(x, y)) {
     idx = i;
     break;
}
    }
}

/* -------------------------- MathMacroTable -----------------------*/

MathMacroTable::MathMacroTable(int n): max_macros(n)
{
    macro_table = new MathMacroTemplateP[max_macros];
    num_macros = 0;
}

MathMacroTable::~MathMacroTable()
{
    delete[] macro_table;
}

// The search is currently linear but will be binary or hash, later.
MathMacroTemplate *MathMacroTable::getTemplate(char const* name) const
{
    for (int i=0; i<num_macros; i++) {
      if (strcmp(name, macro_table[i]->GetName())==0)
return macro_table[i];
    }

    return 0;
}

void MathMacroTable::addTemplate(MathMacroTemplate *m)
{
    if (num_macros<max_macros)
      macro_table[num_macros++] = m;
    else
      lyxerr.print("Error (MathMacroTable::addTemplate): "
     "Macro table exhausted!");
}

// All this stuff aparently leaks because it's created here and is not
// deleted never, but it have to live all the LyX sesion. OK, would not
// so hard to do it in the MacroTable destructor, but this doesn't harm
// seriously, so don't bother me with purify results here.   ;-)

void MathMacroTable::builtinMacros()
{
    MathMacroTemplate *m;
    MathedIter iter;
    MathParInset* inset;// *arg;
    LyxArrayBase *array, *array2;

    built = true;

    lyxerr.debug("Building macros", Error::MATHED);

    // This macro doesn't have arguments
    m = new MathMacroTemplate("notin");  // this leaks
    addTemplate(m);
    array = new LyxArrayBase; // this leaks
    iter.SetData(array);
    iter.Insert(new MathAccentInset(LM_in, LM_TC_BOPS, LM_not)); // this leaks
    m->SetData(array);

    // These two are only while we are still with LyX 2.x
    m = new MathMacroTemplate("emptyset"); // this leaks
    addTemplate(m);
    array = new LyxArrayBase; // this leaks
    iter.SetData(array);
    iter.Insert(new MathAccentInset('O', LM_TC_RM, LM_not)); // this leaks
    m->SetData(array);

    m = new MathMacroTemplate("perp"); // this leaks
    addTemplate(m);
    array = new LyxArrayBase; // this leaks
    iter.SetData(array);
    iter.Insert(LM_bot, LM_TC_BOP);
    m->SetData(array);

    // binom has two arguments
    m = new MathMacroTemplate("binom", 2);
    addTemplate(m);
    array = new LyxArrayBase;
    m->SetData(array);
    iter.SetData(array);
    inset = new MathDelimInset('(', ')');
    iter.Insert(inset, LM_TC_ACTIVE_INSET);
    array = new LyxArrayBase;
    iter.SetData(array);
    MathFracInset *frac = new MathFracInset(LM_OT_ATOP);
    iter.Insert(frac, LM_TC_ACTIVE_INSET);
    inset->SetData(array);
    array = new LyxArrayBase;
    array2 = new LyxArrayBase;
    iter.SetData(array);
    iter.Insert(m->getMacroPar(0));
    iter.SetData(array2);
    iter.Insert(m->getMacroPar(1));
    frac->SetData(array, array2);

/*
    // Cases has 1 argument
    m = new MathMacroTemplate("cases", 1, MMF_Env); // this leaks
    addTemplate(m);
    array = new LyxArrayBase; // this leaks
    iter.SetData(array);
    arg = new MathMatrixInset(2,1); // this leaks

    m->setArgument(arg);
    arg->SetAlign('c',"ll");
    iter.Insert(arg, LM_TC_ACTIVE_INSET);
    inset = new MathDelimInset('{', '.'); // this leaks
    inset->SetData(array);
    array = new LyxArrayBase; // this leaks
    iter.SetData(array);
    iter.Insert(inset, LM_TC_ACTIVE_INSET);
    m->SetData(array);


    // the environment substack has 1 argument
    m = new MathMacroTemplate("substack", 1, MMF_Env); // this leaks
    addTemplate(m);
    arg = new MathMatrixInset(1,1); // this leaks
    m->setArgument(arg);
    arg->SetType(LM_OT_MACRO);
    array = new LyxArrayBase; // this leaks
    iter.SetData(array);
    iter.Insert(arg, LM_TC_ACTIVE_INSET);
    m->SetData(array);*/
}

MathMacroTable MathMacroTable::mathMTable(255);
bool  MathMacroTable::built = false;

¤ Dauer der Verarbeitung: 0.25 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.