home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / gmlibs23 / winhash.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-30  |  7.3 KB  |  316 lines
  1. /*
  2.  * This file contains routines which can be used to determine the character
  3.  * present at a given location in a window.  These functions are used to
  4.  * determine the character under the mouse cursor, and for the log-top printer
  5.  * function.
  6.  */
  7.  
  8. #include <stdio.h>
  9. #include <osbind.h>
  10. #include "windefs.h"
  11.  
  12. extern struct wi_str w[];
  13.  
  14. int    highlighted_wdes = -1;    /* make this global now for use in winmain.c*/
  15.  
  16. /*
  17.  * char_at returns the ascii code of the character in wdes window at
  18.  * (x_loc, y_loc) cursor position.  Zero is returned if the character can
  19.  * not be identified.
  20.  */
  21. int char_at(wdes, x_loc, y_loc)
  22. int wdes, x_loc, y_loc;
  23.  
  24. {
  25.  
  26.   register struct wi_str *wp = &w[wdes];
  27.   int ch, width, boffset, count, cur_y, cur_x;
  28.   register unsigned long mask;
  29.   register unsigned long *dptr;
  30.   register int shift;
  31.   register FNT *fnt = wp->font;
  32.   static char pa[32];         /* pixel array containing character image */
  33.   
  34.   cur_x = x_loc * fnt->inc_x + X0;
  35.   cur_y = y_loc * fnt->inc_y + wp->top_y;
  36.   
  37.   width = 2 * wp->wi_mf.wwords;
  38.   boffset = wp->m_off+cur_x+fnt->inc_x-1;
  39.   dptr = ((char *)(wp->wi_mf.ptr)) + cur_y * width
  40.     + ((boffset >> 4) << 1) - 2;
  41.   shift = 15 - (boffset & 15);
  42.   mask = (-1L<<(shift+fnt->inc_x)|(1<<shift)-1);
  43.   for (count = 0; count < fnt->inc_y; count ++)
  44.   {
  45.     pa[count] = (*dptr & (~ mask)) >> shift;
  46.     ((char *) dptr) += width;
  47.   }
  48.   
  49.   ch = which_char(fnt, &fnt->f_hash, pa);
  50.   if (ch == 0)        /* Not found, check for inverse vidio case */
  51.   {
  52.     for (count = 0; count < fnt->inc_y; count ++)
  53.       pa[count] = ~pa[count] & (1<< fnt->inc_x) - 1;
  54.     ch = which_char(fnt, &fnt->f_hash, pa);
  55.   }
  56.   return (ch);
  57. }
  58.  
  59. /*
  60.  * which_char returns the ascii code of the character bitmap in pa from font
  61.  * font using hash table htbl.
  62.  */
  63. int which_char(font, htbl, pa)
  64. FNT *font;
  65. HTBL *htbl;
  66. char *pa;
  67.  
  68. {
  69.   register int i, h, n;
  70.   
  71.   h = hash_char (pa, font->inc_y);
  72.   if ((htbl->h_t[h] & 128) == 0) /* collision bit set? */
  73.   {
  74.     for (i=0; i<font->inc_y; i++)
  75.       if (font->f_data[(htbl->h_t)[h] * 16 + i] != pa[i])
  76.         break;
  77.     if (i < font->inc_y){
  78.       return 0;
  79.     }
  80.     else
  81.       return (htbl->h_t[h]);
  82.   }
  83.   else                /* collision, search colision list for char */
  84.   {
  85.     n = htbl->h_t[h] & 127;
  86.     while (n != 0)
  87.     {
  88.       for (i=0; i<font->inc_y; i++)
  89.         if (font->f_data[(htbl->h_colision)[n].h_try * 16 + i] != pa[i])
  90.       break;
  91.       if (i < font->inc_y)
  92.         n = htbl->h_colision[n].h_next;
  93.       else
  94.         return (htbl->h_colision[n].h_try);
  95.     }
  96.     return 0;
  97.   }
  98. }
  99.  
  100. /*
  101.  * gen_hash initalizes htbl with the hash table for font font.
  102.  */
  103. void gen_hash(font, htbl)
  104. FNT *font;
  105. HTBL *htbl;
  106.  
  107. {
  108.   register int overflowcnt = 1;
  109.   register int np, tp, i, j;
  110.   int h;
  111.   
  112.   for (i=0; i<128; i++)        /* initalize */
  113.     htbl->h_colision[i].h_next = '\0';
  114.   for (i=0; i<(1<<HASHBITS); i++)
  115.     htbl->h_t[i] = '\0';
  116.   
  117.   for (i=32; i<128; i++)
  118.   {            /* for each character */
  119.     h = hash_char(&font->f_data[i*16], font->inc_y);
  120.     if (htbl->h_t[h] == 0)
  121.       htbl->h_t[h] = i;
  122.     else
  123.     {
  124.       if ((htbl->h_t[h] & 128) == 0) /* already overflowed? */
  125.       { /* No, move first element to overflow list */
  126.     htbl->h_colision[overflowcnt].h_try = htbl->h_t[h];
  127.         htbl->h_t[h] = 128 | overflowcnt;
  128.     overflowcnt++;
  129.       }
  130.     
  131.       tp = htbl->h_t[h] & 127;
  132.       j=0;    /* dbug */
  133.       while ((np = htbl->h_colision[tp].h_next) != 0){
  134.     tp = np;
  135.     j++; /* dbug */
  136.       }
  137. #ifdef DEBUG
  138.       printf("overflow=%d depth=%d hash %d = %d\n",overflowcnt, j, i, h);
  139. #endif
  140.       htbl->h_colision[tp].h_next = overflowcnt;
  141.       htbl->h_colision[overflowcnt].h_try = i;
  142.       ++ overflowcnt;
  143.     }
  144.   }
  145.  
  146. #ifdef DEBUG     /* verify sanity of hash table */
  147.   for (i=32; i<128; i++) /* dbug */
  148.     if ((j = which_char(font, htbl, &font->f_data[i*16])) != i)
  149.   {
  150.     printf("%d != %d\n", i, j);
  151.   }
  152. #endif
  153. }
  154.  
  155. /*
  156.  * hash_char returns the hash code for the character pixel image in pa of
  157.  * height height.
  158.  */
  159. int hash_char(pa, height)
  160. char *pa;
  161. int height;
  162.  
  163. {
  164.   register int h, i, j;
  165.   
  166.   h=0;
  167.   for (i=0; i<height; i++)
  168.   {
  169.     h += pa[i] << i*3 % HASHBITS;
  170.   }
  171.   j = (1<<HASHBITS) - 1;
  172.   h = (h + (h >> HASHBITS + 1)) & j;
  173.  
  174.   return h;
  175. }
  176.  
  177. /*
  178.  * dump_line send the y_coord'th line in the window wdes to the printer.
  179.  * zero is returned if the line was printed ok.
  180.  */
  181. dump_line(wdes, y_coord)
  182. {
  183.   int i;
  184.   char ch;
  185.   
  186.   for (i = 0; i < w[wdes].x_chrs; i++){
  187.     ch = char_at(wdes, i, y_coord);
  188. #if 0
  189.     if (Cprnout(ch) == 0) {
  190.       w[wdes].ptr_status = LOG_NONE;
  191.       return -1;
  192.     }
  193. #endif
  194.   }
  195. #if 0
  196.   if (Cprnout('\n') == 0 | Cprnout('\r') == 0) {
  197.     w[wdes].ptr_status = LOG_NONE;
  198.     return -1;
  199.   }
  200. #endif
  201.   return 0;
  202. }
  203.  
  204. /*
  205.  * dump_window send the contents of wdes to the printer.
  206.  */
  207. dump_window(wdes)
  208. {
  209.   int i;
  210.   
  211.   for (i = 0; i < w[wdes].y_chrs; i++){
  212.     dump_line(wdes, i);
  213.   }
  214. }
  215. /* copy_word fills buffer with the word at (x1, y1) from wdes
  216.  * No checks are made for buffer overflow.
  217.  */
  218. copy_word(wdes, x1, y1, buffer)
  219. int wdes, x1, y1;
  220. char * buffer;
  221. {
  222.   register int fx, lx, yo, xo;
  223.   
  224.   yo = w[wdes].y_off / w[wdes].font->inc_y; /* adjust for scroll bar action */  
  225.   xo = w[wdes].x_off / w[wdes].font->inc_x;
  226.   fx = x1 - 1;
  227.   lx = x1 + 1;
  228.   
  229.   while (fx + xo >= 0 && char_at(wdes, fx + xo, y1 + yo) != ' ')
  230.     --fx;
  231.   while (lx + xo < w[wdes].x_chrs && char_at(wdes, lx + xo, y1 + yo) != ' ')
  232.     ++lx;
  233.   copy_text(wdes, ++fx, y1, --lx, y1, buffer);
  234. }
  235.  
  236. /* copy_text fills buffer with the text between (x1, y1) and (x2, y2) from wdes
  237.  * where point 1 is before point 2.  No checks are made for buffer overflow.
  238.  */
  239. copy_text(wdes, x1, y1, x2, y2, buffer)
  240. int wdes, x1, y1, x2, y2;
  241. char * buffer;
  242. {
  243.   static int old_hh;
  244.   static int old_y1;
  245.   register int cx, cy, i, lastnbi, lastnbx;
  246.   int inc_y, inc_x, top_y;
  247.  
  248.   /* undo any old selected text which might be inverted on screen */
  249.   if (highlighted_wdes > 0 && w[highlighted_wdes].font != NULL)
  250.   {
  251.     w_update(highlighted_wdes, FM_COPY, 0, old_y1,
  252.       w[highlighted_wdes].x_chrs * w[highlighted_wdes].font->inc_x + X0 + 1,
  253.       old_hh);
  254.   }
  255.   if (y1 > y2) return;    /* nothing to do */
  256.  
  257.   inc_y = w[wdes].font->inc_y;
  258.   inc_x = w[wdes].font->inc_x;
  259.   top_y = w[wdes].top_y;
  260.     
  261.   y1 = y1 + w[wdes].y_off / inc_y;    /* adjust for scroll bar action */  
  262.   y2 = y2 + w[wdes].y_off / inc_y;    /* assumes _off is multiple of inc_ */
  263.   x1 = x1 + w[wdes].x_off / inc_x;
  264.   x2 = x2 + w[wdes].x_off / inc_x;
  265.   i = 0;
  266.   lastnbi = 0;
  267.   lastnbx = x1;
  268.  
  269.   if (y1 > y2)
  270.   {
  271.     highlighted_wdes = -1;    /* no undo required on next call */
  272.     return;
  273.   }
  274.   
  275.   old_y1 = y1 * inc_y + top_y;
  276.   old_hh = (y2 - y1 + 2) * inc_y + Y0;
  277.   highlighted_wdes = wdes;
  278.   
  279.   cx = x1;
  280.   cy = y1;
  281.  
  282.   while (cy < y2 || (cy == y2 && cx <= x2))
  283.   {
  284.     buffer[i] = char_at(wdes, cx, cy);
  285.     if (buffer[i] != ' ')
  286.     {
  287.       lastnbi = i;
  288.       lastnbx = cx;
  289.     }
  290.     cx ++;
  291.     if (cx >= w[wdes].x_chrs)
  292.     {
  293.       if (cy == y1)    /* first line */
  294.         w_update(wdes, FM_INVERT, x1 * inc_x, cy * inc_y + top_y,
  295.       (++lastnbx - x1) * inc_x + X0, inc_y);
  296.       else
  297.         w_update(wdes, FM_INVERT, 0, cy * inc_y + top_y,
  298.       ++lastnbx * inc_x + X0, inc_y);
  299.       cx = 0;
  300.       cy ++;
  301.       i = ++lastnbi;
  302.       lastnbx = -1;
  303.       buffer[i] = '\r';
  304.     }
  305.     i++;
  306.   }
  307.   if (cy == y1)    /* one line */
  308.     w_update(wdes, FM_INVERT, x1 * inc_x, cy * inc_y + top_y,
  309.       (++lastnbx - x1) * inc_x + X0, inc_y);
  310.   else
  311.     w_update(wdes, FM_INVERT, 0, cy * inc_y + top_y,
  312.       ++lastnbx * inc_x + X0, inc_y);
  313.   buffer[++lastnbi] = '\0';
  314. }
  315.  
  316.