616 lines
16 KiB
C
Executable File
616 lines
16 KiB
C
Executable File
/* $calcurse: calendar.c,v 1.10 2007/08/12 13:09:02 culot Exp $ */
|
|
|
|
/*
|
|
* Calcurse - text-based organizer
|
|
* Copyright (c) 2004-2007 Frederic Culot
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*
|
|
* Send your feedback or comments to : calcurse@culot.org
|
|
* Calcurse home page : http://culot.org/calcurse
|
|
*
|
|
*/
|
|
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <time.h>
|
|
#include <math.h>
|
|
|
|
#include "i18n.h"
|
|
#include "day.h"
|
|
#include "apoint.h"
|
|
#include "event.h"
|
|
#include "calendar.h"
|
|
#include "custom.h"
|
|
#include "vars.h"
|
|
#include "utils.h"
|
|
|
|
#ifndef M_PI
|
|
#define M_PI 3.14159265358979323846
|
|
#endif
|
|
|
|
#define EPOCH 90
|
|
#define EPSILONg 279.403303 /* solar ecliptic long at EPOCH */
|
|
#define RHOg 282.768422 /* solar ecliptic long of perigee at EPOCH */
|
|
#define ECCEN 0.016713 /* solar orbit eccentricity */
|
|
#define lzero 318.351648 /* lunar mean long at EPOCH */
|
|
#define Pzero 36.340410 /* lunar mean long of perigee at EPOCH */
|
|
#define Nzero 318.510107 /* lunar mean long of node at EPOCH */
|
|
#define TM_YEAR_BASE 1900
|
|
|
|
#define isleap(y) ((((y) % 4) == 0 && ((y) % 100) != 0) || ((y) % 400) == 0)
|
|
|
|
static date_t today, slctd_day;
|
|
static bool week_begins_on_monday;
|
|
static pthread_mutex_t date_thread_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
static pthread_t calendar_t_date;
|
|
|
|
|
|
/* Thread needed to update current date in calendar. */
|
|
static void *
|
|
calendar_date_thread(void *arg)
|
|
{
|
|
time_t now, tomorrow;
|
|
|
|
for (;;) {
|
|
tomorrow = (time_t)(get_today() + DAYINSEC);
|
|
|
|
while ((now = time(NULL)) < tomorrow) {
|
|
sleep(tomorrow - now);
|
|
}
|
|
|
|
calendar_set_current_date();
|
|
calendar_update_panel(cwin);
|
|
}
|
|
|
|
pthread_exit((void*) 0);
|
|
}
|
|
|
|
/* Launch the calendar date thread. */
|
|
void
|
|
calendar_start_date_thread(void)
|
|
{
|
|
pthread_create(&calendar_t_date, NULL, calendar_date_thread, NULL);
|
|
return;
|
|
}
|
|
|
|
/* Stop the calendar date thread. */
|
|
void
|
|
calendar_stop_date_thread(void)
|
|
{
|
|
pthread_cancel(calendar_t_date);
|
|
return;
|
|
}
|
|
|
|
/* Set static variable today to current date */
|
|
void
|
|
calendar_set_current_date(void)
|
|
{
|
|
time_t timer;
|
|
struct tm *tm;
|
|
|
|
timer = time(NULL);
|
|
tm = localtime(&timer);
|
|
|
|
pthread_mutex_lock(&date_thread_mutex);
|
|
today.dd = tm->tm_mday;
|
|
today.mm = tm->tm_mon + 1;
|
|
today.yyyy = tm->tm_year + 1900;
|
|
pthread_mutex_unlock(&date_thread_mutex);
|
|
}
|
|
|
|
/* Needed to display sunday or monday as the first day of week in calendar. */
|
|
void
|
|
calendar_set_first_day_of_week(wday_e first_day)
|
|
{
|
|
switch (first_day) {
|
|
case SUNDAY:
|
|
week_begins_on_monday = false;
|
|
break;
|
|
case MONDAY:
|
|
week_begins_on_monday = true;
|
|
break;
|
|
default:
|
|
fputs(_("ERROR in calendar_set_first_day_of_week\n"), stderr);
|
|
week_begins_on_monday = false;
|
|
/* NOTREACHED */
|
|
}
|
|
}
|
|
|
|
/* Swap first day of week in calendar. */
|
|
void
|
|
calendar_change_first_day_of_week(void)
|
|
{
|
|
week_begins_on_monday = !week_begins_on_monday;
|
|
}
|
|
|
|
/* Return true if week begins on monday, false otherwise. */
|
|
bool
|
|
calendar_week_begins_on_monday(void)
|
|
{
|
|
return (week_begins_on_monday);
|
|
}
|
|
|
|
/* Fill in the given variable with the current date. */
|
|
void
|
|
calendar_store_current_date(date_t *date)
|
|
{
|
|
pthread_mutex_lock(&date_thread_mutex);
|
|
*date = today;
|
|
pthread_mutex_unlock(&date_thread_mutex);
|
|
}
|
|
|
|
/* This is to start at the current date in calendar. */
|
|
void
|
|
calendar_init_slctd_day(void)
|
|
{
|
|
calendar_store_current_date(&slctd_day);
|
|
}
|
|
|
|
/* Return the selected day in calendar */
|
|
date_t *
|
|
calendar_get_slctd_day(void)
|
|
{
|
|
return (&slctd_day);
|
|
}
|
|
|
|
/* Returned value represents the selected day in calendar (in seconds) */
|
|
long
|
|
calendar_get_slctd_day_sec(void)
|
|
{
|
|
return (date2sec(slctd_day, 0, 0));
|
|
}
|
|
|
|
static int
|
|
isBissextile(unsigned year)
|
|
{
|
|
return (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0));
|
|
}
|
|
|
|
static unsigned
|
|
months_to_days(unsigned month)
|
|
{
|
|
return ((month * 3057 - 3007) / 100);
|
|
}
|
|
|
|
|
|
static long
|
|
years_to_days(unsigned year)
|
|
{
|
|
return (year * 365L + year / 4 - year / 100 + year / 400);
|
|
}
|
|
|
|
static long
|
|
ymd_to_scalar(unsigned year, unsigned month, unsigned day)
|
|
{
|
|
long scalar;
|
|
|
|
scalar = day + months_to_days(month);
|
|
if (month > 2)
|
|
scalar -= isBissextile(year) ? 1 : 2;
|
|
year--;
|
|
scalar += years_to_days(year);
|
|
|
|
return (scalar);
|
|
}
|
|
|
|
/* Function used to display the calendar panel. */
|
|
void
|
|
calendar_update_panel(WINDOW *cwin)
|
|
{
|
|
date_t current_day, check_day;
|
|
int c_day, c_day_1, day_1_sav, numdays, j;
|
|
unsigned yr, mo;
|
|
int ofs_x, ofs_y;
|
|
int item_this_day = 0;
|
|
int title_lines = 3;
|
|
int sunday_first = 0;
|
|
|
|
/* inits */
|
|
calendar_store_current_date(¤t_day);
|
|
erase_window_part(cwin, 1, title_lines, CALWIDTH - 2, CALHEIGHT - 2);
|
|
mo = slctd_day.mm;
|
|
yr = slctd_day.yyyy;
|
|
if (!calendar_week_begins_on_monday())
|
|
sunday_first = 1;
|
|
|
|
/* offset for centering calendar in window */
|
|
ofs_y = 2 + (CALHEIGHT - 9) / 2;
|
|
ofs_x = (CALWIDTH - 27) / 2;
|
|
|
|
/* checking the number of days in february */
|
|
numdays = days[mo - 1];
|
|
if (2 == mo && isBissextile(yr))
|
|
++numdays;
|
|
|
|
/*
|
|
* the first calendar day will be monday or sunday, depending on
|
|
* 'week_begins_on_monday' value
|
|
*/
|
|
c_day_1 =
|
|
(int)((ymd_to_scalar(yr, mo, 1 + sunday_first) - (long)1) % 7L);
|
|
|
|
/* Write the current month and year on top of the calendar */
|
|
custom_apply_attr(cwin, ATTR_HIGH);
|
|
mvwprintw(cwin, ofs_y,
|
|
(CALWIDTH - (strlen(_(monthnames[mo - 1])) + 5)) / 2,
|
|
"%s %d", _(monthnames[mo - 1]), slctd_day.yyyy);
|
|
custom_remove_attr(cwin, ATTR_HIGH);
|
|
++ofs_y;
|
|
|
|
/* print the days, with regards to the first day of the week */
|
|
custom_apply_attr(cwin, ATTR_HIGH);
|
|
for (j = 0; j < 7; j++) {
|
|
mvwprintw(cwin, ofs_y, ofs_x + 4 * j, "%s",
|
|
_(daynames[1 + j - sunday_first]));
|
|
}
|
|
custom_remove_attr(cwin, ATTR_HIGH);
|
|
|
|
day_1_sav = (c_day_1 + 1) * 3 + c_day_1 - 7;
|
|
|
|
for (c_day = 1; c_day <= numdays; ++c_day, ++c_day_1, c_day_1 %= 7) {
|
|
check_day.dd = c_day;
|
|
check_day.mm = slctd_day.mm;
|
|
check_day.yyyy = slctd_day.yyyy;
|
|
|
|
/* check if the day contains an event or an appointment */
|
|
item_this_day =
|
|
day_check_if_item(check_day);
|
|
|
|
/* Go to next line, the week is over. */
|
|
if (!c_day_1 && 1 != c_day) {
|
|
++ofs_y;
|
|
ofs_x = 2 - day_1_sav - 4 * c_day - 1;
|
|
}
|
|
|
|
/* This is today, so print it in yellow. */
|
|
if (c_day == current_day.dd && current_day.mm == slctd_day.mm
|
|
&& current_day.yyyy == slctd_day.yyyy &&
|
|
current_day.dd != slctd_day.dd) {
|
|
|
|
custom_apply_attr(cwin, ATTR_LOWEST);
|
|
mvwprintw(cwin, ofs_y + 1,
|
|
ofs_x + day_1_sav + 4 * c_day + 1, "%2d", c_day);
|
|
custom_remove_attr(cwin, ATTR_LOWEST);
|
|
|
|
} else if (c_day == slctd_day.dd &&
|
|
( (current_day.dd != slctd_day.dd) ||
|
|
(current_day.mm != slctd_day.mm)
|
|
|| (current_day.yyyy != slctd_day.yyyy))) {
|
|
|
|
/* This is the selected day, print it in red. */
|
|
custom_apply_attr(cwin, ATTR_MIDDLE);
|
|
mvwprintw(cwin, ofs_y + 1,
|
|
ofs_x + day_1_sav + 4 * c_day + 1, "%2d", c_day);
|
|
custom_remove_attr(cwin, ATTR_MIDDLE);
|
|
|
|
} else if (c_day == slctd_day.dd &&
|
|
current_day.dd == slctd_day.dd &&
|
|
current_day.mm == slctd_day.mm &&
|
|
current_day.yyyy == slctd_day.yyyy) {
|
|
|
|
/* today is the selected day */
|
|
custom_apply_attr(cwin, ATTR_MIDDLE);
|
|
mvwprintw(cwin, ofs_y + 1,
|
|
ofs_x + day_1_sav + 4 * c_day + 1, "%2d", c_day);
|
|
custom_remove_attr(cwin, ATTR_MIDDLE);
|
|
|
|
} else if (item_this_day) {
|
|
custom_apply_attr(cwin, ATTR_LOW);
|
|
mvwprintw(cwin, ofs_y + 1,
|
|
ofs_x + day_1_sav + 4 * c_day + 1, "%2d", c_day);
|
|
custom_remove_attr(cwin, ATTR_LOW);
|
|
} else
|
|
/* otherwise, print normal days in black */
|
|
mvwprintw(cwin, ofs_y + 1,
|
|
ofs_x + day_1_sav + 4 * c_day + 1, "%2d", c_day);
|
|
|
|
}
|
|
wnoutrefresh(cwin);
|
|
}
|
|
|
|
/*
|
|
* Ask for a date to jump to, then check the correctness of that date
|
|
* and jump to it.
|
|
* If the entered date is empty, automatically jump to the current date.
|
|
* today is the current day given to that routine, and slctd_day is updated
|
|
* with the newly selected date.
|
|
*/
|
|
void
|
|
calendar_change_day(void)
|
|
{
|
|
#define LDAY 11
|
|
char selected_day[LDAY] = "";
|
|
date_t today;
|
|
int dday, dmonth, dyear;
|
|
int wrong_day = 1;
|
|
char *mesg_line1 = _("The day you entered is not valid");
|
|
char *mesg_line2 = _("Press [ENTER] to continue");
|
|
char *request_date =
|
|
_("Enter the day to go to [ENTER for today] : mm/dd/yyyy");
|
|
|
|
while (wrong_day) {
|
|
status_mesg(request_date, "");
|
|
if (getstring(swin, selected_day, LDAY, 0, 1) == GETSTRING_ESC)
|
|
return;
|
|
else {
|
|
if (strlen(selected_day) == 0) {
|
|
calendar_store_current_date(&today);
|
|
|
|
/* go to today */
|
|
wrong_day = 0;
|
|
slctd_day.dd = today.dd;
|
|
slctd_day.mm = today.mm;
|
|
slctd_day.yyyy = today.yyyy;
|
|
|
|
} else if (strlen(selected_day) != LDAY - 1) {
|
|
|
|
wrong_day = 1;
|
|
|
|
} else {
|
|
|
|
sscanf(selected_day, "%u/%u/%u",
|
|
&dmonth, &dday, &dyear);
|
|
wrong_day = 0;
|
|
|
|
/* basic check on entered date */
|
|
if ((dday <= 0) || (dday >= 32) ||
|
|
(dmonth <= 0) || (dmonth >= 13) ||
|
|
(dyear <= 0) || (dyear >= 3000))
|
|
wrong_day = 1;
|
|
|
|
/* go to chosen day */
|
|
if (wrong_day != 1) {
|
|
slctd_day.dd = dday;
|
|
slctd_day.mm = dmonth;
|
|
slctd_day.yyyy = dyear;
|
|
}
|
|
}
|
|
|
|
if (wrong_day) {
|
|
status_mesg(mesg_line1, mesg_line2);
|
|
wgetch(swin);
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/* Move to next day, next month or next year in calendar. */
|
|
void
|
|
calendar_move_right(void)
|
|
{
|
|
if ((slctd_day.dd == 31) && (slctd_day.mm == 12)) {
|
|
slctd_day.dd = 0;
|
|
slctd_day.mm = 1;
|
|
slctd_day.yyyy++;
|
|
} else if (slctd_day.dd == days[slctd_day.mm - 1]) {
|
|
slctd_day.mm++;
|
|
slctd_day.dd = 1;
|
|
} else
|
|
slctd_day.dd++;
|
|
}
|
|
|
|
/* Move to previous day, previous month or previous year in calendar. */
|
|
void
|
|
calendar_move_left(void)
|
|
{
|
|
if ((slctd_day.dd == 1) && (slctd_day.mm == 1)) {
|
|
slctd_day.dd = 32;
|
|
slctd_day.mm = 12;
|
|
slctd_day.yyyy--;
|
|
} else if (slctd_day.dd == 1) {
|
|
slctd_day.dd = days[slctd_day.mm - 2];
|
|
slctd_day.mm--;
|
|
} else
|
|
slctd_day.dd--;
|
|
}
|
|
|
|
/* Move to previous week, previous month or previous year in calendar. */
|
|
void
|
|
calendar_move_up(void)
|
|
{
|
|
if ((slctd_day.dd <= 7) && (slctd_day.mm == 1)) {
|
|
slctd_day.dd = 31 - (7 - slctd_day.dd);
|
|
slctd_day.mm = 12;
|
|
slctd_day.yyyy--;
|
|
} else if (slctd_day.dd <= 7) {
|
|
slctd_day.dd = days[slctd_day.mm - 2] -
|
|
(7 - slctd_day.dd);
|
|
slctd_day.mm--;
|
|
} else
|
|
slctd_day.dd -= 7;
|
|
}
|
|
|
|
/* Move to next week, next month or next year in calendar. */
|
|
void
|
|
calendar_move_down(void)
|
|
{
|
|
if ((slctd_day.dd > days[slctd_day.mm - 1] - 7)
|
|
&& (slctd_day.mm == 12)) {
|
|
slctd_day.dd = (7 - (31 - slctd_day.dd));
|
|
slctd_day.mm = 1;
|
|
slctd_day.yyyy++;
|
|
} else if (slctd_day.dd > days[slctd_day.mm - 1] - 7) {
|
|
slctd_day.dd = (7 - (days[slctd_day.mm - 1] - slctd_day.dd));
|
|
slctd_day.mm++;
|
|
} else
|
|
slctd_day.dd += 7;
|
|
}
|
|
|
|
/*
|
|
* The pom, potm, dotr, adj360 are used to compute the current
|
|
* phase of the moon.
|
|
* The code is based on the OpenBSD version of pom(6).
|
|
* Below is reported the copyright notice.
|
|
*/
|
|
/*
|
|
* Copyright (c) 1989, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* This code is derived from software posted to USENET.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* dtor --
|
|
* convert degrees to radians
|
|
*/
|
|
static double
|
|
dtor(double deg)
|
|
{
|
|
return(deg * M_PI / 180);
|
|
}
|
|
|
|
/*
|
|
* adj360 --
|
|
* adjust value so 0 <= deg <= 360
|
|
*/
|
|
static void
|
|
adj360(double *deg)
|
|
{
|
|
for (;;)
|
|
if (*deg < 0.0)
|
|
*deg += 360.0;
|
|
else if (*deg > 360.0)
|
|
*deg -= 360.0;
|
|
else
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* potm --
|
|
* return phase of the moon
|
|
*/
|
|
static double
|
|
potm(double days)
|
|
{
|
|
double N, Msol, Ec, LambdaSol, l, Mm, Ev, Ac, A3, Mmprime;
|
|
double A4, lprime, V, ldprime, D, Nm;
|
|
|
|
N = 360.0 * days / 365.242191; /* sec 46 #3 */
|
|
adj360(&N);
|
|
Msol = N + EPSILONg - RHOg; /* sec 46 #4 */
|
|
adj360(&Msol);
|
|
Ec = 360 / M_PI * ECCEN * sin(dtor(Msol)); /* sec 46 #5 */
|
|
LambdaSol = N + Ec + EPSILONg; /* sec 46 #6 */
|
|
adj360(&LambdaSol);
|
|
l = 13.1763966 * days + lzero; /* sec 65 #4 */
|
|
adj360(&l);
|
|
Mm = l - (0.1114041 * days) - Pzero; /* sec 65 #5 */
|
|
adj360(&Mm);
|
|
Nm = Nzero - (0.0529539 * days); /* sec 65 #6 */
|
|
adj360(&Nm);
|
|
Ev = 1.2739 * sin(dtor(2*(l - LambdaSol) - Mm)); /* sec 65 #7 */
|
|
Ac = 0.1858 * sin(dtor(Msol)); /* sec 65 #8 */
|
|
A3 = 0.37 * sin(dtor(Msol));
|
|
Mmprime = Mm + Ev - Ac - A3; /* sec 65 #9 */
|
|
Ec = 6.2886 * sin(dtor(Mmprime)); /* sec 65 #10 */
|
|
A4 = 0.214 * sin(dtor(2 * Mmprime)); /* sec 65 #11 */
|
|
lprime = l + Ev + Ec - Ac + A4; /* sec 65 #12 */
|
|
V = 0.6583 * sin(dtor(2 * (lprime - LambdaSol))); /* sec 65 #13 */
|
|
ldprime = lprime + V; /* sec 65 #14 */
|
|
D = ldprime - LambdaSol; /* sec 67 #2 */
|
|
return(50.0 * (1 - cos(dtor(D)))); /* sec 67 #3 */
|
|
}
|
|
|
|
/*
|
|
* Phase of the Moon. Calculates the current phase of the moon.
|
|
* Based on routines from `Practical Astronomy with Your Calculator',
|
|
* by Duffett-Smith. Comments give the section from the book that
|
|
* particular piece of code was adapted from.
|
|
*
|
|
* -- Keith E. Brandt VIII 1984
|
|
*
|
|
* Updated to the Third Edition of Duffett-Smith's book, IX 1998
|
|
*
|
|
*/
|
|
static double
|
|
pom(time_t tmpt)
|
|
{
|
|
struct tm *GMT;
|
|
double days;
|
|
int cnt;
|
|
pom_e pom;
|
|
|
|
pom = NO_POM;
|
|
GMT = gmtime(&tmpt);
|
|
days = (GMT->tm_yday + 1) + ((GMT->tm_hour +
|
|
(GMT->tm_min / 60.0) + (GMT->tm_sec / 3600.0)) / 24.0);
|
|
for (cnt = EPOCH; cnt < GMT->tm_year; ++cnt)
|
|
days += isleap(cnt + TM_YEAR_BASE) ? 366 : 365;
|
|
/* Selected time could be before EPOCH */
|
|
for (cnt = GMT->tm_year; cnt < EPOCH; ++cnt)
|
|
days -= isleap(cnt + TM_YEAR_BASE) ? 366 : 365;
|
|
|
|
return (potm(days));
|
|
}
|
|
|
|
/*
|
|
* Return a pictogram representing the current phase of the moon.
|
|
* Careful: date is the selected day in calendar at 00:00, so it represents
|
|
* the phase of the moon for previous day.
|
|
*/
|
|
char *
|
|
calendar_get_pom(time_t date)
|
|
{
|
|
char *pom_pict[MOON_PHASES] = {" ", "|) ", "(|)", "(| ", " | "};
|
|
pom_e phase = NO_POM;
|
|
double pom_today, relative_pom, pom_yesterday, pom_tomorrow;
|
|
const double half = 50.0;
|
|
|
|
pom_yesterday = pom(date);
|
|
pom_today = pom(date + DAYINSEC);
|
|
relative_pom = abs(pom_today - half);
|
|
pom_tomorrow = pom(date + 2 * DAYINSEC);
|
|
if (pom_today > pom_yesterday && pom_today > pom_tomorrow)
|
|
phase = FULL_MOON;
|
|
else if (pom_today < pom_yesterday && pom_today < pom_tomorrow)
|
|
phase = NEW_MOON;
|
|
else if (relative_pom < abs(pom_yesterday - half) &&
|
|
relative_pom < abs(pom_tomorrow - half))
|
|
phase = (pom_tomorrow > pom_today) ?
|
|
FIRST_QUARTER : LAST_QUARTER;
|
|
|
|
return (pom_pict[phase]);
|
|
}
|