home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3470 < prev    next >
Internet Message Format  |  1991-06-07  |  56KB
  1. From: guido@cwi.nl (Guido van Rossum)
  2. Newsgroups: alt.sources
  3. Subject: STDWIN 0.9.6 patches, part 2/5
  4. Message-ID: <3648@charon.cwi.nl>
  5. Date: 7 Jun 91 13:32:00 GMT
  6.  
  7. Archive-name: stdwin0.9.6/patch2
  8.  
  9. *** 0.9.5/Packs/textedit/editwin.c    Mon Oct 22 13:36:35 1990
  10. --- stdwin/Packs/textedit/editwin.c    Tue May 28 22:57:27 1991
  11. ***************
  12. *** 63,73 ****
  13. --- 63,77 ----
  14.   {
  15.       EDITWIN *ew= ALLOC(EDITWIN);
  16.       int width, height;
  17. +     int hbar, vbar;
  18.       int i;
  19.       
  20.       if (ew == NULL)
  21.           return NULL;
  22. +     wgetdefscrollbars(&hbar, &vbar);
  23. +     wsetdefscrollbars(0, 1);
  24.       ew->win= wopen(filename==NULL ? "Untitled" : filename, ewdrawproc);
  25. +     wsetdefscrollbars(hbar, vbar);
  26.       if (ew->win == NULL) {
  27.           FREE(ew);
  28.           return NULL;
  29. ***************
  30. *** 335,340 ****
  31. --- 339,348 ----
  32.           }
  33.           break;
  34.           
  35. +     case WE_CLOSE:
  36. +         closed= ewclose(ew);
  37. +         break;
  38. + 
  39.       case WE_COMMAND:
  40.           if (e->u.command == WC_CLOSE) {
  41.               closed= ewclose(ew);
  42. ***************
  43. *** 345,351 ****
  44.               e->u.command == WC_TAB ||
  45.               e->u.command == WC_BACKSPACE)
  46.               change= TRUE;
  47. !             goto def;
  48.       
  49.       case WE_MOUSE_DOWN:
  50.           /* Edit the coordinates slightly so teevent always
  51. --- 353,359 ----
  52.               e->u.command == WC_TAB ||
  53.               e->u.command == WC_BACKSPACE)
  54.               change= TRUE;
  55. !         goto def; /* Go pass it on to teevent */
  56.       
  57.       case WE_MOUSE_DOWN:
  58.           /* Edit the coordinates slightly so teevent always
  59. *** 0.9.5/Packs/textedit/text.h    Thu Oct 18 14:00:07 1990
  60. --- stdwin/Packs/textedit/text.h    Tue May 28 22:57:58 1991
  61. ***************
  62. *** 22,28 ****
  63.   struct _textedit {
  64.       /* Drawing environment */
  65.       WINDOW *win;
  66. !     coord left, top, right, bottom;
  67.       hcoord width;    /* == right-left */
  68.       TEXTATTR attr;    /* Text attributes */
  69.       vcoord vspace;    /* Vertical spacing (line height) */
  70. --- 22,28 ----
  71.   struct _textedit {
  72.       /* Drawing environment */
  73.       WINDOW *win;
  74. !     coord left, top, right, bottom;        /* Text area */
  75.       hcoord width;    /* == right-left */
  76.       TEXTATTR attr;    /* Text attributes */
  77.       vcoord vspace;    /* Vertical spacing (line height) */
  78. ***************
  79. *** 55,61 ****
  80.       coord opt_h, opt_v;    /* Caret position in window */
  81.       hcoord opt_avail;    /* White pixels at end of line */
  82.       hcoord opt_end;        /* End of line or next tab stop */
  83. !     
  84.       /* NB: aim, opt_h, opt_v are in window coordinates,
  85.              i.e., tp->left or tp->top has already been added */
  86.   };
  87. --- 55,65 ----
  88.       coord opt_h, opt_v;    /* Caret position in window */
  89.       hcoord opt_avail;    /* White pixels at end of line */
  90.       hcoord opt_end;        /* End of line or next tab stop */
  91. ! 
  92. !     /* View restriction */
  93. !     coord vleft, vtop, vright, vbottom;    /* View area */
  94. !     tbool viewing;                /* TRUE to enable view */
  95. ! 
  96.       /* NB: aim, opt_h, opt_v are in window coordinates,
  97.              i.e., tp->left or tp->top has already been added */
  98.   };
  99. *** 0.9.5/Packs/textedit/textedit.c    Thu Feb 21 10:53:57 1991
  100. --- stdwin/Packs/textedit/textedit.c    Tue May 28 23:18:47 1991
  101. ***************
  102. *** 30,35 ****
  103. --- 30,67 ----
  104.       teinsert(tp, cbuf, 1);
  105.   }
  106.   
  107. + /* Interfaces for wchange and wscroll that clip to the viewing rectangle */
  108. + 
  109. + static void
  110. + techange(tp, left, top, right, bottom)
  111. +     TEXTEDIT *tp;
  112. +     int left, top, right, bottom;
  113. + {
  114. +     if (tp->viewing) {
  115. +         CLIPMIN(left, tp->vleft);
  116. +         CLIPMIN(top, tp->vtop);
  117. +         CLIPMAX(right, tp->vright);
  118. +         CLIPMAX(bottom, tp->vbottom);
  119. +     }
  120. +     wchange(tp->win, left, top, right, bottom);
  121. + }
  122. + 
  123. + static void
  124. + tescroll(tp, left, top, right, bottom, dh, dv)
  125. +     TEXTEDIT *tp;
  126. +     int left, top, right, bottom;
  127. +     int dh, dv;
  128. + {
  129. +     if (tp->viewing) {
  130. +         CLIPMIN(left, tp->vleft);
  131. +         CLIPMIN(top, tp->vtop);
  132. +         CLIPMAX(right, tp->vright);
  133. +         CLIPMAX(bottom, tp->vbottom);
  134. +     }
  135. +     wscroll(tp->win, left, top, right, bottom, dh, dv);
  136. +     /* XXX Should call wchange for bits scrolled in from outside view? */
  137. + }
  138. + 
  139.   /* Optimization for the common case insert char.
  140.      Assumes text measurement is additive. */
  141.   
  142. ***************
  143. *** 110,128 ****
  144.       tp->opt_avail -= w;
  145.       if (tp->active)
  146.           wnocaret(tp->win);
  147. !     wscroll(tp->win,
  148.           tp->opt_h, tp->opt_v,
  149.           tp->opt_end, tp->opt_v + tp->vspace,
  150.           w, 0);
  151.       wbegindrawing(tp->win);
  152.       wdrawchar(tp->opt_h, tp->opt_v, c);
  153.       wenddrawing(tp->win);
  154.       tp->opt_h += w;
  155.       if (tp->active) {
  156. !         wsetcaret(tp->win, tp->opt_h, tp->opt_v);
  157. !         wshow(tp->win,
  158. !             tp->opt_h, tp->opt_v,
  159. !             tp->opt_h, tp->opt_v + tp->vspace);
  160.       }
  161.       tp->aim= tp->opt_h;
  162.       
  163. --- 142,170 ----
  164.       tp->opt_avail -= w;
  165.       if (tp->active)
  166.           wnocaret(tp->win);
  167. !     tescroll(tp,
  168.           tp->opt_h, tp->opt_v,
  169.           tp->opt_end, tp->opt_v + tp->vspace,
  170.           w, 0);
  171.       wbegindrawing(tp->win);
  172. +     if (tp->viewing)
  173. +         wcliprect(tp->vleft, tp->vtop, tp->vright, tp->vbottom);
  174.       wdrawchar(tp->opt_h, tp->opt_v, c);
  175.       wenddrawing(tp->win);
  176.       tp->opt_h += w;
  177.       if (tp->active) {
  178. !         if (!tp->viewing ||
  179. !             tp->vleft <= tp->opt_h &&
  180. !             tp->opt_h <= tp->vright &&
  181. !             tp->vtop <= tp->opt_v &&
  182. !             tp->opt_v + tp->vspace <= tp->vbottom) {
  183. !             wsetcaret(tp->win, tp->opt_h, tp->opt_v);
  184. !             wshow(tp->win,
  185. !                   tp->opt_h, tp->opt_v,
  186. !                   tp->opt_h, tp->opt_v + tp->vspace);
  187. !         }
  188. !         else
  189. !             wnocaret(tp->win);
  190.       }
  191.       tp->aim= tp->opt_h;
  192.       
  193. ***************
  194. *** 205,217 ****
  195.               lineno k= chlast;
  196.               if (shift > 0)
  197.                   k -= shift;
  198. !             wscroll(tp->win,
  199.                   tp->left, tp->top + k*tp->vspace,
  200.                   tp->right, tp->top + tp->nlines*tp->vspace,
  201.                   0, shift*tp->vspace);
  202.           }
  203.           
  204. !         wchange(tp->win,
  205.               tp->left, tp->top + chfirst*tp->vspace,
  206.               tp->right, tp->top + chlast*tp->vspace);
  207.       }
  208. --- 247,259 ----
  209.               lineno k= chlast;
  210.               if (shift > 0)
  211.                   k -= shift;
  212. !             tescroll(tp,
  213.                   tp->left, tp->top + k*tp->vspace,
  214.                   tp->right, tp->top + tp->nlines*tp->vspace,
  215.                   0, shift*tp->vspace);
  216.           }
  217.           
  218. !         techange(tp,
  219.               tp->left, tp->top + chfirst*tp->vspace,
  220.               tp->right, tp->top + chlast*tp->vspace);
  221.       }
  222. ***************
  223. *** 219,225 ****
  224.       tp->nlines= i+1;
  225.       newbottom= tp->top + tp->vspace*tp->nlines;
  226.       if (newbottom < tp->bottom)
  227. !         wchange(tp->win,
  228.               tp->left, newbottom, tp->right, tp->bottom);
  229.       tp->bottom= newbottom;
  230.       tp->aim= UNDEF;
  231. --- 261,267 ----
  232.       tp->nlines= i+1;
  233.       newbottom= tp->top + tp->vspace*tp->nlines;
  234.       if (newbottom < tp->bottom)
  235. !         techange(tp,
  236.               tp->left, newbottom, tp->right, tp->bottom);
  237.       tp->bottom= newbottom;
  238.       tp->aim= UNDEF;
  239. ***************
  240. *** 367,379 ****
  241.       case WE_MOUSE_DOWN:
  242.           {
  243.               int h= e->u.where.h, v= e->u.where.v;
  244. !             if (h >= tp->left && h <= tp->right &&
  245. !                     v >= tp->top && v <= tp->bottom)
  246. !                 teclicknew(tp, h, v,
  247. !                     e->u.where.button == 2,
  248. !                     e->u.where.clicks > 1);
  249. !             else
  250. !                 return FALSE;
  251.           }
  252.           break;
  253.       
  254. --- 409,428 ----
  255.       case WE_MOUSE_DOWN:
  256.           {
  257.               int h= e->u.where.h, v= e->u.where.v;
  258. !             if (tp->viewing) {
  259. !                 if (h < tp->vleft || h > tp->vright ||
  260. !                     v < tp->vtop || v > tp->vbottom)
  261. !                     return FALSE;
  262. !             }
  263. !             else {
  264. !                 if (h < tp->left || h > tp->right ||
  265. !                     v < tp->top || v > tp->bottom)
  266. !                     return FALSE;
  267. !             }
  268. !             teclicknew(tp, h, v,
  269. !                    e->u.where.button == 3 ||
  270. !                    (e->u.where.mask & WM_SHIFT),
  271. !                    e->u.where.clicks > 1);
  272.           }
  273.           break;
  274.       
  275. ***************
  276. *** 644,649 ****
  277. --- 693,717 ----
  278.   }
  279.   
  280.   void
  281. + tesetview(tp, left, top, right, bottom)
  282. +     TEXTEDIT *tp;
  283. +     int left, top, right, bottom;
  284. + {
  285. +     tp->viewing= TRUE;
  286. +     tp->vleft= left;
  287. +     tp->vtop= top;
  288. +     tp->vright= right;
  289. +     tp->vbottom= bottom;
  290. + }
  291. + 
  292. + void
  293. + tenoview(tp)
  294. +     TEXTEDIT *tp;
  295. + {
  296. +     tp->viewing= FALSE;
  297. + }
  298. + 
  299. + void
  300.   tesetfocus(tp, foc1, foc2)
  301.       TEXTEDIT *tp;
  302.       focpos foc1, foc2;
  303. ***************
  304. *** 712,718 ****
  305.       if (buf == NULL || buflen < 0)
  306.           return;
  307.       if (drawing)
  308. !         wchange(tp->win, tp->left, tp->top, tp->right, tp->bottom);
  309.       free(tp->buf);
  310.       tp->buf= buf;
  311.       tp->buflen= buflen;
  312. --- 780,786 ----
  313.       if (buf == NULL || buflen < 0)
  314.           return;
  315.       if (drawing)
  316. !         techange(tp, tp->left, tp->top, tp->right, tp->bottom);
  317.       free(tp->buf);
  318.       tp->buf= buf;
  319.       tp->buflen= buflen;
  320. ***************
  321. *** 721,727 ****
  322.       terecompute(tp, 0, tp->buflen);
  323.       if (drawing) {
  324.           tp->drawing= TRUE;
  325. !         wchange(tp->win, tp->left, tp->top, tp->right, tp->bottom);
  326.       }
  327.   }
  328.   
  329. --- 789,795 ----
  330.       terecompute(tp, 0, tp->buflen);
  331.       if (drawing) {
  332.           tp->drawing= TRUE;
  333. !         techange(tp, tp->left, tp->top, tp->right, tp->bottom);
  334.       }
  335.   }
  336.   
  337. *** 0.9.5/Packs/textedit/textlow.c    Mon Oct 22 13:37:36 1990
  338. --- stdwin/Packs/textedit/textlow.c    Tue May 28 23:19:12 1991
  339. ***************
  340. *** 1,5 ****
  341. --- 1,7 ----
  342.   /* Text Edit, low-level routines */
  343.   
  344. + /* XXX Should make return-less functions void */
  345. + 
  346.   /* CONVENTION:
  347.       routines beginning with te... have a first parameter 'tp';
  348.       routines beginning with z... don't, or are macros that
  349. ***************
  350. *** 199,204 ****
  351. --- 201,208 ----
  352.       tp->top= top;
  353.       tp->right= right;
  354.       tp->width= right-left;
  355. + 
  356. +     tp->viewing= FALSE;
  357.       
  358.       wgettextattr(&saveattr);
  359.       if (win != NULL) {
  360. ***************
  361. *** 247,253 ****
  362.   tedestroy(tp)
  363.       register TEXTEDIT *tp;
  364.   {
  365. !     wchange(tp->win, tp->left, tp->top, tp->right, tp->bottom);
  366.       tefree(tp);
  367.   }
  368.   
  369. --- 251,260 ----
  370.   tedestroy(tp)
  371.       register TEXTEDIT *tp;
  372.   {
  373. !     if (tp->viewing)
  374. !         wchange(tp->win, tp->vleft, tp->vtop, tp->vright, tp->vbottom);
  375. !     else
  376. !         wchange(tp->win, tp->left, tp->top, tp->right, tp->bottom);
  377.       tefree(tp);
  378.   }
  379.   
  380. ***************
  381. *** 294,299 ****
  382. --- 301,308 ----
  383.   {
  384.       if (tp->active && !tp->hilite && tp->foclen > 0) {
  385.           wbegindrawing(tp->win);
  386. +         if (tp->viewing)
  387. +             wcliprect(tp->vleft, tp->vtop, tp->vright, tp->vbottom);
  388.           teinvertfocus(tp);
  389.           wenddrawing(tp->win);
  390.           tp->hilite= TRUE;
  391. ***************
  392. *** 305,310 ****
  393. --- 314,321 ----
  394.   {
  395.       if (tp->hilite) {
  396.           wbegindrawing(tp->win);
  397. +         if (tp->viewing)
  398. +             wcliprect(tp->vleft, tp->vtop, tp->vright, tp->vbottom);
  399.           teinvertfocus(tp);
  400.           wenddrawing(tp->win);
  401.           tp->hilite= FALSE;
  402. ***************
  403. *** 327,332 ****
  404. --- 338,345 ----
  405.   {
  406.       if (tp->hilite) {
  407.           wbegindrawing(tp->win);
  408. +         if (tp->viewing)
  409. +             wcliprect(tp->vleft, tp->vtop, tp->vright, tp->vbottom);
  410.           if (f1 == tp->foc)
  411.               teinvert(tp, zfocend, f2);
  412.           else if (f2 == zfocend)
  413. ***************
  414. *** 379,385 ****
  415.       tedrawnew(tp, tp->left, tp->top, tp->right, tp->bottom);
  416.   }
  417.   
  418. - /*ARGSUSED*/
  419.   void
  420.   tedrawnew(tp, left, top, right, bottom)
  421.       register TEXTEDIT *tp;
  422. --- 392,397 ----
  423. ***************
  424. *** 386,392 ****
  425. --- 398,415 ----
  426.       coord left, top, right, bottom;
  427.   {
  428.       lineno ifirst, ilast, i;
  429. + 
  430. +     /* Clip given area to view */
  431. +     if (tp->viewing) {
  432. +         CLIPMIN(left, tp->vleft);
  433. +         CLIPMIN(top, tp->vtop);
  434. +         CLIPMAX(right, tp->vright);
  435. +         CLIPMAX(bottom, tp->vbottom);
  436. +     }
  437.       
  438. +     /* Restrict drawing to intersection of view and given area */
  439. +     wcliprect(left, top, right, bottom);
  440. +     
  441.       /* Compute first, last line to be drawn */
  442.       ifirst= (top - tp->top)/tp->vspace;
  443.       if (ifirst < 0)
  444. ***************
  445. *** 408,413 ****
  446. --- 431,439 ----
  447.       }
  448.       if (tp->hilite)
  449.           teinvertfocus(tp);
  450. +     
  451. +     /* Reset the clip rectangle */
  452. +     wnoclip();
  453.   }
  454.   
  455.   /* Move the gap to a new position */
  456. ***************
  457. *** 522,527 ****
  458. --- 548,569 ----
  459.           tp->start[i]= zgapend;
  460.   }
  461.   
  462. + /* Interface for wshow that clips to the viewing rectangle */
  463. + 
  464. + static void
  465. + teshow(tp, left, top, right, bottom)
  466. +     TEXTEDIT *tp;
  467. +     int left, top, right, bottom;
  468. + {
  469. +     if (tp->viewing) {
  470. +         CLIPMIN(left, tp->vleft);
  471. +         CLIPMIN(top, tp->vtop);
  472. +         CLIPMAX(right, tp->vright);
  473. +         CLIPMAX(bottom, tp->vbottom);
  474. +     }
  475. +     wshow(tp->win, left, top, right, bottom);
  476. + }
  477. + 
  478.   /* Set the caret at the new focus position,
  479.      or display the focus highlighting, if applicable.
  480.      Also call wshow() of the focus.
  481. ***************
  482. *** 539,545 ****
  483.       tewhichpoint(tp, tp->foc, &h, &v);
  484.       
  485.       if (tp->foclen == 0) {
  486. !         wsetcaret(tp->win, h, v);
  487.           hlast= h;
  488.           vlast= v;
  489.       }
  490. --- 581,594 ----
  491.       tewhichpoint(tp, tp->foc, &h, &v);
  492.       
  493.       if (tp->foclen == 0) {
  494. !         if (!tp->viewing ||
  495. !             tp->vleft <= h && h <= tp->vright &&
  496. !             tp->vtop <= v && v + tp->vspace <= tp->vbottom) {
  497. !             wsetcaret(tp->win, h, v);
  498. !         }
  499. !         else {
  500. !             wnocaret(tp->win);
  501. !         }
  502.           hlast= h;
  503.           vlast= v;
  504.       }
  505. ***************
  506. *** 548,554 ****
  507.           wnocaret(tp->win);
  508.           teshowfocus(tp);
  509.       }
  510. !     wshow(tp->win, h, v, hlast, vlast + tp->vspace);
  511.   }
  512.   
  513.   /* Coordinate transformations.
  514. --- 597,603 ----
  515.           wnocaret(tp->win);
  516.           teshowfocus(tp);
  517.       }
  518. !     teshow(tp, h, v, hlast, vlast + tp->vspace);
  519.   }
  520.   
  521.   /* Coordinate transformations.
  522. *** 0.9.5/Packs/vt/vt.c    Mon Oct 22 15:06:06 1990
  523. --- stdwin/Packs/vt/vt.c    Tue May 14 13:16:40 1991
  524. ***************
  525. *** 15,20 ****
  526. --- 15,21 ----
  527.                   int left, int top, int right, int bottom));
  528.   STATIC void vtdraw _ARGS((VT *vt, int r1, int c1, int r2, int c2));
  529.   STATIC void vtchrange _ARGS((VT *vt, int r1, int c1, int r2, int c2));
  530. + STATIC bool slowcirculate _ARGS((VT *vt, int r1, int r2, int n));
  531.   
  532.   /* Administration for vtfind */
  533.   
  534. *** 0.9.5/Packs/vt/vtvtrm.c    Mon Oct 22 15:46:08 1990
  535. --- stdwin/Packs/vt/vtvtrm.c    Tue May 14 13:17:29 1991
  536. ***************
  537. *** 7,12 ****
  538. --- 7,13 ----
  539.      One other thing: you'll have to call wdone() when you really exit. */
  540.   
  541.   /* XXX This has never been tested... */
  542. + /* XXX The interfaces to trmputdata and trmsense should change !!! */
  543.   
  544.   #include "vtimpl.h"
  545.   #include "vtrm.h"
  546. ***************
  547. *** 30,36 ****
  548.       *rows_return= 24;
  549.       *cols_return= 80;
  550.       *flags_return=
  551. !         HAS_STANDOUT | CAN_SCROLL | CAN_SENSE;
  552.       return TE_OK;
  553.   }
  554.   
  555. --- 31,37 ----
  556.       *rows_return= 24;
  557.       *cols_return= 80;
  558.       *flags_return=
  559. !         HAS_STANDOUT | CAN_SCROLL;
  560.       return TE_OK;
  561.   }
  562.   
  563. ***************
  564. *** 39,44 ****
  565. --- 40,46 ----
  566.       active= FALSE;
  567.   }
  568.   
  569. + /* XXX Need interface change */
  570.   trmputdata(row, col, data)
  571.       int row, col;
  572.       char *data;
  573. ***************
  574. *** 130,135 ****
  575. --- 132,138 ----
  576.       }
  577.   }
  578.   
  579. + /* XXX Need interface change */
  580.   int
  581.   trmsense(row_return, col_return)
  582.       int *row_return, *col_return;
  583. *** 0.9.5/Ports/alfa/draw.c    Tue Jan  8 13:03:32 1991
  584. --- stdwin/Ports/alfa/draw.c    Sun May 12 13:54:10 1991
  585. ***************
  586. *** 3,8 ****
  587. --- 3,9 ----
  588.   #include "alfa.h"
  589.   
  590.   static char *textline[MAXLINES];
  591. + static char *modeline[MAXLINES];
  592.   static short textlen[MAXLINES];
  593.   static char texttouched[MAXLINES];
  594.   
  595. ***************
  596. *** 112,117 ****
  597. --- 113,119 ----
  598.       for (i= top; i < bottom; ++i)
  599.           uptodate[i] = FALSE;
  600.   #else
  601. +     /* XXX This code was never fixed to update the mode array */
  602.       char *p;
  603.   
  604.       if(dv==0)
  605. ***************
  606. *** 238,255 ****
  607.   wbegindrawing(win)
  608.       WINDOW *win;
  609.   {
  610. !     int i;
  611.       
  612.       if (draw_win != NULL)
  613.           wenddrawing(draw_win); /* Finish previous job */
  614.       
  615. !     /* Auto-initialization of the textline array.
  616.          The other arrays needn't be initialized,
  617.          since they are preset to zero. */
  618.       for (i= win->top; i < win->bottom; ++i) {
  619.           if (textline[i] == NULL)
  620.               textline[i]= malloc((unsigned) (columns+1));
  621. !             /*uptodate[i]= FALSE;*/
  622.       }
  623.       
  624.       draw_saveattr= wattr;
  625. --- 240,262 ----
  626.   wbegindrawing(win)
  627.       WINDOW *win;
  628.   {
  629. !     int i, j;
  630.       
  631.       if (draw_win != NULL)
  632.           wenddrawing(draw_win); /* Finish previous job */
  633.       
  634. !     /* Auto-initialization of the textline and modeline array.
  635.          The other arrays needn't be initialized,
  636.          since they are preset to zero. */
  637. +     /* XXX Crash if malloc() fails! */
  638.       for (i= win->top; i < win->bottom; ++i) {
  639.           if (textline[i] == NULL)
  640.               textline[i]= malloc((unsigned) (columns+1));
  641. !         if (modeline[i] == NULL) {
  642. !             modeline[i]= malloc((unsigned) columns);
  643. !             for (j = 0; j < columns; j++)
  644. !                 modeline[i][j] = PLAIN;
  645. !         }
  646.       }
  647.       
  648.       draw_saveattr= wattr;
  649. ***************
  650. *** 271,277 ****
  651.           if (texttouched[i]) {
  652.               texttouched[i]= FALSE;
  653.               textline[i][textlen[i]]= EOS;
  654. !             trmputdata(i, i, 0, textline[i]);
  655.           }
  656.       }
  657.       
  658. --- 278,284 ----
  659.           if (texttouched[i]) {
  660.               texttouched[i]= FALSE;
  661.               textline[i][textlen[i]]= EOS;
  662. !             trmputdata(i, i, 0, textline[i], modeline[i]);
  663.           }
  664.       }
  665.       
  666. ***************
  667. *** 292,307 ****
  668.       int k;
  669.       
  670.       for (k= 0; k < space/2 - 1; ++k)
  671. !         buf[k]= '-'|mask;
  672. !     buf[k++]= ' '|mask;
  673.       while (k < columns && *title != EOS)
  674. !         buf[k++]= *title++|mask;
  675.       if (k < columns)
  676. !         buf[k++]= ' '|mask;
  677.       while (k < columns)
  678. !         buf[k++]= '-'|mask;
  679.       buf[k]= EOS;
  680. !     trmputdata(titline, titline, 0, buf);
  681.       uptodate[titline]= TRUE;
  682.   }
  683.   
  684. --- 299,323 ----
  685.       int k;
  686.       
  687.       for (k= 0; k < space/2 - 1; ++k)
  688. !         buf[k]= '-';
  689. !     buf[k++]= ' ';
  690.       while (k < columns && *title != EOS)
  691. !         buf[k++]= *title++;
  692.       if (k < columns)
  693. !         buf[k++]= ' ';
  694.       while (k < columns)
  695. !         buf[k++]= '-';
  696.       buf[k]= EOS;
  697. !     if (win == front) {
  698. !         char mode[256];
  699. !         int i;
  700. !         for (i = 0; i < k; i++)
  701. !             mode[i] = STANDOUT;
  702. !         trmputdata(titline, titline, 0, buf, mode);
  703. !     }
  704. !     else {
  705. !         trmputdata(titline, titline, 0, buf, (char *)0);
  706. !     }
  707.       uptodate[titline]= TRUE;
  708.   }
  709.   
  710. ***************
  711. *** 312,319 ****
  712.       int len;
  713.   {
  714.       int k;
  715. !     int mask= (wattr.style == 0) ? 0 : 0200;
  716.       char *text;
  717.       WINDOW *win= draw_win;
  718.       
  719.       if (len < 0)
  720. --- 328,336 ----
  721.       int len;
  722.   {
  723.       int k;
  724. !     int flag= (wattr.style == 0) ? PLAIN : STANDOUT;
  725.       char *text;
  726. +     char *mode;
  727.       WINDOW *win= draw_win;
  728.       
  729.       if (len < 0)
  730. ***************
  731. *** 322,333 ****
  732.       if (v < win->top || v >= win->bottom || h >= columns || len == 0)
  733.           return;
  734.       text= textline[v];
  735.       k= textlen[v];
  736. !     while (k < h)
  737. !         text[k++]= ' ';
  738.       while (len > 0) {
  739.   #define APPC(c) \
  740. !     if (h >= 0) text[h]= (c) | mask; if (++h >= columns) break
  741.           unsigned char c= *str++;
  742.           --len;
  743.           if (c < ' ') {
  744. --- 339,353 ----
  745.       if (v < win->top || v >= win->bottom || h >= columns || len == 0)
  746.           return;
  747.       text= textline[v];
  748. +     mode= modeline[v];
  749.       k= textlen[v];
  750. !     for (; k < h; k++) {
  751. !         text[k]= ' ';
  752. !         mode[k]= PLAIN;
  753. !     }
  754.       while (len > 0) {
  755.   #define APPC(c) \
  756. !     if (h >= 0) {text[h]= (c); mode[h]= flag;} if (++h >= columns) break
  757.           unsigned char c= *str++;
  758.           --len;
  759.           if (c < ' ') {
  760. ***************
  761. *** 407,412 ****
  762. --- 427,448 ----
  763.   
  764.   /*ARGSUSED*/
  765.   void
  766. + wfillcircle(h, v, radius)
  767. +     int h, v;
  768. +     int radius;
  769. + {
  770. + }
  771. + 
  772. + /*ARGSUSED*/
  773. + void
  774. + wxorcircle(h, v, radius)
  775. +     int h, v;
  776. +     int radius;
  777. + {
  778. + }
  779. + 
  780. + /*ARGSUSED*/
  781. + void
  782.   wdrawelarc(h, v, radh, radv, ang1, ang2)
  783.       int h, v;
  784.       int radh, radv;
  785. ***************
  786. *** 416,421 ****
  787. --- 452,475 ----
  788.   
  789.   /*ARGSUSED*/
  790.   void
  791. + wfillelarc(h, v, radh, radv, ang1, ang2)
  792. +     int h, v;
  793. +     int radh, radv;
  794. +     int ang1, ang2;
  795. + {
  796. + }
  797. + 
  798. + /*ARGSUSED*/
  799. + void
  800. + wxorelarc(h, v, radh, radv, ang1, ang2)
  801. +     int h, v;
  802. +     int radh, radv;
  803. +     int ang1, ang2;
  804. + {
  805. + }
  806. + 
  807. + /*ARGSUSED*/
  808. + void
  809.   wdrawbox(left, top, right, bottom)
  810.       int left, top, right, bottom;
  811.   {
  812. ***************
  813. *** 459,472 ****
  814.       for (v= top; v < bottom; ++v) {
  815.           int k= textlen[v];
  816.           char *text= textline[v];
  817.           if (k < right) {
  818.               do {
  819. !                 text[k++]= ' ';
  820.               } while (k < right);
  821.               textlen[v]= k;
  822.           }
  823. !         for (k= left; k < right; ++k)
  824. !             text[k] ^= 0200;
  825.           texttouched[v]= TRUE;
  826.       }
  827.   }
  828. --- 513,533 ----
  829.       for (v= top; v < bottom; ++v) {
  830.           int k= textlen[v];
  831.           char *text= textline[v];
  832. +         char *mode= modeline[v];
  833.           if (k < right) {
  834.               do {
  835. !                 text[k]= ' ';
  836. !                 mode[k]= PLAIN;
  837. !                 k++;
  838.               } while (k < right);
  839.               textlen[v]= k;
  840.           }
  841. !         for (k= left; k < right; ++k) {
  842. !             if (mode[k] != PLAIN)
  843. !                 mode[k]= PLAIN;
  844. !             else
  845. !                 mode[k]= STANDOUT;
  846. !         }
  847.           texttouched[v]= TRUE;
  848.       }
  849.   }
  850. ***************
  851. *** 494,503 ****
  852.       for (v= top; v < bottom; ++v) {
  853.           int k= textlen[v];
  854.           char *text= textline[v];
  855.           if (k > right)
  856.               k= right;
  857. !         while (--k >= left)
  858.               text[k]= ' ';
  859.           texttouched[v]= TRUE;
  860.       }
  861.   }
  862. --- 555,567 ----
  863.       for (v= top; v < bottom; ++v) {
  864.           int k= textlen[v];
  865.           char *text= textline[v];
  866. +         char *mode= modeline[v];
  867.           if (k > right)
  868.               k= right;
  869. !         while (--k >= left) {
  870.               text[k]= ' ';
  871. +             mode[k]= PLAIN;
  872. +         }
  873.           texttouched[v]= TRUE;
  874.       }
  875.   }
  876. ***************
  877. *** 504,509 ****
  878. --- 568,597 ----
  879.   
  880.   /*ARGSUSED*/
  881.   void
  882. + wdrawpoly(n, points)
  883. +     int n;
  884. +     POINT *points;
  885. + {
  886. + }
  887. + 
  888. + /*ARGSUSED*/
  889. + void
  890. + wfillpoly(n, points)
  891. +     int n;
  892. +     POINT *points;
  893. + {
  894. + }
  895. + 
  896. + /*ARGSUSED*/
  897. + void
  898. + wxorpoly(n, points)
  899. +     int n;
  900. +     POINT *points;
  901. + {
  902. + }
  903. + 
  904. + /*ARGSUSED*/
  905. + void
  906.   wcliprect(left, top, right, bottom)
  907.       int left, top, right, bottom;
  908.   {
  909. ***************
  910. *** 515,518 ****
  911. --- 603,654 ----
  912.   wnoclip()
  913.   {
  914.       /* XXX not implemented */
  915. + }
  916. + 
  917. + /*ARGSUSED*/
  918. + void
  919. + wsetfont(fontname)
  920. +     char *fontname;
  921. + {
  922. + }
  923. + 
  924. + /*ARGSUSED*/
  925. + void
  926. + wsetsize(size)
  927. +     int size;
  928. + {
  929. + }
  930. + 
  931. + /*ARGSUSED*/
  932. + COLOR
  933. + wfetchcolor(colorname)
  934. +     char *colorname;
  935. + {
  936. +     return 0;
  937. + }
  938. + 
  939. + /*ARGSUSED*/
  940. + void
  941. + wsetfgcolor(color)
  942. +     COLOR color;
  943. + {
  944. + }
  945. + 
  946. + COLOR
  947. + wgetfgcolor()
  948. + {
  949. +     return 0;
  950. + }
  951. + 
  952. + /*ARGSUSED*/
  953. + void
  954. + wsetbgcolor(color)
  955. +     COLOR color;
  956. + {
  957. + }
  958. + 
  959. + COLOR
  960. + wgetbgcolor()
  961. + {
  962. +     return 0;
  963.   }
  964. *** 0.9.5/Ports/alfa/event.c    Thu Oct 18 13:58:28 1990
  965. --- stdwin/Ports/alfa/event.c    Tue May 28 18:35:41 1991
  966. ***************
  967. *** 223,228 ****
  968. --- 223,230 ----
  969.       }
  970.       if (ep->window == NULL && front != syswin)
  971.           ep->window= front;
  972. +     if (ep->type == WE_COMMAND && ep->u.command == WC_CLOSE)
  973. +         ep->type= WE_CLOSE; /* Too hard to do earlier... */
  974.       lasttype= ep->type;
  975.       return ep->type != WE_NULL;
  976.   }
  977. *** 0.9.5/Ports/alfa/menu.c    Mon Oct 29 09:58:17 1990
  978. --- stdwin/Ports/alfa/menu.c    Tue Apr 16 16:20:02 1991
  979. ***************
  980. *** 497,503 ****
  981.           if (lowest < lines)
  982.               uptodate[lowest]= FALSE;
  983.       }
  984. !     trmputdata(i+1, lowest, 0, "");
  985.       leftblank= left;
  986.       trmsync(curitem+1, mp->left);
  987.   }
  988. --- 497,503 ----
  989.           if (lowest < lines)
  990.               uptodate[lowest]= FALSE;
  991.       }
  992. !     trmputdata(i+1, lowest, 0, "", (char *)0);
  993.       leftblank= left;
  994.       trmsync(curitem+1, mp->left);
  995.   }
  996. ***************
  997. *** 559,566 ****
  998.          items on the first menu (after the sysmenu) weren't removed
  999.          from the screen.  I haven't tried to fix this in a more
  1000.          efficient manner. */
  1001. !     trmputdata(line, line, 0, "");
  1002. !     trmputdata(line, line, leftblank, buf);
  1003.       uptodate[line]= FALSE;
  1004.   }
  1005.   
  1006. --- 559,566 ----
  1007.          items on the first menu (after the sysmenu) weren't removed
  1008.          from the screen.  I haven't tried to fix this in a more
  1009.          efficient manner. */
  1010. !     trmputdata(line, line, 0, "", (char *)0);
  1011. !     trmputdata(line, line, leftblank, buf, (char *)0);
  1012.       uptodate[line]= FALSE;
  1013.   }
  1014.   
  1015. *** 0.9.5/Ports/alfa/stdwin.c    Sun Oct 21 12:51:10 1990
  1016. --- stdwin/Ports/alfa/stdwin.c    Tue Apr 16 16:21:10 1991
  1017. ***************
  1018. *** 16,37 ****
  1019.   
  1020.   int lines, columns;
  1021.   
  1022. ! /* Initialization call.
  1023. !    Should be called only once, before any others.
  1024. !    Will exit when the initialization fails. */
  1025. ! 
  1026.   void
  1027. ! winit()
  1028.   {
  1029. !     winitargs((int*)NULL, (char***)NULL);
  1030.   }
  1031.   
  1032.   /*ARGSUSED*/
  1033.   void
  1034. ! winitargs(pargc, pargv)
  1035.       int *pargc;
  1036.       char ***pargv;
  1037.   {
  1038.       int flags;
  1039.       int err;
  1040.       
  1041. --- 16,46 ----
  1042.   
  1043.   int lines, columns;
  1044.   
  1045. ! /*ARGSUSED*/
  1046.   void
  1047. ! winitargs(pargc, pargv)
  1048. !     int *pargc;
  1049. !     char ***pargv;
  1050.   {
  1051. !     wargs(pargc, pargv);
  1052. !     winit();
  1053.   }
  1054.   
  1055.   /*ARGSUSED*/
  1056.   void
  1057. ! wargs(pargc, pargv)
  1058.       int *pargc;
  1059.       char ***pargv;
  1060.   {
  1061. + }
  1062. + 
  1063. + /* Initialization call.
  1064. +    Should be called only once, before any others.
  1065. +    Will exit when the initialization fails. */
  1066. + 
  1067. + void
  1068. + winit()
  1069. + {
  1070.       int flags;
  1071.       int err;
  1072.       
  1073. ***************
  1074. *** 59,65 ****
  1075.       gettckeydefs();
  1076.       if (lines > MAXLINES)
  1077.           lines= MAXLINES;
  1078. !     trmputdata(0, lines-1, 0, "");
  1079.       initsyswin();
  1080.       _winitmenus();
  1081.   }
  1082. --- 68,74 ----
  1083.       gettckeydefs();
  1084.       if (lines > MAXLINES)
  1085.           lines= MAXLINES;
  1086. !     trmputdata(0, lines-1, 0, "", (char *)0);
  1087.       initsyswin();
  1088.       _winitmenus();
  1089.   }
  1090. ***************
  1091. *** 73,79 ****
  1092.   {
  1093.       if (lines > 0) {
  1094.           /* Move cursor to last screen line. */
  1095. !         trmputdata(lines-1, lines-1, 0, "");
  1096.           trmsync(lines-1, 0);
  1097.       }
  1098.       lines= 0;
  1099. --- 82,88 ----
  1100.   {
  1101.       if (lines > 0) {
  1102.           /* Move cursor to last screen line. */
  1103. !         trmputdata(lines-1, lines-1, 0, "", (char *)0);
  1104.           trmsync(lines-1, 0);
  1105.       }
  1106.       lines= 0;
  1107. ***************
  1108. *** 292,297 ****
  1109. --- 301,334 ----
  1110.   {
  1111.   }
  1112.   
  1113. + /*ARGSUSED*/
  1114. + void
  1115. + wsetdefscrollbars(width, height)
  1116. +     int width, height;
  1117. + {
  1118. + }
  1119. + 
  1120. + void
  1121. + wgetdefwinpos(ph, pv)
  1122. +     int *ph, *pv;
  1123. + {
  1124. +     *ph = *pv = 0;
  1125. + }
  1126. + 
  1127. + void
  1128. + wgetdefwinsize(ph, pv)
  1129. +     int *ph, *pv;
  1130. + {
  1131. +     *ph = *pv = 0;
  1132. + }
  1133. + 
  1134. + void
  1135. + wgetdefscrollbars(ph, pv)
  1136. +     int *ph, *pv;
  1137. + {
  1138. +     *ph = *pv = 0;
  1139. + }
  1140. + 
  1141.   /* Make a window the active window. */
  1142.   
  1143.   void
  1144. ***************
  1145. *** 362,368 ****
  1146.           uptodate[i]= FALSE;
  1147.       _wreshuffle();
  1148.       trmundefined();
  1149. !     trmputdata(0, lines-1, 0, "");
  1150.   }
  1151.   
  1152.   /* Temporarily restore cooked tty mode. */
  1153. --- 399,405 ----
  1154.           uptodate[i]= FALSE;
  1155.       _wreshuffle();
  1156.       trmundefined();
  1157. !     trmputdata(0, lines-1, 0, "", (char *)0);
  1158.   }
  1159.   
  1160.   /* Temporarily restore cooked tty mode. */
  1161. ***************
  1162. *** 369,375 ****
  1163.   
  1164.   _wcooked()
  1165.   {
  1166. !     trmputdata(lines-1, lines-1, 0, "");
  1167.       trmsync(lines-1, 0);
  1168.       trmend();
  1169.   }
  1170. --- 406,412 ----
  1171.   
  1172.   _wcooked()
  1173.   {
  1174. !     trmputdata(lines-1, lines-1, 0, "", (char *)0);
  1175.       trmsync(lines-1, 0);
  1176.       trmend();
  1177.   }
  1178. *** 0.9.5/Ports/alfa/syswin.c    Thu Oct 18 13:58:31 1990
  1179. --- stdwin/Ports/alfa/syswin.c    Tue Apr 16 16:21:35 1991
  1180. ***************
  1181. *** 346,355 ****
  1182.       while(Butt[y-1]) {
  1183.           if(y==Curr) sprintf(buf, "%c %s", META('o'), Butt[y-1]); 
  1184.           else sprintf(buf, "o %s", Butt[y-1]);
  1185. !         trmputdata(y, y, 0, buf);
  1186.           ++y;
  1187.       }
  1188. !     trmputdata(y,y,0,"");
  1189.   }
  1190.   
  1191.   /* additional EuroMath WM routine, called after returning from an
  1192. --- 346,355 ----
  1193.       while(Butt[y-1]) {
  1194.           if(y==Curr) sprintf(buf, "%c %s", META('o'), Butt[y-1]); 
  1195.           else sprintf(buf, "o %s", Butt[y-1]);
  1196. !         trmputdata(y, y, 0, buf, (char *)0);
  1197.           ++y;
  1198.       }
  1199. !     trmputdata(y,y,0,"",(char *)0);
  1200.   }
  1201.   
  1202.   /* additional EuroMath WM routine, called after returning from an
  1203. *** 0.9.5/Ports/mac/about.c    Thu Feb 28 12:48:31 1991
  1204. --- stdwin/Ports/mac/about.c    Tue Mar 26 11:08:03 1991
  1205. ***************
  1206. *** 16,23 ****
  1207.      Also see your THINK C licence.
  1208.   */
  1209.   char *about_message=
  1210. !     "STDWIN version 0.9.5 (using THINK C 4.0)\r\r\
  1211. ! Copyright \251 1988, 1989, 1990 Stichting Mathematisch Centrum, \
  1212.   Amsterdam\r\
  1213.   Written by Guido van Rossum (guido@cwi.nl)\r\
  1214.   CWI, dept. AA, P.O.B. 4079\r1009 AB  Amsterdam, The Netherlands\r\r\
  1215. --- 16,23 ----
  1216.      Also see your THINK C licence.
  1217.   */
  1218.   char *about_message=
  1219. !     "STDWIN version 0.9.5a (using THINK C 4.0)\r\r\
  1220. ! Copyright \251 1988, 1989, 1990, 1991 Stichting Mathematisch Centrum, \
  1221.   Amsterdam\r\
  1222.   Written by Guido van Rossum (guido@cwi.nl)\r\
  1223.   CWI, dept. AA, P.O.B. 4079\r1009 AB  Amsterdam, The Netherlands\r\r\
  1224. *** /dev/null    Fri Jun  7 14:31:40 1991
  1225. --- stdwin/Ports/mac/color.c    Tue Apr  9 20:01:40 1991
  1226. ***************
  1227. *** 0 ****
  1228. --- 1,44 ----
  1229. + /* MAC STDWIN -- COLOR HANDLING. */
  1230. + 
  1231. + #include "macwin.h"
  1232. + 
  1233. + /* Provisional color encoding:
  1234. +    - low 16 bits: a color as specified in <QuickDraw.h>
  1235. +    - high 16 bits: a shade factor, 0 -> full, 128 -> 50%
  1236. +    See also draw.c
  1237. + */
  1238. + 
  1239. + static struct colorentry {
  1240. +     char *name;
  1241. +     long color;
  1242. + } colorlist[] = {
  1243. +     {"black",    blackColor},
  1244. +     {"white",    whiteColor},
  1245. +     {"red",        redColor},
  1246. +     {"green",    greenColor},
  1247. +     {"blue",    blueColor},
  1248. +     {"cyan",    cyanColor},
  1249. +     {"magenta",    magentaColor},
  1250. +     {"yellow",    yellowColor},
  1251. +     {"gray25",    blackColor + (192L << 16)},
  1252. +     {"gray50",    blackColor + (128L << 16)},
  1253. +     {"gray75",    blackColor + (64L << 16)},
  1254. +     {"foreground",    blackColor},
  1255. +     {"background",    whiteColor},
  1256. +     {NULL,        0}    /* Sentinel */
  1257. + };
  1258. + 
  1259. + long
  1260. + wfetchcolor(colorname)
  1261. +     char *colorname;
  1262. + {
  1263. +     struct colorentry *p;
  1264. +     
  1265. +     for (p = colorlist; p->name != NULL; p++) {
  1266. +         if (strcmp(p->name, colorname) == 0)
  1267. +             return p->color;
  1268. +     }
  1269. +     
  1270. +     dprintf("wmakecolor: unknown color '%s'", colorname);
  1271. +     return blackColor;
  1272. + }
  1273. *** 0.9.5/Ports/mac/cursor.c    Tue Feb 19 10:46:44 1991
  1274. --- stdwin/Ports/mac/cursor.c    Tue Mar 26 10:37:15 1991
  1275. ***************
  1276. *** 31,43 ****
  1277.               h = GetCursor(plusCursor);
  1278.           else if (strcmp(name, "watch") == 0)
  1279.               h = GetCursor(watchCursor);
  1280.           else if (strcmp(name, "arrow") == 0) {
  1281. !             /* The arrow is not a resource but a quickdraw global.
  1282. !                Fake a handle with a static variable. */
  1283.               static CursPtr arrowptr;
  1284.               arrowptr = &QD(arrow);
  1285.               h = &arrowptr;
  1286.           }
  1287.           else if (strcmp(name, "hand") == 0) {
  1288.               /* The hand is hardcoded below */
  1289.               h = &handcursorptr;
  1290. --- 31,46 ----
  1291.               h = GetCursor(plusCursor);
  1292.           else if (strcmp(name, "watch") == 0)
  1293.               h = GetCursor(watchCursor);
  1294. + #if 0
  1295.           else if (strcmp(name, "arrow") == 0) {
  1296. !             /* The arrow is only a quickdraw global,
  1297. !                which we can't use.
  1298. !                Should have it as a static variable... */
  1299.               static CursPtr arrowptr;
  1300.               arrowptr = &QD(arrow);
  1301.               h = &arrowptr;
  1302.           }
  1303. + #endif
  1304.           else if (strcmp(name, "hand") == 0) {
  1305.               /* The hand is hardcoded below */
  1306.               h = &handcursorptr;
  1307. ***************
  1308. *** 63,69 ****
  1309.   void
  1310.   set_arrow()
  1311.   {
  1312. - /*XXX    SetCursor(&QD(arrow)); */
  1313.       InitCursor();
  1314.   }
  1315.   
  1316. --- 66,71 ----
  1317. *** 0.9.5/Ports/mac/dialog.c    Wed Nov  7 23:35:19 1990
  1318. --- stdwin/Ports/mac/dialog.c    Tue Mar 26 11:09:12 1991
  1319. ***************
  1320. *** 60,65 ****
  1321. --- 60,69 ----
  1322.               def= buf;
  1323.           SFPutFile(PASSPOINT corner, PSTRING(prompt),
  1324.   #ifdef THINK_C /* XXX ??? */
  1325. + /* XXX I think PSTRING returns a pointer to a static buffer
  1326. +    so there can be only one call to PSTRING in an arg list.
  1327. +    Maybe I forgot that when I found this code didn't work.
  1328. +    Should fix it better! */
  1329.               CtoPstr(def),
  1330.   #else
  1331.               PSTRING(def),
  1332. *** 0.9.5/Ports/mac/draw.c    Tue Feb 19 10:46:48 1991
  1333. --- stdwin/Ports/mac/draw.c    Sun Apr  7 16:56:25 1991
  1334. ***************
  1335. *** 8,14 ****
  1336.      text measuring;
  1337.      text drawing;
  1338.      coordinate conversion tools;
  1339. !    ordinary drawing.
  1340.      
  1341.      XXX Should be split, only things used between w{begin,end}drawing
  1342.      belong here.
  1343. --- 8,15 ----
  1344.      text measuring;
  1345.      text drawing;
  1346.      coordinate conversion tools;
  1347. !    ordinary drawing;
  1348. !    color stuff.
  1349.      
  1350.      XXX Should be split, only things used between w{begin,end}drawing
  1351.      belong here.
  1352. ***************
  1353. *** 33,38 ****
  1354. --- 34,43 ----
  1355.   #include <Fonts.h>
  1356.   #endif
  1357.   
  1358. + COLOR _w_fgcolor = blackColor;
  1359. + COLOR _w_bgcolor = whiteColor;
  1360. + static COLOR save_fgcolor, save_bgcolor;
  1361. + 
  1362.   static WINDOW *drawing;
  1363.   static TEXTATTR drawsaveattr;
  1364.   static int baseline;
  1365. ***************
  1366. *** 44,49 ****
  1367. --- 49,62 ----
  1368.   STATIC void setwattr _ARGS((TEXTATTR *attr));
  1369.   STATIC void getfinfo _ARGS((void));
  1370.   
  1371. + /* Patterns -- can't use the QuickDraw globals (sigh) */
  1372. + 
  1373. + static Pattern pat0   = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  1374. + static Pattern pat25  = {0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44};
  1375. + static Pattern pat50  = {0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa};
  1376. + static Pattern pat75  = {0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd};
  1377. + static Pattern pat100 = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  1378. + 
  1379.   void
  1380.   wchange(win, left, top, right, bottom)
  1381.       WINDOW *win;
  1382. ***************
  1383. *** 110,116 ****
  1384. --- 123,135 ----
  1385.           DisposeRgn(ur);
  1386.       }
  1387.       
  1388. +     /* ScrollRect seems to work only in normal mode */
  1389. +     ForeColor(blackColor);
  1390. +     BackColor(whiteColor);
  1391.       ScrollRect(pr, dh, dv, rgn);
  1392. +     ForeColor((short)win->fgcolor);
  1393. +     BackColor((short)win->bgcolor);
  1394. +     
  1395.       InvalRgn(rgn);
  1396.       
  1397.       DisposeRgn(rgn);
  1398. ***************
  1399. *** 131,137 ****
  1400.       rmcaret(win);
  1401.       BeginUpdate(win->w);
  1402.       EraseRect(&win->w->portRect);
  1403. !     DrawGrowIcon(win->w);
  1404.       DrawControls(win->w);
  1405.       getwinrect(win, pr);
  1406.       RectRgn(rgn, pr);
  1407. --- 150,156 ----
  1408.       rmcaret(win);
  1409.       BeginUpdate(win->w);
  1410.       EraseRect(&win->w->portRect);
  1411. !     _wgrowicon(win);
  1412.       DrawControls(win->w);
  1413.       getwinrect(win, pr);
  1414.       RectRgn(rgn, pr);
  1415. ***************
  1416. *** 184,189 ****
  1417. --- 203,215 ----
  1418.       PenNormal();
  1419.       wgettextattr(&drawsaveattr);
  1420.       wsettextattr(&win->attr);
  1421. +     
  1422. +     save_fgcolor = _w_fgcolor;
  1423. +     save_bgcolor = _w_bgcolor;
  1424. +     _w_fgcolor = win->fgcolor;
  1425. +     _w_bgcolor = win->bgcolor;
  1426. +     _w_usefgcolor(_w_fgcolor);
  1427. +     _w_usebgcolor(_w_bgcolor);
  1428.   }
  1429.   
  1430.   void
  1431. ***************
  1432. *** 200,205 ****
  1433. --- 226,237 ----
  1434.           dprintf("warning: wenddrawing ignored for wrong window");
  1435.           return;
  1436.       }
  1437. +     
  1438. +     _w_fgcolor = save_fgcolor;
  1439. +     _w_bgcolor = save_bgcolor;
  1440. +     _w_usefgcolor(win->fgcolor);
  1441. +     _w_usebgcolor(win->bgcolor);
  1442. +     
  1443.       SetOrigin(0, 0);
  1444.       SetRect(&r, -32000, -32000, 32000, 32000);
  1445.       ClipRect(&r);
  1446. ***************
  1447. *** 509,516 ****
  1448.       Rect *pr;
  1449.   {
  1450.       *pr= win->w->portRect;
  1451. !     pr->right -= BAR;
  1452. !     pr->bottom -= BAR;
  1453.   }
  1454.   
  1455.   /* ACTUAL DRAW ROUTINES. */
  1456. --- 541,550 ----
  1457.       Rect *pr;
  1458.   {
  1459.       *pr= win->w->portRect;
  1460. !     if (win->vbar != NULL)
  1461. !         pr->right -= BAR;
  1462. !     if (win->hbar != NULL)
  1463. !         pr->bottom -= BAR;
  1464.   }
  1465.   
  1466.   /* ACTUAL DRAW ROUTINES. */
  1467. ***************
  1468. *** 568,574 ****
  1469.       Rect r;
  1470.       
  1471.       SetRect(&r, left, top, right, bottom);
  1472. !     FillRect(&r, QD(black));
  1473.   }
  1474.   
  1475.   void
  1476. --- 602,608 ----
  1477.       Rect r;
  1478.       
  1479.       SetRect(&r, left, top, right, bottom);
  1480. !     FillRect(&r, drawing->w->pnPat);
  1481.   }
  1482.   
  1483.   void
  1484. ***************
  1485. *** 577,593 ****
  1486.       int perc;
  1487.   {
  1488.       Rect r;
  1489. !     unsigned char *p; /* really Pattern * or PatPtr */
  1490.       
  1491.       perc= (perc + 12)/25;
  1492.       CLIPMIN(perc, 0);
  1493.       
  1494.       switch (perc) {
  1495. !     case 0:    p= &QD(white)[0];    break;
  1496. !     case 1: p= &QD(ltGray)[0];    break;
  1497. !     case 2: p= &QD(gray)[0];     break;
  1498. !     case 3: p= &QD(dkGray)[0];    break;
  1499. !     default: p= &QD(black)[0];    break;
  1500.       }
  1501.       
  1502.       SetRect(&r, left, top, right, bottom);
  1503. --- 611,627 ----
  1504.       int perc;
  1505.   {
  1506.       Rect r;
  1507. !     PatPtr p;
  1508.       
  1509.       perc= (perc + 12)/25;
  1510.       CLIPMIN(perc, 0);
  1511.       
  1512.       switch (perc) {
  1513. !     case 0:    p = &pat0;    break;
  1514. !     case 1: p = &pat25;    break;
  1515. !     case 2: p = &pat50;     break;
  1516. !     case 3: p = &pat75;    break;
  1517. !     default: p = &pat100;    break;
  1518.       }
  1519.       
  1520.       SetRect(&r, left, top, right, bottom);
  1521. ***************
  1522. *** 602,608 ****
  1523.   {
  1524.       Rect r;
  1525.       
  1526. -     /* XXX Isn't there an off-by-one error here? */
  1527.       SetRect(&r, h-radius, v-radius, h+radius, v+radius);
  1528.       FrameOval(&r);
  1529.   }
  1530. --- 636,641 ----
  1531. ***************
  1532. *** 615,623 ****
  1533.   wdrawelarc(h, v, hrad, vrad, ang1, ang2)
  1534.   {
  1535.       Rect r;
  1536. -     /* XXX Does this work? No off-by-one errors? */
  1537.       SetRect(&r, h-hrad, v-vrad, h+hrad, v+vrad);
  1538. !     FrameArc(&r, 90-ang1, ang1-ang2); /* ??? */
  1539.   }
  1540.   
  1541.   /* CLIPPING */
  1542. --- 648,655 ----
  1543.   wdrawelarc(h, v, hrad, vrad, ang1, ang2)
  1544.   {
  1545.       Rect r;
  1546.       SetRect(&r, h-hrad, v-vrad, h+hrad, v+vrad);
  1547. !     FrameArc(&r, 90-ang1, ang1-ang2);
  1548.   }
  1549.   
  1550.   /* CLIPPING */
  1551. ***************
  1552. *** 640,643 ****
  1553. --- 672,738 ----
  1554.       Rect r;
  1555.       getwinrect(drawing, &r);
  1556.       ClipRect(&r);
  1557. + }
  1558. + 
  1559. + /* COLOR */
  1560. + 
  1561. + COLOR
  1562. + wgetfgcolor()
  1563. + {
  1564. +     return _w_fgcolor;
  1565. + }
  1566. + 
  1567. + COLOR
  1568. + wgetbgcolor()
  1569. + {
  1570. +     return _w_bgcolor;
  1571. + }
  1572. + 
  1573. + void
  1574. + wsetfgcolor(color)
  1575. +     COLOR color;
  1576. + {
  1577. +     _w_fgcolor = color;
  1578. +     if (drawing)
  1579. +         _w_usefgcolor(color);
  1580. + }
  1581. + 
  1582. + void
  1583. + wsetbgcolor(color)
  1584. +     COLOR color;
  1585. + {
  1586. +     _w_bgcolor = color;
  1587. +     if (drawing)
  1588. +         _w_usebgcolor(color);
  1589. + }
  1590. + 
  1591. + void
  1592. + _w_usefgcolor(color)
  1593. +     COLOR color;
  1594. + {
  1595. +     ForeColor((short)color);
  1596. +     switch (((color >> 16) + 32) / 64) {
  1597. +     case 0:
  1598. +         PenPat(pat100);
  1599. +         break;
  1600. +     case 1:
  1601. +         PenPat(pat75);
  1602. +         break;
  1603. +     case 2:
  1604. +         PenPat(pat50);
  1605. +         break;
  1606. +     case 3:
  1607. +         PenPat(pat25);
  1608. +         break;
  1609. +     case 4:
  1610. +         PenPat(pat0);
  1611. +         break;
  1612. +     }
  1613. + }
  1614. + 
  1615. + void
  1616. + _w_usebgcolor(color)
  1617. +     COLOR color;
  1618. + {
  1619. +     BackColor((short)color);
  1620.   }
  1621. *** 0.9.5/Ports/mac/event.c    Tue Feb 19 10:46:53 1991
  1622. --- stdwin/Ports/mac/event.c    Tue May 28 22:23:56 1991
  1623. ***************
  1624. *** 9,15 ****
  1625. --- 9,18 ----
  1626.   #endif
  1627.   #ifdef THINK_C
  1628.   #include <EventMgr.h>
  1629. + #ifndef THINK_C_3_0
  1630. + #include <console.h> /* See do_update */
  1631.   #endif
  1632. + #endif
  1633.   
  1634.   void (*_w_idle_proc)();    /* Function to call in idle loop */
  1635.   
  1636. ***************
  1637. *** 83,88 ****
  1638. --- 86,99 ----
  1639.       
  1640.       if (active == NULL)
  1641.           set_arrow();
  1642. +     else if (active->w != FrontWindow()) {
  1643. +         /* Somehow we missed a deactivation event.
  1644. +            Fake one now. */
  1645. +         ep->type= WE_DEACTIVATE;
  1646. +         ep->window= active;
  1647. +         deactivate();
  1648. +         return;
  1649. +     }
  1650.       
  1651.       ep->type= WE_NULL;
  1652.       ep->window= NULL;
  1653. ***************
  1654. *** 206,212 ****
  1655.       
  1656.       win= whichwin((WindowPtr) e.message);
  1657.       if (win == NULL) {
  1658. !         /* dprintf("update evt for alien window"); */
  1659.           return;
  1660.       }
  1661.       _wupdate(win, &r);
  1662. --- 217,239 ----
  1663.       
  1664.       win= whichwin((WindowPtr) e.message);
  1665.       if (win == NULL) {
  1666. !         /* Update event for a window not created by STDWIN
  1667. !            (not a Desk Accessory -- these are taken care of
  1668. !            by GetNextEvent or at some other secret place.)
  1669. !            This is is problem: if we ignore it, it will come
  1670. !            back forever, so we'll never be idle again. */
  1671. ! #ifdef THINK_C
  1672. ! #ifndef THINK_C_3_0
  1673. !         /* Most likely, under THINK C 4.0, it is the console
  1674. !            window.  We can force the window to repaint itself
  1675. !            by calling any console function.  A rather harmless
  1676. !            one is cgetxy.  Use stderr as the one least likely
  1677. !            to be redirected. */
  1678. !         int x, y;
  1679. !         if (stderr->window)
  1680. !             cgetxy(&x, &y, stderr);
  1681. ! #endif
  1682. ! #endif
  1683.           return;
  1684.       }
  1685.       _wupdate(win, &r);
  1686. ***************
  1687. *** 227,239 ****
  1688.       WindowPtr w;
  1689.       int code= FindWindow(PASSPOINT e.where, &w);
  1690.       
  1691. -     /* XXX This doesn't look incredibly necessary:
  1692. -     if (active != NULL) {
  1693. -         SetPort(active->win);
  1694. -         rmcaret(active);
  1695. -     }
  1696. -     */
  1697. -     
  1698.       if (code != inContent && code != inSysWindow)
  1699.           set_arrow();
  1700.       switch (code) {
  1701. --- 254,259 ----
  1702. ***************
  1703. *** 273,289 ****
  1704.   do_key(ep)
  1705.       EVENT *ep;
  1706.   {
  1707. !     char c= e.message & charCodeMask;
  1708.       
  1709. -     /* XXX shouldn't mess at all with non-stdwin windows */
  1710. -     
  1711.       if (e.modifiers & cmdKey) {
  1712.           if (c == '.') {
  1713.               ep->type= WE_COMMAND;
  1714.               ep->u.command= WC_CANCEL;
  1715.           }
  1716. !         else
  1717. !             _wdo_menu(ep, MenuKey(c));
  1718.       }
  1719.       else {
  1720.           ep->type= WE_COMMAND;
  1721. --- 293,317 ----
  1722.   do_key(ep)
  1723.       EVENT *ep;
  1724.   {
  1725. !     int c= e.message & charCodeMask;
  1726.       
  1727.       if (e.modifiers & cmdKey) {
  1728.           if (c == '.') {
  1729.               ep->type= WE_COMMAND;
  1730.               ep->u.command= WC_CANCEL;
  1731.           }
  1732. !         else {
  1733. !             long menu_item= MenuKey(c);
  1734. !             if (HiWord(menu_item) != 0) {
  1735. !                 _wdo_menu(ep, menu_item);
  1736. !             }
  1737. !             else {
  1738. !                 ep->type= WE_KEY;
  1739. !                 ep->u.key.code= c;
  1740. !                 ep->u.key.mask= WM_META;
  1741. !                 /* Should filter out arrow keys? */
  1742. !             }
  1743. !         }
  1744.       }
  1745.       else {
  1746.           ep->type= WE_COMMAND;
  1747. ***************
  1748. *** 350,356 ****
  1749.                   return;
  1750.               /* If we get here we've missed a
  1751.                  deactivate event... */
  1752. !             dprintf("activate without deactivate");
  1753.   #endif
  1754.           }
  1755.           activate(win);
  1756. --- 378,384 ----
  1757.                   return;
  1758.               /* If we get here we've missed a
  1759.                  deactivate event... */
  1760. !             /* dprintf("activate without deactivate"); */
  1761.   #endif
  1762.           }
  1763.           activate(win);
  1764. ***************
  1765. *** 381,387 ****
  1766.       rmcaret(active);
  1767.       hidescrollbars(active);
  1768.       rmlocalmenus(active);
  1769. !     DrawGrowIcon(active->w);
  1770.       active= NULL;
  1771.       set_arrow();
  1772.   }
  1773. --- 409,415 ----
  1774.       rmcaret(active);
  1775.       hidescrollbars(active);
  1776.       rmlocalmenus(active);
  1777. !     _wgrowicon(active);
  1778.       active= NULL;
  1779.       set_arrow();
  1780.   }
  1781. ***************
  1782. *** 492,524 ****
  1783.   {
  1784.       Rect r;
  1785.       long reply;
  1786.       
  1787. !     /* XXX shouldn't mess at all with non-stdwin windows */
  1788.       
  1789. !     /* Set minimal window size */
  1790. !     r.left= LSLOP + MIN_WIDTH + RSLOP + BAR;
  1791. !     r.top= MIN_HEIGHT + BAR;
  1792.       
  1793. !     /* The max size is derived from the document size.
  1794. !        If there is no document size, it is unlimited.
  1795. !        (There is nothing wrong with windows larger than
  1796. !        the screen, really.) */
  1797. !     r.right = r.bottom = 0x7fff;
  1798. !     {
  1799. !         /* Max size restriction based on doc size, if specified */
  1800. !         WINDOW *win = whichwin(w);
  1801. !         int docwidth = win->docwidth;
  1802. !         int docheight = win->docheight;
  1803. !         if (win->docwidth > 0) {
  1804. !             CLIPMIN(docwidth, MIN_WIDTH);
  1805. !             r.right = LSLOP + docwidth + RSLOP + BAR + 1;
  1806. !         }
  1807. !         if (win->docheight > 0) {
  1808. !             CLIPMIN(docheight, MIN_HEIGHT);
  1809. !             r.bottom = docheight + BAR + 1;
  1810. !         }
  1811. !         /* For some reason 1 has to be added.  Sigh. */
  1812. !     }
  1813.       
  1814.       reply= GrowWindow(w, PASSPOINT e.where, &r);
  1815.       if (reply != 0) {
  1816. --- 520,548 ----
  1817.   {
  1818.       Rect r;
  1819.       long reply;
  1820. +     WINDOW *win = whichwin(w);
  1821.       
  1822. !     /* Don't mess at all with non-stdwin windows */
  1823. !     if (win == NULL)
  1824. !         return;
  1825.       
  1826. !     /* Set minimal window size --
  1827. !       1x1 at least, plus space needed for scroll bars */
  1828. !     r.left = LSLOP + 1 + RSLOP;
  1829. !     r.top = 1;
  1830. !     if (win->hbar != NULL)
  1831. !         r.left = 3*BAR;
  1832. !     if (win->vbar != NULL)
  1833. !         r.top = 3*BAR;
  1834. !     if (win->vbar != NULL)
  1835. !         r.left += BAR;
  1836. !     if (win->hbar != NULL)
  1837. !         r.top += BAR;
  1838.       
  1839. !     /* Windows may become as large as the user can get them,
  1840. !        within reason -- the limit 0x7000 should avoid integer
  1841. !        overflow in QuickDraw. */
  1842. !     r.right = r.bottom = 0x7000;
  1843.       
  1844.       reply= GrowWindow(w, PASSPOINT e.where, &r);
  1845.       if (reply != 0) {
  1846. ***************
  1847. *** 537,545 ****
  1848.       /* XXX shouldn't mess at all with non-stdwin windows */
  1849.       
  1850.       if (TrackGoAway(w, PASSPOINT e.where)) {
  1851. !         ep->type= WE_COMMAND;
  1852.           ep->window= whichwin(w);
  1853. -         ep->u.command= WC_CLOSE;
  1854.       }
  1855.   }
  1856.   
  1857. --- 561,568 ----
  1858.       /* XXX shouldn't mess at all with non-stdwin windows */
  1859.       
  1860.       if (TrackGoAway(w, PASSPOINT e.where)) {
  1861. !         ep->type= WE_CLOSE;
  1862.           ep->window= whichwin(w);
  1863.       }
  1864.   }
  1865.   
  1866. ***************
  1867. *** 596,608 ****
  1868.       WindowPtr w;
  1869.   {
  1870.       Rect r;
  1871.       
  1872. !     r= w->portRect;
  1873. !     r.left= r.right - BAR;
  1874. !     InvalRect(&r);
  1875. !     r= w->portRect;
  1876. !     r.top= r.bottom - BAR;
  1877. !     InvalRect(&r);
  1878.   }
  1879.   
  1880.   void
  1881. --- 619,636 ----
  1882.       WindowPtr w;
  1883.   {
  1884.       Rect r;
  1885. +     WINDOW *win = whichwin(w);
  1886.       
  1887. !     if (win->vbar != NULL) {
  1888. !         r = w->portRect;
  1889. !         r.left = r.right - BAR;
  1890. !         InvalRect(&r);
  1891. !     }
  1892. !     if (win->hbar != NULL) {
  1893. !         r = w->portRect;
  1894. !         r.top = r.bottom - BAR;
  1895. !         InvalRect(&r);
  1896. !     }
  1897.   }
  1898.   
  1899.   void
  1900. ***************
  1901. *** 610,622 ****
  1902.       WindowPtr w;
  1903.   {
  1904.       Rect r;
  1905.       
  1906. !     r= w->portRect;
  1907. !     r.left= r.right - BAR;
  1908. !     ValidRect(&r);
  1909. !     r= w->portRect;
  1910. !     r.top= r.bottom - BAR;
  1911. !     ValidRect(&r);
  1912.   }
  1913.   
  1914.   /* Variables needed in click and move detection. */
  1915. --- 638,655 ----
  1916.       WindowPtr w;
  1917.   {
  1918.       Rect r;
  1919. +     WINDOW *win = whichwin(w);
  1920.       
  1921. !     if (win->vbar != NULL) {
  1922. !         r = w->portRect;
  1923. !         r.left = r.right - BAR;
  1924. !         ValidRect(&r);
  1925. !     }
  1926. !     if (win->hbar != NULL) {
  1927. !         r = w->portRect;
  1928. !         r.top = r.bottom - BAR;
  1929. !         ValidRect(&r);
  1930. !     }
  1931.   }
  1932.   
  1933.   /* Variables needed in click and move detection. */
  1934. ***************
  1935. *** 624,631 ****
  1936.   static int m_h, m_v;        /* Doc. coord. of last mouse evt. */
  1937.   static long m_when;        /* TickCount of last mouse evt. */
  1938.   static int m_clicks;        /* N-fold click stage */
  1939. - static int m_button;        /* Which 'button';
  1940. -                    1=normal, 2=shift, 3=command. */
  1941.   
  1942.   static void
  1943.   make_mouse_event(ep, pwhere)
  1944. --- 657,662 ----
  1945. ***************
  1946. *** 637,644 ****
  1947.       int v= pwhere->v + win->orgv;
  1948.       int dh= h - m_h;
  1949.       int dv= v - m_v;
  1950.       
  1951. !     if (dh*dh + dv*dv > CLICK_DIST*CLICK_DIST)
  1952.           m_clicks= 0;    /* Moved too much for a click */
  1953.       
  1954.       if (e.what == mouseDown) {
  1955. --- 668,676 ----
  1956.       int v= pwhere->v + win->orgv;
  1957.       int dh= h - m_h;
  1958.       int dv= v - m_v;
  1959. +     int mask;
  1960.       
  1961. !     if (m_clicks != 0 && dh*dh + dv*dv > CLICK_DIST*CLICK_DIST)
  1962.           m_clicks= 0;    /* Moved too much for a click */
  1963.       
  1964.       if (e.what == mouseDown) {
  1965. ***************
  1966. *** 648,657 ****
  1967.               ++m_clicks;
  1968.           ep->type= WE_MOUSE_DOWN;
  1969.           _wm_down= TRUE;
  1970. -         /* XXX Should swap buttons 2 & 3 (also in textedit)
  1971. -            since X11 (e.g., xterm) uses button 3 for extend */
  1972. -         m_button= (e.modifiers & cmdKey) ? 3 :
  1973. -             (e.modifiers & shiftKey) ? 2 : 1;
  1974.       }
  1975.       else if (e.what == mouseUp) {
  1976.           if (!_wm_down)
  1977. --- 680,685 ----
  1978. ***************
  1979. *** 664,674 ****
  1980.               return;
  1981.           ep->type= WE_MOUSE_MOVE;
  1982.       }
  1983.       ep->u.where.h= m_h= h;
  1984.       ep->u.where.v= m_v= v;
  1985.       ep->u.where.clicks= m_clicks;
  1986. !     ep->u.where.button= m_button;
  1987. !     ep->u.where.mask= (ep->type == WE_MOUSE_UP) ? 0 : 1;
  1988.       ep->window= win;
  1989.       m_when= e.when;
  1990.   }
  1991. --- 692,713 ----
  1992.               return;
  1993.           ep->type= WE_MOUSE_MOVE;
  1994.       }
  1995. +     mask= (ep->type == WE_MOUSE_UP) ? 0 : WM_BUTTON1;
  1996. +     if (e.modifiers & cmdKey)
  1997. +         mask |= WM_META;
  1998. +     if (e.modifiers & shiftKey)
  1999. +         mask |= WM_SHIFT;
  2000. +     if (e.modifiers & alphaLock)
  2001. +         mask |= WM_LOCK;
  2002. +     if (e.modifiers & optionKey)
  2003. +         mask |= WM_OPTION;
  2004. +     if (e.modifiers & controlKey)
  2005. +         mask |= WM_CONTROL;
  2006.       ep->u.where.h= m_h= h;
  2007.       ep->u.where.v= m_v= v;
  2008.       ep->u.where.clicks= m_clicks;
  2009. !     ep->u.where.button= 1;
  2010. !     ep->u.where.mask= mask;
  2011.       ep->window= win;
  2012.       m_when= e.when;
  2013.   }
  2014. ***************
  2015. *** 680,683 ****
  2016. --- 719,735 ----
  2017.   _wresetmouse()
  2018.   {
  2019.       _wm_down= FALSE;
  2020. + }
  2021. + 
  2022. + void
  2023. + wsetactive(win)
  2024. +     WINDOW *win;
  2025. + {
  2026. +     SelectWindow(win->w);
  2027. + }
  2028. + 
  2029. + WINDOW *
  2030. + wgetactive()
  2031. + {
  2032. +     return whichwin(FrontWindow());
  2033.   }
  2034. *** 0.9.5/Ports/mac/macwin.h    Tue Feb 19 10:46:57 1991
  2035. --- stdwin/Ports/mac/macwin.h    Sun Apr  7 16:55:08 1991
  2036. ***************
  2037. *** 65,70 ****
  2038. --- 65,71 ----
  2039.   #define c2pstr CtoPstr    /* XXX actually, used nowhere */
  2040.   
  2041.   /* Quickdraw globals are real globals in THINK C */
  2042. + /* But don't use them, the console library breaks this!!! */
  2043.   #define QD(var) (var)
  2044.   
  2045.   /* THINK C can't declare forward functions as static */
  2046. ***************
  2047. *** 108,113 ****
  2048. --- 109,115 ----
  2049.       struct menubar mbar;    /* List of attached local menus */
  2050.       unsigned long timer;    /* Tick count for timer event */
  2051.       CURSOR *cursor;        /* Cursor if not default */
  2052. +     COLOR fgcolor, bgcolor;    /* Default colors for this window */
  2053.   };
  2054.   
  2055.   extern TEXTATTR wattr;        /* Current text attributes */
  2056. ***************
  2057. *** 135,150 ****
  2058.   
  2059.   #define CLICK_DIST    5    /* Max mouse move within a click */
  2060.   
  2061. - /* Parameters for top left corner choice algorithm: */
  2062. - #define LEFT    20    /* Initial left */
  2063. - #define TOP    40    /* Initial top */
  2064. - #define HINCR    20    /* Increment for left */
  2065. - #define VINCR    16    /* Increment for top */
  2066. - 
  2067. - /* Minimal window size (determined by room for scroll bars only): */
  2068. - #define MIN_WIDTH    (2*BAR)
  2069. - #define MIN_HEIGHT    (2*BAR)
  2070. - 
  2071.   /* Text drawn in the very left or right margin doesn't look nice.
  2072.      Therefore, we have a little margin on each side.
  2073.      Its width is determined here: */
  2074. --- 137,142 ----
  2075. ***************
  2076. *** 156,161 ****
  2077. --- 148,155 ----
  2078.   extern WINDOW *active;        /* Active window, if any */
  2079.   extern bool _wmenuhilite;    /* Set if menu item highlighted */
  2080.   extern bool _wm_down;        /* Set if mouse down (in appl. area) */
  2081. + extern COLOR _w_fgcolor;    /* Current foreground color */
  2082. + extern COLOR _w_bgcolor;    /* Current background color */
  2083.   
  2084.   /* Function prototypes: */
  2085.   
  2086. ***************
  2087. *** 175,184 ****
  2088.   void set_ibeam _ARGS((void));
  2089.   void set_hand _ARGS((void));
  2090.   
  2091. ! void makescrollbars _ARGS((WINDOW *win));
  2092.   void movescrollbars _ARGS((WINDOW *win));
  2093.   void hidescrollbars _ARGS((WINDOW *win));
  2094.   void showscrollbars _ARGS((WINDOW *win));
  2095.   
  2096.   void scrollby _ARGS((WINDOW *win, Rect *pr, int dh, int dv));
  2097.   void do_scroll _ARGS((Point *pwhere,
  2098. --- 169,180 ----
  2099.   void set_ibeam _ARGS((void));
  2100.   void set_hand _ARGS((void));
  2101.   
  2102. ! void makescrollbars _ARGS((WINDOW *win, /*bool*/int hor, /*bool*/int ver));
  2103.   void movescrollbars _ARGS((WINDOW *win));
  2104.   void hidescrollbars _ARGS((WINDOW *win));
  2105.   void showscrollbars _ARGS((WINDOW *win));
  2106. + void _wgrowicon _ARGS((WINDOW *win));
  2107. + void _wfixorigin _ARGS((WINDOW *));
  2108.   
  2109.   void scrollby _ARGS((WINDOW *win, Rect *pr, int dh, int dv));
  2110.   void do_scroll _ARGS((Point *pwhere,
  2111. ***************
  2112. *** 211,216 ****
  2113. --- 207,215 ----
  2114.   bool checktimer _ARGS((EVENT *ep));
  2115.   void autoscroll _ARGS((WINDOW *active, int h, int v));
  2116.   void _wdo_menu _ARGS((EVENT *ep, long menu_item));
  2117. + 
  2118. + void _w_usefgcolor _ARGS((COLOR color));
  2119. + void _w_usebgcolor _ARGS((COLOR color));
  2120.   
  2121.   /* SetRect is much faster this way... */
  2122.   #define SetRect(pr, l, t, r, b) ((pr)->left = (l), (pr)->top = (t), \
  2123. *** 0.9.5/Ports/mac/pstring.c    Wed Nov  7 23:31:34 1990
  2124. --- stdwin/Ports/mac/pstring.c    Tue Mar 26 11:11:41 1991
  2125. ***************
  2126. *** 18,24 ****
  2127.       dst = &buf[1];
  2128.       while ((*dst++ = *src++) != '\0' && dst < &buf[256])
  2129.           ;
  2130. !     buf[0] = dst - &buf[1];
  2131.       return buf;
  2132.   }
  2133.   
  2134. --- 18,24 ----
  2135.       dst = &buf[1];
  2136.       while ((*dst++ = *src++) != '\0' && dst < &buf[256])
  2137.           ;
  2138. !     buf[0] = dst - &buf[1] - 1; /* XXX Recent bugfix! */
  2139.       return buf;
  2140.   }
  2141.   
  2142. *** 0.9.5/Ports/mac/scroll.c    Wed Nov  7 23:37:48 1990
  2143. --- stdwin/Ports/mac/scroll.c    Tue Mar 26 11:15:02 1991
  2144. ***************
  2145. *** 1,3 ****
  2146. --- 1,9 ----
  2147. + /*
  2148. + This code is somehow broken.
  2149. + If I click a few times on an arrow of the scroll bar the cursor freezes.
  2150. + Other forms of scrolling don't have this problem.  WHAT'S WRONG?!?!?!
  2151. + */
  2152. + 
  2153.   /* MAC STDWIN -- SCROLLING. */
  2154.   
  2155.   /* All non-public functions here assume the current grafport is set */
  2156. ***************
  2157. *** 25,30 ****
  2158. --- 31,37 ----
  2159.   STATIC void setscrollbarvalues _ARGS((WINDOW *win));
  2160.   STATIC void usescrollbarvalues _ARGS((WINDOW *win));
  2161.   STATIC void sizescrollbars _ARGS((WINDOW *win));
  2162. + STATIC int calcneworigin _ARGS((int, int, int, int, int));
  2163.   STATIC void calcbar _ARGS((ControlHandle bar,
  2164.       int org, int size, int begin, int end));
  2165.   STATIC void setbar _ARGS((ControlHandle bar, int winsize, int val, int max));
  2166. ***************
  2167. *** 33,38 ****
  2168. --- 40,46 ----
  2169.   STATIC void hidebar _ARGS((ControlHandle bar));
  2170.   STATIC void movebar _ARGS((ControlHandle bar,
  2171.       int left, int top, int right, int bottom));
  2172. + void _wfixorigin _ARGS((WINDOW *));
  2173.   
  2174.   void
  2175.   wsetorigin(win, orgh, orgv)
  2176. ***************
  2177. *** 187,211 ****
  2178.               *((WindowPeek)(win->w))->dataHandle;
  2179.           if (data != NULL) {
  2180.               if (docwidth > 0) {
  2181. -                 CLIPMIN(docwidth, MIN_WIDTH);
  2182.                   data->stdState.right =
  2183.                       data->stdState.left
  2184. !                     + LSLOP + docwidth + RSLOP + BAR;
  2185.               }
  2186.               else
  2187.                   data->stdState.right = 0x7fff;
  2188.               CLIPMAX(data->stdState.right,
  2189.                   screen->portRect.right-3);
  2190.               if (docheight > 0) {
  2191. -                 CLIPMIN(docheight, MIN_HEIGHT);
  2192.                   data->stdState.bottom =
  2193. !                     data->stdState.top
  2194. !                     + docheight + BAR;
  2195.               }
  2196.               else
  2197.                   data->stdState.bottom = 0x7fff;
  2198.               CLIPMAX(data->stdState.bottom,
  2199.                   screen->portRect.bottom-3);
  2200.           }
  2201.       }
  2202.   }
  2203. --- 195,226 ----
  2204.               *((WindowPeek)(win->w))->dataHandle;
  2205.           if (data != NULL) {
  2206.               if (docwidth > 0) {
  2207.                   data->stdState.right =
  2208.                       data->stdState.left
  2209. !                     + LSLOP + docwidth + RSLOP;
  2210. !                 if (win->vbar != NULL)
  2211. !                     data->stdState.right += BAR;
  2212.               }
  2213.               else
  2214.                   data->stdState.right = 0x7fff;
  2215.               CLIPMAX(data->stdState.right,
  2216.                   screen->portRect.right-3);
  2217. +             if (win->hbar != NULL) {
  2218. +                 CLIPMIN(data->stdState.right, 5*BAR);
  2219. +             }
  2220.               if (docheight > 0) {
  2221.                   data->stdState.bottom =
  2222. !                     data->stdState.top + docheight;
  2223. !                 if (win->hbar != NULL)
  2224. !                     data->stdState.bottom += BAR;
  2225.               }
  2226.               else
  2227.                   data->stdState.bottom = 0x7fff;
  2228.               CLIPMAX(data->stdState.bottom,
  2229.                   screen->portRect.bottom-3);
  2230. +             if (win->vbar != NULL) {
  2231. +                 CLIPMIN(data->stdState.bottom, 5*BAR);
  2232. +             }
  2233.           }
  2234.       }
  2235.   }
  2236. ***************
  2237. *** 222,227 ****
  2238. --- 237,243 ----
  2239.   /* Fix the window's origin after a document or window resize.
  2240.      (Also used from do_size() in event.c) */
  2241.   
  2242. + void
  2243.   _wfixorigin(win)
  2244.       WINDOW *win;
  2245.   {
  2246. ***************
  2247. *** 267,272 ****
  2248. --- 283,291 ----
  2249.       ProcPtr action;
  2250.       int width, height;
  2251.       
  2252. +     if (bar == NULL)
  2253. +         return;
  2254. +     
  2255.       wgetwinsize(win, &width, &height);
  2256.       
  2257.       if (bar == win->hbar) {
  2258. ***************
  2259. *** 306,311 ****
  2260. --- 325,332 ----
  2261.       deadline= 0;
  2262.       if (TrackControl(bar, PASSPOINT *pwhere, action) == inThumb)
  2263.           usescrollbarvalues(win);
  2264. +     
  2265. +     SetPort(win->w); /*  THIS IS NEEDED!!! */
  2266.   }
  2267.   
  2268.   static pascal
  2269. ***************
  2270. *** 315,321 ****
  2271.   {
  2272.       long now= TickCount();
  2273.       if (now >= deadline && pcode != 0) {
  2274. !         deltabar(bar, scrollstep);
  2275.           usescrollbarvalues(scrollwin);
  2276.           wupdate(scrollwin);
  2277.           if (deadline == 0 && KeyThresh > KeyRepThresh)
  2278. --- 336,342 ----
  2279.   {
  2280.       long now= TickCount();
  2281.       if (now >= deadline && pcode != 0) {
  2282. !          deltabar(bar, scrollstep);
  2283.           usescrollbarvalues(scrollwin);
  2284.           wupdate(scrollwin);
  2285.           if (deadline == 0 && KeyThresh > KeyRepThresh)
  2286. ***************
  2287. *** 391,399 ****
  2288.       }
  2289.   }
  2290.   
  2291.   void
  2292. ! makescrollbars(win)
  2293.       WINDOW *win;
  2294.   {
  2295.       Rect r;
  2296.       int id= scrollBarProc;
  2297. --- 412,431 ----
  2298.       }
  2299.   }
  2300.   
  2301. + #ifdef JURJENBARPROC
  2302. + static int cdefexists _ARGS((int));
  2303. + static int
  2304. + cdefexists(id)
  2305. +     int id;
  2306. + {
  2307. +     return GetResource('CDEF', id/16) != NULL;
  2308. + }
  2309. + #endif
  2310. + 
  2311.   void
  2312. ! makescrollbars(win, hor, ver)
  2313.       WINDOW *win;
  2314. +     /*bool*/int hor, ver;
  2315.   {
  2316.       Rect r;
  2317.       int id= scrollBarProc;
  2318. ***************
  2319. *** 412,438 ****
  2320.   #endif JURJENBARPROC
  2321.   
  2322.       SetRect(&r, 0, 0, 1, 1); /* Dummy rectangle */
  2323. !     win->hbar= NewControl(win->w,
  2324. !         &r, "", false, 0, 0, 0, scrollBarProc, 0L);
  2325. !     win->vbar= NewControl(win->w,
  2326. !         &r, "", false, 0, 0, 0, id, 0L);
  2327.       sizescrollbars(win);
  2328.   }
  2329.   
  2330. - #ifdef JURJENBARPROC
  2331. - static int
  2332. - cdefexists(id)
  2333. -     int id;
  2334. - {
  2335. -     return GetResource('CDEF', id/16) != NULL;
  2336. - }
  2337. - #endif
  2338. - 
  2339.   void
  2340.   showscrollbars(win)
  2341.       WINDOW *win;
  2342.   {
  2343. !     DrawGrowIcon(win->w);
  2344.       showbar(win->hbar);
  2345.       showbar(win->vbar);
  2346.   }
  2347. --- 444,463 ----
  2348.   #endif JURJENBARPROC
  2349.   
  2350.       SetRect(&r, 0, 0, 1, 1); /* Dummy rectangle */
  2351. !     if (hor)
  2352. !         win->hbar= NewControl(win->w,
  2353. !             &r, "", false, 0, 0, 0, scrollBarProc, 0L);
  2354. !     if (ver)
  2355. !         win->vbar= NewControl(win->w,
  2356. !             &r, "", false, 0, 0, 0, id, 0L);
  2357.       sizescrollbars(win);
  2358.   }
  2359.   
  2360.   void
  2361.   showscrollbars(win)
  2362.       WINDOW *win;
  2363.   {
  2364. !     _wgrowicon(win);
  2365.       showbar(win->hbar);
  2366.       showbar(win->vbar);
  2367.   }
  2368. ***************
  2369. *** 460,472 ****
  2370.   {
  2371.       Rect r;
  2372.       
  2373. !     /* This should be done while the scroll bars are invisible. */
  2374.       
  2375. !     r= win->w->portRect;
  2376. !     movebar(win->vbar, r.right - BAR, r.top - 1,
  2377. !         r.right + 1, r.bottom - BAR + 1);
  2378. !     movebar(win->hbar, r.left - 1, r.bottom - BAR,
  2379. !         r.right - BAR + 1, r.bottom + 1);
  2380.       setscrollbarvalues(win);
  2381.   }
  2382.   
  2383. --- 485,506 ----
  2384.   {
  2385.       Rect r;
  2386.       
  2387. !     /* This must only be called while the scroll bars are invisible. */
  2388.       
  2389. !     r = win->w->portRect;
  2390. !     r.left = r.right - BAR;
  2391. !     r.top--;
  2392. !     r.bottom -= BAR-1;
  2393. !     r.right++;
  2394. !     movebar(win->vbar, r.left, r.top, r.right, r.bottom);
  2395. !     
  2396. !     r = win->w->portRect;
  2397. !     r.left--;
  2398. !     r.top = r.bottom - BAR;
  2399. !     r.right -= BAR-1;
  2400. !     r.bottom++;
  2401. !     movebar(win->hbar, r.left, r.top, r.right, r.bottom);
  2402. !     
  2403.       setscrollbarvalues(win);
  2404.   }
  2405.   
  2406. ***************
  2407. *** 511,516 ****
  2408. --- 545,554 ----
  2409.       int begin, end;
  2410.   {
  2411.       int range;
  2412. +     
  2413. +     if (bar == NULL)
  2414. +         return;
  2415. +     
  2416.       /* For the caller it's easier to remember to pass win->org{h,v};
  2417.          but for our calculations it's easier to have the sign reversed! */
  2418.       org= -org;
  2419. ***************
  2420. *** 526,534 ****
  2421.   usescrollbarvalues(win)
  2422.       WINDOW *win;
  2423.   {
  2424. !     wsetorigin(win,
  2425. !         GetCtlValue(win->hbar) - GetCtlMin(win->hbar),
  2426. !         GetCtlValue(win->vbar) - GetCtlMin(win->vbar));
  2427.       /* Implies setscrollbarvalues! */
  2428.   }
  2429.   
  2430. --- 564,576 ----
  2431.   usescrollbarvalues(win)
  2432.       WINDOW *win;
  2433.   {
  2434. !     int orgh = 0;
  2435. !     int orgv = 0;
  2436. !     if (win->hbar != NULL)
  2437. !         orgh = GetCtlValue(win->hbar) - GetCtlMin(win->hbar);
  2438. !     if (win->vbar != NULL)
  2439. !         orgv = GetCtlValue(win->vbar) - GetCtlMin(win->vbar);
  2440. !     wsetorigin(win, orgh, orgv);
  2441.       /* Implies setscrollbarvalues! */
  2442.   }
  2443.   
  2444. ***************
  2445. *** 557,567 ****
  2446.       ControlHandle bar;
  2447.       int delta;
  2448.   {
  2449. !     int min= GetCtlMin(bar);
  2450. !     int val= GetCtlValue(bar);
  2451. !     int max= GetCtlMax(bar);
  2452. !     int newval= val + delta;
  2453.       
  2454.       if (newval > max)
  2455.           newval= max;
  2456.       if (newval < min)
  2457. --- 599,613 ----
  2458.       ControlHandle bar;
  2459.       int delta;
  2460.   {
  2461. !     int min, val, max, newval;
  2462.       
  2463. +     if (bar == NULL)
  2464. +         return;
  2465. +     min = GetCtlMin(bar);
  2466. +     val = GetCtlValue(bar);
  2467. +     max = GetCtlMax(bar);
  2468. +     newval = val + delta;
  2469. +     
  2470.       if (newval > max)
  2471.           newval= max;
  2472.       if (newval < min)
  2473. ***************
  2474. *** 596,599 ****
  2475. --- 642,676 ----
  2476.           MoveControl(bar, left, top);
  2477.           SizeControl(bar, right-left, bottom-top);
  2478.       }
  2479. + }
  2480. + 
  2481. + void
  2482. + _wgrowicon(win)
  2483. +     WINDOW *win;
  2484. + {
  2485. +     Rect r;
  2486. +     
  2487. +     /* If there are no scroll bars, there is no room to draw the
  2488. +        grow icon; the entire window belongs to the application.
  2489. +        However, clicks in the bottom right corner will still be
  2490. +        intercepted by the window manager. */
  2491. +     
  2492. +     if (win->hbar == NULL && win->vbar == NULL)
  2493. +         return;
  2494. +     
  2495. +     /* Clip the drawing of DrawGrowIcon to the scroll bars present. */
  2496. +     
  2497. +     r= win->w->portRect;
  2498. +     if (win->hbar == NULL)
  2499. +         r.left = r.right - BAR;
  2500. +     if (win->vbar == NULL)
  2501. +         r.top = r.bottom - BAR;
  2502. +     ClipRect(&r);
  2503. +     
  2504. +     DrawGrowIcon(win->w);
  2505. +     
  2506. +     /* Reset clipping */
  2507. +     
  2508. +     SetRect(&r, -32000, -32000, 32000, 32000);
  2509. +     ClipRect(&r);
  2510.   }
  2511.