|
|
|
|
Quellcode-Bibliothek
© Kompilation durch diese Firma
[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]
Datei:
Sprache: Unknown
// -*- 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.29 Sekunden
(vorverarbeitet)
]
|
|
|
|
|
|
