home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume18 / gl_plot / part07 < prev    next >
Text File  |  1989-03-23  |  38KB  |  1,485 lines
  1. Subject:  v18i065:  GL Graphics Library for AT-clone Unix, Part07/07
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: umix!m-net!dtlewis!lewis
  7. Posting-number: Volume 18, Issue 65
  8. Archive-name: gl_plot/part07
  9.  
  10. # To recover, type "sh archive"
  11. echo restoring INSTALL
  12. sed 's/^X//' > INSTALL <<XxX--EOF--XxX
  13. XHOW TO BUILD THE GL LIBRARY
  14. X
  15. X1)  Edit the Makefile file for your system.  Microport System V/AT and 
  16. XSCO Xenix for 286 machines, and MS-DOS for any PC, are currently supported.
  17. XFor Microsoft C under MS-DOS, use the MSC.MAK file.  For Turbo-C under 
  18. XMS-DOS, use the TCC.MAK file.
  19. X
  20. X2)  Edit the config.h file.  Define your target system and compiler, along 
  21. Xwith other parameters that may be specific to your hardware and operating 
  22. Xsystem.
  23. X
  24. X3)  Run make.  For UNIX, just type "make."  For Xenix, type "make xenix."
  25. XTo compile an MS-DOS executable under Xenix, type "make dos."  For 
  26. XMicrosoft C under MS-DOS, type "MAKE MSC.MAK".  For Turbo-C under MS-DOS, 
  27. Xtype "MAKE -FTCC.MAK".
  28. X
  29. XHOW TO INSTALL THE GL LIBRARY
  30. X
  31. XBefore running the demonstration programs "demo" and "xdemo," you
  32. Xmust do a few things.
  33. X
  34. XMicroport System V/AT:
  35. X---------------------
  36. X
  37. X1)  Mode switch program:  The GL library will switch video graphics
  38. Xmodes by executing a program or shell script.  The name of the program
  39. Xis defined in config.h as follows:
  40. X
  41. X    #define MODEPROG "mode"
  42. X
  43. XYou must have a working script or program called "mode" in your
  44. Xpath, or (if you prefer), you can use a different program name for your
  45. Xsystem.  For most systems and video adapters (CGA and EGA compatible), 
  46. Xyou can use the "mode.sh" script, and rename it to "mode" (use the
  47. Xcommand "mv mode.sh mode").
  48. X
  49. XIf you have an Everex Edge (hercules compatible), use mode.c ("mv 
  50. Xmodeprog mode").  For other adapters (possibly including actual 
  51. XHercules boards), you may have to modify mode.c and setmode.c.  
  52. X
  53. XIf you use mode.c, you must make the executable (mode) suid and 
  54. Xowned by root.  Put it in a safe path, of course.
  55. XFor example, sign as root, then:
  56. X
  57. X  \$ mv mode /usr/bin/mode
  58. X  \$ chmod 4555 /usr/bin/mode
  59. X
  60. XBe sure the mode program works before trying anything else.  You should,
  61. Xfor example, be able to type "mode 4" and have your graphics adapter 
  62. Xswitch to 640x200 color graphics mode, and type "mode" to return to 
  63. Xnormal text mode.
  64. X
  65. X2)  Graphics shared memory:  The GL library must be able to attach to
  66. Xa shared memory segment that corresponds to your graphics adapter.  You
  67. Xmust use a kernel that has shared memory enabled.  The standard kernel
  68. Xfor large memory systems should already be configured this way; if not,
  69. Xuse the link kit (edit the last three lines of dfile.wini).
  70. X
  71. XNext, you must sign on as root, and run the shmcreate(1) program to 
  72. Xcreate one or more shared memory keys.  Once you have the key or keys 
  73. Xdefined correctly, you should put the shmcreate commands into your 
  74. X/etc/rc.d/shm.rc file, so the keys will be defined each time the 
  75. Xsystem is booted.
  76. X
  77. XThe key values are actually arbitrary, but have been chosen to match
  78. Xthe physical memory addresses that they point to.  Thus the "b8000" 
  79. Xkey is used for CGA graphics modes, and the "b0000" is used for 
  80. Xhercules compatible adapters.  The "a0000" key can be used for EGA 
  81. Xmodes.  Define keys for each mode you expect to use.
  82. X
  83. XFollowing is a sample shm.rc file for a system with a video adapter
  84. Xwhich supports CGA modes and hercules compatible mode:  
  85. X
  86. X    #  Setup for shared memory segments used for graphics
  87. X
  88. X    # /etc/shmcreate 0xa0000 a0000 65535        # ega high res
  89. X    /etc/shmcreate 0xb0000 b0000 65535        # ega low res
  90. X    /etc/shmcreate 0xb8000 b8000 32768        # cga
  91. X    # /etc/shmcreate 0xc6000 c6000  4096        # pga
  92. X
  93. X3)  Double check.  Use the ipcs(1) command to make sure your shared memory
  94. Xkeys are installed.  Run the mode script (or program) with arguments
  95. Xcorresponding to each mode you want to use.
  96. X
  97. X4)  If you want to be able to do graphics printing, be sure you have a
  98. Xprinter device in the lp spooler which is capable of raw output.  The
  99. Xname of this device should match the PRINTDEV macro in config.h.  See the
  100. X"Readme" file for more information.
  101. X
  102. X5)  You should now be ready to run GL programs.  Try either "demo" or
  103. X"xdemo."  If something is not set up correctly, the error messages should
  104. Xgive a good indication of the problem.  
  105. X
  106. X
  107. XXenix System V 286:
  108. X------------------
  109. X
  110. X1)  Mode switch program:  The GL library will switch video graphics
  111. Xmodes by executing a program or shell script.  The name of the program
  112. Xis defined in config.h as follows:
  113. X
  114. X    #define MODEPROG "mode"
  115. X
  116. XYou must have a working script or program called "mode" in your
  117. Xpath, or (if you prefer), you can use a different program name for your
  118. Xsystem.  For most systems and video adapters (CGA and EGA compatible), 
  119. Xyou can use the "mode.xenix" script, and rename it to "mode" (use the
  120. Xcommand "mv mode.xenix mode").
  121. X
  122. X2)  Double check.  Run the mode script (or program) with arguments
  123. Xcorresponding to each mode you want to use.
  124. X
  125. X3)  If you want to be able to do graphics printing, be sure you have a
  126. Xprinter device in the lp spooler which is capable of raw output.  The
  127. Xname of this device should match the PRINTDEV macro in config.h.  See the
  128. X"Readme" file for more information.
  129. X
  130. X4)  You should now be ready to run GL programs.  Try either "demo" or
  131. X"xdemo."  If something is not set up correctly, the error messages should
  132. Xgive a good indication of the problem.  Note that as of this writing,
  133. XGL has been tested ONLY on an EGA board for Xenix.  It will probably 
  134. Xwork for CGA cards, but hercules compatibles may take some experimenting.  
  135. XAny required modifications to the code will be in the g_init.c module.
  136. X
  137. X
  138. XMS-DOS, cross compiled from Xenix System V 286:
  139. X-----------------------------------------------
  140. X
  141. X1)  Mode switch program:  None required, unless a Hercules compatible
  142. Xvideo board is used, in which case you will have to hack the code to
  143. Xuse some or all of the mode.c and modeset.c routines.
  144. X
  145. X2)  Compile under Xenix, and copy to an MS-DOS disk or partition.
  146. X
  147. X3)  You should now be ready to run GL programs.  
  148. X
  149. X
  150. XMS-DOS with Microsoft C
  151. X-----------------------
  152. X
  153. XJust try running the DEMO.EXE and XDEMO.EXE programs ("DEMO 4" to run
  154. Xthe demo in video mode 4).  Graphics modes 4, 6, and 16 (EGA) will work,
  155. Xas will mode 256 for an IBM/Epson printer on PRN:.  Hercules support is
  156. Xnot currently in the MS-DOS version, but all you need to do is borrow the 
  157. Xmode switching code in SETMODE.C and add it to g_init.c module.
  158. X
  159. X
  160. XMS-DOS with Turbo-C
  161. X-------------------
  162. XThis works the same as Microsoft C, although it compiles faster and runs
  163. Xa little slower.
  164. X
  165. X
  166. X                    d t lewis
  167. X                    Mon Feb 20 20:09:41 EST 1989
  168. X                    system5 dtlewis 2 2.4.0-U AT
  169. XxX--EOF--XxX
  170. echo restoring demo.c
  171. sed 's/^X//' > demo.c <<XxX--EOF--XxX
  172. X#ifndef lint
  173. Xstatic char sccsid[] = "@(#) demo.c 5.1 89/02/20";
  174. X#endif
  175. X
  176. X/*
  177. X *    Copyright (c) David T. Lewis 1987, 1988
  178. X *    All rights reserved.
  179. X *
  180. X *    Permission is granted to use this for any personal noncommercial use.
  181. X *    You may not distribute source or executable code for profit, nor
  182. X *    may you distribute it with a commercial product without the written
  183. X *    consent of the author.  Please send modifications to the author for
  184. X *    inclusion in updates to the program.  Thanks.
  185. X */
  186. X
  187. X#include "config.h"
  188. X#include "gl.h"
  189. X#include <stdio.h>
  190. X#if MIX_C
  191. X#else
  192. X#include <time.h>
  193. X#endif /* MIX_C */
  194. X
  195. Xextern int lines(), strings(), chars(), strokeset(), fillscreen();
  196. Xextern int charset(), ellipses(), arcs(), testplot(), showcursor();
  197. Xextern int linestyles(), curvestyles();
  198. X
  199. Xstatic int mode;
  200. X
  201. Xvoid usage(progname)  
  202. Xchar *progname;
  203. X{
  204. X    fprintf (stderr,"Usage:  %s <mode>\n\n",progname);
  205. X    fprintf (stderr,"Where <mode> is:\n",0);
  206. X    fprintf (stderr,"\t4 (CGA 4 color 320 x 200)\n",0);
  207. X    fprintf (stderr,"\t6 (CGA 2 color 640 x 200)\n",0);
  208. X    fprintf (stderr,"\t8 (Hercules page 0, 720 x 348)\n",0);
  209. X    fprintf (stderr,"\t9 (Hercules page 1, 720 x 348)\n",0);
  210. X    fprintf (stderr,"\t16 (EGA color 640 x 350)\n",0);
  211. X    fprintf (stderr,"\t256 (IBM / Epson compatible printer)\n",0);
  212. X    fprintf (stderr,"\t257 (Laserjet+ printer)\n\n",0);
  213. X}
  214. X
  215. Xmain(argc,argv)
  216. Xint argc;
  217. Xchar *argv[];
  218. X{
  219. X    char str[80];
  220. X    long time();
  221. X    struct tm *gmtime();
  222. X    void srand();
  223. X
  224. X    printf("\nThis demonstration will show the operation of the gl ",0);
  225. X    printf("graphics functions.\n",0);
  226. X    printf("The <delete> key stops the demo.  Press <return> ",0);
  227. X    printf("to view each\n",0);
  228. X    printf("successive screen.\n\n",0);
  229. X    printf("Note: The GLMODE shell variable may be used to specify ",0);
  230. X    printf("the graphics\n",0);
  231. X    printf("mode to use.\n\n",0);
  232. X    printf("Press <return> to continue...",0);
  233. X    gets(str);
  234. X
  235. X    /* Get the mode to use. */
  236. X
  237. X    if (argc < 2) mode = ENV_MODE;
  238. X    else if (argc == 2)  {
  239. X        if (sscanf(argv[1],"%d",&(mode)) != 1)  {
  240. X            usage(argv[0]);
  241. X            exit (1);
  242. X        }
  243. X    }
  244. X    else  {
  245. X        usage(argv[0]);
  246. X        exit (1);
  247. X    }
  248. X
  249. X    /* Set video mode.    */
  250. X    if (g_init(mode))  {
  251. X        usage(argv[0]);
  252. X        fprintf(stderr,"WARNING:  Possible invalid shared memory ",0);
  253. X        fprintf(stderr,"key for requested video mode.\n",0);
  254. X        exit (1);
  255. X    }
  256. X
  257. X    /* Draw patterns.    */
  258. X
  259. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  260. X    if (lines()) fprintf(stderr,"Failed call to lines().\n");
  261. X    if (mode > MAXVIDEO)
  262. X        printf("\nPress <Return> to send to printer...",0);
  263. X    gets(str);
  264. X
  265. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  266. X    g_clear();
  267. X    if (linestyles()) fprintf(stderr,"Failed call to linestyles().\n");
  268. X    if (mode > MAXVIDEO)
  269. X        printf("\nPress <Return> to send to printer...",0);
  270. X    gets(str);
  271. X
  272. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  273. X    g_clear();
  274. X    if (strings()) fprintf(stderr,"Failed call to strings().\n");
  275. X    if (mode > MAXVIDEO)
  276. X        printf("\nPress <Return> to send to printer...",0);
  277. X    gets(str);
  278. X
  279. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  280. X    g_clear();
  281. X    slanttext();
  282. X    if (mode > MAXVIDEO)
  283. X        printf("\nPress <Return> to send to printer...",0);
  284. X    gets(str);
  285. X
  286. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  287. X    g_clear();
  288. X    strokeset();
  289. X    if (mode > MAXVIDEO)
  290. X        printf("\nPress <Return> to send to printer...",0);
  291. X    gets(str);
  292. X
  293. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  294. X    g_clear();
  295. X    if (chars()) fprintf(stderr,"Failed call to chars().\n");
  296. X    if (mode > MAXVIDEO)
  297. X        printf("\nPress <Return> to send to printer...",0);
  298. X    gets(str);
  299. X
  300. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  301. X    g_clear();
  302. X    fillscreen();
  303. X    if (mode > MAXVIDEO)
  304. X        printf("\nPress <Return> to send to printer...",0);
  305. X    gets(str);
  306. X
  307. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  308. X    g_clear();
  309. X    charset();
  310. X    if (mode > MAXVIDEO)
  311. X        printf("\nPress <Return> to send to printer...",0);
  312. X    gets(str);
  313. X
  314. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  315. X    g_clear();
  316. X    ellipses();
  317. X    if (mode > MAXVIDEO)
  318. X        printf("\nPress <Return> to send to printer...",0);
  319. X    gets(str);
  320. X
  321. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  322. X    g_clear();
  323. X    curvestyles();
  324. X    if (mode > MAXVIDEO)
  325. X        printf("\nPress <Return> to send to printer...",0);
  326. X    gets(str);
  327. X
  328. X    if (mode > MAXVIDEO) printf("\nRasterizing output...",0);
  329. X    g_clear();
  330. X    arcs();
  331. X    showcursor();
  332. X
  333. X    g_finish();
  334. X
  335. X    printf("\n\n\n\nThe next demonstration screen will use the ",0);
  336. X    printf("plot(3) interface, rather than\n",0);
  337. X    printf("direct calls to the gl library.  The plot(3) interface ",0);
  338. X    printf("determines graphic \n",0);
  339. X    printf("mode from the GLMODE shell variable, or if GLMODE is not ",0);
  340. X    printf("defined, uses a \n",0);
  341. X    printf("default mode value (defined in config.h). \n\n",0);
  342. X    printf("If you called this program with an argument on the ",0);
  343. X    printf("command line, the \n",0);
  344. X    printf("next screen may use a different graphics mode ",0);
  345. X    printf("than you specified. \n\n",0);
  346. X    printf("Press <return> to continue or <delete> to stop...",0);
  347. X
  348. X    gets(str);
  349. X
  350. X    testplot();
  351. X    gets(str);
  352. X}
  353. XxX--EOF--XxX
  354. echo restoring mode.sh
  355. sed 's/^X//' > mode.sh <<XxX--EOF--XxX
  356. X:
  357. X#  Contributed by Denis Fortin, April 1988.
  358. X#
  359. X#  mode - This trivial little command file is used to set the graphics mode
  360. X#      of the console on Microport System V/AT.
  361. X#
  362. X#  Usage:
  363. X#        mode [value]
  364. X#
  365. X#     where: value is an integer used to select the current display
  366. X#             mode.  If it is omitted, the screen is returned to
  367. X#             normal text mode.
  368. X#
  369. X#  Examples:
  370. X#    mode
  371. X#        Returns to normal text mode
  372. X#
  373. X#    mode 16
  374. X#        Puts an EGA card with Enhanced Display adapter in 640x350
  375. X#        graphics mode.
  376. X#
  377. X#    mode 6
  378. X#        Puts a CGA card in 640x200 graphics mode.
  379. X#
  380. Xif [ \$# -lt 1 ] 
  381. Xthen
  382. X    echo "\033[=h\c"
  383. Xelse
  384. X    echo "\033[=\${1}h\c"
  385. Xfi
  386. XxX--EOF--XxX
  387. echo restoring mode.xenix
  388. sed 's/^X//' > mode.xenix <<XxX--EOF--XxX
  389. X:
  390. X# d t lewis  11-20-1988
  391. X# Script to set video mode using the stty command for Xenix 286.
  392. X#
  393. X# Pick a default (text) mode:
  394. X
  395. XDEFAULT_MODE=ENH_C80x25
  396. X# DEFAULT_MODE=ENH_B80x25
  397. X# DEFAULT_MODE=EGAMONO80x25
  398. X# DEFAULT_MODE=C80x25
  399. X# DEFAULT_MODE=B80x25
  400. X
  401. X    case \$# in
  402. X        1)    ;;    # Correct number of arguments is 1.
  403. X        0)    stty \$DEFAULT_MODE
  404. X            exit;;
  405. X        \?)    echo "Usage: \$0 modenumber"
  406. X            echo "where modenumber is an integer value"
  407. X            ;;
  408. X        *)    echo "Usage: \$0 modenumber"
  409. X            echo "where modenumber is an integer value"
  410. X            ;;
  411. X    esac
  412. X
  413. X
  414. X# These variables should correspond to the defines in graphics.h:
  415. X
  416. X    MONO_TEXT=2
  417. X    COLOR_TEXT=3
  418. X    CGA_COLOR_MODE=4
  419. X    CGA_HI_RES_MODE=6
  420. X    EGA_COLOR_MODE=16
  421. X    HERC_GRAF_MODE=8
  422. X    IBM_PRINTER=256
  423. X
  424. X    case \$1 in
  425. X        \$MONO_TEXT)
  426. X            stty ENH_B80x25
  427. X            ;;
  428. X        \$COLOR_TEXT)
  429. X            stty ENH_C80x25
  430. X            ;;
  431. X        \$CGA_COLOR_MODE)
  432. X            stty CG320
  433. X            # Mode 4    -    320x200    4 color    graphics.
  434. X            ;;
  435. X        \$CGA_HI_RES_MODE)
  436. X            stty BG640
  437. X            # Mode 6    -    640x200    2 color    graphics.
  438. X            ;;
  439. X        \$EGA_COLOR_MODE)
  440. X            stty ENH_CG640
  441. X            ;;
  442. X        \$HERC_GRAF_MODE)
  443. X            # stty ??????????  -don't know the value to use.
  444. X            # Hercules  -    720x348    black &    white graphics.
  445. X            ;;
  446. X        \$IBM_PRINTER)
  447. X            ;;
  448. X        *)
  449. X            stty \$DEFAULT_MODE
  450. X            # Switch back    to normal text mode.
  451. X            ;;
  452. X    esac
  453. X    exit
  454. X
  455. XxX--EOF--XxX
  456. echo restoring n_point.c
  457. sed 's/^X//' > n_point.c <<XxX--EOF--XxX
  458. X#ifndef lint
  459. Xstatic char sccsid[] = "@(#) n_point.c 5.1 89/02/20";
  460. X#endif
  461. X
  462. X/*
  463. X *    Copyright (c) David T. Lewis 1988
  464. X *    All rights reserved.
  465. X *
  466. X *    Permission is granted to use this for any personal noncommercial use.
  467. X *    You may not distribute source or executable code for profit, nor
  468. X *    may you distribute it with a commercial product without the written
  469. X *    consent of the author.  Please send modifications to the author for
  470. X *    inclusion in updates to the program.  Thanks.
  471. X */
  472. X
  473. X/* Sun Aug 21 21:59:55 EDT 1988
  474. X** dtlewis
  475. X** Routine to draw a point in normalized 2-d space.
  476. X*/
  477. X
  478. X#include "config.h"
  479. X#include "bitmaps.h"
  480. X#include "graphics.h"
  481. X
  482. Xextern struct GL_graphics graphics;
  483. Xextern int n_movepen();
  484. Xextern int p_wr_pix();
  485. X
  486. Xint n_point(x,y)  
  487. X    int x,y;
  488. X{
  489. X    if (n_movepen(x,y)) return(1);
  490. X    if (p_wr_pix(n_to_p_x(x), n_to_p_y(y))) return(1);
  491. X    return(0);
  492. X}
  493. XxX--EOF--XxX
  494. echo restoring testpat.c
  495. sed 's/^X//' > testpat.c <<XxX--EOF--XxX
  496. X#ifndef lint
  497. Xstatic char sccsid[] = "@(#) testpat.c 5.1 89/02/20";
  498. X#endif
  499. X
  500. X/*
  501. X *    Copyright (c) David T. Lewis 1988
  502. X *    All rights reserved.
  503. X *
  504. X *    Permission is granted to use this for any personal noncommercial use.
  505. X *    You may not distribute source or executable code for profit, nor
  506. X *    may you distribute it with a commercial product without the written
  507. X *    consent of the author.  Please send modifications to the author for
  508. X *    inclusion in updates to the program.  Thanks.
  509. X */
  510. X
  511. X#include "config.h"
  512. X#include <stdio.h>
  513. X#if MIX_C
  514. X#else
  515. X#include <math.h>
  516. X#endif /* MIX_C */
  517. X#if XEN2DOS
  518. X#include <dos.h>
  519. X#endif /* XEN2DOS */
  520. X#if USOFT
  521. X#include <dos.h>
  522. X#endif /* USOFT */
  523. X#include "gl.h"
  524. X
  525. X#ifndef M_PI_2
  526. X#define M_PI_2    1.5707963268 
  527. X#endif /* M_PI_2 */
  528. X#ifndef M_PI_4
  529. X#define M_PI_4    0.7853981634 
  530. X#endif /* M_PI_4 */
  531. X
  532. Xstatic char str[20];
  533. X
  534. X/* Routines to put test patterns on the screen.    */
  535. X
  536. Xint lines()  {
  537. X
  538. X    if (n_line(4000,4000,20000,20000)) return(1);
  539. X
  540. X        if (n_movepen(6000,6000)) return(1);
  541. X        if (n_draw(12000,6000)) return(1);
  542. X        if (n_draw(12000,12000)) return(1);
  543. X        if (n_draw(6000,12000)) return(1);
  544. X        if (n_draw(6000,6000)) return(1);
  545. X
  546. X        if (n_movepen(6000,6000)) return(1);
  547. X        if (n_draw(12000,12000)) return(1);
  548. X
  549. X    g_pix_color(CYAN);
  550. X
  551. X    if (n_box(700,700,900,1200)) return(1);
  552. X    if (n_box(900,1200,1100,1700)) return(1);
  553. X    if (n_box(20000,20000,30000,30000)) return(1);
  554. X
  555. X    if (n_box(1000,10000,12000,12000)) return(1);
  556. X    if (n_box(9000,9000,13000,13000)) return(1);
  557. X    if (n_box(8000,8000,14000,14000)) return(1);
  558. X    if (n_box(7000,7000,15000,15000)) return(1);
  559. X    if (n_box(6000,6000,16000,16000)) return(1);
  560. X
  561. X        if (n_movepen(2000,13000)) return(1);
  562. X        if (n_draw(4000,13000)) return(1);
  563. X        if (n_movepen(4000,13300)) return(1);
  564. X        if (n_draw(2000,13300)) return(1);
  565. X
  566. X    g_pix_color(GREEN);
  567. X
  568. X        if (n_movepen(2000,14000)) return(1);
  569. X        if (n_draw(30000,14400)) return(1);
  570. X        if (n_draw(2000,14800)) return(1);
  571. X        if (n_draw(30000,15200)) return(1);
  572. X        if (n_draw(2000,15600)) return(1);
  573. X        if (n_draw(30000,16000)) return(1);
  574. X        if (n_draw(2000,16400)) return(1);
  575. X        if (n_draw(30000,16800)) return(1);
  576. X        if (n_draw(2000,17200)) return(1);
  577. X        if (n_draw(30000,17600)) return(1);
  578. X        if (n_draw(2000,18000)) return(1);
  579. X        if (n_draw(30000,18400)) return(1);
  580. X        if (n_draw(0,18800)) return(1);
  581. X        if (n_draw(32000,19200)) return(1);
  582. X        if (n_draw(0,19600)) return(1);
  583. X        if (n_draw(32000,20000)) return(1);
  584. X        if (n_draw(0,20400)) return(1);
  585. X        if (n_draw(32000,20800)) return(1);
  586. X        if (n_draw(0,21200)) return(1);
  587. X        if (n_draw(32000,21600)) return(1);
  588. X        if (n_draw(0,22000)) return(1);
  589. X        if (n_draw(32000,22400)) return(1);
  590. X
  591. X        if (n_movepen(6000,4000)) return(1);
  592. X        if (n_draw(6200,30000)) return(1);
  593. X        if (n_draw(6400,4000)) return(1);
  594. X        if (n_draw(6600,30000)) return(1);
  595. X        if (n_draw(6800,4000)) return(1);
  596. X        if (n_draw(7000,30000)) return(1);
  597. X        if (n_draw(7200,4000)) return(1);
  598. X        if (n_draw(7400,30000)) return(1);
  599. X        if (n_draw(7600,4000)) return(1);
  600. X        if (n_draw(7800,30000)) return(1);
  601. X        if (n_draw(8000,4000)) return(1);
  602. X        if (n_draw(8200,30000)) return(1);
  603. X        if (n_draw(8400,4000)) return(1);
  604. X
  605. X    g_pix_color(BLUE);
  606. X
  607. X        if (n_movepen(2000,2000)) return(1);
  608. X        if (n_draw(32000,4000)) return(1);
  609. X        if (n_draw(31000,32000)) return(1);
  610. X        if (n_draw(1000,30000)) return(1);
  611. X        if (n_draw(2000,2000)) return(1);
  612. X        if (n_draw(31000,32000)) return(1);
  613. X
  614. X        if (n_movepen(0,0)) return(1);
  615. X        if (n_draw(32767,0)) return(1);
  616. X        if (n_draw(32767,32767)) return(1);
  617. X        if (n_draw(0,32767)) return(1);
  618. X        if (n_draw(0,0)) return(1);
  619. X        if (n_draw(32767,32767)) return(1);
  620. X        if (n_movepen(0,32767)) return(1);
  621. X        if (n_draw(32767,0)) return(1);
  622. X
  623. X    return(0);
  624. X}
  625. X
  626. Xint linestyles()  {
  627. X    n_box(1000,1000,30000,30000);
  628. X    g_style(DOTTED);
  629. X    n_box(2000,2000,29000,29000);
  630. X    g_style(DOTDASHED);
  631. X    n_box(3000,3000,28000,28000);
  632. X    g_style(DASHED);
  633. X    n_box(4000,4000,27000,27000);
  634. X    g_style(SHORTDASHED);
  635. X    n_box(5000,5000,26000,26000);
  636. X    g_style(LONGDASHED);
  637. X    n_box(6000,6000,25000,25000);
  638. X    g_style(SOLID);
  639. X    n_box(7000,7000,24000,24000);
  640. X    g_style(DASHED);
  641. X    n_movepen(15500,7000);
  642. X    n_draw(24000,15500);
  643. X    n_draw(15500,24000);
  644. X    n_draw(7000,15500);
  645. X    n_draw(15500,7000);
  646. X    g_style(SOLID);
  647. X    n_movepen(12000,15000);
  648. X    c_cellstr("Line Styles");
  649. X
  650. X    return(0);
  651. X}
  652. X
  653. Xcurvestyles()  {
  654. X    n_ellipse(15500,15500,15000,15000);
  655. X    g_style(DOTTED);
  656. X    n_ellipse(15500,15500,14000,13000);
  657. X    g_style(DOTDASHED);
  658. X    n_ellipse(15500,15500,13000,11000);
  659. X    g_style(DASHED);
  660. X    n_ellipse(15500,15500,12000,9000);
  661. X    g_style(SHORTDASHED);
  662. X    n_ellipse(15500,15500,11000,7000);
  663. X    g_style(LONGDASHED);
  664. X    n_ellipse(15500,15500,10000,5000);
  665. X    g_style(SOLID);
  666. X    n_ellipse(15500,15500,9000,3000);
  667. X    n_movepen(12000,15000);
  668. X    c_cellstr("Ellipses");
  669. X
  670. X    return(0);
  671. X}
  672. X
  673. Xint strings()  {
  674. X
  675. X    n_movepen(10,5000);
  676. X    if (n_grafstr("AbCdEfGhIjKlMnOpQrStUvWxYz")) 
  677. X        return(1);
  678. X
  679. X    /* Don't worry about errors from here on out.  We will get    */
  680. X    /* an error return code each time we try to write off the edge    */
  681. X    /* of the screen.                        */
  682. X
  683. X    g_pix_color(MAGENTA);
  684. X
  685. X    g_fontctl(2.0, 1.0, 1.0, 0.0, 0.0);
  686. X    n_movepen(100, 10000);
  687. X    n_grafstr("AbCdEfGhIjKlMnOpQrStUvWxYz");
  688. X    g_fontctl(4.0, 1.0, 1.0, 0.0, 0.0);
  689. X    n_movepen(100, 15000);
  690. X    n_grafstr("AbCdEfGhIjKlMnO");
  691. X    g_fontctl(3.0, 1.0, 1.0, 0.0, 0.0);
  692. X    n_movepen(100, 20000);
  693. X    n_grafstr("Z#\$%^&*()+");
  694. X    g_fontctl(3.0, 2.0, 1.0, 0.0, 0.0);
  695. X    n_movepen(100, 24000);
  696. X    n_grafstr("Z#\$%^&*()+");
  697. X    g_fontctl(3.0, 2.0, 2.0, 0.0, 0.0);
  698. X    n_movepen(100, 28000);
  699. X    n_grafstr("Z#\$%^&*()+");
  700. X
  701. X    return (0);
  702. X
  703. X}
  704. X
  705. Xint chars()  {
  706. X
  707. X    int idx;
  708. X    char string1[65];
  709. X    char string2[65];
  710. X    char string3[65];
  711. X    char string4[65];
  712. X
  713. X    g_pix_color(RED);
  714. X
  715. X    if (c_cursor(1,1)) return(1);
  716. X    if (c_cellstr("* <== This is (1,1)")) return(1);
  717. X
  718. X    /* Don't worry about errors from here on out.  We will get    */
  719. X    /* an error return code each time we try to write off the edge    */
  720. X    /* of the screen.                        */
  721. X
  722. X    c_cursor(2,30);
  723. X    c_cellstr("* <== This is (2,30)");
  724. X
  725. X    c_cursor(3,60);
  726. X    c_cellstr("* <== This is (3,60)");
  727. X
  728. X    c_cursor(10,40);
  729. X    c_cellstr("* <== This is (10,40)");
  730. X
  731. X    c_cursor(25,40);
  732. X    c_cellstr("X");
  733. X
  734. X    c_cursor(25,80);
  735. X    c_cellstr("X");
  736. X
  737. X    c_cursor(43,90);
  738. X    c_cellstr("X");
  739. X
  740. X    c_cursor(2,1); 
  741. X    c_cellstr("This");
  742. X    c_cursor(3,1); 
  743. X    c_cellstr(" Is ");
  744. X    c_cursor(4,1); 
  745. X    c_cellstr("  A ");
  746. X    c_cursor(5,1); 
  747. X    c_cellstr("TEST");
  748. X    c_cursor(6,1); 
  749. X    c_cellstr("XXXX");
  750. X    c_cursor(7,1); 
  751. X    c_cellstr("XXXX");
  752. X
  753. X    for (idx=0;idx<64;idx++)  {
  754. X        string1[idx]=idx;
  755. X        string2[idx]=idx+64;
  756. X        string3[idx]=idx+128;
  757. X        string4[idx]=idx+192;
  758. X    }
  759. X    string1[64]=0;
  760. X    string2[64]=0;
  761. X    string3[64]=0;
  762. X    string4[64]=0;
  763. X
  764. X    /* The first character of string1[] is a null, making it a    */
  765. X    /* null string.  No good.  Make it the same as the second.    */
  766. X
  767. X    string1[0] = string1[1];
  768. X
  769. X    c_cursor(11,1);
  770. X    c_cellstr(string1);
  771. X    c_cursor(12,2);
  772. X    c_cellstr(string2);
  773. X    c_cursor(13,3);
  774. X    c_cellstr(string3);
  775. X    c_cursor(14,4);
  776. X    c_cellstr(string4);
  777. X    c_cursor(15,5);
  778. X    c_cellstr(string1);
  779. X    c_cursor(16,6);
  780. X    c_cellstr(string2);
  781. X    c_cursor(17,7);
  782. X    c_cellstr(string3);
  783. X    c_cursor(18,8);
  784. X    c_cellstr(string4);
  785. X
  786. X    for (idx=1;idx<=10;idx++)  {
  787. X        if (! c_cursor(idx,20)) c_cellstr("XHIHX");
  788. X    }
  789. X
  790. X    return (0);
  791. X}
  792. X
  793. Xint charset()  {
  794. X    int x,y;
  795. X
  796. X    char cval = 0;
  797. X    g_pix_color(CYAN);
  798. X    for (y=1; y<=60; y++)  {
  799. X        for (x=1; x<=140; x++)  {
  800. X            if (! c_cursor(y,x))  {
  801. X                c_cellchar(cval);
  802. X                cval = (++cval) & 0xff;
  803. X            }
  804. X        }
  805. X    }
  806. X}
  807. X
  808. Xint strokeset()  {
  809. X    int x,y;
  810. X
  811. X    char cval = 0;
  812. X    g_pix_color(CYAN);
  813. X    g_fontctl(2.0, 1.0, 1.0, 0.0, 0.0);
  814. X    for (y=1; y<=60; y += 2)  {
  815. X        for (x=1; x<=140; x += 2)  {
  816. X            if (! c_cursor(y,x))  {
  817. X                n_grafchar(cval);
  818. X                cval = (++cval) & 0x7f;
  819. X            }
  820. X        }
  821. X    }
  822. X}
  823. X
  824. Xint slanttext()  {
  825. X
  826. X    g_pix_color(LT_CYAN);
  827. X    n_movepen(6000,100);
  828. X    g_fontctl(4.0, 1.0, 1.0, 0.0, 0.0);
  829. X    n_grafstr("Text");
  830. X
  831. X    n_movepen(6000,4100);
  832. X    n_grafstr("Can be");
  833. X
  834. X    g_pix_color(LT_GREEN);
  835. X    n_movepen(6000,8100);
  836. X    g_fontctl(4.0, 1.0, 1.0, 0.0, 0.2);
  837. X    n_grafstr("Slanted!");
  838. X
  839. X    g_pix_color(YELLOW);
  840. X    n_movepen(10,30000);
  841. X    g_fontctl(4.0, 1.0, 1.0, M_PI_2, 0.0);
  842. X    n_grafstr("Rotated!");
  843. X
  844. X    g_pix_color(LT_RED);
  845. X    n_movepen(6000,28000);
  846. X    g_fontctl(4.0, 1.0, 1.0, M_PI_4, 0.0);
  847. X    n_grafstr("Or ");
  848. X    g_fontctl(4.0, 1.0, 1.0, M_PI_4, 0.2);
  849. X    n_grafstr("Both!");
  850. X}
  851. X
  852. Xint fillscreen()  {
  853. X    int x,y;
  854. X    char cval;
  855. X    g_pix_color(CYAN);
  856. X    for (x=1; x<=140; x++)  {
  857. X        for (y=1; y<=60; y++)  {
  858. X            cval = ((x+y-1)%10+'0');
  859. X            if (! c_cursor(y,x)) c_cellchar(cval);
  860. X        }
  861. X    }
  862. X    n_box(0,0,32767,32767);
  863. X}
  864. X
  865. Xellipses()  {
  866. X    int idx;
  867. X
  868. X    g_pix_color(CYAN);
  869. X    n_ellipse(10000,10000,4000,6000);
  870. X    n_ellipse(24000,15000,5000,6000);
  871. X    n_ellipse(20000,10000,6000,4000);
  872. X    n_ellipse(18000,18000,4000,3000);
  873. X    n_ellipse(10000,20000,7000,6000);
  874. X    n_ellipse(15000,24000,8000,8000);
  875. X    n_ellipse(10000,28000,5000,6000);
  876. X
  877. X    for (idx=10; idx< 20000; idx +=400)  {
  878. X        n_ellipse(1000+idx,1000+idx,idx,idx);
  879. X    }
  880. X}
  881. X
  882. Xarcs()  {
  883. X    int idx;
  884. X
  885. X    g_pix_color(RED);
  886. X    for (idx=10; idx< 20000; idx +=200)  {
  887. X        n_arc(15000,15000,1000+idx,1000+idx,(float)idx,(float)idx+0.4);
  888. X    }
  889. X}
  890. X
  891. Xplotpattern(size)
  892. Xint size;
  893. X{
  894. X    /* Use the plot(3) interface to draw a bunch of junk, scaled     */
  895. X    /* according to the value of size.                */
  896. X
  897. X    space(0,0,size,size);
  898. X    move(1000,1000);
  899. X    label("This is the BSD plot(3) interface.");
  900. X    circle(1000,1000,100);
  901. X    circle(1000,1000,200);
  902. X    circle(1000,1000,400);
  903. X    circle(1000,1000,800);
  904. X    cont(2000,2000);
  905. X    move(0,0);
  906. X    cont(0,3120);
  907. X    cont(3120,3120);
  908. X    cont(3120,0);
  909. X    cont(0,0);
  910. X}
  911. X
  912. Xplotcircles()  {
  913. X    erase();
  914. X
  915. X    space(0,0,1000,1000);
  916. X
  917. X    move(0,0);
  918. X    cont(999,0);
  919. X    cont(999,999);
  920. X    cont(0,999);
  921. X    cont(0,0);
  922. X
  923. X    circle(500,500,100);
  924. X    circle(500,500,200);
  925. X    circle(500,500,300);
  926. X    circle(500,500,400);
  927. X    circle(500,500,500);
  928. X    circle(500,500,600);
  929. X    circle(500,500,700);
  930. X    circle(500,500,800);
  931. X}
  932. X
  933. Xplotarcs()  {
  934. X    erase();
  935. X
  936. X    arc(500,500,600,500,400,400);
  937. X    arc(500,500,700,500,400,400);
  938. X    arc(500,500,800,500,400,400);
  939. X    arc(500,500,900,500,400,400);
  940. X    arc(500,500,1000,500,400,400);
  941. X    arc(500,500,1100,500,400,400);
  942. X    arc(500,500,1200,500,400,400);
  943. X    arc(500,500,1300,500,400,400);
  944. X}
  945. X
  946. Xint plotstyles()  {
  947. X    space(0,0,1000,1000);
  948. X    erase();
  949. X    move(0,0);
  950. X    cont(1000,0);
  951. X    cont(1000,1000);
  952. X    cont(0,1000);
  953. X    cont(0,0);
  954. X    linemod("dotdashed");
  955. X    line(100,0,900,100);
  956. X    linemod("solid");
  957. X    line(100,100,900,100);
  958. X    line(100,100,900,200);
  959. X    linemod("dotted");
  960. X    line(100,200,900,200);
  961. X    line(100,200,900,300);
  962. X    linemod("shortdashed");
  963. X    line(100,300,900,300);
  964. X    line(100,300,900,400);
  965. X    linemod("longdashed");
  966. X    line(100,400,900,400);
  967. X    line(100,400,900,500);
  968. X    linemod("dotdashed");
  969. X    line(100,500,900,500);
  970. X    line(100,500,900,600);
  971. X    linemod("take the default (solid)");
  972. X    line(100,600,900,600);
  973. X    line(100,600,900,700);
  974. X    linemod("dotted");
  975. X    line(100,700,900,700);
  976. X    line(100,700,900,800);
  977. X    linemod("shortdashed");
  978. X    line(100,800,900,800);
  979. X    line(100,800,900,900);
  980. X    linemod("longdashed");
  981. X    line(100,900,900,900);
  982. X    line(100,900,900,1000);
  983. X}
  984. X
  985. Xtestplot()
  986. X{
  987. X    /* Exercise the plot(3) interface.                */
  988. X    openpl();
  989. X    plotpattern(3120);
  990. X    plotpattern(6240);
  991. X    plotpattern(12480);
  992. X    gets(str);
  993. X    plotcircles();
  994. X    gets(str);
  995. X    plotarcs();
  996. X    gets(str);
  997. X    plotstyles();
  998. X    gets(str);
  999. X    closepl();
  1000. X    exit(0);
  1001. X}
  1002. X
  1003. Xint cursor(x,y)
  1004. Xint x, y;
  1005. X{
  1006. X    n_line(x-800,y,x+800,y);
  1007. X    n_line(x,y-1000,x,y+1000);
  1008. X    return(0);
  1009. X}
  1010. X
  1011. Xint showcursor()  {
  1012. X
  1013. X#define MAX_BOUND_ 28000
  1014. X#define MIN_BOUND 4000
  1015. X
  1016. X    int idx,i,j,xinc,yinc;
  1017. X
  1018. X    if (n_box(0,0,32767,32767)) return(1);
  1019. X    if (n_box(1000,1200,31767,31567)) return(1);
  1020. X    if (n_box(2000,2400,30767,30367)) return(1);
  1021. X
  1022. X    g_pix_mode(XOR);
  1023. X
  1024. X    xinc = 380;
  1025. X    yinc = 330;
  1026. X    i = 14300;
  1027. X    j = 17324;
  1028. X
  1029. X    cursor (i,j);
  1030. X
  1031. X    for (idx=0; idx<1600; idx++)  {
  1032. X        cursor (i,j);
  1033. X        if (i < MIN_BOUND || i > MAX_BOUND_) xinc = - xinc;
  1034. X        if (j > MAX_BOUND_) yinc = - yinc - 10;
  1035. X        if (j < MIN_BOUND) yinc = - yinc; 
  1036. X        i += xinc;
  1037. X        j += yinc;
  1038. X        cursor (i,j);
  1039. X    }
  1040. X
  1041. X    g_pix_mode(OR);
  1042. X
  1043. X    return(0);
  1044. X}
  1045. XxX--EOF--XxX
  1046. echo restoring xdemo.c
  1047. sed 's/^X//' > xdemo.c <<XxX--EOF--XxX
  1048. X#ifndef lint
  1049. Xstatic char sccsid[] = "@(#) xdemo.c 5.1 89/02/20";
  1050. X#endif
  1051. X
  1052. X/*
  1053. X *    Copyright (c) David T. Lewis 1988
  1054. X *    All rights reserved.
  1055. X *
  1056. X *    Permission is granted to use this for any personal noncommercial use.
  1057. X *    You may not distribute source or executable code for profit, nor
  1058. X *    may you distribute it with a commercial product without the written
  1059. X *    consent of the author.  Please send modifications to the author for
  1060. X *    inclusion in updates to the program.  Thanks.
  1061. X */
  1062. X
  1063. X/* Cheap clone of an attention getting program I saw on a Xerox workstation.*/
  1064. X/* system5 dtlewis 2 2.3.0-U AT */
  1065. X/* Tue May 24 22:38:22 EDT 1988 */
  1066. X/* by Dave Lewis */
  1067. X
  1068. X#include <stdio.h>
  1069. X#include "config.h"
  1070. X#include "gl.h"
  1071. X#if MS_DOS
  1072. X#include <stdlib.h>
  1073. X#define DOS_GET_TIME 0x2c
  1074. X#define DOS_KBY_STAT 0x0b;
  1075. X#define DOS 0x21
  1076. X#endif /* MS_DOS */
  1077. X#if MIX_C
  1078. X#else
  1079. X#include <signal.h>
  1080. X#include <time.h>
  1081. X#if MS_DOS
  1082. X#include <dos.h>
  1083. X#endif /* MS_DOS */
  1084. X#endif /* MIX_C */
  1085. X
  1086. X#define MAXINT 32767
  1087. X#define NUMLINES 32
  1088. X
  1089. X#define MSG_COUNT 11
  1090. X
  1091. X#if MS_DOS
  1092. Xstatic REGISTERS inreg, outreg;
  1093. X#endif /* MS_DOS */
  1094. X
  1095. Xvoid border()  {
  1096. X    /* Draw a border and text message. */
  1097. X    int color;
  1098. X    color = g_pix_color(CYAN);
  1099. X    n_box(0,0,32767,32767);
  1100. X    n_movepen(2000,30000);
  1101. X    g_fontctl(2.5, 1.0, 1.0, 0.0, 0.0);
  1102. X    n_grafstr("XOR Write Mode");
  1103. X    g_pix_color(1);
  1104. X    n_line(16383,6000,16383,26767);
  1105. X    n_line(6000,16383,26767,16383);
  1106. X    g_pix_color(color);
  1107. X}
  1108. X
  1109. Xvoid usage(progname)  
  1110. Xchar *progname;
  1111. X{
  1112. X    fprintf (stderr,"Usage:  %s <mode>\n\n",progname);
  1113. X    fprintf (stderr,"Where <mode> is:\n",0);
  1114. X    fprintf (stderr,"\t4 (CGA 4 color 320 x 200)\n",0);
  1115. X    fprintf (stderr,"\t6 (CGA 2 color 640 x 200)\n",0);
  1116. X    fprintf (stderr,"\t8 (Hercules page 0, 720 x 348)\n",0);
  1117. X    fprintf (stderr,"\t9 (Hercules page 1, 720 x 348)\n",0);
  1118. X    fprintf (stderr,"\t16 (EGA color 640 x 350)\n",0);
  1119. X    fprintf (stderr,"\t256 (IBM / Epson compatible printer)\n",0);
  1120. X    fprintf (stderr,"\t257 (Laserjet+ printer)\n\n",0);
  1121. X}
  1122. X
  1123. Xvoid pattern()  {
  1124. X
  1125. X    long x1;
  1126. X    long y1;
  1127. X    long x2;
  1128. X    long y2;
  1129. X    int x1rate;
  1130. X    int y1rate;
  1131. X    int x2rate;
  1132. X    int y2rate;
  1133. X    int rand();
  1134. X    int idx_to_buff;
  1135. X    struct endpoints {
  1136. X        int x1;
  1137. X        int x2;
  1138. X        int y1;
  1139. X        int y2;
  1140. X    } buff[NUMLINES]; 
  1141. X
  1142. X    /* Initialize.    */
  1143. X
  1144. X    /* Modify the slopes and starting location of the endpoint    */
  1145. X    /* motion, to give different patterns every time we run the    */
  1146. X    /* program.                            */
  1147. X    x1 = rand();
  1148. X    y1 = rand();
  1149. X    x2 = rand();
  1150. X    y2 = rand();
  1151. X    x1rate = rand() & 0x0FF + 256;
  1152. X    y1rate = rand() & 0x0FF + 256;
  1153. X    x2rate = rand() & 0x0FF + 256;
  1154. X    y2rate = rand() & 0x0FF + 256;
  1155. X    if (rand() & 0x01) x1rate *= -1;
  1156. X    if (rand() & 0x01) y1rate *= -1;
  1157. X    if (rand() & 0x01) x2rate *= -1;
  1158. X    if (rand() & 0x01) y2rate *= -1;
  1159. X
  1160. X    /* Initialize the line buffer to invalid values (so they don't    */
  1161. X    /* get plotted).                        */
  1162. X
  1163. X    for (idx_to_buff=0; idx_to_buff < NUMLINES; idx_to_buff++)  {
  1164. X        buff[idx_to_buff].x1 = -1;
  1165. X        buff[idx_to_buff].y1 = -1;
  1166. X        buff[idx_to_buff].x2 = -1;
  1167. X        buff[idx_to_buff].y2 = -1;
  1168. X    }
  1169. X
  1170. X    idx_to_buff = 0;
  1171. X
  1172. X    /* Start the display pattern.    */
  1173. X
  1174. X    /* Loop until <del> key is pressed. */
  1175. X    for (;;)  {
  1176. X
  1177. X#if MS_DOS
  1178. X        /* Call to get keyboard status, so DOS can check for    */
  1179. X        /* interrupt signal (^C).                */
  1180. X        inreg.AH = DOS_KBY_STAT;
  1181. X        DO_BIOS(DOS, &inreg, &outreg);
  1182. X#endif /* MS_DOS */
  1183. X
  1184. X        /* Increment buffer pointer, wrapping around buffer.    */
  1185. X        ++idx_to_buff;
  1186. X        idx_to_buff %= NUMLINES;
  1187. X
  1188. X        /* Erase (redraw in XOR mode) old line. */
  1189. X        n_line( buff[idx_to_buff].x1, 
  1190. X            buff[idx_to_buff].y1, 
  1191. X            buff[idx_to_buff].x2, 
  1192. X            buff[idx_to_buff].y2
  1193. X            );
  1194. X
  1195. X        /* Get coordinates of new line. */
  1196. X        if (((x1 += x1rate) < 0) || (x1 > MAXINT))  { 
  1197. X            x1rate *= -1;
  1198. X            x1 += (2 * x1rate);
  1199. X            }
  1200. X        if (((y1 += y1rate) < 0) || (y1 > MAXINT))  {
  1201. X            y1rate *= -1;
  1202. X            y1 += (2 * y1rate);
  1203. X            }
  1204. X        if (((x2 += x2rate) < 0) || (x2 > MAXINT))  {
  1205. X            x2rate *= -1;
  1206. X            x2 += (2 * x2rate);
  1207. X            }
  1208. X        if (((y2 += y2rate) < 0) || (y2 > MAXINT))  {
  1209. X            y2rate *= -1;
  1210. X            y2 += (2 * y2rate);
  1211. X            }
  1212. X
  1213. X        /* Store it in buffer. */
  1214. X        buff[idx_to_buff].x1 = x1;
  1215. X        buff[idx_to_buff].y1 = y1;
  1216. X        buff[idx_to_buff].x2 = x2;
  1217. X        buff[idx_to_buff].y2 = y2;
  1218. X
  1219. X        /* Draw new line. */
  1220. X        n_line( buff[idx_to_buff].x1, 
  1221. X            buff[idx_to_buff].y1, 
  1222. X            buff[idx_to_buff].x2, 
  1223. X            buff[idx_to_buff].y2
  1224. X            );
  1225. X    }
  1226. X}
  1227. X
  1228. Xvoid message()  {
  1229. X    /* Write a cute message every time we get a time signal. */
  1230. X
  1231. X#if MS_DOS
  1232. X#else
  1233. X    static int msg_count = 0;
  1234. X#endif /* MS_DOS */
  1235. X    int save_color;
  1236. X    int save_pix_mode;
  1237. X    save_color = g_pix_color(RED);
  1238. X    save_pix_mode = g_pix_mode(XOR);
  1239. X    c_cursor(2,2);
  1240. X    c_cellstr("Press <Del> to quit...");
  1241. X    g_pix_color(save_color);
  1242. X    g_pix_mode(save_pix_mode);
  1243. X#if MS_DOS
  1244. X#else
  1245. X    if (msg_count < MSG_COUNT)  {
  1246. X        /* Do it MSG_COUNT times, then stop. */
  1247. X        signal(SIGALRM,message);
  1248. X        alarm(1);
  1249. X        msg_count++;
  1250. X    }
  1251. X    else  {
  1252. X        /* Erase the border by redrawing it.    */
  1253. X        border();
  1254. X    }
  1255. X#endif /* MS_DOS */
  1256. X}
  1257. X
  1258. Xmain(argc,argv)
  1259. Xint argc;
  1260. Xchar *argv[];
  1261. X{
  1262. X    int mode;
  1263. X    long timeval;
  1264. X    long time();
  1265. X    struct tm *timestruct;
  1266. X    struct tm *gmtime();
  1267. X    void srand();
  1268. X
  1269. X    /* Get the mode to use. */
  1270. X
  1271. X    if (argc < 2) mode = ENV_MODE;
  1272. X    else if (argc == 2)  {
  1273. X        if (sscanf(argv[1],"%d",&(mode)) != 1)  {
  1274. X            usage(argv[0]);
  1275. X            exit (1);
  1276. X        }
  1277. X    }
  1278. X    else  {
  1279. X        usage(argv[0]);
  1280. X        exit (1);
  1281. X    }
  1282. X
  1283. X    /* Set video mode.    */
  1284. X    if (g_init(mode))  {
  1285. X        usage(argv[0]);
  1286. X        fprintf(stderr,"WARNING:  Possible invalid shared memory ",0);
  1287. X        fprintf(stderr,"key for requested video mode.\n",0);
  1288. X        exit (1);
  1289. X    }
  1290. X
  1291. X    /* Set for XOR mode. */
  1292. X    g_pix_mode(XOR);
  1293. X
  1294. X    /* Set pattern color.    */
  1295. X    g_pix_color(GREEN);
  1296. X
  1297. X    /* Draw a border and a text message. */
  1298. X    border();
  1299. X
  1300. X#if MS_DOS
  1301. X    message();
  1302. X#else
  1303. X    /* Fork and start flashing a cute message. */
  1304. X    if (fork() == 0)  {
  1305. X        /* Child process here. */
  1306. X        /* Child should exit on receipt of a SIGINT signal    */
  1307. X        signal(SIGINT, SIG_DFL);
  1308. X        /* Set a timer to post message. */
  1309. X        signal(SIGALRM,message);
  1310. X        alarm(3);
  1311. X        for(;;) pause();
  1312. X    }
  1313. X
  1314. X    /* Parent process continues here. */
  1315. X#endif /* MS_DOS */
  1316. X
  1317. X    /* Get the current time, and use it as a seed value for the     */
  1318. X    /* rand() function.                        */
  1319. X
  1320. X#if MS_DOS
  1321. X    /* Get the current time using DOS function 0x2c            */
  1322. X    inreg.AH = DOS_GET_TIME;
  1323. X    DO_BIOS(DOS, &inreg, &outreg);
  1324. X    srand((unsigned)outreg.DL);
  1325. X#else
  1326. X    timeval = time((long *) 0);
  1327. X    timestruct = gmtime(&timeval);
  1328. X    srand((unsigned)timestruct->tm_sec);
  1329. X#endif /*MS_DOS */
  1330. X
  1331. X    /* Draw the pattern.    */
  1332. X
  1333. X    pattern();
  1334. X}
  1335. XxX--EOF--XxX
  1336. echo restoring xform.c
  1337. sed 's/^X//' > xform.c <<XxX--EOF--XxX
  1338. X#ifndef lint
  1339. Xstatic char sccsid[] = "@(#) xform.c 5.1 89/02/20";
  1340. X#endif
  1341. X
  1342. X/*
  1343. X *    Copyright (c) David T. Lewis 1988
  1344. X *    All rights reserved.
  1345. X *
  1346. X *    Permission is granted to use this for any personal noncommercial use.
  1347. X *    You may not distribute source or executable code for profit, nor
  1348. X *    may you distribute it with a commercial product without the written
  1349. X *    consent of the author.  Please send modifications to the author for
  1350. X *    inclusion in updates to the program.  Thanks.
  1351. X */
  1352. X
  1353. X/* Various geometric transformations.                    */
  1354. X
  1355. X#include "config.h"
  1356. X#if MIX_C
  1357. X#else
  1358. X#include <math.h>
  1359. X#endif /* MIX_C */
  1360. X#include "bitmaps.h"
  1361. X#include "graphics.h"
  1362. X
  1363. Xextern struct GL_graphics graphics;
  1364. Xextern long longsin(), longcos();
  1365. X
  1366. X/* I_rot_2d_s rotates a point about the origin in two dimensions.    */
  1367. X/* It operates on integer values, and is used used for text rotations    */
  1368. X/* in normalized 2-D coordinate space.                    */
  1369. X/* Since this is intended for text, the y values will be scaled        */
  1370. X/* according to the value of graphics.aspect_ratio.            */
  1371. X/* Note that in this coordinate system, the angle is "backwards",    */
  1372. X/* since the origin is in the upper left of the screen.  Since we    */
  1373. X/* normally want a positive angle to appear counterclockwise on the    */
  1374. X/* screen, the angle parameter will normally be negated prior to    */
  1375. X/* calling this routine.                        */
  1376. X
  1377. Xint i_rot_2d_s(x, y, theta)
  1378. Xint *x, *y;
  1379. Xdouble theta;
  1380. X{
  1381. X
  1382. X#if NOFLOAT
  1383. X    long x_temp = (long)(*x);
  1384. X    long y_temp = (long)(*y);
  1385. X
  1386. X    /* Temporary variable is used to force explicit order of    */
  1387. X    /* integer calculations.  This probably isn't really needed    */
  1388. X    /* with most compilers, but better to be safe than sorry.    */
  1389. X
  1390. X    long ltemp;
  1391. X
  1392. X    /* Scale the (floating point) aspect ratio up to a reasonable    */
  1393. X    /* integer value.                        */
  1394. X
  1395. X    long lratio = (long)(graphics.aspect_ratio * 16.0);
  1396. X
  1397. X    /* Pre-calculate the sin and cos values (save calls to trig    */
  1398. X    /* routines.)                            */
  1399. X
  1400. X    long lsinval = longsin(theta);
  1401. X    long lcosval = longcos(theta);
  1402. X
  1403. X    ltemp = y_temp * lsinval;
  1404. X    ltemp /= 16;    /* Scale down first to avoid overflow.        */
  1405. X    ltemp *= lratio;
  1406. X
  1407. X    *x = (int)((x_temp * lcosval - ltemp) / TRIG_SCALE);
  1408. X
  1409. X    ltemp = x_temp * lsinval;
  1410. X    ltemp /= lratio;
  1411. X    ltemp *= 16;    /* Scale it back.    */
  1412. X
  1413. X    *y = (int)((ltemp + y_temp * lcosval) / TRIG_SCALE);
  1414. X
  1415. X#else
  1416. X    double x_temp = (double)(*x);
  1417. X    double y_temp = (double)(*y);
  1418. X
  1419. X    /* Pre-calculate the sin and cos values (save calls to trig    */
  1420. X    /* routines.)                            */
  1421. X
  1422. X    double sinval = sin(theta);
  1423. X    double cosval = cos(theta);
  1424. X
  1425. X    *x = (int)(x_temp * cosval
  1426. X        - y_temp * sinval * graphics.aspect_ratio);
  1427. X    *y = (int)(x_temp * sinval / graphics.aspect_ratio
  1428. X        + y_temp * cosval);
  1429. X
  1430. X#endif /* NOFLOAT */
  1431. X
  1432. X    return(0);
  1433. X}
  1434. X
  1435. X/* I_rot_2d rotates a point about the origin in two dimensions.    */
  1436. X/* It operates on integer values, and is used used for rotations in    */ 
  1437. X/* normalized 2-D coordinate space.                    */
  1438. X/* Note that in this coordinate system, the angle is "backwards",    */
  1439. X/* since the origin is in the upper left of the screen.  Since we    */
  1440. X/* normally want a positive angle to appear counterclockwise on the    */
  1441. X/* screen, the angle parameter will normally be negated prior to    */
  1442. X/* calling this routine.                        */
  1443. X/* This routine does not account for aspect ratio.            */
  1444. X
  1445. Xint i_rot_2d(x, y, theta)
  1446. Xint *x, *y;
  1447. Xdouble theta;
  1448. X{
  1449. X
  1450. X#if NOFLOAT
  1451. X    long x_temp = (long)(*x);
  1452. X    long y_temp = (long)(*y);
  1453. X
  1454. X    /* Pre-calculate the sin and cos values (save calls to trig    */
  1455. X    /* routines.)                            */
  1456. X
  1457. X    long lsinval = longsin(theta);
  1458. X    long lcosval = longcos(theta);
  1459. X
  1460. X    *x = (int)((x_temp * lcosval - y_temp * lsinval)
  1461. X        /TRIG_SCALE);
  1462. X    *y = (int)((x_temp * lsinval + y_temp * lcosval)
  1463. X        /TRIG_SCALE);
  1464. X#else
  1465. X    double x_temp = (double)(*x);
  1466. X    double y_temp = (double)(*y);
  1467. X
  1468. X    /* Pre-calculate the sin and cos values (save calls to trig    */
  1469. X    /* routines.)                            */
  1470. X
  1471. X    double sinval = sin(theta);
  1472. X    double cosval = cos(theta);
  1473. X
  1474. X    *x = (int)(x_temp * cosval - y_temp * sinval);
  1475. X    *y = (int)(x_temp * sinval + y_temp * cosval);
  1476. X#endif /* NOFLOAT */
  1477. X
  1478. X    return(0);
  1479. X}
  1480. X
  1481. X
  1482. XxX--EOF--XxX
  1483.  
  1484.  
  1485.