/*
* This program is Copyright (C) 1987 by the Board of Trustees of the
* University of Illinois, and by the author Dirk Grunwald.
*
* This program may be freely copied, as long as this copyright
* message remaines affixed. It may not be sold, altough it may
* be distributed with other software which is sold. If the
* software is distributed, the source code must be made available.
*
* No warrenty, expressed or implied, is given with this software.
* It is presented in the hope that it will prove useful.
*/
#include <sys/types.h>
#include <X/Xlib.h>
#include <X/Xutil.h>
#include <X/cursorfont.h>
#include <stdio.h>
#include <ctype.h>
#include "dvistuff.h"
/*
* These constants may need to be changed on your implementation
*/
#define BitsPerByte 8
#define BitsPerShort 16
#define BytesPerShort (sizeof(short))
#define BitsPerByteMask 0x7
#define BitsPerByteShift 3
#define BytesPerShot 2
/*
* Note that ROUNDUP evaluates Y twice.
*/
#define ROUNDUP(x,y) (((x)+(y)-1) / (y))
int debug = 0;
static int obscured = 1;
/*
* X-11 related variables
*/
Display *DISP;
static Window win;
static int backpix;
static GC highpix, forepix;
static GC specialGC;
static int defaultScreen;
static Cursor workingCursor;
static Cursor readyCursor;
/*
* TeX-Dvi related variables
*/
static int rawDviHeight;
static int rawDviWidth; /* part of X interface, not dvistuff */
static int maxHeight;
static int maxWidth;
static int screenWidth, screenHeight;
#define MAX_LEAVES 2
#define LEAF_LEFT 0
#define LEAF_RIGHT 1
static int Leaves;
static int currentLeaf = 0;
static int pageOnLeaf[MAX_LEAVES] = {-1,-1};
static int haveLargePage[MAX_LEAVES] = {-1, -1};
#define SHRINK_NORMAL 0
#define SHRINK_LARGE 1
#define MAX_SHRINKS 2
static int page_w[MAX_SHRINKS], page_h[MAX_SHRINKS];
static int leaf_w[MAX_SHRINKS];
static int shrinkFactor[MAX_SHRINKS];
static int currentShrink;
static struct glyph **shrunkenGlyphs[MAX_SHRINKS][MAX_FONTFAMILY];
static XImage **shrunkenImages[MAX_SHRINKS][MAX_FONTFAMILY];
static int reverse = 0;
static double specialConv;
char *malloc(), *calloc(), *index();
#define MAX(a,b) ((a) < (b)) ? (b) : (a)
#define MIN(a,b) ((a) < (b)) ? (a) : (b)
/*
* I don't know why this is needed, but our sun seems to thing
* and is or & vice versa
*/
#ifdef mc68000
#define GXAND GXand
#define GXOR GXor
#else
#define GXAND GXor
#define GXOR GXand
#endif
main(argc, argv)
int argc;
char **argv;
{
int xargc=argc;
char **xargv=argv;
char *file;
char *display = NULL;
char *option;
int bwidth = 2;
char *fore_color;
char *back_color;
char *high_color;
char *brdr_color;
char *mous_color;
char *geometry = NULL, def[32];
int bdrpix, mouspix;
XColor cdef;
XSizeHints hints;
XSetWindowAttributes xswattrs;
unsigned long xswattrs_mask;
double atof();
char *getenv();
ProgName = *argv;
argv++;
argc--;
if ((DISP = XOpenDisplay(display)) == NULL) {
fprintf(stderr, "[%s] Can't open display '%s'\n",
ProgName, XDisplayName(display));
exit(1);
}
if ((option = XGetDefault(DISP, ProgName, "ReverseVideo")) &&
strcmp(option, "on") == 0)
reverse = 1;
if (option = XGetDefault(DISP, ProgName, "BorderWidth"))
bwidth = atoi(option);
fore_color = XGetDefault(DISP, ProgName, "ForeGround");
back_color = XGetDefault(DISP, ProgName, "BackGround");
high_color = XGetDefault(DISP, ProgName, "Highlight");
brdr_color = XGetDefault(DISP, ProgName, "Border");
mous_color = XGetDefault(DISP, ProgName, "Mouse");
option = XGetDefault(DISP, ProgName, "NormalShrink");
shrinkFactor[SHRINK_NORMAL] = (option == 0) ? 0 : atoi(option);
option = XGetDefault(DISP, ProgName, "LargeShrink");
shrinkFactor[SHRINK_LARGE] = (option == 0) ? 0 : atoi(option);
option = XGetDefault(DISP, ProgName, "Blackness");
dviBlackness = (option == 0) ? DEFAULT_BLACKNESS : atoi(option);
option = XGetDefault(DISP, ProgName, "Leaves");
Leaves = (option == 0) ? 0 : atoi(option);
option = XGetDefault(DISP, ProgName, "Dpi");
dviDPI = (option == 0) ? DEFAULT_DPI : atoi(option);
option = XGetDefault(DISP, ProgName, "TopMargin");
dviVVMargin = (option == 0) ? DEFAULT_VVMARGIN : atof(option) * dviDPI;
option = XGetDefault(DISP, ProgName, "SideMargin");
dviHHMargin = (option == 0) ? DEFAULT_HHMARGIN : atof(option) * dviDPI;
file = NULL;
while (argc) {
if (strcmp(*argv, "-p") == 0 && argc > 1) {
argv++;
argc--;
dviDPI = atoi(*argv);
if (dviDPI <= 0) goto usage;
} else if (strcmp(*argv, "-rv") == 0) {
reverse = !reverse;
} else if (strcmp(*argv, "-bw") == 0 && argc > 1) {
argv++;
argc--;
bwidth = atoi(*argv);
} else if (strcmp(*argv, "-fg") == 0 && argc > 1) {
argv++;
argc--;
fore_color = *argv;
} else if (strcmp(*argv, "-bg") == 0 && argc > 1) {
argv++;
argc--;
back_color = *argv;
} else if (strcmp(*argv, "-hl") == 0 && argc > 1) {
argv++;
argc--;
high_color = *argv;
} else if (strcmp(*argv, "-bd") == 0 && argc > 1) {
argv++;
argc--;
brdr_color = *argv;
} else if (strcmp(*argv, "-ms") == 0 && argc > 1) {
argv++;
argc--;
mous_color = *argv;
} else if (strcmp(*argv,"-l") == 0 && argc > 1) {
argv++;
argc--;
Leaves = atoi(*argv);
if( Leaves < 1 || Leaves > MAX_LEAVES) {
fprintf(stderr,"[%s] Bad number of leaves(%d), using %d\n",
ProgName, Leaves, MAX_LEAVES);
Leaves = MAX_LEAVES;
}
} else if (strcmp(*argv,"-ns") == 0 && argc > 1) {
argv++;
argc--;
shrinkFactor[SHRINK_NORMAL] = atoi(*argv);
} else if (strcmp(*argv,"-ls") == 0 && argc > 1) {
argv++;
argc--;
shrinkFactor[SHRINK_LARGE] = atoi(*argv);
} else if (strcmp(*argv,"-bl") == 0 && argc > 1) {
argv++;
argc--;
dviBlackness = atoi(*argv);
} else if (strcmp(*argv,"-dpi") == 0 && argc > 1) {
argv++;
argc--;
dviDPI = atoi(*argv);
} else if (strcmp(*argv,"-tm") == 0 && argc > 1) {
argv++;
argc--;
dviVVMargin = dviDPI * atof(*argv);
} else if (strcmp(*argv,"-sm") == 0 && argc > 1) {
argv++;
argc--;
dviHHMargin = dviDPI * atof(*argv);
} else if (**argv == '=') {
geometry = *argv;
} else if (**argv != '-') {
if (index(*argv, ':') != NULL)
display = *argv;
else
file = *argv;
} else {
usage:
fprintf(stderr, "Usage: %s [-s <shrink>] [-l <leaves>] [-rv] [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>] [-ms <color>] [=<geometry>] [host:display] dviFile\n",
ProgName);
exit(1);
}
argv++;
argc--;
}
if (file == NULL)
goto usage;
if ((dviFile = fopen(file, "r")) == NULL) {
int n = strlen(file);
char *dvi_name;
if (strcmp(file + n - sizeof(".dvi") + 1, ".dvi") == 0) {
perror(file);
exit(1);
}
dvi_name = malloc((unsigned) n + sizeof(".dvi"));
sprintf(dvi_name, "%s.dvi", file);
if ((dviFile = fopen(dvi_name, "r")) == NULL) {
perror(dvi_name);
exit(1);
}
}
dviInit();
specialConv = (float) dviDPI / 1000.0;
/*
* If no shrink factor was chosen, pick one which will work out nicely
* on their display
*/
defaultScreen = XDefaultScreen(DISP);
maxHeight = XDisplayHeight(DISP, defaultScreen) - 2 * bwidth;
maxWidth = XDisplayWidth(DISP, defaultScreen) - 2 * bwidth;
rawDviHeight = dviTallestPage + 2 * dviVVMargin;
rawDviWidth = dviWidestPage + 2 * dviHHMargin;
if (Leaves == 0) {
if (dviTotalPages == 1) {
Leaves = 1;
} else {
Leaves = 2;
}
}
if (shrinkFactor[SHRINK_NORMAL] == 0) {
int sH;
int sW;
int sH2;
int sW2;
int shrink2;
sH = (rawDviHeight + maxHeight - 1) / maxHeight;
sW = (Leaves * rawDviWidth + maxWidth - 1) / maxWidth;
shrinkFactor[SHRINK_NORMAL] = MAX(sW, sH);
shrinkFactor[SHRINK_NORMAL] = MAX(shrinkFactor[SHRINK_NORMAL], 1);
/*
* Check to see if we can get another shrink size bigger display
* if we cut the margins.
*/
sH2 = (dviTallestPage + (dviHHMargin/32) + maxHeight - 1)
/ maxHeight;
sW2 = ( Leaves * (dviWidestPage + (dviVVMargin/32))
+ maxHeight - 1) / maxHeight;
shrink2 = MAX(sH2, sW2);
shrink2 = MAX(shrink2, 1);
if (shrink2 < shrinkFactor[SHRINK_NORMAL]) {
dviVVMargin /= 32;
dviHHMargin /= 32;
rawDviHeight = dviTallestPage + 2 * dviVVMargin;
rawDviWidth = dviWidestPage + 2 * dviHHMargin;
shrinkFactor[SHRINK_NORMAL] = shrink2;
}
}
page_h[SHRINK_NORMAL]=(rawDviHeight + shrinkFactor[SHRINK_NORMAL] - 1)
/ shrinkFactor[SHRINK_NORMAL];
leaf_w[SHRINK_NORMAL]=(rawDviWidth + shrinkFactor[SHRINK_NORMAL] - 1)
/ shrinkFactor[SHRINK_NORMAL];
/*
* Based on the shrink factor, choose a shrink factor for the enlarged
* display
*/
if (shrinkFactor[SHRINK_LARGE] == 0) {
shrinkFactor[SHRINK_LARGE] = shrinkFactor[SHRINK_NORMAL] / 2;
}
shrinkFactor[SHRINK_LARGE] = MIN(shrinkFactor[SHRINK_LARGE],
shrinkFactor[SHRINK_NORMAL]-1);
shrinkFactor[SHRINK_LARGE] = MAX(shrinkFactor[SHRINK_LARGE], 1);
page_h[SHRINK_LARGE]=(rawDviHeight + shrinkFactor[SHRINK_LARGE] - 1)
/ shrinkFactor[SHRINK_LARGE];
leaf_w[SHRINK_LARGE]=(rawDviWidth + shrinkFactor[SHRINK_LARGE] - 1)
/ shrinkFactor[SHRINK_LARGE];
/*
* Compute the page size given the number of leaves. We may have
* to scale back if everything can't fit.
*/
if (leaf_w[SHRINK_NORMAL] * Leaves <= maxWidth) {
page_w[SHRINK_NORMAL] = leaf_w[SHRINK_NORMAL] * Leaves;
} else {
page_w[SHRINK_NORMAL] = leaf_w[SHRINK_NORMAL];
Leaves = 1;
}
screenWidth = (page_w[SHRINK_NORMAL] > maxWidth)
? maxWidth : page_w[SHRINK_NORMAL];
screenHeight = (page_h[SHRINK_NORMAL] > maxHeight)
? maxHeight : page_h[SHRINK_NORMAL];
highpix = XCreateGC(DISP, RootWindow(DISP, defaultScreen), 0, NULL);
forepix = XCreateGC(DISP, RootWindow(DISP, defaultScreen), 0, NULL);
XCopyGC(DISP, DefaultGC(DISP, 0), (1L<<(GCLastBit+1))-1, highpix);
XCopyGC(DISP, highpix, (1L<<(GCLastBit+1))-1, forepix);
if (reverse) {
XSetForeground(DISP, forepix, WhitePixel(DISP, defaultScreen));
XSetForeground(DISP, highpix, WhitePixel(DISP, defaultScreen));
backpix = BlackPixel(DISP, defaultScreen);
bdrpix = WhitePixel(DISP, defaultScreen);
mouspix = WhitePixel(DISP, defaultScreen);
XSetFunction(DISP, forepix, GXAND); /* or */
XSetFunction(DISP, highpix, GXAND);
} else {
XSetForeground(DISP, forepix, BlackPixel(DISP, defaultScreen));
XSetForeground(DISP, highpix, BlackPixel(DISP, defaultScreen));
backpix = WhitePixel(DISP, defaultScreen);
bdrpix = BlackPixel(DISP, defaultScreen);
mouspix = BlackPixel(DISP, defaultScreen);
XSetFunction(DISP, forepix, GXOR); /* and */
XSetFunction(DISP, highpix, GXOR);
}
if (DisplayCells(DISP, 0) > 2) {
Colormap dcm = DefaultColormap(DISP, defaultScreen);
if (fore_color
&& XParseColor(DISP, dcm, fore_color, &cdef)
&& XAllocColor(DISP, dcm, &cdef)) {
XSetForeground(DISP, forepix, cdef.pixel);
}
if (back_color
&& XParseColor(DISP, dcm, back_color, &cdef)
&& XAllocColor(DISP, dcm, &cdef)) {
backpix = cdef.pixel;
}
if (high_color
&& XParseColor(DISP, dcm, high_color, &cdef)
&& XAllocColor(DISP, dcm, &cdef)) {
XSetForeground(DISP, highpix, cdef.pixel);
}
if (brdr_color
&& XParseColor(DISP, dcm, brdr_color, &cdef)
&& XAllocColor(DISP, dcm, &cdef))
{
/* null statement? */
}
if (mous_color
&& XParseColor(DISP, dcm, mous_color, &cdef)
&& XAllocColor(DISP, dcm, &cdef)) {
mouspix = cdef.pixel;
}
}
XSetBackground(DISP, forepix, backpix);
XSetBackground(DISP, highpix, backpix);
sprintf(def, "=%dx%d+0+0", screenWidth, screenHeight);
hints.width = page_w[SHRINK_NORMAL];
hints.height = page_h[SHRINK_NORMAL];
hints.x = 0; hints.y = 0;
hints.flags = (PSize | PPosition);
xswattrs.border_pixel = bdrpix;
xswattrs.background_pixel = backpix;
xswattrs_mask = (CWBackPixel|CWBorderPixel);
win = XCreateWindow(DISP, RootWindow(DISP, defaultScreen),
0, 0,
screenWidth, screenHeight,
bdrpix,
0, /* depth from parent */
InputOutput,
CopyFromParent,
xswattrs_mask,
&xswattrs);
XSetStandardProperties(DISP, win,
ProgName, "DVI Previewer",
None,
argv, argc, &hints);
XMapRaised(DISP, win);
XSelectInput(DISP, win,
KeyPressMask|ButtonPressMask | ButtonReleaseMask
|ExposureMask | VisibilityChangeMask);
workingCursor = XCreateFontCursor(DISP, XC_watch);
readyCursor = XCreateFontCursor(DISP, XC_spraycan);
XDefineCursor(DISP, win, workingCursor);
XFlush(DISP);
specialGC = XCreateGC(DISP, RootWindow(DISP, defaultScreen), 0, NULL);
XCopyGC(DISP, forepix, (1L<<(GCLastBit+1))-1, specialGC);
mainLoop();
stop_output(0);
}
/*
* Pixmap manipulation routines
*/
static Pixmap pasteUpPixmap[MAX_SHRINKS][MAX_LEAVES];
static GC pasteFillGC;
static GC pasteCopyGC;
static int largePixmapsAllocated = 0;
/*
* Ideally, we'd like to paint up a local pixmap & then transmit the
* entire pixmap. However, it looks like pixmaps require interaction
* with the server.
*
* So, if the entire page fits on the screen, we'll paint the screen
* and when we're done, we'll copy the screen to the pixmap. This
* gives the illusion of progress, but allows us to do fast re-paints.
*
* If we're *not* on the display, we'll just draw to the pixmap and
* update it at the end
*/
static int buildToPixmap = 1;
static void
clearPixmap(leaf, shrinkSize)
int leaf;
int shrinkSize;
{
if (leaf< 0 || leaf >= Leaves) {
fprintf(stderr,"[%s] Reference to bogus leaf in clearPixmap: %d\n",
ProgName, leaf);
exit(1);
}
if (shrinkSize < 0 || shrinkSize >= MAX_SHRINKS ) {
fprintf(stderr,"[%s] reference to bogus shrink %d\n",
ProgName, shrinkSize);
exit(1);
}
XFillRectangle(DISP, pasteUpPixmap[shrinkSize][leaf], pasteFillGC, 0, 0,
leaf_w[shrinkSize], page_h[shrinkSize]);
}
static void
clearWindow(leaf)
int leaf;
{
XFillRectangle(DISP, win, pasteFillGC,
leaf * leaf_w[SHRINK_NORMAL], 0,
leaf_w[SHRINK_NORMAL], page_h[SHRINK_NORMAL]);
}
allocatePixmaps()
{
int i;
for (i = 0; i < Leaves; i++ ) {
pasteUpPixmap[SHRINK_NORMAL][i] =
XCreatePixmap(DISP, win, leaf_w[SHRINK_NORMAL],
page_h[SHRINK_NORMAL], 1);
if (pasteUpPixmap[SHRINK_NORMAL][i] == 0) {
fprintf(stderr,"[%s] erp! out of PIXMAP memory!\n",
ProgName);
exit(1);
}
}
largePixmapsAllocated = 0;
if (pasteFillGC == 0) {
pasteFillGC = XCreateGC(DISP, RootWindow(DISP, defaultScreen),0,NULL);
pasteCopyGC = XCreateGC(DISP, RootWindow(DISP, defaultScreen),0,NULL);
XCopyGC(DISP, forepix, (1L<<(GCLastBit+1))-1, pasteFillGC);
XCopyGC(DISP, forepix, (1L<<(GCLastBit+1))-1, pasteCopyGC);
if (reverse) {
XSetForeground(DISP, pasteFillGC, BlackPixel(DISP, defaultScreen));
} else {
XSetForeground(DISP, pasteFillGC, WhitePixel(DISP, defaultScreen));
}
XSetFunction(DISP, pasteFillGC, GXcopy);
XSetFunction(DISP, pasteCopyGC, GXcopy);
}
/*
* Clear the pixmap
*/
for (i = 0; i < Leaves; i++) {
clearPixmap(i, SHRINK_NORMAL);
}
}
allocateLargePixmaps()
{
int i;
for (i = 0; i < Leaves; i++) {
pasteUpPixmap[SHRINK_LARGE][i] =
XCreatePixmap(DISP, win, leaf_w[SHRINK_LARGE],
page_h[SHRINK_LARGE], 1);
clearPixmap(i, SHRINK_LARGE);
}
largePixmapsAllocated = 1;
}
/*
* display the normal sized leaf
*/
static void
displayLeaves()
{
int leaf;
XClearWindow(DISP,win);
for (leaf = 0; leaf < Leaves; leaf++) {
XCopyArea(DISP, pasteUpPixmap[SHRINK_NORMAL][leaf], win, forepix,
0, 0,
leaf_w[SHRINK_NORMAL], page_h[SHRINK_NORMAL],
leaf_w[SHRINK_NORMAL] * leaf, 0);
}
}
static void displayLeaf(leaf)
int leaf;
{
clearWindow(leaf);
XCopyArea(DISP, pasteUpPixmap[SHRINK_NORMAL][leaf], win, forepix,
0, 0,
leaf_w[SHRINK_NORMAL], page_h[SHRINK_NORMAL],
leaf_w[SHRINK_NORMAL] * leaf, 0);
}
static void
swapLeaf(from, to)
int from;
int to;
{
Pixmap tempPix;
int tempNum;
if (to < 0 || to >= Leaves) {
fprintf(stderr,"[%s] bogus to leaf %d in swapLeaf\n",
ProgName, to);
exit(1);
}
if (from < 0 || from >= Leaves) {
fprintf(stderr,"[%s] bogus from leaf %d in swapLeaf\n",
ProgName, from);
exit(1);
}
tempPix = pasteUpPixmap[SHRINK_NORMAL][to];
pasteUpPixmap[SHRINK_NORMAL][to] = pasteUpPixmap[SHRINK_NORMAL][from];
pasteUpPixmap[SHRINK_NORMAL][from] = tempPix;
tempPix = pasteUpPixmap[SHRINK_LARGE][to];
pasteUpPixmap[SHRINK_LARGE][to] = pasteUpPixmap[SHRINK_LARGE][from];
pasteUpPixmap[SHRINK_LARGE][from] = tempPix;
tempNum = pageOnLeaf[to];
pageOnLeaf[to] = pageOnLeaf[from];
pageOnLeaf[from] = tempNum;
tempNum = haveLargePage[to];
haveLargePage[to] = haveLargePage[from];
haveLargePage[from] = tempNum;
}
static void
buildLeaf(leaf, page, shrinkSize)
int leaf;
int page;
int shrinkSize;
{
XDefineCursor(DISP, win, workingCursor);
if (leaf < 0 || leaf >= Leaves) {
fprintf(stderr,"[%s] bogus leaf %d in buildLeaf\n",
ProgName, leaf);
exit(1);
}
if (shrinkSize < 0 || shrinkSize >= MAX_SHRINKS ) {
fprintf(stderr,"[%s] Bogus shrink size %d in buildLeaf\n",
ProgName, shrinkSize);
exit(1);
}
if (shrinkSize == SHRINK_LARGE && !largePixmapsAllocated) {
allocateLargePixmaps();
}
/*
* If this is a normal size page, kill the information
* for the large version.
*/
if (shrinkSize == SHRINK_NORMAL) {
haveLargePage[leaf] = -1;
}
/*
* Determine if this is a valid page. If it's not, we'll just clear
* the particular leaf.
*/
if (page < 0 || page >= dviTotalPages) {
clearPixmap(leaf, shrinkSize);
if (shrinkSize == SHRINK_NORMAL) {
clearWindow(leaf);
}
} else {
if (obscured || shrinkSize == SHRINK_LARGE) {
buildToPixmap = 1;
} else {
buildToPixmap = 0;
}
if (buildToPixmap) {
clearPixmap(leaf, shrinkSize);
} else {
clearPixmap(leaf, shrinkSize);
if (shrinkSize == SHRINK_NORMAL) {
clearWindow(leaf);
}
}
/*
* Note that dviPreparePage may change dviCurrentPage
*/
currentLeaf = leaf;
currentShrink = shrinkSize;
dviPreparePage(page);
page = dviCurrentPage;
/*
* Save the constructed page if we were painting it to the screen
*/
put_border(0, 0, leaf_w[currentShrink], page_h[currentShrink], 1);
if (! buildToPixmap && shrinkSize == SHRINK_NORMAL) {
XCopyArea(DISP, win, pasteUpPixmap[SHRINK_NORMAL][leaf], forepix,
leaf * leaf_w[currentShrink], 0,
screenWidth, screenHeight, 0,0);
} else if (shrinkSize == SHRINK_NORMAL) {
displayLeaf(leaf);
}
}
pageOnLeaf[leaf] = dviCurrentPage;
XDefineCursor(DISP, win, readyCursor);
XFlush(DISP);
}
/*
* interfaces to dvistuff
*/
/*
* Whenever a new font is registers, we create a shrunken Glyph
* table for it. However, we don't shrink the glyphs -- that's
* done on the fly by the putChar routine.
*/
DviFont *
applicationNewFont(f, key)
struct font *f;
int key;
{
int shrink;
if (key < 0 || key > MAX_FONTFAMILY) {
fprintf(stderr,"[%s] bogus key in Newfont = %d\n",
ProgName, key);
exit(1);
}
for (shrink = SHRINK_NORMAL; shrink <= SHRINK_LARGE; shrink++) {
if (shrunkenGlyphs[shrink][key] == 0) {
int lth = sizeof(struct glyph *) * MAX_GLYPH;
struct glyph **g;
g = (struct glyph **) malloc( lth );
bzero(g, lth);
shrunkenGlyphs[shrink][key] = g;
}
if (shrunkenImages[shrink][key] == 0) {
int lth = sizeof(XImage *) * MAX_GLYPH;
XImage **image;
image = (XImage **) malloc(lth);
bzero(image, lth);
shrunkenImages[shrink][key] = image;
}
}
return(f);
}
/*
* When we reset a font, we only need to free the storage for the
* shrunken glyphs. We keep the glyph table available because we're
* very likely to fill it in again.
*/
void
applicationResetFont(fi, key)
struct fontinfo *fi;
int key;
{
int i;
struct glyph **theseGlyphs;
XImage **theseImages;
int shrink;
for (shrink = SHRINK_NORMAL; shrink <= SHRINK_LARGE; shrink++) {
theseGlyphs = shrunkenGlyphs[shrink][key];
if (theseGlyphs != 0) {
for (i = 0; i < MAX_GLYPH; i++) {
struct glyph *g;
g = theseGlyphs[i];
if (g != 0) {
if ( g -> g_raster != 0) {
free(g -> g_raster);
}
free(g);
theseGlyphs[i] = 0;
}
}
}
theseImages = shrunkenImages[shrink][key];
if (theseImages != 0) {
for (i = 0; i < MAX_GLYPH; i++) {
if (theseImages[i] != 0) {
XDestroyImage(theseImages[i]);
}
theseImages[i] = 0;
}
}
}
}
void
applicationPutChar(hh, vv, charCode)
int hh;
int vv;
int charCode;
{
register struct glyph *g;
int x,y;
XImage *image;
int key;
key = dviCurrentFont -> family;
g = shrunkenGlyphs[currentShrink][key][charCode];
if (g == 0) {
g = dviShrinkGlyph(dviCurrentFont -> f -> f_gly[charCode],
shrinkFactor[currentShrink],
shrinkFactor[currentShrink]);
shrunkenGlyphs[currentShrink][key][charCode] = g;
}
if (g == 0 || !HASRASTER(g)) return;
hh /= shrinkFactor[currentShrink];
vv /= shrinkFactor[currentShrink];
x = hh - g -> g_xorigin;
y = vv - g -> g_yorigin;
image = shrunkenImages[currentShrink][key][charCode];
if (image == 0 ) {
image = XCreateImage(DISP, DefaultVisual(DISP, defaultScreen),
1, XYBitmap,
0, g->g_raster,
g->g_width, g->g_height,
16, 0);
shrunkenImages[currentShrink][key][charCode] = image;
}
if (buildToPixmap) {
XPutImage(DISP, pasteUpPixmap[currentShrink][currentLeaf],
forepix, image,
0, 0,
x, y,
g->g_width, g->g_height);
} else {
XPutImage(DISP, win,
forepix, image,
0, 0,
x + currentLeaf * leaf_w[currentShrink], y,
g->g_width, g->g_height);
}
}
void
applicationSetRule(hh, vv, h, w)
int hh, vv;
int h, w;
{
/* (w,h) specifies lower left corner of rule box */
int nh, nw;
hh /= shrinkFactor[currentShrink];
vv /= shrinkFactor[currentShrink];
nh = h / shrinkFactor[currentShrink];
nw = w / shrinkFactor[currentShrink];
if (nh == 0 && h != 0) {
nh = 1;
}
if (nw == 0 && w != 0) {
nw = 1 ;
}
put_rectangle(hh, vv - nh, nw, nh, forepix);
}
/*
* This code attempts to support the same set of specials
* as imagen1
*/
static char *
skipWhite(c)
char *c;
{
while (c != 0 && *c != 0 && isspace(*c)) c++;
return(c);
}
static char *
skipNonWhite(c)
char *c;
{
while (c != 0 && *c != 0 && ! isspace(*c)) c++;
return(c);
}
#define MAX_POINTS 128
static int pointListCount = 0;
static XPoint pointList[MAX_POINTS];
void
applicationDoSpecial(command)
char *command;
{
char com[20];
int x,y;
char *c, *oc;
c = skipWhite(command);
if (*c == 0) return;
oc = c;
c = skipNonWhite(c);
x = *c;
*c = '\000';
strncpy(com, oc, 20);
*c = x;
c++;
if (strcmp(com, "pa") == 0) {
sscanf(c, " %d %d ", &x, &y);
pointList[pointListCount].x =
(specialConv * x + dviHH) / shrinkFactor[currentShrink];
pointList[pointListCount].y =
(specialConv * y + dviVV) / shrinkFactor[currentShrink];
if (! buildToPixmap) {
pointList[pointListCount].x += currentLeaf * leaf_w[currentShrink];
}
pointListCount++;
/*
* Make all lines styles come out as a simple line.
* Crude, but effective.
*/
} else if (strcmp(com, "fp") == 0
|| strcmp(com,"da") == 0
|| strcmp(com,"dt") == 0) {
if (pointListCount > 0) {
if (buildToPixmap) {
XDrawLines(DISP, pasteUpPixmap[currentShrink][currentLeaf],
specialGC, pointList, pointListCount,
CoordModeOrigin);
} else {
XDrawLines(DISP, win,
specialGC, pointList, pointListCount,
CoordModeOrigin);
}
}
pointListCount = 0;
} else if (strcmp(com, "pn") == 0) {
int penSize;
sscanf(c," %d ", &penSize);
penSize /= (shrinkFactor[currentShrink] * 2); /* looks good */
penSize = MAX(penSize,1);
penSize = MIN(penSize,99);
XSetLineAttributes(DISP, specialGC, penSize,
LineSolid, CapButt, JoinMiter);
} else {
/*
* For now, lets just flush the special
*/
fprintf(stderr, "[%s] special \"%s\" not implemented\n",
ProgName, command);
}
}
int
mainLoop()
{
int ch, arg, sign, number;
XEvent event;
XWindowAttributes query;
char trbuf[100];
char *string;
int nbytes=0;
int repaint;
int rebuild;
#define BOGUSDIR -1
#define FOREWARD 0
#define BACKWARD 1
#define ABSOLUTE 2
int direction;
/*
*
* We need to initialized 'obscured'.
* Ideally, we would like to know if we are covered at all, but
* the best I can come up with is a way to determine if we're
* mapped. This works well for wm, uwm & no window manager at all.
*/
XClearWindow(DISP,win);
XSync(DISP, 0);
XGetWindowAttributes(DISP, win, &query);
obscured = ! (query.map_state == IsViewable);
allocatePixmaps();
dviCurrentPage = 0;
buildLeaf(LEAF_LEFT, 0, SHRINK_NORMAL);
if (Leaves == 2) {
XGetWindowAttributes(DISP, win, &query); /* status changed? */
obscured = ! (query.map_state == IsViewable);
buildLeaf(LEAF_RIGHT, 1, SHRINK_NORMAL);
}
arg = 0;
number = 0;
for (;;) {
repaint = 1;
rebuild = 0;
direction = BOGUSDIR;
XDefineCursor(DISP, win, readyCursor);
bzero(&event, sizeof(event));
XNextEvent (DISP, &event);
string = "";
switch (event.type) {
/*
* If were painting to the display, and were not completely
* visible, wed better really paint to the pixmap, otherwise,
* all the stuff painted in an obscured region wont be in the pixmap.
*/
case VisibilityNotify:
obscured = (event.xvisibility.state != VisibilityUnobscured);
continue;
case Expose:
string = "\f";
nbytes = 1;
break;
case ButtonPress:
{
int leaf;
int otherLeaf;
int normalLeafW = leaf_w[SHRINK_NORMAL];
int leafX;
int leafY;
int lastLeaf = -1;
int x = event.xbutton.x;
int y = event.xbutton.y;
int lastButton = event.xbutton.button;
/*
* Determine which leaf was pointed to & where we will display it
*/
leaf = x / normalLeafW;
if (leaf < 0 || leaf >= Leaves) {
fprintf(stderr,"[%s] error in button press, leaf = %d\n",
ProgName, leaf);
exit(1);
}
if (leaf != lastLeaf && lastLeaf != -1) {
displayLeaf(lastLeaf);
}
lastLeaf = leaf;
if (Leaves == 1) {
otherLeaf = leaf;
} else {
otherLeaf = 1 - leaf;
}
/*
* Build the enlarged page if its not already there
*/
if (haveLargePage[leaf] != pageOnLeaf[leaf]) {
buildLeaf(leaf, pageOnLeaf[leaf], SHRINK_LARGE);
haveLargePage[leaf] = pageOnLeaf[leaf];
}
/*
* Determine where he was looking, build a (x,y) such that
* the thing he was pointing at will be on the screen, as close to
* center as possible.
*/
leafX = (x - (leaf * normalLeafW));
leafX = (leafX * shrinkFactor[SHRINK_NORMAL])
/ shrinkFactor[SHRINK_LARGE];
leafX -= (leaf_w[SHRINK_NORMAL] / 2);
leafX = MAX(leafX, 0);
leafX = MIN(leafX, leaf_w[SHRINK_LARGE]);
leafY = (y * shrinkFactor[SHRINK_NORMAL])
/ shrinkFactor[SHRINK_LARGE];
leafY -= (page_h[SHRINK_NORMAL] / 2);
leafY = MAX(leafY, 0);
leafY = MIN(leafY, page_h[SHRINK_LARGE]);
/*
* Display the enlarged image on the leaf, wait for another
* button event (the release, we hope)& then restore the image as it was
*/
clearWindow(otherLeaf);
XCopyArea(DISP, pasteUpPixmap[SHRINK_LARGE][leaf],
win, forepix,
leafX, leafY,
leaf_w[SHRINK_NORMAL], page_h[SHRINK_NORMAL],
leaf_w[SHRINK_NORMAL] * otherLeaf, 0);
bzero(&event, sizeof(event));
for(;;) {
XNextEvent(DISP, &event);
if (event.type == ButtonRelease
&& event.xbutton.button == lastButton) {
break;
}
}
displayLeaf(otherLeaf);
break;
}
case ButtonRelease:
break;
case KeyPress:
string = trbuf;
nbytes = XLookupString(&event, string, 100, NULL, NULL);
break;
}
if (nbytes == 0) continue;
if (nbytes > 1) goto bad;
switch (ch = *string) {
case 'q':
case '\003': /* control-C */
case '\004': /* control-D */
stop_output(0);
break;
case 'n':
case 'f':
case ' ':
case '\n' :
case '\r' :
/* scroll forward */
direction = FOREWARD;
rebuild = 1;
break;
case 'p':
case 'b':
case '\b':
case 0177 : /* DEL */
/* scroll backward */
direction = BACKWARD;
rebuild = 1;
break;
case '\f':
case 'r' :
/* repaint current page */
repaint = 1;
break;
case 'g':
/* go to absolute page */
direction = ABSOLUTE; /* may not be, but tough */
rebuild = 1;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if (! arg) {
arg = 1;
sign = 1;
number = 0;
}
number = 10*number + sign*(ch - '0');
repaint = 0;
continue;
case '-':
if (! arg) {
arg = 1;
sign = -1;
number = 0;
repaint = 0;
continue;
} else
goto bad;
default:
goto bad;
}
if (rebuild && direction != BOGUSDIR) {
int newLeft;
int newRight;
/*
* canonicalize the request. arg is always > 0, were moving in
* some direction.
*/
if (!arg || number == 0) {
number = 1;
}
if (number < 0) {
if (direction == FOREWARD) {
direction = BACKWARD;
} else if (direction == BACKWARD){
direction = FOREWARD;
}
number = -number;
}
/*
* Turn pages back
*/
if (direction == BACKWARD) {
newLeft = pageOnLeaf[LEAF_LEFT] - number;
} else if (direction == FOREWARD) {
newLeft = pageOnLeaf[LEAF_LEFT] + number;
} else {
newLeft = number - 1; /* pages numbered at 0 */
}
newLeft = MIN(newLeft, dviTotalPages-1);
newLeft = MAX(newLeft, 0);
if (Leaves == 1) {
if (newLeft != pageOnLeaf[LEAF_LEFT]) {
buildLeaf(LEAF_LEFT, newLeft, SHRINK_NORMAL);
}
} else {
newRight = newLeft + 1;
if (pageOnLeaf[LEAF_LEFT] != newLeft) {
if (newLeft == pageOnLeaf[LEAF_RIGHT]) {
swapLeaf(LEAF_RIGHT, LEAF_LEFT);
displayLeaf(LEAF_LEFT);
} else if (newRight == pageOnLeaf[LEAF_LEFT]) {
swapLeaf(LEAF_LEFT, LEAF_RIGHT);
displayLeaf(LEAF_RIGHT);
}
if (pageOnLeaf[LEAF_LEFT] != newLeft) {
buildLeaf(LEAF_LEFT, newLeft, SHRINK_NORMAL);
}
if (pageOnLeaf[LEAF_RIGHT] != newRight) {
buildLeaf(LEAF_RIGHT, newRight, SHRINK_NORMAL);
}
}
}
repaint = 0;
rebuild = 0;
arg = 0;
/*
* Only repaint it if we need to
*/
}
if (repaint){
displayLeaves();
repaint = 0;
}
continue;
bad:
arg = 0; /* throw away numeric argument */
continue;
}
}
stop_output(sig)
{
exit(sig);
}
put_border(x, y, w, h, t)
int x, y, w, h, t;
{
put_rectangle(x, y, w, t, highpix);
put_rectangle(x, y, t, h, highpix);
put_rectangle(x, y + h - t, w, t, highpix);
put_rectangle(x + w - t, y, t, h, highpix);
}
put_rectangle(x, y, w, h, pix)
int x, y, w, h;
GC pix;
{
if (buildToPixmap) {
XFillRectangle(DISP, pasteUpPixmap[currentShrink][currentLeaf],
pix, x, y, w, h);
} else {
XFillRectangle(DISP, win,
pix, x + currentLeaf * leaf_w[currentShrink], y, w, h);
}
}