/*********************************************************************/
/* Finds date of Pratipat, Krsna Paksa, Visnu Masa */
/* */
/* EARTHDATA earth - location */
/* int nYear - Gregorian year */
/* */
/*********************************************************************/
public static GPGregorianTime getFirstDayOfYear(GPLocationProvider earth, int nYear)
{
int[] a = new int[] { 2, 15, 3, 1, 3, 15, 4, 1, 4, 15 };
GPGregorianTime d = new GPGregorianTime(earth);
GPAstroData day = new GPAstroData();
int gy, j, masa;
int step;
uint tmp;
if (nYear >= 1950 && nYear < 2058)
{
tmp = gGaurBeg[(nYear - 1950) * 26 + 22];
d.setDate(nYear, Convert.ToInt32(tmp & 0x3e0) >> 5, Convert.ToInt32(tmp & 0x1f));
d.NextDay();
a[0] = d.getMonth();
a[1] = d.getDay();
}
for (int i = 0; i < 10; i += 2)
{
d.setDate(nYear, a[i], a[i + 1]);
day.calculateDayData(d, earth);
masa = day.determineMasa(d, out gy);
if (masa == 11) // visnu masa
{
do
{
// shifts date
step = day.nTithi / 2;
step = (step > 0) ? step : 1;
for (j = step; j > 0; j--)
{
d.PreviousDay();
}
// try new time
day.calculateDayData(d, earth);
}while (day.nTithi < 28);
d.NextDay();
d.setDayHours(day.sun.getSunriseDayHours());
return(d);
}
}
d.Clear();
d.setDayHours(day.sun.getSunriseDayHours());
return(d);
}
/*********************************************************************/
/* */
/* finds next time when starts next yoga */
/* */
/* timezone is not changed */
/* */
/* return value: index of yoga 0..26 */
/* or -1 if failed */
/*********************************************************************/
public static int GetNextStart(GPGregorianTime startDate, out GPGregorianTime nextDate)
{
double phi = 40 / 3.0;
double l1, l2, sunl;
double jday = startDate.getJulianGreenwichTime();
double xj;
double ayanamsa = GPAyanamsa.GetAyanamsa(jday);
GPMoon moon = new GPMoon();
GPGregorianTime d = new GPGregorianTime(startDate);
GPGregorianTime xd = new GPGregorianTime(startDate.getLocationProvider());
double scan_step = 0.5;
int prev_tit = 0;
int new_tit = -1;
moon.MoonCalc(jday);
sunl = GPSun.GetSunLongitude(jday);
l1 = GPMath.putIn360(moon.longitude_deg + sunl - 2 * ayanamsa);
prev_tit = Convert.ToInt32(Math.Floor(l1 * 3 / 40.0));
int counter = 0;
while (counter < 20)
{
xj = jday;
xd.Copy(d);
jday += scan_step;
d.setDayHours(d.getDayHours() + scan_step);
if (d.getDayHours() > 1.0)
{
d.setDayHours(d.getDayHours() - 1.0);
d.NextDay();
}
moon.MoonCalc(jday);
//SunPosition(d, ed, sun, d.shour - 0.5 + d.tzone/24.0);
//l2 = put_in_360(moon.longitude_deg - sun.longitude_deg - 180.0);
sunl = GPSun.GetSunLongitude(jday);
l2 = GPMath.putIn360(moon.longitude_deg + sunl - 2 * ayanamsa);
//Debugger.Log(0, "", "Current position: " + l2/12.0 + " date: " + jday + "\n");
new_tit = Convert.ToInt32(Math.Floor(l2 / phi));
if (prev_tit != new_tit)
{
jday = xj;
d.Copy(xd);
scan_step *= 0.5;
counter++;
continue;
}
else
{
l1 = l2;
}
}
nextDate = d;
// nextDate.shour += startDate.tzone / 24.0;
// nextDate.NormalizeValues();
return(new_tit);
}
/*********************************************************************/
/* */
/* finds next time when starts next naksatra */
/* */
/* timezone is not changed */
/* */
/* return value: index of naksatra 0..26 */
/* or -1 if failed */
/*********************************************************************/
public static int GetNextNaksatra(GPGregorianTime startDate, out GPGregorianTime nextDate)
{
double phi = 40.0 / 3.0;
double l1, l2;
double jday = startDate.getJulianGreenwichTime();
GPMoon moon = new GPMoon();
GPGregorianTime d = new GPGregorianTime(startDate);
double ayanamsa = GPAyanamsa.GetAyanamsa(jday);
double scan_step = 0.5;
int prev_naks = 0;
int new_naks = -1;
double xj;
GPGregorianTime xd = new GPGregorianTime(startDate.getLocationProvider());
moon.MoonCalc(jday);
l1 = GPMath.putIn360(moon.longitude_deg - ayanamsa);
prev_naks = Convert.ToInt32(Math.Floor(l1 / phi));
int counter = 0;
while (counter < 20)
{
xj = jday;
xd.Copy(d);
jday += scan_step;
d.setDayHours(d.getDayHours() + scan_step);
if (d.getDayHours() > 1.0)
{
d.setDayHours(d.getDayHours() - 1.0);
d.NextDay();
}
moon.MoonCalc(jday);
l2 = GPMath.putIn360(moon.longitude_deg - ayanamsa);
new_naks = Convert.ToInt32(Math.Floor(l2 / phi));
if (prev_naks != new_naks)
{
jday = xj;
d.Copy(xd);
scan_step *= 0.5;
counter++;
continue;
}
else
{
l1 = l2;
}
}
nextDate = d;
return(new_naks);
}
public GPAppHelper()
{
GPLocationProvider loc = getMyLocation();
TodayDate = new GPGregorianTime(loc);
TodayDate.Today();
YesterdayDate = new GPGregorianTime(loc);
YesterdayDate.Today();
YesterdayDate.PreviousDay();
TomorrowDate = new GPGregorianTime(loc);
TomorrowDate.Today();
TomorrowDate.NextDay();
}
public static int GetNextRasi(GPGregorianTime startDate, out GPGregorianTime nextDate)
{
double jday = startDate.getJulianGreenwichTime();
GPMoon moon = new GPMoon();
GPGregorianTime d = new GPGregorianTime(startDate);
double ayanamsa = GPAyanamsa.GetAyanamsa(jday);
double scan_step = 0.5;
int prev_naks = 0;
int new_naks = -1;
double xj;
GPGregorianTime xd = new GPGregorianTime(startDate.getLocationProvider());
moon.MoonCalc(jday);
//l1 = GPMath.putIn360(moon.longitude_deg - ayanamsa);
prev_naks = GPEngine.GetRasi(moon.longitude_deg, ayanamsa);
int counter = 0;
while (counter < 20)
{
xj = jday;
xd.Copy(d);
jday += scan_step;
d.setDayHours(d.getDayHours() + scan_step);
if (d.getDayHours() > 1.0)
{
d.setDayHours(d.getDayHours() - 1.0);
d.NextDay();
}
moon.MoonCalc(jday);
//l2 = GPMath.putIn360(moon.longitude_deg - ayanamsa);
new_naks = GPEngine.GetRasi(moon.longitude_deg, ayanamsa);
if (prev_naks != new_naks)
{
jday = xj;
d.Copy(xd);
scan_step *= 0.5;
counter++;
continue;
}
}
nextDate = d;
return(new_naks);
}
/*********************************************************************/
/* Finds next time when rasi is changed */
/* */
/* startDate - starting date and time, timezone member must be valid */
/* zodiac [out] - found zodiac sign into which is changed */
/* */
/*********************************************************************/
public static GPGregorianTime GetNextSankranti(GPGregorianTime startDate, out int zodiac)
{
GPGregorianTime d;
double step = 1.0;
int count = 0;
double ld, prev;
int prev_rasi, new_rasi;
GPGregorianTime prevday = new GPGregorianTime(startDate.getLocation());
zodiac = 0;
d = new GPGregorianTime(startDate);
double jdate = d.getJulianGreenwichTime();
prev = GPMath.putIn360(GPSun.GetSunLongitude(jdate) - GPAyanamsa.GetAyanamsa(jdate));
prev_rasi = Convert.ToInt32(Math.Floor(prev / 30.0));
while (count < 20)
{
prevday.Copy(d);
d.setDayHours(d.getDayHours() + step);
if (d.getDayHours() > 1.0)
{
d.setDayHours(d.getDayHours() - 1.0);
d.NextDay();
}
jdate = d.getJulianGreenwichTime();
ld = GPMath.putIn360(GPSun.GetSunLongitude(jdate) - GPAyanamsa.GetAyanamsa(jdate));
new_rasi = Convert.ToInt32(Math.Floor(ld / 30.0));
if (prev_rasi != new_rasi)
{
zodiac = new_rasi;
//v uplynulom dni je sankranti
step *= 0.5;
d.Copy(prevday);
count++;
continue;
}
}
return(d);
}
public static GPGregorianTime CalcTithiEndEx(GPGregorianTime vcStart, int GYear, int nMasa, int nPaksa, int nTithi, GPLocationProvider earth, out GPGregorianTime endTithi)
{
int i, gy, nType;
GPGregorianTime d = new GPGregorianTime(earth);
GPGregorianTime dtemp = new GPGregorianTime(earth);
GPAstroData day = new GPAstroData();
int tithi;
int counter;
GPGregorianTime start = new GPGregorianTime(earth), end = new GPGregorianTime(earth);
// SUNDATA sun;
// MOONDATA moon;
double sunrise;
start.setDayHours(-1.0);
end.setDayHours(-1.0);
start.Clear();
end.Clear();
/* d = GetFirstDayOfYear(earth, nGYear + 1486);
* d.shour = 0.5;
* d.TimeZone = earth.tzone;
*/
d.Copy(vcStart);
i = 0;
do
{
d.AddDays(13);
day.calculateDayData(d, earth);
day.nMasa = day.determineMasa(d, out gy);
day.nGaurabdaYear = gy;
i++;
}while (((day.nPaksa != nPaksa) || (day.nMasa != nMasa)) && (i <= 30));
if (i >= 30)
{
d.Clear();
endTithi = d;
return(d);
}
// we found masa and paksa
// now we have to find tithi
tithi = nTithi + nPaksa * 15;
if (day.nTithi == tithi)
{
// loc1
// find tithi juncts in this day and according to that times,
// look in previous or next day for end and start of this tithi
nType = 1;
}
else
{
if (day.nTithi < tithi)
{
// do increment of date until nTithi == tithi
// but if nTithi > tithi
// then do decrement of date
counter = 0;
while (counter < 30)
{
d.NextDay();
day.calculateDayData(d, earth);
if (day.nTithi == tithi)
{
goto cont_2;
}
if ((day.nTithi < tithi) && (day.nPaksa != nPaksa))
{
d.PreviousDay();
goto cont_2;
}
if (day.nTithi > tithi)
{
d.PreviousDay();
goto cont_2;
}
counter++;
}
// somewhere is error
d.Clear();
nType = 0;
}
else
{
// do decrement of date until nTithi <= tithi
counter = 0;
while (counter < 30)
{
d.PreviousDay();
day.calculateDayData(d, earth);
if (day.nTithi == tithi)
{
goto cont_2;
}
if ((day.nTithi > tithi) && (day.nPaksa != nPaksa))
{
goto cont_2;
}
if (day.nTithi < tithi)
{
goto cont_2;
}
counter++;
}
// somewhere is error
d.Clear();
nType = 0;
}
cont_2:
if (day.nTithi == tithi)
{
// do the same as in loc1
nType = 1;
}
else
{
// nTithi != tithi and nTithi < tithi
// but on next day is nTithi > tithi
// that means we will find start and the end of tithi
// in this very day or on next day before sunrise
nType = 2;
}
}
// now we know the type of day-accurancy
// nType = 0 means, that we dont found a day
// nType = 1 means, we find day, when tithi was present at sunrise
// nType = 2 means, we found day, when tithi started after sunrise
// but ended before next sunrise
//
sunrise = day.sun.getSunriseDayHours() / 360 + day.sun.rise.getLocation().getTimeZoneOffsetHours() / 24;
if (nType == 1)
{
GPGregorianTime d1, d2;
d.setDayHours(sunrise);
GetPrevTithiStart(d, out d1);
//d = d1;
//d.shour += 0.02;
GetNextTithiStart(d, out d2);
endTithi = d2;
return(d1);
}
else if (nType == 2)
{
GPGregorianTime d1, d2;
d.setDayHours(sunrise);
GetNextTithiStart(d, out d1);
d.Copy(d1);
d.addDayHours(0.1);
GetNextTithiStart(d, out d2);
endTithi = d2;
return(d1);
}
// if nType == 0, then this algoritmus has some failure
if (nType == 0)
{
d.Clear();
d.setDayHours(0.0);
endTithi = d;
}
else
{
d.Copy(start);
endTithi = end;
}
return(d);
}
/*********************************************************************/
/* Calculates Date of given Tithi */
/*********************************************************************/
public static GPGregorianTime CalcTithiDate(int nGYear, int nMasa, int nPaksa, int nTithi, GPLocationProvider earth)
{
int i = 0, gy = 0;
GPGregorianTime d = new GPGregorianTime(earth);
GPAstroData day = new GPAstroData();
int tithi = 0;
int counter = 0;
uint tmp = 0;
if (nGYear >= 464 && nGYear < 572)
{
tmp = GPGaurabdaYear.gGaurBeg[(nGYear - 464) * 26 + nMasa * 2 + nPaksa];
d.setDate(Convert.ToInt32(tmp & 0xfffc00) >> 10,
Convert.ToInt32(tmp & 0x3e0) >> 5,
Convert.ToInt32(tmp & 0x1f));
d.NextDay();
day.calculateDayData(d, earth);
day.nMasa = day.determineMasa(d, out gy);
day.nGaurabdaYear = gy;
}
else
{
//d = GetFirstDayOfYear(earth, nGYear + 1486);
d.setDate(nGYear + 1486, 2 + nMasa, 15);
if (d.getMonth() > 12)
{
d.setDate(d.getYear() + 1, d.getMonth() - 12, 0);
}
d.setDayHours(0.5);
i = 0;
do
{
d.AddDays(13);
day.calculateDayData(d, earth);
day.nMasa = day.determineMasa(d, out gy);
day.nGaurabdaYear = gy;
i++;
}while (((day.nPaksa != nPaksa) || (day.nMasa != nMasa)) && (i <= 30));
}
if (i >= 30)
{
d.Clear();
return(d);
}
// we found masa and paksa
// now we have to find tithi
tithi = nTithi + nPaksa * 15;
if (day.nTithi == tithi)
{
// loc1
// find tithi juncts in this day and according to that times,
// look in previous or next day for end and start of this tithi
d.PreviousDay();
day.calculateDayData(d, earth);
if ((day.nTithi > tithi) && (day.nPaksa != nPaksa))
{
d.NextDay();
}
return(d);
}
if (day.nTithi < tithi)
{
// do increment of date until nTithi == tithi
// but if nTithi > tithi
// then do decrement of date
counter = 0;
while (counter < 16)
{
d.NextDay();
day.calculateDayData(d, earth);
if (day.nTithi == tithi)
{
return(d);
}
if ((day.nTithi < tithi) && (day.nPaksa != nPaksa))
{
return(d);
}
if (day.nTithi > tithi)
{
return(d);
}
counter++;
}
// somewhere is error
d.Clear();
return(d);
}
else
{
// do decrement of date until nTithi <= tithi
counter = 0;
while (counter < 16)
{
d.PreviousDay();
day.calculateDayData(d, earth);
if (day.nTithi == tithi)
{
return(d);
}
if ((day.nTithi > tithi) && (day.nPaksa != nPaksa))
{
d.NextDay();
return(d);
}
if (day.nTithi < tithi)
{
d.NextDay();
return(d);
}
counter++;
}
// somewhere is error
d.Clear();
return(d);
}
// now we know the type of day-accurancy
// nType = 0 means, that we dont found a day
// nType = 1 means, we find day, when tithi was present at sunrise
// nType = 2 means, we found day, when tithi started after sunrise
// but ended before next sunrise
//
}
/// <summary>
/// Main function of this class
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
public bool ParseCommandArguments(string[] args)
{
GPLocationProvider loc = new GPLocationProvider();
GPLocation loc1 = new GPLocation();
GPGregorianTime vcStart = new GPGregorianTime(loc), vcEnd = new GPGregorianTime(loc);
GPVedicTime vaStart = new GPVedicTime(), vaEnd = new GPVedicTime();
int nCount;
int nReq = 0;
string strFileOut = "";
try
{
loc1.setLatitudeNorthPositive(0.0);
loc1.setLongitudeEastPositive(0.0);
loc1.setTimeZoneName("");
loc.setDefaultLocation(loc1);
vcStart.Clear();
vcEnd = vcStart;
vaStart.tithi = vaStart.masa = vaStart.gyear = 0;
vaEnd = vaStart;
nCount = -1;
int argc = args.Length;
for (int i = 0; i < argc; i++)
{
//TRACE2("arg %d = %s\n", i, args[i]);
if (args[i] == "-L")
{
if (argc >= i + 2)
{
loc1.setLongitudeString(args[i + 1]);
double lat = 0.0;
double longi = 0.0;
GetArg_EarthPos(args[i + 1], ref lat, ref longi);
loc1.setLongitudeEastPositive(longi);
loc1.setLatitudeNorthPositive(lat);
//TRACE2("-L latitude=%f longitude=%f\n", loc.m_fLatitude, loc.m_fLongitude);
}
i++;
}
else if (args[i] == "-N")
{
if (argc >= i + 2)
{
loc1.setCity(args[i + 1]);
//TRACE1("-N name=%s\n", loc.m_strName);
}
i++;
}
else if (args[i] == "-SV")
{
if (argc >= i + 2)
{
GetArg_VaisnDate(args[i + 1], out vaStart);
}
i++;
}
else if (args[i] == "-SG")
{
if (argc >= i + 2)
{
GetArg_Date(args[i + 1], out vcStart);
}
i++;
}
else if (args[i] == "-ST")
{
if (argc >= i + 2)
{
GetArg_Time(args[i + 1], out vcStart);
}
i++;
}
else if (args[i] == "-EG")
{
if (argc >= i + 2)
{
GetArg_Date(args[i + 1], out vcEnd);
//AfxTrace("-EG day=%d month=%d year=%d\n", vcEnd.day, vcEnd.month, vcEnd.year);
}
i++;
}
else if (args[i] == "-EV")
{
if (argc >= i + 2)
{
GetArg_VaisnDate(args[i + 1], out vaEnd);
//AfxTrace("-EV tithi=%d masa=%d gyear=%d\n", vaEnd.tithi, vaEnd.masa, vaEnd.gyear);
}
i++;
}
else if (args[i] == "-EC")
{
if (argc >= i + 2)
{
int.TryParse(args[i + 1], out nCount);
}
i++;
}
else if (args[i] == "-TZ")
{
if (argc >= i + 2)
{
loc1.setTimeZoneName(args[i + 1]);
}
i++;
}
else if (args[i] == "-O")
{
if (argc >= i + 2)
{
strFileOut = args[i + 1];
}
i++;
}
else if (args[i] == "-R")
{
if (argc >= i + 2)
{
if (args[i + 1] == "calendar")
{
nReq = 10;
}
else if (args[i + 1] == "appday")
{
nReq = 11;
}
else if (args[i + 1] == "tithi")
{
nReq = 12;
}
else if (args[i + 1] == "sankranti")
{
nReq = 13;
}
else if (args[i + 1] == "naksatra")
{
nReq = 14;
}
else if (args[i + 1] == "firstday")
{
nReq = 15;
}
else if (args[i + 1] == "gcalendar")
{
nReq = 16;
}
else if (args[i + 1] == "gtithi")
{
nReq = 17;
}
else if (args[i + 1] == "next")
{
nReq = 18;
}
else if (args[i + 1] == "help")
{
nReq = 60;
}
/*else if (args[i+1] == "")
* {
* } else if (args[i+1] == "")
* {
* } else if (args[i+1] == "")
* {
* } else if (args[i+1] == "")
* {
* }*/
}
i++;
}
}
vcStart.setLocationProvider(loc);
vcEnd.setLocationProvider(loc);
switch (nReq)
{
case 10:
case 13:
case 14:
if (vcStart.getYear() == 0 && vaStart.gyear != 0)
{
GPEngine.VATIMEtoVCTIME(vaStart, out vcStart, loc);
}
if (vcEnd.getYear() == 0 && vaEnd.gyear != 0)
{
GPEngine.VATIMEtoVCTIME(vaEnd, out vcEnd, loc);
}
break;
default:
break;
}
if (vcStart.getYear() != 0 && vcEnd.getYear() != 0 && nCount < 0)
{
nCount = Convert.ToInt32(vcEnd.getJulianLocalNoon() - vcStart.getJulianLocalNoon());
}
if (nCount < 0)
{
nCount = 30;
}
GPAppDayResults appday = new GPAppDayResults();
GPCalendarResults calendar = new GPCalendarResults();
//AfxTrace("Count === %d\n", nCount);
StringBuilder fout = new StringBuilder();
switch (nReq)
{
case 10:
// -R -O -LAT -LON -SG -C [-DST -NAME]
vcStart.NextDay();
vcStart.PreviousDay();
calendar.CalculateCalendar(vcStart, nCount);
FormaterXml.WriteXml(FormaterXml.GetCalendarXmlDocument(calendar), fout);
break;
case 11:
// -R -O -LAT -LON -SG -ST [-NAME]
appday.calculateAppearanceDayData(loc, vcStart);
FormaterXml.FormatAppDayXML(appday, fout);
break;
case 12:
FormaterXml.WriteXML_Tithi(fout, loc, vcStart);
break;
case 13:
if (vcEnd.getYear() == 0)
{
vcEnd = vcStart;
vcEnd.AddDays(nCount);
}
FormaterXml.WriteXml(FormaterXml.GetSankrantiXml(loc, vcStart, vcEnd), fout);
break;
case 14:
FormaterXml.WriteXML_Naksatra(fout, loc, vcStart, nCount);
break;
case 15:
FormaterXml.WriteXML_FirstDay_Year(fout, vcStart);
break;
case 16:
vcStart = GPGaurabdaYear.getFirstDayOfYear(loc, vcStart.getYear());
vcEnd = GPGaurabdaYear.getFirstDayOfYear(loc, vcStart.getYear() + 1);
nCount = Convert.ToInt32(vcEnd.getJulianLocalNoon() - vcStart.getJulianLocalNoon());
calendar.CalculateCalendar(vcStart, nCount);
FormaterXml.WriteXml(FormaterXml.GetCalendarXmlDocument(calendar), fout);
break;
case 17:
FormaterXml.WriteXML_GaurabdaTithi(fout, loc, vaStart, vaEnd);
break;
case 18:
FormaterXml.WriteXML_GaurabdaNextTithi(fout, loc, vcStart, vaStart);
break;
}
// application should be windowless
// since some parameters are present
File.WriteAllText(strFileOut, fout.ToString());
}
catch (Exception ex)
{
Console.WriteLine("Exception during execution: " + ex.Message);
}
return(true);
}
public int CalcMasaList(GPLocationProvider loc, int nYear, int nCount)
{
GPMasaListResults mlist = this;
GPAstroData day = new GPAstroData();
GPGregorianTime d = new GPGregorianTime(loc);
GPGregorianTime de = new GPGregorianTime(loc);
GPGregorianTime t = new GPGregorianTime(loc);
vc_end = new GPGregorianTime(loc);
vc_start = new GPGregorianTime(loc);
int lm = -1;
mlist.n_startYear = nYear;
mlist.n_countYears = nCount;
d.Copy(GPGaurabdaYear.getFirstDayOfYear(loc, nYear));
de.Copy(GPGaurabdaYear.getFirstDayOfYear(loc, nYear + nCount));
mlist.vc_start.Copy(d);
mlist.vc_end.Copy(de);
mlist.m_location = loc;
alloc(nCount);
int i = 0;
int prev_paksa = -1;
int current = 0;
while (d.IsBeforeThis(de))
{
day.calculateDayData(d, loc);
if (prev_paksa != day.nPaksa)
{
day.nMasa = day.determineMasa(d, out day.nGaurabdaYear);
if (lm != day.nMasa)
{
if (lm >= 0)
{
t.Copy(d);
t.PreviousDay();
mlist.arr[current].vc_end.Copy(t);
current++;
}
lm = day.nMasa;
mlist.arr[current].masa = day.nMasa;
mlist.arr[current].year = day.nGaurabdaYear;
mlist.arr[current].vc_start.Copy(d);
}
}
prev_paksa = day.nPaksa;
d.NextDay();
i++;
}
t.Copy(d);
mlist.arr[current].vc_end.Copy(t);
current++;
mlist.n_countMasa = current;
return(1);
}
public void CalculateEvents(GPLocationProvider loc, GPGregorianTime vcStart, GPGregorianTime vcEnd)
{
GPCoreEventResults inEvents = this;
GPLocationProvider earth = loc;
GPGregorianTime vc = new GPGregorianTime(loc);
GPSun sun = new GPSun();
//int ndst = 0;
int nData;
inEvents.clear();
inEvents.m_location = loc;
inEvents.m_vcStart = vcStart;
inEvents.m_vcEnd = vcEnd;
GPGregorianTime vcAdd = new GPGregorianTime(loc);
GPGregorianTime vcTemp = null;
GPGregorianTime vcNext = new GPGregorianTime(loc);
vc.Copy(vcStart);
if (GPDisplays.CoreEvents.Sunrise())
{
vcAdd.Copy(vc);
while (vcAdd.IsBeforeThis(vcEnd))
{
sun.SunCalc(vcAdd, earth);
vcTemp = new GPGregorianTime(sun.arunodaya);
inEvents.AddEvent(vcTemp, GPConstants.CCTYPE_S_ARUN, 0);
//GPJulianTime tr, tt, ts;
//GPAstroEngine.CalculateTimeSun(vcTemp, vcTemp.getLocation(), out tr, out tt, out ts);
vcTemp = new GPGregorianTime(sun.rise);
//vcTemp = new GPGregorianTime(vcTemp.getLocation(), tr);
inEvents.AddEvent(vcTemp, GPConstants.CCTYPE_S_RISE, 0);
vcTemp = new GPGregorianTime(sun.noon);
//vcTemp = new GPGregorianTime(vcTemp.getLocation(), tt);
inEvents.AddEvent(vcTemp, GPConstants.CCTYPE_S_NOON, 0);
vcTemp = new GPGregorianTime(sun.set);
//vcTemp = new GPGregorianTime(vcTemp.getLocation(), ts);
inEvents.AddEvent(vcTemp, GPConstants.CCTYPE_S_SET, 0);
vcAdd.NextDay();
}
}
if (GPDisplays.CoreEvents.Tithi())
{
GPTithi te = new GPTithi();
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = te.getCurrentPosition();
//ndst = loc.getTimeZone().GetDaylightChangeType(vcNext);
inEvents.AddEvent(vcAdd, GPConstants.CCTYPE_TITHI, nData);
vcAdd = te.getNext();
}
}
if (GPDisplays.CoreEvents.Naksatra())
{
GPNaksatra te = new GPNaksatra();
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = te.getCurrentNaksatra();
//ndst = loc.getTimeZone().GetDaylightChangeType(vcNext);
inEvents.AddEvent(vcAdd, GPConstants.CCTYPE_NAKS, nData);
vcAdd = te.getNext();
}
}
if (GPDisplays.CoreEvents.Sankranti())
{
GPSankranti te = new GPSankranti();
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = te.getCurrentPosition();
//ndst = loc.getTimeZone().GetDaylightChangeType(vcNext);
inEvents.AddEvent(vcAdd, GPConstants.CCTYPE_SANK, nData);
vcAdd = te.getNext();
}
}
if (GPDisplays.CoreEvents.Conjunction())
{
double[] times = null;
GPConjunction te = new GPConjunction();
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = te.getCurrentPosition();
//ndst = loc.getTimeZone().GetDaylightChangeType(vcNext);
inEvents.AddEvent(vcAdd, GPConstants.CCTYPE_CONJ, nData);
if (GPDisplays.CoreEvents.SunEclipse())
{
GPAstroEngine.CalculateTimesSunEclipse(vcAdd.getJulianGreenwichTime(), vcAdd.getLocation(), out times);
if (times != null && times[2] > 0)
{
for (int i = 0; i < 5; i++)
{
if (times[i] > 0)
{
GPGregorianTime gt = new GPGregorianTime(vcAdd.getLocation());
gt.setJulianGreenwichTime(new GPJulianTime(times[i], 0.0));
inEvents.AddEvent(gt, GPConstants.SUNECLIPSE_CONSTS[i], 0);
}
}
}
}
vcAdd = te.getNext();
}
}
// moon eclipses
if (GPDisplays.CoreEvents.MoonEclipse())
{
double[] times = null;
GPConjunction te = new GPConjunction();
te.setOpositeConjunction(true);
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
GPAstroEngine.CalculateTimesMoonEclipse(vcAdd.getJulianGreenwichTime(), vcAdd.getLocation(), out times);
if (times != null && times[4] > 0)
{
for (int i = 0; i < 9; i++)
{
if (times[i] > 0 && GPConstants.MOONECLIPSE_CONSTS[i] > 0)
{
GPGregorianTime gt = new GPGregorianTime(vcAdd.getLocation());
gt.setJulianGreenwichTime(new GPJulianTime(times[i], 0.0));
inEvents.AddEvent(gt, GPConstants.MOONECLIPSE_CONSTS[i], 0);
}
}
}
vcAdd = te.getNext();
}
}
// rise and set of the moon
if (GPDisplays.CoreEvents.Moonrise())
{
GPJulianTime julian = vc.getJulian();
GPJulianTime julianEnd = vcEnd.getJulian();
GPJulianTime nextJulian;
TRiseSet kind;
while (julian.getGreenwichJulianDay() < julianEnd.getGreenwichJulianDay())
{
nextJulian = GPAstroEngine.GetNextMoonEvent(julian, vc.getLocationProvider(), out kind);
if (kind == TRiseSet.RISE)
{
inEvents.AddEvent(new GPGregorianTime(loc, nextJulian), GPConstants.CoreEventMoonRise, 0);
}
else if (kind == TRiseSet.SET)
{
inEvents.AddEvent(new GPGregorianTime(loc, nextJulian), GPConstants.CoreEventMoonSet, 0);
}
julian.setGreenwichJulianDay(nextJulian.getGreenwichJulianDay() + 10.0 / 1440.0);
}
}
// travellings
{
GPJulianTime julian = vc.getJulian();
GPJulianTime julianEnd = vcEnd.getJulian();
double start, end;
start = julian.getGreenwichJulianDay();
end = julianEnd.getGreenwichJulianDay();
for (int i = 0; i < loc.getChangeCount(); i++)
{
GPLocationChange chn = loc.getChangeAtIndex(i);
if ((chn.julianStart >= start && chn.julianStart <= end) ||
(chn.julianStart >= start && chn.julianEnd <= end))
{
GPGregorianTime startTime = new GPGregorianTime(chn.LocationA);
startTime.setJulianGreenwichTime(new GPJulianTime(chn.julianStart, 0));
GPGregorianTime endTime = new GPGregorianTime(chn.LocationB);
endTime.setJulianGreenwichTime(new GPJulianTime(chn.julianEnd, 0));
inEvents.AddEvent(startTime, GPConstants.CCTYPE_TRAVELLING_START, 0);
inEvents.AddEvent(endTime, GPConstants.CCTYPE_TRAVELLING_END, 0);
}
}
}
// eventual sorting
inEvents.Sort(GPDisplays.CoreEvents.Sort());
}
public static int FormatCalendarPlusCorePlain(GPCalendarPlusEventsResults calev, StringBuilder fout)
{
GPCalendarResults daybuff = calev.theCalendar;
GPCoreEventResults events = calev.theEvents;
//List<string> gstr = GPStrings.getSharedStrings().gstr;
int k;
string str;
GPGregorianTime date = new GPGregorianTime(daybuff.CurrentLocation);
GPCalendarDay pvd;
GPCalendarDay prevd;
GPCalendarDay nextd;
int nPrevMasa = -1;
int nPrevMonth = -1;
if (events.b_sorted == false)
{
events.Sort(true);
}
StringBuilder lineA = new StringBuilder();
StringBuilder lineB = new StringBuilder();
for (k = 0; k < daybuff.getCount(); k++)
{
prevd = daybuff.get(k - 1);
pvd = daybuff.get(k);
nextd = daybuff.get(k + 1);
if (pvd != null)
{
bool writeHeaders = false;
if (nPrevMasa != pvd.astrodata.nMasa && GPDisplays.Calendar.MasaHeader())
{
str = string.Format("{0} {1}", pvd.getMasaLongName(), ((nPrevMasa == GPMasa.ADHIKA_MASA) ? GPStrings.getString(109) : ""));
fout.AppendLine(GPAppHelper.CenterString(str, 80));
fout.AppendLine(GPAppHelper.CenterString(pvd.getGaurabdaYearLongString(), 80));
fout.AppendLine(GPAppHelper.CenterString(pvd.date.getLocation().getFullName(), 80));
fout.AppendLine(GPAppHelper.CenterString(string.Format("{0}: {1}", GPStrings.getString(12), pvd.date.getLocation().getTimeZone().getFullName()), 80));
fout.AppendLine();
nPrevMasa = pvd.astrodata.nMasa;
writeHeaders = true;
}
else if (nPrevMonth != pvd.date.getMonth() && GPDisplays.Calendar.MonthHeader())
{
fout.AppendLine(GPAppHelper.CenterString(string.Format("{0} {1}", GPStrings.getString(759 + pvd.date.getMonth()), pvd.date.getYear()), 80));
fout.AppendLine(GPAppHelper.CenterString(pvd.date.getLocation().getFullName(), 80));
fout.AppendLine(GPAppHelper.CenterString(string.Format("{0}: {1}", GPStrings.getString(12), pvd.date.getLocation().getTimeZone().getFullName()), 80));
fout.AppendLine();
nPrevMonth = pvd.date.getMonth();
writeHeaders = true;
}
if (writeHeaders)
{
int len = fout.Length;
fout.Append(" ");
fout.Append(GPStrings.getString(985).PadRight(16));
fout.Append(GPStrings.getString(986).ToUpper().PadRight(30));
if (GPDisplays.Calendar.PaksaInfoVisible())
{
fout.Append(GPStrings.getString(20).ToUpper().PadRight(6));
}
else
{
fout.Append(string.Empty.PadRight(6));
}
if (GPDisplays.Calendar.YogaVisible())
{
fout.Append(GPStrings.getString(104).ToUpper().PadRight(10));
}
if (GPDisplays.Calendar.NaksatraVisible())
{
fout.Append(GPStrings.getString(15).ToUpper().PadRight(15));
}
if (GPDisplays.Calendar.FastingFlagVisible())
{
fout.Append(GPStrings.getString(987).ToUpper().PadRight(5));
}
if (GPDisplays.Calendar.RasiVisible())
{
fout.Append(GPStrings.getString(105).ToUpper().PadRight(15));
}
fout.AppendLine();
len = fout.Length - len;
fout.AppendLine(string.Empty.PadLeft(len, '-'));
}
AvcGetOldCalendarDayText(pvd, fout, prevd, nextd);
fout.AppendLine();
lineA.Remove(0, lineA.Length);
lineB.Remove(0, lineB.Length);
List <GPStringPair> recs = events.ExtractRecordsForDate(pvd.date);
foreach (GPStringPair rec in recs)
{
lineA.Append(rec.Name);
lineB.Append(rec.Value);
int tosize = Math.Max(lineA.Length, lineB.Length) + 2;
while (lineA.Length < tosize)
{
lineA.Append(' ');
}
while (lineB.Length < tosize)
{
lineB.Append(' ');
}
}
fout.Append(string.Empty.PadLeft(17, ' '));
fout.AppendLine(lineA.ToString());
fout.Append(string.Empty.PadLeft(17, ' '));
fout.AppendLine(lineB.ToString());
fout.AppendLine();
}
date.setDayHours(0.0);
date.NextDay();
}
return(1);
}
public static int WriteXML_GaurabdaNextTithi(StringBuilder doc, GPLocationProvider loc, GPGregorianTime vcStart, GPVedicTime vaStart)
{
int gmasa, gpaksa, gtithi;
gmasa = vaStart.masa;
gpaksa = vaStart.tithi / 15;
gtithi = vaStart.tithi % 15;
doc.Append("<xml>\n");
doc.Append("\t<request name=\"Tithi\" version=\"" + GPFileHelper.FileVersion + "\">\n");
doc.Append("\t\t<arg name=\"longitude\" val=\"" + loc.GetLongitudeEastPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"latitude\" val=\"" + loc.GetLatitudeNorthPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"timezone\" val=\"" + loc.getTimeZone().OffsetSeconds / 60 + "\" />\n");
doc.Append("\t\t<arg name=\"start date\" val=\"" + vcStart + "\" />\n");
doc.Append("\t\t<arg name=\"masa\" val=\"" + gmasa + "\" />\n");
doc.Append("\t\t<arg name=\"paksa\" val=\"" + gpaksa + "\" />\n");
doc.Append("\t\t<arg name=\"tithi\" val=\"" + gtithi + "\" />\n");
doc.Append("\t</request>\n");
doc.Append("\t<result name=\"Tithi\">\n");
GPGregorianTime vcs = new GPGregorianTime(loc);
GPGregorianTime vce = new GPGregorianTime(loc);
GPGregorianTime today = new GPGregorianTime(loc);
GPSun sun = new GPSun();
int A;
double sunrise;
GPAstroData day = new GPAstroData();
int oTithi, oPaksa, oMasa, oYear;
today.Copy(vcStart);
today.PreviousDay();
vcStart.SubDays(15);
for (A = 0; A <= 3; A++)
{
vcs = GPTithi.CalcTithiEndEx(vcStart, 0, gmasa, gpaksa, gtithi, loc, out vce);
if (!vcs.IsBeforeThis(today))
{
oTithi = gpaksa * 15 + gtithi;
oMasa = gmasa;
oPaksa = gpaksa;
oYear = 0;
doc.Append("\t<celebration\n");
// doc.Append( "\t\t<tithi\n");
doc.Append("\t\trtithi=\"" + GPTithi.getName(oTithi) + "\"\n");
doc.Append("\t\trmasa=\"" + GPMasa.GetName(oMasa) + "\"\n");
doc.Append("\t\trpaksa=\"" + GPPaksa.getName(oPaksa) + "\"\n");
// test ci je ksaya
today.Copy(vcs);
today.setDayHours(0.5);
sun.SunCalc(today, loc);
sunrise = sun.getSunriseDayHours();
if (sunrise < vcs.getDayHours())
{
today.Copy(vce);
sun.SunCalc(today, loc);
sunrise = sun.getSunriseDayHours();
if (sunrise < vce.getDayHours())
{
// normal type
vcs.NextDay();
doc.Append("\t\ttype=\"normal\"\n");
}
else
{
// ksaya
vcs.NextDay();
day.calculateDayData(vcs, loc);
oTithi = day.nTithi;
oPaksa = day.nPaksa;
oMasa = day.determineMasa(vcs, out oYear);
doc.Append("\t\ttype=\"ksaya\"\n");
}
}
else
{
// normal, alebo prvy den vriddhi
today.Copy(vce);
sun.SunCalc(today, loc);
if (sun.getSunriseDayHours() < vce.getDayHours())
{
// first day of vriddhi type
doc.Append("\t\ttype=\"vriddhi\"\n");
}
else
{
// normal
doc.Append("\t\ttype=\"normal\"\n");
}
}
doc.Append("\t\tdate=\"" + vcs + "\"\n");
doc.Append("\t\totithi=\"" + GPTithi.getName(oTithi) + "\"\n");
doc.Append("\t\tomasa=\"" + GPMasa.GetName(oMasa) + "\"\n");
doc.Append("\t\topaksa=\"" + GPPaksa.getName(oPaksa) + "\"\n");
doc.Append("\t/>\n");
break;
}
else
{
vcStart.Copy(vcs);
vcs.NextDay();
}
}
doc.Append("\t</result>\n");
doc.Append("</xml>\n");
return(1);
}
public static int WriteXML_GaurabdaTithi(StringBuilder doc, GPLocationProvider loc, GPVedicTime vaStart, GPVedicTime vaEnd)
{
int gyearA = vaStart.gyear;
int gyearB = vaEnd.gyear;
int gmasa = vaStart.masa;
int gpaksa = vaStart.tithi / 15;
int gtithi = vaStart.tithi % 15;
if (gyearB < gyearA)
{
gyearB = gyearA;
}
doc.Append("<xml>\n");
doc.Append("\t<request name=\"Tithi\" version=\"" + GPFileHelper.FileVersion + "\">\n");
doc.Append("\t\t<arg name=\"longitude\" val=\"" + loc.getLocation(0).GetLongitudeEastPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"latitude\" val=\"" + loc.getLocation(0).GetLatitudeNorthPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"timezone\" val=\"" + loc.getLocation(0).getTimeZone().OffsetSeconds / 60 + "\" />\n");
if (gyearA > 1500)
{
doc.Append("\t\t<arg name=\"year-start\" val=\"" + gyearA + "\" />\n");
doc.Append("\t\t<arg name=\"year-end\" val=\"" + gyearB + "\" />\n");
}
else
{
doc.Append("\t\t<arg name=\"gaurabdayear-start\" val=\"" + gyearA + "\" />\n");
doc.Append("\t\t<arg name=\"gaurabdayear-end\" val=\"" + gyearB + "\" />\n");
}
doc.Append("\t\t<arg name=\"masa\" val=\"" + gmasa + "\" />\n");
doc.Append("\t\t<arg name=\"paksa\" val=\"" + gpaksa + "\" />\n");
doc.Append("\t\t<arg name=\"tithi\" val=\"" + gtithi + "\" />\n");
doc.Append("\t</request>\n");
doc.Append("\t<result name=\"Tithi\">\n");
GPGregorianTime vcs = new GPGregorianTime(loc), vce = new GPGregorianTime(loc), today = new GPGregorianTime(loc);
GPSun sun = new GPSun();
int A, B;
double sunrise;
GPAstroData day = new GPAstroData();
int oTithi, oPaksa, oMasa, oYear;
if (gyearA > 1500)
{
A = gyearA - 1487;
B = gyearB - 1485;
}
else
{
A = gyearA;
B = gyearB;
}
for (; A <= B; A++)
{
vcs = GPTithi.CalcTithiEnd(A, gmasa, gpaksa, gtithi, loc, out vce);
if (gyearA > 1500)
{
if ((vcs.getYear() < gyearA) || (vcs.getYear() > gyearB))
{
continue;
}
}
oTithi = gpaksa * 15 + gtithi;
oMasa = gmasa;
oPaksa = gpaksa;
oYear = 0;
doc.Append("\t<celebration\n");
doc.Append("\t\trtithi=\"" + GPTithi.getName(oTithi) + "\"\n");
doc.Append("\t\trmasa=\"" + GPMasa.GetName(oMasa) + "\"\n");
doc.Append("\t\trpaksa=\"" + GPPaksa.getName(oPaksa) + "\"\n");
// test ci je ksaya
today.Copy(vcs);
today.setDayHours(0.5);
sun.SunCalc(today, loc);
sunrise = sun.getSunriseDayHours();
if (sunrise < vcs.getDayHours())
{
today.Copy(vce);
sun.SunCalc(today, loc);
sunrise = sun.getSunriseDayHours();
if (sunrise < vce.getDayHours())
{
// normal type
vcs.NextDay();
doc.Append("\t\ttype=\"normal\"\n");
}
else
{
// ksaya
vcs.NextDay();
day.calculateDayData(vcs, loc);
oTithi = day.nTithi;
oPaksa = day.nPaksa;
oMasa = day.determineMasa(vcs, out oYear);
doc.Append("\t\ttype=\"ksaya\"\n");
}
}
else
{
// normal, alebo prvy den vriddhi
today.Copy(vce);
sun.SunCalc(today, loc);
if (sun.getSunriseDayHours() < vce.getDayHours())
{
// first day of vriddhi type
doc.Append("\t\ttype=\"vriddhi\"\n");
}
else
{
// normal
doc.Append("\t\ttype=\"normal\"\n");
}
}
doc.Append("\t\tdate=\"" + vcs + "\"\n");
doc.Append("\t\totithi=\"" + GPTithi.getName(oTithi) + "\"\n");
doc.Append("\t\tomasa=\"" + GPMasa.GetName(oMasa) + "\"\n");
doc.Append("\t\topaksa=\"" + GPPaksa.getName(oPaksa) + "\"\n");
doc.Append("\t/>\n");
// doc.Append( "\t\t</celebration>\n");
}
doc.Append("\t</result>\n");
doc.Append("</xml>\n");
return(1);
}
public static XmlDocument GetSankrantiXml(GPLocationProvider loc, GPGregorianTime vcStart, GPGregorianTime vcEnd)
{
XmlDocument doc = new XmlDocument();
XmlElement e1, e2, e3, eday, e5, e6;
GPGregorianTime d = new GPGregorianTime(loc);
int zodiac;
d.Copy(vcStart);
e1 = doc.CreateElement("xml");
doc.AppendChild(e1);
e2 = doc.CreateElement("request");
e1.AppendChild(e2);
e2.SetAttribute("name", "Sankranti");
e2.SetAttribute("version", GPFileHelper.FileVersion);
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "longitude");
e3.SetAttribute("val", loc.GetLongitudeEastPositive().ToString());
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "latitude");
e3.SetAttribute("val", loc.GetLatitudeNorthPositive().ToString());
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "timezone");
e3.SetAttribute("val", (loc.getTimeZone().OffsetSeconds / 60).ToString());
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "startdate");
e3.SetAttribute("val", vcStart.ToString());
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "enddate");
e3.SetAttribute("val", vcEnd.ToString());
e2 = doc.CreateElement("result");
e1.AppendChild(e2);
e2.SetAttribute("name", "SankrantiList");
while (d.IsBeforeThis(vcEnd))
{
d = GPSankranti.GetNextSankranti(d, out zodiac);
eday = doc.CreateElement("sank");
e2.AppendChild(eday);
eday.SetAttribute("date", d.getLongDateString());
eday.SetAttribute("time", d.getLongTimeString());
eday.SetAttribute("dayweekid", d.getDayOfWeek().ToString());
eday.SetAttribute("dayweek", getSharedStringHtml(d.getDayOfWeek()));
e5 = doc.CreateElement("zodiac");
eday.AppendChild(e5);
e5.SetAttribute("sans", GPSankranti.GetNameSan(zodiac));
e5.SetAttribute("eng", GPSankranti.GetNameEng(zodiac));
e5.SetAttribute("id", zodiac.ToString());
d.NextDay();
d.NextDay();
}
return(doc);
}