summaryrefslogtreecommitdiff
path: root/dviware/mdvi/include
diff options
context:
space:
mode:
authorNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
committerNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
commite0c6872cf40896c7be36b11dcc744620f10adf1d (patch)
tree60335e10d2f4354b0674ec22d7b53f0f8abee672 /dviware/mdvi/include
Initial commit
Diffstat (limited to 'dviware/mdvi/include')
-rw-r--r--dviware/mdvi/include/CVS/Entries9
-rw-r--r--dviware/mdvi/include/CVS/Repository1
-rw-r--r--dviware/mdvi/include/CVS/Root1
-rw-r--r--dviware/mdvi/include/bitmap.h145
-rw-r--r--dviware/mdvi/include/common.h289
-rw-r--r--dviware/mdvi/include/defaults.h71
-rw-r--r--dviware/mdvi/include/dviopcodes.h72
-rw-r--r--dviware/mdvi/include/fontmap.h82
-rw-r--r--dviware/mdvi/include/mdvi.h767
-rw-r--r--dviware/mdvi/include/private.h50
-rw-r--r--dviware/mdvi/include/sysdeps.h130
11 files changed, 1617 insertions, 0 deletions
diff --git a/dviware/mdvi/include/CVS/Entries b/dviware/mdvi/include/CVS/Entries
new file mode 100644
index 0000000000..f0d8adc4b6
--- /dev/null
+++ b/dviware/mdvi/include/CVS/Entries
@@ -0,0 +1,9 @@
+/bitmap.h/1.1.1.1/Tue Mar 20 09:25:34 2001//
+/common.h/1.1.1.1/Tue Mar 20 09:25:34 2001//
+/defaults.h/1.1.1.1/Tue Mar 20 09:25:35 2001//
+/dviopcodes.h/1.1.1.1/Tue Mar 20 09:25:35 2001//
+/fontmap.h/1.1.1.1/Tue Mar 20 09:25:35 2001//
+/mdvi.h/1.1.1.1/Tue Mar 20 09:25:37 2001//
+/private.h/1.1.1.1/Tue Mar 20 09:25:33 2001//
+/sysdeps.h/1.1.1.1/Tue Mar 20 09:25:37 2001//
+D
diff --git a/dviware/mdvi/include/CVS/Repository b/dviware/mdvi/include/CVS/Repository
new file mode 100644
index 0000000000..4d7fd951c0
--- /dev/null
+++ b/dviware/mdvi/include/CVS/Repository
@@ -0,0 +1 @@
+mdvi/include
diff --git a/dviware/mdvi/include/CVS/Root b/dviware/mdvi/include/CVS/Root
new file mode 100644
index 0000000000..164e86eed7
--- /dev/null
+++ b/dviware/mdvi/include/CVS/Root
@@ -0,0 +1 @@
+agiacom@cvs.mdvi.sourceforge.net:/cvsroot/mdvi
diff --git a/dviware/mdvi/include/bitmap.h b/dviware/mdvi/include/bitmap.h
new file mode 100644
index 0000000000..4d5f23ace9
--- /dev/null
+++ b/dviware/mdvi/include/bitmap.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2000, Matias Atria
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#ifndef _BITMAP_H
+#define _BITMAP_H 1
+
+#include "sysdeps.h"
+
+/* Structures and functions to manipulate bitmaps */
+
+/* bitmap unit (as in X's docs) */
+typedef Uint32 BmUnit;
+
+/* size (in bytes) of a bitmap atom */
+#define BITMAP_BYTES 4
+
+/* size (in bits) of a bitmap atom */
+#define BITMAP_BITS (BITMAP_BYTES << 3)
+
+typedef struct {
+ int width;
+ int height;
+ int stride;
+ BmUnit *data;
+} BITMAP;
+
+#define BM_BYTES_PER_LINE(b) \
+ (ROUND((b)->width, BITMAP_BITS) * BITMAP_BYTES)
+#define BM_WIDTH(b) (((BITMAP *)(b))->width)
+#define BM_HEIGHT(b) (((BITMAP *)(b))->height)
+
+#define BMBIT(n) ((BmUnit)1 << (n))
+
+/* Macros to manipulate individual pixels in a bitmap
+ * (they are slow, don't use them)
+ */
+
+#define bm_offset(b,o) (BmUnit *)((Uchar *)(b) + (o))
+
+#define __bm_unit_ptr(b,x,y) \
+ bm_offset((b)->data, (y) * (b)->stride + \
+ ((x) / BITMAP_BITS) * BITMAP_BYTES)
+
+#define __bm_unit(b,x,y) __bm_unit_ptr((b), (x), (y))[0]
+
+#define BM_GETPIXEL(b,x,y) __bm_unit((b), (x), (y))
+#define BM_SETPIXEL(b,x,y) (__bm_unit((b), (x), (y)) |= FIRSTMASKAT(x))
+#define BM_CLRPIXEL(b,x,y) (__bm_unit((b), (x), (y)) &= ~FIRSTMASKAT(x))
+
+/*
+ * These macros are used to access pixels in a bitmap. They are supposed
+ * to be used like this:
+ */
+#if 0
+ BmUnit *row, mask;
+
+ mask = FIRSTMASK;
+
+ /* position `unit' at coordinates (column_number, row_number) */
+ unit = (BmUnit *)((char *)bitmap->data + row_number * bitmap->stride
+ + (column_number / BITMAP_BITS);
+ /* loop over all pixels IN THE SAME ROW */
+ for(i = 0; i < number_of_pixels; i++) {
+ /* to test if a pixel is set */
+ if(*unit & mask) {
+ /* yes, it is, do something with it */
+ }
+ /* to set/clear a pixel */
+ if(painting)
+ *unit |= mask; /* now you see it */
+ else
+ *unit &= ~mask; /* now you don't */
+ /* move to next pixel */
+ if(mask == LASTMASK) {
+ unit++;
+ UPDATEMASK(mask);
+ }
+ }
+/* end of sample code */
+#endif
+
+/* bitmaps are stored in native byte order */
+#ifdef WORD_BIG_ENDIAN
+#define FIRSTSHIFT (BITMAP_BITS - 1)
+#define LASTSHIFT 0
+#define NEXTMASK(m) ((m) >>= 1)
+#define PREVMASK(m) ((m) <<= 1)
+#define FIRSTSHIFTAT(c) (BITMAP_BITS - ((c) % BITMAP_BITS) - 1)
+#else
+#define FIRSTSHIFT 0
+#define LASTSHIFT (BITMAP_BITS - 1)
+#define NEXTMASK(m) ((m) <<= 1)
+#define PREVMASK(m) ((m) >>= 1)
+#define FIRSTSHIFTAT(c) ((c) % BITMAP_BITS)
+#endif
+
+#define FIRSTMASK BMBIT(FIRSTSHIFT)
+#define FIRSTMASKAT(c) BMBIT(FIRSTSHIFTAT(c))
+#define LASTMASK BMBIT(LASTSHIFT)
+
+extern BITMAP *bitmap_alloc __PROTO((int, int));
+extern BITMAP *bitmap_alloc_raw __PROTO((int, int));
+extern void bitmap_destroy __PROTO((BITMAP *));
+
+/*
+ * set_row(bm, row, col, count, state):
+ * sets `count' pixels to state `onoff', starting from pixel
+ * at position (col, row). All pixels must lie in the same
+ * row.
+ */
+extern void bitmap_set_col __PROTO((BITMAP *, int, int, int, int));
+extern void bitmap_set_row __PROTO((BITMAP *, int, int, int, int));
+
+extern void bitmap_paint_bits __PROTO((BmUnit *, int, int));
+extern void bitmap_clear_bits __PROTO((BmUnit *, int, int));
+
+extern BITMAP *bitmap_copy __PROTO((BITMAP *));
+extern void bitmap_flip_horizontally __PROTO((BITMAP *));
+extern void bitmap_flip_vertically __PROTO((BITMAP *));
+extern void bitmap_flip_diagonally __PROTO((BITMAP *));
+extern void bitmap_rotate_clockwise __PROTO((BITMAP *));
+extern void bitmap_rotate_counter_clockwise __PROTO((BITMAP *));
+extern void bitmap_flip_rotate_clockwise __PROTO((BITMAP *));
+extern void bitmap_flip_rotate_counter_clockwise __PROTO((BITMAP *));
+extern BITMAP *bitmap_convert_lsb8 __PROTO((Uchar *, int, int));
+extern BITMAP *bitmap_convert_msb8 __PROTO((Uchar *, int, int));
+
+#include <stdio.h>
+extern void bitmap_print __PROTO((FILE *, BITMAP *));
+
+#endif /* _BITMAP_H */
diff --git a/dviware/mdvi/include/common.h b/dviware/mdvi/include/common.h
new file mode 100644
index 0000000000..67130feb75
--- /dev/null
+++ b/dviware/mdvi/include/common.h
@@ -0,0 +1,289 @@
+/*
+ * Copyright (C) 2000, Matias Atria
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#ifndef _MDVI_COMMON_H
+#define _MDVI_COMMON_H 1
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <math.h>
+
+#include "sysdeps.h"
+
+#if STDC_HEADERS
+# include <string.h>
+#endif
+
+#if !defined(STDC_HEADERS) || defined(__STRICT_ANSI__)
+# ifndef HAVE_STRCHR
+# define strchr index
+# define strrchr rindex
+# endif
+# ifndef HAVE_MEMCPY
+# define memcpy(a,b,n) bcopy((b), (a), (n))
+# define memmove(a,b,n) bcopy((b), (a), (n))
+# endif
+#endif
+
+#ifdef HAVE_MEMCPY
+#define memzero(a,n) memset((a), 0, (n))
+#else
+#define memzero(a,n) bzero((a), (n))
+#endif
+
+typedef struct _List {
+ struct _List *next;
+ struct _List *prev;
+} List;
+#define LIST(x) ((List *)(x))
+
+typedef struct {
+ char *data;
+ size_t size;
+ size_t length;
+} Buffer;
+
+typedef struct {
+ List *head;
+ List *tail;
+ int count;
+} ListHead;
+#define MDVI_EMPTY_LIST_HEAD {NULL, NULL, 0}
+
+typedef struct {
+ char *data;
+ size_t size;
+ size_t length;
+} Dstring;
+
+/* Functions to read numbers from streams and memory */
+
+#define fgetbyte(p) ((unsigned)getc(p))
+
+extern char *program_name;
+
+extern Ulong fugetn __PROTO((FILE *, size_t));
+extern long fsgetn __PROTO((FILE *, size_t));
+extern Ulong mugetn __PROTO((const Uchar *, size_t));
+extern long msgetn __PROTO((const Uchar *, size_t));
+
+/* To read from a stream (fu: unsigned, fs: signed) */
+#define fuget4(p) fugetn((p), 4)
+#define fuget3(p) fugetn((p), 3)
+#define fuget2(p) fugetn((p), 2)
+#define fuget1(p) fgetbyte(p)
+#define fsget4(p) fsgetn((p), 4)
+#define fsget3(p) fsgetn((p), 3)
+#define fsget2(p) fsgetn((p), 2)
+#define fsget1(p) fsgetn((p), 1)
+
+/* To read from memory (mu: unsigned, ms: signed) */
+#define MUGETN(p,n) ((p) += (n), mugetn((p)-(n), (n)))
+#define MSGETN(p,n) ((p) += (n), msgetn((p)-(n), (n)))
+#define muget4(p) MUGETN((p), 4)
+#define muget3(p) MUGETN((p), 3)
+#define muget2(p) MUGETN((p), 2)
+#define muget1(p) MUGETN((p), 1)
+#define msget4(p) MSGETN((p), 4)
+#define msget3(p) MSGETN((p), 3)
+#define msget2(p) MSGETN((p), 2)
+#define msget1(p) MSGETN((p), 1)
+
+#define ROUND(x,y) (((x) + (y) - 1) / (y))
+#define FROUND(x) (int)((x) + 0.5)
+#define SFROUND(x) (int)((x) >= 0 ? floor((x) + 0.5) : ceil((x) + 0.5))
+
+#define Max(a,b) (((a) > (b)) ? (a) : (b))
+#define Min(a,b) (((a) < (b)) ? (a) : (b))
+
+/* make 2byte number from 2 8bit quantities */
+#define HALFWORD(a,b) ((((a) << 8) & 0xf) | (b))
+#define FULLWORD(a,b,c,d) \
+ ((((Int8)(a) << 24) & 0xff000000) | \
+ (((Uint8)(b) << 16) & 0x00ff0000) | \
+ (((Uint8)(c) << 8) & 0x0000ff00) | \
+ ((Uint8)(d) & 0xff))
+
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+#define SWAPINT(a,b) \
+ ({ int _s = a; a = b; b = _s; })
+#else
+#define SWAPINT(a,b) do { int _s = a; a = b; b = _s; } while(0)
+#endif
+
+#define STREQ(a,b) (strcmp((a), (b)) == 0)
+#define STRNEQ(a,b,n) (strncmp((a), (b), (n)) == 0)
+#define STRCEQ(a,b) (strcasecmp((a), (b)) == 0)
+#define STRNCEQ(a,b,n) (strncasecmp((a), (b), (n)) == 0)
+
+extern char *read_string __PROTO((FILE *, int, char *, size_t));
+extern size_t read_bcpl __PROTO((FILE *, char *, size_t, size_t));
+extern char *read_alloc_bcpl __PROTO((FILE *, size_t, size_t *));
+
+/* miscellaneous */
+
+extern void message __PROTO((const char *, ...));
+extern void crash __PROTO((const char *, ...));
+extern void fatal __PROTO((const char *, ...));
+extern void error __PROTO((const char *, ...));
+extern void warning __PROTO((const char *, ...));
+extern int unit2pix __PROTO((int, const char *));
+extern double unit2pix_factor __PROTO((const char *));
+
+#define LOG_NONE -1
+#define LOG_INFO 0
+#define LOG_WARN 1
+#define LOG_ERROR 2
+#define LOG_DEBUG 3
+
+#define DBG_OPCODE (1 << 0)
+#define DBG_FONTS (1 << 1)
+#define DBG_FILES (1 << 2)
+#define DBG_DVI (1 << 3)
+#define DBG_PARAMS (1 << 4)
+#define DBG_SPECIAL (1 << 5)
+#define DBG_DEVICE (1 << 6)
+#define DBG_GLYPHS (1 << 7)
+#define DBG_BITMAPS (1 << 8)
+#define DBG_PATHS (1 << 9)
+#define DBG_SEARCH (1 << 10)
+#define DBG_VARS (1 << 11)
+#define DBG_BITMAP_OPS (1 << 12)
+#define DBG_BITMAP_DATA (1 << 13)
+#define DBG_TYPE1 (1 << 14)
+#define DBG_TT (1 << 15)
+#define DBG_FT2 (1 << 16)
+#define DBG_FMAP (1 << 17)
+
+#define DBG_SILENT (1 << 31)
+
+#ifdef NODEBUG
+#define DEBUGGING(x) 0
+#else
+#define DEBUGGING(x) (_mdvi_debug_mask & DBG_##x)
+#endif
+
+#ifndef NODEBUG
+extern Uint32 _mdvi_debug_mask;
+extern void __debug __PROTO((int, const char *, ...));
+#define DEBUG(x) __debug x
+#define ASSERT(x) do { \
+ if(!(x)) crash("%s:%d: Assertion %s failed\n", \
+ __FILE__, __LINE__, #x); \
+ } while(0)
+#define ASSERT_VALUE(x,y) do { \
+ if((x) != (y)) \
+ crash("%s:%d: Assertion failed (%d = %s != %s)\n", \
+ __FILE__, __LINE__, (x), #x, #x); \
+ } while(0)
+#else
+#define DEBUG(x) do { } while(0)
+#define ASSERT(x) do { } while(0)
+#define ASSERT_VALUE(x,y) do { } while(0)
+#endif
+
+#define set_debug_mask(m) (_mdvi_debug_mask = (Uint32)(m))
+#define add_debug_mask(m) (_mdvi_debug_mask |= (Uint32)(m))
+#define get_debug_mask() _mdvi_debug_mask
+
+/* memory allocation */
+
+extern void xfree __PROTO((void *));
+extern void *xmalloc __PROTO((size_t));
+extern void *xrealloc __PROTO((void *, size_t));
+extern void *xcalloc __PROTO((size_t, size_t));
+extern char *xstrncpy __PROTO((char *, const char *, size_t));
+extern char *xstrdup __PROTO((const char *));
+extern char *xstrndup __PROTO((const char *, size_t));
+extern void *xmemdup __PROTO((const void *, size_t));
+
+/* macros to make memory allocation nicer */
+#define xalloc(t) (t *)xmalloc(sizeof(t))
+#define xnalloc(t,n) (t *)xcalloc((n), sizeof(t))
+#define xresize(p,t,n) (t *)xrealloc((p), (n) * sizeof(t))
+
+extern int get_number __PROTO((const char *, long *));
+/* return paper dimensions (in cm) */
+extern int paper_dimensions __PROTO((const char *, double *, double *));
+
+extern char *xstradd __PROTO((char *, size_t *, size_t, const char *, size_t));
+
+extern Ulong get_mtime __PROTO((int));
+
+/* lists */
+extern void listh_init __PROTO((ListHead *));
+extern void listh_prepend __PROTO((ListHead *, List *));
+extern void listh_append __PROTO((ListHead *, List *));
+extern void listh_add_before __PROTO((ListHead *, List *, List *));
+extern void listh_add_after __PROTO((ListHead *, List *, List *));
+extern void listh_remove __PROTO((ListHead *, List *));
+extern void listh_concat __PROTO((ListHead *, ListHead *));
+extern void listh_catcon __PROTO((ListHead *, ListHead *));
+
+extern void buff_init __PROTO((Buffer *));
+extern size_t buff_add __PROTO((Buffer *, const char *, size_t));
+extern char *buff_gets __PROTO((Buffer *, size_t *));
+extern void buff_free __PROTO((Buffer *));
+
+extern char *getword __PROTO((char *, const char *, char **));
+extern char *getstring __PROTO((char *, const char *, char **));
+
+extern void dstring_init __PROTO((Dstring *));
+extern int dstring_new __PROTO((Dstring *, const char *, int));
+extern int dstring_append __PROTO((Dstring *, const char *, int));
+extern int dstring_copy __PROTO((Dstring *, int, const char *, int));
+extern int dstring_insert __PROTO((Dstring *, int, const char *, int));
+extern void dstring_reset __PROTO((Dstring *));
+
+#define dstring_length(d) ((d)->length)
+#define dstring_strcat(d,s) dstring_append((d), (s), -1)
+
+extern char *dgets __PROTO((Dstring *, FILE *));
+extern int file_readable __PROTO((const char *));
+extern int file_exists __PROTO((const char *));
+extern char *find_in_path __PROTO((const char *path, const char *file));
+extern const char *file_basename __PROTO((const char *));
+extern const char *file_extension __PROTO((const char *));
+extern char *read_into_core __PROTO((const char *, size_t *));
+
+/*
+ * Miscellaneous macros
+ */
+
+#define LIST_FOREACH(ptr, type, list) \
+ for(ptr = (type *)(list)->head; ptr; ptr = (ptr)->next)
+
+#define Size(x) (sizeof(x) / sizeof((x)[0]))
+
+/* multiply a fix_word by a 32bit number */
+#define B0(x) ((x) & 0xff)
+#define B1(x) B0((x) >> 8)
+#define B2(x) B0((x) >> 16)
+#define B3(x) B0((x) >> 24)
+#define __tfm_mul(z,t) \
+ (((((B0(t) * (z)) >> 8) + (B1(t) * (z))) >> 8) + B2(t) * (z))
+#define TFMSCALE(z,t,a,b) \
+ ((B3(t) == 255) ? \
+ __tfm_mul((z), (t)) / (b) - (a) : \
+ __tfm_mul((z), (t)) / (b))
+#define TFMPREPARE(x,z,a,b) do { \
+ a = 16; z = (x); \
+ while(z > 040000000L) { z >>= 1; a <<= 1; } \
+ b = 256 / a; a *= z; \
+ } while(0)
+
+#endif /* _MDVI_COMMON_H */
diff --git a/dviware/mdvi/include/defaults.h b/dviware/mdvi/include/defaults.h
new file mode 100644
index 0000000000..46ce6ce4a7
--- /dev/null
+++ b/dviware/mdvi/include/defaults.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2000, Matias Atria
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#ifndef _MDVI_DEFAULTS_H
+#define _MDVI_DEFAULTS_H 1
+
+/* resolution */
+#define MDVI_DPI 600
+#define MDVI_VDPI MDVI_DPI
+
+/* horizontal margins */
+#define MDVI_HMARGIN "1in"
+
+/* vertical margins */
+#define MDVI_VMARGIN "1in"
+
+/* rulers */
+#define MDVI_HRUNITS "1in"
+#define MDVI_VRUNITS "1in"
+
+/* paper */
+#define MDVI_PAPERNAME "letter"
+
+/* magnification */
+#define MDVI_MAGNIFICATION 1.0
+
+/* fallback font */
+#define MDVI_FALLBACK_FONT "cmr10"
+
+/* metafont mode */
+#define MDVI_MFMODE NULL
+
+/* default shrinking factor */
+#define MDVI_DEFAULT_SHRINKING -1 /* based on resolution */
+
+/* default pixel density */
+#define MDVI_DEFAULT_DENSITY 50
+
+/* default gamma correction */
+#define MDVI_DEFAULT_GAMMA 1.0
+
+/* default window geometry */
+#define MDVI_GEOMETRY NULL
+
+/* default orientation */
+#define MDVI_ORIENTATION "tblr"
+
+/* colors */
+#define MDVI_FOREGROUND "black"
+#define MDVI_BACKGROUND "white"
+
+/* flags */
+#define MDVI_DEFAULT_FLAGS MDVI_ANTIALIASED
+
+#define MDVI_DEFAULT_CONFIG "mdvi.conf"
+
+#endif /* _MDVI_DEAFAULTS_H */
diff --git a/dviware/mdvi/include/dviopcodes.h b/dviware/mdvi/include/dviopcodes.h
new file mode 100644
index 0000000000..f99af05ea2
--- /dev/null
+++ b/dviware/mdvi/include/dviopcodes.h
@@ -0,0 +1,72 @@
+#ifndef _MDVI_DVIOPCODES_H
+#define _MDVI_DVIOPCODES_H 1
+
+#define DVI_SET_CHAR0 0
+#define DVI_SET_CHAR1 1
+#define DVI_SET_CHAR_MAX 127
+#define DVI_SET1 128
+#define DVI_SET2 129
+#define DVI_SET3 130
+#define DVI_SET4 131
+#define DVI_SET_RULE 132
+#define DVI_PUT1 133
+#define DVI_PUT2 134
+#define DVI_PUT3 135
+#define DVI_PUT4 136
+#define DVI_PUT_RULE 137
+#define DVI_NOOP 138
+#define DVI_BOP 139
+#define DVI_EOP 140
+#define DVI_PUSH 141
+#define DVI_POP 142
+#define DVI_RIGHT1 143
+#define DVI_RIGHT2 144
+#define DVI_RIGHT3 145
+#define DVI_RIGHT4 146
+#define DVI_W0 147
+#define DVI_W1 148
+#define DVI_W2 149
+#define DVI_W3 150
+#define DVI_W4 151
+#define DVI_X0 152
+#define DVI_X1 153
+#define DVI_X2 154
+#define DVI_X3 155
+#define DVI_X4 156
+#define DVI_DOWN1 157
+#define DVI_DOWN2 158
+#define DVI_DOWN3 159
+#define DVI_DOWN4 160
+#define DVI_Y0 161
+#define DVI_Y1 162
+#define DVI_Y2 163
+#define DVI_Y3 164
+#define DVI_Y4 165
+#define DVI_Z0 166
+#define DVI_Z1 167
+#define DVI_Z2 168
+#define DVI_Z3 169
+#define DVI_Z4 170
+#define DVI_FNT_NUM0 171
+#define DVI_FNT_NUM1 172
+#define DVI_FNT_NUM_MAX 234
+#define DVI_FNT1 235
+#define DVI_FNT2 236
+#define DVI_FNT3 237
+#define DVI_FNT4 238
+#define DVI_XXX1 239
+#define DVI_XXX2 240
+#define DVI_XXX3 241
+#define DVI_XXX4 242
+#define DVI_FNT_DEF1 243
+#define DVI_FNT_DEF2 244
+#define DVI_FNT_DEF3 245
+#define DVI_FNT_DEF4 246
+#define DVI_PRE 247
+#define DVI_POST 248
+#define DVI_POST_POST 249
+
+#define DVI_ID 2
+#define DVI_TRAILER 223
+
+#endif /* _MDVI_DVIOPCODES_H */
diff --git a/dviware/mdvi/include/fontmap.h b/dviware/mdvi/include/fontmap.h
new file mode 100644
index 0000000000..0a901ec3a6
--- /dev/null
+++ b/dviware/mdvi/include/fontmap.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2000, Matias Atria
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#ifndef _MDVI_FONTMAP_H
+#define _MDVI_FONTMAP_H 1
+
+typedef struct _DviFontMapEnt DviFontMapEnt;
+typedef struct _DviEncoding DviEncoding;
+
+typedef struct {
+ const char *psname;
+ const char *encoding;
+ const char *fontfile;
+ const char *fullfile;
+ const char *fmfile;
+ int fmtype;
+ long extend;
+ long slant;
+} DviFontMapInfo;
+
+struct _DviEncoding {
+ DviEncoding *next;
+ DviEncoding *prev;
+ char *private;
+ char *filename;
+ char *name;
+ char **vector; /* table with exactly 256 strings */
+ int links;
+ long offset;
+ DviHashTable nametab;
+};
+
+struct _DviFontMapEnt {
+ DviFontMapEnt *next;
+ DviFontMapEnt *prev;
+ char *private;
+ char *fontname;
+ char *psname;
+ char *encoding;
+ char *encfile;
+ char *fontfile;
+ char *fullfile;
+ long extend;
+ long slant;
+};
+
+#define MDVI_FMAP_SLANT(x) ((double)(x)->slant / 10000.0)
+#define MDVI_FMAP_EXTEND(x) ((double)(x)->extend / 10000.0)
+
+extern DviEncoding *mdvi_request_encoding __PROTO((const char *));
+extern void mdvi_release_encoding __PROTO((DviEncoding *, int));
+extern int mdvi_encode_glyph __PROTO((DviEncoding *, const char *));
+extern DviFontMapEnt *mdvi_load_fontmap __PROTO((const char *));
+extern void mdvi_install_fontmap __PROTO((DviFontMapEnt *));
+extern int mdvi_load_fontmaps __PROTO((void));
+extern int mdvi_query_fontmap __PROTO((DviFontMapInfo *, const char *));
+extern void mdvi_flush_encodings __PROTO((void));
+extern void mdvi_flush_fontmaps __PROTO((void));
+
+extern int mdvi_add_fontmap_file __PROTO((const char *, const char *));
+
+/* PS font maps */
+extern int mdvi_ps_read_fontmap __PROTO((const char *));
+extern char *mdvi_ps_find_font __PROTO((const char *));
+extern TFMInfo *mdvi_ps_get_metrics __PROTO((const char *));
+extern void mdvi_ps_flush_fonts __PROTO((void));
+
+#endif /* _MDVI_FONTMAP_H */
diff --git a/dviware/mdvi/include/mdvi.h b/dviware/mdvi/include/mdvi.h
new file mode 100644
index 0000000000..8b16da9f5e
--- /dev/null
+++ b/dviware/mdvi/include/mdvi.h
@@ -0,0 +1,767 @@
+/*
+ * Copyright (C) 2000, Matias Atria
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#ifndef _MDVI_DVI_H
+#define _MDVI_DVI_H 1
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <math.h>
+
+#include "sysdeps.h"
+#include "bitmap.h"
+#include "common.h"
+#include "defaults.h"
+#include "dviopcodes.h"
+
+typedef struct _DviGlyph DviGlyph;
+typedef struct _DviDevice DviDevice;
+typedef struct _DviFontChar DviFontChar;
+typedef struct _DviFontRef DviFontRef;
+typedef struct _DviFontInfo DviFontInfo;
+typedef struct _DviFont DviFont;
+typedef struct _DviState DviState;
+typedef struct _DviPaper DviPaper;
+typedef struct _DviPaperSpec DviPaperSpec;
+typedef struct _DviPageSpec *DviPageSpec;
+typedef struct _DviParams DviParams;
+typedef struct _DviBuffer DviBuffer;
+typedef struct _DviContext DviContext;
+typedef struct _DviRange DviRange;
+typedef struct _DviAppConfig DviAppConfig;
+typedef struct _DviColorPair DviColorPair;
+typedef struct _DviHashBucket DviHashBucket;
+typedef struct _DviHashTable DviHashTable;
+typedef struct _DviConfValue DviConfValue;
+typedef struct _DviSection DviSection;
+typedef struct _DviConfig DviConfig;
+typedef struct _TFMChar TFMChar;
+typedef struct _TFMInfo TFMInfo;
+typedef struct _DviFontSearch DviFontSearch;
+/* this is an opaque type */
+typedef struct _DviFontClass DviFontClass;
+
+typedef void (*DviFreeFunc) __PROTO((void *));
+typedef void (*DviFree2Func) __PROTO((void *, void *));
+
+typedef Ulong DviColor;
+
+#ifdef TRUE
+#undef TRUE
+#endif
+#ifdef FALSE
+#undef FALSE
+#endif
+
+typedef enum {
+ FALSE = 0,
+ TRUE = 1
+} DviBool;
+
+/*
+ * information about a page:
+ * pagenum[0] = offset to BOP
+ * pagenum[1], ..., pagenum[10] = TeX \counters
+ */
+typedef long PageNum[11];
+
+/* this structure contains the platform-specific information
+ * required to interpret a DVI file */
+
+typedef void (*DviGlyphDraw) __PROTO((DviContext *context,
+ DviFontChar *glyph,
+ int x, int y));
+
+typedef void (*DviRuleDraw) __PROTO((DviContext *context,
+ int x, int y,
+ Uint width, Uint height, int fill));
+
+typedef int (*DviColorScale) __PROTO((void *device_data,
+ Ulong *pixels,
+ int npixels,
+ Ulong foreground,
+ Ulong background,
+ double gamma,
+ int density));
+typedef void *(*DviCreateImage) __PROTO((void *device_data,
+ Uint width,
+ Uint height,
+ Uint bpp));
+typedef void (*DviFreeImage) __PROTO((void *image));
+typedef void (*DviPutPixel) __PROTO((void *image, int x, int y, Ulong color));
+typedef void (*DviDevDestroy) __PROTO((void *data));
+typedef void (*DviRefresh) __PROTO((DviContext *dvi, void *device_data));
+typedef void (*DviSetColor) __PROTO((void *device_data, Ulong, Ulong));
+
+struct _DviDevice {
+ DviGlyphDraw draw_glyph;
+ DviRuleDraw draw_rule;
+ DviColorScale alloc_colors;
+ DviCreateImage create_image;
+ DviFreeImage free_image;
+ DviPutPixel put_pixel;
+ DviDevDestroy dev_destroy;
+ DviRefresh refresh;
+ DviSetColor set_color;
+ void * device_data;
+};
+
+/*
+ * Hash tables
+ */
+
+typedef Uchar *DviHashKey;
+#define MDVI_KEY(x) ((DviHashKey)(x))
+
+typedef Ulong (*DviHashFunc) __PROTO((DviHashKey key));
+typedef int (*DviHashComp) __PROTO((DviHashKey key1, DviHashKey key2));
+typedef void (*DviHashFree) __PROTO((DviHashKey key, void *data));
+
+
+struct _DviHashTable {
+ DviHashBucket **buckets;
+ int nbucks;
+ int nkeys;
+ DviHashFunc hash_func;
+ DviHashComp hash_comp;
+ DviHashFree hash_free;
+};
+#define MDVI_EMPTY_HASH_TABLE {NULL, 0, 0, NULL, NULL, NULL}
+
+/*
+ * Fonts
+ */
+
+#include "fontmap.h"
+
+struct _TFMChar {
+ Int32 present;
+ Int32 advance; /* advance */
+ Int32 height; /* ascent */
+ Int32 depth; /* descent */
+ Int32 left; /* leftSideBearing */
+ Int32 right; /* rightSideBearing */
+};
+
+struct _TFMInfo {
+ int type; /* DviFontAFM, DviFontTFM, DviFontOFM */
+ Uint32 checksum;
+ Uint32 design;
+ int loc;
+ int hic;
+ char coding[64];
+ char family[64];
+ TFMChar *chars;
+};
+
+struct _DviGlyph {
+ short x, y; /* origin */
+ Uint w, h; /* dimensions */
+ void *data; /* bitmap or XImage */
+};
+
+typedef void (*DviFontShrinkFunc)
+ __PROTO((DviContext *, DviFont *, DviFontChar *, DviGlyph *));
+typedef int (*DviFontLoadFunc) __PROTO((DviParams *, DviFont *));
+typedef int (*DviFontGetGlyphFunc) __PROTO((DviParams *, DviFont *, int));
+typedef void (*DviFontFreeFunc) __PROTO((DviFont *));
+typedef void (*DviFontResetFunc) __PROTO((DviFont *));
+typedef char *(*DviFontLookupFunc) __PROTO((const char *, Ushort *, Ushort *));
+typedef int (*DviFontEncodeFunc) __PROTO((DviParams *, DviFont *, DviEncoding *));
+
+struct _DviFontInfo {
+ char *name; /* human-readable format identifying string */
+ int scalable; /* does it support scaling natively? */
+ DviFontLoadFunc load;
+ DviFontGetGlyphFunc getglyph;
+ DviFontShrinkFunc shrink0;
+ DviFontShrinkFunc shrink1;
+ DviFontFreeFunc freedata;
+ DviFontResetFunc reset;
+ DviFontLookupFunc lookup;
+ int kpse_type;
+ void * private;
+};
+
+struct _DviFontChar {
+ Uint32 offset;
+ Int16 code; /* format-dependent, not used by MDVI */
+ Int16 width;
+ Int16 height;
+ Int16 x;
+ Int16 y;
+ Int32 tfmwidth;
+ Ushort flags;
+#ifdef __STRICT_ANSI__
+ Ushort loaded;
+ Ushort missing;
+#else
+ Ushort loaded : 1,
+ missing : 1;
+#endif
+ Ulong fg;
+ Ulong bg;
+ BITMAP *glyph_data;
+ /* data for shrunk bitimaps */
+ DviGlyph glyph;
+ DviGlyph shrunk;
+ DviGlyph grey;
+};
+
+struct _DviFontRef {
+ DviFontRef *next;
+ DviFont *ref;
+ Int32 fontid;
+};
+
+typedef enum {
+ DviFontAny = -1,
+ DviFontPK = 0,
+ DviFontGF = 1,
+ DviFontVF = 2,
+ DviFontTFM = 3,
+ DviFontT1 = 4,
+ DviFontTT = 5,
+ DviFontAFM = 6,
+ DviFontOFM = 7
+} DviFontType;
+
+struct _DviFontSearch {
+ int id;
+ Ushort hdpi;
+ Ushort vdpi;
+ Ushort actual_hdpi;
+ Ushort actual_vdpi;
+ const char *wanted_name;
+ const char *actual_name;
+ DviFontClass *curr;
+ DviFontInfo *info;
+};
+
+/* this is a kludge, I know */
+#define ISVIRTUAL(font) ((font)->search.info->getglyph == NULL)
+#define SEARCH_DONE(s) ((s).id < 0)
+#define SEARCH_INIT(s, name, h, v) do { \
+ (s).id = 0; \
+ (s).curr = NULL; \
+ (s).hdpi = (h); \
+ (s).vdpi = (v); \
+ (s).wanted_name = (name); \
+ (s).actual_name = NULL; \
+ } while(0)
+
+struct _DviFont {
+ DviFont *next;
+ DviFont *prev;
+ int type;
+ Int32 checksum;
+ int hdpi;
+ int vdpi;
+ Int32 scale;
+ Int32 design;
+ FILE *in;
+ char *fontname;
+ char *filename;
+ int links;
+ int loc;
+ int hic;
+ Uint flags;
+ DviFontSearch search;
+ DviFontChar *chars;
+ DviFontRef *subfonts;
+ void *private;
+};
+
+/*
+ * Dvi context
+ */
+
+typedef enum {
+ MDVI_PAPER_CLASS_ISO,
+ MDVI_PAPER_CLASS_US,
+ MDVI_PAPER_CLASS_ANY,
+ MDVI_PAPER_CLASS_CUSTOM
+} DviPaperClass;
+
+struct _DviPaper {
+ DviPaperClass pclass;
+ const char *name;
+ double inches_wide;
+ double inches_tall;
+};
+
+struct _DviPaperSpec {
+ const char *name;
+ const char *width;
+ const char *height;
+};
+
+typedef enum {
+ MDVI_ORIENT_TBLR = 0, /* top to bottom, left to right */
+ MDVI_ORIENT_TBRL = 1, /* top to bottom, right to left */
+ MDVI_ORIENT_BTLR = 2, /* bottom to top, left to right */
+ MDVI_ORIENT_BTRL = 3, /* bottom to top, right to left */
+ MDVI_ORIENT_RP90 = 4, /* rotated +90 degrees (counter-clockwise) */
+ MDVI_ORIENT_RM90 = 5, /* rotated -90 degrees (clockwise) */
+ MDVI_ORIENT_IRP90 = 6, /* flip horizontally, then rotate by +90 */
+ MDVI_ORIENT_IRM90 = 7 /* rotate by -90, then flip horizontally */
+} DviOrientation;
+
+typedef enum {
+ MDVI_PAGE_SORT_UP, /* up, using \counter0 */
+ MDVI_PAGE_SORT_DOWN, /* down, using \counter0 */
+ MDVI_PAGE_SORT_RANDOM, /* randomly */
+ MDVI_PAGE_SORT_DVI_UP, /* up, by location in DVI file */
+ MDVI_PAGE_SORT_DVI_DOWN, /* down, by location in DVI file */
+ MDVI_PAGE_SORT_NONE /* don't sort */
+} DviPageSort;
+
+struct _DviParams {
+ double mag; /* magnification */
+ double conv; /* horizontal DVI -> pixel */
+ double vconv; /* vertical DVI -> pixel */
+ double tfm_conv; /* TFM -> DVI */
+ double gamma; /* gamma correction factor */
+ Uint dpi; /* horizontal resolution */
+ Uint vdpi; /* vertical resolution */
+ int hshrink; /* horizontal shrinking factor */
+ int vshrink; /* vertical shrinking factor */
+ Uint density; /* pixel density */
+ Uint flags; /* flags (see MDVI_PARAM macros) */
+ int hdrift; /* max. horizontal drift */
+ int vdrift; /* max. vertical drift */
+ int vsmallsp; /* small vertical space */
+ int thinsp; /* small horizontal space */
+ int layer; /* visible layer (for layered DVI files) */
+ Ulong fg; /* foreground color */
+ Ulong bg; /* background color */
+ DviOrientation orientation; /* page orientation */
+ int base_x;
+ int base_y;
+ Ulong *pixels; /* colors used for antialiasing */
+ int npixels; /* number of entries in `pixels' */
+};
+
+typedef enum {
+ MDVI_PARAM_LAST = 0,
+ MDVI_SET_DPI = 1,
+ MDVI_SET_XDPI = 2,
+ MDVI_SET_YDPI = 3,
+ MDVI_SET_SHRINK = 4,
+ MDVI_SET_XSHRINK = 5,
+ MDVI_SET_YSHRINK = 6,
+ MDVI_SET_GAMMA = 7,
+ MDVI_SET_DENSITY = 8,
+ MDVI_SET_MAGNIFICATION = 9,
+ MDVI_SET_DRIFT = 10,
+ MDVI_SET_HDRIFT = 11,
+ MDVI_SET_VDRIFT = 12,
+ MDVI_SET_ORIENTATION = 13,
+ MDVI_SET_FOREGROUND = 14,
+ MDVI_SET_BACKGROUND = 15
+} DviParamCode;
+
+struct _DviBuffer {
+ Uchar *data;
+ size_t size; /* allocated size */
+ size_t length; /* amount of data buffered */
+ size_t pos; /* current position in buffer */
+ int frozen; /* can we free this data? */
+};
+
+/* DVI registers */
+struct _DviState {
+ int h;
+ int v;
+ int hh;
+ int vv;
+ int w;
+ int x;
+ int y;
+ int z;
+};
+
+struct _DviColorPair {
+ Ulong fg;
+ Ulong bg;
+};
+
+struct _DviContext {
+ char *filename; /* name of the DVI file */
+ FILE *in; /* from here we read */
+ char *fileid; /* from preamble */
+ char *fallback_font; /* fallback font to use if one is not found */
+ int npages; /* number of pages */
+ int currpage; /* currrent page (0 based) */
+ int depth; /* recursion depth */
+ DviBuffer buffer; /* input buffer */
+ DviParams params; /* parameters */
+ DviPaper paper; /* paper type */
+ Int32 num; /* numerator */
+ Int32 den; /* denominator */
+ DviFontRef *fonts; /* fonts used in this file */
+ DviFontRef **fontmap; /* for faster id lookups */
+ DviFontRef *currfont; /* current font */
+ int nfonts; /* # of fonts used in this job */
+ Int32 dvimag; /* original magnification */
+ double dviconv; /* unshrunk scaling factor */
+ double dvivconv; /* unshrunk scaling factor (vertical) */
+ int dvi_page_w; /* unscaled page width */
+ int dvi_page_h; /* unscaled page height */
+ Ulong modtime; /* file modification time */
+ PageNum *pagemap; /* page table */
+ DviState pos; /* registers */
+ DviPageSpec *pagesel; /* page selection data */
+ int curr_layer; /* current layer */
+ DviState *stack; /* DVI stack */
+ int stacksize; /* stack depth */
+ int stacktop; /* stack pointer */
+ DviDevice device; /* device-specific routines */
+ Ulong curr_fg; /* rendering color */
+ Ulong curr_bg;
+ DviColorPair *color_stack;
+ DviHashTable assoc;
+ int color_top;
+ int color_size;
+ DviFontRef *(*findref) __PROTO((DviContext *, Int32));
+ void *user_data; /* client data attached to this context */
+};
+
+typedef enum {
+ MDVI_RANGE_BOUNDED, /* range is finite */
+ MDVI_RANGE_LOWER, /* range has a lower bound */
+ MDVI_RANGE_UPPER, /* range has an upper bound */
+ MDVI_RANGE_UNBOUNDED /* range has no bounds at all */
+} DviRangeType;
+
+struct _DviRange {
+ DviRangeType type; /* one of the above */
+ int from; /* lower bound */
+ int to; /* upper bound */
+ int step; /* step */
+};
+
+struct _DviAppConfig {
+ char *program;
+ char *fallback_font;
+ char *fgcolor;
+ char *bgcolor;
+ char *mfmode;
+ char *hrule_units;
+ char *vrule_units;
+ char *hmargin;
+ char *vmargin;
+ char *page_ranges;
+ char *fontspec;
+ char *fontunspec;
+ DviPaper paper;
+ DviPageSort page_sort;
+ DviParams params;
+ int first_page;
+ int use_tex_page;
+};
+
+/* in-memory configuration files */
+struct _DviConfValue {
+ DviConfValue *next;
+ char *key;
+ char *value;
+};
+
+struct _DviSection {
+ DviSection *next;
+ char *name;
+ long offset;
+ DviConfValue *keys;
+ DviHashTable table;
+};
+
+struct _DviConfig {
+ char *filename;
+ char *core;
+ DviSection *sections;
+ DviHashTable sectable;
+};
+
+
+
+typedef void (*DviSpecialHandler)
+ __PROTO((DviContext *dvi, const char *prefix, const char *arg));
+
+#define RANGE_HAS_LOWER(x) \
+ ((x) == MDVI_RANGE_BOUNDED || (x) == MDVI_RANGE_LOWER)
+#define RANGE_HAS_UPPER(x) \
+ ((x) == MDVI_RANGE_BOUNDED || (x) == MDVI_RANGE_UPPER)
+
+/*
+ * Macros and prototypes
+ */
+
+#define MDVI_PARAM_ANTIALIASED 1
+#define MDVI_PARAM_MONO 2
+#define MDVI_PARAM_CHARBOXES 4
+#define MDVI_PARAM_SHOWUNDEF 8
+#define MDVI_PARAM_DELAYFONTS 16
+
+/*
+ * The FALLBACK priority class is reserved for font formats that
+ * contain no glyph information and are to be used as a last
+ * resort (e.g. TFM, AFM)
+ */
+#define MDVI_FONTPRIO_FALLBACK -3
+#define MDVI_FONTPRIO_LOWEST -2
+#define MDVI_FONTPRIO_LOW -1
+#define MDVI_FONTPRIO_NORMAL 0
+#define MDVI_FONTPRIO_HIGH 1
+#define MDVI_FONTPRIO_HIGHEST 2
+
+#define MDVI_FONT_ENCODED (1 << 0)
+
+#define MDVI_GLYPH_EMPTY ((void *)1)
+/* does the glyph have a non-empty bitmap/image? */
+#define MDVI_GLYPH_NONEMPTY(x) ((x) && (x) != MDVI_GLYPH_EMPTY)
+/* has the glyph been loaded from disk? */
+#define MDVI_GLYPH_UNSET(x) ((x) == NULL)
+/* do we have only a bounding box for this glyph? */
+#define MDVI_GLYPH_ISEMPTY(x) ((x) == MDVI_GLYPH_EMPTY)
+
+#define MDVI_ENABLED(d,x) ((d)->params.flags & (x))
+#define MDVI_DISABLED(d,x) !MDVI_ENABLED((d), (x))
+
+#define MDVI_LASTPAGE(d) ((d)->npages - 1)
+#define MDVI_NPAGES(d) (d)->npages
+#define MDVI_VALIDPAGE(d,p) ((p) >= 0 && (p) <= MDVI_LASTPAGE(d))
+#define MDVI_FLAGS(d) (d)->params.flags
+#define MDVI_SHRINK_FROM_DPI(d) Max(1, (d) / 75)
+#define MDVI_CURRFG(d) (d)->curr_fg
+#define MDVI_CURRBG(d) (d)->curr_bg
+
+#define pixel_round(d,v) (int)((d)->params.conv * (v) + 0.5)
+#define vpixel_round(d,v) (int)((d)->params.vconv * (v) + 0.5)
+#define rule_round(d,v) (int)((d)->params.conv * (v) + 0.99999) /*9999999)*/
+#define vrule_round(d,v) (int)((d)->params.vconv * (v) + 0.99999)
+
+extern int mdvi_reload __PROTO((DviContext *, DviParams *));
+extern void mdvi_setpage __PROTO((DviContext *, int));
+extern int mdvi_dopage __PROTO((DviContext *, int));
+extern void mdvi_shrink_glyph __PROTO((DviContext *, DviFont *, DviFontChar *, DviGlyph *));
+extern void mdvi_shrink_box __PROTO((DviContext *, DviFont *, DviFontChar *, DviGlyph *));
+extern void mdvi_shrink_glyph_grey __PROTO((DviContext *, DviFont *, DviFontChar *, DviGlyph *));
+extern int mdvi_find_tex_page __PROTO((DviContext *, int));
+extern int mdvi_configure __PROTO((DviContext *, DviParamCode, ...));
+
+extern int get_tfm_chars __PROTO((DviParams *, DviFont *, TFMInfo *, int));
+extern int tfm_load_file __PROTO((const char *, TFMInfo *));
+extern int afm_load_file __PROTO((const char *, TFMInfo *));
+extern TFMInfo *get_font_metrics __PROTO((const char *, int, const char *));
+extern char *lookup_font_metrics __PROTO((const char *, int *));
+extern void free_font_metrics __PROTO((TFMInfo *));
+extern void flush_font_metrics __PROTO((void));
+
+#define get_metrics(name) get_font_metrics((name), DviFontAny, NULL)
+
+extern void mdvi_sort_pages __PROTO((DviContext *, DviPageSort));
+extern int mdvi_get_paper_size __PROTO((const char *, DviPaper *));
+extern DviPaperSpec* mdvi_get_paper_specs __PROTO((DviPaperClass));
+extern void mdvi_free_paper_specs __PROTO((DviPaperSpec *));
+
+/* Associations */
+extern int mdvi_assoc_put
+ __PROTO((DviContext *, char *, void *, DviFree2Func));
+extern void * mdvi_assoc_get __PROTO((DviContext *, char *));
+extern void * mdvi_assoc_del __PROTO((DviContext *, char *));
+extern void mdvi_assoc_free __PROTO((DviContext *, char *));
+extern void mdvi_assoc_flush __PROTO((DviContext *));
+
+extern int mdvi_check_config __PROTO((DviAppConfig *));
+extern void mdvi_init_kpathsea __PROTO((const char *, const char *, const char *, int));
+extern DviAppConfig *mdvi_init_app __PROTO((const char *, const char *));
+
+extern DviContext* mdvi_init_context __PROTO((DviParams *, DviPageSpec *, const char *));
+extern void mdvi_destroy_context __PROTO((DviContext *));
+
+/* helper macros that call mdvi_configure() */
+#define mdvi_config_one(d,x,y) mdvi_configure((d), (x), (y), MDVI_PARAM_LAST)
+#define mdvi_set_dpi(d,x) mdvi_config_one((d), MDVI_SET_DPI, (x))
+#define mdvi_set_xdpi(d,x) mdvi_config_one((d), MDVI_SET_XDPI, (x))
+#define mdvi_set_ydpi(d,x) mdvi_config_one((d), MDVI_SET_YDPI, (x))
+#define mdvi_set_hshrink(d,h) mdvi_config_one((d), MDVI_SET_XSHRINK, (h))
+#define mdvi_set_vshrink(d,h) mdvi_config_one((d), MDVI_SET_YSHRINK, (h))
+#define mdvi_set_gamma(d,g) mdvi_config_one((d), MDVI_SET_GAMMA, (g))
+#define mdvi_set_density(d,x) mdvi_config_one((d), MDVI_SET_DENSITY, (x))
+#define mdvi_set_drift(d,x) mdvi_config_one((d), MDVI_SET_DRIFT, (x))
+#define mdvi_set_hdrift(d,h) mdvi_config_one((d), MDVI_SET_HDRIFT, (h))
+#define mdvi_set_vdrift(d,v) mdvi_config_one((d), MDVI_SET_VDRIFT, (v))
+#define mdvi_set_mag(d,m) \
+ mdvi_config_one((d), MDVI_SET_MAGNIFICATION, (m))
+#define mdvi_set_foreground(d,x) \
+ mdvi_config_one((d), MDVI_SET_FOREGROUND, (x))
+#define mdvi_set_background(d,x) \
+ mdvi_config_one((d), MDVI_SET_BACKGROUND, (x))
+#define mdvi_set_orientation(d,x) \
+ mdvi_config_one((d), MDVI_SET_ORIENTATION, (x))
+#define mdvi_set_shrink(d,h,v) \
+ mdvi_configure((d), MDVI_SET_XSHRINK, (h), \
+ MDVI_SET_YSHRINK, (v), MDVI_PARAM_LAST)
+
+extern DviRange* mdvi_parse_range __PROTO((const char *, DviRange *, int *, char **));
+extern DviPageSpec* mdvi_parse_page_spec __PROTO((const char *));
+extern void mdvi_free_page_spec __PROTO((DviPageSpec *));
+extern int mdvi_in_range __PROTO((DviRange *, int, int));
+extern int mdvi_range_length __PROTO((DviRange *, int));
+extern int mdvi_page_selected __PROTO((DviPageSpec *, PageNum, int));
+
+/* Color support */
+extern void mdvi_set_color __PROTO((DviContext *, Ulong, Ulong));
+extern void mdvi_push_color __PROTO((DviContext *, Ulong, Ulong));
+extern void mdvi_pop_color __PROTO((DviContext *));
+extern void mdvi_reset_color __PROTO((DviContext *));
+
+/* Specials */
+extern int mdvi_register_special __PROTO((
+ const char *label,
+ const char *prefix,
+ const char *regex,
+ DviSpecialHandler handler,
+ int replace));
+extern int mdvi_unregister_special __PROTO((const char *prefix));
+extern int mdvi_do_special __PROTO((DviContext *dvi, char *dvi_special));
+extern void mdvi_flush_specials __PROTO((void));
+
+/* Fonts */
+
+#define MDVI_FONTSEL_BITMAP (1 << 0)
+#define MDVI_FONTSEL_GREY (1 << 1)
+#define MDVI_FONTSEL_GLYPH (1 << 2)
+
+#define FONTCHAR(font, code) \
+ (((code) < font->loc || (code) > font->hic || !(font)->chars) ? \
+ NULL : &font->chars[(code) - (font)->loc])
+#define FONT_GLYPH_COUNT(font) ((font)->hic - (font)->loc + 1)
+
+#define glyph_present(x) ((x) && (x)->offset)
+
+/* create a reference to a font */
+extern DviFontRef *font_reference __PROTO((DviParams *params,
+ Int32 dvi_id,
+ const char *font_name,
+ Int32 checksum,
+ int xdpi,
+ int ydpi,
+ Int32 scale_factor));
+
+/* drop a reference to a font */
+extern void font_drop_one __PROTO((DviFontRef *));
+
+/* drop a chain of references */
+extern void font_drop_chain __PROTO((DviFontRef *));
+
+/* destroy selected information for a glyph */
+extern void font_reset_one_glyph __PROTO((DviDevice *, DviFontChar *, int));
+
+/* destroy selected information for all glyphs in a font */
+extern void font_reset_font_glyphs __PROTO((DviDevice *, DviFont *, int));
+
+/* same for a chain of font references */
+extern void font_reset_chain_glyphs __PROTO((DviDevice *, DviFontRef *, int));
+
+extern void font_finish_definitions __PROTO((DviContext *));
+
+/* lookup an id # in a reference chain */
+extern DviFontRef* font_find_flat __PROTO((DviContext *, Int32));
+extern DviFontRef* font_find_mapped __PROTO((DviContext *, Int32));
+
+/* called to reopen (or rewind) a font file */
+extern int font_reopen __PROTO((DviFont *));
+
+/* reads a glyph from a font, and makes all necessary transformations */
+extern DviFontChar* font_get_glyph __PROTO((DviContext *, DviFont *, int));
+
+/* transform a glyph according to the given orientation */
+extern void font_transform_glyph __PROTO((DviOrientation, DviGlyph *));
+
+/* destroy all fonts that are not being used, returns number of fonts freed */
+extern int font_free_unused __PROTO((DviDevice *));
+
+#define font_free_glyph(dev, font, code) \
+ font_reset_one_glyph((dev), \
+ FONTCHAR((font), (code)), MDVI_FONTSEL_GLYPH)
+
+extern int mdvi_encode_font __PROTO((DviParams *, DviFont *));
+
+/* Hash tables */
+#define MDVI_HASH_REPLACE 0
+#define MDVI_HASH_UNIQUE 1
+#define MDVI_HASH_UNCHECKED 2
+
+extern void mdvi_hash_init __PROTO((DviHashTable *));
+extern void mdvi_hash_create __PROTO((DviHashTable *, int));
+extern int mdvi_hash_add __PROTO((DviHashTable *, DviHashKey, void *, int));
+extern int mdvi_hash_destroy_key __PROTO((DviHashTable *, DviHashKey));
+extern void mdvi_hash_reset __PROTO((DviHashTable *, int));
+extern void *mdvi_hash_lookup __PROTO((DviHashTable *, DviHashKey));
+extern void *mdvi_hash_remove __PROTO((DviHashTable *, DviHashKey));
+extern void *mdvi_hash_remove_ptr __PROTO((DviHashTable *, DviHashKey));
+
+#define mdvi_hash_flush(h) mdvi_hash_reset((h), 1)
+#define mdvi_hash_destroy(h) mdvi_hash_reset((h), 0)
+
+/* font lookup functions */
+extern int mdvi_register_font_type __PROTO((DviFontInfo *, int));
+extern char **mdvi_list_font_class __PROTO((int));
+extern int mdvi_get_font_classes __PROTO((void));
+extern int mdvi_unregister_font_type __PROTO((const char *, int));
+extern char *mdvi_lookup_font __PROTO((DviFontSearch *));
+extern DviFont *mdvi_add_font __PROTO((const char *, Int32, int, int, Int32));
+extern int mdvi_font_retry __PROTO((DviParams *, DviFont *));
+
+/* configuration files */
+extern DviConfig *mdvi_read_config __PROTO((const char *));
+extern DviSection *mdvi_find_section __PROTO((DviConfig *, const char *));
+extern int mdvi_destroy_section __PROTO((DviConfig *, DviSection *));
+extern void mdvi_destroy_config __PROTO((DviConfig *));
+
+/* Miscellaneous */
+
+extern DviOrientation mdvi_get_orientation __PROTO((const char *));
+extern int mdvi_get_integer __PROTO((const char *, long *));
+extern int mdvi_get_float __PROTO((const char *, double *));
+extern long mdvi_get_integer_env __PROTO((const char *, long));
+extern double mdvi_get_float_env __PROTO((const char *, double));
+extern char* mdvi_get_string_env __PROTO((const char *, char *));
+extern void mdvi_get_params_env __PROTO((DviParams *));
+
+extern int mdvi_set_logfile __PROTO((const char *));
+extern int mdvi_set_logstream __PROTO((FILE *));
+extern int mdvi_set_loglevel __PROTO((int));
+
+#define mdvi_stop_logging(x) mdvi_set_logstream(NULL)
+
+extern int mdvi_get_pagesort __PROTO((const char *));
+extern int mdvi_get_debugmask __PROTO((const char *));
+extern DviOrientation mdvi_getorient __PROTO((const char *));
+extern int mdvi_getint __PROTO((const char *, long *));
+extern int mdvi_getfloat __PROTO((const char *, double *));
+extern int mdvi_getenv_int __PROTO((const char *, int));
+extern double mdvi_getenv_float __PROTO((const char *, double));
+extern char* mdvi_getenv_string __PROTO((const char *, char *));
+
+/* this will check the environment and then `texmf.cnf' for
+ * the given name changed to lowercase, and `_' changed to `-' */
+extern char* mdvi_getenv __PROTO((const char *));
+
+#endif /* _MDVI_DVI_H */
diff --git a/dviware/mdvi/include/private.h b/dviware/mdvi/include/private.h
new file mode 100644
index 0000000000..261a91172e
--- /dev/null
+++ b/dviware/mdvi/include/private.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2000, Matias Atria
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#ifndef _MDVI_PRIVATE_H
+#define _MDVI_PRIVATE_H 1
+
+#define HAVE_PROTOTYPES 1
+#include <kpathsea/debug.h>
+#include <kpathsea/tex-file.h>
+#include <kpathsea/tex-glyph.h>
+#include <kpathsea/cnf.h>
+#include <kpathsea/proginit.h>
+#include <kpathsea/progname.h>
+
+#define ISSP(p) (*(p) == ' ' || *(p) == '\t')
+#define SKIPSP(p) while(ISSP(p)) p++
+#define SKIPNSP(p) while(*(p) && !ISSP(p)) p++
+
+#ifdef ENABLE_NLS
+#include <libintl.h>
+#define _(x) gettext(x)
+#define _G(x) x
+#else
+#define _(x) x
+#define _G(x) x
+#endif /* ENABLE_NLS */
+
+#if defined (__i386__) && defined (__GNUC__) && __GNUC__ >= 2
+#define _BREAKPOINT() do { __asm__ __volatile__ ("int $03"); } while(0)
+#elif defined (__alpha__) && defined (__GNUC__) && __GNUC__ >= 2
+#define _BREAKPOINT() do { __asm__ __volatile__ ("bpt"); } while(0)
+#else /* !__i386__ && !__alpha__ */
+#define _BREAKPOINT()
+#endif /* __i386__ */
+
+#endif /* _MDVI_PRIVATE_H */
diff --git a/dviware/mdvi/include/sysdeps.h b/dviware/mdvi/include/sysdeps.h
new file mode 100644
index 0000000000..a59f7e1033
--- /dev/null
+++ b/dviware/mdvi/include/sysdeps.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2000, Matias Atria
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#ifndef _SYSDEP_H
+#define _SYSDEP_H 1
+
+/*
+ * The purpose of this file is to define symbols that describe the
+ * system-dependent features we use. Namely, byte order, native integer
+ * types of various sizes, and safe pointer<->integer conversion.
+ */
+
+#include "config.h"
+
+#ifdef WORDS_BIGENDIAN
+#define WORD_BIG_ENDIAN 1
+#else
+#define WORD_LITTLE_ENDIAN 1
+#endif
+
+typedef unsigned long Ulong;
+typedef unsigned int Uint;
+typedef unsigned short Ushort;
+typedef unsigned char Uchar;
+
+/* this one's easy */
+typedef unsigned char Uint8;
+typedef char Int8;
+
+/* define a datatype for 32bit integers (either int or long) */
+#if SIZEOF_LONG == 4
+typedef unsigned long Uint32;
+typedef long Int32;
+#else /* SIZEOF_LONG != 4 */
+#if SIZEOF_INT == 4
+typedef unsigned int Uint32;
+typedef int Int32;
+#else /* SIZEOF_INT != 4 */
+#ifdef __cplusplus
+#include "No.appropriate.32bit.native.type.found.Fix.sysdeps.h"
+#else
+#error No appropriate 32bit native type found. Fix sysdeps.h
+#endif /* ! __cplusplus */
+#endif /* SIZEOF_INT != 4 */
+#endif /* SIZEOF_LONG != 4 */
+
+/* now 16bit integers (one of long, int or short) */
+#if SIZEOF_SHORT == 2
+typedef unsigned short Uint16;
+typedef short Int16;
+#else /* SIZEOF_SHORT != 2 */
+#if SIZEOF_INT == 2
+typedef unsigned int Uint16;
+typedef short Int16;
+#else /* SIZEOF_INT != 2 */
+#ifdef __cplusplus
+#include "No.appropriate.16bit.native.type.found.Fix.sysdeps.h"
+#else
+#error No appropriate 16bit native type found. Fix sysdeps.h
+#endif /* ! __cplusplus */
+#endif /* SIZEOF_INT != 2 */
+#endif /* SIZEOF_SHORT != 2 */
+
+/*
+ * An integer type to convert to and from pointers safely. All we do here is
+ * look for an integer type with the same size as a pointer.
+ */
+#if SIZEOF_LONG == SIZEOF_VOID_P
+typedef unsigned long UINT;
+typedef long INT;
+#else
+#if SIZEOF_INT == SIZEOF_VOID_P
+typedef unsigned int UINT;
+typedef int INT;
+#else
+#if SIZEOF_SHORT == SIZEOF_VOID_P
+typedef unsigned short UINT;
+typedef short INT;
+#else
+#ifdef __cplusplus
+#include "No.native.pointer-compatible.integer.type.found.Fix.sysdeps.h"
+#else
+#error No native pointer-compatible integer type found. Fix sysdeps.h
+#endif
+#endif
+#endif
+#endif
+
+/* nice, uh? */
+typedef void *Pointer;
+
+/* macros to do the safe pointer <-> integer conversions */
+#define Ptr2Int(x) ((INT)((Pointer)(x)))
+#define Int2Ptr(x) ((Pointer)((INT)(x)))
+
+#ifdef _NO_PROTO
+#define __PROTO(x) ()
+#else
+#define __PROTO(x) x
+#endif
+
+#ifdef WITH_REGEX_SPECIALS
+/* if we don't have regexec(), there's no point in this */
+#ifndef HAVE_REGEXEC
+#undef WITH_REGEX_SPECIALS
+#endif
+#endif
+
+#ifdef WITH_TYPE1_FONTS
+/* if we don't have the t1lib library, undefine this */
+#ifndef T1LIB_VERSION
+#undef WITH_TYPE1_FONTS
+#endif
+#endif
+
+#endif /* _SYSDEP_H */