v01i028: moire, Part01/01
Tom Tkacik
tkacik at kyzyl.mi.org
Sat Jun 8 12:56:59 AEST 1991
Submitted-by: tkacik at kyzyl.mi.org (Tom Tkacik)
Posting-number: Volume 1, Issue 28
Archive-name: moire/part01
Here is the latest version of moire. It now generates more
patterns, including pentagrams and triangles.
And it has fixed the iswind() problem. This just seemes like a good
time to repost this.
--
Tom Tkacik |
tkacik at kyzyl.mi.org | To rent this space, call 1-800-555-QUIP.
tkacik at hobbes.cs.gmr.com |
#--------------------------------CUT HERE-------------------------------------
#! /bin/sh
#
# This is a shell archive. Save this into a file, edit it
# and delete all lines above this comment. Then give this
# file to sh by executing the command "sh file". The files
# will be extracted into the current directory owned by
# you with default permissions.
#
echo 'x - Makefile'
if test -f Makefile; then echo 'shar: not overwriting Makefile'; else
sed 's/^X//' << '________This_Is_The_END________' > Makefile
X#
X# for gcc uncomment the following two lines
X#CC = gcc
X#GNULIB=/usr/local/lib/gcc-gnulib
X
XLDFLAGS = -s
XSHAREDLIB=/lib/crt0s.o /lib/shlib.ifile
X
XCFLAGS = -O
X
XNAME = moire
XDIR = /usr/games
XSRC = moire.c line.c prewinit.c
XOBJ = moire.o line.o prewinit.o
X
X$(NAME): $(OBJ)
X $(LD) $(LDFLAGS) $(SHAREDLIB) $(OBJ) $(GNULIB) -o moire
X
Xinstall:
X mv $(NAME) $(DIR)/$(NAME)
X chgrp bin $(DIR)/$(NAME)
X chown bin $(DIR)/$(NAME)
X
Xlint: $(SRC)
X lint -x -u $(SRC)
X
X# use gcc as a version of lint (for ANSI C compatability)
X# because the standard include files use #sccs
X# do not be pedantic about pre-processing
Xpedantic: $(SRC)
X gcc -ansi -E moire.c > junk.c
X gcc -ansi -pedantic -S junk.c
X gcc -ansi -E line.c > junk.c
X gcc -ansi -pedantic -S junk.c
X gcc -ansi -E prewinit.c > junk.c
X gcc -ansi -pedantic -S junk.c
X rm junk.c junk.s
X
X
Xclean:
X rm -f $(OBJ) moire
________This_Is_The_END________
if test `wc -c < Makefile` -ne 858; then
echo 'shar: Makefile was damaged during transit (should have been 858 bytes)'
fi
fi ; : end of overwriting check
echo 'x - README'
if test -f README; then echo 'shar: not overwriting README'; else
sed 's/^X//' << '________This_Is_The_END________' > README
XI wrote this demo program while trying my hand at line and
Xcircle generation. It has a few more options than the earlier version.
X
XAlso, the iswind() problem is now solved for those of you who allow
Xlogins from other than the console.
X
XLine drawing is done using Bresenham's line algorithm.
XCircles are drawn using a modification to Bresenham's circle algorithm
Xso that they appear round. I use an aspect ratio of 3/2.
XI had to generalize Bresenham's circle algorithm to generate the
Xellipses. Getting it right was very tricky.
XTo make it worse, I tried to make it more efficient by performing
Xstrength reduction on the code. The result, is that the algorithm
Xis not easy to follow. The meak of heart should not try to
Xmodify it, (or even look at it).
X
XThe lines and circles are first drawn to an array in memory, and
Xthen wrastop() is used to copy it to the screen. It would be faster
Xto draw directly to the video memory, (but I have not made the
Xhardware modification necessary to do so). Perhaps it's time to get
Xthat vidpal and mgr.
X
XThis code is placed in the public domain, with the hope it can be used
Xin real programs :-).
X
XThomas Tkacik
Xtkacik at kyzyl.mi.org
X
________This_Is_The_END________
if test `wc -c < README` -ne 1177; then
echo 'shar: README was damaged during transit (should have been 1177 bytes)'
fi
fi ; : end of overwriting check
echo 'x - line.c'
if test -f line.c; then echo 'shar: not overwriting line.c'; else
sed 's/^X//' << '________This_Is_The_END________' > line.c
X/*
X * line.c
X * written by Thomas Tkacik kyzyl!tkacik
X *
X * This code is submitted to the public domain
X * You may do with it what you wish
X */
X
X#include <sys/window.h>
X#include <stdio.h>
X
X#define SHORTS 45 /* shorts per row */
X#define WIDTH SHORTS*16
X#define HEIGHT 12*25 /* user lines */
X#define SCREEN_SHORTS SHORTS*HEIGHT /* number of shorts on screen */
X
X#define abs(x) (((x)>0)?(x):(-x))
X#define sign(x) (((x)>=0)?1:-1)
X
Xunsigned short screen[HEIGHT][SHORTS]; /* what's on the screen */
X
X/*
X * display prints out all of the new changes
X */
X
Xvoid
Xdisplay(wn, x, y, width, height)
Xint wn, x, y, width, height;
X{
X /* if wrastop fails just keep going */
X /* do not bother printing an error message */
X /* it will work the next time */
X
X (void)wrastop(wn,screen[0],SHORTS*2,0,0,x,y,x,y,width,height,
X SRCSRC,DSTSRC,0);
X}
X
X/*
X * clearmem the entire screen image in memory
X */
X
Xvoid
Xclearmem()
X{
X register int i;
X register unsigned short *scrpt;
X
X scrpt = screen[0];
X for(i=0; i < HEIGHT*SHORTS; i++)
X *(scrpt++) = 0;
X}
X
X
X/*
X * dot if the given point is on the screen
X * change its value (xor it with 1)
X */
X
Xvoid
Xdot(x, y)
Xregister int x, y;
X{
X if((x>=0) && (y>=0) && (x<WIDTH) && (y<HEIGHT))
X screen[y][x>>4] ^= 1<<(x & 0xf);
X}
X
X/*
X * draw a line between two points using bresenham's algorithm
X * the starting point is drawn but not the end point
X */
X
Xvoid
Xline(x1, y1, x2, y2)
Xregister int x1, y1;
X int x2, y2;
X{
X register short error, delta_x, delta_y;
X register short y_gt_x = 0; /* assume delta_x > delta_y */
X short i;
X int sign_x, sign_y;
X
X
X delta_x = x2 - x1; /* algorithm wants 2*deltas */
X delta_y = y2 - y1;
X
X sign_x = sign(delta_x); /* used for determining direction */
X sign_y = sign(delta_y);
X
X delta_x = abs(delta_x);
X delta_y = abs(delta_y);
X
X if(delta_y>delta_x) {
X x2 = y1; /* swap x1 and y1 */
X y1 = x1;
X x1 = x2;
X
X x2 = delta_y; /* swap delta_x and delta_y */
X delta_y = delta_x;
X delta_x = x2;
X
X x2 = sign_y; /* swap sign_x and sign_y */
X sign_y = sign_x;
X sign_x = x2;
X
X y_gt_x = 1; /* delta_y > delta_x! */
X }
X
X delta_y *= 2; /* delta_y is only used as 2*delta_y */
X error = delta_y - delta_x; /* actually 2*delta_y-delta_x */
X
X for(i=0; i < delta_x; i++) {
X if(y_gt_x) /* if so then swap on plotting pixels */
X dot(y1,x1); /* turn on pixel */
X else
X dot(x1,y1);
X
X if(error >= 0) {
X y1 += sign_y;
X error += (delta_y - 2*delta_x);
X } else {
X error += delta_y;
X }
X
X x1 += sign_x;
X }
X}
X
X/*
X * circle will draw a circle centered at the specified point
X * and with the specified radius using a slightly modified
X * version of bresenham's circle algorithm
X *
X * this routine is made so that the circles appear to be round
X *
X * r is the width of the circle in pixels
X * the height will be calculated
X *
X */
X
X#define AX 2 /* aspect ratio is AX/AY */
X#define AY 3
X#define AX2 (AX*AX)
X#define AY2 (AY*AY)
X
Xvoid
Xcircle(x, y, r)
Xint x, y, r;
X{
X register int error, delta_x, delta_y;
X register int x1, y1;
X
X x1 = 0;
X y1 = r;
X error = AX2 + AY2 - (2*AY2*r);
X
X while(y1>=0) {
X dot(x+x1,y+y1);
X dot(x-x1,y+y1);
X dot(x+x1,y-y1);
X dot(x-x1,y-y1);
X
X delta_x = 2*(error - AX2*x1) - AX2;
X delta_y = 2*(error + AY2*y1) - AY2;
X
X if((error < 0) && (delta_y <= 0)) {
X x1++;
X error += (2*AX2*x1 + AX2);
X } else if((error > 0) && (delta_x > 0)) {
X y1--;
X error += (AY2 - 2*AY2*y1);
X } else {
X x1++;
X y1--;
X error += 2*AX2*x1 - 2*AY2*y1 + AX + AY;
X }
X }
X}
X
X/*
X * draw an ellipse with center at x,y
X * and major and minor axes axis_x and axis_y
X *
X * a generalization of bresenham's circle algorithm is used
X *
X * I have made the code harder to understand by performing
X * strength reduction so fewer multiplies are required
X * being replaced with additions
X * (more could be done, but then too many registers are needed)
X *
X * Gcc does a nice job of using registers
X *
X */
X
Xvoid
Xellipse(x, y, axis_x, axis_y)
Xregister int x, y;
Xint axis_x, axis_y;
X{
X register int x1, y1, delta_x, delta_y;
X int dx, dy, error, axis_x2, axis_y2;
X short x_gt_y; /* is axis_x > axis_y */
X
X /* check for the degenerate cases */
X if((axis_x == 0) && (axis_y == 0)) {
X dot(x, y);
X return;
X }
X else if(axis_x == 0) {
X line(x, y-axis_y, x, y+axis_y);
X dot(x, y+axis_y); /* line does not do the endpoint */
X return;
X }
X else if(axis_y == 0) {
X line(x-axis_x, y, x+axis_x, y);
X dot(x+axis_x, y); /* line does not do the endpoint */
X return;
X }
X
X /* make axis_y the larger of axis_x and axis_y */
X
X x_gt_y = 0;
X
X if(axis_y < axis_x) {
X axis_x ^= axis_y; /* swap axis_x and axis_y */
X axis_y ^= axis_x;
X axis_x ^= axis_y;
X
X x_gt_y = 1; /* axis_y < axis_x! */
X }
X
X /* initialize error term and counters */
X
X x1 = 0;
X y1 = axis_y;
X axis_x2 = axis_x * axis_x;
X axis_y2 = axis_y * axis_y;
X dx = axis_y2;
X dy = axis_x2 * (1 - 2*axis_y);
X error = axis_x2 + axis_y2 - (2*axis_x2*axis_y);
X
X /* first do the two end points */
X /* because we draw all four quadrants */
X /* the end points will get drawn twice, erasing them */
X /* they get done now so that they only get drawn once */
X if(x_gt_y) {
X dot(x, y + axis_x);
X dot(x, y - axis_x);
X } else {
X dot(x + axis_x, y);
X dot(x - axis_x, y);
X }
X
X /* draw the rest of the ellipse */
X
X while(y1 > 0) {
X if(x1 > 0) {
X if(x_gt_y) { /* were x and y switched */
X dot(x + y1, y + x1);
X dot(x - y1, y + x1);
X dot(x + y1, y - x1);
X dot(x - y1, y - x1);
X } else {
X dot(x + x1, y + y1);
X dot(x - x1, y + y1);
X dot(x + x1, y - y1);
X dot(x - x1, y - y1);
X }
X } else { /* for very skinny ellipses */
X if(x_gt_y) {
X dot(x + y1, y);
X dot(x - y1, y);
X } else {
X dot(x, y + y1);
X dot(x, y - y1);
X }
X }
X
X delta_x = 2*(error - axis_y2*x1) - axis_y2;
X delta_y = 2*(error + axis_x2*y1) - axis_x2;
X
X if((error<0) && (delta_y<=0)) {
X x1 += 1;
X dx += 2*axis_y2;
X error += dx;
X } else if((error>0) && (delta_x>0)) {
X y1 -= 1;
X dy += 2*axis_x2;
X error += dy;
X } else {
X x1 += 1;
X y1 -= 1;
X dx += 2*axis_y2;
X dy += 2*axis_x2;
X error += dx + dy;
X }
X }
X}
X
________This_Is_The_END________
if test `wc -c < line.c` -ne 6068; then
echo 'shar: line.c was damaged during transit (should have been 6068 bytes)'
fi
fi ; : end of overwriting check
echo 'x - moire.6'
if test -f moire.6; then echo 'shar: not overwriting moire.6'; else
sed 's/^X//' << '________This_Is_The_END________' > moire.6
X.\" .TH MAHJONGG 6 "1 August 1988"
X.TH MOIRE 6
X.SH NAME
Xmoire \- Create moire patterns
X.SH SYNOPSIS
X.B moire
X[ \fB-lcxvpt+\fP ] [ \fB-b\fP ] [ \fB-n \fI###\fP ]
X.SH DESCRIPTION
X.I Moire
Xcreates moire patterns by bouncing lines around a window.
XVarious circle and line figures can also be used.
XBy default, 100 lines are used, but this can be set to any number less than 100.
XMoire opens a bordered window when it begins, and allows this window to
Xbe moved or resized.
XIt is also possible to have \fImoire\fR run in a full screen window without
Xa border.
XThis allows moire to replace the background pattern,
Xwith other windows in front.
X.SH OPTIONS
X.IP \fB\-l
XGenerate moire patterns with lines.
XThis is the default.
X.IP \fB\-c
XGenerate moire patterns with circles.
X.IP \fB\-+
XGenerate moire patterns with crosses.
X.IP \fB\-v
XGenerate moire patterns with vees.
X.IP \fB\-p
XGenerate moire patterns with pentagrams.
X.IP \fB\-t
XGenerate moire patterns with triangles.
X.IP \fB\-x
XGenerate moire patterns with exes.
X.IP \fB\-b
XRun \fImoire\fR in a full screen borderless window.
X.IP \fB\-n \fI#\fR
XStart with \fI#\fR number of lines, circles, or crosses.
X.SH FILES
X/usr/games/moire executable
X.SH AUTHOR
XThomas Tkacik
X.br
Xtkacik at kyzyl.mi.org
X.SH BUGS
XThat's not a bug, it's a feature!
________This_Is_The_END________
if test `wc -c < moire.6` -ne 1281; then
echo 'shar: moire.6 was damaged during transit (should have been 1281 bytes)'
fi
fi ; : end of overwriting check
echo 'x - moire.c'
if test -f moire.c; then echo 'shar: not overwriting moire.c'; else
sed 's/^X//' << '________This_Is_The_END________' > moire.c
X/*
X * moire.c
X * written by Thomas Tkacik kyzyl!tkacik
X *
X * This code is submitted to the public domain
X * You may do with it what you wish
X */
X
X#include <stdio.h>
X#include <termio.h>
X#include <sys/signal.h>
X#include <tam.h>
X#include <kcodes.h>
X#include <sys/window.h>
X#include "moire.h"
X
Xvoid prewinit();
X
X/* the number of lines to keep */
Xint num_lines = DEFLINE;
X
X/* the end points of each line */
Xstruct points {
X short x1,y1;
X short x2,y2;
X} lines[MAXLINE],increment;
X
X/* the bounding box */
Xstruct rect {
X short xmin,ymin;
X short xmax,ymax;
X} border;
X
X/* window structure */
Xstruct uwdata win;
X
X/* window discriptor */
Xint wn;
X
X/* terminal status */
Xstruct termio termstat;
X
Xint
Xmain(argc, argv)
Xint argc;
Xchar **argv;
X{
X int c, errflg = 0; /* for use with getopt() */
X extern int optind;
X extern char *optarg;
X
X int bordered = BORDERED; /* bordered or borderless window */
X int type = LINE;
X
X while((c = getopt(argc, argv, "lc+vdptxbn:")) != EOF) {
X switch(c) {
X case 'n':
X num_lines = atoi(optarg);
X if(num_lines > MAXLINE)
X num_lines = MAXLINE;
X break;
X case 'l':
X type = LINE;
X break;
X case '+':
X type = CROSS;
X break;
X case 'c':
X type = CIRCLE;
X break;
X case 'v':
X type = VEE;
X break;
X case 'd':
X type = DIAMOND;
X break;
X case 'p':
X type = PENTA;
X break;
X case 't':
X type = TRIANGLE;
X break;
X case 'x':
X type = EX;
X break;
X case 'b':
X bordered = BORDERLESS;
X break;
X default:
X errflg = 1;
X }
X }
X if(errflg == 1) {
X (void)fprintf(stderr,"Usage: %s [-lxcvdpt+] [-b] [-n #]\n", argv[0]);
X exit(1);
X }
X
X /* initialize the window */
X
X initialize(bordered);
X
X moire(type);
X
X return(0);
X}
X
X/*
X * initialize the window and signals
X */
X
Xvoid
Xinitialize(bordered)
Xint bordered;
X{
X /* pre-check if things are ok --- no need to call iswind() */
X prewinit();
X
X /* initialize the tam routines */
X winit();
X
X /* open the moire window */
X
X if(bordered == BORDERED) {
X if((wn = wcreate(1,0,18,76, BORDRESIZE)) == -1) {
X (void)fprintf(stderr,
X "could not open window wn = %d\n",wn);
X wexit(1);
X }
X } else {
X if((wn = wcreate(1,0,24,80, NBORDER)) == -1) {
X (void)fprintf(stderr,
X "could not open window wn = %d\n",wn);
X wexit(1);
X }
X }
X
X /* label the moire window */
X wlabel(wn, "Moire");
X wuser(wn, "Moire");
X
X /* turn off the cursor */
X wputs(wn,"\033[=1C");
X
X /* enable interrupts */
X /* set the interrupt character to control-c */
X
X (void)ioctl(wn, TCGETA, &termstat);
X termstat.c_lflag |= ISIG;
X termstat.c_cc[0] = CNTL_C;
X (void)ioctl(wn, TCSETA, &termstat);
X
X /* determine the initial window size */
X
X (void)ioctl(wn,WIOCGETD,&win);
X border.xmin = 1;
X border.ymin = 1;
X border.xmax = win.uw_width;
X border.ymax = win.uw_height;
X
X /* clear the memory image of the screen */
X clearmem();
X
X /* set up signals */
X
X (void)signal(SIGHUP, leave);
X (void)signal(SIGINT, leave);
X (void)signal(SIGQUIT, leave);
X (void)signal(SIGWIND, resize);
X}
X
X/*
X * generate the moire patterns
X */
X
Xvoid
Xmoire(type)
Xint type;
X{
X int i, j;
X void srand48();
X long time();
X
X /* initialize the random number generator */
X
X srand48((long)getpid() + time((long *)0));
X
X /* set the first line */
X
X lines[0].x1 = 2;
X lines[0].y1 = 2;
X lines[0].x2 = 2;
X lines[0].y2 = 2;
X
X /* set the increment values */
X
X increment.x1 = newinc(2,4,0);
X increment.y1 = newinc(3,5,0);
X increment.x2 = newinc(4,7,1);
X increment.y2 = newinc(3,6,1);
X
X /* draw the first line */
X
X draw(0, type);
X
X /* draw the rest of the lines before deleting any */
X
X for(i = 1; i < num_lines; i++) {
X update(i,i-1);
X draw(i, type);
X }
X
X /* now delete and add lines */
X
X j = num_lines - 1;
X i = 0;
X for(;;) {
X if(i >= num_lines)
X i = 0;
X
X /* erase old line */
X draw(i, type);
X
X /* find new line */
X update(i,j);
X
X /* draw new line */
X draw(i, type);
X
X j = i;
X i += 1;
X }
X}
X
X/*
X * find the coordinates of the next line
X * given the previous line
X * check if it should bounce off a wall
X */
X
Xvoid
Xupdate(i,j)
Xint i,j;
X{
X /* calculate new x1 */
X
X lines[i].x1 = lines[j].x1 + increment.x1;
X if(lines[i].x1 >= border.xmax) {
X increment.x1 = -newinc(2,4,0);
X lines[i].x1 = 2*border.xmax-lines[i].x1;
X }
X if(lines[i].x1 <= 0) {
X increment.x1 = newinc(2,4,0);
X lines[i].x1 = -lines[i].x1;
X }
X
X /* calculate new y1 */
X
X lines[i].y1 = lines[j].y1 + increment.y1;
X if(lines[i].y1 >= border.ymax) {
X increment.y1 = -newinc(3,5,0);
X lines[i].y1 = 2*border.ymax-lines[i].y1;
X }
X if(lines[i].y1 <= 0) {
X increment.y1 = newinc(3,5,0);
X lines[i].y1 = -lines[i].y1;
X }
X
X /* calculate new x2 */
X
X lines[i].x2 = lines[j].x2 + increment.x2;
X if(lines[i].x2 >= border.xmax) {
X increment.x2 = -newinc(4,7,1);
X lines[i].x2 = 2*border.xmax-lines[i].x2;
X }
X if(lines[i].x2 <= 0) {
X increment.x2 = newinc(4,7,1);
X lines[i].x2 = -lines[i].x2;
X }
X
X /* calculate new y2 */
X
X lines[i].y2 = lines[j].y2 + increment.y2;
X if(lines[i].y2 >= border.ymax) {
X increment.y2 = -newinc(3,6,1);
X lines[i].y2 = 2*border.ymax-lines[i].y2;
X }
X if(lines[i].y2 <= 0) {
X increment.y2 = newinc(3,6,1);
X lines[i].y2 = -lines[i].y2;
X }
X}
X
X/*
X * Xor the line to the in memory screen
X * and then display it on the moire window
X */
X
Xvoid
Xdraw(i, type)
Xint i;
Xint type;
X{
X int xmin, ymin, xmax, ymax;
X int xmean, ymean;
X
X xmin = lines[i].x1;
X ymin = lines[i].y1;
X xmax = lines[i].x2;
X ymax = lines[i].y2;
X
X /* find the center of the cross or circle */
X
X xmean = (xmin + xmax) / 2;
X ymean = (ymin + ymax) / 2;
X
X
X /* draw or erase pattern to/from the internal image */
X /* because line xor's the line onto the screen image */
X /* if it is already there, it will be erased */
X
X switch(type) {
X case LINE:
X line(xmin, ymin, xmax, ymax);
X break;
X case CROSS:
X line(xmean, ymin, xmean, ymax);
X line(xmin, ymean, xmax, ymean);
X break;
X case CIRCLE:
X ellipse(xmean, ymean, abs(xmax-xmin)/2, abs(ymax-ymin)/2);
X break;
X case VEE:
X line(xmin, ymin, xmean, ymax);
X line(xmean, ymax, xmax, ymin);
X break;
X case DIAMOND:
X line(xmin, ymean, xmean, ymin);
X line(xmean, ymin, xmax, ymean);
X line(xmax, ymean, xmean, ymax);
X line(xmean, ymax, xmin, ymean);
X break;
X case PENTA:
X line(xmin, ymin, xmean, ymax);
X line(xmean, ymax, xmax, ymin);
X line(xmax, ymin, xmin, ymean);
X line(xmin, ymean, xmax, ymean);
X line(xmax, ymean, xmin, ymin);
X break;
X case TRIANGLE:
X line(xmin, ymin, xmean, ymax);
X line(xmean, ymax, xmax, ymin);
X line(xmax, ymin, xmin, ymin);
X break;
X case EX:
X line(xmin, ymin, xmax, ymax);
X line(xmax, ymin, xmin, ymax);
X break;
X }
X
X /* make sure that min really is smaller than max */
X
X if(xmin > xmax) {
X xmin = xmax;
X xmax = lines[i].x1;
X }
X if(ymin > ymax) {
X ymin = ymax;
X ymax = lines[i].y1;
X }
X
X /* is the line still visible -- the screen may now be smaller */
X
X if((xmin < border.xmax-1) && (ymin < border.ymax-1)) {
X
X /* display the smallest region containing the new line */
X
X if(xmax > border.xmax-1)
X xmax = border.xmax-1;
X if(ymax > border.ymax-1)
X ymax = border.ymax-1;
X
X display(wn, xmin, ymin, xmax-xmin+1, ymax-ymin+1);
X }
X}
X
X/*
X * get a new increment value
X */
X
Xint
Xnewinc(least, range, even)
Xint least, range, even;
X{
X return(((int)(least + drand48()*range) & ~1) + even);
X}
X
X/*
X * resize is called whenever the window size is changed
X */
X
Xint
Xresize()
X{
X /* determine new window size */
X
X (void)ioctl(wn,WIOCGETD,&win);
X
X border.xmax = win.uw_width;
X border.ymax = win.uw_height;
X
X /* reset signal trap */
X
X (void)signal(SIGWIND, resize);
X return 0;
X}
X
X/*
X * exit the program
X */
X
Xint
Xleave()
X{
X wdelete(wn);
X wexit(0);
X
X return 0;
X}
X
________This_Is_The_END________
if test `wc -c < moire.c` -ne 7666; then
echo 'shar: moire.c was damaged during transit (should have been 7666 bytes)'
fi
fi ; : end of overwriting check
echo 'x - moire.h'
if test -f moire.h; then echo 'shar: not overwriting moire.h'; else
sed 's/^X//' << '________This_Is_The_END________' > moire.h
X/*
X * moire.h
X * written by Thomas Tkacik tetnix!tet
X *
X * This code is submitted to the public domain
X * You may do with it what you wish
X */
X
X#define MAXLINE 100 /* maximum number of lines that may appear */
X#define DEFLINE 60 /* default number that will appear */
X#define MAXHEIGHT 248 /* maximum height of screen in pixels */
X#define MAXWIDTH 685 /* maximum width of screen in pixels */
X
X#define LINE 0
X#define CROSS 1
X#define CIRCLE 2
X#define VEE 3
X#define DIAMOND 4
X#define PENTA 5
X#define TRIANGLE 6
X#define EX 7
X#define BORDERED 0
X#define BORDERLESS 1
X
X#define CNTL_C '\003' /* Control C */
X
X#define min(x,y) ((x)<(y)?(x):(y))
X
Xextern void display();
Xextern void clearmem();
Xextern void dot();
Xextern void line();
Xextern void circle();
Xextern void ellipse();
X
Xextern void initialize();
Xextern void moire();
Xextern void update();
Xextern void draw();
Xextern int newinc();
Xextern int resize();
Xextern int leave();
X
Xextern int (*signal())();
Xextern int ioctl();
Xextern void exit();
Xextern double drand48();
X
________This_Is_The_END________
if test `wc -c < moire.h` -ne 1026; then
echo 'shar: moire.h was damaged during transit (should have been 1026 bytes)'
fi
fi ; : end of overwriting check
echo 'x - prewinit.c'
if test -f prewinit.c; then echo 'shar: not overwriting prewinit.c'; else
sed 's/^X//' << '________This_Is_The_END________' > prewinit.c
X/*
X * This routine should be executed before running the tam routine winit()
X * It will check if the program is being run from the console, and will
X * get a fresh window for the program to use.
X *
X * Iswind() is not needed. This routine does the job.
X *
X * This routine is in the public domain.
X * Not only are you allowed to use this code, I wish you would.
X *
X * Thomas Tkacik tkacik at kyzyl.mi.org
X */
X
X#include <fcntl.h>
X#include <stdio.h>
X#include <sys/window.h>
X
Xvoid prewinit()
X{
X
X struct uwdata win_data;
X int wn;
X
X /* will fail if not a window */
X if(ioctl(1, WIOCGETD, &win_data) == -1) {
X (void)fprintf(stderr, "must use the bitmapped display\n");
X exit(1);
X }
X
X /* everything is fine, running from the console */
X
X /* detach from stdin, stout and stderr, and get a fresh window */
X (void)close(0);
X if((wn = open("/dev/window", O_RDWR )) == -1) {
X (void)fprintf(stderr, "cannot open window\n");
X exit(1);
X }
X (void)close(1);
X (void)close(2);
X (void)dup(wn);
X (void)dup(wn);
X}
X
________This_Is_The_END________
if test `wc -c < prewinit.c` -ne 997; then
echo 'shar: prewinit.c was damaged during transit (should have been 997 bytes)'
fi
fi ; : end of overwriting check
exit 0
--
Tom Tkacik |
tkacik at kyzyl.mi.org | To rent this space, call 1-800-555-QUIP.
tkacik at hobbes.cs.gmr.com |
--
David H. Brierley
Home: dave at galaxia.newport.ri.us; Work: dhb at quahog.ssd.ray.com
Send comp.sources.3b1 submissions to comp-sources-3b1 at galaxia.newport.ri.us
%% Can I be excused, my brain is full. **
More information about the Comp.sources.3b1
mailing list