home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume18 / gl_plot / part02 < prev    next >
Text File  |  1989-03-23  |  35KB  |  1,425 lines
  1. Subject:  v18i060:  GL Graphics Library for AT-clone Unix, Part02/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 60
  8. Archive-name: gl_plot/part02
  9.  
  10. # To recover, type "sh archive"
  11. echo restoring Makefile
  12. sed 's/^X//' > Makefile <<XxX--EOF--XxX
  13. X
  14. X# @(#) Makefile 5.1 89/02/20
  15. X
  16. X# Makefile for UNIX, Xenix, and MS-DOS compiled under Xenix.
  17. X#
  18. X# Edit the config.h file for your system before running make.
  19. X# Uncomment the CFLAGS, LIBS and EXE_SUFFIX defines (below) for your 
  20. X# system, by removing the "# " in front of the lines that apply to your
  21. X# system.
  22. X#
  23. X# Run "make" to build the GL library and demo programs.
  24. X# Follow instructions in the INSTALL file before running demos.
  25. X
  26. X# ===> BEGINNING OF USER CONFIGURATIONS <===
  27. X
  28. X# Compiler flags:
  29. X#
  30. X# For Microport 286, use:
  31. XCFLAGS = -Ml -O 
  32. X# For Xenix 286, use:
  33. X# (Warning:  uSoft optimizer may mess you up; don't use it...)
  34. X# CFLAGS = -Ml -Me
  35. X# For Xenix 286 cross compile to MS-DOS target, use:
  36. X# CFLAGS = -Ml -Me -dos
  37. X
  38. X# Link library flags:
  39. X#
  40. X# For UNIX, use the math library:
  41. XLIBS = -lm
  42. X# For MS-DOS target, no math library needed:
  43. X# LIBS = 
  44. X
  45. X# Suffix to stick on the end of the executable program:
  46. X#
  47. X# For UNIX, no suffix:
  48. XEXE_SUFFIX=
  49. X# For MS-DOS target, executables are called *.EXE:
  50. X# EXE_SUFFIX=.exe
  51. X
  52. X# ===> END OF USER CONFIGURATIONS <===
  53. X
  54. XHDR = bitmaps.h cellfont.h config.h font.h graphics.h modes.h gl.h gf_types.h
  55. X
  56. XOBJ = g_clear.o n_mvpen.o n_draw.o n_box.o n_line.o p_wr_pix.o g_init.o n_gfchar.o n_gfstr.o g_finish.o c_cellch.o c_cellst.o c_cursor.o g_pixctl.o n_curves.o n_point.o plot.o g_fntctl.o xform.o trig.o machdep.o g_print.o
  57. X
  58. X# Default make operations, for Microport System V/AT
  59. Xuport:    gl.a demo xdemo modeprog 
  60. X
  61. X# Make operations for Xenix 286
  62. Xxenix:    gl.a demo xdemo 
  63. X
  64. X# Make operations for Xenix cross compile to MS-DOS target
  65. Xdos:    gl.a demo xdemo 
  66. X
  67. Xclean:
  68. X    rm \$(OBJ)
  69. X    rm mode.o setmode.o
  70. X    rm demo.o testpat.o xdemo.o
  71. X
  72. Xclobber:
  73. X    rm modeprog demo xdemo gl.a
  74. X    rm \$(OBJ)
  75. X    rm mode.o setmode.o
  76. X    rm demo.o testpat.o xdemo.o
  77. X
  78. Xmodeprog:    mode.c setmode.c 
  79. X    cc -o modeprog\$(EXE_SUFFIX) mode.c setmode.c
  80. X    chmod +x mode.sh
  81. X    #
  82. X    # If you have an EGA or CGA, you can use mode.sh instead of
  83. X    # the mode.c program (mv mode.sh mode)."  If you have an Everex
  84. X    # Edge, use mode.c (mv modeprog mode).  For other adapters, you 
  85. X    # may have to modify mode.c.  A slightly modified version of
  86. X    # mode.c may be required for standard hercules graphics.
  87. X    #
  88. X    # For Xenix 286, use mode.xenix (edit to taste).
  89. X    #
  90. X    # If you use mode.c, you must make the executable (mode) suid and 
  91. X    # owned by root.  Put it in a safe path, of course.
  92. X    # For example, sign as root, then:
  93. X    #
  94. X    #   \$ mv modeprog /usr/bin/mode
  95. X    #   \$ chmod 4555 /usr/bin/mode
  96. X    #
  97. X    # Don't forget to create your video shared memory using shmcreate(1)
  98. X    # (Microport only).  This should be in your /etc/rc.d/shm.rc file.
  99. X    #
  100. X    # Try running demo and xdemo to see how things work.
  101. X
  102. Xgl.a:    \$(OBJ) $(HDR)
  103. X    ar rv gl.a \$(OBJ)
  104. X    sh -c "if test -x /usr/bin/ranlib -o -x /bin/ranlib;then ranlib gl.a;fi"
  105. X
  106. Xdemo:    demo.o testpat.o gl.a
  107. X    cc -o demo\$(EXE_SUFFIX) $(CFLAGS) demo.o testpat.o gl.a $(LIBS)
  108. X
  109. Xxdemo:    xdemo.o gl.a
  110. X    cc -o xdemo\$(EXE_SUFFIX) $(CFLAGS) xdemo.o gl.a $(LIBS)
  111. X
  112. XxX--EOF--XxX
  113. echo restoring g_finish.c
  114. sed 's/^X//' > g_finish.c <<XxX--EOF--XxX
  115. X#ifndef lint
  116. Xstatic char sccsid[] = "@(#) g_finish.c 5.1 89/02/20";
  117. X#endif
  118. X
  119. X/*
  120. X *    Copyright (c) David T. Lewis 1987, 1988
  121. X *    All rights reserved.
  122. X *
  123. X *    Permission is granted to use this for any personal noncommercial use.
  124. X *    You may not distribute source or executable code for profit, nor
  125. X *    may you distribute it with a commercial product without the written
  126. X *    consent of the author.  Please send modifications to the author for
  127. X *    inclusion in updates to the program.  Thanks.
  128. X */
  129. X
  130. X
  131. X/* Wed Feb 10 20:58:37 EST 1988                        */
  132. X/* Detach shared memory and do any other clean up chores.        */
  133. X/* If printing, the print job is dispatched to the print spooler.    */
  134. X/* This routine is specific to Microport System V/AT, and presumes     */
  135. X/* that shared memory segments have been defined (usually at system     */
  136. X/* boot time) such that    the shared memory keys are "B8000L" for CGA     */
  137. X/* adapter, and so on. */
  138. X
  139. X#define MODULE "g_finish"
  140. X
  141. X#include "config.h"
  142. X#include <stdio.h>
  143. X#if MIX_C
  144. X#else
  145. X#include <sys/types.h>
  146. X#include <string.h>
  147. X#if TCC
  148. X#else
  149. X#include <malloc.h>
  150. X#endif /* TCC */
  151. X#endif /* MIX_C */
  152. X#if MS_DOS
  153. Xextern int g_setmod();
  154. Xextern int g_text;
  155. X#else
  156. X#include <sys/ipc.h>
  157. X#endif /* MS_DOS */
  158. X#if HAS_SIG
  159. X#include <signal.h>
  160. X#endif /* HAS_SIG */
  161. X#include "bitmaps.h"
  162. X#include "graphics.h"
  163. X#include "modes.h"
  164. X
  165. Xextern struct GL_graphics graphics;
  166. Xextern int errno;
  167. Xextern int g_clear();
  168. Xextern char *getenv();
  169. X#if HAS_SIG
  170. Xextern SIG_TYPE (*gl_last_int_handler)();
  171. X#endif /* HAS_SIG */
  172. X
  173. Xstatic FILE *fhandle;
  174. X
  175. Xextern int IBM_send_print();
  176. Xextern int LJ_send_print();
  177. X
  178. Xstatic int open_print()
  179. X{
  180. X    char printprog[60];
  181. X    char *envptr;
  182. X    int istat;
  183. X    /* Open a pipe to the print spooler (or straight to printer)    */
  184. X
  185. X    /* Use the environment variable PLOTDEV if set. */
  186. X
  187. X    strcpy(printprog, PRINTPROG);
  188. X    strcat(printprog, " ");
  189. X    strcat(printprog, LP_DEV_FLAG);
  190. X#if HAS_ENV
  191. X    if ((envptr = getenv(GL_PLOT_DEV)) != NULL)  {
  192. X        strcat(printprog, envptr);
  193. X    }
  194. X    else  {
  195. X        strcat(printprog, PRINTDEV);
  196. X    }
  197. X#else
  198. X    /* Some systems do not understand getenv()    */
  199. X    strcat(printprog, PRINTDEV);
  200. X#endif /* HAS_ENV */
  201. X
  202. X#if HAS_PIPES    /* Pipe to a print spooler program.            */
  203. X    if ((fhandle = popen(printprog, "w")) == NULL)  {
  204. X        fprintf(stderr, "%s:  Error piping to %s\n", MODULE,printprog);
  205. X        return(1); 
  206. X    }
  207. X#else        /* No pipes; write directly to the printer device.    */
  208. X#if HAS_STDPRN    /* Use predefined value of "stdprn"            */
  209. X    fhandle = stdprn;    
  210. X#else        /* Hope that stream I/O works for the printer device    */
  211. X    if ((fhandle = fopen(DOSPRINTER, "w")) == NULL)  {
  212. X        fprintf(stderr, "%s:  Error opening %s\n", MODULE,DOSPRINTER);
  213. X        return(1); 
  214. X    }
  215. X#endif /* HAS_STDPRN */
  216. X#endif /* HAS_PIPES */
  217. X    return(0);
  218. X}
  219. X
  220. Xstatic int close_print()
  221. X{
  222. X    int istat;
  223. X#if HAS_PIPES
  224. X    if ((istat=pclose(fhandle)) < 0) return(istat);
  225. X#else    /* No pipe to close, but close the stream to printer if open    */
  226. X#if HAS_STDPRN    /* Don't need to do anything -- stdprn stays open    */
  227. X#else        /* Close the stream pointing at the printer        */
  228. X    if ((istat=fclose(fhandle)) < 0) return(istat);
  229. X#endif /* HAS_STDPRN */
  230. X#endif /* HAS_PIPES */
  231. X    return(0);
  232. X}
  233. X
  234. Xint g_finish()
  235. X{
  236. X    int istat;
  237. X
  238. X    graphics.initialized = FALSE;
  239. X
  240. X#if HAS_SIG
  241. X#if DO_CLEANUP
  242. X    /* Restore the SIGINT signal handler that was in effect prior    */
  243. X    /* to the call to g_init().                    */
  244. X    signal(SIGINT, gl_last_int_handler);
  245. X#endif /* DO_CLEANUP */
  246. X#endif /* HAS_SIG */
  247. X
  248. X    switch (graphics.grafmode)  {
  249. X
  250. X        case CGA_HI_RES_MODE:
  251. X            /* Erase graphics memory.        */
  252. X            if (g_clear()) return(1);
  253. X            /* Detach the shared memory segment.    */
  254. X#if SVAT
  255. X            if (shmdt(graphics.cgamem) < 0) return(errno);
  256. X#endif /* SVAT */
  257. X            break;
  258. X
  259. X        case CGA_COLOR_MODE:
  260. X            /* Erase graphics memory.        */
  261. X            if (g_clear()) return(1);
  262. X            /* Detach the shared memory segment.    */
  263. X#if SVAT
  264. X            if (shmdt(graphics.cgamem) < 0) return(errno);
  265. X#endif /* SVAT */
  266. X            break;
  267. X
  268. X        case EGA_COLOR_MODE:
  269. X            /* Erase graphics memory.        */
  270. X            if (g_clear()) return(1);
  271. X            /* Detach the shared memory segment.    */
  272. X#if SVAT
  273. X            if (shmdt(graphics.egamem) < 0) return(errno);
  274. X#endif /* SVAT */
  275. X            break;
  276. X
  277. X        case HERC_P0_MODE:
  278. X        case HERC_P1_MODE:
  279. X            /* Erase graphics memory.        */
  280. X            if (g_clear()) return(1);
  281. X            /* Detach the shared memory segment.    */
  282. X#if SVAT
  283. X            if (shmdt(graphics.hercmem) < 0) return(errno);
  284. X#endif /* SVAT */
  285. X            break;
  286. X
  287. X        case IBM_PRINTER:
  288. X
  289. X            /* Print the buffer */
  290. X            if ((istat=open_print()) !=0) return(istat);
  291. X            if ((istat=IBM_send_print(fhandle)) !=0) return(istat);
  292. X            if ((istat=close_print()) !=0) return(istat);
  293. X
  294. X            /* Free the allocated memory. */
  295. X            free(graphics.printbuf1);
  296. X            free(graphics.printbuf2);
  297. X            free(graphics.printbuf3);
  298. X
  299. X            break;
  300. X
  301. X        case LJ_PRINTER:
  302. X
  303. X            /* Print the buffer */
  304. X            if ((istat=open_print()) !=0) return(istat);
  305. X            if ((istat=LJ_send_print(fhandle)) !=0) return(istat);
  306. X            if ((istat=close_print()) !=0) return(istat);
  307. X
  308. X            /* Free the allocated memory. */
  309. X            free(graphics.lj_buf1);
  310. X            free(graphics.lj_buf2);
  311. X            free(graphics.lj_buf3);
  312. X
  313. X            break;
  314. X
  315. X        default:
  316. X            return(1);
  317. X    }
  318. X
  319. X    /* Tell the hardware to go back to default (text) mode, using    */
  320. X    /* the MODEPROG program.  The default action of the mode    */
  321. X    /* program is assumed to be text mode.                */
  322. X
  323. X    if (graphics.grafmode <= MAXVIDEO)  {
  324. X#if MS_DOS
  325. X        g_setmod(g_text);
  326. X#else
  327. X        system(MODEPROG);
  328. X#endif /* MS_DOS */
  329. X    }
  330. X
  331. X    return(0);
  332. X}
  333. X
  334. X
  335. XxX--EOF--XxX
  336. echo restoring g_print.c
  337. sed 's/^X//' > g_print.c <<XxX--EOF--XxX
  338. X#ifndef lint
  339. Xstatic char sccsid[] = "@(#) g_print.c 5.1 89/02/20";
  340. X#endif
  341. X
  342. X/*
  343. X *    Copyright (c) David T. Lewis 1987, 1988, 1989
  344. X *    All rights reserved.
  345. X *
  346. X *    Permission is granted to use this for any personal noncommercial use.
  347. X *    You may not distribute source or executable code for profit, nor
  348. X *    may you distribute it with a commercial product without the written
  349. X *    consent of the author.  Please send modifications to the author for
  350. X *    inclusion in updates to the program.  Thanks.
  351. X */
  352. X
  353. X/* Sat Feb 18 15:54:14 EST 1989                        */
  354. X/* Printer specific code.                        */
  355. X
  356. X#include <stdio.h>
  357. X#include "config.h"
  358. X#if MS_DOS
  359. X#include <stdlib.h>
  360. X#endif /* MS_DOS */
  361. X#if XENIX_286
  362. X#include <sys/fcntl.h>
  363. X#include <sys/machdep.h>
  364. X#include <sys/sysmacros.h>
  365. X#endif /* XENIX_286 */
  366. X#include "bitmaps.h"
  367. X#include "gf_types.h"
  368. X#include "graphics.h"
  369. X#include "modes.h"
  370. X
  371. X/* Use BIOS output for printer on MS-DOS.    */
  372. X#if MS_DOS
  373. Xextern int bios_print();
  374. X#define FWRITE(a,b,c,d) bios_print(a,b,c)
  375. X#else
  376. X#define FWRITE(a,b,c,d) fwrite(a,b,c,d)
  377. X#endif /* MS_DOS */
  378. X
  379. Xextern struct GL_graphics graphics;
  380. X
  381. X#define FORM_FEED (014)
  382. X
  383. X#define EPSON_START_GRAPHICS 033, 'A', 07, 033, 02
  384. X#define IBM_START_GRAPHICS 033, '1'
  385. X#define IBM_PAGE_END 033, 'A', 014, 033, 02
  386. X#define IBM_LINE_START 033, 'L', 0300, 03
  387. X#define IBM_LINE_END 015, 012
  388. X
  389. Xstatic char IBM_pg_top[] = {EPSON_START_GRAPHICS, IBM_START_GRAPHICS};
  390. Xstatic char IBM_pg_end[] = {IBM_PAGE_END};
  391. Xstatic char IBM_pg_ff_end[] = {IBM_PAGE_END, FORM_FEED};
  392. Xstatic char IBM_ln_start[] = {IBM_LINE_START};
  393. Xstatic char IBM_ln_end[] = {IBM_LINE_END};
  394. X
  395. X#define LJ_RESET 033, 'E'
  396. X#define LJ_150_DPI 033, '*', 't', '1', '5', '0', 'R'    /* 150 dpi graphics */
  397. X#define LJ_CUR_HOME 033, '&', 'a', '3', 'C'          /* Cursor to column 3 */
  398. X#define LJ_START_GRAPHICS 033, '*', 'r', '1', 'A'
  399. X#define LJ_XFER_GRAPHICS 033, '*', 'b', '1', '4', '0', 'W'     /* 140 bytes */
  400. X#define LJ_END_GRAPHICS 033, '*', 'r', 'B'
  401. X
  402. Xstatic char LJ_pg_top[]={LJ_RESET, LJ_150_DPI, LJ_CUR_HOME, LJ_START_GRAPHICS};
  403. Xstatic char LJ_pg_end[] = {LJ_END_GRAPHICS, LJ_RESET};
  404. Xstatic char LJ_pg_ff_end[] = {LJ_END_GRAPHICS, LJ_RESET};
  405. Xstatic char LJ_ln_start[] = {LJ_XFER_GRAPHICS};
  406. Xstatic char LJ_ln_end[] = {0};    /* No line end needed */
  407. X
  408. X/* A do-nothing function.  The printer function pointers will initially    */
  409. X/* point to this, just to avoid core dumps later on.            */
  410. X
  411. Xstatic int null_function(fp)
  412. XFILE *fp;
  413. X{
  414. X    return(0);
  415. X}
  416. X
  417. X/* For printers, the following four functions send data required to    */
  418. X/* start the print, end the print, start each line, and end each line.    */
  419. X/* These function pointers are defined globally here, and are used to    */
  420. X/* send data to printers in g_finish().  These are initialized to a    */
  421. X/* safe value now, and set to the appropriate values for the current    */
  422. X/* graphics mode later in g_init().                    */
  423. X
  424. Xint (*pr_head)() = null_function;
  425. Xint (*pr_tail)() = null_function;
  426. Xint (*pr_lnst)() = null_function;
  427. Xint (*pr_lnend)() = null_function;
  428. X
  429. X/* Following is the device specific code for each printer (sorry, there    */
  430. X/* is only one working so far, but I like to plan ahead).        */
  431. X
  432. X/* Start of IBM or Epson compatible dot matrix printer code.        */
  433. X
  434. Xint IBM_head(fp)
  435. XFILE *fp;
  436. X{
  437. X    /* Begin graphics mode; set line spacing    */
  438. X    if((FWRITE(IBM_pg_top,sizeof(char),sizeof(IBM_pg_top),fp)) <
  439. X        sizeof(IBM_pg_top)) return(1);
  440. X    else return(0);
  441. X}
  442. X
  443. Xint IBM_tail(fp)
  444. XFILE *fp;
  445. X{
  446. X    /* End of page, begin text mode                    */
  447. X#if HAS_PIPES
  448. X    if((FWRITE(IBM_pg_end,sizeof(char),sizeof(IBM_pg_end),fp)) <
  449. X        sizeof(IBM_pg_end)) return(1);
  450. X    else return(0);
  451. X#else
  452. X    /* If we are not piping to a print spooler program, then we    */
  453. X    /* need to supply our own form feed command.            */
  454. X    if((FWRITE(IBM_pg_ff_end,sizeof(char),sizeof(IBM_pg_ff_end),fp)) <
  455. X        sizeof(IBM_pg_ff_end)) return(1);
  456. X    else return(0);
  457. X#endif /* HAS_PIPES */
  458. X}
  459. X
  460. Xint IBM_lnst(fp)
  461. XFILE *fp;
  462. X{
  463. X    /* Start a line of graphics data    */
  464. X    if((FWRITE(IBM_ln_start,sizeof(char),sizeof(IBM_ln_start),fp)) <
  465. X        sizeof(IBM_ln_start)) return(1);
  466. X    else return(0);
  467. X}
  468. X
  469. Xint IBM_lnend(fp)
  470. XFILE *fp;
  471. X{
  472. X    /* End line of graphics data        */
  473. X    if((FWRITE(IBM_ln_end,sizeof(char),sizeof(IBM_ln_end),fp)) <
  474. X        sizeof(IBM_ln_end)) return(1);
  475. X    else return(0);
  476. X}
  477. X
  478. Xint IBM_send_print(fp)
  479. XFILE *fp;
  480. X#define MODULE "IBM_send_print"
  481. X{
  482. X    int idx;
  483. X
  484. X    /* Dump the print image to the file    */
  485. X
  486. X    /* Set line feed pitch for graphics    */
  487. X
  488. X    (*pr_head)(fp);
  489. X
  490. X    /* Write the lines of data (3 buffers full) */
  491. X    for (idx=0; idx<PRINTLINES; idx++)  {
  492. X        (*pr_lnst)(fp);
  493. X        FWRITE(&(graphics.printbuf1->buf[idx][0]),
  494. X            sizeof(char), PRINTDENSITY, fp);
  495. X        (*pr_lnend)(fp);
  496. X    }
  497. X    for (idx=0; idx<PRINTLINES; idx++)  {
  498. X        (*pr_lnst)(fp);
  499. X        FWRITE(&(graphics.printbuf2->buf[idx][0]),
  500. X            sizeof(char), PRINTDENSITY, fp);
  501. X        (*pr_lnend)(fp);
  502. X    }
  503. X    for (idx=0; idx<PRINTLINES; idx++)  {
  504. X        (*pr_lnst)(fp);
  505. X        FWRITE(&(graphics.printbuf3->buf[idx][0]),
  506. X            sizeof(char), PRINTDENSITY, fp);
  507. X        (*pr_lnend)(fp);
  508. X    }
  509. X
  510. X    /* Set line feed pitch back for text    */
  511. X
  512. X    if ((*pr_tail)(fp))  {
  513. X        fprintf(stderr,"%s: unable to write to printer\n",MODULE);
  514. X        return(1);
  515. X    }
  516. X    return(0);
  517. X}
  518. X
  519. X/* End of IBM or Epson compatible dot matrix printer code.        */
  520. X
  521. X
  522. X/* Start of Laserjet+ printer code.        */
  523. X
  524. Xint LJ_head(fp)
  525. XFILE *fp;
  526. X{
  527. X    /* Begin graphics mode; set line spacing    */
  528. X    if((FWRITE(LJ_pg_top,sizeof(char),sizeof(LJ_pg_top),fp)) <
  529. X        sizeof(LJ_pg_top)) return(1);
  530. X    else return(0);
  531. X}
  532. X
  533. Xint LJ_tail(fp)
  534. XFILE *fp;
  535. X{
  536. X    /* End of page, reset and eject page    */
  537. X    if((FWRITE(LJ_pg_end,sizeof(char),sizeof(LJ_pg_end),fp)) <
  538. X        sizeof(LJ_pg_end)) return(1);
  539. X    else return(0);
  540. X}
  541. X
  542. Xint LJ_lnst(fp)
  543. XFILE *fp;
  544. X{
  545. X    /* Start a line of graphics data    */
  546. X    if((FWRITE(LJ_ln_start,sizeof(char),sizeof(LJ_ln_start),fp)) <
  547. X        sizeof(LJ_ln_start)) return(1);
  548. X    else return(0);
  549. X}
  550. X
  551. Xint LJ_lnend(fp)
  552. XFILE *fp;
  553. X{
  554. X    /* End line of graphics data        */
  555. X    return(0);
  556. X}
  557. X
  558. Xint LJ_send_print(fp)
  559. XFILE *fp;
  560. X#undef MODULE
  561. X#define MODULE "LJ_send_print"
  562. X{
  563. X    int idx;
  564. X
  565. X    /* Dump the print image to the file    */
  566. X
  567. X    /* Start page of graphics */
  568. X
  569. X    (*pr_head)(fp);
  570. X
  571. X    /* Write the lines of data (3 buffers full) */
  572. X    for (idx=0; idx<LJ_LINES; idx++)  {
  573. X        (*pr_lnst)(fp);
  574. X        FWRITE(&(graphics.lj_buf1->buf[idx][0]),
  575. X            sizeof(char), LJ_BYTES_PER_LINE, fp);
  576. X        (*pr_lnend)(fp);
  577. X    }
  578. X    for (idx=0; idx<LJ_LINES; idx++)  {
  579. X        (*pr_lnst)(fp);
  580. X        FWRITE(&(graphics.lj_buf2->buf[idx][0]),
  581. X            sizeof(char), LJ_BYTES_PER_LINE, fp);
  582. X        (*pr_lnend)(fp);
  583. X    }
  584. X    for (idx=0; idx<LJ_LINES; idx++)  {
  585. X        (*pr_lnst)(fp);
  586. X        FWRITE(&(graphics.lj_buf3->buf[idx][0]),
  587. X            sizeof(char), LJ_BYTES_PER_LINE, fp);
  588. X        (*pr_lnend)(fp);
  589. X    }
  590. X
  591. X    /* End of page */
  592. X
  593. X    if ((*pr_tail)(fp))  {
  594. X        fprintf(stderr,"%s: unable to write to printer\n",MODULE);
  595. X        return(1);
  596. X    }
  597. X    return(0);
  598. X}
  599. X
  600. X/* End of Laserjet+ printer code.        */
  601. X
  602. X
  603. XxX--EOF--XxX
  604. echo restoring mode.c
  605. sed 's/^X//' > mode.c <<XxX--EOF--XxX
  606. X#ifndef lint
  607. Xstatic char sccsid[] = "@(#) mode.c 5.1 89/02/20";
  608. X#endif
  609. X
  610. X/*
  611. X *    Copyright (c) David T. Lewis 1987, 1988
  612. X *    All rights reserved.
  613. X *
  614. X *    Permission is granted to use this for any personal noncommercial use.
  615. X *    You may not distribute source or executable code for profit, nor
  616. X *    may you distribute it with a commercial product without the written
  617. X *    consent of the author.  Please send modifications to the author for
  618. X *    inclusion in updates to the program.  Thanks.
  619. X */
  620. X
  621. X/* dtlewis 7-13-1987 
  622. X** Take command line argument to set graphics mode.  If no argument, then
  623. X** read standard input until end of file.
  624. X*/
  625. X
  626. X#define NORMAL_MODE 2
  627. X
  628. X#include <stdio.h>
  629. X#include "config.h"
  630. X
  631. Xmain(argc,argv) 
  632. Xint argc;
  633. Xchar *argv[];
  634. X{
  635. X    int setmode();
  636. X    int modevalue, stat;
  637. X    char *inbuf[20];
  638. X
  639. X    if (argc > 2) {
  640. X        printf("Usage:  mode n\n");
  641. X        exit(0);
  642. X    }
  643. X
  644. X    else if (argc == 2)  {
  645. X        if (sscanf(argv[1],"%d",&modevalue) != 1)  {
  646. X            printf("Unknown mode %s\n",argv[1]);
  647. X            exit(1);
  648. X        }
  649. X        setmode(modevalue);
  650. X    }
  651. X    else if (argc == 1)  {
  652. X#ifdef DEBUG
  653. X        for ( ; ; ) {
  654. X            stat=scanf("%d", &modevalue);
  655. X            if (stat == EOF) exit(0);
  656. X            /* Clear input stream if bad read. */
  657. X            if (stat == 0) gets(inbuf, 20, stdin); 
  658. X            if (stat == 1 && modevalue >= 0 && modevalue <=11) 
  659. X                setmode(modevalue);
  660. X            }
  661. X#endif /* DEBUG */
  662. X        setmode(NORMAL_MODE);
  663. X        }
  664. X    }
  665. XxX--EOF--XxX
  666. echo restoring msc.mak
  667. sed 's/^X//' > msc.mak <<XxX--EOF--XxX
  668. X
  669. X# @(#) msc.mak 5.1 89/02/20
  670. X
  671. X# Makefile for MS-DOS with Microsoft C and the Microsoft "make" utility.
  672. X# Use the command "make msc.mak" to build the system.
  673. X#
  674. X# Edit the config.h file for your system before running make.
  675. X# Run "make" to build the GL library and demo programs.
  676. X# Follow instructions in the INSTALL file before running demos.
  677. X
  678. XCC = msc
  679. X# Note:  Do NOT use the optimizer!  You must compile with the "/Od" switch.
  680. XCFLAGS = /AL /Od
  681. XLIB = lib
  682. X
  683. XHDR = bitmaps.h cellfont.h config.h font.h graphics.h modes.h gl.h gf_types.h
  684. X
  685. XOBJ1= g_clear.obj n_mvpen.obj n_draw.obj n_box.obj n_line.obj p_wr_pix.obj 
  686. XOBJ2= n_gfchar.obj n_gfstr.obj g_finish.obj c_cellch.obj c_cellst.obj 
  687. XOBJ3= c_cursor.obj g_pixctl.obj n_curves.obj n_point.obj plot.obj g_fntctl.obj 
  688. XOBJ4= xform.obj trig.obj machdep.obj g_init.obj g_print.obj
  689. X
  690. X.c.obj:
  691. X    \$(CC) $(CFLAGS) $*.c;
  692. X    \$(LIB) gl.lib -+$*.obj;
  693. X
  694. Xgl.lib:    \$(OBJ1) $(OBJ2) $(OBJ3) $(OBJ4) $(HDR)
  695. X    \$(LIB) gl.lib;
  696. X
  697. Xdemo.obj:    demo.c \$(HDR)
  698. X    \$(CC) $(CFLAGS) $*.c;
  699. X
  700. Xtestpat.obj:    testpat.c \$(HDR)
  701. X    \$(CC) $(CFLAGS) $*.c;
  702. X
  703. Xxdemo.obj:    xdemo.c \$(HDR)
  704. X    \$(CC) $(CFLAGS) $*.c;
  705. X
  706. Xg_clear.obj:    g_clear.c \$(HDR) 
  707. X
  708. Xn_mvpen.obj:    n_mvpen.c \$(HDR)
  709. X
  710. Xn_draw.obj:    n_draw.c \$(HDR)
  711. X
  712. Xn_box.obj:    n_box.c \$(HDR)
  713. X
  714. Xn_line.obj:    n_line.c \$(HDR)
  715. X
  716. Xp_wr_pix.obj:    p_wr_pix.c \$(HDR)
  717. X
  718. Xn_gfchar.obj:    n_gfchar.c \$(HDR)
  719. X
  720. Xn_gfstr.obj:    n_gfstr.c \$(HDR)
  721. X
  722. Xg_finish.obj:    g_finish.c \$(HDR)
  723. X
  724. Xc_cellch.obj:    c_cellch.c \$(HDR)
  725. X
  726. Xc_cellst.obj:    c_cellst.c \$(HDR)
  727. X
  728. Xc_cursor.obj:    c_cursor.c \$(HDR)
  729. X
  730. Xg_pixctl.obj:    g_pixctl.c \$(HDR)
  731. X
  732. Xn_curves.obj:    n_curves.c \$(HDR)
  733. X
  734. Xn_point.obj:    n_point.c \$(HDR)
  735. X
  736. Xplot.obj:    plot.c \$(HDR)
  737. X
  738. Xg_fntctl.obj:    g_fntctl.c \$(HDR)
  739. X
  740. Xxform.obj:    xform.c \$(HDR)
  741. X
  742. Xtrig.obj:    trig.c \$(HDR)
  743. X
  744. Xmachdep.obj:    machdep.c \$(HDR)
  745. X
  746. Xg_print.obj:    g_print.c \$(HDR)
  747. X
  748. Xg_init.obj:    g_init.c \$(HDR)
  749. X
  750. Xdemo.exe:    demo.obj testpat.obj gl.lib
  751. X    link demo.obj testpat.obj,demo.exe,,gl.lib;
  752. X
  753. Xxdemo.exe:    demo.obj testpat.obj gl.lib
  754. X    link xdemo.obj ,xdemo.exe,,gl.lib;
  755. X
  756. X
  757. XxX--EOF--XxX
  758. echo restoring n_mvpen.c
  759. sed 's/^X//' > n_mvpen.c <<XxX--EOF--XxX
  760. X#ifndef lint
  761. Xstatic char sccsid[] = "@(#) n_mvpen.c 5.1 89/02/20";
  762. X#endif
  763. X
  764. X/*
  765. X *    Copyright (c) David T. Lewis 1987, 1988
  766. X *    All rights reserved.
  767. X *
  768. X *    Permission is granted to use this for any personal noncommercial use.
  769. X *    You may not distribute source or executable code for profit, nor
  770. X *    may you distribute it with a commercial product without the written
  771. X *    consent of the author.  Please send modifications to the author for
  772. X *    inclusion in updates to the program.  Thanks.
  773. X */
  774. X
  775. X/* dtlewis Fri Jul  3 23:12:40 EDT 1987 
  776. X** Routine to move the logical graphics cursor to the indicated (x,y)
  777. X** position.
  778. X*/
  779. X
  780. X#include "config.h"
  781. X#include "bitmaps.h"
  782. X#include "graphics.h"
  783. X
  784. Xextern struct GL_graphics graphics;
  785. X
  786. Xint n_movepen(x,y)  
  787. X    int x,y;
  788. X{
  789. X        /* Set the graphics cursor to the indicated position. */
  790. X        /* X and y are in normalized 2-D coordinates (0 to 32767). */
  791. X
  792. X    /* Check for x or y off the screen.            */
  793. X#if INT16
  794. X    /* 16 bit integers, use simple check.            */
  795. X        if ((graphics.x_cursor = x) < 0 ) return(1);
  796. X        if ((graphics.y_cursor = y) < 0 ) return(1);
  797. X#else
  798. X    /* Use explicit check.                    */
  799. X        if (((graphics.x_cursor = x) < 0) || (x > NRM_X_RANGE)) return(1);
  800. X        if (((graphics.y_cursor = y) < 0) || (y > NRM_X_RANGE)) return(1);
  801. X#endif /* INT16 */
  802. X
  803. X    return(0);
  804. X}
  805. XxX--EOF--XxX
  806. echo restoring p_wr_pix.c
  807. sed 's/^X//' > p_wr_pix.c <<XxX--EOF--XxX
  808. X#ifndef lint
  809. Xstatic char sccsid[] = "@(#) p_wr_pix.c 5.1 89/02/20";
  810. X#endif
  811. X
  812. X/*
  813. X *    Copyright (c) David T. Lewis 1987, 1988
  814. X *    All rights reserved.
  815. X *
  816. X *    Permission is granted to use this for any personal noncommercial use.
  817. X *    You may not distribute source or executable code for profit, nor
  818. X *    may you distribute it with a commercial product without the written
  819. X *    consent of the author.  Please send modifications to the author for
  820. X *    inclusion in updates to the program.  Thanks.
  821. X */
  822. X
  823. X#include "config.h"
  824. X#include "bitmaps.h"
  825. X#include "gf_types.h"
  826. X#include "graphics.h"
  827. X#include "modes.h"
  828. X
  829. X/*
  830. X *    Mon Mar 23 00:14:50 EST 1987
  831. X *    Sun Mar 13 22:21:46 EST 1988
  832. X *    system5 dtlewis 2 1.3 AT
  833. X *
  834. X *    This routine writes a pixel dot at (x,y), where x and y are
  835. X *    pixel coordinates.  Operates on bit maps defined in bitmaps.h,
  836. X *    and works for video adapter boards (direct write to screen
  837. X *    memory) or printers (write to a bitmap allocated in main memory).
  838. X */
  839. X
  840. Xextern struct GL_graphics graphics;
  841. X
  842. Xint p_wr_pix(x,y)  
  843. X    int x, y;
  844. X{
  845. X
  846. Xint row, col, page;
  847. Xunsigned char bitmask;
  848. Xregister char shiftcount;
  849. X
  850. X/* If this is MIX-C, we have small memory model only, and we can't get    */
  851. X/* a 32 bit pointer to the screen.  Therefore, cheat and use the BIOS.    */
  852. X#if MIX_C
  853. Xwritedot(y, x, graphics.color);
  854. Xreturn (0);
  855. X#endif /* MIX_C */
  856. X
  857. Xswitch (graphics.grafmode) {
  858. X
  859. X    case CGA_COLOR_MODE:
  860. X
  861. X        row = y >> 1;
  862. X        col = x >> 2;
  863. X
  864. X        /* Select a color mask, consisting of four 2 bit patterns. */
  865. X        switch (graphics.color) {
  866. X            case 0:    bitmask = 0;
  867. X                break;
  868. X            case 1: bitmask = 0x055;
  869. X                break;
  870. X            case 2: bitmask = 0x0AA;
  871. X                break;
  872. X            case 3:    bitmask = 0x0FF;
  873. X                break;
  874. X            default:bitmask = 0x0FF;
  875. X        }
  876. X
  877. X        /* Apply the color mask to the two bit pixel of interest. */
  878. X        switch (x & 0x0003)  {
  879. X            case 0:    bitmask &= PIX0;
  880. X                break;
  881. X            case 1:    bitmask &= PIX1;
  882. X                break;
  883. X            case 2:    bitmask &= PIX2;
  884. X                break;
  885. X            case 3:    bitmask &= PIX3;
  886. X                break;
  887. X        }
  888. X
  889. X        /* Write pixel to the appropriate page for this line. */
  890. X        if (y & 0x0001) 
  891. X            switch (graphics.wrt_mode)  {
  892. X                case OR:
  893. X                    (graphics.cgamem)->page2[row][col] 
  894. X                        |= bitmask;
  895. X                    break;
  896. X                case XOR:
  897. X                    (graphics.cgamem)->page2[row][col] 
  898. X                        ^= bitmask;
  899. X                    break;
  900. X            }
  901. X        else
  902. X            switch (graphics.wrt_mode)  {
  903. X                case OR:
  904. X                    (graphics.cgamem)->page1[row][col] 
  905. X                        |= bitmask;
  906. X                    break;
  907. X                case XOR:
  908. X                    (graphics.cgamem)->page1[row][col] 
  909. X                        ^= bitmask;
  910. X                    break;
  911. X            }
  912. X        break;
  913. X
  914. X    case CGA_HI_RES_MODE:
  915. X
  916. X        row = y >> 1;
  917. X        col = x >> 3;
  918. X
  919. X        bitmask = 0x80;
  920. X        shiftcount = x & 0x0007;
  921. X        bitmask = bitmask >> shiftcount;
  922. X
  923. X        if (y & 0x0001) {
  924. X            switch (graphics.wrt_mode)  {
  925. X                case OR:
  926. X                    (graphics.cgamem)->page2[row][col] 
  927. X                        |= bitmask;
  928. X                    break;
  929. X                case XOR:
  930. X                    (graphics.cgamem)->page2[row][col] 
  931. X                        ^= bitmask;
  932. X                    break;
  933. X            }
  934. X        }
  935. X        else {
  936. X            switch (graphics.wrt_mode)  {
  937. X                case OR:
  938. X                    (graphics.cgamem)->page1[row][col] 
  939. X                        |= bitmask;
  940. X                    break;
  941. X                case XOR:
  942. X                    (graphics.cgamem)->page1[row][col] 
  943. X                        ^= bitmask;
  944. X                    break;
  945. X            }
  946. X        }
  947. X        break;
  948. X
  949. X    case EGA_COLOR_MODE:
  950. X
  951. X        col = x >> 3;
  952. X
  953. X        bitmask = 0x80;
  954. X        shiftcount = x & 0x0007;
  955. X        bitmask = bitmask >> shiftcount;
  956. X
  957. X        (graphics.egamem)->mem[y][col] |= bitmask;
  958. X        break;
  959. X
  960. X    case HERC_P0_MODE:
  961. X    case HERC_P1_MODE:
  962. X
  963. X        row = y >> 2;
  964. X        col = x >> 3;
  965. X
  966. X        bitmask = 0x80 >> (x & 0x0007);
  967. X
  968. X        switch (y & 0x0003) {
  969. X
  970. X            case 0:
  971. X                switch (graphics.wrt_mode)  {
  972. X                    case OR:
  973. X                        (graphics.hercmem)
  974. X                        ->page1[row][col] 
  975. X                        |= bitmask;
  976. X                        break;
  977. X                    case XOR:
  978. X                        (graphics.hercmem)
  979. X                        ->page1[row][col] 
  980. X                        ^= bitmask;
  981. X                        break;
  982. X                }
  983. X                break;
  984. X            case 1:
  985. X                switch (graphics.wrt_mode)  {
  986. X                    case OR:
  987. X                        (graphics.hercmem)
  988. X                        ->page2[row][col] 
  989. X                        |= bitmask;
  990. X                        break;
  991. X                    case XOR:
  992. X                        (graphics.hercmem)
  993. X                        ->page2[row][col] 
  994. X                        ^= bitmask;
  995. X                        break;
  996. X                }
  997. X                break;
  998. X            case 2:
  999. X                switch (graphics.wrt_mode)  {
  1000. X                    case OR:
  1001. X                        (graphics.hercmem)
  1002. X                        ->page3[row][col] 
  1003. X                        |= bitmask;
  1004. X                        break;
  1005. X                    case XOR:
  1006. X                        (graphics.hercmem)
  1007. X                        ->page3[row][col] 
  1008. X                        ^= bitmask;
  1009. X                        break;
  1010. X                }
  1011. X                break;
  1012. X            case 3:
  1013. X                switch (graphics.wrt_mode)  {
  1014. X                    case OR:
  1015. X                        (graphics.hercmem)
  1016. X                        ->page4[row][col] 
  1017. X                        |= bitmask;
  1018. X                        break;
  1019. X                    case XOR:
  1020. X                        (graphics.hercmem)
  1021. X                        ->page4[row][col] 
  1022. X                        ^= bitmask;
  1023. X                        break;
  1024. X                }
  1025. X                break;
  1026. X        }
  1027. X        break;
  1028. X
  1029. X    case IBM_PRINTER:
  1030. X
  1031. X        col = PRINTDENSITY - y - 1;
  1032. X
  1033. X        row = (x >> 3);
  1034. X        page = 0;
  1035. X        while (row >= PRINTLINES)  {
  1036. X            row -= PRINTLINES;
  1037. X            ++page;
  1038. X        }
  1039. X
  1040. X        bitmask = 0x80 >> (x & 0x0007);
  1041. X
  1042. X        switch (page) {
  1043. X
  1044. X            case 0:    /* Page 0 */
  1045. X                switch (graphics.wrt_mode)  {
  1046. X                    case OR:
  1047. X                        (graphics.printbuf1)
  1048. X                        ->buf[row][col] 
  1049. X                        |= bitmask;
  1050. X                        break;
  1051. X                    case XOR:
  1052. X                        (graphics.printbuf1)
  1053. X                        ->buf[row][col] 
  1054. X                        ^= bitmask;
  1055. X                        break;
  1056. X                    }
  1057. X                break;
  1058. X            case 1:    /* Page 1 */
  1059. X                switch (graphics.wrt_mode)  {
  1060. X                    case OR:
  1061. X                        (graphics.printbuf2)
  1062. X                        ->buf[row][col] 
  1063. X                        |= bitmask;
  1064. X                        break;
  1065. X                    case XOR:
  1066. X                        (graphics.printbuf2)
  1067. X                        ->buf[row][col] 
  1068. X                        ^= bitmask;
  1069. X                        break;
  1070. X                    }
  1071. X                break;
  1072. X            case 2: /* Page 2 */
  1073. X                switch (graphics.wrt_mode)  {
  1074. X                    case OR:
  1075. X                        (graphics.printbuf3)
  1076. X                        ->buf[row][col] 
  1077. X                        |= bitmask;
  1078. X                        break;
  1079. X                    case XOR:
  1080. X                        (graphics.printbuf3)
  1081. X                        ->buf[row][col] 
  1082. X                        ^= bitmask;
  1083. X                        break;
  1084. X                    }
  1085. X                break;
  1086. X        }
  1087. X        break;
  1088. X
  1089. X    case LJ_PRINTER:
  1090. X
  1091. X        col = LJ_BYTES_PER_LINE - (y >> 3) - 1;
  1092. X        row = x;
  1093. X        page = 0;
  1094. X        while (row >= LJ_LINES)  {
  1095. X            row -= LJ_LINES;
  1096. X            ++page;
  1097. X        }
  1098. X
  1099. X        bitmask = 0x01 << (y & 0x0007);
  1100. X
  1101. X        switch (page) {
  1102. X
  1103. X            case 0:    /* Page 0 */
  1104. X                switch (graphics.wrt_mode)  {
  1105. X                    case OR:
  1106. X                        (graphics.lj_buf1)
  1107. X                        ->buf[row][col] 
  1108. X                        |= bitmask;
  1109. X                        break;
  1110. X                    case XOR:
  1111. X                        (graphics.lj_buf1)
  1112. X                        ->buf[row][col] 
  1113. X                        ^= bitmask;
  1114. X                        break;
  1115. X                    }
  1116. X                break;
  1117. X            case 1:    /* Page 1 */
  1118. X                switch (graphics.wrt_mode)  {
  1119. X                    case OR:
  1120. X                        (graphics.lj_buf2)
  1121. X                        ->buf[row][col] 
  1122. X                        |= bitmask;
  1123. X                        break;
  1124. X                    case XOR:
  1125. X                        (graphics.lj_buf2)
  1126. X                        ->buf[row][col] 
  1127. X                        ^= bitmask;
  1128. X                        break;
  1129. X                    }
  1130. X                break;
  1131. X            case 2: /* Page 2 */
  1132. X                switch (graphics.wrt_mode)  {
  1133. X                    case OR:
  1134. X                        (graphics.lj_buf3)
  1135. X                        ->buf[row][col] 
  1136. X                        |= bitmask;
  1137. X                        break;
  1138. X                    case XOR:
  1139. X                        (graphics.lj_buf3)
  1140. X                        ->buf[row][col] 
  1141. X                        ^= bitmask;
  1142. X                        break;
  1143. X                    }
  1144. X                break;
  1145. X        }
  1146. X        break;
  1147. X
  1148. X    default:
  1149. X        return(1);
  1150. X    }
  1151. X    return(0);
  1152. X}
  1153. XxX--EOF--XxX
  1154. echo restoring setmode.c
  1155. sed 's/^X//' > setmode.c <<XxX--EOF--XxX
  1156. X#ifndef lint
  1157. Xstatic char sccsid[] = "@(#) setmode.c 5.1 89/02/20";
  1158. X#endif
  1159. X#define MS_DOS 0
  1160. X#define UNIX 1
  1161. X/*
  1162. X *    Module    :    mode
  1163. X *    Date    :    8705.20
  1164. X *    Author    :    Jeffrey A. Turner
  1165. X *    Purpose    :    Set cga video modes (0-6) when active Unix display
  1166. X *            is an mda.  Modified to support modes 7 and 8
  1167. X *            on Everex Edge.
  1168. X *
  1169. X *    Modifications:    dtlewis 8-16-1987 Changes to support mode 7 and to
  1170. X *            support Hercules operation on an Everex Edge.
  1171. X *            Hercules 720 x 348 (page 0) is referred to as
  1172. X *            mode 8 for this routine, and Hercules page 1 is
  1173. X *            referred to as mode 9.  Note that these are for
  1174. X *            convenience, and conflict with the PCjr mode
  1175. X *            assignments, which I presume to be non-reusable
  1176. X *            and obsolete.
  1177. X *
  1178. X *            Split modeset() off from the main routine to make
  1179. X *            it callable from any program.
  1180. X *
  1181. X *            Renamed the function to setmode().
  1182. X *
  1183. X *    Useage:        int setmode(modenumber)
  1184. X *            int modenumber
  1185. X *
  1186. X *    \$Log$
  1187. X */
  1188. X
  1189. X#include <stdio.h>
  1190. X#if UNIX
  1191. X#include <sys/types.h>
  1192. X#include <sys/io_op.h>
  1193. X#endif
  1194. X
  1195. Xextern    errno;
  1196. X
  1197. Xint    fd;
  1198. X
  1199. X/* Define the mode register settings. */
  1200. Xunsigned char    creg[12] = {
  1201. X    0x2c, 0x28, 0x2d, 0x2d, 0x2a, 0x2e, 0x1e, 0x2d, 0x0e, 0x8e, 0x2d, 0x2d
  1202. X};
  1203. X/* Define the Everex extended graphics register settings */
  1204. Xunsigned char    ext_graf_reg[12] = {
  1205. X    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x06, 0x06
  1206. X};
  1207. X
  1208. Xunsigned char    params[192] = {
  1209. X/*0*/    0x38, 0x28, 0x2d, 0x0a, 0x1f, 0x06, 0x19, 0x1c,   /* 40x25 b/w */
  1210. X    0x02, 0x07, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
  1211. X
  1212. X/*1*/    0x38, 0x28, 0x2d, 0x0a, 0x1f, 0x06, 0x19, 0x1c,   /* 40x25 color */
  1213. X    0x02, 0x07, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
  1214. X
  1215. X/*2*/    0x61, 0x50, 0x52, 0x0f, 0x19, 0x06, 0x19, 0x19,      /* 80x25 b/w */
  1216. X    0x02, 0x0d, 0x0b, 0x0c, 0x00, 0x00, 0x00, 0x00,
  1217. X
  1218. X/*3*/    0x71, 0x50, 0x5a, 0x0a, 0x1f, 0x06, 0x19, 0x1c,      /* 80x25 color */
  1219. X    0x02, 0x07, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
  1220. X
  1221. X/*4*/    0x38, 0x28, 0x2d, 0x0a, 0x7f, 0x06, 0x64, 0x70,      /* 320x200 color */
  1222. X    0x02, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
  1223. X
  1224. X/*5*/    0x38, 0x28, 0x2d, 0x0a, 0x7f, 0x06, 0x64, 0x70,      /* 320x200 b/w */
  1225. X    0x02, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
  1226. X
  1227. X/*6*/    0x38, 0x28, 0x2d, 0x0a, 0x7f, 0x06, 0x64, 0x70,      /* 640x200 b/w */
  1228. X    0x02, 0x01, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
  1229. X
  1230. X/*7*/    0x61, 0x50, 0x52, 0x0f, 0x19, 0x06, 0x19, 0x19,      /* mono */
  1231. X    0x02, 0x0d, 0x0b, 0x0c, 0x00, 0x00, 0x00, 0x00,
  1232. X
  1233. X/*8*/    0x36, 0x2d, 0x2e, 0x07, 0x5a, 0x02, 0x57, 0x57,   /* Hercules 720x348 */
  1234. X    0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  1235. X
  1236. X/*9*/    0x36, 0x2d, 0x2e, 0x07, 0x5a, 0x02, 0x57, 0x57,   /* Hercules 720x348 */
  1237. X    0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  1238. X
  1239. X/*10*/    0x9a, 0x84, 0x86, 0x0f, 0x19, 0x06, 0x19, 0x19,   /* Everex 132x25b&w */
  1240. X    0x02, 0x0d, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00,
  1241. X
  1242. X/*11*/    0x9a, 0x84, 0x86, 0x0f, 0x2d, 0x02, 0x2c, 0x2c,   /* Everex 132x44b&w */
  1243. X    0x02, 0x07, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00
  1244. X};
  1245. X
  1246. Xsetmode(mode)
  1247. Xint    mode;
  1248. X{
  1249. X    int    i, j;
  1250. X    int    bport;
  1251. X    int    cgaaddr  = 0x3d4;        /* cga 6845 port address */
  1252. X    int    monoaddr = 0x3b4;        /* mda 6845 port address */
  1253. X
  1254. X#if UNIX
  1255. X    if ((fd = open("/dev/mem", 2)) < 0) {
  1256. X        fprintf(stderr, "mode: open of /dev/mem failed\n");
  1257. X        perror("mode");
  1258. X        exit(1);
  1259. X        }
  1260. X#endif
  1261. X    if ((mode == 2) | (mode == 7) | (mode == 8) | (mode == 9) |
  1262. X            (mode == 10) | (mode == 11))  {
  1263. X        /* Select mono mode on Everex Edge. */
  1264. X        bport = cgaaddr;
  1265. X        outb(bport+9, 2);        /* Extended Graphics Register */
  1266. X        bport = monoaddr;
  1267. X        }
  1268. X    else  {
  1269. X        /* Select CGA mode on Everex Edge. */
  1270. X        bport = monoaddr;
  1271. X        outb(bport+9, 0);        /* Extended Graphics Register */
  1272. X        bport = cgaaddr;
  1273. X        }
  1274. X
  1275. X    outb(bport+4, 0);            /* Reset mode register */
  1276. X
  1277. X    outb(bport+11, 0x06);            /* Enable all 64k of Everex 
  1278. X                        ** Edge video memory, for mono 
  1279. X                        ** adapter. 
  1280. X                        */
  1281. X
  1282. X    outb(bport+9, ext_graf_reg[mode]);    /* set Everex "extended 
  1283. X                        graphics register" */
  1284. X    j = (mode+1)*16;
  1285. X
  1286. X    for(i = mode*16, j = 0; j < 16; i++, j++) {
  1287. X        outb(bport, j);            /* select register */
  1288. X        outb(bport+1, params[i]);    /* send value */
  1289. X        }
  1290. X
  1291. X    outb(bport+4, creg[mode]);        /* enable */
  1292. X    if (mode == 6)
  1293. X        outb(bport+5, 0x3f);    /* set overscan for 640x200 */
  1294. X    else
  1295. X        outb(bport+5, 0x30);    /* set normal overscan */
  1296. X    close(fd);
  1297. X    return(0);
  1298. X}
  1299. X
  1300. X#if UNIX
  1301. Xoutb(portno, data)
  1302. Xint    portno;
  1303. Xint    data;
  1304. X{
  1305. X    io_op_t    iop;
  1306. X
  1307. X    iop.io_port = portno;
  1308. X    iop.io_byte = data;
  1309. X    if (ioctl(fd, IOCIOP_WB, &iop) < 0) {
  1310. X        fprintf(stderr, "mode: error on IOCIOP_WB\n");
  1311. X        perror("mode");
  1312. X        exit(1);
  1313. X    }
  1314. X}
  1315. X#endif
  1316. X
  1317. X
  1318. X#if MS_DOS
  1319. Xoutb(portno, data)
  1320. Xint portno;
  1321. Xint data;
  1322. X{
  1323. X    outp(portno,data);
  1324. X}
  1325. X#endif
  1326. X
  1327. XxX--EOF--XxX
  1328. echo restoring tcc.mak
  1329. sed 's/^X//' > tcc.mak <<XxX--EOF--XxX
  1330. X
  1331. X# @(#) tcc.mak 5.1 89/02/20
  1332. X
  1333. X# Makefile for MS-DOS with Borland Turbo-C and the Borland "make" utility.
  1334. X# Use the command "make -ftcc.mak" to build the system.
  1335. X#
  1336. X# Edit the config.h file for your system before running make.
  1337. X# Run "make" to build the GL library and demo programs.
  1338. X# Follow instructions in the INSTALL file before running demos.
  1339. X
  1340. XCC = tcc
  1341. XCFLAGS = -c -ml
  1342. XLFLAGS = -ml
  1343. XPATHS = -I\TC\INCLUDE -L\TC\LIB
  1344. XLIB = tlib
  1345. XLINK = tlink
  1346. X
  1347. XHDR = bitmaps.h cellfont.h config.h font.h graphics.h modes.h gl.h gf_types.h
  1348. X
  1349. XOBJ1= g_clear.obj n_mvpen.obj n_draw.obj n_box.obj n_line.obj p_wr_pix.obj 
  1350. XOBJ2= n_gfchar.obj n_gfstr.obj g_finish.obj c_cellch.obj c_cellst.obj 
  1351. XOBJ3= c_cursor.obj g_pixctl.obj n_curves.obj n_point.obj plot.obj g_fntctl.obj 
  1352. XOBJ4= xform.obj trig.obj machdep.obj g_init.obj g_print.obj
  1353. X
  1354. Xall:    demo.exe xdemo.exe
  1355. X
  1356. X.c.obj:
  1357. X    \$(CC) $(CFLAGS) $(PATHS) $*.c
  1358. X    \$(LIB) gl.lib -+$*.obj
  1359. X
  1360. Xgl.lib:    \$(OBJ1) $(OBJ2) $(OBJ3) $(OBJ4) $(HDR)
  1361. X    \$(LIB) gl.lib
  1362. X
  1363. Xdemo.obj:    demo.c \$(HDR)
  1364. X    \$(CC) $(CFLAGS) $(PATHS) $*.c
  1365. X
  1366. Xtestpat.obj:    testpat.c \$(HDR)
  1367. X    \$(CC) $(CFLAGS) $(PATHS) $*.c
  1368. X
  1369. Xxdemo.obj:    xdemo.c \$(HDR)
  1370. X    \$(CC) $(CFLAGS) $(PATHS) $*.c
  1371. X
  1372. Xg_clear.obj:    g_clear.c \$(HDR) 
  1373. X
  1374. Xn_mvpen.obj:    n_mvpen.c \$(HDR)
  1375. X
  1376. Xn_draw.obj:    n_draw.c \$(HDR)
  1377. X
  1378. Xn_box.obj:    n_box.c \$(HDR)
  1379. X
  1380. Xn_line.obj:    n_line.c \$(HDR)
  1381. X
  1382. Xp_wr_pix.obj:    p_wr_pix.c \$(HDR)
  1383. X
  1384. Xn_gfchar.obj:    n_gfchar.c \$(HDR)
  1385. X
  1386. Xn_gfstr.obj:    n_gfstr.c \$(HDR)
  1387. X
  1388. Xg_finish.obj:    g_finish.c \$(HDR)
  1389. X
  1390. Xc_cellch.obj:    c_cellch.c \$(HDR)
  1391. X
  1392. Xc_cellst.obj:    c_cellst.c \$(HDR)
  1393. X
  1394. Xc_cursor.obj:    c_cursor.c \$(HDR)
  1395. X
  1396. Xg_pixctl.obj:    g_pixctl.c \$(HDR)
  1397. X
  1398. Xn_curves.obj:    n_curves.c \$(HDR)
  1399. X
  1400. Xn_point.obj:    n_point.c \$(HDR)
  1401. X
  1402. Xplot.obj:    plot.c \$(HDR)
  1403. X
  1404. Xg_fntctl.obj:    g_fntctl.c \$(HDR)
  1405. X
  1406. Xxform.obj:    xform.c \$(HDR)
  1407. X
  1408. Xtrig.obj:    trig.c \$(HDR)
  1409. X
  1410. Xmachdep.obj:    machdep.c \$(HDR)
  1411. X
  1412. Xg_print.obj:    g_print.c \$(HDR)
  1413. X
  1414. Xg_init.obj:    g_init.c \$(HDR)
  1415. X
  1416. Xdemo.exe:    demo.obj testpat.obj gl.lib
  1417. X    \$(CC) $(LFLAGS) $(PATHS) demo.obj testpat.obj gl.lib
  1418. X
  1419. Xxdemo.exe:    xdemo.obj testpat.obj gl.lib
  1420. X    \$(CC) $(LFLAGS) $(PATHS) xdemo.obj gl.lib
  1421. X
  1422. XxX--EOF--XxX
  1423.  
  1424.  
  1425.