Quellcode-Bibliothek

^© Kompilation durch diese Firma

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

Datei: math_iter.h Sprache: C

Original von: Lyx^©

// -*- C++ -*-
/*
*  File:        math_iter.h
*  Purpose:     Iterator for Math paragraphs
*  Author:      Alejandro Aguilar Sierra <[email protected]>
*  Created:     January 1997
*  Description: Using iterators is the only way to handle math paragraphs
*
*  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_ITER__
#define __MATH_ITER__

#ifdef __GNUG__
#pragma interface
#endif

#include "math_defs.h"

///
enum mathIterFlags {
/// Allow newlines
    MthIF_CR = 1,
    /// Allow tabs
    MthIF_Tabs = 2
};

/**
Specialized array iterator for amth paragraph.  Used for
storing and querying data operations
*/
class MathedIter {
public:
    ///
    MathedIter()
    {
pos = 0;
fcode = 0;
array = NULL;
flags = 0;
ncols = row = col = 0;
    }
    ///
    MathedIter(LyxArrayBase *);
    ///
    virtual ~MathedIter() { }
    ///
    bool goNextCode(MathedTextCodes);
    ///
   void goPosRel(int);
    ///
    void goPosAbs(int);
    ///
    int Empty() { return array->last<=1; }
    ///
    int OK() { return array && (pos < array->last); }
    ///
    int IsFirst() { return (pos==0); }
    ///
    byte GetChar();
    ///
    byte* GetString(int& len);
    ///
    MathedInset* GetInset();
    ///
    MathParInset* GetActiveInset();
    ///
    bool IsInset();
    ///
    bool IsActive();
    ///
    bool IsFont();
    ///
    bool IsScript();
    ///
    bool IsTab();
    ///
    bool IsCR();
    ///
    virtual void Reset();
    ///
    virtual void Insert(byte, MathedTextCodes c=LM_TC_CONST);
    ///
    virtual void Insert(MathedInset*, int t=LM_TC_INSET);
    ///
    virtual bool Delete();
    ///
    virtual bool Next();
    /// Check consistency of tabs and newlines
    void checkTabs();
    /// Try to adjust tabs in the expected place, as in eqnarrays
    void adjustTabs();
    ///
    short FCode() const { return fcode; }
    ///
    int getPos() const { return pos; }
    ///
    int getRow() const { return row; }
    ///
    int getCol() const { return col; }
    ///
    void setNumCols(int n) { ncols = n; }
    ///
    void SetData(LyxArrayBase *a) { array = a; Reset(); }
    ///
    LyxArrayBase *GetData() { return array; }

    /// Copy every object from position p1 to p2
    LyxArrayBase *Copy(int p1=0, int p2=10000);

    /// Delete every object from position p1 to p2
    void Clear();

protected:
    ///
    void split(int);
    ///
    void join(int);
    ///
    int flags;
    ///
    short fcode;
    ///
    int pos;
    ///
    int row, col, ncols;
    ///
    LyxArrayBase *array;
    // one element stack
    struct MIState {
     ///
short fcode;
     ///
int x, y;
     ///
int pos, row, col;
    } stck;

    /// Saves the current state of the iterator
    virtual void ipush();
    /// Recover previous state
    virtual void ipop();
};

///
#define MX_WAS_SUB   1
///
#define MX_WAS_SUPER 2

/**
A graphic iterator (updates position.) Used for
metrics and updating cursor position
*/
class MathedXIter: public MathedIter {
public:
    ///
    MathedXIter(): MathedIter() { x = y = size = 0;  p = 0; crow = 0; }
    ///
    MathedXIter(MathParInset*);
    ///
    ~MathedXIter() { };
    ///
    void SetData(MathParInset *);
    ///
    MathParInset *getPar() { return p; }
    ///
    bool Next();
    ///
    bool Prev();
    ///
    bool Up();
    ///
    bool Down();
    ///
    bool goNextColumn();
    ///
    void GoLast();
    ///
    void GoBegin();
    ///
    void Adjust();
    ///
    inline void GetPos(int&, int&);
    ///
    inline void GetIncPos(int&, int&);
    ///
    byte* GetString(int&);
    ///
    int GetX();
    ///
    int GetY();
    ///
    void subMetrics(int, int);
    ///
    void fitCoord(int, int);
    ///
    void getAD(int& a, int& d);

    /// Create a new row and insert #ncols# tabs.
    void addRow();
///
void delRow();

/**$ These two functions will be moved from here */
   //@{
///
    bool setLabel(char* label);
///
    bool setNumbered(bool);
//@}

///
    void setTab(int, int);
    /// Merge the array at current position
    void Merge(LyxArrayBase*);
    /// Delete every object from current position to pos2
    void Clean(int pos2);
    MathedRowSt *adjustVerticalSt();

private:
    /// This function is not recursive, as MathPar::Metrics is
    void IMetrics(int, int&, int&, int&);
    /// Font size (display, text, script, script2)
    int size;
    /// current position
    int x, y;
//    /// max ascent and descent
//    int asc, des;
///
    MathParInset *p;

    // Limits auxiliary variables
    /// Position and max width of a script
    int sx, sw;
    /// true=center, false=left align (default)
    bool limits;
    /// Type of previous script
    short s_type;

    void ipush();

    void ipop();

protected:
    ///
    MathedRowSt *crow;

private:
    ///
    friend class MathedCursor;
};

//--------------------   Inline functions   --------------------------//

inline
bool MathedIter::IsInset()
{
    return MathIsInset(array->bf[pos]);
}

inline
bool MathedIter::IsActive()
{
    return MathIsActive(array->bf[pos]);
}

inline
bool MathedIter::IsFont()
{
    return MathIsFont(array->bf[pos]);
}

inline
bool MathedIter::IsScript()
{
    return MathIsScript(array->bf[pos]);
}

inline
bool MathedIter::IsTab()
{
    return (array->bf[pos]==LM_TC_TAB);
}

inline
bool MathedIter::IsCR()
{
    return (array->bf[pos]==LM_TC_CR);
}

inline
MathedIter::MathedIter(LyxArrayBase *d): array(d)
{
    pos = 0;
    row = col = 0;
    fcode = (array && IsFont()) ? array->bf[0]: 0;
}


inline
void MathedIter::ipush()
{
    stck.fcode = fcode;
    stck.pos = pos;
    stck.row = row;
    stck.col = col;
}

inline
void MathedIter::ipop()
{
    fcode = stck.fcode;
    pos = stck.pos;
    row = stck.row;
    col = stck.col;
}

inline
void MathedXIter::GetPos(int&xx, int& yy)
{
    if (p)
      p->GetXY(xx, yy);
    else
      { xx = 0;  yy = 0; }
    xx += x;  yy += y;
}

inline
int MathedXIter::GetX()
{
    int xx, yy;
    GetPos(xx, yy);
    return xx;
}

inline
int MathedXIter::GetY()
{
    int xx, yy;
    GetPos(xx, yy);
    return yy;
}

inline
void MathedXIter::GetIncPos(int& xx, int& yy)
{
    xx = x;  yy = y;
}

inline
void MathedXIter::getAD(int& a, int& d)
{
    if (crow) {
a = crow->asc;
d = crow->desc;
    } else
      if (p) {
   a = p->Ascent();
   d = p->Descent();
      } else {
   a = d = 0;
      }
}

#endif

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