home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 1: Collection A / 17Bit_Collection_A.iso / files / 223.dms / in.adf / Source / starglb.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-07-26  |  23.5 KB  |  825 lines
  1. /*=========================================================================
  2.   Starglb.c -- This module handles initialization and global functions
  3.   for the StarChart program.
  4.  
  5.   Credits for Star Chart:
  6.        Robert L. Hill of the Orange County, CA. Amiga Friends User Group
  7.                       wrote the original version of StarChart in AmigaBasic
  8.                       The star data and many of the main functions of this
  9.                       version are derived from that program.
  10.  
  11.        Ray R. Larson  wrote the c version 1.0 of StarChart, 'intuitionizing'
  12.                       and enhancing the speed and functions of the original.
  13.  
  14.   Copyright (c) 1986 by Ray R. Larson
  15.   
  16.   This program may be freely distributed and copied, but may not be sold
  17.   without the permission of the author. If you modify or enhance it, 
  18.   please include the above credits (and please send me a copy!).
  19.  
  20. Ray R. Larson
  21. 6425 Central Ave. #304
  22. El Cerrito, CA 94530
  23.  
  24. BitNet  LARSON@UCBCMSA
  25. =========================================================================*/
  26. /*------------Header file for all of the standard stuff----*/ 
  27. /*-------------plus definitions of global structures-------*/
  28. #include "star.h" 
  29. #include <graphics/gfxmacros.h>
  30. #include <time.h>
  31.  
  32. /*------------------ extern vars ------------------*/
  33.  
  34. extern LONG MathTransBase;
  35. extern LONG MathBase; 
  36. extern struct star_rec StarTable[];
  37. extern char *Greek[]; 
  38. extern struct cons_rec Constel[];
  39. extern struct RastPort *rp;
  40. extern struct Window *w;
  41. extern struct Screen *scr;      /* pointer to the custom screen    - RRL */
  42. extern struct ViewPort *vport;
  43. extern struct FileHandle *Open();
  44. extern FLOAT cos(), sin(), tan();
  45. extern struct TextAttr TxtAt_Plain,TxtAt_BIU,TxtAt_BU,TxtAt_BI,TxtAt_B,
  46.        TxtAt_IU,TxtAt_I,TxtAt_U;
  47. BOOL CalcParm = FALSE;
  48. extern UWORD defaultCT[32], CTable[32], *ctabptr;
  49. extern UBYTE DefaultStartFile[];
  50.  
  51. /*------------------ global vars ------------------*/
  52.  
  53. struct ParamStruct DefaultParms, Parms;  /* parameter structures */
  54. extern struct ParamStruct workParms;
  55.  
  56. /* Days per month - used in date calculations */
  57. SHORT Dd[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
  58. SHORT DSum[13] = {0,0,31,59,90,120,151,181,212,243,273,304,334};
  59.  
  60. /* values based on pi, used in angular calculations - PI defined in mathffp.h*/
  61. FLOAT P1, P12 , P15;
  62.  
  63. /* values used in determining the type of display for an object */
  64. FLOAT MaxPlus = 2.0, MaxWhite = 11.1;
  65.  
  66. SHORT TimeDelay = 1;  /* time delay is 1 for real time. Max is 1800 */
  67.                       /* for one hour per second of program time    */
  68. SHORT SecondsCount = 0;
  69.  
  70. struct Coord coords[MAXSTARS]; /* x and y screen coordinates for stars */
  71.  
  72.  
  73. /**********************************************************************
  74.  *  IntuiTexts for the horizon labels.
  75.  **********************************************************************/
  76.  
  77. struct IntuiText LeftLabel = {
  78.    15, 0,     /* FrontPen, BackPen */
  79.    JAM2,       /* DrawMode */
  80.    30, 85,     /* LeftEdge, TopEdge */
  81.    &TxtAt_Plain, /* ITextFont Pointer */ 
  82.    /* The IText */
  83.    (UBYTE *)"  ",
  84.    NULL
  85.  };
  86.  
  87. struct IntuiText RightLabel = {
  88.    15, 0,     /* FrontPen, BackPen */
  89.    JAM2,       /* DrawMode */
  90.    601, 85,     /* LeftEdge, TopEdge */
  91.    &TxtAt_Plain, /* ITextFont Pointer */ 
  92.    /* The IText */
  93.    (UBYTE *)"  ",
  94.    &LeftLabel
  95.  };
  96.  
  97. struct IntuiText BotLabel = {
  98.    15, 0,     /* FrontPen, BackPen */
  99.    JAM2,       /* DrawMode */
  100.    315, 171,     /* LeftEdge, TopEdge */
  101.    &TxtAt_Plain, /* ITextFont Pointer */ 
  102.    /* The IText */
  103.    (UBYTE *)"  ",
  104.    &RightLabel
  105.  };
  106.  
  107.  
  108.  
  109. /**********************************************************************
  110.  *  IntuiTexts for the parameter display area
  111.  **********************************************************************/
  112. UBYTE STBuf[10];
  113. struct IntuiText SidTimeText = {
  114.    1, 0,     /* FrontPen, BackPen */
  115.    JAM2,       /* DrawMode */
  116.    450, 177,     /* LeftEdge, TopEdge */
  117.    &TxtAt_Plain, /* ITextFont Pointer */ 
  118.    /* The IText */
  119.    (UBYTE *)&STBuf[0],
  120.    NULL
  121.  };
  122.  
  123. UBYTE DateBuf[12];
  124. struct IntuiText DateText = {
  125.    1, 0,     /* FrontPen, BackPen */
  126.    JAM2,       /* DrawMode */
  127.    243, 177,     /* LeftEdge, TopEdge */
  128.    &TxtAt_Plain, /* ITextFont Pointer */ 
  129.    /* The IText */
  130.    (UBYTE *)&DateBuf[0],
  131.    &SidTimeText    /* NextText */
  132.  };
  133.  
  134. UBYTE LatBuf[4];
  135. struct IntuiText LatText = {
  136.    1, 0,     /* FrontPen, BackPen */
  137.    JAM2,       /* DrawMode */
  138.    483, 167,     /* LeftEdge, TopEdge */
  139.    &TxtAt_Plain, /* ITextFont Pointer */ 
  140.    /* The IText */
  141.    (UBYTE *)&LatBuf[0],
  142.    &DateText    /* NextText */
  143.  };
  144.  
  145. UBYTE LnMinBuf[4];
  146. struct IntuiText LongMinText = {
  147.    1, 0,     /* FrontPen, BackPen */
  148.    JAM2,       /* DrawMode */
  149.    305, 167,     /* LeftEdge, TopEdge */
  150.    &TxtAt_Plain, /* ITextFont Pointer */ 
  151.    /* The IText */
  152.    (UBYTE *)&LnMinBuf[0],
  153.    &LatText    /* NextText */
  154.  };
  155.  
  156. UBYTE LnDegBuf[6];
  157. struct IntuiText LongDegText = {
  158.    1, 0,     /* FrontPen, BackPen */
  159.    JAM2,       /* DrawMode */
  160.    230, 167,     /* LeftEdge, TopEdge */
  161.    &TxtAt_Plain, /* ITextFont Pointer */ 
  162.    /* The IText */
  163.    (UBYTE *)&LnDegBuf[0],
  164.    &LongMinText    /* NextText */
  165.  };
  166.  
  167.  
  168. struct IntuiText DispText_5 = {
  169.    1, 0,     /* FrontPen, BackPen */
  170.    JAM2,       /* DrawMode */
  171.    333, 177,     /* LeftEdge, TopEdge */
  172.    &TxtAt_B, /* ITextFont Pointer */ 
  173.    /* The IText */
  174.    (UBYTE *)"Sidereal Time:",
  175.    &LongDegText    /* NextText */
  176.  };
  177.  
  178.  
  179. struct IntuiText DispText_4 = {
  180.    1, 0,     /* FrontPen, BackPen */
  181.    JAM2,       /* DrawMode */
  182.    200, 177,     /* LeftEdge, TopEdge */
  183.    &TxtAt_B, /* ITextFont Pointer */ 
  184.    /* The IText */
  185.    (UBYTE *)"Date:",
  186.    &DispText_5    /* NextText */
  187.  };
  188.  
  189.  
  190. struct IntuiText DispText_3 = {
  191.    1, 0,     /* FrontPen, BackPen */
  192.    JAM2,       /* DrawMode */
  193.    508, 167,     /* LeftEdge, TopEdge */
  194.    &TxtAt_I, /* ITextFont Pointer */ 
  195.    /* The IText */
  196.    (UBYTE *)"Deg.",
  197.    &DispText_4    /* NextText */
  198.  };
  199.  
  200.  
  201. struct IntuiText DispText_2 = {
  202.    1, 0,     /* FrontPen, BackPen */
  203.    JAM2,       /* DrawMode */
  204.    398, 167,     /* LeftEdge, TopEdge */
  205.    &TxtAt_B, /* ITextFont Pointer */ 
  206.    /* The IText */
  207.    (UBYTE *)"Latitude:",
  208.    &DispText_3    /* NextText */
  209.  };
  210.  
  211.  
  212. struct IntuiText DispText_1 = {
  213.    1, 0,     /* FrontPen, BackPen */
  214.    JAM2,       /* DrawMode */
  215.    223, 167,     /* LeftEdge, TopEdge */
  216.    &TxtAt_I, /* ITextFont Pointer */ 
  217.    /* The IText */
  218.    (UBYTE *)"     Deg.     Min.",
  219.    &DispText_2    /* NextText */
  220.  };
  221.  
  222.  
  223. struct IntuiText DispText_0 = {
  224.    1, 0,     /* FrontPen, BackPen */
  225.    JAM2,       /* DrawMode */
  226.    137, 167,     /* LeftEdge, TopEdge */
  227.    &TxtAt_B, /* ITextFont Pointer */ 
  228.    /* The IText */
  229.    (UBYTE *)"Longitude:",
  230.    &DispText_1    /* NextText */
  231.  };
  232.  
  233.  
  234.  
  235.  
  236. /**********************************************************************
  237.  perform initialization of the screen and data structures (as needed) 
  238. **********************************************************************/
  239. initialize()
  240. {
  241.   struct FileHandle *filedes;
  242.   LONG timestamp;
  243.   struct tm *timedat;
  244.  
  245.  
  246.   if((filedes = Open(&DefaultStartFile[0],MODE_OLDFILE))==NULL)
  247.     { /* set defaults to local stuff (for me) */
  248.       DefaultParms.LongitudeDeg =118;
  249.        DefaultParms.LongitudeMin = 10;
  250.        DefaultParms.Latitude = 34;
  251.        
  252.        /* read the system clock */
  253.        timestamp = time(NULL);
  254.        timedat = localtime(×tamp);
  255.  
  256.        DefaultParms.Month = timedat->tm_mon + 1;
  257.        DefaultParms.Day = timedat->tm_mday;
  258.        DefaultParms.Year= timedat->tm_year + 1900;
  259.        DefaultParms.Hour = timedat->tm_hour;
  260.        DefaultParms.Minute = timedat->tm_min;
  261.        DefaultParms.Horizon = 0;/* zero for North, one for South */
  262.        CalcParams(&DefaultParms); /* calculate sidereal time, GST, etc. from work */
  263.      }
  264.   else { /* read the default parameters from the file */
  265.          Read(filedes,&DefaultParms,(LONG)sizeof(struct ParamStruct));
  266.          Read(filedes,&CTable[0],(LONG)(32*sizeof(UWORD)));
  267.          /* change the registers to the new  colors */
  268.          LoadRGB4(vport,&CTable,32L);
  269.  
  270.          Close(filedes);
  271.        }
  272.        
  273.   /* global PI based values for calculations */
  274.   P1 = PI/180.0;
  275.   P12 = PI/12.0;
  276.   P15 = P1 * 15.0;
  277.  
  278.   Parms = DefaultParms; /* set the current parms to the default */
  279.   
  280.   DisplayStars();
  281.   DisplayAllText();
  282. }
  283. /***************************************************************************
  284.  * SetEW - set labels for the east and west sides of the display 
  285.  ***************************************************************************/
  286. SetEW(horiz)
  287. SHORT horiz;
  288. {  
  289.    if (horiz) {
  290.       RightLabel.IText = (UBYTE *)"W";
  291.       LeftLabel.IText = (UBYTE *)"E";
  292.       BotLabel.IText = (UBYTE *)"S";
  293.       } 
  294.    else {
  295.       RightLabel.IText = (UBYTE *)"E";
  296.       LeftLabel.IText = (UBYTE *)"W";
  297.       BotLabel.IText = (UBYTE *)"N";
  298.       } 
  299.    PrintIText(rp,&BotLabel,0L,0L);
  300.    
  301. }
  302.  
  303. /***************************************************************************
  304.  * PlotStar - draw a star into the display area. - must provide coords 
  305.  ***************************************************************************/
  306. PlotStar(magnitude,chartx,charty,highlight)
  307. FLOAT magnitude;
  308. LONG chartx, charty;
  309. SHORT highlight;
  310. { 
  311.   LONG starcolor;
  312.   SetDrMd(rp,JAM1);
  313.   if (highlight) SetAPen(rp,(LONG)(highlight + 10)); /* output star in color */
  314.   else if (magnitude > MaxWhite) SetAPen(rp,12L); /* output in alternate blue */
  315.   else 
  316.      {
  317.        starcolor = (LONG) magnitude + 3.5; /* round up */
  318.        if (starcolor > 10L) starcolor = 12L;
  319.        SetAPen(rp,starcolor);
  320.      }
  321.  
  322.   if (magnitude > MaxPlus) /* magnitude is an inverse measure */
  323.      WritePixel(rp,chartx,charty);
  324.   else   
  325.      { Move(rp,chartx-1L,charty);
  326.        Draw(rp,chartx+1L,charty);
  327.        Move(rp,chartx,charty-1L);
  328.        Draw(rp,chartx,charty+1L);
  329.      }
  330. } /* end of PlotStar */
  331.  
  332. /***************************************************************************
  333.  * BlinkStar - blink the star indicated by the table index number in red
  334.  ***************************************************************************/
  335. BlinkStar (index,count,highlight,circle)
  336. SHORT index,count,highlight,circle;
  337. {
  338.   SHORT i;
  339.   FLOAT mag;
  340.   LONG x, y;
  341.  
  342.   mag = StarTable[index].Mag;
  343.   x = coords[index].x;
  344.   y = coords[index].y;
  345.   
  346.   if (x == 0L) return;
  347.  
  348.   if (circle > 0) 
  349.      { SetDrMd(rp,COMPLEMENT);
  350.        DrawEllipse(rp,x,y,(LONG)circle,(LONG)(circle / 2));
  351.      }
  352.        
  353.   for (i=0; i < count; i++)
  354.     {
  355.       PlotStar(mag,x,y,highlight);
  356.       Delay(25L);
  357.       PlotStar(mag,x,y,0);
  358.       Delay(10L);
  359.     }
  360.  
  361.   if (circle > 0) 
  362.      { SetDrMd(rp,COMPLEMENT);
  363.        DrawEllipse(rp,x,y,(LONG)circle,(LONG)(circle /2));
  364.        
  365.      }
  366.   SetDrMd(rp,JAM1);
  367.  
  368. } /* end of BlinkStar */
  369.  
  370. /***************************************************************************
  371.  * HighLightStar - Plot the star indicated by the table index number.
  372.  ***************************************************************************/
  373. HighLightStar (index,highlight,circle)
  374. SHORT index,highlight,circle;
  375. {
  376.   SHORT i;
  377.   FLOAT mag;
  378.   LONG x, y;
  379.  
  380.   mag = StarTable[index].Mag;
  381.   x = coords[index].x;
  382.   y = coords[index].y;
  383.  
  384.   if (x == 0L) return;
  385.   
  386.   PlotStar(mag,x,y,highlight);
  387.   if (circle > 0) 
  388.      { SetDrMd(rp,COMPLEMENT);
  389.        DrawEllipse(rp,x,y,(LONG)circle,(LONG)(circle /2));
  390.        SetDrMd(rp,JAM1);
  391.      }
  392.  
  393. } /* end of HighLightStar */
  394.  
  395. /***************************************************************************
  396.  * PlotConst - Plot a constellation from a list of startable indexes.
  397.  *             If highlight is 1, the stars are output in red. If
  398.  *             highlight is 0, they are output in normal colors.
  399.  ***************************************************************************/
  400. BOOL PlotConst(list,highlight,dispflag)
  401. SHORT list[], highlight, dispflag;
  402.  
  403. {
  404.   SHORT i, nstars, index;
  405.   FLOAT mag;
  406.   LONG x, y;
  407.   BOOL visible, major;
  408.  
  409.   nstars = list[0];
  410.   visible = FALSE;
  411.   if (dispflag & 4) major = TRUE;
  412.   else major = FALSE;
  413.  
  414.   /* highlight all the visible stars in the constellation list */
  415.   for(i=1; i <= nstars; i++)
  416.      {  index = list[i];
  417.         if (major && StarTable[index].GreekNum == 0) continue;
  418.           
  419.         mag = StarTable[index].Mag;
  420.         x = coords[index].x;
  421.         y = coords[index].y;
  422.         if (x != 0L)
  423.           { visible = TRUE;
  424.             PlotStar(mag,x,y,highlight);
  425.           }
  426.          
  427.      }
  428.   /* if none of the stars were visible - return now */
  429.   return(visible);
  430.   
  431. } /* end of PlotConst */
  432.  
  433. /***************************************************************************
  434.  * PlotObjects - Plot Messier or NGC objects.
  435.  ***************************************************************************/
  436. PlotObjects(type,highlight)
  437. char type;
  438. SHORT highlight;
  439.  
  440. {
  441.   SHORT i;
  442.  
  443.   for (i=1; i <= NumStars; i++)
  444.      { if (coords[i].x != 0L) /* is it visible ? */
  445.          { if (StarTable[i].GreekNum == 0)
  446.              { /* not a major star */
  447.               if (*(StarTable[i].StarName) == type)
  448.                  PlotStar(StarTable[i].Mag,
  449.               coords[i].x,coords[i].y,highlight);
  450.          }
  451.          }
  452.      }
  453.  
  454. } /* end of PlotObjects */
  455.  
  456. /***************************************************************************
  457.  * CalcGst - calculate Greenwich time
  458.  ***************************************************************************/
  459. FLOAT CalcGst(day,month)
  460. SHORT day, month;
  461. {
  462.    FLOAT df,Gst;
  463.     
  464.    df = (FLOAT) day + DSum[month];
  465.    Gst = 6.68 + (df * 4.0) / 60.0;
  466.    if (Gst > 24.0) return(Gst - 24.0);
  467.    else return(Gst);
  468.  
  469. }
  470.  
  471. /***************************************************************************
  472.  * ClearChart - clear the star display area to black.
  473.  ***************************************************************************/
  474. ClearChart()
  475. {
  476.   SetAPen(rp,2L);
  477.   RectFill(rp,CHARTLEFT,CHARTTOP,CHARTRIGHT,CHARTBOT);
  478. }
  479.  
  480. /***************************************************************************
  481.  * DisplayStars - Calculate the positions of the visible stars given the
  482.  *  current parms and plot them on the screen. Save positions in coords.
  483.  ***************************************************************************/
  484. DisplayStars()
  485. {
  486.   extern UBYTE WTMessage[];
  487.   extern UBYTE WinTitle[]; /* default window title */
  488.   
  489.   sprintf(WTMessage,"Calculating Star Positions for Current Date and Time");
  490.   SetWindowTitles(w,WTMessage,(UBYTE *)-1);
  491.   CalcStars();
  492.   SetWindowTitles(w,WinTitle,(UBYTE *)-1);
  493.   ReDisplay();
  494.   SetEW(Parms.Horizon);
  495.  
  496. } /* end of DisplayStars */
  497.  
  498. /***************************************************************************
  499.  * CalcStars - Calculate the positions of the visible stars given the
  500.  *  current parms and plot them on the screen. Save positions in coords.
  501.  ***************************************************************************/
  502. CalcStars()
  503. {
  504.   FLOAT Xpos,Ypos, LatRad, LatPos, LatCOS, LatSIN, F;
  505.   SHORT i;
  506.   register FLOAT yeardif, RA, DC, xRad, yRad;
  507.   BOOL visible;
  508.   struct star_rec *ST;
  509.   struct Coord *c;
  510.  
  511.   /* set some (variable) constants */
  512.   yeardif = (FLOAT)(Parms.Year - 1950);
  513.   LatRad = Parms.Latitude * P1;
  514.   LatPos = 160.0 - (1.78 * Parms.Latitude);
  515.   LatCOS = cos(LatRad);
  516.   LatSIN =  -sin(LatRad);
  517.   F = 140.0 / 1.5708;
  518.  
  519.   /* for a little extra speed we will use pointers rather than array indexes */
  520.   ST = &StarTable[1];
  521.   c = &coords[1];
  522.  
  523.   for (i = 1; i <= NumStars; i++)
  524.     { 
  525.      RA = ST->Ra;
  526.      DC = ST->Dc;
  527.  
  528.      if (((Parms.Horizon == 0)&&(DC < 0.0)) || /* north view */
  529.          ((Parms.Horizon == 1)&&
  530.           ((DC > (FLOAT)Parms.Latitude)|| 
  531.            (DC < (FLOAT)(Parms.Latitude - 90))) /* south view */
  532.           ))
  533.         { /* don't bother calculating if it will never be visible given the */
  534.           /* current position and orientation.                    */
  535.           c->x = 0L;
  536.           c->y = 0L;
  537.           ST++;
  538.           c++;  
  539.           continue;
  540.          }
  541.          
  542.      if (yeardif) {
  543.        /* convert right Asc. and declination of star to radians */
  544.        xRad = RA * P12;
  545.        yRad = DC * P1;
  546.        
  547.      
  548.        /* correct for year - uses mathffp routines*/
  549.        Xpos = RA + 
  550.              (3.07 + 1.34 * sin(xRad) * tan(xRad))
  551.           * yeardif / 3600.0;
  552.  
  553.       
  554.        Ypos = DC + 20.0 * cos(yRad) * yeardif / 3600.0;
  555.       }
  556.    else { /* year is 1950 - basis for the star table */
  557.          Xpos = RA;
  558.          Ypos = DC;
  559.         }
  560.   
  561.    /* modify the Xpos and Ypos for the date, time, location and horizon */   
  562.    if(Parms.Horizon == 0) 
  563.      visible = NorthView(&Xpos,&Ypos,LatRad,LatPos,LatCOS,LatSIN,F);
  564.    else 
  565.      visible = SouthView(&Xpos,&Ypos,LatCOS,LatSIN);
  566.   
  567.    /* if the star is visible from the current location - save coords and   */
  568.    /* plot it on the display (not any more - actual plot is done in redisp */
  569.    if(visible)
  570.      { /* set the display coordinates */
  571.        c->x = CHARTLEFT + (LONG)((2.0 * Xpos) + 0.5);
  572.        c->y = (CHARTTOP+1L) + (LONG)(Ypos + 0.5);
  573.      }
  574.    else 
  575.      { c->x = 0L;
  576.        c->y = 0L;
  577.      }
  578.      
  579.    /* increment the pointers */
  580.    ST++;
  581.    c++;  
  582.    } /* end of for loop */
  583. } /* end of DisplayStars */
  584.  
  585.  
  586. /***************************************************************************
  587.  * NorthView - calculate star position for Northern Sky
  588.  *  returns 1 if star is visible, zero if not visible from current location
  589.  ***************************************************************************/
  590. BOOL NorthView (xposit,yposit,lat,LatPos,latcos,latsin,F)
  591. FLOAT *xposit, *yposit,lat,LatPos,latcos,latsin,F;
  592. {
  593.   FLOAT DecRad,HourRad, Temp1, TempX, TempY;
  594.   register FLOAT xpos, ypos;
  595.  
  596.   xpos = *xposit;
  597.   ypos = *yposit;
  598.  
  599.   if (ypos < 0.0) return(0);
  600.   
  601.   /* convert declination, latitude, and local sidereal time to radians */
  602.   DecRad = ypos * P1;
  603.   HourRad = P12 * (Parms.Lst - xpos);
  604.   
  605.   /* eliminate stars below the horizon line */
  606.   if(( latcos * cos(DecRad) * cos(HourRad))
  607.      <( latsin * sin(DecRad))) return(0);
  608.  
  609.   xpos = xpos - Parms.Lst;
  610.   ypos = ypos * P1;
  611.   
  612.   /* Map to scale for the display */
  613.   xpos = (xpos * P15) - 1.5708;
  614.  
  615.   Temp1 =  F * (1.5708 -  abs(ypos));
  616.   TempX = Temp1 * cos(xpos) + 140.0;
  617.   
  618.   TempY = Temp1 * sin(xpos) + LatPos;
  619.   
  620.   xpos = TempX;
  621.   ypos = TempY;
  622.  
  623.   if((xpos > 279.0) || (xpos < 0.0)) return(0);
  624.   if((ypos > 159.0) || (ypos < 0.0)) return(0);
  625.   
  626.   /* if we got to here it must be visible */
  627.   *xposit = xpos;
  628.   *yposit = ypos;
  629.   return(1);
  630. } /* end of NorthView */
  631.  
  632. /***************************************************************************
  633.  * SouthView - calculate star position for Southern Sky
  634.  *  returns 1 if star is visible, zero if not visible from current location
  635.  ***************************************************************************/
  636. BOOL SouthView (xposit,yposit,latcos,latsin)
  637. FLOAT *xposit, *yposit,latcos,latsin;
  638. {
  639.   FLOAT DecRad,LatRad,HourRad, LatPos, Temp1;
  640.   register FLOAT xpos, ypos;
  641.  
  642.   xpos = *xposit;
  643.   ypos = *yposit;
  644.  
  645.   if (ypos > (FLOAT)Parms.Latitude) return(0);
  646.  
  647.   if (ypos < (FLOAT)(Parms.Latitude - 90)) return(0);
  648.  
  649.   
  650.   /* convert declination, latitude, and local sidereal time to radians */
  651.   DecRad = ypos * P1;
  652.   HourRad = P12 * (Parms.Lst - xpos);
  653.   
  654.   /* eliminate stars below the horizon line */
  655.   if(( latcos * cos(DecRad) * cos(HourRad))
  656.      <( latsin * sin(DecRad))) return(0);
  657.  
  658.   xpos =  Parms.Lst - xpos;
  659.   if(xpos < -12.0) xpos += 24.0;
  660.   if(xpos > 12.0) xpos -= 24.0;
  661.   xpos = 140.0 + (23.33 * xpos);
  662.   
  663.   if((xpos > 279) || (xpos < 0)) return(0);
  664.  
  665.   ypos = 1.78 * (Parms.Latitude - ypos);
  666.   
  667.   if((ypos > 159.0) || (ypos < 0.0)) return(0);
  668.   
  669.   /* if we got to here it must be visible */
  670.   *xposit = xpos;
  671.   *yposit = ypos;
  672.   return(1);
  673. } /* end of SouthView */
  674.  
  675. /***************************************************************************
  676.  * ReDisplay - Plots the stars currently in the coords table.
  677.  ***************************************************************************/
  678. ReDisplay()
  679. { 
  680.   SHORT i;
  681.   struct star_rec *S;
  682.   struct Coord *c;
  683.  
  684.   ClearChart();
  685.   S = &StarTable[1];
  686.   c = &coords[1];
  687.  
  688.   for(i=1; i <= NumStars; i++) 
  689.      {if (c->x) /* if the coord is not 0 */
  690.         PlotStar(S->Mag,c->x,c->y,0);
  691.       S++;
  692.       c++;
  693.      }
  694. }
  695.  
  696. /***************************************************************************
  697.  * DisplayAllText - Print out the parameters and their labels in the
  698.  *               text display area;
  699.  ***************************************************************************/
  700. DisplayAllText()
  701. {
  702.   setlatdisp();
  703.   setlndisp();
  704.   setdatedisp();
  705.   settimedisp();
  706.   PrintIText(w->RPort,&DispText_0,-20L,13L);
  707. }  
  708.  
  709. /***************************************************************************
  710.  * DispDateText - Format and print out the current date
  711.  ***************************************************************************/
  712. DispDateText()
  713. {
  714.   setdatedisp();
  715.   PrintIText(w->RPort,&DateText,-20L,13L);
  716. }  
  717.  
  718. /***************************************************************************
  719.  * DispTimeText - Format and print out the current time.
  720.  ***************************************************************************/
  721. DispTimeText()
  722. {
  723.   settimedisp();
  724.   PrintIText(w->RPort,&SidTimeText,-20L,13L);
  725. }  
  726.  
  727. /***************************************************************************
  728.  * DispDateTimeText - Format and print out both the date and time
  729.  ***************************************************************************/
  730. DispDateTimeText()
  731. {
  732.   setdatedisp();
  733.   settimedisp();
  734.   PrintIText(w->RPort,&DateText,-20L,13L);
  735. }  
  736.  
  737.  
  738. /***************************************************************************
  739.  * setlatdisp - Put current latitude into display buffer.
  740.  ***************************************************************************/
  741. setlatdisp()
  742. {     
  743.    sprintf(&LatBuf[0],"%2d",Parms.Latitude);
  744. }
  745.  
  746. /***************************************************************************
  747.  * setlndisp - Put current longitude into display buffer.
  748.  ***************************************************************************/
  749. setlndisp()
  750. {     
  751.     sprintf(&LnDegBuf[0], "%3d",Parms.LongitudeDeg);
  752.     sprintf(&LnMinBuf[0], "%2d",Parms.LongitudeMin);
  753. }
  754.  
  755. /***************************************************************************
  756.  * setdatedisp - Put current date into display buffer.
  757.  ***************************************************************************/
  758. setdatedisp()
  759. {    
  760.     sprintf(&DateBuf[0],"%2d/%2d/%4d",Parms.Month,Parms.Day,Parms.Year);
  761. }
  762.  
  763. /***************************************************************************
  764.  * settimedisp - Put current time into display buffer.
  765.  ***************************************************************************/
  766. settimedisp()
  767. {
  768.    sprintf(&STBuf[0],"%2d:%02d:%02d",Parms.Hr,Parms.Mn,SecondsCount);
  769. }
  770. /***************************************************************************
  771.  * UpdateTime - increment the current time and date by the TimeDelay value
  772.  ***************************************************************************/
  773. BOOL UpdateTime()
  774. {
  775.   SHORT worksecs, workmins, workhours;
  776.   BOOL datechange = FALSE;
  777.   BOOL hourchange; /* display is updated each hour */
  778.   
  779.   hourchange = FALSE;
  780.   SecondsCount += TimeDelay;
  781.   if (SecondsCount < 60) DispTimeText();
  782.   else
  783.    {  workhours = SecondsCount / 3600;  
  784.       workmins = SecondsCount % 3600;
  785.       worksecs = workmins % 60;
  786.       workmins = workmins / 60;
  787.       SecondsCount = worksecs;
  788.  
  789.       workmins += Parms.Mn;
  790.       workhours += Parms.Hr;
  791.  
  792.       if (workmins > 59)
  793.        { workhours++;
  794.          hourchange = TRUE;
  795.          workmins -= 60;
  796.        }
  797.       Parms.Mn = workmins;
  798.  
  799.       if (workhours > 23)
  800.        { Parms.Day++;
  801.          workhours -= 24;
  802.          datechange = TRUE;
  803.        }
  804.       Parms.Hr = workhours;
  805.  
  806.       if (datechange)
  807.        { if (Parms.Day > Dd[Parms.Month])
  808.             {  Parms.Day -= Dd[Parms.Month];
  809.                Parms.Month++;
  810.              }
  811.          if (Parms.Month > 12)
  812.             { Parms.Year++;
  813.           Parms.Month -= 12;
  814.             }
  815.          DispDateTimeText();
  816.        }
  817.       else DispTimeText();
  818.    }
  819.   Parms.Lst = (FLOAT)Parms.Hr
  820.               + ((FLOAT)Parms.Mn / 60.0) + ((FLOAT)SecondsCount / 3600.0); 
  821.               
  822.   return(hourchange);
  823. }
  824.  
  825.