home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 1: Collection A / 17Bit_Collection_A.iso / files / 223.dms / in.adf / Source / star5.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-07-26  |  8.1 KB  |  256 lines
  1. /*=========================================================================
  2.   Star5.c -- This module handles star and constellation selection. It is
  3.   invoked when the user clicks the right or left mouse button on a star.
  4.   It also includes the search algorithms and search table initialization
  5.   for searching by star and constellation name.
  6.  
  7.   Credits for Star Chart:
  8.        Robert L. Hill of the Orange County, CA. Amiga Friends User Group
  9.                       wrote the original version of StarChart in AmigaBasic
  10.                       The star data and many of the main functions of this
  11.                       version are derived from that program.
  12.  
  13.        Ray R. Larson  wrote the c version 1.0 of StarChart, 'intuitionizing'
  14.                       and enhancing the speed and functions of the original.
  15.  
  16.   Copyright (c) 1986 by Ray R. Larson
  17.   
  18.   This program may be freely distributed and copied, but may not be sold
  19.   without the permission of the author. If you modify or enhance it, 
  20.   please include the above credits (and please send me a copy!).
  21.  
  22. Ray R. Larson
  23. 6425 Central Ave. #304
  24. El Cerrito, CA 94530
  25.  
  26. BitNet  LARSON@UCBCMSA
  27. =========================================================================*/
  28. /*------------Header file for all of the standard stuff----*/ 
  29. /*-------------plus definitions of global structures-------*/
  30. #include "star.h" 
  31.  
  32. /*------------------ Global search tables ---------*/
  33. extern SHORT StarIndex[];
  34. extern SHORT *ConstList[];
  35. extern SHORT *GreekList[];
  36.  
  37. /*------------------ extern vars ------------------*/
  38.  
  39. extern struct star_rec StarTable[];
  40. extern char *Greek[]; 
  41. extern struct cons_rec Constel[];
  42. extern struct Coord coords[];
  43. extern struct RastPort *rp;
  44. extern struct Window *w;
  45. extern struct Screen *scr;      /* pointer to the custom screen    - RRL */
  46. extern UBYTE WTMessage[];
  47. extern UBYTE WinTitle[];
  48. extern SHORT DisplayFlags, ConDispFlags; /* type of info display */
  49.  
  50. /**************************************************************************
  51.  * Handle mouse button clicks in the star display area
  52.  **************************************************************************/
  53. Do_buttons(code,mousex,mousey)
  54.    USHORT code;
  55.    SHORT mousex, mousey;
  56. { 
  57.   SHORT stars, constindex, *starlist, hitlist[15], scancoords();
  58.   
  59.   if(ONCHART((LONG)mousex,(LONG)mousey) == 0) return; /* mouse not in star area */
  60.  
  61.   switch(code) {
  62.  
  63.     case SELECTUP:
  64.           stars = scancoords((LONG)mousex,(LONG)mousey,hitlist,15);
  65.               if (stars) DisplayInfo(hitlist,stars,0,DisplayFlags);
  66.               break;
  67.  
  68.     case MENUUP: 
  69.           stars = scancoords((LONG)mousex,(LONG)mousey,hitlist,1);
  70.               if (stars)
  71.                 { constindex = StarTable[hitlist[0]].ConsNum;
  72.                   sprintf(WTMessage,
  73.                            "The Constellation of %s - The %s",
  74.                              Constel[constindex].ConsName,
  75.                  Constel[constindex].ConsMean);
  76.                   SetWindowTitles(w,WTMessage,(UBYTE *)-1);
  77.                   PlotConst(ConstList[constindex],1,ConDispFlags);
  78.                   Delay(200L);
  79.           PlotConst(ConstList[constindex],0,ConDispFlags);
  80.                   SetWindowTitles(w,WinTitle,(UBYTE *)-1);
  81.                 }
  82.          break;
  83.  
  84.   } /* end code switch */
  85. }
  86.  
  87.  
  88. /**************************************************************************
  89.  * SearchIndex - This function performs a binary search on the StarIndex
  90.  *   table to locate a named star record. If successful, it returns a
  91.  *   pointer to a star_rec structure for the matching star, if the star
  92.  *   is not in the table, it returns NULL.
  93.  **************************************************************************/
  94. SHORT SearchIndex(key)
  95. char *key;
  96. {
  97.   SHORT mid, low, high, compval;
  98.   BOOL found = FALSE;
  99.  
  100.   low = 1;
  101.   high = NumStars; /* in star.h */
  102.   while (low <= high)
  103.      { mid = (low + high)/2;
  104.        compval = strcmp(key,StarTable[StarIndex[mid]].StarName);
  105.        if (compval == 0) return(StarIndex[mid]);
  106.        else
  107.           { if (compval < 0) high = mid-1;
  108.         else low = mid + 1;
  109.           }
  110.       }
  111.    /* if we get to here nothing was found */
  112.    return(0);
  113. }
  114.  
  115. /**********************************************************************
  116.  * scancoords() - this function performs a simple sequential search of
  117.  *                the coords array of coordinates for stars, it finds
  118.  *                up to MaxCount objects located within +-2 pixels of
  119.  *                the supplied findx and findy position on the starchart
  120.  *                the indexes of the matching coords elements are added
  121.  *                to the List array, and the total number found is returned
  122.  *                as the result of the function.
  123.  *********************************************************************/
  124. SHORT scancoords(findx,findy,list,maxcount)
  125. LONG findx, findy;
  126. SHORT list[], maxcount;
  127. {
  128.   LONG xmax,xmin,ymax,ymin;
  129.   SHORT i, hitcount = 0;
  130.   
  131.   xmax = findx + 3;
  132.   xmin = findx - 3;
  133.   ymax = findy + 3;
  134.   ymin = findy - 3;
  135.  
  136.   for(i=1;(i <= NumStars) && (maxcount); i++)
  137.      {
  138.     if (INRANGE(coords[i].x,xmin,xmax))
  139.        { 
  140.              if(INRANGE(coords[i].y,ymin,ymax))
  141.            { 
  142.                   list[hitcount] = i;
  143.           hitcount++;
  144.              maxcount--;
  145.            }
  146.           }
  147.      }
  148.  
  149.   return(hitcount);
  150. }
  151.  
  152. /**************************************************************************
  153.  * SearchConst - This function performs a binary search on the Constell
  154.  *   table to locate a named constellation record. If successful, it returns
  155.  *   the index of the found record. If the constellation name is not in the
  156.  *   table, it returns NULL. It only performs partial matching of the names
  157.  **************************************************************************/
  158. SHORT SearchConst(key)
  159. char *key;
  160. {
  161.   SHORT mid, low, high; 
  162.   SHORT compval, complen;
  163.  
  164.   low = 1;
  165.   high = NumCons; /* in star.h */
  166.   complen = strlen(key) - 2;
  167.   if (complen < 3) complen = strlen(key);
  168.  
  169.   while (low <= high)
  170.      { mid = (low + high)/2;
  171.        compval = strncmp(key,Constel[mid].ConsName,complen);
  172.        if (compval == 0) return(mid);
  173.        else
  174.           { if (compval < 0) high = mid-1;
  175.         else low = mid + 1;
  176.           }
  177.       }
  178.    /* if we get to here nothing was found */
  179.    return(0);
  180. }
  181.  
  182. /**************************************************************************
  183.  * SearchGreek - This function performs a sequential search on the Greek
  184.  *   table to locate a named Greek letter record. If successful, it returns
  185.  *   the index of the found record. If the key is not in the table, 
  186.  *   it returns NULL.
  187.  **************************************************************************/
  188. SHORT SearchGreek(key)
  189. char *key;
  190. {
  191.   SHORT compval, i;
  192.  
  193.   for (i = 1; i <= NumGreek; i++)
  194.      {
  195.        compval = strncmp(key,Greek[i],strlen(key));
  196.        if (compval == 0) return(i);
  197.      }
  198.    /* if we get to here nothing was found */
  199.    return(0);
  200. }
  201.  
  202. /* the following routine extracts the first word */
  203. firststr(str,first,rest)
  204. char *str, *first, *rest;
  205. { 
  206.   char *blank;
  207.   extern char *index();
  208.  
  209.   /* extract first word from input key */
  210.  
  211.   while (isspace(*str)) str++;
  212.  
  213.   strcpy(first,str); /* first non-blank chars */
  214.   blank = index(first,' ');
  215.   if (blank == NULL)
  216.      { *rest = '\0';
  217.        return;
  218.      }
  219.   *blank = '\0';
  220.   blank++;
  221.   while(isspace(*blank)) blank++;
  222.   strcpy(rest, blank);
  223.   return;
  224. }
  225.  
  226. /**********************************************************************
  227.  * AndLists - perform Boolean set intersection on two arrays of numbers
  228.  * this function returns the single number that the sets have in common
  229.  * (that is, it is pretty simple version of set intersection, could have
  230.  * it fill in another list with all the common members, but for this 
  231.  * application that should not be needed.) Note that the first ([0])
  232.  * element in each list holds the number of array members in the rest
  233.  * of the list, and that each list is in ascending order of the values
  234.  * of the elements.
  235.  **********************************************************************/
  236. SHORT AndLists(L1,L2)
  237. SHORT L1[],L2[];
  238. {
  239.   SHORT i, j, count1, count2;
  240.  
  241.   count1 = L1[0];
  242.   count2 = L2[0];
  243.   i = j = 1;
  244.  
  245.   while ((i <= count1) && (j <= count2))
  246.      {
  247.        if (L1[i] == L2[j]) return(L1[i]);
  248.        if (L1[i] < L2[j]) i++;
  249.        if (L1[i] > L2[j]) j++;
  250.  
  251.      }
  252.  
  253. /* if we get to here there were no common elements */
  254. return(0);
  255. }
  256.