[BACK]Return to if.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / plot

Annotation of OpenXM_contrib2/asir2000/plot/if.c, Revision 1.27

1.2       noro        1: /*
                      2:  * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
                      3:  * All rights reserved.
                      4:  *
                      5:  * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
                      6:  * non-exclusive and royalty-free license to use, copy, modify and
                      7:  * redistribute, solely for non-commercial and non-profit purposes, the
                      8:  * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
                      9:  * conditions of this Agreement. For the avoidance of doubt, you acquire
                     10:  * only a limited right to use the SOFTWARE hereunder, and FLL or any
                     11:  * third party developer retains all rights, including but not limited to
                     12:  * copyrights, in and to the SOFTWARE.
                     13:  *
                     14:  * (1) FLL does not grant you a license in any way for commercial
                     15:  * purposes. You may use the SOFTWARE only for non-commercial and
                     16:  * non-profit purposes only, such as academic, research and internal
                     17:  * business use.
                     18:  * (2) The SOFTWARE is protected by the Copyright Law of Japan and
                     19:  * international copyright treaties. If you make copies of the SOFTWARE,
                     20:  * with or without modification, as permitted hereunder, you shall affix
                     21:  * to all such copies of the SOFTWARE the above copyright notice.
                     22:  * (3) An explicit reference to this SOFTWARE and its copyright owner
                     23:  * shall be made on your publication or presentation in any form of the
                     24:  * results obtained by use of the SOFTWARE.
                     25:  * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
1.3       noro       26:  * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
1.2       noro       27:  * for such modification or the source code of the modified part of the
                     28:  * SOFTWARE.
                     29:  *
                     30:  * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
                     31:  * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
                     32:  * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
                     33:  * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
                     34:  * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
                     35:  * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
                     36:  * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
                     37:  * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
                     38:  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
                     39:  * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
                     40:  * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
                     41:  * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
                     42:  * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
                     43:  * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
                     44:  * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
                     45:  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
                     46:  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
                     47:  *
1.27    ! saito      48:  * $OpenXM: OpenXM_contrib2/asir2000/plot/if.c,v 1.26 2014/03/25 19:22:15 ohara Exp $
1.2       noro       49: */
1.1       noro       50: #include "ca.h"
                     51: #include "parse.h"
                     52: #include "ox.h"
                     53: #include "ifplot.h"
                     54:
1.22      saito      55: #if defined(INTERVAL)
1.24      saito      56: // Time message and func
1.22      saito      57: #include <sys/types.h>
                     58: #include <sys/resource.h>
                     59: #include <sys/time.h>
                     60:
                     61: static struct oEGT ltime;
                     62: static double r0;
                     63: double get_rtime();
                     64: #if defined(ITV_TIME_CHECK)
                     65: void tstart()
                     66: {
                     67:        get_eg(&ltime);
1.24      saito      68:        r0=get_rtime();
1.22      saito      69: }
                     70:
                     71: void tstop(struct canvas *can)
                     72: {
                     73:        struct oEGT egt1;
                     74:        double e, g, r;
                     75:        char ts[100];
                     76:        void popdown_warning();
                     77:        Widget warnshell,warndialog;
                     78:
                     79:        get_eg(&egt1);
1.24      saito      80:        e=egt1.exectime - ltime.exectime;
                     81:        g=egt1.gctime - ltime.gctime;
                     82:        r=get_rtime() - r0;
1.22      saito      83:        sprintf(ts,"(%8.6f + gc %8.6f) total %8.6f \n",e,g,r);
                     84:        create_popup(can->shell,"Message",&ts,&warnshell,&warndialog);
                     85:        XawDialogAddButton(warndialog,"OK",popdown_warning,warnshell);
                     86:        XtPopup(warnshell,XtGrabNone);
                     87:        SetWM_Proto(warnshell);
                     88: }
                     89: #else
                     90: #define tstart()
                     91: #define tstop(a)
                     92: #endif
                     93: #endif
                     94:
1.8       noro       95: extern JMP_BUF ox_env;
1.1       noro       96:
1.24      saito      97: int open_canvas(NODE arg){
1.4       noro       98:        int id;
                     99:        struct canvas *can;
                    100:        LIST wsize;
                    101:        STRING wname;
                    102:
1.24      saito     103:        wsize=(LIST)ARG0(arg);
                    104:        wname=(STRING)ARG1(arg);
1.27    ! saito     105:        id=search_canvas();
        !           106:        can=canvas[id];
        !           107:        can->mode=modeNO(INTERACTIVE);
1.24      saito     108:        if(!wsize){
                    109:                can->width=DEFAULTWIDTH;
                    110:                can->height=DEFAULTHEIGHT;
1.4       noro      111:        } else {
1.24      saito     112:                can->width=QTOS((Q)BDY(BDY(wsize)));
                    113:                can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
1.4       noro      114:        }
1.24      saito     115:        if(wname)can->wname=BDY(wname);
                    116:        else can->wname="";
1.4       noro      117:        create_canvas(can);
                    118:        return id;
                    119: }
                    120:
1.27    ! saito     121: int plot(NODE arg,char *fn){
1.1       noro      122:        int id;
                    123:        NODE n;
                    124:        struct canvas *can;
                    125:        P formula;
                    126:        LIST xrange,yrange,zrange,wsize;
                    127:        STRING wname;
1.12      noro      128:        V v;
1.1       noro      129:
1.24      saito     130:        formula=(P)ARG0(arg);
                    131:        xrange=(LIST)ARG1(arg);
                    132:        yrange=(LIST)ARG2(arg);
                    133:        zrange=(LIST)ARG3(arg);
                    134:        wsize=(LIST)ARG4(arg);
                    135:        wname=(STRING)ARG5(arg);
                    136:        can=canvas[id=search_canvas()];
                    137:        if(xrange){
                    138:                n=BDY(xrange);can->vx=VR((P)BDY(n));n=NEXT(n);
                    139:                can->qxmin=(Q)BDY(n);n=NEXT(n);can->qxmax=(Q)BDY(n);
                    140:                can->xmin=ToReal(can->qxmin);can->xmax=ToReal(can->qxmax);
                    141:        }
                    142:        if(yrange){
                    143:                n=BDY(yrange);can->vy=VR((P)BDY(n));n=NEXT(n);
                    144:                can->qymin=(Q)BDY(n);n=NEXT(n);can->qymax=(Q)BDY(n);
                    145:                can->ymin=ToReal(can->qymin);can->ymax=ToReal(can->qymax);
                    146:        }
1.27    ! saito     147:        can->mode=modeNO(fn);
1.24      saito     148:        if(zrange){
                    149:                n=BDY(zrange); can->zmin=ToReal(BDY(n));
                    150:                n=NEXT(n);can->zmax=ToReal(BDY(n));
                    151:                n=NEXT(n);
1.27    ! saito     152:                if(can->mode==modeNO(CONPLOT))can->nzstep=QTOS((Q)BDY(n));
1.12      noro      153:                else {
1.24      saito     154:                        can->vx=VR((P)BDY(BDY(zrange)));
                    155:                        can->nzstep=QTOS((Q)BDY(n));
1.12      noro      156:                }
                    157:        }
1.24      saito     158:        if(!wsize){
                    159:                can->width=DEFAULTWIDTH;
                    160:                can->height=DEFAULTHEIGHT;
1.1       noro      161:        } else {
1.24      saito     162:                can->width=QTOS((Q)BDY(BDY(wsize)));
                    163:                can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
1.1       noro      164:        }
1.24      saito     165:        if(wname) can->wname = BDY(wname);
                    166:        else can->wname="";
                    167:        can->formula=formula;
1.27    ! saito     168:        if(can->mode==modeNO(PLOT)){
1.24      saito     169:                //plot
1.1       noro      170:                plotcalc(can);
1.14      noro      171:                create_canvas(can);
1.1       noro      172:                plot_print(display,can);
1.14      noro      173:        } else {
1.24      saito     174:                //ifplot,conplot
1.14      noro      175:                create_canvas(can);
1.24      saito     176:                ifplotmainOld(can);
1.12      noro      177:        }
1.1       noro      178:        copy_to_canvas(can);
                    179:        return id;
                    180: }
                    181:
1.24      saito     182: void ifplotmainOld(struct canvas *can){
                    183:        int i,width,height;
                    184:        double ** tabe;
                    185:
                    186:        width=can->width;height=can->height;
                    187:        tabe=(double **)ALLOCA((width+1)*sizeof(double *));
                    188:        for(i=0;i<width;i++)tabe[i]=(double *)ALLOCA((height+1)*sizeof(double));
                    189:        define_cursor(can->window,runningcur);
                    190:        set_busy(can); set_selection();
                    191:        calc(tabe,can,0);
                    192:        if_printOld(display,tabe,can);
                    193:        reset_selection(); reset_busy(can);
                    194:        define_cursor(can->window,normalcur);
                    195: }
                    196:
                    197: int memory_plot(NODE arg,LIST *bytes){
1.6       noro      198:        NODE n;
                    199:        struct canvas tmp_can;
                    200:        struct canvas *can;
                    201:        P formula;
                    202:        LIST xrange,yrange,zrange,wsize;
                    203:        int width,height;
                    204:        double **tabe;
                    205:        int i;
                    206:        BYTEARRAY barray;
                    207:        Q qw,qh;
                    208:
1.24      saito     209:        formula=(P)ARG0(arg);
                    210:        xrange=(LIST)ARG1(arg);
                    211:        yrange=(LIST)ARG2(arg);
                    212:        zrange=(LIST)ARG3(arg);
                    213:        wsize=(LIST)ARG4(arg);
1.6       noro      214:
1.19      noro      215:        bzero((char *)&tmp_can,sizeof(tmp_can));
1.24      saito     216:        can=&tmp_can;
                    217:        n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
                    218:        can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
                    219:        can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
                    220:        if( yrange ){
                    221:                n=BDY(yrange); can->vy=VR((P)BDY(n)); n=NEXT(n);
                    222:                can->qymin=(Q)BDY(n); n=NEXT(n); can->qymax=(Q)BDY(n);
                    223:                can->ymin=ToReal(can->qymin); can->ymax=ToReal(can->qymax);
                    224:                if( zrange ){
                    225:                        n=NEXT(BDY(zrange));
                    226:                        can->zmin=ToReal(BDY(n)); n=NEXT(n); can->zmax=ToReal(BDY(n));
1.27    ! saito     227:                        n=NEXT(n);
        !           228:                        if(n) can->nzstep=QTOS((Q)BDY(n));
1.24      saito     229:                        else can->nzstep=MAXGC;
1.27    ! saito     230:                        can->mode=modeNO(CONPLOT);
1.6       noro      231:                } else
1.27    ! saito     232:                        can->mode=modeNO(IFPLOT);
1.6       noro      233:        } else
1.27    ! saito     234:                can->mode=modeNO(PLOT);
1.24      saito     235:        if( !wsize ){
                    236:                can->width=DEFAULTWIDTH; can->height=DEFAULTHEIGHT;
1.6       noro      237:        } else {
1.24      saito     238:                can->width=QTOS((Q)BDY(BDY(wsize)));
                    239:                can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
1.6       noro      240:        }
1.24      saito     241:        can->wname="";
                    242:        can->formula=formula;
1.27    ! saito     243:        if( can->mode==modeNO(PLOT)){
1.6       noro      244:                plotcalc(can);
1.19      noro      245:                memory_print(can,&barray);
                    246:                STOQ(can->width,qw); STOQ(can->height,qh);
1.24      saito     247:                n=mknode(3,qw,qh,barray);
1.19      noro      248:                MKLIST(*bytes,n);
                    249:        } else {
1.24      saito     250:                width=can->width; height=can->height;
                    251:                tabe=(double **)ALLOCA(width*sizeof(double *));
                    252:                for( i=0; i<width; i++ )
                    253:                        tabe[i]=(double *)ALLOCA(height*sizeof(double));
1.6       noro      254:                calc(tabe,can,1);
                    255:                memory_if_print(tabe,can,&barray);
                    256:                STOQ(width,qw); STOQ(height,qh);
1.24      saito     257:                n=mknode(3,qw,qh,barray);
1.6       noro      258:                MKLIST(*bytes,n);
                    259:        }
1.27    ! saito     260:        return 0;
1.6       noro      261: }
                    262:
1.24      saito     263: int plotover(NODE arg){
                    264:        int id,orgcolor,color;
1.1       noro      265:        P formula;
                    266:        struct canvas *can;
                    267:        VL vl,vl0;
                    268:
1.24      saito     269:        id=QTOS((Q)ARG0(arg));
                    270:        formula=(P)ARG1(arg);
                    271:        can=canvas[id];
                    272:        orgcolor=can->color;
1.27    ! saito     273:        if(argc(arg)==3) can->color=QTOS((Q)ARG2(arg));
        !           274:        else can->color=0;
1.7       noro      275:        get_vars_recursive((Obj)formula,&vl);
1.24      saito     276:        for(vl0=vl;vl0;vl0=NEXT(vl0))
                    277:                if(vl0->v->attr==(pointer)V_IND)
                    278:                        if(vl->v!=can->vx && vl->v!=can->vy)return -1;
                    279:        if(argc(arg)==3) can->color=QTOS((Q)ARG2(arg));
                    280:        else can->color=0;
1.18      noro      281: #if !defined(VISUAL)
1.17      noro      282:        set_drawcolor(can->color);
1.18      noro      283: #endif
1.24      saito     284:        current_can=can;
                    285:        can->formula=formula;
1.27    ! saito     286:        if(can->mode==modeNO(PLOT)){
1.21      saito     287:                plotcalc(can);
                    288:                plot_print(display,can);
1.24      saito     289:        } else ifplotmainOld(can);
1.21      saito     290:        copy_to_canvas(can);
1.24      saito     291:        can->color=color;
1.21      saito     292: #if !defined(VISUAL)
                    293:        set_drawcolor(can->color);
                    294: #endif
1.26      ohara     295:        return id;
1.1       noro      296: }
                    297:
1.24      saito     298: int drawcircle(NODE arg){
1.4       noro      299: #if !defined(VISUAL)
1.24      saito     300:        int id,index,wx,wy,wr,c;
1.1       noro      301:        pointer ptr;
                    302:        Q ret;
                    303:        LIST xyr;
                    304:        Obj x,y,r;
                    305:        struct canvas *can;
                    306:
1.24      saito     307:        index=QTOS((Q)ARG0(arg));
                    308:        xyr=(LIST)ARG1(arg);
                    309:        x=(Obj)ARG0(BDY(xyr)); y=(Obj)ARG1(BDY(xyr)); r=(Obj)ARG2(BDY(xyr));
                    310:        c=QTOS((Q)ARG2(arg));
                    311:        can=canvas[index];
                    312:        if(!can->window)return -1;
1.1       noro      313:        else {
1.24      saito     314:                current_can=can;
1.21      saito     315:                set_drawcolor(c);
1.24      saito     316:                wx=(ToReal(x)-can->xmin)*can->width/(can->xmax-can->xmin);
                    317:                wy=(can->ymax-ToReal(y))*can->height/(can->ymax-can->ymin);
                    318:                wr=ToReal(r);
1.21      saito     319:                XFillArc(display,can->pix,cdrawGC,wx-wr/2,wy-wr/2,wr,wr,0,360*64);
1.1       noro      320:                copy_to_canvas(can);
1.21      saito     321:                set_drawcolor(can->color);
1.1       noro      322:                return index;
                    323:        }
1.4       noro      324: #endif
                    325: }
                    326:
1.24      saito     327: int draw_obj(NODE arg){
                    328:        int index,color,x,y,u,v,len,r;
1.4       noro      329:        NODE obj,n;
                    330:        RealVect *vect;
                    331:        struct canvas *can;
                    332:
1.24      saito     333:        index=QTOS((Q)ARG0(arg));
                    334:        can=canvas[index];
                    335:        if(!can && closed_canvas[index]){
                    336:                canvas[index]=closed_canvas[index];
                    337:                closed_canvas[index]=0;
                    338:                can=canvas[index];
1.10      noro      339:                popup_canvas(index);
1.24      saito     340:                current_can=can;
                    341:        } else if(!can||(can && !can->window)){
1.5       noro      342:                set_lasterror("draw_obj : canvas does not exist");
1.4       noro      343:                return -1;
1.5       noro      344:        }
1.4       noro      345:
1.24      saito     346:        obj=BDY((LIST)ARG1(arg));
                    347:        if(argc(arg)== 3) color=QTOS((Q)ARG2(arg));
                    348:        else color=0; // black
                    349:        switch(len=length(obj)){
                    350:                case 2: // point
                    351:                        x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj));
1.5       noro      352:                        draw_point(display,can,x,y,color);
1.16      noro      353:                        MKRVECT3(vect,x,y,color); MKNODE(n,vect,can->history);
1.24      saito     354:                        can->history=n;
1.5       noro      355:                        break;
1.24      saito     356:                case 3: // circle
                    357:                        x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj));
                    358:                        r=(int)ToReal((Q)ARG2(obj));
1.16      noro      359:                        MKRVECT4(vect,x,y,r,color); MKNODE(n,vect,can->history);
1.24      saito     360:                        can->history=n;
1.4       noro      361:                        break;
1.24      saito     362:                case 4: // line
                    363:                        x=(int)ToReal((Q)ARG0(obj)); y=(int)ToReal((Q)ARG1(obj));
                    364:                        u=(int)ToReal((Q)ARG2(obj)); v=(int)ToReal((Q)ARG3(obj));
1.5       noro      365:                        draw_line(display,can,x,y,u,v,color);
1.16      noro      366:                        MKRVECT5(vect,x,y,u,v,color); MKNODE(n,vect,can->history);
1.24      saito     367:                        can->history=n;
1.4       noro      368:                        break;
                    369:                default:
1.5       noro      370:                        set_lasterror("draw_obj : invalid request");
1.4       noro      371:                        return -1;
                    372:        }
1.21      saito     373: #if !defined(VISUAL)
                    374:        set_drawcolor(can->color);
                    375: #endif
1.9       noro      376:        return 0;
                    377: }
                    378:
1.24      saito     379: int draw_string(NODE arg){
                    380:        int index,x,y,color;
1.9       noro      381:        char *str;
                    382:        NODE pos;
                    383:        struct canvas *can;
                    384:
1.24      saito     385:        index=QTOS((Q)ARG0(arg));
                    386:        can=canvas[index];
                    387:        if(!can && closed_canvas[index]){
                    388:                canvas[index]=closed_canvas[index];
                    389:                closed_canvas[index]=0;
                    390:                can=canvas[index];
1.11      noro      391:                popup_canvas(index);
1.24      saito     392:                current_can=can;
                    393:        } else if(!can||(can && !can->window)){
1.11      noro      394:                set_lasterror("draw_obj : canvas does not exist");
1.9       noro      395:                return -1;
                    396:        }
                    397:
1.24      saito     398:        pos=BDY((LIST)ARG1(arg));
                    399:        str=BDY((STRING)ARG2(arg));
                    400:        if(argc(arg)==4)color=QTOS((Q)ARG3(arg));
                    401:        else color=0; // black
                    402:        x=(int)ToReal((Q)ARG0(pos));
                    403:        y=(int)ToReal((Q)ARG1(pos));
1.9       noro      404:        draw_character_string(display,can,x,y,str,color);
1.21      saito     405: #if !defined(VISUAL)
                    406:        set_drawcolor(can->color);
                    407: #endif
1.4       noro      408:        return 0;
                    409: }
                    410:
1.24      saito     411: int clear_canvas(NODE arg){
1.4       noro      412:        int index;
                    413:        struct canvas *can;
                    414:
1.24      saito     415:        index=QTOS((Q)ARG0(arg));
                    416:        can=canvas[index];
                    417:        if(!can||!can->window) return -1;
1.4       noro      418:        clear_pixmap(can);
                    419:        copy_to_canvas(can);
1.24      saito     420:        // clear the history
                    421:        can->history=0;
1.27    ! saito     422:        return 0;
1.1       noro      423: }
                    424:
                    425: #define RealtoDbl(r) ((r)?BDY(r):0.0)
                    426:
1.24      saito     427: int arrayplot(NODE arg){
1.1       noro      428:        int id,ix,w,h;
                    429:        VECT array;
                    430:        LIST xrange,wsize;
                    431:        char *wname;
                    432:        NODE n;
                    433:        double ymax,ymin,dy,xstep;
                    434:        Real *tab;
                    435:        struct canvas *can;
                    436:        POINT *pa;
                    437:
1.24      saito     438:        array=(VECT)ARG0(arg);
                    439:        xrange=(LIST)ARG1(arg);
                    440:        can=canvas[id=search_canvas()];
                    441:        n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
                    442:        can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
                    443:        can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
                    444:        if(!wsize){
                    445:                can->width=DEFAULTWIDTH;
                    446:                can->height=DEFAULTHEIGHT;
1.1       noro      447:        } else {
1.24      saito     448:                can->width=QTOS((Q)BDY(BDY(wsize)));
                    449:                can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
1.1       noro      450:        }
1.27    ! saito     451:        can->wname=wname; can->formula=0; can->mode=modeNO(PLOT);
1.1       noro      452:        create_canvas(can);
1.24      saito     453:        w=array->len;
                    454:        h=can->height;
                    455:        tab=(Real *)BDY(array);
                    456:        if(can->ymax==can->ymin){
                    457:                for(ymax=ymin=RealtoDbl(tab[0]),ix=1; ix<w; ix++){
                    458:                        if(RealtoDbl(tab[ix])>ymax)ymax=RealtoDbl(tab[ix]);
                    459:                        if(RealtoDbl(tab[ix])<ymin)ymin=RealtoDbl(tab[ix]);
1.1       noro      460:                }
1.24      saito     461:                can->ymax=ymax;
                    462:                can->ymin=ymin;
1.1       noro      463:        } else {
1.24      saito     464:                ymax=can->ymax;
                    465:                ymin=can->ymin;
1.1       noro      466:        }
1.24      saito     467:        dy=ymax-ymin;
                    468:        can->pa=(struct pa *)MALLOC(sizeof(struct pa));
                    469:        can->pa[0].length=w;
                    470:        can->pa[0].pos=pa=(POINT *)MALLOC(w*sizeof(POINT));
                    471:        xstep=(double)can->width/(double)(w-1);
                    472:        for(ix=0;ix<w;ix++){
1.1       noro      473: #ifndef MAXSHORT
                    474: #define MAXSHORT ((short)0x7fff)
                    475: #endif
                    476:                double t;
                    477:
1.24      saito     478:                pa[ix].x=(int)(ix*xstep);
                    479:                t=(h - 1)*(ymax - RealtoDbl(tab[ix]))/dy;
                    480:                if(t>MAXSHORT)pa[ix].y=MAXSHORT;
                    481:                else if(t<-MAXSHORT)pa[ix].y=-MAXSHORT;
                    482:                else pa[ix].y=(long)t;
1.1       noro      483:        }
                    484:        plot_print(display,can);
                    485:        copy_to_canvas(can);
                    486:        return id;
                    487: }
                    488:
1.24      saito     489: void ifplot_resize(struct canvas *can,POINT spos,POINT epos){
1.1       noro      490:        struct canvas *ncan;
                    491:        struct canvas fakecan;
                    492:        Q dx,dy,dx2,dy2,xmin,xmax,ymin,ymax,xmid,ymid;
                    493:        Q sx,sy,ex,ey,cw,ch,ten,two;
                    494:        Q s,t;
                    495:        int new;
                    496:        int w,h,m;
                    497:
1.24      saito     498:        if(XC(spos)<XC(epos) && YC(spos)<YC(epos)){
                    499:                if(can->precise && !can->wide){
                    500:                        fakecan=*can;
                    501:                        ncan=&fakecan;
1.1       noro      502:                } else {
1.24      saito     503:                        new=search_canvas();
                    504:                        ncan=canvas[new];
1.1       noro      505:                }
1.24      saito     506:                ncan->mode=can->mode;
                    507:                ncan->zmin=can->zmin; ncan->zmax=can->zmax;
                    508:                ncan->nzstep=can->nzstep;
                    509:                ncan->wname=can->wname;
                    510:                ncan->vx=can->vx; ncan->vy=can->vy;
                    511:                ncan->formula=can->formula;
                    512:                w=XC(epos)-XC(spos);
                    513:                h=YC(epos)-YC(spos);
                    514:                m=MAX(can->width,can->height);
                    515:                if(can->precise){
                    516:                        ncan->width=w;
                    517:                        ncan->height=h;
                    518:                } else if(w>h){
                    519:                        ncan->width=m;
                    520:                        ncan->height=m*h/w;
1.1       noro      521:                } else {
1.24      saito     522:                        ncan->width=m*w/h;
                    523:                        ncan->height=m;
1.1       noro      524:                }
1.24      saito     525:                if(can->wide){
                    526:                        STOQ(10,ten);
                    527:                        STOQ(2,two);
                    528:                        subq(can->qxmax,can->qxmin,&t);
                    529:                        mulq(t,ten,&dx);
                    530:                        subq(can->qymax,can->qymin,&t);
                    531:                        mulq(t,ten,&dy);
                    532:                        addq(can->qxmax,can->qxmin,&t);
                    533:                        divq(t,two,&xmid);
                    534:                        addq(can->qymax,can->qymin,&t);
                    535:                        divq(t,two,&ymid);
                    536:                        divq(dx,two,&dx2);
                    537:                        divq(dy,two,&dy2);
                    538:                        subq(xmid,dx2,&xmin);
                    539:                        addq(xmid,dx2,&xmax);
                    540:                        subq(ymid,dy2,&ymin);
                    541:                        addq(ymid,dy2,&ymax);
1.1       noro      542:                } else {
1.24      saito     543:                        subq(can->qxmax,can->qxmin,&dx);
                    544:                        subq(can->qymax,can->qymin,&dy);
                    545:                        xmin=can->qxmin;
                    546:                        xmax=can->qxmax;
                    547:                        ymin=can->qymin;
                    548:                        ymax=can->qymax;
1.1       noro      549:                }
                    550:                STOQ(XC(spos),sx); STOQ(YC(spos),sy); STOQ(XC(epos),ex); STOQ(YC(epos),ey);
                    551:                STOQ(can->width,cw); STOQ(can->height,ch);
                    552:                mulq(sx,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmin);
                    553:                mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax);
                    554:                mulq(ey,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymin);
                    555:                mulq(sy,dy,&t); divq(t,ch,&s); subq(ymax,s,&ncan->qymax);
1.24      saito     556:                ncan->xmin=ToReal(ncan->qxmin); ncan->xmax=ToReal(ncan->qxmax);
                    557:                ncan->ymin=ToReal(ncan->qymin); ncan->ymax=ToReal(ncan->qymax);
                    558:                if(can->precise && !can->wide){
                    559:                        current_can=can;
1.1       noro      560:                        alloc_pixmap(ncan);
1.4       noro      561: #if defined(VISUAL)
1.24      saito     562:                        ncan->real_can=can;
1.4       noro      563: #endif
1.1       noro      564:                        qifplotmain(ncan);
                    565:                        copy_subimage(ncan,can,spos);
                    566:                        copy_to_canvas(can);
                    567:                } else {
                    568:                        create_canvas(ncan);
1.24      saito     569:                        if( can->precise ) qifplotmain(ncan);
                    570:                        else ifplotmain(ncan);
1.1       noro      571:                        copy_to_canvas(ncan);
                    572:                }
                    573:        }
                    574: }
                    575:
1.24      saito     576: void plot_resize(struct canvas *can,POINT spos,POINT epos){
1.1       noro      577:        struct canvas *ncan;
                    578:        Q dx,dx2,xmin,xmax,xmid;
1.7       noro      579:        double dy,ymin,ymax,ymid;
1.1       noro      580:        Q sx,ex,cw,ten,two;
                    581:        Q s,t;
                    582:        int new;
                    583:        int w,h,m;
                    584:
1.24      saito     585:        if( XC(spos)<XC(epos) && YC(spos)<YC(epos) ){
                    586:                new=search_canvas(); ncan=canvas[new];
                    587:                ncan->mode=can->mode;
                    588:                ncan->zmin=can->zmin; ncan->zmax=can->zmax;
                    589:                ncan->nzstep=can->nzstep;
                    590:                ncan->wname=can->wname;
                    591:                ncan->vx=can->vx; ncan->vy=can->vy;
                    592:                ncan->formula=can->formula;
                    593:                w=XC(epos)-XC(spos);
                    594:                h=YC(epos)-YC(spos);
                    595:                m=MAX(can->width,can->height);
                    596:                if( w>h ){
                    597:                        ncan->width=m; ncan->height=m * h/w;
1.1       noro      598:                } else {
1.24      saito     599:                        ncan->width=m * w/h; ncan->height=m;
1.1       noro      600:                }
1.24      saito     601:                if( can->wide ){
1.1       noro      602:                        STOQ(10,ten); STOQ(2,two);
                    603:                        subq(can->qxmax,can->qxmin,&t); mulq(t,ten,&dx);
                    604:                        addq(can->qxmax,can->qxmin,&t); divq(t,two,&xmid);
                    605:                        divq(dx,two,&dx2); subq(xmid,dx2,&xmin); addq(xmid,dx2,&xmax);
                    606:
1.24      saito     607:                        dy=(can->ymax-can->ymin)*10;
                    608:                        ymid=(can->ymax+can->ymin)/2;
                    609:                        ymin=ymid-dy/2; ymax=ymid+dy/2;
1.1       noro      610:                } else {
                    611:                        subq(can->qxmax,can->qxmin,&dx);
1.24      saito     612:                        xmin=can->qxmin; xmax=can->qxmax;
1.1       noro      613:
1.24      saito     614:                        dy=can->ymax-can->ymin;
                    615:                        ymin=can->ymin; ymax=can->ymax;
1.1       noro      616:                }
                    617:                STOQ(XC(spos),sx); STOQ(XC(epos),ex); STOQ(can->width,cw);
                    618:                mulq(sx,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmin);
                    619:                mulq(ex,dx,&t); divq(t,cw,&s); addq(xmin,s,&ncan->qxmax);
1.24      saito     620:                ncan->xmin=ToReal(ncan->qxmin); ncan->xmax=ToReal(ncan->qxmax);
1.1       noro      621:
1.24      saito     622:                ncan->ymin=ymax-YC(epos)*dy/can->height;
                    623:                ncan->ymax=ymax-YC(spos)*dy/can->height;
1.1       noro      624:
                    625:                create_canvas(ncan);
                    626:                plotcalc(ncan);
                    627:                plot_print(display,ncan);
                    628:                copy_to_canvas(ncan);
                    629:        }
                    630: }
                    631:
1.24      saito     632: void qifplotmain(struct canvas *can)
1.1       noro      633: {
                    634:        int width,height;
1.24      saito     635:        char **tabe,*tabeb;
1.1       noro      636:        int i;
                    637:
1.24      saito     638:        width=can->width; height=can->height;
                    639:        tabe=(char **)ALLOCA(width*sizeof(char *)+width*height*sizeof(char));
                    640:        bzero((void *)tabe,width*sizeof(char *)+width*height*sizeof(char));
                    641:        for( i=0, tabeb=(char *)(tabe+width); i<width; i++ )
                    642:                tabe[i]=tabeb + height*i;
1.1       noro      643:        define_cursor(can->window,runningcur);
                    644:        set_busy(can); set_selection();
1.24      saito     645:        qcalc(tabe,can); qif_print(display,tabe,can);
1.1       noro      646:        reset_selection(); reset_busy(can);
                    647:        define_cursor(can->window,normalcur);
                    648: }
                    649:
1.24      saito     650: //*******************ifplotNG
1.27    ! saito     651: int ifplotNG(NODE arg,int func){
1.24      saito     652:        int id,orgcolor,color,op_code;
                    653:        NODE n;
                    654:        struct canvas *can;
                    655:        P formula;
                    656:        LIST xrange,yrange,zrange,wsize;
                    657:        STRING wname;
                    658:
                    659:        formula=(P)ARG0(arg);
                    660:        color=QTOS((Q)ARG1(arg));
                    661:        xrange=(LIST)ARG2(arg);
                    662:        yrange=(LIST)ARG3(arg);
                    663:        zrange=(LIST)ARG4(arg);
                    664:        wsize=(LIST)ARG5(arg);
                    665:        wname=(STRING)ARG6(arg);
                    666:
                    667:        can=canvas[id=search_canvas()];
                    668:        orgcolor=can->color;
                    669:        can->color=color;
                    670:        can->division=0;
                    671:        // set canvas data
                    672:        if(xrange){
                    673:                n=BDY(xrange); can->vx=VR((P)BDY(n)); n=NEXT(n);
                    674:                can->qxmin=(Q)BDY(n); n=NEXT(n); can->qxmax=(Q)BDY(n);
                    675:                can->xmin=ToReal(can->qxmin); can->xmax=ToReal(can->qxmax);
                    676:        }
                    677:        if(yrange){
                    678:                n=BDY(yrange); can->vy=VR((P)BDY(n)); n=NEXT(n);
                    679:                can->qymin=(Q)BDY(n); n=NEXT(n); can->qymax=(Q)BDY(n);
                    680:                can->ymin=ToReal(can->qymin); can->ymax=ToReal(can->qymax);
                    681:        }
                    682:        if(zrange){
                    683:                n=BDY(zrange); can->zmin=ToReal(BDY(n));
                    684:                n=NEXT(n); can->zmax=ToReal(BDY(n));
                    685:                n=NEXT(n); can->nzstep=QTOS((Q)BDY(n));
                    686:        }
                    687:        if(!wsize){
                    688:                can->width=DEFAULTWIDTH;
                    689:                can->height=DEFAULTHEIGHT;
                    690:        } else {
                    691:                can->width=QTOS((Q)BDY(BDY(wsize)));
                    692:                can->height=QTOS((Q)BDY(NEXT(BDY(wsize))));
                    693:        }
                    694:        if(wname) can->wname=BDY(wname);
                    695:        else can->wname="";
                    696:        can->formula=formula;
                    697:        set_drawcolor(color);
1.27    ! saito     698:        can->mode=func;
1.24      saito     699:        create_canvas(can);
                    700:        ifplotmain(can);
                    701:        set_drawcolor(orgcolor);
                    702:        copy_to_canvas(can);
                    703:        can->color=orgcolor;
                    704:        return id;
                    705: }
                    706:
1.27    ! saito     707: int ifplotOP(NODE arg,int func){
        !           708:        //ineqnor[D,Q,B],ineqnand[D,Q,B],ineqnxor[D,Q,b],plotover[D,Q,B]
1.24      saito     709:        int index,orgcolor,color,op_code;
1.27    ! saito     710:        P formula;
        !           711:        struct canvas *can;
        !           712:        VL vl,vl0;
1.24      saito     713:        NODE n;
1.27    ! saito     714:
1.24      saito     715:        index=QTOS((Q)ARG0(arg));
                    716:        formula=(P)ARG1(arg);
                    717:        color=QTOS((Q)ARG2(arg));
1.27    ! saito     718:        // set canvas data
1.24      saito     719:        can=canvas[index];
                    720:        orgcolor=can->color;
                    721:        can->color=color;
                    722:        can->formula=formula;
1.27    ! saito     723:        current_can=can;
        !           724:        get_vars_recursive((Obj)formula,&vl);
        !           725:        for(vl0=vl;vl0;vl0=NEXT(vl0))
        !           726:                if(vl0->v->attr==(pointer)V_IND)
        !           727:                        if(vl->v!=can->vx && vl->v!=can->vy)return -1;
        !           728: #if !defined(VISUAL)
        !           729:        set_drawcolor(can->color);
        !           730: #endif
        !           731:        can->mode=func;
1.24      saito     732:        set_drawcolor(color);
                    733:        ifplotmain(can);
                    734:        set_drawcolor(orgcolor);
                    735:        copy_to_canvas(can);
                    736:        can->color=orgcolor;
1.27    ! saito     737: #if !defined(VISUAL)
        !           738:        set_drawcolor(can->color);
        !           739: #endif
1.24      saito     740:        return index;
                    741: }
                    742:
                    743: void ifplotmain(struct canvas *can){
                    744:        int width,height,i,j,ix,iy,**mask;
                    745:        double **tabe;
1.1       noro      746:
1.24      saito     747:        width=can->width; height=can->height;
                    748:        tabe=(double **)ALLOCA((width+1)*sizeof(double *));
                    749:        for(i=0;i<width;i++)tabe[i]=(double *)ALLOCA((height+1)*sizeof(double));
1.1       noro      750:        define_cursor(can->window,runningcur);
                    751:        set_busy(can); set_selection();
1.24      saito     752:        set_drawcolor(can->color);
                    753:        switch(can->mode){
1.27    ! saito     754:        case 6://IFPLOTD
1.24      saito     755:                calc(tabe,can,0);
                    756:                if_print(display,tabe,can,1);
                    757:                break;
1.27    ! saito     758:        case 7://IFPLOTQ
1.24      saito     759:                calcq(tabe,can,0);
                    760:                if_print(display,tabe,can,1);
                    761:                break;
1.27    ! saito     762:        case 8://IFPLOTB
1.24      saito     763:                calcb(tabe,can,0);
                    764:                if_print(display,tabe,can,0);
                    765:                break;
1.25      noro      766: #if defined(INTERVAL)
1.27    ! saito     767:        case 9://INEQND
1.24      saito     768:                calc(tabe,can,0);
                    769:                area_print(display,tabe,can,0);
                    770:                break;
1.27    ! saito     771:        case 10://INEQNQ
1.24      saito     772:                calcq(tabe,can,0);
                    773:                area_print(display,tabe,can,0);
                    774:                break;
1.27    ! saito     775:        case 11://INEQNB
1.24      saito     776:                calcb(tabe,can,0);
                    777:                area_print(display,tabe,can,0);
                    778:                break;
1.27    ! saito     779:        case 12://INEQNFAND
1.24      saito     780:                calc(tabe,can,0);
1.27    ! saito     781:                area_print(display,tabe,can,2);
1.24      saito     782:                break;
1.27    ! saito     783:        case 13://INEQNQAND
1.24      saito     784:                calcq(tabe,can,0);
                    785:                area_print(display,tabe,can,2);
                    786:                break;
1.27    ! saito     787:        case 14://INEQNBAND
1.24      saito     788:                calcb(tabe,can,0);
                    789:                area_print(display,tabe,can,2);
                    790:                break;
1.27    ! saito     791:        case 15://INEQNDOR
1.24      saito     792:                calc(tabe,can,0);
                    793:                area_print(display,tabe,can,3);
                    794:                break;
1.27    ! saito     795:        case 16://INEQNQOR
1.24      saito     796:                calcq(tabe,can,0);
                    797:                area_print(display,tabe,can,3);
                    798:                break;
1.27    ! saito     799:        case 17://INEQNBOR
1.24      saito     800:                calcb(tabe,can,0);
                    801:                area_print(display,tabe,can,3);
                    802:                break;
1.27    ! saito     803:        case 18://INEQNDXOR
1.24      saito     804:                calc(tabe,can,0);
                    805:                area_print(display,tabe,can,4);
                    806:                break;
1.27    ! saito     807:        case 19://INEQNQXOR
1.24      saito     808:                calcq(tabe,can,0);
                    809:                area_print(display,tabe,can,4);
                    810:                break;
1.27    ! saito     811:        case 20://INEQNBXOR
1.24      saito     812:                calcb(tabe,can,0);
                    813:                area_print(display,tabe,can,4);
                    814:                break;
1.27    ! saito     815:        case 21://CONPLOTD
1.24      saito     816:                calc(tabe,can,0);
                    817:                con_print(display,tabe,can);
                    818:                break;
1.27    ! saito     819:        case 22://CONPLOTQ
        !           820:                calcq(tabe,can,0);
        !           821:                con_print(display,tabe,can);
        !           822:                break;
        !           823:        case 23://CONPLOTB
1.24      saito     824:                calcb(tabe,can,0);
                    825:                con_print(display,tabe,can);
                    826:                break;
1.27    ! saito     827:        case 24://ITVIFPLOT:
        !           828:                itvcalc(tabe,can,1);
        !           829:                if_print(display,tabe,can,1);
1.24      saito     830:                break;
1.27    ! saito     831:        case 25://PLOTOVERD
1.24      saito     832:                calc(tabe,can,0);
                    833:                over_print(display,tabe,can,0);
                    834:                break;
1.27    ! saito     835:        case 26://PLOTOVERQ:
1.24      saito     836:                calcq(tabe,can,0);
                    837:                over_print(display,tabe,can,0);
                    838:                break;
1.27    ! saito     839:        case 27://PLOTOVERB:
1.24      saito     840:                calcb(tabe,can,0);
                    841:                over_print(display,tabe,can,0);
                    842:                break;
                    843: #endif
                    844:        }
                    845:        set_drawcolor(can->color);
1.1       noro      846:        reset_selection(); reset_busy(can);
                    847:        define_cursor(can->window,normalcur);
                    848: }
1.22      saito     849:
1.25      noro      850: #if defined(INTERVAL)
1.24      saito     851: int objcp(NODE arg){
1.22      saito     852:        int idsrc, idtrg, op_code;
                    853:        struct canvas *cansrc, *cantrg;
                    854:
1.24      saito     855:        idsrc=QTOS((Q)ARG0(arg));
                    856:        idtrg=QTOS((Q)ARG1(arg));
                    857:        op_code=QTOS((Q)ARG2(arg));
                    858:        cansrc=canvas[idsrc];
                    859:        cantrg=canvas[idtrg];
1.22      saito     860:        obj_op(cansrc, cantrg, op_code);
                    861:        return idsrc;
                    862: }
                    863:
1.24      saito     864: void obj_op(struct canvas *cansrc, struct canvas *cantrg, int op){
1.22      saito     865:        XImage *imgsrc, *imgtrg;
                    866:        int width, height, i, j;
                    867:        unsigned long src, trg, black, white;
                    868:
1.24      saito     869:        width=cansrc->width; height=cansrc->height;
                    870:        imgsrc=XGetImage(display, cansrc->pix, 0, 0, width, height, -1, ZPixmap);
                    871:        imgtrg=XGetImage(display, cantrg->pix, 0, 0, width, height, -1, ZPixmap);
1.22      saito     872:        black=GetColor(display, "black");
                    873:        white=GetColor(display, "white");
                    874:        flush();
                    875:        define_cursor(cantrg->window,runningcur);
                    876:        set_busy(cantrg); set_selection();
1.24      saito     877:        cantrg->precise=cansrc->precise;
                    878:        cantrg->noaxis=cansrc->noaxis;
                    879:        cantrg->noaxisb=cansrc->noaxisb;
                    880:        cantrg->vx=cansrc->vx;
                    881:        cantrg->vy=cansrc->vy;
                    882:        cantrg->formula=cansrc->formula;
                    883:        cantrg->width=cansrc->width;
                    884:        cantrg->height=cansrc->height;
                    885:        cantrg->xmin=cansrc->xmin;
                    886:        cantrg->xmax=cansrc->xmax;
                    887:        cantrg->ymin=cansrc->ymin;
                    888:        cantrg->ymax=cansrc->ymax;
                    889:        cantrg->zmin=cansrc->zmin;
                    890:        cantrg->zmax=cansrc->zmax;
                    891:        cantrg->nzstep=cansrc->nzstep;
                    892:        cantrg->qxmin=cansrc->qxmin;
                    893:        cantrg->qxmax=cansrc->qxmax;
                    894:        cantrg->qymin=cansrc->qymin;
                    895:        cantrg->qymax=cansrc->qymax;
                    896:        cantrg->pa=cansrc->pa;
                    897:        switch(op){
1.22      saito     898:                case 1:/* and case */
                    899:                        for(i=0;i<width;i++)for(j=0;j<height;j++){
1.24      saito     900:                                src=XGetPixel(imgsrc,i,j);
                    901:                                trg=XGetPixel(imgtrg,i,j);
                    902:                                if( (src == black) || (trg == black) )
1.22      saito     903:                                        XPutPixel(imgtrg,i,j,black);
1.24      saito     904:                                else if( (src == white) || (trg == white) )
1.22      saito     905:                                        XPutPixel(imgtrg,i,j,white);
                    906:                                else XPutPixel(imgtrg,i,j,(src & trg));
                    907:                        }
                    908:                        break;
                    909:                case 3:/* copy case */
1.24      saito     910:                        imgtrg->data=imgsrc->data;
1.22      saito     911:                        break;
                    912:                case 6:/* xor case */
                    913:                        for(i=0;i<width;i++)for(j=0;j<height;j++){
1.24      saito     914:                                src=XGetPixel(imgsrc,i,j);
                    915:                                trg=XGetPixel(imgtrg,i,j);
                    916:                                if( (src == black) || (trg == black) )
1.22      saito     917:                                        XPutPixel(imgtrg,i,j,black);
1.24      saito     918:                                else if( (src == white) && (trg == white) )
1.22      saito     919:                                        XPutPixel(imgtrg,i,j,trg|src);
1.24      saito     920:                                else if( (src != white) && (trg != white) )
1.22      saito     921:                                        XPutPixel(imgtrg,i,j,white);
1.24      saito     922:                                else if( src == white )
1.22      saito     923:                                        XPutPixel(imgtrg,i,j,src);
                    924:                        }
                    925:                        break;
                    926:                case 7:/* or case */
                    927:                        for(i=0;i<width;i++)for(j=0;j<height;j++){
1.24      saito     928:                                src=XGetPixel(imgsrc,i,j);
                    929:                                trg=XGetPixel(imgtrg,i,j);
                    930:                                if( (src == black) || (trg == black) )
1.22      saito     931:                                        XPutPixel(imgtrg,i,j,black);
1.24      saito     932:                                else if(src == white)
1.22      saito     933:                                        XPutPixel(imgtrg,i,j,trg);
1.24      saito     934:                                else if(trg == white)
1.22      saito     935:                                        XPutPixel(imgtrg,i,j,src);
                    936:                        }
                    937:                        break;
                    938:                default:
                    939:                        break;
                    940:        }
                    941:        XPutImage(display, cantrg->pix, drawGC, imgtrg, 0, 0, 0, 0, width, height);
                    942:        reset_selection(); reset_busy(cantrg);
                    943:        define_cursor(cantrg->window,normalcur);
                    944:        copy_to_canvas(cantrg);
                    945:        count_and_flush();
                    946:        flush();
                    947: }
1.24      saito     948: int polarplotNG(NODE arg){
1.27    ! saito     949:        int i,id,color,orgcolor,width,height;
1.22      saito     950:        NODE n;
                    951:        struct canvas *can;
1.24      saito     952:        P formula;
1.27    ! saito     953:        LIST range,geom;
1.22      saito     954:        STRING wname;
1.24      saito     955:        V v;
1.22      saito     956:
1.24      saito     957:        formula=(P)ARG0(arg);
1.27    ! saito     958:        color=QTOS((Q)ARG1(arg));
        !           959:        range=(LIST)ARG2(arg);
        !           960:        geom=(LIST)ARG3(arg);
1.24      saito     961:        wname=(STRING)ARG4(arg);
                    962:
1.27    ! saito     963:        id=search_canvas();
        !           964:        can=canvas[id];
        !           965:        can->mode=modeNO(POLARPLOT);
        !           966:        if(range){
        !           967:                n=NEXT(BDY(range));
        !           968:                can->zmin=ToReal(BDY(n));
        !           969:                n=NEXT(n);can->zmax=ToReal(BDY(n));
        !           970:                n=NEXT(n);
        !           971:                can->vx=VR((P)BDY(BDY(range)));
        !           972:                can->nzstep=n?QTOS((Q)BDY(n)):DEFAULTPOLARSTEP;
1.24      saito     973:        }
1.27    ! saito     974:        if(geom){
        !           975:                can->width=width=QTOS((Q)BDY(BDY(geom)));
        !           976:                can->height=height=QTOS((Q)BDY(NEXT(BDY(geom))));
1.22      saito     977:        }
1.24      saito     978:        if(wname)can->wname=BDY(wname);
                    979:        else can->wname="";
                    980:        can->formula=formula;
                    981:        orgcolor=can->color;
                    982:        can->color=color;
1.27    ! saito     983:        polarcalc(can);
1.22      saito     984:        create_canvas(can);
1.27    ! saito     985:        set_drawcolor(color);
        !           986:        polar_print(display,can);
1.24      saito     987:        can->color=orgcolor;
1.27    ! saito     988:        set_drawcolor(orgcolor);
        !           989:        reset_selection(); reset_busy(can);
        !           990:        define_cursor(can->window,normalcur);
1.22      saito     991:        return id;
                    992: }
1.25      noro      993: #endif

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>