home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / math_defs.h < prev    next >
C/C++ Source or Header  |  1998-04-23  |  13KB  |  554 lines
  1. // -*- C++ -*-
  2. /*
  3.  *  File:        math_defs.h
  4.  *  Purpose:     Math editor definitions 
  5.  *  Author:      Alejandro Aguilar Sierra <asierra@servidor.unam.mx> 
  6.  *  Created:     January 1996
  7.  *  Description: Math paragraph and objects for a WYSIWYG math editor.
  8.  *
  9.  *  Dependencies: Xlib
  10.  *
  11.  *  Copyright: (c) 1996, 1997 Alejandro Aguilar Sierra
  12.  *
  13.  *   Version: 0.8beta, Mathed & Lyx project.
  14.  *
  15.  *   You are free to use and modify this code under the terms of
  16.  *   the GNU General Public Licence version 2 or later.
  17.  * 
  18.  */
  19.  
  20. #ifndef __MATH_DEFS__
  21. #define __MATH_DEFS__
  22.  
  23. #ifdef __GNUG__
  24. #pragma interface
  25. #endif
  26.  
  27. #include <stdio.h>
  28. #include "array.h"
  29.  
  30. ///
  31. #define MATH_ALIGN_LEFT    1
  32. ///
  33. #define MATH_ALIGN_RIGHT   2
  34. ///
  35. #define MATH_ALIGN_BOTTOM  4
  36. ///
  37. #define MATH_ALIGN_TOP     8
  38. ///
  39. #define MATH_COLSEP 8
  40. ///
  41. #define MATH_ROWSEP 8
  42.  
  43.  
  44. /// Standard Math Sizes (Math mode styles)
  45. enum MathedStyles {
  46.    LM_ST_DISPLAY=0,
  47.    LM_ST_TEXT,
  48.    LM_ST_SCRIPT,
  49.    LM_ST_SCRIPTSCRIPT
  50. };
  51.  
  52.  
  53. /// Standard LaTeX Math Environments
  54. enum MathedEnvironment {
  55.    LM_EN_INTEXT=0,
  56.    LM_EN_DISPLAY,
  57.    LM_EN_EQUATION,
  58.    LM_EN_EQNARRAYAST,
  59.    LM_EN_EQNARRAY,
  60.    LM_EN_ARRAY
  61. };
  62.  
  63. ///
  64. /** The restrictions of a standard LaTeX math paragraph
  65.   allows to get a small number of text codes (<30) */
  66. enum MathedTextCodes  {      
  67.    LM_TC_MIN = 0,              //  This must be >= 0
  68.    LM_TC_OPEN,                 //  Open and Close group
  69.    LM_TC_CLOSE,
  70.    LM_TC_TAB,                  //  Tabulator
  71.    LM_TC_CR,                   //  New line  
  72.    LM_TC_INSET,                   //  Math Inset
  73.    LM_TC_UP,                   //  Super and sub scripts
  74.    LM_TC_DOWN,
  75.    LM_TC_ACTIVE_INSET,         //  Editable Math Inset
  76.    LM_TC_TEXT_INSET,           //  Editable Text Inset
  77.    LM_FONT_BEGIN, 
  78.    LM_TC_CONST,                //  Internal code for constants
  79.    LM_TC_VAR,                  //  Internal code for variables   
  80.    LM_TC_RM,
  81.    LM_TC_CAL,
  82.    LM_TC_BF,
  83.    LM_TC_SF,
  84.    LM_TC_TT,
  85.    LM_TC_IT,
  86.    LM_TC_TEXTRM,
  87.    LM_TC_TEX,                //  Math mode TeX characters ",;:{}"
  88.    LM_TC_SPECIAL,            //  Special characters "{}&#_%"
  89.    LM_TC_BOP,                //  Internal code for operators  
  90.    LM_TC_SYMB,                 //  Internal code for symbols
  91.    LM_TC_BOPS,
  92.    LM_TC_BSYM,
  93.    LM_FONT_END,
  94.     
  95.    LM_TC_MAX                   //  This must be < 32 
  96. };
  97.  
  98. ///
  99. #define LM_TC_NORMAL LM_TC_VAR
  100.  
  101.        
  102. /// Types of lyx-math insets 
  103. enum MathedInsetTypes  {
  104.    LM_OT_MIN = 0,
  105.    LM_OT_PAR,           // A simple paragraph
  106.    LM_OT_PARN,           // A simple numbered paragraph
  107.    LM_OT_MPAR,          // A multiline paragraph
  108.    LM_OT_MPARN,          // A multiline numbered paragraph
  109.    LM_OT_MATRIX,    // An array
  110.    LM_OT_BIGOP,        // A big operator
  111.    LM_OT_UNDEF,         // A LaTeX macro
  112.    LM_OT_FUNC,
  113.    LM_OT_FUNCLIM,
  114.    LM_OT_SCRIPT,
  115.    LM_OT_SPACE,
  116.    LM_OT_DOTS,
  117.    LM_OT_FRAC,        // A fraction
  118.    LM_OT_ATOP,
  119.    LM_OT_STACKREL,
  120.    LM_OT_SQRT,        // A radical
  121.    LM_OT_DELIM,        // A delimiter
  122.    LM_OT_DECO,        // A decoration
  123.    LM_OT_ACCENT,        // An accent
  124.    LM_OT_MACRO,
  125.    LM_OT_MACRO_ARG,
  126.    LM_OT_MAX
  127. };
  128.  
  129. ///
  130. enum MathedBinaryTypes {
  131.     LMB_NONE = 0,
  132.     LMB_RELATION,
  133.     LMB_OPERATOR,
  134.     LMB_BOP = (LMB_RELATION | LMB_OPERATOR)
  135. };
  136.  
  137. class LString;
  138. class MathedInset;
  139. class MathParInset;
  140.  
  141.  
  142. /// Abstract base class for all math objects. 
  143. /**
  144.     A math insets is for use of the math editor only, it isn't a
  145.     general LyX inset. It's used to represent all the math objects.
  146.     The formulaInset (a LyX inset) encapsulates a math inset.
  147.  */
  148. class MathedInset  {
  149.  public: 
  150.     /// A math inset has a name (usually its LaTeX name), type and font-size
  151.     MathedInset(char const *nm, short ot, short st);
  152.     ///
  153.     MathedInset(MathedInset*);
  154.     ///
  155.     virtual ~MathedInset() { };
  156.     
  157.     /// Draw the object 
  158.     virtual void Draw(int x, int baseline)=0;
  159.     
  160.     /// Write LaTeX and Lyx code
  161.     virtual void Write(FILE *file)=0;
  162.     /// Write LaTeX and Lyx code
  163.     virtual void Write(LString &file)=0;
  164.    
  165.     /// Reproduces itself
  166.     virtual MathedInset *Clone()=0;
  167.    
  168.     /// Compute the size of the object
  169.     virtual void Metrics()=0; 
  170.     /// 
  171.     virtual int Ascent() const { return ascent; }
  172.     ///
  173.     virtual int Descent() const { return descent; }
  174.     ///
  175.     virtual int Width() const { return width; }
  176.     ///
  177.     virtual int Height() const { return ascent + descent; }
  178.     
  179.     ///
  180.     virtual bool GetLimits() const { return false; }
  181.     ///
  182.     virtual void SetLimits(bool) { }   
  183.    
  184.     ///
  185.     char const *GetName() const { return name; }
  186.     ///
  187.     short GetType() const { return objtype; }
  188.     ///
  189.     short GetStyle() const { return size; }
  190.           
  191.     //Man:  Avoid to use these functions if it's not strictly necessary 
  192.     ///
  193.     virtual void  SetType(short t) { objtype = t; }
  194.     ///
  195.     virtual void  SetStyle(short st) { size = st; }// Metrics(); }
  196.     ///
  197.     virtual void  SetName(char const* n) { name = n; }
  198.     /// 
  199.     void setDrawable(long unsigned int d) { pm = d; }
  200.  
  201.  protected:
  202.     ///
  203.     char const *name;
  204.     ///
  205.     short objtype;
  206.     ///
  207.     int width;
  208.     ///
  209.     int ascent;
  210.     ///
  211.     int descent;
  212.     ///
  213.     short size;
  214.     /// This works while only one process can draw unless
  215.     /// the process have their own data
  216.     static long unsigned int pm;
  217.     /// Default metrics
  218.     static int df_asc, df_des, df_width;
  219.  
  220.     /// In a near future maybe we use a better fonts renderer than X
  221.     void drawStr(short, int, int, int, byte*, int);
  222.     ///
  223.     friend class MathedCursor;
  224.     ///
  225.     friend void mathed_init_fonts();
  226. };
  227.  
  228. struct MathedRowSt;
  229.  
  230.  
  231. /// Paragraph permissions
  232. enum MathedParFlag {
  233.     LMPF_BASIC = 0,
  234.     /// If false can use a non-standard size
  235.     LMPF_FIXED_SIZE = 1,
  236.     /// If true can insert newlines 
  237.     LMPF_ALLOW_CR  = 2,
  238.     /// If true can use tabs
  239.     LMPF_ALLOW_TAB = 4,
  240.     /// If true can insert new columns
  241.     LMPF_ALLOW_NEW_COL = 8,
  242.     /// Smaller than current size (frac)
  243.     LMPF_SMALLER = 16,
  244.     /// Script size (subscript, stackrel)
  245.     LMPF_SCRIPT = 32
  246. };
  247.  
  248.  
  249. /// The math paragraph base class. 
  250. /** This is the base to all editable math objects */
  251. class MathParInset: public MathedInset  {
  252.  public: 
  253.     ///
  254.     MathParInset(short st=LM_ST_TEXT, char const *nm=NULL, short ot=LM_OT_MIN);
  255.     ///
  256.     MathParInset(MathParInset*);
  257.     ///
  258.     virtual ~MathParInset();
  259.     ///
  260.     virtual MathedInset *Clone();   
  261.  
  262.     /// Draw the object on a drawable
  263.     virtual void Draw(int x, int baseline);
  264.    
  265.     /// Write LaTeX code
  266.     virtual void Write(FILE *file);
  267.     /// Write LaTeX code
  268.     virtual void Write(LString &file);
  269.     ///
  270.     virtual void Metrics();
  271.     ///
  272.     virtual void UserSetSize(short);
  273.  
  274.     /// Data is stored in a LyXArray
  275.     virtual void SetData(LyxArrayBase *);
  276.     ///
  277.     virtual LyxArrayBase * GetData() { return array; }
  278.  
  279.     /// Paragraph position
  280.     virtual void GetXY(int&, int&) const;
  281.     ///
  282.     virtual void setXY(int x, int y) { xo =x;  yo = y; }
  283.     ///
  284.     virtual void SetFocus(int,int) { };
  285.     ///
  286.     virtual bool Inside(int, int);   
  287.    
  288.     // Tab stuff used by Matrix.
  289.     ///
  290.     virtual void SetAlign(char, char const*) { };
  291. //    ///
  292. //    virtual int GetTabPos() { return 0; }
  293. //    ///
  294. //    virtual int GetTab(int) { return 0; }
  295.     ///
  296.     virtual int GetColumns() { return 1; }
  297.     ///
  298.     virtual int GetRows() { return 1; }
  299.     ///
  300.     virtual bool isMatrix() { return false; }
  301. //    /// These functions should report an error
  302. //    virtual char const* GetLabel() { return 0; }
  303. //    virtual char const* GetLabel(int) { return 0; }
  304.  
  305.     // Vertical switching
  306.     ///
  307.     virtual bool setArgumentIdx(int i) { return (i==0); }
  308.     ///
  309.     virtual bool setNextArgIdx() { return false; }
  310.     ///
  311.     virtual int  getArgumentIdx() { return 0; }
  312.     ///
  313.     virtual int  getMaxArgumentIdx() { return 0; }
  314. //    ///
  315. //    virtual void SetLabel(char const*) { }
  316.     ///
  317.     virtual void SetStyle(short);
  318.     ///
  319.     virtual MathedRowSt *getRowSt() const { return 0; }
  320.     ///
  321.     virtual void setRowSt(MathedRowSt*) { }
  322.     ///
  323.     virtual bool Permit(short f) { return (bool)(f & flag); }
  324.     
  325.  protected:
  326.     /// Paragraph data is stored here
  327.     LyxArrayBase *array;
  328.     /// Cursor start position
  329.     int xo, yo;
  330.     /// 
  331.     short flag;
  332.  
  333.  private:
  334.     ///
  335.     virtual void setFlag(MathedParFlag f) { flag |= f; }
  336.     ///
  337.     friend class InsetFormula;
  338.     ///
  339.     friend class MathedXIter;
  340.     ///
  341.     friend class MathedCursor;
  342.     ///
  343.     friend LyxArrayBase *mathed_parse(unsigned flags = 0, LyxArrayBase*a=NULL, MathParInset**p=NULL);
  344. };
  345.  
  346.  
  347.  
  348. // The physical structure of a row and aditional information is stored here
  349. /* The physical structure of a row and aditional information is stored here.
  350.     It allows to manage the extra info independently of the paragraph data.  
  351.     Only used for multiline paragraphs.
  352.  */
  353. struct MathedRowSt {    
  354.     /// 
  355.     MathedRowSt(int n) {
  356.         w = new int[n+1]; // this leaks
  357.     next = 0;
  358.     label = 0;
  359.     numbered = true;
  360.     }
  361.     ///
  362.     ~MathedRowSt() {
  363.     delete[] w;
  364.     if (label) delete[] label;
  365.     }
  366.     /// Should be const but...
  367.     MathedRowSt* getNext() const  { return next; }
  368.     /// ...we couldn't use this.
  369.     void setNext(MathedRowSt* n) { next = n; }
  370.     ///
  371.     char const* getLabel() const { return label; }
  372.     ///
  373.     bool isNumbered() const { return numbered; }
  374.     ///
  375.     int  getBaseline() const { return y; }    
  376.     ///
  377.     int  getTab(int i) { return w[i]; }
  378.     /// 
  379.     void setLabel(char* l) { label = l; }
  380.     ///
  381.     void setNumbered(bool nf) { numbered = nf; }
  382.     ///
  383.     void setTab(int i, int t) { w[i] = t; }
  384.     
  385.  private:
  386.     /// Vericals 
  387.     int asc, desc, y;
  388.     /// widths 
  389.     int *w;
  390.     /// 
  391.     char *label;
  392.     ///
  393.     bool numbered;
  394.     ///
  395.     MathedRowSt *next;
  396.     ///
  397.     friend class MathMatrixInset;
  398.     ///
  399.     friend class MathedXIter;
  400. };
  401.  
  402.  
  403.  
  404. /// Multiline math paragraph base class. 
  405. /** This is the base to all multiline editable math objects
  406.     like array and eqnarray. 
  407.  */
  408. class MathMatrixInset: public MathParInset {
  409.  public: 
  410.     ///
  411.     MathMatrixInset(int m=1, int n=1, short st=LM_ST_TEXT);
  412.     ///
  413.     MathMatrixInset(MathMatrixInset*);
  414.     ///
  415.     MathedInset *Clone();
  416.     ///
  417.     virtual ~MathMatrixInset();
  418.     ///
  419.     void Draw(int, int);
  420.     ///
  421.     void Write(FILE *file);
  422.     ///
  423.     void Write(LString &file);
  424.     ///
  425.     void Metrics();
  426.     ///
  427.     void SetData(LyxArrayBase *);
  428.     ///
  429.     void SetAlign(char, char const*);
  430.     ///
  431.     char *GetAlign(char* vv) {
  432.     *vv = v_align;
  433.     return h_align;
  434.     }
  435. //    ///
  436. //    int GetTab(int);
  437.     ///
  438.     int GetColumns() { return nc; }
  439.     ///
  440.     int GetRows() { return nr; }
  441.     ///
  442.     virtual bool isMatrix() { return true; }
  443.  
  444.     /// Use this to manage the extra information independently of paragraph
  445.     MathedRowSt *getRowSt() const { return row; }
  446.     ///
  447.     void setRowSt(MathedRowSt* r) { row = r; }
  448.     
  449.  protected:
  450.     ///  Number of columns & rows
  451.     int nc, nr;
  452.     /// tab sizes
  453.     int *ws;   
  454.     /// 
  455.     char v_align; // add approp. signedness
  456.     ///
  457.     char* h_align;
  458.     /// Vertical structure
  459.     MathedRowSt *row;
  460.  
  461. };
  462.  
  463.  
  464.  
  465. /*************************  Prototypes  **********************************/
  466. /// 
  467. LyxArrayBase *mathed_parse(unsigned flags, LyxArrayBase *data, MathParInset **mt);
  468. ///
  469. void mathed_write(MathParInset*, FILE *, int*, char fragile, char const* label=NULL);
  470. ///
  471. void mathed_write(MathParInset*, LString&, int*, char fragile, char const* label=NULL);
  472. ///
  473. void mathed_parser_file(FILE*, int);
  474. ///
  475. int mathed_parser_lineno();
  476. ///
  477. int MathedLookupBOP(short);
  478.  
  479. /************************ Inline functions ********************************/
  480.  
  481. ///
  482. #define MathIsInset(x)  (LM_TC_INSET<=(x) && (x)<=LM_TC_ACTIVE_INSET)
  483. ///
  484. #define MathIsFont(x)  (LM_TC_CONST<=(x) && (x)<=LM_TC_BSYM)
  485. ///
  486. #define MathIsAlphaFont(x)  (LM_TC_VAR<=(x) && (x)<=LM_TC_TEXTRM)
  487. ///
  488. #define MathIsActive(x)  (LM_TC_INSET<(x) && (x)<=LM_TC_ACTIVE_INSET) 
  489. ///
  490. #define MathIsUp(x)    ((x)==LM_TC_UP) 
  491. ///
  492. #define MathIsDown(x)  ((x)==LM_TC_DOWN)
  493. ///
  494. #define MathIsScript(x)  ((x)==LM_TC_DOWN || (x)==LM_TC_UP)  
  495. ///
  496. #define MathIsBOPS(x)    (MathedLookupBOP(x)>LMB_NONE)
  497.  
  498.  
  499. inline bool MathIsBinary(short x)
  500. {
  501.     return (x==LM_TC_BOP || x==LM_TC_BOPS);
  502. }
  503.  
  504. inline bool MathIsSymbol(short x) {
  505.     return (LM_TC_SYMB<=x && x<=LM_TC_BSYM);
  506. }
  507.      
  508.  
  509. inline 
  510. MathedInset::MathedInset(char const *nm, short ot, short st):
  511.   name(nm), objtype(ot), size(st) 
  512. {
  513.    width = ascent = descent = 0;
  514. }
  515.  
  516. inline
  517. bool MathParInset::Inside(int x, int y) 
  518. {
  519.   return (x>=xo && x<=xo+width && y<=yo+descent && y>=yo-ascent);
  520. }
  521.  
  522.  
  523. inline
  524. void MathParInset::GetXY(int& x, int& y) const
  525. {
  526.    x = xo; y = yo;
  527. }
  528.  
  529. inline
  530. void MathParInset::UserSetSize(short sz)
  531. {
  532.    if (sz>=0) {
  533.        size = sz;      
  534.        flag = flag & ~LMPF_FIXED_SIZE;
  535.    }
  536. }
  537.  
  538.  
  539. inline
  540. void MathParInset::SetStyle(short sz) 
  541. {
  542.     if (Permit(LMPF_FIXED_SIZE)) {
  543.     if (Permit(LMPF_SCRIPT)) 
  544.       sz = (sz<LM_ST_SCRIPT) ? LM_ST_SCRIPT: LM_ST_SCRIPTSCRIPT;
  545.     if (Permit(LMPF_SMALLER) && sz < LM_ST_SCRIPTSCRIPT) {
  546.         sz++;
  547.     } 
  548.     MathedInset::SetStyle(sz);
  549.     }
  550. }
  551.  
  552. #endif
  553.  
  554.