/*
* 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 <stdio.h>
#include <ctype.h>
#include <suntool/sunview.h>
#include <suntool/canvas.h>
#include <sunwindow/defaults.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sun/fbio.h>
#include "dvistuff.h"
/*
* These constants may need to be changed on your implementation
*/
/*
* Note that ROUNDUP evaluates Y twice.
*/
#define ROUNDUP(x,y) (((x)+(y)-1) / (y))
#define DEBUG printf
#define INFORM (Debug > 2)
#define TALK (Debug > 1)
#define VERBOSE (Debug > 0)
int Debug = 0;
static int obscured = 1;
/*
* SunTools related variables
*/
static Window tool = 0;
static Canvas ptubeWindow = 0;
static Pixwin *ptube = 0;
static int canvasHeight;
static int canvasWidth;
static int canvasNormalWidthOffset;
static int canvasNormalHeightOffset;
typedef int (*intFuncp)();
intFuncp memPixmapOps;
static int foregroundMode = PIX_SRC | PIX_DST;
static int clearMode = PIX_CLR;
static int setMode = PIX_SET;
static int copyMode = PIX_SRC;
static int paintMode;
static int cursorMode;
static int globalArg = 0;
static int globalNumber = 0;
static int globalSign = 1;
static int globalOtherLeaf = 0;
static int globalLeafX;
static int globalLeafY;
static int globalDisplayState;
static int globalDisplayLeaf;
static int firstPage = 0;
static char *dviFileName = 0;
static Cursor workingCursor;
static Cursor readyCursor;
short workingCursorData[] = {
#include <images/hglass.cursor>;
};
mpr_static(workingCursorPixrect, 16, 16, 1, workingCursorData);
short readyCursorData[] = {
#include <images/bullseye.cursor>;
};
mpr_static(readyCursorPixrect, 16, 16, 1, readyCursorData);
/*
* TeX-Dvi related variables
*/
static int rawDviHeight;
static int rawDviWidth; /* part of X interface, not dvistuff */
static int maxHeight;
static int maxWidth;
static int maxDepth;
static int screenWidth, screenHeight;
#define MAX_LEAVES 2
#define LEAF_LEFT 0
#define LEAF_RIGHT 1
#define DEFAULT_LEAVES 2
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];
typedef struct mpr_data MprData;
static Pixrect **shrunkenPixrect[MAX_SHRINKS][MAX_FONTFAMILY];
static int reverse = 0;
static double specialConv;
#define TEXSUN_STATE_NAME "TEXSUN_STATE"
#define maxStateLines 100
char *stateFileName;
char **globalArgv;
int globalArgc;
char *malloc(), *calloc(), *index();
#define MAXFUNC(a,b) ((a) < (b)) ? (b) : (a)
#define MINFUNC(a,b) ((a) < (b)) ? (a) : (b)
stop_output()
{
/*
* We must write the state before killing the window
*/
writeState(stateFileName);
window_set(tool, FRAME_NO_CONFIRM, TRUE, 0);
window_destroy (tool);
exit (0);
}
main(argc, argv)
int argc;
char **argv;
{
int xargc=argc;
char **xargv=argv;
char *display = NULL;
char option[120];
int optionEnd;
char *poption;
int bwidth = 2;
char *geometry = NULL, def[32];
int bdrpix, mouspix;
unsigned long xswattrs_mask;
struct rect tool_rect;
int ptubeSelected();
int repaintCanvas();
int resizeCanvas();
double atof();
char *getenv();
/*
* Choose an explicit name so we always find the options.
*/
ProgName = "texsun";
argv++;
argc--;
dviFileName = NULL;
strcpy(option, ProgName);
sprintf(option,"/%s/", ProgName);
optionEnd = strlen(option);
option[optionEnd] = 0;
reverse = (int) defaults_get_boolean(strcat(option,"ReverseVideo"), 0, 0);
option[optionEnd] = 0;
shrinkFactor[SHRINK_NORMAL] =
defaults_get_integer(strcat(option,"NormalShrink"), 0, 0);
option[optionEnd] = 0;
shrinkFactor[SHRINK_LARGE] =
defaults_get_integer(strcat(option,"LargeShrink"), 0, 0);
option[optionEnd] = 0;
dviDPI = defaults_get_integer(strcat(option,"Dpi"), DEFAULT_DPI, 0);
option[optionEnd] = 0;
Leaves = defaults_get_integer(strcat(option,"Leaves"), 0, 0);
option[optionEnd] = 0;
poption = defaults_get_string(strcat(option,"TopMargin"), 0, 0);
dviVVMargin = DEFAULT_VVMARGIN * ( (poption == 0) ? 1.0 : atof(poption));
option[optionEnd] = 0;
poption = defaults_get_string(strcat(option,"SideMargin"), 0, 0);
dviHHMargin = DEFAULT_HHMARGIN * ( (poption == 0) ? 1.0 : atof(poption));
option[optionEnd] = 0;
dviBlackness = defaults_get_integer(strcat(option,"Blackness"),
DEFAULT_BLACKNESS, 0);
option[optionEnd] = 0;
stateFileName = defaults_get_string(strcat(option,"StateFile"), 0, 0);
if (stateFileName == 0) {
stateFileName = getenv(TEXSUN_STATE_NAME);
}
if (argc > 0 && strcmp(argv[0], "-new") == 0) {
argv++;
argc--;
} else {
readState(&argc, &argv, stateFileName);
}
globalArgc = argc;
globalArgv = argv;
while (argc) {
if (strcmp(*argv, "-rv") == 0) {
reverse = !reverse;
/*
* these two are for the state-saver
*/
} else if (strcmp(*argv, "-rvOn") == 0 ) {
reverse = 1;
} else if (strcmp(*argv, "-rvOff") == 0) {
reverse = 0;
} 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,"-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 (strcmp(*argv, "-bl") == 0 && argc > 1) {
argv++;
argc--;
dviBlackness = atoi(*argv);
} else if (strcmp(*argv, "-pg") == 0 && argc > 1) {
argv++;
argc--;
firstPage = atoi(*argv);
} else if (strcmp(*argv,"-debug") == 0 && argc > 1) {
argv++;
argc--;
Debug = atoi(*argv);
} else if (**argv != '-') {
dviFileName = *argv;
} else {
usage:
fprintf(stderr, "Usage: %s [-ns <shrink>] [-ls <shrink>] [-dpi <dots>] \n",
ProgName);
fprintf(stderr, " [-l <leaves>] [-rv] [-tm <inches>] [-sm <inches>] dviFile\n");
exit(1);
}
argv++;
argc--;
}
if (dviFileName == NULL)
goto usage;
if ((dviFile = fopen(dviFileName, "r")) == NULL) {
int n = strlen(dviFileName);
char *dvi_name;
if (strcmp(dviFileName + n - sizeof(".dvi") + 1, ".dvi") == 0) {
perror(dviFileName);
exit(1);
}
dvi_name = malloc((unsigned) n + sizeof(".dvi"));
sprintf(dvi_name, "%s.dvi", dviFileName);
if ((dviFile = fopen(dvi_name, "r")) == NULL) {
perror(dvi_name);
exit(1);
}
dviFileName = dvi_name;
}
if (INFORM) {
fprintf(stderr, "[texsun] call dviInit();\n");
}
dviInit();
if (TALK) {
fprintf(stderr,"page is %d wide, %d high\n",
dviTallestPage, dviWidestPage);
}
if (((double) dviTallestPage * (double) dviWidestPage) > 4.0e7) {
fprintf(stderr,"[%s] Warning: Your page size is %d wide and %d tall,\n",
ProgName, dviTallestPage, dviWidestPage);
fprintf(stderr,"which may be too big to be displayed\n");
}
specialConv = (float) dviDPI / 1000.0;
/*
* If no shrink factor was chosen, pick one which will work out nicely
* on their display
*/
if (INFORM) {
fprintf(stderr, "[texsun] set screenSpecific\n");
}
setScreenSpecifics();
rawDviHeight = dviTallestPage + 2 * dviVVMargin;
rawDviWidth = dviWidestPage + 2 * dviHHMargin;
if (Leaves == 0) {
if (dviTotalPages == 1) {
Leaves = 1;
} else {
Leaves = DEFAULT_LEAVES;
}
}
if (INFORM) {
fprintf(stderr, "[texsun] choose screenSpecific\n");
}
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] = MAXFUNC(sW, sH);
shrinkFactor[SHRINK_NORMAL] = MAXFUNC(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 = MAXFUNC(sH2, sW2);
shrink2 = MAXFUNC(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] = MINFUNC(shrinkFactor[SHRINK_LARGE],
shrinkFactor[SHRINK_NORMAL]-1);
shrinkFactor[SHRINK_LARGE] = MAXFUNC(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 cant 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];
tool_rect.r_left = 0;
tool_rect.r_top = 0;
tool_rect.r_width = 0;
tool_rect.r_height = 0;
cursorMode = PIX_SRC ^ PIX_DST;
if (reverse) {
paintMode = PIX_NOT(PIX_SRC);
} else {
paintMode = PIX_SRC;
}
if (INFORM) {
fprintf(stderr,"[texsun] create the tool windows\n");
}
/* create the tool */
tool = window_create (0, FRAME,
FRAME_LABEL, "TeXsun",
FRAME_OPEN_RECT, &tool_rect,
0);
if (tool == 0) {
fprintf(stderr,"Unable to create window\n");
exit(1);
}
ptubeWindow = window_create(tool, CANVAS,
CANVAS_AUTO_SHRINK, TRUE,
CANVAS_AUTO_EXPAND, TRUE,
CANVAS_WIDTH, screenWidth,
WIN_FIT_WIDTH, screenWidth,
CANVAS_HEIGHT, screenHeight,
WIN_FIT_HEIGHT, screenHeight,
CANVAS_RETAINED, FALSE,
CANVAS_REPAINT_PROC, repaintCanvas,
CANVAS_RESIZE_PROC, resizeCanvas,
WIN_EVENT_PROC, ptubeSelected,
WIN_BOTTOM_MARGIN, 0,
WIN_LEFT_MARGIN, 0,
WIN_TOP_MARGIN, 0,
WIN_RIGHT_MARGIN, 0,
WIN_X, 0,
WIN_Y, 0,
0);
if (ptubeWindow == 0) {
fprintf(stderr,"Unable to create canvas\n");
exit(1);
}
readyCursor = cursor_create(CURSOR_IMAGE, &readyCursorPixrect,
CURSOR_OP, cursorMode, 0);
workingCursor = cursor_create(CURSOR_IMAGE, &workingCursorPixrect,
CURSOR_OP, cursorMode, 0);
ptubeInit();
window_set(ptubeWindow, WIN_CONSUME_KBD_EVENT, WIN_ASCII_EVENTS,0);
signal (SIGINT, stop_output);
signal (SIGQUIT, stop_output);
signal (SIGIOT, stop_output);
window_fit(ptubeWindow);
window_fit(tool);
if (INFORM) {
fprintf(stderr,"[texsun] enter window loop\n");
}
window_main_loop (tool);
/* terminate tool */
stop_output(0);
}
/*
* State-maintenance routines.
*
* The state is maintained in a file indicated by the environment
* variable TEXSUN_STATE.
*
* The state is written as a sequence of options, the same options
* which can be specified on the command line.
*
* When the state is used, the saved options are inserted in the
* command line before any new options. Thus, new options will
* over-ride the saved options, and both saved state and command
* line options will over-ride the default options.
*/
readState(inOutArgc, inOutArgv, stateFileName)
char ***inOutArgv;
int *inOutArgc;
char *stateFileName;
{
if (stateFileName != 0) {
FILE *f;
char **newArgv;
char *p;
int newArgc;
char buffer[512];
char *bufp;
int i;
int argc = *inOutArgc;
char **argv = *inOutArgv;
newArgv = (char **) malloc( sizeof(char *) * (argc + maxStateLines));
f = fopen(stateFileName,"r");
/*
* The program name has already been removed.
*/
newArgc = 0;
if (f != 0) {
while (!feof(f)) {
p = fgets(buffer, 512, f);
if (p != 0) {
int lth;
lth = strlen(buffer);
p = malloc(lth + 1);
strcpy(p, buffer);
p[lth-1] = 0; /* kill the newline character */
newArgv[newArgc++] = p;
}
}
for (i = 0 ; i < argc; i++ ) {
newArgv[newArgc++] = argv[i];
}
*inOutArgc = newArgc;
*inOutArgv = newArgv;
}
}
}
writeState(stateFileName)
char *stateFileName;
{
if (stateFileName != 0) {
FILE *f;
char *ptr;
f = fopen(stateFileName,"w");
if (f != 0) {
fprintf(f, "-rv%s\n", (reverse) ? "On" : "Off");
fprintf(f, "-l\n%d\n", Leaves);
fprintf(f, "-ns\n%d\n", shrinkFactor[SHRINK_NORMAL]);
fprintf(f, "-ls\n%d\n", shrinkFactor[SHRINK_LARGE]);
fprintf(f, "-dpi\n%d\n", dviDPI);
fprintf(f, "-tm\n%f\n", (double)
((double) dviVVMargin / (double) dviDPI));
fprintf(f, "-sm\n%f\n", (double)
((double) dviHHMargin / (double) dviDPI));
fprintf(f, "-bl\n%d\n", dviBlackness);
fprintf(f, "-debug\n%d\n", Debug);
fprintf(f, "-pg\n%d\n", pageOnLeaf[0]);
fprintf(f, "%s\n", dviFileName);
fclose(f);
}
}
}
/*
* Sun Screen-specific things
*/
setScreenSpecifics()
{
struct fbtype FbType;
int Fb;
Fb = open("/dev/fb", O_RDONLY, 0);
if (Fb < 0) {
perror("open");
fprintf(stderr,"Unable to open /dev/fb\n");
exit(1);
}
if (ioctl(Fb, FBIOGTYPE, &FbType) == -1) {
perror("ioctl");
fprintf(stderr,"Unable to determine screen size\n");
exit(1);
}
maxWidth = FbType.fb_width;
maxHeight = FbType.fb_height;
maxDepth = FbType.fb_depth;
close(Fb);
}
resizeCanvas(canvas, width, height)
{
canvasWidth = width;
canvasHeight = height;
if (canvasWidth > (Leaves * leaf_w[SHRINK_NORMAL])) {
canvasNormalWidthOffset =
(canvasWidth - Leaves * leaf_w[SHRINK_NORMAL]);
}
if (canvasHeight > (Leaves * page_h[SHRINK_NORMAL])) {
canvasNormalHeightOffset =
(canvasHeight - Leaves * page_h[SHRINK_NORMAL]);
}
}
repaintCanvas(canvas, pixwin, repaint_area)
Canvas canvas;
Pixwin *pixwin;
Rectlist *repaint_area;
{
displayLeaves();
}
/*
* Pixmap manipulation routines
*/
static Pixrect *pasteUpPixmap[MAX_SHRINKS][MAX_LEAVES];
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 = 0;
static void
clearPixmap(leaf, shrinkSize)
int leaf;
int shrinkSize;
{
Pixrect *w;
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);
}
w = pasteUpPixmap[shrinkSize][leaf];
pr_rop(w, 0, 0,
leaf_w[shrinkSize], page_h[shrinkSize],
clearMode,
w, 0, 0);
}
/*
* Clear the window. Actually, for a black-on-white display (normal)
* this means we need to *set* the entire display using COLOR(1) color.
*/
static void
clearWindow()
{
int localClear = PIX_COLOR(1) | clearMode;
if (reverse) {
localClear = PIX_NOT(localClear);
}
pw_writebackground(ptube,
0, 0,
canvasWidth, canvasHeight,
localClear);
}
allocatePixmaps()
{
int i;
for (i = 0; i < Leaves; i++ ) {
pasteUpPixmap[SHRINK_NORMAL][i] = (Pixrect *)
mem_create(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);
stop_output();
}
}
largePixmapsAllocated = 0;
/*
* 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] = (Pixrect *)
mem_create(leaf_w[SHRINK_LARGE], page_h[SHRINK_LARGE], 1);
clearPixmap(i, SHRINK_LARGE);
}
largePixmapsAllocated = 1;
}
/*
* display the normal sized leaf
*/
static int
displayLeaves()
{
if (globalDisplayState == SHRINK_LARGE) {
/*
* globalLeafX and globalLeafY point the part of the display
* they want to see, scaled to the large shrink.
*
*/
int leafX;
int leafY;
int leafW;
int leafH;
int canvasX;
int canvasY;
leafW = MINFUNC(leaf_w[SHRINK_LARGE], canvasWidth);
leafH = MINFUNC(page_h[SHRINK_LARGE], canvasHeight);
leafX = globalLeafX - (leafW / 2); /* find left side */
if (leafX < 0) {
canvasX = -leafX;
leafX = 0;
} else {
canvasX = 0;
}
if ((leafX + leafW) > leaf_w[SHRINK_LARGE]) {
leafW = leaf_w[SHRINK_LARGE] - leafX;
}
leafY = globalLeafY - (leafH / 2); /* gind top side */
if (leafY < 0) {
canvasY = -leafY;
leafY = 0;
} else {
canvasY = 0;
}
if ((leafY + leafH) > page_h[SHRINK_LARGE]) {
leafH = page_h[SHRINK_LARGE] - leafY;
}
#ifdef UNDEF
if (leafW < canvasWidth) {
leafX += (canvasWidth - leafW) / 2;
}
if (leafH < canvasHeight) {
leafY += (canvasHeight - leafH) / 2;
}
#endif
clearWindow();
pw_write(ptube,
canvasX, canvasY,
leafW, leafH,
paintMode,
pasteUpPixmap[SHRINK_LARGE][globalDisplayLeaf],
leafX, leafY);
} else {
clearWindow();
pw_write(ptube,
0, 0,
leaf_w[SHRINK_NORMAL], page_h[SHRINK_NORMAL],
paintMode,
pasteUpPixmap[SHRINK_NORMAL][0],
0,0);
pw_write(ptube,
leaf_w[SHRINK_NORMAL], 0,
leaf_w[SHRINK_NORMAL], page_h[SHRINK_NORMAL],
paintMode,
pasteUpPixmap[SHRINK_NORMAL][1],
0,0);
}
}
static void
swapLeaf(from, to)
int from;
int to;
{
Pixrect *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;
{
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);
}
window_set(ptubeWindow, WIN_CURSOR, workingCursor, 0);
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 = 1;
}
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) {
clearPixmap(leaf, SHRINK_NORMAL);
/*
* We save the pixmap from the *retained* image -- the tool may not
* actually be up. This isn't optimal, but it saves us a lot of
* hacking & having to determine when we're obscured.
*/
pr_rop(pasteUpPixmap[SHRINK_NORMAL][leaf],
0,0,
leaf_w[SHRINK_NORMAL], page_h[SHRINK_NORMAL],
copyMode,
ptube -> pw_prretained,
leaf_w[SHRINK_NORMAL] * leaf, 0);
} else if (shrinkSize == SHRINK_NORMAL) {
/* null */
}
}
pageOnLeaf[leaf] = dviCurrentPage;
window_set(ptubeWindow, WIN_CURSOR, readyCursor, 0);
}
/*
* 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 (shrunkenPixrect[shrink][key] == 0) {
int lth = sizeof(Pixrect *) * MAX_GLYPH;
Pixrect **g;
g = (Pixrect **) malloc( lth );
bzero(g, lth);
shrunkenPixrect[shrink][key] = g;
}
}
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;
Pixrect **thesePixrect;
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;
}
}
}
thesePixrect = shrunkenPixrect[shrink][key];
if (thesePixrect != 0) {
for (i = 0; i < MAX_GLYPH; i++) {
Pixrect *g;
g = thesePixrect[i];
if (g != 0) {
free(g -> pr_data);
free(g);
thesePixrect[i] = 0;
}
}
}
}
}
void
applicationPutChar(hh, vv, charCode)
int hh;
int vv;
int charCode;
{
register struct glyph *g;
int x,y;
int key;
Pixrect *image;
key = dviCurrentFont -> family;
g = shrunkenGlyphs[currentShrink][key][charCode];
if (g == 0) {
MprData *newMpr = (MprData *) malloc(sizeof(MprData));
Pixrect *newPixrect = (Pixrect *) malloc(sizeof(Pixrect));
extern struct pixrectops mem_ops;
g = dviShrinkGlyph(dviCurrentFont -> f -> f_gly[charCode],
shrinkFactor[currentShrink],
shrinkFactor[currentShrink]);
shrunkenGlyphs[currentShrink][key][charCode] = g;
newMpr -> md_linebytes = SHRUNK_GLYPH_BYTES_WIDE(g);
newMpr -> md_image = (short *) g -> g_raster;
newMpr -> md_offset.x = 0;
newMpr -> md_offset.y = 0;
newMpr -> md_primary = 0;
newMpr -> md_flags = 0;
newPixrect -> pr_ops = &mem_ops;
newPixrect -> pr_size.x = g -> g_width;
newPixrect -> pr_size.y = g -> g_height;
newPixrect -> pr_depth =1;
newPixrect -> pr_data = (caddr_t) newMpr;
shrunkenPixrect[currentShrink][key][charCode] = newPixrect;
}
if (g == 0 || !HASRASTER(g)) return;
hh /= shrinkFactor[currentShrink];
vv /= shrinkFactor[currentShrink];
x = hh - g -> g_xorigin;
y = vv - g -> g_yorigin;
image = shrunkenPixrect[currentShrink][key][charCode];
if (buildToPixmap) {
pr_rop(pasteUpPixmap[currentShrink][currentLeaf],
x,y,
g->g_width, g->g_height,
foregroundMode,
image,
0,0);
} else {
x += currentLeaf * leaf_w[currentShrink];
pw_write(ptube,
x, y,
g->g_width, g->g_height,
foregroundMode,
image,
0,0);
}
}
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, setMode);
}
/*
* 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 struct pr_pos pointList[MAX_POINTS];
static struct pr_brush specialBrush = {1};
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) {
int fx,fy;
int tx,ty;
int i;
fx = pointList[0].x;
fy = pointList[0].y;
for (i = 0; i < pointListCount; i++) {
tx = pointList[i].x;
ty = pointList[i].y;
if (buildToPixmap) {
pr_vector(pasteUpPixmap[currentShrink][currentLeaf],
fx, fy, tx, ty, foregroundMode, -1);
} else {
pw_vector(ptube,
fx, fy, tx, ty, foregroundMode, -1);
}
fx = tx;
fy = ty;
}
}
pointListCount = 0;
} else if (strcmp(com, "pn") == 0) {
int penSize;
sscanf(c," %d ", &penSize);
penSize /= (shrinkFactor[currentShrink] * 2); /* looks good */
penSize = MAXFUNC(penSize,1);
penSize = MINFUNC(penSize,99);
/*
* We dont do anything with this
*/
} else {
/*
* For now, lets just flush the special
*/
pointListCount = 0;
fprintf(stderr, "[%s] special \"%s\" not implemented\n",
ProgName, command);
}
}
ptubeInit()
{
struct inputmask mask;
ptube = canvas_pixwin(ptubeWindow);
if (ptube == (Pixwin *) NULL) {
fprintf(stderr,"Couldn't create ptube pixwin\n");
stop_output(0);
}
obscured = 1; /* SunTools does auto-save-unders */
globalDisplayState = SHRINK_NORMAL;
resizeCanvas(ptube,
(int) window_get(ptube, CANVAS_WIDTH),
(int) window_get(ptube, CANVAS_HEIGHT));
allocatePixmaps();
dviCurrentPage = firstPage;
buildLeaf(LEAF_LEFT, dviCurrentPage, SHRINK_NORMAL);
if (Leaves == 2) {
buildLeaf(LEAF_RIGHT, dviCurrentPage + 1, SHRINK_NORMAL);
}
globalArg = 0;
globalNumber = 0;
}
/* respond to damage to ptube subwindow */
static int
ptubeSighandler(sw)
caddr_t sw;
{
displayLeaves();
}
static int
ptubeSelected(win, inputEvent, arg)
Window *win;
Event *inputEvent;
caddr_t arg;
{
int ch;
int repaint;
int rebuild;
#define BOGUSDIR -1
#define FOREWARD 0
#define BACKWARD 1
#define ABSOLUTE 2
int direction;
Event *ie;
repaint = 1;
rebuild = 0;
direction = BOGUSDIR;
ie = inputEvent;
switch(event_id(ie)) {
case BUT(1) :
case BUT(2) :
case BUT(3):
if (event_is_down(ie)) { /* button going down? */
int leaf;
int normalLeafW = leaf_w[SHRINK_NORMAL];
int leafX;
int leafY;
int lastLeaf = -1;
int x = event_x(ie);
int y = event_y(ie);
/*
* Determine which leaf was pointed to & where we will display it
*/
leaf = x / normalLeafW;
if (leaf < 0 || leaf >= Leaves) {
leaf = Leaves - 1;
}
lastLeaf = leaf;
if (Leaves == 1) {
globalOtherLeaf = leaf;
} else {
globalOtherLeaf = 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];
}
leafX = (x - (leaf * normalLeafW));
leafX = (leafX * shrinkFactor[SHRINK_NORMAL])
/ shrinkFactor[SHRINK_LARGE];
leafY = (y * shrinkFactor[SHRINK_NORMAL])
/ shrinkFactor[SHRINK_LARGE];
globalLeafX = leafX;
globalLeafY = leafY;
globalDisplayLeaf = leaf;
globalDisplayState = SHRINK_LARGE;
displayLeaves();
} else {
globalDisplayState = SHRINK_NORMAL;
displayLeaves();
}
return;
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 (! globalArg) {
globalArg = 1;
globalSign = 1;
globalNumber = 0;
}
globalNumber = 10*globalNumber + (event_id(ie) - '0');
return;
case '-':
if (! globalArg) {
globalArg = 1;
globalSign = -1;
globalNumber = 0;
repaint = 0;
return;
} else
goto bad;
default:
goto bad;
}
if (rebuild && direction != BOGUSDIR) {
int newLeft;
int newRight;
/*
* canonicalize the request. globalArg is always > 0, were moving in
* some direction.
*/
if (globalArg == 0 || globalNumber == 0) {
globalNumber = 1;
}
globalNumber = globalNumber * globalSign;
if (globalNumber < 0) {
if (direction == FOREWARD) {
direction = BACKWARD;
} else if (direction == BACKWARD){
direction = FOREWARD;
}
globalNumber = -globalNumber;
}
/*
* Turn pages
*/
if (direction == BACKWARD) {
newLeft = pageOnLeaf[LEAF_LEFT] - globalNumber;
} else if (direction == FOREWARD) {
newLeft = pageOnLeaf[LEAF_LEFT] + globalNumber;
} else {
newLeft = globalNumber - 1; /* pages globalNumbered at 0 */
}
newLeft = MINFUNC(newLeft, dviTotalPages-1);
newLeft = MAXFUNC(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);
} else if (newRight == pageOnLeaf[LEAF_LEFT]) {
swapLeaf(LEAF_LEFT, LEAF_RIGHT);
}
if (pageOnLeaf[LEAF_LEFT] != newLeft) {
buildLeaf(LEAF_LEFT, newLeft, SHRINK_NORMAL);
}
if (pageOnLeaf[LEAF_RIGHT] != newRight) {
buildLeaf(LEAF_RIGHT, newRight, SHRINK_NORMAL);
}
}
}
/*
* Only repaint it if we need to
*/
}
displayLeaves();
globalArg = 0;
globalNumber = 0;
return;
bad:
globalArg = 0; /* throw away numeric globalArgument */
return;
}
put_border(x, y, w, h, t)
int x, y, w, h, t;
{
put_rectangle(x, y, w, t, setMode);
put_rectangle(x, y, t, h, setMode);
put_rectangle(x, y + h - t, w, t, setMode);
put_rectangle(x + w - t, y, t, h, setMode);
}
put_rectangle(x, y, w, h, pix)
int x, y, w, h;
int pix;
{
if (buildToPixmap) {
pr_rop(pasteUpPixmap[currentShrink][currentLeaf],
x,y,
w,h,
pix,
pasteUpPixmap[currentShrink][currentLeaf],
0, 0);
} else {
pw_write(ptube,
x + currentLeaf * leaf_w[currentShrink],y,
w,h,
pix,
ptube, 0, 0);
}
}