sources/new-s5r4/x11graf2.c

   1 /*     Loglan82 Compiler&Interpreter
   2      Copyright (C) 1981-1993 Institute of Informatics, University of Warsaw
   3      Copyright (C)  1993, 1994 LITA, Pau
   4
   5      This program is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published by
   7      the Free Software Foundation; either version 2 of the License, or
   8      (at your option) any later version.
   9
  10      This program is distributed in the hope that it will be useful,
  11      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13      GNU General Public License for more details.
  14
  15              You should have received a copy of the GNU General Public License
  16              along with this program; if not, write to the Free Software
  17              Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19  contacts:  Andrzej.Salwicki@univ-pau.fr
  20
  21 or             Andrzej Salwicki
  22                 LITA   Departement d'Informatique
  23                 Universite de Pau
  24                 Avenue de l'Universite
  25                 64000 Pau   FRANCE
  26                  tel.  ++33 59923154    fax. ++33 59841696
  27
  28 =======================================================================
  29 */
  30
  31 #define send_par(par) theMessage.data.s[cnt++]=(short)(param[par].xword);
  32 #define send_shrt(wd) theMessage.data.s[cnt++]=(short)(wd);
  33 #define send_word(wd) theMessage.data.s[cnt++]=(short)((wd)&0xffff); \
  34                       theMessage.data.s[cnt++]=(short)(((wd)>>16)&0xffff);
  35
  36
  37 #define send_sig                        \
  38    theMessage.type=ClientMessage;       \
  39    theMessage.format = 16;              \
  40    theMessage.message_type = nrproc;    \
  41    XSendEvent(theDisplay,theWindow,True,NoEventMask,&theMessage);       \
  42    XFlush(theDisplay);
  43
  44 #define nxtev do XNextEvent( theDisplay, &retEv );      \
  45               while( retEv.type!=ClientMessage );       \
  46               cnt = 0;
  47
  48 #define rec_par(par) param[par].xword=(int)(retEv.xclient.data.s[cnt++]);
  49 #define rec_shrt(sh) sh  = (int)(retEv.xclient.data.s[cnt++]);
  50 #define rec_word(wd) wd  = (int)(retEv.xclient.data.s[cnt++]) & 0xffff; \
  51                      wd |= (int)(retEv.xclient.data.s[cnt++]) << 16;
  52
  53
  54
  55         case GRON :
  56                 if ((theDisplay = XOpenDisplay(NULL)) == NULL){
  57                    fprintf (stderr,"\nint:  Can't open display\n");
  58                    exit(1);
  59                 }
  60                 myWindow = XCreateWindow(
  61                               theDisplay,
  62                               RootWindow(theDisplay,DefaultScreen(theDisplay)),
  63                               0,0,1,1,0,
  64                               CopyFromParent,InputOnly,CopyFromParent,
  65                               0,NULL
  66                            );
  67                 if( (child_no=fork())==0 ){
  68                    char me[16];
  69                    sprintf(me,"%d",(int)myWindow);
  70                    execlp("herc","herc",me,NULL);
  71                 }
  72                 graphmode = TRUE;
  73                 curx=cury=0;
  74                 nxtev
  75                 rec_word(theWindow);
  76                 break;
  77
  78         case GROFF :
  79                 if( graphmode == FALSE )  break;
  80                 send_sig
  81                 child_no=0;
  82                 graphmode = FALSE;
  83                 break;
  84
  85         case CLS :
  86                 send_sig
  87                 break;
  88
  89
  90         case PUSHXY :
  91                 xystack[stackptr].x = curx;
  92                 xystack[stackptr].y = cury;
  93                 xystack[stackptr].fcol = fcol;
  94                 xystack[stackptr].bcol = bcol;
  95                 xystack[stackptr].style= style;
  96
  97                 stackptr++;
  98                 if( stackptr == 16 ) stackptr--;
  99
 100                 break;
 101
 102
 103         case POPHXY :
 104
 105                 stackptr--;
 106                 if( stackptr < 0 ){
 107                    stackptr = 0;
 108                    break;
 109                 }
 110
 111                 curx = xystack[stackptr].x;
 112                 cury = xystack[stackptr].y;
 113                 fcol = xystack[stackptr].fcol;
 114                 bcol = xystack[stackptr].bcol;
 115                 style= xystack[stackptr].style;
 116
 117                 cnt = 0;
 118                 nrproc = COLOR;
 119                 send_shrt(fcol)
 120                 send_sig
 121
 122                 cnt = 0;
 123                 nrproc = BORDER;
 124                 send_shrt(bcol)
 125                 send_sig
 126
 127                 cnt = 0;
 128                 nrproc = STYLE;
 129                 send_shrt(style)
 130                 send_sig
 131
 132                 break;
 133
 134
 135         case POINT :
 136                 send_par(0)
 137                 send_par(1)
 138                 send_sig
 139         case MOVE :
 140                 curx=param[0].xword;
 141                 cury=param[1].xword;
 142                 break;
 143
 144         case DRAW :
 145                 send_shrt(curx)
 146                 send_shrt(cury)
 147                 send_par(0)
 148                 send_par(1)
 149                 send_sig
 150                 curx=param[0].xword;
 151                 cury=param[1].xword;
 152                 break;
 153
 154         case INXPOS :
 155                 param[0].xword = curx;
 156                 break;
 157
 158         case INYPOS :
 159                 param[0].xword = cury;
 160                 break;
 161
 162         case HFILL :
 163         case VFILL :
 164                 send_shrt(curx)
 165                 send_shrt(cury)
 166                 send_par(0)
 167                 send_sig
 168                 break;
 169
 170         case HASCII :
 171                 send_shrt(curx)
 172                 send_shrt(cury)
 173                 send_par(0)
 174                 send_sig
 175                 if( param[0].xword != 0 )  curx += 8;
 176                 break;
 177
 178         case COLOR :
 179                 fcol = param[0].xword;
 180                 send_par(0)
 181                 send_sig
 182                 break;
 183
 184         case BORDER :
 185                 bcol = param[0].xword;
 186                 send_par(0)
 187                 send_sig
 188                 break;
 189
 190         case STYLE :
 191                 bcol = param[0].xword;
 192                 send_par(0)
 193                 send_sig
 194                 break;
 195
 196         case INPIX :
 197                 send_par(0)
 198                 send_par(1)
 199                 send_sig
 200                 curx=param[0].xword;
 201                 cury=param[1].xword;
 202                 nxtev
 203                 rec_par(2)
 204                 break;
 205
 206         case OUTSTRING :
 207                 {
 208                    char *s= (char *)(M + strings + param[ 0 ].xword + 1);
 209                    int signs=M[ strings + param[ 0 ].xword ];
 210                    nrproc=HASCII;
 211                    while( signs-- ){
 212                       word sign=0;
 213                       cnt = 0;
 214                       send_shrt(curx)
 215                       send_shrt(cury)
 216                       send_shrt(sign)
 217                       send_sig
 218                       sign = (word)(*s);
 219                       cnt = 0;
 220                       send_shrt(curx)
 221                       send_shrt(cury)
 222                       send_shrt(sign)
 223                       send_sig
 224                       s++;
 225                       curx+=8;
 226                    }
 227                 }
 228                 break;
 229
 230         case GETMAP :
 231                 {
 232                    word map;
 233                    word x=param[0].xword;
 234                    word y=param[1].xword;
 235                    word w = x - curx + 1;
 236                    word h = y - cury + 1;
 237                    x = curx;
 238                    y = cury;
 239                    if( w <= 0 ){ w=-w; x-=w; }
 240                    if( h <= 0 ){ h=-h; y-=h; }
 241                    send_shrt(x)
 242                    send_shrt(y)
 243                    send_shrt(w)
 244                    send_shrt(h)
 245                    send_sig
 246                    nxtev
 247                    rec_word(map)
 248                    newarry((word) 1, 3, (word)AINT, &param[ 2 ].xvirt, &am);
 249                    M[ am+3 ] = map;
 250                    M[ am+4 ] = w;
 251                    M[ am+5 ] = h;
 252                 }
 253                 break;
 254
 255         case PUTMAP :
 256         case ORMAP :
 257         case XORMAP :
 258                 if (member(&param[ 0 ].xvirt, &am)){
 259                    send_word( M[ am+3 ] )
 260                    send_shrt(curx)
 261                    send_shrt(cury)
 262                    send_shrt( M[ am+4 ] )
 263                    send_shrt( M[ am+5 ] )
 264                    send_sig
 265                 }else errsignal(RTEREFTN);
 266                 break;
 267
 268 /*
 269         case PATERN :
 270                 patern((int *) &param[ 0 ].xword, (int *) &param[ 1 ].xword,
 271                        (int *) &param[ 2 ].xword, (int *) &param[ 3 ].xword);
 272                 break;
 273
 274         case INTENS :
 275                 intens((int *) &param[ 0 ].xword);
 276                 break;
 277
 278         case PALETT :
 279                 pallet((int *) &param[ 0 ].xword);
 280                 break;
 281
 282         case VIDEO :
 283                 if (member(&param[ 0 ].xvirt, &am))
 284                     if (M[ am ] >= 0x8000L/sizeof(word))
 285                         video(normalize((char *) &M[ am+3 ]));
 286                     else errsignal(RTEILLAB);
 287                 else errsignal(RTEREFTN);
 288                 break;
 289
 290         case HPAGE :
 291                 i = (int) param[ 1 ].xword;
 292                 if (i == 0) graphmode = FALSE;
 293                 else
 294                     if (i == 1) graphmode = TRUE;
 295                 hpage((int *) &param[ 0 ].xword, &i,
 296                       (int *) &param[ 2 ].xword);
 297                 break;
 298
 299         case NOCARD :
 300                 param[ 0 ].xword = nocard(NULL);
 301                 break;
 302 */
 303
 304         case TRACK :
 305                 send_par(0)
 306                 send_par(1)
 307                 send_sig
 308                 nxtev
 309                 rec_shrt( curx )
 310                 rec_shrt( cury )
 311                 break;
 312
 313         case INKEY :
 314              if( child_no == 0 ) param[ 0 ].xword = inkey();
 315              else
 316              {
 317                 int keycode;
 318                 send_sig
 319                 nxtev
 320                 rec_word(keycode)
 321                 param[ 0 ].xword = keycode;
 322              }
 323              break;
 324
 325 /*
 326         case HFONT :
 327                 hfont((int *) &param[ 0 ].xword, (int *) &param[ 1 ].xword);
 328                 break;
 329
 330         case HFONT8 :
 331                 param[ 0 ].xword = 0;
 332                 param[ 1 ].xword = 0;
 333                 hfont8((int *) &param[ 0 ].xword, (int *) &param[ 1 ].xword);
 334                 break;
 335 */
 336
 337         case CIRB :
 338              {
 339                 double alfa,beta,aspect,abs; word kolb,wwyp;
 340
 341                 send_par(0)
 342                 send_par(1)
 343                 param[2].xword *= 2;
 344                 send_par(2)
 345                 alfa = (double)(param[3].xreal);
 346                 beta = (double)(param[4].xreal);
 347                 kolb = param[5].xword;
 348                 wwyp = param[6].xword;
 349
 350                 aspect = (double)(param[7].xword) / (double)(param[8].xword);
 351                 aspect *= (double)(param[2].xword);
 352
 353                 alfa = alfa / M_PI * 180.0 * 64.0 ;
 354                 beta = beta / M_PI * 180.0 * 64.0 ;
 355
 356                 abs = alfa - beta;
 357                 if( abs < 0.0 )  abs = -abs;
 358                 if( abs < 0.0001 )
 359                    beta+=360.0*64.0;
 360
 361                 send_shrt( (unsigned)aspect )
 362                 send_shrt( (unsigned)alfa   )
 363                 send_shrt( (unsigned)beta   )
 364                 send_sig
 365              }
 366                 break;
 367
 368 /* MOUSE */
 369
 370         case INIT :
 371                 param[ 0 ].xbool = 2;
 372                 param[ 1 ].xbool = lbool(1);
 373                 break;
 374
 375         case STATUS :
 376                 send_sig
 377                 nxtev
 378                 rec_par(0)
 379                 rec_par(1)
 380                 rec_par(2)
 381                 rec_par(3)
 382                 rec_par(4)
 383                 break;
 384
 385         case GETPRESS :
 386         case GETRELEASE :
 387                 send_par(0)
 388                 send_sig
 389                 nxtev
 390                 rec_par(1)
 391                 rec_par(2)
 392                 rec_par(3)
 393                 rec_par(4)
 394                 rec_par(5)
 395                 rec_par(6)
 396                 break;
 397
 398         case SHOWCURSOR :
 399         case HIDECURSOR :
 400         case SETPOSITION :
 401         case SETWINDOW :
 402         case DEFCURSOR :
 403         case SETSPEED :
 404         case SETMARGINS :
 405         case SETTHRESHOLD :
 406                 break;
 407
 408         case GETMOVEMENT :
 409                 send_sig
 410                 nxtev
 411                 rec_par(0)
 412                 rec_par(1)
 413                 break;
 414