home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 1: Collection A / 17Bit_Collection_A.iso / files / 223.dms / in.adf / Source / star4.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-07-26  |  14.6 KB  |  508 lines
  1. /*=========================================================================
  2.   Star4.c -- This module builds and submits a requester in response to
  3.   the user's choice of 'Set Parameters' from the parameters menu
  4.   of the Star Chart program. The requester lets the user modify the 
  5.   longitude, latitude, date, time and observed horizon for their observing
  6.   location.
  7.   
  8.  
  9.   Credits for Star Chart:
  10.        Robert L. Hill of the Orange County, CA. Amiga Friends User Group
  11.                       wrote the original version of StarChart in AmigaBasic
  12.                       The star data and many of the main functions of this
  13.                       version are derived from that program.
  14.  
  15.        Ray R. Larson  wrote the c version 1.0 of StarChart, 'intuitionizing'
  16.                       and enhancing the speed and functions of the original.
  17.  
  18.   Copyright (c) 1986 by Ray R. Larson
  19.   
  20.   This program may be freely distributed and copied, but may not be sold
  21.   without the permission of the author. If you modify or enhance it, 
  22.   please include the above credits (and please send me a copy!).
  23.  
  24. Ray R. Larson
  25. 6425 Central Ave. #304
  26. El Cerrito, CA 94530
  27.  
  28. BitNet  LARSON@UCBCMSA
  29. =========================================================================*/
  30. /*------------Header file for all of the standard stuff----*/ 
  31. /*-------------plus definitions of global structures-------*/
  32. #include "star.h" 
  33.  
  34. /*  Definitions for Gadget ID numbers  (see Star3.c)         */ 
  35. #define  LONGDEGGAD   0
  36. #define  LONGMINGAD   1
  37. #define  LATDEGGAD   2
  38. #define  YEARGAD   3
  39. #define  MONGAD   4
  40. #define  DAYGAD   5
  41. #define  HOURGAD   6
  42. #define  MINGAD   7
  43. #define  SECGAD   8
  44. #define  NORTHGAD   9
  45. #define  SOUTHGAD   10
  46. #define  CANGAD   11
  47. #define  OKGAD   12
  48. /* another macro */
  49. #define ABS(x) ((x<0)?(-(x)):(x))
  50.  
  51. /****************************************************************************
  52.  *  Global Structures 
  53.  ***************************************************************************/
  54.  
  55. /* the newwindow structure used in GT */
  56. extern struct NewWindow nw;
  57. extern struct Window *w;
  58. extern SHORT SecondsCount;
  59. extern struct ParamStruct Parms;
  60. extern SHORT Dd[],DSum[]; /* tables of days per month- in starglb.c */
  61.  
  62. /****************************************************************************
  63.  * External function definitions
  64.  ***************************************************************************/
  65. extern struct IntuiMessage *GetMsg();
  66.  
  67. /****************************************************************************
  68.  * Requester structure and global pointer to it's gadget list.
  69.  ***************************************************************************/
  70. struct Requester ParamRequester;
  71. struct ParamStruct workParms;
  72.  
  73. extern struct Gadget *ParamGads, north, south, day;
  74.  
  75. /* Integer string gadgets - defined in star3.c */
  76. extern struct Gadget sec, min, hour, day, mon, year,
  77.        LatDeg, LongMin, LongDeg;
  78.  
  79. /**********************************************************************
  80.  *  Border Definitions for the requester
  81.  **********************************************************************/
  82.  
  83. SHORT Req_Pairs2[] = {
  84.   1,     1,   
  85.   358,     1,   
  86.   358,     188,   
  87.   1,     188,   
  88.   1,     1    
  89. };
  90. SHORT Req_Pairs1[] = {
  91.   0,     0,   
  92.   362,     0,   
  93.   362,     192,   
  94.   0,     192,   
  95.   0,     0    
  96. };
  97.  
  98. struct Border Req_bord_2 = {
  99.   2, 2,       /* LeftEdge, TopEdge */
  100.   1,  7,  JAM1,  /* FrontPen, BackPen, DrawMode*/
  101.   5,             /* Count of XY pairs */  
  102.   (SHORT *)&Req_Pairs2, /* XY pairs */
  103.   NULL           /* Next Border */
  104. };
  105.  
  106. struct Border Req_bord_1 = {
  107.   0,  0,       /* LeftEdge, TopEdge */
  108.   7,  3,  JAM1,  /* FrontPen, BackPen, DrawMode*/
  109.   5,             /* Count of XY pairs */  
  110.   (SHORT *)&Req_Pairs1, /* XY pairs */
  111.   &Req_bord_2           /* Next Border */
  112. };
  113.  
  114. extern struct TextAttr TxtAt_BU;
  115.  
  116. struct IntuiText Req_Text = {
  117.    2, 7,     /* FrontPen, BackPen */
  118.    JAM2,       /* DrawMode */
  119.    50, 1,     /* LeftEdge, TopEdge */
  120.    &TxtAt_BU, /* ITextFont Pointer */ 
  121.    /* The IText */
  122.    (UBYTE *)"    Parameters for Star Chart    ",
  123.    NULL    /* NextText */
  124.  };
  125.  
  126. extern struct TextAttr TxtAt_B;
  127.  
  128. struct IntuiText Error_Text = {
  129.    3, 2,     /* FrontPen, BackPen */
  130.    JAM2,       /* DrawMode */
  131.    0, 0,     /* LeftEdge, TopEdge */
  132.    &TxtAt_B, /* ITextFont Pointer */ 
  133.    /* The IText */
  134.    (UBYTE *)"?",
  135.    NULL    /* NextText */
  136.  };
  137.  
  138. /****************************************************************************
  139.  *               The Code part of the GetParam module.
  140.  ***************************************************************************/
  141. GetParams()
  142. {
  143.   BOOL cancelchosen;
  144.   LONG iflags;
  145.   struct RastPort *reqrp;
  146.  
  147.  
  148.   /* fix the IDCMP flags to report requester set and clear */
  149.   iflags = nw.IDCMPFlags;
  150.   iflags |= REQCLEAR;
  151.   ModifyIDCMP(w,iflags);
  152.   
  153.  
  154.       /* initialize the text Param requester */ 
  155.       InitParamReq();
  156.  
  157.       /* Put up the requester  */ 
  158.       Request(&ParamRequester,w);
  159.       
  160.       /* set the north/south imagery */
  161.        reqrp = ParamRequester.ReqLayer->rp;
  162.  
  163.        if(workParms.Horizon == 0)
  164.          { SetDrMd(reqrp, COMPLEMENT);
  165.            RectFill(reqrp,94L,153L,158L,169L);
  166.            SetDrMd(reqrp, JAM1);
  167.           }
  168.        else
  169.           { SetDrMd(reqrp, COMPLEMENT);
  170.            RectFill(reqrp,206L,153L,274L,169L);
  171.            SetDrMd(reqrp, JAM1);
  172.           }
  173.  
  174.       /* let the user fill in the parameters and wait for a cancel or ok. */  
  175.       cancelchosen = WaitParamReq(reqrp);
  176.       
  177.       /* if the user cancelled, just return -- otherwise set Parms and    */
  178.       /* re-calculate and redisplay the star chart.                       */
  179.       if (cancelchosen) return(0);
  180.       
  181.       /* figure out current siderial time, etc. and update the Parms struct */
  182.       CalcParams(&workParms);
  183.       Parms = workParms;
  184.       
  185.       /* recalculate star positions and display them. */
  186.       DisplayStars();
  187.       DisplayAllText();
  188.       
  189. } /* GetParams */
  190.  
  191. /*
  192.  *  Init the Itext Param requester
  193.  */
  194. InitParamReq()
  195. { 
  196.   struct RastPort *reqrp;
  197.   
  198.   InitRequester(&ParamRequester);
  199.   ParamRequester.LeftEdge  = 110;
  200.   ParamRequester.TopEdge   = 2;
  201.   ParamRequester.Width     = 363;
  202.   ParamRequester.Height    = 193;
  203.   ParamRequester.ReqGadget = ParamGads;
  204.   ParamRequester.ReqText   = &Req_Text;
  205.   ParamRequester.BackFill  = 2;
  206.   ParamRequester.Flags     = 0;
  207.   ParamRequester.ReqBorder = &Req_bord_1;
  208.   
  209.   /* copy the parms structure */
  210.   workParms = Parms;
  211.  
  212.    InitStringGad(&sec,SecondsCount);
  213.    InitStringGad(&min,workParms.Minute);
  214.    InitStringGad(&hour,workParms.Hour);
  215.    InitStringGad(&day,workParms.Day);
  216.    InitStringGad(&mon,workParms.Month);
  217.    InitStringGad(&year,workParms.Year);
  218.    InitStringGad(&LatDeg,workParms.Latitude);
  219.    InitStringGad(&LongMin,workParms.LongitudeMin);
  220.    InitStringGad(&LongDeg,workParms.LongitudeDeg);
  221.  
  222.  
  223. } /* InitParamReq */
  224.  
  225.  
  226. InitStringGad(gad,val)
  227. struct Gadget *gad;
  228. SHORT val;
  229. {
  230.   struct StringInfo *si;
  231.   
  232.   si = (struct StringInfo *)gad->SpecialInfo;
  233.   sprintf(si->Buffer,"%d",val);
  234.   si->NumChars = (LONG)strlen(si->Buffer);
  235.   *(si->UndoBuffer) = '\0';
  236. }
  237.  
  238.   
  239. /****************************************************************************
  240.  *  WaitParamReq - permit user to change the values in the parameter gadgets
  241.  *                 and check the values they install until either the 
  242.  *                 CANCEL gadget is clicked or the OK gadget is clicked AND
  243.  *                 there are no outstanding input errors
  244.  ***************************************************************************/
  245. BOOL WaitParamReq(reqrp)
  246. struct RastPort *reqrp;
  247. {
  248.   ULONG  class = GADGETDOWN;
  249.   USHORT Param = 0;
  250.   USHORT selected = 0;
  251.   struct IntuiMessage *message;
  252.   struct Gadget *gadget, *lastgad;
  253.   BOOL cancelflag = FALSE;
  254.   LONG  errorflag = 0L, checkvals();
  255.  
  256.   lastgad =  NULL;
  257.  
  258.   while (class != REQCLEAR)
  259.     {
  260.     if ((message=(struct IntuiMessage *) GetMsg(w->UserPort)) == 0L)
  261.       {
  262.       Wait(1L<<w->UserPort->mp_SigBit);
  263.       continue;
  264.       }
  265.  
  266.     class  = message->Class;
  267.     gadget = (struct Gadget *) message->IAddress;
  268.     ReplyMsg(message);
  269.     switch (class)
  270.       {
  271.       case GADGETDOWN: /* check to see if the user clicked on a new */
  272.                /* gadget withou hitting return on the old one */
  273.                /* if so, treat this like a gadgetup for the   */
  274.                /* previous gadget.                     */
  275.  
  276.               if (lastgad == NULL) 
  277.              errorflag = checkvals(reqrp,gadget,errorflag,class);
  278.                       else
  279.              errorflag = checkvals(reqrp,lastgad,errorflag,class);
  280.                      lastgad = gadget;
  281.                       break;
  282.  
  283.       case GADGETUP: 
  284.          switch (gadget->GadgetID)
  285.         {
  286.         case  NORTHGAD: 
  287.                       if(workParms.Horizon != 0)
  288.                         { SetDrMd(reqrp, COMPLEMENT);
  289.                           RectFill(reqrp,94L,153L,158L,169L);
  290.                           RectFill(reqrp,206L,153L,274L,169L);
  291.                           SetDrMd(reqrp, JAM1);
  292.                          }
  293.              workParms.Horizon = 0;
  294.              break;   
  295.              
  296.         case  SOUTHGAD: 
  297.                       if(workParms.Horizon != 1)
  298.                         { SetDrMd(reqrp, COMPLEMENT);
  299.                           RectFill(reqrp,94L,153L,158L,169L);
  300.                      RectFill(reqrp,206L,153L,274L,169L);
  301.                           SetDrMd(reqrp, JAM1);
  302.                          }
  303.              workParms.Horizon = 1;
  304.              break;   
  305.         
  306.  
  307.         case  CANGAD : 
  308.                      cancelflag = TRUE;
  309.                              break; 
  310.  
  311.                    case  OKGAD  :
  312.                   if (errorflag == 0) 
  313.                      EndRequest(&ParamRequester,w);
  314.                  else DisplayBeep(w->WScreen);    
  315.                  break;
  316.  
  317.                 default: errorflag = checkvals(reqrp,gadget,errorflag,class);
  318.  
  319.              } /* end of GADGETUP switch */
  320.  
  321.         } /* end of CLASS switch */
  322.     }/* end of while loop */
  323.     
  324.  
  325. return(cancelflag);
  326.        
  327. } /* WaitParamReq */
  328.    
  329. /****************************************************************************
  330.  *  checkvals - verify that the values returned by the integer gadgets are
  331.  *              in the appropriate range for the parameter.
  332.   ***************************************************************************/
  333. LONG checkvals(reqrp,checkgad,errorflag,class)
  334. struct RastPort *reqrp;
  335. struct Gadget *checkgad;
  336. LONG errorflag;
  337. ULONG class;
  338. {
  339.   struct StringInfo *si;
  340.   BOOL  inputerror = FALSE;
  341.   LONG  checknum, pendingerror;
  342.  
  343.    if (checkgad == NULL) return(errorflag);
  344.    pendingerror = errorflag;
  345.  
  346.    si = (struct StringInfo *)checkgad->SpecialInfo;
  347.    if (si == NULL) return(errorflag);
  348.  
  349.   /* this is kind of a kludge, but necessary since Intuition will have set */
  350.   /* LongInt to zero, IF the user clicks on a gadget THEN  clicks on       */
  351.   /* another, without hitting return on the old one and not modifying the  */
  352.   /* contents of the string buffer, the LongInt value for the gadget is    */
  353.   /* reported as zero.                               */ 
  354.   if (class == GADGETUP) checknum = si->LongInt;
  355.   else checknum = atol(si->Buffer);
  356.      
  357.   /* check the values input */
  358.   switch (checkgad->GadgetID)
  359.        {
  360.     case  LONGDEGGAD: 
  361.           if (INRANGE(checknum,-180L,180L))
  362.             { workParms.LongitudeDeg = checknum;
  363.               errorflag &= ~(1L << LONGDEGGAD);
  364.           break;
  365.         }
  366.           else inputerror = TRUE;
  367.           break;
  368.             
  369.     case  LONGMINGAD:
  370.           if (INRANGE(checknum,0L,59L))
  371.             { workParms.LongitudeMin = checknum;
  372.               errorflag &= ~(1L << LONGMINGAD);
  373.           break;
  374.         }
  375.           else inputerror = TRUE;
  376.           break;   
  377.             
  378.     case  LATDEGGAD: 
  379.           if (INRANGE(checknum,0L,90L))
  380.             { workParms.Latitude = checknum;
  381.               errorflag &= ~(1L << LATDEGGAD);
  382.           break;
  383.         }
  384.           else inputerror = TRUE;
  385.         break;   
  386.             
  387.     case  YEARGAD:
  388.           if (INRANGE(checknum,1900L,2100L))
  389.             { workParms.Year = checknum;
  390.               errorflag &= ~(1L << YEARGAD);
  391.           break;
  392.         }
  393.           else inputerror = TRUE;
  394.         break;   
  395.              
  396.     case  MONGAD:
  397.           if (INRANGE(checknum,1L,12L))
  398.             { workParms.Month = checknum;
  399.               errorflag &= ~(1L << MONGAD);
  400.           if ((INRANGE(workParms.Day,1,Dd[workParms.Month])) == 0)
  401.              { 
  402.                    checkgad = &day;
  403.                si = (struct StringInfo *)checkgad->SpecialInfo;
  404.                        inputerror = TRUE;
  405.                break;
  406.               }
  407.          break;
  408.         }
  409.           else inputerror = TRUE;
  410.         break;   
  411.              
  412.     case  DAYGAD:
  413.           if (INRANGE(checknum,1L,(LONG)Dd[workParms.Month]))
  414.             { workParms.Day = checknum;
  415.               errorflag &= ~(1L << DAYGAD);
  416.           break;
  417.         }
  418.           else inputerror = TRUE;
  419.           break;   
  420.              
  421.     case  HOURGAD:
  422.           if (INRANGE(checknum,0L,23L))
  423.             { workParms.Hour = checknum;
  424.               errorflag &= ~(1L << HOURGAD);
  425.           break;
  426.         }
  427.           else inputerror = TRUE;
  428.           break;   
  429.              
  430.     case  MINGAD:
  431.           if (INRANGE(checknum,0L,59L))
  432.             { workParms.Minute = checknum;
  433.               errorflag &= ~(1L << MINGAD);
  434.           break;
  435.         }
  436.           else inputerror = TRUE;
  437.          break;   
  438.              
  439.     case  SECGAD:
  440.           if (INRANGE(checknum,0L,59L))
  441.             { SecondsCount = checknum;
  442.               errorflag &= ~(1L << SECGAD);
  443.           break;
  444.         }
  445.           else inputerror = TRUE;
  446.          break;   
  447.      } /* end of Gadget id switch */
  448.  
  449.     if (inputerror == TRUE) /* put a "?" next to the gadget */
  450.       { 
  451.         errorflag |= (1L << checkgad->GadgetID);
  452.         DisplayBeep(w->WScreen);
  453.         PrintIText(reqrp,&Error_Text,
  454.           (LONG)(checkgad->LeftEdge - 10),(LONG)checkgad->TopEdge);
  455.       }
  456.  
  457.     if ((pendingerror != errorflag) && (inputerror == FALSE))
  458.       { /* user must have fixed an error, so turn off the ? */
  459.         pendingerror = errorflag;
  460.         Error_Text.FrontPen = 2;
  461.         PrintIText(reqrp,&Error_Text,
  462.           (LONG)(checkgad->LeftEdge - 10),(LONG)checkgad->TopEdge);
  463.         Error_Text.FrontPen = 3;
  464.       }
  465. return(errorflag);
  466.        
  467. } /* end of checkvals */
  468.  
  469.  
  470. /*************************************************************************
  471.  *  CalcParams - Calculate local siderial time (Lst) and Greenwich
  472.  *               siderial time based on the current work parameters.
  473.  ************************************************************************/
  474. CalcParams(p)
  475. struct ParamStruct *p;
  476. {
  477.   FLOAT workhours, LocalOffset, MeanLocTime;
  478.   FLOAT CalcGst(); /* calcGst is in starglb.c */
  479.   SHORT degrees, temp;
  480.  
  481.   
  482.   degrees = ABS(p->LongitudeDeg) % 15;
  483.   workhours = (FLOAT)degrees 
  484.         + ((FLOAT)p->LongitudeMin / 60.0);
  485.   LocalOffset = (workhours * 4.0)/60.0;
  486.   
  487.  /* get Greenwich time */
  488.   p->Gst = CalcGst(p->Day,p->Month);
  489.   workhours = (FLOAT)p->Hour + ((FLOAT)p->Minute / 60.0);
  490.   if(p->LongitudeDeg < 0)
  491.      MeanLocTime = workhours + LocalOffset;
  492.   else 
  493.      MeanLocTime = workhours - LocalOffset;
  494.      
  495.   /* local siderial time */
  496.   p->Lst = MeanLocTime + p->Gst;
  497.   if (p->Lst > 24.0) 
  498.      p->Lst -= 24.0;
  499.   if (p->Lst < 0) 
  500.      p->Lst += 24;
  501.   
  502.   /* set siderial times in the workparms */
  503.   temp = (SHORT)(p->Lst * 60.0);
  504.   p->Hr = temp / 60;
  505.   p->Mn = temp % 60;
  506. }
  507.  
  508.