Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/PVS/sets_aux/ (Beweissystem der NASA Version 6.0.9^©) Datei vom 28.9.2014 mit Größe 5 kB

Quellcode-Bibliothek math_macro.C Sprache: C

// -*- C++ -*-
/*
*  File:        math_macro.C
*  Purpose:     Implementation of macro class for mathed
*  Author:      Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
*  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;

quality93%

¤ 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.0.14Bemerkung: (vorverarbeitet) ¤

*Bot Zugriff

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

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.