bvs%carlisle@Sun.COM (Bruce Schwartz) (12/17/88)
#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create:
# circ.c
# line.c
# oval.c
# rect.c
# text.c
# poly.c
# This archive created: Fri Dec 16 15:05:53 1988
export PATH; PATH=/bin:/usr/bin:$PATH
if test -f 'circ.c'
then
echo shar: "will not over-write existing file 'circ.c'"
else
cat << \SHAR_EOF > 'circ.c'
/* $Header: circ.c,v 1.3 88/12/02 10:43:36 bvs Exp $ */
/* Copyright (C) 1988 by Sun Microsystems. All rights reserved. */
#include <stdio.h>
#include "go.h"
#include "gopvt.h"
/* circ section */
typedef struct {
ITEMHEADER;
} ICIRC;
static void *CircHolder()
{
return((ICIRC *)malloc(sizeof(ICIRC)));
}
extern double sqrt();
static void *CircNew(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
ICIRC *pitem = (ICIRC *)malloc(sizeof(ICIRC));
double xlen = (double)((x0 - x1)/2);
double ylen = (double)((y0 - y1)/2);
double xcenter = (double)((x0 + x1)/2);
double ycenter = (double)((y0 + y1)/2);
double radius = (int)sqrt((double)(xlen*xlen + ylen*ylen));
pitem->type = CIRC;
pitem->x0 = xcenter - radius;
pitem->y0 = ycenter - radius;
pitem->x1 = xcenter + radius;
pitem->y1 = ycenter + radius;
pitem->rotation = 0;
pitem->xscale = 1;
pitem->yscale = 1;
pitem->prop = PropCopyOf(PropCurrent());
return(pitem);
}
static void *CircDraw(pitem)
ICIRC *pitem;
{
float stroke = PropStrokeColor(pitem->prop);
float fill = PropFillColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
ps_gsave();
if(fill >= 0.0)
{
ps_setgray(fill);
ps_drawcirc((X0 + X1)/2, (Y0 + Y1)/2, (X1 - X0)/2);
ps_fill();
}
if(stroke >= 0.0)
{
ps_setlinewidth(width);
ps_setgray(stroke);
ps_drawcirc((X0 + X1)/2, (Y0 + Y1)/2, (X1 - X0)/2);
ps_stroke();
}
ps_grestore();
return(pitem);
}
static void *CircPrint(pitem, pfile)
ICIRC *pitem;
FILE *pfile;
{
float stroke = PropStrokeColor(pitem->prop);
float fill = PropFillColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
fprintf(pfile, "%% circle\n");
if(fill >= 0.0)
{
fprintf(pfile, "%f setgray ", fill);
fprintf(pfile, "%d %d %d circpath ",
(X0 + X1)/2, (Y0 + Y1)/2, (X1 - X0)/2);
fprintf(pfile, "fill\n");
}
if(stroke >= 0.0)
{
fprintf(pfile, "%d setlinewidth ", width);
fprintf(pfile, "%f setgray ", stroke);
fprintf(pfile, "%d %d %d circpath ",
(X0 + X1)/2, (Y0 + Y1)/2, (X1 - X0)/2);
fprintf(pfile, "stroke\n");
}
return(pitem);
}
GOCircInit(pgoprocs)
GOPROCS *pgoprocs;
{
pgoprocs->holder= CircHolder;
pgoprocs->new = CircNew;
pgoprocs->draw = CircDraw;
pgoprocs->print = CircPrint;
}
/************* event handlers *************/
static void *CircSelect(x, y)
int x,y;
{
ps_circcreateinteractive(x, y);
}
static void *CircAdjust(x, y)
int x,y;
{
fprintf(stderr, "CircAdjust not implemented\n");
}
static void *CircReply(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
/* maybe we should just make this an oval! */
ITEM *pitem;
if((x0 == x1) && (y0 == y1)) return;
pitem = GONewCirc(x0, y0, x1, y1);
GOItemAddToTop(pitem);
GODrawItem(pitem);
return(pitem);
}
static void *CircBegin()
{
ps_xcursor();
}
EHCircInit(pprocs)
EHPROCS *pprocs;
{
pprocs->handleselect = CircSelect;
pprocs->handleadjust = CircAdjust;
pprocs->handlereply = CircReply;
pprocs->handlebegin = CircBegin;
}
SHAR_EOF
fi
if test -f 'line.c'
then
echo shar: "will not over-write existing file 'line.c'"
else
cat << \SHAR_EOF > 'line.c'
/* $Header: line.c,v 1.3 88/12/02 10:43:37 bvs Exp $ */
/* Copyright (C) 1988 by Sun Microsystems. All rights reserved. */
#include <stdio.h>
#include <math.h>
#include "go.h"
#include "gopvt.h"
/* line section */
typedef struct {
ITEMHEADER;
} ILINE;
static void *LineHolder()
{
return((ILINE *)malloc(sizeof(ILINE)));
}
#define SQUARE(x) ((x)*(x))
static void *LineNew(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
double length = sqrt((double)(SQUARE(x0 - x1) + SQUARE(y0 - y1)));
ILINE *pitem = (ILINE *)malloc(sizeof(ILINE));
pitem->type = LINE;
pitem->rotation =
atan2((double)(y1 - y0), (double)(x1 - x0)) * 180.0 / M_PI;
pitem->x0 = (int)(((double)x0 + (double)x1 - length) / 2.0);
pitem->y0 = (y0 + y1) / 2;
pitem->x1 = pitem->x0 + length;
pitem->y1 = pitem->y0;
pitem->xscale = 1;
pitem->yscale = 1;
pitem->prop = PropCopyOf(PropCurrent());
return(pitem);
}
static void *LineDraw(pitem)
ILINE *pitem;
{
float stroke = PropStrokeColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
ps_gsave();
if(stroke >= 0.0)
{
ps_setlinewidth(width);
ps_setgray(stroke);
ps_drawline(X0, Y0, X1, Y1);
ps_stroke();
}
ps_grestore();
return(pitem);
}
static void *LinePrint(pitem, pfile)
ILINE *pitem;
FILE *pfile;
{
float stroke = PropStrokeColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
fprintf(pfile, "%% line\n");
if(stroke >= 0.0)
{
fprintf(pfile, "%d setlinewidth ", width);
fprintf(pfile, "%f setgray ", stroke);
fprintf(pfile, "%d %d %d %d linepath ", X0, Y0, X1, Y1);
fprintf(pfile, "stroke\n");
}
return(pitem);
}
GOLineInit(pgoprocs)
GOPROCS *pgoprocs;
{
pgoprocs->holder= LineHolder;
pgoprocs->new = LineNew;
pgoprocs->draw = LineDraw;
pgoprocs->print = LinePrint;
}
/************* event handlers *************/
static void *LineSelect(x, y)
int x,y;
{
ps_linecreateinteractive(x, y);
}
static void *LineAdjust(x, y)
int x,y;
{
fprintf(stderr, "LineAdjust not implemented\n");
}
static void *LineReply(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
ITEM *pitem;
if((x0 == x1) && (y0 == y1)) return;
pitem = GONewLine(x0, y0, x1, y1);
GOItemAddToTop(pitem);
GODrawItem(pitem);
return(pitem);
}
static void *LineBegin()
{
ps_xcursor();
}
EHLineInit(pprocs)
EHPROCS *pprocs;
{
pprocs->handleselect = LineSelect;
pprocs->handleadjust = LineAdjust;
pprocs->handlereply = LineReply;
pprocs->handlebegin = LineBegin;
}
SHAR_EOF
fi
if test -f 'oval.c'
then
echo shar: "will not over-write existing file 'oval.c'"
else
cat << \SHAR_EOF > 'oval.c'
/* $Header: oval.c,v 1.3 88/12/02 10:43:39 bvs Exp $ */
/* Copyright (C) 1988 by Sun Microsystems. All rights reserved. */
#include <stdio.h>
#include "go.h"
#include "gopvt.h"
/* oval section */
typedef struct {
ITEMHEADER;
} IOVAL;
static void *OvalHolder()
{
return((IOVAL *)malloc(sizeof(IOVAL)));
}
static void *OvalNew(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
IOVAL *pitem = (IOVAL *)malloc(sizeof(IOVAL));
pitem->type = OVAL;
pitem->x0 = MIN(x0, x1);
pitem->y0 = MIN(y0, y1);
pitem->x1 = MAX(x0, x1);
pitem->y1 = MAX(y0, y1);
pitem->rotation = 0;
pitem->xscale = 1;
pitem->yscale = 1;
pitem->prop = PropCopyOf(PropCurrent());
return(pitem);
}
static void *OvalDraw(pitem)
IOVAL *pitem;
{
float stroke = PropStrokeColor(pitem->prop);
float fill = PropFillColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
ps_gsave();
if(fill >= 0.0)
{
ps_setgray(fill);
ps_drawoval(X0, Y0, X1, Y1);
ps_fill();
}
if(stroke >= 0.0)
{
ps_setlinewidth(width);
ps_setgray(stroke);
ps_drawoval(X0, Y0, X1, Y1);
ps_stroke();
}
ps_grestore();
return(pitem);
}
static void *OvalPrint(pitem, pfile)
IOVAL *pitem;
FILE *pfile;
{
float stroke = PropStrokeColor(pitem->prop);
float fill = PropFillColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
fprintf(pfile, "%% oval\n");
if(fill >= 0.0)
{
fprintf(pfile, "%f setgray ", fill);
fprintf(pfile, "%d %d %d %d ovalpath ", X0, Y0, W, H);
fprintf(pfile, "fill\n");
}
if(stroke >= 0.0)
{
fprintf(pfile, "%d setlinewidth ", width);
fprintf(pfile, "%f setgray ", stroke);
fprintf(pfile, "%d %d %d %d ovalpath ", X0, Y0, W, H);
fprintf(pfile, "stroke\n");
}
return(pitem);
}
GOOvalInit(pgoprocs)
GOPROCS *pgoprocs;
{
pgoprocs->holder= OvalHolder;
pgoprocs->new = OvalNew;
pgoprocs->draw = OvalDraw;
pgoprocs->print = OvalPrint;
}
/************* event handlers *************/
static void *OvalSelect(x, y)
int x,y;
{
ps_ovalcreateinteractive(x, y);
}
static void *OvalAdjust(x, y)
int x,y;
{
fprintf(stderr, "OvalAdjust not implemented\n");
}
static void *OvalReply(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
ITEM *pitem;
if((x0 == x1) && (y0 == y1)) return;
pitem = GONewOval(x0, y0, x1, y1);
GOItemAddToTop(pitem);
GODrawItem(pitem);
return(pitem);
}
static void *OvalBegin()
{
ps_xcursor();
}
EHOvalInit(pprocs)
EHPROCS *pprocs;
{
pprocs->handleselect = OvalSelect;
pprocs->handleadjust = OvalAdjust;
pprocs->handlereply = OvalReply;
pprocs->handlebegin = OvalBegin;
}
SHAR_EOF
fi
if test -f 'rect.c'
then
echo shar: "will not over-write existing file 'rect.c'"
else
cat << \SHAR_EOF > 'rect.c'
/* $Header: rect.c,v 1.4 88/12/02 10:43:24 bvs Exp $ */
/* Copyright (C) 1988 by Sun Microsystems. All rights reserved. */
#include <stdio.h>
#include "go.h"
#include "gopvt.h"
/* rect section */
typedef struct {
ITEMHEADER;
} IRECT;
static void *RectHolder()
{
return((IRECT *)malloc(sizeof(IRECT)));
}
static void *RectNew(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
IRECT *pitem = (IRECT *)RectHolder();
pitem->type = RECT;
pitem->x0 = MIN(x0, x1);
pitem->y0 = MIN(y0, y1);
pitem->x1 = MAX(x0, x1);
pitem->y1 = MAX(y0, y1);
pitem->rotation = 0;
pitem->xscale = 1;
pitem->yscale = 1;
pitem->prop = PropCopyOf(PropCurrent());
return(pitem);
}
static void *RectDraw(pitem)
IRECT *pitem;
{
float stroke = PropStrokeColor(pitem->prop);
float fill = PropFillColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
ps_gsave();
if(fill >= 0.0)
{
ps_setgray(fill);
ps_drawrect(X0, Y0, X1, Y1);
ps_fill();
}
if(stroke >= 0.0)
{
ps_setlinewidth(width);
ps_setgray(stroke);
ps_drawrect(X0, Y0, X1, Y1);
ps_stroke();
}
ps_grestore();
return(pitem);
}
static void *RectPrint(pitem, pfile)
IRECT *pitem;
FILE *pfile;
{
float stroke = PropStrokeColor(pitem->prop);
float fill = PropFillColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
fprintf(pfile, "%% rectangle\n");
if(fill >= 0.0)
{
fprintf(pfile, "%f setgray ", fill);
fprintf(pfile, "%d %d %d %d rectpath ", X0, Y0, W, H);
fprintf(pfile, "fill\n");
}
if(stroke >= 0.0)
{
fprintf(pfile, "%d setlinewidth ", width);
fprintf(pfile, "%f setgray ", stroke);
fprintf(pfile, "%d %d %d %d rectpath ", X0, Y0, W, H);
fprintf(pfile, "stroke\n");
}
return(pitem);
}
GORectInit(pgoprocs)
GOPROCS *pgoprocs;
{
pgoprocs->holder= RectHolder;
pgoprocs->new = RectNew;
pgoprocs->draw = RectDraw;
pgoprocs->print = RectPrint;
}
/************* event handlers *************/
static void *RectSelect(x, y)
int x,y;
{
ps_rectcreateinteractive(x, y);
}
static void *RectAdjust(x, y)
int x,y;
{
fprintf(stderr, "RectAdjust not implemented\n");
}
static void *RectReply(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
ITEM *pitem;
if((x0 == x1) && (y0 == y1)) return;
pitem = GONewRect(x0, y0, x1, y1);
GOItemAddToTop(pitem);
GODrawItem(pitem);
return(pitem);
}
static void *RectBegin()
{
ps_xcursor();
}
EHRectInit(pprocs)
EHPROCS *pprocs;
{
pprocs->handleselect = RectSelect;
pprocs->handleadjust = RectAdjust;
pprocs->handlereply = RectReply;
pprocs->handlebegin = RectBegin;
}
SHAR_EOF
fi
if test -f 'text.c'
then
echo shar: "will not over-write existing file 'text.c'"
else
cat << \SHAR_EOF > 'text.c'
/* $Header: text.c,v 1.3 88/12/02 10:43:41 bvs Exp $ */
/* Copyright (C) 1988 by Sun Microsystems. All rights reserved. */
#include <stdio.h>
#include "go.h"
#include "gopvt.h"
/* text section */
typedef struct {
ITEMHEADER;
char *ptext;
} ITEXT;
static void *TextHolder()
{
return((ITEXT *)malloc(sizeof(ITEXT)));
}
extern double sqrt();
static void *TextNew(x0, y0, ptext)
int x0, y0;
char *ptext;
{
ITEXT *pitem = (ITEXT *)malloc(sizeof(ITEXT));
pitem->prop = PropCopyOf(PropCurrent());
pitem->type = TEXT;
pitem->rotation = 0;
pitem->xscale = 1;
pitem->yscale = 1;
pitem->ptext = (char *)malloc(strlen(ptext));
strcpy(pitem->ptext, ptext);
pitem->y0 = y0 - FontDescent(PropFont(pitem->prop));
pitem->y1 = y0 + FontAscent(PropFont(pitem->prop));
pitem->x0 = x0;
pitem->x1 = x0 + FontTextWidth(PropFont(pitem->prop), ptext);
return(pitem);
}
static void *TextDraw(pitem)
ITEXT *pitem;
{
float text = PropTextColor(pitem->prop);
FONT *pfont = PropFont(pitem->prop);
ps_gsave();
if(text >= 0.0)
{
ps_setgray(text);
ps_moveto(pitem->x0, pitem->y0 + FontDescent(pfont));
ps_show(pitem->ptext);
}
ps_grestore();
return(pitem);
}
static void *TextPrint(pitem, pfile)
ITEXT *pitem;
FILE *pfile;
{
float text = PropTextColor(pitem->prop);
FONT *pfont = PropFont(pitem->prop);
if(text >= 0.0)
{
fprintf(pfile, "%f setgray ", text);
fprintf(pfile, "%d %d moveto ",
pitem->x0, pitem->y0 + FontDescent(pfont));
fprintf(pfile, "(%s) show\n", pitem->ptext);
}
return(pitem);
}
static void *TextWrite(pitem, pfile)
ITEXT *pitem;
FILE *pfile;
{
char *pc;
pc = pitem->ptext;
while((*pc != 0) && (*pc != '\n') && (*pc != 10))
{
fputc(*pc, pfile);
pc++;
}
fputc('\n', pfile);
/* fprintf(pfile, "%s\n", pitem->ptext); */
}
static void *TextRead(pitem, pfile)
ITEXT *pitem;
FILE *pfile;
{
char buf[256];
fgets(buf, 256, pfile);
pitem->ptext = (char *)malloc(strlen(buf));
strcpy(pitem->ptext, buf);
}
GOTextInit(pgoprocs)
GOPROCS *pgoprocs;
{
pgoprocs->holder= TextHolder;
pgoprocs->new = TextNew;
pgoprocs->draw = TextDraw;
pgoprocs->print = TextPrint;
pgoprocs->write = TextWrite;
pgoprocs->read = TextRead;
}
/************* event handlers *************/
static int iText = 0;
static char aText[255];
static int textx, texty;
static int bSaved = 0;
static void *TextBegin()
{
ps_xcursor();
}
static void *TextSelect(x, y)
int x,y;
{
int ascent = FontAscent(FontDefault());
int descent = FontDescent(FontDefault());
if(iText != 0)
{
TextComplete();
}
iText = 0;
aText[0] = 0;
textx = x;
texty = y;
if(bSaved) ps_restorearea();
ps_savearea(textx - 6, texty - descent - 1, 1000, texty + ascent + 1);
/* ps_savearea(0, 0, 1000, 1000); */
bSaved = 1;
ps_setgray(1.0);
ps_drawrect(textx - 4, texty - descent - 1, textx + 4, texty + ascent + 1);
ps_fill();
ps_setgray(0.0);
ps_drawline(textx, texty - descent, textx, texty + ascent);
ps_drawline(textx - 3, texty, textx + 3, texty);
ps_stroke();
}
static void *TextAdjust(x, y)
int x,y;
{
fprintf(stderr, "TextAdjust not implemented\n");
}
static void *TextKey(key)
int key;
{
int ascent = FontAscent(FontDefault());
int descent = FontDescent(FontDefault());
/* fprintf(stderr, "TextKey %c (0x%x)\n", key, key); */
switch(key)
{
default:
aText[iText] = key;
iText++;
aText[iText] = 0;
break;
case 0177:
case '\b':
if(iText)
{
iText--;
aText[iText] = 0;
}
break;
}
ps_restorearea();
ps_setgray(PropTextColor(PropCurrent()));
ps_moveto(textx, texty);
ps_show(aText);
ps_rlineto(0, ascent);
ps_rlineto(0, -ascent - descent);
ps_rmoveto(0, descent);
ps_rmoveto(-3, 0);
ps_rlineto(6, 0);
ps_stroke();
}
static TextComplete()
{
ITEM *pitem;
ps_restorearea();
bSaved = 0;
pitem = GONewText(textx, texty, aText, FontDefault());
GOItemAddToTop(pitem);
GODrawItem(pitem);
/*
ps_moveto(textx, texty);
ps_show(aText);
*/
iText = 0;
aText[0] = 0;
}
static void *TextEnd()
{
if(iText)
TextComplete();
else if(bSaved)
ps_restorearea();
}
static void *TextProp(c)
int c;
{
PropHandle(c);
if(iText != 0)
{
ps_setgray(PropTextColor(PropCurrent()));
ps_moveto(textx, texty);
ps_show(aText);
}
}
EHTextInit(pprocs)
EHPROCS *pprocs;
{
pprocs->handleselect = TextSelect;
pprocs->handleadjust = TextAdjust;
pprocs->handlekey = TextKey;
pprocs->handlebegin = TextBegin;
pprocs->handleend = TextEnd;
pprocs->handleprop = TextProp;
}
SHAR_EOF
fi
if test -f 'poly.c'
then
echo shar: "will not over-write existing file 'poly.c'"
else
cat << \SHAR_EOF > 'poly.c'
/* $Header: poly.c,v 1.2 88/12/02 10:43:49 bvs Exp $ */
/* Copyright (C) 1988 by Sun Microsystems. All rights reserved. */
#include <stdio.h>
#include <math.h>
#include "go.h"
#include "gopvt.h"
/* poly section */
typedef struct {
int x;
int y;
} POINT;
typedef struct {
ITEMHEADER;
POINT *apoint;
int length;
int closepath;
} IPOLY;
static void *PolyHolder()
{
return((IPOLY *)malloc(sizeof(IPOLY)));
}
static PolyMinMax(pitem, apoint, length)
IPOLY *pitem;
POINT apoint[];
int length;
{
int i;
int x0 = apoint[0].x;
int y0 = apoint[0].y;
int x1 = x0;
int y1 = y0;
/* find bounds */
for(i = 1; i < length; i++)
{
x0 = MIN(x0, apoint[i].x);
y0 = MIN(y0, apoint[i].y);
x1 = MAX(x1, apoint[i].x);
y1 = MAX(y1, apoint[i].y);
}
/* make relative */
for(i = length - 1; i > 0; i--)
{
apoint[i].x -= apoint[i - 1].x;
apoint[i].y -= apoint[i - 1].y;
}
apoint[0].x -= x0;
apoint[0].y -= y0;
pitem->x0 = x0;
pitem->y0 = y0;
pitem->x1 = x1;
pitem->y1 = y1;
pitem->apoint = apoint;
pitem->length = length;
}
static void *PolyNew(apoint, length, closepath)
POINT apoint[]; /* apoint will not be copied by this proc! */
int length;
int closepath;
{
IPOLY *pitem = (IPOLY *)PolyHolder();
pitem->type = POLY;
pitem->rotation = 0;
pitem->closepath= closepath;
/* take care of x0,y0,x1,y1 */
PolyMinMax(pitem, apoint, length);
pitem->xscale = 1;
pitem->yscale = 1;
pitem->prop = PropCopyOf(PropCurrent());
return(pitem);
}
static void *PolyDraw(pitem)
IPOLY *pitem;
{
float stroke = PropStrokeColor(pitem->prop);
float fill = PropFillColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
int i;
ps_gsave();
if(fill >= 0.0)
{
ps_setgray(fill);
ps_moveto(pitem->x0, pitem->y0);
ps_rmoveto(pitem->apoint[0].x, pitem->apoint[0].y);
for(i = 1; i < pitem->length; i++)
ps_rlineto(pitem->apoint[i].x, pitem->apoint[i].y);
ps_closepath();
ps_fill();
}
if(stroke >= 0.0)
{
ps_setlinewidth(width);
ps_setgray(stroke);
ps_moveto(pitem->x0, pitem->y0);
ps_rmoveto(pitem->apoint[0].x, pitem->apoint[0].y);
for(i = 1; i < pitem->length; i++)
ps_rlineto(pitem->apoint[i].x, pitem->apoint[i].y);
if(pitem->closepath) ps_closepath();
ps_stroke();
}
ps_grestore();
return(pitem);
}
static void *PolyPrint(pitem, pfile)
IPOLY *pitem;
FILE *pfile;
{
float stroke = PropStrokeColor(pitem->prop);
float fill = PropFillColor(pitem->prop);
int width = PropLineWidth(pitem->prop);
int i;
fprintf(pfile, "%% poly\n");
if(fill >= 0.0)
{
fprintf(pfile, "%f setgray ", fill);
fprintf(pfile, "%d %d moveto ", pitem->x0, pitem->y0);
fprintf(pfile, "%d %d rmoveto ",
pitem->apoint[0].x, pitem->apoint[0].y);
fprintf(pfile, "\n");
for(i = 1; i < pitem->length; i++)
{
fprintf(pfile, "%d %d rlineto \n",
pitem->apoint[i].x, pitem->apoint[i].y);
}
fprintf(pfile, "closepath fill\n");
}
if(stroke >= 0.0)
{
fprintf(pfile, "%d setlinewidth ", width);
fprintf(pfile, "%f setgray ", stroke);
fprintf(pfile, "%d %d moveto ", pitem->x0, pitem->y0);
fprintf(pfile, "%d %d rmoveto ",
pitem->apoint[0].x, pitem->apoint[0].y);
fprintf(pfile, "\n");
for(i = 1; i < pitem->length; i++)
{
fprintf(pfile, "%d %d rlineto ",
pitem->apoint[i].x, pitem->apoint[i].y);
}
if(pitem->closepath) fprintf(pfile, "closepath ");
fprintf(pfile, "stroke\n");
}
return(pitem);
}
static void *PolyWrite(pitem, pfile)
IPOLY *pitem;
FILE *pfile;
{
int i;
fprintf(pfile, "%d ", pitem->closepath);
fprintf(pfile, "%d\n", pitem->length);
for(i = 0; i < pitem->length; i++)
fprintf(pfile, "%d %d\n", pitem->apoint[i].x, pitem->apoint[i].y);
}
static void *PolyRead(pitem, pfile)
IPOLY *pitem;
FILE *pfile;
{
int i;
if(1 != fscanf(pfile, "%d", &pitem->closepath))
{
fprintf(stderr, "Error reading poly...exiting");
exit(1);
}
if(1 != fscanf(pfile, "%d", &pitem->length))
{
fprintf(stderr, "Error reading poly...exiting");
exit(1);
}
pitem->apoint = (POINT *)malloc(pitem->length * sizeof(POINT));
for(i = 0; i < pitem->length; i++)
{
if(2 != fscanf(pfile, "%d %d",
&pitem->apoint[i].x, &pitem->apoint[i].y))
{
fprintf(stderr, "Error reading poly...exiting");
exit(1);
}
}
while(getc(pfile) != '\n') ;
}
GOPolyInit(pgoprocs)
GOPROCS *pgoprocs;
{
pgoprocs->holder= PolyHolder;
pgoprocs->new = PolyNew;
pgoprocs->draw = PolyDraw;
pgoprocs->print = PolyPrint;
pgoprocs->read = PolyRead;
pgoprocs->write = PolyWrite;
}
/* Brushes and polygons draw the same! */
GOBrushInit(pgoprocs)
GOPROCS *pgoprocs;
{
GOPolyInit(pgoprocs);
}
/************* event handlers *************/
static POINT *pbuf = (POINT *)0;
static POINT *pcurrent;
static int lcurrent;
#define MAXPOINTS 100
static polyBeginCurrent(x, y)
int x, y;
{
lcurrent = 1;
pbuf = pcurrent = (POINT *)malloc(MAXPOINTS * sizeof(POINT));
pcurrent->x = x;
pcurrent->y = y;
}
static polyAddPoint(x, y)
int x, y;
{
lcurrent++;
if(lcurrent >= MAXPOINTS)
{
fprintf(stderr, "too many points in polygon\n");
return;
}
ps_drawline(pcurrent->x, pcurrent->y, x, y);
ps_stroke();
pcurrent++;
pcurrent->x = x;
pcurrent->y = y;
}
static polyEndCurrent()
{
ITEM *pitem;
POINT *ppoint;
if(lcurrent == 1)
{
free(pbuf);
return;
}
/* polyAddPoint(pbuf->x, pbuf->y); */
ppoint = (POINT *)malloc(lcurrent * sizeof(POINT));
bcopy(pbuf, ppoint, lcurrent * sizeof(POINT));
pitem = PolyNew(ppoint, lcurrent, 1);
GOItemAddToTop(pitem);
GODrawItem(pitem);
free(pbuf);
pbuf = 0;
lcurrent = 1;
}
static void *PolySelect(x, y)
int x,y;
{
if(pbuf)
return;
polyBeginCurrent(x, y);
ps_linecreateinteractive(x, y);
}
static void *PolyAdjust(x, y)
int x,y;
{
}
static void *PolyReply(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
if((lcurrent != 1) && (pcurrent->x == x1) && (pcurrent->y == y1))
{
polyAddPoint(x1, y1);
polyEndCurrent();
return;
}
polyAddPoint(x1, y1);
ps_linecreateinteractive(x1, y1);
}
static void *PolyEnd()
{
if(pbuf)
{
polyEndCurrent();
}
}
static void *PolyBegin()
{
ps_xcursor();
}
EHPolyInit(pprocs)
EHPROCS *pprocs;
{
pprocs->handleselect = PolySelect;
pprocs->handleadjust = PolyAdjust;
pprocs->handlereply = PolyReply;
pprocs->handlebegin = PolyBegin;
pprocs->handlebegin = PolyEnd;
}
/************* event handlers *************/
static void *BrushSelect(x, y)
int x,y;
{
ps_pencilCreateinteractive(x, y);
}
static void *BrushAdjust(x, y)
int x,y;
{
}
static void *BrushReply(x0, y0, x1, y1)
int x0, y0, x1, y1;
{
ITEM *pitem;
int length;
int i;
POINT *ppoint;
ps_getint(&length);
ppoint = (POINT *)malloc(length * sizeof(POINT));
for(i = 0; i < length; i++)
{
ps_getint(&ppoint[i].x);
ps_getint(&ppoint[i].y);
}
pitem = PolyNew(ppoint, length, 0);
GOItemAddToTop(pitem);
GODrawItem(pitem);
return(pitem);
}
static void *BrushEnd()
{
}
static void *BrushBegin()
{
ps_xcursor();
}
EHBrushInit(pprocs)
EHPROCS *pprocs;
{
pprocs->handleselect = BrushSelect;
pprocs->handleadjust = BrushAdjust;
pprocs->handlereply = BrushReply;
pprocs->handlebegin = BrushBegin;
pprocs->handlebegin = BrushEnd;
}
SHAR_EOF
fi
exit 0
# End of shell archive