version 1.1.1.1, 1999/12/03 07:39:13 |
version 1.12, 2002/08/02 08:59:47 |
|
|
/* $OpenXM: OpenXM/src/asir99/plot/if.c,v 1.1.1.1 1999/11/10 08:12:34 noro Exp $ */ |
/* |
|
* Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED |
|
* All rights reserved. |
|
* |
|
* FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited, |
|
* non-exclusive and royalty-free license to use, copy, modify and |
|
* redistribute, solely for non-commercial and non-profit purposes, the |
|
* computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and |
|
* conditions of this Agreement. For the avoidance of doubt, you acquire |
|
* only a limited right to use the SOFTWARE hereunder, and FLL or any |
|
* third party developer retains all rights, including but not limited to |
|
* copyrights, in and to the SOFTWARE. |
|
* |
|
* (1) FLL does not grant you a license in any way for commercial |
|
* purposes. You may use the SOFTWARE only for non-commercial and |
|
* non-profit purposes only, such as academic, research and internal |
|
* business use. |
|
* (2) The SOFTWARE is protected by the Copyright Law of Japan and |
|
* international copyright treaties. If you make copies of the SOFTWARE, |
|
* with or without modification, as permitted hereunder, you shall affix |
|
* to all such copies of the SOFTWARE the above copyright notice. |
|
* (3) An explicit reference to this SOFTWARE and its copyright owner |
|
* shall be made on your publication or presentation in any form of the |
|
* results obtained by use of the SOFTWARE. |
|
* (4) In the event that you modify the SOFTWARE, you shall notify FLL by |
|
* e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification |
|
* for such modification or the source code of the modified part of the |
|
* SOFTWARE. |
|
* |
|
* THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL |
|
* MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND |
|
* EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS |
|
* FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES' |
|
* RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY |
|
* MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY. |
|
* UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT, |
|
* OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY |
|
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL |
|
* DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES |
|
* ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES |
|
* FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY |
|
* DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF |
|
* SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART |
|
* OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY |
|
* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, |
|
* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. |
|
* |
|
* $OpenXM: OpenXM_contrib2/asir2000/plot/if.c,v 1.11 2002/08/02 02:57:48 noro Exp $ |
|
*/ |
#include "ca.h" |
#include "ca.h" |
#include "parse.h" |
#include "parse.h" |
#include "ox.h" |
#include "ox.h" |
#include "ifplot.h" |
#include "ifplot.h" |
|
|
extern jmp_buf ox_env; |
extern JMP_BUF ox_env; |
|
|
|
int open_canvas(NODE arg) |
|
{ |
|
int id; |
|
struct canvas *can; |
|
LIST wsize; |
|
STRING wname; |
|
|
|
wsize = (LIST)ARG0(arg); |
|
wname = (STRING)ARG1(arg); |
|
|
|
can = canvas[id = search_canvas()]; |
|
can->mode = MODE_INTERACTIVE; |
|
if ( !wsize ) { |
|
can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT; |
|
} else { |
|
can->width = QTOS((Q)BDY(BDY(wsize))); |
|
can->height = QTOS((Q)BDY(NEXT(BDY(wsize)))); |
|
} |
|
if ( wname ) |
|
can->wname = BDY(wname); |
|
else |
|
can->wname = ""; |
|
create_canvas(can); |
|
return id; |
|
} |
|
|
int plot(NODE arg) |
int plot(NODE arg) |
{ |
{ |
int id; |
int id; |
Line 14 int plot(NODE arg) |
|
Line 88 int plot(NODE arg) |
|
P formula; |
P formula; |
LIST xrange,yrange,zrange,wsize; |
LIST xrange,yrange,zrange,wsize; |
STRING wname; |
STRING wname; |
|
V v; |
|
|
formula = (P)ARG0(arg); |
formula = (P)ARG0(arg); |
xrange = (LIST)ARG1(arg); |
xrange = (LIST)ARG1(arg); |
Line 23 int plot(NODE arg) |
|
Line 98 int plot(NODE arg) |
|
wname = (STRING)ARG5(arg); |
wname = (STRING)ARG5(arg); |
|
|
can = canvas[id = search_canvas()]; |
can = canvas[id = search_canvas()]; |
|
if ( xrange ) { |
|
n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n); |
|
can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n); |
|
can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax); |
|
} |
|
if ( yrange ) { |
|
n = BDY(yrange); can->vy = VR((P)BDY(n)); n = NEXT(n); |
|
can->qymin = (Q)BDY(n); n = NEXT(n); can->qymax = (Q)BDY(n); |
|
can->ymin = ToReal(can->qymin); can->ymax = ToReal(can->qymax); |
|
} |
|
if ( xrange && yrange ) |
|
can->mode = zrange ? MODE_CONPLOT : MODE_IFPLOT; |
|
else |
|
can->mode = xrange ? MODE_PLOT : MODE_POLARPLOT; |
|
|
|
if ( zrange ) { |
|
n = BDY(zrange); v = VR((P)BDY(n)); n = NEXT(n); |
|
can->zmin = ToReal(BDY(n)); |
|
n = NEXT(n); can->zmax = ToReal(BDY(n)); |
|
n = NEXT(n); |
|
if ( can->mode == MODE_CONPLOT ) |
|
can->nzstep = n ? QTOS((Q)BDY(n)) : MAXGC; |
|
else { |
|
/* XXX */ |
|
can->vx = v; |
|
can->nzstep = n ? QTOS((Q)BDY(n)) : DEFAULTPOLARSTEP; |
|
} |
|
} |
|
|
|
if ( !wsize ) { |
|
can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT; |
|
} else { |
|
can->width = QTOS((Q)BDY(BDY(wsize))); |
|
can->height = QTOS((Q)BDY(NEXT(BDY(wsize)))); |
|
} |
|
if ( wname ) |
|
can->wname = BDY(wname); |
|
else |
|
can->wname = ""; |
|
can->formula = formula; |
|
create_canvas(can); |
|
if ( can->mode == MODE_PLOT ) { |
|
plotcalc(can); |
|
plot_print(display,can); |
|
} else if ( can->mode == MODE_POLARPLOT ) { |
|
polarplotcalc(can); |
|
plot_print(display,can); |
|
} else |
|
ifplotmain(can); |
|
copy_to_canvas(can); |
|
return id; |
|
} |
|
|
|
int polarplot(NODE arg) |
|
{ |
|
int id; |
|
NODE n; |
|
struct canvas *can; |
|
P formula; |
|
LIST xrange,yrange,zrange,wsize; |
|
STRING wname; |
|
|
|
formula = (P)ARG0(arg); |
|
xrange = (LIST)ARG1(arg); |
|
wsize = (LIST)ARG4(arg); |
|
wname = (STRING)ARG5(arg); |
|
|
|
can = canvas[id = search_canvas()]; |
n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n); |
n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n); |
|
/* XXX use zmin, zmax to hold parameter range */ |
|
can->zmin = ToReal((Num)BDY(n)); n = NEXT(n); |
|
can->zmax = ToReal((Num)BDY(n)); |
|
can->mode = MODE_POLARPLOT; |
|
if ( !wsize ) { |
|
can->width = DEFAULTWIDTH; can->height = DEFAULTHEIGHT; |
|
} else { |
|
can->width = QTOS((Q)BDY(BDY(wsize))); |
|
can->height = QTOS((Q)BDY(NEXT(BDY(wsize)))); |
|
} |
|
if ( wname ) |
|
can->wname = BDY(wname); |
|
else |
|
can->wname = ""; |
|
can->formula = formula; |
|
create_canvas(can); |
|
polarplotcalc(can); |
|
plot_print(display,can); |
|
copy_to_canvas(can); |
|
return id; |
|
} |
|
|
|
int memory_plot(NODE arg,LIST *bytes) |
|
{ |
|
NODE n; |
|
struct canvas tmp_can; |
|
struct canvas *can; |
|
P formula; |
|
LIST xrange,yrange,zrange,wsize; |
|
int width,height; |
|
double **tabe; |
|
int i; |
|
BYTEARRAY barray; |
|
Q qw,qh; |
|
|
|
formula = (P)ARG0(arg); |
|
xrange = (LIST)ARG1(arg); |
|
yrange = (LIST)ARG2(arg); |
|
zrange = (LIST)ARG3(arg); |
|
wsize = (LIST)ARG4(arg); |
|
|
|
can = &tmp_can; |
|
n = BDY(xrange); can->vx = VR((P)BDY(n)); n = NEXT(n); |
can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n); |
can->qxmin = (Q)BDY(n); n = NEXT(n); can->qxmax = (Q)BDY(n); |
can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax); |
can->xmin = ToReal(can->qxmin); can->xmax = ToReal(can->qxmax); |
if ( yrange ) { |
if ( yrange ) { |
Line 48 int plot(NODE arg) |
|
Line 234 int plot(NODE arg) |
|
can->width = QTOS((Q)BDY(BDY(wsize))); |
can->width = QTOS((Q)BDY(BDY(wsize))); |
can->height = QTOS((Q)BDY(NEXT(BDY(wsize)))); |
can->height = QTOS((Q)BDY(NEXT(BDY(wsize)))); |
} |
} |
if ( wname ) |
can->wname = ""; |
can->wname = BDY(wname); |
|
else |
|
can->wname = ""; |
|
can->formula = formula; |
can->formula = formula; |
create_canvas(can); |
if ( can->mode == MODE_PLOT ) |
if ( can->mode == MODE_PLOT ) { |
|
plotcalc(can); |
plotcalc(can); |
plot_print(display,can); |
else { |
} else |
width = can->width; height = can->height; |
ifplotmain(can); |
tabe = (double **)ALLOCA(width*sizeof(double *)); |
copy_to_canvas(can); |
for ( i = 0; i < width; i++ ) |
return id; |
tabe[i] = (double *)ALLOCA(height*sizeof(double)); |
|
calc(tabe,can,1); |
|
memory_if_print(tabe,can,&barray); |
|
STOQ(width,qw); STOQ(height,qh); |
|
n = mknode(3,qw,qh,barray); |
|
MKLIST(*bytes,n); |
|
} |
} |
} |
|
|
int plotover(NODE arg) |
int plotover(NODE arg) |
Line 76 int plotover(NODE arg) |
|
Line 264 int plotover(NODE arg) |
|
can = canvas[index]; |
can = canvas[index]; |
if ( !can->window ) |
if ( !can->window ) |
return -1; |
return -1; |
get_vars_recursive(formula,&vl); |
get_vars_recursive((Obj)formula,&vl); |
for ( vl0 = vl; vl0; vl0 = NEXT(vl0) ) |
for ( vl0 = vl; vl0; vl0 = NEXT(vl0) ) |
if ( vl0->v->attr == V_IND ) |
if ( vl0->v->attr == (pointer)V_IND ) |
if ( vl->v != can->vx && vl->v != can->vy ) |
if ( vl->v != can->vx && vl->v != can->vy ) |
return -1; |
return -1; |
current_can = can; |
current_can = can; |
Line 94 int plotover(NODE arg) |
|
Line 282 int plotover(NODE arg) |
|
|
|
int drawcircle(NODE arg) |
int drawcircle(NODE arg) |
{ |
{ |
|
#if !defined(VISUAL) |
int id; |
int id; |
int index; |
int index; |
pointer ptr; |
pointer ptr; |
Line 119 int drawcircle(NODE arg) |
|
Line 308 int drawcircle(NODE arg) |
|
copy_to_canvas(can); |
copy_to_canvas(can); |
return index; |
return index; |
} |
} |
|
#endif |
} |
} |
|
|
|
int draw_obj(NODE arg) |
|
{ |
|
int index; |
|
int x,y,u,v,len,r; |
|
NODE obj,n; |
|
RealVect *vect; |
|
struct canvas *can; |
|
int color; |
|
|
|
index = QTOS((Q)ARG0(arg)); |
|
can = canvas[index]; |
|
if ( !can && closed_canvas[index] ) { |
|
canvas[index] = closed_canvas[index]; |
|
closed_canvas[index] = 0; |
|
can = canvas[index]; |
|
popup_canvas(index); |
|
current_can = can; |
|
} else if ( !can || (can && !can->window) ) { |
|
set_lasterror("draw_obj : canvas does not exist"); |
|
return -1; |
|
} |
|
|
|
obj = BDY((LIST)ARG1(arg)); |
|
if ( argc(arg) == 3 ) |
|
color = QTOS((Q)ARG2(arg)); |
|
else |
|
color = 0; /* black */ |
|
switch ( len = length(obj) ) { |
|
case 2: /* point */ |
|
x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj)); |
|
draw_point(display,can,x,y,color); |
|
MKRVECT2(vect,x,y); MKNODE(n,vect,can->history); can->history = n; |
|
break; |
|
case 3: /* circle */ |
|
x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj)); |
|
r = (int)ToReal((Q)ARG2(obj)); |
|
MKRVECT3(vect,x,y,r); MKNODE(n,vect,can->history); can->history = n; |
|
break; |
|
case 4: /* line */ |
|
x = (int)ToReal((Q)ARG0(obj)); y = (int)ToReal((Q)ARG1(obj)); |
|
u = (int)ToReal((Q)ARG2(obj)); v = (int)ToReal((Q)ARG3(obj)); |
|
draw_line(display,can,x,y,u,v,color); |
|
MKRVECT4(vect,x,y,u,v); MKNODE(n,vect,can->history); can->history = n; |
|
break; |
|
default: |
|
set_lasterror("draw_obj : invalid request"); |
|
return -1; |
|
} |
|
return 0; |
|
} |
|
|
|
int draw_string(NODE arg) |
|
{ |
|
int index,x,y; |
|
char *str; |
|
NODE pos; |
|
struct canvas *can; |
|
int color; |
|
|
|
index = QTOS((Q)ARG0(arg)); |
|
can = canvas[index]; |
|
if ( !can && closed_canvas[index] ) { |
|
canvas[index] = closed_canvas[index]; |
|
closed_canvas[index] = 0; |
|
can = canvas[index]; |
|
popup_canvas(index); |
|
current_can = can; |
|
} else if ( !can || (can && !can->window) ) { |
|
set_lasterror("draw_obj : canvas does not exist"); |
|
return -1; |
|
} |
|
|
|
pos = BDY((LIST)ARG1(arg)); |
|
str = BDY((STRING)ARG2(arg)); |
|
if ( argc(arg) == 4 ) |
|
color = QTOS((Q)ARG3(arg)); |
|
else |
|
color = 0; /* black */ |
|
x = (int)ToReal((Q)ARG0(pos)); |
|
y = (int)ToReal((Q)ARG1(pos)); |
|
draw_character_string(display,can,x,y,str,color); |
|
return 0; |
|
} |
|
|
|
int clear_canvas(NODE arg) |
|
{ |
|
int index; |
|
struct canvas *can; |
|
|
|
index = QTOS((Q)ARG0(arg)); |
|
can = canvas[index]; |
|
if ( !can || !can->window ) |
|
return -1; |
|
clear_pixmap(can); |
|
copy_to_canvas(can); |
|
/* clear the history */ |
|
can->history = 0; |
|
} |
|
|
#define RealtoDbl(r) ((r)?BDY(r):0.0) |
#define RealtoDbl(r) ((r)?BDY(r):0.0) |
|
|
int arrayplot(NODE arg) |
int arrayplot(NODE arg) |
Line 130 int arrayplot(NODE arg) |
|
Line 419 int arrayplot(NODE arg) |
|
LIST xrange,wsize; |
LIST xrange,wsize; |
char *wname; |
char *wname; |
NODE n; |
NODE n; |
Q ret; |
|
double ymax,ymin,dy,xstep; |
double ymax,ymin,dy,xstep; |
Real *tab; |
Real *tab; |
struct canvas *can; |
struct canvas *can; |
Line 182 int arrayplot(NODE arg) |
|
Line 470 int arrayplot(NODE arg) |
|
else if ( t < -MAXSHORT ) |
else if ( t < -MAXSHORT ) |
pa[ix].y = -MAXSHORT; |
pa[ix].y = -MAXSHORT; |
else |
else |
pa[ix].y = t; |
pa[ix].y = (long)t; |
} |
} |
plot_print(display,can); |
plot_print(display,can); |
copy_to_canvas(can); |
copy_to_canvas(can); |
return id; |
return id; |
} |
} |
|
|
ifplot_resize(can,spos,epos) |
void ifplot_resize(struct canvas *can,POINT spos,POINT epos) |
struct canvas *can; |
|
POINT spos,epos; |
|
{ |
{ |
struct canvas *ncan; |
struct canvas *ncan; |
struct canvas fakecan; |
struct canvas fakecan; |
Line 200 POINT spos,epos; |
|
Line 486 POINT spos,epos; |
|
Q s,t; |
Q s,t; |
int new; |
int new; |
int w,h,m; |
int w,h,m; |
Q ret; |
|
|
|
if ( XC(spos) < XC(epos) && YC(spos) < YC(epos) ) { |
if ( XC(spos) < XC(epos) && YC(spos) < YC(epos) ) { |
if ( can->precise && !can->wide ) { |
if ( can->precise && !can->wide ) { |
Line 249 POINT spos,epos; |
|
Line 534 POINT spos,epos; |
|
if ( can->precise && !can->wide ) { |
if ( can->precise && !can->wide ) { |
current_can = can; |
current_can = can; |
alloc_pixmap(ncan); |
alloc_pixmap(ncan); |
|
#if defined(VISUAL) |
|
ncan->real_can = can; |
|
#endif |
qifplotmain(ncan); |
qifplotmain(ncan); |
copy_subimage(ncan,can,spos); |
copy_subimage(ncan,can,spos); |
copy_to_canvas(can); |
copy_to_canvas(can); |
Line 263 POINT spos,epos; |
|
Line 551 POINT spos,epos; |
|
} |
} |
} |
} |
|
|
plot_resize(can,spos,epos) |
void plot_resize(struct canvas *can,POINT spos,POINT epos) |
struct canvas *can; |
|
POINT spos,epos; |
|
{ |
{ |
struct canvas *ncan; |
struct canvas *ncan; |
Q dx,dx2,xmin,xmax,xmid; |
Q dx,dx2,xmin,xmax,xmid; |
double dy,dy2,ymin,ymax,ymid; |
double dy,ymin,ymax,ymid; |
Q sx,ex,cw,ten,two; |
Q sx,ex,cw,ten,two; |
double sy,ey; |
|
Q s,t; |
Q s,t; |
int new; |
int new; |
int w,h,m; |
int w,h,m; |
Line 323 POINT spos,epos; |
|
Line 608 POINT spos,epos; |
|
} |
} |
} |
} |
|
|
ifplotmain(can) |
void ifplotmain(struct canvas *can) |
struct canvas *can; |
|
{ |
{ |
int width,height; |
int width,height; |
double **tabe,*tabeb; |
double **tabe; |
int i; |
int i; |
|
|
width = can->width; height = can->height; |
width = can->width; height = can->height; |
Line 336 struct canvas *can; |
|
Line 620 struct canvas *can; |
|
tabe[i] = (double *)ALLOCA(height*sizeof(double)); |
tabe[i] = (double *)ALLOCA(height*sizeof(double)); |
define_cursor(can->window,runningcur); |
define_cursor(can->window,runningcur); |
set_busy(can); set_selection(); |
set_busy(can); set_selection(); |
calc(tabe,can); if_print(display,tabe,can); |
calc(tabe,can,0); if_print(display,tabe,can); |
reset_selection(); reset_busy(can); |
reset_selection(); reset_busy(can); |
define_cursor(can->window,normalcur); |
define_cursor(can->window,normalcur); |
} |
} |
|
|
qifplotmain(can) |
void qifplotmain(struct canvas *can) |
struct canvas *can; |
|
{ |
{ |
int width,height; |
int width,height; |
char **tabe,*tabeb; |
char **tabe,*tabeb; |
Line 350 struct canvas *can; |
|
Line 633 struct canvas *can; |
|
|
|
width = can->width; height = can->height; |
width = can->width; height = can->height; |
tabe = (char **)ALLOCA(width*sizeof(char *)+width*height*sizeof(char)); |
tabe = (char **)ALLOCA(width*sizeof(char *)+width*height*sizeof(char)); |
bzero(tabe,width*sizeof(char *)+width*height*sizeof(char)); |
bzero((void *)tabe,width*sizeof(char *)+width*height*sizeof(char)); |
for ( i = 0, tabeb = (char *)(tabe+width); i < width; i++ ) |
for ( i = 0, tabeb = (char *)(tabe+width); i < width; i++ ) |
tabe[i] = tabeb + height*i; |
tabe[i] = tabeb + height*i; |
define_cursor(can->window,runningcur); |
define_cursor(can->window,runningcur); |