Quelle math_defs.h Sprache: C

// -*- C++ -*-
/*
*  File:        math_defs.h
*  Purpose:     Math editor definitions
*  Author:      Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
*  Created:     January 1996
*  Description: Math paragraph and objects for a WYSIWYG math editor.
*
*  Dependencies: Xlib
*
*  Copyright: (c) 1996, 1997 Alejandro Aguilar Sierra
*
*   Version: 0.8beta, Mathed & Lyx project.
*
*   You are free to use and modify this code under the terms of
*   the GNU General Public Licence version 2 or later.
*
*/

#ifndef __MATH_DEFS__
#define __MATH_DEFS__

#ifdef __GNUG__
#pragma interface
#endif

#include <stdio.h>
#include "array.h"

///
#define MATH_ALIGN_LEFT    1
///
#define MATH_ALIGN_RIGHT   2
///
#define MATH_ALIGN_BOTTOM  4
///
#define MATH_ALIGN_TOP     8
///
#define MATH_COLSEP 8
///
#define MATH_ROWSEP 8

/// Standard Math Sizes (Math mode styles)
enum MathedStyles {
///
   LM_ST_DISPLAY=0,
   ///
   LM_ST_TEXT,
   ///
   LM_ST_SCRIPT,
   ///
   LM_ST_SCRIPTSCRIPT
};

/// Standard LaTeX Math Environments
enum MathedEnvironment {
///
   LM_EN_INTEXT=0,
   ///
   LM_EN_DISPLAY,
   ///
   LM_EN_EQUATION,
   ///
   LM_EN_EQNARRAYAST,
   ///
   LM_EN_EQNARRAY,
   ///
   LM_EN_ARRAY
};

/** The restrictions of a standard LaTeX math paragraph
  allows to get a small number of text codes (<30) */
enum MathedTextCodes  {
   /// This must be >= 0
   LM_TC_MIN = 0,
   /// Open and Close group
   LM_TC_OPEN,
   ///
   LM_TC_CLOSE,
   /// Tabulator
   LM_TC_TAB,
   /// New line
   LM_TC_CR,
   /// Math Inset
   LM_TC_INSET,
   /// Super and sub scripts
   LM_TC_UP,
   ///
   LM_TC_DOWN,
   /// Editable Math Inset
   LM_TC_ACTIVE_INSET,
   /// Editable Text Inset
   LM_TC_TEXT_INSET,
   ///
   LM_FONT_BEGIN,
   /// Internal code for constants
   LM_TC_CONST,
   /// Internal code for variables
   LM_TC_VAR,
   ///
   LM_TC_RM,
   ///
   LM_TC_CAL,
   ///
   LM_TC_BF,
   ///
   LM_TC_SF,
   ///
   LM_TC_TT,
   ///
   LM_TC_IT,
   ///
   LM_TC_TEXTRM,
   /// Math mode TeX characters ",;:{}"
   LM_TC_TEX,
   /// Special characters "{}&#_%"
   LM_TC_SPECIAL,
   /// Internal code for operators
   LM_TC_BOP,
   /// Internal code for symbols
   LM_TC_SYMB,
   ///
   LM_TC_BOPS,
   ///
   LM_TC_BSYM,
   ///
   LM_FONT_END,

   /// This must be < 32
   LM_TC_MAX
};

///
#define LM_TC_NORMAL LM_TC_VAR


/// Types of lyx-math insets
enum MathedInsetTypes  {
   ///
   LM_OT_MIN = 0,
   /// A simple paragraph
   LM_OT_PAR,
   /// A simple numbered paragraph
   LM_OT_PARN,
   /// A multiline paragraph
   LM_OT_MPAR,
   /// A multiline numbered paragraph
   LM_OT_MPARN,
   /// An array
   LM_OT_MATRIX,
   /// A big operator
   LM_OT_BIGOP,
   /// A LaTeX macro
   LM_OT_UNDEF,
   ///
   LM_OT_FUNC,
   ///
   LM_OT_FUNCLIM,
   ///
   LM_OT_SCRIPT,
   ///
   LM_OT_SPACE,
   ///
   LM_OT_DOTS,
   /// A fraction
   LM_OT_FRAC,
   ///
   LM_OT_ATOP,
   ///
   LM_OT_STACKREL,
   /// A radical
   LM_OT_SQRT,
   /// A delimiter
   LM_OT_DELIM,
   /// A decoration
   LM_OT_DECO,
   /// An accent
   LM_OT_ACCENT,
   ///
   LM_OT_MACRO,
   ///
   LM_OT_MACRO_ARG,
   ///
   LM_OT_MAX
};

///
enum MathedBinaryTypes {
///
    LMB_NONE = 0,
    ///
    LMB_RELATION,
    ///
    LMB_OPERATOR,
    ///
    LMB_BOP = (LMB_RELATION | LMB_OPERATOR)
};

class LString;
class MathedInset;
class MathParInset;

/** Abstract base class for all math objects.
    A math insets is for use of the math editor only, it isn't a
    general LyX inset. It's used to represent all the math objects.
    The formulaInset (a LyX inset) encapsulates a math inset.
*/
class MathedInset  {
public:
    /// A math inset has a name (usually its LaTeX name), type and font-size
    MathedInset(char const *nm, short ot, short st);
    ///
    MathedInset(MathedInset*);
    ///
    virtual ~MathedInset() { };

    /// Draw the object
    virtual void Draw(int x, int baseline)=0;

    /// Write LaTeX and Lyx code
    virtual void Write(FILE *file)=0;
    /// Write LaTeX and Lyx code
    virtual void Write(LString &file)=0;

    /// Reproduces itself
    virtual MathedInset *Clone()=0;

    /// Compute the size of the object
    virtual void Metrics()=0;
    ///
    virtual int Ascent() const { return ascent; }
    ///
    virtual int Descent() const { return descent; }
    ///
    virtual int Width() const { return width; }
    ///
    virtual int Height() const { return ascent + descent; }

    ///
    virtual bool GetLimits() const { return false; }
    ///
    virtual void SetLimits(bool) { }

    ///
    char const *GetName() const { return name; }
    ///
    short GetType() const { return objtype; }
    ///
    short GetStyle() const { return size; }

    //Man:  Avoid to use these functions if it's not strictly necessary
    ///
    virtual void  SetType(short t) { objtype = t; }
    ///
    virtual void  SetStyle(short st) { size = st; } // Metrics();
    ///
    virtual void  SetName(char const* n) { name = n; }
    ///
    void setDrawable(long unsigned int d) { pm = d; }

protected:
    ///
    char const *name;
    ///
    short objtype;
    ///
    int width;
    ///
    int ascent;
    ///
    int descent;
    ///
    short size;
    /// This works while only one process can draw unless
    /// the process have their own data
    static long unsigned int pm;
    /// Default metrics
    static int df_asc, df_des, df_width;

    /// In a near future maybe we use a better fonts renderer than X
    void drawStr(short, int, int, int, byte*, int);
///
    friend class MathedCursor;
///
    friend void mathed_init_fonts();
};

struct MathedRowSt;

/// Paragraph permissions
enum MathedParFlag {
    LMPF_BASIC = 0,
    /// If false can use a non-standard size
    LMPF_FIXED_SIZE = 1,
    /// If true can insert newlines
    LMPF_ALLOW_CR  = 2,
    /// If true can use tabs
    LMPF_ALLOW_TAB = 4,
    /// If true can insert new columns
    LMPF_ALLOW_NEW_COL = 8,
    /// Smaller than current size (frac)
    LMPF_SMALLER = 16,
    /// Script size (subscript, stackrel)
    LMPF_SCRIPT = 32
};

/** The math paragraph base class, base to all editable math objects */
class MathParInset: public MathedInset  {
public:
    ///
    MathParInset(short st=LM_ST_TEXT, char const *nm=NULL, short ot=LM_OT_MIN);
    ///
    MathParInset(MathParInset*);
    ///
    virtual ~MathParInset();
    ///
    virtual MathedInset *Clone();

    /// Draw the object on a drawable
    virtual void Draw(int x, int baseline);

    /// Write LaTeX code
    virtual void Write(FILE *file);
    /// Write LaTeX code
    virtual void Write(LString &file);
    ///
    virtual void Metrics();
    ///
    virtual void UserSetSize(short);

    /// Data is stored in a LyXArray
    virtual void SetData(LyxArrayBase *);
    ///
    virtual LyxArrayBase * GetData() { return array; }

    /// Paragraph position
    virtual void GetXY(int&, int&) const;
    ///
    virtual void setXY(int x, int y) { xo =x;  yo = y; }
    ///
    virtual void SetFocus(int,int) { };
    ///
    virtual bool Inside(int, int);

    // Tab stuff used by Matrix.
    ///
    virtual void SetAlign(char, char const*) { };
//    ///
//    virtual int GetTabPos() { return 0; }
//    ///
//    virtual int GetTab(int) { return 0; }
    ///
    virtual int GetColumns() { return 1; }
    ///
    virtual int GetRows() { return 1; }
    ///
    virtual bool isMatrix() { return false; }
//    /// These functions should report an error
//    virtual char const* GetLabel() { return 0; }
//    virtual char const* GetLabel(int) { return 0; }

    // Vertical switching
    ///
    virtual bool setArgumentIdx(int i) { return (i==0); }
    ///
    virtual bool setNextArgIdx() { return false; }
    ///
    virtual int  getArgumentIdx() { return 0; }
    ///
    virtual int  getMaxArgumentIdx() { return 0; }
//    ///
//    virtual void SetLabel(char const*) { }
    ///
    virtual void SetStyle(short);
///
    virtual MathedRowSt *getRowSt() const { return 0; }
///
    virtual void setRowSt(MathedRowSt*) { }
///
    virtual bool Permit(short f) { return (bool)(f & flag); }

protected:
    /// Paragraph data is stored here
    LyxArrayBase *array;
    /// Cursor start position
    int xo, yo;
    ///
    short flag;

private:
    ///
    virtual void setFlag(MathedParFlag f) { flag |= f; }
///
    friend class InsetFormula;
///
    friend class MathedXIter;
///
    friend class MathedCursor;
///
    friend LyxArrayBase *mathed_parse(unsigned flags = 0, LyxArrayBase*a=NULL, MathParInset**p=NULL);
};

/* The physical structure of a row and aditional information is stored here.
    It allows to manage the extra info independently of the paragraph data.
    Only used for multiline paragraphs.
*/
struct MathedRowSt {
    ///
    MathedRowSt(int n) {
     w = new int[n+1]; // this leaks
next = 0;
label = 0;
numbered = true;
    }
    ///
    ~MathedRowSt() {
delete[] w;
if (label) delete[] label;
    }
    /// Should be const but...
    MathedRowSt* getNext() const  { return next; }
    /// ...we couldn't use this.
    void setNext(MathedRowSt* n) { next = n; }
    ///
    char const* getLabel() const { return label; }
    ///
    bool isNumbered() const { return numbered; }
    ///
    int  getBaseline() const { return y; }
    ///
    int  getTab(int i) { return w[i]; }
    ///
    void setLabel(char* l) { label = l; }
    ///
    void setNumbered(bool nf) { numbered = nf; }
    ///
    void setTab(int i, int t) { w[i] = t; }

private:
    /// Vericals
    int asc, desc, y;
    /// widths
    int *w;
    ///
    char *label;
    ///
    bool numbered;
    ///
    MathedRowSt *next;
///
    friend class MathMatrixInset;
///
    friend class MathedXIter;
};

/** Multiline math paragraph base class.
    This is the base to all multiline editable math objects
    like array and eqnarray.
*/
class MathMatrixInset: public MathParInset {
public:
    ///
    MathMatrixInset(int m=1, int n=1, short st=LM_ST_TEXT);
    ///
    MathMatrixInset(MathMatrixInset*);
    ///
    MathedInset *Clone();
    ///
    virtual ~MathMatrixInset();
    ///
    void Draw(int, int);
    ///
    void Write(FILE *file);
    ///
    void Write(LString &file);
    ///
    void Metrics();
    ///
    void SetData(LyxArrayBase *);
    ///
    void SetAlign(char, char const*);
    ///
    char *GetAlign(char* vv) {
*vv = v_align;
return h_align;
    }
//    ///
//    int GetTab(int);
    ///
    int GetColumns() { return nc; }
    ///
    int GetRows() { return nr; }
    ///
    virtual bool isMatrix() { return true; }

    /// Use this to manage the extra information independently of paragraph
    MathedRowSt *getRowSt() const { return row; }
///
    void setRowSt(MathedRowSt* r) { row = r; }

protected:
    ///  Number of columns & rows
    int nc, nr;
    /// tab sizes
    int *ws;
    ///
    char v_align; // add approp. signedness
    ///
    char* h_align;
    /// Vertical structure
    MathedRowSt *row;

};

/*************************  Prototypes  **********************************/
///
LyxArrayBase *mathed_parse(unsigned flags, LyxArrayBase *data, MathParInset **mt);
///
void mathed_write(MathParInset*, FILE *, int*, char fragile, char const* label=NULL);
///
void mathed_write(MathParInset*, LString&, int*, char fragile, char const* label=NULL);
///
void mathed_parser_file(FILE*, int);
///
int mathed_parser_lineno();
///
int MathedLookupBOP(short);

/************************ Inline functions ********************************/

///
#define MathIsInset(x)  (LM_TC_INSET<=(x) && (x)<=LM_TC_ACTIVE_INSET)
///
#define MathIsFont(x)  (LM_TC_CONST<=(x) && (x)<=LM_TC_BSYM)
///
#define MathIsAlphaFont(x)  (LM_TC_VAR<=(x) && (x)<=LM_TC_TEXTRM)
///
#define MathIsActive(x)  (LM_TC_INSET<(x) && (x)<=LM_TC_ACTIVE_INSET)
///
#define MathIsUp(x)    ((x)==LM_TC_UP)
///
#define MathIsDown(x)  ((x)==LM_TC_DOWN)
///
#define MathIsScript(x)  ((x)==LM_TC_DOWN || (x)==LM_TC_UP)
///
#define MathIsBOPS(x)    (MathedLookupBOP(x)>LMB_NONE)

///
inline bool MathIsBinary(short x)
{
    return (x==LM_TC_BOP || x==LM_TC_BOPS);
}

///
inline bool MathIsSymbol(short x) {
    return (LM_TC_SYMB<=x && x<=LM_TC_BSYM);
}


inline
MathedInset::MathedInset(char const *nm, short ot, short st):
  name(nm), objtype(ot), size(st)
{
   width = ascent = descent = 0;
}

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

inline
void MathParInset::GetXY(int& x, int& y) const
{
   x = xo; y = yo;
}

inline
void MathParInset::UserSetSize(short sz)
{
   if (sz>=0) {
       size = sz;
       flag = flag & ~LMPF_FIXED_SIZE;
   }
}

inline
void MathParInset::SetStyle(short sz)
{
    if (Permit(LMPF_FIXED_SIZE)) {
if (Permit(LMPF_SCRIPT))
   sz = (sz<LM_ST_SCRIPT) ? LM_ST_SCRIPT: LM_ST_SCRIPTSCRIPT;
if (Permit(LMPF_SMALLER) && sz < LM_ST_SCRIPTSCRIPT) {
     sz++;
}
MathedInset::SetStyle(sz);
    }
}

#endif

quality98%

¤ Dauer der Verarbeitung: 0.27 Sekunden (vorverarbeitet) ¤

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.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.