/******************************************************************************
* *
* D i s p l a y o f M a t h s i n a w i n d o w . *
* *
*******************************************************************************
* Copyright (C) 2003-4 by Arthur Norman, Codemist Ltd. All Rights Reserved. *
*******************************************************************************
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; *
* version 2.1 of the License. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. *
* *
* See also the FOX Toolkit addendum to the LGPL, which also applies to this *
* code. This addedum gives, in addition to the rights granted by the LGPL, *
* permission to distribute this code statically linked against other code *
* without any need for that other code to have its source released. *
******************************************************************************/
#ifndef FXSHOWMATH_H
#define FXSHOWMATH_H
/* Signature: 4b1e1a0d 14-Apr-2006 */
// I will represent information on the screen by nests of "boxes".
typedef struct TextBox
{
unsigned char type, flags;
short int height, depth, width;
int n;
char *text;
} TextBox;
typedef struct MatrixBox
{
unsigned char type, flags;
short int height, depth, width;
// I will arrange a matrix as a bunch of "NestBox" structures that are
// each BoxTower. The "BoxTower-ness" is used to represent the row
// structure. Each row will be a chain of BoxBeside NestBox structures.
// The top-level BracketBox is used when measuring to trigger measuring
// this mess so that each row and each column has a consistent size and so
// that the overall base-line of the box is half way up it.
short int dy; // NB this must be signed
union Box *sub;
} MatrixBox;
typedef struct BracketBox
{
unsigned char type, flags;
short int height, depth, width;
// a "BracketBox" is used to represent an item enclosed within
// large delimiters. I record the left and right delimiters being used
// (from a limited range of symbols) together with the width of the
// left delimiter, which is how far the contents must be offset. Note
// that a "right vertical bar" is represented here by an exclamation
// mark so I can distinguish it from a left vertical bar.
char leftBracket, rightBracket;
short int dx;
union Box *sub;
// Just for the sake of \sqrt I permit "brackets" to store an additional
// component. This is used for the "3" in "\sqrt[3]{x}"
short int dx1, dy1;
union Box *sub1;
} BracketBox;
typedef struct NestBox
{
unsigned char type, flags;
short int height, depth, width;
short int dx1, dy1, dx2, dy2;
union Box *sub1;
union Box *sub2;
} NestBox;
typedef struct NestBox3
{
unsigned char type, flags;
short int height, depth, width;
short int dx1, dx2, dx3, dy1, dy2, dy3;
union Box *sub1;
union Box *sub2;
union Box *sub3;
} NestBox3;
typedef struct SymBox
{
unsigned char type, flags;
short int height, depth, width;
} SymBox;
typedef struct FrameBox
{
unsigned char type, flags;
short int height, depth, width;
union Box *sub;
} FrameBox;
typedef struct TopBox
{
unsigned char type, flags;
short int height, depth, width;
union Box *sub;
void *chunk;
int measuredSize;
} TopBox;
typedef union Box
{
TextBox text;
NestBox nest;
NestBox3 nest3;
SymBox sym;
BracketBox bracket;
MatrixBox matrix;
FrameBox frame;
TopBox top;
} Box;
extern Box *makeTextBox(const char *s, int n, int fnt);
extern void *masterFont[36];
// Some flags
#define FontMask 0x0f
#define FontFamilyMask 0x03
#define FntRoman 0x00
#define FntItalic 0x01
#define FntSymbol 0x02
#define FntExtension 0x03
#define FontSizeMask 0x0c
#define FntRegular 0x00
#define FntScript 0x04
#define FntScrScr 0x08
#define FntBig 0x10
// The 12 maths fonts currently in play are kept in this array which
// it may sometimes be necessary to inspect. The width of an "M" in the
// normal size one of these is in mathWidth again for marginal cases
// that feel they nee dit.
extern void *mathFont[12];
extern int mathWidth;
// The overall interface here is perhaps not too complicated!
//
// Before trying to make any use of this code you must call
// setUpShowMath, indicating the size (in decipoints) of the
// font to be used.
//
// parseTeX() is given a function that will return characters from
// TeX-line input, and a handle (called owner). It returns a reference
// to a Box structure in its own private memory. The function should
// return zero at end-of-data.
//
// Before any Box is displayed you MUST call measureBox() on it to
// get its layout established.
//
// Finally within your onPaint() method you can call paintBox() to
// display the Box at a given location.
typedef int getTeXchar();
// Get it all ready. If mainSize is positive it is the font size in decipoints,
// if negative its absolute value if the window width in pixels, and a font
// size will be selected base on that. Returns zero if the necessary fonts
// are not available.
extern int setupShowMath(FXApp *app, int mainSize);
// Call this at end to tidy up.
extern void closeShowMath(FXApp *app);
// reset the font size, using same convention as before. Returns zero
// if it was not possible to set the new size, but in that case it leaves
// any previous set of valid fonts in place.
extern int changeMathFontSize(FXApp *app, int newSize);
// at any font size formulae can be drawn at one of 5 different scales,
// and this is use dto help ensure that things fit across the page. This
// is used to indicate which should be used. Arg is 0 - 4.
extern void setMathsFontScale(int n);
// the character-reader must hand back some TeX-line stuff, which is parsed
// and a Box returned. The "owner" is an integer handle that will be
// notified if the box ever gets discarded (eg because memory gets full).
extern Box *parseTeX(getTeXchar *fn, int owner);
// this MUST be called before you rely on metrics extracted from a Box. It
// does detailed layout adjustment.
extern void measureBox(Box *b);
// measureBox1 is like measureBox but if the Box has already been measured
// and if setMathsFontScale has not changed the scale since then the
// existing measurements are left intact.
extern void measureBox1(Box *b);
// make something appear on the screen.
extern void paintBox(FXDC *dc, Box *b, int x, int y);
// It may be useful to be able to process Box pointers as handles. The
// next two map between Box pointers as created by parseTeX and integers.
extern Box *poolPointerFromHandle(int n);
extern int handleFromPoolPointer(Box *b);
// In the owner of a box changes this lets you tell it that.
extern void updateOwner(Box *b, int new_owner);
// When the memory being used by a box is about to be discarded it will notify
// the recorded owner by calling this...
extern void reportDestroy(int p);
#endif // FXSHOWMATH_H
// end of FXShowMath.h