void
plstik(PLFLT mx, PLFLT my, PLFLT dx, PLFLT dy)
{
plP_draphy(plP_mmpcx(mx), plP_mmpcy(my));
plP_draphy(plP_mmpcx((PLFLT) (mx + dx)), plP_mmpcy((PLFLT) (my + dy)));
plP_draphy(plP_mmpcx(mx), plP_mmpcy(my));
}
void
plxtik(PLINT x, PLINT y, PLINT below, PLINT above)
{
plP_draphy(x, y);
if (below != 0)
plP_draphy(x, y - below);
if (above != 0)
plP_draphy(x, y + above);
plP_draphy(x, y);
}
void
plytik(PLINT x, PLINT y, PLINT left, PLINT right)
{
plP_draphy(x, y);
if (left != 0)
plP_draphy(x - left, y);
if (right != 0)
plP_draphy(x + right, y);
plP_draphy(x, y);
}
void
c_plpoin3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code)
{
PLINT i, sym, ifont = plsc->cfont;
PLFLT u, v;
PLFLT xmin, xmax, ymin, ymax, zmin, zmax, zscale;
if (plsc->level < 3) {
plabort("plpoin3: Please set up window first");
return;
}
if (code < -1 || code > 127) {
plabort("plpoin3: Invalid code");
return;
}
plP_gdom(&xmin, &xmax, &ymin, &ymax);
plP_grange(&zscale, &zmin, &zmax);
if (code == -1) {
for (i = 0; i < n; i++) {
if(x[i] >= xmin && x[i] <= xmax &&
y[i] >= ymin && y[i] <= ymax &&
z[i] >= zmin && z[i] <= zmax) {
u = plP_wcpcx(plP_w3wcx( x[i], y[i], z[i] ));
v = plP_wcpcy(plP_w3wcy( x[i], y[i], z[i] ));
plP_movphy(u,v);
plP_draphy(u,v);
}
}
}
else {
if (ifont > numberfonts)
ifont = 1;
sym = *(fntlkup + (ifont - 1) * numberchars + code);
for( i=0; i < n; i++ ) {
if(x[i] >= xmin && x[i] <= xmax &&
y[i] >= ymin && y[i] <= ymax &&
z[i] >= zmin && z[i] <= zmax) {
u = plP_wcpcx(plP_w3wcx( x[i], y[i], z[i] ));
v = plP_wcpcy(plP_w3wcy( x[i], y[i], z[i] ));
plhrsh(sym, u, v);
}
}
}
return;
}
void
plfill_soft(short *x, short *y, PLINT n)
{
PLINT i, j;
PLINT xp1, yp1, xp2, yp2, xp3, yp3;
PLINT k, dinc;
PLFLT ci, si;
double temp;
buffersize = 2 * BINC;
buffer = (PLINT *) malloc((size_t) buffersize * sizeof(PLINT));
if ( ! buffer) {
plabort("plfill: Out of memory");
return;
}
/* Loop over sets of lines in pattern */
for (k = 0; k < plsc->nps; k++) {
bufferleng = 0;
temp = DTOR * plsc->inclin[k] * 0.1;
si = sin(temp) * plsc->ypmm;
ci = cos(temp) * plsc->xpmm;
/* normalize: 1 = si*si + ci*ci */
temp = sqrt((double) (si*si + ci*ci));
si /= temp;
ci /= temp;
dinc = plsc->delta[k] * SSQR(plsc->ypmm * ABS(ci),
plsc->xpmm * ABS(si)) / 1000.;
if (dinc < 0) dinc = -dinc;
if (dinc == 0) dinc = 1;
xp1 = x[n-2];
yp1 = y[n-2];
tran(&xp1, &yp1, (PLFLT) ci, (PLFLT) si);
xp2 = x[n-1];
yp2 = y[n-1];
tran(&xp2, &yp2, (PLFLT) ci, (PLFLT) si);
/* Loop over points in polygon */
for (i = 0; i < n; i++) {
xp3 = x[i];
yp3 = y[i];
tran(&xp3, &yp3, (PLFLT) ci, (PLFLT) si);
buildlist(xp1, yp1, xp2, yp2, xp3, yp3, dinc);
xp1 = xp2;
yp1 = yp2;
xp2 = xp3;
yp2 = yp3;
}
/* Sort list by y then x */
qsort((void *) buffer, (size_t) bufferleng / 2,
(size_t) sizeof(struct point), compar);
/* OK, now do the hatching */
i = 0;
while (i < bufferleng) {
xp1 = buffer[i];
yp1 = buffer[i + 1];
i += 2;
xp2 = xp1;
yp2 = yp1;
tran(&xp1, &yp1, (PLFLT) ci, (PLFLT) (-si));
plP_movphy(xp1, yp1);
xp1 = buffer[i];
yp1 = buffer[i + 1];
i += 2;
if (yp2 != yp1) {
fprintf(stderr, "plfill: oh oh we are lost\n");
for (j = 0; j < bufferleng; j+=2) {
fprintf(stderr, "plfill: %d %d\n",
(int) buffer[j], (int) buffer[j+1]);
}
continue; /* Uh oh we're lost */
}
tran(&xp1, &yp1, (PLFLT) ci, (PLFLT) (-si));
plP_draphy(xp1, yp1);
}
}
free((void *) buffer);
}
/*----------------------------------------------------------------------*\
* void plline3(n, x, y, z)
*
* Draws a line in 3 space. You must first set up the viewport, the
* 2d viewing window (in world coordinates), and the 3d normalized
* coordinate box. See x18c.c for more info.
*
* This version adds clipping against the 3d bounding box specified in plw3d
\*----------------------------------------------------------------------*/
void
c_plline3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
{
int i;
PLFLT vmin[3], vmax[3], zscale;
if (plsc->level < 3) {
plabort("plline3: Please set up window first");
return;
}
/* get the bounding box in 3d */
plP_gdom(&vmin[0], &vmax[0], &vmin[1], &vmax[1]);
plP_grange(&zscale, &vmin[2], &vmax[2]);
/* interate over the vertices */
for( i=0; i < n-1; i++ ) {
PLFLT p0[3], p1[3];
int axis;
/* copy the end points of the segment to allow clipping */
p0[0] = x[i]; p0[1] = y[i]; p0[2] = z[i];
p1[0] = x[i+1]; p1[1] = y[i+1]; p1[2] = z[i+1];
/* check against each axis of the bounding box */
for(axis = 0; axis < 3; axis++) {
if(p0[axis] < vmin[axis]) { /* first out */
if(p1[axis] < vmin[axis]) {
break; /* both endpoints out so quit */
} else {
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmin[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p0[axis] = vmin[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p0[k] = (1-t)*p0[k] + t*p1[k];
}
}
} else if(p1[axis] < vmin[axis]) { /* second out */
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmin[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p1[axis] = vmin[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p1[k] = (1-t)*p0[k] + t*p1[k];
}
}
if(p0[axis] > vmax[axis]) { /* first out */
if(p1[axis] > vmax[axis]) {
break; /* both out so quit */
} else {
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmax[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p0[axis] = vmax[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p0[k] = (1-t)*p0[k] + t*p1[k];
}
}
} else if(p1[axis] > vmax[axis]) { /* second out */
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmax[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p1[axis] = vmax[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p1[k] = (1-t)*p0[k] + t*p1[k];
}
}
}
/* if we made it to here without "break"ing out of the loop, the
remaining segment is visible */
if( axis == 3 ) { /* not clipped away */
PLFLT u0, v0, u1, v1;
u0 = plP_wcpcx(plP_w3wcx( p0[0], p0[1], p0[2] ));
v0 = plP_wcpcy(plP_w3wcy( p0[0], p0[1], p0[2] ));
u1 = plP_wcpcx(plP_w3wcx( p1[0], p1[1], p1[2] ));
v1 = plP_wcpcy(plP_w3wcy( p1[0], p1[1], p1[2] ));
plP_movphy(u0,v0);
plP_draphy(u1,v1);
}
}
return;
}
void
c_plpoly3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLBOOL *draw, PLBOOL ifcc)
{
int i;
PLFLT vmin[3], vmax[3], zscale;
PLFLT u1, v1, u2, v2, u3, v3;
PLFLT c;
if (plsc->level < 3) {
plabort("plpoly3: Please set up window first");
return;
}
if ( n < 3 ) {
plabort("plpoly3: Must specify at least 3 points");
return;
}
/* Now figure out which side this is. */
u1 = plP_wcpcx(plP_w3wcx( x[0], y[0], z[0] ));
v1 = plP_wcpcy(plP_w3wcy( x[0], y[0], z[0] ));
u2 = plP_wcpcx(plP_w3wcx( x[1], y[1], z[1] ));
v2 = plP_wcpcy(plP_w3wcy( x[1], y[1], z[1] ));
u3 = plP_wcpcx(plP_w3wcx( x[2], y[2], z[2] ));
v3 = plP_wcpcy(plP_w3wcy( x[2], y[2], z[2] ));
c = (u1-u2)*(v3-v2)-(v1-v2)*(u3-u2);
if ( c *(1 - 2*ABS(ifcc)) < 0. )
return;
/* get the bounding box in 3d */
plP_gdom(&vmin[0], &vmax[0], &vmin[1], &vmax[1]);
plP_grange(&zscale, &vmin[2], &vmax[2]);
/* interate over the vertices */
for( i=0; i < n-1; i++ ) {
PLFLT p0[3], p1[3];
int axis;
/* copy the end points of the segment to allow clipping */
p0[0] = x[i]; p0[1] = y[i]; p0[2] = z[i];
p1[0] = x[i+1]; p1[1] = y[i+1]; p1[2] = z[i+1];
/* check against each axis of the bounding box */
for(axis = 0; axis < 3; axis++) {
if(p0[axis] < vmin[axis]) { /* first out */
if(p1[axis] < vmin[axis]) {
break; /* both endpoints out so quit */
} else {
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmin[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p0[axis] = vmin[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p0[k] = (1-t)*p0[k] + t*p1[k];
}
}
} else if(p1[axis] < vmin[axis]) { /* second out */
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmin[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p1[axis] = vmin[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p1[k] = (1-t)*p0[k] + t*p1[k];
}
}
if(p0[axis] > vmax[axis]) { /* first out */
if(p1[axis] > vmax[axis]) {
break; /* both out so quit */
} else {
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmax[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p0[axis] = vmax[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p0[k] = (1-t)*p0[k] + t*p1[k];
}
}
} else if(p1[axis] > vmax[axis]) { /* second out */
int j;
/* interpolate to find intersection with box */
PLFLT t = (vmax[axis] - p0[axis]) / (p1[axis] - p0[axis]);
p1[axis] = vmax[axis];
for(j = 1; j<3; j++) {
int k = (axis+j)%3;
p1[k] = (1-t)*p0[k] + t*p1[k];
}
}
}
/* if we made it to here without "break"ing out of the loop, the
remaining segment is visible */
if( axis == 3 && draw[i] ) { /* not clipped away */
PLFLT myu0, myv0, myu1, myv1;
myu0 = plP_wcpcx(plP_w3wcx( p0[0], p0[1], p0[2] ));
myv0 = plP_wcpcy(plP_w3wcy( p0[0], p0[1], p0[2] ));
myu1 = plP_wcpcx(plP_w3wcx( p1[0], p1[1], p1[2] ));
myv1 = plP_wcpcy(plP_w3wcy( p1[0], p1[1], p1[2] ));
plP_movphy(myu0,myv0);
plP_draphy(myu1,myv1);
}
}
return;
}
void
plytik( PLINT x, PLINT y, PLINT left, PLINT right )
{
plP_movphy( x - left, y );
plP_draphy( x + right, y );
}
void
plxtik( PLINT x, PLINT y, PLINT below, PLINT above )
{
plP_movphy( x, y - below );
plP_draphy( x, y + above );
}
void
c_plaxes(PLFLT x0, PLFLT y0,
const char *xopt, PLFLT xtick, PLINT nxsub,
const char *yopt, PLFLT ytick, PLINT nysub)
{
PLINT lax, lbx, lcx, lgx, lix, llx, lsx, ltx;
PLINT lay, lby, lcy, lgy, liy, lly, lsy, lty;
PLINT xmajor, xminor, ymajor, yminor;
PLINT i, i1x, i2x, i3x, i4x, i1y, i2y, i3y, i4y;
PLINT nxsub1, nysub1;
PLINT lxmin, lxmax, lymin, lymax;
PLINT pxmin, pxmax, pymin, pymax;
PLINT vppxmi, vppxma, vppymi, vppyma;
PLFLT xtick1, ytick1, vpwxmi, vpwxma, vpwymi, vpwyma;
PLFLT vpwxmin, vpwxmax, vpwymin, vpwymax;
PLFLT xp0, yp0, tn, tp, temp;
if (plsc->level < 3) {
plabort("plbox: Please set up window first");
return;
}
/* Open the clip limits to the subpage limits */
plP_gclp(&lxmin, &lxmax, &lymin, &lymax);
plP_gphy(&pxmin, &pxmax, &pymin, &pymax);
plP_sclp(pxmin, pxmax, pymin, pymax);
vppxmi = plsc->vppxmi;
vppxma = plsc->vppxma;
vppymi = plsc->vppymi;
vppyma = plsc->vppyma;
/* Convert world coordinates to physical */
xp0 = plP_wcpcx(x0);
yp0 = plP_wcpcy(y0);
/* Set plot options from input */
lax = plP_stsearch(xopt, 'a');
lbx = plP_stsearch(xopt, 'b');
lcx = plP_stsearch(xopt, 'c');
lgx = plP_stsearch(xopt, 'g');
lix = plP_stsearch(xopt, 'i');
llx = plP_stsearch(xopt, 'l');
lsx = plP_stsearch(xopt, 's');
ltx = plP_stsearch(xopt, 't');
lay = plP_stsearch(yopt, 'a');
lby = plP_stsearch(yopt, 'b');
lcy = plP_stsearch(yopt, 'c');
lgy = plP_stsearch(yopt, 'g');
liy = plP_stsearch(yopt, 'i');
lly = plP_stsearch(yopt, 'l');
lsy = plP_stsearch(yopt, 's');
lty = plP_stsearch(yopt, 't');
/* Tick and subtick sizes in device coords */
xmajor = MAX(ROUND(plsc->majht * plsc->ypmm), 1);
ymajor = MAX(ROUND(plsc->majht * plsc->xpmm), 1);
xminor = MAX(ROUND(plsc->minht * plsc->ypmm), 1);
yminor = MAX(ROUND(plsc->minht * plsc->xpmm), 1);
nxsub1 = nxsub;
nysub1 = nysub;
xtick1 = llx ? 1.0 : xtick;
ytick1 = lly ? 1.0 : ytick;
plgvpw(&vpwxmin, &vpwxmax, &vpwymin, &vpwymax);
/* n.b. large change; vpwxmi always numerically less than vpwxma, and
* similarly for vpwymi */
vpwxmi = (vpwxmax > vpwxmin) ? vpwxmin : vpwxmax;
vpwxma = (vpwxmax > vpwxmin) ? vpwxmax : vpwxmin;
vpwymi = (vpwymax > vpwymin) ? vpwymin : vpwymax;
vpwyma = (vpwymax > vpwymin) ? vpwymax : vpwymin;
lax = lax && vpwymi < y0 && y0 < vpwyma ;
lay = lay && vpwxmi < x0 && x0 < vpwxma ;
/* Calculate tick spacing */
if (ltx || lgx)
pldtik(vpwxmi, vpwxma, &xtick1, &nxsub1);
if (lty || lgy)
pldtik(vpwymi, vpwyma, &ytick1, &nysub1);
/* n.b. large change; xtick1, nxsub1, ytick1, nysub1 always positive. */
/* Set up tick variables */
if (lix) {
i1x = xminor;
i2x = 0;
i3x = xmajor;
i4x = 0;
}
else {
i1x = 0;
i2x = xminor;
i3x = 0;
i4x = xmajor;
}
if (liy) {
i1y = yminor;
i2y = 0;
i3y = ymajor;
i4y = 0;
}
else {
i1y = 0;
i2y = yminor;
i3y = 0;
i4y = ymajor;
}
/* Draw the bottom edge of the box */
if (lbx) {
plP_movphy(vppxmi, vppymi);
if (ltx) {
tp = xtick1 * floor(vpwxmi / xtick1);
for (;;) {
tn = tp + xtick1;
if (lsx) {
if (llx) {
for (i = 0; i <= 7; i++) {
temp = tp + xlog[i];
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), vppymi, i1x, i2x);
}
}
else {
for (i = 1; i <= nxsub1 - 1; i++) {
temp = tp + i * xtick1 / nxsub1;
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), vppymi, i1x, i2x);
}
}
}
if (!BETW(tn, vpwxmi, vpwxma))
break;
plxtik(plP_wcpcx(tn), vppymi, i3x, i4x);
tp = tn;
}
}
plP_draphy(vppxma, vppymi);
}
/* Draw right-hand edge of box */
if (lcy) {
plP_movphy(vppxma, vppymi);
if (lty) {
tp = ytick1 * floor(vpwymi / ytick1);
for (;;) {
tn = tp + ytick1;
if (lsy) {
if (lly) {
for (i = 0; i <= 7; i++) {
temp = tp + xlog[i];
if (BETW(temp, vpwymi, vpwyma))
plytik(vppxma, plP_wcpcy(temp), i2y, i1y);
}
}
else {
for (i = 1; i <= nysub1 - 1; i++) {
temp = tp + i * ytick1 / nysub1;
if (BETW(temp, vpwymi, vpwyma))
plytik(vppxma, plP_wcpcy(temp), i2y, i1y);
}
}
}
if (!BETW(tn, vpwymi, vpwyma))
break;
plytik(vppxma, plP_wcpcy(tn), i4y, i3y);
tp = tn;
}
}
plP_draphy(vppxma, vppyma);
}
/* Draw the top edge of the box */
if (lcx) {
plP_movphy(vppxma, vppyma);
if (ltx) {
tp = xtick1 * (floor(vpwxma / xtick1) + 1);
for (;;) {
tn = tp - xtick1;
if (lsx) {
if (llx) {
for (i = 7; i >= 0; i--) {
temp = tn + xlog[i];
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), vppyma, i2x, i1x);
}
}
else {
for (i = nxsub1 - 1; i >= 1; i--) {
temp = tn + i * xtick1 / nxsub1;
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), vppyma, i2x, i1x);
}
}
}
if (!BETW(tn, vpwxmi, vpwxma))
break;
plxtik(plP_wcpcx(tn), vppyma, i4x, i3x);
tp = tn;
}
}
plP_draphy(vppxmi, vppyma);
}
/* Draw left-hand edge of box */
if (lby) {
plP_movphy(vppxmi, vppyma);
if (lty) {
tp = ytick1 * (floor(vpwyma / ytick1) + 1);
for (;;) {
tn = tp - ytick1;
if (lsy) {
if (lly) {
for (i = 7; i >= 0; i--) {
temp = tn + xlog[i];
if (BETW(temp, vpwymi, vpwyma))
plytik(vppxmi, plP_wcpcy(temp), i1y, i2y);
}
}
else {
for (i = nysub1 - 1; i >= 1; i--) {
temp = tn + i * ytick1 / nysub1;
if (BETW(temp, vpwymi, vpwyma))
plytik(vppxmi, plP_wcpcy(temp), i1y, i2y);
}
}
}
if (!BETW(tn, vpwymi, vpwyma))
break;
plytik(vppxmi, plP_wcpcy(tn), i3y, i4y);
tp = tn;
}
}
plP_draphy(vppxmi, vppymi);
}
/* Draw the horizontal axis */
if (lax) {
plP_movphy(vppxmi, yp0);
if (ltx) {
tp = xtick1 * floor(vpwxmi / xtick1);
for (;;) {
tn = tp + xtick1;
if (lsx) {
if (llx) {
for (i = 0; i <= 7; i++) {
temp = tp + xlog[i];
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), yp0, xminor, xminor);
}
}
else {
for (i = 1; i <= nxsub1 - 1; i++) {
temp = tp + i * xtick1 / nxsub1;
if (BETW(temp, vpwxmi, vpwxma))
plxtik(plP_wcpcx(temp), yp0, xminor, xminor);
}
}
}
if (!BETW(tn, vpwxmi, vpwxma))
break;
plxtik(plP_wcpcx(tn), yp0, xmajor, xmajor);
tp = tn;
}
}
plP_draphy(vppxma, yp0);
}
/* Draw the vertical axis */
if (lay) {
plP_movphy(xp0, vppymi);
if (lty) {
tp = ytick1 * floor(vpwymi / ytick1);
for (;;) {
tn = tp + ytick1;
if (lsy) {
if (lly) {
for (i = 0; i <= 7; i++) {
temp = tp + xlog[i];
if (BETW(temp, vpwymi, vpwyma))
plytik(xp0, plP_wcpcy(temp), yminor, yminor);
}
}
else {
for (i = 1; i <= nysub1 - 1; i++) {
temp = tp + i * ytick1 / nysub1;
if (BETW(temp, vpwymi, vpwyma))
plytik(xp0, plP_wcpcy(temp), yminor, yminor);
}
}
}
if (!BETW(tn, vpwymi, vpwyma))
break;
plytik(xp0, plP_wcpcy(tn), ymajor, ymajor);
tp = tn;
}
}
plP_draphy(xp0, vppyma);
}
/* Draw grids */
grid_box(xopt, xtick1, nxsub1, yopt, ytick1, nysub1);
/* Write labels */
label_box(xopt, xtick1, yopt, ytick1);
/* Restore the clip limits to viewport edge */
plP_sclp(lxmin, lxmax, lymin, lymax);
}
static void
plchar(signed char *vxygrid, PLFLT *xform, PLINT base, PLINT oline, PLINT uline,
PLINT refx, PLINT refy, PLFLT scale, PLFLT xpmm, PLFLT ypmm,
PLFLT *p_xorg, PLFLT *p_yorg, PLFLT *p_width)
{
PLINT xbase, ybase, ydisp, lx, ly, cx, cy;
PLINT k, penup;
PLFLT x, y;
PLINT llx[STLEN], lly[STLEN], l = 0;
xbase = vxygrid[2];
*p_width = vxygrid[3] - xbase;
if (base == 0) {
ybase = 0;
ydisp = vxygrid[0];
}
else {
ybase = vxygrid[0];
ydisp = 0;
}
k = 4;
penup = 1;
for (;;) {
cx = vxygrid[k++];
cy = vxygrid[k++];
if (cx == 64 && cy == 64) {
if (l) {
plP_draphy_poly(llx, lly, l);
l = 0;
}
break;
}
if (cx == 64 && cy == 0) {
if (l) {
plP_draphy_poly(llx, lly, l);
l = 0;
}
penup = 1;
}
else {
x = *p_xorg + (cx - xbase) * scale;
y = *p_yorg + (cy - ybase) * scale;
lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
if (penup == 1) {
if (l) {
plP_draphy_poly(llx, lly, l);
l = 0;
}
llx[l] = lx;
lly[l++] = ly; /* store 1st point ! */
plP_movphy(lx, ly);
penup = 0;
}
else {
llx[l] = lx;
lly[l++] = ly;
}
}
}
if (oline) {
x = *p_xorg;
y = *p_yorg + (30 + ydisp) * scale;
lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
plP_movphy(lx, ly);
x = *p_xorg + *p_width * scale;
lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
plP_draphy(lx, ly);
}
if (uline) {
x = *p_xorg;
y = *p_yorg + (-5 + ydisp) * scale;
lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
plP_movphy(lx, ly);
x = *p_xorg + *p_width * scale;
lx = refx + ROUND(xpmm * (xform[0] * x + xform[1] * y));
ly = refy + ROUND(ypmm * (xform[2] * x + xform[3] * y));
plP_draphy(lx, ly);
}
*p_xorg = *p_xorg + *p_width * scale;
}
