home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3471 < prev    next >
Encoding:
Internet Message Format  |  1991-06-08  |  57.4 KB
  1. From: guido@cwi.nl (Guido van Rossum)
  2. Newsgroups: alt.sources
  3. Subject: STDWIN 0.9.6 patches, part 3/5
  4. Message-ID: <3649@charon.cwi.nl>
  5. Date: 7 Jun 91 13:32:04 GMT
  6.  
  7. Archive-name: stdwin0.9.6/patch3
  8.  
  9. *** 0.9.5/Ports/mac/stdwin.c    Thu Feb 21 10:54:56 1991
  10. --- stdwin/Ports/mac/stdwin.c    Tue May 28 22:27:01 1991
  11. ***************
  12. *** 11,16 ****
  13. --- 11,24 ----
  14.   #endif
  15.   
  16.   
  17. + /* Parameters for top left corner choice algorithm in wopen() */
  18. + 
  19. + #define LEFT    20    /* Initial left */
  20. + #define TOP    40    /* Initial top */
  21. + #define HINCR    20    /* Increment for left */
  22. + #define VINCR    16    /* Increment for top */
  23. + 
  24. + 
  25.   /* GLOBAL DATA. */
  26.   
  27.               /* XXX choose less obvious names */
  28. ***************
  29. *** 17,25 ****
  30.   GrafPtr screen;        /* The Mac Window Manager's GrafPort */
  31.   TEXTATTR wattr;        /* Current or default text attributes */
  32.   
  33. ! static int def_left= LEFT;
  34. ! static int def_top= TOP;
  35. ! static int def_width, def_height;
  36.   
  37.   
  38.   /* INITIALIZATION AND TERMINATION. */
  39. --- 25,38 ----
  40.   GrafPtr screen;        /* The Mac Window Manager's GrafPort */
  41.   TEXTATTR wattr;        /* Current or default text attributes */
  42.   
  43. ! static int def_left = 0;
  44. ! static int def_top = 0;
  45. ! static int def_width = 0;
  46. ! static int def_height = 0;
  47. ! static int def_horscroll = 0;
  48. ! static int def_verscroll = 1;
  49. ! static int next_left = LEFT;    /* For default placement algorithm */
  50. ! static int next_top = TOP;
  51.   
  52.   
  53.   /* INITIALIZATION AND TERMINATION. */
  54. ***************
  55. *** 85,91 ****
  56.   #ifdef MPW
  57.       set_open_hook(std_open_hook);
  58.   #endif
  59. -     wsetdefwinsize(0, 0);
  60.       set_watch();
  61.   }
  62.   
  63. --- 98,103 ----
  64. ***************
  65. *** 101,107 ****
  66.       Rect r;
  67.       r= screen->portRect;
  68.       *pwidth= r.right - r.left;
  69. !     *pheight= r.bottom - r.top;
  70.   }
  71.   
  72.   void
  73. --- 113,119 ----
  74.       Rect r;
  75.       r= screen->portRect;
  76.       *pwidth= r.right - r.left;
  77. !     *pheight= r.bottom - r.top - MENUBARHEIGHT;
  78.   }
  79.   
  80.   void
  81. ***************
  82. *** 108,120 ****
  83.   wgetscrmm(pmmwidth, pmmheight)
  84.       int *pmmwidth, *pmmheight;
  85.   {
  86. !     Rect r;
  87. !     r= screen->portRect;
  88.       /* XXX Three pixels/mm is an approximation of the truth at most */
  89. !     *pmmwidth= (r.right - r.left) / 3;
  90. !     *pmmheight= (r.bottom - r.top) / 3;
  91.   }
  92.   
  93.   /* Routine called by "Resume" button in bomb box (passed to InitDialogs).
  94.      I have yet to see a program crash where an attempted exit to the
  95.      Finder caused any harm, so I think it's safe.
  96. --- 120,139 ----
  97.   wgetscrmm(pmmwidth, pmmheight)
  98.       int *pmmwidth, *pmmheight;
  99.   {
  100. !     int width, height;
  101. !     wgetscrsize(&width, &height);
  102.       /* XXX Three pixels/mm is an approximation of the truth at most */
  103. !     *pmmwidth= width / 3;
  104. !     *pmmheight= height / 3;
  105.   }
  106.   
  107. + int
  108. + wgetmouseconfig()
  109. + {
  110. +     return WM_BUTTON1 | WM_SHIFT | WM_META | WM_LOCK | WM_OPTION;
  111. +     /* XXX Should figure out if we have a Control button as well */
  112. + }
  113. + 
  114.   /* Routine called by "Resume" button in bomb box (passed to InitDialogs).
  115.      I have yet to see a program crash where an attempted exit to the
  116.      Finder caused any harm, so I think it's safe.
  117. ***************
  118. *** 126,131 ****
  119. --- 145,151 ----
  120.       ExitToShell();
  121.   }
  122.   
  123. + 
  124.   /* WINDOWS. */
  125.   
  126.   /* Find the WINDOW pointer corresponding to a WindowPtr. */
  127. ***************
  128. *** 154,186 ****
  129.   {
  130.       WINDOW *win= ALLOC(WINDOW);
  131.       Rect r;
  132.       
  133.       if (win == NULL) {
  134. !         dprintf("wopen: ALLOC failed"); /* XXX */
  135.           return NULL;
  136.       }
  137. ! 
  138. !     /* Find a nice position for the window. */
  139. !     if (def_left + def_width + BAR + LSLOP + RSLOP
  140. !             > screen->portRect.right) {
  141. !         def_left= LEFT;
  142. !         CLIPMAX(def_left, screen->portRect.right -
  143. !             (def_width + BAR + LSLOP + RSLOP));
  144. !         CLIPMIN(def_left, 0);
  145.       }
  146. !     if (def_top + def_height + BAR > screen->portRect.bottom) {
  147. !         def_top= TOP;
  148. !         CLIPMAX(def_top, screen->portRect.bottom -
  149. !             (def_height + BAR));
  150. !         CLIPMIN(def_top, MENUBARHEIGHT + TITLEBARHEIGHT);
  151.       }
  152.       
  153. !     SetRect(&r, def_left, def_top,
  154. !         def_left+def_width + BAR + LSLOP + RSLOP,
  155. !         def_top+def_height + BAR);
  156. !     def_left += HINCR;
  157. !     def_top += VINCR;
  158.       
  159.       win->w= NewWindow((Ptr)NULL, &r, PSTRING(title), TRUE, zoomDocProc,
  160.           (WindowPtr)(-1), TRUE, 0L);
  161.       SetWRefCon(win->w, (long)win);
  162. --- 174,270 ----
  163.   {
  164.       WINDOW *win= ALLOC(WINDOW);
  165.       Rect r;
  166. +     int width, height;        /* As seen by the user */
  167. +     int tot_width, tot_height;    /* Including slop & scroll bars */
  168. +     int left, top;            /* Window corner as seen by the user */
  169.       
  170.       if (win == NULL) {
  171. !         dprintf("wopen: ALLOC failed");
  172.           return NULL;
  173.       }
  174. !     
  175. !     /* Determine window size.
  176. !        If the program specified a size, use that, within reason --
  177. !        sizes are clipped to 0x7000 to avoid overflow in QuickDraw's
  178. !        calculations.
  179. !        Otherwise, use two-third of the screen size, but at most
  180. !        512x342 (to avoid creating gigantic windows by default on
  181. !        large screen Macs). */
  182. !     
  183. !     if (def_width <= 0) {
  184. !         width = screen->portRect.right * 2/3;
  185. !         CLIPMAX(width, 512);
  186.       }
  187. !     else {
  188. !         width = def_width;
  189. !         CLIPMAX(width, 0x7000);
  190.       }
  191. +     if (def_horscroll)
  192. +         CLIPMIN(width, 3*BAR);
  193. +     tot_width = width + LSLOP + RSLOP;
  194. +     if (def_verscroll)
  195. +         tot_width += BAR;
  196.       
  197. !     if (def_height <= 0) {
  198. !         height= screen->portRect.bottom * 2/3;
  199. !         CLIPMAX(height, 342);
  200. !     }
  201. !     else {
  202. !         height = def_height;
  203. !         CLIPMAX(height, 0x7000);
  204. !     }
  205. !     if (def_verscroll)
  206. !         CLIPMIN(height, 3*BAR);
  207. !     tot_height = height;
  208. !     if (def_horscroll)
  209. !         tot_height += BAR;
  210.       
  211. +     /* Determine window position.
  212. +        It the program specified a position, use that, but make sure
  213. +        that at least a small piece of the title bar is visible --
  214. +        so the user can recover a window that "fell off the screen".
  215. +        Exception: the title bar may hide completely under the menu
  216. +        bar, since this is the only way to get an (almost) full
  217. +        screen window.
  218. +        Otherwise, place the window a little to the right and below
  219. +        the last window placed; it it doesn't fit, move it up.
  220. +        With default placement, the window will never hide under the
  221. +        title bar. */
  222. +     
  223. +     if (def_left <= 0) {
  224. +         left = next_left;
  225. +         if (left + tot_width >= screen->portRect.right) {
  226. +             left = LEFT;
  227. +             CLIPMAX(left, screen->portRect.right - tot_width);
  228. +             CLIPMIN(left, 0);
  229. +         }
  230. +     }
  231. +     else {
  232. +         left = def_left - LSLOP;
  233. +         CLIPMAX(left, screen->portRect.right - BAR);
  234. +         CLIPMIN(left, BAR - tot_width);
  235. +     }
  236. +     
  237. +     if (def_top <= 0) {
  238. +         top = next_top;
  239. +         if (top + tot_height >= screen->portRect.bottom) {
  240. +             top = TOP;
  241. +             CLIPMAX(top, screen->portRect.bottom - tot_height);
  242. +             CLIPMIN(top, MENUBARHEIGHT + TITLEBARHEIGHT);
  243. +         }
  244. +     }
  245. +     else {
  246. +         top = def_top;
  247. +         CLIPMAX(top, screen->portRect.bottom);
  248. +         CLIPMIN(top, MENUBARHEIGHT);
  249. +     }
  250. +     
  251. +     next_left = left + HINCR;
  252. +     next_top = top + VINCR;
  253. +     
  254. +     /* Create the window now and initialize its attributes */
  255. +     
  256. +     SetRect(&r, left, top, left + tot_width, top + tot_height);
  257.       win->w= NewWindow((Ptr)NULL, &r, PSTRING(title), TRUE, zoomDocProc,
  258.           (WindowPtr)(-1), TRUE, 0L);
  259.       SetWRefCon(win->w, (long)win);
  260. ***************
  261. *** 197,205 ****
  262.       win->orgv= 0;
  263.       win->timer= 0;
  264.       win->cursor = NULL;
  265.       
  266.       initmbar(&win->mbar);
  267. !     makescrollbars(win);
  268.       
  269.       return win;
  270.   }
  271. --- 281,295 ----
  272.       win->orgv= 0;
  273.       win->timer= 0;
  274.       win->cursor = NULL;
  275. +     win->fgcolor = _w_fgcolor;
  276. +     win->bgcolor = _w_bgcolor;
  277.       
  278. +     SetPort(win->w);
  279. +     _w_usefgcolor(win->fgcolor);
  280. +     _w_usebgcolor(win->bgcolor);
  281. +     
  282.       initmbar(&win->mbar);
  283. !     makescrollbars(win, def_horscroll, def_verscroll);
  284.       
  285.       return win;
  286.   }
  287. ***************
  288. *** 230,235 ****
  289. --- 320,345 ----
  290.   }
  291.   
  292.   void
  293. + wgetwinpos(win, ph, pv)
  294. +     WINDOW *win;
  295. +     int *ph, *pv;
  296. + {
  297. +     Point p;
  298. +     GrafPtr saveport;
  299. +     
  300. +     GetPort(&saveport);
  301. +     
  302. +     SetPort(win->w);
  303. +     p.h = win->w->portRect.left + LSLOP;
  304. +     p.v = win->w->portRect.top;
  305. +     LocalToGlobal(&p);
  306. +     *ph = p.h;
  307. +     *pv = p.v;
  308. +     
  309. +     SetPort(saveport);
  310. + }
  311. + 
  312. + void
  313.   wsettitle(win, title)
  314.       WINDOW *win;
  315.       char *title;
  316. ***************
  317. *** 272,282 ****
  318.   wsetdefwinpos(h, v)
  319.       int h, v;
  320.   {
  321. !     /* XXX Sanity checks? Change interaction with wopen()? */
  322. !     if (h > 0)
  323. !         def_left = h;
  324. !     if (v > 0)
  325. !         def_top = v;
  326.   }
  327.   
  328.   void
  329. --- 382,389 ----
  330.   wsetdefwinpos(h, v)
  331.       int h, v;
  332.   {
  333. !     def_left = h;
  334. !     def_top = v;
  335.   }
  336.   
  337.   void
  338. ***************
  339. *** 291,312 ****
  340.   wsetdefwinsize(width, height)
  341.       int width, height;
  342.   {
  343. -     /* XXX Shouldn't this be done by wopen() instead? */
  344. -     if (width <= 0) {
  345. -         width= screen->portRect.right * 2/3;
  346. -         CLIPMAX(width, 512);
  347. -     }
  348. -     CLIPMAX(width, screen->portRect.right - BAR - LSLOP - RSLOP);
  349. -     CLIPMIN(width, MIN_WIDTH);
  350. -     
  351. -     if (height <= 0) {
  352. -         height= screen->portRect.bottom * 2/3;
  353. -         CLIPMAX(height, 342);
  354. -     }
  355. -     CLIPMAX(height, screen->portRect.bottom
  356. -         - MENUBARHEIGHT - TITLEBARHEIGHT - BAR);
  357. -     CLIPMIN(height, MIN_HEIGHT);
  358. -     
  359.       def_width= width;
  360.       def_height= height;
  361.   }
  362. --- 398,403 ----
  363. ***************
  364. *** 320,327 ****
  365.   }
  366.   
  367.   void
  368. ! wsetactive(win)
  369. !     WINDOW *win;
  370.   {
  371. !     SelectWindow(win->w);
  372.   }
  373. --- 411,427 ----
  374.   }
  375.   
  376.   void
  377. ! wsetdefscrollbars(hor, ver)
  378. !     int hor, ver;
  379.   {
  380. !     def_horscroll = hor;
  381. !     def_verscroll = ver;
  382. ! }
  383. ! 
  384. ! void
  385. ! wgetdefscrollbars(phor, pver)
  386. !     int *phor, *pver;
  387. ! {
  388. !     *phor = def_horscroll;
  389. !     *pver = def_verscroll;
  390.   }
  391. *** 0.9.5/Ports/msdos/README    Thu Feb 28 11:30:38 1991
  392. --- stdwin/Ports/msdos/README    Tue Apr 23 15:56:24 1991
  393. ***************
  394. *** 1,4 ****
  395.   Sorry, there is no real STDWIN port for MS-DOS yet.  What you can is
  396. ! to port the alfa version with the help of the file "ptrm.c" in this
  397.   directory, which is a substitute (using the MS-DOS console driver) for
  398. ! the VTRM module used by the alfa version for all its tty I/O.
  399. --- 1,5 ----
  400.   Sorry, there is no real STDWIN port for MS-DOS yet.  What you can is
  401. ! to port the alfa version with the help of the file "vtrm.c" in this
  402.   directory, which is a substitute (using the MS-DOS console driver) for
  403. ! the VTRM module used by the alfa version for all its tty I/O (the UNIX
  404. ! version of vtrm.c is in ../vtrm).
  405. *** 0.9.5/Ports/msdos/dir.c    Wed Jun 24 13:40:34 1987
  406. --- stdwin/Ports/msdos/dir.c    Tue Apr 23 15:56:39 1991
  407. ***************
  408. *** 1,28 ****
  409.   /*
  410.    * MS-DOS version of UNIX directory access package.
  411.    * (opendir, readdir, closedir).
  412.    */
  413.   
  414. ! #include <sys/types.h>
  415. ! #include <sys/stat.h>
  416. ! #include <errno.h>
  417.   #include <dos.h>
  418. ! extern int errno;
  419. ! #define MAXPATH 64
  420. ! 
  421.   #include "dir.h"
  422. - static char *firstf();
  423. - static char *nextf();
  424.   
  425.   typedef int bool;
  426. ! #define TRUE 1
  427. ! #define FALSE 0
  428.   #define EOS '\0'
  429. - #define NULL 0
  430.   
  431. ! static char dirpath[MAXPATH+1]= "";
  432. ! static bool busy= FALSE;
  433.   
  434.   /*
  435.    * Open a directory.
  436.    * This MS-DOS version allows only one directory to be open at a time.
  437. --- 1,38 ----
  438. + /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1990. */
  439. + 
  440.   /*
  441.    * MS-DOS version of UNIX directory access package.
  442.    * (opendir, readdir, closedir).
  443.    */
  444.   
  445. ! #include <stdio.h>
  446. ! #include <ctype.h>
  447. ! #include <string.h>
  448.   #include <dos.h>
  449. ! #include <errno.h>
  450. ! #include <sys\types.h>
  451. ! #include <sys\stat.h>
  452.   #include "dir.h"
  453.   
  454. + #define Visible
  455. + #define Hidden static
  456. + #define Procedure
  457. + 
  458.   typedef int bool;
  459. ! 
  460. ! #define Yes ((bool) 1)
  461. ! #define No  ((bool) 0)
  462. ! 
  463. ! #define MAXPATH 64
  464.   #define EOS '\0'
  465.   
  466. ! extern int errno;
  467. ! Hidden char *firstf();
  468. ! Hidden char *nextf();
  469.   
  470. + Hidden char dirpath[MAXPATH+1] = "";
  471. + Hidden bool busy = No;
  472. + 
  473.   /*
  474.    * Open a directory.
  475.    * This MS-DOS version allows only one directory to be open at a time.
  476. ***************
  477. *** 30,153 ****
  478.    * Then it only saves the file name and returns a pointer to it.
  479.    */
  480.   
  481. ! char *
  482. ! opendir(path)
  483. !     char *path;
  484.   {
  485.       struct stat buffer;
  486.   
  487.       if (dirpath[0] != EOS) {
  488. !          errno= EMFILE;
  489.            return NULL; /* Only one directory can be open at a time */
  490.       }
  491.       if (stat(path, &buffer) == -1)
  492.           return NULL; /* Directory doesn't exist */
  493.       if ((buffer.st_mode & S_IFMT) != S_IFDIR) {
  494. !         errno= ENOENT;
  495.           return NULL; /* Not a directory */
  496.       }
  497.       strcpy(dirpath, path);
  498. !     path= dirpath + strlen(dirpath);
  499.       if (path > dirpath && path[-1] != ':' && path[-1] != '/' &&
  500.               path[-1] != '\\')
  501.           *path++ = '\\';
  502.       strcpy(path, "*.*");
  503. !     busy= FALSE; /* Tell readdir this is the first time */
  504. !     return dirpath;
  505.   }
  506.   
  507.   /*
  508. -  * Close a directory.
  509. -  * We must clear the first char of dirpath to signal opendir that
  510. -  * no directory is open.
  511. -  */
  512. - 
  513. - closedir(dirp)
  514. -     char *dirp;
  515. - {
  516. -     dirp[0]= EOS;
  517. - }
  518. - 
  519. - /*
  520.    * Read the next directory entry.
  521.    */
  522.   
  523. ! struct direct *
  524. ! readdir(dp)
  525. !     char *dp;
  526.   {
  527.       static struct direct buffer;
  528.       char *p;
  529.   
  530.       if (!busy)
  531. !         p= firstf(dp);
  532.       else
  533. !         p= nextf();
  534. !     busy= (p != NULL);
  535.       if (!busy)
  536.           return NULL;
  537.       strcpy(buffer.d_name, p);
  538. !     buffer.d_namlen= strlen(p);
  539.       return &buffer;
  540.   }
  541.   
  542.   
  543.   /*
  544. !  * Low-level implementation -- access to DOS system calls FIRST and NEXT.
  545.    */
  546.   
  547. ! static char dta[64]; /* Device Transfer Area */
  548.   
  549. ! /* File attributes */
  550. ! #define READONLY    0x01
  551. ! #define HIDDEN        0x02
  552. ! #define SYSTEM        0x04
  553. ! #define VOLUMEID    0x08
  554. ! #define DIRECTORY    0x10
  555. ! #define ARCHIVE        0x20
  556.   
  557. ! #define MATCHATTR    (HIDDEN|SYSTEM|DIRECTORY)
  558.   
  559. ! static char *
  560. ! firstf(pat)
  561. !     char *pat;
  562.   {
  563. !     int flags;
  564. !     union REGS regs;
  565. !     struct SREGS segregs;
  566.   
  567. !     setdta(dta);
  568.   
  569. !     segread(&segregs);
  570. !     regs.h.ah = 0x4e;
  571. !     regs.x.cx = MATCHATTR;
  572.   #ifdef M_I86LM /* Large Model -- far pointers */
  573. !     regs.x.dx = FP_OFF(pat);
  574. !     segregs.ds = FP_SEG(pat);
  575.   #else
  576. !     regs.x.dx = (int) pat;
  577.   #endif
  578. !     flags= intdosx(®s, ®s, &segregs);
  579. !     if (regs.x.cflag)
  580. !     return NULL;
  581. !     fixfile();
  582. !     return dta + 30;
  583.   }
  584.   
  585. ! static char *
  586. ! nextf()
  587.   {
  588. !     int flags;
  589. !     union REGS regs;
  590.   
  591. !     setdta(dta);
  592.   
  593. !     regs.h.ah = 0x4f;
  594. !     flags= intdos(®s, ®s);
  595. !     if (regs.x.cflag)
  596. !     return NULL;
  597. !     fixfile();
  598. !     return dta + 30;
  599.   }
  600.   
  601.   /*
  602. --- 40,151 ----
  603.    * Then it only saves the file name and returns a pointer to it.
  604.    */
  605.   
  606. ! Visible DIR *opendir(path)
  607. !      char *path;
  608.   {
  609.       struct stat buffer;
  610.   
  611.       if (dirpath[0] != EOS) {
  612. !          errno = EMFILE;
  613.            return NULL; /* Only one directory can be open at a time */
  614.       }
  615.       if (stat(path, &buffer) == -1)
  616.           return NULL; /* Directory doesn't exist */
  617.       if ((buffer.st_mode & S_IFMT) != S_IFDIR) {
  618. !         errno = ENOENT;
  619.           return NULL; /* Not a directory */
  620.       }
  621.       strcpy(dirpath, path);
  622. !     path = dirpath + strlen(dirpath);
  623.       if (path > dirpath && path[-1] != ':' && path[-1] != '/' &&
  624.               path[-1] != '\\')
  625.           *path++ = '\\';
  626.       strcpy(path, "*.*");
  627. !     busy = No; /* Tell readdir this is the first time */
  628. !     return (DIR *) dirpath;
  629.   }
  630.   
  631.   /*
  632.    * Read the next directory entry.
  633.    */
  634.   
  635. ! Visible struct direct *readdir(dp)
  636. !      char *dp;
  637.   {
  638.       static struct direct buffer;
  639.       char *p;
  640.   
  641.       if (!busy)
  642. !         p = firstf((char *)dp);
  643.       else
  644. !         p = nextf();
  645. !     busy = (p != NULL);
  646.       if (!busy)
  647.           return NULL;
  648.       strcpy(buffer.d_name, p);
  649. !     buffer.d_namlen = strlen(p);
  650.       return &buffer;
  651.   }
  652.   
  653.   
  654.   /*
  655. !  * Close a directory.
  656. !  * We must clear the first char of dirpath to signal opendir that
  657. !  * no directory is open.
  658.    */
  659.   
  660. ! Visible Procedure closedir(dirp)
  661. !      DIR *dirp;
  662. ! {
  663. !     dirp[0] = EOS;
  664. ! }
  665.   
  666. ! /*
  667. !  * Low-level implementation -- access to DOS system calls FIRST and NEXT.
  668. !  */
  669.   
  670. ! Hidden char dta[64]; /* Device Transfer Area */
  671.   
  672. ! #define DIRATTR 0x10
  673. ! 
  674. ! Hidden char *firstf(pat)
  675. !      char *pat;
  676.   {
  677. !     static int flags;
  678. !     union REGS regs;
  679. !     struct SREGS segregs;
  680.   
  681. !     setdta(dta);
  682.   
  683. !     segread(&segregs);
  684. !     regs.h.ah = 0x4e;
  685. !     regs.x.cx = DIRATTR;
  686.   #ifdef M_I86LM /* Large Model -- far pointers */
  687. !     regs.x.dx = FP_OFF(pat);
  688. !     segregs.ds = FP_SEG(pat);
  689.   #else
  690. !     regs.x.dx = (int) pat;
  691.   #endif
  692. !     flags = intdosx(®s, ®s, &segregs);
  693. !     if (regs.x.cflag)
  694. !       return NULL;
  695. !     fixfile();
  696. !     return dta + 30;
  697.   }
  698.   
  699. ! Hidden char *nextf()
  700.   {
  701. !     int flags;
  702. !     union REGS regs;
  703.   
  704. !     setdta(dta);
  705.   
  706. !     regs.h.ah = 0x4f;
  707. !     flags = intdos(®s, ®s);
  708. !     if (regs.x.cflag)
  709. !       return NULL;
  710. !     fixfile();
  711. !     return dta + 30;
  712.   }
  713.   
  714.   /*
  715. ***************
  716. *** 154,166 ****
  717.    * Convert the file name in the Device Transfer Area to lower case.
  718.    */
  719.   
  720. ! static
  721. ! fixfile()
  722.   {
  723.       char *cp;
  724.   
  725. !     for (cp= dta+30; *cp != EOS; ++cp)
  726. !         *cp= tolower(*cp);
  727.   }
  728.   
  729.   /*
  730. --- 152,163 ----
  731.    * Convert the file name in the Device Transfer Area to lower case.
  732.    */
  733.   
  734. ! Hidden Procedure fixfile()
  735.   {
  736.       char *cp;
  737.   
  738. !     for (cp = dta+30; *cp != EOS; ++cp)
  739. !       *cp = tolower(*cp);
  740.   }
  741.   
  742.   /*
  743. ***************
  744. *** 167,186 ****
  745.    * Tell MS-DOS where the Device Transfer Area is.
  746.    */
  747.   
  748. ! static
  749. ! setdta(dta)
  750. !     char *dta;
  751.   {
  752. !     union REGS regs;
  753. !     struct SREGS segregs;
  754.   
  755. !     segread(&segregs);
  756. !     regs.h.ah = 0x1a;
  757.   #ifdef M_I86LM /* Large Model -- far pointers */
  758. !     regs.x.dx = FP_OFF(dta);
  759. !     segregs.ds = FP_SEG(dta);
  760.   #else
  761. !     regs.x.dx = (int) dta;
  762.   #endif
  763. !     intdosx(®s, ®s, &segregs);
  764.   }
  765. --- 164,182 ----
  766.    * Tell MS-DOS where the Device Transfer Area is.
  767.    */
  768.   
  769. ! Hidden Procedure setdta(dta)
  770. !      char *dta;
  771.   {
  772. !     union REGS regs;
  773. !     struct SREGS segregs;
  774.   
  775. !     segread(&segregs);
  776. !     regs.h.ah = 0x1a;
  777.   #ifdef M_I86LM /* Large Model -- far pointers */
  778. !     regs.x.dx = FP_OFF(dta);
  779. !     segregs.ds = FP_SEG(dta);
  780.   #else
  781. !     regs.x.dx = (int) dta;
  782.   #endif
  783. !     intdosx(®s, ®s, &segregs);
  784.   }
  785. *** 0.9.5/Ports/msdos/dir.h    Wed Jun 24 13:38:30 1987
  786. --- stdwin/Ports/msdos/dir.h    Tue Apr 23 15:56:53 1991
  787. ***************
  788. *** 1,3 ****
  789. --- 1,5 ----
  790. + /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1990. */
  791. + 
  792.   /*
  793.    * Interface for MS-DOS version of UNIX directory access package.
  794.    * (opendir, readdir, closedir).
  795. ***************
  796. *** 10,14 ****
  797.   
  798.   typedef char DIR;
  799.   
  800. ! DIR *opendir();
  801. ! struct direct *readdir();
  802. --- 12,17 ----
  803.   
  804.   typedef char DIR;
  805.   
  806. ! extern DIR *opendir();
  807. ! extern struct direct *readdir();
  808. ! extern closedir();
  809. *** 0.9.5/Ports/msdos/lib.    Fri Sep  4 16:17:13 1987
  810. --- stdwin/Ports/msdos/lib.    Tue Apr 23 15:57:05 1991
  811. ***************
  812. *** 24,32 ****
  813.   
  814.   style.obj:
  815.   
  816. ! PTRM=        ptrm.obj
  817.   
  818. ! ptrm.obj:
  819.   
  820.   ALFA=        bind.obj draw.obj event.obj keymap.obj measure.obj \
  821.           menu.obj scroll.obj stdwin.obj syswin.obj
  822. --- 24,32 ----
  823.   
  824.   style.obj:
  825.   
  826. ! VTRM=        vtrm.obj
  827.   
  828. ! vtrm.obj:
  829.   
  830.   ALFA=        bind.obj draw.obj event.obj keymap.obj measure.obj \
  831.           menu.obj scroll.obj stdwin.obj syswin.obj
  832. ***************
  833. *** 49,52 ****
  834.   
  835.   syswin.obj: alfa.h
  836.   
  837. ! ALL=        $(TOOLS) $(TEXTEDIT) $(PTRM) $(ALFA)
  838. --- 49,52 ----
  839.   
  840.   syswin.obj: alfa.h
  841.   
  842. ! ALL=        $(TOOLS) $(TEXTEDIT) $(VTRM) $(ALFA)
  843. *** /dev/null    Fri Jun  7 14:31:40 1991
  844. --- stdwin/Ports/msdos/vtrm.c    Tue Apr 23 15:52:28 1991
  845. ***************
  846. *** 0 ****
  847. --- 1,1137 ----
  848. + /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1991. */
  849. + 
  850. + /*
  851. +  * ibm Pc virtual TeRMinal package.
  852. +  *
  853. +  * (Under reconstruction by Guido!)
  854. +  *
  855. +  * An implementation of the VTRM interface for MS-DOS machines.
  856. +  *
  857. +  * This code supports two modes of accessing the screen.
  858. +  * The first one (BIOS) will be used, unless the user overwrites this
  859. +  * by setting the SCREEN environment variable.
  860. +  * This variable can also be used to convey a screen size that differs
  861. +  * from the default 25 lines and 80 columns. See below.
  862. +  *
  863. +  * The two modes are:
  864. +  *
  865. +  * 1) IBM BIOS interrupt 10 hex, video io.
  866. +  *    (See IBM PC XT Technical Reference 6936833, May 1983,
  867. +  *     Appendix A, pages A46-A47).
  868. +  *    This is what you really want to use, since it's the only one that
  869. +  *    can decently scroll. It cannot insert or delete characters, so
  870. +  *    most optimisations from the unix version of vtrm.c are useless
  871. +  *    and taken out.
  872. +  *    Unfortunately, not every PC-compatible machine supports this BIOS
  873. +  *    interrupt, so for these unlucky souls there is the following escape:
  874. +  *
  875. +  * 2) The ANSI.SYS driver.
  876. +  *    (See IBM MS-DOS 6936839, Jan 1983, Version 2.00, Chapter 13.)
  877. +  *    (Some compatibles don't have a separate ANSI.SYS driver but do the
  878. +  *    same escape interpretation by default.)
  879. +  *    This works reasonably, apart from scrolling downward, or part of
  880. +  *    the screen, which is clumsy.
  881. +  *    (The ANSI standard provides an escape sequence for scrolling
  882. +  *    but ANSI.SYS does not support it, nor any other way of scrolling.)
  883. +  *
  884. +  * The rest of the interface is the same as described in the unix version,
  885. +  * with the following exceptions:
  886. +  *    - to ease coding for ansi scrolls, the terminal is supposed to
  887. +  *    contain blanks at positions that were not written yet;
  888. +  *    the unknown rubbish that is initially on the screen can
  889. +  *    only be cleared by the caller by scrolling the whole screen up
  890. +  *    by one or more lines;
  891. +  *    - the number of lines on the terminal is assumed to be 25;
  892. +  *    the number of columns is (1) determined by a BIOS function, or
  893. +  *    (2) assumed to be 80 for ANSI;
  894. +  *    the user can overwrite this by setting the environment variable:
  895. +  *
  896. +  *        SET SCREEN=BIOS y x
  897. +  *    or
  898. +  *        SET SCREEN=ANSI y x
  899. +  *
  900. +  *    where x and y are the number of lines and columns respectively.
  901. +  *
  902. +  * The lines and columns of our virtual terminal are numbered
  903. +  *    y = {0...lines-1} from top to bottom, and
  904. +  *    x = {0...cols-1} from left to right,
  905. +  * respectively.
  906. +  *
  907. +  * The Visible Procedures in this package are as described in the unix version.
  908. +  *
  909. +  */
  910. + 
  911. + /* Includes: */
  912. + 
  913. + #include <stdio.h>
  914. + #include <ctype.h>
  915. + #include <string.h>
  916. + #include <dos.h>
  917. + #include <fcntl.h>
  918. + #include <io.h>
  919. + #include "vtrm.h"
  920. + 
  921. + /* Style definitions: */
  922. + 
  923. + #define Visible
  924. + #define Hidden static
  925. + #define Procedure
  926. + 
  927. + typedef int bool;
  928. + typedef char *string;
  929. + typedef short intlet;
  930. + 
  931. + #define Yes ((bool) 1)
  932. + #define No  ((bool) 0)
  933. + 
  934. + /* Forward declarations: */
  935. + 
  936. + extern char *malloc();
  937. + 
  938. + /* Data definitions: */
  939. + 
  940. + #ifdef VTRMTRACE
  941. + #define TRACEFILE "TRACE.TRM"
  942. + Hidden FILE *vtrmfp= (FILE *) NULL;
  943. + #endif
  944. + 
  945. + #define STDIN_HANDLE 0
  946. + 
  947. + #define Undefined (-1)
  948. + 
  949. + #define Min(a,b) ((a) <= (b) ? (a) : (b))
  950. + 
  951. + /* terminal status */
  952. + 
  953. + Hidden int started = No;
  954. + 
  955. + Hidden int scr_mode = 0;
  956. + #define ANSI 'A'
  957. + #define BIOS 'B'
  958. + 
  959. + #define Nlines    25
  960. + #define Ncols    80
  961. + Hidden int lines = Nlines;
  962. + Hidden int cols = Ncols;
  963. + Hidden int flags = 0;
  964. + 
  965. + /* current standout mode */
  966. + #define Off    PLAIN
  967. + #define On    STANDOUT
  968. + Hidden int so_mode = Off;
  969. + 
  970. + /* current cursor position */
  971. + Hidden intlet cur_y = Undefined, cur_x = Undefined;
  972. + 
  973. + /* "linedata[y][x]" holds the char on the terminal,
  974. +  * "linemode[y][x]" the STANDOUT bit.
  975. +  * The STANDOUT bit tells whether the character is standing out.
  976. +  * "lenline[y]" holds the length of the line.
  977. +  * (Partially) empty lines are distinghuished by "lenline[y] < cols".
  978. +  * Unknown chars will be ' ', so the scrolling routines for ANSI
  979. +  * can use "unwritten" chars (with indent > 0 in trmputdata).
  980. +  * To make the optimising compare in putline fail, lenline[y] is initially 0.
  981. +  * The latter implies that if a line is first addressed with trmputdata,
  982. +  * any rubbish that is on the screen beyond the data that gets put, will
  983. +  * remain there.
  984. +  */
  985. + 
  986. + Hidden char     **linedata = 0;
  987. + Hidden char     **linemode = 0;
  988. + 
  989. + Hidden intlet *lenline = 0;
  990. + 
  991. + /* To compare the mode part of the line when the
  992. +  * mode parameter of trmputdata == NULL, we use the following:
  993. +  */
  994. + Hidden char plain[1]= {PLAIN};
  995. + 
  996. + /* Make the cursor invisible when trmsync() tries to move outside the screen */
  997. + Hidden bool no_cursor = No;
  998. + 
  999. + /*
  1000. +  * Starting, Ending and (fatal) Error.
  1001. +  */
  1002. + 
  1003. + Hidden bool wasbreak;
  1004. + 
  1005. + /*
  1006. +  * Initialization call.
  1007. +  * Determine terminal mode.
  1008. +  * Start up terminal and internal administration.
  1009. +  * Return Yes if succeeded, No if trouble (which doesn't apply here).
  1010. +  */
  1011. + 
  1012. + Visible int trmstart(plines, pcols, pflags)
  1013. +      int *plines;
  1014. +      int *pcols;
  1015. +      int *pflags;
  1016. + {
  1017. +     static char setup = No;
  1018. +     int err;
  1019. + 
  1020. + #ifdef VTRMTRACE
  1021. +     if (!started) vtrmfp= fopen(TRACEFILE, vtrmfp ? "a" : "w");
  1022. +     if (vtrmfp) fprintf(vtrmfp, "\ttrmstart(&li, &co, &fl);\n");
  1023. + #endif
  1024. + 
  1025. +     if (started)
  1026. +         return TE_TWICE;
  1027. + 
  1028. +     if (!setup) {
  1029. +         err = set_screen_up();
  1030. +         if (err != TE_OK)
  1031. +             return err;
  1032. +         setup = Yes;
  1033. +     }
  1034. + 
  1035. +     err = start_trm();        /* internal administration */
  1036. +     if (err != TE_OK)
  1037. +         return err;
  1038. + 
  1039. +     *plines = lines;
  1040. +     *pcols = cols;
  1041. +     *pflags = flags;
  1042. + 
  1043. +     setmode(STDIN_HANDLE, O_BINARY); /* Don't translate CRLF to LF */
  1044. +     setraw(STDIN_HANDLE, Yes);
  1045. +     wasbreak = getbreak(); /* Save BREAK status; restore when done */
  1046. +     setbreak(No);
  1047. + 
  1048. +     started = Yes;
  1049. +     return TE_OK;
  1050. + }
  1051. + 
  1052. + Hidden int set_screen_up()
  1053. + {
  1054. +     int height;
  1055. +     int width;
  1056. +     int get_screen_env();
  1057. +     int get_cols();
  1058. + 
  1059. +     height = width = 0;
  1060. +     scr_mode = get_screen_env(&height, &width);
  1061. + 
  1062. +     switch (scr_mode) {
  1063. +     case BIOS:
  1064. +     case TE_OK:
  1065. +         cols = get_cols();
  1066. +         flags = HAS_STANDOUT|CAN_SCROLL;
  1067. +         break;
  1068. +     case ANSI:
  1069. +         flags = HAS_STANDOUT;
  1070. +         break;
  1071. +     default:
  1072. +         return scr_mode; /* Error flag */
  1073. +     }
  1074. + 
  1075. +     /* allow x and y in environment variable SCREEN to override */
  1076. +     if (height > 0)
  1077. +         lines = height;
  1078. +     if (width > 0)
  1079. +         cols = width;
  1080. +     return TE_OK;
  1081. + }
  1082. + 
  1083. + Hidden int get_screen_env(pheight, pwidth)
  1084. +      int *pheight;
  1085. +      int *pwidth;
  1086. + {
  1087. +     string s;
  1088. +     int mode;
  1089. +     char screrr;
  1090. +     string getenv();
  1091. +     string strip();
  1092. +     string skip();
  1093. + 
  1094. +     screrr = No;
  1095. +     s = getenv("SCREEN");
  1096. +     if (s == NULL)
  1097. +         return BIOS;
  1098. + 
  1099. +     s = strip(s);
  1100. +     switch (*s) {
  1101. +     case '\0':
  1102. +         return BIOS;
  1103. +     case 'a':
  1104. +         mode = ANSI;
  1105. +         s = skip(s, "ansi");
  1106. +         break;
  1107. +     case 'A':
  1108. +         mode = ANSI;
  1109. +         s = skip(s, "ANSI");
  1110. +         break;
  1111. +     case 'b':
  1112. +         mode = BIOS;
  1113. +         s = skip(s, "bios");
  1114. +         break;
  1115. +     case 'B':
  1116. +         mode = BIOS;
  1117. +         s = skip(s, "BIOS");
  1118. +         break;
  1119. +     default:
  1120. +         mode = BIOS;
  1121. +         screrr = Yes;
  1122. +     }
  1123. + 
  1124. +     /* *pheight and *pwidth were set to 0 above */
  1125. +     s = strip(s);
  1126. +     while (isdigit(*s)) {
  1127. +         *pheight = *pheight * 10 + (*s++ - '0');
  1128. +     }
  1129. +     s = strip(s);
  1130. +     while (isdigit(*s)) {
  1131. +         *pwidth = *pwidth * 10 + (*s++ -'0');
  1132. +     }
  1133. +     s = strip(s);
  1134. +     if (screrr || *s != '\0')
  1135. +         return TE_BADSCREEN;
  1136. + 
  1137. +     return mode;
  1138. + }
  1139. + 
  1140. + Hidden string strip(s)
  1141. +      string s;
  1142. + {
  1143. +     while (*s == ' ' || *s == '\t')
  1144. +         ++s;
  1145. +     return s;
  1146. + }
  1147. + 
  1148. + Hidden string skip(s, pat)
  1149. +      string s;
  1150. +      string pat;
  1151. + {
  1152. +     while (*s && *s == *pat)
  1153. +         ++s, ++pat;
  1154. +     return s;
  1155. + }
  1156. + 
  1157. + /* initialise internal administration */
  1158. + 
  1159. + Hidden int start_trm()
  1160. + {
  1161. +     register int y;
  1162. + 
  1163. +     if (linedata == NULL) {
  1164. +         if ((linedata = (char**) malloc(lines * sizeof(char*))) == NULL)
  1165. +             return TE_NOMEM;
  1166. +         for (y = 0; y < lines; y++) {
  1167. +             if ((linedata[y] = (char*) malloc(cols * sizeof(char))) == NULL)
  1168. +                 return TE_NOMEM;
  1169. +         }
  1170. +     }
  1171. +     if (linemode == NULL) {
  1172. +         if ((linemode = (char**) malloc(lines * sizeof(char*))) == NULL)
  1173. +             return TE_NOMEM;
  1174. +         for (y = 0; y < lines; y++) {
  1175. +             if ((linemode[y] = (char*) malloc(cols * sizeof(char))) == NULL)
  1176. +                 return TE_NOMEM;
  1177. +         }
  1178. +     }
  1179. +     if (lenline == 0) {
  1180. +         if ((lenline = (intlet *) malloc(lines * sizeof(intlet))) == NULL)
  1181. +             return TE_NOMEM;
  1182. +     }
  1183. +         
  1184. +     trmundefined();
  1185. +     return TE_OK;
  1186. + }
  1187. + 
  1188. + /*
  1189. +  * Termination call.
  1190. +  * Beware that it might be called by a catched interrupt even in the middle
  1191. +  * of trmstart()!
  1192. +  */
  1193. + 
  1194. + Visible Procedure trmend()
  1195. + {
  1196. + #ifdef VTRMTRACE
  1197. +     if (vtrmfp) fprintf(vtrmfp, "\ttrmend();\n");
  1198. + #endif
  1199. +     if (started && so_mode != Off)
  1200. +         standend();
  1201. +     if (scr_mode == ANSI) {
  1202. +         fflush(stdout);
  1203. +     }
  1204. +     /* Always turn off RAW mode -- it is unlikely that anybody
  1205. +        would want to interface to COMMAND.COM in raw mode.
  1206. +        This way, if you were accidentally left in RAW mode
  1207. +        because of a crash, it will go away if you re-enter. */
  1208. +     setraw(STDIN_HANDLE, No);
  1209. +     setbreak(wasbreak);
  1210. + 
  1211. +     started = No;
  1212. + #ifdef VTRMTRACE
  1213. +     if (vtrmfp) fclose(vtrmfp);
  1214. + #endif
  1215. + }
  1216. + 
  1217. + /*
  1218. +  * Set all internal statuses to undefined, especially the contents of
  1219. +  * the screen, so a hard redraw will not be optimised to heaven.
  1220. +  */
  1221. + 
  1222. + Visible Procedure trmundefined()
  1223. + {
  1224. +     register int y, x;
  1225. + #ifdef VTRMTRACE
  1226. +     if (vtrmfp) fprintf(vtrmfp, "\ttrmundefined();\n");
  1227. + #endif
  1228. + 
  1229. +     cur_y = cur_x = Undefined;
  1230. +     so_mode = Undefined;
  1231. + 
  1232. +     for (y = 0; y < lines; y++) {
  1233. +         for (x = 0; x < cols; x++) {
  1234. +             linedata[y][x] = ' ';
  1235. +             linemode[y][x] = PLAIN;
  1236. +         }
  1237. +             /* they may get printed in scrolling */
  1238. +         lenline[y] = cols;
  1239. +     }
  1240. + }
  1241. + 
  1242. + #ifdef VTRMTRACE
  1243. + 
  1244. + Hidden Procedure check_started(m)
  1245. +      char *m;
  1246. + {
  1247. +     if (!started) {
  1248. +         trmend();
  1249. +         if (vtrmfp) fprintf(vtrmfp, "Not started: %s\n", m);
  1250. +         exit(TE_TWICE);
  1251. +     }
  1252. + }
  1253. + #else
  1254. + 
  1255. + #define check_started(m) /*empty*/
  1256. + 
  1257. + #endif
  1258. + 
  1259. + /*
  1260. +  * Sensing the cursor.
  1261. +  * (NOT IMPLEMENTED, since there is no way to locally move the cursor.)
  1262. +  */
  1263. + 
  1264. + /*
  1265. +  * Sense the current (y, x) cursor position, after a possible manual
  1266. +  * change by the user with local cursor motions.
  1267. +  * If the terminal cannot be asked for the current cursor position,
  1268. +  * or if the string returned by the terminal is garbled,
  1269. +  * the position is made Undefined.
  1270. +  */
  1271. + Visible Procedure trmsense(sense, format, py, px)
  1272. +      string sense;
  1273. +      string format;
  1274. +      int *py;
  1275. +      int *px;
  1276. + {
  1277. + #ifdef VTRMTRACE
  1278. +     if (vtrmfp) fprintf(vtrmfp, "\ttrmsense(&yy, &xx);\n");
  1279. + #endif
  1280. +     check_started("trmsense called outside trmstart/trmend");
  1281. + 
  1282. + /*    *py = *px = Undefined;
  1283. +  *
  1284. +  *
  1285. +  *    if (flags&CAN_SENSE && getpos(py, px)) {
  1286. +  *        if (*py < 0 || lines <= *py || *px < 0 || cols <= *px)
  1287. +  *            *py = *px = Undefined;
  1288. +  *    }
  1289. +  */
  1290. +     *py = *px= Undefined;
  1291. + }
  1292. + 
  1293. + /*
  1294. +  * Putting data on the screen.
  1295. +  */
  1296. + 
  1297. + /*
  1298. +  * Fill screen area with given "data".
  1299. +  * Characters for which the corresponding chars in "mode" have the value
  1300. +  * STANDOUT must be put in inverse video.
  1301. +  */
  1302. + Visible Procedure trmputdata(yfirst, ylast, indent, data, mode)
  1303. +      int yfirst;
  1304. +      int ylast;
  1305. +      register int indent;
  1306. +      register string data;
  1307. +      string mode;
  1308. + {
  1309. +     register int y;
  1310. +     int x, len, lendata, space;
  1311. + 
  1312. + #ifdef VTRMTRACE
  1313. +     if (vtrmfp) fprintf(vtrmfp, "\ttrmputdata(%d, %d, %d, \"%s\");\n",
  1314. +                 yfirst, ylast, indent, data);
  1315. + #endif
  1316. +     check_started("trmputdata called outside trmstart/trmend");
  1317. + 
  1318. +     if (yfirst < 0)
  1319. +         yfirst = 0;
  1320. +     if (ylast >= lines)
  1321. +         ylast = lines-1;
  1322. +     space = cols*(ylast-yfirst+1) - indent;
  1323. +     if (space <= 0)
  1324. +         return;
  1325. +     yfirst += indent/cols;
  1326. +     indent %= cols;
  1327. +     y = yfirst;
  1328. +     if (data) {
  1329. +         x = indent;
  1330. +         lendata = strlen(data);
  1331. +         if (ylast == lines-1 && lendata >= space)
  1332. +             lendata = space - 1;
  1333. +         len = Min(lendata, cols-x);
  1334. +         while (/*** len > 0 && ***/ y <= ylast) {
  1335. +             put_line(y, x, data, mode, len);
  1336. +             y++;
  1337. +             lendata -= len;
  1338. +             if (lendata > 0) {
  1339. +                 x = 0;
  1340. +                 data += len;
  1341. +                 if (mode != NULL)
  1342. +                     mode += len;
  1343. +                 len = Min(lendata, cols);
  1344. +             }
  1345. +             else
  1346. +                 break;
  1347. +         }
  1348. +     }
  1349. +     if (y <= ylast)
  1350. +         clear_lines(y, ylast);
  1351. + }
  1352. + 
  1353. + /*
  1354. +  * We will try to get the picture:
  1355. +  *
  1356. +  *            op>>>>>>>>>>>op                       oq
  1357. +  *            ^         ^                       ^
  1358. +  *         <xskip><-----m1----><---------------od-------------------->
  1359. +  *   OLD:   "You're in a maze of twisty little pieces of code, all alike"
  1360. +  *   NEW:       "in a maze of little twisting pieces of code, all alike"
  1361. +  *            <-----m1----><----------------nd--------------------->
  1362. +  *            ^         ^                     ^
  1363. +  *            np>>>>>>>>>>>np                     nq
  1364. +  * where
  1365. +  *    op, oq, np, nq are pointers to start and end of Old and New data,
  1366. +  * and
  1367. +  *    xskip = length of indent to be skipped,
  1368. +  *    m1 = length of Matching part at start,
  1369. +  *    od = length of Differing end on screen,
  1370. +  *    nd = length of Differing end in data to be put.
  1371. +  */
  1372. + Hidden int put_line(y, xskip, data, mode, len)
  1373. +      int y;
  1374. +      int xskip;
  1375. +      string data;
  1376. +      string mode;
  1377. +      int len;
  1378. + {
  1379. +     register char *op, *oq, *mp;
  1380. +     char *np, *nq, *mo;
  1381. +     int m1, od, nd, delta;
  1382. + 
  1383. +     /* Bugfix GvR 19-June-87: */
  1384. +     while (lenline[y] < xskip) {
  1385. +         linedata[y][lenline[y]] = ' ';
  1386. +         linemode[y][lenline[y]] = PLAIN;
  1387. +         lenline[y]++;
  1388. +     }
  1389. +     
  1390. +     /* calculate the magic parameters */
  1391. +     op = &linedata[y][xskip];
  1392. +     oq = &linedata[y][lenline[y]-1];
  1393. +     mp = &linemode[y][xskip];
  1394. +     np = data;
  1395. +     nq = data + len - 1;
  1396. +     mo = (mode != NULL ? mode : plain);
  1397. +     m1 = 0;
  1398. +     while (*op == *np && *mp == *mo && op <= oq && np <= nq) {
  1399. +         op++, np++, mp++, m1++;
  1400. +         if (mode != NULL) mo++;
  1401. +     }
  1402. +     od = oq - op + 1;
  1403. +     nd = nq - np + 1;
  1404. +     /* now we have the picture above */
  1405. + 
  1406. +     if (od==0 && nd==0)
  1407. +         return;
  1408. + 
  1409. +     delta = nd - od;
  1410. +     move(y, xskip + m1);
  1411. +     if (nd > 0) {
  1412. +         mo= (mode != NULL ? mode+(np-data) : NULL);
  1413. +         put_str(np, mo, nd);
  1414. +     }
  1415. +     if (delta < 0) {
  1416. +         clr_to_eol();
  1417. +         return;
  1418. +     }
  1419. +     lenline[y] = xskip + len;
  1420. +     if (cur_x == cols) {
  1421. +         cur_y++;
  1422. +         cur_x = 0;
  1423. +     }
  1424. + }
  1425. + 
  1426. + /*
  1427. +  * Scrolling (part of) the screen up (or down, dy<0).
  1428. +  */
  1429. + 
  1430. + Visible Procedure trmscrollup(yfirst, ylast, by)
  1431. +      register int yfirst;
  1432. +      register int ylast;
  1433. +      register int by;
  1434. + {
  1435. + #ifdef VTRMTRACE
  1436. +     if (vtrmfp) fprintf(vtrmfp, "\ttrmscrollup(%d, %d, %d);\n", yfirst, ylast, by);
  1437. + #endif
  1438. +     check_started("trmscrollup called outside trmstart/trmend");
  1439. + 
  1440. +     if (by == 0)
  1441. +         return;
  1442. + 
  1443. +     if (yfirst < 0)
  1444. +         yfirst = 0;
  1445. +     if (ylast >= lines)
  1446. +         ylast = lines-1;
  1447. + 
  1448. +     if (yfirst > ylast)
  1449. +         return;
  1450. + 
  1451. +     if (so_mode != Off)
  1452. +         standend();
  1453. + 
  1454. +     if (by > 0 && yfirst + by > ylast
  1455. +         ||
  1456. +         by < 0 && yfirst - by > ylast)
  1457. +     {
  1458. +         clear_lines(yfirst, ylast);
  1459. +         return;
  1460. +     }
  1461. + 
  1462. +     switch (scr_mode) {
  1463. +     case BIOS:
  1464. +         biosscrollup(yfirst, ylast, by);
  1465. +         break;
  1466. +     case ANSI:
  1467. +         if (by > 0 && yfirst == 0) {
  1468. +             lf_scroll(ylast, by);
  1469. +         }
  1470. +         else if (by > 0) {
  1471. +             move_lines(yfirst+by, yfirst, ylast-yfirst+1-by, 1);
  1472. +             clear_lines(ylast-by+1, ylast);
  1473. +         }
  1474. +         else {
  1475. +             move_lines(ylast+by, ylast, ylast-yfirst+1+by, -1);
  1476. +             clear_lines(yfirst, yfirst-by-1);
  1477. +         }
  1478. +         break;
  1479. +     }
  1480. + }
  1481. + 
  1482. + /*
  1483. +  * Synchronization, move cursor to given position (or previous if < 0).
  1484. +  */
  1485. + 
  1486. + Visible Procedure trmsync(y, x)
  1487. +      int y;
  1488. +      int x;
  1489. + {
  1490. + #ifdef VTRMTRACE
  1491. +     if (vtrmfp) fprintf(vtrmfp, "\ttrmsync(%d, %d);\n", y, x);
  1492. + #endif
  1493. +     check_started("trmsync called outside trmstart/trmend");
  1494. + 
  1495. +     if (0 <= y && y < lines && 0 <= x && x < cols) {
  1496. +         move(y, x);
  1497. +     }
  1498. +     fflush(stdout);
  1499. + }
  1500. + 
  1501. + /*
  1502. +  * Send a bell, visible if possible.
  1503. +  */
  1504. + 
  1505. + Visible Procedure trmbell() {
  1506. + #ifdef VTRMTRACE
  1507. +     if (vtrmfp) fprintf(vtrmfp, "\ttrmbell();\n");
  1508. + #endif
  1509. +     check_started("trmbell called outside trmstart/trmend");
  1510. +     ring_bell();
  1511. + }
  1512. + 
  1513. + /*
  1514. +  * Now for the real work: here are all low level routines that really
  1515. +  * differ for BIOS or ANSI mode.
  1516. +  */
  1517. + 
  1518. + /*
  1519. +  * BIOS video io is called by generating an 8086 software interrupt,
  1520. +  * using lattice's int86() function.
  1521. +  * To ease coding, all routines fill in the apropriate parameters in regs,
  1522. +  * and then call bios10(code), where code is to be placed in ah.
  1523. +  */
  1524. + 
  1525. + Hidden union REGS regs, outregs;
  1526. + 
  1527. + /* A macro for speed  */
  1528. + #define bios10(code) (regs.h.ah = (code), int86(0x10, ®s, ®s))
  1529. + #define nbios10(code) (regs.h.ah = (code), int86(0x10, ®s, &outregs))
  1530. + 
  1531. + /* Video attributes: (see the BASIC manual) (used for standout mode) */
  1532. + 
  1533. + Hidden int video_attr;
  1534. + #define V_NORMAL 7
  1535. + #define V_STANDOUT (7<<4)
  1536. + 
  1537. + /* Some BIOS only routines */
  1538. + 
  1539. + Hidden get_cols()
  1540. + {
  1541. +     bios10(15);
  1542. +     return regs.h.ah;
  1543. + }
  1544. + 
  1545. + /*
  1546. +  * ANSI escape sequences
  1547. +  */
  1548. + #define A_CUP    "\033[%d;%dH"   /* cursor position */
  1549. + #define A_SGR0    "\033[0m"       /* set graphics rendition to normal */
  1550. + #define A_SGR7    "\033[7m"       /* set graphics rendition to standout */
  1551. + #define A_ED    "\033[2J"       /* erase display (and cursor home) */
  1552. + #define A_EL    "\033[K"        /* erase (to end of) line */
  1553. + 
  1554. + /*
  1555. +  * The following routine is the time bottleneck, I believe!
  1556. +  */
  1557. + 
  1558. + Hidden Procedure put_str(data, mode, n)
  1559. +      char *data;
  1560. +      char *mode;
  1561. +      int n;
  1562. + {
  1563. +     register char c, mo, so;
  1564. + 
  1565. +     so = so_mode;
  1566. +     if (scr_mode == BIOS) {
  1567. +         regs.x.cx = 1;    /* repition count */
  1568. +         regs.h.bh = 0;    /* page number */
  1569. +         regs.h.bl = video_attr;
  1570. +         while (--n >= 0) {
  1571. +             c = *data++;
  1572. +             mo= (mode != NULL ? *mode++ : PLAIN);
  1573. +             if (mo != so) {
  1574. +                 so= mo;
  1575. +                 so ? standout() : standend();
  1576. +                 regs.h.bl = video_attr;
  1577. +             }
  1578. +             regs.h.al = c /* &CHAR */;
  1579. +             nbios10(9);
  1580. +             if (cur_x >= cols-1) {
  1581. +                 linedata[cur_y][cols-1] = c;
  1582. +                 linemode[cur_y][cols-1] = mo;
  1583. +                 continue;
  1584. +             }
  1585. +             regs.h.dh = cur_y;
  1586. +             regs.h.dl = cur_x + 1;
  1587. +             nbios10(2);
  1588. +             linedata[cur_y][cur_x] = c;
  1589. +             linemode[cur_y][cur_x]= mo;
  1590. +             cur_x++;
  1591. +         }
  1592. +     }
  1593. +     else {
  1594. +         while (--n >= 0) {
  1595. +             c = *data++;
  1596. +             mo= (mode != NULL ? *mode++ : PLAIN);
  1597. +             if (mo != so) {
  1598. +                 so= mo;
  1599. +                 so ? standout() : standend();
  1600. +             }
  1601. +             putch(c);
  1602. +             linedata[cur_y][cur_x] = c;
  1603. +             linemode[cur_y][cur_x]= mo;
  1604. +             cur_x++;
  1605. +         }
  1606. +     }
  1607. + }
  1608. + 
  1609. + /*
  1610. +  * Move to position y,x on the screen
  1611. +  */
  1612. + 
  1613. + Hidden Procedure move(y, x)
  1614. +      int y;
  1615. +      int x;
  1616. + {
  1617. +     if (scr_mode != BIOS && cur_y == y && cur_x == x)
  1618. +         return;
  1619. +     switch (scr_mode) {
  1620. +     case BIOS:
  1621. +         regs.h.dh = y;
  1622. +         regs.h.dl = x;
  1623. +         regs.h.bh = 0; /* Page; must be 0 for graphics */
  1624. +         bios10(2);
  1625. +         break;
  1626. +     case ANSI:
  1627. +         cprintf(A_CUP, y+1, x+1);
  1628. +         break;
  1629. +     }
  1630. +     cur_y = y;
  1631. +     cur_x = x;
  1632. + }
  1633. + 
  1634. + Hidden Procedure standout()
  1635. + {
  1636. +     so_mode = On;
  1637. +     switch (scr_mode) {
  1638. +     case BIOS:
  1639. +         video_attr = V_STANDOUT;
  1640. +         break;
  1641. +     case ANSI:
  1642. +         cputs(A_SGR7);
  1643. +         break;
  1644. +     }
  1645. + }
  1646. + 
  1647. + Hidden Procedure standend()
  1648. + {
  1649. +     so_mode = Off;
  1650. +     switch (scr_mode) {
  1651. +     case BIOS:
  1652. +         video_attr = V_NORMAL;
  1653. +         break;
  1654. +     case ANSI:
  1655. +         cputs(A_SGR0);
  1656. +         break;
  1657. +     }
  1658. + }
  1659. + 
  1660. + Hidden Procedure clear_lines(yfirst, ylast)
  1661. +      int yfirst;
  1662. +      int ylast;
  1663. + {
  1664. +     register int y;
  1665. + 
  1666. +     if (scr_mode == BIOS) {
  1667. +         regs.h.al = 0;    /* scroll with al = 0 means blank window */
  1668. +         regs.h.ch = yfirst;
  1669. +         regs.h.cl = 0;
  1670. +         regs.h.dh = ylast;
  1671. +         regs.h.dl = cols-1;
  1672. +         regs.h.bh = V_NORMAL;
  1673. +         bios10(6);
  1674. +         for (y = yfirst; y <= ylast; y++)
  1675. +             lenline[y] = 0;
  1676. +         return;
  1677. +     }
  1678. +     /* scr_mode == ANSI */
  1679. +     if (yfirst == 0 && ylast == lines-1) {
  1680. +         if (so_mode == On)
  1681. +             standend();
  1682. +         move(0, 0);        /* since some ANSI'd don't move */
  1683. +         cputs(A_ED);
  1684. +         cur_y = cur_x = 0;
  1685. +         for (y = yfirst; y < ylast; y++)
  1686. +             lenline[y] = 0;
  1687. +         return;
  1688. +     }
  1689. +     for (y = yfirst; y <= ylast; y++) {
  1690. +         if (lenline[y] > 0) {
  1691. +             move(y, 0);
  1692. +             clr_to_eol();
  1693. +         }
  1694. +     }
  1695. + }
  1696. + 
  1697. + Hidden Procedure clr_to_eol()
  1698. + {
  1699. +     if (so_mode == On)
  1700. +         standend();
  1701. +     switch (scr_mode) {
  1702. +     case BIOS:
  1703. +         regs.h.bh = 0;    /* page */
  1704. +         regs.x.cx = lenline[cur_y] - cur_x;
  1705. +         regs.h.al = ' ';
  1706. +         regs.h.bl = V_NORMAL;
  1707. +         bios10(9);
  1708. +         break;
  1709. +     case ANSI:
  1710. +         cputs(A_EL);
  1711. +         break;
  1712. +     }
  1713. +     lenline[cur_y] = cur_x;
  1714. + }
  1715. + 
  1716. + /* scrolling for BIOS */
  1717. + 
  1718. + Hidden Procedure biosscrollup(yfirst, ylast, by)
  1719. +      int yfirst;
  1720. +      int ylast;
  1721. +      int by;
  1722. + {
  1723. +     regs.h.al = (by < 0 ? -by : by);
  1724. +     regs.h.ch = yfirst;
  1725. +     regs.h.cl = 0;
  1726. +     regs.h.dh = ylast;
  1727. +     regs.h.dl = cols-1;
  1728. +     regs.h.bh= V_NORMAL;
  1729. +     bios10(by < 0 ? 7 : 6);
  1730. +     cur_y = cur_x = Undefined;
  1731. +     if (by > 0)
  1732. +         scr_lines(yfirst, ylast, by, 1);
  1733. +     else
  1734. +         scr_lines(ylast, yfirst, -by, -1);
  1735. + }
  1736. + 
  1737. + /* Reset internal administration accordingly */
  1738. + 
  1739. + Hidden Procedure scr_lines(yfrom, yto, n, dy)
  1740. +      int yfrom;
  1741. +      int yto;
  1742. +      int n;
  1743. +      int dy;
  1744. + {
  1745. +     register int y, x;
  1746. +     char *savedata;
  1747. +     char *savemode;
  1748. + 
  1749. +     while (n-- > 0) {
  1750. +         savedata = linedata[yfrom];
  1751. +         savemode= linemode[yfrom];
  1752. +         for (y = yfrom; y != yto; y += dy) {
  1753. +             linedata[y] = linedata[y+dy];
  1754. +             linemode[y] = linemode[y+dy];
  1755. +             lenline[y] = lenline[y+dy];
  1756. +         }
  1757. +         linedata[yto] = savedata;
  1758. +         linemode[yto] = savemode;
  1759. +         for (x = 0; x < cols; x++ ) {
  1760. +             linedata[yto][x] = ' ';
  1761. +             linemode[yto][x] = PLAIN;
  1762. +         }
  1763. +         lenline[yto] = 0;
  1764. +     }
  1765. + }
  1766. + 
  1767. + Hidden Procedure lf_scroll(yto, by)
  1768. +      int yto;
  1769. +      int by;
  1770. + {
  1771. +     register int n = by;
  1772. + 
  1773. +     move(lines-1, 0);
  1774. +     while (n-- > 0) {
  1775. +         putch('\n');
  1776. +     }
  1777. +     scr_lines(0, lines-1, by, 1);
  1778. +     move_lines(lines-1-by, lines-1, lines-1-yto, -1);
  1779. +     clear_lines(yto-by+1, yto);
  1780. + }
  1781. + 
  1782. + /* for dumb scrolling, uses and updates internal administration */
  1783. + 
  1784. + Hidden Procedure move_lines(yfrom, yto, n, dy)
  1785. +      int yfrom;
  1786. +      int yto;
  1787. +      int n;
  1788. +      int dy;
  1789. + {
  1790. +     while (n-- > 0) {
  1791. +         put_line(yto, 0, linedata[yfrom], linemode[yfrom], lenline[yfrom]);
  1792. +         yfrom += dy;
  1793. +         yto += dy;
  1794. +     }
  1795. + }
  1796. + 
  1797. + Hidden Procedure ring_bell()
  1798. + {
  1799. +     switch (scr_mode) {
  1800. +     case BIOS:
  1801. +         regs.h.al = '\007';
  1802. +         regs.h.bl = V_NORMAL;
  1803. +         bios10(14);
  1804. +         break;
  1805. +     case ANSI:
  1806. +         putch('\007');
  1807. +         break;
  1808. +     }
  1809. + }
  1810. + 
  1811. + /*
  1812. +  * Show the current internal statuses of the screen on vtrmfp.
  1813. +  * For debugging only.
  1814. +  */
  1815. + 
  1816. + #ifdef SHOW
  1817. + Visible Procedure trmshow(s)
  1818. +      char *s;
  1819. + {
  1820. +     int y, x;
  1821. + 
  1822. +     if (!vtrmfp)
  1823. +         return;
  1824. +     fprintf(vtrmfp, "<<< %s >>>\n", s);
  1825. +     for (y = 0; y < lines; y++) {
  1826. +         for (x = 0; x <= lenline[y] /*** && x < cols ***/ ; x++) {
  1827. +             fputc(linedata[y][x], vtrmfp);
  1828. +         }
  1829. +         fputc('\n', vtrmfp);
  1830. +         for (x = 0; x <= lenline[y] && x < cols-1; x++) {
  1831. +             if (linemode[y][x] == STANDOUT)
  1832. +                 fputc('-', vtrmfp);
  1833. +             else
  1834. +                 fputc(' ', vtrmfp);
  1835. +         }
  1836. +         fputc('\n', vtrmfp);
  1837. +     }
  1838. +     fprintf(vtrmfp, "CUR_Y = %d, CUR_X = %d.\n", cur_y, cur_x);
  1839. +     fflush(vtrmfp);
  1840. + }
  1841. + #endif
  1842. + 
  1843. + /*
  1844. +  * Interrupt handling.
  1845. +  *
  1846. +  * (This has not properly been tested, nor is it clear that
  1847. +  * this interface is what we want.  Anyway, it's here for you
  1848. +  * to experiment with.  What does it do, you may ask?
  1849. +  * Assume an interactive program which reads its characters
  1850. +  * through trminput.  Assume ^C is the interrupt character.
  1851. +  * Normally, ^C is treated just like any other character: when
  1852. +  * typed, it turns up in the input.  The program may understand
  1853. +  * input ^C as "quit from the current mode".
  1854. +  * Occasionally, the program goes into a long period of computation.
  1855. +  * Now it would be uninterruptible, except if it calls a routine,
  1856. +  * say pollinterrupt(), at times in its computational loop;
  1857. +  * pollinterrupt() magically looks ahead in the input queue, 
  1858. +  * via trmavail() and trminput(), and if it sees a ^C, discards all input
  1859. +  * before that point and returns Yes.  It also sets a flag, so that
  1860. +  * the interupt "sticks around" until either trminput or trmavail
  1861. +  * is called.  It is undefined whether typing ^C several times in
  1862. +  * a row is seen as one interrupt, or an interrupt followed by input
  1863. +  * of ^C's.  A program should be prepared for either.)
  1864. +  */
  1865. + 
  1866. + #ifdef NOT_USED
  1867. + 
  1868. + extern bool intrflag;
  1869. + 
  1870. + bool trminterrupt()
  1871. + {
  1872. +     /* Force a check for ^C which will call handler. */
  1873. +     /* (This does a ^C check even if stdin is in RAW mode. */
  1874. +     (void) kbhit();
  1875. +     return intrflag;
  1876. + }
  1877. + 
  1878. + #endif /* NOT_USED */
  1879. + 
  1880. + 
  1881. + /* Definitions for DOS function calls. */
  1882. + 
  1883. + #define IOCTL        0x44
  1884. + #define IOCTL_GETDATA    0x4400
  1885. + #define IOCTL_SETDATA    0x4401
  1886. + #define DEVICEBIT    0x80
  1887. + #define RAWBIT        0x20
  1888. + 
  1889. + #define BREAKCK        0x33
  1890. + #define GET        0x00
  1891. + #define SET        0x01
  1892. + 
  1893. + #define IOCTL_GETSTS    0x4406
  1894. + 
  1895. + /*
  1896. +  * Terminal input without echo.
  1897. +  */
  1898. + 
  1899. + Visible int trminput()
  1900. + {
  1901. +     char c;
  1902. + 
  1903. + #ifdef NOT_USED
  1904. +     intrflag= No;
  1905. + #endif
  1906. +     /* Assume stdin is in RAW mode; this turns echo and ^C checks off. */
  1907. +     if (read(STDIN_HANDLE, &c, 1) < 1)
  1908. +         return -1;
  1909. +     else
  1910. +         return c;
  1911. + }
  1912. + 
  1913. + /*
  1914. +  * Check for character available.
  1915. +  *
  1916. +  */
  1917. + 
  1918. + Visible bool trmavail()
  1919. + {
  1920. + #ifdef NOT_USED
  1921. +     intrflag= No;
  1922. + #endif
  1923. +     regs.x.ax = IOCTL_GETSTS;
  1924. +     regs.x.bx = STDIN_HANDLE;
  1925. +     intdos(®s, ®s);
  1926. +     if (regs.x.cflag)
  1927. +         return -1; /* Error */
  1928. +     return regs.h.al != 0;
  1929. + }
  1930. + 
  1931. + /* Issue an IOCTL to turn RAW for a device on or off. */
  1932. + 
  1933. + Hidden Procedure setraw(handle, raw)
  1934. +      int handle;
  1935. +      bool raw;
  1936. + {
  1937. +     regs.x.ax = IOCTL_GETDATA;
  1938. +     regs.x.bx = handle;
  1939. +     intdos(®s, ®s);
  1940. +     if (regs.x.cflag || !(regs.h.dl & DEVICEBIT))
  1941. +         return; /* Error or not a device -- ignore it */
  1942. +     regs.h.dh = 0;
  1943. +     if (raw)
  1944. +         regs.h.dl |= RAWBIT;
  1945. +     else
  1946. +         regs.h.dl &= ~RAWBIT;
  1947. +     regs.x.ax = IOCTL_SETDATA;
  1948. +     intdos(®s, ®s);
  1949. +     /* Ignore errors */
  1950. + }
  1951. + 
  1952. + /* Get the raw bit of a device. */
  1953. + 
  1954. + Hidden int getraw(handle)
  1955. +      int handle;
  1956. + {
  1957. +     regs.x.ax = IOCTL_GETDATA;
  1958. +     regs.x.bx = handle;
  1959. +     intdos(®s, ®s);
  1960. +     return !regs.x.cflag &&
  1961. +         (regs.h.dh & (DEVICEBIT|RAWBIT)) == (DEVICEBIT|RAWBIT);
  1962. + }
  1963. + 
  1964. + /* Set the break status. */
  1965. + 
  1966. + Hidden Procedure setbreak(on)
  1967. +      bool on;
  1968. + {
  1969. +     bdos(BREAKCK, on, SET);
  1970. + }
  1971. + 
  1972. + /* Get the break status. */
  1973. + 
  1974. + Hidden int getbreak()
  1975. + {
  1976. +     regs.x.ax = (BREAKCK << 8) | GET;
  1977. +     intdos(®s, ®s);
  1978. +     return regs.h.dl;
  1979. + }
  1980. + 
  1981. + Visible int trmsuspend()
  1982. + {
  1983. +     return spawnlp(P_WAIT, "COMMAND.COM", NULL) == 0;
  1984. + }
  1985. *** /dev/null    Fri Jun  7 14:31:40 1991
  1986. --- stdwin/Ports/vtrm/os.h    Tue May 14 13:45:59 1991
  1987. ***************
  1988. *** 0 ****
  1989. --- 1,33 ----
  1990. + /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1991. */
  1991. + 
  1992. + /* Auto-configuration file for vtrm.
  1993. +    Edit this if you have portability problems. */
  1994. + 
  1995. + #include <stdio.h>
  1996. + #include <ctype.h>
  1997. + #include <string.h>        /* Or <strings.h> for 4.2 BSD */
  1998. + 
  1999. + /* is this a termio system ? */
  2000. + #ifdef SYSV
  2001. + #define HAS_TERMIO
  2002. + #endif
  2003. + 
  2004. + /* 4.2 BSD select() system call available ? */
  2005. + #ifndef SYSV
  2006. + #define HAS_SELECT
  2007. + #endif
  2008. + 
  2009. + /* can #include <signal.h> ? */
  2010. + #define SIGNAL
  2011. + 
  2012. + #ifdef SIGNAL
  2013. + #define SIGTYPE void
  2014. + /* type returned by signal handler function: (used to be int) */
  2015. + #endif
  2016. + 
  2017. + /* can #include <setjmp.h> ? */
  2018. + #define SETJMP
  2019. + 
  2020. + /* VOID is used in casts only, for quieter lint */
  2021. + /* make it empty if your compiler doesn't have void */
  2022. + #define VOID (void)
  2023. *** 0.9.5/Ports/x11/dialog.c    Thu Oct 18 13:58:40 1990
  2024. --- stdwin/Ports/x11/dialog.c    Wed Apr  3 22:10:08 1991
  2025. ***************
  2026. *** 3,8 ****
  2027. --- 3,16 ----
  2028.   #include "x11.h"
  2029.   #include "llevent.h"
  2030.   
  2031. + /* Forward static function declarations */
  2032. + 
  2033. + static int dialog _ARGS((char *, char *, int, int, int));
  2034. + static void addbutton _ARGS((int, char *, int, bool, int, int, int, int));
  2035. + static int dialogeventloop _ARGS((int));
  2036. + static int charcode _ARGS((XKeyEvent *));
  2037. + static bool addchar _ARGS((int));
  2038. + 
  2039.   /* The kinds of dialogs we know */
  2040.   
  2041.   #define MESSAGEKIND    0
  2042. ***************
  2043. *** 76,81 ****
  2044. --- 84,97 ----
  2045.   static int promptwidth;
  2046.   static int buttonwidth;
  2047.   
  2048. + /* Forward static function declarations */
  2049. + 
  2050. + static bool buttonevent _ARGS((struct button *, XEvent *));
  2051. + static void drawbutton _ARGS((struct button *));
  2052. + static void hilitebutton _ARGS((struct button *, bool));
  2053. + static void gettext _ARGS((char *, int));
  2054. + static void killbuttons _ARGS((void));
  2055. + 
  2056.   /* Dialog routine.
  2057.      Create the window and subwindows, then engage in interaction.
  2058.      Return the proper return value for waskync or waskstr.
  2059. ***************
  2060. *** 191,200 ****
  2061.       
  2062.       /* Create the box window and its GC */
  2063.       
  2064. !     fg= _wgetpixel("menuForeground", "Foreground",
  2065. !                         BlackPixelOfScreen(_ws));
  2066. !     bg= _wgetpixel("menuBackground", "Background",
  2067. !                         WhitePixelOfScreen(_ws));
  2068.       box.border= 2*IBORDER;
  2069.       (void) _wcreate(&box, RootWindowOfScreen(_ws), 0, FALSE, fg, bg);
  2070.       _wsaveunder(&box, True);
  2071. --- 207,214 ----
  2072.       
  2073.       /* Create the box window and its GC */
  2074.       
  2075. !     fg = _wgetpixel("menuForeground", "MenuForeground", _w_fgcolor);
  2076. !     bg = _wgetpixel("menuBackground", "MenuBackground", _w_bgcolor);
  2077.       box.border= 2*IBORDER;
  2078.       (void) _wcreate(&box, RootWindowOfScreen(_ws), 0, FALSE, fg, bg);
  2079.       _wsaveunder(&box, True);
  2080. ***************
  2081. *** 201,206 ****
  2082. --- 215,221 ----
  2083.       XSelectInput(_wd, box.wid,
  2084.           ExposureMask|KeyPressMask|StructureNotifyMask);
  2085.       b_gc= _wgcreate(box.wid, _wf->fid, fg, bg);
  2086. +     XSetPlaneMask(_wd, b_gc, fg ^ bg);
  2087.       
  2088.       /* Keep window managers happy:
  2089.          a name for WM's that insist on displaying a window title;
  2090. ***************
  2091. *** 330,336 ****
  2092.   
  2093.   /* Add a command button */
  2094.   
  2095. ! static
  2096.   addbutton(type, text, ret, def, x, y, width, height)
  2097.       int type;
  2098.       char *text;
  2099. --- 345,351 ----
  2100.   
  2101.   /* Add a command button */
  2102.   
  2103. ! static void
  2104.   addbutton(type, text, ret, def, x, y, width, height)
  2105.       int type;
  2106.       char *text;
  2107. ***************
  2108. *** 559,565 ****
  2109.   
  2110.   /* Draw procedure to draw a command button or text item */
  2111.   
  2112. ! static
  2113.   drawbutton(bp)
  2114.       struct button *bp;
  2115.   {
  2116. --- 574,580 ----
  2117.   
  2118.   /* Draw procedure to draw a command button or text item */
  2119.   
  2120. ! static void
  2121.   drawbutton(bp)
  2122.       struct button *bp;
  2123.   {
  2124. ***************
  2125. *** 590,596 ****
  2126.   
  2127.   /* Highlight or unhighlight a command button */
  2128.   
  2129. ! static
  2130.   hilitebutton(bp, hilite)
  2131.       struct button *bp;
  2132.       bool hilite;
  2133. --- 605,611 ----
  2134.   
  2135.   /* Highlight or unhighlight a command button */
  2136.   
  2137. ! static void
  2138.   hilitebutton(bp, hilite)
  2139.       struct button *bp;
  2140.       bool hilite;
  2141. ***************
  2142. *** 604,610 ****
  2143.   
  2144.   /* Extract the text from the text item */
  2145.   
  2146. ! static
  2147.   gettext(buf, len)
  2148.       char *buf;
  2149.       int len;
  2150. --- 619,625 ----
  2151.   
  2152.   /* Extract the text from the text item */
  2153.   
  2154. ! static void
  2155.   gettext(buf, len)
  2156.       char *buf;
  2157.       int len;
  2158. ***************
  2159. *** 619,625 ****
  2160.   
  2161.   /* Destroy all buttons and associated data structures */
  2162.   
  2163. ! static
  2164.   killbuttons()
  2165.   {
  2166.       int i;
  2167. --- 634,640 ----
  2168.   
  2169.   /* Destroy all buttons and associated data structures */
  2170.   
  2171. ! static void
  2172.   killbuttons()
  2173.   {
  2174.       int i;
  2175. *** 0.9.5/Ports/x11/draw.c    Thu Oct 18 13:58:40 1990
  2176. --- stdwin/Ports/x11/draw.c    Tue May 14 13:47:44 1991
  2177. ***************
  2178. *** 6,29 ****
  2179.   
  2180.   static Window wid;
  2181.   static GC gc;
  2182. ! static unsigned long fg, bg;
  2183.   
  2184. - /* Start using the given Window ID, GC, fg and bg.
  2185. -    (I had hoped to use this from the Dialog and Menu modules,
  2186. -    but this hope didn't come true.) */
  2187. - 
  2188. - static void
  2189. - _wusewgc(awid, agc, afg, abg)
  2190. -     Window awid;
  2191. -     GC agc;
  2192. -     unsigned long afg, abg;
  2193. - {
  2194. -     wid= awid;
  2195. -     gc= agc;
  2196. -     fg= afg;
  2197. -     bg= abg;
  2198. - }
  2199. - 
  2200.   /* Put the current font's ID in the current GC, if non-null.
  2201.      Called by _wfontswitch. */
  2202.   
  2203. --- 6,13 ----
  2204.   
  2205.   static Window wid;
  2206.   static GC gc;
  2207. ! COLOR _w_fgcolor, _w_bgcolor;
  2208.   
  2209.   /* Put the current font's ID in the current GC, if non-null.
  2210.      Called by _wfontswitch. */
  2211.   
  2212. ***************
  2213. *** 43,48 ****
  2214. --- 27,33 ----
  2215.      should occur. */
  2216.   
  2217.   static TEXTATTR saveattr;
  2218. + static COLOR savefgcolor, savebgcolor;
  2219.   
  2220.   void
  2221.   wbegindrawing(win)
  2222. ***************
  2223. *** 51,58 ****
  2224.       _wtrace(4, "wbegindrawing(win = 0x%lx)", (long)win);
  2225.       if (wid != 0)
  2226.           _werror("recursive wbegindrawing");
  2227. !     _wusewgc(win->wa.wid, win->gca, win->fga, win->bga);
  2228.       saveattr= wattr;
  2229.       wsettextattr(&win->attr);
  2230.       if (win->caretshown)
  2231.           _winvertcaret(win); /* Hide caret temporarily */
  2232. --- 36,50 ----
  2233.       _wtrace(4, "wbegindrawing(win = 0x%lx)", (long)win);
  2234.       if (wid != 0)
  2235.           _werror("recursive wbegindrawing");
  2236. !     savefgcolor = _w_fgcolor;
  2237. !     savebgcolor = _w_bgcolor;
  2238.       saveattr= wattr;
  2239. +     wid = win->wa.wid;
  2240. +     gc = win->gca;
  2241. +     _w_fgcolor = win->fga;
  2242. +     _w_bgcolor = win->bga;
  2243. +     XSetForeground(_wd, gc, (unsigned long) _w_fgcolor);
  2244. +     XSetBackground(_wd, gc, (unsigned long) _w_bgcolor);
  2245.       wsettextattr(&win->attr);
  2246.       if (win->caretshown)
  2247.           _winvertcaret(win); /* Hide caret temporarily */
  2248. ***************
  2249. *** 68,76 ****
  2250.       if (wid != win->wa.wid)
  2251.           _werror("wrong call to enddrawing");
  2252.       else {
  2253.           if (win->caretshown)
  2254.               _winvertcaret(win); /* Put it back on */
  2255. !         _wusewgc((Window)0, (GC)0, 0L, 0L); /* Clear all */
  2256.           wsettextattr(&saveattr);
  2257.           XFlush(_wd);
  2258.       }
  2259. --- 60,74 ----
  2260.       if (wid != win->wa.wid)
  2261.           _werror("wrong call to enddrawing");
  2262.       else {
  2263. +         wnoclip();
  2264.           if (win->caretshown)
  2265.               _winvertcaret(win); /* Put it back on */
  2266. !         _w_fgcolor = savefgcolor;
  2267. !         _w_bgcolor = savebgcolor;
  2268. !         XSetForeground(_wd, gc, (unsigned long) _w_fgcolor);
  2269. !         XSetBackground(_wd, gc, (unsigned long) _w_bgcolor);
  2270. !         wid = 0;
  2271. !         gc = 0;
  2272.           wsettextattr(&saveattr);
  2273.           XFlush(_wd);
  2274.       }
  2275. ***************
  2276. *** 230,237 ****
  2277. --- 228,237 ----
  2278.       _wtrace(7, "wxorline((h1,v1)=(%d,%d), (h2,v2)=(%d,%d))",
  2279.           h1, v1, h2, v2);
  2280.       XSetFunction(_wd, gc, GXinvert);
  2281. +     XSetPlaneMask(_wd, gc, _w_fgcolor ^ _w_bgcolor);
  2282.       XDrawLine(_wd, wid, gc, h1, v1, h2, v2);
  2283.       XSetFunction(_wd, gc, GXcopy);
  2284. +     XSetPlaneMask(_wd, gc, AllPlanes);
  2285.   }
  2286.   
  2287.   /* Draw a rectangle *inside* the given coordinate box */
  2288. ***************
  2289. *** 259,267 ****
  2290.          Can't set function to GXclear because it doesn't work
  2291.          with color.  So we fill with the background color. */
  2292.       
  2293. !     XSetForeground(_wd, gc, bg);
  2294.       XFillRectangle(_wd, wid, gc, left, top, right-left, bottom-top);
  2295. !     XSetForeground(_wd, gc, fg);
  2296.   }
  2297.   
  2298.   /* Invert the bits in the given rectangle.
  2299. --- 259,267 ----
  2300.          Can't set function to GXclear because it doesn't work
  2301.          with color.  So we fill with the background color. */
  2302.       
  2303. !     XSetForeground(_wd, gc, (unsigned long) _w_bgcolor);
  2304.       XFillRectangle(_wd, wid, gc, left, top, right-left, bottom-top);
  2305. !     XSetForeground(_wd, gc, (unsigned long) _w_fgcolor);
  2306.   }
  2307.   
  2308.   /* Invert the bits in the given rectangle.
  2309. ***************
  2310. *** 275,282 ****
  2311.       
  2312.       if (left >= right || top >= bottom)
  2313.           return;
  2314. !     
  2315.       _winvert(wid, gc, left, top, right-left, bottom-top);
  2316.   }
  2317.   
  2318.   /* Paint a given rectangle black */
  2319. --- 275,287 ----
  2320.       
  2321.       if (left >= right || top >= bottom)
  2322.           return;
  2323. ! 
  2324. !     /* _winvert assumes the plane mask is the XOR of fg and bg color;
  2325. !        this is no longer standard now we support colors... */
  2326. ! 
  2327. !     XSetPlaneMask(_wd, gc, _w_fgcolor ^ _w_bgcolor);
  2328.       _winvert(wid, gc, left, top, right-left, bottom-top);
  2329. +     XSetPlaneMask(_wd, gc, AllPlanes);
  2330.   }
  2331.   
  2332.   /* Paint a given rectangle black */
  2333. ***************
  2334. *** 318,327 ****
  2335.       int radius;
  2336.   {
  2337.       _wtrace(7, "wdrawcircle(h=%d, v=%d, radius=%d)", h, v, radius);
  2338. !     XDrawArc(_wd, wid, gc, h-radius, v-radius, 2*radius, 2*radius,
  2339.           0, 360*64);
  2340.   }
  2341.   
  2342.   /* Draw an elliptical arc.
  2343.      The begin and end angles are specified in degrees (I'm not sure this
  2344.      is a good idea, but I don't like X's degrees*64 either...).
  2345. --- 323,360 ----
  2346.       int radius;
  2347.   {
  2348.       _wtrace(7, "wdrawcircle(h=%d, v=%d, radius=%d)", h, v, radius);
  2349. !     XDrawArc(_wd, wid, gc, h-radius, v-radius, 2*radius-1, 2*radius-1,
  2350.           0, 360*64);
  2351.   }
  2352.   
  2353. + /* Fill a circle with given center and radius */
  2354. + 
  2355. + void
  2356. + wfillcircle(h, v, radius)
  2357. +     int h, v;
  2358. +     int radius;
  2359. + {
  2360. +     _wtrace(7, "wfillcircle(h=%d, v=%d, radius=%d)", h, v, radius);
  2361. +     XFillArc(_wd, wid, gc, h-radius, v-radius, 2*radius-1, 2*radius-1,
  2362. +         0, 360*64);
  2363. + }
  2364. + 
  2365. + /* Invert a circle with given center and radius */
  2366. + 
  2367. + void
  2368. + wxorcircle(h, v, radius)
  2369. +     int h, v;
  2370. +     int radius;
  2371. + {
  2372. +     _wtrace(7, "wfillcircle(h=%d, v=%d, radius=%d)", h, v, radius);
  2373. +     XSetFunction(_wd, gc, GXinvert);
  2374. +     XSetPlaneMask(_wd, gc, _w_fgcolor ^ _w_bgcolor);
  2375. +     XFillArc(_wd, wid, gc, h-radius, v-radius, 2*radius-1, 2*radius-1,
  2376. +         0, 360*64);
  2377. +     XSetFunction(_wd, gc, GXcopy);
  2378. +     XSetPlaneMask(_wd, gc, AllPlanes);
  2379. + }
  2380. + 
  2381.   /* Draw an elliptical arc.
  2382.      The begin and end angles are specified in degrees (I'm not sure this
  2383.      is a good idea, but I don't like X's degrees*64 either...).
  2384. ***************
  2385. *** 336,345 ****
  2386.   {
  2387.       _wtrace(7, "wdrawelarc(%d, %d, %d, %d, %d, %d)",
  2388.           h, v, hhalf, vhalf, angle1, angle2);
  2389. !     XDrawArc(_wd, wid, gc, h-hhalf, v-vhalf, 2*hhalf, 2*vhalf,
  2390.           angle1*64, angle2*64);
  2391.   }
  2392.   
  2393.   /* Clip drawing output to a rectangle. */
  2394.   
  2395.   void
  2396. --- 369,449 ----
  2397.   {
  2398.       _wtrace(7, "wdrawelarc(%d, %d, %d, %d, %d, %d)",
  2399.           h, v, hhalf, vhalf, angle1, angle2);
  2400. !     XDrawArc(_wd, wid, gc, h-hhalf, v-vhalf, 2*hhalf-1, 2*vhalf-1,
  2401.           angle1*64, angle2*64);
  2402.   }
  2403.   
  2404. + /* Fill an elliptical arc segment */
  2405. + 
  2406. + void
  2407. + wfillelarc(h, v, hhalf, vhalf, angle1, angle2)
  2408. +     int h, v;        /* Center */
  2409. +     int hhalf, vhalf;    /* Half axes */
  2410. +     int angle1, angle2;    /* Begin, end angle */
  2411. + {
  2412. +     _wtrace(7, "wfillelarc(%d, %d, %d, %d, %d, %d)",
  2413. +         h, v, hhalf, vhalf, angle1, angle2);
  2414. +     XFillArc(_wd, wid, gc, h-hhalf, v-vhalf, 2*hhalf-1, 2*vhalf-1,
  2415. +         angle1*64, angle2*64);
  2416. + }
  2417. + 
  2418. + /* Invert an elliptical arc segment */
  2419. + 
  2420. + void
  2421. + wxorelarc(h, v, hhalf, vhalf, angle1, angle2)
  2422. +     int h, v;        /* Center */
  2423. +     int hhalf, vhalf;    /* Half axes */
  2424. +     int angle1, angle2;    /* Begin, end angle */
  2425. + {
  2426. +     _wtrace(7, "wfillelarc(%d, %d, %d, %d, %d, %d)",
  2427. +         h, v, hhalf, vhalf, angle1, angle2);
  2428. +     XSetFunction(_wd, gc, GXinvert);
  2429. +     XSetPlaneMask(_wd, gc, _w_fgcolor ^ _w_bgcolor);
  2430. +     XFillArc(_wd, wid, gc, h-hhalf, v-vhalf, 2*hhalf-1, 2*vhalf-1,
  2431. +         angle1*64, angle2*64);
  2432. +     XSetFunction(_wd, gc, GXcopy);
  2433. +     XSetPlaneMask(_wd, gc, AllPlanes);
  2434. + }
  2435. + 
  2436. + /* Draw n-1 lines connecting n points */
  2437. + 
  2438. + void
  2439. + wdrawpoly(n, points)
  2440. +     int n;
  2441. +     POINT *points;
  2442. + {
  2443. +     _wtrace(7, "wdrawpoly(%d, ...)", n);
  2444. +     XDrawLines(_wd, wid, gc, (XPoint *)points, n, CoordModeOrigin);
  2445. + }
  2446. + 
  2447. + /* Fill a polygon given by n points (may be self-intersecting) */
  2448. + 
  2449. + void
  2450. + wfillpoly(n, points)
  2451. +     int n;
  2452. +     POINT *points;
  2453. + {
  2454. +     _wtrace(7, "wfillpoly(%d, ...)", n);
  2455. +     XFillPolygon(_wd, wid, gc, (XPoint *)points, n,
  2456. +              Complex, CoordModeOrigin);
  2457. + }
  2458. + 
  2459. + /* Invert a polygon given by n points (may be self-intersecting) */
  2460. + 
  2461. + void
  2462. + wxorpoly(n, points)
  2463. +     int n;
  2464. +     POINT *points;
  2465. + {
  2466. +     _wtrace(7, "wfillpoly(%d, ...)", n);
  2467. +     XSetFunction(_wd, gc, GXinvert);
  2468. +     XSetPlaneMask(_wd, gc, _w_fgcolor ^ _w_bgcolor);
  2469. +     XFillPolygon(_wd, wid, gc, (XPoint *)points, n,
  2470. +              Complex, CoordModeOrigin);
  2471. +     XSetFunction(_wd, gc, GXcopy);
  2472. +     XSetPlaneMask(_wd, gc, AllPlanes);
  2473. + }
  2474. + 
  2475.   /* Clip drawing output to a rectangle. */
  2476.   
  2477.   void
  2478. ***************
  2479. *** 362,365 ****
  2480. --- 466,518 ----
  2481.   wnoclip()
  2482.   {
  2483.       XSetClipMask(_wd, gc, None);
  2484. + }
  2485. + 
  2486. + 
  2487. + /* Color stuff. */
  2488. + 
  2489. + void
  2490. + _w_initcolors()
  2491. + {
  2492. +     _w_fgcolor = _wgetpixel("foreground", "Foreground",
  2493. +                         BlackPixelOfScreen(_ws));
  2494. +     _w_bgcolor = _wgetpixel("background", "Background",
  2495. +                         WhitePixelOfScreen(_ws));
  2496. +     
  2497. +     /* Swap the pixel values if 'reverse' specified */
  2498. +     if (_wgetbool("reverse", "Reverse", 0)) {
  2499. +         unsigned long temp= _w_fgcolor;
  2500. +         _w_fgcolor = _w_bgcolor;
  2501. +         _w_bgcolor = temp;
  2502. +     }
  2503. + }
  2504. + 
  2505. + COLOR
  2506. + wgetfgcolor()
  2507. + {
  2508. +     return _w_fgcolor;
  2509. + }
  2510. + 
  2511. + COLOR
  2512. + wgetbgcolor()
  2513. + {
  2514. +     return _w_bgcolor;
  2515. + }
  2516. + 
  2517. + void
  2518. + wsetfgcolor(color)
  2519. +     COLOR color;
  2520. + {
  2521. +     _w_fgcolor = color;
  2522. +     if (gc != 0)
  2523. +         XSetForeground(_wd, gc, (unsigned long) _w_fgcolor);
  2524. + }
  2525. + 
  2526. + void
  2527. + wsetbgcolor(color)
  2528. +     COLOR color;
  2529. + {
  2530. +     _w_bgcolor = color;
  2531. +     if (gc != 0)
  2532. +         XSetBackground(_wd, gc, (unsigned long) _w_bgcolor);
  2533.   }
  2534.