home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-387-Vol-3of3.iso / a / amix2410.zip / PATCH1 next >
Text File  |  1992-08-26  |  48KB  |  1,681 lines
  1. *** 1.1    1992/08/23 17:46:38
  2. --- tigdebug.c    1992/08/14 14:50:16
  3. ***************
  4. *** 1,11 ****
  5. --- 1,15 ----
  6.   void
  7.   Trace(char *arg)
  8.   {
  9. + #ifdef DOTRACE
  10.     ErrorF("Trace %s\n", arg);
  11. + #endif
  12.   }
  13.   
  14.   void
  15.   Untrace(char *arg)
  16.   {
  17. + #ifdef DOTRACE
  18.     ErrorF("Untrace %s\n", arg);
  19. + #endif
  20.   }
  21. *** 1.1    1992/08/23 17:46:38
  22. --- tiggc.c    1992/08/22 16:02:11
  23. ***************
  24. *** 1,6 ****
  25. --- 1,10 ----
  26.   /*
  27.    * TIGA GC control and manipulation
  28.    *
  29. +  * 10 Aug 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  30. +  *                    Fixed "memory leak" caused by
  31. +  *                    allocating tbox structures that
  32. +  *                    were never freed.
  33.    * 16 Jan 92 Keith Gabryelski        Bug fix in
  34.    *                    tigSetstip() that would cause
  35.    *                    stipples that had positive indexes
  36. ***************
  37. *** 544,550 ****
  38.   { 
  39.     GCPRIV *pPriv;
  40.     int win_moved;
  41. !   BoxRec *tbox;
  42.     PixmapPtr pPix=(PixmapPtr)pDraw;
  43.     extern void miPolyPoint();
  44.     
  45. --- 548,554 ----
  46.   { 
  47.     GCPRIV *pPriv;
  48.     int win_moved;
  49. !   BoxRec tbox;
  50.     PixmapPtr pPix=(PixmapPtr)pDraw;
  51.     extern void miPolyPoint();
  52.     
  53. ***************
  54. *** 569,580 ****
  55.         else if(pGC->clientClipType==CT_NONE)
  56.       { 
  57.         (*pGC->pScreen->RegionDestroy)(pPriv->clip);
  58. !       tbox=XNEW(BoxRec);
  59. !       tbox->x1=0;
  60. !           tbox->y1=0;
  61. !       tbox->x2=pDraw->width; 
  62. !       tbox->y2=pDraw->height;
  63. !       pPriv->clip=(*pGC->pScreen->RegionCreate)(tbox, 1);
  64.         win_moved=TRUE;
  65.       }
  66.       }
  67. --- 573,583 ----
  68.         else if(pGC->clientClipType==CT_NONE)
  69.       { 
  70.         (*pGC->pScreen->RegionDestroy)(pPriv->clip);
  71. !       tbox.x1=0;
  72. !           tbox.y1=0;
  73. !       tbox.x2=pDraw->width; 
  74. !       tbox.y2=pDraw->height;
  75. !       pPriv->clip=(*pGC->pScreen->RegionCreate)(&tbox, 1);
  76.         win_moved=TRUE;
  77.       }
  78.       }
  79. *** 1.1    1992/08/23 17:46:38
  80. --- tigimag.c    1992/08/22 16:04:58
  81. ***************
  82. *** 2,7 ****
  83. --- 2,11 ----
  84.    * More X primitives; primarily those dealing with 
  85.    * blits and images
  86.    *
  87. +  * 10 Aug 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  88. +  *                    Fixed "memory leak" caused by
  89. +  *                    allocating tbox structures that
  90. +  *                    were never freed.
  91.    * 22 Jun 90 Erich Rickheit KSC  Admitted responsibility
  92.    *  5 Jul 90 Erich Rickheit KSC  Moved in tigCopyArea
  93.    */
  94. ***************
  95. *** 88,94 ****
  96.       RegionPtr      reg, draw;
  97.       GCPRIV        * pPriv;
  98.       long    bm;
  99. !     BoxRec        * tbox;
  100.       WindowPtr      pWin;
  101.       unsigned char    *s;
  102.   
  103. --- 92,98 ----
  104.       RegionPtr      reg, draw;
  105.       GCPRIV        * pPriv;
  106.       long    bm;
  107. !     BoxRec        tbox;
  108.       WindowPtr      pWin;
  109.       unsigned char    *s;
  110.   
  111. ***************
  112. *** 129,140 ****
  113.               *s = swiz[*s];
  114.           host2gsp(pImage, bm, (p * h) / 8, 1);
  115.           /* figger clip region */
  116. !         tbox = XNEW(BoxRec);
  117. !         tbox->x1 = xorg + x; 
  118. !         tbox->y1 = yorg + y;
  119. !         tbox->x2 = tbox->x1 + w; 
  120. !         tbox->y2 = tbox->y1 + h;
  121. !         draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  122.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  123.           /* blit that mother */
  124.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) { 
  125. --- 133,143 ----
  126.               *s = swiz[*s];
  127.           host2gsp(pImage, bm, (p * h) / 8, 1);
  128.           /* figger clip region */
  129. !         tbox.x1 = xorg + x; 
  130. !         tbox.y1 = yorg + y;
  131. !         tbox.x2 = tbox.x1 + w; 
  132. !         tbox.y2 = tbox.y1 + h;
  133. !         draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  134.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  135.           /* blit that mother */
  136.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) { 
  137. ***************
  138. *** 163,174 ****
  139.           }
  140.           set_srcbm(bm, p, w, h, 1);
  141.           /* figger clip region */
  142. !         tbox = XNEW(BoxRec);
  143. !         tbox->x1 = xorg + x; 
  144. !         tbox->y1 = yorg + y;
  145. !         tbox->x2 = tbox->x1 + w; 
  146. !         tbox->y2 = tbox->y1 + h;
  147. !         draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  148.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  149.           set_fcolor(0); /* clear stuff out */
  150.           for (r = 0; r < REGION_NUM_RECTS(draw); r++)
  151. --- 166,176 ----
  152.           }
  153.           set_srcbm(bm, p, w, h, 1);
  154.           /* figger clip region */
  155. !         tbox.x1 = xorg + x; 
  156. !         tbox.y1 = yorg + y;
  157. !         tbox.x2 = tbox.x1 + w; 
  158. !         tbox.y2 = tbox.y1 + h;
  159. !         draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  160.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  161.           set_fcolor(0); /* clear stuff out */
  162.           for (r = 0; r < REGION_NUM_RECTS(draw); r++)
  163. ***************
  164. *** 207,218 ****
  165.                */
  166.           p = (w + 3) & ~3;
  167.           /* figger clip region */
  168. !         tbox = XNEW(BoxRec);
  169. !         tbox->x1 = xorg + x; 
  170. !         tbox->y1 = yorg + y;
  171. !         tbox->x2 = tbox->x1 + w; 
  172. !         tbox->y2 = tbox->y1 + h;
  173. !         draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  174.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  175.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) { 
  176.               host2gspxy(pImage, p, scrtop, scrpitch * 8,
  177. --- 209,219 ----
  178.                */
  179.           p = (w + 3) & ~3;
  180.           /* figger clip region */
  181. !         tbox.x1 = xorg + x; 
  182. !         tbox.y1 = yorg + y;
  183. !         tbox.x2 = tbox.x1 + w; 
  184. !         tbox.y2 = tbox.y1 + h;
  185. !         draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  186.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  187.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) { 
  188.               host2gspxy(pImage, p, scrtop, scrpitch * 8,
  189. ***************
  190. *** 254,260 ****
  191.       RegionPtr      reg, draw;
  192.       GCPRIV        * pPriv;
  193.       long    bm;
  194. !     BoxRec        * tbox;
  195.       WindowPtr      pWin;
  196.       unsigned char    *s, *t, *bits;
  197.       int    fg, bg;
  198. --- 255,261 ----
  199.       RegionPtr      reg, draw;
  200.       GCPRIV        * pPriv;
  201.       long    bm;
  202. !     BoxRec        tbox;
  203.       WindowPtr      pWin;
  204.       unsigned char    *s, *t, *bits;
  205.       int    fg, bg;
  206. ***************
  207. *** 287,298 ****
  208.       /* send down bits */
  209.       host2gsp(bits, bm, pBitmap->devKind * h, 1);
  210.       /* figger rectangle */
  211. !     tbox = XNEW(BoxRec);
  212. !     tbox->x1 = xs; 
  213. !     tbox->y1 = ys;
  214. !     tbox->x2 = tbox->x1 + w; 
  215. !     tbox->y2 = tbox->y1 + h;
  216. !     draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  217.       (*pGC->pScreen->Intersect)(draw, draw, reg);
  218.   
  219.       i = (~pGC->planemask) & 0xff;
  220. --- 288,298 ----
  221.       /* send down bits */
  222.       host2gsp(bits, bm, pBitmap->devKind * h, 1);
  223.       /* figger rectangle */
  224. !     tbox.x1 = xs; 
  225. !     tbox.y1 = ys;
  226. !     tbox.x2 = tbox.x1 + w; 
  227. !     tbox.y2 = tbox.y1 + h;
  228. !     draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  229.       (*pGC->pScreen->Intersect)(draw, draw, reg);
  230.   
  231.       i = (~pGC->planemask) & 0xff;
  232. ***************
  233. *** 336,342 ****
  234.   int    xSrc, ySrc, width, height, xDst, yDst;
  235.   {
  236.     RegionPtr     blitme, temp;
  237. !   BoxRec       *tbox;
  238.     ScreenPtr     pScreen=pGC->pScreen;
  239.     int           count, i, j, t, w, h, Sx, Sy, Dx, Dy;
  240.     int          *order, *wid;
  241. --- 336,342 ----
  242.   int    xSrc, ySrc, width, height, xDst, yDst;
  243.   {
  244.     RegionPtr     blitme, temp;
  245. !   BoxRec       tbox;
  246.     ScreenPtr     pScreen=pGC->pScreen;
  247.     int           count, i, j, t, w, h, Sx, Sy, Dx, Dy;
  248.     int          *order, *wid;
  249. ***************
  250. *** 355,365 ****
  251.   
  252.     if(pSrc->type == DRAWABLE_PIXMAP)
  253.       { 
  254. !       tbox = XNEW(BoxRec);
  255. !       tbox->x1 = tbox->y1 = 0;
  256. !       tbox->x2 = ((PixmapPtr)pSrc)->drawable.width;
  257. !       tbox->y2 = ((PixmapPtr)pSrc)->drawable.height;
  258. !       blitme = (*pScreen->RegionCreate)(tbox, 1);
  259.         Sx = Sy = 0;
  260.       }
  261.     else
  262. --- 355,364 ----
  263.   
  264.     if(pSrc->type == DRAWABLE_PIXMAP)
  265.       { 
  266. !       tbox.x1 = tbox.y1 = 0;
  267. !       tbox.x2 = ((PixmapPtr)pSrc)->drawable.width;
  268. !       tbox.y2 = ((PixmapPtr)pSrc)->drawable.height;
  269. !       blitme = (*pScreen->RegionCreate)(&tbox, 1);
  270.         Sx = Sy = 0;
  271.       }
  272.     else
  273. ***************
  274. *** 377,398 ****
  275.         (*pScreen->TranslateRegion)(blitme, -Sx, -Sy);
  276.       }
  277.     /* intersect with source rectangle */
  278. !   tbox = XNEW(BoxRec);
  279. !   tbox->x1 = xSrc; 
  280. !   tbox->y1 = ySrc;
  281. !   tbox->x2 = tbox->x1 + width; 
  282. !   tbox->y2 = tbox->y1 + height;
  283. !   temp = (*pScreen->RegionCreate)(tbox, 1);
  284.     (*pScreen->Intersect)(blitme, blitme, temp);
  285.     (*pGC->pScreen->RegionDestroy)(temp);
  286.     /* intersect with dest clip */
  287.     if(pDst->type == DRAWABLE_PIXMAP)
  288.       { 
  289. !       tbox = XNEW(BoxRec);
  290. !       tbox->x1 = tbox->y1 = 0;
  291. !       tbox->x2 = ((PixmapPtr)pDst)->drawable.width;
  292. !       tbox->y2 = ((PixmapPtr)pDst)->drawable.height;
  293. !       temp = (*pScreen->RegionCreate)(tbox, 1);
  294.         (*pScreen->TranslateRegion)(temp, -xDst + xSrc, -yDst + ySrc);
  295.         Dx = Dy = 0;
  296.       }
  297. --- 376,395 ----
  298.         (*pScreen->TranslateRegion)(blitme, -Sx, -Sy);
  299.       }
  300.     /* intersect with source rectangle */
  301. !   tbox.x1 = xSrc; 
  302. !   tbox.y1 = ySrc;
  303. !   tbox.x2 = tbox.x1 + width; 
  304. !   tbox.y2 = tbox.y1 + height;
  305. !   temp = (*pScreen->RegionCreate)(&tbox, 1);
  306.     (*pScreen->Intersect)(blitme, blitme, temp);
  307.     (*pGC->pScreen->RegionDestroy)(temp);
  308.     /* intersect with dest clip */
  309.     if(pDst->type == DRAWABLE_PIXMAP)
  310.       { 
  311. !       tbox.x1 = tbox.y1 = 0;
  312. !       tbox.x2 = ((PixmapPtr)pDst)->drawable.width;
  313. !       tbox.y2 = ((PixmapPtr)pDst)->drawable.height;
  314. !       temp = (*pScreen->RegionCreate)(&tbox, 1);
  315.         (*pScreen->TranslateRegion)(temp, -xDst + xSrc, -yDst + ySrc);
  316.         Dx = Dy = 0;
  317.       }
  318. *** 1.1    1992/08/23 17:46:38
  319. --- tigimg.c    1992/08/22 16:04:08
  320. ***************
  321. *** 2,7 ****
  322. --- 2,11 ----
  323.    * More X primitives; primarily those dealing with 
  324.    * blits and images
  325.    *
  326. +  * 10 Aug 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  327. +  *                    Fixed "memory leak" caused by
  328. +  *                    allocating tbox structures that
  329. +  *                    were never freed.
  330.    * 22 Jun 90 Erich Rickheit KSC  Admitted responsibility
  331.    *  5 Jul 90 Erich Rickheit KSC  Moved in tigCopyArea
  332.    */
  333. ***************
  334. *** 88,94 ****
  335.       RegionPtr      reg, draw;
  336.       GCPRIV        * pPriv;
  337.       long    bm;
  338. !     BoxRec        * tbox;
  339.       WindowPtr      pWin;
  340.       unsigned char    *s;
  341.   
  342. --- 92,98 ----
  343.       RegionPtr      reg, draw;
  344.       GCPRIV        * pPriv;
  345.       long    bm;
  346. !     BoxRec        tbox;
  347.       WindowPtr      pWin;
  348.       unsigned char    *s;
  349.   
  350. ***************
  351. *** 129,140 ****
  352.               *s = swiz[*s];
  353.           host2gsp(pImage, bm, (p * h) / 8, 1);
  354.           /* figger clip region */
  355. !         tbox = XNEW(BoxRec);
  356. !         tbox->x1 = xorg + x; 
  357. !         tbox->y1 = yorg + y;
  358. !         tbox->x2 = tbox->x1 + w; 
  359. !         tbox->y2 = tbox->y1 + h;
  360. !         draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  361.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  362.           /* blit that mother */
  363.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) { 
  364. --- 133,143 ----
  365.               *s = swiz[*s];
  366.           host2gsp(pImage, bm, (p * h) / 8, 1);
  367.           /* figger clip region */
  368. !         tbox.x1 = xorg + x; 
  369. !         tbox.y1 = yorg + y;
  370. !         tbox.x2 = tbox.x1 + w; 
  371. !         tbox.y2 = tbox.y1 + h;
  372. !         draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  373.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  374.           /* blit that mother */
  375.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) { 
  376. ***************
  377. *** 163,174 ****
  378.           }
  379.           set_srcbm(bm, p, w, h, 1);
  380.           /* figger clip region */
  381. !         tbox = XNEW(BoxRec);
  382. !         tbox->x1 = xorg + x; 
  383. !         tbox->y1 = yorg + y;
  384. !         tbox->x2 = tbox->x1 + w; 
  385. !         tbox->y2 = tbox->y1 + h;
  386. !         draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  387.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  388.           set_fcolor(0); /* clear stuff out */
  389.           for (r = 0; r < REGION_NUM_RECTS(draw); r++)
  390. --- 166,176 ----
  391.           }
  392.           set_srcbm(bm, p, w, h, 1);
  393.           /* figger clip region */
  394. !         tbox.x1 = xorg + x; 
  395. !         tbox.y1 = yorg + y;
  396. !         tbox.x2 = tbox.x1 + w; 
  397. !         tbox.y2 = tbox.y1 + h;
  398. !         draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  399.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  400.           set_fcolor(0); /* clear stuff out */
  401.           for (r = 0; r < REGION_NUM_RECTS(draw); r++)
  402. ***************
  403. *** 207,218 ****
  404.                */
  405.           p = (w + 3) & ~3;
  406.           /* figger clip region */
  407. !         tbox = XNEW(BoxRec);
  408. !         tbox->x1 = xorg + x; 
  409. !         tbox->y1 = yorg + y;
  410. !         tbox->x2 = tbox->x1 + w; 
  411. !         tbox->y2 = tbox->y1 + h;
  412. !         draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  413.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  414.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) {
  415.           HOST2GSPXY(pImage, p, scrtop, scrpitch * 8,
  416. --- 209,219 ----
  417.                */
  418.           p = (w + 3) & ~3;
  419.           /* figger clip region */
  420. !         tbox.x1 = xorg + x; 
  421. !         tbox.y1 = yorg + y;
  422. !         tbox.x2 = tbox.x1 + w; 
  423. !         tbox.y2 = tbox.y1 + h;
  424. !         draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  425.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  426.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) {
  427.           HOST2GSPXY(pImage, p, scrtop, scrpitch * 8,
  428. ***************
  429. *** 256,262 ****
  430.       RegionPtr      reg, draw;
  431.       GCPRIV        * pPriv;
  432.       long    bm;
  433. !     BoxRec        * tbox;
  434.       WindowPtr      pWin;
  435.       unsigned char    *s, *t, *bits;
  436.       int    fg, bg;
  437. --- 257,263 ----
  438.       RegionPtr      reg, draw;
  439.       GCPRIV        * pPriv;
  440.       long    bm;
  441. !     BoxRec        tbox;
  442.       WindowPtr      pWin;
  443.       unsigned char    *s, *t, *bits;
  444.       int    fg, bg;
  445. ***************
  446. *** 288,299 ****
  447.       /* send down bits */
  448.       host2gsp(bits, bm, pBitmap->devKind * h, 1);
  449.       /* figger rectangle */
  450. !     tbox = XNEW(BoxRec);
  451. !     tbox->x1 = xs; 
  452. !     tbox->y1 = ys;
  453. !     tbox->x2 = tbox->x1 + w; 
  454. !     tbox->y2 = tbox->y1 + h;
  455. !     draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  456.       (*pGC->pScreen->Intersect)(draw, draw, reg);
  457.   
  458.       i = (~pGC->planemask) & 0xff;
  459. --- 289,299 ----
  460.       /* send down bits */
  461.       host2gsp(bits, bm, pBitmap->devKind * h, 1);
  462.       /* figger rectangle */
  463. !     tbox.x1 = xs; 
  464. !     tbox.y1 = ys;
  465. !     tbox.x2 = tbox.x1 + w; 
  466. !     tbox.y2 = tbox.y1 + h;
  467. !     draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  468.       (*pGC->pScreen->Intersect)(draw, draw, reg);
  469.   
  470.       i = (~pGC->planemask) & 0xff;
  471. ***************
  472. *** 337,343 ****
  473.   int    xSrc, ySrc, width, height, xDst, yDst;
  474.   {
  475.     RegionPtr     blitme, temp;
  476. !   BoxRec       *tbox;
  477.     ScreenPtr     pScreen=pGC->pScreen;
  478.     int           count, i, j, t, w, h, Sx, Sy, Dx, Dy;
  479.     int          *order, *wid;
  480. --- 337,343 ----
  481.   int    xSrc, ySrc, width, height, xDst, yDst;
  482.   {
  483.     RegionPtr     blitme, temp;
  484. !   BoxRec       tbox;
  485.     ScreenPtr     pScreen=pGC->pScreen;
  486.     int           count, i, j, t, w, h, Sx, Sy, Dx, Dy;
  487.     int          *order, *wid;
  488. ***************
  489. *** 356,366 ****
  490.   
  491.     if(pSrc->type == DRAWABLE_PIXMAP)
  492.       { 
  493. !       tbox = XNEW(BoxRec);
  494. !       tbox->x1 = tbox->y1 = 0;
  495. !       tbox->x2 = ((PixmapPtr)pSrc)->drawable.width;
  496. !       tbox->y2 = ((PixmapPtr)pSrc)->drawable.height;
  497. !       blitme = (*pScreen->RegionCreate)(tbox, 1);
  498.         Sx = Sy = 0;
  499.       }
  500.     else
  501. --- 356,365 ----
  502.   
  503.     if(pSrc->type == DRAWABLE_PIXMAP)
  504.       { 
  505. !       tbox.x1 = tbox.y1 = 0;
  506. !       tbox.x2 = ((PixmapPtr)pSrc)->drawable.width;
  507. !       tbox.y2 = ((PixmapPtr)pSrc)->drawable.height;
  508. !       blitme = (*pScreen->RegionCreate)(&tbox, 1);
  509.         Sx = Sy = 0;
  510.       }
  511.     else
  512. ***************
  513. *** 378,399 ****
  514.         (*pScreen->TranslateRegion)(blitme, -Sx, -Sy);
  515.       }
  516.     /* intersect with source rectangle */
  517. !   tbox = XNEW(BoxRec);
  518. !   tbox->x1 = xSrc; 
  519. !   tbox->y1 = ySrc;
  520. !   tbox->x2 = tbox->x1 + width; 
  521. !   tbox->y2 = tbox->y1 + height;
  522. !   temp = (*pScreen->RegionCreate)(tbox, 1);
  523.     (*pScreen->Intersect)(blitme, blitme, temp);
  524.     (*pGC->pScreen->RegionDestroy)(temp);
  525.     /* intersect with dest clip */
  526.     if(pDst->type == DRAWABLE_PIXMAP)
  527.       { 
  528. !       tbox = XNEW(BoxRec);
  529. !       tbox->x1 = tbox->y1 = 0;
  530. !       tbox->x2 = ((PixmapPtr)pDst)->drawable.width;
  531. !       tbox->y2 = ((PixmapPtr)pDst)->drawable.height;
  532. !       temp = (*pScreen->RegionCreate)(tbox, 1);
  533.         (*pScreen->TranslateRegion)(temp, -xDst + xSrc, -yDst + ySrc);
  534.         Dx = Dy = 0;
  535.       }
  536. --- 377,396 ----
  537.         (*pScreen->TranslateRegion)(blitme, -Sx, -Sy);
  538.       }
  539.     /* intersect with source rectangle */
  540. !   tbox.x1 = xSrc; 
  541. !   tbox.y1 = ySrc;
  542. !   tbox.x2 = tbox.x1 + width; 
  543. !   tbox.y2 = tbox.y1 + height;
  544. !   temp = (*pScreen->RegionCreate)(&tbox, 1);
  545.     (*pScreen->Intersect)(blitme, blitme, temp);
  546.     (*pGC->pScreen->RegionDestroy)(temp);
  547.     /* intersect with dest clip */
  548.     if(pDst->type == DRAWABLE_PIXMAP)
  549.       { 
  550. !       tbox.x1 = tbox.y1 = 0;
  551. !       tbox.x2 = ((PixmapPtr)pDst)->drawable.width;
  552. !       tbox.y2 = ((PixmapPtr)pDst)->drawable.height;
  553. !       temp = (*pScreen->RegionCreate)(&tbox, 1);
  554.         (*pScreen->TranslateRegion)(temp, -xDst + xSrc, -yDst + ySrc);
  555.         Dx = Dy = 0;
  556.       }
  557. *** 1.1    1992/08/23 17:46:38
  558. --- tigmem.c    1992/08/22 16:08:48
  559. ***************
  560. *** 1,6 ****
  561. --- 1,9 ----
  562.   /*
  563.    * Routines to manage TIGA on-board memory
  564.    *
  565. +  * 10 Aug 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  566. +  *            Fixed problem in "tigmemdone" that could
  567. +  *            cause server crash if no blocks ever allocated
  568.    * 16 Jan 92 Keith Gabryelski        Bug fix in tigrequest that
  569.    *                    may cause 0 to be return
  570.    *                    even if memory was allocated.
  571. ***************
  572. *** 67,72 ****
  573. --- 70,77 ----
  574.       BLOCK * cur = blocks, *t;
  575.       unsigned long    loc;
  576.   
  577. +     if (blocks == NULL)
  578. +     return;
  579.       loc = blocks->address;
  580.       while (cur) { 
  581.           t = cur->next;
  582. ***************
  583. *** 75,80 ****
  584. --- 80,86 ----
  585.           Xfree(cur);
  586.           cur = t;
  587.       }
  588. +     blocks = NULL;
  589.       gsp_free(loc);
  590.   }
  591.   
  592. *** 1.1    1992/08/23 17:46:38
  593. --- tigpix.c    1992/08/22 16:22:16
  594. ***************
  595. *** 9,14 ****
  596. --- 9,23 ----
  597.    * of the data. Note that the pitch is padded out to a word boundary.
  598.    * Pixmaps (at this point) can be only 1 or 8 bits deep.
  599.    *
  600. +  * 15 Aug 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  601. +  *    Fixed problem in tigpixSolidSp and tigpixStipSp which caused
  602. +  *    server crash and/or display anomalies because clipping wasn't
  603. +  *    being done.  tigpixStipSp re-written using technique from
  604. +  *    X11R5 sources by Keith Gabryelski.  NOTE: tigpixTileSp probably
  605. +  *      still needs work.
  606. +  * 5 Jul 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  607. +  *    Fixed problem in tigDestroyPixmap that caused server crash
  608. +  *    if Pixmap already freed.
  609.    * 22 Jun 90 Erich Rickheit KSC  Admitted responsibility
  610.    * 28 Jun 91 Aaron Orenstein     (Partially) Recoded for X11R4
  611.    */
  612. ***************
  613. *** 100,106 ****
  614.    * if(!IS_VALID_PIXMAP(pPix)) return TRUE;
  615.    */
  616.   
  617. !   if(pPixmap)
  618.       if(--pPixmap->refcnt==0)
  619.         {
  620.       if(pPixmap->devPrivate.ptr) Xfree(pPixmap->devPrivate.ptr);
  621. --- 109,115 ----
  622.    * if(!IS_VALID_PIXMAP(pPix)) return TRUE;
  623.    */
  624.   
  625. !   if(pPixmap) {
  626.       if(--pPixmap->refcnt==0)
  627.         {
  628.       if(pPixmap->devPrivate.ptr) Xfree(pPixmap->devPrivate.ptr);
  629. ***************
  630. *** 108,113 ****
  631. --- 117,123 ----
  632.       Xfree(pPixmap);
  633.       return TRUE;
  634.         }
  635. +     }
  636.   
  637.     UNTRACE("tigDestroyPixmap");
  638.     return TRUE;
  639. ***************
  640. *** 257,277 ****
  641.     UNTRACE("tigpixSolidSp");
  642.   }
  643.   #else
  644. ! void tigpixSolidSp(pPixmap, pGC, npt, ppt, pwidth, fSorted)
  645. !     PixmapPtr   pPixmap;
  646. !     GCPtr    pGC;
  647. !     register int          npt;        /* number of spans to fill */
  648. !     register DDXPointPtr  ppt;        /* pointer to list of start points */
  649. !     register int         *pwidth;    /* pointer to list of n widths */
  650. !     int     fSorted;
  651.   {
  652.     register int  *dstBase;
  653.     register int   color;
  654.     register int   alu;
  655.     int            pitch; /* pitch in Longwords */
  656.   
  657.     TRACE("tigpixSolidSp");
  658.   
  659.     dstBase=(int *)pPixmap->devPrivate.ptr;
  660.     color=LongByteRepeater(pGC->fgPixel&0xFF);
  661.     alu=pGC->alu;
  662. --- 267,310 ----
  663.     UNTRACE("tigpixSolidSp");
  664.   }
  665.   #else
  666. ! void tigpixSolidSp(pPixmap, pGC, nptInit, pptInit, pwidthInit, fSorted)
  667. ! PixmapPtr pPixmap;
  668. ! GCPtr pGC;
  669. ! int nptInit;        /* number of spans to fill */
  670. ! DDXPointPtr  pptInit;        /* pointer to list of start points */
  671. ! int *pwidthInit;    /* pointer to list of n widths */
  672. ! int fSorted;
  673.   {
  674.     register int  *dstBase;
  675.     register int   color;
  676.     register int   alu;
  677.     int            pitch; /* pitch in Longwords */
  678. +   register int   npt;
  679. +   register DDXPointPtr ppt;
  680. +   register int   *pwidth;
  681. +   int            *pwidthFree;    /* copies of the pointers to free */
  682. +   DDXPointPtr    pptFree;
  683. +   GCPRIV         *pPriv;
  684.   
  685.     TRACE("tigpixSolidSp");
  686.   
  687. +   pPriv=(GCPRIV *)pGC->devPrivates[tigGCPrivateIndex].ptr;
  688. +   npt=nptInit*miFindMaxBand(pPriv->clip);
  689. +   pwidthFree=(int *)ALLOCATE_LOCAL(npt*sizeof(int));
  690. +   pptFree=(DDXPointPtr)ALLOCATE_LOCAL(npt*sizeof(DDXPointRec));
  691. + 
  692. +   if(!(pptFree&&pwidthFree))
  693. +     {
  694. +       if(pptFree) DEALLOCATE_LOCAL(pptFree);
  695. +       if(pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
  696. +         return;
  697. +     }
  698. + 
  699. +   pwidth=pwidthFree;
  700. +   ppt=pptFree;
  701. +   
  702. +   npt=miClipSpans(pPriv->clip,pptInit,pwidthInit,nptInit,ppt,pwidth,fSorted);
  703. + 
  704.     dstBase=(int *)pPixmap->devPrivate.ptr;
  705.     color=LongByteRepeater(pGC->fgPixel&0xFF);
  706.     alu=pGC->alu;
  707. ***************
  708. *** 374,379 ****
  709. --- 407,572 ----
  710.   /*
  711.    * Draws stippled spans into the pixmap
  712.    */
  713. + void
  714. + tigpixStipSp(pPixmap, pGC, nptInit, pptInit, pwidthInit, fSorted)
  715. + PixmapPtr pPixmap;
  716. + GCPtr pGC;
  717. + int nptInit;
  718. + DDXPointPtr pptInit;
  719. + int *pwidthInit;
  720. + int fSorted;
  721. + {
  722. +     PixmapPtr               tile;
  723. +     unsigned char          *srcBase;
  724. +     unsigned char          *dstBase;
  725. +     register unsigned char  color;
  726. +     register int            alu;
  727. +     register int   npt;
  728. +     register DDXPointPtr ppt;
  729. +     register int   *pwidth;
  730. +     int            *pwidthFree;    /* copies of the pointers to free */
  731. +     DDXPointPtr    pptFree;
  732. +     GCPRIV         *pPriv;
  733. +   
  734. +     pPriv=(GCPRIV *)pGC->devPrivates[tigGCPrivateIndex].ptr;
  735. + 
  736. +     npt=nptInit*miFindMaxBand(pPriv->clip);
  737. +     pwidthFree=(int *)ALLOCATE_LOCAL(npt*sizeof(int));
  738. +     pptFree=(DDXPointPtr)ALLOCATE_LOCAL(npt*sizeof(DDXPointRec));
  739. + 
  740. +     if(!(pptFree&&pwidthFree))
  741. +       {
  742. +         if(pptFree) DEALLOCATE_LOCAL(pptFree);
  743. +         if(pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
  744. +         return;
  745. +       }
  746. + 
  747. +     pwidth=pwidthFree;
  748. +     ppt=pptFree;
  749. +   
  750. +     npt=miClipSpans(pPriv->clip,pptInit,pwidthInit,nptInit,ppt,pwidth,fSorted);
  751. + 
  752. +     tile = pGC->stipple;
  753. +     srcBase = (unsigned char *)tile->devPrivate.ptr;
  754. +     dstBase = (unsigned char *)pPixmap->devPrivate.ptr;
  755. +   
  756. +     color = pGC->fgPixel;
  757. +     alu = pGC->alu;
  758. + 
  759. +     if (pPixmap->drawable.depth == 8)
  760. +     {
  761. +     while (npt--)
  762. +     {
  763. +         register unsigned char *dst;
  764. +         register unsigned char *src;
  765. +         int                     sbyte, sbit, srcX;
  766. +         int                     x, x0, x1;
  767. +   
  768. +         x0 = ppt->x;
  769. +         x1 = x0 + *pwidth;
  770. + 
  771. +         if (x0 < x1)
  772. +         {
  773. +         dst = dstBase + (ppt->y * pPixmap->devKind);
  774. +         src = srcBase +
  775. +             (((ppt->y-pGC->patOrg.y) % ((int)tile->drawable.height)) *
  776. +              tile->devKind);
  777. +         srcX = (x0 - pGC->patOrg.x) % (int)(tile->drawable.width);
  778. +         sbyte = srcX / 8; 
  779. +         sbit = 0x80 >> (srcX&7);
  780. + 
  781. +         for (x = x0; x < x1; x++)
  782. +         { 
  783. +             if (sbit & src[sbyte]) DoRop(dst[x], alu, color, dst[x]);
  784. + 
  785. +             if (++srcX == (int)(tile->drawable.width))
  786. +             { 
  787. +             sbit = 0x80;
  788. +             srcX = sbyte = 0;
  789. +             }
  790. +             else if(!(sbit >>= 1))
  791. +             { 
  792. +             sbit = 0x80;
  793. +             sbyte++;
  794. +             }
  795. +         }
  796. +         }
  797. + 
  798. +         ppt++;
  799. +         pwidth++;
  800. +     }
  801. +     }
  802. +     else                /* 1 bit... */
  803. +     {
  804. +     if (color)
  805. +         color = 0xFF;
  806. + 
  807. +     while(npt--)
  808. +     {
  809. +         register unsigned char *dst;
  810. +         int                     dbyte, dbit;
  811. +         register unsigned char *src;
  812. +         int                     sbyte, sbit, srcX;
  813. +         int                     x, x0, x1;
  814. +         register unsigned char  dstFunc;
  815. + 
  816. +         x0 = ppt->x;
  817. +         x1 = x0 + *pwidth;
  818. + 
  819. +         if (x0 < x1)
  820. +         {
  821. +         dst = dstBase + (ppt->y * pPixmap->devKind);
  822. +         dbyte = x0 / 8;
  823. +         dbit = 0x80 >> (x0&7);
  824. +         DoRop(dstFunc, alu, color, dst[dbyte]);
  825. + 
  826. +         src = srcBase +
  827. +             (((ppt->y-pGC->patOrg.y) % ((int)tile->drawable.height)) *
  828. +              tile->devKind);
  829. +         srcX = (x0 - pGC->patOrg.x) % ((int)tile->drawable.width);
  830. +         sbyte = srcX / 8;
  831. +         sbit = 0x80 >> (srcX&7);
  832. + 
  833. +         for (x = x0; x < x1; x++)
  834. +         {
  835. +             if (sbit & src[sbyte])
  836. +             if(dbit & dstFunc)
  837. +                 dst[dbyte] |= dbit;
  838. +             else
  839. +                 dst[dbyte] &= ~dbit;
  840. + 
  841. +             if (++srcX == ((int)tile->drawable.width))
  842. +             {
  843. +             sbit = 0x80;
  844. +             srcX = sbyte = 0;
  845. +             }
  846. +             else if (!(sbit >>= 1))
  847. +             {
  848. +             sbit = 0x80;
  849. +             sbyte++;
  850. +             }
  851. + 
  852. +             if (!(dbit >>= 1))
  853. +             {
  854. +             dbit = 0x80;
  855. +             dbyte++;
  856. +             DoRop(dstFunc, alu, color, dst[dbyte]);
  857. +             }
  858. +         }
  859. +         }
  860. + 
  861. +         ppt++;
  862. +         pwidth++;
  863. +     }
  864. +     }
  865. +     DEALLOCATE_LOCAL(pptFree);
  866. +     DEALLOCATE_LOCAL(pwidthFree);
  867. + }
  868. + 
  869. + #if 0 /* Rick Schaeffer: Old code...trying new routine above */
  870. + /*
  871. +  * Draws stippled spans into the pixmap
  872. +  */
  873.   void tigpixStipSp(pDraw, pGC, count, pts, width, sorted)
  874.        DrawablePtr    pDraw;
  875.        GCPtr          pGC;
  876. ***************
  877. *** 486,493 ****
  878.       }
  879.     UNTRACE("tigpixStipSp");
  880.   }
  881. ! 
  882. ! 
  883.   
  884.   /*
  885.    * Draws tiled spans into the pixmap
  886. --- 679,685 ----
  887.       }
  888.     UNTRACE("tigpixStipSp");
  889.   }
  890. ! #endif
  891.   
  892.   /*
  893.    * Draws tiled spans into the pixmap
  894. ***************
  895. *** 516,521 ****
  896. --- 708,718 ----
  897.       /*dest = (unsigned char *)pix->devPrivate;*/
  898.       dest = (unsigned char *)pix->devPrivate.ptr; /* RS */
  899.       /*tile = pGC->tile;*/
  900. + 
  901. +     if (pGC->tileIsPixel) {
  902. +         return;
  903. +     }
  904. + 
  905.       tile = pGC->tile.pixmap; /* RS */
  906.       /*src = (unsigned char *)tile->devPrivate;*/
  907.       src = (unsigned char *)tile->devPrivate.ptr; /* RS */
  908. *** 1.1    1992/08/23 17:46:38
  909. --- tigprim.c    1992/08/22 16:26:40
  910. ***************
  911. *** 1,6 ****
  912. --- 1,12 ----
  913.   /*
  914.    * X primitives; Trying to make best use of TIGA primitives
  915.    *
  916. +  * 10 Aug 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  917. +  *    Fixed "memory leak" problem caused by allocation of tbox
  918. +  *    structure that were never freed.
  919. +  * 20 Jul 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  920. +  *    Fixed problem that caused pattern fills to work improperly.  The
  921. +  *    code wasn't waiting for the tiga to finish the fill operation.
  922.    * 22 Jun 90 Erich Rickheit KSC  Admitted responsibility
  923.    *  5 Jul 90 Erich Rickheit KSC  Moved tigCopyArea to tigimg.c
  924.    * 10 Jul 90 Erich Rickheit KSC  Added tigDashLine,tigDashSegment
  925. ***************
  926. *** 223,229 ****
  927.       int    i, j, r, xorg, yorg;
  928.       RegionPtr      reg, draw;
  929.       GCPRIV        * pPriv;
  930. !     BoxRec        * tbox;
  931.   
  932.       TRACE("tigSolidRect");
  933.       xorg=pWin->drawable.x; /* used to be ->origin.x AKO */
  934. --- 229,235 ----
  935.       int    i, j, r, xorg, yorg;
  936.       RegionPtr      reg, draw;
  937.       GCPRIV        * pPriv;
  938. !     BoxRec        tbox;
  939.   
  940.       TRACE("tigSolidRect");
  941.       xorg=pWin->drawable.x; /* used to be ->origin.x AKO */
  942. ***************
  943. *** 240,251 ****
  944.       set_colors(pGC->fgPixel, pGC->bgPixel);
  945.   
  946.       for (i = 0; i < count; i++) {
  947. !         tbox = XNEW(BoxRec);
  948. !         tbox->x1 = xorg + rects[i].x;
  949. !         tbox->y1 = yorg + rects[i].y;
  950. !         tbox->x2 = tbox->x1 + rects[i].width;
  951. !         tbox->y2 = tbox->y1 + rects[i].height;
  952. !         draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  953.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  954.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) {
  955.               fill_rect(REGION_RECTS(draw)[r].x2 - REGION_RECTS(draw)[r].x1,
  956. --- 246,256 ----
  957.       set_colors(pGC->fgPixel, pGC->bgPixel);
  958.   
  959.       for (i = 0; i < count; i++) {
  960. !         tbox.x1 = xorg + rects[i].x;
  961. !         tbox.y1 = yorg + rects[i].y;
  962. !         tbox.x2 = tbox.x1 + rects[i].width;
  963. !         tbox.y2 = tbox.y1 + rects[i].height;
  964. !         draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  965.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  966.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) {
  967.               fill_rect(REGION_RECTS(draw)[r].x2 - REGION_RECTS(draw)[r].x1,
  968. ***************
  969. *** 341,346 ****
  970. --- 346,352 ----
  971.               REGION_RECTS(reg)[r].x1, REGION_RECTS(reg)[r].y1);
  972.           patnfill_polygon(count, (unsigned short *)plist);
  973.       }
  974. +     synchronize();
  975.       set_clip_rect(scrwidth,scrheight, 0, 0);
  976.       UNTRACE("tigStipFillPoly");
  977.   }
  978. ***************
  979. *** 364,370 ****
  980.       int    i, j, r, xorg, yorg;
  981.       RegionPtr      reg, draw;
  982.       GCPRIV        * pPriv;
  983. !     BoxRec        * tbox;
  984.   
  985.       TRACE("tigStipRect");
  986.       xorg=pWin->drawable.x; /* used to be ->origin.x AKO */
  987. --- 370,376 ----
  988.       int    i, j, r, xorg, yorg;
  989.       RegionPtr      reg, draw;
  990.       GCPRIV        * pPriv;
  991. !     BoxRec        tbox;
  992.   
  993.       TRACE("tigStipRect");
  994.       xorg=pWin->drawable.x; /* used to be ->origin.x AKO */
  995. ***************
  996. *** 384,395 ****
  997.       set_colors(pGC->fgPixel, pGC->bgPixel);
  998.   
  999.       for (i = 0; i < count; i++) { 
  1000. !         tbox = XNEW(BoxRec);
  1001. !         tbox->x1 = xorg + rects[i].x;
  1002. !         tbox->y1 = yorg + rects[i].y;
  1003. !         tbox->x2 = tbox->x1 + rects[i].width;
  1004. !         tbox->y2 = tbox->y1 + rects[i].height;
  1005. !         draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  1006.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  1007.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) {
  1008.               patnfill_rect(REGION_RECTS(draw)[r].x2 - REGION_RECTS(draw)[r].x1,
  1009. --- 390,400 ----
  1010.       set_colors(pGC->fgPixel, pGC->bgPixel);
  1011.   
  1012.       for (i = 0; i < count; i++) { 
  1013. !         tbox.x1 = xorg + rects[i].x;
  1014. !         tbox.y1 = yorg + rects[i].y;
  1015. !         tbox.x2 = tbox.x1 + rects[i].width;
  1016. !         tbox.y2 = tbox.y1 + rects[i].height;
  1017. !         draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  1018.           (*pGC->pScreen->Intersect)(draw, draw, reg);
  1019.           for (r = 0; r < REGION_NUM_RECTS(draw); r++) {
  1020.               patnfill_rect(REGION_RECTS(draw)[r].x2 - REGION_RECTS(draw)[r].x1,
  1021. ***************
  1022. *** 398,403 ****
  1023. --- 403,409 ----
  1024.           }
  1025.           (*pGC->pScreen->RegionDestroy)(draw);
  1026.       }
  1027. +     synchronize();
  1028.       UNTRACE("tigStipRect");
  1029.   }
  1030.   
  1031. *** 1.1    1992/08/23 17:46:38
  1032. --- tigscrinit.c    1992/08/23 17:52:25
  1033. ***************
  1034. *** 9,14 ****
  1035. --- 9,19 ----
  1036.   ** Written at the University of Massachusetts at Lowell, Lowell, MA.
  1037.   **
  1038.   */
  1039. + /*
  1040. +  * 20 Jul 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  1041. +  *    Added code to release tiga memory allocated for cursors and
  1042. +  *  patterns.
  1043. + */
  1044.   #include "../amix.h"
  1045.   #include "resource.h"
  1046.   #include "servermd.h"        /* For PixmapBytePad */
  1047. ***************
  1048. *** 35,40 ****
  1049. --- 40,47 ----
  1050.   int tigWindowPrivateIndex;
  1051.   int tigGeneration=0;
  1052.   
  1053. + extern unsigned long tigpatmem;
  1054. + 
  1055.   #ifdef LOWELLTIGA
  1056.   char *tigagm = "/usr/X/lib/tigagm.coff";
  1057.   char *osc1="36.000MHZ";
  1058. ***************
  1059. *** 291,302 ****
  1060.       return TRUE;
  1061.   }
  1062.   
  1063. - 
  1064.   Bool tigCloseScreen(index, pScreen)
  1065.        int index;
  1066.        ScreenPtr pScreen;
  1067.   {
  1068. !   return TRUE;
  1069. ! }
  1070.   
  1071.   
  1072. --- 298,314 ----
  1073.       return TRUE;
  1074.   }
  1075.   
  1076.   Bool tigCloseScreen(index, pScreen)
  1077.        int index;
  1078.        ScreenPtr pScreen;
  1079.   {
  1080. !     TRACE("tigCloseScreen");
  1081.   
  1082. +     if (tigpatmem != NULL)
  1083. +         tigfree(tigpatmem);
  1084.   
  1085. +     tigmemdone();
  1086. +     UNTRACE("tigCloseScreen");
  1087. + 
  1088. +     return TRUE;
  1089. + }
  1090. *** 1.1    1992/08/23 17:46:38
  1091. --- tigspan.c    1992/08/14 14:50:23
  1092. ***************
  1093. *** 223,228 ****
  1094. --- 223,230 ----
  1095.       i |= i << 8 | i << 16 | i << 24;
  1096.       set_pmask(i);
  1097.       set_colors(pGC->fgPixel, pGC->bgPixel);
  1098. +     tigSetstip(pGC->stipple, pDraw->x + pGC->patOrg.x,
  1099. +            pDraw->y + pGC->patOrg.y);
  1100.       for (r = 0; r < REGION_NUM_RECTS(reg); r++) {
  1101.           if ((pts[0].y >= REGION_RECTS(reg)[r].y2) || (pts[count-1].y
  1102.            < REGION_RECTS(reg)[r].y1))
  1103. ***************
  1104. *** 241,246 ****
  1105. --- 243,249 ----
  1106.           if (i < count) 
  1107.               be = i;
  1108.       }
  1109. +  synchronize();
  1110.    UNTRACE("tigFillStipSpans");
  1111.   }
  1112.   
  1113. ***************
  1114. *** 454,460 ****
  1115.         porgy=pPixmap->drawable.y+pGC->patOrg.y;
  1116.       }
  1117.   
  1118. !   if(!(pTile=pGC->tile.pixmap)) return;
  1119.     tBase=pTile->devPrivate.ptr;
  1120.     tWidth=pTile->drawable.width;
  1121.     tHeight=pTile->drawable.height;
  1122. --- 457,463 ----
  1123.         porgy=pPixmap->drawable.y+pGC->patOrg.y;
  1124.       }
  1125.   
  1126. !   if(pGC->tileIsPixel || !(pTile=pGC->tile.pixmap)) return;
  1127.     tBase=pTile->devPrivate.ptr;
  1128.     tWidth=pTile->drawable.width;
  1129.     tHeight=pTile->drawable.height;
  1130. ***************
  1131. *** 544,550 ****
  1132.       }
  1133.   
  1134.     get_colors(&ofc, &obc); /* WHY??? - AKO */
  1135. !   if(!(tile=pGC->tile.pixmap)) return; /* RS */
  1136.   
  1137.     data=(unsigned char *)tile->devPrivate.ptr; /* RS */
  1138.   
  1139. --- 547,553 ----
  1140.       }
  1141.   
  1142.     get_colors(&ofc, &obc); /* WHY??? - AKO */
  1143. !   if(pGC->tileIsPixel || !(tile=pGC->tile.pixmap)) return; /* RS */
  1144.   
  1145.     data=(unsigned char *)tile->devPrivate.ptr; /* RS */
  1146.   
  1147. *** 1.1    1992/08/23 17:46:38
  1148. --- tigtext.c    1992/08/22 21:10:20
  1149. ***************
  1150. *** 1,6 ****
  1151. --- 1,12 ----
  1152.   /*
  1153.    * Stuff to manipulate TIGA fonts and text
  1154.    *
  1155. +  * 10 Aug 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  1156. +  *    Fixed "memory leak" problem caused by allocation of tbox
  1157. +  *    structure that were never freed.
  1158. +  * 1 Jun 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  1159. +  *    Fix bug in which shifts were backwards causing problems with
  1160. +  *    large fonts.
  1161.    * 22 Jun 90 Erich Rickheit KSC  Admitted responsibility
  1162.    */
  1163.   
  1164. ***************
  1165. *** 215,230 ****
  1166.                   instfont = cur->next;
  1167.               Xfree(cur);
  1168.           }
  1169. !     Xfree(finf->patn);
  1170. !     Xfree(finf->locs);
  1171. !     Xfree(finf->owtab);
  1172. !     Xfree(finf);
  1173.       UNTRACE("tigUnrealizeFont");
  1174.       return TRUE;
  1175.   }
  1176.   
  1177.   
  1178. ! static short    tem[37];
  1179.   
  1180.   /*
  1181.    * We only have enough memory on the board to keep a few fonts down
  1182. --- 221,238 ----
  1183.                   instfont = cur->next;
  1184.               Xfree(cur);
  1185.           }
  1186. !     if (finf) {
  1187. !       Xfree(finf->patn);
  1188. !       Xfree(finf->locs);
  1189. !       Xfree(finf->owtab);
  1190. !       Xfree(finf);
  1191. !     }
  1192.       UNTRACE("tigUnrealizeFont");
  1193.       return TRUE;
  1194.   }
  1195.   
  1196.   
  1197. ! static unsigned short    tem[37];
  1198.   
  1199.   /*
  1200.    * We only have enough memory on the board to keep a few fonts down
  1201. ***************
  1202. *** 247,252 ****
  1203. --- 255,261 ----
  1204.           if (pFont == cur->fnp) { 
  1205.               if (cur->loc != NULL) { 
  1206.                   select_font(cur->fid);
  1207. +                 UNTRACE("tigFontLoad.0");
  1208.                   return;
  1209.               } else
  1210.                { 
  1211. ***************
  1212. *** 286,292 ****
  1213.          */
  1214.       tem[0] = finf->tigfont.magic;
  1215.       tem[1] = 0xffff & finf->tigfont.length;
  1216. !     tem[2] = (finf->tigfont.length) << 16;
  1217.       tem[3] = 0x4142; 
  1218.       tem[4] = 0;
  1219.       tem[19] = finf->tigfont.first;
  1220. --- 295,301 ----
  1221.          */
  1222.       tem[0] = finf->tigfont.magic;
  1223.       tem[1] = 0xffff & finf->tigfont.length;
  1224. !     tem[2] = (finf->tigfont.length) >> 16;
  1225.       tem[3] = 0x4142; 
  1226.       tem[4] = 0;
  1227.       tem[19] = finf->tigfont.first;
  1228. ***************
  1229. *** 300,312 ****
  1230.       tem[27] = finf->tigfont.descent;
  1231.       tem[28] = finf->tigfont.leading;
  1232.       tem[29] = 0xffff & finf->tigfont.rowpitch;
  1233. !     tem[30] = (finf->tigfont.rowpitch) << 16;
  1234.       tem[31] = 0xffff & finf->tigfont.oPatnTbl;
  1235. !     tem[32] = (finf->tigfont.oPatnTbl) << 16;
  1236.       tem[33] = 0xffff & finf->tigfont.oLocTbl;
  1237. !     tem[34] = (finf->tigfont.oLocTbl) << 16;
  1238.       tem[35] = 0xffff & finf->tigfont.oOwTbl;
  1239. !     tem[36] = (finf->tigfont.oOwTbl) << 16;
  1240.       host2gsp(tem, cur->loc, sizeof(short)*37, 0);
  1241.       pt = finf->tigfont.rowpitch;
  1242.       host2gsp(finf->patn, cur->loc + finf->tigfont.oPatnTbl,
  1243. --- 309,321 ----
  1244.       tem[27] = finf->tigfont.descent;
  1245.       tem[28] = finf->tigfont.leading;
  1246.       tem[29] = 0xffff & finf->tigfont.rowpitch;
  1247. !     tem[30] = (finf->tigfont.rowpitch) >> 16;
  1248.       tem[31] = 0xffff & finf->tigfont.oPatnTbl;
  1249. !     tem[32] = (finf->tigfont.oPatnTbl) >> 16;
  1250.       tem[33] = 0xffff & finf->tigfont.oLocTbl;
  1251. !     tem[34] = (finf->tigfont.oLocTbl) >> 16;
  1252.       tem[35] = 0xffff & finf->tigfont.oOwTbl;
  1253. !     tem[36] = (finf->tigfont.oOwTbl) >> 16;
  1254.       host2gsp(tem, cur->loc, sizeof(short)*37, 0);
  1255.       pt = finf->tigfont.rowpitch;
  1256.       host2gsp(finf->patn, cur->loc + finf->tigfont.oPatnTbl,
  1257. ***************
  1258. *** 319,325 ****
  1259.           return;
  1260.       }
  1261.       select_font(cur->fid);
  1262. !     UNTRACE("tigFontLoad");
  1263.   }
  1264.   
  1265.   #define DRAW_X 0
  1266. --- 328,334 ----
  1267.           return;
  1268.       }
  1269.       select_font(cur->fid);
  1270. !     UNTRACE("tigFontLoad.1");
  1271.   }
  1272.   
  1273.   #define DRAW_X 0
  1274. ***************
  1275. *** 340,346 ****
  1276.     RegionPtr      reg, draw;
  1277.     unsigned char *text;
  1278.     ExtentInfoRec  inf;
  1279. !   BoxRec        *tbox;
  1280.     int           start, asc, des, tw, c, xw, yw;
  1281.     FONTPRIV      *finf;
  1282.   
  1283. --- 349,355 ----
  1284.     RegionPtr      reg, draw;
  1285.     unsigned char *text;
  1286.     ExtentInfoRec  inf;
  1287. !   BoxRec        tbox;
  1288.     int           start, asc, des, tw, c, xw, yw;
  1289.     FONTPRIV      *finf;
  1290.   
  1291. ***************
  1292. *** 349,354 ****
  1293. --- 358,364 ----
  1294.     if(pGC->font->devPriv[pGC->pScreen->myNum] == NULL)
  1295.       { 
  1296.         miImageText8(pWin, pGC, x, y, count, itext);
  1297. +       UNTRACE("tigImageText8.0");
  1298.         return;
  1299.       }
  1300.     
  1301. ***************
  1302. *** 372,388 ****
  1303.     asc=pGC->font->pFI->maxbounds.metrics.ascent;
  1304.     des=pGC->font->pFI->maxbounds.metrics.descent;
  1305.   
  1306. !   tbox=XNEW(BoxRec);
  1307. !   tbox->x1=xw=x+xorg; 
  1308. !   tbox->x2=tbox->x1+tw;
  1309. !   tbox->y1=yw=y+yorg-asc; 
  1310. !   tbox->y2=y+yorg+des;
  1311.   
  1312. !   j=(*pGC->pScreen->RectIn)(reg, tbox);
  1313.   
  1314.     if(j==rgnOUT) /* trivial reject */
  1315.       { 
  1316.         Xfree(text);
  1317.         return;
  1318.       }
  1319.   
  1320. --- 382,398 ----
  1321.     asc=pGC->font->pFI->maxbounds.metrics.ascent;
  1322.     des=pGC->font->pFI->maxbounds.metrics.descent;
  1323.   
  1324. !   tbox.x1=xw=x+xorg; 
  1325. !   tbox.x2=tbox.x1+tw;
  1326. !   tbox.y1=yw=y+yorg-asc; 
  1327. !   tbox.y2=y+yorg+des;
  1328.   
  1329. !   j=(*pGC->pScreen->RectIn)(reg, &tbox);
  1330.   
  1331.     if(j==rgnOUT) /* trivial reject */
  1332.       { 
  1333.         Xfree(text);
  1334. +       UNTRACE("tigImageText8.1");
  1335.         return;
  1336.       }
  1337.   
  1338. ***************
  1339. *** 393,405 ****
  1340.         set_colors(pGC->fgPixel, pGC->bgPixel);
  1341.         text_out(x+xorg, y+yorg-asc, text);
  1342.         Xfree(text);
  1343.         return;
  1344.       }
  1345.   
  1346.     /* intersect rectangles */
  1347. !   draw=(*pGC->pScreen->RegionCreate)(tbox, 1);
  1348.     (*pGC->pScreen->Intersect)(draw, draw, reg);
  1349.   
  1350.     set_ppop(xftotf[pGC->alu]);
  1351.     set_pmask(LongByteRepeater((~pGC->planemask)&0xFF));
  1352.     set_colors(pGC->fgPixel, pGC->bgPixel);
  1353. --- 403,417 ----
  1354.         set_colors(pGC->fgPixel, pGC->bgPixel);
  1355.         text_out(x+xorg, y+yorg-asc, text);
  1356.         Xfree(text);
  1357. +       UNTRACE("tigImageText8.2");
  1358.         return;
  1359.       }
  1360.   
  1361.     /* intersect rectangles */
  1362. !   draw=(*pGC->pScreen->RegionCreate)(&tbox, 1);
  1363.     (*pGC->pScreen->Intersect)(draw, draw, reg);
  1364.   
  1365. + #if 1
  1366.     set_ppop(xftotf[pGC->alu]);
  1367.     set_pmask(LongByteRepeater((~pGC->planemask)&0xFF));
  1368.     set_colors(pGC->fgPixel, pGC->bgPixel);
  1369. ***************
  1370. *** 415,443 ****
  1371.         text_out(x+xorg,y+yorg-asc,text);
  1372.       }
  1373.     set_clip_rect(scrwidth,scrheight,0,0);
  1374. ! 
  1375.     /*
  1376.      * Text needs to be clipped. We do it by drawing the text 
  1377.      * offscreen and then blitting in the visible chunks (all
  1378.      * because hardware clipping won't do text!)
  1379. !    *  set_pmask(0); 
  1380. !    *  set_ppop(0);
  1381. !    *  set_colors(pGC->fgPixel, pGC->bgPixel);
  1382. !    *  text_out(DRAW_X,DRAW_Y, text);
  1383. !    *
  1384. !    *  for(r=0; r<REGION_NUM_RECTS(draw); r++)
  1385. !    *    bitblt(REGION_RECTS(draw)[r].x2-REGION_RECTS(draw)[r].x1,
  1386. !    *       REGION_RECTS(draw)[r].y2-REGION_RECTS(draw)[r].y1,
  1387. !    *       REGION_RECTS(draw)[r].x1-xw+DRAW_X,
  1388. !    *       REGION_RECTS(draw)[r].y1-yw+DRAW_Y,
  1389. !    *       REGION_RECTS(draw)[r].x1,
  1390. !    *       REGION_RECTS(draw)[r].y1);
  1391. !    */
  1392.     
  1393.     Xfree(text);
  1394.     (*pGC->pScreen->RegionDestroy)(draw);
  1395.   
  1396. !   UNTRACE("tigImageText");
  1397.     return;
  1398.   }
  1399.   
  1400. --- 427,456 ----
  1401.         text_out(x+xorg,y+yorg-asc,text);
  1402.       }
  1403.     set_clip_rect(scrwidth,scrheight,0,0);
  1404. ! #else
  1405.     /*
  1406.      * Text needs to be clipped. We do it by drawing the text 
  1407.      * offscreen and then blitting in the visible chunks (all
  1408.      * because hardware clipping won't do text!)
  1409. !   */
  1410. !       set_pmask(0); 
  1411. !       set_ppop(0);
  1412. !       set_colors(pGC->fgPixel, pGC->bgPixel);
  1413. !       text_out(DRAW_X,DRAW_Y, text);
  1414. !     
  1415. !       for(r=0; r<REGION_NUM_RECTS(draw); r++)
  1416. !         bitblt(REGION_RECTS(draw)[r].x2-REGION_RECTS(draw)[r].x1,
  1417. !            REGION_RECTS(draw)[r].y2-REGION_RECTS(draw)[r].y1,
  1418. !            REGION_RECTS(draw)[r].x1-xw+DRAW_X,
  1419. !            REGION_RECTS(draw)[r].y1-yw+DRAW_Y,
  1420. !            REGION_RECTS(draw)[r].x1,
  1421. !            REGION_RECTS(draw)[r].y1);
  1422. ! #endif
  1423.     
  1424.     Xfree(text);
  1425.     (*pGC->pScreen->RegionDestroy)(draw);
  1426.   
  1427. !   UNTRACE("tigImageText8.3");
  1428.     return;
  1429.   }
  1430.   
  1431. ***************
  1432. *** 460,467 ****
  1433.     RegionPtr      reg, draw;
  1434.     unsigned char    *text;
  1435.     ExtentInfoRec  inf;
  1436. !   BoxRec        * tbox;
  1437. !   int    start, fg, asc, des, tw, xw, yw;
  1438.     
  1439.     TRACE("tigPolyText8");
  1440.   
  1441. --- 473,480 ----
  1442.     RegionPtr      reg, draw;
  1443.     unsigned char    *text;
  1444.     ExtentInfoRec  inf;
  1445. !   BoxRec        tbox;
  1446. !   int   start, fg, asc, des, tw, xw, yw;
  1447.     
  1448.     TRACE("tigPolyText8");
  1449.   
  1450. ***************
  1451. *** 494,506 ****
  1452.     asc=pGC->font->pFI->maxbounds.metrics.ascent;
  1453.     des=pGC->font->pFI->maxbounds.metrics.descent;
  1454.   
  1455. !   tbox=XNEW(BoxRec);
  1456. !   tbox->x1=xw=x+xorg; 
  1457. !   tbox->x2=tbox->x1+tw;
  1458. !   tbox->y1=yw=y+yorg-asc; 
  1459. !   tbox->y2=y+yorg+des;
  1460.     
  1461. !   j=(*pGC->pScreen->RectIn)(reg, tbox);
  1462.   
  1463.     if(j==rgnOUT) /* trivial reject */
  1464.       { 
  1465. --- 507,518 ----
  1466.     asc=pGC->font->pFI->maxbounds.metrics.ascent;
  1467.     des=pGC->font->pFI->maxbounds.metrics.descent;
  1468.   
  1469. !   tbox.x1=xw=x+xorg; 
  1470. !   tbox.x2=tbox.x1+tw;
  1471. !   tbox.y1=yw=y+yorg-asc; 
  1472. !   tbox.y2=y+yorg+des;
  1473.     
  1474. !   j=(*pGC->pScreen->RectIn)(reg, &tbox);
  1475.   
  1476.     if(j==rgnOUT) /* trivial reject */
  1477.       { 
  1478. ***************
  1479. *** 534,539 ****
  1480. --- 546,552 ----
  1481.   
  1482.     /* Ummm... I think TIGA clips text (it does for me!) - AKO */
  1483.   
  1484. + #if 1
  1485.     set_pmask(LongByteRepeater((~pGC->planemask)&0xFF));
  1486.   
  1487.     if(fg)
  1488. ***************
  1489. *** 550,556 ****
  1490.       }
  1491.   
  1492.     /* intersect rectangles */
  1493. !   draw=(*pGC->pScreen->RegionCreate)(tbox, 1);
  1494.     (*pGC->pScreen->Intersect)(draw, draw, reg);
  1495.     
  1496.     for(r=0; r<REGION_NUM_RECTS(draw); r++)
  1497. --- 563,569 ----
  1498.       }
  1499.   
  1500.     /* intersect rectangles */
  1501. !   draw=(*pGC->pScreen->RegionCreate)(&tbox, 1);
  1502.     (*pGC->pScreen->Intersect)(draw, draw, reg);
  1503.     
  1504.     for(r=0; r<REGION_NUM_RECTS(draw); r++)
  1505. ***************
  1506. *** 562,606 ****
  1507.         text_out(x+xorg,y+yorg-asc,text);
  1508.       }
  1509.     set_clip_rect(scrwidth,scrheight,0,0);
  1510. ! 
  1511.     /*
  1512.      * Text needs to be clipped. We do it by drawing the text 
  1513.      * offscreen and then blitting in the visible chunks (all
  1514.      * because hardware clipping won't do text!)
  1515. -    *  set_ppop(0); 
  1516. -    *  set_fcolor(0); 
  1517. -    *  set_pmask(0);
  1518. -    *  set_clip_rect(tw,des-asc,DRAW_X,DRAW_Y);
  1519. -    *  fill_rect(tw,des-asc, DRAW_X, DRAW_Y);
  1520. -    *
  1521. -    *  if(fg) set_colors(fg, 0);
  1522. -    *  else set_colors(fg, 0xff);
  1523. -    *
  1524. -    *  text_out(DRAW_X,DRAW_Y, text);
  1525. -    *
  1526. -    *  set_clip_rect(scrwidth,scrheight,DRAW_X,DRAW_Y);
  1527. -    *
  1528. -    *
  1529. -    *  set_pmask(pmask);
  1530. -    *
  1531. -    *  if(fg)
  1532. -    *    {  
  1533. -    *      transp_on();
  1534. -    *      set_ppop(xftotf[pGC->alu]);
  1535. -    *    }
  1536. -    *  else
  1537. -    *    {
  1538. -    *      set_ppop(tigfaketrans[pGC->alu]);
  1539. -    *    }
  1540. -    *
  1541. -    *  for(r=0; r<REGION_NUM_RECTS(draw); r++)
  1542. -    *    bitblt(REGION_RECTS(draw)[r].x2-REGION_RECTS(draw)[r].x1,
  1543. -    *       REGION_RECTS(draw)[r].y2-REGION_RECTS(draw)[r].y1,
  1544. -    *       REGION_RECTS(draw)[r].x1-xw+DRAW_X,
  1545. -    *       REGION_RECTS(draw)[r].y1-yw+DRAW_Y,
  1546. -    *       REGION_RECTS(draw)[r].x1,
  1547. -    *       REGION_RECTS(draw)[r].y1);
  1548.      */
  1549.     Xfree(text);
  1550.     (*pGC->pScreen->RegionDestroy)(draw);
  1551.     transp_off();
  1552. --- 575,620 ----
  1553.         text_out(x+xorg,y+yorg-asc,text);
  1554.       }
  1555.     set_clip_rect(scrwidth,scrheight,0,0);
  1556. ! #else
  1557.     /*
  1558.      * Text needs to be clipped. We do it by drawing the text 
  1559.      * offscreen and then blitting in the visible chunks (all
  1560.      * because hardware clipping won't do text!)
  1561.      */
  1562. +       set_ppop(0); 
  1563. +       set_fcolor(0); 
  1564. +       set_pmask(0);
  1565. +       set_clip_rect(tw,des-asc,DRAW_X,DRAW_Y);
  1566. +       fill_rect(tw,des-asc, DRAW_X, DRAW_Y);
  1567. +     
  1568. +       if(fg) set_colors(fg, 0);
  1569. +       else set_colors(fg, 0xff);
  1570. +     
  1571. +       text_out(DRAW_X,DRAW_Y, text);
  1572. +     
  1573. +       set_clip_rect(scrwidth,scrheight,DRAW_X,DRAW_Y);
  1574. +     
  1575. +     
  1576. +       set_pmask(pmask);
  1577. +     
  1578. +       if(fg)
  1579. +         {  
  1580. +           transp_on();
  1581. +           set_ppop(xftotf[pGC->alu]);
  1582. +         }
  1583. +       else
  1584. +         {
  1585. +           set_ppop(tigfaketrans[pGC->alu]);
  1586. +         }
  1587. +     
  1588. +       for(r=0; r<REGION_NUM_RECTS(draw); r++)
  1589. +         bitblt(REGION_RECTS(draw)[r].x2-REGION_RECTS(draw)[r].x1,
  1590. +            REGION_RECTS(draw)[r].y2-REGION_RECTS(draw)[r].y1,
  1591. +            REGION_RECTS(draw)[r].x1-xw+DRAW_X,
  1592. +            REGION_RECTS(draw)[r].y1-yw+DRAW_Y,
  1593. +            REGION_RECTS(draw)[r].x1,
  1594. +            REGION_RECTS(draw)[r].y1);
  1595. + #endif
  1596.     Xfree(text);
  1597.     (*pGC->pScreen->RegionDestroy)(draw);
  1598.     transp_off();
  1599. ***************
  1600. *** 625,631 ****
  1601.       GCPRIV        * pPriv;
  1602.       unsigned char    *text;
  1603.       ExtentInfoRec  inf;
  1604. !     BoxRec        * tbox;
  1605.       int    start, fg, asc, des, tw, xw, yw;
  1606.       static int offscreen_x, offscreen_y; /* 0, 768 */
  1607.       static int offscreen_area_known = FALSE;
  1608. --- 639,645 ----
  1609.       GCPRIV        * pPriv;
  1610.       unsigned char    *text;
  1611.       ExtentInfoRec  inf;
  1612. !     BoxRec        tbox;
  1613.       int    start, fg, asc, des, tw, xw, yw;
  1614.       static int offscreen_x, offscreen_y; /* 0, 768 */
  1615.       static int offscreen_area_known = FALSE;
  1616. ***************
  1617. *** 656,670 ****
  1618.       tw = text_width(text);
  1619.       asc = pGC->font->pFI->maxbounds.metrics.ascent;
  1620.       des = pGC->font->pFI->maxbounds.metrics.descent;
  1621. !     tbox = XNEW(BoxRec);
  1622. !     tbox->x1 = xw = x + xorg; 
  1623. !     tbox->x2 = tbox->x1 + tw;
  1624. !     tbox->y1 = yw = y + yorg - asc; 
  1625. !     tbox->y2 = y + yorg + des;
  1626.       j = x + tw;
  1627.   
  1628.       /* intersect rectangles */
  1629. !     draw = (*pGC->pScreen->RegionCreate)(tbox, 1);
  1630.       (*pGC->pScreen->Intersect)(draw, draw, pPriv->clip);
  1631.   
  1632.       if (!offscreen_area_known)
  1633. --- 670,683 ----
  1634.       tw = text_width(text);
  1635.       asc = pGC->font->pFI->maxbounds.metrics.ascent;
  1636.       des = pGC->font->pFI->maxbounds.metrics.descent;
  1637. !     tbox.x1 = xw = x + xorg; 
  1638. !     tbox.x2 = tbox.x1 + tw;
  1639. !     tbox.y1 = yw = y + yorg - asc; 
  1640. !     tbox.y2 = y + yorg + des;
  1641.       j = x + tw;
  1642.   
  1643.       /* intersect rectangles */
  1644. !     draw = (*pGC->pScreen->RegionCreate)(&tbox, 1);
  1645.       (*pGC->pScreen->Intersect)(draw, draw, pPriv->clip);
  1646.   
  1647.       if (!offscreen_area_known)
  1648. ***************
  1649. *** 738,743 ****
  1650. --- 751,757 ----
  1651.       Xfree(text);
  1652.       (*pGC->pScreen->RegionDestroy)(draw);
  1653.       transp_off();
  1654. +     synchronize();
  1655.       UNTRACE("tigStipText8");
  1656.       return j;
  1657.   }
  1658. *** 1.1    1992/08/23 17:46:38
  1659. --- tigwin.c    1992/08/22 21:11:36
  1660. ***************
  1661. *** 1,6 ****
  1662. --- 1,8 ----
  1663.   /*
  1664.    * TIGA  window control stuff
  1665.    *
  1666. +  * 20 Aug 92 Rick Schaeffer (ricks@isc-br.isc-br.com)
  1667. +  *    Fix memory leak.
  1668.    * 22 Jun 90 Erich Rickheit KSC  Admitted responsibility
  1669.    * 1  Jul 91 Aaron Orenstein    Changed tigSetstip(...origin.x, origin.y)
  1670.    *                              to tigSetstip(...drawable.x, drawable.y)
  1671. ***************
  1672. *** 174,179 ****
  1673. --- 176,182 ----
  1674.            pbox[order[i]].x1, pbox[order[i]].y1);
  1675.       
  1676.       (*pWin->drawable.pScreen->RegionDestroy)(newreg);
  1677. +     Xfree(order);
  1678.       set_ppop(op);
  1679.       UNTRACE("tigCopyWindow");
  1680.   }
  1681.